Merge "Modified return values for Restore operations"

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