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