Introduce CdmFactory interface.

content/renderer/media/crypto/proxy_decryptor.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 "content/renderer/media/crypto/proxy_decryptor.h"
 
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
-#include "content/renderer/media/crypto/content_decryption_module_factory.h"
 #include "media/base/cdm_callback_promise.h"
+#include "media/base/cdm_factory.h"
 #include "media/cdm/json_web_key.h"
 #include "media/cdm/key_system_names.h"
 
-#if defined(ENABLE_PEPPER_CDMS)
-#include "content/renderer/media/crypto/pepper_cdm_wrapper.h"
-#endif  // defined(ENABLE_PEPPER_CDMS)
-
 #if defined(ENABLE_BROWSER_CDMS)
 #include "content/renderer/media/crypto/renderer_cdm_manager.h"
 #endif  // defined(ENABLE_BROWSER_CDMS)
 
 namespace content {
 
 // Special system code to signal a closed persistent session in a SessionError()
 // call. This is needed because there is no SessionClosed() call in the prefixed
 // EME API.
 const int kSessionClosedSystemCode = 29127;
 
-ProxyDecryptor::ProxyDecryptor(
-#if defined(ENABLE_PEPPER_CDMS)
-    const CreatePepperCdmCB& create_pepper_cdm_cb,
-#elif defined(ENABLE_BROWSER_CDMS)
-    RendererCdmManager* manager,
-#endif  // defined(ENABLE_PEPPER_CDMS)
-    const KeyAddedCB& key_added_cb,
-    const KeyErrorCB& key_error_cb,
-    const KeyMessageCB& key_message_cb)
-    :
-#if defined(ENABLE_PEPPER_CDMS)
-      create_pepper_cdm_cb_(create_pepper_cdm_cb),
-#elif defined(ENABLE_BROWSER_CDMS)
-      manager_(manager),
-      cdm_id_(RendererCdmManager::kInvalidCdmId),
-#endif  // defined(ENABLE_PEPPER_CDMS)
-      key_added_cb_(key_added_cb),
+ProxyDecryptor::ProxyDecryptor(const KeyAddedCB& key_added_cb,
+                               const KeyErrorCB& key_error_cb,
+                               const KeyMessageCB& key_message_cb)
+    : key_added_cb_(key_added_cb),
       key_error_cb_(key_error_cb),
       key_message_cb_(key_message_cb),
       is_clear_key_(false),
+#if defined(ENABLE_BROWSER_CDMS)
+      cdm_id_(RendererCdmManager::kInvalidCdmId),
+#endif  // defined(ENABLE_PEPPER_CDMS)
       weak_ptr_factory_(this) {
-#if defined(ENABLE_PEPPER_CDMS)
-  DCHECK(!create_pepper_cdm_cb_.is_null());
-#endif  // defined(ENABLE_PEPPER_CDMS)
   DCHECK(!key_added_cb_.is_null());
   DCHECK(!key_error_cb_.is_null());
   DCHECK(!key_message_cb_.is_null());
 }
 
 ProxyDecryptor::~ProxyDecryptor() {
   // Destroy the decryptor explicitly before destroying the plugin.
   media_keys_.reset();
 }
 
 media::Decryptor* ProxyDecryptor::GetDecryptor() {
   return media_keys_ ? media_keys_->GetDecryptor() : NULL;
 }
 
 #if defined(ENABLE_BROWSER_CDMS)
 int ProxyDecryptor::GetCdmId() {
   return cdm_id_;
 }
 #endif
 
-bool ProxyDecryptor::InitializeCDM(const std::string& key_system,
+bool ProxyDecryptor::InitializeCDM(const media::CdmFactory& cdm_factory,
+                                   const std::string& key_system,
                                    const GURL& security_origin) {
   DVLOG(1) << "InitializeCDM: key_system = " << key_system;
 
   DCHECK(!media_keys_);
-  media_keys_ = CreateMediaKeys(key_system, security_origin);
+  media_keys_ = CreateMediaKeys(cdm_factory, key_system, security_origin);
   if (!media_keys_)
     return false;
 
   is_clear_key_ =
       media::IsClearKey(key_system) || media::IsExternalClearKey(key_system);
   return true;
 }
 
 // Returns true if |data| is prefixed with |header| and has data after the
 // |header|.
@@ skipping 123 matching lines @@
       base::Bind(&ProxyDecryptor::OnSessionClosed,
                  weak_ptr_factory_.GetWeakPtr(),
                  web_session_id),
       base::Bind(&ProxyDecryptor::OnSessionError,
                  weak_ptr_factory_.GetWeakPtr(),
                  web_session_id)));
   media_keys_->RemoveSession(web_session_id, promise.Pass());
 }
 
 scoped_ptr<media::MediaKeys> ProxyDecryptor::CreateMediaKeys(
+    const media::CdmFactory& cdm_factory,
     const std::string& key_system,
     const GURL& security_origin) {
-  return ContentDecryptionModuleFactory::Create(
+  base::WeakPtr<ProxyDecryptor> weak_this = weak_ptr_factory_.GetWeakPtr();
+  return cdm_factory.Create(
       key_system,
       security_origin,
-#if defined(ENABLE_PEPPER_CDMS)
-      create_pepper_cdm_cb_,
-#elif defined(ENABLE_BROWSER_CDMS)
-      manager_,
+#if defined(ENABLE_BROWSER_CDMS)
       &cdm_id_,
-#endif  // defined(ENABLE_PEPPER_CDMS)
-      base::Bind(&ProxyDecryptor::OnSessionMessage,
-                 weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&ProxyDecryptor::OnSessionReady,
-                 weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&ProxyDecryptor::OnSessionClosed,
-                 weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&ProxyDecryptor::OnSessionError,
-                 weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&ProxyDecryptor::OnSessionKeysChange,
-                 weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&ProxyDecryptor::OnSessionExpirationUpdate,
-                 weak_ptr_factory_.GetWeakPtr()));
+#endif
+      base::Bind(&ProxyDecryptor::OnSessionMessage, weak_this),
+      base::Bind(&ProxyDecryptor::OnSessionReady, weak_this),
+      base::Bind(&ProxyDecryptor::OnSessionClosed, weak_this),
+      base::Bind(&ProxyDecryptor::OnSessionError, weak_this),
+      base::Bind(&ProxyDecryptor::OnSessionKeysChange, weak_this),
+      base::Bind(&ProxyDecryptor::OnSessionExpirationUpdate, weak_this));
 }
 
 void ProxyDecryptor::OnSessionMessage(const std::string& web_session_id,
                                       const std::vector<uint8>& message,
                                       const GURL& destination_url) {
   // Assumes that OnSessionCreated() has been called before this.
 
   // For ClearKey, convert the message from JSON into just passing the key
   // as the message. If unable to extract the key, return the message unchanged.
   if (is_clear_key_) {
@@ skipping 77 matching lines @@
   bool is_persistent =
       session_type == PersistentSession || session_type == LoadSession;
   active_sessions_.insert(std::make_pair(web_session_id, is_persistent));
 
   // For LoadSession(), generate the SessionReady event.
   if (session_type == LoadSession)
     OnSessionReady(web_session_id);
 }
 
 }  // namespace content