Add PPAPI decryptor interfaces.

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 "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
@@ skipping 276 matching lines @@
 // returned vector are only guaranteed valid so long as the vector of strings
 // is not modified.
 scoped_array<const char*> StringVectorToArgArray(
     const std::vector<std::string>& vector) {
   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.size())
+    return 0;
+
+  ScopedPPResource resource(PPB_Buffer_Impl::Create(instance, data.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())
+    return 0;
+  memcpy(mapper.data(), data.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
 
 // static
 PluginInstance* PluginInstance::Create(PluginDelegate* delegate,
                                        PluginModule* module) {
   base::Callback<const void*(const char*)> get_plugin_interface_func =
       base::Bind(&PluginModule::GetPluginInterface, module);
   PPP_Instance_Combined* ppp_instance_combined =
       PPP_Instance_Combined::Create(get_plugin_interface_func);
   if (!ppp_instance_combined)
     return NULL;
   return new PluginInstance(delegate, module, ppp_instance_combined);
 }
 
 PluginInstance::PluginInstance(
     PluginDelegate* delegate,
     PluginModule* module,
     ::ppapi::PPP_Instance_Combined* instance_interface)
     : delegate_(delegate),
       module_(module),
       instance_interface_(instance_interface),
       pp_instance_(0),
       container_(NULL),
       full_frame_(false),
       sent_initial_did_change_view_(false),
       view_change_weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       has_webkit_focus_(false),
       has_content_area_focus_(false),
       find_identifier_(-1),
+      plugin_decryption_interface_(NULL),
       plugin_find_interface_(NULL),
       plugin_input_event_interface_(NULL),
       plugin_messaging_interface_(NULL),
       plugin_mouse_lock_interface_(NULL),
       plugin_pdf_interface_(NULL),
       plugin_private_interface_(NULL),
       plugin_selection_interface_(NULL),
       plugin_textinput_interface_(NULL),
       plugin_zoom_interface_(NULL),
       checked_for_plugin_input_event_interface_(false),
@@ skipping 616 matching lines @@
 
 void PluginInstance::StopFind() {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (!LoadFindInterface())
     return;
   find_identifier_ = -1;
   plugin_find_interface_->StopFind(pp_instance());
 }
 
+bool PluginInstance::LoadContentDecryptionModuleInterface() {
+  if (!plugin_decryption_interface_) {
+    plugin_decryption_interface_ =
+        static_cast<const PPP_ContentDecryptor_Dev*>(
+          module_->GetPluginInterface(
+              PPP_CONTENTDECRYPTOR_DEV_INTERFACE));
+  }
+  return !!plugin_decryption_interface_;
+}
+
 bool PluginInstance::LoadFindInterface() {
   if (!plugin_find_interface_) {
     plugin_find_interface_ =
         static_cast<const PPP_Find_Dev*>(module_->GetPluginInterface(
             PPP_FIND_DEV_INTERFACE));
   }
 
   return !!plugin_find_interface_;
 }
 
@@ skipping 291 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.
 }
 
+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));
+
+    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));
+  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) {
+  if (!LoadContentDecryptionModuleInterface())
+    return false;
+  ScopedPPResource encrypted_resource(ScopedPPResource::PassRef(),
+                                      MakeBufferResource(pp_instance(),
+                                                         encrypted_block));
+  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_->Decrypt(pp_instance(),
+                                                         encrypted_resource,
+                                                         pp_callback));
+}
+
+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));
+  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));
+}
+
 bool PluginInstance::FlashIsFullscreenOrPending() {
   return fullscreen_container_ != NULL;
 }
 
 bool PluginInstance::IsFullscreenOrPending() {
   return desired_fullscreen_state_;
 }
 
 bool PluginInstance::SetFullscreen(bool fullscreen) {
   // Keep a reference on the stack. See NOTE above.
@@ skipping 564 matching lines @@
 PP_Var PluginInstance::GetDefaultCharSet(PP_Instance instance) {
   std::string encoding = delegate()->GetDefaultEncoding();
   return StringVar::StringToPPVar(encoding);
 }
 
 PP_Var PluginInstance::GetFontFamilies(PP_Instance instance) {
   // No in-process implementation.
   return PP_MakeUndefined();
 }
 
+void PluginInstance::NeedKey(PP_Instance instance,
+                             PP_Var key_system,
+                             PP_Var session_id,
+                             PP_Resource init_data) {
+}
+
+void PluginInstance::KeyAdded(PP_Instance instance,
+                              PP_Var key_system,
+                              PP_Var session_id) {
+}
+
+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) {
+  // Extract the std::strings from the PP_Vars.
+  StringVar* key_system_string = StringVar::FromPPVar(key_system_var);

[ddorwin, 2012/07/17 21:47:56]

Just checking, are these non-owning pointers?

[Tom Finegan, 2012/07/17 22:15:34]

Correct-- this just gives access to the data. It does not take ownership.

+  StringVar* session_id_string = StringVar::FromPPVar(session_id_var);
+  StringVar* default_url_string = StringVar::FromPPVar(default_url_var);
+
+  if (!key_system_string || !session_id_string || !default_url_string) {

[ddorwin, 2012/07/17 21:47:56]

Does this mean they are NULL or what?
Maybe DCHECK on the first two. The last is optional. Or just pass the values
back to the callback to handle there.

[Tom Finegan, 2012/07/17 22:15:34]

It means they're NULL. I'll DCHECK The first two and just pass things through to
the callback.  

+    // TODO(tomfinegan): KeyError here?
+    return;
+  }
+
+  EnterResourceNoLock<PPB_Buffer_API> enter(message_resource, true);
+  if (enter.failed()) {
+    // TODO(tomfinegan): KeyError here?
+    NOTREACHED();
+    return;
+  }
+
+  BufferAutoMapper mapper(enter.object());
+  if (!mapper.data() || !mapper.size()) {
+    // TODO(tomfinegan): KeyError here?
+    NOTREACHED();
+    return;
+  }
+
+  std::string message(reinterpret_cast<char*>(mapper.data()), mapper.size());
+  if (message.empty()) {
+    // TODO(tomfinegan): KeyError here?
+    NOTREACHED();
+    return;
+  }
+

[ddorwin, 2012/07/17 21:47:56]

What about the other values? And where would we actually call a callback?

[Tom Finegan, 2012/07/17 22:15:34]

The callback would happen right about where this comment is-- I was planning on
passing the StringVar values using the StringVar::value(), but that's not going
to work (assuming an async callback, the callback will not be pleased when it
gets vars with already freed memory because they've been Release()'d from the
tracker).

If the callback is synchronous it probably doesn't matter, and cleaning up here
would be fine.

+  // Relase the PP_Vars.

[ddorwin, 2012/07/17 21:47:56]

Release

[Tom Finegan, 2012/07/17 22:15:34]

Done.

+  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,
+                              PP_Var session_id,
+                              uint16_t media_error,
+                              uint16_t system_error) {
+}
+
+void PluginInstance::DeliverBlock(PP_Instance instance,
+                                  PP_Resource decrypted_block,
+                                  PP_CompletionCallback callback) {
+}
+
+void PluginInstance::DeliverFrame(PP_Instance instance,
+                                  PP_Resource decrypted_frame,
+                                  PP_CompletionCallback callback) {
+}
+
+void PluginInstance::DeliverSamples(PP_Instance instance,
+                                    PP_Resource decrypted_samples,
+                                    PP_CompletionCallback callback) {
+}
+
+
 void PluginInstance::NumberOfFindResultsChanged(PP_Instance instance,
                                                 int32_t total,
                                                 PP_Bool final_result) {
   DCHECK_NE(find_identifier_, -1);
   delegate_->NumberOfFindResultsChanged(find_identifier_, total,
                                         PP_ToBool(final_result));
 }
 
 void PluginInstance::SelectedFindResultChanged(PP_Instance instance,
                                                int32_t index) {
@@ skipping 347 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