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 PpExceptionTypeToMediaException(

[xhwang, 2016/10/24 17:06:13]

Please also update the function name.

     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 755 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