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_instance_proxy.h"
6
7 #include "base/memory/ref_counted.h"
8 #include "build/build_config.h"
9 #include "ppapi/c/pp_errors.h"
10 #include "ppapi/c/pp_time.h"
11 #include "ppapi/c/pp_var.h"
12 #include "ppapi/c/ppb_audio_config.h"
13 #include "ppapi/c/ppb_instance.h"
14 #include "ppapi/c/ppb_messaging.h"
15 #include "ppapi/c/ppb_mouse_lock.h"
16 #include "ppapi/c/private/pp_content_decryptor.h"
17 #include "ppapi/proxy/broker_resource.h"
18 #include "ppapi/proxy/browser_font_singleton_resource.h"
19 #include "ppapi/proxy/content_decryptor_private_serializer.h"
20 #include "ppapi/proxy/enter_proxy.h"
21 #include "ppapi/proxy/file_mapping_resource.h"
22 #include "ppapi/proxy/flash_clipboard_resource.h"
23 #include "ppapi/proxy/flash_file_resource.h"
24 #include "ppapi/proxy/flash_fullscreen_resource.h"
25 #include "ppapi/proxy/flash_resource.h"
26 #include "ppapi/proxy/gamepad_resource.h"
27 #include "ppapi/proxy/host_dispatcher.h"
28 #include "ppapi/proxy/isolated_file_system_private_resource.h"
29 #include "ppapi/proxy/message_handler.h"
30 #include "ppapi/proxy/network_proxy_resource.h"
31 #include "ppapi/proxy/pdf_resource.h"
32 #include "ppapi/proxy/plugin_dispatcher.h"
33 #include "ppapi/proxy/ppapi_messages.h"
34 #include "ppapi/proxy/serialized_var.h"
35 #include "ppapi/proxy/truetype_font_singleton_resource.h"
36 #include "ppapi/proxy/uma_private_resource.h"
37 #include "ppapi/shared_impl/ppapi_globals.h"
38 #include "ppapi/shared_impl/ppb_url_util_shared.h"
39 #include "ppapi/shared_impl/ppb_view_shared.h"
40 #include "ppapi/shared_impl/var.h"
41 #include "ppapi/thunk/enter.h"
42 #include "ppapi/thunk/ppb_compositor_api.h"
43 #include "ppapi/thunk/ppb_graphics_2d_api.h"
44 #include "ppapi/thunk/ppb_graphics_3d_api.h"
45 #include "ppapi/thunk/thunk.h"
46
47 // Windows headers interfere with this file.
48 #ifdef PostMessage
49 #undef PostMessage
50 #endif
51
52 using ppapi::thunk::EnterInstanceNoLock;
53 using ppapi::thunk::EnterResourceNoLock;
54 using ppapi::thunk::PPB_Compositor_API;
55 using ppapi::thunk::PPB_Graphics2D_API;
56 using ppapi::thunk::PPB_Graphics3D_API;
57 using ppapi::thunk::PPB_Instance_API;
58
59 namespace ppapi {
60 namespace proxy {
61
62 namespace {
63
64 #if !defined(OS_NACL)
65 const char kSerializationError[] = "Failed to convert a PostMessage "
66 "argument from a PP_Var to a Javascript value. It may have cycles or be of "
67 "an unsupported type.";
68 #endif
69
RequestSurroundingText(PP_Instance instance)70 void RequestSurroundingText(PP_Instance instance) {
71 PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
72 if (!dispatcher)
73 return; // Instance has gone away while message was pending.
74
75 InstanceData* data = dispatcher->GetInstanceData(instance);
76 DCHECK(data); // Should have it, since we still have a dispatcher.
77 data->is_request_surrounding_text_pending = false;
78 if (!data->should_do_request_surrounding_text)
79 return;
80
81 // Just fake out a RequestSurroundingText message to the proxy for the PPP
82 // interface.
83 InterfaceProxy* proxy = dispatcher->GetInterfaceProxy(API_ID_PPP_TEXT_INPUT);
84 if (!proxy)
85 return;
86 proxy->OnMessageReceived(PpapiMsg_PPPTextInput_RequestSurroundingText(
87 API_ID_PPP_TEXT_INPUT, instance,
88 PPB_Instance_Shared::kExtraCharsForTextInput));
89 }
90
91 } // namespace
92
PPB_Instance_Proxy(Dispatcher * dispatcher)93 PPB_Instance_Proxy::PPB_Instance_Proxy(Dispatcher* dispatcher)
94 : InterfaceProxy(dispatcher),
95 callback_factory_(this) {
96 }
97
~PPB_Instance_Proxy()98 PPB_Instance_Proxy::~PPB_Instance_Proxy() {
99 }
100
OnMessageReceived(const IPC::Message & msg)101 bool PPB_Instance_Proxy::OnMessageReceived(const IPC::Message& msg) {
102 // Prevent the dispatcher from going away during a call to ExecuteScript.
103 // This must happen OUTSIDE of ExecuteScript since the SerializedVars use
104 // the dispatcher upon return of the function (converting the
105 // SerializedVarReturnValue/OutParam to a SerializedVar in the destructor).
106 #if !defined(OS_NACL)
107 ScopedModuleReference death_grip(dispatcher());
108 #endif
109
110 bool handled = true;
111 IPC_BEGIN_MESSAGE_MAP(PPB_Instance_Proxy, msg)
112 #if !defined(OS_NACL)
113 // Plugin -> Host messages.
114 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetWindowObject,
115 OnHostMsgGetWindowObject)
116 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetOwnerElementObject,
117 OnHostMsgGetOwnerElementObject)
118 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_BindGraphics,
119 OnHostMsgBindGraphics)
120 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_IsFullFrame,
121 OnHostMsgIsFullFrame)
122 IPC_MESSAGE_HANDLER(
123 PpapiHostMsg_PPBInstance_GetAudioHardwareOutputSampleRate,
124 OnHostMsgGetAudioHardwareOutputSampleRate)
125 IPC_MESSAGE_HANDLER(
126 PpapiHostMsg_PPBInstance_GetAudioHardwareOutputBufferSize,
127 OnHostMsgGetAudioHardwareOutputBufferSize)
128 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ExecuteScript,
129 OnHostMsgExecuteScript)
130 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetDefaultCharSet,
131 OnHostMsgGetDefaultCharSet)
132 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetPluginToHandleFindRequests,
133 OnHostMsgSetPluginToHandleFindRequests);
134 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_NumberOfFindResultsChanged,
135 OnHostMsgNumberOfFindResultsChanged)
136 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SelectFindResultChanged,
137 OnHostMsgSelectFindResultChanged)
138 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetTickmarks,
139 OnHostMsgSetTickmarks)
140 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PostMessage,
141 OnHostMsgPostMessage)
142 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetFullscreen,
143 OnHostMsgSetFullscreen)
144 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetScreenSize,
145 OnHostMsgGetScreenSize)
146 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_RequestInputEvents,
147 OnHostMsgRequestInputEvents)
148 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ClearInputEvents,
149 OnHostMsgClearInputEvents)
150 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_StartTrackingLatency,
151 OnHostMsgStartTrackingLatency)
152 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_LockMouse,
153 OnHostMsgLockMouse)
154 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UnlockMouse,
155 OnHostMsgUnlockMouse)
156 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetCursor,
157 OnHostMsgSetCursor)
158 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetTextInputType,
159 OnHostMsgSetTextInputType)
160 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UpdateCaretPosition,
161 OnHostMsgUpdateCaretPosition)
162 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_CancelCompositionText,
163 OnHostMsgCancelCompositionText)
164 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UpdateSurroundingText,
165 OnHostMsgUpdateSurroundingText)
166 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetDocumentURL,
167 OnHostMsgGetDocumentURL)
168 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ResolveRelativeToDocument,
169 OnHostMsgResolveRelativeToDocument)
170 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanRequest,
171 OnHostMsgDocumentCanRequest)
172 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanAccessDocument,
173 OnHostMsgDocumentCanAccessDocument)
174 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetPluginInstanceURL,
175 OnHostMsgGetPluginInstanceURL)
176 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetPluginReferrerURL,
177 OnHostMsgGetPluginReferrerURL)
178 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PromiseResolved,
179 OnHostMsgPromiseResolved)
180 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PromiseResolvedWithSession,
181 OnHostMsgPromiseResolvedWithSession)
182 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PromiseRejected,
183 OnHostMsgPromiseRejected)
184 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionMessage,
185 OnHostMsgSessionMessage)
186 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionReady,
187 OnHostMsgSessionReady)
188 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionClosed,
189 OnHostMsgSessionClosed)
190 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionError,
191 OnHostMsgSessionError)
192 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DeliverBlock,
193 OnHostMsgDeliverBlock)
194 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DecoderInitializeDone,
195 OnHostMsgDecoderInitializeDone)
196 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DecoderDeinitializeDone,
197 OnHostMsgDecoderDeinitializeDone)
198 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DecoderResetDone,
199 OnHostMsgDecoderResetDone)
200 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DeliverFrame,
201 OnHostMsgDeliverFrame)
202 IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DeliverSamples,
203 OnHostMsgDeliverSamples)
204 #endif // !defined(OS_NACL)
205
206 // Host -> Plugin messages.
207 IPC_MESSAGE_HANDLER(PpapiMsg_PPBInstance_MouseLockComplete,
208 OnPluginMsgMouseLockComplete)
209
210 IPC_MESSAGE_UNHANDLED(handled = false)
211 IPC_END_MESSAGE_MAP()
212 return handled;
213 }
214
BindGraphics(PP_Instance instance,PP_Resource device)215 PP_Bool PPB_Instance_Proxy::BindGraphics(PP_Instance instance,
216 PP_Resource device) {
217 // If device is 0, pass a null HostResource. This signals the host to unbind
218 // all devices.
219 HostResource host_resource;
220 PP_Resource pp_resource = 0;
221 if (device) {
222 Resource* resource =
223 PpapiGlobals::Get()->GetResourceTracker()->GetResource(device);
224 if (!resource || resource->pp_instance() != instance)
225 return PP_FALSE;
226 host_resource = resource->host_resource();
227 pp_resource = resource->pp_resource();
228 } else {
229 // Passing 0 means unbinding all devices.
230 dispatcher()->Send(new PpapiHostMsg_PPBInstance_BindGraphics(
231 API_ID_PPB_INSTANCE, instance, 0));
232 return PP_TRUE;
233 }
234
235 // We need to pass different resource to Graphics 2D and 3D right now. Once
236 // 3D is migrated to the new design, we should be able to unify this.
237 EnterResourceNoLock<PPB_Compositor_API> enter_compositor(device, false);
238 EnterResourceNoLock<PPB_Graphics2D_API> enter_2d(device, false);
239 EnterResourceNoLock<PPB_Graphics3D_API> enter_3d(device, false);
240 if (enter_compositor.succeeded() || enter_2d.succeeded()) {
241 dispatcher()->Send(new PpapiHostMsg_PPBInstance_BindGraphics(
242 API_ID_PPB_INSTANCE, instance, pp_resource));
243 return PP_TRUE;
244 } else if (enter_3d.succeeded()) {
245 dispatcher()->Send(new PpapiHostMsg_PPBInstance_BindGraphics(
246 API_ID_PPB_INSTANCE, instance, host_resource.host_resource()));
247 return PP_TRUE;
248 }
249 return PP_FALSE;
250 }
251
IsFullFrame(PP_Instance instance)252 PP_Bool PPB_Instance_Proxy::IsFullFrame(PP_Instance instance) {
253 PP_Bool result = PP_FALSE;
254 dispatcher()->Send(new PpapiHostMsg_PPBInstance_IsFullFrame(
255 API_ID_PPB_INSTANCE, instance, &result));
256 return result;
257 }
258
GetViewData(PP_Instance instance)259 const ViewData* PPB_Instance_Proxy::GetViewData(PP_Instance instance) {
260 InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
261 GetInstanceData(instance);
262 if (!data)
263 return NULL;
264 return &data->view;
265 }
266
FlashIsFullscreen(PP_Instance instance)267 PP_Bool PPB_Instance_Proxy::FlashIsFullscreen(PP_Instance instance) {
268 // This function is only used for proxying in the renderer process. It is not
269 // implemented in the plugin process.
270 NOTREACHED();
271 return PP_FALSE;
272 }
273
GetWindowObject(PP_Instance instance)274 PP_Var PPB_Instance_Proxy::GetWindowObject(PP_Instance instance) {
275 ReceiveSerializedVarReturnValue result;
276 dispatcher()->Send(new PpapiHostMsg_PPBInstance_GetWindowObject(
277 API_ID_PPB_INSTANCE, instance, &result));
278 return result.Return(dispatcher());
279 }
280
GetOwnerElementObject(PP_Instance instance)281 PP_Var PPB_Instance_Proxy::GetOwnerElementObject(PP_Instance instance) {
282 ReceiveSerializedVarReturnValue result;
283 dispatcher()->Send(new PpapiHostMsg_PPBInstance_GetOwnerElementObject(
284 API_ID_PPB_INSTANCE, instance, &result));
285 return result.Return(dispatcher());
286 }
287
ExecuteScript(PP_Instance instance,PP_Var script,PP_Var * exception)288 PP_Var PPB_Instance_Proxy::ExecuteScript(PP_Instance instance,
289 PP_Var script,
290 PP_Var* exception) {
291 ReceiveSerializedException se(dispatcher(), exception);
292 if (se.IsThrown())
293 return PP_MakeUndefined();
294
295 ReceiveSerializedVarReturnValue result;
296 dispatcher()->Send(new PpapiHostMsg_PPBInstance_ExecuteScript(
297 API_ID_PPB_INSTANCE, instance,
298 SerializedVarSendInput(dispatcher(), script), &se, &result));
299 return result.Return(dispatcher());
300 }
301
GetAudioHardwareOutputSampleRate(PP_Instance instance)302 uint32_t PPB_Instance_Proxy::GetAudioHardwareOutputSampleRate(
303 PP_Instance instance) {
304 uint32_t result = PP_AUDIOSAMPLERATE_NONE;
305 dispatcher()->Send(
306 new PpapiHostMsg_PPBInstance_GetAudioHardwareOutputSampleRate(
307 API_ID_PPB_INSTANCE, instance, &result));
308 return result;
309 }
310
GetAudioHardwareOutputBufferSize(PP_Instance instance)311 uint32_t PPB_Instance_Proxy::GetAudioHardwareOutputBufferSize(
312 PP_Instance instance) {
313 uint32_t result = 0;
314 dispatcher()->Send(
315 new PpapiHostMsg_PPBInstance_GetAudioHardwareOutputBufferSize(
316 API_ID_PPB_INSTANCE, instance, &result));
317 return result;
318 }
319
GetDefaultCharSet(PP_Instance instance)320 PP_Var PPB_Instance_Proxy::GetDefaultCharSet(PP_Instance instance) {
321 PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
322 if (!dispatcher)
323 return PP_MakeUndefined();
324
325 ReceiveSerializedVarReturnValue result;
326 dispatcher->Send(new PpapiHostMsg_PPBInstance_GetDefaultCharSet(
327 API_ID_PPB_INSTANCE, instance, &result));
328 return result.Return(dispatcher);
329 }
330
SetPluginToHandleFindRequests(PP_Instance instance)331 void PPB_Instance_Proxy::SetPluginToHandleFindRequests(PP_Instance instance) {
332 dispatcher()->Send(new PpapiHostMsg_PPBInstance_SetPluginToHandleFindRequests(
333 API_ID_PPB_INSTANCE, instance));
334 }
335
NumberOfFindResultsChanged(PP_Instance instance,int32_t total,PP_Bool final_result)336 void PPB_Instance_Proxy::NumberOfFindResultsChanged(PP_Instance instance,
337 int32_t total,
338 PP_Bool final_result) {
339 dispatcher()->Send(new PpapiHostMsg_PPBInstance_NumberOfFindResultsChanged(
340 API_ID_PPB_INSTANCE, instance, total, final_result));
341 }
342
SelectedFindResultChanged(PP_Instance instance,int32_t index)343 void PPB_Instance_Proxy::SelectedFindResultChanged(PP_Instance instance,
344 int32_t index) {
345 dispatcher()->Send(new PpapiHostMsg_PPBInstance_SelectFindResultChanged(
346 API_ID_PPB_INSTANCE, instance, index));
347 }
348
SetTickmarks(PP_Instance instance,const PP_Rect * tickmarks,uint32_t count)349 void PPB_Instance_Proxy::SetTickmarks(PP_Instance instance,
350 const PP_Rect* tickmarks,
351 uint32_t count) {
352 dispatcher()->Send(new PpapiHostMsg_PPBInstance_SetTickmarks(
353 API_ID_PPB_INSTANCE, instance,
354 std::vector<PP_Rect>(tickmarks, tickmarks + count)));
355 }
356
IsFullscreen(PP_Instance instance)357 PP_Bool PPB_Instance_Proxy::IsFullscreen(PP_Instance instance) {
358 InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
359 GetInstanceData(instance);
360 if (!data)
361 return PP_FALSE;
362 return PP_FromBool(data->view.is_fullscreen);
363 }
364
SetFullscreen(PP_Instance instance,PP_Bool fullscreen)365 PP_Bool PPB_Instance_Proxy::SetFullscreen(PP_Instance instance,
366 PP_Bool fullscreen) {
367 PP_Bool result = PP_FALSE;
368 dispatcher()->Send(new PpapiHostMsg_PPBInstance_SetFullscreen(
369 API_ID_PPB_INSTANCE, instance, fullscreen, &result));
370 return result;
371 }
372
GetScreenSize(PP_Instance instance,PP_Size * size)373 PP_Bool PPB_Instance_Proxy::GetScreenSize(PP_Instance instance,
374 PP_Size* size) {
375 PP_Bool result = PP_FALSE;
376 dispatcher()->Send(new PpapiHostMsg_PPBInstance_GetScreenSize(
377 API_ID_PPB_INSTANCE, instance, &result, size));
378 return result;
379 }
380
GetSingletonResource(PP_Instance instance,SingletonResourceID id)381 Resource* PPB_Instance_Proxy::GetSingletonResource(PP_Instance instance,
382 SingletonResourceID id) {
383 InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
384 GetInstanceData(instance);
385
386 InstanceData::SingletonResourceMap::iterator it =
387 data->singleton_resources.find(id);
388 if (it != data->singleton_resources.end())
389 return it->second.get();
390
391 scoped_refptr<Resource> new_singleton;
392 Connection connection(PluginGlobals::Get()->GetBrowserSender(), dispatcher());
393
394 switch (id) {
395 case BROKER_SINGLETON_ID:
396 new_singleton = new BrokerResource(connection, instance);
397 break;
398 case FILE_MAPPING_SINGLETON_ID:
399 new_singleton = new FileMappingResource(connection, instance);
400 break;
401 case GAMEPAD_SINGLETON_ID:
402 new_singleton = new GamepadResource(connection, instance);
403 break;
404 case ISOLATED_FILESYSTEM_SINGLETON_ID:
405 new_singleton =
406 new IsolatedFileSystemPrivateResource(connection, instance);
407 break;
408 case NETWORK_PROXY_SINGLETON_ID:
409 new_singleton = new NetworkProxyResource(connection, instance);
410 break;
411 case TRUETYPE_FONT_SINGLETON_ID:
412 new_singleton = new TrueTypeFontSingletonResource(connection, instance);
413 break;
414 case UMA_SINGLETON_ID:
415 new_singleton = new UMAPrivateResource(connection, instance);
416 break;
417 // Flash/trusted resources aren't needed for NaCl.
418 #if !defined(OS_NACL) && !defined(NACL_WIN64)
419 case BROWSER_FONT_SINGLETON_ID:
420 new_singleton = new BrowserFontSingletonResource(connection, instance);
421 break;
422 case FLASH_CLIPBOARD_SINGLETON_ID:
423 new_singleton = new FlashClipboardResource(connection, instance);
424 break;
425 case FLASH_FILE_SINGLETON_ID:
426 new_singleton = new FlashFileResource(connection, instance);
427 break;
428 case FLASH_FULLSCREEN_SINGLETON_ID:
429 new_singleton = new FlashFullscreenResource(connection, instance);
430 break;
431 case FLASH_SINGLETON_ID:
432 new_singleton = new FlashResource(connection, instance,
433 static_cast<PluginDispatcher*>(dispatcher()));
434 break;
435 case PDF_SINGLETON_ID:
436 new_singleton = new PDFResource(connection, instance);
437 break;
438 #else
439 case BROWSER_FONT_SINGLETON_ID:
440 case FLASH_CLIPBOARD_SINGLETON_ID:
441 case FLASH_FILE_SINGLETON_ID:
442 case FLASH_FULLSCREEN_SINGLETON_ID:
443 case FLASH_SINGLETON_ID:
444 case PDF_SINGLETON_ID:
445 NOTREACHED();
446 break;
447 #endif // !defined(OS_NACL) && !defined(NACL_WIN64)
448 }
449
450 if (!new_singleton.get()) {
451 // Getting here implies that a constructor is missing in the above switch.
452 NOTREACHED();
453 return NULL;
454 }
455
456 data->singleton_resources[id] = new_singleton;
457 return new_singleton.get();
458 }
459
RequestInputEvents(PP_Instance instance,uint32_t event_classes)460 int32_t PPB_Instance_Proxy::RequestInputEvents(PP_Instance instance,
461 uint32_t event_classes) {
462 dispatcher()->Send(new PpapiHostMsg_PPBInstance_RequestInputEvents(
463 API_ID_PPB_INSTANCE, instance, false, event_classes));
464
465 // We always register for the classes we can handle, this function validates
466 // the flags so we can notify it if anything was invalid, without requiring
467 // a sync reply.
468 return ValidateRequestInputEvents(false, event_classes);
469 }
470
RequestFilteringInputEvents(PP_Instance instance,uint32_t event_classes)471 int32_t PPB_Instance_Proxy::RequestFilteringInputEvents(
472 PP_Instance instance,
473 uint32_t event_classes) {
474 dispatcher()->Send(new PpapiHostMsg_PPBInstance_RequestInputEvents(
475 API_ID_PPB_INSTANCE, instance, true, event_classes));
476
477 // We always register for the classes we can handle, this function validates
478 // the flags so we can notify it if anything was invalid, without requiring
479 // a sync reply.
480 return ValidateRequestInputEvents(true, event_classes);
481 }
482
ClearInputEventRequest(PP_Instance instance,uint32_t event_classes)483 void PPB_Instance_Proxy::ClearInputEventRequest(PP_Instance instance,
484 uint32_t event_classes) {
485 dispatcher()->Send(new PpapiHostMsg_PPBInstance_ClearInputEvents(
486 API_ID_PPB_INSTANCE, instance, event_classes));
487 }
488
StartTrackingLatency(PP_Instance instance)489 void PPB_Instance_Proxy::StartTrackingLatency(PP_Instance instance) {
490 dispatcher()->Send(new PpapiHostMsg_PPBInstance_StartTrackingLatency(
491 API_ID_PPB_INSTANCE, instance));
492 }
493
ZoomChanged(PP_Instance instance,double factor)494 void PPB_Instance_Proxy::ZoomChanged(PP_Instance instance,
495 double factor) {
496 // Not proxied yet.
497 NOTIMPLEMENTED();
498 }
499
ZoomLimitsChanged(PP_Instance instance,double minimum_factor,double maximium_factor)500 void PPB_Instance_Proxy::ZoomLimitsChanged(PP_Instance instance,
501 double minimum_factor,
502 double maximium_factor) {
503 // Not proxied yet.
504 NOTIMPLEMENTED();
505 }
506
GetDocumentURL(PP_Instance instance,PP_URLComponents_Dev * components)507 PP_Var PPB_Instance_Proxy::GetDocumentURL(PP_Instance instance,
508 PP_URLComponents_Dev* components) {
509 ReceiveSerializedVarReturnValue result;
510 PP_URLComponents_Dev url_components;
511 dispatcher()->Send(new PpapiHostMsg_PPBInstance_GetDocumentURL(
512 API_ID_PPB_INSTANCE, instance, &url_components, &result));
513 if (components)
514 *components = url_components;
515 return result.Return(dispatcher());
516 }
517
518 #if !defined(OS_NACL)
ResolveRelativeToDocument(PP_Instance instance,PP_Var relative,PP_URLComponents_Dev * components)519 PP_Var PPB_Instance_Proxy::ResolveRelativeToDocument(
520 PP_Instance instance,
521 PP_Var relative,
522 PP_URLComponents_Dev* components) {
523 ReceiveSerializedVarReturnValue result;
524 dispatcher()->Send(new PpapiHostMsg_PPBInstance_ResolveRelativeToDocument(
525 API_ID_PPB_INSTANCE, instance,
526 SerializedVarSendInput(dispatcher(), relative),
527 &result));
528 return PPB_URLUtil_Shared::ConvertComponentsAndReturnURL(
529 result.Return(dispatcher()),
530 components);
531 }
532
DocumentCanRequest(PP_Instance instance,PP_Var url)533 PP_Bool PPB_Instance_Proxy::DocumentCanRequest(PP_Instance instance,
534 PP_Var url) {
535 PP_Bool result = PP_FALSE;
536 dispatcher()->Send(new PpapiHostMsg_PPBInstance_DocumentCanRequest(
537 API_ID_PPB_INSTANCE, instance,
538 SerializedVarSendInput(dispatcher(), url),
539 &result));
540 return result;
541 }
542
DocumentCanAccessDocument(PP_Instance instance,PP_Instance target)543 PP_Bool PPB_Instance_Proxy::DocumentCanAccessDocument(PP_Instance instance,
544 PP_Instance target) {
545 PP_Bool result = PP_FALSE;
546 dispatcher()->Send(new PpapiHostMsg_PPBInstance_DocumentCanAccessDocument(
547 API_ID_PPB_INSTANCE, instance, target, &result));
548 return result;
549 }
550
GetPluginInstanceURL(PP_Instance instance,PP_URLComponents_Dev * components)551 PP_Var PPB_Instance_Proxy::GetPluginInstanceURL(
552 PP_Instance instance,
553 PP_URLComponents_Dev* components) {
554 ReceiveSerializedVarReturnValue result;
555 dispatcher()->Send(new PpapiHostMsg_PPBInstance_GetPluginInstanceURL(
556 API_ID_PPB_INSTANCE, instance, &result));
557 return PPB_URLUtil_Shared::ConvertComponentsAndReturnURL(
558 result.Return(dispatcher()),
559 components);
560 }
561
GetPluginReferrerURL(PP_Instance instance,PP_URLComponents_Dev * components)562 PP_Var PPB_Instance_Proxy::GetPluginReferrerURL(
563 PP_Instance instance,
564 PP_URLComponents_Dev* components) {
565 ReceiveSerializedVarReturnValue result;
566 dispatcher()->Send(new PpapiHostMsg_PPBInstance_GetPluginReferrerURL(
567 API_ID_PPB_INSTANCE, instance, &result));
568 return PPB_URLUtil_Shared::ConvertComponentsAndReturnURL(
569 result.Return(dispatcher()),
570 components);
571 }
572
PromiseResolved(PP_Instance instance,uint32 promise_id)573 void PPB_Instance_Proxy::PromiseResolved(PP_Instance instance,
574 uint32 promise_id) {
575 dispatcher()->Send(new PpapiHostMsg_PPBInstance_PromiseResolved(
576 API_ID_PPB_INSTANCE, instance, promise_id));
577 }
578
PromiseResolvedWithSession(PP_Instance instance,uint32 promise_id,PP_Var web_session_id_var)579 void PPB_Instance_Proxy::PromiseResolvedWithSession(PP_Instance instance,
580 uint32 promise_id,
581 PP_Var web_session_id_var) {
582 dispatcher()->Send(new PpapiHostMsg_PPBInstance_PromiseResolvedWithSession(
583 API_ID_PPB_INSTANCE,
584 instance,
585 promise_id,
586 SerializedVarSendInput(dispatcher(), web_session_id_var)));
587 }
588
PromiseRejected(PP_Instance instance,uint32 promise_id,PP_CdmExceptionCode exception_code,uint32 system_code,PP_Var error_description_var)589 void PPB_Instance_Proxy::PromiseRejected(PP_Instance instance,
590 uint32 promise_id,
591 PP_CdmExceptionCode exception_code,
592 uint32 system_code,
593 PP_Var error_description_var) {
594 dispatcher()->Send(new PpapiHostMsg_PPBInstance_PromiseRejected(
595 API_ID_PPB_INSTANCE,
596 instance,
597 promise_id,
598 exception_code,
599 system_code,
600 SerializedVarSendInput(dispatcher(), error_description_var)));
601 }
602
SessionMessage(PP_Instance instance,PP_Var web_session_id_var,PP_Var message_var,PP_Var destination_url_var)603 void PPB_Instance_Proxy::SessionMessage(PP_Instance instance,
604 PP_Var web_session_id_var,
605 PP_Var message_var,
606 PP_Var destination_url_var) {
607 dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionMessage(
608 API_ID_PPB_INSTANCE,
609 instance,
610 SerializedVarSendInput(dispatcher(), web_session_id_var),
611 SerializedVarSendInput(dispatcher(), message_var),
612 SerializedVarSendInput(dispatcher(), destination_url_var)));
613 }
614
SessionReady(PP_Instance instance,PP_Var web_session_id_var)615 void PPB_Instance_Proxy::SessionReady(PP_Instance instance,
616 PP_Var web_session_id_var) {
617 dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionReady(
618 API_ID_PPB_INSTANCE,
619 instance,
620 SerializedVarSendInput(dispatcher(), web_session_id_var)));
621 }
622
SessionClosed(PP_Instance instance,PP_Var web_session_id_var)623 void PPB_Instance_Proxy::SessionClosed(PP_Instance instance,
624 PP_Var web_session_id_var) {
625 dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionClosed(
626 API_ID_PPB_INSTANCE,
627 instance,
628 SerializedVarSendInput(dispatcher(), web_session_id_var)));
629 }
630
SessionError(PP_Instance instance,PP_Var web_session_id_var,PP_CdmExceptionCode exception_code,uint32 system_code,PP_Var error_description_var)631 void PPB_Instance_Proxy::SessionError(PP_Instance instance,
632 PP_Var web_session_id_var,
633 PP_CdmExceptionCode exception_code,
634 uint32 system_code,
635 PP_Var error_description_var) {
636 dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionError(
637 API_ID_PPB_INSTANCE,
638 instance,
639 SerializedVarSendInput(dispatcher(), web_session_id_var),
640 exception_code,
641 system_code,
642 SerializedVarSendInput(dispatcher(), error_description_var)));
643 }
644
DeliverBlock(PP_Instance instance,PP_Resource decrypted_block,const PP_DecryptedBlockInfo * block_info)645 void PPB_Instance_Proxy::DeliverBlock(PP_Instance instance,
646 PP_Resource decrypted_block,
647 const PP_DecryptedBlockInfo* block_info) {
648 PP_Resource decrypted_block_host_resource = 0;
649
650 if (decrypted_block) {
651 Resource* object =
652 PpapiGlobals::Get()->GetResourceTracker()->GetResource(decrypted_block);
653 if (!object || object->pp_instance() != instance) {
654 NOTREACHED();
655 return;
656 }
657 decrypted_block_host_resource = object->host_resource().host_resource();
658 }
659
660 std::string serialized_block_info;
661 if (!SerializeBlockInfo(*block_info, &serialized_block_info)) {
662 NOTREACHED();
663 return;
664 }
665
666 dispatcher()->Send(
667 new PpapiHostMsg_PPBInstance_DeliverBlock(API_ID_PPB_INSTANCE,
668 instance,
669 decrypted_block_host_resource,
670 serialized_block_info));
671 }
672
DecoderInitializeDone(PP_Instance instance,PP_DecryptorStreamType decoder_type,uint32_t request_id,PP_Bool success)673 void PPB_Instance_Proxy::DecoderInitializeDone(
674 PP_Instance instance,
675 PP_DecryptorStreamType decoder_type,
676 uint32_t request_id,
677 PP_Bool success) {
678 dispatcher()->Send(
679 new PpapiHostMsg_PPBInstance_DecoderInitializeDone(
680 API_ID_PPB_INSTANCE,
681 instance,
682 decoder_type,
683 request_id,
684 success));
685 }
686
DecoderDeinitializeDone(PP_Instance instance,PP_DecryptorStreamType decoder_type,uint32_t request_id)687 void PPB_Instance_Proxy::DecoderDeinitializeDone(
688 PP_Instance instance,
689 PP_DecryptorStreamType decoder_type,
690 uint32_t request_id) {
691 dispatcher()->Send(
692 new PpapiHostMsg_PPBInstance_DecoderDeinitializeDone(
693 API_ID_PPB_INSTANCE,
694 instance,
695 decoder_type,
696 request_id));
697 }
698
DecoderResetDone(PP_Instance instance,PP_DecryptorStreamType decoder_type,uint32_t request_id)699 void PPB_Instance_Proxy::DecoderResetDone(PP_Instance instance,
700 PP_DecryptorStreamType decoder_type,
701 uint32_t request_id) {
702 dispatcher()->Send(
703 new PpapiHostMsg_PPBInstance_DecoderResetDone(
704 API_ID_PPB_INSTANCE,
705 instance,
706 decoder_type,
707 request_id));
708 }
709
DeliverFrame(PP_Instance instance,PP_Resource decrypted_frame,const PP_DecryptedFrameInfo * frame_info)710 void PPB_Instance_Proxy::DeliverFrame(PP_Instance instance,
711 PP_Resource decrypted_frame,
712 const PP_DecryptedFrameInfo* frame_info) {
713 PP_Resource host_resource = 0;
714 if (decrypted_frame != 0) {
715 ResourceTracker* tracker = PpapiGlobals::Get()->GetResourceTracker();
716 Resource* object = tracker->GetResource(decrypted_frame);
717
718 if (!object || object->pp_instance() != instance) {
719 NOTREACHED();
720 return;
721 }
722
723 host_resource = object->host_resource().host_resource();
724 }
725
726 std::string serialized_frame_info;
727 if (!SerializeBlockInfo(*frame_info, &serialized_frame_info)) {
728 NOTREACHED();
729 return;
730 }
731
732 dispatcher()->Send(
733 new PpapiHostMsg_PPBInstance_DeliverFrame(API_ID_PPB_INSTANCE,
734 instance,
735 host_resource,
736 serialized_frame_info));
737 }
738
DeliverSamples(PP_Instance instance,PP_Resource decrypted_samples,const PP_DecryptedSampleInfo * sample_info)739 void PPB_Instance_Proxy::DeliverSamples(
740 PP_Instance instance,
741 PP_Resource decrypted_samples,
742 const PP_DecryptedSampleInfo* sample_info) {
743 PP_Resource host_resource = 0;
744 if (decrypted_samples != 0) {
745 ResourceTracker* tracker = PpapiGlobals::Get()->GetResourceTracker();
746 Resource* object = tracker->GetResource(decrypted_samples);
747
748 if (!object || object->pp_instance() != instance) {
749 NOTREACHED();
750 return;
751 }
752
753 host_resource = object->host_resource().host_resource();
754 }
755
756 std::string serialized_sample_info;
757 if (!SerializeBlockInfo(*sample_info, &serialized_sample_info)) {
758 NOTREACHED();
759 return;
760 }
761
762 dispatcher()->Send(
763 new PpapiHostMsg_PPBInstance_DeliverSamples(API_ID_PPB_INSTANCE,
764 instance,
765 host_resource,
766 serialized_sample_info));
767 }
768 #endif // !defined(OS_NACL)
769
PostMessage(PP_Instance instance,PP_Var message)770 void PPB_Instance_Proxy::PostMessage(PP_Instance instance,
771 PP_Var message) {
772 dispatcher()->Send(new PpapiHostMsg_PPBInstance_PostMessage(
773 API_ID_PPB_INSTANCE,
774 instance, SerializedVarSendInputShmem(dispatcher(), message,
775 instance)));
776 }
777
RegisterMessageHandler(PP_Instance instance,void * user_data,const PPP_MessageHandler_0_1 * handler,PP_Resource message_loop)778 int32_t PPB_Instance_Proxy::RegisterMessageHandler(
779 PP_Instance instance,
780 void* user_data,
781 const PPP_MessageHandler_0_1* handler,
782 PP_Resource message_loop) {
783 InstanceData* data =
784 static_cast<PluginDispatcher*>(dispatcher())->GetInstanceData(instance);
785 if (!data)
786 return PP_ERROR_BADARGUMENT;
787
788 int32_t result = PP_ERROR_FAILED;
789 scoped_ptr<MessageHandler> message_handler = MessageHandler::Create(
790 instance, handler, user_data, message_loop, &result);
791 if (message_handler)
792 data->message_handler = message_handler.Pass();
793 return result;
794 }
795
UnregisterMessageHandler(PP_Instance instance)796 void PPB_Instance_Proxy::UnregisterMessageHandler(PP_Instance instance) {
797 InstanceData* data =
798 static_cast<PluginDispatcher*>(dispatcher())->GetInstanceData(instance);
799 if (!data)
800 return;
801 data->message_handler.reset();
802 }
803
SetCursor(PP_Instance instance,PP_MouseCursor_Type type,PP_Resource image,const PP_Point * hot_spot)804 PP_Bool PPB_Instance_Proxy::SetCursor(PP_Instance instance,
805 PP_MouseCursor_Type type,
806 PP_Resource image,
807 const PP_Point* hot_spot) {
808 // Some of these parameters are important for security. This check is in the
809 // plugin process just for the convenience of the caller (since we don't
810 // bother returning errors from the other process with a sync message). The
811 // parameters will be validated again in the renderer.
812 if (!ValidateSetCursorParams(type, image, hot_spot))
813 return PP_FALSE;
814
815 HostResource image_host_resource;
816 if (image) {
817 Resource* cursor_image =
818 PpapiGlobals::Get()->GetResourceTracker()->GetResource(image);
819 if (!cursor_image || cursor_image->pp_instance() != instance)
820 return PP_FALSE;
821 image_host_resource = cursor_image->host_resource();
822 }
823
824 dispatcher()->Send(new PpapiHostMsg_PPBInstance_SetCursor(
825 API_ID_PPB_INSTANCE, instance, static_cast<int32_t>(type),
826 image_host_resource, hot_spot ? *hot_spot : PP_MakePoint(0, 0)));
827 return PP_TRUE;
828 }
829
LockMouse(PP_Instance instance,scoped_refptr<TrackedCallback> callback)830 int32_t PPB_Instance_Proxy::LockMouse(PP_Instance instance,
831 scoped_refptr<TrackedCallback> callback) {
832 // Save the mouse callback on the instance data.
833 InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
834 GetInstanceData(instance);
835 if (!data)
836 return PP_ERROR_BADARGUMENT;
837 if (TrackedCallback::IsPending(data->mouse_lock_callback))
838 return PP_ERROR_INPROGRESS; // Already have a pending callback.
839 data->mouse_lock_callback = callback;
840
841 dispatcher()->Send(new PpapiHostMsg_PPBInstance_LockMouse(
842 API_ID_PPB_INSTANCE, instance));
843 return PP_OK_COMPLETIONPENDING;
844 }
845
UnlockMouse(PP_Instance instance)846 void PPB_Instance_Proxy::UnlockMouse(PP_Instance instance) {
847 dispatcher()->Send(new PpapiHostMsg_PPBInstance_UnlockMouse(
848 API_ID_PPB_INSTANCE, instance));
849 }
850
SetTextInputType(PP_Instance instance,PP_TextInput_Type type)851 void PPB_Instance_Proxy::SetTextInputType(PP_Instance instance,
852 PP_TextInput_Type type) {
853 CancelAnyPendingRequestSurroundingText(instance);
854 dispatcher()->Send(new PpapiHostMsg_PPBInstance_SetTextInputType(
855 API_ID_PPB_INSTANCE, instance, type));
856 }
857
UpdateCaretPosition(PP_Instance instance,const PP_Rect & caret,const PP_Rect & bounding_box)858 void PPB_Instance_Proxy::UpdateCaretPosition(PP_Instance instance,
859 const PP_Rect& caret,
860 const PP_Rect& bounding_box) {
861 dispatcher()->Send(new PpapiHostMsg_PPBInstance_UpdateCaretPosition(
862 API_ID_PPB_INSTANCE, instance, caret, bounding_box));
863 }
864
CancelCompositionText(PP_Instance instance)865 void PPB_Instance_Proxy::CancelCompositionText(PP_Instance instance) {
866 CancelAnyPendingRequestSurroundingText(instance);
867 dispatcher()->Send(new PpapiHostMsg_PPBInstance_CancelCompositionText(
868 API_ID_PPB_INSTANCE, instance));
869 }
870
SelectionChanged(PP_Instance instance)871 void PPB_Instance_Proxy::SelectionChanged(PP_Instance instance) {
872 // The "right" way to do this is to send the message to the host. However,
873 // all it will do is call RequestSurroundingText with a hardcoded number of
874 // characters in response, which is an entire IPC round-trip.
875 //
876 // We can avoid this round-trip by just implementing the
877 // RequestSurroundingText logic in the plugin process. If the logic in the
878 // host becomes more complex (like a more adaptive number of characters),
879 // we'll need to reevanuate whether we want to do the round trip instead.
880 //
881 // Be careful to post a task to avoid reentering the plugin.
882
883 InstanceData* data =
884 static_cast<PluginDispatcher*>(dispatcher())->GetInstanceData(instance);
885 if (!data)
886 return;
887 data->should_do_request_surrounding_text = true;
888
889 if (!data->is_request_surrounding_text_pending) {
890 base::MessageLoop::current()->PostTask(
891 FROM_HERE,
892 RunWhileLocked(base::Bind(&RequestSurroundingText, instance)));
893 data->is_request_surrounding_text_pending = true;
894 }
895 }
896
UpdateSurroundingText(PP_Instance instance,const char * text,uint32_t caret,uint32_t anchor)897 void PPB_Instance_Proxy::UpdateSurroundingText(PP_Instance instance,
898 const char* text,
899 uint32_t caret,
900 uint32_t anchor) {
901 dispatcher()->Send(new PpapiHostMsg_PPBInstance_UpdateSurroundingText(
902 API_ID_PPB_INSTANCE, instance, text, caret, anchor));
903 }
904
905 #if !defined(OS_NACL)
OnHostMsgGetWindowObject(PP_Instance instance,SerializedVarReturnValue result)906 void PPB_Instance_Proxy::OnHostMsgGetWindowObject(
907 PP_Instance instance,
908 SerializedVarReturnValue result) {
909 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
910 return;
911 EnterInstanceNoLock enter(instance);
912 if (enter.succeeded())
913 result.Return(dispatcher(), enter.functions()->GetWindowObject(instance));
914 }
915
OnHostMsgGetOwnerElementObject(PP_Instance instance,SerializedVarReturnValue result)916 void PPB_Instance_Proxy::OnHostMsgGetOwnerElementObject(
917 PP_Instance instance,
918 SerializedVarReturnValue result) {
919 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
920 return;
921 EnterInstanceNoLock enter(instance);
922 if (enter.succeeded()) {
923 result.Return(dispatcher(),
924 enter.functions()->GetOwnerElementObject(instance));
925 }
926 }
927
OnHostMsgBindGraphics(PP_Instance instance,PP_Resource device)928 void PPB_Instance_Proxy::OnHostMsgBindGraphics(PP_Instance instance,
929 PP_Resource device) {
930 // Note that we ignroe the return value here. Otherwise, this would need to
931 // be a slow sync call, and the plugin side of the proxy will have already
932 // validated the resources, so we shouldn't see errors here that weren't
933 // already caught.
934 EnterInstanceNoLock enter(instance);
935 if (enter.succeeded())
936 enter.functions()->BindGraphics(instance, device);
937 }
938
OnHostMsgGetAudioHardwareOutputSampleRate(PP_Instance instance,uint32_t * result)939 void PPB_Instance_Proxy::OnHostMsgGetAudioHardwareOutputSampleRate(
940 PP_Instance instance, uint32_t* result) {
941 EnterInstanceNoLock enter(instance);
942 if (enter.succeeded())
943 *result = enter.functions()->GetAudioHardwareOutputSampleRate(instance);
944 }
945
OnHostMsgGetAudioHardwareOutputBufferSize(PP_Instance instance,uint32_t * result)946 void PPB_Instance_Proxy::OnHostMsgGetAudioHardwareOutputBufferSize(
947 PP_Instance instance, uint32_t* result) {
948 EnterInstanceNoLock enter(instance);
949 if (enter.succeeded())
950 *result = enter.functions()->GetAudioHardwareOutputBufferSize(instance);
951 }
952
OnHostMsgIsFullFrame(PP_Instance instance,PP_Bool * result)953 void PPB_Instance_Proxy::OnHostMsgIsFullFrame(PP_Instance instance,
954 PP_Bool* result) {
955 EnterInstanceNoLock enter(instance);
956 if (enter.succeeded())
957 *result = enter.functions()->IsFullFrame(instance);
958 }
959
OnHostMsgExecuteScript(PP_Instance instance,SerializedVarReceiveInput script,SerializedVarOutParam out_exception,SerializedVarReturnValue result)960 void PPB_Instance_Proxy::OnHostMsgExecuteScript(
961 PP_Instance instance,
962 SerializedVarReceiveInput script,
963 SerializedVarOutParam out_exception,
964 SerializedVarReturnValue result) {
965 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
966 return;
967 EnterInstanceNoLock enter(instance);
968 if (enter.failed())
969 return;
970
971 if (dispatcher()->IsPlugin())
972 NOTREACHED();
973 else
974 static_cast<HostDispatcher*>(dispatcher())->set_allow_plugin_reentrancy();
975
976 result.Return(dispatcher(), enter.functions()->ExecuteScript(
977 instance,
978 script.Get(dispatcher()),
979 out_exception.OutParam(dispatcher())));
980 }
981
OnHostMsgGetDefaultCharSet(PP_Instance instance,SerializedVarReturnValue result)982 void PPB_Instance_Proxy::OnHostMsgGetDefaultCharSet(
983 PP_Instance instance,
984 SerializedVarReturnValue result) {
985 if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
986 return;
987 EnterInstanceNoLock enter(instance);
988 if (enter.succeeded())
989 result.Return(dispatcher(), enter.functions()->GetDefaultCharSet(instance));
990 }
991
OnHostMsgSetPluginToHandleFindRequests(PP_Instance instance)992 void PPB_Instance_Proxy::OnHostMsgSetPluginToHandleFindRequests(
993 PP_Instance instance) {
994 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
995 return;
996 EnterInstanceNoLock enter(instance);
997 if (enter.succeeded())
998 enter.functions()->SetPluginToHandleFindRequests(instance);
999 }
1000
OnHostMsgNumberOfFindResultsChanged(PP_Instance instance,int32_t total,PP_Bool final_result)1001 void PPB_Instance_Proxy::OnHostMsgNumberOfFindResultsChanged(
1002 PP_Instance instance,
1003 int32_t total,
1004 PP_Bool final_result) {
1005 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1006 return;
1007 EnterInstanceNoLock enter(instance);
1008 if (enter.succeeded()) {
1009 enter.functions()->NumberOfFindResultsChanged(
1010 instance, total, final_result);
1011 }
1012 }
1013
OnHostMsgSelectFindResultChanged(PP_Instance instance,int32_t index)1014 void PPB_Instance_Proxy::OnHostMsgSelectFindResultChanged(
1015 PP_Instance instance,
1016 int32_t index) {
1017 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1018 return;
1019 EnterInstanceNoLock enter(instance);
1020 if (enter.succeeded())
1021 enter.functions()->SelectedFindResultChanged(instance, index);
1022 }
1023
OnHostMsgSetTickmarks(PP_Instance instance,const std::vector<PP_Rect> & tickmarks)1024 void PPB_Instance_Proxy::OnHostMsgSetTickmarks(
1025 PP_Instance instance,
1026 const std::vector<PP_Rect>& tickmarks) {
1027 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1028 return;
1029 const PP_Rect* array = tickmarks.empty() ? NULL : &tickmarks[0];
1030 EnterInstanceNoLock enter(instance);
1031 if (enter.succeeded()) {
1032 enter.functions()->SetTickmarks(instance,
1033 array,
1034 static_cast<uint32_t>(tickmarks.size()));
1035 }
1036 }
1037
OnHostMsgSetFullscreen(PP_Instance instance,PP_Bool fullscreen,PP_Bool * result)1038 void PPB_Instance_Proxy::OnHostMsgSetFullscreen(PP_Instance instance,
1039 PP_Bool fullscreen,
1040 PP_Bool* result) {
1041 EnterInstanceNoLock enter(instance);
1042 if (enter.succeeded())
1043 *result = enter.functions()->SetFullscreen(instance, fullscreen);
1044 }
1045
1046
OnHostMsgGetScreenSize(PP_Instance instance,PP_Bool * result,PP_Size * size)1047 void PPB_Instance_Proxy::OnHostMsgGetScreenSize(PP_Instance instance,
1048 PP_Bool* result,
1049 PP_Size* size) {
1050 EnterInstanceNoLock enter(instance);
1051 if (enter.succeeded())
1052 *result = enter.functions()->GetScreenSize(instance, size);
1053 }
1054
OnHostMsgRequestInputEvents(PP_Instance instance,bool is_filtering,uint32_t event_classes)1055 void PPB_Instance_Proxy::OnHostMsgRequestInputEvents(PP_Instance instance,
1056 bool is_filtering,
1057 uint32_t event_classes) {
1058 EnterInstanceNoLock enter(instance);
1059 if (enter.succeeded()) {
1060 if (is_filtering)
1061 enter.functions()->RequestFilteringInputEvents(instance, event_classes);
1062 else
1063 enter.functions()->RequestInputEvents(instance, event_classes);
1064 }
1065 }
1066
OnHostMsgClearInputEvents(PP_Instance instance,uint32_t event_classes)1067 void PPB_Instance_Proxy::OnHostMsgClearInputEvents(PP_Instance instance,
1068 uint32_t event_classes) {
1069 EnterInstanceNoLock enter(instance);
1070 if (enter.succeeded())
1071 enter.functions()->ClearInputEventRequest(instance, event_classes);
1072 }
1073
OnHostMsgStartTrackingLatency(PP_Instance instance)1074 void PPB_Instance_Proxy::OnHostMsgStartTrackingLatency(PP_Instance instance) {
1075 EnterInstanceNoLock enter(instance);
1076 if (enter.succeeded())
1077 enter.functions()->StartTrackingLatency(instance);
1078 }
1079
OnHostMsgPostMessage(PP_Instance instance,SerializedVarReceiveInput message)1080 void PPB_Instance_Proxy::OnHostMsgPostMessage(
1081 PP_Instance instance,
1082 SerializedVarReceiveInput message) {
1083 EnterInstanceNoLock enter(instance);
1084 if (!message.is_valid_var()) {
1085 PpapiGlobals::Get()->LogWithSource(
1086 instance, PP_LOGLEVEL_ERROR, std::string(), kSerializationError);
1087 return;
1088 }
1089
1090 if (enter.succeeded())
1091 enter.functions()->PostMessage(instance,
1092 message.GetForInstance(dispatcher(),
1093 instance));
1094 }
1095
OnHostMsgLockMouse(PP_Instance instance)1096 void PPB_Instance_Proxy::OnHostMsgLockMouse(PP_Instance instance) {
1097 // Need to be careful to always issue the callback.
1098 pp::CompletionCallback cb = callback_factory_.NewCallback(
1099 &PPB_Instance_Proxy::MouseLockCompleteInHost, instance);
1100
1101 EnterInstanceNoLock enter(instance, cb.pp_completion_callback());
1102 if (enter.succeeded())
1103 enter.SetResult(enter.functions()->LockMouse(instance, enter.callback()));
1104 }
1105
OnHostMsgUnlockMouse(PP_Instance instance)1106 void PPB_Instance_Proxy::OnHostMsgUnlockMouse(PP_Instance instance) {
1107 EnterInstanceNoLock enter(instance);
1108 if (enter.succeeded())
1109 enter.functions()->UnlockMouse(instance);
1110 }
1111
OnHostMsgGetDocumentURL(PP_Instance instance,PP_URLComponents_Dev * components,SerializedVarReturnValue result)1112 void PPB_Instance_Proxy::OnHostMsgGetDocumentURL(
1113 PP_Instance instance,
1114 PP_URLComponents_Dev* components,
1115 SerializedVarReturnValue result) {
1116 if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
1117 return;
1118 EnterInstanceNoLock enter(instance);
1119 if (enter.succeeded()) {
1120 PP_Var document_url = enter.functions()->GetDocumentURL(instance,
1121 components);
1122 result.Return(dispatcher(), document_url);
1123 }
1124 }
1125
OnHostMsgResolveRelativeToDocument(PP_Instance instance,SerializedVarReceiveInput relative,SerializedVarReturnValue result)1126 void PPB_Instance_Proxy::OnHostMsgResolveRelativeToDocument(
1127 PP_Instance instance,
1128 SerializedVarReceiveInput relative,
1129 SerializedVarReturnValue result) {
1130 if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
1131 return;
1132 EnterInstanceNoLock enter(instance);
1133 if (enter.succeeded()) {
1134 result.Return(dispatcher(),
1135 enter.functions()->ResolveRelativeToDocument(
1136 instance, relative.Get(dispatcher()), NULL));
1137 }
1138 }
1139
OnHostMsgDocumentCanRequest(PP_Instance instance,SerializedVarReceiveInput url,PP_Bool * result)1140 void PPB_Instance_Proxy::OnHostMsgDocumentCanRequest(
1141 PP_Instance instance,
1142 SerializedVarReceiveInput url,
1143 PP_Bool* result) {
1144 if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
1145 return;
1146 EnterInstanceNoLock enter(instance);
1147 if (enter.succeeded()) {
1148 *result = enter.functions()->DocumentCanRequest(instance,
1149 url.Get(dispatcher()));
1150 }
1151 }
1152
OnHostMsgDocumentCanAccessDocument(PP_Instance active,PP_Instance target,PP_Bool * result)1153 void PPB_Instance_Proxy::OnHostMsgDocumentCanAccessDocument(PP_Instance active,
1154 PP_Instance target,
1155 PP_Bool* result) {
1156 if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
1157 return;
1158 EnterInstanceNoLock enter(active);
1159 if (enter.succeeded())
1160 *result = enter.functions()->DocumentCanAccessDocument(active, target);
1161 }
1162
OnHostMsgGetPluginInstanceURL(PP_Instance instance,SerializedVarReturnValue result)1163 void PPB_Instance_Proxy::OnHostMsgGetPluginInstanceURL(
1164 PP_Instance instance,
1165 SerializedVarReturnValue result) {
1166 if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
1167 return;
1168 EnterInstanceNoLock enter(instance);
1169 if (enter.succeeded()) {
1170 result.Return(dispatcher(),
1171 enter.functions()->GetPluginInstanceURL(instance, NULL));
1172 }
1173 }
1174
OnHostMsgGetPluginReferrerURL(PP_Instance instance,SerializedVarReturnValue result)1175 void PPB_Instance_Proxy::OnHostMsgGetPluginReferrerURL(
1176 PP_Instance instance,
1177 SerializedVarReturnValue result) {
1178 if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
1179 return;
1180 EnterInstanceNoLock enter(instance);
1181 if (enter.succeeded()) {
1182 result.Return(dispatcher(),
1183 enter.functions()->GetPluginReferrerURL(instance, NULL));
1184 }
1185 }
1186
OnHostMsgPromiseResolved(PP_Instance instance,uint32_t promise_id)1187 void PPB_Instance_Proxy::OnHostMsgPromiseResolved(PP_Instance instance,
1188 uint32_t promise_id) {
1189 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1190 return;
1191 EnterInstanceNoLock enter(instance);
1192 if (enter.succeeded()) {
1193 enter.functions()->PromiseResolved(instance, promise_id);
1194 }
1195 }
1196
OnHostMsgPromiseResolvedWithSession(PP_Instance instance,uint32_t promise_id,SerializedVarReceiveInput web_session_id)1197 void PPB_Instance_Proxy::OnHostMsgPromiseResolvedWithSession(
1198 PP_Instance instance,
1199 uint32_t promise_id,
1200 SerializedVarReceiveInput web_session_id) {
1201 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1202 return;
1203 EnterInstanceNoLock enter(instance);
1204 if (enter.succeeded()) {
1205 enter.functions()->PromiseResolvedWithSession(
1206 instance, promise_id, web_session_id.Get(dispatcher()));
1207 }
1208 }
1209
OnHostMsgPromiseRejected(PP_Instance instance,uint32_t promise_id,PP_CdmExceptionCode exception_code,uint32_t system_code,SerializedVarReceiveInput error_description)1210 void PPB_Instance_Proxy::OnHostMsgPromiseRejected(
1211 PP_Instance instance,
1212 uint32_t promise_id,
1213 PP_CdmExceptionCode exception_code,
1214 uint32_t system_code,
1215 SerializedVarReceiveInput error_description) {
1216 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1217 return;
1218 EnterInstanceNoLock enter(instance);
1219 if (enter.succeeded()) {
1220 enter.functions()->PromiseRejected(instance,
1221 promise_id,
1222 exception_code,
1223 system_code,
1224 error_description.Get(dispatcher()));
1225 }
1226 }
1227
OnHostMsgSessionMessage(PP_Instance instance,SerializedVarReceiveInput web_session_id,SerializedVarReceiveInput message,SerializedVarReceiveInput destination_url)1228 void PPB_Instance_Proxy::OnHostMsgSessionMessage(
1229 PP_Instance instance,
1230 SerializedVarReceiveInput web_session_id,
1231 SerializedVarReceiveInput message,
1232 SerializedVarReceiveInput destination_url) {
1233 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1234 return;
1235 EnterInstanceNoLock enter(instance);
1236 if (enter.succeeded()) {
1237 enter.functions()->SessionMessage(instance,
1238 web_session_id.Get(dispatcher()),
1239 message.Get(dispatcher()),
1240 destination_url.Get(dispatcher()));
1241 }
1242 }
1243
OnHostMsgSessionReady(PP_Instance instance,SerializedVarReceiveInput web_session_id)1244 void PPB_Instance_Proxy::OnHostMsgSessionReady(
1245 PP_Instance instance,
1246 SerializedVarReceiveInput web_session_id) {
1247 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1248 return;
1249 EnterInstanceNoLock enter(instance);
1250 if (enter.succeeded()) {
1251 enter.functions()->SessionReady(instance, web_session_id.Get(dispatcher()));
1252 }
1253 }
1254
OnHostMsgSessionClosed(PP_Instance instance,SerializedVarReceiveInput web_session_id)1255 void PPB_Instance_Proxy::OnHostMsgSessionClosed(
1256 PP_Instance instance,
1257 SerializedVarReceiveInput web_session_id) {
1258 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1259 return;
1260 EnterInstanceNoLock enter(instance);
1261 if (enter.succeeded()) {
1262 enter.functions()->SessionClosed(instance,
1263 web_session_id.Get(dispatcher()));
1264 }
1265 }
1266
OnHostMsgSessionError(PP_Instance instance,SerializedVarReceiveInput web_session_id,PP_CdmExceptionCode exception_code,uint32_t system_code,SerializedVarReceiveInput error_description)1267 void PPB_Instance_Proxy::OnHostMsgSessionError(
1268 PP_Instance instance,
1269 SerializedVarReceiveInput web_session_id,
1270 PP_CdmExceptionCode exception_code,
1271 uint32_t system_code,
1272 SerializedVarReceiveInput error_description) {
1273 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1274 return;
1275 EnterInstanceNoLock enter(instance);
1276 if (enter.succeeded()) {
1277 enter.functions()->SessionError(instance,
1278 web_session_id.Get(dispatcher()),
1279 exception_code,
1280 system_code,
1281 error_description.Get(dispatcher()));
1282 }
1283 }
1284
OnHostMsgDeliverBlock(PP_Instance instance,PP_Resource decrypted_block,const std::string & serialized_block_info)1285 void PPB_Instance_Proxy::OnHostMsgDeliverBlock(
1286 PP_Instance instance,
1287 PP_Resource decrypted_block,
1288 const std::string& serialized_block_info) {
1289 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1290 return;
1291 PP_DecryptedBlockInfo block_info;
1292 if (!DeserializeBlockInfo(serialized_block_info, &block_info))
1293 return;
1294
1295 EnterInstanceNoLock enter(instance);
1296 if (enter.succeeded())
1297 enter.functions()->DeliverBlock(instance, decrypted_block, &block_info);
1298 }
1299
OnHostMsgDecoderInitializeDone(PP_Instance instance,PP_DecryptorStreamType decoder_type,uint32_t request_id,PP_Bool success)1300 void PPB_Instance_Proxy::OnHostMsgDecoderInitializeDone(
1301 PP_Instance instance,
1302 PP_DecryptorStreamType decoder_type,
1303 uint32_t request_id,
1304 PP_Bool success) {
1305 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1306 return;
1307 EnterInstanceNoLock enter(instance);
1308 if (enter.succeeded()) {
1309 enter.functions()->DecoderInitializeDone(instance,
1310 decoder_type,
1311 request_id,
1312 success);
1313 }
1314 }
1315
OnHostMsgDecoderDeinitializeDone(PP_Instance instance,PP_DecryptorStreamType decoder_type,uint32_t request_id)1316 void PPB_Instance_Proxy::OnHostMsgDecoderDeinitializeDone(
1317 PP_Instance instance,
1318 PP_DecryptorStreamType decoder_type,
1319 uint32_t request_id) {
1320 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1321 return;
1322 EnterInstanceNoLock enter(instance);
1323 if (enter.succeeded())
1324 enter.functions()->DecoderDeinitializeDone(instance,
1325 decoder_type,
1326 request_id);
1327 }
1328
OnHostMsgDecoderResetDone(PP_Instance instance,PP_DecryptorStreamType decoder_type,uint32_t request_id)1329 void PPB_Instance_Proxy::OnHostMsgDecoderResetDone(
1330 PP_Instance instance,
1331 PP_DecryptorStreamType decoder_type,
1332 uint32_t request_id) {
1333 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1334 return;
1335 EnterInstanceNoLock enter(instance);
1336 if (enter.succeeded())
1337 enter.functions()->DecoderResetDone(instance, decoder_type, request_id);
1338 }
1339
OnHostMsgDeliverFrame(PP_Instance instance,PP_Resource decrypted_frame,const std::string & serialized_frame_info)1340 void PPB_Instance_Proxy::OnHostMsgDeliverFrame(
1341 PP_Instance instance,
1342 PP_Resource decrypted_frame,
1343 const std::string& serialized_frame_info) {
1344 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1345 return;
1346 PP_DecryptedFrameInfo frame_info;
1347 if (!DeserializeBlockInfo(serialized_frame_info, &frame_info))
1348 return;
1349
1350 EnterInstanceNoLock enter(instance);
1351 if (enter.succeeded())
1352 enter.functions()->DeliverFrame(instance, decrypted_frame, &frame_info);
1353 }
1354
OnHostMsgDeliverSamples(PP_Instance instance,PP_Resource audio_frames,const std::string & serialized_sample_info)1355 void PPB_Instance_Proxy::OnHostMsgDeliverSamples(
1356 PP_Instance instance,
1357 PP_Resource audio_frames,
1358 const std::string& serialized_sample_info) {
1359 if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1360 return;
1361 PP_DecryptedSampleInfo sample_info;
1362 if (!DeserializeBlockInfo(serialized_sample_info, &sample_info))
1363 return;
1364
1365 EnterInstanceNoLock enter(instance);
1366 if (enter.succeeded())
1367 enter.functions()->DeliverSamples(instance, audio_frames, &sample_info);
1368 }
1369
OnHostMsgSetCursor(PP_Instance instance,int32_t type,const ppapi::HostResource & custom_image,const PP_Point & hot_spot)1370 void PPB_Instance_Proxy::OnHostMsgSetCursor(
1371 PP_Instance instance,
1372 int32_t type,
1373 const ppapi::HostResource& custom_image,
1374 const PP_Point& hot_spot) {
1375 // This API serves PPB_CursorControl_Dev and PPB_MouseCursor, so is public.
1376 EnterInstanceNoLock enter(instance);
1377 if (enter.succeeded()) {
1378 enter.functions()->SetCursor(
1379 instance, static_cast<PP_MouseCursor_Type>(type),
1380 custom_image.host_resource(), &hot_spot);
1381 }
1382 }
1383
OnHostMsgSetTextInputType(PP_Instance instance,PP_TextInput_Type type)1384 void PPB_Instance_Proxy::OnHostMsgSetTextInputType(PP_Instance instance,
1385 PP_TextInput_Type type) {
1386 EnterInstanceNoLock enter(instance);
1387 if (enter.succeeded())
1388 enter.functions()->SetTextInputType(instance, type);
1389 }
1390
OnHostMsgUpdateCaretPosition(PP_Instance instance,const PP_Rect & caret,const PP_Rect & bounding_box)1391 void PPB_Instance_Proxy::OnHostMsgUpdateCaretPosition(
1392 PP_Instance instance,
1393 const PP_Rect& caret,
1394 const PP_Rect& bounding_box) {
1395 EnterInstanceNoLock enter(instance);
1396 if (enter.succeeded())
1397 enter.functions()->UpdateCaretPosition(instance, caret, bounding_box);
1398 }
1399
OnHostMsgCancelCompositionText(PP_Instance instance)1400 void PPB_Instance_Proxy::OnHostMsgCancelCompositionText(PP_Instance instance) {
1401 EnterInstanceNoLock enter(instance);
1402 if (enter.succeeded())
1403 enter.functions()->CancelCompositionText(instance);
1404 }
1405
OnHostMsgUpdateSurroundingText(PP_Instance instance,const std::string & text,uint32_t caret,uint32_t anchor)1406 void PPB_Instance_Proxy::OnHostMsgUpdateSurroundingText(
1407 PP_Instance instance,
1408 const std::string& text,
1409 uint32_t caret,
1410 uint32_t anchor) {
1411 EnterInstanceNoLock enter(instance);
1412 if (enter.succeeded()) {
1413 enter.functions()->UpdateSurroundingText(instance, text.c_str(), caret,
1414 anchor);
1415 }
1416 }
1417 #endif // !defined(OS_NACL)
1418
OnPluginMsgMouseLockComplete(PP_Instance instance,int32_t result)1419 void PPB_Instance_Proxy::OnPluginMsgMouseLockComplete(PP_Instance instance,
1420 int32_t result) {
1421 if (!dispatcher()->IsPlugin())
1422 return;
1423
1424 // Save the mouse callback on the instance data.
1425 InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
1426 GetInstanceData(instance);
1427 if (!data)
1428 return; // Instance was probably deleted.
1429 if (!TrackedCallback::IsPending(data->mouse_lock_callback)) {
1430 NOTREACHED();
1431 return;
1432 }
1433 data->mouse_lock_callback->Run(result);
1434 }
1435
1436 #if !defined(OS_NACL)
MouseLockCompleteInHost(int32_t result,PP_Instance instance)1437 void PPB_Instance_Proxy::MouseLockCompleteInHost(int32_t result,
1438 PP_Instance instance) {
1439 dispatcher()->Send(new PpapiMsg_PPBInstance_MouseLockComplete(
1440 API_ID_PPB_INSTANCE, instance, result));
1441 }
1442 #endif // !defined(OS_NACL)
1443
CancelAnyPendingRequestSurroundingText(PP_Instance instance)1444 void PPB_Instance_Proxy::CancelAnyPendingRequestSurroundingText(
1445 PP_Instance instance) {
1446 InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
1447 GetInstanceData(instance);
1448 if (!data)
1449 return; // Instance was probably deleted.
1450 data->should_do_request_surrounding_text = false;
1451 }
1452
1453 } // namespace proxy
1454 } // namespace ppapi
1455