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 215fa73b795ee0ca6120b6f2f0143e7ce610113b..ebcb28990f81af4e9eada94e36d7dd9d73f58a94 100644
--- a/webkit/plugins/ppapi/ppapi_plugin_instance.cc
+++ b/webkit/plugins/ppapi/ppapi_plugin_instance.cc
@@ -294,6 +294,34 @@ 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 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
@@ -323,6 +351,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),
@@ -959,6 +988,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_ =
@@ -1270,6 +1309,97 @@ 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_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;
 }
@@ -1854,6 +1984,86 @@ PP_Var PluginInstance::GetFontFamilies(PP_Instance instance) {
   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) {