Encrypted Media: Replace DecryptorClient with key event callbacks.

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_proxy.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/channel_layout.h"
 #include "media/base/data_buffer.h"
 #include "media/base/decoder_buffer.h"
-#include "media/base/decryptor_client.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_buffer_api.h"
 #include "ui/gfx/rect.h"
 #include "webkit/plugins/ppapi/ppb_buffer_impl.h"
@@ skipping 239 matching lines @@
   }
 }
 
 }  // namespace
 
 ContentDecryptorDelegate::ContentDecryptorDelegate(
     PP_Instance pp_instance,
     const PPP_ContentDecryptor_Private* plugin_decryption_interface)
     : pp_instance_(pp_instance),
       plugin_decryption_interface_(plugin_decryption_interface),
-      decryptor_client_(NULL),
       next_decryption_request_id_(1),
       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),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       weak_this_(weak_ptr_factory_.GetWeakPtr()) {
 }
 
-void ContentDecryptorDelegate::set_decrypt_client(
-    media::DecryptorClient* decryptor_client) {
-  decryptor_client_ = decryptor_client;
+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,
                                                   const uint8* init_data,
                                                   int init_data_length) {
   if (key_system.empty())
     return false;
 
   PP_Var init_data_array =
@@ skipping 322 matching lines @@
 }
 
 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.
 }
 
 void ContentDecryptorDelegate::KeyAdded(PP_Var key_system_var,
                                         PP_Var session_id_var) {
-  if (!decryptor_client_)
+  if (key_added_cb_.is_null())

[ddorwin, 2012/12/21 04:19:06]

In what scenarios can this occur? Should there be a DCHECK, DLOG, return value,
or some other indication of failure?

[xhwang, 2012/12/21 05:50:07]

hmm, I guess this comes from my paranoid about not trusting the plugin/CDM. This
is to guard the case where the plugin/CDM fires key events before we
SetKeyEventCallbacks(). For example, if some other people choose to implement
another plugin that calls the PPB interface before GKR is called...

     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) {
-    decryptor_client_->KeyError("", "", media::Decryptor::kUnknownError, 0);
+    key_error_cb_.Run("", "", media::Decryptor::kUnknownError, 0);
     return;
   }
 
-  decryptor_client_->KeyAdded(key_system_string->value(),
-                              session_id_string->value());
+  key_added_cb_.Run(key_system_string->value(), 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 (!decryptor_client_)
+  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) {
-    decryptor_client_->KeyError("", "", media::Decryptor::kUnknownError, 0);
+    key_error_cb_.Run("", "", media::Decryptor::kUnknownError, 0);
     return;
   }
 
-  decryptor_client_->KeyMessage(key_system_string->value(),
-                                session_id_string->value(),
-                                message,
-                                default_url_string->value());
+  key_message_cb_.Run(key_system_string->value(),
+                      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 (!decryptor_client_)
+  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) {
-    decryptor_client_->KeyError("", "", media::Decryptor::kUnknownError, 0);
+    key_error_cb_.Run("", "", media::Decryptor::kUnknownError, 0);
     return;
   }
 
-  decryptor_client_->KeyError(
+  key_error_cb_.Run(
       key_system_string->value(),
       session_id_string->value(),
       static_cast<media::Decryptor::KeyError>(media_error),
       system_code);
 }
 
 void ContentDecryptorDelegate::DecoderInitializeDone(
      PP_DecryptorStreamType decoder_type,
      uint32_t request_id,
      PP_Bool success) {
@@ skipping 320 matching lines @@
 
   if (free_buffers_.empty())
     return;
 
   tracking_info->buffer_id = free_buffers_.front();
   free_buffers_.pop();
 }
 
 }  // namespace ppapi
 }  // namespace webkit