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

Modified return values for Restore operations

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

RestoreOfflineLicense and RestoreLicenseForRelease now return
CdmResponseType errors rather than a boolean. These error codes
can now be used when gathering metrics.

Bug: 115517916
Test: WV unit/integration tests
Change-Id: If4784d2cdd9825948c5dec31d3e60058ea06b61d
This commit is contained in:
Rahul Frias
2019-01-17 00:09:38 -08:00
parent cfe7221d9e
commit 675b934406
8 changed files with 159 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -258,16 +258,19 @@ CdmResponseType CdmSession::RestoreOfflineSession(
}
}
CdmResponseType result;
if (license_type == kLicenseTypeRelease) {
if (!license_parser_->RestoreLicenseForRelease(key_request_,
key_response_)) {
result =
license_parser_->RestoreLicenseForRelease(key_request_, key_response_);
if (result != NO_ERROR) {
return RELEASE_LICENSE_ERROR_1;
}
} else {
if (!license_parser_->RestoreOfflineLicense(
key_request_, key_response_, offline_key_renewal_response_,
playback_start_time, last_playback_time, grace_period_end_time,
this)) {
result = license_parser_->RestoreOfflineLicense(
key_request_, key_response_, offline_key_renewal_response_,
playback_start_time, last_playback_time, grace_period_end_time, this);
if (result != NO_ERROR) {
return RESTORE_OFFLINE_LICENSE_ERROR_2;
}
}
@@ -312,9 +315,10 @@ CdmResponseType CdmSession::RestoreUsageSession(
usage_entry_number_ = usage_data.usage_entry_number;
usage_provider_session_token_ = usage_data.provider_session_token;
CdmResponseType sts = NO_ERROR;
if (usage_support_type_ == kUsageEntrySupport &&
usage_table_header_ != NULL) {
CdmResponseType sts = usage_table_header_->LoadEntry(
sts = usage_table_header_->LoadEntry(
crypto_session_.get(), usage_entry_, usage_entry_number_);
if (sts != NO_ERROR) {
LOGE("CdmSession::RestoreUsageSession: failed to load usage entry = %d",
@@ -323,13 +327,15 @@ CdmResponseType CdmSession::RestoreUsageSession(
}
}
if (!license_parser_->RestoreLicenseForRelease(key_request_, key_response_)) {
sts = license_parser_->RestoreLicenseForRelease(key_request_, key_response_);
if (sts != NO_ERROR) {
return RELEASE_LICENSE_ERROR_2;
}
if (usage_support_type_ == kUsageEntrySupport &&
usage_table_header_ != NULL) {
CdmResponseType sts =
sts =
usage_table_header_->UpdateEntry(crypto_session_.get(), &usage_entry_);
if (sts != NO_ERROR) {
LOGE("CdmSession::RestoreUsageSession: failed to update usage entry: %d",

65
libwvdrmengine/cdm/core/src/license.cpp
View File

@@ -700,24 +700,26 @@ CdmResponseType CdmLicense::HandleEmbeddedKeyData(
return HandleNewEntitledKeys(init_data.ExtractWrappedKeys());
}
bool CdmLicense::RestoreOfflineLicense(
CdmResponseType CdmLicense::RestoreOfflineLicense(
const CdmKeyMessage& license_request,
const CdmKeyResponse& license_response,
const CdmKeyResponse& license_renewal_response, int64_t playback_start_time,
int64_t last_playback_time, int64_t grace_period_end_time,
CdmSession* cdm_session) {
if (license_request.empty() || license_response.empty()) {
LOGE(
"CdmLicense::RestoreOfflineLicense: key_request or response empty: "
"%u %u",
license_request.size(), license_response.size());
return false;
if (license_request.empty()) {
LOGE("CdmLicense::RestoreOfflineLicense: empty |license_request|");
return EMPTY_LICENSE_REQUEST_2;
}
if (license_response.empty()) {
LOGE("CdmLicense::RestoreOfflineLicense: empty |license_response|");
return EMPTY_LICENSE_RESPONSE_3;
}
SignedMessage signed_request;
if (!signed_request.ParseFromString(license_request)) {
LOGE("CdmLicense::RestoreOfflineLicense: license_request parse failed");
return false;
LOGE("CdmLicense::RestoreOfflineLicense: |license_request| parse failed");
return PARSE_REQUEST_ERROR_1;
}
if (signed_request.type() != SignedMessage::LICENSE_REQUEST) {
@@ -725,26 +727,26 @@ bool CdmLicense::RestoreOfflineLicense(
"CdmLicense::RestoreOfflineLicense: license request type: expected = "
"%d, actual = %d",
SignedMessage::LICENSE_REQUEST, signed_request.type());
return false;
return INVALID_LICENSE_REQUEST_TYPE_1;
}
key_request_ = signed_request.msg();
CdmResponseType sts = HandleKeyResponse(license_response);
if (sts != KEY_ADDED) return false;
if (sts != KEY_ADDED) return sts;
if (!license_renewal_response.empty()) {
sts = HandleKeyUpdateResponse(true, license_renewal_response);
if (sts != KEY_ADDED) return false;
if (sts != KEY_ADDED) return sts;
}
if (!provider_session_token_.empty()) {
if (cdm_session &&
cdm_session->get_usage_support_type() == kUsageEntrySupport) {
CdmResponseType status = cdm_session->UpdateUsageEntryInformation();
if (NO_ERROR != status) return false;
if (NO_ERROR != status) return sts;
}
std::string usage_report;
@@ -778,24 +780,26 @@ bool CdmLicense::RestoreOfflineLicense(
policy_engine_->RestorePlaybackTimes(playback_start_time, last_playback_time,
grace_period_end_time);
return true;
return NO_ERROR;
}
bool CdmLicense::RestoreLicenseForRelease(
CdmResponseType CdmLicense::RestoreLicenseForRelease(
const CdmKeyMessage& license_request,
const CdmKeyResponse& license_response) {
if (license_request.empty() || license_response.empty()) {
LOGE(
"CdmLicense::RestoreLicenseForRelease: key_request or response empty:"
" %u %u",
license_request.size(), license_response.size());
return false;
if (license_request.empty()) {
LOGE("CdmLicense::RestoreLicenseForRelease: empty |license_request|");
return EMPTY_LICENSE_REQUEST_3;
}
if (license_response.empty()) {
LOGE("CdmLicense::RestoreLicenseForRelease: empty |license_response|");
return EMPTY_LICENSE_RESPONSE_4;
}
SignedMessage signed_request;
if (!signed_request.ParseFromString(license_request)) {
LOGE("CdmLicense::RestoreLicenseForRelease: license_request parse failed");
return false;
return PARSE_REQUEST_ERROR_2;
}
if (signed_request.type() != SignedMessage::LICENSE_REQUEST) {
@@ -804,7 +808,7 @@ bool CdmLicense::RestoreLicenseForRelease(
"expected "
"= %d, actual = %d",
SignedMessage::LICENSE_REQUEST, signed_request.type());
return false;
return INVALID_LICENSE_REQUEST_TYPE_2;
}
key_request_ = signed_request.msg();
@@ -814,7 +818,7 @@ bool CdmLicense::RestoreLicenseForRelease(
LOGE(
"CdmLicense::RestoreLicenseForRelease: unable to parse signed license"
" response");
return false;
return LICENSE_RESPONSE_PARSE_ERROR_4;
}
if (SignedMessage::LICENSE != signed_response.type()) {
@@ -822,14 +826,14 @@ bool CdmLicense::RestoreLicenseForRelease(
"CdmLicense::RestoreLicenseForRelease: unrecognized signed message "
"type: %d",
signed_response.type());
return false;
return INVALID_LICENSE_TYPE_2;
}
if (!signed_response.has_signature()) {
LOGE(
"CdmLicense::RestoreLicenseForRelease: license response is not"
" signed");
return false;
return SIGNATURE_NOT_FOUND_2;
}
License license;
@@ -837,7 +841,7 @@ bool CdmLicense::RestoreLicenseForRelease(
LOGE(
"CdmLicense::RestoreLicenseForRelease: unable to parse license"
" response");
return false;
return LICENSE_RESPONSE_PARSE_ERROR_5;
}
if (license.id().has_provider_session_token())
@@ -848,11 +852,12 @@ bool CdmLicense::RestoreLicenseForRelease(
if (!signed_response.has_session_key()) {
LOGE("CdmLicense::RestoreLicenseForRelease: no session keys present");
return false;
return SESSION_KEYS_NOT_FOUND_2;
}
if (!license.id().has_provider_session_token()) {
return KEY_ADDED == HandleKeyResponse(license_response);
CdmResponseType result = HandleKeyResponse(license_response);
return result == KEY_ADDED ? NO_ERROR : result;
}
if (license.policy().has_renewal_server_url())
@@ -861,7 +866,7 @@ bool CdmLicense::RestoreLicenseForRelease(
// If the policy engine already has keys, they will now expire.
// If the policy engine does not already have keys, this will not add any.
policy_engine_->SetLicenseForRelease(license);
return true;
return NO_ERROR;
}
bool CdmLicense::IsKeyLoaded(const KeyId& key_id) {