Add PPAPI decryptor implementation.

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"
@@ skipping 118 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetCursor,
                         OnHostMsgSetCursor)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetTextInputType,
                         OnHostMsgSetTextInputType)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UpdateCaretPosition,
                         OnHostMsgUpdateCaretPosition)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_CancelCompositionText,
                         OnHostMsgCancelCompositionText)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UpdateSurroundingText,
                         OnHostMsgUpdateSurroundingText)
+
 #if !defined(OS_NACL)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ResolveRelativeToDocument,
                         OnHostMsgResolveRelativeToDocument)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanRequest,
                         OnHostMsgDocumentCanRequest)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanAccessDocument,
                         OnHostMsgDocumentCanAccessDocument)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetDocumentURL,
                         OnHostMsgGetDocumentURL)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetPluginInstanceURL,
                         OnHostMsgGetPluginInstanceURL)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_NeedKey,
+                        OnHostMsgNeedKey)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_KeyAdded,
+                        OnHostMsgKeyAdded)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_KeyMessage,
+                        OnHostMsgKeyMessage)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_KeyError,
+                        OnHostMsgKeyError)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DeliverBlock,
+                        OnHostMsgDeliverBlock)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DeliverFrame,
+                        OnHostMsgDeliverFrame)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DeliverSamples,
+                        OnHostMsgDeliverSamples)
 #endif  // !defined(OS_NACL)
 
     // Host -> Plugin messages.
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBInstance_MouseLockComplete,
                         OnPluginMsgMouseLockComplete)
 
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
@@ skipping 230 matching lines @@
 PP_Var PPB_Instance_Proxy::GetPluginInstanceURL(
       PP_Instance instance,
       PP_URLComponents_Dev* components) {
   ReceiveSerializedVarReturnValue result;
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_GetPluginInstanceURL(
       API_ID_PPB_INSTANCE, instance, &result));
   return PPB_URLUtil_Shared::ConvertComponentsAndReturnURL(
       result.Return(dispatcher()),
       components);
 }
+
+void PPB_Instance_Proxy::NeedKey(PP_Instance instance,
+                                 PP_Var key_system,
+                                 PP_Var session_id,
+                                 PP_Var init_data) {
+  dispatcher()->Send(
+      new PpapiHostMsg_PPBInstance_NeedKey(
+          API_ID_PPB_INSTANCE,
+          instance,
+          SerializedVarSendInput(dispatcher(), key_system),
+          SerializedVarSendInput(dispatcher(), session_id),
+          SerializedVarSendInput(dispatcher(), init_data)));
+}
+
+void PPB_Instance_Proxy::KeyAdded(PP_Instance instance,
+                                  PP_Var key_system,
+                                  PP_Var session_id) {
+  dispatcher()->Send(
+      new PpapiHostMsg_PPBInstance_KeyAdded(
+          API_ID_PPB_INSTANCE,
+          instance,
+          SerializedVarSendInput(dispatcher(), key_system),
+          SerializedVarSendInput(dispatcher(), session_id)));
+}
+
+void PPB_Instance_Proxy::KeyMessage(PP_Instance instance,
+                                    PP_Var key_system,
+                                    PP_Var session_id,
+                                    PP_Resource message,
+                                    PP_Var default_url) {
+  Resource* object =
+      PpapiGlobals::Get()->GetResourceTracker()->GetResource(message);
+  if (!object || object->pp_instance() != instance)
+    return;
+  dispatcher()->Send(
+      new PpapiHostMsg_PPBInstance_KeyMessage(
+          API_ID_PPB_INSTANCE,
+          instance,
+          SerializedVarSendInput(dispatcher(), key_system),
+          SerializedVarSendInput(dispatcher(), session_id),
+          object->host_resource().host_resource(),
+          SerializedVarSendInput(dispatcher(), default_url)));
+}
+
+void PPB_Instance_Proxy::KeyError(PP_Instance instance,
+                                  PP_Var key_system,
+                                  PP_Var session_id,
+                                  int32_t media_error,
+                                  int32_t system_code) {
+  dispatcher()->Send(
+      new PpapiHostMsg_PPBInstance_KeyError(
+          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) {
+  Resource* object =
+      PpapiGlobals::Get()->GetResourceTracker()->GetResource(decrypted_block);
+  if (!object || object->pp_instance() != instance)
+    return;
+  dispatcher()->Send(
+      new PpapiHostMsg_PPBInstance_DeliverBlock(API_ID_PPB_INSTANCE,
+          instance,
+          object->host_resource().host_resource(),
+          request_id));
+}
+
+void PPB_Instance_Proxy::DeliverFrame(PP_Instance instance,
+                                      PP_Resource decrypted_frame,
+                                      int32_t request_id) {
+  Resource* object =
+      PpapiGlobals::Get()->GetResourceTracker()->GetResource(decrypted_frame);
+  if (!object || object->pp_instance() != instance)
+    return;
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_DeliverFrame(
+          API_ID_PPB_INSTANCE,
+          instance,
+          object->host_resource().host_resource(),
+          request_id));
+}
+
+void PPB_Instance_Proxy::DeliverSamples(PP_Instance instance,
+                                        PP_Resource decrypted_samples,
+                                        int32_t request_id) {
+  Resource* object =
+      PpapiGlobals::Get()->GetResourceTracker()->GetResource(decrypted_samples);
+  if (!object || object->pp_instance() != instance)
+    return;
+  dispatcher()->Send(
+      new PpapiHostMsg_PPBInstance_DeliverSamples(
+          API_ID_PPB_INSTANCE,
+          instance,
+          object->host_resource().host_resource(),
+          request_id));
+}
+
 #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)));
 }
 
 PP_Bool PPB_Instance_Proxy::SetCursor(PP_Instance instance,
@@ skipping 313 matching lines @@
 
 void PPB_Instance_Proxy::OnHostMsgGetPluginInstanceURL(
     PP_Instance instance,
     SerializedVarReturnValue result) {
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->GetPluginInstanceURL(instance, NULL));
   }
 }
+
+void PPB_Instance_Proxy::OnHostMsgNeedKey(PP_Instance instance,
+                                          SerializedVarReceiveInput key_system,
+                                          SerializedVarReceiveInput session_id,
+                                          SerializedVarReceiveInput init_data) {
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded()) {
+    enter.functions()->NeedKey(instance,
+                               key_system.Get(dispatcher()),
+                               session_id.Get(dispatcher()),
+                               init_data.Get(dispatcher()));
+  }
+}
+
+void PPB_Instance_Proxy::OnHostMsgKeyAdded(
+    PP_Instance instance,
+    SerializedVarReceiveInput key_system,
+    SerializedVarReceiveInput session_id) {
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded()) {
+    enter.functions()->KeyAdded(instance,
+                                key_system.Get(dispatcher()),
+                                session_id.Get(dispatcher()));
+  }
+}
+
+void PPB_Instance_Proxy::OnHostMsgKeyMessage(
+    PP_Instance instance,
+    SerializedVarReceiveInput key_system,
+    SerializedVarReceiveInput session_id,
+    PP_Resource message,
+    SerializedVarReceiveInput default_url) {
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded()) {
+    enter.functions()->KeyMessage(instance,
+                                  key_system.Get(dispatcher()),
+                                  session_id.Get(dispatcher()),
+                                  message,
+                                  default_url.Get(dispatcher()));
+  }
+}
+
+void PPB_Instance_Proxy::OnHostMsgKeyError(
+    PP_Instance instance,
+    SerializedVarReceiveInput key_system,
+    SerializedVarReceiveInput session_id,
+    int32_t media_error,
+    int32_t system_error) {
+  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) {
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded())
+    enter.functions()->DeliverBlock(instance, decrypted_block, request_id);
+}
+
+void PPB_Instance_Proxy::OnHostMsgDeliverFrame(PP_Instance instance,
+                                               PP_Resource decrypted_frame,
+                                               int32_t request_id) {
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded())
+    enter.functions()->DeliverFrame(instance, decrypted_frame, request_id);
+}
+
+void PPB_Instance_Proxy::OnHostMsgDeliverSamples(PP_Instance instance,
+                                                 PP_Resource decrypted_samples,
+                                                 int32_t request_id) {
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded())
+    enter.functions()->DeliverSamples(instance, decrypted_samples, request_id);
+}
+
 #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);
   if (enter.succeeded()) {
     enter.functions()->SetCursor(
@@ skipping 51 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