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

Return more descriptive error codes on license generation failure

Browse Source 
[ Merge from http://go/wvgerrit/14745 ]

License generation errors previously would result in code -2916 being returned
though the mediaDrm API. More descriptive error codes are now being returned
from -2850 to -2836

b/13976775

Change-Id: I613ad650ab0a072ce9d8029e2af52b72dc617236
This commit is contained in:
Rahul Frias
2015-06-17 17:32:11 -07:00
parent b879cc6c3a
commit 99a2346e3a
7 changed files with 169 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
libwvdrmengine/cdm/core/include/license.h
View File

@@ -30,12 +30,10 @@ class CdmLicense {
virtual bool Init(const std::string& token, CryptoSession* session,
PolicyEngine* policy_engine);
virtual bool PrepareKeyRequest(const InitializationData& init_data,
const CdmLicenseType license_type,
const CdmAppParameterMap& app_parameters,
const CdmSessionId& session_id,
CdmKeyMessage* signed_request,
std::string* server_url);
virtual CdmResponseType PrepareKeyRequest(
const InitializationData& init_data, const CdmLicenseType license_type,
const CdmAppParameterMap& app_parameters, const CdmSessionId& session_id,
CdmKeyMessage* signed_request, std::string* server_url);
virtual CdmResponseType PrepareKeyUpdateRequest(
bool is_renewal, const CdmAppParameterMap& app_parameters,
const CdmSessionId& session_id, CdmKeyMessage* signed_request,

25
libwvdrmengine/cdm/core/include/wv_cdm_types.h
View File

@@ -80,14 +80,14 @@ enum CdmResponseType {
EMPTY_KEYSET_ID_ENG_2,
EMPTY_KEYSET_ID_ENG_3,
EMPTY_KEYSET_ID_ENG_4,
EMPTY_LICENSE_REQUEST,
EMPTY_LICENSE_RENEWAL,
EMPTY_LICENSE_RESPONSE_1,
EMPTY_LICENSE_RESPONSE_2,
EMPTY_PROVISIONING_CERTIFICATE_1,
EMPTY_PROVISIONING_RESPONSE,
EMPTY_SESSION_ID,
GENERATE_DERIVED_KEYS_ERROR,
GENERATE_NONCE_ERROR,
LICENSE_RENEWAL_NONCE_GENERATION_ERROR,
GENERATE_USAGE_REPORT_ERROR,
GET_LICENSE_ERROR,
GET_RELEASED_LICENSE_ERROR,
@@ -122,7 +122,7 @@ enum CdmResponseType {
INVALID_QUERY_KEY,
INVALID_SESSION_ID,
KEY_REQUEST_ERROR_1,
KEY_REQUEST_ERROR_2,
UNUSED_1, /* previously KEY_REQUEST_ERROR_2 */
KEY_SIZE_ERROR,
KEYSET_ID_NOT_FOUND_1,
KEYSET_ID_NOT_FOUND_2,
@@ -148,7 +148,7 @@ enum CdmResponseType {
RELEASE_USAGE_INFO_ERROR,
RENEW_KEY_ERROR_1,
RENEW_KEY_ERROR_2,
RENEWAL_REQUEST_ERROR,
LICENSE_RENEWAL_SIGNING_ERROR,
RESTORE_OFFLINE_LICENSE_ERROR_1,
RESTORE_OFFLINE_LICENSE_ERROR_2,
SESSION_INIT_ERROR_1,
@@ -177,7 +177,7 @@ enum CdmResponseType {
UNPROVISION_ERROR_4,
UNSUPPORTED_INIT_DATA,
USAGE_INFO_NOT_FOUND,
SERVICE_CERTIFICATE_REQUEST_GENERATE_ERROR,
LICENSE_RENEWAL_SERVICE_CERTIFICATE_GENERATION_ERROR,
PARSE_SERVICE_CERTIFICATE_ERROR,
SERVICE_CERTIFICATE_TYPE_ERROR,
CLIENT_ID_GENERATE_RANDOM_ERROR,
@@ -187,6 +187,21 @@ enum CdmResponseType {
CLIENT_ID_RSA_ENCRYPT_ERROR,
INVALID_QUERY_STATUS,
EMPTY_PROVISIONING_CERTIFICATE_2,
LICENSE_PARSER_NOT_INITIALIZED_4,
INVALID_PARAMETERS_LIC_3,
INVALID_PARAMETERS_LIC_4,
INVALID_PARAMETERS_LIC_5,
INVALID_PARAMETERS_LIC_6,
INVALID_PARAMETERS_LIC_7,
LICENSE_REQUEST_SERVICE_CERTIFICATE_GENERATION_ERROR,
CENC_INIT_DATA_UNAVAILABLE,
PREPARE_CENC_CONTENT_ID_FAILED,
WEBM_INIT_DATA_UNAVAILABLE,
PREPARE_WEBM_CONTENT_ID_FAILED,
UNSUPPORTED_INIT_DATA_FORMAT,
LICENSE_REQUEST_NONCE_GENERATION_ERROR,
LICENSE_REQUEST_SIGNING_ERROR,
EMPTY_LICENSE_REQUEST,
};
enum CdmKeyStatus {

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

@@ -209,11 +209,12 @@ CdmResponseType CdmSession::GenerateKeyRequest(
}
app_parameters_ = app_parameters;
if (!license_parser_->PrepareKeyRequest(init_data, license_type,
app_parameters, session_id_,
key_request, server_url)) {
return KEY_REQUEST_ERROR_2;
}
CdmResponseType status = license_parser_->PrepareKeyRequest(
init_data, license_type,
app_parameters, session_id_,
key_request, server_url);
if (KEY_MESSAGE != status) return status;
key_request_ = *key_request;
if (is_offline_) {

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

@@ -163,36 +163,34 @@ bool CdmLicense::Init(const std::string& token, CryptoSession* session,
return true;
}
bool CdmLicense::PrepareKeyRequest(const InitializationData& init_data,
const CdmLicenseType license_type,
const CdmAppParameterMap& app_parameters,
const CdmSessionId& session_id,
CdmKeyMessage* signed_request,
std::string* server_url) {
CdmResponseType CdmLicense::PrepareKeyRequest(
const InitializationData& init_data, const CdmLicenseType license_type,
const CdmAppParameterMap& app_parameters, const CdmSessionId& session_id,
CdmKeyMessage* signed_request, std::string* server_url) {
if (!initialized_) {
LOGE("CdmLicense::PrepareKeyRequest: not initialized");
return false;
return LICENSE_PARSER_NOT_INITIALIZED_4;
}
if (!init_data.is_supported()) {
LOGE("CdmLicense::PrepareKeyRequest: unsupported init data type (%s)",
init_data.type().c_str());
return false;
return INVALID_PARAMETERS_LIC_3;
}
if (init_data.IsEmpty() && stored_init_data_.empty()) {
LOGE("CdmLicense::PrepareKeyRequest: empty init data provided");
return false;
return INVALID_PARAMETERS_LIC_4;
}
if (session_id.empty()) {
LOGE("CdmLicense::PrepareKeyRequest: empty session id provided");
return false;
return INVALID_PARAMETERS_LIC_5;
}
if (!signed_request) {
LOGE("CdmLicense::PrepareKeyRequest: no signed request provided");
return false;
return INVALID_PARAMETERS_LIC_6;
}
if (!server_url) {
LOGE("CdmLicense::PrepareKeyRequest: no server url provided");
return false;
return INVALID_PARAMETERS_LIC_7;
}
std::string service_certificate;
@@ -200,7 +198,9 @@ bool CdmLicense::PrepareKeyRequest(const InitializationData& init_data,
if (privacy_mode_enabled) {
if (!GetServiceCertificate(session_id, &service_certificate)) {
stored_init_data_ = init_data.data();
return PrepareServiceCertificateRequest(signed_request, server_url);
return PrepareServiceCertificateRequest(signed_request, server_url)
? KEY_MESSAGE
: LICENSE_REQUEST_SERVICE_CERTIFICATE_GENERATION_ERROR;
}
}
@@ -211,7 +211,7 @@ bool CdmLicense::PrepareKeyRequest(const InitializationData& init_data,
CdmResponseType status =
PrepareClientId(privacy_mode_enabled, service_certificate, app_parameters,
&license_request);
if (NO_ERROR != status) return false;
if (NO_ERROR != status) return status;
// Content Identification may be a cenc_id, a webm_id or a license_id
LicenseRequest_ContentIdentification* content_id =
@@ -227,11 +227,11 @@ bool CdmLicense::PrepareKeyRequest(const InitializationData& init_data,
cenc_content_id->add_pssh(stored_init_data_);
} else {
LOGE("CdmLicense::PrepareKeyRequest: ISO-CENC init data not available");
return false;
return CENC_INIT_DATA_UNAVAILABLE;
}
if (!PrepareContentId(license_type, request_id, cenc_content_id)) {
return false;
return PREPARE_CENC_CONTENT_ID_FAILED;
}
} else if (init_data.is_webm()) {
LicenseRequest_ContentIdentification_WebM* webm_content_id =
@@ -243,16 +243,16 @@ bool CdmLicense::PrepareKeyRequest(const InitializationData& init_data,
webm_content_id->set_header(stored_init_data_);
} else {
LOGE("CdmLicense::PrepareKeyRequest: WebM init data not available");
return false;
return WEBM_INIT_DATA_UNAVAILABLE;
}
if (!PrepareContentId(license_type, request_id, webm_content_id)) {
return false;
return PREPARE_WEBM_CONTENT_ID_FAILED;
}
} else {
LOGE("CdmLicense::PrepareKeyRequest: no support for init data type (%s)",
init_data.type().c_str());
return false;
return UNSUPPORTED_INIT_DATA_FORMAT;
}
license_request.set_type(LicenseRequest::NEW);
@@ -263,7 +263,7 @@ bool CdmLicense::PrepareKeyRequest(const InitializationData& init_data,
// of the license response.
uint32_t nonce;
if (!session_->GenerateNonce(&nonce)) {
return false;
return LICENSE_REQUEST_NONCE_GENERATION_ERROR;
}
license_request.set_key_control_nonce(nonce);
LOGD("PrepareKeyRequest: nonce=%u", nonce);
@@ -281,13 +281,13 @@ bool CdmLicense::PrepareKeyRequest(const InitializationData& init_data,
if (!session_->PrepareRequest(serialized_license_req, false,
&license_request_signature)) {
signed_request->clear();
return false;
return LICENSE_REQUEST_SIGNING_ERROR;
}
if (license_request_signature.empty()) {
LOGE("CdmLicense::PrepareKeyRequest: License request signature empty");
signed_request->clear();
return false;
return EMPTY_LICENSE_REQUEST;
}
// Put serialize license request and signature together
@@ -299,7 +299,7 @@ bool CdmLicense::PrepareKeyRequest(const InitializationData& init_data,
signed_message.SerializeToString(signed_request);
*server_url = server_url_;
return true;
return KEY_MESSAGE;
}
CdmResponseType CdmLicense::PrepareKeyUpdateRequest(
@@ -334,7 +334,7 @@ CdmResponseType CdmLicense::PrepareKeyUpdateRequest(
if (!GetServiceCertificate(session_id, &service_certificate)) {
return PrepareServiceCertificateRequest(signed_request, server_url)
? KEY_MESSAGE
: SERVICE_CERTIFICATE_REQUEST_GENERATE_ERROR;
: LICENSE_RENEWAL_SERVICE_CERTIFICATE_GENERATION_ERROR;
}
}
CdmResponseType status =
@@ -385,7 +385,7 @@ CdmResponseType CdmLicense::PrepareKeyUpdateRequest(
// of the license response.
uint32_t nonce;
if (!session_->GenerateNonce(&nonce)) {
return GENERATE_NONCE_ERROR;
return LICENSE_RENEWAL_NONCE_GENERATION_ERROR;
}
license_request.set_key_control_nonce(nonce);
LOGD("PrepareKeyUpdateRequest: nonce=%u", nonce);
@@ -399,13 +399,13 @@ CdmResponseType CdmLicense::PrepareKeyUpdateRequest(
std::string license_request_signature;
if (!session_->PrepareRenewalRequest(serialized_license_req,
&license_request_signature))
return RENEWAL_REQUEST_ERROR;
return LICENSE_RENEWAL_SIGNING_ERROR;
if (license_request_signature.empty()) {
LOGE(
"CdmLicense::PrepareKeyUpdateRequest: empty license request"
" signature");
return EMPTY_LICENSE_REQUEST;
return EMPTY_LICENSE_RENEWAL;
}
// Put serialize license request and signature together
@@ -1064,7 +1064,7 @@ bool CdmLicense::GetServiceCertificate(const CdmSessionId& session_id,
&signed_service_certificate) ||
signed_service_certificate.empty() ||
NO_ERROR != VerifyAndExtractSignedServiceCertificate(
signed_service_certificate, service_certificate)) {
signed_service_certificate, service_certificate)) {
*service_certificate = service_certificate_;
}

58
libwvdrmengine/cdm/core/test/test_printers.cpp
View File

@@ -94,7 +94,7 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
break;
case EMPTY_KEYSET_ID_ENG_4: *os << "EMPTY_KEYSET_ID_ENG_4";
break;
case EMPTY_LICENSE_REQUEST: *os << "EMPTY_LICENSE_REQUEST";
case EMPTY_LICENSE_RENEWAL: *os << "EMPTY_LICENSE_RENEWAL";
break;
case EMPTY_LICENSE_RESPONSE_1: *os << "EMPTY_LICENSE_RESPONSE_1";
break;
@@ -108,7 +108,7 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
break;
case GENERATE_DERIVED_KEYS_ERROR: *os << "GENERATE_DERIVED_KEYS_ERROR";
break;
case GENERATE_NONCE_ERROR: *os << "GENERATE_NONCE_ERROR";
case LICENSE_RENEWAL_NONCE_GENERATION_ERROR: *os << "LICENSE_RENEWAL_NONCE_GENERATION_ERROR";
break;
case GENERATE_USAGE_REPORT_ERROR: *os << "GENERATE_USAGE_REPORT_ERROR";
break;
@@ -178,8 +178,6 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
break;
case KEY_REQUEST_ERROR_1: *os << "KEY_REQUEST_ERROR_1";
break;
case KEY_REQUEST_ERROR_2: *os << "KEY_REQUEST_ERROR_2";
break;
case KEY_SIZE_ERROR: *os << "KEY_SIZE_ERROR";
break;
case KEYSET_ID_NOT_FOUND_1: *os << "KEYSET_ID_NOT_FOUND_1";
@@ -231,7 +229,7 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
break;
case RENEW_KEY_ERROR_2: *os << "RENEW_KEY_ERROR_2";
break;
case RENEWAL_REQUEST_ERROR: *os << "RENEWAL_REQUEST_ERROR";
case LICENSE_RENEWAL_SIGNING_ERROR: *os << "LICENSE_RENEWAL_SIGNING_ERROR";
break;
case RESTORE_OFFLINE_LICENSE_ERROR_1: *os << "RESTORE_OFFLINE_LICENSE_ERROR_1";
break;
@@ -289,8 +287,58 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
break;
case USAGE_INFO_NOT_FOUND: *os << "USAGE_INFO_NOT_FOUND";
break;
case LICENSE_RENEWAL_SERVICE_CERTIFICATE_GENERATION_ERROR:
*os << "LICENSE_RENEWAL_SERVICE_CERTIFICATE_GENERATION_ERROR";
break;
case EMPTY_PROVISIONING_CERTIFICATE_2: *os << "EMPTY_PROVISIONING_CERTIFICATE_2";
break;
case PARSE_SERVICE_CERTIFICATE_ERROR: *os << "PARSE_SERVICE_CERTIFICATE_ERROR";
break;
case SERVICE_CERTIFICATE_TYPE_ERROR: *os << "SERVICE_CERTIFICATE_TYPE_ERROR";
break;
case CLIENT_ID_GENERATE_RANDOM_ERROR: *os << "CLIENT_ID_GENERATE_RANDOM_ERROR";
break;
case CLIENT_ID_AES_INIT_ERROR: *os << "CLIENT_ID_AES_INIT_ERROR";
break;
case CLIENT_ID_AES_ENCRYPT_ERROR: *os << "CLIENT_ID_AES_ENCRYPT_ERROR";
break;
case CLIENT_ID_RSA_INIT_ERROR: *os << "CLIENT_ID_RSA_INIT_ERROR";
break;
case CLIENT_ID_RSA_ENCRYPT_ERROR: *os << "CLIENT_ID_RSA_ENCRYPT_ERROR";
break;
case INVALID_QUERY_STATUS: *os << "INVALID_QUERY_STATUS";
break;
case LICENSE_PARSER_NOT_INITIALIZED_4: *os << "LICENSE_PARSER_NOT_INITIALIZED_4";
break;
case INVALID_PARAMETERS_LIC_3: *os << "INVALID_PARAMETERS_LIC_3";
break;
case INVALID_PARAMETERS_LIC_4: *os << "INVALID_PARAMETERS_LIC_4";
break;
case INVALID_PARAMETERS_LIC_5: *os << "INVALID_PARAMETERS_LIC_5";
break;
case INVALID_PARAMETERS_LIC_6: *os << "INVALID_PARAMETERS_LIC_6";
break;
case INVALID_PARAMETERS_LIC_7: *os << "INVALID_PARAMETERS_LIC_7";
break;
case LICENSE_REQUEST_SERVICE_CERTIFICATE_GENERATION_ERROR:
*os << "LICENSE_REQUEST_SERVICE_CERTIFICATE_GENERATION_ERROR";
break;
case CENC_INIT_DATA_UNAVAILABLE: *os << "CENC_INIT_DATA_UNAVAILABLE";
break;
case PREPARE_CENC_CONTENT_ID_FAILED: *os << "PREPARE_CENC_CONTENT_ID_FAILED";
break;
case WEBM_INIT_DATA_UNAVAILABLE: *os << "WEBM_INIT_DATA_UNAVAILABLE";
break;
case PREPARE_WEBM_CONTENT_ID_FAILED: *os << "PREPARE_WEBM_CONTENT_ID_FAILED";
break;
case UNSUPPORTED_INIT_DATA_FORMAT: *os << "UNSUPPORTED_INIT_DATA_FORMAT";
break;
case LICENSE_REQUEST_NONCE_GENERATION_ERROR: *os << "LICENSE_REQUEST_NONCE_GENERATION_ERROR";
break;
case LICENSE_REQUEST_SIGNING_ERROR: *os << "LICENSE_REQUEST_SIGNING_ERROR";
break;
case EMPTY_LICENSE_REQUEST: *os << "EMPTY_LICENSE_REQUEST";
break;
default:
*os << "Unknown CdmResponseType";
break;

26
libwvdrmengine/include/WVErrors.h
View File

@@ -54,14 +54,14 @@ enum {
kEmptyKeySetIdEng2 = ERROR_DRM_VENDOR_MIN + 38,
kEmptyKeySetIdEng3 = ERROR_DRM_VENDOR_MIN + 39,
kEmptyKeySetIdEng4 = ERROR_DRM_VENDOR_MIN + 40,
kEmptyLicenseRequest = ERROR_DRM_VENDOR_MIN + 41,
kEmptyLicenseRenewal = ERROR_DRM_VENDOR_MIN + 41,
kEmptyLicenseResponse1 = ERROR_DRM_VENDOR_MIN + 42,
kEmptyLicenseResponse2 = ERROR_DRM_VENDOR_MIN + 43,
kEmptyProvisioningCertificate1 = ERROR_DRM_VENDOR_MIN + 44,
kEmptyProvisioningResponse = ERROR_DRM_VENDOR_MIN + 45,
kEmptySessionId = ERROR_DRM_VENDOR_MIN + 46,
kGenerateDerivedKeysError = ERROR_DRM_VENDOR_MIN + 47,
kGenerateNonceError = ERROR_DRM_VENDOR_MIN + 48,
kLicenseRenewalNonceGenerationError = ERROR_DRM_VENDOR_MIN + 48,
kGenerateUsageReportError = ERROR_DRM_VENDOR_MIN + 49,
kGetLicenseError = ERROR_DRM_VENDOR_MIN + 50,
kGetReleasedLicenseError = ERROR_DRM_VENDOR_MIN + 51,
@@ -96,7 +96,6 @@ enum {
kInvalidQueryKey = ERROR_DRM_VENDOR_MIN + 80,
kInvalidSessionId = ERROR_DRM_VENDOR_MIN + 81,
kKeyRequestError1 = ERROR_DRM_VENDOR_MIN + 82,
kKeyRequestError2 = ERROR_DRM_VENDOR_MIN + 83,
kKeySizeError = ERROR_DRM_VENDOR_MIN + 84,
kKeySetIdNotFound1 = ERROR_DRM_VENDOR_MIN + 85,
kKeySetIdNotFound2 = ERROR_DRM_VENDOR_MIN + 86,
@@ -123,7 +122,7 @@ enum {
kReleaseUsageInfoError = ERROR_DRM_VENDOR_MIN + 107,
kRenewKeyError1 = ERROR_DRM_VENDOR_MIN + 108,
kRenewKeyError2 = ERROR_DRM_VENDOR_MIN + 109,
kRenewalRequestError = ERROR_DRM_VENDOR_MIN + 110,
kLicenseRenewalSigningError = ERROR_DRM_VENDOR_MIN + 110,
kRestoreOfflineLicenseError1 = ERROR_DRM_VENDOR_MIN + 111,
kRestoreOfflineLicenseError2 = ERROR_DRM_VENDOR_MIN + 112,
kSessionInitError1 = ERROR_DRM_VENDOR_MIN + 113,
@@ -152,7 +151,7 @@ enum {
kUnprovisioningError4 = ERROR_DRM_VENDOR_MIN + 136,
kUnsupportedInitData = ERROR_DRM_VENDOR_MIN + 137,
kUsageInfoNotFound = ERROR_DRM_VENDOR_MIN + 138,
kServiceCertificateRequestGenerateError = ERROR_DRM_VENDOR_MIN + 139,
kLicenseRenewalServiceCertificateGenerationError = ERROR_DRM_VENDOR_MIN + 139,
kParseServiceCertificateError = ERROR_DRM_VENDOR_MIN + 140,
kServiceCertificateTypeError = ERROR_DRM_VENDOR_MIN + 141,
kClientIdGenerateRandomError = ERROR_DRM_VENDOR_MIN + 142,
@@ -162,7 +161,22 @@ enum {
kClientIdRsaEncryptError = ERROR_DRM_VENDOR_MIN + 146,
kInvalidQueryStatus = ERROR_DRM_VENDOR_MIN + 147,
kEmptyProvisioningCertificate2 = ERROR_DRM_VENDOR_MIN + 148,
kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 148,
kLicenseParserNotInitialized4 = ERROR_DRM_VENDOR_MIN + 149,
kInvalidParametersLic3 = ERROR_DRM_VENDOR_MIN + 150,
kInvalidParametersLic4 = ERROR_DRM_VENDOR_MIN + 151,
kInvalidParametersLic5 = ERROR_DRM_VENDOR_MIN + 152,
kInvalidParametersLic6 = ERROR_DRM_VENDOR_MIN + 153,
kInvalidParametersLic7 = ERROR_DRM_VENDOR_MIN + 154,
kLicenseRequestServiceCertificateGenerationError = ERROR_DRM_VENDOR_MIN + 155,
kCencInitDataUnavailable = ERROR_DRM_VENDOR_MIN + 156,
kPrepareCencContentIdFailed = ERROR_DRM_VENDOR_MIN + 157,
kWebmInitDataUnavailable = ERROR_DRM_VENDOR_MIN + 158,
kPrepareWebmContentIdFailed = ERROR_DRM_VENDOR_MIN + 159,
kUnsupportedInitDataFormat = ERROR_DRM_VENDOR_MIN + 160,
kLicenseRequestNonceGenerationError = ERROR_DRM_VENDOR_MIN + 161,
kLicenseRequestSigningError = ERROR_DRM_VENDOR_MIN + 162,
kEmptyLicenseRequest = ERROR_DRM_VENDOR_MIN + 163,
kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 163,
// Used by crypto test mode
kErrorTestMode = ERROR_DRM_VENDOR_MAX,

48
libwvdrmengine/include/mapErrors-inl.h
View File

@@ -95,8 +95,8 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
return kEmptyKeySetIdEng3;
case wvcdm::EMPTY_KEYSET_ID_ENG_4:
return kEmptyKeySetIdEng4;
case wvcdm::EMPTY_LICENSE_REQUEST:
return kEmptyLicenseRequest;
case wvcdm::EMPTY_LICENSE_RENEWAL:
return kEmptyLicenseRenewal;
case wvcdm::EMPTY_LICENSE_RESPONSE_1:
return kEmptyLicenseResponse1;
case wvcdm::EMPTY_LICENSE_RESPONSE_2:
@@ -109,8 +109,8 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
return kEmptySessionId;
case wvcdm::GENERATE_DERIVED_KEYS_ERROR:
return kGenerateDerivedKeysError;
case wvcdm::GENERATE_NONCE_ERROR:
return kGenerateNonceError;
case wvcdm::LICENSE_RENEWAL_NONCE_GENERATION_ERROR:
return kLicenseRenewalNonceGenerationError;
case wvcdm::GENERATE_USAGE_REPORT_ERROR:
return kGenerateUsageReportError;
case wvcdm::GET_LICENSE_ERROR:
@@ -181,8 +181,6 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
return kInvalidSessionId;
case wvcdm::KEY_REQUEST_ERROR_1:
return kKeyRequestError1;
case wvcdm::KEY_REQUEST_ERROR_2:
return kKeyRequestError2;
case wvcdm::KEY_SIZE_ERROR:
return kKeySizeError;
case wvcdm::KEYSET_ID_NOT_FOUND_1:
@@ -233,8 +231,8 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
return kRenewKeyError1;
case wvcdm::RENEW_KEY_ERROR_2:
return kRenewKeyError2;
case wvcdm::RENEWAL_REQUEST_ERROR:
return kRenewalRequestError;
case wvcdm::LICENSE_RENEWAL_SIGNING_ERROR:
return kLicenseRenewalSigningError;
case wvcdm::RESTORE_OFFLINE_LICENSE_ERROR_1:
return kRestoreOfflineLicenseError1;
case wvcdm::RESTORE_OFFLINE_LICENSE_ERROR_2:
@@ -289,8 +287,8 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
return kUnsupportedInitData;
case wvcdm::USAGE_INFO_NOT_FOUND:
return kUsageInfoNotFound;
case wvcdm::SERVICE_CERTIFICATE_REQUEST_GENERATE_ERROR:
return kServiceCertificateRequestGenerateError;
case wvcdm::LICENSE_RENEWAL_SERVICE_CERTIFICATE_GENERATION_ERROR:
return kLicenseRenewalServiceCertificateGenerationError;
case wvcdm::PARSE_SERVICE_CERTIFICATE_ERROR:
return kParseServiceCertificateError;
case wvcdm::SERVICE_CERTIFICATE_TYPE_ERROR:
@@ -313,6 +311,36 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
return kInvalidQueryStatus;
case wvcdm::EMPTY_PROVISIONING_CERTIFICATE_2:
return kEmptyProvisioningCertificate2;
case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_4:
return kLicenseParserNotInitialized4;
case wvcdm::INVALID_PARAMETERS_LIC_3:
return kInvalidParametersLic3;
case wvcdm::INVALID_PARAMETERS_LIC_4:
return kInvalidParametersLic4;
case wvcdm::INVALID_PARAMETERS_LIC_5:
return kInvalidParametersLic5;
case wvcdm::INVALID_PARAMETERS_LIC_6:
return kInvalidParametersLic6;
case wvcdm::INVALID_PARAMETERS_LIC_7:
return kInvalidParametersLic7;
case wvcdm::LICENSE_REQUEST_SERVICE_CERTIFICATE_GENERATION_ERROR:
return kLicenseRequestServiceCertificateGenerationError;
case wvcdm::CENC_INIT_DATA_UNAVAILABLE:
return kCencInitDataUnavailable;
case wvcdm::PREPARE_CENC_CONTENT_ID_FAILED:
return kPrepareCencContentIdFailed;
case wvcdm::WEBM_INIT_DATA_UNAVAILABLE:
return kWebmInitDataUnavailable;
case wvcdm::PREPARE_WEBM_CONTENT_ID_FAILED:
return kPrepareWebmContentIdFailed;
case wvcdm::UNSUPPORTED_INIT_DATA_FORMAT:
return kUnsupportedInitDataFormat;
case wvcdm::LICENSE_REQUEST_NONCE_GENERATION_ERROR:
return kLicenseRequestNonceGenerationError;
case wvcdm::LICENSE_REQUEST_SIGNING_ERROR:
return kLicenseRequestSigningError;
case wvcdm::EMPTY_LICENSE_REQUEST:
return kEmptyLicenseRequest;
case wvcdm::UNKNOWN_ERROR:
return android::ERROR_DRM_UNKNOWN;
}