Add PPAPI decryptor interfaces.

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)
+    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)
+
 #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,
@@ skipping 374 matching lines @@
 void PPB_Instance_Proxy::OnHostMsgGetOwnerElementObject(
     PP_Instance instance,
     SerializedVarReturnValue result) {
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->GetOwnerElementObject(instance));
   }
 }
 
+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(),
+          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_error) {
+  dispatcher()->Send(
+      new PpapiHostMsg_PPBInstance_KeyError(
+          API_ID_PPB_INSTANCE,
+          instance,
+          SerializedVarSendInput(dispatcher(), key_system),
+          SerializedVarSendInput(dispatcher(), session_id),
+          media_error,
+          system_error));
+}
+
+void PPB_Instance_Proxy::DeliverBlock(PP_Instance instance,
+                                      PP_Resource decrypted_block,
+                                      uint64_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(),
+                                                request_id));
+}
+
+void PPB_Instance_Proxy::DeliverFrame(PP_Instance instance,
+                                      PP_Resource decrypted_frame,
+                                      uint64_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(),
+                                                request_id));
+}
+
+void PPB_Instance_Proxy::DeliverSamples(PP_Instance instance,
+                                        PP_Resource decrypted_samples,
+                                        uint64_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(),
+                                                  request_id));
+}
+
+
 void PPB_Instance_Proxy::OnHostMsgBindGraphics(PP_Instance instance,
                                                const HostResource& device,
                                                PP_Bool* result) {
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     *result = enter.functions()->BindGraphics(instance,
                                               device.host_resource());
   }
 }
 
@@ skipping 229 matching lines @@
     const std::string& text,
     uint32_t caret,
     uint32_t anchor) {
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     enter.functions()->UpdateSurroundingText(instance, text.c_str(), caret,
                                              anchor);
   }
 }
 
+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,
+    const ppapi::HostResource& message,
+    SerializedVarReceiveInput default_url) {
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded()) {
+    enter.functions()->KeyMessage(instance,
+                                  key_system.Get(dispatcher()),
+                                  session_id.Get(dispatcher()),
+                                  message.host_resource(),
+                                  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,
+    const ppapi::HostResource& decrypted_block,
+    uint64_t request_id) {
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded()) {
+    enter.functions()->DeliverBlock(instance,
+                                    decrypted_block.host_resource(),
+                                    request_id);
+  }
+}
+
+void PPB_Instance_Proxy::OnHostMsgDeliverFrame(
+    PP_Instance instance,
+    const ppapi::HostResource& decrypted_frame,
+    uint64_t request_id) {
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded()) {
+    enter.functions()->DeliverFrame(instance,
+                                    decrypted_frame.host_resource(),
+                                    request_id);
+  }
+}
+
+void PPB_Instance_Proxy::OnHostMsgDeliverSamples(
+    PP_Instance instance,
+    const ppapi::HostResource& decrypted_samples,
+    uint64_t request_id) {
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded()) {
+    enter.functions()->DeliverSamples(instance,
+                                      decrypted_samples.host_resource(),
+                                      request_id);
+  }
+}
+
 void PPB_Instance_Proxy::OnPluginMsgMouseLockComplete(PP_Instance instance,
                                                       int32_t result) {
   // Save the mouse callback on the instance data.
   InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
       GetInstanceData(instance);
   if (!data)
     return;  // Instance was probably deleted.
   if (!TrackedCallback::IsPending(data->mouse_lock_callback)) {
     NOTREACHED();
     return;
   }
   TrackedCallback::ClearAndRun(&(data->mouse_lock_callback), result);
 }
 
 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