Call CDMWrapper from PpapiDecryptor.

webkit/plugins/ppapi/ppapi_plugin_instance.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/ppapi_plugin_instance.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop.h"
+#include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_offset_string_conversions.h"
 #include "base/utf_string_conversions.h"
+#include "media/base/decoder_buffer.h"
+#include "media/base/decryptor_client.h"
+#include "ppapi/c/dev/pp_decryption_buffer_dev.h"
 #include "ppapi/c/dev/ppb_find_dev.h"
 #include "ppapi/c/dev/ppb_zoom_dev.h"
 #include "ppapi/c/dev/ppp_find_dev.h"
 #include "ppapi/c/dev/ppp_selection_dev.h"
 #include "ppapi/c/dev/ppp_text_input_dev.h"
 #include "ppapi/c/dev/ppp_zoom_dev.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/ppb_audio_config.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_gamepad.h"
 #include "ppapi/c/ppp_input_event.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/c/ppp_messaging.h"
 #include "ppapi/c/ppp_mouse_lock.h"
 #include "ppapi/c/private/ppp_instance_private.h"
 #include "ppapi/shared_impl/ppb_input_event_shared.h"
 #include "ppapi/shared_impl/ppb_url_util_shared.h"
+#include "ppapi/shared_impl/ppb_var_shared.h"
 #include "ppapi/shared_impl/ppb_view_shared.h"
 #include "ppapi/shared_impl/ppp_instance_combined.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_buffer_api.h"
 #include "printing/units.h"
 #include "third_party/skia/include/core/SkCanvas.h"
@@ skipping 248 matching lines @@
   scoped_array<const char*> array(new const char*[vector.size()]);
   for (size_t i = 0; i < vector.size(); ++i)
     array[i] = vector[i].c_str();
   return array.Pass();
 }
 
 // Creates a PP_Resource containing a PPB_Buffer_Impl, copies |data| into the
 // buffer resource, and returns it. Returns a PP_Resource equal to 0 on
 // failure.
 PP_Resource MakeBufferResource(PP_Instance instance,
-                               const std::string& data) {
-  if (data.empty())
+                               const char* data, size_t size) {
+  if (!data)
     return 0;
 
-  ScopedPPResource resource(PPB_Buffer_Impl::Create(instance, data.size()));
+  ScopedPPResource resource(PPB_Buffer_Impl::Create(instance, size));
   if (!resource.get())
     return 0;
 
   EnterResourceNoLock<PPB_Buffer_API> enter(resource, true);
   if (enter.failed())
     return 0;
 
   BufferAutoMapper mapper(enter.object());
-  if (!mapper.data() || mapper.size() < data.size())
+  if (!mapper.data() || mapper.size() < size)
     return 0;
-  memcpy(mapper.data(), data.data(), data.size());
+  memcpy(mapper.data(), data, size);
 
   // Add the resource to the tracker...
   // TODO(tomfinegan): wild guess/no idea if this is right.
   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(resource.get());
 
   return resource.Release();
 }
 
 }  // namespace
 
@@ skipping 46 matching lines @@
       sad_plugin_(NULL),
       input_event_mask_(0),
       filtered_input_event_mask_(0),
       text_input_type_(kPluginDefaultTextInputType),
       text_input_caret_(0, 0, 0, 0),
       text_input_caret_bounds_(0, 0, 0, 0),
       text_input_caret_set_(false),
       selection_caret_(0),
       selection_anchor_(0),
       pending_user_gesture_(0.0),
-      flash_impl_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+      flash_impl_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      decryptor_client_(NULL),
+      next_decryption_buffer_id_(0) {
   pp_instance_ = HostGlobals::Get()->AddInstance(this);
 
   memset(&current_print_settings_, 0, sizeof(current_print_settings_));
   DCHECK(delegate);
   module_->InstanceCreated(this);
   delegate_->InstanceCreated(this);
   message_channel_.reset(new MessageChannel(this));
 
   view_data_.is_page_visible = delegate->IsPageVisible();
 
@@ skipping 916 matching lines @@
   if (!LoadPdfInterface())
     return;
   PP_PrivatePageTransformType transform_type =
       type == WebPlugin::RotationType90Clockwise ?
       PP_PRIVATEPAGETRANSFORMTYPE_ROTATE_90_CW :
       PP_PRIVATEPAGETRANSFORMTYPE_ROTATE_90_CCW;
   plugin_pdf_interface_->Transform(pp_instance(), transform_type);
   // NOTE: plugin instance may have been deleted.
 }
 
+void PluginInstance::SetDecryptClient(
+    media::DecryptorClient* decryptor_client) {
+  DCHECK(decryptor_client);
+  decryptor_client_ = decryptor_client;
+}
+
 bool PluginInstance::GenerateKeyRequest(const std::string& key_system,
                                         const std::string& init_data) {
   if (!LoadContentDecryptionModuleInterface())
     return false;
 
   if (key_system.empty())
     return false;
 
   PP_Resource init_data_resource = 0;
   if (init_data.size()) {
     ScopedPPResource local_init_data(ScopedPPResource::PassRef(),
                                      MakeBufferResource(pp_instance(),
-                                                        init_data));
+                                                        init_data.data(),
+                                                        init_data.size()));
 
     if (!local_init_data.get())
       return false;
     init_data_resource = local_init_data.Release();
   }
 
   return PP_ToBool(plugin_decryption_interface_->GenerateKeyRequest(
       pp_instance(),
       StringVar::StringToPPVar(key_system),
       init_data_resource));
 }
 
 bool PluginInstance::AddKey(const std::string& session_id,
                             const std::string& key) {
   if (!LoadContentDecryptionModuleInterface())
     return false;
 
   StringVar session_id_var(session_id);
   if (session_id_var.value().size() < session_id.size())
     return false;
 
   ScopedPPResource key_resource(ScopedPPResource::PassRef(),
-                                MakeBufferResource(pp_instance(), key));
+                                MakeBufferResource(pp_instance(),
+                                                   key.data(),
+                                                   key.size()));
   if (!key_resource.get())
     return false;
 
   return PP_ToBool(plugin_decryption_interface_->AddKey(
       pp_instance(),
       session_id_var.GetPPVar(),
       key_resource));
 }
 
 bool PluginInstance::CancelKeyRequest(const std::string& session_id) {
   if (!LoadContentDecryptionModuleInterface())
     return false;
   StringVar session_id_var(session_id);
   if (session_id_var.value().size() < session_id.size())
     return false;
   return PP_ToBool(plugin_decryption_interface_->CancelKeyRequest(
       pp_instance(),
       session_id_var.GetPPVar()));
 }
 
-bool PluginInstance::Decrypt(const std::string& encrypted_block,
-                             const CDMStatusCB& callback) {
+bool PluginInstance::Decrypt(
+    const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
+    const CDMStatusCB& callback) {
   if (!LoadContentDecryptionModuleInterface())
     return false;
-  ScopedPPResource encrypted_resource(ScopedPPResource::PassRef(),
-                                      MakeBufferResource(pp_instance(),
-                                                         encrypted_block));
+
+  DCHECK(encrypted_buffer->GetDecryptConfig());
+  DCHECK(encrypted_buffer->GetData());
+  DCHECK_GT(encrypted_buffer->GetDataSize(), 0);
+  ScopedPPResource encrypted_resource(
+      ScopedPPResource::PassRef(),
+      MakeBufferResource(
+          pp_instance(),
+          reinterpret_cast<const char*>(encrypted_buffer->GetData()),
+          encrypted_buffer->GetDataSize()));
+
   if (!encrypted_resource.get())
     return false;
   // TODO(tomfinegan): wrap callback in PP_CompletionCallback and pass it to
   // the plugin.
-  PP_CompletionCallback pp_callback = {NULL, NULL, 0};
+
+  const media::DecryptConfig& decrypt_config =
+      *encrypted_buffer->GetDecryptConfig();
+
+  uint64_t buffer_id = next_decryption_buffer_id_++;
+  DCHECK(!ContainsKey(cdm_status_cb_map_, buffer_id));
+  cdm_status_cb_map_.insert(std::make_pair(buffer_id, callback));
+
+  PP_DecryptionBuffer_Dev buffer;
+  buffer.data = encrypted_resource;
+  buffer.data_offset = decrypt_config.data_offset();
+  buffer.id = buffer_id;
+  // TODO(xhwang): Fill all fields here.
+
   return PP_ToBool(plugin_decryption_interface_->Decrypt(pp_instance(),
-                                                         encrypted_resource,
-                                                         pp_callback));
+                                                         &buffer));
 }
 
 bool PluginInstance::DecryptAndDecode(const std::string& encrypted_block,
                                       const CDMStatusCB& callback) {
   if (!LoadContentDecryptionModuleInterface())
     return false;
-  ScopedPPResource encrypted_resource(ScopedPPResource::PassRef(),
-                                      MakeBufferResource(pp_instance(),
-                                                         encrypted_block));
+  ScopedPPResource encrypted_resource(
+      ScopedPPResource::PassRef(),
+      MakeBufferResource(pp_instance(),
+                         encrypted_block.data(), encrypted_block.size()));
   if (!encrypted_resource.get())
     return false;
   // TODO(tomfinegan): wrap callback in PP_CompletionCallback and pass it to
   // the plugin.
   PP_CompletionCallback pp_callback = {NULL, NULL, 0};
   return PP_ToBool(plugin_decryption_interface_->DecryptAndDecode(
       pp_instance(),
       encrypted_resource,
       pp_callback));
 }
@@ skipping 596 matching lines @@
 
 PP_Var PluginInstance::GetFontFamilies(PP_Instance instance) {
   // No in-process implementation.
   return PP_MakeUndefined();
 }
 
 void PluginInstance::NeedKey(PP_Instance instance,
                              PP_Var key_system_var,
                              PP_Var session_id_var,
                              PP_Resource init_data) {
-  StringVar* key_system_string = StringVar::FromPPVar(key_system_var);
-  StringVar* session_id_string = StringVar::FromPPVar(session_id_var);
+  //StringVar* key_system_string = StringVar::FromPPVar(key_system_var);
+  //StringVar* session_id_string = StringVar::FromPPVar(session_id_var);
 
   // TODO(tomfinegan): Where does the call to this method come from? Or, where
   // does it go for handling. I need to read more of the EME proposed spec, but
   // this is what I understand so far:
   // - JS app sends needkey before anything else when it knows that encrypted
   //   data is going to be streamed to the user agent.
   // - OR is the media stack going to see something in the stream that looks
   //   like init data, and then send NeedKey. If this is the case NeedKey
   //   probably needs to move to the PPP interface.
 
   HostGlobals::Get()->GetVarTracker()->ReleaseVar(key_system_var);
   HostGlobals::Get()->GetVarTracker()->ReleaseVar(session_id_var);
 }
 
 void PluginInstance::KeyAdded(PP_Instance instance,
                               PP_Var key_system,
                               PP_Var session_id) {
+  DCHECK(decryptor_client_);
+
 }
 
 void PluginInstance::KeyMessage(PP_Instance instance,
                                 PP_Var key_system_var,
                                 PP_Var session_id_var,
                                 PP_Resource message_resource,
                                 PP_Var default_url_var) {
   StringVar* key_system_string = StringVar::FromPPVar(key_system_var);
   StringVar* session_id_string = StringVar::FromPPVar(session_id_var);
   StringVar* default_url_string = StringVar::FromPPVar(default_url_var);
@@ skipping 17 matching lines @@
     return;
   }
 
   std::string message(reinterpret_cast<char*>(mapper.data()), mapper.size());
   if (message.empty()) {
     // TODO(tomfinegan): KeyError here?
     NOTREACHED();
     return;
   }
 
+  DCHECK(decryptor_client_);
+  scoped_array<uint8> message_array(new uint8[message.size()]);
+  memcpy(message_array.get(), message.data(), message.size());
+
+  decryptor_client_->KeyMessage(key_system_string->value(),
+                                session_id_string->value(),
+                                message_array.Pass(),
+                                message.size(),
+                                default_url_string->value());
+
   // Release the PP_Vars.
   HostGlobals::Get()->GetVarTracker()->ReleaseVar(key_system_var);
   HostGlobals::Get()->GetVarTracker()->ReleaseVar(session_id_var);
   HostGlobals::Get()->GetVarTracker()->ReleaseVar(default_url_var);
 
   // Release the PP_Resource.
   // TODO(tomfinegan): Confirm that the buffer is freed.
   HostGlobals::Get()->GetResourceTracker()->ReleaseResource(message_resource);
 }
 
 void PluginInstance::KeyError(PP_Instance instance,
                               PP_Var key_system_var,
                               PP_Var session_id_var,
                               uint16_t media_error,
                               uint16_t system_error) {
-  StringVar* key_system_string = StringVar::FromPPVar(key_system_var);
-  StringVar* session_id_string = StringVar::FromPPVar(session_id_var);
+  //StringVar* key_system_string = StringVar::FromPPVar(key_system_var);
+  //StringVar* session_id_string = StringVar::FromPPVar(session_id_var);
 
   HostGlobals::Get()->GetVarTracker()->ReleaseVar(key_system_var);
   HostGlobals::Get()->GetVarTracker()->ReleaseVar(session_id_var);
 }
 
 void PluginInstance::DeliverBlock(PP_Instance instance,
                                   PP_Resource decrypted_block,
-                                  PP_CompletionCallback callback) {
+                                  uint32_t id) {
   // TODO(tomfinegan): Determine where |decrypted_block| goes, and what
   // callback actually is (callback will likely be the result of some
   // base::Bind usage in the media stack. Hash this out with xhwang.
   //
+
+  std::map<uint64_t, CDMStatusCB>::iterator found = cdm_status_cb_map_.find(id);
+  if (found != cdm_status_cb_map_.end()) {
+    DVLOG(3) << "DeliverBlock(): Buffer ID " << id << " found, callback fired.";
+    found->second.Run(NULL, 0);
+    cdm_status_cb_map_.erase(found);
+  }
+  else {
+    DVLOG(3) << "DeliverBlock(): Buffer ID " << id << " not found.";
+    NOTREACHED();
+  }
+
   HostGlobals::Get()->GetResourceTracker()->ReleaseResource(decrypted_block);
 }
 
 void PluginInstance::DeliverFrame(PP_Instance instance,
                                   PP_Resource decrypted_frame,
                                   PP_CompletionCallback callback) {
   // Not implemented in v0.1 of the EME/CDM work.
 }
 
 void PluginInstance::DeliverSamples(PP_Instance instance,
@@ skipping 372 matching lines @@
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit