widevine-partner/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fewer parameters for storing and retrieve license information.

Browse Source 
[ Merge of http://go/wvgerrit/84990 ]

Storing and retrieving licenses from device files had required 15
parameters to the DeviceFiles methods.  Now, licenses information is
bundled together in a single struct `CdmLicenseData`, similar to
`CdmUsageData`.

Bug: 137882164
Test: Linux and Android unittest
Change-Id: I149b39573800e7c66681343b252b41341a8902f7
This commit is contained in:
Alex Dale
2019-09-03 11:58:27 -07:00
parent 6793f74aa2
commit 5bfdd515eb
7 changed files with 364 additions and 395 deletions
Download Patch File Download Diff File Expand all files Collapse all files

180
libwvdrmengine/cdm/core/test/device_files_unittest.cpp
View File

@@ -2294,7 +2294,7 @@ TEST_P(DeviceFilesStoreTest, StoreLicense) {
DeviceFiles::ResponseType sub_error_code;
DeviceFiles device_files(&file_system);
EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
EXPECT_TRUE(device_files.StoreLicense(
DeviceFiles::CdmLicenseData license_data{
license_test_data[license_num].key_set_id,
license_test_data[license_num].license_state,
license_test_data[license_num].pssh_data,
@@ -2305,9 +2305,11 @@ TEST_P(DeviceFilesStoreTest, StoreLicense) {
license_test_data[license_num].key_release_url,
license_test_data[license_num].playback_start_time,
license_test_data[license_num].last_playback_time,
license_test_data[license_num].grace_period_end_time, app_parameters,
license_test_data[license_num].grace_period_end_time,
app_parameters,
license_test_data[license_num].usage_entry,
license_test_data[license_num].usage_entry_number, &sub_error_code));
license_test_data[license_num].usage_entry_number};
EXPECT_TRUE(device_files.StoreLicense(license_data, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
}
@@ -2349,18 +2351,22 @@ TEST_F(DeviceFilesTest, StoreLicenses) {
CdmAppParameterMap app_parameters =
GetAppParameters(license_test_data[i].app_parameters);
EXPECT_TRUE(device_files.StoreLicense(
license_test_data[i].key_set_id, license_test_data[i].license_state,
license_test_data[i].pssh_data, license_test_data[i].key_request,
DeviceFiles::CdmLicenseData license_data{
license_test_data[i].key_set_id,
license_test_data[i].license_state,
license_test_data[i].pssh_data,
license_test_data[i].key_request,
license_test_data[i].key_response,
license_test_data[i].key_renewal_request,
license_test_data[i].key_renewal_response,
license_test_data[i].key_release_url,
license_test_data[i].playback_start_time,
license_test_data[i].last_playback_time,
license_test_data[i].grace_period_end_time, app_parameters,
license_test_data[i].grace_period_end_time,
app_parameters,
license_test_data[i].usage_entry,
license_test_data[i].usage_entry_number, &sub_error_code));
license_test_data[i].usage_entry_number};
EXPECT_TRUE(device_files.StoreLicense(license_data, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
}
}
@@ -2394,43 +2400,35 @@ TEST_F(DeviceFilesTest, RetrieveLicenses) {
DeviceFiles device_files(&file_system);
EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
CdmInitData pssh_data;
CdmKeyMessage key_request;
CdmKeyResponse key_response;
CdmKeyMessage key_renewal_request;
CdmKeyResponse key_renewal_response;
int64_t playback_start_time, last_playback_time;
int64_t grace_period_end_time;
std::string release_server_url;
CdmAppParameterMap app_parameters;
std::string usage_entry;
uint32_t usage_entry_number;
DeviceFiles::CdmLicenseData license_data;
DeviceFiles::ResponseType sub_error_code;
for (size_t i = 0; i < kNumberOfLicenses; i++) {
DeviceFiles::LicenseState license_state;
EXPECT_TRUE(device_files.RetrieveLicense(
license_test_data[i].key_set_id, &license_state, &pssh_data,
&key_request, &key_response, &key_renewal_request,
&key_renewal_response, &release_server_url, &playback_start_time,
&last_playback_time, &grace_period_end_time, &app_parameters,
&usage_entry, &usage_entry_number, &sub_error_code));
EXPECT_EQ(license_test_data[i].license_state, license_state);
EXPECT_EQ(license_test_data[i].pssh_data, pssh_data);
EXPECT_EQ(license_test_data[i].key_request, key_request);
EXPECT_EQ(license_test_data[i].key_response, key_response);
EXPECT_EQ(license_test_data[i].key_request, key_request);
EXPECT_EQ(license_test_data[i].key_response, key_response);
EXPECT_EQ(license_test_data[i].playback_start_time, playback_start_time);
EXPECT_EQ(license_test_data[i].last_playback_time, last_playback_time);
EXPECT_TRUE(device_files.RetrieveLicense(license_test_data[i].key_set_id,
&license_data, &sub_error_code));
EXPECT_EQ(license_test_data[i].key_set_id, license_data.key_set_id);
EXPECT_EQ(license_test_data[i].license_state, license_data.state);
EXPECT_EQ(license_test_data[i].pssh_data, license_data.pssh_data);
EXPECT_EQ(license_test_data[i].key_request, license_data.license_request);
EXPECT_EQ(license_test_data[i].key_response, license_data.license);
EXPECT_EQ(license_test_data[i].key_renewal_request,
license_data.license_renewal_request);
EXPECT_EQ(license_test_data[i].key_renewal_response,
license_data.license_renewal);
EXPECT_EQ(license_test_data[i].playback_start_time,
license_data.playback_start_time);
EXPECT_EQ(license_test_data[i].last_playback_time,
license_data.last_playback_time);
EXPECT_EQ(license_test_data[i].grace_period_end_time,
grace_period_end_time);
EXPECT_EQ(license_test_data[i].usage_entry, usage_entry);
EXPECT_EQ(license_test_data[i].usage_entry_number, usage_entry_number);
license_data.grace_period_end_time);
EXPECT_EQ(license_test_data[i].usage_entry, license_data.usage_entry);
EXPECT_EQ(license_test_data[i].usage_entry_number,
license_data.usage_entry_number);
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
std::map<std::string, std::string>::iterator itr;
for (itr = app_parameters.begin(); itr != app_parameters.end(); ++itr) {
for (itr = license_data.app_parameters.begin();
itr != license_data.app_parameters.end(); ++itr) {
EXPECT_NE(std::string::npos,
license_test_data[i].app_parameters.find(itr->first));
EXPECT_NE(std::string::npos,
@@ -2465,38 +2463,25 @@ TEST_F(DeviceFilesTest, AppParametersBackwardCompatibility) {
DeviceFiles device_files(&file_system);
EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
DeviceFiles::LicenseState license_state;
CdmInitData pssh_data;
CdmKeyMessage key_request;
CdmKeyResponse key_response;
CdmKeyMessage key_renewal_request;
CdmKeyResponse key_renewal_response;
int64_t playback_start_time, last_playback_time;
int64_t grace_period_end_time;
std::string release_server_url;
CdmAppParameterMap app_parameters;
std::string usage_entry;
uint32_t usage_entry_number;
DeviceFiles::CdmLicenseData license_data;
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files.RetrieveLicense(
test_data->key_set_id, &license_state, &pssh_data, &key_request,
&key_response, &key_renewal_request, &key_renewal_response,
&release_server_url, &playback_start_time, &last_playback_time,
&grace_period_end_time, &app_parameters, &usage_entry,
&usage_entry_number, &sub_error_code));
EXPECT_EQ(test_data->license_state, license_state);
EXPECT_EQ(test_data->pssh_data, pssh_data);
EXPECT_EQ(test_data->key_request, key_request);
EXPECT_EQ(test_data->key_response, key_response);
EXPECT_EQ(test_data->key_request, key_request);
EXPECT_EQ(test_data->key_response, key_response);
EXPECT_EQ(test_data->playback_start_time, playback_start_time);
EXPECT_EQ(test_data->last_playback_time, last_playback_time);
EXPECT_EQ(test_data->grace_period_end_time, grace_period_end_time);
EXPECT_EQ(0u, app_parameters.size());
EXPECT_EQ(test_data->usage_entry, usage_entry);
EXPECT_EQ(test_data->usage_entry_number, usage_entry_number);
EXPECT_TRUE(device_files.RetrieveLicense(test_data->key_set_id, &license_data,
&sub_error_code));
EXPECT_EQ(test_data->license_state, license_data.state);
EXPECT_EQ(test_data->pssh_data, license_data.pssh_data);
EXPECT_EQ(test_data->key_request, license_data.license_request);
EXPECT_EQ(test_data->key_response, license_data.license);
EXPECT_EQ(test_data->key_renewal_request,
license_data.license_renewal_request);
EXPECT_EQ(test_data->key_renewal_response, license_data.license_renewal);
EXPECT_EQ(test_data->playback_start_time, license_data.playback_start_time);
EXPECT_EQ(test_data->last_playback_time, license_data.last_playback_time);
EXPECT_EQ(test_data->grace_period_end_time,
license_data.grace_period_end_time);
EXPECT_EQ(0u, license_data.app_parameters.size());
EXPECT_EQ(test_data->usage_entry, license_data.usage_entry);
EXPECT_EQ(test_data->usage_entry_number, license_data.usage_entry_number);
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
}
@@ -2518,8 +2503,7 @@ TEST_F(DeviceFilesTest, UpdateLicenseState) {
Eq(license_update_test_data[i].file_data.size())))
.WillOnce(ReturnArg<1>());
EXPECT_CALL(*file, Read(_, _)).Times(0);
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files.StoreLicense(
DeviceFiles::CdmLicenseData license_data{
license_update_test_data[0].key_set_id,
license_update_test_data[i].license_state,
license_update_test_data[0].pssh_data,
@@ -2533,7 +2517,9 @@ TEST_F(DeviceFilesTest, UpdateLicenseState) {
license_update_test_data[0].grace_period_end_time,
GetAppParameters(license_test_data[0].app_parameters),
license_update_test_data[0].usage_entry,
license_update_test_data[0].usage_entry_number, &sub_error_code));
license_update_test_data[0].usage_entry_number};
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files.StoreLicense(license_data, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
}
}
@@ -2566,43 +2552,37 @@ TEST_F(DeviceFilesTest, DeleteLicense) {
DeviceFiles device_files(&file_system);
EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
DeviceFiles::LicenseState license_state;
CdmInitData pssh_data;
CdmKeyMessage key_request;
CdmKeyResponse key_response;
CdmKeyMessage key_renewal_request;
CdmKeyResponse key_renewal_response;
std::string release_server_url;
int64_t playback_start_time, last_playback_time, grace_period_end_time;
CdmAppParameterMap app_parameters;
std::string usage_entry;
uint32_t usage_entry_number;
DeviceFiles::CdmLicenseData license_data;
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files.RetrieveLicense(
license_test_data[0].key_set_id, &license_state, &pssh_data, &key_request,
&key_response, &key_renewal_request, &key_renewal_response,
&release_server_url, &playback_start_time, &last_playback_time,
&grace_period_end_time, &app_parameters, &usage_entry,
&usage_entry_number, &sub_error_code));
EXPECT_EQ(license_test_data[0].license_state, license_state);
EXPECT_EQ(license_test_data[0].pssh_data, pssh_data);
EXPECT_EQ(license_test_data[0].key_request, key_request);
EXPECT_EQ(license_test_data[0].key_response, key_response);
EXPECT_EQ(license_test_data[0].key_request, key_request);
EXPECT_EQ(license_test_data[0].key_response, key_response);
EXPECT_EQ(license_test_data[0].playback_start_time, playback_start_time);
EXPECT_EQ(license_test_data[0].last_playback_time, last_playback_time);
EXPECT_EQ(license_test_data[0].grace_period_end_time, grace_period_end_time);
EXPECT_TRUE(device_files.RetrieveLicense(license_test_data[0].key_set_id,
&license_data, &sub_error_code));
EXPECT_EQ(license_test_data[0].key_set_id, license_data.key_set_id);
EXPECT_EQ(license_test_data[0].license_state, license_data.state);
EXPECT_EQ(license_test_data[0].pssh_data, license_data.pssh_data);
EXPECT_EQ(license_test_data[0].key_request, license_data.license_request);
EXPECT_EQ(license_test_data[0].key_response, license_data.license);
EXPECT_EQ(license_test_data[0].key_renewal_request,
license_data.license_renewal_request);
EXPECT_EQ(license_test_data[0].key_renewal_response,
license_data.license_renewal);
EXPECT_EQ(license_test_data[0].playback_start_time,
license_data.playback_start_time);
EXPECT_EQ(license_test_data[0].last_playback_time,
license_data.last_playback_time);
EXPECT_EQ(license_test_data[0].grace_period_end_time,
license_data.grace_period_end_time);
std::map<std::string, std::string>::iterator itr;
for (itr = app_parameters.begin(); itr != app_parameters.end(); ++itr) {
for (itr = license_data.app_parameters.begin();
itr != license_data.app_parameters.end(); ++itr) {
EXPECT_NE(license_test_data[0].app_parameters.find(itr->first),
std::string::npos);
EXPECT_NE(license_test_data[0].app_parameters.find(itr->second),
std::string::npos);
}
EXPECT_EQ(license_test_data[0].usage_entry, usage_entry);
EXPECT_EQ(license_test_data[0].usage_entry_number, usage_entry_number);
EXPECT_EQ(license_test_data[0].usage_entry, license_data.usage_entry);
EXPECT_EQ(license_test_data[0].usage_entry_number,
license_data.usage_entry_number);
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_TRUE(device_files.DeleteLicense(license_test_data[0].key_set_id));

242
libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp
View File

@@ -1380,24 +1380,42 @@ TEST_F(UsageTableHeaderTest,
uint32_t usage_entry_number_to_be_deleted =
usage_entry_info_vector.size() - 3; // kUsageEntryInfoOfflineLicense1
metrics::CryptoMetrics metrics;
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files_->StoreLicense(
DeviceFiles::ResponseType sub_error_code;
const DeviceFiles::CdmLicenseData license_data_1{
usage_entry_info_vector[usage_entry_info_vector.size() - 1].key_set_id,
kActiveLicenseState, kPsshData, kKeyRequest, kKeyResponse,
kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
usage_entry_info_vector.size() - 2, &sub_error_code));
kActiveLicenseState,
kPsshData,
kKeyRequest,
kKeyResponse,
kKeyRenewalRequest,
kKeyRenewalResponse,
kReleaseServerUrl,
kPlaybackStartTime,
kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime,
kEmptyAppParameters,
kUsageEntry,
static_cast<uint32_t>(usage_entry_info_vector.size() - 2)};
EXPECT_TRUE(device_files_->StoreLicense(license_data_1, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_TRUE(device_files_->StoreLicense(
const DeviceFiles::CdmLicenseData license_data_2{
usage_entry_info_vector[usage_entry_info_vector.size() - 2].key_set_id,
kActiveLicenseState, kPsshData, kKeyRequest, kKeyResponse,
kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
usage_entry_info_vector.size() - 3, &sub_error_code));
kActiveLicenseState,
kPsshData,
kKeyRequest,
kKeyResponse,
kKeyRenewalRequest,
kKeyRenewalResponse,
kReleaseServerUrl,
kPlaybackStartTime,
kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime,
kEmptyAppParameters,
kUsageEntry,
static_cast<uint32_t>(usage_entry_info_vector.size() - 3)};
EXPECT_TRUE(device_files_->StoreLicense(license_data_2, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
@@ -1589,14 +1607,23 @@ TEST_F(UsageTableHeaderTest,
usage_entry_info_vector.size() - 1; // kUsageEntryInfoOfflineLicense3
metrics::CryptoMetrics metrics;
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files_->StoreLicense(
const DeviceFiles::CdmLicenseData license_data{
usage_entry_info_vector[last_usage_entry_number].key_set_id,
kActiveLicenseState, kPsshData, kKeyRequest, kKeyResponse,
kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
last_usage_entry_number, &sub_error_code));
kActiveLicenseState,
kPsshData,
kKeyRequest,
kKeyResponse,
kKeyRenewalRequest,
kKeyRenewalResponse,
kReleaseServerUrl,
kPlaybackStartTime,
kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime,
kEmptyAppParameters,
kUsageEntry,
last_usage_entry_number};
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files_->StoreLicense(license_data, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
@@ -1737,14 +1764,23 @@ TEST_F(UsageTableHeaderTest,
usage_entry_info_vector.size() - 3; // kUsageEntryInfoOfflineLicense3
metrics::CryptoMetrics metrics;
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files_->StoreLicense(
const DeviceFiles::CdmLicenseData license_data{
usage_entry_info_vector[last_valid_usage_entry_number].key_set_id,
kActiveLicenseState, kPsshData, kKeyRequest, kKeyResponse,
kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
last_valid_usage_entry_number, &sub_error_code));
kActiveLicenseState,
kPsshData,
kKeyRequest,
kKeyResponse,
kKeyRenewalRequest,
kKeyRenewalResponse,
kReleaseServerUrl,
kPlaybackStartTime,
kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime,
kEmptyAppParameters,
kUsageEntry,
last_valid_usage_entry_number};
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files_->StoreLicense(license_data, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
@@ -1895,14 +1931,24 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsOffline) {
usage_entry_info_vector.size() - 1; // kUsageEntryInfoOfflineLicense3
metrics::CryptoMetrics metrics;
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files_->StoreLicense(
const DeviceFiles::CdmLicenseData stored_license_data{
usage_entry_info_vector[last_usage_entry_number].key_set_id,
kActiveLicenseState, kPsshData, kKeyRequest, kKeyResponse,
kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
last_usage_entry_number, &sub_error_code));
kActiveLicenseState,
kPsshData,
kKeyRequest,
kKeyResponse,
kKeyRenewalRequest,
kKeyRenewalResponse,
kReleaseServerUrl,
kPlaybackStartTime,
kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime,
kEmptyAppParameters,
kUsageEntry,
last_usage_entry_number};
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(
device_files_->StoreLicense(stored_license_data, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
@@ -1945,39 +1991,27 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsOffline) {
usage_table_header_->DeleteEntry(usage_entry_number_to_be_deleted,
device_files_, &metrics));
DeviceFiles::LicenseState license_state = DeviceFiles::kLicenseStateUnknown;
CdmInitData pssh_data;
CdmKeyMessage key_request;
CdmKeyResponse key_response;
CdmKeyMessage key_renewal_request;
CdmKeyResponse key_renewal_response;
std::string release_server_url;
int64_t playback_start_time;
int64_t last_playback_time;
int64_t grace_period_end_time;
CdmAppParameterMap app_parameters;
CdmUsageEntry usage_entry;
uint32_t usage_entry_number = ~0;
DeviceFiles::CdmLicenseData retrieved_license_data;
EXPECT_TRUE(
device_files_->RetrieveLicense(kUsageEntryInfoOfflineLicense3.key_set_id,
&retrieved_license_data, &sub_error_code));
EXPECT_TRUE(device_files_->RetrieveLicense(
kUsageEntryInfoOfflineLicense3.key_set_id, &license_state, &pssh_data,
&key_request, &key_response, &key_renewal_request, &key_renewal_response,
&release_server_url, &playback_start_time, &last_playback_time,
&grace_period_end_time, &app_parameters, &usage_entry,
&usage_entry_number, &sub_error_code));
EXPECT_EQ(kActiveLicenseState, license_state);
EXPECT_EQ(kPsshData, pssh_data);
EXPECT_EQ(kKeyRequest, key_request);
EXPECT_EQ(kKeyResponse, key_response);
EXPECT_EQ(kKeyRenewalRequest, key_renewal_request);
EXPECT_EQ(kKeyRenewalResponse, key_renewal_response);
EXPECT_EQ(kReleaseServerUrl, release_server_url);
EXPECT_EQ(kPlaybackStartTime, playback_start_time);
EXPECT_EQ(kPlaybackStartTime + kPlaybackDuration, last_playback_time);
EXPECT_EQ(kGracePeriodEndTime, grace_period_end_time);
EXPECT_EQ(kEmptyAppParameters.size(), app_parameters.size());
EXPECT_EQ(kAnotherUsageEntry, usage_entry);
EXPECT_EQ(usage_entry_number_to_be_deleted, usage_entry_number);
EXPECT_EQ(kActiveLicenseState, retrieved_license_data.state);
EXPECT_EQ(kPsshData, retrieved_license_data.pssh_data);
EXPECT_EQ(kKeyRequest, retrieved_license_data.license_request);
EXPECT_EQ(kKeyResponse, retrieved_license_data.license);
EXPECT_EQ(kKeyRenewalRequest, retrieved_license_data.license_renewal_request);
EXPECT_EQ(kKeyRenewalResponse, retrieved_license_data.license_renewal);
EXPECT_EQ(kReleaseServerUrl, retrieved_license_data.release_server_url);
EXPECT_EQ(kPlaybackStartTime, retrieved_license_data.playback_start_time);
EXPECT_EQ(kPlaybackStartTime + kPlaybackDuration,
retrieved_license_data.last_playback_time);
EXPECT_EQ(kGracePeriodEndTime, retrieved_license_data.grace_period_end_time);
EXPECT_EQ(kEmptyAppParameters.size(),
retrieved_license_data.app_parameters.size());
EXPECT_EQ(kAnotherUsageEntry, retrieved_license_data.usage_entry);
EXPECT_EQ(usage_entry_number_to_be_deleted,
retrieved_license_data.usage_entry_number);
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
}
@@ -2118,14 +2152,24 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreOfflineAndUnknknown) {
usage_entry_info_vector.size() - 3; // kUsageEntryInfoOfflineLicense3
metrics::CryptoMetrics metrics;
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(device_files_->StoreLicense(
const DeviceFiles::CdmLicenseData stored_license_data{
usage_entry_info_vector[last_valid_usage_entry_number].key_set_id,
kActiveLicenseState, kPsshData, kKeyRequest, kKeyResponse,
kKeyRenewalRequest, kKeyRenewalResponse, kReleaseServerUrl,
kPlaybackStartTime, kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry,
last_valid_usage_entry_number, &sub_error_code));
kActiveLicenseState,
kPsshData,
kKeyRequest,
kKeyResponse,
kKeyRenewalRequest,
kKeyRenewalResponse,
kReleaseServerUrl,
kPlaybackStartTime,
kPlaybackStartTime + kPlaybackDuration,
kGracePeriodEndTime,
kEmptyAppParameters,
kUsageEntry,
last_valid_usage_entry_number};
DeviceFiles::ResponseType sub_error_code;
EXPECT_TRUE(
device_files_->StoreLicense(stored_license_data, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
@@ -2169,39 +2213,27 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreOfflineAndUnknknown) {
usage_table_header_->DeleteEntry(usage_entry_number_to_be_deleted,
device_files_, &metrics));
DeviceFiles::LicenseState license_state = DeviceFiles::kLicenseStateUnknown;
CdmInitData pssh_data;
CdmKeyMessage key_request;
CdmKeyResponse key_response;
CdmKeyMessage key_renewal_request;
CdmKeyResponse key_renewal_response;
std::string release_server_url;
int64_t playback_start_time;
int64_t last_playback_time;
int64_t grace_period_end_time;
CdmAppParameterMap app_parameters;
CdmUsageEntry usage_entry;
uint32_t usage_entry_number = ~0;
DeviceFiles::CdmLicenseData retrieved_license_data;
EXPECT_TRUE(
device_files_->RetrieveLicense(kUsageEntryInfoOfflineLicense3.key_set_id,
&retrieved_license_data, &sub_error_code));
EXPECT_TRUE(device_files_->RetrieveLicense(
kUsageEntryInfoOfflineLicense3.key_set_id, &license_state, &pssh_data,
&key_request, &key_response, &key_renewal_request, &key_renewal_response,
&release_server_url, &playback_start_time, &last_playback_time,
&grace_period_end_time, &app_parameters, &usage_entry,
&usage_entry_number, &sub_error_code));
EXPECT_EQ(kActiveLicenseState, license_state);
EXPECT_EQ(kPsshData, pssh_data);
EXPECT_EQ(kKeyRequest, key_request);
EXPECT_EQ(kKeyResponse, key_response);
EXPECT_EQ(kKeyRenewalRequest, key_renewal_request);
EXPECT_EQ(kKeyRenewalResponse, key_renewal_response);
EXPECT_EQ(kReleaseServerUrl, release_server_url);
EXPECT_EQ(kPlaybackStartTime, playback_start_time);
EXPECT_EQ(kPlaybackStartTime + kPlaybackDuration, last_playback_time);
EXPECT_EQ(kGracePeriodEndTime, grace_period_end_time);
EXPECT_EQ(kEmptyAppParameters.size(), app_parameters.size());
EXPECT_EQ(kAnotherUsageEntry, usage_entry);
EXPECT_EQ(usage_entry_number_to_be_deleted, usage_entry_number);
EXPECT_EQ(kActiveLicenseState, retrieved_license_data.state);
EXPECT_EQ(kPsshData, retrieved_license_data.pssh_data);
EXPECT_EQ(kKeyRequest, retrieved_license_data.license_request);
EXPECT_EQ(kKeyResponse, retrieved_license_data.license);
EXPECT_EQ(kKeyRenewalRequest, retrieved_license_data.license_renewal_request);
EXPECT_EQ(kKeyRenewalResponse, retrieved_license_data.license_renewal);
EXPECT_EQ(kReleaseServerUrl, retrieved_license_data.release_server_url);
EXPECT_EQ(kPlaybackStartTime, retrieved_license_data.playback_start_time);
EXPECT_EQ(kPlaybackStartTime + kPlaybackDuration,
retrieved_license_data.last_playback_time);
EXPECT_EQ(kGracePeriodEndTime, retrieved_license_data.grace_period_end_time);
EXPECT_EQ(kEmptyAppParameters.size(),
retrieved_license_data.app_parameters.size());
EXPECT_EQ(kAnotherUsageEntry, retrieved_license_data.usage_entry);
EXPECT_EQ(usage_entry_number_to_be_deleted,
retrieved_license_data.usage_entry_number);
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
}