Add PPAPI decryptor implementation.

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 96 matching lines @@
 using ppapi::PPP_Instance_Combined;
 using ppapi::ScopedPPResource;
 using ppapi::StringVar;
 using ppapi::TrackedCallback;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Buffer_API;
 using ppapi::thunk::PPB_Graphics2D_API;
 using ppapi::thunk::PPB_Graphics3D_API;
 using ppapi::thunk::PPB_ImageData_API;
 using ppapi::Var;
+using ppapi::ArrayBufferVar;

[xhwang, 2012/08/15 00:27:57]

It looks like these are alphabetically ordered, w/ the only exception of
TrackedCallback. If that's the case, should move this line up.

[Tom Finegan, 2012/08/16 03:10:48]

Yeah, wasn't sure what to do-- ArrayBufferVar next to Var made sense, but
sorting based on prevailing order also makes sense. dmichael? :)

 using ppapi::ViewData;
 using WebKit::WebBindings;
 using WebKit::WebCanvas;
 using WebKit::WebCursorInfo;
 using WebKit::WebDocument;
 using WebKit::WebElement;
 using WebKit::WebFrame;
 using WebKit::WebInputEvent;
 using WebKit::WebPlugin;
 using WebKit::WebPluginContainer;
@@ skipping 160 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

[xhwang, 2012/08/15 00:27:57]

Returns an invalid PP_Resource (with a 0 ID) on failure?

[Tom Finegan, 2012/08/16 03:10:48]

Done.

+// failure.
+PP_Resource MakeBufferResource(PP_Instance instance,
+                               const base::StringPiece& data) {
+  if (data.empty())
+    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());
+  memcpy(mapper.data(), data.data(), data.size());
+
+  return resource.get();
+}
+
 }  // 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 622 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::LoadContentDecryptorInterface() {
+  if (!plugin_decryption_interface_) {
+    plugin_decryption_interface_ =
+        static_cast<const PPP_ContentDecryptor_Private*>(
+          module_->GetPluginInterface(
+              PPP_CONTENTDECRYPTOR_PRIVATE_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 297 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 (!LoadContentDecryptorInterface())
+    return false;
+  if (key_system.empty())
+    return false;
+  PP_Var init_data_array =
+      PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
+          init_data.size(), init_data.data());
+  return PP_ToBool(plugin_decryption_interface_->GenerateKeyRequest(
+      pp_instance(),
+      StringVar::StringToPPVar(key_system),
+      init_data_array));
+}
+
+bool PluginInstance::AddKey(const std::string& session_id,
+                            const std::string& key) {
+  if (!LoadContentDecryptorInterface())
+    return false;
+  StringVar session_id_var(session_id);
+  PP_Var key_array =
+      PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(key.size(),
+                                                                 key.data());
+  return PP_ToBool(plugin_decryption_interface_->AddKey(
+      pp_instance(),
+      session_id_var.GetPPVar(),
+      key_array));
+}
+
+bool PluginInstance::CancelKeyRequest(const std::string& session_id) {
+  if (!LoadContentDecryptorInterface())
+    return false;
+  StringVar session_id_var(session_id);
+  return PP_ToBool(plugin_decryption_interface_->CancelKeyRequest(
+      pp_instance(),
+      session_id_var.GetPPVar()));
+}
+
+bool PluginInstance::Decrypt(const base::StringPiece& encrypted_block,
+                             const DecryptedDataCB& callback) {
+  if (!LoadContentDecryptorInterface())
+    return false;
+  ScopedPPResource encrypted_resource(MakeBufferResource(pp_instance(),
+                                                         encrypted_block));
+  if (!encrypted_resource.get())
+    return false;
+  // TODO(tomfinegan): Store callback and ID in a map, and pass ID to decryptor.
+  return PP_ToBool(plugin_decryption_interface_->Decrypt(pp_instance(),
+                                                         encrypted_resource,
+                                                         0));
+}
+
+bool PluginInstance::DecryptAndDecode(const base::StringPiece& encrypted_block,
+                                      const DecryptedDataCB& callback) {
+  if (!LoadContentDecryptorInterface())
+    return false;
+  ScopedPPResource encrypted_resource(ScopedPPResource::PassRef(),
+                                      MakeBufferResource(pp_instance(),
+                                                         encrypted_block));
+  if (!encrypted_resource.get())
+    return false;
+  // TODO(tomfinegan): Store callback and ID in a map, and pass ID to decryptor.
+  return PP_ToBool(plugin_decryption_interface_->DecryptAndDecode(
+      pp_instance(),
+      encrypted_resource,
+      0));
+}
+
 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 588 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_var,
+                             PP_Var session_id_var,
+                             PP_Var init_data_var) {
+  StringVar* key_system_string = StringVar::FromPPVar(key_system_var);
+  StringVar* session_id_string = StringVar::FromPPVar(session_id_var);
+  StringVar* init_data_string = StringVar::FromPPVar(init_data_var);
+
+  if (!key_system_string || !session_id_string || !init_data_string)
+    return;
+}
+
+void PluginInstance::KeyAdded(PP_Instance instance,
+                              PP_Var key_system_var,
+                              PP_Var session_id_var) {
+  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) {
+    // TODO(tomfinegan): KeyError here?

[xhwang, 2012/08/15 00:27:57]

The CDMWrapper should check this. Here we probably should just do DCHECK, and
pass things through.

[Tom Finegan, 2012/08/16 03:10:48]

No DCHECKs-- per dmichael we're supposed to treat the plugin as untrusted.

Removed the checks, though.

+    return;
+  }
+
+  // TODO(tomfinegan): send the data to media stack.
+}
+
+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);
+
+  if (!key_system_string || !session_id_string || !default_url_string) {
+    // TODO(tomfinegan): KeyError here?

[xhwang, 2012/08/15 00:27:57]

ditto.

[Tom Finegan, 2012/08/16 03:10:48]

Done/removed checks.

+    return;
+  }
+
+  EnterResourceNoLock<PPB_Buffer_API> enter(message_resource, true);
+  if (enter.failed()) {
+    // TODO(tomfinegan): KeyError here?

[xhwang, 2012/08/15 00:27:57]

Can this happen if we implemented everything correctly? Or can this be triggered
by a malicious CDM implementation? If not, should this be a DCHECK? 

[Tom Finegan, 2012/08/16 03:10:48]

Initial question: presumably yes, at the very least out of memory could trigger
it. Otoh we're just going to crash if we're oom. :)

See above re DCHECK.

+    return;
+  }
+
+  BufferAutoMapper mapper(enter.object());
+  if (!mapper.data() || !mapper.size()) {
+    // TODO(tomfinegan): KeyError here?

[xhwang, 2012/08/15 00:27:57]

ditto here and below.

[Tom Finegan, 2012/08/16 03:10:48]

Done/removed checks.

+    return;
+  }
+
+  std::string message(reinterpret_cast<char*>(mapper.data()), mapper.size());
+  if (message.empty()) {
+    // TODO(tomfinegan): KeyError here?
+    return;
+  }
+
+  // TODO(tomfinegan): send the data to media stack.
+}
+
+void PluginInstance::KeyError(PP_Instance instance,
+                              PP_Var key_system_var,
+                              PP_Var session_id_var,
+                              int32_t media_error,
+                              int32_t system_code) {
+  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)
+    return;
+
+  // TODO(tomfinegan): send the data to media stack.
+}
+
+void PluginInstance::DeliverBlock(PP_Instance instance,
+                                  PP_Resource decrypted_block,
+                                  int32_t request_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.

[xhwang, 2012/08/15 00:27:57]

You can simplify this to:
TODO(xhwang): Pass the decrypted block back to media stack.

[Tom Finegan, 2012/08/16 03:10:48]

Done.

+  //
+}
+
+void PluginInstance::DeliverFrame(PP_Instance instance,
+                                  PP_Resource decrypted_frame,
+                                  int32_t request_id) {
+  // TODO(tomfinegan): To be implemented after completion of v0.1 of the
+  // EME/CDM work.

[xhwang, 2012/08/15 00:27:57]

Add NOTREACHED();

[Tom Finegan, 2012/08/16 03:10:48]

dmichael said not to use things that can bring down the browser here.

+}
+
+void PluginInstance::DeliverSamples(PP_Instance instance,
+                                    PP_Resource decrypted_samples,
+                                    int32_t request_id) {
+  // TODO(tomfinegan): To be implemented after completion of v0.1 of the
+  // EME/CDM work.

[xhwang, 2012/08/15 00:27:57]

Add NOTREACHED();

[Tom Finegan, 2012/08/16 03:10:48]

Ditto.

+}
+
+
 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 355 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