Modify the PPAPI CDM interface to pass more info.

ppapi/proxy/ppb_instance_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/ppb_instance_proxy.h"
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_time.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_audio_config.h"
 #include "ppapi/c/ppb_instance.h"
 #include "ppapi/c/ppb_messaging.h"
 #include "ppapi/c/ppb_mouse_lock.h"
+#include "ppapi/c/private/pp_content_decryptor.h"
+#include "ppapi/proxy/content_decryptor_private_serializer-inl.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_proxy_delegate.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_flash_proxy.h"
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/ppb_url_util_shared.h"
 #include "ppapi/shared_impl/ppb_view_shared.h"
@@ skipping 442 matching lines @@
           API_ID_PPB_INSTANCE,
           instance,
           SerializedVarSendInput(dispatcher(), key_system),
           SerializedVarSendInput(dispatcher(), session_id),
           media_error,
           system_code));
 }
 
 void PPB_Instance_Proxy::DeliverBlock(PP_Instance instance,
                                       PP_Resource decrypted_block,
-                                      int32_t request_id) {
+                                      const PP_DecryptedBlockInfo* block_info) {
   Resource* object =
       PpapiGlobals::Get()->GetResourceTracker()->GetResource(decrypted_block);
   if (!object || object->pp_instance() != instance)
     return;
+
+  std::string serialized_block_info;
+  if (!SerializeBlockInfo(block_info, &serialized_block_info))
+    return;
+
   dispatcher()->Send(
       new PpapiHostMsg_PPBInstance_DeliverBlock(API_ID_PPB_INSTANCE,
           instance,
           object->host_resource().host_resource(),
-          request_id));
+          serialized_block_info));
 }
 
 void PPB_Instance_Proxy::DeliverFrame(PP_Instance instance,
                                       PP_Resource decrypted_frame,
-                                      int32_t request_id) {
+                                      const PP_DecryptedBlockInfo* block_info) {
   Resource* object =
       PpapiGlobals::Get()->GetResourceTracker()->GetResource(decrypted_frame);
   if (!object || object->pp_instance() != instance)
     return;
+
+  std::string serialized_block_info;
+  if (!SerializeBlockInfo(block_info, &serialized_block_info))
+    return;
+
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_DeliverFrame(
           API_ID_PPB_INSTANCE,
           instance,
           object->host_resource().host_resource(),
-          request_id));
+          serialized_block_info));
 }
 
-void PPB_Instance_Proxy::DeliverSamples(PP_Instance instance,
-                                        PP_Resource decrypted_samples,
-                                        int32_t request_id) {
+void PPB_Instance_Proxy::DeliverSamples(
+    PP_Instance instance,
+    PP_Resource decrypted_samples,
+    const PP_DecryptedBlockInfo* block_info) {
   Resource* object =
       PpapiGlobals::Get()->GetResourceTracker()->GetResource(decrypted_samples);
   if (!object || object->pp_instance() != instance)
     return;
+
+  std::string serialized_block_info;
+  if (!SerializeBlockInfo(block_info, &serialized_block_info))
+      return;
+
   dispatcher()->Send(
       new PpapiHostMsg_PPBInstance_DeliverSamples(
           API_ID_PPB_INSTANCE,
           instance,
           object->host_resource().host_resource(),
-          request_id));
+          serialized_block_info));
 }
 
 #endif  // !defined(OS_NACL)
 
 void PPB_Instance_Proxy::PostMessage(PP_Instance instance,
                                      PP_Var message) {
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_PostMessage(
       API_ID_PPB_INSTANCE,
       instance, SerializedVarSendInput(dispatcher(), message)));
 }
@@ skipping 373 matching lines @@
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     enter.functions()->KeyError(instance,
                                 key_system.Get(dispatcher()),
                                 session_id.Get(dispatcher()),
                                 media_error,
                                 system_error);
   }
 }
 
-void PPB_Instance_Proxy::OnHostMsgDeliverBlock(PP_Instance instance,
-                                               PP_Resource decrypted_block,
-                                               int32_t request_id) {
+void PPB_Instance_Proxy::OnHostMsgDeliverBlock(
+    PP_Instance instance,
+    PP_Resource decrypted_block,
+    const std::string& serialized_block_info) {
+  PP_DecryptedBlockInfo block_info;
+  if (!DeserializeBlockInfo(serialized_block_info, &block_info))
+    return;
+
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
-    enter.functions()->DeliverBlock(instance, decrypted_block, request_id);
+    enter.functions()->DeliverBlock(instance, decrypted_block, &block_info);
 }
 
-void PPB_Instance_Proxy::OnHostMsgDeliverFrame(PP_Instance instance,
-                                               PP_Resource decrypted_frame,
-                                               int32_t request_id) {
+void PPB_Instance_Proxy::OnHostMsgDeliverFrame(
+    PP_Instance instance,
+    PP_Resource decrypted_frame,
+    const std::string& serialized_block_info) {
+  PP_DecryptedBlockInfo block_info;
+  if (!DeserializeBlockInfo(serialized_block_info, &block_info))
+    return;
+
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
-    enter.functions()->DeliverFrame(instance, decrypted_frame, request_id);
+    enter.functions()->DeliverFrame(instance, decrypted_frame, &block_info);
 }
 
-void PPB_Instance_Proxy::OnHostMsgDeliverSamples(PP_Instance instance,
-                                                 PP_Resource decrypted_samples,
-                                                 int32_t request_id) {
+void PPB_Instance_Proxy::OnHostMsgDeliverSamples(
+    PP_Instance instance,
+    PP_Resource decrypted_samples,
+    const std::string& serialized_block_info) {
+  PP_DecryptedBlockInfo block_info;
+  if (!DeserializeBlockInfo(serialized_block_info, &block_info))
+    return;
+
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
-    enter.functions()->DeliverSamples(instance, decrypted_samples, request_id);
+    enter.functions()->DeliverSamples(instance, decrypted_samples, &block_info);
 }
 
 #endif  // !defined(OS_NACL)
 
 void  PPB_Instance_Proxy::OnHostMsgSetCursor(
     PP_Instance instance,
     int32_t type,
     const ppapi::HostResource& custom_image,
     const PP_Point& hot_spot) {
   EnterInstanceNoLock enter(instance);
@@ skipping 53 matching lines @@
 }
 
 void PPB_Instance_Proxy::MouseLockCompleteInHost(int32_t result,
                                                  PP_Instance instance) {
   dispatcher()->Send(new PpapiMsg_PPBInstance_MouseLockComplete(
       API_ID_PPB_INSTANCE, instance, result));
 }
 
 }  // namespace proxy
 }  // namespace ppapi