Return more descriptive error codes on license generation failure

[ 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

libwvdrmengine/cdm/core/include/license.h

@@ -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,
+  virtual CdmResponseType PrepareKeyRequest(
-                                 const CdmLicenseType license_type,
+      const InitializationData& init_data, const CdmLicenseType license_type,
-                                 const CdmAppParameterMap& app_parameters,
+      const CdmAppParameterMap& app_parameters, const CdmSessionId& session_id,
-                                 const CdmSessionId& session_id,
+      CdmKeyMessage* signed_request, std::string* server_url);
-                                 CdmKeyMessage* signed_request,
-                                 std::string* server_url);
   virtual CdmResponseType PrepareKeyUpdateRequest(
       bool is_renewal, const CdmAppParameterMap& app_parameters,
       const CdmSessionId& session_id, CdmKeyMessage* signed_request,

libwvdrmengine/cdm/core/include/wv_cdm_types.h

@@ -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 {

libwvdrmengine/cdm/core/src/cdm_session.cpp

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

libwvdrmengine/cdm/core/src/license.cpp

@@ -163,36 +163,34 @@ bool CdmLicense::Init(const std::string& token, CryptoSession* session,
   return true;
 }
 
-bool CdmLicense::PrepareKeyRequest(const InitializationData& init_data,
+CdmResponseType CdmLicense::PrepareKeyRequest(
-                                   const CdmLicenseType license_type,
+    const InitializationData& init_data, const CdmLicenseType license_type,
-                                   const CdmAppParameterMap& app_parameters,
+    const CdmAppParameterMap& app_parameters, const CdmSessionId& session_id,
-                                   const CdmSessionId& session_id,
+    CdmKeyMessage* signed_request, std::string* server_url) {
-                                   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_;
   }
 

libwvdrmengine/cdm/core/test/test_printers.cpp

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

libwvdrmengine/include/WVErrors.h

@@ -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,

libwvdrmengine/include/mapErrors-inl.h

@@ -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:
+    case wvcdm::EMPTY_LICENSE_RENEWAL:
-      return kEmptyLicenseRequest;
+      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:
+    case wvcdm::LICENSE_RENEWAL_NONCE_GENERATION_ERROR:
-      return kGenerateNonceError;
+      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:
+    case wvcdm::LICENSE_RENEWAL_SIGNING_ERROR:
-      return kRenewalRequestError;
+      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:
+    case wvcdm::LICENSE_RENEWAL_SERVICE_CERTIFICATE_GENERATION_ERROR:
-      return kServiceCertificateRequestGenerateError;
+      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;
   }