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

50
libwvdrmengine/cdm/core/include/device_files.h
View File

@@ -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<std::string>* key_set_ids);
virtual bool DeleteAllFiles();

26
libwvdrmengine/cdm/core/src/cdm_engine.cpp
View File

@@ -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());

61
libwvdrmengine/cdm/core/src/cdm_session.cpp
View File

@@ -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<int>(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<int>(license_state), static_cast<int>(license_type));
license_data.state == DeviceFiles::kLicenseStateActive)) {
LOGE("Invalid offline license state: state = %d, license_type = %d",
static_cast<int>(license_data.state), static_cast<int>(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<int>(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<int>(error_detail_alt);
}
return result;
}

118
libwvdrmengine/cdm/core/src/device_files.cpp
View File

@@ -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<int>(state));
LOGE("Unknown license state: %d", static_cast<int>(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<int>(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();

82
libwvdrmengine/cdm/core/src/usage_table_header.cpp
View File

@@ -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<int>(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<int>(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<int>(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<int>(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<int>(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<int>(sub_error_code));
continue;

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);
}