media: Rename MediaKeys to ContentDecryptionModule

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 20 matching lines @@
 #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::ContentDecryptionModule;
 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;
 using ppapi::thunk::PPB_Buffer_API;
 
@@ skipping 214 matching lines @@
       return media::kSampleFormatPlanarS16;
     case PP_DECRYPTEDSAMPLEFORMAT_PLANAR_F32:
       return media::kSampleFormatPlanarF32;
     default:
       NOTREACHED();
       return media::kUnknownSampleFormat;
   }
 }
 
 PP_SessionType MediaSessionTypeToPpSessionType(
-    MediaKeys::SessionType session_type) {
+    ContentDecryptionModule::SessionType session_type) {
   switch (session_type) {
-    case MediaKeys::TEMPORARY_SESSION:
+    case ContentDecryptionModule::TEMPORARY_SESSION:
       return PP_SESSIONTYPE_TEMPORARY;
-    case MediaKeys::PERSISTENT_LICENSE_SESSION:
+    case ContentDecryptionModule::PERSISTENT_LICENSE_SESSION:
       return PP_SESSIONTYPE_PERSISTENT_LICENSE;
-    case MediaKeys::PERSISTENT_RELEASE_MESSAGE_SESSION:
+    case ContentDecryptionModule::PERSISTENT_RELEASE_MESSAGE_SESSION:
       return PP_SESSIONTYPE_PERSISTENT_RELEASE;
     default:
       NOTREACHED();
       return PP_SESSIONTYPE_TEMPORARY;
   }
 }
 
 PP_InitDataType MediaInitDataTypeToPpInitDataType(
     media::EmeInitDataType init_data_type) {
   switch (init_data_type) {
@@ skipping 49 matching lines @@
     case PP_CDMKEYSTATUS_STATUSPENDING:
       return media::CdmKeyInformation::KEY_STATUS_PENDING;
     case PP_CDMKEYSTATUS_RELEASED:
       return media::CdmKeyInformation::RELEASED;
     default:
       NOTREACHED();
       return media::CdmKeyInformation::INTERNAL_ERROR;
   }
 }
 
-MediaKeys::MessageType PpCdmMessageTypeToMediaMessageType(
+ContentDecryptionModule::MessageType PpCdmMessageTypeToMediaMessageType(
     PP_CdmMessageType message_type) {
   switch (message_type) {
     case PP_CDMMESSAGETYPE_LICENSE_REQUEST:
-      return MediaKeys::LICENSE_REQUEST;
+      return ContentDecryptionModule::LICENSE_REQUEST;
     case PP_CDMMESSAGETYPE_LICENSE_RENEWAL:
-      return MediaKeys::LICENSE_RENEWAL;
+      return ContentDecryptionModule::LICENSE_RENEWAL;
     case PP_CDMMESSAGETYPE_LICENSE_RELEASE:
-      return MediaKeys::LICENSE_RELEASE;
+      return ContentDecryptionModule::LICENSE_RELEASE;
     default:
       NOTREACHED();
-      return MediaKeys::LICENSE_REQUEST;
+      return ContentDecryptionModule::LICENSE_REQUEST;
   }
 }
 
 // TODO(xhwang): Unify EME UMA reporting code when prefixed EME is deprecated.
 // See http://crbug.com/412987 for details.
 void ReportSystemCodeUMA(const std::string& key_system, uint32_t system_code) {
   // Sparse histogram macro does not cache the histogram, so it's safe to use
   // macro with non-static histogram name here.
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       "Media.EME." + media::GetKeySystemNameForUMA(key_system) + ".SystemCode",
@@ skipping 63 matching lines @@
 
   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);
 }
 
 void ContentDecryptorDelegate::CreateSessionAndGenerateRequest(
-    MediaKeys::SessionType session_type,
+    ContentDecryptionModule::SessionType session_type,
     media::EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
     std::unique_ptr<NewSessionCdmPromise> promise) {
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   PP_Var init_data_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           base::checked_cast<uint32_t>(init_data.size()), init_data.data());
   plugin_decryption_interface_->CreateSessionAndGenerateRequest(
       pp_instance_, promise_id, MediaSessionTypeToPpSessionType(session_type),
       MediaInitDataTypeToPpInitDataType(init_data_type), init_data_array);
 }
 
 void ContentDecryptorDelegate::LoadSession(
-    media::MediaKeys::SessionType session_type,
+    ContentDecryptionModule::SessionType session_type,
     const std::string& session_id,
     std::unique_ptr<NewSessionCdmPromise> promise) {
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   plugin_decryption_interface_->LoadSession(
       pp_instance_, promise_id, MediaSessionTypeToPpSessionType(session_type),
       StringVar::StringToPPVar(session_id));
 }
 
 void ContentDecryptorDelegate::UpdateSession(
     const std::string& session_id,
@@ skipping 803 matching lines @@
 
   if (!video_decode_cb_.is_null())
     video_decode_cb_.ResetAndReturn().Run(media::Decryptor::kError, NULL);
 
   cdm_promise_adapter_.Clear();
 
   cdm_session_tracker_.CloseRemainingSessions(session_closed_cb_);
 }
 
 }  // namespace content