media: Rename MediaKeys to ContentDecryptionModule

media/mojo/services/mojo_cdm_service.cc

 // Copyright 2014 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/mojo/services/mojo_cdm_service.h"
 
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 16 matching lines @@
 namespace {
 
 // Manages all CDMs created by MojoCdmService. Can only have one instance per
 // process so use a LazyInstance to ensure this.
 class CdmManager {
  public:
   CdmManager() {}
   ~CdmManager() {}
 
   // Returns the CDM associated with |cdm_id|. Can be called on any thread.
-  scoped_refptr<MediaKeys> GetCdm(int cdm_id) {
+  scoped_refptr<ContentDecryptionModule> GetCdm(int cdm_id) {
     base::AutoLock lock(lock_);
     auto iter = cdm_map_.find(cdm_id);
     return iter == cdm_map_.end() ? nullptr : iter->second;
   }
 
   // Registers the |cdm| for |cdm_id|.
-  void RegisterCdm(int cdm_id, const scoped_refptr<MediaKeys>& cdm) {
+  void RegisterCdm(int cdm_id,
+                   const scoped_refptr<ContentDecryptionModule>& cdm) {
     base::AutoLock lock(lock_);
     DCHECK(!cdm_map_.count(cdm_id));
     cdm_map_[cdm_id] = cdm;
   }
 
   // Unregisters the CDM associated with |cdm_id|.
   void UnregisterCdm(int cdm_id) {
     base::AutoLock lock(lock_);
     DCHECK(cdm_map_.count(cdm_id));
     cdm_map_.erase(cdm_id);
   }
 
  private:
   // Lock to protect |cdm_map_|.
   base::Lock lock_;
-  std::map<int, scoped_refptr<MediaKeys>> cdm_map_;
+  std::map<int, scoped_refptr<ContentDecryptionModule>> cdm_map_;
 
   DISALLOW_COPY_AND_ASSIGN(CdmManager);
 };
 
 base::LazyInstance<CdmManager>::Leaky g_cdm_manager = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 using SimpleMojoCdmPromise = MojoCdmPromise<>;
 using NewSessionMojoCdmPromise = MojoCdmPromise<std::string>;
 
 int MojoCdmService::next_cdm_id_ = CdmContext::kInvalidCdmId + 1;
 
 // static
-scoped_refptr<MediaKeys> MojoCdmService::LegacyGetCdm(int cdm_id) {
+scoped_refptr<ContentDecryptionModule> MojoCdmService::LegacyGetCdm(
+    int cdm_id) {
   DVLOG(1) << __func__ << ": " << cdm_id;
   return g_cdm_manager.Get().GetCdm(cdm_id);
 }
 
 MojoCdmService::MojoCdmService(base::WeakPtr<MojoCdmServiceContext> context,
                                CdmFactory* cdm_factory)
     : context_(context),
       cdm_factory_(cdm_factory),
       cdm_id_(CdmContext::kInvalidCdmId),
       weak_factory_(this) {
@@ skipping 75 matching lines @@
                      base::MakeUnique<SimpleMojoCdmPromise>(callback));
 }
 
 void MojoCdmService::RemoveSession(const std::string& session_id,
                                    const RemoveSessionCallback& callback) {
   DVLOG(2) << __func__;
   cdm_->RemoveSession(session_id,
                       base::MakeUnique<SimpleMojoCdmPromise>(callback));
 }
 
-scoped_refptr<MediaKeys> MojoCdmService::GetCdm() {
+scoped_refptr<ContentDecryptionModule> MojoCdmService::GetCdm() {
   return cdm_;
 }
 
-void MojoCdmService::OnCdmCreated(const InitializeCallback& callback,
-                                  const scoped_refptr<MediaKeys>& cdm,
-                                  const std::string& error_message) {
+void MojoCdmService::OnCdmCreated(
+    const InitializeCallback& callback,
+    const scoped_refptr<::media::ContentDecryptionModule>& cdm,
+    const std::string& error_message) {
   mojom::CdmPromiseResultPtr cdm_promise_result(mojom::CdmPromiseResult::New());
 
   // TODO(xhwang): This should not happen when KeySystemInfo is properly
   // populated. See http://crbug.com/469366
   if (!cdm || !context_) {
     cdm_promise_result->success = false;
     cdm_promise_result->exception = CdmPromise::Exception::NOT_SUPPORTED_ERROR;
     cdm_promise_result->system_code = 0;
     cdm_promise_result->error_message = error_message;
     callback.Run(std::move(cdm_promise_result), 0, nullptr);
@@ skipping 17 matching lines @@
         cdm_, GetProxy(&decryptor_service),
         base::Bind(&MojoCdmService::OnDecryptorConnectionError, weak_this_)));
   }
 
   DVLOG(1) << __func__ << ": CDM successfully created with ID " << cdm_id_;
   cdm_promise_result->success = true;
   callback.Run(std::move(cdm_promise_result), cdm_id_,
                std::move(decryptor_service));
 }
 
-void MojoCdmService::OnSessionMessage(const std::string& session_id,
-                                      MediaKeys::MessageType message_type,
-                                      const std::vector<uint8_t>& message) {
+void MojoCdmService::OnSessionMessage(
+    const std::string& session_id,
+    ::media::ContentDecryptionModule::MessageType message_type,
+    const std::vector<uint8_t>& message) {
   DVLOG(2) << __func__ << "(" << message_type << ")";
   client_->OnSessionMessage(session_id, message_type, message);
 }
 
 void MojoCdmService::OnSessionKeysChange(const std::string& session_id,
                                          bool has_additional_usable_key,
                                          CdmKeysInfo keys_info) {
   DVLOG(2) << __func__
            << " has_additional_usable_key=" << has_additional_usable_key;
 
@@ skipping 18 matching lines @@
 
 void MojoCdmService::OnDecryptorConnectionError() {
   DVLOG(2) << __func__;
 
   // MojoDecryptorService has lost connectivity to it's client, so it can be
   // freed.
   decryptor_.reset();
 }
 
 }  // namespace media