Add PPAPI decryptor interfaces.

webkit/plugins/ppapi/ppapi_plugin_instance.cc

Index: webkit/plugins/ppapi/ppapi_plugin_instance.cc
diff --git a/webkit/plugins/ppapi/ppapi_plugin_instance.cc b/webkit/plugins/ppapi/ppapi_plugin_instance.cc
index f01279333f155c15d6d0acd32c6d5088a9dc9ccf..8aec3ce014095162a71e744d61832ad2376ac001 100644
--- a/webkit/plugins/ppapi/ppapi_plugin_instance.cc
+++ b/webkit/plugins/ppapi/ppapi_plugin_instance.cc
@@ -114,6 +114,7 @@ using ppapi::thunk::PPB_Graphics2D_API;
 using ppapi::thunk::PPB_Graphics3D_API;
 using ppapi::thunk::PPB_ImageData_API;
 using ppapi::Var;
+using ppapi::ArrayBufferVar;
 using ppapi::ViewData;
 using WebKit::WebBindings;
 using WebKit::WebCanvas;
@@ -294,6 +295,28 @@ scoped_array<const char*> StringVectorToArgArray(
   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 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
@@ -323,6 +346,7 @@ PluginInstance::PluginInstance(
       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),
@@ -961,6 +985,16 @@ void PluginInstance::StopFind() {
   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_ =
@@ -1278,6 +1312,74 @@ void PluginInstance::RotateView(WebPlugin::RotationType 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_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 (!LoadContentDecryptionModuleInterface())
+    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 (!LoadContentDecryptionModuleInterface())
+    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,

[dmichael (off chromium), 2012/08/08 22:24:02]

Why StringPiece? Isn't this going to come in to you as a WebKit ArrayBuffer? It
seems like you're guaranteeing that you will have to copy, and StringPiece
doesn't feel like the right type for binary stuff anyway.

[xhwang, 2012/08/09 00:49:26]

This was my idea :/ I proposed that to Tom to avoid one extra data copy.

To clarify, this Decrypt() is not directly called by the application or WebKit.
It is called by the media stack (e.g. http://goo.gl/whIO8).

Actually using StringPiece was my idea a week ago. After that I realized that I
also need to pass in decryption configurations along with the encrypted data, so
I just pass in media::DecoderBuffer now: http://goo.gl/e3Jdb

Does this sound good to you? When you have time, please also take a look at:
http://goo.gl/hLwlc ?

[dmichael (off chromium), 2012/08/09 04:18:00]

Yes, I think that makes sense. I also was misunderstanding StringPiece. I'm used
to just using a raw pointer or something for this kind of thing, but StringPiece
would've been fine for referencing a buffer with a length.

I think long term, we'll probably want the buffer part to point to the
ArrayBuffer from JavaScript, which in the future might be mappable to shared
memory so we can save another copy. But that can probably be wrapped behind
DecoderBuffer at this level anyway.

+                             const DecryptedDataCB& callback) {
+  if (!LoadContentDecryptionModuleInterface())
+    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 (!LoadContentDecryptionModuleInterface())
+    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;
 }
@@ -1879,6 +1981,114 @@ PP_Var PluginInstance::GetFontFamilies(PP_Instance instance) {
   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;
+
+  // 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.
+}
+
+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?
+    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?
+    return;
+  }
+
+  EnterResourceNoLock<PPB_Buffer_API> enter(message_resource, true);
+  if (enter.failed()) {
+    // TODO(tomfinegan): KeyError here?
+    return;
+  }
+
+  BufferAutoMapper mapper(enter.object());
+  if (!mapper.data() || !mapper.size()) {
+    // TODO(tomfinegan): KeyError here?
+    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_error) {
+  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,
+                                  uint64_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.
+  //
+}
+
+void PluginInstance::DeliverFrame(PP_Instance instance,
+                                  PP_Resource decrypted_frame,
+                                  uint64_t request_id) {
+  // TODO(tomfinegan): To be implemented after completion of v0.1 of the
+  // EME/CDM work.
+}
+
+void PluginInstance::DeliverSamples(PP_Instance instance,
+                                    PP_Resource decrypted_samples,
+                                    uint64_t request_id) {
+  // TODO(tomfinegan): To be implemented after completion of v0.1 of the
+  // EME/CDM work.
+}
+
+
 void PluginInstance::NumberOfFindResultsChanged(PP_Instance instance,
                                                 int32_t total,
                                                 PP_Bool final_result) {