media: Rename MediaKeys to ContentDecryptionModule

media/cdm/ppapi/external_clear_key/clear_key_cdm.cc

 // Copyright 2013 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 "media/cdm/ppapi/external_clear_key/clear_key_cdm.h"
 
 #include <algorithm>
 #include <cstring>
 #include <sstream>
 #include <utility>
@@ skipping 127 matching lines @@
       return cdm::kUnknownError;
     case media::CdmPromise::CLIENT_ERROR:
       return cdm::kClientError;
     case media::CdmPromise::OUTPUT_ERROR:
       return cdm::kOutputError;
   }
   NOTREACHED();
   return cdm::kUnknownError;
 }
 
-static media::MediaKeys::SessionType ConvertSessionType(
+static media::ContentDecryptionModule::SessionType ConvertSessionType(
     cdm::SessionType session_type) {
   switch (session_type) {
     case cdm::kTemporary:
-      return media::MediaKeys::TEMPORARY_SESSION;
+      return media::ContentDecryptionModule::TEMPORARY_SESSION;
     case cdm::kPersistentLicense:
-      return media::MediaKeys::PERSISTENT_LICENSE_SESSION;
+      return media::ContentDecryptionModule::PERSISTENT_LICENSE_SESSION;
     case cdm::kPersistentKeyRelease:
-      return media::MediaKeys::PERSISTENT_RELEASE_MESSAGE_SESSION;
+      return media::ContentDecryptionModule::PERSISTENT_RELEASE_MESSAGE_SESSION;
   }
   NOTREACHED();
-  return media::MediaKeys::TEMPORARY_SESSION;
+  return media::ContentDecryptionModule::TEMPORARY_SESSION;
 }
 
 static media::EmeInitDataType ConvertInitDataType(
     cdm::InitDataType init_data_type) {
   switch (init_data_type) {
     case cdm::kCenc:
       return media::EmeInitDataType::CENC;
     case cdm::kKeyIds:
       return media::EmeInitDataType::KEYIDS;
     case cdm::kWebM:
@@ skipping 174 matching lines @@
       new media::CdmCallbackPromise<std::string>(
           base::Bind(&ClearKeyCdm::OnSessionLoaded, base::Unretained(this),
                      promise_id),
           base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                      promise_id)));
   // AesDecryptor does not support loading, so create a temporary session to
   // represent it in other session-related methods.
   std::vector<uint8_t> key_id(
       kLoadableSessionKeyId,
       kLoadableSessionKeyId + arraysize(kLoadableSessionKeyId) - 1);
-  decryptor_->CreateSessionAndGenerateRequest(MediaKeys::TEMPORARY_SESSION,
-                                              EmeInitDataType::WEBM, key_id,
-                                              std::move(promise));
+  decryptor_->CreateSessionAndGenerateRequest(
+      ContentDecryptionModule::TEMPORARY_SESSION, EmeInitDataType::WEBM, key_id,
+      std::move(promise));
 }
 
 void ClearKeyCdm::UpdateSession(uint32_t promise_id,
                                 const char* session_id,
                                 uint32_t session_id_length,
                                 const uint8_t* response,
                                 uint32_t response_size) {
   DVLOG(1) << __func__;
   std::string web_session_str(session_id, session_id_length);
 
@@ skipping 383 matching lines @@
       new media::CdmCallbackPromise<>(
           base::Bind(&ClearKeyCdm::OnLoadSessionUpdated,
                      base::Unretained(this)),
           base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                      promise_id_for_emulated_loadsession_)));
   decryptor_->UpdateSession(
       session_id_for_emulated_loadsession_,
       std::vector<uint8_t>(jwk_set.begin(), jwk_set.end()), std::move(promise));
 }
 
-void ClearKeyCdm::OnSessionMessage(const std::string& session_id,
-                                   MediaKeys::MessageType message_type,
-                                   const std::vector<uint8_t>& message) {
+void ClearKeyCdm::OnSessionMessage(
+    const std::string& session_id,
+    ContentDecryptionModule::MessageType message_type,
+    const std::vector<uint8_t>& message) {
   DVLOG(1) << "OnSessionMessage: " << message.size();
 
   // Ignore the message when we are waiting to update the loadable session.
   if (session_id == session_id_for_emulated_loadsession_)
     return;
 
   // OnSessionMessage() only called during CreateSession(), so no promise
   // involved (OnSessionCreated() called to resolve the CreateSession()
   // promise).
   host_->OnSessionMessage(session_id.data(), session_id.length(),
@@ skipping 203 matching lines @@
   is_running_platform_verification_test_ = true;
 
   std::string service_id = "test_service_id";
   std::string challenge = "test_challenge";
 
   host_->SendPlatformChallenge(service_id.data(), service_id.size(),
                                challenge.data(), challenge.size());
 }
 
 }  // namespace media