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.
5 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
8 #include "base/callback_helpers.h"
9 #include "base/command_line.h"
10 #include "base/debug/trace_event.h"
11 #include "base/logging.h"
12 #include "base/memory/linked_ptr.h"
13 #include "base/message_loop/message_loop.h"
14 #include "base/stl_util.h"
15 #include "base/strings/stringprintf.h"
16 #include "base/strings/utf_offset_string_conversions.h"
17 #include "base/strings/utf_string_conversions.h"
18 #include "base/time/time.h"
19 #include "cc/layers/texture_layer.h"
20 #include "content/common/content_constants_internal.h"
21 #include "content/public/common/content_switches.h"
22 #include "content/public/common/page_zoom.h"
23 #include "content/public/renderer/content_renderer_client.h"
24 #include "content/renderer/pepper/common.h"
25 #include "content/renderer/pepper/content_decryptor_delegate.h"
26 #include "content/renderer/pepper/event_conversion.h"
27 #include "content/renderer/pepper/fullscreen_container.h"
28 #include "content/renderer/pepper/gfx_conversion.h"
29 #include "content/renderer/pepper/host_dispatcher_wrapper.h"
30 #include "content/renderer/pepper/host_globals.h"
31 #include "content/renderer/pepper/message_channel.h"
32 #include "content/renderer/pepper/npapi_glue.h"
33 #include "content/renderer/pepper/pepper_browser_connection.h"
34 #include "content/renderer/pepper/pepper_file_ref_renderer_host.h"
35 #include "content/renderer/pepper/pepper_graphics_2d_host.h"
36 #include "content/renderer/pepper/pepper_in_process_router.h"
37 #include "content/renderer/pepper/pepper_url_loader_host.h"
38 #include "content/renderer/pepper/plugin_module.h"
39 #include "content/renderer/pepper/plugin_object.h"
40 #include "content/renderer/pepper/ppb_buffer_impl.h"
41 #include "content/renderer/pepper/ppb_graphics_3d_impl.h"
42 #include "content/renderer/pepper/ppb_image_data_impl.h"
43 #include "content/renderer/pepper/renderer_ppapi_host_impl.h"
44 #include "content/renderer/pepper/url_request_info_util.h"
45 #include "content/renderer/pepper/url_response_info_util.h"
46 #include "content/renderer/render_frame_impl.h"
47 #include "content/renderer/render_thread_impl.h"
48 #include "content/renderer/render_view_impl.h"
49 #include "content/renderer/render_widget.h"
50 #include "content/renderer/render_widget_fullscreen_pepper.h"
51 #include "content/renderer/sad_plugin.h"
52 #include "media/base/audio_hardware_config.h"
53 #include "ppapi/c/dev/ppb_zoom_dev.h"
54 #include "ppapi/c/dev/ppp_selection_dev.h"
55 #include "ppapi/c/dev/ppp_text_input_dev.h"
56 #include "ppapi/c/dev/ppp_zoom_dev.h"
57 #include "ppapi/c/pp_rect.h"
58 #include "ppapi/c/ppb_audio_config.h"
59 #include "ppapi/c/ppb_core.h"
60 #include "ppapi/c/ppb_gamepad.h"
61 #include "ppapi/c/ppp_input_event.h"
62 #include "ppapi/c/ppp_instance.h"
63 #include "ppapi/c/ppp_messaging.h"
64 #include "ppapi/c/ppp_mouse_lock.h"
65 #include "ppapi/c/private/ppb_find_private.h"
66 #include "ppapi/c/private/ppp_find_private.h"
67 #include "ppapi/c/private/ppp_instance_private.h"
68 #include "ppapi/c/private/ppp_pdf.h"
69 #include "ppapi/host/ppapi_host.h"
70 #include "ppapi/proxy/ppapi_messages.h"
71 #include "ppapi/proxy/serialized_var.h"
72 #include "ppapi/proxy/uma_private_resource.h"
73 #include "ppapi/proxy/url_loader_resource.h"
74 #include "ppapi/shared_impl/ppapi_permissions.h"
75 #include "ppapi/shared_impl/ppapi_preferences.h"
76 #include "ppapi/shared_impl/ppb_gamepad_shared.h"
77 #include "ppapi/shared_impl/ppb_input_event_shared.h"
78 #include "ppapi/shared_impl/ppb_url_util_shared.h"
79 #include "ppapi/shared_impl/ppb_view_shared.h"
80 #include "ppapi/shared_impl/ppp_instance_combined.h"
81 #include "ppapi/shared_impl/resource.h"
82 #include "ppapi/shared_impl/scoped_pp_resource.h"
83 #include "ppapi/shared_impl/time_conversion.h"
84 #include "ppapi/shared_impl/url_request_info_data.h"
85 #include "ppapi/shared_impl/var.h"
86 #include "ppapi/thunk/enter.h"
87 #include "ppapi/thunk/ppb_buffer_api.h"
88 #include "printing/metafile.h"
89 #include "printing/metafile_skia_wrapper.h"
90 #include "printing/units.h"
91 #include "skia/ext/platform_canvas.h"
92 #include "skia/ext/platform_device.h"
93 #include "third_party/WebKit/public/platform/WebCursorInfo.h"
94 #include "third_party/WebKit/public/platform/WebGamepads.h"
95 #include "third_party/WebKit/public/platform/WebRect.h"
96 #include "third_party/WebKit/public/platform/WebString.h"
97 #include "third_party/WebKit/public/platform/WebURL.h"
98 #include "third_party/WebKit/public/platform/WebURLError.h"
99 #include "third_party/WebKit/public/platform/WebURLRequest.h"
100 #include "third_party/WebKit/public/web/WebBindings.h"
101 #include "third_party/WebKit/public/web/WebCompositionUnderline.h"
102 #include "third_party/WebKit/public/web/WebDataSource.h"
103 #include "third_party/WebKit/public/web/WebDocument.h"
104 #include "third_party/WebKit/public/web/WebElement.h"
105 #include "third_party/WebKit/public/web/WebInputEvent.h"
106 #include "third_party/WebKit/public/web/WebLocalFrame.h"
107 #include "third_party/WebKit/public/web/WebPluginContainer.h"
108 #include "third_party/WebKit/public/web/WebPrintParams.h"
109 #include "third_party/WebKit/public/web/WebPrintScalingOption.h"
110 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
111 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
112 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
113 #include "third_party/WebKit/public/web/WebView.h"
114 #include "third_party/khronos/GLES2/gl2.h"
115 #include "third_party/skia/include/core/SkCanvas.h"
116 #include "third_party/skia/include/core/SkRect.h"
117 #include "ui/gfx/image/image_skia.h"
118 #include "ui/gfx/image/image_skia_rep.h"
119 #include "ui/gfx/range/range.h"
120 #include "ui/gfx/rect_conversions.h"
121 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
122 #include "v8/include/v8.h"
123 #include "webkit/renderer/compositor_bindings/web_layer_impl.h"
125 #if defined(OS_CHROMEOS)
126 #include "ui/events/keycodes/keyboard_codes_posix.h"
129 #if defined(OS_MACOSX)
130 #include "printing/metafile_impl.h"
131 #endif // defined(OS_MACOSX)
134 #include "base/metrics/histogram.h"
135 #include "base/win/windows_version.h"
136 #include "skia/ext/platform_canvas.h"
137 #include "ui/gfx/codec/jpeg_codec.h"
138 #include "ui/gfx/gdi_util.h"
141 using base::StringPrintf;
142 using ppapi::InputEventData;
143 using ppapi::PpapiGlobals;
144 using ppapi::PPB_InputEvent_Shared;
145 using ppapi::PPB_View_Shared;
146 using ppapi::PPP_Instance_Combined;
147 using ppapi::Resource;
148 using ppapi::ScopedPPResource;
149 using ppapi::StringVar;
150 using ppapi::TrackedCallback;
151 using ppapi::thunk::EnterResourceNoLock;
152 using ppapi::thunk::PPB_Buffer_API;
153 using ppapi::thunk::PPB_Gamepad_API;
154 using ppapi::thunk::PPB_Graphics2D_API;
155 using ppapi::thunk::PPB_Graphics3D_API;
156 using ppapi::thunk::PPB_ImageData_API;
158 using ppapi::ArrayBufferVar;
159 using ppapi::ViewData;
160 using blink::WebBindings;
161 using blink::WebCanvas;
162 using blink::WebCursorInfo;
163 using blink::WebDocument;
164 using blink::WebElement;
165 using blink::WebFrame;
166 using blink::WebInputEvent;
167 using blink::WebLocalFrame;
168 using blink::WebPlugin;
169 using blink::WebPluginContainer;
170 using blink::WebPrintParams;
171 using blink::WebPrintScalingOption;
172 using blink::WebScopedUserGesture;
173 using blink::WebString;
174 using blink::WebURLError;
175 using blink::WebURLLoader;
176 using blink::WebURLLoaderClient;
177 using blink::WebURLRequest;
178 using blink::WebURLResponse;
179 using blink::WebUserGestureIndicator;
180 using blink::WebUserGestureToken;
181 using blink::WebView;
186 // Exported by pdf.dll
187 typedef bool (*RenderPDFPageToDCProc)(const unsigned char* pdf_buffer,
198 bool stretch_to_bounds,
199 bool keep_aspect_ratio,
200 bool center_in_bounds,
203 void DrawEmptyRectangle(HDC dc) {
204 // TODO(sanjeevr): This is a temporary hack. If we output a JPEG
205 // to the EMF, the EnumEnhMetaFile call fails in the browser
206 // process. The failure also happens if we output nothing here.
207 // We need to investigate the reason for this failure and fix it.
208 // In the meantime this temporary hack of drawing an empty
209 // rectangle in the DC gets us by.
210 Rectangle(dc, 0, 0, 0, 0);
212 #endif // defined(OS_WIN)
216 // Check PP_TextInput_Type and ui::TextInputType are kept in sync.
217 COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_NONE) == int(PP_TEXTINPUT_TYPE_NONE),
219 COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_TEXT) == int(PP_TEXTINPUT_TYPE_TEXT),
221 COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_PASSWORD) ==
222 int(PP_TEXTINPUT_TYPE_PASSWORD),
224 COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_SEARCH) == int(PP_TEXTINPUT_TYPE_SEARCH),
226 COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_EMAIL) == int(PP_TEXTINPUT_TYPE_EMAIL),
228 COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_NUMBER) == int(PP_TEXTINPUT_TYPE_NUMBER),
230 COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_TELEPHONE) ==
231 int(PP_TEXTINPUT_TYPE_TELEPHONE),
233 COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_URL) == int(PP_TEXTINPUT_TYPE_URL),
236 // The default text input type is to regard the plugin always accept text input.
237 // This is for allowing users to use input methods even on completely-IME-
238 // unaware plugins (e.g., PPAPI Flash or PDF plugin for M16).
239 // Plugins need to explicitly opt out the text input mode if they know
240 // that they don't accept texts.
241 const ui::TextInputType kPluginDefaultTextInputType = ui::TEXT_INPUT_TYPE_TEXT;
243 #define COMPILE_ASSERT_MATCHING_ENUM(webkit_name, np_name) \
244 COMPILE_ASSERT(static_cast<int>(WebCursorInfo::webkit_name) == \
245 static_cast<int>(np_name), \
248 #define COMPILE_ASSERT_PRINT_SCALING_MATCHING_ENUM(webkit_name, pp_name) \
249 COMPILE_ASSERT(static_cast<int>(webkit_name) == static_cast<int>(pp_name), \
252 // <embed>/<object> attributes.
253 const char kWidth[] = "width";
254 const char kHeight[] = "height";
255 const char kBorder[] = "border"; // According to w3c, deprecated.
256 const char kStyle[] = "style";
258 COMPILE_ASSERT_MATCHING_ENUM(TypePointer, PP_MOUSECURSOR_TYPE_POINTER);
259 COMPILE_ASSERT_MATCHING_ENUM(TypeCross, PP_MOUSECURSOR_TYPE_CROSS);
260 COMPILE_ASSERT_MATCHING_ENUM(TypeHand, PP_MOUSECURSOR_TYPE_HAND);
261 COMPILE_ASSERT_MATCHING_ENUM(TypeIBeam, PP_MOUSECURSOR_TYPE_IBEAM);
262 COMPILE_ASSERT_MATCHING_ENUM(TypeWait, PP_MOUSECURSOR_TYPE_WAIT);
263 COMPILE_ASSERT_MATCHING_ENUM(TypeHelp, PP_MOUSECURSOR_TYPE_HELP);
264 COMPILE_ASSERT_MATCHING_ENUM(TypeEastResize, PP_MOUSECURSOR_TYPE_EASTRESIZE);
265 COMPILE_ASSERT_MATCHING_ENUM(TypeNorthResize, PP_MOUSECURSOR_TYPE_NORTHRESIZE);
266 COMPILE_ASSERT_MATCHING_ENUM(TypeNorthEastResize,
267 PP_MOUSECURSOR_TYPE_NORTHEASTRESIZE);
268 COMPILE_ASSERT_MATCHING_ENUM(TypeNorthWestResize,
269 PP_MOUSECURSOR_TYPE_NORTHWESTRESIZE);
270 COMPILE_ASSERT_MATCHING_ENUM(TypeSouthResize, PP_MOUSECURSOR_TYPE_SOUTHRESIZE);
271 COMPILE_ASSERT_MATCHING_ENUM(TypeSouthEastResize,
272 PP_MOUSECURSOR_TYPE_SOUTHEASTRESIZE);
273 COMPILE_ASSERT_MATCHING_ENUM(TypeSouthWestResize,
274 PP_MOUSECURSOR_TYPE_SOUTHWESTRESIZE);
275 COMPILE_ASSERT_MATCHING_ENUM(TypeWestResize, PP_MOUSECURSOR_TYPE_WESTRESIZE);
276 COMPILE_ASSERT_MATCHING_ENUM(TypeNorthSouthResize,
277 PP_MOUSECURSOR_TYPE_NORTHSOUTHRESIZE);
278 COMPILE_ASSERT_MATCHING_ENUM(TypeEastWestResize,
279 PP_MOUSECURSOR_TYPE_EASTWESTRESIZE);
280 COMPILE_ASSERT_MATCHING_ENUM(TypeNorthEastSouthWestResize,
281 PP_MOUSECURSOR_TYPE_NORTHEASTSOUTHWESTRESIZE);
282 COMPILE_ASSERT_MATCHING_ENUM(TypeNorthWestSouthEastResize,
283 PP_MOUSECURSOR_TYPE_NORTHWESTSOUTHEASTRESIZE);
284 COMPILE_ASSERT_MATCHING_ENUM(TypeColumnResize,
285 PP_MOUSECURSOR_TYPE_COLUMNRESIZE);
286 COMPILE_ASSERT_MATCHING_ENUM(TypeRowResize, PP_MOUSECURSOR_TYPE_ROWRESIZE);
287 COMPILE_ASSERT_MATCHING_ENUM(TypeMiddlePanning,
288 PP_MOUSECURSOR_TYPE_MIDDLEPANNING);
289 COMPILE_ASSERT_MATCHING_ENUM(TypeEastPanning, PP_MOUSECURSOR_TYPE_EASTPANNING);
290 COMPILE_ASSERT_MATCHING_ENUM(TypeNorthPanning,
291 PP_MOUSECURSOR_TYPE_NORTHPANNING);
292 COMPILE_ASSERT_MATCHING_ENUM(TypeNorthEastPanning,
293 PP_MOUSECURSOR_TYPE_NORTHEASTPANNING);
294 COMPILE_ASSERT_MATCHING_ENUM(TypeNorthWestPanning,
295 PP_MOUSECURSOR_TYPE_NORTHWESTPANNING);
296 COMPILE_ASSERT_MATCHING_ENUM(TypeSouthPanning,
297 PP_MOUSECURSOR_TYPE_SOUTHPANNING);
298 COMPILE_ASSERT_MATCHING_ENUM(TypeSouthEastPanning,
299 PP_MOUSECURSOR_TYPE_SOUTHEASTPANNING);
300 COMPILE_ASSERT_MATCHING_ENUM(TypeSouthWestPanning,
301 PP_MOUSECURSOR_TYPE_SOUTHWESTPANNING);
302 COMPILE_ASSERT_MATCHING_ENUM(TypeWestPanning, PP_MOUSECURSOR_TYPE_WESTPANNING);
303 COMPILE_ASSERT_MATCHING_ENUM(TypeMove, PP_MOUSECURSOR_TYPE_MOVE);
304 COMPILE_ASSERT_MATCHING_ENUM(TypeVerticalText,
305 PP_MOUSECURSOR_TYPE_VERTICALTEXT);
306 COMPILE_ASSERT_MATCHING_ENUM(TypeCell, PP_MOUSECURSOR_TYPE_CELL);
307 COMPILE_ASSERT_MATCHING_ENUM(TypeContextMenu, PP_MOUSECURSOR_TYPE_CONTEXTMENU);
308 COMPILE_ASSERT_MATCHING_ENUM(TypeAlias, PP_MOUSECURSOR_TYPE_ALIAS);
309 COMPILE_ASSERT_MATCHING_ENUM(TypeProgress, PP_MOUSECURSOR_TYPE_PROGRESS);
310 COMPILE_ASSERT_MATCHING_ENUM(TypeNoDrop, PP_MOUSECURSOR_TYPE_NODROP);
311 COMPILE_ASSERT_MATCHING_ENUM(TypeCopy, PP_MOUSECURSOR_TYPE_COPY);
312 COMPILE_ASSERT_MATCHING_ENUM(TypeNone, PP_MOUSECURSOR_TYPE_NONE);
313 COMPILE_ASSERT_MATCHING_ENUM(TypeNotAllowed, PP_MOUSECURSOR_TYPE_NOTALLOWED);
314 COMPILE_ASSERT_MATCHING_ENUM(TypeZoomIn, PP_MOUSECURSOR_TYPE_ZOOMIN);
315 COMPILE_ASSERT_MATCHING_ENUM(TypeZoomOut, PP_MOUSECURSOR_TYPE_ZOOMOUT);
316 COMPILE_ASSERT_MATCHING_ENUM(TypeGrab, PP_MOUSECURSOR_TYPE_GRAB);
317 COMPILE_ASSERT_MATCHING_ENUM(TypeGrabbing, PP_MOUSECURSOR_TYPE_GRABBING);
318 // Do not assert WebCursorInfo::TypeCustom == PP_CURSORTYPE_CUSTOM;
319 // PP_CURSORTYPE_CUSTOM is pinned to allow new cursor types.
321 COMPILE_ASSERT_PRINT_SCALING_MATCHING_ENUM(blink::WebPrintScalingOptionNone,
322 PP_PRINTSCALINGOPTION_NONE);
323 COMPILE_ASSERT_PRINT_SCALING_MATCHING_ENUM(
324 blink::WebPrintScalingOptionFitToPrintableArea,
325 PP_PRINTSCALINGOPTION_FIT_TO_PRINTABLE_AREA);
326 COMPILE_ASSERT_PRINT_SCALING_MATCHING_ENUM(
327 blink::WebPrintScalingOptionSourceSize,
328 PP_PRINTSCALINGOPTION_SOURCE_SIZE);
330 // Sets |*security_origin| to be the WebKit security origin associated with the
331 // document containing the given plugin instance. On success, returns true. If
332 // the instance is invalid, returns false and |*security_origin| will be
334 bool SecurityOriginForInstance(PP_Instance instance_id,
335 blink::WebSecurityOrigin* security_origin) {
336 PepperPluginInstanceImpl* instance =
337 HostGlobals::Get()->GetInstance(instance_id);
341 WebElement plugin_element = instance->container()->element();
342 *security_origin = plugin_element.document().securityOrigin();
346 // Convert the given vector to an array of C-strings. The strings in the
347 // returned vector are only guaranteed valid so long as the vector of strings
349 scoped_ptr<const char* []> StringVectorToArgArray(
350 const std::vector<std::string>& vector) {
351 scoped_ptr<const char * []> array(new const char* [vector.size()]);
352 for (size_t i = 0; i < vector.size(); ++i)
353 array[i] = vector[i].c_str();
357 // Returns true if this is a "system reserved" key which should not be sent to
358 // a plugin. Some poorly behaving plugins (like Flash) incorrectly report that
359 // they handle all keys sent to them. This can prevent keystrokes from working
360 // for things like screen brightness and volume control.
361 bool IsReservedSystemInputEvent(const blink::WebInputEvent& event) {
362 #if defined(OS_CHROMEOS)
363 if (event.type != WebInputEvent::KeyDown &&
364 event.type != WebInputEvent::KeyUp)
366 const blink::WebKeyboardEvent& key_event =
367 static_cast<const blink::WebKeyboardEvent&>(event);
368 switch (key_event.windowsKeyCode) {
369 case ui::VKEY_BRIGHTNESS_DOWN:
370 case ui::VKEY_BRIGHTNESS_UP:
371 case ui::VKEY_KBD_BRIGHTNESS_DOWN:
372 case ui::VKEY_KBD_BRIGHTNESS_UP:
373 case ui::VKEY_VOLUME_MUTE:
374 case ui::VKEY_VOLUME_DOWN:
375 case ui::VKEY_VOLUME_UP:
380 #endif // defined(OS_CHROMEOS)
384 class PluginInstanceLockTarget : public MouseLockDispatcher::LockTarget {
386 PluginInstanceLockTarget(PepperPluginInstanceImpl* plugin)
389 virtual void OnLockMouseACK(bool succeeded) OVERRIDE {
390 plugin_->OnLockMouseACK(succeeded);
393 virtual void OnMouseLockLost() OVERRIDE { plugin_->OnMouseLockLost(); }
395 virtual bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event)
397 plugin_->HandleMouseLockedInputEvent(event);
402 PepperPluginInstanceImpl* plugin_;
408 PepperPluginInstanceImpl* PepperPluginInstanceImpl::Create(
409 RenderFrameImpl* render_frame,
410 PluginModule* module,
411 WebPluginContainer* container,
412 const GURL& plugin_url) {
413 base::Callback<const void*(const char*)> get_plugin_interface_func =
414 base::Bind(&PluginModule::GetPluginInterface, module);
415 PPP_Instance_Combined* ppp_instance_combined =
416 PPP_Instance_Combined::Create(get_plugin_interface_func);
417 if (!ppp_instance_combined)
419 return new PepperPluginInstanceImpl(
420 render_frame, module, ppp_instance_combined, container, plugin_url);
423 PepperPluginInstanceImpl::ExternalDocumentLoader::ExternalDocumentLoader()
424 : finished_loading_(false) {}
426 PepperPluginInstanceImpl::ExternalDocumentLoader::~ExternalDocumentLoader() {}
428 void PepperPluginInstanceImpl::ExternalDocumentLoader::ReplayReceivedData(
429 WebURLLoaderClient* document_loader) {
430 for (std::list<std::string>::iterator it = data_.begin(); it != data_.end();
432 document_loader->didReceiveData(
433 NULL, it->c_str(), it->length(), 0 /* encoded_data_length */);
435 if (finished_loading_) {
436 document_loader->didFinishLoading(
439 blink::WebURLLoaderClient::kUnknownEncodedDataLength);
442 document_loader->didFail(NULL, *error_);
446 void PepperPluginInstanceImpl::ExternalDocumentLoader::didReceiveData(
447 WebURLLoader* loader,
450 int encoded_data_length) {
451 data_.push_back(std::string(data, data_length));
454 void PepperPluginInstanceImpl::ExternalDocumentLoader::didFinishLoading(
455 WebURLLoader* loader,
457 int64_t total_encoded_data_length) {
458 DCHECK(!finished_loading_);
459 finished_loading_ = true;
462 void PepperPluginInstanceImpl::ExternalDocumentLoader::didFail(
463 WebURLLoader* loader,
464 const WebURLError& error) {
465 DCHECK(!error_.get());
466 error_.reset(new WebURLError(error));
469 PepperPluginInstanceImpl::GamepadImpl::GamepadImpl()
470 : Resource(ppapi::Resource::Untracked()) {}
472 PepperPluginInstanceImpl::GamepadImpl::~GamepadImpl() {}
474 PPB_Gamepad_API* PepperPluginInstanceImpl::GamepadImpl::AsPPB_Gamepad_API() {
478 void PepperPluginInstanceImpl::GamepadImpl::Sample(
479 PP_Instance instance,
480 PP_GamepadsSampleData* data) {
481 blink::WebGamepads webkit_data;
482 RenderThreadImpl::current()->SampleGamepads(&webkit_data);
483 ConvertWebKitGamepadData(bit_cast<ppapi::WebKitGamepads>(webkit_data), data);
486 PepperPluginInstanceImpl::PepperPluginInstanceImpl(
487 RenderFrameImpl* render_frame,
488 PluginModule* module,
489 ppapi::PPP_Instance_Combined* instance_interface,
490 WebPluginContainer* container,
491 const GURL& plugin_url)
492 : RenderFrameObserver(render_frame),
493 render_frame_(render_frame),
495 instance_interface_(instance_interface),
497 container_(container),
498 layer_bound_to_fullscreen_(false),
499 plugin_url_(plugin_url),
501 sent_initial_did_change_view_(false),
502 bound_graphics_2d_platform_(NULL),
503 has_webkit_focus_(false),
504 has_content_area_focus_(false),
505 find_identifier_(-1),
506 plugin_find_interface_(NULL),
507 plugin_input_event_interface_(NULL),
508 plugin_mouse_lock_interface_(NULL),
509 plugin_pdf_interface_(NULL),
510 plugin_private_interface_(NULL),
511 plugin_selection_interface_(NULL),
512 plugin_textinput_interface_(NULL),
513 plugin_zoom_interface_(NULL),
514 checked_for_plugin_input_event_interface_(false),
515 checked_for_plugin_pdf_interface_(false),
516 gamepad_impl_(new GamepadImpl()),
517 uma_private_impl_(NULL),
518 plugin_print_interface_(NULL),
519 plugin_graphics_3d_interface_(NULL),
520 always_on_top_(false),
521 fullscreen_container_(NULL),
522 flash_fullscreen_(false),
523 desired_fullscreen_state_(false),
525 input_event_mask_(0),
526 filtered_input_event_mask_(0),
527 text_input_type_(kPluginDefaultTextInputType),
528 text_input_caret_(0, 0, 0, 0),
529 text_input_caret_bounds_(0, 0, 0, 0),
530 text_input_caret_set_(false),
532 selection_anchor_(0),
533 pending_user_gesture_(0.0),
534 document_loader_(NULL),
535 external_document_load_(false),
537 isolate_(v8::Isolate::GetCurrent()),
539 view_change_weak_ptr_factory_(this),
540 weak_factory_(this) {
541 pp_instance_ = HostGlobals::Get()->AddInstance(this);
543 memset(¤t_print_settings_, 0, sizeof(current_print_settings_));
544 module_->InstanceCreated(this);
546 if (render_frame) { // NULL in tests
547 render_frame->render_view()->PepperInstanceCreated(this);
548 // Bind a callback now so that we can inform the RenderViewImpl when we are
549 // destroyed. This works around a temporary problem stemming from work to
550 // move parts of RenderViewImpl in to RenderFrameImpl (see
551 // crbug.com/245126). If destruction happens in this order:
552 // 1) RenderFrameImpl
553 // 2) PepperPluginInstanceImpl
555 // Then after 1), the PepperPluginInstanceImpl doesn't have any way to talk
556 // to the RenderViewImpl. But when the instance is destroyed, it still
557 // needs to inform the RenderViewImpl that it has gone away, otherwise
558 // between (2) and (3), the RenderViewImpl will still have the dead
559 // instance in its active set, and so might make calls on the deleted
560 // instance. See crbug.com/343576 for more information. Once the plugin
561 // calls move entirely from RenderViewImpl in to RenderFrameImpl, this
562 // can be a little bit simplified by instead making a direct call on
563 // RenderFrameImpl in the destructor (but only if render_frame_ is valid).
564 instance_deleted_callback_ =
565 base::Bind(&RenderViewImpl::PepperInstanceDeleted,
566 render_frame->render_view()->AsWeakPtr(),
567 base::Unretained(this));
568 view_data_.is_page_visible = !render_frame_->GetRenderWidget()->is_hidden();
570 // Set the initial focus.
571 SetContentAreaFocus(render_frame_->GetRenderWidget()->has_focus());
573 if (!module_->IsProxied()) {
574 PepperBrowserConnection* browser_connection =
575 PepperBrowserConnection::Get(render_frame_);
576 browser_connection->DidCreateInProcessInstance(
578 render_frame_->GetRoutingID(),
579 container_->element().document().url(),
584 RendererPpapiHostImpl* host_impl = module_->renderer_ppapi_host();
585 resource_creation_ = host_impl->CreateInProcessResourceCreationAPI(this);
587 if (GetContentClient()->renderer() && // NULL in unit tests.
588 GetContentClient()->renderer()->IsExternalPepperPlugin(module->name()))
589 external_document_load_ = true;
592 PepperPluginInstanceImpl::~PepperPluginInstanceImpl() {
593 DCHECK(!fullscreen_container_);
595 // Free all the plugin objects. This will automatically clear the back-
596 // pointer from the NPObject so WebKit can't call into the plugin any more.
598 // Swap out the set so we can delete from it (the objects will try to
599 // unregister themselves inside the delete call).
600 PluginObjectSet plugin_object_copy;
601 live_plugin_objects_.swap(plugin_object_copy);
602 for (PluginObjectSet::iterator i = plugin_object_copy.begin();
603 i != plugin_object_copy.end();
607 if (TrackedCallback::IsPending(lock_mouse_callback_))
608 lock_mouse_callback_->Abort();
610 if (!instance_deleted_callback_.is_null())
611 instance_deleted_callback_.Run();
613 if (!module_->IsProxied() && render_frame_) {
614 PepperBrowserConnection* browser_connection =
615 PepperBrowserConnection::Get(render_frame_);
616 browser_connection->DidDeleteInProcessInstance(pp_instance());
619 UnSetAndDeleteLockTargetAdapter();
620 module_->InstanceDeleted(this);
621 // If we switched from the NaCl plugin module, notify it too.
622 if (original_module_.get())
623 original_module_->InstanceDeleted(this);
625 // This should be last since some of the above "instance deleted" calls will
626 // want to look up in the global map to get info off of our object.
627 HostGlobals::Get()->InstanceDeleted(pp_instance_);
630 // NOTE: Any of these methods that calls into the plugin needs to take into
631 // account that the plugin may use Var to remove the <embed> from the DOM, which
632 // will make the PepperWebPluginImpl drop its reference, usually the last one.
633 // If a method needs to access a member of the instance after the call has
634 // returned, then it needs to keep its own reference on the stack.
636 void PepperPluginInstanceImpl::Delete() {
640 render_frame_->render_view()->plugin_find_handler() == this) {
641 render_frame_->render_view()->set_plugin_find_handler(NULL);
644 // Keep a reference on the stack. See NOTE above.
645 scoped_refptr<PepperPluginInstanceImpl> ref(this);
646 // Force the MessageChannel to release its "passthrough object" which should
647 // release our last reference to the "InstanceObject" and will probably
648 // destroy it. We want to do this prior to calling DidDestroy in case the
649 // destructor of the instance object tries to use the instance.
650 message_channel_->SetPassthroughObject(NULL);
651 // If this is a NaCl plugin instance, shut down the NaCl plugin by calling
652 // its DidDestroy. Don't call DidDestroy on the untrusted plugin instance,
653 // since there is little that it can do at this point.
654 if (original_instance_interface_)
655 original_instance_interface_->DidDestroy(pp_instance());
657 instance_interface_->DidDestroy(pp_instance());
658 // Ensure we don't attempt to call functions on the destroyed instance.
659 original_instance_interface_.reset();
660 instance_interface_.reset();
662 if (fullscreen_container_) {
663 fullscreen_container_->Destroy();
664 fullscreen_container_ = NULL;
667 // Force-unbind any Graphics. In the case of Graphics2D, if the plugin
668 // leaks the graphics 2D, it may actually get cleaned up after our
669 // destruction, so we need its pointers to be up-to-date.
670 BindGraphics(pp_instance(), 0);
674 bool PepperPluginInstanceImpl::is_deleted() const { return is_deleted_; }
676 void PepperPluginInstanceImpl::Paint(WebCanvas* canvas,
677 const gfx::Rect& plugin_rect,
678 const gfx::Rect& paint_rect) {
679 TRACE_EVENT0("ppapi", "PluginInstance::Paint");
680 if (module()->is_crashed()) {
681 // Crashed plugin painting.
682 if (!sad_plugin_) // Lazily initialize bitmap.
683 sad_plugin_ = GetContentClient()->renderer()->GetSadPluginBitmap();
685 PaintSadPlugin(canvas, plugin_rect, *sad_plugin_);
689 if (bound_graphics_2d_platform_)
690 bound_graphics_2d_platform_->Paint(canvas, plugin_rect, paint_rect);
693 void PepperPluginInstanceImpl::InvalidateRect(const gfx::Rect& rect) {
694 if (fullscreen_container_) {
696 fullscreen_container_->Invalidate();
698 fullscreen_container_->InvalidateRect(rect);
700 if (!container_ || view_data_.rect.size.width == 0 ||
701 view_data_.rect.size.height == 0)
702 return; // Nothing to do.
704 container_->invalidate();
706 container_->invalidateRect(rect);
708 if (texture_layer_) {
709 if (rect.IsEmpty()) {
710 texture_layer_->SetNeedsDisplay();
712 texture_layer_->SetNeedsDisplayRect(rect);
717 void PepperPluginInstanceImpl::ScrollRect(int dx,
719 const gfx::Rect& rect) {
720 if (texture_layer_) {
721 InvalidateRect(rect);
722 } else if (fullscreen_container_) {
723 fullscreen_container_->ScrollRect(dx, dy, rect);
725 if (full_frame_ && !IsViewAccelerated()) {
726 container_->scrollRect(dx, dy, rect);
728 // Can't do optimized scrolling since there could be other elements on top
729 // of us or the view renders via the accelerated compositor which is
730 // incompatible with the move and backfill scrolling model.
731 InvalidateRect(rect);
736 void PepperPluginInstanceImpl::CommitBackingTexture() {
737 if (!texture_layer_.get())
739 gpu::Mailbox mailbox;
740 uint32 sync_point = 0;
741 bound_graphics_3d_->GetBackingMailbox(&mailbox, &sync_point);
742 DCHECK(!mailbox.IsZero());
743 DCHECK_NE(sync_point, 0u);
744 texture_layer_->SetTextureMailboxWithoutReleaseCallback(
745 cc::TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point));
746 texture_layer_->SetNeedsDisplay();
749 void PepperPluginInstanceImpl::InstanceCrashed() {
750 // Force free all resources and vars.
751 HostGlobals::Get()->InstanceCrashed(pp_instance());
753 // Free any associated graphics.
754 SetFullscreen(false);
755 FlashSetFullscreen(false, false);
756 // Unbind current 2D or 3D graphics context.
757 BindGraphics(pp_instance(), 0);
758 InvalidateRect(gfx::Rect());
760 if (content_decryptor_delegate_) {
761 content_decryptor_delegate_->InstanceCrashed();
762 content_decryptor_delegate_.reset();
766 render_frame_->PluginCrashed(module_->path(), module_->GetPeerProcessId());
767 UnSetAndDeleteLockTargetAdapter();
770 static void SetGPUHistogram(const ppapi::Preferences& prefs,
771 const std::vector<std::string>& arg_names,
772 const std::vector<std::string>& arg_values) {
773 // Calculate a histogram to let us determine how likely people are to try to
774 // run Stage3D content on machines that have it blacklisted.
776 bool needs_gpu = false;
777 bool is_xp = base::win::GetVersion() <= base::win::VERSION_XP;
779 for (size_t i = 0; i < arg_names.size(); i++) {
780 if (arg_names[i] == "wmode") {
781 // In theory content other than Flash could have a "wmode" argument,
782 // but that's pretty unlikely.
783 if (arg_values[i] == "direct" || arg_values[i] == "gpu")
788 // 0 : No 3D content and GPU is blacklisted
789 // 1 : No 3D content and GPU is not blacklisted
790 // 2 : 3D content but GPU is blacklisted
791 // 3 : 3D content and GPU is not blacklisted
792 // 4 : No 3D content and GPU is blacklisted on XP
793 // 5 : No 3D content and GPU is not blacklisted on XP
794 // 6 : 3D content but GPU is blacklisted on XP
795 // 7 : 3D content and GPU is not blacklisted on XP
796 UMA_HISTOGRAM_ENUMERATION(
797 "Flash.UsesGPU", is_xp * 4 + needs_gpu * 2 + prefs.is_webgl_supported, 8);
801 bool PepperPluginInstanceImpl::Initialize(
802 const std::vector<std::string>& arg_names,
803 const std::vector<std::string>& arg_values,
807 message_channel_.reset(new MessageChannel(this));
809 full_frame_ = full_frame;
811 UpdateTouchEventRequest();
812 container_->setWantsWheelEvents(IsAcceptingWheelEvents());
815 ppapi::Preferences(render_frame_->render_view()->webkit_preferences()),
821 scoped_ptr<const char * []> argn_array(StringVectorToArgArray(argn_));
822 scoped_ptr<const char * []> argv_array(StringVectorToArgArray(argv_));
823 bool success = PP_ToBool(instance_interface_->DidCreate(
824 pp_instance(), argn_.size(), argn_array.get(), argv_array.get()));
826 message_channel_->StopQueueingJavaScriptMessages();
830 bool PepperPluginInstanceImpl::HandleDocumentLoad(
831 const blink::WebURLResponse& response) {
832 DCHECK(!document_loader_);
833 if (external_document_load_) {
834 // The external proxy isn't available, so save the response and record
835 // document load notifications for later replay.
836 external_document_response_ = response;
837 external_document_loader_.reset(new ExternalDocumentLoader());
838 document_loader_ = external_document_loader_.get();
842 if (module()->is_crashed()) {
843 // Don't create a resource for a crashed plugin.
844 container()->element().document().frame()->stopLoading();
848 DCHECK(!document_loader_);
850 // Create a loader resource host for this load. Note that we have to set
851 // the document_loader before issuing the in-process
852 // PPP_Instance.HandleDocumentLoad call below, since this may reentrantly
853 // call into the instance and expect it to be valid.
854 RendererPpapiHostImpl* host_impl = module_->renderer_ppapi_host();
855 PepperURLLoaderHost* loader_host =
856 new PepperURLLoaderHost(host_impl, true, pp_instance(), 0);
857 // TODO(teravest): Remove set_document_loader() from instance and clean up
858 // this relationship.
859 set_document_loader(loader_host);
860 loader_host->didReceiveResponse(NULL, response);
862 // This host will be pending until the resource object attaches to it.
864 // PpapiHost now owns the pointer to loader_host, so we don't have to worry
865 // about managing it.
866 int pending_host_id = host_impl->GetPpapiHost()->AddPendingResourceHost(
867 scoped_ptr<ppapi::host::ResourceHost>(loader_host));
868 DCHECK(pending_host_id);
870 DataFromWebURLResponse(
874 base::Bind(&PepperPluginInstanceImpl::DidDataFromWebURLResponse,
875 weak_factory_.GetWeakPtr(),
879 // If the load was not abandoned, document_loader_ will now be set. It's
880 // possible that the load was canceled by now and document_loader_ was
881 // already nulled out.
885 bool PepperPluginInstanceImpl::SendCompositionEventToPlugin(
886 PP_InputEvent_Type type,
887 const base::string16& text) {
888 std::vector<blink::WebCompositionUnderline> empty;
889 return SendCompositionEventWithUnderlineInformationToPlugin(
893 static_cast<int>(text.size()),
894 static_cast<int>(text.size()));
898 PepperPluginInstanceImpl::SendCompositionEventWithUnderlineInformationToPlugin(
899 PP_InputEvent_Type type,
900 const base::string16& text,
901 const std::vector<blink::WebCompositionUnderline>& underlines,
904 // Keep a reference on the stack. See NOTE above.
905 scoped_refptr<PepperPluginInstanceImpl> ref(this);
907 if (!LoadInputEventInterface())
910 PP_InputEvent_Class event_class = PP_INPUTEVENT_CLASS_IME;
911 if (!(filtered_input_event_mask_ & event_class) &&
912 !(input_event_mask_ & event_class))
915 ppapi::InputEventData event;
916 event.event_type = type;
917 event.event_time_stamp =
918 ppapi::TimeTicksToPPTimeTicks(base::TimeTicks::Now());
920 // Convert UTF16 text to UTF8 with offset conversion.
921 std::vector<size_t> utf16_offsets;
922 utf16_offsets.push_back(selection_start);
923 utf16_offsets.push_back(selection_end);
924 for (size_t i = 0; i < underlines.size(); ++i) {
925 utf16_offsets.push_back(underlines[i].startOffset);
926 utf16_offsets.push_back(underlines[i].endOffset);
928 std::vector<size_t> utf8_offsets(utf16_offsets);
929 event.character_text = base::UTF16ToUTF8AndAdjustOffsets(text, &utf8_offsets);
931 // Set the converted selection range.
932 event.composition_selection_start =
933 (utf8_offsets[0] == std::string::npos ? event.character_text.size()
935 event.composition_selection_end =
936 (utf8_offsets[1] == std::string::npos ? event.character_text.size()
939 // Set the converted segmentation points.
940 // Be sure to add 0 and size(), and remove duplication or errors.
941 std::set<size_t> offset_set(utf8_offsets.begin() + 2, utf8_offsets.end());
942 offset_set.insert(0);
943 offset_set.insert(event.character_text.size());
944 offset_set.erase(std::string::npos);
945 event.composition_segment_offsets.assign(offset_set.begin(),
948 // Set the composition target.
949 for (size_t i = 0; i < underlines.size(); ++i) {
950 if (underlines[i].thick) {
951 std::vector<uint32_t>::iterator it =
952 std::find(event.composition_segment_offsets.begin(),
953 event.composition_segment_offsets.end(),
954 utf8_offsets[2 * i + 2]);
955 if (it != event.composition_segment_offsets.end()) {
956 event.composition_target_segment =
957 it - event.composition_segment_offsets.begin();
964 bool handled = false;
965 if (filtered_input_event_mask_ & event_class)
966 event.is_filtered = true;
968 handled = true; // Unfiltered events are assumed to be handled.
969 scoped_refptr<PPB_InputEvent_Shared> event_resource(
970 new PPB_InputEvent_Shared(ppapi::OBJECT_IS_IMPL, pp_instance(), event));
971 handled |= PP_ToBool(plugin_input_event_interface_->HandleInputEvent(
972 pp_instance(), event_resource->pp_resource()));
976 void PepperPluginInstanceImpl::RequestInputEventsHelper(
977 uint32_t event_classes) {
978 if (event_classes & PP_INPUTEVENT_CLASS_TOUCH)
979 UpdateTouchEventRequest();
980 if (event_classes & PP_INPUTEVENT_CLASS_WHEEL)
981 container_->setWantsWheelEvents(IsAcceptingWheelEvents());
984 bool PepperPluginInstanceImpl::HandleCompositionStart(
985 const base::string16& text) {
986 return SendCompositionEventToPlugin(PP_INPUTEVENT_TYPE_IME_COMPOSITION_START,
990 bool PepperPluginInstanceImpl::HandleCompositionUpdate(
991 const base::string16& text,
992 const std::vector<blink::WebCompositionUnderline>& underlines,
995 return SendCompositionEventWithUnderlineInformationToPlugin(
996 PP_INPUTEVENT_TYPE_IME_COMPOSITION_UPDATE,
1003 bool PepperPluginInstanceImpl::HandleCompositionEnd(
1004 const base::string16& text) {
1005 return SendCompositionEventToPlugin(PP_INPUTEVENT_TYPE_IME_COMPOSITION_END,
1009 bool PepperPluginInstanceImpl::HandleTextInput(const base::string16& text) {
1010 return SendCompositionEventToPlugin(PP_INPUTEVENT_TYPE_IME_TEXT, text);
1013 void PepperPluginInstanceImpl::GetSurroundingText(base::string16* text,
1014 gfx::Range* range) const {
1015 std::vector<size_t> offsets;
1016 offsets.push_back(selection_anchor_);
1017 offsets.push_back(selection_caret_);
1018 *text = base::UTF8ToUTF16AndAdjustOffsets(surrounding_text_, &offsets);
1019 range->set_start(offsets[0] == base::string16::npos ? text->size()
1021 range->set_end(offsets[1] == base::string16::npos ? text->size()
1025 bool PepperPluginInstanceImpl::IsPluginAcceptingCompositionEvents() const {
1026 return (filtered_input_event_mask_ & PP_INPUTEVENT_CLASS_IME) ||
1027 (input_event_mask_ & PP_INPUTEVENT_CLASS_IME);
1030 gfx::Rect PepperPluginInstanceImpl::GetCaretBounds() const {
1031 if (!text_input_caret_set_) {
1032 // If it is never set by the plugin, use the bottom left corner.
1033 return gfx::Rect(view_data_.rect.point.x,
1034 view_data_.rect.point.y + view_data_.rect.size.height,
1039 // TODO(kinaba) Take CSS transformation into accont.
1040 // TODO(kinaba) Take bounding_box into account. On some platforms, an
1041 // "exclude rectangle" where candidate window must avoid the region can be
1042 // passed to IME. Currently, we pass only the caret rectangle because
1043 // it is the only information supported uniformly in Chromium.
1044 gfx::Rect caret(text_input_caret_);
1045 caret.Offset(view_data_.rect.point.x, view_data_.rect.point.y);
1049 bool PepperPluginInstanceImpl::HandleInputEvent(
1050 const blink::WebInputEvent& event,
1051 WebCursorInfo* cursor_info) {
1052 TRACE_EVENT0("ppapi", "PepperPluginInstanceImpl::HandleInputEvent");
1056 if (WebInputEvent::isMouseEventType(event.type)) {
1057 render_frame_->PepperDidReceiveMouseEvent(this);
1060 // Don't dispatch input events to crashed plugins.
1061 if (module()->is_crashed())
1064 // Don't send reserved system key events to plugins.
1065 if (IsReservedSystemInputEvent(event))
1068 // Keep a reference on the stack. See NOTE above.
1069 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1072 if (LoadInputEventInterface()) {
1073 PP_InputEvent_Class event_class = ClassifyInputEvent(event.type);
1077 if ((filtered_input_event_mask_ & event_class) ||
1078 (input_event_mask_ & event_class)) {
1079 // Actually send the event.
1080 std::vector<ppapi::InputEventData> events;
1081 CreateInputEventData(event, &events);
1083 // Allow the user gesture to be pending after the plugin handles the
1084 // event. This allows out-of-process plugins to respond to the user
1085 // gesture after processing has finished here.
1086 if (WebUserGestureIndicator::isProcessingUserGesture()) {
1087 pending_user_gesture_ =
1088 ppapi::EventTimeToPPTimeTicks(event.timeStampSeconds);
1089 pending_user_gesture_token_ =
1090 WebUserGestureIndicator::currentUserGestureToken();
1091 pending_user_gesture_token_.setOutOfProcess();
1094 // Each input event may generate more than one PP_InputEvent.
1095 for (size_t i = 0; i < events.size(); i++) {
1096 if (filtered_input_event_mask_ & event_class)
1097 events[i].is_filtered = true;
1099 rv = true; // Unfiltered events are assumed to be handled.
1100 scoped_refptr<PPB_InputEvent_Shared> event_resource(
1101 new PPB_InputEvent_Shared(
1102 ppapi::OBJECT_IS_IMPL, pp_instance(), events[i]));
1104 rv |= PP_ToBool(plugin_input_event_interface_->HandleInputEvent(
1105 pp_instance(), event_resource->pp_resource()));
1111 *cursor_info = *cursor_;
1115 void PepperPluginInstanceImpl::HandleMessage(PP_Var message) {
1116 TRACE_EVENT0("ppapi", "PepperPluginInstanceImpl::HandleMessage");
1117 ppapi::proxy::HostDispatcher* dispatcher =
1118 ppapi::proxy::HostDispatcher::GetForInstance(pp_instance());
1119 if (!dispatcher || (message.type == PP_VARTYPE_OBJECT)) {
1120 // The dispatcher should always be valid, and the browser should never send
1121 // an 'object' var over PPP_Messaging.
1125 dispatcher->Send(new PpapiMsg_PPPMessaging_HandleMessage(
1126 ppapi::API_ID_PPP_MESSAGING,
1128 ppapi::proxy::SerializedVarSendInputShmem(dispatcher, message,
1132 PP_Var PepperPluginInstanceImpl::GetInstanceObject() {
1133 // Keep a reference on the stack. See NOTE above.
1134 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1136 // If the plugin supports the private instance interface, try to retrieve its
1138 if (LoadPrivateInterface())
1139 return plugin_private_interface_->GetInstanceObject(pp_instance());
1140 return PP_MakeUndefined();
1143 void PepperPluginInstanceImpl::ViewChanged(
1144 const gfx::Rect& position,
1145 const gfx::Rect& clip,
1146 const std::vector<gfx::Rect>& cut_outs_rects) {
1147 // WebKit can give weird (x,y) positions for empty clip rects (since the
1148 // position technically doesn't matter). But we want to make these
1149 // consistent since this is given to the plugin, so force everything to 0
1150 // in the "everything is clipped" case.
1152 if (!clip.IsEmpty())
1155 cut_outs_rects_ = cut_outs_rects;
1157 view_data_.rect = PP_FromGfxRect(position);
1158 view_data_.clip_rect = PP_FromGfxRect(clip);
1159 view_data_.device_scale = container_->deviceScaleFactor();
1160 view_data_.css_scale =
1161 container_->pageZoomFactor() * container_->pageScaleFactor();
1163 if (desired_fullscreen_state_ || view_data_.is_fullscreen) {
1164 WebElement element = container_->element();
1165 WebDocument document = element.document();
1166 bool is_fullscreen_element = (element == document.fullScreenElement());
1167 if (!view_data_.is_fullscreen && desired_fullscreen_state_ &&
1168 render_frame()->GetRenderWidget()->is_fullscreen() &&
1169 is_fullscreen_element) {
1170 // Entered fullscreen. Only possible via SetFullscreen().
1171 view_data_.is_fullscreen = true;
1172 } else if (view_data_.is_fullscreen && !is_fullscreen_element) {
1173 // Exited fullscreen. Possible via SetFullscreen() or F11/link,
1174 // so desired_fullscreen_state might be out-of-date.
1175 desired_fullscreen_state_ = false;
1176 view_data_.is_fullscreen = false;
1178 // This operation will cause the plugin to re-layout which will send more
1179 // DidChangeView updates. Schedule an asynchronous update and suppress
1180 // notifications until that completes to avoid sending intermediate sizes
1182 ScheduleAsyncDidChangeView();
1184 // Reset the size attributes that we hacked to fill in the screen and
1185 // retrigger ViewChanged. Make sure we don't forward duplicates of
1186 // this view to the plugin.
1187 ResetSizeAttributesAfterFullscreen();
1192 UpdateFlashFullscreenState(fullscreen_container_ != NULL);
1194 SendDidChangeView();
1197 void PepperPluginInstanceImpl::SetWebKitFocus(bool has_focus) {
1198 if (has_webkit_focus_ == has_focus)
1201 bool old_plugin_focus = PluginHasFocus();
1202 has_webkit_focus_ = has_focus;
1203 if (PluginHasFocus() != old_plugin_focus)
1204 SendFocusChangeNotification();
1207 void PepperPluginInstanceImpl::SetContentAreaFocus(bool has_focus) {
1208 if (has_content_area_focus_ == has_focus)
1211 bool old_plugin_focus = PluginHasFocus();
1212 has_content_area_focus_ = has_focus;
1213 if (PluginHasFocus() != old_plugin_focus)
1214 SendFocusChangeNotification();
1217 void PepperPluginInstanceImpl::PageVisibilityChanged(bool is_visible) {
1218 if (is_visible == view_data_.is_page_visible)
1219 return; // Nothing to do.
1220 view_data_.is_page_visible = is_visible;
1222 // If the initial DidChangeView notification hasn't been sent to the plugin,
1223 // let it pass the visibility state for us, instead of sending a notification
1224 // immediately. It is possible that PepperPluginInstanceImpl::ViewChanged()
1225 // hasn't been called for the first time. In that case, most of the fields in
1226 // |view_data_| haven't been properly initialized.
1227 if (sent_initial_did_change_view_)
1228 SendDidChangeView();
1231 void PepperPluginInstanceImpl::ViewInitiatedPaint() {
1232 if (bound_graphics_2d_platform_)
1233 bound_graphics_2d_platform_->ViewInitiatedPaint();
1234 else if (bound_graphics_3d_.get())
1235 bound_graphics_3d_->ViewInitiatedPaint();
1238 void PepperPluginInstanceImpl::ViewFlushedPaint() {
1239 // Keep a reference on the stack. See NOTE above.
1240 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1241 if (bound_graphics_2d_platform_)
1242 bound_graphics_2d_platform_->ViewFlushedPaint();
1243 else if (bound_graphics_3d_.get())
1244 bound_graphics_3d_->ViewFlushedPaint();
1247 void PepperPluginInstanceImpl::SetSelectedText(
1248 const base::string16& selected_text) {
1249 selected_text_ = selected_text;
1252 void PepperPluginInstanceImpl::SetLinkUnderCursor(const std::string& url) {
1253 link_under_cursor_ = base::UTF8ToUTF16(url);
1256 void PepperPluginInstanceImpl::SetTextInputType(ui::TextInputType type) {
1257 text_input_type_ = type;
1258 render_frame_->PepperTextInputTypeChanged(this);
1261 base::string16 PepperPluginInstanceImpl::GetSelectedText(bool html) {
1262 // Keep a reference on the stack. See NOTE above.
1263 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1264 if (!LoadSelectionInterface())
1265 return selected_text_;
1267 PP_Var rv = plugin_selection_interface_->GetSelectedText(pp_instance(),
1269 StringVar* string = StringVar::FromPPVar(rv);
1270 base::string16 selection;
1272 selection = base::UTF8ToUTF16(string->value());
1273 // Release the ref the plugin transfered to us.
1274 HostGlobals::Get()->GetVarTracker()->ReleaseVar(rv);
1278 base::string16 PepperPluginInstanceImpl::GetLinkAtPosition(
1279 const gfx::Point& point) {
1280 // Keep a reference on the stack. See NOTE above.
1281 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1282 if (!LoadPdfInterface()) {
1283 // TODO(koz): Change the containing function to GetLinkUnderCursor(). We can
1284 // return |link_under_cursor_| here because this is only ever called with
1285 // the current mouse coordinates.
1286 return link_under_cursor_;
1292 PP_Var rv = plugin_pdf_interface_->GetLinkAtPosition(pp_instance(), p);
1293 // If the plugin returns undefined for this function it has switched to
1294 // providing us with the link under the cursor eagerly.
1295 if (rv.type == PP_VARTYPE_UNDEFINED)
1296 return link_under_cursor_;
1297 StringVar* string = StringVar::FromPPVar(rv);
1298 base::string16 link;
1300 link = base::UTF8ToUTF16(string->value());
1301 // Release the ref the plugin transfered to us.
1302 PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(rv);
1306 void PepperPluginInstanceImpl::RequestSurroundingText(
1307 size_t desired_number_of_characters) {
1308 // Keep a reference on the stack. See NOTE above.
1309 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1310 if (!LoadTextInputInterface())
1312 plugin_textinput_interface_->RequestSurroundingText(
1313 pp_instance(), desired_number_of_characters);
1316 void PepperPluginInstanceImpl::Zoom(double factor, bool text_only) {
1317 // Keep a reference on the stack. See NOTE above.
1318 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1319 if (!LoadZoomInterface())
1321 plugin_zoom_interface_->Zoom(pp_instance(), factor, PP_FromBool(text_only));
1324 bool PepperPluginInstanceImpl::StartFind(const base::string16& search_text,
1325 bool case_sensitive,
1327 // Keep a reference on the stack. See NOTE above.
1328 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1329 if (!LoadFindInterface())
1331 find_identifier_ = identifier;
1333 plugin_find_interface_->StartFind(pp_instance(),
1334 base::UTF16ToUTF8(search_text).c_str(),
1335 PP_FromBool(case_sensitive)));
1338 void PepperPluginInstanceImpl::SelectFindResult(bool forward) {
1339 // Keep a reference on the stack. See NOTE above.
1340 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1341 if (LoadFindInterface())
1342 plugin_find_interface_->SelectFindResult(pp_instance(),
1343 PP_FromBool(forward));
1346 void PepperPluginInstanceImpl::StopFind() {
1347 // Keep a reference on the stack. See NOTE above.
1348 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1349 if (!LoadFindInterface())
1351 find_identifier_ = -1;
1352 plugin_find_interface_->StopFind(pp_instance());
1355 bool PepperPluginInstanceImpl::LoadFindInterface() {
1356 if (!module_->permissions().HasPermission(ppapi::PERMISSION_PRIVATE))
1358 if (!plugin_find_interface_) {
1359 plugin_find_interface_ = static_cast<const PPP_Find_Private*>(
1360 module_->GetPluginInterface(PPP_FIND_PRIVATE_INTERFACE));
1363 return !!plugin_find_interface_;
1366 bool PepperPluginInstanceImpl::LoadInputEventInterface() {
1367 if (!checked_for_plugin_input_event_interface_) {
1368 checked_for_plugin_input_event_interface_ = true;
1369 plugin_input_event_interface_ = static_cast<const PPP_InputEvent*>(
1370 module_->GetPluginInterface(PPP_INPUT_EVENT_INTERFACE));
1372 return !!plugin_input_event_interface_;
1375 bool PepperPluginInstanceImpl::LoadMouseLockInterface() {
1376 if (!plugin_mouse_lock_interface_) {
1377 plugin_mouse_lock_interface_ = static_cast<const PPP_MouseLock*>(
1378 module_->GetPluginInterface(PPP_MOUSELOCK_INTERFACE));
1381 return !!plugin_mouse_lock_interface_;
1384 bool PepperPluginInstanceImpl::LoadPdfInterface() {
1385 if (!checked_for_plugin_pdf_interface_) {
1386 checked_for_plugin_pdf_interface_ = true;
1387 plugin_pdf_interface_ = static_cast<const PPP_Pdf_1*>(
1388 module_->GetPluginInterface(PPP_PDF_INTERFACE_1));
1391 return !!plugin_pdf_interface_;
1394 bool PepperPluginInstanceImpl::LoadPrintInterface() {
1395 // Only check for the interface if the plugin has dev permission.
1396 if (!module_->permissions().HasPermission(ppapi::PERMISSION_DEV))
1398 if (!plugin_print_interface_) {
1399 plugin_print_interface_ = static_cast<const PPP_Printing_Dev*>(
1400 module_->GetPluginInterface(PPP_PRINTING_DEV_INTERFACE));
1402 return !!plugin_print_interface_;
1405 bool PepperPluginInstanceImpl::LoadPrivateInterface() {
1406 // If this is a NaCl app, we want to talk to the trusted NaCl plugin to
1407 // call GetInstanceObject. This is necessary to ensure that the properties
1408 // the trusted plugin exposes (readyState and lastError) work properly. Note
1409 // that untrusted NaCl apps are not allowed to provide PPP_InstancePrivate,
1410 // so it's correct to never look up PPP_InstancePrivate for them.
1412 // If this is *not* a NaCl plugin, original_module_ will never be set; we talk
1413 // to the "real" module.
1414 scoped_refptr<PluginModule> module =
1415 original_module_ ? original_module_ : module_;
1416 // Only check for the interface if the plugin has private permission.
1417 if (!module->permissions().HasPermission(ppapi::PERMISSION_PRIVATE))
1419 if (!plugin_private_interface_) {
1420 plugin_private_interface_ = static_cast<const PPP_Instance_Private*>(
1421 module->GetPluginInterface(PPP_INSTANCE_PRIVATE_INTERFACE));
1424 return !!plugin_private_interface_;
1427 bool PepperPluginInstanceImpl::LoadSelectionInterface() {
1428 if (!plugin_selection_interface_) {
1429 plugin_selection_interface_ = static_cast<const PPP_Selection_Dev*>(
1430 module_->GetPluginInterface(PPP_SELECTION_DEV_INTERFACE));
1432 return !!plugin_selection_interface_;
1435 bool PepperPluginInstanceImpl::LoadTextInputInterface() {
1436 if (!plugin_textinput_interface_) {
1437 plugin_textinput_interface_ = static_cast<const PPP_TextInput_Dev*>(
1438 module_->GetPluginInterface(PPP_TEXTINPUT_DEV_INTERFACE));
1441 return !!plugin_textinput_interface_;
1444 bool PepperPluginInstanceImpl::LoadZoomInterface() {
1445 if (!plugin_zoom_interface_) {
1446 plugin_zoom_interface_ = static_cast<const PPP_Zoom_Dev*>(
1447 module_->GetPluginInterface(PPP_ZOOM_DEV_INTERFACE));
1450 return !!plugin_zoom_interface_;
1453 void PepperPluginInstanceImpl::UpdateLayerTransform() {
1454 if (!bound_graphics_2d_platform_ || !texture_layer_) {
1455 // Currently the transform is only applied for Graphics2D.
1458 // Set the UV coordinates of the texture based on the size of the Graphics2D
1459 // context. By default a texture gets scaled to the size of the layer. But
1460 // if the size of the Graphics2D context doesn't match the size of the plugin
1461 // then it will be incorrectly stretched. This also affects how the plugin
1462 // is painted when it is being resized. If the Graphics2D contents are
1463 // stretched when a plugin is resized while waiting for a new frame from the
1464 // plugin to be rendered, then flickering behavior occurs as in
1465 // crbug.com/353453.
1466 gfx::SizeF graphics_2d_size_in_dip =
1467 gfx::ScaleSize(bound_graphics_2d_platform_->Size(),
1468 bound_graphics_2d_platform_->GetScale());
1469 gfx::Size plugin_size_in_dip(view_data_.rect.size.width,
1470 view_data_.rect.size.height);
1472 texture_layer_->SetUV(
1473 gfx::PointF(0.0f, 0.0f),
1475 plugin_size_in_dip.width() / graphics_2d_size_in_dip.width(),
1476 plugin_size_in_dip.height() / graphics_2d_size_in_dip.height()));
1479 bool PepperPluginInstanceImpl::PluginHasFocus() const {
1480 return flash_fullscreen_ || (has_webkit_focus_ && has_content_area_focus_);
1483 void PepperPluginInstanceImpl::SendFocusChangeNotification() {
1484 // Keep a reference on the stack. RenderViewImpl::PepperFocusChanged may
1485 // remove the <embed> from the DOM, which will make the PepperWebPluginImpl
1486 // drop its reference, usually the last one. This is similar to possible
1487 // plugin behavior described at the NOTE above Delete().
1488 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1493 bool has_focus = PluginHasFocus();
1494 render_frame_->render_view()->PepperFocusChanged(this, has_focus);
1496 // instance_interface_ may have been cleared in Delete() if the
1497 // PepperWebPluginImpl is destroyed.
1498 if (instance_interface_)
1499 instance_interface_->DidChangeFocus(pp_instance(), PP_FromBool(has_focus));
1502 void PepperPluginInstanceImpl::UpdateTouchEventRequest() {
1503 bool raw_touch = (filtered_input_event_mask_ & PP_INPUTEVENT_CLASS_TOUCH) ||
1504 (input_event_mask_ & PP_INPUTEVENT_CLASS_TOUCH);
1505 container_->requestTouchEventType(
1507 ? blink::WebPluginContainer::TouchEventRequestTypeRaw
1508 : blink::WebPluginContainer::TouchEventRequestTypeSynthesizedMouse);
1511 bool PepperPluginInstanceImpl::IsAcceptingWheelEvents() const {
1512 return (filtered_input_event_mask_ & PP_INPUTEVENT_CLASS_WHEEL) ||
1513 (input_event_mask_ & PP_INPUTEVENT_CLASS_WHEEL);
1516 void PepperPluginInstanceImpl::ScheduleAsyncDidChangeView() {
1517 if (view_change_weak_ptr_factory_.HasWeakPtrs())
1518 return; // Already scheduled.
1519 base::MessageLoop::current()->PostTask(
1521 base::Bind(&PepperPluginInstanceImpl::SendAsyncDidChangeView,
1522 view_change_weak_ptr_factory_.GetWeakPtr()));
1525 void PepperPluginInstanceImpl::SendAsyncDidChangeView() {
1526 // The bound callback that owns the weak pointer is still valid until after
1527 // this function returns. SendDidChangeView checks HasWeakPtrs, so we need to
1528 // invalidate them here.
1529 // NOTE: If we ever want to have more than one pending callback, it should
1530 // use a different factory, or we should have a different strategy here.
1531 view_change_weak_ptr_factory_.InvalidateWeakPtrs();
1532 SendDidChangeView();
1535 void PepperPluginInstanceImpl::SendDidChangeView() {
1536 // Don't send DidChangeView to crashed plugins.
1537 if (module()->is_crashed())
1540 if (view_change_weak_ptr_factory_.HasWeakPtrs() ||
1541 (sent_initial_did_change_view_ &&
1542 last_sent_view_data_.Equals(view_data_)))
1543 return; // Nothing to update.
1545 sent_initial_did_change_view_ = true;
1546 last_sent_view_data_ = view_data_;
1547 ScopedPPResource resource(
1548 ScopedPPResource::PassRef(),
1549 (new PPB_View_Shared(ppapi::OBJECT_IS_IMPL, pp_instance(), view_data_))
1552 UpdateLayerTransform();
1554 // It's possible that Delete() has been called but the renderer hasn't
1555 // released its reference to this object yet.
1556 if (instance_interface_) {
1557 instance_interface_->DidChangeView(
1558 pp_instance(), resource, &view_data_.rect, &view_data_.clip_rect);
1562 void PepperPluginInstanceImpl::ReportGeometry() {
1563 // If this call was delayed, we may have transitioned back to fullscreen in
1564 // the mean time, so only report the geometry if we are actually in normal
1566 if (container_ && !fullscreen_container_ && !flash_fullscreen_)
1567 container_->reportGeometry();
1570 bool PepperPluginInstanceImpl::GetPreferredPrintOutputFormat(
1571 PP_PrintOutputFormat_Dev* format) {
1572 // Keep a reference on the stack. See NOTE above.
1573 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1574 if (!LoadPrintInterface())
1576 uint32_t supported_formats =
1577 plugin_print_interface_->QuerySupportedFormats(pp_instance());
1578 if (supported_formats & PP_PRINTOUTPUTFORMAT_PDF) {
1579 *format = PP_PRINTOUTPUTFORMAT_PDF;
1585 bool PepperPluginInstanceImpl::SupportsPrintInterface() {
1586 PP_PrintOutputFormat_Dev format;
1587 return GetPreferredPrintOutputFormat(&format);
1590 bool PepperPluginInstanceImpl::IsPrintScalingDisabled() {
1591 DCHECK(plugin_print_interface_);
1592 if (!plugin_print_interface_)
1594 return plugin_print_interface_->IsScalingDisabled(pp_instance()) == PP_TRUE;
1597 int PepperPluginInstanceImpl::PrintBegin(const WebPrintParams& print_params) {
1598 // Keep a reference on the stack. See NOTE above.
1599 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1600 PP_PrintOutputFormat_Dev format;
1601 if (!GetPreferredPrintOutputFormat(&format)) {
1602 // PrintBegin should not have been called since SupportsPrintInterface
1603 // would have returned false;
1608 PP_PrintSettings_Dev print_settings;
1609 print_settings.printable_area = PP_FromGfxRect(print_params.printableArea);
1610 print_settings.content_area = PP_FromGfxRect(print_params.printContentArea);
1611 print_settings.paper_size = PP_FromGfxSize(print_params.paperSize);
1612 print_settings.dpi = print_params.printerDPI;
1613 print_settings.orientation = PP_PRINTORIENTATION_NORMAL;
1614 print_settings.grayscale = PP_FALSE;
1615 print_settings.print_scaling_option =
1616 static_cast<PP_PrintScalingOption_Dev>(print_params.printScalingOption);
1617 print_settings.format = format;
1618 num_pages = plugin_print_interface_->Begin(pp_instance(), &print_settings);
1621 current_print_settings_ = print_settings;
1627 bool PepperPluginInstanceImpl::PrintPage(int page_number,
1628 blink::WebCanvas* canvas) {
1629 #if defined(ENABLE_FULL_PRINTING)
1630 DCHECK(plugin_print_interface_);
1631 PP_PrintPageNumberRange_Dev page_range;
1632 page_range.first_page_number = page_range.last_page_number = page_number;
1633 // The canvas only has a metafile on it for print preview.
1634 bool save_for_later =
1635 (printing::MetafileSkiaWrapper::GetMetafileFromCanvas(*canvas) != NULL);
1636 #if defined(OS_MACOSX) || defined(OS_WIN)
1637 save_for_later = save_for_later && skia::IsPreviewMetafile(*canvas);
1639 if (save_for_later) {
1640 ranges_.push_back(page_range);
1641 canvas_ = skia::SharePtr(canvas);
1644 return PrintPageHelper(&page_range, 1, canvas);
1646 #else // defined(ENABLED_PRINTING)
1651 bool PepperPluginInstanceImpl::PrintPageHelper(
1652 PP_PrintPageNumberRange_Dev* page_ranges,
1654 blink::WebCanvas* canvas) {
1655 // Keep a reference on the stack. See NOTE above.
1656 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1657 DCHECK(plugin_print_interface_);
1658 if (!plugin_print_interface_)
1660 PP_Resource print_output = plugin_print_interface_->PrintPages(
1661 pp_instance(), page_ranges, num_ranges);
1667 if (current_print_settings_.format == PP_PRINTOUTPUTFORMAT_PDF)
1668 ret = PrintPDFOutput(print_output, canvas);
1670 // Now we need to release the print output resource.
1671 PluginModule::GetCore()->ReleaseResource(print_output);
1676 void PepperPluginInstanceImpl::PrintEnd() {
1677 // Keep a reference on the stack. See NOTE above.
1678 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1679 if (!ranges_.empty())
1680 PrintPageHelper(&(ranges_.front()), ranges_.size(), canvas_.get());
1684 DCHECK(plugin_print_interface_);
1685 if (plugin_print_interface_)
1686 plugin_print_interface_->End(pp_instance());
1688 memset(¤t_print_settings_, 0, sizeof(current_print_settings_));
1689 #if defined(OS_MACOSX)
1690 last_printed_page_ = NULL;
1691 #endif // defined(OS_MACOSX)
1694 bool PepperPluginInstanceImpl::CanRotateView() {
1695 if (!LoadPdfInterface())
1701 void PepperPluginInstanceImpl::RotateView(WebPlugin::RotationType type) {
1702 if (!LoadPdfInterface())
1704 PP_PrivatePageTransformType transform_type =
1705 type == WebPlugin::RotationType90Clockwise
1706 ? PP_PRIVATEPAGETRANSFORMTYPE_ROTATE_90_CW
1707 : PP_PRIVATEPAGETRANSFORMTYPE_ROTATE_90_CCW;
1708 plugin_pdf_interface_->Transform(pp_instance(), transform_type);
1709 // NOTE: plugin instance may have been deleted.
1712 bool PepperPluginInstanceImpl::FlashIsFullscreenOrPending() {
1713 return fullscreen_container_ != NULL;
1716 bool PepperPluginInstanceImpl::IsFullscreenOrPending() {
1717 return desired_fullscreen_state_;
1720 bool PepperPluginInstanceImpl::SetFullscreen(bool fullscreen) {
1721 // Keep a reference on the stack. See NOTE above.
1722 scoped_refptr<PepperPluginInstanceImpl> ref(this);
1724 // Check whether we are trying to switch to the state we're already going
1725 // to (i.e. if we're already switching to fullscreen but the fullscreen
1726 // container isn't ready yet, don't do anything more).
1727 if (fullscreen == IsFullscreenOrPending())
1732 if (fullscreen && !render_frame_->render_view()
1733 ->renderer_preferences()
1734 .plugin_fullscreen_allowed)
1737 // Check whether we are trying to switch while the state is in transition.
1738 // The 2nd request gets dropped while messing up the internal state, so
1740 if (view_data_.is_fullscreen != desired_fullscreen_state_)
1743 if (fullscreen && !IsProcessingUserGesture())
1746 VLOG(1) << "Setting fullscreen to " << (fullscreen ? "on" : "off");
1747 desired_fullscreen_state_ = fullscreen;
1750 // Create the user gesture in case we're processing one that's pending.
1751 WebScopedUserGesture user_gesture(CurrentUserGestureToken());
1752 // WebKit does not resize the plugin to fill the screen in fullscreen mode,
1753 // so we will tweak plugin's attributes to support the expected behavior.
1754 KeepSizeAttributesBeforeFullscreen();
1755 SetSizeAttributesForFullscreen();
1756 container_->element().requestFullScreen();
1758 container_->element().document().cancelFullScreen();
1763 void PepperPluginInstanceImpl::UpdateFlashFullscreenState(
1764 bool flash_fullscreen) {
1765 bool is_mouselock_pending = TrackedCallback::IsPending(lock_mouse_callback_);
1767 if (flash_fullscreen == flash_fullscreen_) {
1768 // Manually clear callback when fullscreen fails with mouselock pending.
1769 if (!flash_fullscreen && is_mouselock_pending)
1770 lock_mouse_callback_->Run(PP_ERROR_FAILED);
1776 bool old_plugin_focus = PluginHasFocus();
1777 flash_fullscreen_ = flash_fullscreen;
1778 if (is_mouselock_pending && !IsMouseLocked()) {
1779 if (!IsProcessingUserGesture() &&
1780 !module_->permissions().HasPermission(
1781 ppapi::PERMISSION_BYPASS_USER_GESTURE)) {
1782 lock_mouse_callback_->Run(PP_ERROR_NO_USER_GESTURE);
1784 // Open a user gesture here so the Webkit user gesture checks will succeed
1785 // for out-of-process plugins.
1786 WebScopedUserGesture user_gesture(CurrentUserGestureToken());
1788 lock_mouse_callback_->Run(PP_ERROR_FAILED);
1792 if (PluginHasFocus() != old_plugin_focus)
1793 SendFocusChangeNotification();
1796 bool PepperPluginInstanceImpl::IsViewAccelerated() {
1800 WebDocument document = container_->element().document();
1801 WebLocalFrame* frame = document.frame();
1804 WebView* view = frame->view();
1808 return view->isAcceleratedCompositingActive();
1811 bool PepperPluginInstanceImpl::PrintPDFOutput(PP_Resource print_output,
1812 blink::WebCanvas* canvas) {
1813 #if defined(ENABLE_FULL_PRINTING)
1814 ppapi::thunk::EnterResourceNoLock<PPB_Buffer_API> enter(print_output, true);
1818 BufferAutoMapper mapper(enter.object());
1819 if (!mapper.data() || !mapper.size()) {
1824 // For Windows, we need the PDF DLL to render the output PDF to a DC.
1825 HMODULE pdf_module = GetModuleHandle(L"pdf.dll");
1828 RenderPDFPageToDCProc render_proc = reinterpret_cast<RenderPDFPageToDCProc>(
1829 GetProcAddress(pdf_module, "RenderPDFPageToDC"));
1832 #endif // defined(OS_WIN)
1835 #if defined(OS_POSIX) && !defined(OS_ANDROID)
1836 // On Linux we just set the final bits in the native metafile
1837 // (NativeMetafile and PreviewMetafile must have compatible formats,
1838 // i.e. both PDF for this to work).
1839 printing::Metafile* metafile =
1840 printing::MetafileSkiaWrapper::GetMetafileFromCanvas(*canvas);
1841 DCHECK(metafile != NULL);
1843 ret = metafile->InitFromData(mapper.data(), mapper.size());
1844 #elif defined(OS_WIN)
1845 printing::Metafile* metafile =
1846 printing::MetafileSkiaWrapper::GetMetafileFromCanvas(*canvas);
1848 // We only have a metafile when doing print preview, so we just want to
1849 // pass the PDF off to preview.
1850 ret = metafile->InitFromData(mapper.data(), mapper.size());
1852 // On Windows, we now need to render the PDF to the DC that backs the
1854 HDC dc = skia::BeginPlatformPaint(canvas);
1855 DrawEmptyRectangle(dc);
1856 gfx::Size size_in_pixels;
1857 size_in_pixels.set_width(
1858 printing::ConvertUnit(current_print_settings_.printable_area.size.width,
1859 static_cast<int>(printing::kPointsPerInch),
1860 current_print_settings_.dpi));
1861 size_in_pixels.set_height(printing::ConvertUnit(
1862 current_print_settings_.printable_area.size.height,
1863 static_cast<int>(printing::kPointsPerInch),
1864 current_print_settings_.dpi));
1865 // We need to scale down DC to fit an entire page into DC available area.
1866 // First, we'll try to use default scaling based on the 72dpi that is
1867 // used in webkit for printing.
1868 // If default scaling is not enough to fit the entire PDF without
1869 // Current metafile is based on screen DC and have current screen size.
1870 // Writing outside of those boundaries will result in the cut-off output.
1871 // On metafiles (this is the case here), scaling down will still record
1872 // original coordinates and we'll be able to print in full resolution.
1873 // Before playback we'll need to counter the scaling up that will happen
1874 // in the browser (printed_document_win.cc).
1875 double dynamic_scale = gfx::CalculatePageScale(
1876 dc, size_in_pixels.width(), size_in_pixels.height());
1877 double page_scale = static_cast<double>(printing::kPointsPerInch) /
1878 static_cast<double>(current_print_settings_.dpi);
1880 if (dynamic_scale < page_scale) {
1881 page_scale = dynamic_scale;
1882 printing::MetafileSkiaWrapper::SetCustomScaleOnCanvas(*canvas,
1886 gfx::ScaleDC(dc, page_scale);
1888 ret = render_proc(static_cast<unsigned char*>(mapper.data()),
1892 current_print_settings_.dpi,
1893 current_print_settings_.dpi,
1896 size_in_pixels.width(),
1897 size_in_pixels.height(),
1903 skia::EndPlatformPaint(canvas);
1905 #endif // defined(OS_WIN)
1908 #else // defined(ENABLE_FULL_PRINTING)
1913 void PepperPluginInstanceImpl::UpdateLayer() {
1917 gpu::Mailbox mailbox;
1918 uint32 sync_point = 0;
1919 if (bound_graphics_3d_.get()) {
1920 bound_graphics_3d_->GetBackingMailbox(&mailbox, &sync_point);
1921 DCHECK_EQ(mailbox.IsZero(), sync_point == 0);
1923 bool want_3d_layer = !mailbox.IsZero();
1924 bool want_2d_layer = !!bound_graphics_2d_platform_;
1925 bool want_layer = want_3d_layer || want_2d_layer;
1927 if ((want_layer == !!texture_layer_.get()) &&
1928 (want_3d_layer == layer_is_hardware_) &&
1929 layer_bound_to_fullscreen_ == !!fullscreen_container_) {
1930 UpdateLayerTransform();
1934 if (texture_layer_) {
1935 if (!layer_bound_to_fullscreen_)
1936 container_->setWebLayer(NULL);
1937 else if (fullscreen_container_)
1938 fullscreen_container_->SetLayer(NULL);
1940 texture_layer_ = NULL;
1943 bool opaque = false;
1944 if (want_3d_layer) {
1945 DCHECK(bound_graphics_3d_.get());
1946 texture_layer_ = cc::TextureLayer::CreateForMailbox(NULL);
1947 opaque = bound_graphics_3d_->IsOpaque();
1948 texture_layer_->SetTextureMailboxWithoutReleaseCallback(
1949 cc::TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point));
1951 DCHECK(bound_graphics_2d_platform_);
1952 texture_layer_ = cc::TextureLayer::CreateForMailbox(this);
1953 bound_graphics_2d_platform_->AttachedToNewLayer();
1954 opaque = bound_graphics_2d_platform_->IsAlwaysOpaque();
1955 texture_layer_->SetFlipped(false);
1957 web_layer_.reset(new webkit::WebLayerImpl(texture_layer_));
1958 if (fullscreen_container_) {
1959 fullscreen_container_->SetLayer(web_layer_.get());
1960 // Ignore transparency in fullscreen, since that's what Flash always
1961 // wants to do, and that lets it not recreate a context if
1962 // wmode=transparent was specified.
1963 texture_layer_->SetContentsOpaque(true);
1965 container_->setWebLayer(web_layer_.get());
1966 texture_layer_->SetContentsOpaque(opaque);
1969 layer_bound_to_fullscreen_ = !!fullscreen_container_;
1970 layer_is_hardware_ = want_3d_layer;
1971 UpdateLayerTransform();
1974 bool PepperPluginInstanceImpl::PrepareTextureMailbox(
1975 cc::TextureMailbox* mailbox,
1976 scoped_ptr<cc::SingleReleaseCallback>* release_callback,
1977 bool use_shared_memory) {
1978 if (!bound_graphics_2d_platform_)
1980 return bound_graphics_2d_platform_->PrepareTextureMailbox(mailbox,
1984 void PepperPluginInstanceImpl::OnDestruct() { render_frame_ = NULL; }
1986 void PepperPluginInstanceImpl::AddPluginObject(PluginObject* plugin_object) {
1987 DCHECK(live_plugin_objects_.find(plugin_object) ==
1988 live_plugin_objects_.end());
1989 live_plugin_objects_.insert(plugin_object);
1992 void PepperPluginInstanceImpl::RemovePluginObject(PluginObject* plugin_object) {
1993 // Don't actually verify that the object is in the set since during module
1994 // deletion we'll be in the process of freeing them.
1995 live_plugin_objects_.erase(plugin_object);
1998 bool PepperPluginInstanceImpl::IsProcessingUserGesture() {
1999 PP_TimeTicks now = ppapi::TimeTicksToPPTimeTicks(base::TimeTicks::Now());
2000 // Give a lot of slack so tests won't be flaky.
2001 const PP_TimeTicks kUserGestureDurationInSeconds = 10.0;
2002 return pending_user_gesture_token_.hasGestures() &&
2003 (now - pending_user_gesture_ < kUserGestureDurationInSeconds);
2006 WebUserGestureToken PepperPluginInstanceImpl::CurrentUserGestureToken() {
2007 if (!IsProcessingUserGesture())
2008 pending_user_gesture_token_ = WebUserGestureToken();
2009 return pending_user_gesture_token_;
2012 void PepperPluginInstanceImpl::OnLockMouseACK(bool succeeded) {
2013 if (TrackedCallback::IsPending(lock_mouse_callback_))
2014 lock_mouse_callback_->Run(succeeded ? PP_OK : PP_ERROR_FAILED);
2017 void PepperPluginInstanceImpl::OnMouseLockLost() {
2018 if (LoadMouseLockInterface())
2019 plugin_mouse_lock_interface_->MouseLockLost(pp_instance());
2022 void PepperPluginInstanceImpl::HandleMouseLockedInputEvent(
2023 const blink::WebMouseEvent& event) {
2024 // |cursor_info| is ignored since it is hidden when the mouse is locked.
2025 blink::WebCursorInfo cursor_info;
2026 HandleInputEvent(event, &cursor_info);
2029 void PepperPluginInstanceImpl::SimulateInputEvent(
2030 const InputEventData& input_event) {
2031 WebView* web_view = container()->element().document().frame()->view();
2037 bool handled = SimulateIMEEvent(input_event);
2041 std::vector<linked_ptr<WebInputEvent> > events =
2042 CreateSimulatedWebInputEvents(
2044 view_data_.rect.point.x + view_data_.rect.size.width / 2,
2045 view_data_.rect.point.y + view_data_.rect.size.height / 2);
2046 for (std::vector<linked_ptr<WebInputEvent> >::iterator it = events.begin();
2049 web_view->handleInputEvent(*it->get());
2053 bool PepperPluginInstanceImpl::SimulateIMEEvent(
2054 const InputEventData& input_event) {
2055 switch (input_event.event_type) {
2056 case PP_INPUTEVENT_TYPE_IME_COMPOSITION_START:
2057 case PP_INPUTEVENT_TYPE_IME_COMPOSITION_UPDATE:
2058 SimulateImeSetCompositionEvent(input_event);
2060 case PP_INPUTEVENT_TYPE_IME_COMPOSITION_END:
2061 DCHECK(input_event.character_text.empty());
2062 SimulateImeSetCompositionEvent(input_event);
2064 case PP_INPUTEVENT_TYPE_IME_TEXT:
2067 render_frame_->SimulateImeConfirmComposition(
2068 base::UTF8ToUTF16(input_event.character_text), gfx::Range());
2076 void PepperPluginInstanceImpl::SimulateImeSetCompositionEvent(
2077 const InputEventData& input_event) {
2081 std::vector<size_t> offsets;
2082 offsets.push_back(input_event.composition_selection_start);
2083 offsets.push_back(input_event.composition_selection_end);
2084 offsets.insert(offsets.end(),
2085 input_event.composition_segment_offsets.begin(),
2086 input_event.composition_segment_offsets.end());
2088 base::string16 utf16_text =
2089 base::UTF8ToUTF16AndAdjustOffsets(input_event.character_text, &offsets);
2091 std::vector<blink::WebCompositionUnderline> underlines;
2092 for (size_t i = 2; i + 1 < offsets.size(); ++i) {
2093 blink::WebCompositionUnderline underline;
2094 underline.startOffset = offsets[i];
2095 underline.endOffset = offsets[i + 1];
2096 if (input_event.composition_target_segment == static_cast<int32_t>(i - 2))
2097 underline.thick = true;
2098 underlines.push_back(underline);
2101 render_frame_->SimulateImeSetComposition(
2102 utf16_text, underlines, offsets[0], offsets[1]);
2105 ContentDecryptorDelegate*
2106 PepperPluginInstanceImpl::GetContentDecryptorDelegate() {
2107 if (content_decryptor_delegate_)
2108 return content_decryptor_delegate_.get();
2110 const PPP_ContentDecryptor_Private* plugin_decryption_interface =
2111 static_cast<const PPP_ContentDecryptor_Private*>(
2112 module_->GetPluginInterface(PPP_CONTENTDECRYPTOR_PRIVATE_INTERFACE));
2113 if (!plugin_decryption_interface)
2116 content_decryptor_delegate_.reset(
2117 new ContentDecryptorDelegate(pp_instance_, plugin_decryption_interface));
2118 return content_decryptor_delegate_.get();
2121 PP_Bool PepperPluginInstanceImpl::BindGraphics(PP_Instance instance,
2122 PP_Resource device) {
2123 TRACE_EVENT0("ppapi", "PepperPluginInstanceImpl::BindGraphics");
2124 // The Graphics3D instance can't be destroyed until we call
2126 scoped_refptr<ppapi::Resource> old_graphics = bound_graphics_3d_.get();
2127 if (bound_graphics_3d_.get()) {
2128 bound_graphics_3d_->BindToInstance(false);
2129 bound_graphics_3d_ = NULL;
2131 if (bound_graphics_2d_platform_) {
2132 bound_graphics_2d_platform_->BindToInstance(NULL);
2133 bound_graphics_2d_platform_ = NULL;
2136 // Special-case clearing the current device.
2139 InvalidateRect(gfx::Rect());
2143 // Refuse to bind if in transition to fullscreen with PPB_FlashFullscreen or
2144 // to/from fullscreen with PPB_Fullscreen.
2145 if ((fullscreen_container_ && !flash_fullscreen_) ||
2146 desired_fullscreen_state_ != view_data_.is_fullscreen)
2149 const ppapi::host::PpapiHost* ppapi_host =
2150 RendererPpapiHost::GetForPPInstance(instance)->GetPpapiHost();
2151 ppapi::host::ResourceHost* host = ppapi_host->GetResourceHost(device);
2152 PepperGraphics2DHost* graphics_2d = NULL;
2154 if (host->IsGraphics2DHost())
2155 graphics_2d = static_cast<PepperGraphics2DHost*>(host);
2156 DLOG_IF(ERROR, !graphics_2d) << "Resource is not PepperGraphics2DHost.";
2159 EnterResourceNoLock<PPB_Graphics3D_API> enter_3d(device, false);
2160 PPB_Graphics3D_Impl* graphics_3d =
2161 enter_3d.succeeded()
2162 ? static_cast<PPB_Graphics3D_Impl*>(enter_3d.object())
2166 if (graphics_2d->BindToInstance(this)) {
2167 bound_graphics_2d_platform_ = graphics_2d;
2171 } else if (graphics_3d) {
2172 // Make sure graphics can only be bound to the instance it is
2174 if (graphics_3d->pp_instance() == pp_instance() &&
2175 graphics_3d->BindToInstance(true)) {
2176 bound_graphics_3d_ = graphics_3d;
2182 // The instance cannot be bound or the device is not a valid resource type.
2186 PP_Bool PepperPluginInstanceImpl::IsFullFrame(PP_Instance instance) {
2187 return PP_FromBool(full_frame());
2190 const ViewData* PepperPluginInstanceImpl::GetViewData(PP_Instance instance) {
2194 PP_Bool PepperPluginInstanceImpl::FlashIsFullscreen(PP_Instance instance) {
2195 return PP_FromBool(flash_fullscreen_);
2198 PP_Var PepperPluginInstanceImpl::GetWindowObject(PP_Instance instance) {
2200 return PP_MakeUndefined();
2202 WebLocalFrame* frame = container_->element().document().frame();
2204 return PP_MakeUndefined();
2206 return NPObjectToPPVar(this, frame->windowObject());
2209 PP_Var PepperPluginInstanceImpl::GetOwnerElementObject(PP_Instance instance) {
2211 return PP_MakeUndefined();
2212 return NPObjectToPPVar(this, container_->scriptableObjectForElement());
2215 PP_Var PepperPluginInstanceImpl::ExecuteScript(PP_Instance instance,
2217 PP_Var* exception) {
2218 // Executing the script may remove the plugin from the DOM, so we need to keep
2219 // a reference to ourselves so that we can still process the result after the
2220 // WebBindings::evaluate() below.
2221 scoped_refptr<PepperPluginInstanceImpl> ref(this);
2222 TryCatch try_catch(exception);
2223 if (try_catch.has_exception())
2224 return PP_MakeUndefined();
2226 // Convert the script into an inconvenient NPString object.
2227 StringVar* script_string = StringVar::FromPPVar(script);
2228 if (!script_string) {
2229 try_catch.SetException("Script param to ExecuteScript must be a string.");
2230 return PP_MakeUndefined();
2233 np_script.UTF8Characters = script_string->value().c_str();
2234 np_script.UTF8Length = script_string->value().length();
2236 // Get the current frame to pass to the evaluate function.
2237 WebLocalFrame* frame = container_->element().document().frame();
2239 try_catch.SetException("No frame to execute script in.");
2240 return PP_MakeUndefined();
2245 if (IsProcessingUserGesture()) {
2246 blink::WebScopedUserGesture user_gesture(CurrentUserGestureToken());
2248 WebBindings::evaluate(NULL, frame->windowObject(), &np_script, &result);
2251 WebBindings::evaluate(NULL, frame->windowObject(), &np_script, &result);
2254 // TryCatch doesn't catch the exceptions properly. Since this is only for
2255 // a trusted API, just set to a general exception message.
2256 try_catch.SetException("Exception caught");
2257 WebBindings::releaseVariantValue(&result);
2258 return PP_MakeUndefined();
2261 PP_Var ret = NPVariantToPPVar(this, &result);
2262 WebBindings::releaseVariantValue(&result);
2266 uint32_t PepperPluginInstanceImpl::GetAudioHardwareOutputSampleRate(
2267 PP_Instance instance) {
2268 RenderThreadImpl* thread = RenderThreadImpl::current();
2269 return thread->GetAudioHardwareConfig()->GetOutputSampleRate();
2272 uint32_t PepperPluginInstanceImpl::GetAudioHardwareOutputBufferSize(
2273 PP_Instance instance) {
2274 RenderThreadImpl* thread = RenderThreadImpl::current();
2275 return thread->GetAudioHardwareConfig()->GetOutputBufferSize();
2278 PP_Var PepperPluginInstanceImpl::GetDefaultCharSet(PP_Instance instance) {
2280 return PP_MakeUndefined();
2281 return StringVar::StringToPPVar(
2282 render_frame_->render_view()->webkit_preferences().default_encoding);
2285 // These PPB_ContentDecryptor_Private calls are responses to
2286 // PPP_ContentDecryptor_Private calls made on |content_decryptor_delegate_|.
2287 // Therefore, |content_decryptor_delegate_| must have been initialized when
2288 // the following methods are called.
2289 void PepperPluginInstanceImpl::SessionCreated(PP_Instance instance,
2290 uint32_t session_id,
2291 PP_Var web_session_id_var) {
2292 content_decryptor_delegate_->OnSessionCreated(session_id, web_session_id_var);
2295 void PepperPluginInstanceImpl::SessionMessage(PP_Instance instance,
2296 uint32_t session_id,
2298 PP_Var destination_url) {
2299 content_decryptor_delegate_->OnSessionMessage(
2300 session_id, message_var, destination_url);
2303 void PepperPluginInstanceImpl::SessionReady(PP_Instance instance,
2304 uint32_t session_id) {
2305 content_decryptor_delegate_->OnSessionReady(session_id);
2308 void PepperPluginInstanceImpl::SessionClosed(PP_Instance instance,
2309 uint32_t session_id) {
2310 content_decryptor_delegate_->OnSessionClosed(session_id);
2313 void PepperPluginInstanceImpl::SessionError(PP_Instance instance,
2314 uint32_t session_id,
2315 int32_t media_error,
2316 uint32_t system_code) {
2317 content_decryptor_delegate_->OnSessionError(
2318 session_id, media_error, system_code);
2321 void PepperPluginInstanceImpl::DeliverBlock(
2322 PP_Instance instance,
2323 PP_Resource decrypted_block,
2324 const PP_DecryptedBlockInfo* block_info) {
2325 content_decryptor_delegate_->DeliverBlock(decrypted_block, block_info);
2328 void PepperPluginInstanceImpl::DecoderInitializeDone(
2329 PP_Instance instance,
2330 PP_DecryptorStreamType decoder_type,
2331 uint32_t request_id,
2333 content_decryptor_delegate_->DecoderInitializeDone(
2334 decoder_type, request_id, success);
2337 void PepperPluginInstanceImpl::DecoderDeinitializeDone(
2338 PP_Instance instance,
2339 PP_DecryptorStreamType decoder_type,
2340 uint32_t request_id) {
2341 content_decryptor_delegate_->DecoderDeinitializeDone(decoder_type,
2345 void PepperPluginInstanceImpl::DecoderResetDone(
2346 PP_Instance instance,
2347 PP_DecryptorStreamType decoder_type,
2348 uint32_t request_id) {
2349 content_decryptor_delegate_->DecoderResetDone(decoder_type, request_id);
2352 void PepperPluginInstanceImpl::DeliverFrame(
2353 PP_Instance instance,
2354 PP_Resource decrypted_frame,
2355 const PP_DecryptedFrameInfo* frame_info) {
2356 content_decryptor_delegate_->DeliverFrame(decrypted_frame, frame_info);
2359 void PepperPluginInstanceImpl::DeliverSamples(
2360 PP_Instance instance,
2361 PP_Resource audio_frames,
2362 const PP_DecryptedSampleInfo* sample_info) {
2363 content_decryptor_delegate_->DeliverSamples(audio_frames, sample_info);
2366 void PepperPluginInstanceImpl::SetPluginToHandleFindRequests(
2367 PP_Instance instance) {
2368 if (!LoadFindInterface())
2370 bool is_main_frame =
2372 render_frame_->GetRenderView()->GetMainRenderFrame() == render_frame_;
2375 render_frame_->render_view()->set_plugin_find_handler(this);
2378 void PepperPluginInstanceImpl::NumberOfFindResultsChanged(
2379 PP_Instance instance,
2381 PP_Bool final_result) {
2382 DCHECK_NE(find_identifier_, -1);
2383 if (render_frame_) {
2384 render_frame_->reportFindInPageMatchCount(
2385 find_identifier_, total, PP_ToBool(final_result));
2389 void PepperPluginInstanceImpl::SelectedFindResultChanged(PP_Instance instance,
2391 DCHECK_NE(find_identifier_, -1);
2392 if (render_frame_) {
2393 render_frame_->reportFindInPageSelection(
2394 find_identifier_, index + 1, blink::WebRect());
2398 void PepperPluginInstanceImpl::SetTickmarks(PP_Instance instance,
2399 const PP_Rect* tickmarks,
2401 if (!render_frame_ || !render_frame_->GetWebFrame())
2404 blink::WebVector<blink::WebRect> tickmarks_converted(
2405 static_cast<size_t>(count));
2406 for (uint32 i = 0; i < count; ++i) {
2407 tickmarks_converted[i] = blink::WebRect(tickmarks[i].point.x,
2408 tickmarks[i].point.y,
2409 tickmarks[i].size.width,
2410 tickmarks[i].size.height);
2413 blink::WebFrame* frame = render_frame_->GetWebFrame();
2414 frame->setTickmarks(tickmarks_converted);
2417 PP_Bool PepperPluginInstanceImpl::IsFullscreen(PP_Instance instance) {
2418 return PP_FromBool(view_data_.is_fullscreen);
2421 PP_Bool PepperPluginInstanceImpl::SetFullscreen(PP_Instance instance,
2422 PP_Bool fullscreen) {
2423 return PP_FromBool(SetFullscreen(PP_ToBool(fullscreen)));
2426 PP_Bool PepperPluginInstanceImpl::GetScreenSize(PP_Instance instance,
2428 blink::WebScreenInfo info = render_frame()->GetRenderWidget()->screenInfo();
2429 *size = PP_MakeSize(info.rect.width, info.rect.height);
2433 ppapi::Resource* PepperPluginInstanceImpl::GetSingletonResource(
2434 PP_Instance instance,
2435 ppapi::SingletonResourceID id) {
2436 // Flash APIs and some others aren't implemented in-process.
2438 case ppapi::BROKER_SINGLETON_ID:
2439 case ppapi::BROWSER_FONT_SINGLETON_ID:
2440 case ppapi::EXTENSIONS_COMMON_SINGLETON_ID:
2441 case ppapi::FILE_MAPPING_SINGLETON_ID:
2442 case ppapi::FLASH_CLIPBOARD_SINGLETON_ID:
2443 case ppapi::FLASH_FILE_SINGLETON_ID:
2444 case ppapi::FLASH_FULLSCREEN_SINGLETON_ID:
2445 case ppapi::FLASH_SINGLETON_ID:
2446 case ppapi::ISOLATED_FILESYSTEM_SINGLETON_ID:
2447 case ppapi::NETWORK_PROXY_SINGLETON_ID:
2448 case ppapi::PDF_SINGLETON_ID:
2449 case ppapi::TRUETYPE_FONT_SINGLETON_ID:
2452 case ppapi::GAMEPAD_SINGLETON_ID:
2453 return gamepad_impl_.get();
2454 case ppapi::UMA_SINGLETON_ID: {
2455 if (!uma_private_impl_) {
2456 RendererPpapiHostImpl* host_impl = module_->renderer_ppapi_host();
2457 if (host_impl->in_process_router()) {
2458 uma_private_impl_ = new ppapi::proxy::UMAPrivateResource(
2459 host_impl->in_process_router()->GetPluginConnection(instance),
2463 return uma_private_impl_.get();
2471 int32_t PepperPluginInstanceImpl::RequestInputEvents(PP_Instance instance,
2472 uint32_t event_classes) {
2473 input_event_mask_ |= event_classes;
2474 filtered_input_event_mask_ &= ~(event_classes);
2475 RequestInputEventsHelper(event_classes);
2476 return ValidateRequestInputEvents(false, event_classes);
2479 int32_t PepperPluginInstanceImpl::RequestFilteringInputEvents(
2480 PP_Instance instance,
2481 uint32_t event_classes) {
2482 filtered_input_event_mask_ |= event_classes;
2483 input_event_mask_ &= ~(event_classes);
2484 RequestInputEventsHelper(event_classes);
2485 return ValidateRequestInputEvents(true, event_classes);
2488 void PepperPluginInstanceImpl::ClearInputEventRequest(PP_Instance instance,
2489 uint32_t event_classes) {
2490 input_event_mask_ &= ~(event_classes);
2491 filtered_input_event_mask_ &= ~(event_classes);
2492 RequestInputEventsHelper(event_classes);
2495 void PepperPluginInstanceImpl::ZoomChanged(PP_Instance instance,
2497 // We only want to tell the page to change its zoom if the whole page is the
2498 // plugin. If we're in an iframe, then don't do anything.
2499 if (!IsFullPagePlugin())
2501 container()->zoomLevelChanged(content::ZoomFactorToZoomLevel(factor));
2504 void PepperPluginInstanceImpl::ZoomLimitsChanged(PP_Instance instance,
2505 double minimum_factor,
2506 double maximum_factor) {
2509 if (minimum_factor > maximum_factor) {
2513 double minimum_level = ZoomFactorToZoomLevel(minimum_factor);
2514 double maximum_level = ZoomFactorToZoomLevel(maximum_factor);
2515 render_frame_->render_view()->webview()->zoomLimitsChanged(minimum_level,
2519 void PepperPluginInstanceImpl::PostMessage(PP_Instance instance,
2521 message_channel_->PostMessageToJavaScript(message);
2524 PP_Bool PepperPluginInstanceImpl::SetCursor(PP_Instance instance,
2525 PP_MouseCursor_Type type,
2527 const PP_Point* hot_spot) {
2528 if (!ValidateSetCursorParams(type, image, hot_spot))
2531 if (type != PP_MOUSECURSOR_TYPE_CUSTOM) {
2532 DoSetCursor(new WebCursorInfo(static_cast<WebCursorInfo::Type>(type)));
2536 EnterResourceNoLock<PPB_ImageData_API> enter(image, true);
2539 PPB_ImageData_Impl* image_data =
2540 static_cast<PPB_ImageData_Impl*>(enter.object());
2542 ImageDataAutoMapper auto_mapper(image_data);
2543 if (!auto_mapper.is_valid())
2546 scoped_ptr<WebCursorInfo> custom_cursor(
2547 new WebCursorInfo(WebCursorInfo::TypeCustom));
2548 custom_cursor->hotSpot.x = hot_spot->x;
2549 custom_cursor->hotSpot.y = hot_spot->y;
2551 const SkBitmap* bitmap = image_data->GetMappedBitmap();
2552 // Make a deep copy, so that the cursor remains valid even after the original
2553 // image data gets freed.
2554 if (!bitmap->copyTo(&custom_cursor->customImage.getSkBitmap())) {
2558 DoSetCursor(custom_cursor.release());
2562 int32_t PepperPluginInstanceImpl::LockMouse(
2563 PP_Instance instance,
2564 scoped_refptr<TrackedCallback> callback) {
2565 if (TrackedCallback::IsPending(lock_mouse_callback_))
2566 return PP_ERROR_INPROGRESS;
2568 if (IsMouseLocked())
2571 if (!CanAccessMainFrame())
2572 return PP_ERROR_NOACCESS;
2574 if (!IsProcessingUserGesture())
2575 return PP_ERROR_NO_USER_GESTURE;
2577 // Attempt mouselock only if Flash isn't waiting on fullscreen, otherwise
2578 // we wait and call LockMouse() in UpdateFlashFullscreenState().
2579 if (!FlashIsFullscreenOrPending() || flash_fullscreen_) {
2580 // Open a user gesture here so the Webkit user gesture checks will succeed
2581 // for out-of-process plugins.
2582 WebScopedUserGesture user_gesture(CurrentUserGestureToken());
2584 return PP_ERROR_FAILED;
2587 // Either mouselock succeeded or a Flash fullscreen is pending.
2588 lock_mouse_callback_ = callback;
2589 return PP_OK_COMPLETIONPENDING;
2592 void PepperPluginInstanceImpl::UnlockMouse(PP_Instance instance) {
2593 GetMouseLockDispatcher()->UnlockMouse(GetOrCreateLockTargetAdapter());
2596 void PepperPluginInstanceImpl::SetTextInputType(PP_Instance instance,
2597 PP_TextInput_Type type) {
2601 if (itype < 0 || itype > ui::TEXT_INPUT_TYPE_URL)
2602 itype = ui::TEXT_INPUT_TYPE_NONE;
2603 SetTextInputType(static_cast<ui::TextInputType>(itype));
2606 void PepperPluginInstanceImpl::UpdateCaretPosition(
2607 PP_Instance instance,
2608 const PP_Rect& caret,
2609 const PP_Rect& bounding_box) {
2612 text_input_caret_ = PP_ToGfxRect(caret);
2613 text_input_caret_bounds_ = PP_ToGfxRect(bounding_box);
2614 text_input_caret_set_ = true;
2615 render_frame_->PepperCaretPositionChanged(this);
2618 void PepperPluginInstanceImpl::CancelCompositionText(PP_Instance instance) {
2620 render_frame_->PepperCancelComposition(this);
2623 void PepperPluginInstanceImpl::SelectionChanged(PP_Instance instance) {
2624 // TODO(kinaba): currently the browser always calls RequestSurroundingText.
2625 // It can be optimized so that it won't call it back until the information
2626 // is really needed.
2628 // Avoid calling in nested context or else this will reenter the plugin. This
2629 // uses a weak pointer rather than exploiting the fact that this class is
2630 // refcounted because we don't actually want this operation to affect the
2631 // lifetime of the instance.
2632 base::MessageLoop::current()->PostTask(
2634 base::Bind(&PepperPluginInstanceImpl::RequestSurroundingText,
2635 weak_factory_.GetWeakPtr(),
2636 static_cast<size_t>(kExtraCharsForTextInput)));
2639 void PepperPluginInstanceImpl::UpdateSurroundingText(PP_Instance instance,
2645 surrounding_text_ = text;
2646 selection_caret_ = caret;
2647 selection_anchor_ = anchor;
2648 render_frame_->PepperSelectionChanged(this);
2651 PP_Var PepperPluginInstanceImpl::ResolveRelativeToDocument(
2652 PP_Instance instance,
2654 PP_URLComponents_Dev* components) {
2655 StringVar* relative_string = StringVar::FromPPVar(relative);
2656 if (!relative_string)
2657 return PP_MakeNull();
2659 WebElement plugin_element = container()->element();
2660 GURL document_url = plugin_element.document().baseURL();
2661 return ppapi::PPB_URLUtil_Shared::GenerateURLReturn(
2662 document_url.Resolve(relative_string->value()), components);
2665 PP_Bool PepperPluginInstanceImpl::DocumentCanRequest(PP_Instance instance,
2667 StringVar* url_string = StringVar::FromPPVar(url);
2671 blink::WebSecurityOrigin security_origin;
2672 if (!SecurityOriginForInstance(instance, &security_origin))
2675 GURL gurl(url_string->value());
2676 if (!gurl.is_valid())
2679 return BoolToPPBool(security_origin.canRequest(gurl));
2682 PP_Bool PepperPluginInstanceImpl::DocumentCanAccessDocument(
2683 PP_Instance instance,
2684 PP_Instance target) {
2685 blink::WebSecurityOrigin our_origin;
2686 if (!SecurityOriginForInstance(instance, &our_origin))
2689 blink::WebSecurityOrigin target_origin;
2690 if (!SecurityOriginForInstance(instance, &target_origin))
2693 return BoolToPPBool(our_origin.canAccess(target_origin));
2696 PP_Var PepperPluginInstanceImpl::GetDocumentURL(
2697 PP_Instance instance,
2698 PP_URLComponents_Dev* components) {
2699 blink::WebDocument document = container()->element().document();
2700 return ppapi::PPB_URLUtil_Shared::GenerateURLReturn(document.url(),
2704 PP_Var PepperPluginInstanceImpl::GetPluginInstanceURL(
2705 PP_Instance instance,
2706 PP_URLComponents_Dev* components) {
2707 return ppapi::PPB_URLUtil_Shared::GenerateURLReturn(plugin_url_, components);
2710 PP_Var PepperPluginInstanceImpl::GetPluginReferrerURL(
2711 PP_Instance instance,
2712 PP_URLComponents_Dev* components) {
2713 blink::WebDocument document = container()->element().document();
2715 return ppapi::PPB_URLUtil_Shared::GenerateURLReturn(document.url(),
2717 WebLocalFrame* frame = document.frame();
2719 return PP_MakeUndefined();
2720 const WebURLRequest& request = frame->dataSource()->originalRequest();
2721 WebString referer = request.httpHeaderField("Referer");
2722 if (referer.isEmpty())
2723 return PP_MakeUndefined();
2724 return ppapi::PPB_URLUtil_Shared::GenerateURLReturn(GURL(referer),
2728 PP_ExternalPluginResult PepperPluginInstanceImpl::ResetAsProxied(
2729 scoped_refptr<PluginModule> module) {
2730 // Save the original module and switch over to the new one now that this
2731 // plugin is using the IPC-based proxy.
2732 original_module_ = module_;
2735 // Don't send any messages to the plugin until DidCreate() has finished.
2736 message_channel_->QueueJavaScriptMessages();
2738 // For NaCl instances, remember the NaCl plugin instance interface, so we
2739 // can shut it down by calling its DidDestroy in our Delete() method.
2740 original_instance_interface_.reset(instance_interface_.release());
2742 base::Callback<const void*(const char*)> get_plugin_interface_func =
2743 base::Bind(&PluginModule::GetPluginInterface, module_.get());
2744 PPP_Instance_Combined* ppp_instance_combined =
2745 PPP_Instance_Combined::Create(get_plugin_interface_func);
2746 if (!ppp_instance_combined) {
2747 // The proxy must support at least one usable PPP_Instance interface.
2748 // While this could be a failure to implement the interface in the NaCl
2749 // module, it is more likely that the NaCl process has crashed. Either
2750 // way, report that module initialization failed.
2751 return PP_EXTERNAL_PLUGIN_ERROR_MODULE;
2754 instance_interface_.reset(ppp_instance_combined);
2755 // Clear all PPP interfaces we may have cached.
2756 plugin_find_interface_ = NULL;
2757 plugin_input_event_interface_ = NULL;
2758 checked_for_plugin_input_event_interface_ = false;
2759 plugin_mouse_lock_interface_ = NULL;
2760 plugin_pdf_interface_ = NULL;
2761 checked_for_plugin_pdf_interface_ = false;
2762 plugin_private_interface_ = NULL;
2763 plugin_selection_interface_ = NULL;
2764 plugin_textinput_interface_ = NULL;
2765 plugin_zoom_interface_ = NULL;
2767 // Re-send the DidCreate event via the proxy.
2768 scoped_ptr<const char * []> argn_array(StringVectorToArgArray(argn_));
2769 scoped_ptr<const char * []> argv_array(StringVectorToArgArray(argv_));
2770 if (!instance_interface_->DidCreate(
2771 pp_instance(), argn_.size(), argn_array.get(), argv_array.get()))
2772 return PP_EXTERNAL_PLUGIN_ERROR_INSTANCE;
2773 message_channel_->StopQueueingJavaScriptMessages();
2775 // Clear sent_initial_did_change_view_ and cancel any pending DidChangeView
2776 // event. This way, SendDidChangeView will send the "current" view
2777 // immediately (before other events like HandleDocumentLoad).
2778 sent_initial_did_change_view_ = false;
2779 view_change_weak_ptr_factory_.InvalidateWeakPtrs();
2780 SendDidChangeView();
2782 DCHECK(external_document_load_);
2783 external_document_load_ = false;
2784 if (!external_document_response_.isNull()) {
2785 document_loader_ = NULL;
2786 // Pass the response to the new proxy.
2787 HandleDocumentLoad(external_document_response_);
2788 external_document_response_ = blink::WebURLResponse();
2789 // Replay any document load events we've received to the real loader.
2790 external_document_loader_->ReplayReceivedData(document_loader_);
2791 external_document_loader_.reset(NULL);
2794 return PP_EXTERNAL_PLUGIN_OK;
2797 bool PepperPluginInstanceImpl::IsValidInstanceOf(PluginModule* module) {
2799 return module == module_.get() || module == original_module_.get();
2802 NPP PepperPluginInstanceImpl::instanceNPP() { return npp_.get(); }
2804 PepperPluginInstance* PepperPluginInstance::Get(PP_Instance instance_id) {
2805 return HostGlobals::Get()->GetInstance(instance_id);
2808 RenderView* PepperPluginInstanceImpl::GetRenderView() {
2809 return render_frame_ ? render_frame_->render_view() : NULL;
2812 blink::WebPluginContainer* PepperPluginInstanceImpl::GetContainer() {
2816 v8::Isolate* PepperPluginInstanceImpl::GetIsolate() const { return isolate_; }
2818 ppapi::VarTracker* PepperPluginInstanceImpl::GetVarTracker() {
2819 return HostGlobals::Get()->GetVarTracker();
2822 const GURL& PepperPluginInstanceImpl::GetPluginURL() { return plugin_url_; }
2824 base::FilePath PepperPluginInstanceImpl::GetModulePath() {
2825 return module_->path();
2828 PP_Resource PepperPluginInstanceImpl::CreateImage(gfx::ImageSkia* source_image,
2830 gfx::ImageSkiaRep image_skia_rep = source_image->GetRepresentation(scale);
2832 if (image_skia_rep.is_null() || image_skia_rep.scale() != scale)
2835 scoped_refptr<PPB_ImageData_Impl> image_data(
2836 new PPB_ImageData_Impl(pp_instance(), PPB_ImageData_Impl::PLATFORM));
2837 if (!image_data->Init(PPB_ImageData_Impl::GetNativeImageDataFormat(),
2838 image_skia_rep.pixel_width(),
2839 image_skia_rep.pixel_height(),
2844 ImageDataAutoMapper mapper(image_data.get());
2845 if (!mapper.is_valid())
2848 skia::PlatformCanvas* canvas = image_data->GetPlatformCanvas();
2849 // Note: Do not SkBitmap::copyTo the canvas bitmap directly because it will
2850 // ignore the allocated pixels in shared memory and re-allocate a new buffer.
2851 canvas->writePixels(image_skia_rep.sk_bitmap(), 0, 0);
2853 return image_data->GetReference();
2856 PP_ExternalPluginResult PepperPluginInstanceImpl::SwitchToOutOfProcessProxy(
2857 const base::FilePath& file_path,
2858 ppapi::PpapiPermissions permissions,
2859 const IPC::ChannelHandle& channel_handle,
2860 base::ProcessId plugin_pid,
2861 int plugin_child_id) {
2862 // Create a new module for each instance of the external plugin that is using
2863 // the IPC based out-of-process proxy. We can't use the existing module,
2864 // because it is configured for the in-process plugin, and we must keep it
2865 // that way to allow the page to create other instances.
2866 scoped_refptr<PluginModule> external_plugin_module(
2867 module_->CreateModuleForExternalPluginInstance());
2869 RendererPpapiHostImpl* renderer_ppapi_host =
2870 external_plugin_module->CreateOutOfProcessModule(render_frame_,
2877 if (!renderer_ppapi_host) {
2878 DLOG(ERROR) << "CreateExternalPluginModule() failed";
2879 return PP_EXTERNAL_PLUGIN_ERROR_MODULE;
2882 // Finally, switch the instance to the proxy.
2883 return external_plugin_module->InitAsProxiedExternalPlugin(this);
2886 void PepperPluginInstanceImpl::SetAlwaysOnTop(bool on_top) {
2887 always_on_top_ = on_top;
2890 void PepperPluginInstanceImpl::DoSetCursor(WebCursorInfo* cursor) {
2891 cursor_.reset(cursor);
2892 if (fullscreen_container_) {
2893 fullscreen_container_->DidChangeCursor(*cursor);
2894 } else if (render_frame_) {
2895 render_frame_->PepperDidChangeCursor(this, *cursor);
2899 bool PepperPluginInstanceImpl::IsFullPagePlugin() {
2900 WebLocalFrame* frame = container()->element().document().frame();
2901 return frame->view()->mainFrame()->document().isPluginDocument();
2904 bool PepperPluginInstanceImpl::FlashSetFullscreen(bool fullscreen,
2905 bool delay_report) {
2906 TRACE_EVENT0("ppapi", "PepperPluginInstanceImpl::FlashSetFullscreen");
2907 // Keep a reference on the stack. See NOTE above.
2908 scoped_refptr<PepperPluginInstanceImpl> ref(this);
2910 // We check whether we are trying to switch to the state we're already going
2911 // to (i.e. if we're already switching to fullscreen but the fullscreen
2912 // container isn't ready yet, don't do anything more).
2913 if (fullscreen == FlashIsFullscreenOrPending())
2918 if (fullscreen && !render_frame_->render_view()
2919 ->renderer_preferences()
2920 .plugin_fullscreen_allowed)
2923 // Unbind current 2D or 3D graphics context.
2924 VLOG(1) << "Setting fullscreen to " << (fullscreen ? "on" : "off");
2926 DCHECK(!fullscreen_container_);
2927 fullscreen_container_ =
2928 render_frame_->CreatePepperFullscreenContainer(this);
2931 DCHECK(fullscreen_container_);
2932 fullscreen_container_->Destroy();
2933 fullscreen_container_ = NULL;
2934 UpdateFlashFullscreenState(false);
2935 if (!delay_report) {
2938 base::MessageLoop::current()->PostTask(
2940 base::Bind(&PepperPluginInstanceImpl::ReportGeometry, this));
2947 bool PepperPluginInstanceImpl::IsRectTopmost(const gfx::Rect& rect) {
2948 if (flash_fullscreen_)
2951 return container_->isRectTopmost(rect);
2954 int32_t PepperPluginInstanceImpl::Navigate(
2955 const ppapi::URLRequestInfoData& request,
2957 bool from_user_action) {
2959 return PP_ERROR_FAILED;
2961 WebDocument document = container_->element().document();
2962 WebLocalFrame* frame = document.frame();
2964 return PP_ERROR_FAILED;
2966 ppapi::URLRequestInfoData completed_request = request;
2968 WebURLRequest web_request;
2969 if (!CreateWebURLRequest(
2970 pp_instance_, &completed_request, frame, &web_request)) {
2971 return PP_ERROR_FAILED;
2973 web_request.setFirstPartyForCookies(document.firstPartyForCookies());
2974 web_request.setHasUserGesture(from_user_action);
2976 GURL gurl(web_request.url());
2977 if (gurl.SchemeIs("javascript")) {
2978 // In imitation of the NPAPI implementation, only |target_frame == frame| is
2979 // allowed for security reasons.
2980 WebFrame* target_frame =
2981 frame->view()->findFrameByName(WebString::fromUTF8(target), frame);
2982 if (target_frame != frame)
2983 return PP_ERROR_NOACCESS;
2985 // TODO(viettrungluu): NPAPI sends the result back to the plugin -- do we
2987 WebString result = container_->executeScriptURL(gurl, from_user_action);
2988 return result.isNull() ? PP_ERROR_FAILED : PP_OK;
2991 // Only GETs and POSTs are supported.
2992 if (web_request.httpMethod() != "GET" && web_request.httpMethod() != "POST")
2993 return PP_ERROR_BADARGUMENT;
2995 WebString target_str = WebString::fromUTF8(target);
2996 container_->loadFrameRequest(web_request, target_str, false, NULL);
3000 int PepperPluginInstanceImpl::MakePendingFileRefRendererHost(
3001 const base::FilePath& path) {
3002 RendererPpapiHostImpl* host_impl = module_->renderer_ppapi_host();
3003 PepperFileRefRendererHost* file_ref_host(
3004 new PepperFileRefRendererHost(host_impl, pp_instance(), 0, path));
3005 return host_impl->GetPpapiHost()->AddPendingResourceHost(
3006 scoped_ptr<ppapi::host::ResourceHost>(file_ref_host));
3009 void PepperPluginInstanceImpl::SetEmbedProperty(PP_Var key, PP_Var value) {
3010 message_channel_->SetReadOnlyProperty(key, value);
3013 bool PepperPluginInstanceImpl::CanAccessMainFrame() const {
3016 blink::WebDocument containing_document = container_->element().document();
3018 if (!containing_document.frame() || !containing_document.frame()->view() ||
3019 !containing_document.frame()->view()->mainFrame()) {
3022 blink::WebDocument main_document =
3023 containing_document.frame()->view()->mainFrame()->document();
3025 return containing_document.securityOrigin().canAccess(
3026 main_document.securityOrigin());
3029 void PepperPluginInstanceImpl::KeepSizeAttributesBeforeFullscreen() {
3030 WebElement element = container_->element();
3031 width_before_fullscreen_ = element.getAttribute(WebString::fromUTF8(kWidth));
3032 height_before_fullscreen_ =
3033 element.getAttribute(WebString::fromUTF8(kHeight));
3034 border_before_fullscreen_ =
3035 element.getAttribute(WebString::fromUTF8(kBorder));
3036 style_before_fullscreen_ = element.getAttribute(WebString::fromUTF8(kStyle));
3039 void PepperPluginInstanceImpl::SetSizeAttributesForFullscreen() {
3042 blink::WebScreenInfo info = render_frame_->GetRenderWidget()->screenInfo();
3043 screen_size_for_fullscreen_ = gfx::Size(info.rect.width, info.rect.height);
3044 std::string width = StringPrintf("%d", screen_size_for_fullscreen_.width());
3045 std::string height = StringPrintf("%d", screen_size_for_fullscreen_.height());
3047 WebElement element = container_->element();
3048 element.setAttribute(WebString::fromUTF8(kWidth), WebString::fromUTF8(width));
3049 element.setAttribute(WebString::fromUTF8(kHeight),
3050 WebString::fromUTF8(height));
3051 element.setAttribute(WebString::fromUTF8(kBorder), WebString::fromUTF8("0"));
3053 // There should be no style settings that matter in fullscreen mode,
3054 // so just replace them instead of appending.
3055 // NOTE: "position: fixed" and "display: block" reset the plugin and
3056 // using %% settings might not work without them (e.g. if the plugin is a
3057 // child of a container element).
3059 style += StringPrintf("width: %s !important; ", width.c_str());
3060 style += StringPrintf("height: %s !important; ", height.c_str());
3061 style += "margin: 0 !important; padding: 0 !important; border: 0 !important";
3062 container_->element().setAttribute(kStyle, WebString::fromUTF8(style));
3065 void PepperPluginInstanceImpl::ResetSizeAttributesAfterFullscreen() {
3066 screen_size_for_fullscreen_ = gfx::Size();
3067 WebElement element = container_->element();
3068 element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
3069 element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
3070 element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
3071 element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
3074 bool PepperPluginInstanceImpl::IsMouseLocked() {
3075 return GetMouseLockDispatcher()->IsMouseLockedTo(
3076 GetOrCreateLockTargetAdapter());
3079 bool PepperPluginInstanceImpl::LockMouse() {
3080 return GetMouseLockDispatcher()->LockMouse(GetOrCreateLockTargetAdapter());
3083 MouseLockDispatcher::LockTarget*
3084 PepperPluginInstanceImpl::GetOrCreateLockTargetAdapter() {
3085 if (!lock_target_.get()) {
3086 lock_target_.reset(new PluginInstanceLockTarget(this));
3088 return lock_target_.get();
3091 MouseLockDispatcher* PepperPluginInstanceImpl::GetMouseLockDispatcher() {
3092 if (flash_fullscreen_) {
3093 RenderWidgetFullscreenPepper* container =
3094 static_cast<RenderWidgetFullscreenPepper*>(fullscreen_container_);
3095 return container->mouse_lock_dispatcher();
3096 } else if (render_frame_) {
3097 return render_frame_->render_view()->mouse_lock_dispatcher();
3102 void PepperPluginInstanceImpl::UnSetAndDeleteLockTargetAdapter() {
3103 if (lock_target_.get()) {
3104 GetMouseLockDispatcher()->OnLockTargetDestroyed(lock_target_.get());
3105 lock_target_.reset();
3109 void PepperPluginInstanceImpl::DidDataFromWebURLResponse(
3110 const blink::WebURLResponse& response,
3111 int pending_host_id,
3112 const ppapi::URLResponseInfoData& data) {
3113 RendererPpapiHostImpl* host_impl = module_->renderer_ppapi_host();
3115 if (host_impl->in_process_router()) {
3116 // Running in-process, we can just create the resource and call the
3117 // PPP_Instance function directly.
3118 scoped_refptr<ppapi::proxy::URLLoaderResource> loader_resource(
3119 new ppapi::proxy::URLLoaderResource(
3120 host_impl->in_process_router()->GetPluginConnection(pp_instance()),
3125 PP_Resource loader_pp_resource = loader_resource->GetReference();
3126 if (!instance_interface_->HandleDocumentLoad(pp_instance(),
3127 loader_pp_resource))
3128 loader_resource->Close();
3129 // We don't pass a ref into the plugin, if it wants one, it will have taken
3130 // an additional one.
3131 ppapi::PpapiGlobals::Get()->GetResourceTracker()->ReleaseResource(
3132 loader_pp_resource);
3134 // Running out-of-process. Initiate an IPC call to notify the plugin
3136 ppapi::proxy::HostDispatcher* dispatcher =
3137 ppapi::proxy::HostDispatcher::GetForInstance(pp_instance());
3138 dispatcher->Send(new PpapiMsg_PPPInstance_HandleDocumentLoad(
3139 ppapi::API_ID_PPP_INSTANCE, pp_instance(), pending_host_id, data));
3143 } // namespace content