ppapi/proxy/ppb_testing_proxy.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/proxy/ppb_testing_proxy.h"
   6
   7 #include "base/message_loop/message_loop.h"
   8 #include "ppapi/c/private/ppb_testing_private.h"
   9 #include "ppapi/proxy/enter_proxy.h"
  10 #include "ppapi/proxy/plugin_dispatcher.h"
  11 #include "ppapi/proxy/ppapi_messages.h"
  12 #include "ppapi/shared_impl/ppapi_globals.h"
  13 #include "ppapi/shared_impl/proxy_lock.h"
  14 #include "ppapi/shared_impl/resource.h"
  15 #include "ppapi/shared_impl/resource_tracker.h"
  16 #include "ppapi/thunk/enter.h"
  17 #include "ppapi/thunk/ppb_graphics_2d_api.h"
  18 #include "ppapi/thunk/ppb_input_event_api.h"
  19
  20 using ppapi::thunk::EnterInstance;
  21 using ppapi::thunk::EnterResource;
  22 using ppapi::thunk::EnterResourceNoLock;
  23 using ppapi::thunk::PPB_Graphics2D_API;
  24 using ppapi::thunk::PPB_InputEvent_API;
  25
  26 namespace ppapi {
  27 namespace proxy {
  28
  29 namespace {
  30
  31 PP_Bool ReadImageData(PP_Resource graphics_2d,
  32                       PP_Resource image,
  33                       const PP_Point* top_left) {
  34   ProxyAutoLock lock;
  35   Resource* image_object =
  36       PpapiGlobals::Get()->GetResourceTracker()->GetResource(image);
  37   if (!image_object)
  38     return PP_FALSE;
  39   Resource* graphics_2d_object =
  40       PpapiGlobals::Get()->GetResourceTracker()->GetResource(graphics_2d);
  41   if (!graphics_2d_object ||
  42       image_object->pp_instance() != graphics_2d_object->pp_instance())
  43     return PP_FALSE;
  44
  45   EnterResourceNoLock<PPB_Graphics2D_API> enter(graphics_2d, true);
  46   if (enter.failed())
  47     return PP_FALSE;
  48   const HostResource& host_image = image_object->host_resource();
  49   return enter.object()->ReadImageData(host_image.host_resource(), top_left) ?
  50       PP_TRUE : PP_FALSE;
  51 }
  52
  53 void RunMessageLoop(PP_Instance instance) {
  54   base::MessageLoop::ScopedNestableTaskAllower allow(
  55       base::MessageLoop::current());
  56   CHECK(PpapiGlobals::Get()->GetMainThreadMessageLoop()->
  57       BelongsToCurrentThread());
  58   base::MessageLoop::current()->Run();
  59 }
  60
  61 void QuitMessageLoop(PP_Instance instance) {
  62   CHECK(PpapiGlobals::Get()->GetMainThreadMessageLoop()->
  63             BelongsToCurrentThread());
  64   base::MessageLoop::current()->QuitNow();
  65 }
  66
  67 uint32_t GetLiveObjectsForInstance(PP_Instance instance_id) {
  68   ProxyAutoLock lock;
  69   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance_id);
  70   if (!dispatcher)
  71     return static_cast<uint32_t>(-1);
  72
  73   uint32_t result = 0;
  74   dispatcher->Send(new PpapiHostMsg_PPBTesting_GetLiveObjectsForInstance(
  75       API_ID_PPB_TESTING, instance_id, &result));
  76   return result;
  77 }
  78
  79 PP_Bool IsOutOfProcess() {
  80   return PP_TRUE;
  81 }
  82
  83 void SimulateInputEvent(PP_Instance instance_id, PP_Resource input_event) {
  84   ProxyAutoLock lock;
  85   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance_id);
  86   if (!dispatcher)
  87     return;
  88   EnterResourceNoLock<PPB_InputEvent_API> enter(input_event, false);
  89   if (enter.failed())
  90     return;
  91
  92   const InputEventData& input_event_data = enter.object()->GetInputEventData();
  93   dispatcher->Send(new PpapiHostMsg_PPBTesting_SimulateInputEvent(
  94       API_ID_PPB_TESTING, instance_id, input_event_data));
  95 }
  96
  97 PP_Var GetDocumentURL(PP_Instance instance, PP_URLComponents_Dev* components) {
  98   EnterInstance enter(instance);
  99   if (enter.failed())
 100     return PP_MakeUndefined();
 101   return enter.functions()->GetDocumentURL(instance, components);
 102 }
 103
 104 // TODO(dmichael): Ideally we could get a way to check the number of vars in the
 105 // host-side tracker when running out-of-process, to make sure the proxy does
 106 // not leak host-side vars.
 107 uint32_t GetLiveVars(PP_Var live_vars[], uint32_t array_size) {
 108   ProxyAutoLock lock;
 109   std::vector<PP_Var> vars =
 110       PpapiGlobals::Get()->GetVarTracker()->GetLiveVars();
 111   for (size_t i = 0u;
 112        i < std::min(static_cast<size_t>(array_size), vars.size());
 113        ++i)
 114     live_vars[i] = vars[i];
 115   return vars.size();
 116 }
 117
 118 void SetMinimumArrayBufferSizeForShmem(PP_Instance instance,
 119                                        uint32_t threshold) {
 120   ProxyAutoLock lock;
 121   RawVarDataGraph::SetMinimumArrayBufferSizeForShmemForTest(threshold);
 122   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
 123   if (!dispatcher)
 124     return;
 125   dispatcher->Send(
 126       new PpapiHostMsg_PPBTesting_SetMinimumArrayBufferSizeForShmem(
 127           API_ID_PPB_TESTING, threshold));
 128 }
 129
 130 void RunV8GC(PP_Instance instance) {
 131   // TODO(raymes): Implement this if we need it.
 132   NOTIMPLEMENTED();
 133 }
 134
 135 const PPB_Testing_Private testing_interface = {
 136   &ReadImageData,
 137   &RunMessageLoop,
 138   &QuitMessageLoop,
 139   &GetLiveObjectsForInstance,
 140   &IsOutOfProcess,
 141   &SimulateInputEvent,
 142   &GetDocumentURL,
 143   &GetLiveVars,
 144   &SetMinimumArrayBufferSizeForShmem,
 145   &RunV8GC
 146 };
 147
 148 }  // namespace
 149
 150 PPB_Testing_Proxy::PPB_Testing_Proxy(Dispatcher* dispatcher)
 151     : InterfaceProxy(dispatcher),
 152       ppb_testing_impl_(NULL) {
 153   if (!dispatcher->IsPlugin()) {
 154     ppb_testing_impl_ = static_cast<const PPB_Testing_Private*>(
 155         dispatcher->local_get_interface()(PPB_TESTING_PRIVATE_INTERFACE));
 156   }
 157 }
 158
 159 PPB_Testing_Proxy::~PPB_Testing_Proxy() {
 160 }
 161
 162 // static
 163 const PPB_Testing_Private* PPB_Testing_Proxy::GetProxyInterface() {
 164   return &testing_interface;
 165 }
 166
 167 bool PPB_Testing_Proxy::OnMessageReceived(const IPC::Message& msg) {
 168   if (!dispatcher()->permissions().HasPermission(PERMISSION_TESTING))
 169     return false;
 170
 171   bool handled = true;
 172   IPC_BEGIN_MESSAGE_MAP(PPB_Testing_Proxy, msg)
 173     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBTesting_ReadImageData,
 174                         OnMsgReadImageData)
 175     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBTesting_GetLiveObjectsForInstance,
 176                         OnMsgGetLiveObjectsForInstance)
 177     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBTesting_SimulateInputEvent,
 178                         OnMsgSimulateInputEvent)
 179     IPC_MESSAGE_HANDLER(
 180         PpapiHostMsg_PPBTesting_SetMinimumArrayBufferSizeForShmem,
 181         OnMsgSetMinimumArrayBufferSizeForShmem)
 182     IPC_MESSAGE_UNHANDLED(handled = false)
 183   IPC_END_MESSAGE_MAP()
 184   return handled;
 185 }
 186
 187 void PPB_Testing_Proxy::OnMsgReadImageData(
 188     const HostResource& device_context_2d,
 189     const HostResource& image,
 190     const PP_Point& top_left,
 191     PP_Bool* result) {
 192   *result = ppb_testing_impl_->ReadImageData(
 193       device_context_2d.host_resource(), image.host_resource(), &top_left);
 194 }
 195
 196 void PPB_Testing_Proxy::OnMsgRunMessageLoop(PP_Instance instance) {
 197   ppb_testing_impl_->RunMessageLoop(instance);
 198 }
 199
 200 void PPB_Testing_Proxy::OnMsgQuitMessageLoop(PP_Instance instance) {
 201   ppb_testing_impl_->QuitMessageLoop(instance);
 202 }
 203
 204 void PPB_Testing_Proxy::OnMsgGetLiveObjectsForInstance(PP_Instance instance,
 205                                                        uint32_t* result) {
 206   *result = ppb_testing_impl_->GetLiveObjectsForInstance(instance);
 207 }
 208
 209 void PPB_Testing_Proxy::OnMsgSimulateInputEvent(
 210     PP_Instance instance,
 211     const InputEventData& input_event) {
 212   scoped_refptr<PPB_InputEvent_Shared> input_event_impl(
 213       new PPB_InputEvent_Shared(OBJECT_IS_PROXY, instance, input_event));
 214   ppb_testing_impl_->SimulateInputEvent(instance,
 215                                         input_event_impl->pp_resource());
 216 }
 217
 218 void PPB_Testing_Proxy::OnMsgSetMinimumArrayBufferSizeForShmem(
 219     uint32_t threshold) {
 220   RawVarDataGraph::SetMinimumArrayBufferSizeForShmemForTest(threshold);
 221 }
 222
 223 }  // namespace proxy
 224 }  // namespace ppapi