Separate CDM initialization from GenerateKeyRequest & remove key_system parameters.

webkit/renderer/media/crypto/ppapi_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 "webkit/renderer/media/crypto/ppapi_decryptor.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/data_buffer.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "webkit/plugins/ppapi/content_decryptor_delegate.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
-#include "webkit/renderer/media/crypto/key_systems.h"
 
 namespace webkit_media {
 
+scoped_ptr<webkit_media::PpapiDecryptor> PpapiDecryptor::Create(
+    const std::string& key_system,
+    const scoped_refptr<webkit::ppapi::PluginInstance>& plugin_instance,
+    const media::KeyAddedCB& key_added_cb,
+    const media::KeyErrorCB& key_error_cb,
+    const media::KeyMessageCB& key_message_cb,
+    const media::NeedKeyCB& need_key_cb,
+    const base::Closure& destroy_plugin_cb) {
+  webkit::ppapi::ContentDecryptorDelegate* plugin_cdm_delegate =
+      plugin_instance->GetContentDecryptorDelegate();
+  if (!plugin_cdm_delegate) {
+    DVLOG(1) << "PpapiDecryptor: plugin cdm delegate creation failed.";
+    return scoped_ptr<webkit_media::PpapiDecryptor>();
+  }
+
+  plugin_cdm_delegate->Initialize(key_system);
+
+  return scoped_ptr<webkit_media::PpapiDecryptor>(
+      new PpapiDecryptor(plugin_instance,
+                         plugin_cdm_delegate,
+                         key_added_cb,
+                         key_error_cb,
+                         key_message_cb,
+                         need_key_cb,
+                         destroy_plugin_cb));
+}
+
 PpapiDecryptor::PpapiDecryptor(
     const scoped_refptr<webkit::ppapi::PluginInstance>& plugin_instance,
+    webkit::ppapi::ContentDecryptorDelegate* plugin_cdm_delegate,
     const media::KeyAddedCB& key_added_cb,
     const media::KeyErrorCB& key_error_cb,
     const media::KeyMessageCB& key_message_cb,
     const media::NeedKeyCB& need_key_cb,
     const base::Closure& destroy_plugin_cb)
     : plugin_instance_(plugin_instance),
+      plugin_cdm_delegate_(plugin_cdm_delegate),
       key_added_cb_(key_added_cb),
       key_error_cb_(key_error_cb),
       key_message_cb_(key_message_cb),
       need_key_cb_(need_key_cb),
       destroy_plugin_cb_(destroy_plugin_cb),
-      plugin_cdm_delegate_(NULL),
       render_loop_proxy_(base::MessageLoopProxy::current()),
       weak_ptr_factory_(this),
       weak_this_(weak_ptr_factory_.GetWeakPtr()) {
   DCHECK(plugin_instance_.get());
+
+  plugin_cdm_delegate_->SetKeyEventCallbacks(
+      base::Bind(&PpapiDecryptor::KeyAdded, weak_this_),
+      base::Bind(&PpapiDecryptor::KeyError, weak_this_),
+      base::Bind(&PpapiDecryptor::KeyMessage, weak_this_),
+      base::Bind(&PpapiDecryptor::NeedKey, weak_this_));
 }
 
 PpapiDecryptor::~PpapiDecryptor() {
   plugin_cdm_delegate_ = NULL;
   plugin_instance_ = NULL;
   destroy_plugin_cb_.Run();
 }
 
-bool PpapiDecryptor::GenerateKeyRequest(const std::string& key_system,
-                                        const std::string& type,
+bool PpapiDecryptor::GenerateKeyRequest(const std::string& type,
                                         const uint8* init_data,
                                         int init_data_length) {
   DVLOG(2) << "GenerateKeyRequest()";
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
-
-  if (!plugin_cdm_delegate_) {
-    plugin_cdm_delegate_ = plugin_instance_->GetContentDecryptorDelegate();
-    if (!plugin_cdm_delegate_) {
-      DVLOG(1) << "PpapiDecryptor: plugin cdm delegate creation failed.";
-      return false;
-    }
-    plugin_cdm_delegate_->SetKeyEventCallbacks(
-        base::Bind(&PpapiDecryptor::KeyAdded, weak_this_),
-        base::Bind(&PpapiDecryptor::KeyError, weak_this_),
-        base::Bind(&PpapiDecryptor::KeyMessage, weak_this_),
-        base::Bind(&PpapiDecryptor::NeedKey, weak_this_));
-  }
+  DCHECK(plugin_cdm_delegate_);
 
   if (!plugin_cdm_delegate_->GenerateKeyRequest(
-      key_system, type, init_data, init_data_length)) {
-    ReportFailureToCallPlugin(key_system, std::string());
+      type, init_data, init_data_length)) {
+    ReportFailureToCallPlugin(std::string());
     return false;
   }
 
   return true;
 }
 
-void PpapiDecryptor::AddKey(const std::string& key_system,
-                            const uint8* key,
+void PpapiDecryptor::AddKey(const uint8* key,
                             int key_length,
                             const uint8* init_data,
                             int init_data_length,
                             const std::string& session_id) {
   DVLOG(2) << "AddKey()";
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
 
   if (!plugin_cdm_delegate_->AddKey(
       session_id, key, key_length, init_data, init_data_length)) {
-    ReportFailureToCallPlugin(key_system, session_id);
+    ReportFailureToCallPlugin(session_id);
   }
 
   if (!new_audio_key_cb_.is_null())
     new_audio_key_cb_.Run();
 
   if (!new_video_key_cb_.is_null())
     new_video_key_cb_.Run();
 }
 
-void PpapiDecryptor::CancelKeyRequest(const std::string& key_system,
-                                      const std::string& session_id) {
+void PpapiDecryptor::CancelKeyRequest(const std::string& session_id) {
   DVLOG(2) << "CancelKeyRequest()";
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
 
   if (!plugin_cdm_delegate_->CancelKeyRequest(session_id))
-    ReportFailureToCallPlugin(key_system, session_id);
+    ReportFailureToCallPlugin(session_id);
 }
 
 media::MediaKeys* PpapiDecryptor::GetMediaKeys() {
   return this;
 }
 
 void PpapiDecryptor::RegisterNewKeyCB(StreamType stream_type,
                                       const NewKeyCB& new_key_cb) {
   switch (stream_type) {
     case kAudio:
@@ skipping 115 matching lines @@
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
     render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &PpapiDecryptor::DeinitializeDecoder, weak_this_, stream_type));
     return;
   }
 
   DVLOG(2) << "DeinitializeDecoder() - stream_type: " << stream_type;
   plugin_cdm_delegate_->DeinitializeDecoder(stream_type);
 }
 
-void PpapiDecryptor::ReportFailureToCallPlugin(const std::string& key_system,
-                                               const std::string& session_id) {
+void PpapiDecryptor::ReportFailureToCallPlugin(const std::string& session_id) {
   DVLOG(1) << "Failed to call plugin.";
-  key_error_cb_.Run(key_system, session_id, kUnknownError, 0);
+  key_error_cb_.Run(session_id, kUnknownError, 0);
 }
 
 void PpapiDecryptor::OnDecoderInitialized(StreamType stream_type,
                                           bool success) {
   switch (stream_type) {
     case kAudio:
       DCHECK(!audio_decoder_init_cb_.is_null());
       base::ResetAndReturn(&audio_decoder_init_cb_).Run(success);
       break;
     case kVideo:
       DCHECK(!video_decoder_init_cb_.is_null());
       base::ResetAndReturn(&video_decoder_init_cb_).Run(success);
       break;
     default:
       NOTREACHED();
   }
 }
 
-void PpapiDecryptor::KeyAdded(const std::string& key_system,
-                              const std::string& session_id) {
+void PpapiDecryptor::KeyAdded(const std::string& session_id) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
-  key_added_cb_.Run(key_system, session_id);
+  key_added_cb_.Run(session_id);
 }
 
-void PpapiDecryptor::KeyError(const std::string& key_system,
-                              const std::string& session_id,
+void PpapiDecryptor::KeyError(const std::string& session_id,
                               media::MediaKeys::KeyError error_code,
                               int system_code) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
-  key_error_cb_.Run(key_system, session_id, error_code, system_code);
+  key_error_cb_.Run(session_id, error_code, system_code);
 }
 
-void PpapiDecryptor::KeyMessage(const std::string& key_system,
-                                const std::string& session_id,
+void PpapiDecryptor::KeyMessage(const std::string& session_id,
                                 const std::string& message,
                                 const std::string& default_url) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
-  key_message_cb_.Run(key_system, session_id, message, default_url);
+  key_message_cb_.Run(session_id, message, default_url);
 }
 
-void PpapiDecryptor::NeedKey(const std::string& key_system,
-                             const std::string& session_id,
+void PpapiDecryptor::NeedKey(const std::string& session_id,
                              const std::string& type,
                              scoped_ptr<uint8[]> init_data,
                              int init_data_size) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
-  need_key_cb_.Run(key_system, session_id, type,
-                   init_data.Pass(), init_data_size);
+  need_key_cb_.Run(session_id, type, init_data.Pass(), init_data_size);
 }
 
 }  // namespace webkit_media