ppapi/proxy/resource_creation_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/resource_creation_proxy.h"
   6
   7 #include "ppapi/c/pp_errors.h"
   8 #include "ppapi/c/pp_size.h"
   9 #include "ppapi/proxy/audio_input_resource.h"
  10 #include "ppapi/proxy/browser_font_resource_trusted.h"
  11 #include "ppapi/proxy/connection.h"
  12 #include "ppapi/proxy/ext_crx_file_system_private_resource.h"
  13 #include "ppapi/proxy/file_chooser_resource.h"
  14 #include "ppapi/proxy/file_io_resource.h"
  15 #include "ppapi/proxy/file_system_resource.h"
  16 #include "ppapi/proxy/flash_drm_resource.h"
  17 #include "ppapi/proxy/flash_font_file_resource.h"
  18 #include "ppapi/proxy/flash_menu_resource.h"
  19 #include "ppapi/proxy/graphics_2d_resource.h"
  20 #include "ppapi/proxy/host_resolver_private_resource.h"
  21 #include "ppapi/proxy/host_resolver_resource.h"
  22 #include "ppapi/proxy/net_address_resource.h"
  23 #include "ppapi/proxy/plugin_dispatcher.h"
  24 #include "ppapi/proxy/plugin_globals.h"
  25 #include "ppapi/proxy/plugin_resource_tracker.h"
  26 #include "ppapi/proxy/ppapi_messages.h"
  27 #include "ppapi/proxy/ppb_audio_proxy.h"
  28 #include "ppapi/proxy/ppb_broker_proxy.h"
  29 #include "ppapi/proxy/ppb_buffer_proxy.h"
  30 #include "ppapi/proxy/ppb_file_ref_proxy.h"
  31 #include "ppapi/proxy/ppb_flash_message_loop_proxy.h"
  32 #include "ppapi/proxy/ppb_graphics_3d_proxy.h"
  33 #include "ppapi/proxy/ppb_image_data_proxy.h"
  34 #include "ppapi/proxy/ppb_network_monitor_private_proxy.h"
  35 #include "ppapi/proxy/ppb_tcp_server_socket_private_proxy.h"
  36 #include "ppapi/proxy/ppb_tcp_socket_private_proxy.h"
  37 #include "ppapi/proxy/ppb_tcp_socket_proxy.h"
  38 #include "ppapi/proxy/ppb_video_decoder_proxy.h"
  39 #include "ppapi/proxy/ppb_x509_certificate_private_proxy.h"
  40 #include "ppapi/proxy/printing_resource.h"
  41 #include "ppapi/proxy/talk_resource.h"
  42 #include "ppapi/proxy/truetype_font_resource.h"
  43 #include "ppapi/proxy/udp_socket_private_resource.h"
  44 #include "ppapi/proxy/udp_socket_resource.h"
  45 #include "ppapi/proxy/url_loader_resource.h"
  46 #include "ppapi/proxy/url_request_info_resource.h"
  47 #include "ppapi/proxy/url_response_info_resource.h"
  48 #include "ppapi/proxy/video_capture_resource.h"
  49 #include "ppapi/proxy/video_destination_resource.h"
  50 #include "ppapi/proxy/video_source_resource.h"
  51 #include "ppapi/proxy/websocket_resource.h"
  52 #include "ppapi/shared_impl/api_id.h"
  53 #include "ppapi/shared_impl/host_resource.h"
  54 #include "ppapi/shared_impl/ppb_audio_config_shared.h"
  55 #include "ppapi/shared_impl/ppb_input_event_shared.h"
  56 #include "ppapi/shared_impl/ppb_resource_array_shared.h"
  57 #include "ppapi/shared_impl/var.h"
  58 #include "ppapi/thunk/enter.h"
  59 #include "ppapi/thunk/ppb_image_data_api.h"
  60
  61 using ppapi::thunk::ResourceCreationAPI;
  62
  63 namespace ppapi {
  64 namespace proxy {
  65
  66 ResourceCreationProxy::ResourceCreationProxy(Dispatcher* dispatcher)
  67     : InterfaceProxy(dispatcher) {
  68 }
  69
  70 ResourceCreationProxy::~ResourceCreationProxy() {
  71 }
  72
  73 // static
  74 InterfaceProxy* ResourceCreationProxy::Create(Dispatcher* dispatcher) {
  75   return new ResourceCreationProxy(dispatcher);
  76 }
  77
  78 PP_Resource ResourceCreationProxy::CreateFileIO(PP_Instance instance) {
  79   return (new FileIOResource(GetConnection(), instance))->GetReference();
  80 }
  81
  82 PP_Resource ResourceCreationProxy::CreateFileRef(PP_Instance instance,
  83                                                  PP_Resource file_system,
  84                                                  const char* path) {
  85   return PPB_FileRef_Proxy::CreateProxyResource(instance, file_system, path);
  86 }
  87
  88 PP_Resource ResourceCreationProxy::CreateFileRef(
  89     const PPB_FileRef_CreateInfo& create_info) {
  90   return PPB_FileRef_Proxy::DeserializeFileRef(create_info);
  91 }
  92
  93 PP_Resource ResourceCreationProxy::CreateFileSystem(
  94     PP_Instance instance,
  95     PP_FileSystemType type) {
  96   return (new FileSystemResource(GetConnection(), instance,
  97                                  type))->GetReference();
  98 }
  99
 100 PP_Resource ResourceCreationProxy::CreateIsolatedFileSystem(
 101     PP_Instance instance,
 102     const char* fsid) {
 103   FileSystemResource* fs = new FileSystemResource(
 104       GetConnection(), instance, PP_FILESYSTEMTYPE_ISOLATED);
 105   fs->InitIsolatedFileSystem(fsid);
 106   return fs->GetReference();
 107 }
 108
 109 PP_Resource ResourceCreationProxy::CreateIMEInputEvent(
 110     PP_Instance instance,
 111     PP_InputEvent_Type type,
 112     PP_TimeTicks time_stamp,
 113     struct PP_Var text,
 114     uint32_t segment_number,
 115     const uint32_t* segment_offsets,
 116     int32_t target_segment,
 117     uint32_t selection_start,
 118     uint32_t selection_end) {
 119   return PPB_InputEvent_Shared::CreateIMEInputEvent(
 120       OBJECT_IS_PROXY, instance, type, time_stamp, text, segment_number,
 121       segment_offsets, target_segment, selection_start, selection_end);
 122 }
 123
 124 PP_Resource ResourceCreationProxy::CreateKeyboardInputEvent(
 125     PP_Instance instance,
 126     PP_InputEvent_Type type,
 127     PP_TimeTicks time_stamp,
 128     uint32_t modifiers,
 129     uint32_t key_code,
 130     struct PP_Var character_text) {
 131   return PPB_InputEvent_Shared::CreateKeyboardInputEvent(
 132       OBJECT_IS_PROXY, instance, type, time_stamp, modifiers, key_code,
 133       character_text);
 134 }
 135
 136 PP_Resource ResourceCreationProxy::CreateMouseInputEvent(
 137     PP_Instance instance,
 138     PP_InputEvent_Type type,
 139     PP_TimeTicks time_stamp,
 140     uint32_t modifiers,
 141     PP_InputEvent_MouseButton mouse_button,
 142     const PP_Point* mouse_position,
 143     int32_t click_count,
 144     const PP_Point* mouse_movement) {
 145   return PPB_InputEvent_Shared::CreateMouseInputEvent(
 146       OBJECT_IS_PROXY, instance, type, time_stamp, modifiers,
 147       mouse_button, mouse_position, click_count, mouse_movement);
 148 }
 149
 150 PP_Resource ResourceCreationProxy::CreateTouchInputEvent(
 151     PP_Instance instance,
 152     PP_InputEvent_Type type,
 153     PP_TimeTicks time_stamp,
 154     uint32_t modifiers) {
 155   return PPB_InputEvent_Shared::CreateTouchInputEvent(
 156       OBJECT_IS_PROXY, instance, type, time_stamp, modifiers);
 157 }
 158
 159 PP_Resource ResourceCreationProxy::CreateResourceArray(
 160     PP_Instance instance,
 161     const PP_Resource elements[],
 162     uint32_t size) {
 163   PPB_ResourceArray_Shared* object = new PPB_ResourceArray_Shared(
 164       OBJECT_IS_PROXY, instance, elements, size);
 165   return object->GetReference();
 166 }
 167
 168 PP_Resource ResourceCreationProxy::CreateTrueTypeFont(
 169     PP_Instance instance,
 170     const PP_TrueTypeFontDesc_Dev* desc) {
 171   return (new TrueTypeFontResource(GetConnection(),
 172                                    instance, *desc))->GetReference();
 173
 174 }
 175
 176 PP_Resource ResourceCreationProxy::CreateURLLoader(PP_Instance instance) {
 177     return (new URLLoaderResource(GetConnection(), instance))->GetReference();
 178 }
 179
 180 PP_Resource ResourceCreationProxy::CreateURLRequestInfo(
 181     PP_Instance instance) {
 182   return (new URLRequestInfoResource(
 183       GetConnection(), instance, URLRequestInfoData()))->GetReference();
 184 }
 185
 186 PP_Resource ResourceCreationProxy::CreateWheelInputEvent(
 187     PP_Instance instance,
 188     PP_TimeTicks time_stamp,
 189     uint32_t modifiers,
 190     const PP_FloatPoint* wheel_delta,
 191     const PP_FloatPoint* wheel_ticks,
 192     PP_Bool scroll_by_page) {
 193   return PPB_InputEvent_Shared::CreateWheelInputEvent(
 194       OBJECT_IS_PROXY, instance, time_stamp, modifiers,
 195       wheel_delta, wheel_ticks, scroll_by_page);
 196 }
 197
 198 PP_Resource ResourceCreationProxy::CreateAudio(
 199     PP_Instance instance,
 200     PP_Resource config_id,
 201     PPB_Audio_Callback audio_callback,
 202     void* user_data) {
 203   return PPB_Audio_Proxy::CreateProxyResource(instance, config_id,
 204                                               audio_callback, user_data);
 205 }
 206
 207 PP_Resource ResourceCreationProxy::CreateAudioTrusted(PP_Instance instance) {
 208   // Proxied plugins can't create trusted audio devices.
 209   return 0;
 210 }
 211
 212 PP_Resource ResourceCreationProxy::CreateAudioConfig(
 213     PP_Instance instance,
 214     PP_AudioSampleRate sample_rate,
 215     uint32_t sample_frame_count) {
 216   return PPB_AudioConfig_Shared::Create(
 217       OBJECT_IS_PROXY, instance, sample_rate, sample_frame_count);
 218 }
 219
 220 PP_Resource ResourceCreationProxy::CreateFileChooser(
 221     PP_Instance instance,
 222     PP_FileChooserMode_Dev mode,
 223     const PP_Var& accept_types) {
 224   scoped_refptr<StringVar> string_var = StringVar::FromPPVar(accept_types);
 225   std::string str = string_var.get() ? string_var->value() : std::string();
 226   return (new FileChooserResource(GetConnection(), instance, mode, str.c_str()))
 227       ->GetReference();
 228 }
 229
 230 PP_Resource ResourceCreationProxy::CreateGraphics2D(PP_Instance instance,
 231                                                     const PP_Size* size,
 232                                                     PP_Bool is_always_opaque) {
 233   return (new Graphics2DResource(GetConnection(), instance, *size,
 234                                  is_always_opaque))->GetReference();
 235 }
 236
 237 PP_Resource ResourceCreationProxy::CreateGraphics3D(
 238     PP_Instance instance,
 239     PP_Resource share_context,
 240     const int32_t* attrib_list) {
 241   return PPB_Graphics3D_Proxy::CreateProxyResource(
 242       instance, share_context, attrib_list);
 243 }
 244
 245 PP_Resource ResourceCreationProxy::CreateGraphics3DRaw(
 246     PP_Instance instance,
 247     PP_Resource share_context,
 248     const int32_t* attrib_list) {
 249   // Not proxied. The raw creation function is used only in the implementation
 250   // of the proxy on the host side.
 251   return 0;
 252 }
 253
 254 PP_Resource ResourceCreationProxy::CreateHostResolver(PP_Instance instance) {
 255   return (new HostResolverResource(GetConnection(), instance))->GetReference();
 256 }
 257
 258 PP_Resource ResourceCreationProxy::CreateHostResolverPrivate(
 259     PP_Instance instance) {
 260   return (new HostResolverPrivateResource(
 261       GetConnection(), instance))->GetReference();
 262 }
 263
 264 PP_Resource ResourceCreationProxy::CreateImageData(
 265     PP_Instance instance,
 266     PP_ImageDataFormat format,
 267     const PP_Size* size,
 268     PP_Bool init_to_zero) {
 269   // On the plugin side, we create PlatformImageData resources for trusted
 270   // plugins and SimpleImageData resources for untrusted ones.
 271   PPB_ImageData_Shared::ImageDataType type =
 272 #if !defined(OS_NACL)
 273       PPB_ImageData_Shared::PLATFORM;
 274 #else
 275       PPB_ImageData_Shared::SIMPLE;
 276 #endif
 277   return PPB_ImageData_Proxy::CreateProxyResource(
 278       instance, type,
 279       format, *size, init_to_zero);
 280 }
 281
 282 PP_Resource ResourceCreationProxy::CreateImageDataSimple(
 283     PP_Instance instance,
 284     PP_ImageDataFormat format,
 285     const PP_Size* size,
 286     PP_Bool init_to_zero) {
 287   return PPB_ImageData_Proxy::CreateProxyResource(
 288       instance,
 289       PPB_ImageData_Shared::SIMPLE,
 290       format, *size, init_to_zero);
 291 }
 292
 293 PP_Resource ResourceCreationProxy::CreateNetAddressFromIPv4Address(
 294     PP_Instance instance,
 295     const PP_NetAddress_IPv4* ipv4_addr) {
 296   return (new NetAddressResource(GetConnection(), instance,
 297                                  *ipv4_addr))->GetReference();
 298 }
 299
 300 PP_Resource ResourceCreationProxy::CreateNetAddressFromIPv6Address(
 301     PP_Instance instance,
 302     const PP_NetAddress_IPv6* ipv6_addr) {
 303   return (new NetAddressResource(GetConnection(), instance,
 304                                  *ipv6_addr))->GetReference();
 305 }
 306
 307 PP_Resource ResourceCreationProxy::CreateNetAddressFromNetAddressPrivate(
 308     PP_Instance instance,
 309     const PP_NetAddress_Private& private_addr) {
 310   return (new NetAddressResource(GetConnection(), instance,
 311                                  private_addr))->GetReference();
 312 }
 313
 314 PP_Resource ResourceCreationProxy::CreateNetworkMonitor(
 315     PP_Instance instance,
 316     PPB_NetworkMonitor_Callback callback,
 317     void* user_data) {
 318   return PPB_NetworkMonitor_Private_Proxy::CreateProxyResource(
 319       instance, callback, user_data);
 320 }
 321
 322 PP_Resource ResourceCreationProxy::CreatePrinting(PP_Instance instance) {
 323   return (new PrintingResource(GetConnection(), instance))->GetReference();
 324 }
 325
 326 PP_Resource ResourceCreationProxy::CreateTCPServerSocketPrivate(
 327     PP_Instance instance) {
 328   return PPB_TCPServerSocket_Private_Proxy::CreateProxyResource(instance);
 329 }
 330
 331 PP_Resource ResourceCreationProxy::CreateTCPSocket(
 332     PP_Instance instance) {
 333   return PPB_TCPSocket_Proxy::CreateProxyResource(instance);
 334 }
 335
 336 PP_Resource ResourceCreationProxy::CreateTCPSocketPrivate(
 337     PP_Instance instance) {
 338   return PPB_TCPSocket_Private_Proxy::CreateProxyResource(instance);
 339 }
 340
 341 PP_Resource ResourceCreationProxy::CreateUDPSocket(PP_Instance instance) {
 342   return (new UDPSocketResource(GetConnection(), instance))->GetReference();
 343 }
 344
 345 PP_Resource ResourceCreationProxy::CreateUDPSocketPrivate(
 346     PP_Instance instance) {
 347   return (new UDPSocketPrivateResource(
 348       GetConnection(), instance))->GetReference();
 349 }
 350
 351 PP_Resource ResourceCreationProxy::CreateVideoDestination(
 352     PP_Instance instance) {
 353   return (new VideoDestinationResource(GetConnection(),
 354                                        instance))->GetReference();
 355 }
 356
 357 PP_Resource ResourceCreationProxy::CreateVideoSource(
 358     PP_Instance instance) {
 359   return (new VideoSourceResource(GetConnection(), instance))->GetReference();
 360 }
 361
 362 PP_Resource ResourceCreationProxy::CreateWebSocket(PP_Instance instance) {
 363   return (new WebSocketResource(GetConnection(), instance))->GetReference();
 364 }
 365
 366 PP_Resource ResourceCreationProxy::CreateX509CertificatePrivate(
 367     PP_Instance instance) {
 368   return PPB_X509Certificate_Private_Proxy::CreateProxyResource(instance);
 369 }
 370
 371 #if !defined(OS_NACL)
 372 PP_Resource ResourceCreationProxy::CreateAudioInput(
 373     PP_Instance instance) {
 374   return (new AudioInputResource(GetConnection(), instance))->GetReference();
 375 }
 376
 377 PP_Resource ResourceCreationProxy::CreateBroker(PP_Instance instance) {
 378   return PPB_Broker_Proxy::CreateProxyResource(instance);
 379 }
 380
 381 PP_Resource ResourceCreationProxy::CreateBrowserFont(
 382     PP_Instance instance,
 383     const PP_BrowserFont_Trusted_Description* description) {
 384   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
 385   if (!dispatcher)
 386     return 0;
 387   if (!BrowserFontResource_Trusted::IsPPFontDescriptionValid(*description))
 388     return 0;
 389   return (new BrowserFontResource_Trusted(GetConnection(), instance,
 390       *description, dispatcher->preferences()))->GetReference();
 391 }
 392
 393 PP_Resource ResourceCreationProxy::CreateBuffer(PP_Instance instance,
 394                                                 uint32_t size) {
 395   return PPB_Buffer_Proxy::CreateProxyResource(instance, size);
 396 }
 397
 398 PP_Resource ResourceCreationProxy::CreateFlashDRM(PP_Instance instance) {
 399   return (new FlashDRMResource(GetConnection(), instance))->GetReference();
 400 }
 401
 402 PP_Resource ResourceCreationProxy::CreateFlashFontFile(
 403     PP_Instance instance,
 404     const PP_BrowserFont_Trusted_Description* description,
 405     PP_PrivateFontCharset charset) {
 406   return (new FlashFontFileResource(
 407       GetConnection(), instance, description, charset))->GetReference();
 408 }
 409
 410 PP_Resource ResourceCreationProxy::CreateFlashMenu(
 411     PP_Instance instance,
 412     const PP_Flash_Menu* menu_data) {
 413   scoped_refptr<FlashMenuResource> flash_menu(
 414       new FlashMenuResource(GetConnection(), instance));
 415   if (!flash_menu->Initialize(menu_data))
 416     return 0;
 417   return flash_menu->GetReference();
 418 }
 419
 420 PP_Resource ResourceCreationProxy::CreateFlashMessageLoop(
 421     PP_Instance instance) {
 422   return PPB_Flash_MessageLoop_Proxy::CreateProxyResource(instance);
 423 }
 424
 425 PP_Resource ResourceCreationProxy::CreateScrollbar(PP_Instance instance,
 426                                                    PP_Bool vertical) {
 427   NOTIMPLEMENTED();  // Not proxied yet.
 428   return 0;
 429 }
 430
 431 PP_Resource ResourceCreationProxy::CreateTalk(PP_Instance instance) {
 432   return (new TalkResource(GetConnection(), instance))->GetReference();
 433 }
 434
 435 PP_Resource ResourceCreationProxy::CreateVideoCapture(PP_Instance instance) {
 436   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
 437   if (!dispatcher)
 438     return 0;
 439   return (new VideoCaptureResource(GetConnection(), instance, dispatcher))
 440       ->GetReference();
 441 }
 442
 443 PP_Resource ResourceCreationProxy::CreateVideoDecoder(
 444     PP_Instance instance,
 445     PP_Resource context3d_id,
 446     PP_VideoDecoder_Profile profile) {
 447   return PPB_VideoDecoder_Proxy::CreateProxyResource(
 448       instance, context3d_id, profile);
 449 }
 450
 451 #endif  // !defined(OS_NACL)
 452
 453 bool ResourceCreationProxy::Send(IPC::Message* msg) {
 454   return dispatcher()->Send(msg);
 455 }
 456
 457 bool ResourceCreationProxy::OnMessageReceived(const IPC::Message& msg) {
 458   return false;
 459 }
 460
 461 Connection ResourceCreationProxy::GetConnection() {
 462   return Connection(PluginGlobals::Get()->GetBrowserSender(), dispatcher());
 463 }
 464
 465 }  // namespace proxy
 466 }  // namespace ppapi