Merge "Modified return values for Restore operations"

libwvdrmengine/cdm/core/include/license.h

@@ -57,14 +57,15 @@ class CdmLicense {
   virtual CdmResponseType HandleEmbeddedKeyData(
       const InitializationData& init_data);
 
-  virtual bool RestoreOfflineLicense(
+  virtual CdmResponseType 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);
-  virtual bool RestoreLicenseForRelease(const CdmKeyMessage& license_request,
+  virtual CdmResponseType RestoreLicenseForRelease(
-                                        const CdmKeyResponse& license_response);
+      const CdmKeyMessage& license_request,
+      const CdmKeyResponse& license_response);
   virtual bool HasInitData() { return stored_init_data_.get(); }
   virtual bool IsKeyLoaded(const KeyId& key_id);
 

libwvdrmengine/cdm/core/include/wv_cdm_types.h

@@ -342,6 +342,19 @@ enum CdmResponseType {
   GET_DECRYPT_HASH_ERROR = 297,
   SESSION_NOT_FOUND_20 = 298,
   INVALID_DECRYPT_HASH_FORMAT = 299,
+  EMPTY_LICENSE_REQUEST_2 = 300,
+  EMPTY_LICENSE_REQUEST_3 = 301,
+  EMPTY_LICENSE_RESPONSE_3 = 302,
+  EMPTY_LICENSE_RESPONSE_4 = 303,
+  PARSE_REQUEST_ERROR_1 = 304,
+  PARSE_REQUEST_ERROR_2 = 305,
+  INVALID_LICENSE_REQUEST_TYPE_1 = 306,
+  INVALID_LICENSE_REQUEST_TYPE_2 = 307,
+  LICENSE_RESPONSE_PARSE_ERROR_4 = 308,
+  LICENSE_RESPONSE_PARSE_ERROR_5 = 309,
+  INVALID_LICENSE_TYPE_2 = 310,
+  SIGNATURE_NOT_FOUND_2 = 311,
+  SESSION_KEYS_NOT_FOUND_2 = 312,
   // Don't forget to add new values to ../test/test_printers.cpp.
 };
 

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -260,16 +260,19 @@ CdmResponseType CdmSession::RestoreOfflineSession(
     }
   }
 
+  CdmResponseType result;
   if (license_type == kLicenseTypeRelease) {
-    if (!license_parser_->RestoreLicenseForRelease(key_request_,
+    result =
-                                                   key_response_)) {
+        license_parser_->RestoreLicenseForRelease(key_request_, key_response_);
+
+    if (result != NO_ERROR) {
       return RELEASE_LICENSE_ERROR_1;
     }
   } else {
-    if (!license_parser_->RestoreOfflineLicense(
+    result = license_parser_->RestoreOfflineLicense(
-            key_request_, key_response_, offline_key_renewal_response_,
+        key_request_, key_response_, offline_key_renewal_response_,
-            playback_start_time, last_playback_time, grace_period_end_time,
+        playback_start_time, last_playback_time, grace_period_end_time, this);
-            this)) {
+    if (result != NO_ERROR) {
       return RESTORE_OFFLINE_LICENSE_ERROR_2;
     }
   }
@@ -314,9 +317,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",
@@ -325,13 +329,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",

libwvdrmengine/cdm/core/src/license.cpp

@@ -705,24 +705,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()) {
+  if (license_request.empty()) {
-    LOGE(
+    LOGE("CdmLicense::RestoreOfflineLicense: empty |license_request|");
-        "CdmLicense::RestoreOfflineLicense: key_request or response empty: "
+    return EMPTY_LICENSE_REQUEST_2;
-        "%u %u",
+  }
-        license_request.size(), license_response.size());
+
-    return false;
+  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");
+    LOGE("CdmLicense::RestoreOfflineLicense: |license_request| parse failed");
-    return false;
+    return PARSE_REQUEST_ERROR_1;
   }
 
   if (signed_request.type() != SignedMessage::LICENSE_REQUEST) {
@@ -730,26 +732,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;
@@ -783,24 +785,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()) {
+  if (license_request.empty()) {
-    LOGE(
+    LOGE("CdmLicense::RestoreLicenseForRelease: empty |license_request|");
-        "CdmLicense::RestoreLicenseForRelease: key_request or response empty:"
+    return EMPTY_LICENSE_REQUEST_3;
-        " %u %u",
+  }
-        license_request.size(), license_response.size());
+
-    return false;
+  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) {
@@ -809,7 +813,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();
@@ -819,7 +823,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()) {
@@ -827,14 +831,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;
@@ -842,7 +846,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())
@@ -853,11 +857,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())
@@ -866,7 +871,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) {

libwvdrmengine/cdm/core/test/test_printers.cpp

@@ -787,6 +787,45 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
     case INVALID_DECRYPT_HASH_FORMAT:
       *os << "INVALID_DECRYPT_HASH_FORMAT";
       break;
+    case EMPTY_LICENSE_REQUEST_2:
+      *os << "EMPTY_LICENSE_REQUEST_2";
+      break;
+    case EMPTY_LICENSE_REQUEST_3:
+      *os << "EMPTY_LICENSE_REQUEST_3";
+      break;
+    case EMPTY_LICENSE_RESPONSE_3:
+      *os << "EMPTY_LICENSE_RESPONSE_3";
+      break;
+    case EMPTY_LICENSE_RESPONSE_4:
+      *os << "EMPTY_LICENSE_RESPONSE_4";
+      break;
+    case PARSE_REQUEST_ERROR_1:
+      *os << "PARSE_REQUEST_ERROR_1";
+      break;
+    case PARSE_REQUEST_ERROR_2:
+      *os << "PARSE_REQUEST_ERROR_2";
+      break;
+    case INVALID_LICENSE_REQUEST_TYPE_1:
+      *os << "INVALID_LICENSE_REQUEST_TYPE_1";
+      break;
+    case INVALID_LICENSE_REQUEST_TYPE_2:
+      *os << "INVALID_LICENSE_REQUEST_TYPE_2";
+      break;
+    case LICENSE_RESPONSE_PARSE_ERROR_4:
+      *os << "LICENSE_RESPONSE_PARSE_ERROR_4";
+      break;
+    case LICENSE_RESPONSE_PARSE_ERROR_5:
+      *os << "LICENSE_RESPONSE_PARSE_ERROR_5";
+      break;
+    case INVALID_LICENSE_TYPE_2:
+      *os << "INVALID_LICENSE_TYPE_2";
+      break;
+    case SIGNATURE_NOT_FOUND_2:
+      *os << "SIGNATURE_NOT_FOUND_2";
+      break;
+    case SESSION_KEYS_NOT_FOUND_2:
+      *os << "SESSION_KEYS_NOT_FOUND_2";
+      break;
     default:
       *os << "Unknown CdmResponseType";
       break;

libwvdrmengine/include/WVErrors.h

@@ -273,10 +273,23 @@ enum {
   kSetDecryptHashError = ERROR_DRM_VENDOR_MIN + 283,
   kGetDecryptHashError = ERROR_DRM_VENDOR_MIN + 284,
   kInvalidDecryptHashFormat = ERROR_DRM_VENDOR_MIN + 285,
+  kEmptyLicenseRequest2 = ERROR_DRM_VENDOR_MIN + 286,
+  kEmptyLicenseRequest3 = ERROR_DRM_VENDOR_MIN + 287,
+  kEmptyLicenseResponse3 = ERROR_DRM_VENDOR_MIN + 288,
+  kEmptyLicenseResponse4 = ERROR_DRM_VENDOR_MIN + 289,
+  kParseRequestError1 = ERROR_DRM_VENDOR_MIN + 290,
+  kParseRequestError2 = ERROR_DRM_VENDOR_MIN + 291,
+  kInvalidLicenseRequestType1 = ERROR_DRM_VENDOR_MIN + 292,
+  kInvalidLicenseRequestType2 = ERROR_DRM_VENDOR_MIN + 293,
+  kLicenseResponseParseError4 = ERROR_DRM_VENDOR_MIN + 294,
+  kLicenseResponseParseError5 = ERROR_DRM_VENDOR_MIN + 295,
+  kInvalidLicenseType2 = ERROR_DRM_VENDOR_MIN + 296,
+  kSignatureNotFound2 = ERROR_DRM_VENDOR_MIN + 297,
+  kSessionKeysNotFound2 = ERROR_DRM_VENDOR_MIN + 298,
 
   // This should always follow the last error code.
   // The offset value should be updated each time a new error code is added.
-  kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 285,
+  kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 298,
 
   // Used by crypto test mode
   kErrorTestMode = ERROR_DRM_VENDOR_MAX,

libwvdrmengine/include/mapErrors-inl.h

@@ -531,6 +531,32 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
       return kGetDecryptHashError;
     case wvcdm::INVALID_DECRYPT_HASH_FORMAT:
       return kInvalidDecryptHashFormat;
+    case wvcdm::EMPTY_LICENSE_REQUEST_2:
+      return kEmptyLicenseRequest2;
+    case wvcdm::EMPTY_LICENSE_REQUEST_3:
+      return kEmptyLicenseRequest3;
+    case wvcdm::EMPTY_LICENSE_RESPONSE_3:
+      return kEmptyLicenseResponse3;
+    case wvcdm::EMPTY_LICENSE_RESPONSE_4:
+      return kEmptyLicenseResponse4;
+    case wvcdm::PARSE_REQUEST_ERROR_1:
+      return kParseRequestError1;
+    case wvcdm::PARSE_REQUEST_ERROR_2:
+      return kParseRequestError2;
+    case wvcdm::INVALID_LICENSE_REQUEST_TYPE_1:
+      return kInvalidLicenseRequestType1;
+    case wvcdm::INVALID_LICENSE_REQUEST_TYPE_2:
+      return kInvalidLicenseRequestType2;
+    case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_4:
+      return kLicenseResponseParseError4;
+    case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_5:
+      return kLicenseResponseParseError5;
+    case wvcdm::INVALID_LICENSE_TYPE_2:
+      return kInvalidLicenseType2;
+    case wvcdm::SIGNATURE_NOT_FOUND_2:
+      return kSignatureNotFound2;
+    case wvcdm::SESSION_KEYS_NOT_FOUND_2:
+      return kSessionKeysNotFound2;
   }
 
   // Return here instead of as a default case so that the compiler will warn

libwvdrmengine/include_hidl/mapErrors-inl.h

@@ -308,6 +308,19 @@ static Status mapCdmResponseType(wvcdm::CdmResponseType res) {
     case wvcdm::SET_DECRYPT_HASH_ERROR:
     case wvcdm::GET_DECRYPT_HASH_ERROR:
     case wvcdm::INVALID_DECRYPT_HASH_FORMAT:
+    case wvcdm::EMPTY_LICENSE_REQUEST_2:
+    case wvcdm::EMPTY_LICENSE_REQUEST_3:
+    case wvcdm::EMPTY_LICENSE_RESPONSE_3:
+    case wvcdm::EMPTY_LICENSE_RESPONSE_4:
+    case wvcdm::PARSE_REQUEST_ERROR_1:
+    case wvcdm::PARSE_REQUEST_ERROR_2:
+    case wvcdm::INVALID_LICENSE_REQUEST_TYPE_1:
+    case wvcdm::INVALID_LICENSE_REQUEST_TYPE_2:
+    case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_4:
+    case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_5:
+    case wvcdm::INVALID_LICENSE_TYPE_2:
+    case wvcdm::SIGNATURE_NOT_FOUND_2:
+    case wvcdm::SESSION_KEYS_NOT_FOUND_2:
       ALOGW("Returns UNKNOWN error for legacy status: %d", res);
       return Status::ERROR_DRM_UNKNOWN;