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