ppapi/proxy/ppb_instance_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_instance_proxy.h"
   6
   7 #include "base/memory/ref_counted.h"
   8 #include "build/build_config.h"
   9 #include "media/base/limits.h"
  10 #include "ppapi/c/pp_errors.h"
  11 #include "ppapi/c/pp_time.h"
  12 #include "ppapi/c/pp_var.h"
  13 #include "ppapi/c/ppb_audio_config.h"
  14 #include "ppapi/c/ppb_instance.h"
  15 #include "ppapi/c/ppb_messaging.h"
  16 #include "ppapi/c/ppb_mouse_lock.h"
  17 #include "ppapi/c/private/pp_content_decryptor.h"
  18 #include "ppapi/proxy/broker_resource.h"
  19 #include "ppapi/proxy/browser_font_singleton_resource.h"
  20 #include "ppapi/proxy/content_decryptor_private_serializer.h"
  21 #include "ppapi/proxy/enter_proxy.h"
  22 #include "ppapi/proxy/file_mapping_resource.h"
  23 #include "ppapi/proxy/flash_clipboard_resource.h"
  24 #include "ppapi/proxy/flash_file_resource.h"
  25 #include "ppapi/proxy/flash_fullscreen_resource.h"
  26 #include "ppapi/proxy/flash_resource.h"
  27 #include "ppapi/proxy/gamepad_resource.h"
  28 #include "ppapi/proxy/host_dispatcher.h"
  29 #include "ppapi/proxy/isolated_file_system_private_resource.h"
  30 #include "ppapi/proxy/message_handler.h"
  31 #include "ppapi/proxy/network_proxy_resource.h"
  32 #include "ppapi/proxy/pdf_resource.h"
  33 #include "ppapi/proxy/plugin_dispatcher.h"
  34 #include "ppapi/proxy/ppapi_messages.h"
  35 #include "ppapi/proxy/serialized_var.h"
  36 #include "ppapi/proxy/truetype_font_singleton_resource.h"
  37 #include "ppapi/proxy/uma_private_resource.h"
  38 #include "ppapi/shared_impl/array_var.h"
  39 #include "ppapi/shared_impl/ppapi_globals.h"
  40 #include "ppapi/shared_impl/ppb_url_util_shared.h"
  41 #include "ppapi/shared_impl/ppb_view_shared.h"
  42 #include "ppapi/shared_impl/scoped_pp_var.h"
  43 #include "ppapi/shared_impl/var.h"
  44 #include "ppapi/thunk/enter.h"
  45 #include "ppapi/thunk/ppb_compositor_api.h"
  46 #include "ppapi/thunk/ppb_graphics_2d_api.h"
  47 #include "ppapi/thunk/ppb_graphics_3d_api.h"
  48 #include "ppapi/thunk/thunk.h"
  49
  50 // Windows headers interfere with this file.
  51 #ifdef PostMessage
  52 #undef PostMessage
  53 #endif
  54
  55 using ppapi::thunk::EnterInstanceNoLock;
  56 using ppapi::thunk::EnterResourceNoLock;
  57 using ppapi::thunk::PPB_Compositor_API;
  58 using ppapi::thunk::PPB_Graphics2D_API;
  59 using ppapi::thunk::PPB_Graphics3D_API;
  60 using ppapi::thunk::PPB_Instance_API;
  61
  62 namespace ppapi {
  63 namespace proxy {
  64
  65 namespace {
  66
  67 #if !defined(OS_NACL)
  68 const char kSerializationError[] = "Failed to convert a PostMessage "
  69     "argument from a PP_Var to a Javascript value. It may have cycles or be of "
  70     "an unsupported type.";
  71 #endif
  72
  73 void RequestSurroundingText(PP_Instance instance) {
  74   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
  75   if (!dispatcher)
  76     return;  // Instance has gone away while message was pending.
  77
  78   InstanceData* data = dispatcher->GetInstanceData(instance);
  79   DCHECK(data);  // Should have it, since we still have a dispatcher.
  80   data->is_request_surrounding_text_pending = false;
  81   if (!data->should_do_request_surrounding_text)
  82     return;
  83
  84   // Just fake out a RequestSurroundingText message to the proxy for the PPP
  85   // interface.
  86   InterfaceProxy* proxy = dispatcher->GetInterfaceProxy(API_ID_PPP_TEXT_INPUT);
  87   if (!proxy)
  88     return;
  89   proxy->OnMessageReceived(PpapiMsg_PPPTextInput_RequestSurroundingText(
  90       API_ID_PPP_TEXT_INPUT, instance,
  91       PPB_Instance_Shared::kExtraCharsForTextInput));
  92 }
  93
  94 }  // namespace
  95
  96 PPB_Instance_Proxy::PPB_Instance_Proxy(Dispatcher* dispatcher)
  97     : InterfaceProxy(dispatcher),
  98       callback_factory_(this) {
  99 }
 100
 101 PPB_Instance_Proxy::~PPB_Instance_Proxy() {
 102 }
 103
 104 bool PPB_Instance_Proxy::OnMessageReceived(const IPC::Message& msg) {
 105   // Prevent the dispatcher from going away during a call to ExecuteScript.
 106   // This must happen OUTSIDE of ExecuteScript since the SerializedVars use
 107   // the dispatcher upon return of the function (converting the
 108   // SerializedVarReturnValue/OutParam to a SerializedVar in the destructor).
 109 #if !defined(OS_NACL)
 110   ScopedModuleReference death_grip(dispatcher());
 111 #endif
 112
 113   bool handled = true;
 114   IPC_BEGIN_MESSAGE_MAP(PPB_Instance_Proxy, msg)
 115 #if !defined(OS_NACL)
 116     // Plugin -> Host messages.
 117     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetWindowObject,
 118                         OnHostMsgGetWindowObject)
 119     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetOwnerElementObject,
 120                         OnHostMsgGetOwnerElementObject)
 121     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_BindGraphics,
 122                         OnHostMsgBindGraphics)
 123     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_IsFullFrame,
 124                         OnHostMsgIsFullFrame)
 125     IPC_MESSAGE_HANDLER(
 126         PpapiHostMsg_PPBInstance_GetAudioHardwareOutputSampleRate,
 127         OnHostMsgGetAudioHardwareOutputSampleRate)
 128     IPC_MESSAGE_HANDLER(
 129         PpapiHostMsg_PPBInstance_GetAudioHardwareOutputBufferSize,
 130         OnHostMsgGetAudioHardwareOutputBufferSize)
 131     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ExecuteScript,
 132                         OnHostMsgExecuteScript)
 133     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetDefaultCharSet,
 134                         OnHostMsgGetDefaultCharSet)
 135     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetPluginToHandleFindRequests,
 136                         OnHostMsgSetPluginToHandleFindRequests);
 137     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_NumberOfFindResultsChanged,
 138                         OnHostMsgNumberOfFindResultsChanged)
 139     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SelectFindResultChanged,
 140                         OnHostMsgSelectFindResultChanged)
 141     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetTickmarks,
 142                         OnHostMsgSetTickmarks)
 143     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PostMessage,
 144                         OnHostMsgPostMessage)
 145     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetFullscreen,
 146                         OnHostMsgSetFullscreen)
 147     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetScreenSize,
 148                         OnHostMsgGetScreenSize)
 149     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_RequestInputEvents,
 150                         OnHostMsgRequestInputEvents)
 151     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ClearInputEvents,
 152                         OnHostMsgClearInputEvents)
 153     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_StartTrackingLatency,
 154                         OnHostMsgStartTrackingLatency)
 155     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_LockMouse,
 156                         OnHostMsgLockMouse)
 157     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UnlockMouse,
 158                         OnHostMsgUnlockMouse)
 159     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetCursor,
 160                         OnHostMsgSetCursor)
 161     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetTextInputType,
 162                         OnHostMsgSetTextInputType)
 163     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UpdateCaretPosition,
 164                         OnHostMsgUpdateCaretPosition)
 165     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_CancelCompositionText,
 166                         OnHostMsgCancelCompositionText)
 167     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UpdateSurroundingText,
 168                         OnHostMsgUpdateSurroundingText)
 169     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetDocumentURL,
 170                         OnHostMsgGetDocumentURL)
 171     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ResolveRelativeToDocument,
 172                         OnHostMsgResolveRelativeToDocument)
 173     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanRequest,
 174                         OnHostMsgDocumentCanRequest)
 175     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanAccessDocument,
 176                         OnHostMsgDocumentCanAccessDocument)
 177     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetPluginInstanceURL,
 178                         OnHostMsgGetPluginInstanceURL)
 179     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetPluginReferrerURL,
 180                         OnHostMsgGetPluginReferrerURL)
 181     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PromiseResolved,
 182                         OnHostMsgPromiseResolved)
 183     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PromiseResolvedWithSession,
 184                         OnHostMsgPromiseResolvedWithSession)
 185     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PromiseResolvedWithKeyIds,
 186                         OnHostMsgPromiseResolvedWithKeyIds)
 187     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PromiseRejected,
 188                         OnHostMsgPromiseRejected)
 189     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionMessage,
 190                         OnHostMsgSessionMessage)
 191     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionKeysChange,
 192                         OnHostMsgSessionKeysChange)
 193     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionExpirationChange,
 194                         OnHostMsgSessionExpirationChange)
 195     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionReady,
 196                         OnHostMsgSessionReady)
 197     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionClosed,
 198                         OnHostMsgSessionClosed)
 199     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionError,
 200                         OnHostMsgSessionError)
 201     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DeliverBlock,
 202                         OnHostMsgDeliverBlock)
 203     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DecoderInitializeDone,
 204                         OnHostMsgDecoderInitializeDone)
 205     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DecoderDeinitializeDone,
 206                         OnHostMsgDecoderDeinitializeDone)
 207     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DecoderResetDone,
 208                         OnHostMsgDecoderResetDone)
 209     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DeliverFrame,
 210                         OnHostMsgDeliverFrame)
 211     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DeliverSamples,
 212                         OnHostMsgDeliverSamples)
 213 #endif  // !defined(OS_NACL)
 214
 215     // Host -> Plugin messages.
 216     IPC_MESSAGE_HANDLER(PpapiMsg_PPBInstance_MouseLockComplete,
 217                         OnPluginMsgMouseLockComplete)
 218
 219     IPC_MESSAGE_UNHANDLED(handled = false)
 220   IPC_END_MESSAGE_MAP()
 221   return handled;
 222 }
 223
 224 PP_Bool PPB_Instance_Proxy::BindGraphics(PP_Instance instance,
 225                                          PP_Resource device) {
 226   // If device is 0, pass a null HostResource. This signals the host to unbind
 227   // all devices.
 228   PP_Resource pp_resource = 0;
 229   if (device) {
 230     Resource* resource =
 231         PpapiGlobals::Get()->GetResourceTracker()->GetResource(device);
 232     if (!resource || resource->pp_instance() != instance)
 233       return PP_FALSE;
 234     // We need to pass different resource to Graphics 2D, 3D and Compositor
 235     // right now.  Once 3D is migrated to the new design, we should be able to
 236     // unify this.
 237     if (resource->AsPPB_Graphics3D_API()) {
 238       pp_resource = resource->host_resource().host_resource();
 239     } else if (resource->AsPPB_Graphics2D_API() ||
 240                resource->AsPPB_Compositor_API()) {
 241       pp_resource = resource->pp_resource();
 242     } else {
 243       // A bad resource.
 244       return PP_FALSE;
 245     }
 246   }
 247   dispatcher()->Send(new PpapiHostMsg_PPBInstance_BindGraphics(
 248         API_ID_PPB_INSTANCE, instance, pp_resource));
 249   return PP_TRUE;
 250 }
 251
 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
 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
 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
 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
 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
 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
 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
 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
 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
 331 void PPB_Instance_Proxy::SetPluginToHandleFindRequests(PP_Instance instance) {
 332   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SetPluginToHandleFindRequests(
 333       API_ID_PPB_INSTANCE, instance));
 334 }
 335
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 489 void PPB_Instance_Proxy::StartTrackingLatency(PP_Instance instance) {
 490   dispatcher()->Send(new PpapiHostMsg_PPBInstance_StartTrackingLatency(
 491       API_ID_PPB_INSTANCE, instance));
 492 }
 493
 494 void PPB_Instance_Proxy::ZoomChanged(PP_Instance instance,
 495                                      double factor) {
 496   // Not proxied yet.
 497   NOTIMPLEMENTED();
 498 }
 499
 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
 507 PP_Var PPB_Instance_Proxy::GetDocumentURL(PP_Instance instance,
 508                                           PP_URLComponents_Dev* components) {
 509   ReceiveSerializedVarReturnValue result;
 510   PP_URLComponents_Dev url_components = {{0}};
 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)
 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
 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
 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
 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
 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
 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
 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
 589 void PPB_Instance_Proxy::PromiseResolvedWithKeyIds(PP_Instance instance,
 590                                                    uint32 promise_id,
 591                                                    PP_Var key_ids_var) {
 592   ArrayVar* key_ids_array = ArrayVar::FromPPVar(key_ids_var);
 593   if (!key_ids_array ||
 594       key_ids_array->GetLength() > media::limits::kMaxKeyIds) {
 595     NOTREACHED();
 596     return;
 597   }
 598
 599   std::vector<std::vector<uint8_t> > key_ids;
 600   for (size_t i = 0; i < key_ids_array->GetLength(); ++i) {
 601     ArrayBufferVar* key_id = ArrayBufferVar::FromPPVar(key_ids_array->Get(i));
 602     if (!key_id || key_id->ByteLength() < media::limits::kMinKeyIdLength ||
 603         key_id->ByteLength() > media::limits::kMaxKeyIdLength) {
 604       NOTREACHED();
 605       continue;
 606     }
 607
 608     const uint8_t* key_id_ptr = static_cast<const uint8_t*>(key_id->Map());
 609     const uint32_t key_id_size = key_id->ByteLength();
 610     std::vector<uint8_t> key_id_vector(key_id_ptr, key_id_ptr + key_id_size);
 611     key_ids.push_back(key_id_vector);
 612   }
 613
 614   dispatcher()->Send(new PpapiHostMsg_PPBInstance_PromiseResolvedWithKeyIds(
 615       API_ID_PPB_INSTANCE, instance, promise_id, key_ids));
 616 }
 617
 618 void PPB_Instance_Proxy::PromiseRejected(PP_Instance instance,
 619                                          uint32 promise_id,
 620                                          PP_CdmExceptionCode exception_code,
 621                                          uint32 system_code,
 622                                          PP_Var error_description_var) {
 623   dispatcher()->Send(new PpapiHostMsg_PPBInstance_PromiseRejected(
 624       API_ID_PPB_INSTANCE,
 625       instance,
 626       promise_id,
 627       exception_code,
 628       system_code,
 629       SerializedVarSendInput(dispatcher(), error_description_var)));
 630 }
 631
 632 void PPB_Instance_Proxy::SessionMessage(PP_Instance instance,
 633                                         PP_Var web_session_id_var,
 634                                         PP_Var message_var,
 635                                         PP_Var destination_url_var) {
 636   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionMessage(
 637       API_ID_PPB_INSTANCE,
 638       instance,
 639       SerializedVarSendInput(dispatcher(), web_session_id_var),
 640       SerializedVarSendInput(dispatcher(), message_var),
 641       SerializedVarSendInput(dispatcher(), destination_url_var)));
 642 }
 643
 644 void PPB_Instance_Proxy::SessionKeysChange(PP_Instance instance,
 645                                            PP_Var web_session_id_var,
 646                                            PP_Bool has_additional_usable_key) {
 647   StringVar* session_id = StringVar::FromPPVar(web_session_id_var);
 648   if (!session_id ||
 649       session_id->value().length() > media::limits::kMaxWebSessionIdLength) {
 650     NOTREACHED();
 651     return;
 652   }
 653
 654   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionKeysChange(
 655       API_ID_PPB_INSTANCE,
 656       instance,
 657       session_id->value(),
 658       has_additional_usable_key));
 659 }
 660
 661 void PPB_Instance_Proxy::SessionExpirationChange(PP_Instance instance,
 662                                                  PP_Var web_session_id_var,
 663                                                  PP_Time new_expiry_time) {
 664   StringVar* session_id = StringVar::FromPPVar(web_session_id_var);
 665   if (!session_id ||
 666       session_id->value().length() > media::limits::kMaxWebSessionIdLength) {
 667     NOTREACHED();
 668     return;
 669   }
 670
 671   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionExpirationChange(
 672       API_ID_PPB_INSTANCE, instance, session_id->value(), new_expiry_time));
 673 }
 674
 675 void PPB_Instance_Proxy::SessionReady(PP_Instance instance,
 676                                       PP_Var web_session_id_var) {
 677   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionReady(
 678       API_ID_PPB_INSTANCE,
 679       instance,
 680       SerializedVarSendInput(dispatcher(), web_session_id_var)));
 681 }
 682
 683 void PPB_Instance_Proxy::SessionClosed(PP_Instance instance,
 684                                        PP_Var web_session_id_var) {
 685   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionClosed(
 686       API_ID_PPB_INSTANCE,
 687       instance,
 688       SerializedVarSendInput(dispatcher(), web_session_id_var)));
 689 }
 690
 691 void PPB_Instance_Proxy::SessionError(PP_Instance instance,
 692                                       PP_Var web_session_id_var,
 693                                       PP_CdmExceptionCode exception_code,
 694                                       uint32 system_code,
 695                                       PP_Var error_description_var) {
 696   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionError(
 697       API_ID_PPB_INSTANCE,
 698       instance,
 699       SerializedVarSendInput(dispatcher(), web_session_id_var),
 700       exception_code,
 701       system_code,
 702       SerializedVarSendInput(dispatcher(), error_description_var)));
 703 }
 704
 705 void PPB_Instance_Proxy::DeliverBlock(PP_Instance instance,
 706                                       PP_Resource decrypted_block,
 707                                       const PP_DecryptedBlockInfo* block_info) {
 708   PP_Resource decrypted_block_host_resource = 0;
 709
 710   if (decrypted_block) {
 711     Resource* object =
 712         PpapiGlobals::Get()->GetResourceTracker()->GetResource(decrypted_block);
 713     if (!object || object->pp_instance() != instance) {
 714       NOTREACHED();
 715       return;
 716     }
 717     decrypted_block_host_resource = object->host_resource().host_resource();
 718   }
 719
 720   std::string serialized_block_info;
 721   if (!SerializeBlockInfo(*block_info, &serialized_block_info)) {
 722     NOTREACHED();
 723     return;
 724   }
 725
 726   dispatcher()->Send(
 727       new PpapiHostMsg_PPBInstance_DeliverBlock(API_ID_PPB_INSTANCE,
 728           instance,
 729           decrypted_block_host_resource,
 730           serialized_block_info));
 731 }
 732
 733 void PPB_Instance_Proxy::DecoderInitializeDone(
 734     PP_Instance instance,
 735     PP_DecryptorStreamType decoder_type,
 736     uint32_t request_id,
 737     PP_Bool success) {
 738   dispatcher()->Send(
 739       new PpapiHostMsg_PPBInstance_DecoderInitializeDone(
 740           API_ID_PPB_INSTANCE,
 741           instance,
 742           decoder_type,
 743           request_id,
 744           success));
 745 }
 746
 747 void PPB_Instance_Proxy::DecoderDeinitializeDone(
 748     PP_Instance instance,
 749     PP_DecryptorStreamType decoder_type,
 750     uint32_t request_id) {
 751   dispatcher()->Send(
 752       new PpapiHostMsg_PPBInstance_DecoderDeinitializeDone(
 753           API_ID_PPB_INSTANCE,
 754           instance,
 755           decoder_type,
 756           request_id));
 757 }
 758
 759 void PPB_Instance_Proxy::DecoderResetDone(PP_Instance instance,
 760                                           PP_DecryptorStreamType decoder_type,
 761                                           uint32_t request_id) {
 762   dispatcher()->Send(
 763       new PpapiHostMsg_PPBInstance_DecoderResetDone(
 764           API_ID_PPB_INSTANCE,
 765           instance,
 766           decoder_type,
 767           request_id));
 768 }
 769
 770 void PPB_Instance_Proxy::DeliverFrame(PP_Instance instance,
 771                                       PP_Resource decrypted_frame,
 772                                       const PP_DecryptedFrameInfo* frame_info) {
 773   PP_Resource host_resource = 0;
 774   if (decrypted_frame != 0) {
 775     ResourceTracker* tracker = PpapiGlobals::Get()->GetResourceTracker();
 776     Resource* object = tracker->GetResource(decrypted_frame);
 777
 778     if (!object || object->pp_instance() != instance) {
 779       NOTREACHED();
 780       return;
 781     }
 782
 783     host_resource = object->host_resource().host_resource();
 784   }
 785
 786   std::string serialized_frame_info;
 787   if (!SerializeBlockInfo(*frame_info, &serialized_frame_info)) {
 788     NOTREACHED();
 789     return;
 790   }
 791
 792   dispatcher()->Send(
 793       new PpapiHostMsg_PPBInstance_DeliverFrame(API_ID_PPB_INSTANCE,
 794                                                 instance,
 795                                                 host_resource,
 796                                                 serialized_frame_info));
 797 }
 798
 799 void PPB_Instance_Proxy::DeliverSamples(
 800     PP_Instance instance,
 801     PP_Resource decrypted_samples,
 802     const PP_DecryptedSampleInfo* sample_info) {
 803   PP_Resource host_resource = 0;
 804   if (decrypted_samples != 0) {
 805     ResourceTracker* tracker = PpapiGlobals::Get()->GetResourceTracker();
 806     Resource* object = tracker->GetResource(decrypted_samples);
 807
 808     if (!object || object->pp_instance() != instance) {
 809       NOTREACHED();
 810       return;
 811     }
 812
 813     host_resource = object->host_resource().host_resource();
 814   }
 815
 816   std::string serialized_sample_info;
 817   if (!SerializeBlockInfo(*sample_info, &serialized_sample_info)) {
 818     NOTREACHED();
 819     return;
 820   }
 821
 822   dispatcher()->Send(
 823       new PpapiHostMsg_PPBInstance_DeliverSamples(API_ID_PPB_INSTANCE,
 824                                                   instance,
 825                                                   host_resource,
 826                                                   serialized_sample_info));
 827 }
 828 #endif  // !defined(OS_NACL)
 829
 830 void PPB_Instance_Proxy::PostMessage(PP_Instance instance,
 831                                      PP_Var message) {
 832   dispatcher()->Send(new PpapiHostMsg_PPBInstance_PostMessage(
 833       API_ID_PPB_INSTANCE,
 834       instance, SerializedVarSendInputShmem(dispatcher(), message,
 835                                             instance)));
 836 }
 837
 838 int32_t PPB_Instance_Proxy::RegisterMessageHandler(
 839     PP_Instance instance,
 840     void* user_data,
 841     const PPP_MessageHandler_0_2* handler,
 842     PP_Resource message_loop) {
 843   InstanceData* data =
 844       static_cast<PluginDispatcher*>(dispatcher())->GetInstanceData(instance);
 845   if (!data)
 846     return PP_ERROR_BADARGUMENT;
 847
 848   int32_t result = PP_ERROR_FAILED;
 849   scoped_ptr<MessageHandler> message_handler = MessageHandler::Create(
 850       instance, handler, user_data, message_loop, &result);
 851   if (message_handler)
 852     data->message_handler = message_handler.Pass();
 853   return result;
 854 }
 855
 856 // TODO(dmichael): Remove this. crbug.com/414398
 857 int32_t PPB_Instance_Proxy::RegisterMessageHandler_1_1_Deprecated(
 858     PP_Instance instance,
 859     void* user_data,
 860     const PPP_MessageHandler_0_1_Deprecated* handler,
 861     PP_Resource message_loop) {
 862   InstanceData* data =
 863       static_cast<PluginDispatcher*>(dispatcher())->GetInstanceData(instance);
 864   if (!data)
 865     return PP_ERROR_BADARGUMENT;
 866
 867   int32_t result = PP_ERROR_FAILED;
 868   scoped_ptr<MessageHandler> message_handler = MessageHandler::CreateDeprecated(
 869       instance, handler, user_data, message_loop, &result);
 870   if (message_handler)
 871     data->message_handler = message_handler.Pass();
 872   return result;
 873 }
 874
 875 void PPB_Instance_Proxy::UnregisterMessageHandler(PP_Instance instance) {
 876   InstanceData* data =
 877       static_cast<PluginDispatcher*>(dispatcher())->GetInstanceData(instance);
 878   if (!data)
 879     return;
 880   data->message_handler.reset();
 881 }
 882
 883 PP_Bool PPB_Instance_Proxy::SetCursor(PP_Instance instance,
 884                                       PP_MouseCursor_Type type,
 885                                       PP_Resource image,
 886                                       const PP_Point* hot_spot) {
 887   // Some of these parameters are important for security. This check is in the
 888   // plugin process just for the convenience of the caller (since we don't
 889   // bother returning errors from the other process with a sync message). The
 890   // parameters will be validated again in the renderer.
 891   if (!ValidateSetCursorParams(type, image, hot_spot))
 892     return PP_FALSE;
 893
 894   HostResource image_host_resource;
 895   if (image) {
 896     Resource* cursor_image =
 897         PpapiGlobals::Get()->GetResourceTracker()->GetResource(image);
 898     if (!cursor_image || cursor_image->pp_instance() != instance)
 899       return PP_FALSE;
 900     image_host_resource = cursor_image->host_resource();
 901   }
 902
 903   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SetCursor(
 904       API_ID_PPB_INSTANCE, instance, static_cast<int32_t>(type),
 905       image_host_resource, hot_spot ? *hot_spot : PP_MakePoint(0, 0)));
 906   return PP_TRUE;
 907 }
 908
 909 int32_t PPB_Instance_Proxy::LockMouse(PP_Instance instance,
 910                                       scoped_refptr<TrackedCallback> callback) {
 911   // Save the mouse callback on the instance data.
 912   InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
 913       GetInstanceData(instance);
 914   if (!data)
 915     return PP_ERROR_BADARGUMENT;
 916   if (TrackedCallback::IsPending(data->mouse_lock_callback))
 917     return PP_ERROR_INPROGRESS;  // Already have a pending callback.
 918   data->mouse_lock_callback = callback;
 919
 920   dispatcher()->Send(new PpapiHostMsg_PPBInstance_LockMouse(
 921       API_ID_PPB_INSTANCE, instance));
 922   return PP_OK_COMPLETIONPENDING;
 923 }
 924
 925 void PPB_Instance_Proxy::UnlockMouse(PP_Instance instance) {
 926   dispatcher()->Send(new PpapiHostMsg_PPBInstance_UnlockMouse(
 927       API_ID_PPB_INSTANCE, instance));
 928 }
 929
 930 void PPB_Instance_Proxy::SetTextInputType(PP_Instance instance,
 931                                           PP_TextInput_Type type) {
 932   CancelAnyPendingRequestSurroundingText(instance);
 933   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SetTextInputType(
 934       API_ID_PPB_INSTANCE, instance, type));
 935 }
 936
 937 void PPB_Instance_Proxy::UpdateCaretPosition(PP_Instance instance,
 938                                              const PP_Rect& caret,
 939                                              const PP_Rect& bounding_box) {
 940   dispatcher()->Send(new PpapiHostMsg_PPBInstance_UpdateCaretPosition(
 941       API_ID_PPB_INSTANCE, instance, caret, bounding_box));
 942 }
 943
 944 void PPB_Instance_Proxy::CancelCompositionText(PP_Instance instance) {
 945   CancelAnyPendingRequestSurroundingText(instance);
 946   dispatcher()->Send(new PpapiHostMsg_PPBInstance_CancelCompositionText(
 947       API_ID_PPB_INSTANCE, instance));
 948 }
 949
 950 void PPB_Instance_Proxy::SelectionChanged(PP_Instance instance) {
 951   // The "right" way to do this is to send the message to the host. However,
 952   // all it will do is call RequestSurroundingText with a hardcoded number of
 953   // characters in response, which is an entire IPC round-trip.
 954   //
 955   // We can avoid this round-trip by just implementing the
 956   // RequestSurroundingText logic in the plugin process. If the logic in the
 957   // host becomes more complex (like a more adaptive number of characters),
 958   // we'll need to reevanuate whether we want to do the round trip instead.
 959   //
 960   // Be careful to post a task to avoid reentering the plugin.
 961
 962   InstanceData* data =
 963       static_cast<PluginDispatcher*>(dispatcher())->GetInstanceData(instance);
 964   if (!data)
 965     return;
 966   data->should_do_request_surrounding_text = true;
 967
 968   if (!data->is_request_surrounding_text_pending) {
 969     base::MessageLoop::current()->PostTask(
 970         FROM_HERE,
 971         RunWhileLocked(base::Bind(&RequestSurroundingText, instance)));
 972     data->is_request_surrounding_text_pending = true;
 973   }
 974 }
 975
 976 void PPB_Instance_Proxy::UpdateSurroundingText(PP_Instance instance,
 977                                                const char* text,
 978                                                uint32_t caret,
 979                                                uint32_t anchor) {
 980   dispatcher()->Send(new PpapiHostMsg_PPBInstance_UpdateSurroundingText(
 981       API_ID_PPB_INSTANCE, instance, text, caret, anchor));
 982 }
 983
 984 #if !defined(OS_NACL)
 985 void PPB_Instance_Proxy::OnHostMsgGetWindowObject(
 986     PP_Instance instance,
 987     SerializedVarReturnValue result) {
 988   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
 989     return;
 990   EnterInstanceNoLock enter(instance);
 991   if (enter.succeeded())
 992     result.Return(dispatcher(), enter.functions()->GetWindowObject(instance));
 993 }
 994
 995 void PPB_Instance_Proxy::OnHostMsgGetOwnerElementObject(
 996     PP_Instance instance,
 997     SerializedVarReturnValue result) {
 998   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
 999     return;
1000   EnterInstanceNoLock enter(instance);
1001   if (enter.succeeded()) {
1002     result.Return(dispatcher(),
1003                   enter.functions()->GetOwnerElementObject(instance));
1004   }
1005 }
1006
1007 void PPB_Instance_Proxy::OnHostMsgBindGraphics(PP_Instance instance,
1008                                                PP_Resource device) {
1009   // Note that we ignroe the return value here. Otherwise, this would need to
1010   // be a slow sync call, and the plugin side of the proxy will have already
1011   // validated the resources, so we shouldn't see errors here that weren't
1012   // already caught.
1013   EnterInstanceNoLock enter(instance);
1014   if (enter.succeeded())
1015     enter.functions()->BindGraphics(instance, device);
1016 }
1017
1018 void PPB_Instance_Proxy::OnHostMsgGetAudioHardwareOutputSampleRate(
1019     PP_Instance instance, uint32_t* result) {
1020   EnterInstanceNoLock enter(instance);
1021   if (enter.succeeded())
1022     *result = enter.functions()->GetAudioHardwareOutputSampleRate(instance);
1023 }
1024
1025 void PPB_Instance_Proxy::OnHostMsgGetAudioHardwareOutputBufferSize(
1026     PP_Instance instance, uint32_t* result) {
1027   EnterInstanceNoLock enter(instance);
1028   if (enter.succeeded())
1029     *result = enter.functions()->GetAudioHardwareOutputBufferSize(instance);
1030 }
1031
1032 void PPB_Instance_Proxy::OnHostMsgIsFullFrame(PP_Instance instance,
1033                                               PP_Bool* result) {
1034   EnterInstanceNoLock enter(instance);
1035   if (enter.succeeded())
1036     *result = enter.functions()->IsFullFrame(instance);
1037 }
1038
1039 void PPB_Instance_Proxy::OnHostMsgExecuteScript(
1040     PP_Instance instance,
1041     SerializedVarReceiveInput script,
1042     SerializedVarOutParam out_exception,
1043     SerializedVarReturnValue result) {
1044   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1045     return;
1046   EnterInstanceNoLock enter(instance);
1047   if (enter.failed())
1048     return;
1049
1050   if (dispatcher()->IsPlugin())
1051     NOTREACHED();
1052   else
1053     static_cast<HostDispatcher*>(dispatcher())->set_allow_plugin_reentrancy();
1054
1055   result.Return(dispatcher(), enter.functions()->ExecuteScript(
1056       instance,
1057       script.Get(dispatcher()),
1058       out_exception.OutParam(dispatcher())));
1059 }
1060
1061 void PPB_Instance_Proxy::OnHostMsgGetDefaultCharSet(
1062     PP_Instance instance,
1063     SerializedVarReturnValue result) {
1064   if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
1065     return;
1066   EnterInstanceNoLock enter(instance);
1067   if (enter.succeeded())
1068     result.Return(dispatcher(), enter.functions()->GetDefaultCharSet(instance));
1069 }
1070
1071 void PPB_Instance_Proxy::OnHostMsgSetPluginToHandleFindRequests(
1072     PP_Instance instance) {
1073   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1074     return;
1075   EnterInstanceNoLock enter(instance);
1076   if (enter.succeeded())
1077     enter.functions()->SetPluginToHandleFindRequests(instance);
1078 }
1079
1080 void PPB_Instance_Proxy::OnHostMsgNumberOfFindResultsChanged(
1081     PP_Instance instance,
1082     int32_t total,
1083     PP_Bool final_result) {
1084   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1085     return;
1086   EnterInstanceNoLock enter(instance);
1087   if (enter.succeeded()) {
1088     enter.functions()->NumberOfFindResultsChanged(
1089         instance, total, final_result);
1090   }
1091 }
1092
1093 void PPB_Instance_Proxy::OnHostMsgSelectFindResultChanged(
1094     PP_Instance instance,
1095     int32_t index) {
1096   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1097     return;
1098   EnterInstanceNoLock enter(instance);
1099   if (enter.succeeded())
1100     enter.functions()->SelectedFindResultChanged(instance, index);
1101 }
1102
1103 void PPB_Instance_Proxy::OnHostMsgSetTickmarks(
1104     PP_Instance instance,
1105     const std::vector<PP_Rect>& tickmarks) {
1106   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1107     return;
1108   const PP_Rect* array = tickmarks.empty() ? NULL : &tickmarks[0];
1109   EnterInstanceNoLock enter(instance);
1110   if (enter.succeeded()) {
1111     enter.functions()->SetTickmarks(instance,
1112                                     array,
1113                                     static_cast<uint32_t>(tickmarks.size()));
1114   }
1115 }
1116
1117 void PPB_Instance_Proxy::OnHostMsgSetFullscreen(PP_Instance instance,
1118                                                 PP_Bool fullscreen,
1119                                                 PP_Bool* result) {
1120   EnterInstanceNoLock enter(instance);
1121   if (enter.succeeded())
1122     *result = enter.functions()->SetFullscreen(instance, fullscreen);
1123 }
1124
1125
1126 void PPB_Instance_Proxy::OnHostMsgGetScreenSize(PP_Instance instance,
1127                                                 PP_Bool* result,
1128                                                 PP_Size* size) {
1129   EnterInstanceNoLock enter(instance);
1130   if (enter.succeeded())
1131     *result = enter.functions()->GetScreenSize(instance, size);
1132 }
1133
1134 void PPB_Instance_Proxy::OnHostMsgRequestInputEvents(PP_Instance instance,
1135                                                      bool is_filtering,
1136                                                      uint32_t event_classes) {
1137   EnterInstanceNoLock enter(instance);
1138   if (enter.succeeded()) {
1139     if (is_filtering)
1140       enter.functions()->RequestFilteringInputEvents(instance, event_classes);
1141     else
1142       enter.functions()->RequestInputEvents(instance, event_classes);
1143   }
1144 }
1145
1146 void PPB_Instance_Proxy::OnHostMsgClearInputEvents(PP_Instance instance,
1147                                                    uint32_t event_classes) {
1148   EnterInstanceNoLock enter(instance);
1149   if (enter.succeeded())
1150     enter.functions()->ClearInputEventRequest(instance, event_classes);
1151 }
1152
1153 void PPB_Instance_Proxy::OnHostMsgStartTrackingLatency(PP_Instance instance) {
1154   EnterInstanceNoLock enter(instance);
1155   if (enter.succeeded())
1156     enter.functions()->StartTrackingLatency(instance);
1157 }
1158
1159 void PPB_Instance_Proxy::OnHostMsgPostMessage(
1160     PP_Instance instance,
1161     SerializedVarReceiveInput message) {
1162   EnterInstanceNoLock enter(instance);
1163   if (!message.is_valid_var()) {
1164     PpapiGlobals::Get()->LogWithSource(
1165         instance, PP_LOGLEVEL_ERROR, std::string(), kSerializationError);
1166     return;
1167   }
1168
1169   if (enter.succeeded())
1170     enter.functions()->PostMessage(instance,
1171                                    message.GetForInstance(dispatcher(),
1172                                                           instance));
1173 }
1174
1175 void PPB_Instance_Proxy::OnHostMsgLockMouse(PP_Instance instance) {
1176   // Need to be careful to always issue the callback.
1177   pp::CompletionCallback cb = callback_factory_.NewCallback(
1178       &PPB_Instance_Proxy::MouseLockCompleteInHost, instance);
1179
1180   EnterInstanceNoLock enter(instance, cb.pp_completion_callback());
1181   if (enter.succeeded())
1182     enter.SetResult(enter.functions()->LockMouse(instance, enter.callback()));
1183 }
1184
1185 void PPB_Instance_Proxy::OnHostMsgUnlockMouse(PP_Instance instance) {
1186   EnterInstanceNoLock enter(instance);
1187   if (enter.succeeded())
1188     enter.functions()->UnlockMouse(instance);
1189 }
1190
1191 void PPB_Instance_Proxy::OnHostMsgGetDocumentURL(
1192     PP_Instance instance,
1193     PP_URLComponents_Dev* components,
1194     SerializedVarReturnValue result) {
1195   if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
1196     return;
1197   EnterInstanceNoLock enter(instance);
1198   if (enter.succeeded()) {
1199     PP_Var document_url = enter.functions()->GetDocumentURL(instance,
1200                                                             components);
1201     result.Return(dispatcher(), document_url);
1202   }
1203 }
1204
1205 void PPB_Instance_Proxy::OnHostMsgResolveRelativeToDocument(
1206     PP_Instance instance,
1207     SerializedVarReceiveInput relative,
1208     SerializedVarReturnValue result) {
1209   if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
1210     return;
1211   EnterInstanceNoLock enter(instance);
1212   if (enter.succeeded()) {
1213     result.Return(dispatcher(),
1214                   enter.functions()->ResolveRelativeToDocument(
1215                       instance, relative.Get(dispatcher()), NULL));
1216   }
1217 }
1218
1219 void PPB_Instance_Proxy::OnHostMsgDocumentCanRequest(
1220     PP_Instance instance,
1221     SerializedVarReceiveInput url,
1222     PP_Bool* result) {
1223   if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
1224     return;
1225   EnterInstanceNoLock enter(instance);
1226   if (enter.succeeded()) {
1227     *result = enter.functions()->DocumentCanRequest(instance,
1228                                                     url.Get(dispatcher()));
1229   }
1230 }
1231
1232 void PPB_Instance_Proxy::OnHostMsgDocumentCanAccessDocument(PP_Instance active,
1233                                                             PP_Instance target,
1234                                                             PP_Bool* result) {
1235   if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
1236     return;
1237   EnterInstanceNoLock enter(active);
1238   if (enter.succeeded())
1239     *result = enter.functions()->DocumentCanAccessDocument(active, target);
1240 }
1241
1242 void PPB_Instance_Proxy::OnHostMsgGetPluginInstanceURL(
1243     PP_Instance instance,
1244     SerializedVarReturnValue result) {
1245   if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
1246     return;
1247   EnterInstanceNoLock enter(instance);
1248   if (enter.succeeded()) {
1249     result.Return(dispatcher(),
1250                   enter.functions()->GetPluginInstanceURL(instance, NULL));
1251   }
1252 }
1253
1254 void PPB_Instance_Proxy::OnHostMsgGetPluginReferrerURL(
1255     PP_Instance instance,
1256     SerializedVarReturnValue result) {
1257   if (!dispatcher()->permissions().HasPermission(PERMISSION_DEV))
1258     return;
1259   EnterInstanceNoLock enter(instance);
1260   if (enter.succeeded()) {
1261     result.Return(dispatcher(),
1262                   enter.functions()->GetPluginReferrerURL(instance, NULL));
1263   }
1264 }
1265
1266 void PPB_Instance_Proxy::OnHostMsgPromiseResolved(PP_Instance instance,
1267                                                   uint32_t promise_id) {
1268   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1269     return;
1270   EnterInstanceNoLock enter(instance);
1271   if (enter.succeeded()) {
1272     enter.functions()->PromiseResolved(instance, promise_id);
1273   }
1274 }
1275
1276 void PPB_Instance_Proxy::OnHostMsgPromiseResolvedWithSession(
1277     PP_Instance instance,
1278     uint32_t promise_id,
1279     SerializedVarReceiveInput web_session_id) {
1280   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1281     return;
1282   EnterInstanceNoLock enter(instance);
1283   if (enter.succeeded()) {
1284     enter.functions()->PromiseResolvedWithSession(
1285         instance, promise_id, web_session_id.Get(dispatcher()));
1286   }
1287 }
1288
1289 void PPB_Instance_Proxy::OnHostMsgPromiseResolvedWithKeyIds(
1290     PP_Instance instance,
1291     uint32_t promise_id,
1292     const std::vector<std::vector<uint8_t> >& key_ids) {
1293   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1294     return;
1295   if (key_ids.size() > media::limits::kMaxKeyIds) {
1296     NOTREACHED();
1297     return;
1298   }
1299
1300   scoped_refptr<ArrayVar> key_ids_array = new ArrayVar();
1301   key_ids_array->SetLength(key_ids.size());
1302   for (size_t i = 0; i < key_ids.size(); ++i) {
1303     const std::vector<uint8_t>& entry = key_ids[i];
1304     if (entry.size() < media::limits::kMinKeyIdLength ||
1305         entry.size() > media::limits::kMaxKeyIdLength) {
1306       NOTREACHED();
1307       continue;
1308     }
1309     key_ids_array->Set(
1310         i,
1311         PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(entry.size(),
1312                                                                    &entry[0]));
1313   }
1314
1315   EnterInstanceNoLock enter(instance);
1316   if (enter.succeeded()) {
1317     ScopedPPVar key_ids_var(ScopedPPVar::PassRef(), key_ids_array->GetPPVar());
1318     enter.functions()->PromiseResolvedWithKeyIds(
1319         instance, promise_id, key_ids_var.get());
1320   }
1321 }
1322
1323 void PPB_Instance_Proxy::OnHostMsgPromiseRejected(
1324     PP_Instance instance,
1325     uint32_t promise_id,
1326     PP_CdmExceptionCode exception_code,
1327     uint32_t system_code,
1328     SerializedVarReceiveInput error_description) {
1329   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1330     return;
1331   EnterInstanceNoLock enter(instance);
1332   if (enter.succeeded()) {
1333     enter.functions()->PromiseRejected(instance,
1334                                        promise_id,
1335                                        exception_code,
1336                                        system_code,
1337                                        error_description.Get(dispatcher()));
1338   }
1339 }
1340
1341 void PPB_Instance_Proxy::OnHostMsgSessionMessage(
1342     PP_Instance instance,
1343     SerializedVarReceiveInput web_session_id,
1344     SerializedVarReceiveInput message,
1345     SerializedVarReceiveInput destination_url) {
1346   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1347     return;
1348   EnterInstanceNoLock enter(instance);
1349   if (enter.succeeded()) {
1350     enter.functions()->SessionMessage(instance,
1351                                       web_session_id.Get(dispatcher()),
1352                                       message.Get(dispatcher()),
1353                                       destination_url.Get(dispatcher()));
1354   }
1355 }
1356
1357 void PPB_Instance_Proxy::OnHostMsgSessionKeysChange(
1358     PP_Instance instance,
1359     const std::string& web_session_id,
1360     PP_Bool has_additional_usable_key) {
1361   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1362     return;
1363   EnterInstanceNoLock enter(instance);
1364   if (enter.succeeded()) {
1365     ScopedPPVar web_session_id_var(ScopedPPVar::PassRef(),
1366                                    StringVar::StringToPPVar(web_session_id));
1367     enter.functions()->SessionKeysChange(
1368         instance, web_session_id_var.get(), has_additional_usable_key);
1369   }
1370 }
1371
1372 void PPB_Instance_Proxy::OnHostMsgSessionExpirationChange(
1373     PP_Instance instance,
1374     const std::string& web_session_id,
1375     PP_Time new_expiry_time) {
1376   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1377     return;
1378   EnterInstanceNoLock enter(instance);
1379   if (enter.succeeded()) {
1380     ScopedPPVar web_session_id_var(ScopedPPVar::PassRef(),
1381                                    StringVar::StringToPPVar(web_session_id));
1382     enter.functions()->SessionExpirationChange(
1383         instance, web_session_id_var.get(), new_expiry_time);
1384   }
1385 }
1386
1387 void PPB_Instance_Proxy::OnHostMsgSessionReady(
1388     PP_Instance instance,
1389     SerializedVarReceiveInput web_session_id) {
1390   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1391     return;
1392   EnterInstanceNoLock enter(instance);
1393   if (enter.succeeded()) {
1394     enter.functions()->SessionReady(instance, web_session_id.Get(dispatcher()));
1395   }
1396 }
1397
1398 void PPB_Instance_Proxy::OnHostMsgSessionClosed(
1399     PP_Instance instance,
1400     SerializedVarReceiveInput web_session_id) {
1401   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1402     return;
1403   EnterInstanceNoLock enter(instance);
1404   if (enter.succeeded()) {
1405     enter.functions()->SessionClosed(instance,
1406                                      web_session_id.Get(dispatcher()));
1407   }
1408 }
1409
1410 void PPB_Instance_Proxy::OnHostMsgSessionError(
1411     PP_Instance instance,
1412     SerializedVarReceiveInput web_session_id,
1413     PP_CdmExceptionCode exception_code,
1414     uint32_t system_code,
1415     SerializedVarReceiveInput error_description) {
1416   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1417     return;
1418   EnterInstanceNoLock enter(instance);
1419   if (enter.succeeded()) {
1420     enter.functions()->SessionError(instance,
1421                                     web_session_id.Get(dispatcher()),
1422                                     exception_code,
1423                                     system_code,
1424                                     error_description.Get(dispatcher()));
1425   }
1426 }
1427
1428 void PPB_Instance_Proxy::OnHostMsgDeliverBlock(
1429     PP_Instance instance,
1430     PP_Resource decrypted_block,
1431     const std::string& serialized_block_info) {
1432   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1433     return;
1434   PP_DecryptedBlockInfo block_info;
1435   if (!DeserializeBlockInfo(serialized_block_info, &block_info))
1436     return;
1437
1438   EnterInstanceNoLock enter(instance);
1439   if (enter.succeeded())
1440     enter.functions()->DeliverBlock(instance, decrypted_block, &block_info);
1441 }
1442
1443 void PPB_Instance_Proxy::OnHostMsgDecoderInitializeDone(
1444     PP_Instance instance,
1445     PP_DecryptorStreamType decoder_type,
1446     uint32_t request_id,
1447     PP_Bool success) {
1448   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1449     return;
1450   EnterInstanceNoLock enter(instance);
1451   if (enter.succeeded()) {
1452     enter.functions()->DecoderInitializeDone(instance,
1453                                              decoder_type,
1454                                              request_id,
1455                                              success);
1456   }
1457 }
1458
1459 void PPB_Instance_Proxy::OnHostMsgDecoderDeinitializeDone(
1460     PP_Instance instance,
1461     PP_DecryptorStreamType decoder_type,
1462     uint32_t request_id) {
1463   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1464     return;
1465   EnterInstanceNoLock enter(instance);
1466   if (enter.succeeded())
1467     enter.functions()->DecoderDeinitializeDone(instance,
1468                                                decoder_type,
1469                                                request_id);
1470 }
1471
1472 void PPB_Instance_Proxy::OnHostMsgDecoderResetDone(
1473     PP_Instance instance,
1474     PP_DecryptorStreamType decoder_type,
1475     uint32_t request_id) {
1476   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1477     return;
1478   EnterInstanceNoLock enter(instance);
1479   if (enter.succeeded())
1480     enter.functions()->DecoderResetDone(instance, decoder_type, request_id);
1481 }
1482
1483 void PPB_Instance_Proxy::OnHostMsgDeliverFrame(
1484     PP_Instance instance,
1485     PP_Resource decrypted_frame,
1486     const std::string& serialized_frame_info) {
1487   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1488     return;
1489   PP_DecryptedFrameInfo frame_info;
1490   if (!DeserializeBlockInfo(serialized_frame_info, &frame_info))
1491     return;
1492
1493   EnterInstanceNoLock enter(instance);
1494   if (enter.succeeded())
1495     enter.functions()->DeliverFrame(instance, decrypted_frame, &frame_info);
1496 }
1497
1498 void PPB_Instance_Proxy::OnHostMsgDeliverSamples(
1499     PP_Instance instance,
1500     PP_Resource audio_frames,
1501     const std::string& serialized_sample_info) {
1502   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
1503     return;
1504   PP_DecryptedSampleInfo sample_info;
1505   if (!DeserializeBlockInfo(serialized_sample_info, &sample_info))
1506     return;
1507
1508   EnterInstanceNoLock enter(instance);
1509   if (enter.succeeded())
1510     enter.functions()->DeliverSamples(instance, audio_frames, &sample_info);
1511 }
1512
1513 void PPB_Instance_Proxy::OnHostMsgSetCursor(
1514     PP_Instance instance,
1515     int32_t type,
1516     const ppapi::HostResource& custom_image,
1517     const PP_Point& hot_spot) {
1518   // This API serves PPB_CursorControl_Dev and PPB_MouseCursor, so is public.
1519   EnterInstanceNoLock enter(instance);
1520   if (enter.succeeded()) {
1521     enter.functions()->SetCursor(
1522         instance, static_cast<PP_MouseCursor_Type>(type),
1523         custom_image.host_resource(), &hot_spot);
1524   }
1525 }
1526
1527 void PPB_Instance_Proxy::OnHostMsgSetTextInputType(PP_Instance instance,
1528                                                    PP_TextInput_Type type) {
1529   EnterInstanceNoLock enter(instance);
1530   if (enter.succeeded())
1531     enter.functions()->SetTextInputType(instance, type);
1532 }
1533
1534 void PPB_Instance_Proxy::OnHostMsgUpdateCaretPosition(
1535     PP_Instance instance,
1536     const PP_Rect& caret,
1537     const PP_Rect& bounding_box) {
1538   EnterInstanceNoLock enter(instance);
1539   if (enter.succeeded())
1540     enter.functions()->UpdateCaretPosition(instance, caret, bounding_box);
1541 }
1542
1543 void PPB_Instance_Proxy::OnHostMsgCancelCompositionText(PP_Instance instance) {
1544   EnterInstanceNoLock enter(instance);
1545   if (enter.succeeded())
1546     enter.functions()->CancelCompositionText(instance);
1547 }
1548
1549 void PPB_Instance_Proxy::OnHostMsgUpdateSurroundingText(
1550     PP_Instance instance,
1551     const std::string& text,
1552     uint32_t caret,
1553     uint32_t anchor) {
1554   EnterInstanceNoLock enter(instance);
1555   if (enter.succeeded()) {
1556     enter.functions()->UpdateSurroundingText(instance, text.c_str(), caret,
1557                                              anchor);
1558   }
1559 }
1560 #endif  // !defined(OS_NACL)
1561
1562 void PPB_Instance_Proxy::OnPluginMsgMouseLockComplete(PP_Instance instance,
1563                                                       int32_t result) {
1564   if (!dispatcher()->IsPlugin())
1565     return;
1566
1567   // Save the mouse callback on the instance data.
1568   InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
1569       GetInstanceData(instance);
1570   if (!data)
1571     return;  // Instance was probably deleted.
1572   if (!TrackedCallback::IsPending(data->mouse_lock_callback)) {
1573     NOTREACHED();
1574     return;
1575   }
1576   data->mouse_lock_callback->Run(result);
1577 }
1578
1579 #if !defined(OS_NACL)
1580 void PPB_Instance_Proxy::MouseLockCompleteInHost(int32_t result,
1581                                                  PP_Instance instance) {
1582   dispatcher()->Send(new PpapiMsg_PPBInstance_MouseLockComplete(
1583       API_ID_PPB_INSTANCE, instance, result));
1584 }
1585 #endif  // !defined(OS_NACL)
1586
1587 void PPB_Instance_Proxy::CancelAnyPendingRequestSurroundingText(
1588     PP_Instance instance) {
1589   InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
1590       GetInstanceData(instance);
1591   if (!data)
1592     return;  // Instance was probably deleted.
1593   data->should_do_request_surrounding_text = false;
1594 }
1595
1596 }  // namespace proxy
1597 }  // namespace ppapi