Home | History | Annotate | Download | only in proxy 
      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/dev/ppb_testing_dev.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 const PPB_Testing_Dev testing_interface = {
    131   &ReadImageData,
    132   &RunMessageLoop,
    133   &QuitMessageLoop,
    134   &GetLiveObjectsForInstance,
    135   &IsOutOfProcess,
    136   &SimulateInputEvent,
    137   &GetDocumentURL,
    138   &GetLiveVars,
    139   &SetMinimumArrayBufferSizeForShmem
    140 };
    141 
    142 InterfaceProxy* CreateTestingProxy(Dispatcher* dispatcher) {
    143   return new PPB_Testing_Proxy(dispatcher);
    144 }
    145 
    146 }  // namespace
    147 
    148 PPB_Testing_Proxy::PPB_Testing_Proxy(Dispatcher* dispatcher)
    149     : InterfaceProxy(dispatcher),
    150       ppb_testing_impl_(NULL) {
    151   if (!dispatcher->IsPlugin()) {
    152     ppb_testing_impl_ = static_cast<const PPB_Testing_Dev*>(
    153         dispatcher->local_get_interface()(PPB_TESTING_DEV_INTERFACE));
    154   }
    155 }
    156 
    157 PPB_Testing_Proxy::~PPB_Testing_Proxy() {
    158 }
    159 
    160 // static
    161 const InterfaceProxy::Info* PPB_Testing_Proxy::GetInfo() {
    162   static const Info info = {
    163     &testing_interface,
    164     PPB_TESTING_DEV_INTERFACE,
    165     API_ID_PPB_TESTING,
    166     false,
    167     &CreateTestingProxy,
    168   };
    169   return &info;
    170 }
    171 
    172 bool PPB_Testing_Proxy::OnMessageReceived(const IPC::Message& msg) {
    173   if (!dispatcher()->permissions().HasPermission(PERMISSION_TESTING))
    174     return false;
    175 
    176   bool handled = true;
    177   IPC_BEGIN_MESSAGE_MAP(PPB_Testing_Proxy, msg)
    178     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBTesting_ReadImageData,
    179                         OnMsgReadImageData)
    180     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBTesting_GetLiveObjectsForInstance,
    181                         OnMsgGetLiveObjectsForInstance)
    182     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBTesting_SimulateInputEvent,
    183                         OnMsgSimulateInputEvent)
    184     IPC_MESSAGE_HANDLER(
    185         PpapiHostMsg_PPBTesting_SetMinimumArrayBufferSizeForShmem,
    186         OnMsgSetMinimumArrayBufferSizeForShmem)
    187     IPC_MESSAGE_UNHANDLED(handled = false)
    188   IPC_END_MESSAGE_MAP()
    189   return handled;
    190 }
    191 
    192 void PPB_Testing_Proxy::OnMsgReadImageData(
    193     const HostResource& device_context_2d,
    194     const HostResource& image,
    195     const PP_Point& top_left,
    196     PP_Bool* result) {
    197   *result = ppb_testing_impl_->ReadImageData(
    198       device_context_2d.host_resource(), image.host_resource(), &top_left);
    199 }
    200 
    201 void PPB_Testing_Proxy::OnMsgRunMessageLoop(PP_Instance instance) {
    202   ppb_testing_impl_->RunMessageLoop(instance);
    203 }
    204 
    205 void PPB_Testing_Proxy::OnMsgQuitMessageLoop(PP_Instance instance) {
    206   ppb_testing_impl_->QuitMessageLoop(instance);
    207 }
    208 
    209 void PPB_Testing_Proxy::OnMsgGetLiveObjectsForInstance(PP_Instance instance,
    210                                                        uint32_t* result) {
    211   *result = ppb_testing_impl_->GetLiveObjectsForInstance(instance);
    212 }
    213 
    214 void PPB_Testing_Proxy::OnMsgSimulateInputEvent(
    215     PP_Instance instance,
    216     const InputEventData& input_event) {
    217   scoped_refptr<PPB_InputEvent_Shared> input_event_impl(
    218       new PPB_InputEvent_Shared(OBJECT_IS_PROXY, instance, input_event));
    219   ppb_testing_impl_->SimulateInputEvent(instance,
    220                                         input_event_impl->pp_resource());
    221 }
    222 
    223 void PPB_Testing_Proxy::OnMsgSetMinimumArrayBufferSizeForShmem(
    224     uint32_t threshold) {
    225   RawVarDataGraph::SetMinimumArrayBufferSizeForShmemForTest(threshold);
    226 }
    227 
    228 }  // namespace proxy
    229 }  // namespace ppapi
    230