Move MediaKeys::Exception to CdmPromise::Exception

content/renderer/pepper/content_decryptor_delegate.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/pepper/content_decryptor_delegate.h"
 
 #include <string.h>
 #include <utility>
 #include <vector>
 
@@ skipping 18 matching lines @@
 #include "media/base/video_util.h"
 #include "ppapi/shared_impl/array_var.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_buffer_api.h"
 #include "ui/gfx/geometry/rect.h"
 
+using media::CdmPromise;
 using media::Decryptor;
 using media::MediaKeys;
 using media::NewSessionCdmPromise;
 using media::SimpleCdmPromise;
 using ppapi::ArrayBufferVar;
 using ppapi::ArrayVar;
 using ppapi::PpapiGlobals;
 using ppapi::ScopedPPResource;
 using ppapi::StringVar;
 using ppapi::thunk::EnterResourceNoLock;
@@ skipping 233 matching lines @@
       return PP_INITDATATYPE_KEYIDS;
     case media::EmeInitDataType::WEBM:
       return PP_INITDATATYPE_WEBM;
     case media::EmeInitDataType::UNKNOWN:
       break;
   }
   NOTREACHED();
   return PP_INITDATATYPE_KEYIDS;
 }
 
-MediaKeys::Exception PpExceptionTypeToMediaException(
+CdmPromise::Exception PpExceptionTypeToCdmPromiseException(
     PP_CdmExceptionCode exception_code) {
   switch (exception_code) {
     case PP_CDMEXCEPTIONCODE_NOTSUPPORTEDERROR:
-      return MediaKeys::NOT_SUPPORTED_ERROR;
+      return CdmPromise::NOT_SUPPORTED_ERROR;
     case PP_CDMEXCEPTIONCODE_INVALIDSTATEERROR:
-      return MediaKeys::INVALID_STATE_ERROR;
+      return CdmPromise::INVALID_STATE_ERROR;
     case PP_CDMEXCEPTIONCODE_INVALIDACCESSERROR:
-      return MediaKeys::INVALID_ACCESS_ERROR;
+      return CdmPromise::INVALID_ACCESS_ERROR;
     case PP_CDMEXCEPTIONCODE_QUOTAEXCEEDEDERROR:
-      return MediaKeys::QUOTA_EXCEEDED_ERROR;
+      return CdmPromise::QUOTA_EXCEEDED_ERROR;
     case PP_CDMEXCEPTIONCODE_UNKNOWNERROR:
-      return MediaKeys::UNKNOWN_ERROR;
+      return CdmPromise::UNKNOWN_ERROR;
     case PP_CDMEXCEPTIONCODE_CLIENTERROR:
-      return MediaKeys::CLIENT_ERROR;
+      return CdmPromise::CLIENT_ERROR;
     case PP_CDMEXCEPTIONCODE_OUTPUTERROR:
-      return MediaKeys::OUTPUT_ERROR;
+      return CdmPromise::OUTPUT_ERROR;
     default:
       NOTREACHED();
-      return MediaKeys::UNKNOWN_ERROR;
+      return CdmPromise::UNKNOWN_ERROR;
   }
 }
 
 media::CdmKeyInformation::KeyStatus PpCdmKeyStatusToCdmKeyInformationKeyStatus(
     PP_CdmKeyStatus status) {
   switch (status) {
     case PP_CDMKEYSTATUS_USABLE:
       return media::CdmKeyInformation::USABLE;
     case PP_CDMKEYSTATUS_INVALID:
       return media::CdmKeyInformation::INTERNAL_ERROR;
@@ skipping 87 matching lines @@
 void ContentDecryptorDelegate::InstanceCrashed() {
   fatal_plugin_error_cb_.Run();
   SatisfyAllPendingCallbacksOnError();
 }
 
 void ContentDecryptorDelegate::SetServerCertificate(
     const std::vector<uint8_t>& certificate,
     std::unique_ptr<media::SimpleCdmPromise> promise) {
   if (certificate.size() < media::limits::kMinCertificateLength ||
       certificate.size() > media::limits::kMaxCertificateLength) {
-    promise->reject(
-        media::MediaKeys::INVALID_ACCESS_ERROR, 0, "Incorrect certificate.");
+    promise->reject(CdmPromise::INVALID_ACCESS_ERROR, 0,
+                    "Incorrect certificate.");
     return;
   }
 
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   PP_Var certificate_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           base::checked_cast<uint32_t>(certificate.size()), certificate.data());
   plugin_decryption_interface_->SetServerCertificate(
       pp_instance_, promise_id, certificate_array);
 }
@@ skipping 32 matching lines @@
           base::checked_cast<uint32_t>(response.size()), response.data());
   plugin_decryption_interface_->UpdateSession(
       pp_instance_, promise_id, StringVar::StringToPPVar(session_id),
       response_array);
 }
 
 void ContentDecryptorDelegate::CloseSession(
     const std::string& session_id,
     std::unique_ptr<SimpleCdmPromise> promise) {
   if (session_id.length() > media::limits::kMaxSessionIdLength) {
-    promise->reject(
-        media::MediaKeys::INVALID_ACCESS_ERROR, 0, "Incorrect session.");
+    promise->reject(CdmPromise::INVALID_ACCESS_ERROR, 0, "Incorrect session.");
     return;
   }
 
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   plugin_decryption_interface_->CloseSession(
       pp_instance_, promise_id, StringVar::StringToPPVar(session_id));
 }
 
 void ContentDecryptorDelegate::RemoveSession(
     const std::string& session_id,
     std::unique_ptr<SimpleCdmPromise> promise) {
   if (session_id.length() > media::limits::kMaxSessionIdLength) {
-    promise->reject(
-        media::MediaKeys::INVALID_ACCESS_ERROR, 0, "Incorrect session.");
+    promise->reject(CdmPromise::INVALID_ACCESS_ERROR, 0, "Incorrect session.");
     return;
   }
 
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   plugin_decryption_interface_->RemoveSession(
       pp_instance_, promise_id, StringVar::StringToPPVar(session_id));
 }
 
 // TODO(xhwang): Remove duplication of code in Decrypt(),
 // DecryptAndDecodeAudio() and DecryptAndDecodeVideo().
@@ skipping 250 matching lines @@
 void ContentDecryptorDelegate::OnPromiseRejected(
     uint32_t promise_id,
     PP_CdmExceptionCode exception_code,
     uint32_t system_code,
     PP_Var error_description) {
   ReportSystemCodeUMA(key_system_, system_code);
 
   StringVar* error_description_string = StringVar::FromPPVar(error_description);
   DCHECK(error_description_string);
   cdm_promise_adapter_.RejectPromise(
-      promise_id, PpExceptionTypeToMediaException(exception_code), system_code,
-      error_description_string->value());
+      promise_id, PpExceptionTypeToCdmPromiseException(exception_code),
+      system_code, error_description_string->value());
 }
 
 void ContentDecryptorDelegate::OnSessionMessage(PP_Var session_id,
                                                 PP_CdmMessageType message_type,
                                                 PP_Var message) {
   if (session_message_cb_.is_null())
     return;
 
   StringVar* session_id_string = StringVar::FromPPVar(session_id);
   DCHECK(session_id_string);
@@ skipping 483 matching lines @@
                                           empty_frames);
   }
 
   if (!video_decode_cb_.is_null())
     video_decode_cb_.ResetAndReturn().Run(media::Decryptor::kError, NULL);
 
   cdm_promise_adapter_.Clear();
 }
 
 }  // namespace content