Add PPAPI decryptor implementation.

ppapi/proxy/ppp_content_decryptor_private_proxy.cc

Index: ppapi/proxy/ppp_content_decryptor_private_proxy.cc
diff --git a/ppapi/proxy/ppp_content_decryptor_private_proxy.cc b/ppapi/proxy/ppp_content_decryptor_private_proxy.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ad8043fbccc0b55013a494be4f5cdbd283d7e316
--- /dev/null
+++ b/ppapi/proxy/ppp_content_decryptor_private_proxy.cc
@@ -0,0 +1,230 @@
+// 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 "ppapi/proxy/ppp_content_decryptor_private_proxy.h"
+
+#include "ppapi/c/pp_bool.h"
+#include "ppapi/proxy/host_dispatcher.h"
+#include "ppapi/proxy/plugin_globals.h"
+#include "ppapi/proxy/plugin_resource_tracker.h"
+#include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/proxy/serialized_var.h"
+#include "ppapi/thunk/enter.h"
+#include "ppapi/thunk/ppb_instance_api.h"
+#include "ppapi/thunk/thunk.h"
+
+using ppapi::thunk::PPB_Instance_API;
+
+namespace ppapi {
+namespace proxy {
+
+namespace {
+
+PP_Bool GenerateKeyRequest(PP_Instance instance,
+                           PP_Var key_system,
+                           PP_Var init_data) {
+  HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
+  if (!dispatcher) {
+    NOTREACHED();
+    return PP_FALSE;
+  }
+
+  return PP_FromBool(dispatcher->Send(
+      new PpapiMsg_PPPContentDecryptor_GenerateKeyRequest(
+          API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
+          instance,
+          SerializedVarSendInput(dispatcher, key_system),
+          SerializedVarSendInput(dispatcher, init_data))));
+}
+
+PP_Bool AddKey(PP_Instance instance,
+               PP_Var session_id,
+               PP_Var key) {
+  HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
+  if (!dispatcher) {
+    NOTREACHED();
+    return PP_FALSE;
+  }
+
+  return PP_FromBool(dispatcher->Send(
+      new PpapiMsg_PPPContentDecryptor_AddKey(
+          API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
+          instance,
+          SerializedVarSendInput(dispatcher, session_id),
+          SerializedVarSendInput(dispatcher, key))));
+}
+
+PP_Bool CancelKeyRequest(PP_Instance instance, PP_Var session_id) {
+  HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
+  if (!dispatcher) {
+    return PP_FALSE;
+  }
+
+  return PP_FromBool(dispatcher->Send(
+      new PpapiMsg_PPPContentDecryptor_CancelKeyRequest(
+          API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
+          instance,
+          SerializedVarSendInput(dispatcher, session_id))));
+}
+
+PP_Bool Decrypt(PP_Instance instance,
+                PP_Resource encrypted_block,
+                int32_t request_id) {
+  HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
+  if (!dispatcher) {
+    NOTREACHED();
+    return PP_FALSE;
+  }
+
+  HostResource host_resource;
+  host_resource.SetHostResource(instance, encrypted_block);
+
+  return PP_FromBool(dispatcher->Send(
+      new PpapiMsg_PPPContentDecryptor_Decrypt(
+          API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
+          instance,
+          host_resource,
+          request_id)));
+}
+
+PP_Bool DecryptAndDecode(PP_Instance instance,
+                         PP_Resource encrypted_block,
+                         int32_t request_id) {
+  HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
+  if (!dispatcher) {
+    NOTREACHED();
+    return PP_FALSE;
+  }
+
+  HostResource host_resource;
+  host_resource.SetHostResource(instance, encrypted_block);
+
+  return PP_FromBool(dispatcher->Send(
+      new PpapiMsg_PPPContentDecryptor_DecryptAndDecode(
+          API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
+          instance,
+          host_resource,
+          request_id)));
+}
+
+static const PPP_ContentDecryptor_Private content_decryptor_interface = {
+  &GenerateKeyRequest,
+  &AddKey,
+  &CancelKeyRequest,
+  &Decrypt,
+  &DecryptAndDecode
+};
+
+InterfaceProxy* CreateContentDecryptorPPPProxy(Dispatcher* dispatcher) {
+  return new PPP_ContentDecryptor_Private_Proxy(dispatcher);
+}
+
+}  // namespace
+
+PPP_ContentDecryptor_Private_Proxy::PPP_ContentDecryptor_Private_Proxy(
+    Dispatcher* dispatcher)
+    : InterfaceProxy(dispatcher),
+      ppp_decryptor_impl_(NULL) {
+  if (dispatcher->IsPlugin()) {
+    ppp_decryptor_impl_ = static_cast<const PPP_ContentDecryptor_Private*>(
+        dispatcher->local_get_interface()(
+            PPP_CONTENTDECRYPTOR_PRIVATE_INTERFACE));
+  }
+}
+
+PPP_ContentDecryptor_Private_Proxy::~PPP_ContentDecryptor_Private_Proxy() {
+}
+
+// static
+const PPP_ContentDecryptor_Private*
+    PPP_ContentDecryptor_Private_Proxy::GetProxyInterface() {
+  return &content_decryptor_interface;
+}
+
+bool PPP_ContentDecryptor_Private_Proxy::OnMessageReceived(
+    const IPC::Message& msg) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(PPP_ContentDecryptor_Private_Proxy, msg)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_GenerateKeyRequest,
+                        OnMsgGenerateKeyRequest)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_AddKey,
+                        OnMsgAddKey)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_CancelKeyRequest,
+                        OnMsgCancelKeyRequest)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_Decrypt,
+                        OnMsgDecrypt)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_DecryptAndDecode,
+                        OnMsgDecryptAndDecode)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  DCHECK(handled);
+  return handled;
+}
+
+void PPP_ContentDecryptor_Private_Proxy::OnMsgGenerateKeyRequest(
+    PP_Instance instance,
+    SerializedVarReceiveInput key_system,
+    SerializedVarReceiveInput init_data) {

[dmichael (off chromium), 2012/08/15 19:01:00]

I think you might need to AddRef your key_system and init_data vars.
SerializedVarReceiveInput decrements the ref-count upon exiting this function,
but the way your C++ wrapper is written, it looks like the CDM expects to
receive a Var with ref-count of 1.

[dmichael (off chromium), 2012/08/16 17:02:28]

ping? See PPP_Messaging_Proxy for an example. As-is, you might not be getting
any obvious side effects if you only use the var within the scope of
GenerateKeyRequest. But if the CDM tries to AddRef the Var and keep it around
after returning from GenerateKeyRequest, it will probably disappear out from
under it. Comment applies all places where you use SerializedVarReceiveInput in
the PPP proxy.

[Tom Finegan, 2012/08/16 18:10:58]

Done.

+  if (ppp_decryptor_impl_) {
+    CallWhileUnlocked(ppp_decryptor_impl_->GenerateKeyRequest,
+                      instance,
+                      key_system.Get(dispatcher()),
+                      init_data.Get(dispatcher()));
+  }
+}
+
+void PPP_ContentDecryptor_Private_Proxy::OnMsgAddKey(
+    PP_Instance instance,
+    SerializedVarReceiveInput session_id,
+    SerializedVarReceiveInput key) {
+  if (ppp_decryptor_impl_) {
+    CallWhileUnlocked(ppp_decryptor_impl_->AddKey,
+                      instance,
+                      session_id.Get(dispatcher()),
+                      key.Get(dispatcher()));
+  }
+}
+
+void PPP_ContentDecryptor_Private_Proxy::OnMsgCancelKeyRequest(
+    PP_Instance instance,
+    SerializedVarReceiveInput session_id) {
+  if (ppp_decryptor_impl_) {
+    CallWhileUnlocked(CancelKeyRequest,
+                      instance,
+                      session_id.Get(dispatcher()));
+  }
+}
+
+void PPP_ContentDecryptor_Private_Proxy::OnMsgDecrypt(
+    PP_Instance instance,
+    const HostResource& encrypted_block,
+    int32_t request_id) {
+  if (ppp_decryptor_impl_) {
+    PP_Resource plugin_resource =
+        PluginGlobals::Get()->plugin_resource_tracker()->
+            PluginResourceForHostResource(encrypted_block);
+    CallWhileUnlocked(ppp_decryptor_impl_->Decrypt,
+                      instance,
+                      plugin_resource,
+                      request_id);
+  }
+}
+
+void PPP_ContentDecryptor_Private_Proxy::OnMsgDecryptAndDecode(
+    PP_Instance instance,
+    const HostResource& encrypted_block,
+    int32_t request_id) {
+  if (ppp_decryptor_impl_) {
+    PP_Resource plugin_resource =
+        PluginGlobals::Get()->plugin_resource_tracker()->
+            PluginResourceForHostResource(encrypted_block);
+    CallWhileUnlocked(ppp_decryptor_impl_->DecryptAndDecode,
+                      instance,
+                      plugin_resource,
+                      request_id);
+  }
+}
+
+}  // namespace proxy
+}  // namespace ppapi