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