From 5bfdd515eb54cb1e316c11fdd4a316c8dba92e2b Mon Sep 17 00:00:00 2001 From: Alex Dale Date: Tue, 3 Sep 2019 11:58:27 -0700 Subject: [PATCH] Fewer parameters for storing and retrieve license information. [ 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 --- .../cdm/core/include/device_files.h | 50 ++-- libwvdrmengine/cdm/core/src/cdm_engine.cpp | 26 +- libwvdrmengine/cdm/core/src/cdm_session.cpp | 61 +++-- libwvdrmengine/cdm/core/src/device_files.cpp | 118 ++++----- .../cdm/core/src/usage_table_header.cpp | 82 +++--- .../cdm/core/test/device_files_unittest.cpp | 180 ++++++------- .../core/test/usage_table_header_unittest.cpp | 242 ++++++++++-------- 7 files changed, 364 insertions(+), 395 deletions(-) diff --git a/libwvdrmengine/cdm/core/include/device_files.h b/libwvdrmengine/cdm/core/include/device_files.h index 3e9a0a13..61879012 100644 --- a/libwvdrmengine/cdm/core/include/device_files.h +++ b/libwvdrmengine/cdm/core/include/device_files.h @@ -53,6 +53,31 @@ class DeviceFiles { kLicenseNotPresent = kResponseTypeBase + 16, }; + // CdmLicenseData represents all of the data that is stored in CDM + // license file. License data is uniquely keyed using |key_set_id|. + struct CdmLicenseData { + std::string key_set_id; + LicenseState state; + CdmInitData pssh_data; + // License request / response. + CdmKeyMessage license_request; + CdmKeyResponse license; + // License renewal request / response. + CdmKeyMessage license_renewal_request; + CdmKeyResponse license_renewal; + // License release. + std::string release_server_url; + // License times. + int64_t playback_start_time; + int64_t last_playback_time; + int64_t grace_period_end_time; + // App parameters. + CdmAppParameterMap app_parameters; + // Usage entry and index. + CdmUsageEntry usage_entry; + uint32_t usage_entry_number; + }; + struct CdmUsageData { std::string provider_session_token; CdmKeyMessage license_request; @@ -79,27 +104,12 @@ class DeviceFiles { virtual bool HasCertificate(); virtual bool RemoveCertificate(); - virtual bool StoreLicense( - const std::string& key_set_id, const LicenseState state, - const CdmInitData& pssh_data, const CdmKeyMessage& key_request, - const CdmKeyResponse& key_response, - const CdmKeyMessage& key_renewal_request, - const CdmKeyResponse& key_renewal_response, - const std::string& release_server_url, int64_t playback_start_time, - int64_t last_playback_time, int64_t grace_period_end_time, - const CdmAppParameterMap& app_parameters, - const CdmUsageEntry& usage_entry, uint32_t usage_entry_number, - ResponseType* result); + virtual bool StoreLicense(const CdmLicenseData& license_data, + ResponseType* result); - virtual bool RetrieveLicense( - const std::string& key_set_id, LicenseState* 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, int64_t* last_playback_time, - int64_t* grace_period_end_time, CdmAppParameterMap* app_parameters, - CdmUsageEntry* usage_entry, uint32_t* usage_entry_number, - ResponseType* result); + virtual bool RetrieveLicense(const std::string& key_set_id, + CdmLicenseData* license_data, + ResponseType* result); virtual bool DeleteLicense(const std::string& key_set_id); virtual bool ListLicenses(std::vector* key_set_ids); virtual bool DeleteAllFiles(); diff --git a/libwvdrmengine/cdm/core/src/cdm_engine.cpp b/libwvdrmengine/cdm/core/src/cdm_engine.cpp index b599a818..aebd5db8 100644 --- a/libwvdrmengine/cdm/core/src/cdm_engine.cpp +++ b/libwvdrmengine/cdm/core/src/cdm_engine.cpp @@ -1097,31 +1097,11 @@ CdmResponseType CdmEngine::GetOfflineLicenseState( return GET_OFFLINE_LICENSE_STATE_ERROR_1; } - DeviceFiles::LicenseState state; - - // Dummy arguments to make the RetrieveLicense call, - // do not care about the return value except for license state. - CdmAppParameterMap app_parameters; - CdmKeyMessage key_request; - CdmKeyResponse key_response; - CdmInitData offline_init_data; - CdmKeyMessage offline_key_renewal_request; - CdmKeyResponse offline_key_renewal_response; - CdmUsageEntry usage_entry; - int64_t grace_period_end_time; - int64_t last_playback_time; - std::string offline_release_server_url; - int64_t playback_start_time; - uint32_t usage_entry_number; + DeviceFiles::CdmLicenseData license_data; DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError; - if (handle.RetrieveLicense( - key_set_id, &state, &offline_init_data, &key_request, &key_response, - &offline_key_renewal_request, &offline_key_renewal_response, - &offline_release_server_url, &playback_start_time, - &last_playback_time, &grace_period_end_time, &app_parameters, - &usage_entry, &usage_entry_number, &sub_error_code)) { - *license_state = MapDeviceFilesLicenseState(state); + if (handle.RetrieveLicense(key_set_id, &license_data, &sub_error_code)) { + *license_state = MapDeviceFilesLicenseState(license_data.state); } else { LOGE("Failed to retrieve license state: key_set_id = %s", key_set_id.c_str()); diff --git a/libwvdrmengine/cdm/core/src/cdm_session.cpp b/libwvdrmengine/cdm/core/src/cdm_session.cpp index b9763d52..71fd431a 100644 --- a/libwvdrmengine/cdm/core/src/cdm_session.cpp +++ b/libwvdrmengine/cdm/core/src/cdm_session.cpp @@ -219,30 +219,32 @@ CdmResponseType CdmSession::RestoreOfflineSession(const CdmKeySetId& key_set_id, } key_set_id_ = key_set_id; - DeviceFiles::LicenseState license_state; - int64_t playback_start_time; - int64_t last_playback_time; - int64_t grace_period_end_time; + DeviceFiles::CdmLicenseData license_data; DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError; - if (!file_handle_->RetrieveLicense( - key_set_id, &license_state, &offline_init_data_, &key_request_, - &key_response_, &offline_key_renewal_request_, - &offline_key_renewal_response_, &offline_release_server_url_, - &playback_start_time, &last_playback_time, &grace_period_end_time, - &app_parameters_, &usage_entry_, &usage_entry_number_, - &sub_error_code)) { + if (!file_handle_->RetrieveLicense(key_set_id, &license_data, + &sub_error_code)) { LOGE("Failed to retrieve license: sub_error_code = %d, key_set_id = %s", static_cast(sub_error_code), key_set_id.c_str()); SetErrorDetail(error_detail, sub_error_code); return sub_error_code == DeviceFiles::kFileNotFound ? KEYSET_ID_NOT_FOUND_4 : GET_LICENSE_ERROR; } + offline_init_data_ = std::move(license_data.pssh_data); + key_request_ = std::move(license_data.license_request); + key_response_ = std::move(license_data.license); + offline_key_renewal_request_ = + std::move(license_data.license_renewal_request); + offline_key_renewal_response_ = std::move(license_data.license_renewal); + offline_release_server_url_ = std::move(license_data.release_server_url); + app_parameters_ = std::move(license_data.app_parameters); + usage_entry_ = std::move(license_data.usage_entry); + usage_entry_number_ = license_data.usage_entry_number; // Attempts to restore a released offline license are treated as a release // retry. if (Properties::allow_restore_of_offline_licenses_with_release()) { - if (license_state == DeviceFiles::kLicenseStateReleasing) { + if (license_data.state == DeviceFiles::kLicenseStateReleasing) { license_type = kLicenseTypeRelease; } } @@ -250,9 +252,9 @@ CdmResponseType CdmSession::RestoreOfflineSession(const CdmKeySetId& key_set_id, // Only restore offline licenses if they are active or this is a release // retry. if (!(license_type == kLicenseTypeRelease || - license_state == DeviceFiles::kLicenseStateActive)) { - LOGE("Invalid offline license state: license_state = %d, license_type = %d", - static_cast(license_state), static_cast(license_type)); + license_data.state == DeviceFiles::kLicenseStateActive)) { + LOGE("Invalid offline license state: state = %d, license_type = %d", + static_cast(license_data.state), static_cast(license_type)); return GET_RELEASED_LICENSE_ERROR; } @@ -285,7 +287,8 @@ CdmResponseType CdmSession::RestoreOfflineSession(const CdmKeySetId& key_set_id, } else { result = license_parser_->RestoreOfflineLicense( key_request_, key_response_, offline_key_renewal_response_, - playback_start_time, last_playback_time, grace_period_end_time, this); + license_data.playback_start_time, license_data.last_playback_time, + license_data.grace_period_end_time, this); if (result != NO_ERROR) { SetErrorDetail(error_detail, result); return RESTORE_OFFLINE_LICENSE_ERROR_2; @@ -300,7 +303,7 @@ CdmResponseType CdmSession::RestoreOfflineSession(const CdmKeySetId& key_set_id, LOGE("Failed to update usage entry: status = %d", static_cast(sts)); return sts; } - if (!StoreLicense(license_state, error_detail)) { + if (!StoreLicense(license_data.state, error_detail)) { LOGW("Unable to save updated usage info"); } } @@ -895,15 +898,25 @@ CdmResponseType CdmSession::StoreLicense() { bool CdmSession::StoreLicense(DeviceFiles::LicenseState state, int* error_detail) { DeviceFiles::ResponseType error_detail_alt = DeviceFiles::kNoError; - bool result = file_handle_->StoreLicense( - key_set_id_, state, offline_init_data_, key_request_, key_response_, - offline_key_renewal_request_, offline_key_renewal_response_, - offline_release_server_url_, policy_engine_->GetPlaybackStartTime(), + DeviceFiles::CdmLicenseData license_data{ + key_set_id_, + state, + /* pssh_data = */ offline_init_data_, + /* license_request = */ key_request_, + /* license = */ key_response_, + /* license_renewal_request = */ offline_key_renewal_request_, + /* license_renewal = */ offline_key_renewal_response_, + offline_release_server_url_, + policy_engine_->GetPlaybackStartTime(), policy_engine_->GetLastPlaybackTime(), - policy_engine_->GetGracePeriodEndTime(), app_parameters_, usage_entry_, - usage_entry_number_, &error_detail_alt); + policy_engine_->GetGracePeriodEndTime(), + app_parameters_, + usage_entry_, + usage_entry_number_}; + + bool result = file_handle_->StoreLicense(license_data, &error_detail_alt); if (error_detail != nullptr) { - *error_detail = error_detail_alt; + *error_detail = static_cast(error_detail_alt); } return result; } diff --git a/libwvdrmengine/cdm/core/src/device_files.cpp b/libwvdrmengine/cdm/core/src/device_files.cpp index f519c528..bc572380 100644 --- a/libwvdrmengine/cdm/core/src/device_files.cpp +++ b/libwvdrmengine/cdm/core/src/device_files.cpp @@ -211,16 +211,8 @@ bool DeviceFiles::RemoveCertificate() { return RemoveFile(GetCertificateFileName()); } -bool DeviceFiles::StoreLicense( - const std::string& key_set_id, const LicenseState state, - const CdmInitData& pssh_data, const CdmKeyMessage& license_request, - const CdmKeyResponse& license_message, - const CdmKeyMessage& license_renewal_request, - const CdmKeyResponse& license_renewal, - const std::string& release_server_url, int64_t playback_start_time, - int64_t last_playback_time, int64_t grace_period_end_time, - const CdmAppParameterMap& app_parameters, const CdmUsageEntry& usage_entry, - const uint32_t usage_entry_number, ResponseType* result) { +bool DeviceFiles::StoreLicense(const CdmLicenseData& license_data, + ResponseType* result) { RETURN_FALSE_IF_NULL(result); *result = kNoError; @@ -233,7 +225,7 @@ bool DeviceFiles::StoreLicense( file.set_version(video_widevine_client::sdk::File::VERSION_1); License* license = file.mutable_license(); - switch (state) { + switch (license_data.state) { case kLicenseStateActive: license->set_state(License_LicenseState_ACTIVE); break; @@ -241,47 +233,42 @@ bool DeviceFiles::StoreLicense( license->set_state(License_LicenseState_RELEASING); break; default: - LOGE("Unknown license state: %d", static_cast(state)); + LOGE("Unknown license state: %d", static_cast(license_data.state)); *result = kUnknownLicenseState; return false; break; } - license->set_pssh_data(pssh_data); - license->set_license_request(license_request); - license->set_license(license_message); - license->set_renewal_request(license_renewal_request); - license->set_renewal(license_renewal); - license->set_release_server_url(release_server_url); - license->set_playback_start_time(playback_start_time); - license->set_last_playback_time(last_playback_time); - license->set_grace_period_end_time(grace_period_end_time); - NameValue* app_params; - for (CdmAppParameterMap::const_iterator iter = app_parameters.begin(); - iter != app_parameters.end(); ++iter) { - app_params = license->add_app_parameters(); + license->set_pssh_data(license_data.pssh_data); + license->set_license_request(license_data.license_request); + license->set_license(license_data.license); + license->set_renewal_request(license_data.license_renewal_request); + license->set_renewal(license_data.license_renewal); + license->set_release_server_url(license_data.release_server_url); + license->set_playback_start_time(license_data.playback_start_time); + license->set_last_playback_time(license_data.last_playback_time); + license->set_grace_period_end_time(license_data.grace_period_end_time); + for (CdmAppParameterMap::const_iterator iter = + license_data.app_parameters.cbegin(); + iter != license_data.app_parameters.cend(); ++iter) { + NameValue* app_params = license->add_app_parameters(); app_params->set_name(iter->first); app_params->set_value(iter->second); } - license->set_usage_entry(usage_entry); - license->set_usage_entry_number(usage_entry_number); + license->set_usage_entry(license_data.usage_entry); + license->set_usage_entry_number(license_data.usage_entry_number); std::string serialized_file; file.SerializeToString(&serialized_file); - reserved_license_ids_.erase(key_set_id); - *result = - StoreFileWithHash(key_set_id + kLicenseFileNameExt, serialized_file); + reserved_license_ids_.erase(license_data.key_set_id); + *result = StoreFileWithHash(license_data.key_set_id + kLicenseFileNameExt, + serialized_file); return *result == kNoError; } -bool DeviceFiles::RetrieveLicense( - const std::string& key_set_id, LicenseState* state, CdmInitData* pssh_data, - CdmKeyMessage* license_request, CdmKeyResponse* license_message, - CdmKeyMessage* license_renewal_request, CdmKeyResponse* license_renewal, - 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, ResponseType* result) { +bool DeviceFiles::RetrieveLicense(const std::string& key_set_id, + CdmLicenseData* license_data, + ResponseType* result) { // This check must be made first as the RETURN_FALSE_IF_NULL() macro // will assign kParameterNull to |result|. if (result == nullptr) { @@ -289,20 +276,7 @@ bool DeviceFiles::RetrieveLicense( return false; } RETURN_FALSE_WITH_RESULT_IF_UNINITIALIZED(result); - - RETURN_FALSE_WITH_RESULT_IF_NULL(state, result); - RETURN_FALSE_WITH_RESULT_IF_NULL(pssh_data, result); - RETURN_FALSE_WITH_RESULT_IF_NULL(license_request, result); - RETURN_FALSE_WITH_RESULT_IF_NULL(license_message, result); - RETURN_FALSE_WITH_RESULT_IF_NULL(license_renewal_request, result); - RETURN_FALSE_WITH_RESULT_IF_NULL(license_renewal, result); - RETURN_FALSE_WITH_RESULT_IF_NULL(release_server_url, result); - RETURN_FALSE_WITH_RESULT_IF_NULL(playback_start_time, result); - RETURN_FALSE_WITH_RESULT_IF_NULL(last_playback_time, result); - RETURN_FALSE_WITH_RESULT_IF_NULL(grace_period_end_time, result); - RETURN_FALSE_WITH_RESULT_IF_NULL(app_parameters, result); - RETURN_FALSE_WITH_RESULT_IF_NULL(usage_entry, result); - RETURN_FALSE_WITH_RESULT_IF_NULL(usage_entry_number, result); + RETURN_FALSE_WITH_RESULT_IF_NULL(license_data, result); video_widevine_client::sdk::File file; *result = RetrieveHashedFile(key_set_id + kLicenseFileNameExt, &file); @@ -334,35 +308,37 @@ bool DeviceFiles::RetrieveLicense( return false; } + license_data->key_set_id = key_set_id; + License license = file.license(); switch (license.state()) { case License_LicenseState_ACTIVE: - *state = kLicenseStateActive; + license_data->state = kLicenseStateActive; break; case License_LicenseState_RELEASING: - *state = kLicenseStateReleasing; + license_data->state = kLicenseStateReleasing; break; default: LOGW("Unrecognized license state: %d", static_cast(license.state())); - *state = kLicenseStateUnknown; + license_data->state = kLicenseStateUnknown; break; } - *pssh_data = license.pssh_data(); - *license_request = license.license_request(); - *license_message = license.license(); - *license_renewal_request = license.renewal_request(); - *license_renewal = license.renewal(); - *release_server_url = license.release_server_url(); - *playback_start_time = license.playback_start_time(); - *last_playback_time = license.last_playback_time(); - *grace_period_end_time = license.grace_period_end_time(); + license_data->pssh_data = license.pssh_data(); + license_data->license_request = license.license_request(); + license_data->license = license.license(); + license_data->license_renewal_request = license.renewal_request(); + license_data->license_renewal = license.renewal(); + license_data->release_server_url = license.release_server_url(); + license_data->playback_start_time = license.playback_start_time(); + license_data->last_playback_time = license.last_playback_time(); + license_data->grace_period_end_time = license.grace_period_end_time(); for (int i = 0; i < license.app_parameters_size(); ++i) { - (*app_parameters)[license.app_parameters(i).name()] = + license_data->app_parameters[license.app_parameters(i).name()] = license.app_parameters(i).value(); } - *usage_entry = license.usage_entry(); - *usage_entry_number = license.usage_entry_number(); + license_data->usage_entry = license.usage_entry(); + license_data->usage_entry_number = license.usage_entry_number(); return true; } @@ -628,7 +604,7 @@ bool DeviceFiles::RetrieveUsageInfo( bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name, const std::string& provider_session_token, CdmKeyMessage* license_request, - CdmKeyResponse* license_response, + CdmKeyResponse* license, std::string* usage_entry, uint32_t* usage_entry_number) { RETURN_FALSE_IF_UNINITIALIZED(); @@ -643,7 +619,7 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name, for (; index < file.usage_info().sessions_size(); ++index) { if (file.usage_info().sessions(index).token() == provider_session_token) { *license_request = file.usage_info().sessions(index).license_request(); - *license_response = file.usage_info().sessions(index).license(); + *license = file.usage_info().sessions(index).license(); *usage_entry = file.usage_info().sessions(index).usage_entry(); *usage_entry_number = file.usage_info().sessions(index).usage_entry_number(); @@ -657,7 +633,7 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name, bool DeviceFiles::RetrieveUsageInfoByKeySetId( const std::string& usage_info_file_name, const std::string& key_set_id, std::string* provider_session_token, CdmKeyMessage* license_request, - CdmKeyResponse* license_response, std::string* usage_entry, + CdmKeyResponse* license, std::string* usage_entry, uint32_t* usage_entry_number) { RETURN_FALSE_IF_UNINITIALIZED(); @@ -672,7 +648,7 @@ bool DeviceFiles::RetrieveUsageInfoByKeySetId( if (file.usage_info().sessions(index).key_set_id() == key_set_id) { *provider_session_token = file.usage_info().sessions(index).token(); *license_request = file.usage_info().sessions(index).license_request(); - *license_response = file.usage_info().sessions(index).license(); + *license = file.usage_info().sessions(index).license(); *usage_entry = file.usage_info().sessions(index).usage_entry(); *usage_entry_number = file.usage_info().sessions(index).usage_entry_number(); diff --git a/libwvdrmengine/cdm/core/src/usage_table_header.cpp b/libwvdrmengine/cdm/core/src/usage_table_header.cpp index 2a5db310..ac4e2b3a 100644 --- a/libwvdrmengine/cdm/core/src/usage_table_header.cpp +++ b/libwvdrmengine/cdm/core/src/usage_table_header.cpp @@ -387,34 +387,30 @@ CdmResponseType UsageTableHeader::GetEntry(uint32_t usage_entry_number, uint32_t entry_number; switch (usage_entry_info_[usage_entry_number].storage_type) { case kStorageLicense: { - DeviceFiles::LicenseState license_state; - std::string init_data, key_request, key_response, key_renewal_request; - std::string key_renewal_response, release_server_url; - int64_t playback_start_time, last_playback_time, grace_period_end_time; - CdmAppParameterMap app_parameters; + DeviceFiles::CdmLicenseData license_data; DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError; if (!handle->RetrieveLicense( - usage_entry_info_[usage_entry_number].key_set_id, &license_state, - &init_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, &entry_number, &sub_error_code)) { + usage_entry_info_[usage_entry_number].key_set_id, &license_data, + &sub_error_code)) { LOGE("Failed to retrieve license: status = %d", static_cast(sub_error_code)); return USAGE_GET_ENTRY_RETRIEVE_LICENSE_FAILED; } + + entry_number = license_data.usage_entry_number; + *usage_entry = std::move(license_data.usage_entry); break; } case kStorageUsageInfo: { std::string provider_session_token; CdmKeyMessage license_request; - CdmKeyResponse license_response; + CdmKeyResponse license; if (!handle->RetrieveUsageInfoByKeySetId( usage_entry_info_[usage_entry_number].usage_info_file_name, usage_entry_info_[usage_entry_number].key_set_id, - &provider_session_token, &license_request, &license_response, - usage_entry, &entry_number)) { + &provider_session_token, &license_request, &license, usage_entry, + &entry_number)) { LOGE("Failed to retrieve usage information"); return USAGE_GET_ENTRY_RETRIEVE_USAGE_INFO_FAILED; } @@ -448,32 +444,25 @@ CdmResponseType UsageTableHeader::StoreEntry(uint32_t usage_entry_number, static_cast(usage_entry_number < usage_entry_info_.size() ? usage_entry_info_[usage_entry_number].storage_type : kStorageTypeUnknown)); - uint32_t entry_number; + switch (usage_entry_info_[usage_entry_number].storage_type) { case kStorageLicense: { - DeviceFiles::LicenseState license_state; - std::string init_data, key_request, key_response, key_renewal_request; - std::string key_renewal_response, release_server_url; - int64_t playback_start_time, last_playback_time, grace_period_end_time; - CdmAppParameterMap app_parameters; - CdmUsageEntry entry; + DeviceFiles::CdmLicenseData license_data; DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError; + if (!handle->RetrieveLicense( - usage_entry_info_[usage_entry_number].key_set_id, &license_state, - &init_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, - &entry, &entry_number, &sub_error_code)) { + usage_entry_info_[usage_entry_number].key_set_id, &license_data, + &sub_error_code)) { LOGE("Failed to retrieve license: status = %d", static_cast(sub_error_code)); return USAGE_STORE_ENTRY_RETRIEVE_LICENSE_FAILED; } - if (!handle->StoreLicense( - usage_entry_info_[usage_entry_number].key_set_id, license_state, - init_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)) { + + // Update. + license_data.usage_entry = usage_entry; + license_data.usage_entry_number = usage_entry_number; + + if (!handle->StoreLicense(license_data, &sub_error_code)) { LOGE("Failed to store license: status = %d", static_cast(sub_error_code)); return USAGE_STORE_LICENSE_FAILED; @@ -482,6 +471,7 @@ CdmResponseType UsageTableHeader::StoreEntry(uint32_t usage_entry_number, } case kStorageUsageInfo: { CdmUsageEntry entry; + uint32_t entry_number; std::string provider_session_token, init_data, key_request, key_response, key_renewal_request; if (!handle->RetrieveUsageInfoByKeySetId( @@ -582,27 +572,18 @@ bool UsageTableHeader::UpgradeLicensesFromUsageTable( } for (size_t i = 0; i < key_set_ids.size(); ++i) { - DeviceFiles::LicenseState license_state; - std::string init_data, key_request, key_response, key_renewal_request; - std::string key_renewal_response, release_server_url; - int64_t playback_start_time, last_playback_time, grace_period_end_time; - CdmAppParameterMap app_parameters; - CdmUsageEntry usage_entry; - uint32_t usage_entry_number; + DeviceFiles::CdmLicenseData license_data; DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError; - if (!handle->RetrieveLicense( - key_set_ids[i], &license_state, &init_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)) { + + if (!handle->RetrieveLicense(key_set_ids[i], &license_data, + &sub_error_code)) { LOGW("Failed to retrieve license: key_set_index = %zu, status = %d", i, static_cast(sub_error_code)); continue; } std::string provider_session_token; - if (!CdmLicense::ExtractProviderSessionToken(key_response, + if (!CdmLicense::ExtractProviderSessionToken(license_data.license, &provider_session_token)) { LOGW("Failed to extract provider session token: key_set_index = %zu", i); continue; @@ -621,7 +602,8 @@ bool UsageTableHeader::UpgradeLicensesFromUsageTable( if (!CreateDummyOldUsageEntry(crypto_session.get())) continue; status = AddEntry(crypto_session.get(), true /* persistent license */, - key_set_ids[i], kEmptyString, &usage_entry_number); + key_set_ids[i], kEmptyString, + &license_data.usage_entry_number); if (status != NO_ERROR) continue; @@ -633,7 +615,7 @@ bool UsageTableHeader::UpgradeLicensesFromUsageTable( continue; } - status = UpdateEntry(crypto_session.get(), &usage_entry); + status = UpdateEntry(crypto_session.get(), &license_data.usage_entry); if (status != NO_ERROR) { crypto_session->Close(); @@ -641,11 +623,7 @@ bool UsageTableHeader::UpgradeLicensesFromUsageTable( continue; } - if (!handle->StoreLicense( - key_set_ids[i], license_state, init_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)) { + if (!handle->StoreLicense(license_data, &sub_error_code)) { LOGW("Failed to store license: key_set_index = %zu, status = %d", i, static_cast(sub_error_code)); continue; diff --git a/libwvdrmengine/cdm/core/test/device_files_unittest.cpp b/libwvdrmengine/cdm/core/test/device_files_unittest.cpp index 0d46b00b..5b071c06 100644 --- a/libwvdrmengine/cdm/core/test/device_files_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/device_files_unittest.cpp @@ -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::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::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)); diff --git a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp b/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp index d1aa9606..fa95419d 100644 --- a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp @@ -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(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(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); }