Separate CDM initialization from GenerateKeyRequest & remove key_system parameters.

webkit/plugins/ppapi/content_decryptor_delegate.cc

 // Copyright (c) 2012 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/plugins/ppapi/content_decryptor_delegate.h"
 
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "media/base/audio_decoder_config.h"
@@ skipping 267 matching lines @@
       pending_audio_decrypt_request_id_(0),
       pending_video_decrypt_request_id_(0),
       pending_audio_decoder_init_request_id_(0),
       pending_video_decoder_init_request_id_(0),
       pending_audio_decode_request_id_(0),
       pending_video_decode_request_id_(0),
       weak_ptr_factory_(this),
       weak_this_(weak_ptr_factory_.GetWeakPtr()) {
 }
 
+void ContentDecryptorDelegate::Initialize(const std::string& key_system) {
+  // TODO(ddorwin): Add an Initialize method to PPP_ContentDecryptor_Private.
+  DCHECK(!key_system.empty());
+  key_system_ = key_system;
+}
+
 void ContentDecryptorDelegate::SetKeyEventCallbacks(
     const media::KeyAddedCB& key_added_cb,
     const media::KeyErrorCB& key_error_cb,
     const media::KeyMessageCB& key_message_cb,
     const media::NeedKeyCB& need_key_cb) {
   key_added_cb_ = key_added_cb;
   key_error_cb_ = key_error_cb;
   key_message_cb_ = key_message_cb;
   need_key_cb_ = need_key_cb;
 }
 
-bool ContentDecryptorDelegate::GenerateKeyRequest(const std::string& key_system,
-                                                  const std::string& type,
+bool ContentDecryptorDelegate::GenerateKeyRequest(const std::string& type,
                                                   const uint8* init_data,
                                                   int init_data_length) {
-  if (key_system.empty())
-    return false;
-
   PP_Var init_data_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           init_data_length, init_data);
 
   plugin_decryption_interface_->GenerateKeyRequest(
       pp_instance_,
-      StringVar::StringToPPVar(key_system),
+      StringVar::StringToPPVar(key_system_),  // TODO(ddorwin): Remove.
       StringVar::StringToPPVar(type),
       init_data_array);
   return true;
 }
 
 bool ContentDecryptorDelegate::AddKey(const std::string& session_id,
                                       const uint8* key,
                                       int key_length,
                                       const uint8* init_data,
                                       int init_data_length) {
@@ skipping 285 matching lines @@
   plugin_decryption_interface_->DecryptAndDecode(pp_instance_,
                                                  PP_DECRYPTORSTREAMTYPE_VIDEO,
                                                  pp_resource,
                                                  &block_info);
   return true;
 }
 
 void ContentDecryptorDelegate::NeedKey(PP_Var key_system_var,
                                        PP_Var session_id_var,
                                        PP_Var init_data_var) {
-  // TODO(tomfinegan): send the data to media stack.
+  // TODO(ddorwin): Remove from PPB_ContentDecryptor_Private.
+  NOTREACHED();
 }
 
 void ContentDecryptorDelegate::KeyAdded(PP_Var key_system_var,
                                         PP_Var session_id_var) {
   if (key_added_cb_.is_null())
     return;
 
-  StringVar* key_system_string = StringVar::FromPPVar(key_system_var);
   StringVar* session_id_string = StringVar::FromPPVar(session_id_var);
-  if (!key_system_string || !session_id_string) {
-    key_error_cb_.Run(
-        std::string(), std::string(), media::MediaKeys::kUnknownError, 0);
+  if (!session_id_string) {
+    key_error_cb_.Run(std::string(), media::MediaKeys::kUnknownError, 0);
     return;
   }
 
-  key_added_cb_.Run(key_system_string->value(), session_id_string->value());
+  key_added_cb_.Run(session_id_string->value());
 }
 
 void ContentDecryptorDelegate::KeyMessage(PP_Var key_system_var,
                                           PP_Var session_id_var,
                                           PP_Var message_var,
                                           PP_Var default_url_var) {
   if (key_message_cb_.is_null())
     return;
 
-  StringVar* key_system_string = StringVar::FromPPVar(key_system_var);
   StringVar* session_id_string = StringVar::FromPPVar(session_id_var);
 
   ArrayBufferVar* message_array_buffer =
       ArrayBufferVar::FromPPVar(message_var);
 
   std::string message;
   if (message_array_buffer) {
     const char* data = static_cast<const char*>(message_array_buffer->Map());
     message.assign(data, message_array_buffer->ByteLength());
   }
 
   StringVar* default_url_string = StringVar::FromPPVar(default_url_var);
 
-  if (!key_system_string || !session_id_string || !default_url_string) {
-    key_error_cb_.Run(
-        std::string(), std::string(), media::MediaKeys::kUnknownError, 0);
+  if (!session_id_string || !default_url_string) {
+    key_error_cb_.Run(std::string(), media::MediaKeys::kUnknownError, 0);
     return;
   }
 
-  key_message_cb_.Run(key_system_string->value(),
-                      session_id_string->value(),
+  key_message_cb_.Run(session_id_string->value(),
                       message,
                       default_url_string->value());
 }
 
 void ContentDecryptorDelegate::KeyError(PP_Var key_system_var,
                                         PP_Var session_id_var,
                                         int32_t media_error,
                                         int32_t system_code) {
   if (key_error_cb_.is_null())
     return;
 
-  StringVar* key_system_string = StringVar::FromPPVar(key_system_var);
   StringVar* session_id_string = StringVar::FromPPVar(session_id_var);
-  if (!key_system_string || !session_id_string) {
-    key_error_cb_.Run(
-        std::string(), std::string(), media::MediaKeys::kUnknownError, 0);
+  if (!session_id_string) {
+    key_error_cb_.Run(std::string(), media::MediaKeys::kUnknownError, 0);
     return;
   }
 
-  key_error_cb_.Run(
-      key_system_string->value(),
-      session_id_string->value(),
-      static_cast<media::MediaKeys::KeyError>(media_error),
-      system_code);
+  key_error_cb_.Run(session_id_string->value(),
+                    static_cast<media::MediaKeys::KeyError>(media_error),
+                    system_code);
 }
 
 void ContentDecryptorDelegate::DecoderInitializeDone(
      PP_DecryptorStreamType decoder_type,
      uint32_t request_id,
      PP_Bool success) {
   if (decoder_type == PP_DECRYPTORSTREAMTYPE_AUDIO) {
     // If the request ID is not valid or does not match what's saved, do
     // nothing.
     if (request_id == 0 ||
@@ skipping 324 matching lines @@
 
   if (free_buffers_.empty())
     return;
 
   tracking_info->buffer_id = free_buffers_.front();
   free_buffers_.pop();
 }
 
 }  // namespace ppapi
 }  // namespace webkit