Modify the PPAPI CDM interface to pass more info.

ppapi/proxy/ppp_content_decryptor_private_proxy.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 "ppapi/proxy/ppp_content_decryptor_private_proxy.h"
 
 #include "base/platform_file.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/ppb_core.h"
+#include "ppapi/proxy/content_decryptor_private_serializer.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/ppb_buffer_proxy.h"
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_buffer_api.h"
 #include "ppapi/thunk/ppb_buffer_trusted_api.h"
@@ skipping 66 matching lines @@
   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) {
+               PP_Var key,
+               PP_Var init_data) {
   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))));
+          SerializedVarSendInput(dispatcher, key),
+          SerializedVarSendInput(dispatcher, init_data))));
 }
 
 PP_Bool CancelKeyRequest(PP_Instance instance, PP_Var session_id) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     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) {
+                const PP_EncryptedBlockInfo* encrypted_block_info) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return PP_FALSE;
   }
   const PPB_Core* core = static_cast<const PPB_Core*>(
       dispatcher->local_get_interface()(PPB_CORE_INTERFACE));
   if (!core) {
     NOTREACHED();
     return PP_FALSE;
@@ skipping 15 matching lines @@
   if (ShareHostBufferResourceToPlugin(dispatcher,
                                       encrypted_block,
                                       &handle) == PP_FALSE)
     return PP_FALSE;
 
   PPPDecryptor_Buffer buffer;
   buffer.resource = host_resource;
   buffer.handle = handle;
   buffer.size = size;
 
+  std::string serialized_block_info;
+  if (!SerializeBlockInfo(*encrypted_block_info, &serialized_block_info))
+    return PP_FALSE;
+
   return PP_FromBool(dispatcher->Send(
       new PpapiMsg_PPPContentDecryptor_Decrypt(
           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
           instance,
           buffer,
-          request_id)));
+          serialized_block_info)));
 }
 
 PP_Bool DecryptAndDecode(PP_Instance instance,
                          PP_Resource encrypted_block,
-                         int32_t request_id) {
+                         const PP_EncryptedBlockInfo* encrypted_block_info) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return PP_FALSE;
   }
 
   HostResource host_resource;
   host_resource.SetHostResource(instance, encrypted_block);
 
+  uint32_t size = 0;
+  if (DescribeHostBufferResource(encrypted_block, &size) == PP_FALSE)
+    return PP_FALSE;
+
+  base::SharedMemoryHandle handle;
+  if (ShareHostBufferResourceToPlugin(dispatcher,
+                                      encrypted_block,
+                                      &handle) == PP_FALSE)
+    return PP_FALSE;
+
+  PPPDecryptor_Buffer buffer;
+  buffer.resource = host_resource;
+  buffer.handle = handle;
+  buffer.size = size;
+
+  std::string serialized_block_info;
+  if (!SerializeBlockInfo(*encrypted_block_info, &serialized_block_info))
+    return PP_FALSE;
+
   return PP_FromBool(dispatcher->Send(
       new PpapiMsg_PPPContentDecryptor_DecryptAndDecode(
           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
           instance,
-          host_resource,
-          request_id)));
+          buffer,
+          serialized_block_info)));
 }
 
 static const PPP_ContentDecryptor_Private content_decryptor_interface = {
   &GenerateKeyRequest,
   &AddKey,
   &CancelKeyRequest,
   &Decrypt,
   &DecryptAndDecode
 };
 
@@ skipping 51 matching lines @@
     CallWhileUnlocked(ppp_decryptor_impl_->GenerateKeyRequest,
                       instance,
                       ExtractReceivedVarAndAddRef(dispatcher(), &key_system),
                       ExtractReceivedVarAndAddRef(dispatcher(), &init_data));
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgAddKey(
     PP_Instance instance,
     SerializedVarReceiveInput session_id,
-    SerializedVarReceiveInput key) {
+    SerializedVarReceiveInput key,
+    SerializedVarReceiveInput init_data) {
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(ppp_decryptor_impl_->AddKey,
                       instance,
                       ExtractReceivedVarAndAddRef(dispatcher(), &session_id),
-                      ExtractReceivedVarAndAddRef(dispatcher(), &key));
+                      ExtractReceivedVarAndAddRef(dispatcher(), &key),
+                      ExtractReceivedVarAndAddRef(dispatcher(), &init_data));
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgCancelKeyRequest(
     PP_Instance instance,
     SerializedVarReceiveInput session_id) {
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(ppp_decryptor_impl_->CancelKeyRequest,
                       instance,
                       ExtractReceivedVarAndAddRef(dispatcher(), &session_id));
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgDecrypt(
     PP_Instance instance,
     const PPPDecryptor_Buffer& encrypted_buffer,
-    int32_t request_id) {
+    const std::string& serialized_block_info) {
   if (ppp_decryptor_impl_) {
     PP_Resource plugin_resource =
         PPB_Buffer_Proxy::AddProxyResource(encrypted_buffer.resource,
                                            encrypted_buffer.handle,
                                            encrypted_buffer.size);
+    PP_EncryptedBlockInfo block_info;
+    if (!DeserializeBlockInfo(serialized_block_info, &block_info))
+      return;
     CallWhileUnlocked(ppp_decryptor_impl_->Decrypt,
                       instance,
                       plugin_resource,
-                      request_id);
+                      const_cast<const PP_EncryptedBlockInfo*>(&block_info));
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgDecryptAndDecode(
     PP_Instance instance,
-    const HostResource& encrypted_block,
-    int32_t request_id) {
+    const PPPDecryptor_Buffer& encrypted_buffer,
+    const std::string& serialized_block_info) {
   if (ppp_decryptor_impl_) {
     PP_Resource plugin_resource =
-        PluginGlobals::Get()->plugin_resource_tracker()->
-            PluginResourceForHostResource(encrypted_block);
+        PPB_Buffer_Proxy::AddProxyResource(encrypted_buffer.resource,
+                                           encrypted_buffer.handle,
+                                           encrypted_buffer.size);
+    PP_EncryptedBlockInfo block_info;
+    if (!DeserializeBlockInfo(serialized_block_info, &block_info))
+      return;
     CallWhileUnlocked(ppp_decryptor_impl_->DecryptAndDecode,
                       instance,
                       plugin_resource,
-                      request_id);
+                      const_cast<const PP_EncryptedBlockInfo*>(&block_info));
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi