Connect new EME APIs to internal implementation.

The MediaKeys/Decryptor creation code is moved from ProxyDecryptor to
ContentDecryptorModuleFactory so it can be shared with both versions of the API.

There must be a translation between session objects in the EME APIs and
the session_id used internally. This requires more work; for now, only
one session is supported.

BUG=250048

Review URL: https://chromiumcodereview.appspot.com/17320011

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@208365 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 109 insertions, 38 deletions

diff --git a/webkit/renderer/media/crypto/proxy_decryptor.cc b/webkit/renderer/media/crypto/proxy_decryptor.cc
index 007c6d9..9bcc78b 100644
--- a/webkit/renderer/media/crypto/proxy_decryptor.cc
+++ b/webkit/renderer/media/crypto/proxy_decryptor.cc
@@ -44,8 +44,13 @@ static scoped_refptr<webkit::ppapi::PluginInstance> CreateHelperPlugin(
   return ppapi_plugin->instance();
 }
 
+void DestroyHelperPluginForClient(
+    WebKit::WebMediaPlayerClient* web_media_player_client) {
+  web_media_player_client->closeHelperPlugin();
+}
+
 void ProxyDecryptor::DestroyHelperPlugin() {
-  web_media_player_client_->closeHelperPlugin();
+  DestroyHelperPluginForClient(web_media_player_client_);
 }
 
 #endif  // defined(ENABLE_PEPPER_CDMS)
@@ -54,9 +59,9 @@ ProxyDecryptor::ProxyDecryptor(
 #if defined(ENABLE_PEPPER_CDMS)
     WebKit::WebMediaPlayerClient* web_media_player_client,
     WebKit::WebFrame* web_frame,
-#elif defined(OS_ANDROID) && !defined(GOOGLE_TV)
+#elif defined(OS_ANDROID)
     scoped_ptr<media::MediaKeys> media_keys,
-#endif
+#endif  // defined(ENABLE_PEPPER_CDMS)
     const media::KeyAddedCB& key_added_cb,
     const media::KeyErrorCB& key_error_cb,
     const media::KeyMessageCB& key_message_cb)
@@ -64,9 +69,9 @@ ProxyDecryptor::ProxyDecryptor(
 #if defined(ENABLE_PEPPER_CDMS)
       web_media_player_client_(web_media_player_client),
       web_frame_(web_frame),
-#elif defined(OS_ANDROID) && !defined(GOOGLE_TV)
-      media_keys_(media_keys.Pass()),
-#endif
+#elif defined(OS_ANDROID)
+    media_keys_(media_keys.Pass()),
+#endif  // defined(ENABLE_PEPPER_CDMS)
       key_added_cb_(key_added_cb),
       key_error_cb_(key_error_cb),
       key_message_cb_(key_message_cb) {
@@ -149,31 +154,35 @@ void ProxyDecryptor::CancelKeyRequest(const std::string& session_id) {
 }
 
 #if defined(ENABLE_PEPPER_CDMS)
-scoped_ptr<media::MediaKeys> ProxyDecryptor::CreatePpapiDecryptor(
-    const std::string& key_system) {
-  DCHECK(web_media_player_client_);
-  DCHECK(web_frame_);
+scoped_ptr<media::MediaKeys>
+ContentDecryptionModuleFactory::CreatePpapiDecryptor(
+    const std::string& key_system,
+    const media::KeyAddedCB& key_added_cb,
+    const media::KeyErrorCB& key_error_cb,
+    const media::KeyMessageCB& key_message_cb,
+    const base::Closure& destroy_plugin_cb,
+    WebKit::WebMediaPlayerClient* web_media_player_client,
+    WebKit::WebFrame* web_frame) {
+  DCHECK(web_media_player_client);
+  DCHECK(web_frame);
 
   std::string plugin_type = GetPepperType(key_system);
   DCHECK(!plugin_type.empty());
   const scoped_refptr<webkit::ppapi::PluginInstance>& plugin_instance =
-      CreateHelperPlugin(plugin_type, web_media_player_client_, web_frame_);
+      CreateHelperPlugin(plugin_type, web_media_player_client, web_frame);
   if (!plugin_instance.get()) {
-    DVLOG(1) << "ProxyDecryptor: plugin instance creation failed.";
+    DLOG(ERROR) << "ProxyDecryptor: plugin instance creation failed.";
     return scoped_ptr<media::MediaKeys>();
   }
 
   scoped_ptr<webkit_media::PpapiDecryptor> decryptor = PpapiDecryptor::Create(
       key_system,
       plugin_instance,
-      base::Bind(&ProxyDecryptor::KeyAdded, weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&ProxyDecryptor::KeyError, weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&ProxyDecryptor::KeyMessage, weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&ProxyDecryptor::DestroyHelperPlugin,
-                 weak_ptr_factory_.GetWeakPtr()));
+      key_added_cb, key_error_cb, key_message_cb,
+      destroy_plugin_cb);
 
   if (!decryptor)
-    DestroyHelperPlugin();
+    DestroyHelperPluginForClient(web_media_player_client);
   // Else the new object will call destroy_plugin_cb to destroy Helper Plugin.
 
   return scoped_ptr<media::MediaKeys>(decryptor.Pass());
@@ -182,21 +191,52 @@ scoped_ptr<media::MediaKeys> ProxyDecryptor::CreatePpapiDecryptor(
 
 scoped_ptr<media::MediaKeys> ProxyDecryptor::CreateMediaKeys(
     const std::string& key_system) {
+  return ContentDecryptionModuleFactory::Create(
+      key_system,
+#if defined(ENABLE_PEPPER_CDMS)
+      web_media_player_client_,
+      web_frame_,
+      base::Bind(&ProxyDecryptor::DestroyHelperPlugin,
+                 weak_ptr_factory_.GetWeakPtr()),
+#elif defined(OS_ANDROID)
+      media_keys_.Pass(),
+#endif  // defined(ENABLE_PEPPER_CDMS)
+      base::Bind(&ProxyDecryptor::KeyAdded, weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&ProxyDecryptor::KeyError, weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&ProxyDecryptor::KeyMessage, weak_ptr_factory_.GetWeakPtr()));
+}
+
+scoped_ptr<media::MediaKeys> ContentDecryptionModuleFactory::Create(
+    const std::string& key_system,
+#if defined(ENABLE_PEPPER_CDMS)
+    WebKit::WebMediaPlayerClient* web_media_player_client,
+    WebKit::WebFrame* web_frame,
+    const base::Closure& destroy_plugin_cb,
+#elif defined(OS_ANDROID)
+    scoped_ptr<media::MediaKeys> media_keys,
+#endif  // defined(ENABLE_PEPPER_CDMS)
+    const media::KeyAddedCB& key_added_cb,
+    const media::KeyErrorCB& key_error_cb,
+    const media::KeyMessageCB& key_message_cb) {
   if (CanUseAesDecryptor(key_system)) {
-    return scoped_ptr<media::MediaKeys>(new media::AesDecryptor(
-        base::Bind(&ProxyDecryptor::KeyAdded, weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&ProxyDecryptor::KeyError, weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&ProxyDecryptor::KeyMessage, weak_ptr_factory_.GetWeakPtr())
-        ));
+    return scoped_ptr<media::MediaKeys>(
+        new media::AesDecryptor(key_added_cb, key_error_cb, key_message_cb));
   }
 
 #if defined(ENABLE_PEPPER_CDMS)
-  return CreatePpapiDecryptor(key_system);
-#elif defined(OS_ANDROID) && !defined(GOOGLE_TV)
-  return media_keys_.Pass();
+  // TODO(ddorwin): Remove when the WD API implementation supports loading
+  // Pepper-based CDMs: http://crbug.com/250049
+  if (!web_media_player_client)
+    return scoped_ptr<media::MediaKeys>();
+
+  return CreatePpapiDecryptor(
+      key_system, key_added_cb, key_error_cb, key_message_cb,
+      destroy_plugin_cb, web_media_player_client, web_frame);
+#elif defined(OS_ANDROID)
+  return media_keys.Pass();
 #else
   return scoped_ptr<media::MediaKeys>();
-#endif
+#endif  // defined(ENABLE_PEPPER_CDMS)
 }
 
 void ProxyDecryptor::KeyAdded(const std::string& session_id) {
diff --git a/webkit/renderer/media/crypto/proxy_decryptor.h b/webkit/renderer/media/crypto/proxy_decryptor.h
index 878c6e4..b9980d9 100644
--- a/webkit/renderer/media/crypto/proxy_decryptor.h
+++ b/webkit/renderer/media/crypto/proxy_decryptor.h
@@ -20,6 +20,41 @@ class WebMediaPlayerClient;
 
 namespace webkit_media {
 
+// TODO(ddorwin): Move to its own file.
+class ContentDecryptionModuleFactory {
+ public:
+  static scoped_ptr<media::MediaKeys> Create(
+      const std::string& key_system,
+#if defined(ENABLE_PEPPER_CDMS)
+      // TODO(ddorwin): We need different pointers for the WD API.
+      WebKit::WebMediaPlayerClient* web_media_player_client,
+      WebKit::WebFrame* web_frame,
+      const base::Closure& destroy_plugin_cb,
+#elif defined(OS_ANDROID)
+      // TODO(scherkus): Revert the ProxyDecryptor changes from r208040 so that
+      // this class always creates the MediaKeys.
+      // A ProxyMediaKeys to be used if |key_system| is not Clear Key.
+      scoped_ptr<media::MediaKeys> media_keys,
+#endif  // defined(ENABLE_PEPPER_CDMS)
+      const media::KeyAddedCB& key_added_cb,
+      const media::KeyErrorCB& key_error_cb,
+      const media::KeyMessageCB& key_message_cb);
+
+ private:
+#if defined(ENABLE_PEPPER_CDMS)
+  static scoped_ptr<media::MediaKeys> CreatePpapiDecryptor(
+      const std::string& key_system,
+      const media::KeyAddedCB& key_added_cb,
+      const media::KeyErrorCB& key_error_cb,
+      const media::KeyMessageCB& key_message_cb,
+      const base::Closure& destroy_plugin_cb,
+      // TODO(ddorwin): We need different pointers for the WD API.
+      WebKit::WebMediaPlayerClient* web_media_player_client,
+      WebKit::WebFrame* web_frame);
+#endif  // defined(ENABLE_PEPPER_CDMS)
+};
+
+// ProxyDecryptor is for EME v0.1b only. It should not be used for the WD API.
 // A decryptor proxy that creates a real decryptor object on demand and
 // forwards decryptor calls to it.
 // TODO(xhwang): Currently we don't support run-time switching among decryptor
@@ -31,9 +66,9 @@ class ProxyDecryptor : public media::MediaKeys {
 #if defined(ENABLE_PEPPER_CDMS)
       WebKit::WebMediaPlayerClient* web_media_player_client,
       WebKit::WebFrame* web_frame,
-#elif defined(OS_ANDROID) && !defined(GOOGLE_TV)
-      scoped_ptr<media::MediaKeys> media_keys,
-#endif
+#elif defined(OS_ANDROID)
+    scoped_ptr<media::MediaKeys> media_keys,
+#endif  // defined(ENABLE_PEPPER_CDMS)
       const media::KeyAddedCB& key_added_cb,
       const media::KeyErrorCB& key_error_cb,
       const media::KeyMessageCB& key_message_cb);
@@ -59,16 +94,9 @@ class ProxyDecryptor : public media::MediaKeys {
   virtual void CancelKeyRequest(const std::string& session_id) OVERRIDE;
 
  private:
-  // Helper functions to create MediaKeys to handle the given |key_system|.
+  // Helper function to create MediaKeys to handle the given |key_system|.
   scoped_ptr<media::MediaKeys> CreateMediaKeys(const std::string& key_system);
 
-#if defined(ENABLE_PEPPER_CDMS)
-  scoped_ptr<media::MediaKeys> CreatePpapiDecryptor(
-      const std::string& key_system);
-  // Callback for cleaning up a Pepper CDM.
-  void DestroyHelperPlugin();
-#endif  // defined(ENABLE_PEPPER_CDMS)
-
   // Callbacks for firing key events.
   void KeyAdded(const std::string& session_id);
   void KeyError(const std::string& session_id,
@@ -81,6 +109,9 @@ class ProxyDecryptor : public media::MediaKeys {
   base::WeakPtrFactory<ProxyDecryptor> weak_ptr_factory_;
 
 #if defined(ENABLE_PEPPER_CDMS)
+  // Callback for cleaning up a Pepper-based CDM.
+  void DestroyHelperPlugin();
+
   // Needed to create the PpapiDecryptor.
   WebKit::WebMediaPlayerClient* web_media_player_client_;
   WebKit::WebFrame* web_frame_;