media: Make MediaKeys ref-counted.

content/browser/media/cdm/browser_cdm_manager.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 "content/browser/media/cdm/browser_cdm_manager.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/task_runner.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/permission_manager.h"
 #include "content/public/browser/permission_type.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "content/public/browser/web_contents.h"
-#include "media/base/browser_cdm.h"
 #include "media/base/browser_cdm_factory.h"
 #include "media/base/cdm_promise.h"
 #include "media/base/limits.h"
 
 #if defined(OS_ANDROID)
 #include "content/public/common/renderer_preferences.h"
 #endif
 
 namespace content {
 
-using media::BrowserCdm;
 using media::MediaKeys;
-using media::ScopedBrowserCdmPtr;
 
 namespace {
 
 #if defined(OS_ANDROID)
 // Android only supports 128-bit key IDs.
 const size_t kAndroidKeyIdBytes = 128 / 8;
 #endif
 
 // The ID used in this class is a concatenation of |render_frame_id| and
 // |cdm_id|, i.e. (render_frame_id << 32) + cdm_id.
@@ skipping 169 matching lines @@
     IPC_MESSAGE_HANDLER(CdmHostMsg_LoadSession, OnLoadSession)
     IPC_MESSAGE_HANDLER(CdmHostMsg_UpdateSession, OnUpdateSession)
     IPC_MESSAGE_HANDLER(CdmHostMsg_CloseSession, OnCloseSession)
     IPC_MESSAGE_HANDLER(CdmHostMsg_RemoveSession, OnRemoveSession)
     IPC_MESSAGE_HANDLER(CdmHostMsg_DestroyCdm, OnDestroyCdm)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-media::BrowserCdm* BrowserCdmManager::GetCdm(int render_frame_id,
-                                             int cdm_id) const {
+scoped_refptr<MediaKeys> BrowserCdmManager::GetCdm(int render_frame_id,
+                                                   int cdm_id) const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
-  return cdm_map_.get(GetId(render_frame_id, cdm_id));
+  const auto& iter = cdm_map_.find(GetId(render_frame_id, cdm_id));
+  return iter == cdm_map_.end() ? nullptr : iter->second;
 }
 
 void BrowserCdmManager::RenderFrameDeleted(int render_frame_id) {
   if (!task_runner_->RunsTasksOnCurrentThread()) {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&BrowserCdmManager::RemoveAllCdmForFrame,
                    this, render_frame_id));
     return;
   }
@@ skipping 18 matching lines @@
     return;
   }
 
   Send(new CdmMsg_ResolvePromiseWithSession(render_frame_id, cdm_id, promise_id,
                                             session_id));
 }
 
 void BrowserCdmManager::RejectPromise(int render_frame_id,
                                       int cdm_id,
                                       uint32_t promise_id,
-                                      media::MediaKeys::Exception exception,
+                                      MediaKeys::Exception exception,
                                       uint32_t system_code,
                                       const std::string& error_message) {
   Send(new CdmMsg_RejectPromise(render_frame_id, cdm_id, promise_id, exception,
                                 system_code, error_message));
 }
 
-void BrowserCdmManager::OnSessionMessage(
-    int render_frame_id,
-    int cdm_id,
-    const std::string& session_id,
-    media::MediaKeys::MessageType message_type,
-    const std::vector<uint8>& message,
-    const GURL& legacy_destination_url) {
+void BrowserCdmManager::OnSessionMessage(int render_frame_id,
+                                         int cdm_id,
+                                         const std::string& session_id,
+                                         MediaKeys::MessageType message_type,
+                                         const std::vector<uint8>& message,
+                                         const GURL& legacy_destination_url) {
   GURL verified_gurl = legacy_destination_url;
   if (!verified_gurl.is_valid() && !verified_gurl.is_empty()) {
     DLOG(WARNING) << "SessionMessage legacy_destination_url is invalid : "
                   << legacy_destination_url.possibly_invalid_spec();
     verified_gurl =
         GURL::EmptyGURL();  // Replace invalid legacy_destination_url.
   }
 
   Send(new CdmMsg_SessionMessage(render_frame_id, cdm_id, session_id,
                                  message_type, message, verified_gurl));
@@ skipping 58 matching lines @@
 void BrowserCdmManager::OnSetServerCertificate(
     int render_frame_id,
     int cdm_id,
     uint32_t promise_id,
     const std::vector<uint8_t>& certificate) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   scoped_ptr<SimplePromise> promise(new SimplePromise(
       weak_ptr_factory_.GetWeakPtr(), render_frame_id, cdm_id, promise_id));
 
-  BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
+  scoped_refptr<MediaKeys> cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
   if (certificate.empty()) {
     promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0, "Empty certificate.");
     return;
   }
 
@@ skipping 37 matching lines @@
       eme_init_data_type = media::EmeInitDataType::CENC;
       break;
 #endif
     default:
       NOTREACHED();
       promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0,
                       "Invalid init data type.");
       return;
   }
 
-  BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
+  scoped_refptr<MediaKeys> cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     DLOG(WARNING) << "No CDM found for: " << render_frame_id << ", " << cdm_id;
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
   CheckPermissionStatus(
       render_frame_id, cdm_id,
       base::Bind(&BrowserCdmManager::CreateSessionAndGenerateRequestIfPermitted,
                  this, render_frame_id, cdm_id, params.session_type,
                  eme_init_data_type, init_data, base::Passed(&promise)));
 }
 
 void BrowserCdmManager::OnLoadSession(
     int render_frame_id,
     int cdm_id,
     uint32_t promise_id,
     media::MediaKeys::SessionType session_type,
     const std::string& session_id) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   scoped_ptr<NewSessionPromise> promise(new NewSessionPromise(
       weak_ptr_factory_.GetWeakPtr(), render_frame_id, cdm_id, promise_id));
 
-  BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
+  scoped_refptr<MediaKeys> cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     DLOG(WARNING) << "No CDM found for: " << render_frame_id << ", " << cdm_id;
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
   CheckPermissionStatus(
       render_frame_id, cdm_id,
       base::Bind(&BrowserCdmManager::LoadSessionIfPermitted,
                  this, render_frame_id, cdm_id, session_type,
                  session_id, base::Passed(&promise)));
 }
 
 void BrowserCdmManager::OnUpdateSession(int render_frame_id,
                                         int cdm_id,
                                         uint32_t promise_id,
                                         const std::string& session_id,
                                         const std::vector<uint8>& response) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   scoped_ptr<SimplePromise> promise(new SimplePromise(
       weak_ptr_factory_.GetWeakPtr(), render_frame_id, cdm_id, promise_id));
 
-  BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
+  scoped_refptr<MediaKeys> cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
   if (response.size() > media::limits::kMaxSessionResponseLength) {
     LOG(WARNING) << "Response for ID " << cdm_id
                  << " is too long: " << response.size();
     promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0, "Response too long.");
     return;
   }
 
   if (response.empty()) {
     promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0, "Response is empty.");
     return;
   }
 
   cdm->UpdateSession(session_id, response, promise.Pass());
 }
 
 void BrowserCdmManager::OnCloseSession(int render_frame_id,
                                        int cdm_id,
                                        uint32_t promise_id,
                                        const std::string& session_id) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   scoped_ptr<SimplePromise> promise(new SimplePromise(
       weak_ptr_factory_.GetWeakPtr(), render_frame_id, cdm_id, promise_id));
 
-  BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
+  scoped_refptr<MediaKeys> cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
   cdm->CloseSession(session_id, promise.Pass());
 }
 
 void BrowserCdmManager::OnRemoveSession(int render_frame_id,
                                         int cdm_id,
                                         uint32_t promise_id,
                                         const std::string& session_id) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   scoped_ptr<SimplePromise> promise(new SimplePromise(
       weak_ptr_factory_.GetWeakPtr(), render_frame_id, cdm_id, promise_id));
 
-  BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
+  scoped_refptr<MediaKeys> cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
   cdm->RemoveSession(session_id, promise.Pass());
 }
 
 void BrowserCdmManager::OnDestroyCdm(int render_frame_id, int cdm_id) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
@@ skipping 10 matching lines @@
                                uint32_t promise_id,
                                const std::string& key_system,
                                const GURL& security_origin,
                                bool use_hw_secure_codecs) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!GetCdm(render_frame_id, cdm_id));
 
   scoped_ptr<SimplePromise> promise(new SimplePromise(
       weak_ptr_factory_.GetWeakPtr(), render_frame_id, cdm_id, promise_id));
 
-  ScopedBrowserCdmPtr cdm(media::CreateBrowserCdm(
+  scoped_refptr<MediaKeys> cdm(media::CreateBrowserCdm(
       key_system, use_hw_secure_codecs,
       BROWSER_CDM_MANAGER_CB(OnSessionMessage),
       BROWSER_CDM_MANAGER_CB(OnSessionClosed),
       BROWSER_CDM_MANAGER_CB(OnLegacySessionError),
       BROWSER_CDM_MANAGER_CB(OnSessionKeysChange),
       BROWSER_CDM_MANAGER_CB(OnSessionExpirationUpdate)));
 
   if (!cdm) {
     DVLOG(1) << "failed to create CDM.";
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "Failed to create CDM.");
     return;
   }
 
   uint64 id = GetId(render_frame_id, cdm_id);
-  cdm_map_.add(id, cdm.Pass());
+  cdm_map_[id] = cdm;
   cdm_security_origin_map_[id] = security_origin;
   promise->resolve();
 }
 
 void BrowserCdmManager::RemoveAllCdmForFrame(int render_frame_id) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   std::vector<uint64> ids_to_remove;
-  for (CdmMap::iterator it = cdm_map_.begin(); it != cdm_map_.end(); ++it) {
-    if (IdBelongsToFrame(it->first, render_frame_id))
-      ids_to_remove.push_back(it->first);
+  for (const auto& entry : cdm_map_) {
+    if (IdBelongsToFrame(entry.first, render_frame_id))
+      ids_to_remove.push_back(entry.first);
   }
 
-  for (size_t i = 0; i < ids_to_remove.size(); ++i)
-    RemoveCdm(ids_to_remove[i]);
+  for (const auto& id_to_remove : ids_to_remove)
+    RemoveCdm(id_to_remove);
 }
 
 void BrowserCdmManager::RemoveCdm(uint64 id) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   cdm_map_.erase(id);
   cdm_security_origin_map_.erase(id);
 }
 
 void BrowserCdmManager::CheckPermissionStatus(
@@ skipping 60 matching lines @@
     const std::vector<uint8>& init_data,
     scoped_ptr<media::NewSessionCdmPromise> promise,
     bool permission_was_allowed) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   if (!permission_was_allowed) {
     promise->reject(MediaKeys::NOT_SUPPORTED_ERROR, 0, "Permission denied.");
     return;
   }
 
-  BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
+  scoped_refptr<MediaKeys> cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
   cdm->CreateSessionAndGenerateRequest(session_type, init_data_type,
                                        init_data, promise.Pass());
 }
 
 void BrowserCdmManager::LoadSessionIfPermitted(
     int render_frame_id,
     int cdm_id,
     media::MediaKeys::SessionType session_type,
     const std::string& session_id,
     scoped_ptr<media::NewSessionCdmPromise> promise,
     bool permission_was_allowed) {
   DCHECK_NE(media::MediaKeys::SessionType::TEMPORARY_SESSION, session_type);
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   if (!permission_was_allowed) {
     promise->reject(MediaKeys::NOT_SUPPORTED_ERROR, 0, "Permission denied.");
     return;
   }
 
-  BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
+  scoped_refptr<MediaKeys> cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
   cdm->LoadSession(session_type, session_id, promise.Pass());
 }
 
 }  // namespace content