media: Rename MediaKeys to ContentDecryptionModule

media/blink/webcontentdecryptionmodulesession_impl.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 "webcontentdecryptionmodulesession_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/cdm_promise.h"
+#include "media/base/content_decryption_module.h"
 #include "media/base/key_system_names.h"
 #include "media/base/key_systems.h"
 #include "media/base/limits.h"
-#include "media/base/media_keys.h"
 #include "media/blink/cdm_result_promise.h"
 #include "media/blink/cdm_session_adapter.h"
 #include "media/blink/webmediaplayer_util.h"
 #include "media/cdm/json_web_key.h"
 #include "third_party/WebKit/public/platform/WebData.h"
 #include "third_party/WebKit/public/platform/WebEncryptedMediaKeyInformation.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 
 #if defined(USE_PROPRIETARY_CODECS)
 #include "media/cdm/cenc_utils.h"
 #endif
 
 namespace media {
 
 namespace {
 
 const char kCloseSessionUMAName[] = "CloseSession";
 const char kGenerateRequestUMAName[] = "GenerateRequest";
 const char kLoadSessionUMAName[] = "LoadSession";
 const char kRemoveSessionUMAName[] = "RemoveSession";
 const char kUpdateSessionUMAName[] = "UpdateSession";
 
 blink::WebContentDecryptionModuleSession::Client::MessageType
-convertMessageType(MediaKeys::MessageType message_type) {
+convertMessageType(ContentDecryptionModule::MessageType message_type) {
   switch (message_type) {
-    case media::MediaKeys::LICENSE_REQUEST:
+    case ContentDecryptionModule::LICENSE_REQUEST:
       return blink::WebContentDecryptionModuleSession::Client::MessageType::
           LicenseRequest;
-    case media::MediaKeys::LICENSE_RENEWAL:
+    case ContentDecryptionModule::LICENSE_RENEWAL:
       return blink::WebContentDecryptionModuleSession::Client::MessageType::
           LicenseRenewal;
-    case media::MediaKeys::LICENSE_RELEASE:
+    case ContentDecryptionModule::LICENSE_RELEASE:
       return blink::WebContentDecryptionModuleSession::Client::MessageType::
           LicenseRelease;
   }
 
   NOTREACHED();
   return blink::WebContentDecryptionModuleSession::Client::MessageType::
       LicenseRequest;
 }
 
 blink::WebEncryptedMediaKeyInformation::KeyStatus convertStatus(
@@ skipping 14 matching lines @@
     case media::CdmKeyInformation::KEY_STATUS_PENDING:
       return blink::WebEncryptedMediaKeyInformation::KeyStatus::StatusPending;
     case media::CdmKeyInformation::RELEASED:
       return blink::WebEncryptedMediaKeyInformation::KeyStatus::Released;
   }
 
   NOTREACHED();
   return blink::WebEncryptedMediaKeyInformation::KeyStatus::InternalError;
 }
 
-MediaKeys::SessionType convertSessionType(
+ContentDecryptionModule::SessionType convertSessionType(
     blink::WebEncryptedMediaSessionType session_type) {
   switch (session_type) {
     case blink::WebEncryptedMediaSessionType::Temporary:
-      return MediaKeys::TEMPORARY_SESSION;
+      return ContentDecryptionModule::TEMPORARY_SESSION;
     case blink::WebEncryptedMediaSessionType::PersistentLicense:
-      return MediaKeys::PERSISTENT_LICENSE_SESSION;
+      return ContentDecryptionModule::PERSISTENT_LICENSE_SESSION;
     case blink::WebEncryptedMediaSessionType::PersistentReleaseMessage:
-      return MediaKeys::PERSISTENT_RELEASE_MESSAGE_SESSION;
+      return ContentDecryptionModule::PERSISTENT_RELEASE_MESSAGE_SESSION;
     case blink::WebEncryptedMediaSessionType::Unknown:
       break;
   }
 
   NOTREACHED();
-  return MediaKeys::TEMPORARY_SESSION;
+  return ContentDecryptionModule::TEMPORARY_SESSION;
 }
 
 bool SanitizeInitData(EmeInitDataType init_data_type,
                       const unsigned char* init_data,
                       size_t init_data_length,
                       std::vector<uint8_t>* sanitized_init_data,
                       std::string* error_message) {
   DCHECK_GT(init_data_length, 0u);
   if (init_data_length > limits::kMaxInitDataLength) {
     error_message->assign("Initialization data too long.");
@@ skipping 82 matching lines @@
   // stripping irrelevant data or fields, pre-parsing it, sanitizing it,
   // and/or generating a fully sanitized version. The user agent should check
   // that the length and values of fields are reasonable. Unknown fields should
   // be rejected or removed.
   if (response_length > limits::kMaxSessionResponseLength)
     return false;
 
   if (IsClearKey(key_system) || IsExternalClearKey(key_system)) {
     std::string key_string(response, response + response_length);
     KeyIdAndKeyPairs keys;
-    MediaKeys::SessionType session_type = MediaKeys::TEMPORARY_SESSION;
+    ContentDecryptionModule::SessionType session_type =
+        ContentDecryptionModule::TEMPORARY_SESSION;
     if (!ExtractKeysFromJWKSet(key_string, &keys, &session_type))
       return false;
 
     // Must contain at least one key.
     if (keys.empty())
       return false;
 
     for (const auto key_pair : keys) {
       if (key_pair.first.size() < limits::kMinKeyIdLength ||
           key_pair.first.size() > limits::kMaxKeyIdLength) {
@@ skipping 168 matching lines @@
     result.completeWithError(
         blink::WebContentDecryptionModuleExceptionTypeError, 0,
         "Invalid session ID.");
     return;
   }
 
   // TODO(jrummell): Now that there are 2 types of persistent sessions, the
   // session type should be passed from blink. Type should also be passed in the
   // constructor (and removed from initializeNewSession()).
   adapter_->LoadSession(
-      MediaKeys::PERSISTENT_LICENSE_SESSION, sanitized_session_id,
+      ContentDecryptionModule::PERSISTENT_LICENSE_SESSION, sanitized_session_id,
       std::unique_ptr<NewSessionCdmPromise>(new NewSessionCdmResultPromise(
           result, adapter_->GetKeySystemUMAPrefix() + kLoadSessionUMAName,
           base::Bind(
               &WebContentDecryptionModuleSessionImpl::OnSessionInitialized,
               weak_ptr_factory_.GetWeakPtr()))));
 }
 
 void WebContentDecryptionModuleSessionImpl::update(
     const uint8_t* response,
     size_t response_length,
@@ skipping 49 matching lines @@
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(!session_id_.empty());
   DCHECK(thread_checker_.CalledOnValidThread());
   adapter_->RemoveSession(
       session_id_,
       std::unique_ptr<SimpleCdmPromise>(new CdmResultPromise<>(
           result, adapter_->GetKeySystemUMAPrefix() + kRemoveSessionUMAName)));
 }
 
 void WebContentDecryptionModuleSessionImpl::OnSessionMessage(
-    MediaKeys::MessageType message_type,
+    ContentDecryptionModule::MessageType message_type,
     const std::vector<uint8_t>& message) {
   DCHECK(client_) << "Client not set before message event";
   DCHECK(thread_checker_.CalledOnValidThread());
   client_->message(convertMessageType(message_type), message.data(),
                    message.size());
 }
 
 void WebContentDecryptionModuleSessionImpl::OnSessionKeysChange(
     bool has_additional_usable_key,
     CdmKeysInfo keys_info) {
@@ skipping 41 matching lines @@
 
   DCHECK(session_id_.empty()) << "Session ID may not be changed once set.";
   session_id_ = session_id;
   *status =
       adapter_->RegisterSession(session_id_, weak_ptr_factory_.GetWeakPtr())
           ? SessionInitStatus::NEW_SESSION
           : SessionInitStatus::SESSION_ALREADY_EXISTS;
 }
 
 }  // namespace media