?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove Observer methods in RTCVideoEncoderFactory.
[chromium-blink-merge.git] / content / renderer / render_widget.cc
blob8658aebb8b92cf921e280a6fe469366142dd0fe3
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "content/renderer/render_widget.h"
6
7 #include "base/auto_reset.h"
8 #include "base/bind.h"
9 #include "base/command_line.h"
10 #include "base/debug/trace_event.h"
11 #include "base/debug/trace_event_synthetic_delay.h"
12 #include "base/logging.h"
13 #include "base/memory/scoped_ptr.h"
14 #include "base/memory/singleton.h"
15 #include "base/message_loop/message_loop.h"
16 #include "base/metrics/histogram.h"
17 #include "base/stl_util.h"
18 #include "base/strings/utf_string_conversions.h"
19 #include "base/sys_info.h"
20 #include "build/build_config.h"
21 #include "cc/base/switches.h"
22 #include "cc/debug/benchmark_instrumentation.h"
23 #include "cc/output/output_surface.h"
24 #include "cc/trees/layer_tree_host.h"
25 #include "content/child/npapi/webplugin.h"
26 #include "content/common/gpu/client/context_provider_command_buffer.h"
27 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
28 #include "content/common/gpu/gpu_process_launch_causes.h"
29 #include "content/common/input/synthetic_gesture_packet.h"
30 #include "content/common/input/web_input_event_traits.h"
31 #include "content/common/input_messages.h"
32 #include "content/common/swapped_out_messages.h"
33 #include "content/common/view_messages.h"
34 #include "content/public/common/content_switches.h"
35 #include "content/public/common/context_menu_params.h"
36 #include "content/renderer/cursor_utils.h"
37 #include "content/renderer/external_popup_menu.h"
38 #include "content/renderer/gpu/compositor_output_surface.h"
39 #include "content/renderer/gpu/compositor_software_output_device.h"
40 #include "content/renderer/gpu/delegated_compositor_output_surface.h"
41 #include "content/renderer/gpu/frame_swap_message_queue.h"
42 #include "content/renderer/gpu/mailbox_output_surface.h"
43 #include "content/renderer/gpu/queue_message_swap_promise.h"
44 #include "content/renderer/gpu/render_widget_compositor.h"
45 #include "content/renderer/ime_event_guard.h"
46 #include "content/renderer/input/input_handler_manager.h"
47 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
48 #include "content/renderer/render_frame_impl.h"
49 #include "content/renderer/render_frame_proxy.h"
50 #include "content/renderer/render_process.h"
51 #include "content/renderer/render_thread_impl.h"
52 #include "content/renderer/renderer_blink_platform_impl.h"
53 #include "content/renderer/resizing_mode_selector.h"
54 #include "ipc/ipc_sync_message.h"
55 #include "skia/ext/platform_canvas.h"
56 #include "third_party/WebKit/public/platform/WebCursorInfo.h"
57 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
58 #include "third_party/WebKit/public/platform/WebRect.h"
59 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
60 #include "third_party/WebKit/public/platform/WebSize.h"
61 #include "third_party/WebKit/public/platform/WebString.h"
62 #include "third_party/WebKit/public/web/WebDeviceEmulationParams.h"
63 #include "third_party/WebKit/public/web/WebPagePopup.h"
64 #include "third_party/WebKit/public/web/WebPopupMenu.h"
65 #include "third_party/WebKit/public/web/WebPopupMenuInfo.h"
66 #include "third_party/WebKit/public/web/WebRange.h"
67 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
68 #include "third_party/skia/include/core/SkShader.h"
69 #include "ui/base/ui_base_switches.h"
70 #include "ui/gfx/frame_time.h"
71 #include "ui/gfx/point_conversions.h"
72 #include "ui/gfx/rect_conversions.h"
73 #include "ui/gfx/size_conversions.h"
74 #include "ui/gfx/skia_util.h"
75 #include "ui/gl/gl_switches.h"
76 #include "ui/surface/transport_dib.h"
77
78 #if defined(OS_ANDROID)
79 #include <android/keycodes.h>
80 #include "content/renderer/android/synchronous_compositor_factory.h"
81 #endif
82
83 #if defined(OS_POSIX)
84 #include "ipc/ipc_channel_posix.h"
85 #include "third_party/skia/include/core/SkMallocPixelRef.h"
86 #include "third_party/skia/include/core/SkPixelRef.h"
87 #endif // defined(OS_POSIX)
88
89 #include "third_party/WebKit/public/web/WebWidget.h"
90
91 using blink::WebCompositionUnderline;
92 using blink::WebCursorInfo;
93 using blink::WebDeviceEmulationParams;
94 using blink::WebGestureEvent;
95 using blink::WebInputEvent;
96 using blink::WebKeyboardEvent;
97 using blink::WebMouseEvent;
98 using blink::WebMouseWheelEvent;
99 using blink::WebNavigationPolicy;
100 using blink::WebPagePopup;
101 using blink::WebPopupMenu;
102 using blink::WebPopupMenuInfo;
103 using blink::WebPopupType;
104 using blink::WebRange;
105 using blink::WebRect;
106 using blink::WebScreenInfo;
107 using blink::WebSize;
108 using blink::WebTextDirection;
109 using blink::WebTouchEvent;
110 using blink::WebTouchPoint;
111 using blink::WebVector;
112 using blink::WebWidget;
113
114 namespace {
115
116 typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
117
118 class TextInputModeMapSingleton {
119 public:
120 static TextInputModeMapSingleton* GetInstance() {
121 return Singleton<TextInputModeMapSingleton>::get();
122 }
123 TextInputModeMapSingleton() {
124 map_["verbatim"] = ui::TEXT_INPUT_MODE_VERBATIM;
125 map_["latin"] = ui::TEXT_INPUT_MODE_LATIN;
126 map_["latin-name"] = ui::TEXT_INPUT_MODE_LATIN_NAME;
127 map_["latin-prose"] = ui::TEXT_INPUT_MODE_LATIN_PROSE;
128 map_["full-width-latin"] = ui::TEXT_INPUT_MODE_FULL_WIDTH_LATIN;
129 map_["kana"] = ui::TEXT_INPUT_MODE_KANA;
130 map_["katakana"] = ui::TEXT_INPUT_MODE_KATAKANA;
131 map_["numeric"] = ui::TEXT_INPUT_MODE_NUMERIC;
132 map_["tel"] = ui::TEXT_INPUT_MODE_TEL;
133 map_["email"] = ui::TEXT_INPUT_MODE_EMAIL;
134 map_["url"] = ui::TEXT_INPUT_MODE_URL;
135 }
136 const TextInputModeMap& map() const { return map_; }
137 private:
138 TextInputModeMap map_;
139
140 friend struct DefaultSingletonTraits<TextInputModeMapSingleton>;
141
142 DISALLOW_COPY_AND_ASSIGN(TextInputModeMapSingleton);
143 };
144
145 ui::TextInputMode ConvertInputMode(const blink::WebString& input_mode) {
146 static TextInputModeMapSingleton* singleton =
147 TextInputModeMapSingleton::GetInstance();
148 TextInputModeMap::const_iterator it =
149 singleton->map().find(input_mode.utf8());
150 if (it == singleton->map().end())
151 return ui::TEXT_INPUT_MODE_DEFAULT;
152 return it->second;
153 }
154
155 bool IsThreadedCompositingEnabled() {
156 content::RenderThreadImpl* impl = content::RenderThreadImpl::current();
157 return impl && !!impl->compositor_message_loop_proxy().get();
158 }
159
160 // TODO(brianderson): Replace the hard-coded threshold with a fraction of
161 // the BeginMainFrame interval.
162 // 4166us will allow 1/4 of a 60Hz interval or 1/2 of a 120Hz interval to
163 // be spent in input hanlders before input starts getting throttled.
164 const int kInputHandlingTimeThrottlingThresholdMicroseconds = 4166;
165
166 } // namespace
167
168 namespace content {
169
170 // RenderWidget::ScreenMetricsEmulator ----------------------------------------
171
172 class RenderWidget::ScreenMetricsEmulator {
173 public:
174 ScreenMetricsEmulator(
175 RenderWidget* widget,
176 const WebDeviceEmulationParams& params);
177 virtual ~ScreenMetricsEmulator();
178
179 // Scale and offset used to convert between host coordinates
180 // and webwidget coordinates.
181 float scale() { return scale_; }
182 gfx::Point offset() { return offset_; }
183 gfx::Rect applied_widget_rect() const { return applied_widget_rect_; }
184 gfx::Rect original_screen_rect() const { return original_view_screen_rect_; }
185 const WebScreenInfo& original_screen_info() { return original_screen_info_; }
186
187 void ChangeEmulationParams(
188 const WebDeviceEmulationParams& params);
189
190 // The following methods alter handlers' behavior for messages related to
191 // widget size and position.
192 void OnResizeMessage(const ViewMsg_Resize_Params& params);
193 void OnUpdateScreenRectsMessage(const gfx::Rect& view_screen_rect,
194 const gfx::Rect& window_screen_rect);
195 void OnShowContextMenu(ContextMenuParams* params);
196 gfx::Rect AdjustValidationMessageAnchor(const gfx::Rect& anchor);
197
198 private:
199 void Reapply();
200 void Apply(float top_controls_layout_height,
201 gfx::Rect resizer_rect,
202 bool is_fullscreen);
203
204 RenderWidget* widget_;
205
206 // Parameters as passed by RenderWidget::EnableScreenMetricsEmulation.
207 WebDeviceEmulationParams params_;
208
209 // The computed scale and offset used to fit widget into browser window.
210 float scale_;
211 gfx::Point offset_;
212
213 // Widget rect as passed to webwidget.
214 gfx::Rect applied_widget_rect_;
215
216 // Original values to restore back after emulation ends.
217 gfx::Size original_size_;
218 gfx::Size original_physical_backing_size_;
219 gfx::Size original_visible_viewport_size_;
220 blink::WebScreenInfo original_screen_info_;
221 gfx::Rect original_view_screen_rect_;
222 gfx::Rect original_window_screen_rect_;
223 };
224
225 RenderWidget::ScreenMetricsEmulator::ScreenMetricsEmulator(
226 RenderWidget* widget,
227 const WebDeviceEmulationParams& params)
228 : widget_(widget),
229 params_(params),
230 scale_(1.f) {
231 original_size_ = widget_->size_;
232 original_physical_backing_size_ = widget_->physical_backing_size_;
233 original_visible_viewport_size_ = widget_->visible_viewport_size_;
234 original_screen_info_ = widget_->screen_info_;
235 original_view_screen_rect_ = widget_->view_screen_rect_;
236 original_window_screen_rect_ = widget_->window_screen_rect_;
237 Apply(widget_->top_controls_layout_height_, widget_->resizer_rect_,
238 widget_->is_fullscreen_);
239 }
240
241 RenderWidget::ScreenMetricsEmulator::~ScreenMetricsEmulator() {
242 widget_->screen_info_ = original_screen_info_;
243
244 widget_->SetDeviceScaleFactor(original_screen_info_.deviceScaleFactor);
245 widget_->SetScreenMetricsEmulationParameters(0.f, gfx::Point(), 1.f);
246 widget_->view_screen_rect_ = original_view_screen_rect_;
247 widget_->window_screen_rect_ = original_window_screen_rect_;
248 widget_->Resize(original_size_,
249 original_physical_backing_size_,
250 widget_->top_controls_layout_height_,
251 original_visible_viewport_size_,
252 widget_->resizer_rect_,
253 widget_->is_fullscreen_,
254 NO_RESIZE_ACK);
255 }
256
257 void RenderWidget::ScreenMetricsEmulator::ChangeEmulationParams(
258 const WebDeviceEmulationParams& params) {
259 params_ = params;
260 Reapply();
261 }
262
263 void RenderWidget::ScreenMetricsEmulator::Reapply() {
264 Apply(widget_->top_controls_layout_height_, widget_->resizer_rect_,
265 widget_->is_fullscreen_);
266 }
267
268 void RenderWidget::ScreenMetricsEmulator::Apply(
269 float top_controls_layout_height,
270 gfx::Rect resizer_rect,
271 bool is_fullscreen) {
272 applied_widget_rect_.set_size(gfx::Size(params_.viewSize));
273 if (!applied_widget_rect_.width())
274 applied_widget_rect_.set_width(original_size_.width());
275 if (!applied_widget_rect_.height())
276 applied_widget_rect_.set_height(original_size_.height());
277
278 if (params_.fitToView && !original_size_.IsEmpty()) {
279 int original_width = std::max(original_size_.width(), 1);
280 int original_height = std::max(original_size_.height(), 1);
281 float width_ratio =
282 static_cast<float>(applied_widget_rect_.width()) / original_width;
283 float height_ratio =
284 static_cast<float>(applied_widget_rect_.height()) / original_height;
285 float ratio = std::max(1.0f, std::max(width_ratio, height_ratio));
286 scale_ = 1.f / ratio;
287
288 // Center emulated view inside available view space.
289 offset_.set_x(
290 (original_size_.width() - scale_ * applied_widget_rect_.width()) / 2);
291 offset_.set_y(
292 (original_size_.height() - scale_ * applied_widget_rect_.height()) / 2);
293 } else {
294 scale_ = params_.scale;
295 offset_.SetPoint(params_.offset.x, params_.offset.y);
296 }
297
298 if (params_.screenPosition == WebDeviceEmulationParams::Desktop) {
299 applied_widget_rect_.set_origin(original_view_screen_rect_.origin());
300 widget_->screen_info_.rect = original_screen_info_.rect;
301 widget_->screen_info_.availableRect = original_screen_info_.availableRect;
302 widget_->window_screen_rect_ = original_window_screen_rect_;
303 } else {
304 applied_widget_rect_.set_origin(gfx::Point(0, 0));
305 widget_->screen_info_.rect = applied_widget_rect_;
306 widget_->screen_info_.availableRect = applied_widget_rect_;
307 widget_->window_screen_rect_ = applied_widget_rect_;
308 }
309
310 float applied_device_scale_factor = params_.deviceScaleFactor ?
311 params_.deviceScaleFactor : original_screen_info_.deviceScaleFactor;
312 widget_->screen_info_.deviceScaleFactor = applied_device_scale_factor;
313
314 // Pass three emulation parameters to the blink side:
315 // - we keep the real device scale factor in compositor to produce sharp image
316 // even when emulating different scale factor;
317 // - in order to fit into view, WebView applies offset and scale to the
318 // root layer.
319 widget_->SetScreenMetricsEmulationParameters(
320 original_screen_info_.deviceScaleFactor, offset_, scale_);
321
322 widget_->SetDeviceScaleFactor(applied_device_scale_factor);
323 widget_->view_screen_rect_ = applied_widget_rect_;
324
325 gfx::Size physical_backing_size = gfx::ToCeiledSize(gfx::ScaleSize(
326 original_size_, original_screen_info_.deviceScaleFactor));
327 widget_->Resize(applied_widget_rect_.size(), physical_backing_size,
328 top_controls_layout_height, applied_widget_rect_.size(), resizer_rect,
329 is_fullscreen, NO_RESIZE_ACK);
330 }
331
332 void RenderWidget::ScreenMetricsEmulator::OnResizeMessage(
333 const ViewMsg_Resize_Params& params) {
334 bool need_ack = params.new_size != original_size_ &&
335 !params.new_size.IsEmpty() && !params.physical_backing_size.IsEmpty();
336 original_size_ = params.new_size;
337 original_physical_backing_size_ = params.physical_backing_size;
338 original_screen_info_ = params.screen_info;
339 original_visible_viewport_size_ = params.visible_viewport_size;
340 Apply(params.top_controls_layout_height, params.resizer_rect,
341 params.is_fullscreen);
342
343 if (need_ack) {
344 widget_->set_next_paint_is_resize_ack();
345 if (widget_->compositor_)
346 widget_->compositor_->SetNeedsRedrawRect(gfx::Rect(widget_->size_));
347 }
348 }
349
350 void RenderWidget::ScreenMetricsEmulator::OnUpdateScreenRectsMessage(
351 const gfx::Rect& view_screen_rect,
352 const gfx::Rect& window_screen_rect) {
353 original_view_screen_rect_ = view_screen_rect;
354 original_window_screen_rect_ = window_screen_rect;
355 if (params_.screenPosition == WebDeviceEmulationParams::Desktop)
356 Reapply();
357 }
358
359 void RenderWidget::ScreenMetricsEmulator::OnShowContextMenu(
360 ContextMenuParams* params) {
361 params->x *= scale_;
362 params->x += offset_.x();
363 params->y *= scale_;
364 params->y += offset_.y();
365 }
366
367 gfx::Rect RenderWidget::ScreenMetricsEmulator::AdjustValidationMessageAnchor(
368 const gfx::Rect& anchor) {
369 gfx::Rect scaled = gfx::ToEnclosedRect(gfx::ScaleRect(anchor, scale_));
370 scaled.set_x(scaled.x() + offset_.x());
371 scaled.set_y(scaled.y() + offset_.y());
372 return scaled;
373 }
374
375 // RenderWidget ---------------------------------------------------------------
376
377 RenderWidget::RenderWidget(blink::WebPopupType popup_type,
378 const blink::WebScreenInfo& screen_info,
379 bool swapped_out,
380 bool hidden,
381 bool never_visible)
382 : routing_id_(MSG_ROUTING_NONE),
383 surface_id_(0),
384 webwidget_(NULL),
385 opener_id_(MSG_ROUTING_NONE),
386 init_complete_(false),
387 top_controls_layout_height_(0.f),
388 next_paint_flags_(0),
389 auto_resize_mode_(false),
390 need_update_rect_for_auto_resize_(false),
391 did_show_(false),
392 is_hidden_(hidden),
393 never_visible_(never_visible),
394 is_fullscreen_(false),
395 has_focus_(false),
396 handling_input_event_(false),
397 handling_ime_event_(false),
398 handling_event_type_(WebInputEvent::Undefined),
399 ignore_ack_for_mouse_move_from_debugger_(false),
400 closing_(false),
401 host_closing_(false),
402 is_swapped_out_(swapped_out),
403 input_method_is_active_(false),
404 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
405 text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
406 can_compose_inline_(true),
407 popup_type_(popup_type),
408 pending_window_rect_count_(0),
409 suppress_next_char_events_(false),
410 screen_info_(screen_info),
411 device_scale_factor_(screen_info_.deviceScaleFactor),
412 current_event_latency_info_(NULL),
413 next_output_surface_id_(0),
414 #if defined(OS_ANDROID)
415 text_field_is_dirty_(false),
416 outstanding_ime_acks_(0),
417 body_background_color_(SK_ColorWHITE),
418 #endif
419 popup_origin_scale_for_emulation_(0.f),
420 frame_swap_message_queue_(new FrameSwapMessageQueue()),
421 resizing_mode_selector_(new ResizingModeSelector()),
422 context_menu_source_type_(ui::MENU_SOURCE_MOUSE),
423 has_host_context_menu_location_(false) {
424 if (!swapped_out)
425 RenderProcess::current()->AddRefProcess();
426 DCHECK(RenderThread::Get());
427 device_color_profile_.push_back('0');
428 }
429
430 RenderWidget::~RenderWidget() {
431 DCHECK(!webwidget_) << "Leaking our WebWidget!";
432
433 // If we are swapped out, we have released already.
434 if (!is_swapped_out_ && RenderProcess::current())
435 RenderProcess::current()->ReleaseProcess();
436 }
437
438 // static
439 RenderWidget* RenderWidget::Create(int32 opener_id,
440 blink::WebPopupType popup_type,
441 const blink::WebScreenInfo& screen_info) {
442 DCHECK(opener_id != MSG_ROUTING_NONE);
443 scoped_refptr<RenderWidget> widget(
444 new RenderWidget(popup_type, screen_info, false, false, false));
445 if (widget->Init(opener_id)) { // adds reference on success.
446 return widget.get();
447 }
448 return NULL;
449 }
450
451 // static
452 WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) {
453 switch (render_widget->popup_type_) {
454 case blink::WebPopupTypeNone: // Nothing to create.
455 break;
456 case blink::WebPopupTypeSelect:
457 case blink::WebPopupTypeSuggestion:
458 return WebPopupMenu::create(render_widget);
459 case blink::WebPopupTypePage:
460 return WebPagePopup::create(render_widget);
461 default:
462 NOTREACHED();
463 }
464 return NULL;
465 }
466
467 bool RenderWidget::Init(int32 opener_id) {
468 return DoInit(opener_id,
469 RenderWidget::CreateWebWidget(this),
470 new ViewHostMsg_CreateWidget(opener_id, popup_type_,
471 &routing_id_, &surface_id_));
472 }
473
474 bool RenderWidget::DoInit(int32 opener_id,
475 WebWidget* web_widget,
476 IPC::SyncMessage* create_widget_message) {
477 DCHECK(!webwidget_);
478
479 if (opener_id != MSG_ROUTING_NONE)
480 opener_id_ = opener_id;
481
482 webwidget_ = web_widget;
483
484 bool result = RenderThread::Get()->Send(create_widget_message);
485 if (result) {
486 RenderThread::Get()->AddRoute(routing_id_, this);
487 // Take a reference on behalf of the RenderThread. This will be balanced
488 // when we receive ViewMsg_Close.
489 AddRef();
490 if (RenderThreadImpl::current()) {
491 RenderThreadImpl::current()->WidgetCreated();
492 if (is_hidden_)
493 RenderThreadImpl::current()->WidgetHidden();
494 }
495 return true;
496 } else {
497 // The above Send can fail when the tab is closing.
498 return false;
499 }
500 }
501
502 // This is used to complete pending inits and non-pending inits.
503 void RenderWidget::CompleteInit() {
504 DCHECK(routing_id_ != MSG_ROUTING_NONE);
505
506 init_complete_ = true;
507
508 if (compositor_)
509 StartCompositor();
510
511 Send(new ViewHostMsg_RenderViewReady(routing_id_));
512 }
513
514 void RenderWidget::SetSwappedOut(bool is_swapped_out) {
515 // We should only toggle between states.
516 DCHECK(is_swapped_out_ != is_swapped_out);
517 is_swapped_out_ = is_swapped_out;
518
519 // If we are swapping out, we will call ReleaseProcess, allowing the process
520 // to exit if all of its RenderViews are swapped out. We wait until the
521 // WasSwappedOut call to do this, to allow the unload handler to finish.
522 // If we are swapping in, we call AddRefProcess to prevent the process from
523 // exiting.
524 if (!is_swapped_out_)
525 RenderProcess::current()->AddRefProcess();
526 }
527
528 void RenderWidget::WasSwappedOut() {
529 // If we have been swapped out and no one else is using this process,
530 // it's safe to exit now.
531 CHECK(is_swapped_out_);
532 RenderProcess::current()->ReleaseProcess();
533 }
534
535 void RenderWidget::EnableScreenMetricsEmulation(
536 const WebDeviceEmulationParams& params) {
537 if (!screen_metrics_emulator_)
538 screen_metrics_emulator_.reset(new ScreenMetricsEmulator(this, params));
539 else
540 screen_metrics_emulator_->ChangeEmulationParams(params);
541 }
542
543 void RenderWidget::DisableScreenMetricsEmulation() {
544 screen_metrics_emulator_.reset();
545 }
546
547 void RenderWidget::SetPopupOriginAdjustmentsForEmulation(
548 ScreenMetricsEmulator* emulator) {
549 popup_origin_scale_for_emulation_ = emulator->scale();
550 popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
551 popup_screen_origin_for_emulation_ = gfx::Point(
552 emulator->original_screen_rect().origin().x() + emulator->offset().x(),
553 emulator->original_screen_rect().origin().y() + emulator->offset().y());
554 screen_info_ = emulator->original_screen_info();
555 device_scale_factor_ = screen_info_.deviceScaleFactor;
556 }
557
558 gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) {
559 if (screen_metrics_emulator_)
560 return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor);
561 return anchor;
562 }
563
564 void RenderWidget::SetScreenMetricsEmulationParameters(
565 float device_scale_factor,
566 const gfx::Point& root_layer_offset,
567 float root_layer_scale) {
568 // This is only supported in RenderView.
569 NOTREACHED();
570 }
571
572 #if defined(OS_MACOSX) || defined(OS_ANDROID)
573 void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
574 ExternalPopupMenu* popup, ScreenMetricsEmulator* emulator) {
575 popup->SetOriginScaleAndOffsetForEmulation(
576 emulator->scale(), emulator->offset());
577 }
578 #endif
579
580 void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
581 if (screen_metrics_emulator_)
582 screen_metrics_emulator_->OnShowContextMenu(params);
583 }
584
585 void RenderWidget::ScheduleCompositeWithForcedRedraw() {
586 if (compositor_) {
587 // Regardless of whether threaded compositing is enabled, always
588 // use this mechanism to force the compositor to redraw. However,
589 // the invalidation code path below is still needed for the
590 // non-threaded case.
591 compositor_->SetNeedsForcedRedraw();
592 }
593 scheduleComposite();
594 }
595
596 bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
597 bool handled = true;
598 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
599 IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
600 IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
601 OnCursorVisibilityChange)
602 IPC_MESSAGE_HANDLER(InputMsg_ImeSetComposition, OnImeSetComposition)
603 IPC_MESSAGE_HANDLER(InputMsg_ImeConfirmComposition, OnImeConfirmComposition)
604 IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
605 IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
606 IPC_MESSAGE_HANDLER(InputMsg_SyntheticGestureCompleted,
607 OnSyntheticGestureCompleted)
608 IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
609 IPC_MESSAGE_HANDLER(ViewMsg_CreatingNew_ACK, OnCreatingNewAck)
610 IPC_MESSAGE_HANDLER(ViewMsg_Resize, OnResize)
611 IPC_MESSAGE_HANDLER(ViewMsg_ColorProfile, OnColorProfile)
612 IPC_MESSAGE_HANDLER(ViewMsg_ChangeResizeRect, OnChangeResizeRect)
613 IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
614 IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
615 IPC_MESSAGE_HANDLER(ViewMsg_SetInputMethodActive, OnSetInputMethodActive)
616 IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowShown, OnCandidateWindowShown)
617 IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowUpdated,
618 OnCandidateWindowUpdated)
619 IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowHidden, OnCandidateWindowHidden)
620 IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
621 IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
622 IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
623 IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
624 #if defined(OS_ANDROID)
625 IPC_MESSAGE_HANDLER(ViewMsg_ShowImeIfNeeded, OnShowImeIfNeeded)
626 IPC_MESSAGE_HANDLER(ViewMsg_ImeEventAck, OnImeEventAck)
627 #endif
628 IPC_MESSAGE_UNHANDLED(handled = false)
629 IPC_END_MESSAGE_MAP()
630 return handled;
631 }
632
633 bool RenderWidget::Send(IPC::Message* message) {
634 // Don't send any messages after the browser has told us to close, and filter
635 // most outgoing messages while swapped out.
636 if ((is_swapped_out_ &&
637 !SwappedOutMessages::CanSendWhileSwappedOut(message)) ||
638 closing_) {
639 delete message;
640 return false;
641 }
642
643 // If given a messsage without a routing ID, then assign our routing ID.
644 if (message->routing_id() == MSG_ROUTING_NONE)
645 message->set_routing_id(routing_id_);
646
647 return RenderThread::Get()->Send(message);
648 }
649
650 void RenderWidget::Resize(const gfx::Size& new_size,
651 const gfx::Size& physical_backing_size,
652 float top_controls_layout_height,
653 const gfx::Size& visible_viewport_size,
654 const gfx::Rect& resizer_rect,
655 bool is_fullscreen,
656 ResizeAck resize_ack) {
657 if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
658 // A resize ack shouldn't be requested if we have not ACK'd the previous
659 // one.
660 DCHECK(resize_ack != SEND_RESIZE_ACK || !next_paint_is_resize_ack());
661 DCHECK(resize_ack == SEND_RESIZE_ACK || resize_ack == NO_RESIZE_ACK);
662 }
663
664 // Ignore this during shutdown.
665 if (!webwidget_)
666 return;
667
668 if (compositor_) {
669 compositor_->setViewportSize(new_size, physical_backing_size);
670 compositor_->SetTopControlsLayoutHeight(top_controls_layout_height);
671 }
672
673 physical_backing_size_ = physical_backing_size;
674 top_controls_layout_height_ = top_controls_layout_height;
675 visible_viewport_size_ = visible_viewport_size;
676 resizer_rect_ = resizer_rect;
677
678 // NOTE: We may have entered fullscreen mode without changing our size.
679 bool fullscreen_change = is_fullscreen_ != is_fullscreen;
680 if (fullscreen_change)
681 WillToggleFullscreen();
682 is_fullscreen_ = is_fullscreen;
683
684 webwidget_->setTopControlsLayoutHeight(top_controls_layout_height);
685
686 if (size_ != new_size) {
687 size_ = new_size;
688
689 // When resizing, we want to wait to paint before ACK'ing the resize. This
690 // ensures that we only resize as fast as we can paint. We only need to
691 // send an ACK if we are resized to a non-empty rect.
692 webwidget_->resize(new_size);
693 } else if (!resizing_mode_selector_->is_synchronous_mode()) {
694 resize_ack = NO_RESIZE_ACK;
695 }
696
697 webwidget()->resizePinchViewport(gfx::Size(
698 visible_viewport_size.width(),
699 visible_viewport_size.height()));
700
701 if (new_size.IsEmpty() || physical_backing_size.IsEmpty()) {
702 // For empty size or empty physical_backing_size, there is no next paint
703 // (along with which to send the ack) until they are set to non-empty.
704 resize_ack = NO_RESIZE_ACK;
705 }
706
707 // Send the Resize_ACK flag once we paint again if requested.
708 if (resize_ack == SEND_RESIZE_ACK)
709 set_next_paint_is_resize_ack();
710
711 if (fullscreen_change)
712 DidToggleFullscreen();
713
714 // If a resize ack is requested and it isn't set-up, then no more resizes will
715 // come in and in general things will go wrong.
716 DCHECK(resize_ack != SEND_RESIZE_ACK || next_paint_is_resize_ack());
717 }
718
719 void RenderWidget::ResizeSynchronously(const gfx::Rect& new_position) {
720 Resize(new_position.size(),
721 new_position.size(),
722 top_controls_layout_height_,
723 visible_viewport_size_,
724 gfx::Rect(),
725 is_fullscreen_,
726 NO_RESIZE_ACK);
727 view_screen_rect_ = new_position;
728 window_screen_rect_ = new_position;
729 if (!did_show_)
730 initial_pos_ = new_position;
731 }
732
733 void RenderWidget::OnClose() {
734 if (closing_)
735 return;
736 closing_ = true;
737
738 // Browser correspondence is no longer needed at this point.
739 if (routing_id_ != MSG_ROUTING_NONE) {
740 if (RenderThreadImpl::current())
741 RenderThreadImpl::current()->WidgetDestroyed();
742 RenderThread::Get()->RemoveRoute(routing_id_);
743 SetHidden(false);
744 }
745
746 // If there is a Send call on the stack, then it could be dangerous to close
747 // now. Post a task that only gets invoked when there are no nested message
748 // loops.
749 base::MessageLoop::current()->PostNonNestableTask(
750 FROM_HERE, base::Bind(&RenderWidget::Close, this));
751
752 // Balances the AddRef taken when we called AddRoute.
753 Release();
754 }
755
756 // Got a response from the browser after the renderer decided to create a new
757 // view.
758 void RenderWidget::OnCreatingNewAck() {
759 DCHECK(routing_id_ != MSG_ROUTING_NONE);
760
761 CompleteInit();
762 }
763
764 void RenderWidget::OnResize(const ViewMsg_Resize_Params& params) {
765 if (resizing_mode_selector_->ShouldAbortOnResize(this, params))
766 return;
767
768 if (screen_metrics_emulator_) {
769 screen_metrics_emulator_->OnResizeMessage(params);
770 return;
771 }
772
773 bool orientation_changed =
774 screen_info_.orientationAngle != params.screen_info.orientationAngle;
775
776 screen_info_ = params.screen_info;
777 SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
778 Resize(params.new_size, params.physical_backing_size,
779 params.top_controls_layout_height,
780 params.visible_viewport_size, params.resizer_rect,
781 params.is_fullscreen, SEND_RESIZE_ACK);
782
783 if (orientation_changed)
784 OnOrientationChange();
785 }
786
787 void RenderWidget::OnColorProfile(const std::vector<char>& color_profile) {
788 SetDeviceColorProfile(color_profile);
789 }
790
791 void RenderWidget::OnChangeResizeRect(const gfx::Rect& resizer_rect) {
792 if (resizer_rect_ == resizer_rect)
793 return;
794 resizer_rect_ = resizer_rect;
795 if (webwidget_)
796 webwidget_->didChangeWindowResizerRect();
797 }
798
799 void RenderWidget::OnWasHidden() {
800 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
801 // Go into a mode where we stop generating paint and scrolling events.
802 SetHidden(true);
803 FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
804 WasHidden());
805 }
806
807 void RenderWidget::OnWasShown(bool needs_repainting,
808 const ui::LatencyInfo& latency_info) {
809 TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
810 // During shutdown we can just ignore this message.
811 if (!webwidget_)
812 return;
813
814 // See OnWasHidden
815 SetHidden(false);
816 FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
817 WasShown());
818
819 if (!needs_repainting)
820 return;
821
822 // Generate a full repaint.
823 if (compositor_) {
824 ui::LatencyInfo swap_latency_info(latency_info);
825 scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor(
826 compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info));
827 compositor_->SetNeedsForcedRedraw();
828 }
829 scheduleComposite();
830 }
831
832 void RenderWidget::OnRequestMoveAck() {
833 DCHECK(pending_window_rect_count_);
834 pending_window_rect_count_--;
835 }
836
837 GURL RenderWidget::GetURLForGraphicsContext3D() {
838 return GURL();
839 }
840
841 scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(bool fallback) {
842 // For widgets that are never visible, we don't start the compositor, so we
843 // never get a request for a cc::OutputSurface.
844 DCHECK(!never_visible_);
845
846 #if defined(OS_ANDROID)
847 if (SynchronousCompositorFactory* factory =
848 SynchronousCompositorFactory::GetInstance()) {
849 return factory->CreateOutputSurface(routing_id(),
850 frame_swap_message_queue_);
851 }
852 #endif
853
854 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
855 bool use_software = fallback;
856 if (command_line.HasSwitch(switches::kDisableGpuCompositing))
857 use_software = true;
858
859 scoped_refptr<ContextProviderCommandBuffer> context_provider;
860 if (!use_software) {
861 context_provider = ContextProviderCommandBuffer::Create(
862 CreateGraphicsContext3D(), "RenderCompositor");
863 if (!context_provider.get()) {
864 // Cause the compositor to wait and try again.
865 return scoped_ptr<cc::OutputSurface>();
866 }
867 }
868
869 uint32 output_surface_id = next_output_surface_id_++;
870 if (command_line.HasSwitch(switches::kEnableDelegatedRenderer)) {
871 DCHECK(IsThreadedCompositingEnabled());
872 return scoped_ptr<cc::OutputSurface>(
873 new DelegatedCompositorOutputSurface(routing_id(),
874 output_surface_id,
875 context_provider,
876 frame_swap_message_queue_));
877 }
878 if (!context_provider.get()) {
879 scoped_ptr<cc::SoftwareOutputDevice> software_device(
880 new CompositorSoftwareOutputDevice());
881
882 return scoped_ptr<cc::OutputSurface>(
883 new CompositorOutputSurface(routing_id(),
884 output_surface_id,
885 NULL,
886 software_device.Pass(),
887 frame_swap_message_queue_,
888 true));
889 }
890
891 if (command_line.HasSwitch(cc::switches::kCompositeToMailbox)) {
892 // Composite-to-mailbox is currently used for layout tests in order to cause
893 // them to draw inside in the renderer to do the readback there. This should
894 // no longer be the case when crbug.com/311404 is fixed.
895 DCHECK(IsThreadedCompositingEnabled() ||
896 RenderThreadImpl::current()->layout_test_mode());
897 cc::ResourceFormat format = cc::RGBA_8888;
898 if (base::SysInfo::IsLowEndDevice())
899 format = cc::RGB_565;
900 return scoped_ptr<cc::OutputSurface>(
901 new MailboxOutputSurface(routing_id(),
902 output_surface_id,
903 context_provider,
904 scoped_ptr<cc::SoftwareOutputDevice>(),
905 frame_swap_message_queue_,
906 format));
907 }
908 bool use_swap_compositor_frame_message = false;
909 return scoped_ptr<cc::OutputSurface>(
910 new CompositorOutputSurface(routing_id(),
911 output_surface_id,
912 context_provider,
913 scoped_ptr<cc::SoftwareOutputDevice>(),
914 frame_swap_message_queue_,
915 use_swap_compositor_frame_message));
916 }
917
918 void RenderWidget::OnSwapBuffersAborted() {
919 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
920 // Schedule another frame so the compositor learns about it.
921 scheduleComposite();
922 }
923
924 void RenderWidget::OnSwapBuffersPosted() {
925 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
926 }
927
928 void RenderWidget::OnSwapBuffersComplete() {
929 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersComplete");
930
931 // Notify subclasses that composited rendering was flushed to the screen.
932 DidFlushPaint();
933 }
934
935 void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event,
936 const ui::LatencyInfo& latency_info,
937 bool is_keyboard_shortcut) {
938 base::AutoReset<bool> handling_input_event_resetter(
939 &handling_input_event_, true);
940 if (!input_event)
941 return;
942 base::AutoReset<WebInputEvent::Type> handling_event_type_resetter(
943 &handling_event_type_, input_event->type);
944 #if defined(OS_ANDROID)
945 // On Android, when a key is pressed or sent from the Keyboard using IME,
946 // |AdapterInputConnection| generates input key events to make sure all JS
947 // listeners that monitor KeyUp and KeyDown events receive the proper key
948 // code. Since this input key event comes from IME, we need to set the
949 // IME event guard here to make sure it does not interfere with other IME
950 // events.
951 scoped_ptr<ImeEventGuard> ime_event_guard_maybe;
952 if (WebInputEvent::isKeyboardEventType(input_event->type)) {
953 const WebKeyboardEvent& key_event =
954 *static_cast<const WebKeyboardEvent*>(input_event);
955 // Some keys are special and it's essential that no events get blocked.
956 if (key_event.nativeKeyCode != AKEYCODE_TAB &&
957 key_event.nativeKeyCode != AKEYCODE_DPAD_CENTER)
958 ime_event_guard_maybe.reset(new ImeEventGuard(this));
959 }
960 #endif
961
962 base::AutoReset<const ui::LatencyInfo*> resetter(&current_event_latency_info_,
963 &latency_info);
964
965 base::TimeTicks start_time;
966 if (base::TimeTicks::IsHighResNowFastAndReliable())
967 start_time = base::TimeTicks::HighResNow();
968
969 const char* const event_name =
970 WebInputEventTraits::GetName(input_event->type);
971 TRACE_EVENT1("renderer", "RenderWidget::OnHandleInputEvent",
972 "event", event_name);
973 TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("blink.HandleInputEvent");
974 TRACE_EVENT_FLOW_STEP0(
975 "input",
976 "LatencyInfo.Flow",
977 TRACE_ID_DONT_MANGLE(latency_info.trace_id),
978 "HanldeInputEventMain");
979
980 scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor;
981 ui::LatencyInfo swap_latency_info(latency_info);
982 if (compositor_) {
983 latency_info_swap_promise_monitor =
984 compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info)
985 .Pass();
986 }
987
988 if (base::TimeTicks::IsHighResNowFastAndReliable()) {
989 // If we don't have a high res timer, these metrics won't be accurate enough
990 // to be worth collecting. Note that this does introduce some sampling bias.
991
992 base::TimeDelta now = base::TimeDelta::FromInternalValue(
993 base::TimeTicks::HighResNow().ToInternalValue());
994
995 int64 delta =
996 static_cast<int64>((now.InSecondsF() - input_event->timeStampSeconds) *
997 base::Time::kMicrosecondsPerSecond);
998
999 UMA_HISTOGRAM_CUSTOM_COUNTS(
1000 "Event.AggregatedLatency.Renderer2", delta, 1, 10000000, 100);
1001 base::HistogramBase* counter_for_type = base::Histogram::FactoryGet(
1002 base::StringPrintf("Event.Latency.Renderer2.%s", event_name),
1003 1,
1004 10000000,
1005 100,
1006 base::HistogramBase::kUmaTargetedHistogramFlag);
1007 counter_for_type->Add(delta);
1008 }
1009
1010 bool prevent_default = false;
1011 if (WebInputEvent::isMouseEventType(input_event->type)) {
1012 const WebMouseEvent& mouse_event =
1013 *static_cast<const WebMouseEvent*>(input_event);
1014 TRACE_EVENT2("renderer", "HandleMouseMove",
1015 "x", mouse_event.x, "y", mouse_event.y);
1016 context_menu_source_type_ = ui::MENU_SOURCE_MOUSE;
1017 prevent_default = WillHandleMouseEvent(mouse_event);
1018 }
1019
1020 if (WebInputEvent::isKeyboardEventType(input_event->type)) {
1021 context_menu_source_type_ = ui::MENU_SOURCE_KEYBOARD;
1022 #if defined(OS_ANDROID)
1023 // The DPAD_CENTER key on Android has a dual semantic: (1) in the general
1024 // case it should behave like a select key (i.e. causing a click if a button
1025 // is focused). However, if a text field is focused (2), its intended
1026 // behavior is to just show the IME and don't propagate the key.
1027 // A typical use case is a web form: the DPAD_CENTER should bring up the IME
1028 // when clicked on an input text field and cause the form submit if clicked
1029 // when the submit button is focused, but not vice-versa.
1030 // The UI layer takes care of translating DPAD_CENTER into a RETURN key,
1031 // but at this point we have to swallow the event for the scenario (2).
1032 const WebKeyboardEvent& key_event =
1033 *static_cast<const WebKeyboardEvent*>(input_event);
1034 if (key_event.nativeKeyCode == AKEYCODE_DPAD_CENTER &&
1035 GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE) {
1036 OnShowImeIfNeeded();
1037 prevent_default = true;
1038 }
1039 #endif
1040 }
1041
1042 if (WebInputEvent::isGestureEventType(input_event->type)) {
1043 const WebGestureEvent& gesture_event =
1044 *static_cast<const WebGestureEvent*>(input_event);
1045 context_menu_source_type_ = ui::MENU_SOURCE_TOUCH;
1046 prevent_default = prevent_default || WillHandleGestureEvent(gesture_event);
1047 }
1048
1049 bool processed = prevent_default;
1050 if (input_event->type != WebInputEvent::Char || !suppress_next_char_events_) {
1051 suppress_next_char_events_ = false;
1052 if (!processed && webwidget_)
1053 processed = webwidget_->handleInputEvent(*input_event);
1054 }
1055
1056 // If this RawKeyDown event corresponds to a browser keyboard shortcut and
1057 // it's not processed by webkit, then we need to suppress the upcoming Char
1058 // events.
1059 if (!processed && is_keyboard_shortcut)
1060 suppress_next_char_events_ = true;
1061
1062 InputEventAckState ack_result = processed ?
1063 INPUT_EVENT_ACK_STATE_CONSUMED : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1064 if (!processed && input_event->type == WebInputEvent::TouchStart) {
1065 const WebTouchEvent& touch_event =
1066 *static_cast<const WebTouchEvent*>(input_event);
1067 // Hit-test for all the pressed touch points. If there is a touch-handler
1068 // for any of the touch points, then the renderer should continue to receive
1069 // touch events.
1070 ack_result = INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
1071 for (size_t i = 0; i < touch_event.touchesLength; ++i) {
1072 if (touch_event.touches[i].state == WebTouchPoint::StatePressed &&
1073 HasTouchEventHandlersAt(
1074 gfx::ToFlooredPoint(touch_event.touches[i].position))) {
1075 ack_result = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1076 break;
1077 }
1078 }
1079 }
1080
1081 // Unconsumed touchmove acks should never be throttled as they're required to
1082 // dispatch compositor-handled scroll gestures.
1083 bool event_type_can_be_rate_limited =
1084 input_event->type == WebInputEvent::MouseMove ||
1085 input_event->type == WebInputEvent::MouseWheel ||
1086 (input_event->type == WebInputEvent::TouchMove &&
1087 ack_result == INPUT_EVENT_ACK_STATE_CONSUMED);
1088
1089 bool frame_pending = compositor_ && compositor_->BeginMainFrameRequested();
1090
1091 // If we don't have a fast and accurate HighResNow, we assume the input
1092 // handlers are heavy and rate limit them.
1093 bool rate_limiting_wanted = true;
1094 if (base::TimeTicks::IsHighResNowFastAndReliable()) {
1095 base::TimeTicks end_time = base::TimeTicks::HighResNow();
1096 total_input_handling_time_this_frame_ += (end_time - start_time);
1097 rate_limiting_wanted =
1098 total_input_handling_time_this_frame_.InMicroseconds() >
1099 kInputHandlingTimeThrottlingThresholdMicroseconds;
1100 }
1101
1102 TRACE_EVENT_SYNTHETIC_DELAY_END("blink.HandleInputEvent");
1103
1104 // Note that we can't use handling_event_type_ here since it will be overriden
1105 // by reentrant calls for events after the paused one.
1106 bool no_ack = ignore_ack_for_mouse_move_from_debugger_ &&
1107 input_event->type == WebInputEvent::MouseMove;
1108 if (!WebInputEventTraits::IgnoresAckDisposition(*input_event) && !no_ack) {
1109 InputHostMsg_HandleInputEvent_ACK_Params ack;
1110 ack.type = input_event->type;
1111 ack.state = ack_result;
1112 ack.latency = swap_latency_info;
1113 scoped_ptr<IPC::Message> response(
1114 new InputHostMsg_HandleInputEvent_ACK(routing_id_, ack));
1115 if (rate_limiting_wanted && event_type_can_be_rate_limited &&
1116 frame_pending && !is_hidden_) {
1117 // We want to rate limit the input events in this case, so we'll wait for
1118 // painting to finish before ACKing this message.
1119 TRACE_EVENT_INSTANT0("renderer",
1120 "RenderWidget::OnHandleInputEvent ack throttled",
1121 TRACE_EVENT_SCOPE_THREAD);
1122 if (pending_input_event_ack_) {
1123 // As two different kinds of events could cause us to postpone an ack
1124 // we send it now, if we have one pending. The Browser should never
1125 // send us the same kind of event we are delaying the ack for.
1126 Send(pending_input_event_ack_.release());
1127 }
1128 pending_input_event_ack_ = response.Pass();
1129 if (compositor_)
1130 compositor_->NotifyInputThrottledUntilCommit();
1131 } else {
1132 Send(response.release());
1133 }
1134 }
1135 if (input_event->type == WebInputEvent::MouseMove)
1136 ignore_ack_for_mouse_move_from_debugger_ = false;
1137
1138 #if defined(OS_ANDROID)
1139 // Allow the IME to be shown when the focus changes as a consequence
1140 // of a processed touch end event.
1141 if (input_event->type == WebInputEvent::TouchEnd && processed)
1142 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
1143 #elif defined(USE_AURA)
1144 // Show the virtual keyboard if enabled and a user gesture triggers a focus
1145 // change.
1146 if (processed && (input_event->type == WebInputEvent::TouchEnd ||
1147 input_event->type == WebInputEvent::MouseUp))
1148 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_IME);
1149 #endif
1150
1151 if (!prevent_default) {
1152 if (WebInputEvent::isKeyboardEventType(input_event->type))
1153 DidHandleKeyEvent();
1154 if (WebInputEvent::isMouseEventType(input_event->type))
1155 DidHandleMouseEvent(*(static_cast<const WebMouseEvent*>(input_event)));
1156 if (WebInputEvent::isTouchEventType(input_event->type))
1157 DidHandleTouchEvent(*(static_cast<const WebTouchEvent*>(input_event)));
1158 }
1159 }
1160
1161 void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
1162 if (webwidget_)
1163 webwidget_->setCursorVisibilityState(is_visible);
1164 }
1165
1166 void RenderWidget::OnMouseCaptureLost() {
1167 if (webwidget_)
1168 webwidget_->mouseCaptureLost();
1169 }
1170
1171 void RenderWidget::OnSetFocus(bool enable) {
1172 has_focus_ = enable;
1173 if (webwidget_)
1174 webwidget_->setFocus(enable);
1175 }
1176
1177 void RenderWidget::ClearFocus() {
1178 // We may have got the focus from the browser before this gets processed, in
1179 // which case we do not want to unfocus ourself.
1180 if (!has_focus_ && webwidget_)
1181 webwidget_->setFocus(false);
1182 }
1183
1184 void RenderWidget::FlushPendingInputEventAck() {
1185 if (pending_input_event_ack_)
1186 Send(pending_input_event_ack_.release());
1187 total_input_handling_time_this_frame_ = base::TimeDelta();
1188 }
1189
1190 ///////////////////////////////////////////////////////////////////////////////
1191 // WebWidgetClient
1192
1193 void RenderWidget::didAutoResize(const WebSize& new_size) {
1194 if (size_.width() != new_size.width || size_.height() != new_size.height) {
1195 size_ = new_size;
1196
1197 if (resizing_mode_selector_->is_synchronous_mode()) {
1198 WebRect new_pos(rootWindowRect().x,
1199 rootWindowRect().y,
1200 new_size.width,
1201 new_size.height);
1202 view_screen_rect_ = new_pos;
1203 window_screen_rect_ = new_pos;
1204 }
1205
1206 AutoResizeCompositor();
1207
1208 if (!resizing_mode_selector_->is_synchronous_mode())
1209 need_update_rect_for_auto_resize_ = true;
1210 }
1211 }
1212
1213 void RenderWidget::AutoResizeCompositor() {
1214 physical_backing_size_ = gfx::ToCeiledSize(gfx::ScaleSize(size_,
1215 device_scale_factor_));
1216 if (compositor_)
1217 compositor_->setViewportSize(size_, physical_backing_size_);
1218 }
1219
1220 void RenderWidget::initializeLayerTreeView() {
1221 DCHECK(!host_closing_);
1222
1223 compositor_ =
1224 RenderWidgetCompositor::Create(this, IsThreadedCompositingEnabled());
1225 compositor_->setViewportSize(size_, physical_backing_size_);
1226 if (init_complete_)
1227 StartCompositor();
1228 }
1229
1230 void RenderWidget::DestroyLayerTreeView() {
1231 // Always send this notification to prevent new layer tree views from
1232 // being created, even if one hasn't been created yet.
1233 if (webwidget_)
1234 webwidget_->willCloseLayerTreeView();
1235 compositor_.reset();
1236 }
1237
1238 blink::WebLayerTreeView* RenderWidget::layerTreeView() {
1239 return compositor_.get();
1240 }
1241
1242 void RenderWidget::willBeginCompositorFrame() {
1243 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
1244
1245 // The following two can result in further layout and possibly
1246 // enable GPU acceleration so they need to be called before any painting
1247 // is done.
1248 UpdateTextInputState(NO_SHOW_IME, FROM_NON_IME);
1249 UpdateSelectionBounds();
1250 }
1251
1252 void RenderWidget::didBecomeReadyForAdditionalInput() {
1253 TRACE_EVENT0("renderer", "RenderWidget::didBecomeReadyForAdditionalInput");
1254 FlushPendingInputEventAck();
1255 }
1256
1257 void RenderWidget::DidCommitCompositorFrame() {
1258 FOR_EACH_OBSERVER(RenderFrameProxy, render_frame_proxies_,
1259 DidCommitCompositorFrame());
1260 #if defined(VIDEO_HOLE)
1261 FOR_EACH_OBSERVER(RenderFrameImpl, video_hole_frames_,
1262 DidCommitCompositorFrame());
1263 #endif // defined(VIDEO_HOLE)
1264 }
1265
1266 // static
1267 scoped_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
1268 IPC::Message* msg,
1269 MessageDeliveryPolicy policy,
1270 FrameSwapMessageQueue* frame_swap_message_queue,
1271 scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
1272 bool commit_requested,
1273 int source_frame_number) {
1274 if (policy == MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE &&
1275 // No need for lock: this gets changed only on this thread.
1276 !commit_requested &&
1277 // No need for lock: Messages are only enqueued from this thread, if we
1278 // don't have any now, no other thread will add any.
1279 frame_swap_message_queue->Empty()) {
1280 sync_message_filter->Send(msg);
1281 return scoped_ptr<cc::SwapPromise>();
1282 }
1283
1284 bool first_message_for_frame = false;
1285 frame_swap_message_queue->QueueMessageForFrame(policy,
1286 source_frame_number,
1287 make_scoped_ptr(msg),
1288 &first_message_for_frame);
1289 if (first_message_for_frame) {
1290 scoped_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
1291 sync_message_filter, frame_swap_message_queue, source_frame_number));
1292 return promise.PassAs<cc::SwapPromise>();
1293 }
1294 return scoped_ptr<cc::SwapPromise>();
1295 }
1296
1297 void RenderWidget::QueueMessage(IPC::Message* msg,
1298 MessageDeliveryPolicy policy) {
1299 // RenderThreadImpl::current() is NULL in some tests.
1300 if (!compositor_ || !RenderThreadImpl::current()) {
1301 Send(msg);
1302 return;
1303 }
1304
1305 scoped_ptr<cc::SwapPromise> swap_promise =
1306 QueueMessageImpl(msg,
1307 policy,
1308 frame_swap_message_queue_.get(),
1309 RenderThreadImpl::current()->sync_message_filter(),
1310 compositor_->commitRequested(),
1311 compositor_->GetSourceFrameNumber());
1312
1313 if (swap_promise) {
1314 compositor_->QueueSwapPromise(swap_promise.Pass());
1315 compositor_->SetNeedsCommit();
1316 }
1317 }
1318
1319 void RenderWidget::didCommitAndDrawCompositorFrame() {
1320 // NOTE: Tests may break if this event is renamed or moved. See
1321 // tab_capture_performancetest.cc.
1322 TRACE_EVENT0("gpu", "RenderWidget::didCommitAndDrawCompositorFrame");
1323 // Notify subclasses that we initiated the paint operation.
1324 DidInitiatePaint();
1325 }
1326
1327 void RenderWidget::didCompleteSwapBuffers() {
1328 TRACE_EVENT0("renderer", "RenderWidget::didCompleteSwapBuffers");
1329
1330 // Notify subclasses threaded composited rendering was flushed to the screen.
1331 DidFlushPaint();
1332
1333 if (!next_paint_flags_ &&
1334 !need_update_rect_for_auto_resize_ &&
1335 !plugin_window_moves_.size()) {
1336 return;
1337 }
1338
1339 ViewHostMsg_UpdateRect_Params params;
1340 params.view_size = size_;
1341 params.plugin_window_moves.swap(plugin_window_moves_);
1342 params.flags = next_paint_flags_;
1343
1344 Send(new ViewHostMsg_UpdateRect(routing_id_, params));
1345 next_paint_flags_ = 0;
1346 need_update_rect_for_auto_resize_ = false;
1347 }
1348
1349 void RenderWidget::scheduleComposite() {
1350 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1351 // render_thread may be NULL in tests.
1352 if (render_thread && render_thread->compositor_message_loop_proxy().get() &&
1353 compositor_) {
1354 compositor_->setNeedsAnimate();
1355 }
1356 }
1357
1358 void RenderWidget::didChangeCursor(const WebCursorInfo& cursor_info) {
1359 // TODO(darin): Eliminate this temporary.
1360 WebCursor cursor;
1361 InitializeCursorFromWebKitCursorInfo(&cursor, cursor_info);
1362 // Only send a SetCursor message if we need to make a change.
1363 if (!current_cursor_.IsEqual(cursor)) {
1364 current_cursor_ = cursor;
1365 Send(new ViewHostMsg_SetCursor(routing_id_, cursor));
1366 }
1367 }
1368
1369 // We are supposed to get a single call to Show for a newly created RenderWidget
1370 // that was created via RenderWidget::CreateWebView. So, we wait until this
1371 // point to dispatch the ShowWidget message.
1372 //
1373 // This method provides us with the information about how to display the newly
1374 // created RenderWidget (i.e., as a blocked popup or as a new tab).
1375 //
1376 void RenderWidget::show(WebNavigationPolicy) {
1377 DCHECK(!did_show_) << "received extraneous Show call";
1378 DCHECK(routing_id_ != MSG_ROUTING_NONE);
1379 DCHECK(opener_id_ != MSG_ROUTING_NONE);
1380
1381 if (did_show_)
1382 return;
1383
1384 did_show_ = true;
1385 // NOTE: initial_pos_ may still have its default values at this point, but
1386 // that's okay. It'll be ignored if as_popup is false, or the browser
1387 // process will impose a default position otherwise.
1388 Send(new ViewHostMsg_ShowWidget(opener_id_, routing_id_, initial_pos_));
1389 SetPendingWindowRect(initial_pos_);
1390 }
1391
1392 void RenderWidget::didFocus() {
1393 }
1394
1395 void RenderWidget::didBlur() {
1396 }
1397
1398 void RenderWidget::DoDeferredClose() {
1399 // No more compositing is possible. This prevents shutdown races between
1400 // previously posted CreateOutputSurface tasks and the host being unable to
1401 // create them because the close message was handled.
1402 DestroyLayerTreeView();
1403 // Also prevent new compositors from being created.
1404 host_closing_ = true;
1405 Send(new ViewHostMsg_Close(routing_id_));
1406 }
1407
1408 void RenderWidget::closeWidgetSoon() {
1409 if (is_swapped_out_) {
1410 // This widget is currently swapped out, and the active widget is in a
1411 // different process. Have the browser route the close request to the
1412 // active widget instead, so that the correct unload handlers are run.
1413 Send(new ViewHostMsg_RouteCloseEvent(routing_id_));
1414 return;
1415 }
1416
1417 // If a page calls window.close() twice, we'll end up here twice, but that's
1418 // OK. It is safe to send multiple Close messages.
1419
1420 // Ask the RenderWidgetHost to initiate close. We could be called from deep
1421 // in Javascript. If we ask the RendwerWidgetHost to close now, the window
1422 // could be closed before the JS finishes executing. So instead, post a
1423 // message back to the message loop, which won't run until the JS is
1424 // complete, and then the Close message can be sent.
1425 base::MessageLoop::current()->PostNonNestableTask(
1426 FROM_HERE, base::Bind(&RenderWidget::DoDeferredClose, this));
1427 }
1428
1429 void RenderWidget::QueueSyntheticGesture(
1430 scoped_ptr<SyntheticGestureParams> gesture_params,
1431 const SyntheticGestureCompletionCallback& callback) {
1432 DCHECK(!callback.is_null());
1433
1434 pending_synthetic_gesture_callbacks_.push(callback);
1435
1436 SyntheticGesturePacket gesture_packet;
1437 gesture_packet.set_gesture_params(gesture_params.Pass());
1438
1439 Send(new InputHostMsg_QueueSyntheticGesture(routing_id_, gesture_packet));
1440 }
1441
1442 void RenderWidget::Close() {
1443 screen_metrics_emulator_.reset();
1444 DestroyLayerTreeView();
1445 if (webwidget_) {
1446 webwidget_->close();
1447 webwidget_ = NULL;
1448 }
1449 }
1450
1451 WebRect RenderWidget::windowRect() {
1452 if (pending_window_rect_count_)
1453 return pending_window_rect_;
1454
1455 return view_screen_rect_;
1456 }
1457
1458 void RenderWidget::setToolTipText(const blink::WebString& text,
1459 WebTextDirection hint) {
1460 Send(new ViewHostMsg_SetTooltipText(routing_id_, text, hint));
1461 }
1462
1463 void RenderWidget::setWindowRect(const WebRect& rect) {
1464 WebRect pos = rect;
1465 if (popup_origin_scale_for_emulation_) {
1466 float scale = popup_origin_scale_for_emulation_;
1467 pos.x = popup_screen_origin_for_emulation_.x() +
1468 (pos.x - popup_view_origin_for_emulation_.x()) * scale;
1469 pos.y = popup_screen_origin_for_emulation_.y() +
1470 (pos.y - popup_view_origin_for_emulation_.y()) * scale;
1471 }
1472
1473 if (!resizing_mode_selector_->is_synchronous_mode()) {
1474 if (did_show_) {
1475 Send(new ViewHostMsg_RequestMove(routing_id_, pos));
1476 SetPendingWindowRect(pos);
1477 } else {
1478 initial_pos_ = pos;
1479 }
1480 } else {
1481 ResizeSynchronously(pos);
1482 }
1483 }
1484
1485 void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
1486 pending_window_rect_ = rect;
1487 pending_window_rect_count_++;
1488 }
1489
1490 WebRect RenderWidget::rootWindowRect() {
1491 if (pending_window_rect_count_) {
1492 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
1493 // the RootWindowRect is probably going to return wrong results since the
1494 // browser may not have processed the Move yet. There isn't really anything
1495 // good to do in this case, and it shouldn't happen - since this size is
1496 // only really needed for windowToScreen, which is only used for Popups.
1497 return pending_window_rect_;
1498 }
1499
1500 return window_screen_rect_;
1501 }
1502
1503 WebRect RenderWidget::windowResizerRect() {
1504 return resizer_rect_;
1505 }
1506
1507 void RenderWidget::OnSetInputMethodActive(bool is_active) {
1508 // To prevent this renderer process from sending unnecessary IPC messages to
1509 // a browser process, we permit the renderer process to send IPC messages
1510 // only during the input method attached to the browser process is active.
1511 input_method_is_active_ = is_active;
1512 }
1513
1514 void RenderWidget::OnCandidateWindowShown() {
1515 webwidget_->didShowCandidateWindow();
1516 }
1517
1518 void RenderWidget::OnCandidateWindowUpdated() {
1519 webwidget_->didUpdateCandidateWindow();
1520 }
1521
1522 void RenderWidget::OnCandidateWindowHidden() {
1523 webwidget_->didHideCandidateWindow();
1524 }
1525
1526 void RenderWidget::OnImeSetComposition(
1527 const base::string16& text,
1528 const std::vector<WebCompositionUnderline>& underlines,
1529 int selection_start, int selection_end) {
1530 if (!ShouldHandleImeEvent())
1531 return;
1532 ImeEventGuard guard(this);
1533 if (!webwidget_->setComposition(
1534 text, WebVector<WebCompositionUnderline>(underlines),
1535 selection_start, selection_end)) {
1536 // If we failed to set the composition text, then we need to let the browser
1537 // process to cancel the input method's ongoing composition session, to make
1538 // sure we are in a consistent state.
1539 Send(new InputHostMsg_ImeCancelComposition(routing_id()));
1540 }
1541 #if defined(OS_MACOSX) || defined(USE_AURA)
1542 UpdateCompositionInfo(true);
1543 #endif
1544 }
1545
1546 void RenderWidget::OnImeConfirmComposition(const base::string16& text,
1547 const gfx::Range& replacement_range,
1548 bool keep_selection) {
1549 if (!ShouldHandleImeEvent())
1550 return;
1551 ImeEventGuard guard(this);
1552 handling_input_event_ = true;
1553 if (text.length())
1554 webwidget_->confirmComposition(text);
1555 else if (keep_selection)
1556 webwidget_->confirmComposition(WebWidget::KeepSelection);
1557 else
1558 webwidget_->confirmComposition(WebWidget::DoNotKeepSelection);
1559 handling_input_event_ = false;
1560 #if defined(OS_MACOSX) || defined(USE_AURA)
1561 UpdateCompositionInfo(true);
1562 #endif
1563 }
1564
1565 void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
1566 // During shutdown we can just ignore this message.
1567 if (!webwidget_)
1568 return;
1569
1570 // Even if the browser provides an empty damage rect, it's still expecting to
1571 // receive a repaint ack so just damage the entire widget bounds.
1572 if (size_to_paint.IsEmpty()) {
1573 size_to_paint = size_;
1574 }
1575
1576 set_next_paint_is_repaint_ack();
1577 if (compositor_)
1578 compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint));
1579 }
1580
1581 void RenderWidget::OnSyntheticGestureCompleted() {
1582 DCHECK(!pending_synthetic_gesture_callbacks_.empty());
1583
1584 pending_synthetic_gesture_callbacks_.front().Run();
1585 pending_synthetic_gesture_callbacks_.pop();
1586 }
1587
1588 void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
1589 if (!webwidget_)
1590 return;
1591 webwidget_->setTextDirection(direction);
1592 }
1593
1594 void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
1595 const gfx::Rect& window_screen_rect) {
1596 if (screen_metrics_emulator_) {
1597 screen_metrics_emulator_->OnUpdateScreenRectsMessage(
1598 view_screen_rect, window_screen_rect);
1599 } else {
1600 view_screen_rect_ = view_screen_rect;
1601 window_screen_rect_ = window_screen_rect;
1602 }
1603 Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
1604 }
1605
1606 void RenderWidget::showImeIfNeeded() {
1607 OnShowImeIfNeeded();
1608 }
1609
1610 void RenderWidget::OnShowImeIfNeeded() {
1611 #if defined(OS_ANDROID) || defined(USE_AURA)
1612 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
1613 #endif
1614 }
1615
1616 #if defined(OS_ANDROID)
1617 void RenderWidget::IncrementOutstandingImeEventAcks() {
1618 ++outstanding_ime_acks_;
1619 }
1620
1621 void RenderWidget::OnImeEventAck() {
1622 --outstanding_ime_acks_;
1623 DCHECK(outstanding_ime_acks_ >= 0);
1624 }
1625 #endif
1626
1627 bool RenderWidget::ShouldHandleImeEvent() {
1628 #if defined(OS_ANDROID)
1629 return !!webwidget_ && outstanding_ime_acks_ == 0;
1630 #else
1631 return !!webwidget_;
1632 #endif
1633 }
1634
1635 bool RenderWidget::SendAckForMouseMoveFromDebugger() {
1636 if (handling_event_type_ == WebInputEvent::MouseMove) {
1637 // If we pause multiple times during a single mouse move event, we should
1638 // only send ACK once.
1639 if (!ignore_ack_for_mouse_move_from_debugger_) {
1640 InputHostMsg_HandleInputEvent_ACK_Params ack;
1641 ack.type = handling_event_type_;
1642 ack.state = INPUT_EVENT_ACK_STATE_CONSUMED;
1643 Send(new InputHostMsg_HandleInputEvent_ACK(routing_id_, ack));
1644 }
1645 return true;
1646 }
1647 return false;
1648 }
1649
1650 void RenderWidget::IgnoreAckForMouseMoveFromDebugger() {
1651 ignore_ack_for_mouse_move_from_debugger_ = true;
1652 }
1653
1654 void RenderWidget::SetDeviceScaleFactor(float device_scale_factor) {
1655 if (device_scale_factor_ == device_scale_factor)
1656 return;
1657
1658 device_scale_factor_ = device_scale_factor;
1659 scheduleComposite();
1660 }
1661
1662 bool RenderWidget::SetDeviceColorProfile(
1663 const std::vector<char>& color_profile) {
1664 if (device_color_profile_ == color_profile)
1665 return false;
1666
1667 device_color_profile_ = color_profile;
1668 return true;
1669 }
1670
1671 void RenderWidget::ResetDeviceColorProfileForTesting() {
1672 if (!device_color_profile_.empty())
1673 device_color_profile_.clear();
1674 device_color_profile_.push_back('0');
1675 }
1676
1677 void RenderWidget::OnOrientationChange() {
1678 }
1679
1680 gfx::Vector2d RenderWidget::GetScrollOffset() {
1681 // Bare RenderWidgets don't support scroll offset.
1682 return gfx::Vector2d();
1683 }
1684
1685 void RenderWidget::SetHidden(bool hidden) {
1686 if (is_hidden_ == hidden)
1687 return;
1688
1689 // The status has changed. Tell the RenderThread about it.
1690 is_hidden_ = hidden;
1691 if (is_hidden_)
1692 RenderThreadImpl::current()->WidgetHidden();
1693 else
1694 RenderThreadImpl::current()->WidgetRestored();
1695 }
1696
1697 void RenderWidget::WillToggleFullscreen() {
1698 if (!webwidget_)
1699 return;
1700
1701 if (is_fullscreen_) {
1702 webwidget_->willExitFullScreen();
1703 } else {
1704 webwidget_->willEnterFullScreen();
1705 }
1706 }
1707
1708 void RenderWidget::DidToggleFullscreen() {
1709 if (!webwidget_)
1710 return;
1711
1712 if (is_fullscreen_) {
1713 webwidget_->didEnterFullScreen();
1714 } else {
1715 webwidget_->didExitFullScreen();
1716 }
1717 }
1718
1719 bool RenderWidget::next_paint_is_resize_ack() const {
1720 return ViewHostMsg_UpdateRect_Flags::is_resize_ack(next_paint_flags_);
1721 }
1722
1723 void RenderWidget::set_next_paint_is_resize_ack() {
1724 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
1725 }
1726
1727 void RenderWidget::set_next_paint_is_repaint_ack() {
1728 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK;
1729 }
1730
1731 static bool IsDateTimeInput(ui::TextInputType type) {
1732 return type == ui::TEXT_INPUT_TYPE_DATE ||
1733 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
1734 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
1735 type == ui::TEXT_INPUT_TYPE_MONTH ||
1736 type == ui::TEXT_INPUT_TYPE_TIME ||
1737 type == ui::TEXT_INPUT_TYPE_WEEK;
1738 }
1739
1740
1741 void RenderWidget::StartHandlingImeEvent() {
1742 DCHECK(!handling_ime_event_);
1743 handling_ime_event_ = true;
1744 }
1745
1746 void RenderWidget::FinishHandlingImeEvent() {
1747 DCHECK(handling_ime_event_);
1748 handling_ime_event_ = false;
1749 // While handling an ime event, text input state and selection bounds updates
1750 // are ignored. These must explicitly be updated once finished handling the
1751 // ime event.
1752 UpdateSelectionBounds();
1753 #if defined(OS_ANDROID)
1754 UpdateTextInputState(NO_SHOW_IME, FROM_IME);
1755 #endif
1756 }
1757
1758 void RenderWidget::UpdateTextInputState(ShowIme show_ime,
1759 ChangeSource change_source) {
1760 if (handling_ime_event_)
1761 return;
1762 if (show_ime == NO_SHOW_IME && !input_method_is_active_)
1763 return;
1764 ui::TextInputType new_type = GetTextInputType();
1765 if (IsDateTimeInput(new_type))
1766 return; // Not considered as a text input field in WebKit/Chromium.
1767
1768 blink::WebTextInputInfo new_info;
1769 if (webwidget_)
1770 new_info = webwidget_->textInputInfo();
1771 const ui::TextInputMode new_mode = ConvertInputMode(new_info.inputMode);
1772
1773 bool new_can_compose_inline = CanComposeInline();
1774
1775 // Only sends text input params if they are changed or if the ime should be
1776 // shown.
1777 if (show_ime == SHOW_IME_IF_NEEDED ||
1778 (text_input_type_ != new_type ||
1779 text_input_mode_ != new_mode ||
1780 text_input_info_ != new_info ||
1781 can_compose_inline_ != new_can_compose_inline)
1782 #if defined(OS_ANDROID)
1783 || text_field_is_dirty_
1784 #endif
1785 ) {
1786 ViewHostMsg_TextInputState_Params p;
1787 p.type = new_type;
1788 p.flags = new_info.flags;
1789 p.mode = new_mode;
1790 p.value = new_info.value.utf8();
1791 p.selection_start = new_info.selectionStart;
1792 p.selection_end = new_info.selectionEnd;
1793 p.composition_start = new_info.compositionStart;
1794 p.composition_end = new_info.compositionEnd;
1795 p.can_compose_inline = new_can_compose_inline;
1796 p.show_ime_if_needed = (show_ime == SHOW_IME_IF_NEEDED);
1797 #if defined(USE_AURA)
1798 p.is_non_ime_change = true;
1799 #endif
1800 #if defined(OS_ANDROID)
1801 p.is_non_ime_change = (change_source == FROM_NON_IME) ||
1802 text_field_is_dirty_;
1803 if (p.is_non_ime_change)
1804 IncrementOutstandingImeEventAcks();
1805 text_field_is_dirty_ = false;
1806 #endif
1807 Send(new ViewHostMsg_TextInputStateChanged(routing_id(), p));
1808
1809 text_input_info_ = new_info;
1810 text_input_type_ = new_type;
1811 text_input_mode_ = new_mode;
1812 can_compose_inline_ = new_can_compose_inline;
1813 }
1814 }
1815
1816 void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
1817 WebRect focus_webrect;
1818 WebRect anchor_webrect;
1819 webwidget_->selectionBounds(focus_webrect, anchor_webrect);
1820 *focus = focus_webrect;
1821 *anchor = anchor_webrect;
1822 }
1823
1824 void RenderWidget::UpdateSelectionBounds() {
1825 if (!webwidget_)
1826 return;
1827 if (handling_ime_event_)
1828 return;
1829
1830 // With composited selection updates, the selection bounds will be reported
1831 // directly by the compositor, in which case explicit IPC selection
1832 // notifications should be suppressed.
1833 if (!blink::WebRuntimeFeatures::isCompositedSelectionUpdateEnabled()) {
1834 ViewHostMsg_SelectionBounds_Params params;
1835 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
1836 if (selection_anchor_rect_ != params.anchor_rect ||
1837 selection_focus_rect_ != params.focus_rect) {
1838 selection_anchor_rect_ = params.anchor_rect;
1839 selection_focus_rect_ = params.focus_rect;
1840 webwidget_->selectionTextDirection(params.focus_dir, params.anchor_dir);
1841 params.is_anchor_first = webwidget_->isSelectionAnchorFirst();
1842 Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
1843 }
1844 }
1845
1846 #if defined(OS_MACOSX) || defined(USE_AURA)
1847 UpdateCompositionInfo(false);
1848 #endif
1849 }
1850
1851 // Check blink::WebTextInputType and ui::TextInputType is kept in sync.
1852 COMPILE_ASSERT(int(blink::WebTextInputTypeNone) == \
1853 int(ui::TEXT_INPUT_TYPE_NONE), mismatching_enums);
1854 COMPILE_ASSERT(int(blink::WebTextInputTypeText) == \
1855 int(ui::TEXT_INPUT_TYPE_TEXT), mismatching_enums);
1856 COMPILE_ASSERT(int(blink::WebTextInputTypePassword) == \
1857 int(ui::TEXT_INPUT_TYPE_PASSWORD), mismatching_enums);
1858 COMPILE_ASSERT(int(blink::WebTextInputTypeSearch) == \
1859 int(ui::TEXT_INPUT_TYPE_SEARCH), mismatching_enums);
1860 COMPILE_ASSERT(int(blink::WebTextInputTypeEmail) == \
1861 int(ui::TEXT_INPUT_TYPE_EMAIL), mismatching_enums);
1862 COMPILE_ASSERT(int(blink::WebTextInputTypeNumber) == \
1863 int(ui::TEXT_INPUT_TYPE_NUMBER), mismatching_enums);
1864 COMPILE_ASSERT(int(blink::WebTextInputTypeTelephone) == \
1865 int(ui::TEXT_INPUT_TYPE_TELEPHONE), mismatching_enums);
1866 COMPILE_ASSERT(int(blink::WebTextInputTypeURL) == \
1867 int(ui::TEXT_INPUT_TYPE_URL), mismatching_enums);
1868 COMPILE_ASSERT(int(blink::WebTextInputTypeDate) == \
1869 int(ui::TEXT_INPUT_TYPE_DATE), mismatching_enum);
1870 COMPILE_ASSERT(int(blink::WebTextInputTypeDateTime) == \
1871 int(ui::TEXT_INPUT_TYPE_DATE_TIME), mismatching_enum);
1872 COMPILE_ASSERT(int(blink::WebTextInputTypeDateTimeLocal) == \
1873 int(ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL), mismatching_enum);
1874 COMPILE_ASSERT(int(blink::WebTextInputTypeMonth) == \
1875 int(ui::TEXT_INPUT_TYPE_MONTH), mismatching_enum);
1876 COMPILE_ASSERT(int(blink::WebTextInputTypeTime) == \
1877 int(ui::TEXT_INPUT_TYPE_TIME), mismatching_enum);
1878 COMPILE_ASSERT(int(blink::WebTextInputTypeWeek) == \
1879 int(ui::TEXT_INPUT_TYPE_WEEK), mismatching_enum);
1880 COMPILE_ASSERT(int(blink::WebTextInputTypeTextArea) == \
1881 int(ui::TEXT_INPUT_TYPE_TEXT_AREA), mismatching_enums);
1882 COMPILE_ASSERT(int(blink::WebTextInputTypeContentEditable) == \
1883 int(ui::TEXT_INPUT_TYPE_CONTENT_EDITABLE), mismatching_enums);
1884 COMPILE_ASSERT(int(blink::WebTextInputTypeDateTimeField) == \
1885 int(ui::TEXT_INPUT_TYPE_DATE_TIME_FIELD), mismatching_enums);
1886
1887 ui::TextInputType RenderWidget::WebKitToUiTextInputType(
1888 blink::WebTextInputType type) {
1889 // Check the type is in the range representable by ui::TextInputType.
1890 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX)) <<
1891 "blink::WebTextInputType and ui::TextInputType not synchronized";
1892 return static_cast<ui::TextInputType>(type);
1893 }
1894
1895 ui::TextInputType RenderWidget::GetTextInputType() {
1896 if (webwidget_)
1897 return WebKitToUiTextInputType(webwidget_->textInputInfo().type);
1898 return ui::TEXT_INPUT_TYPE_NONE;
1899 }
1900
1901 #if defined(OS_MACOSX) || defined(USE_AURA)
1902 void RenderWidget::UpdateCompositionInfo(bool should_update_range) {
1903 gfx::Range range = gfx::Range();
1904 if (should_update_range) {
1905 GetCompositionRange(&range);
1906 } else {
1907 range = composition_range_;
1908 }
1909 std::vector<gfx::Rect> character_bounds;
1910 GetCompositionCharacterBounds(&character_bounds);
1911
1912 if (!ShouldUpdateCompositionInfo(range, character_bounds))
1913 return;
1914 composition_character_bounds_ = character_bounds;
1915 composition_range_ = range;
1916 Send(new InputHostMsg_ImeCompositionRangeChanged(
1917 routing_id(), composition_range_, composition_character_bounds_));
1918 }
1919
1920 void RenderWidget::GetCompositionCharacterBounds(
1921 std::vector<gfx::Rect>* bounds) {
1922 DCHECK(bounds);
1923 bounds->clear();
1924 }
1925
1926 void RenderWidget::GetCompositionRange(gfx::Range* range) {
1927 size_t location, length;
1928 if (webwidget_->compositionRange(&location, &length)) {
1929 range->set_start(location);
1930 range->set_end(location + length);
1931 } else if (webwidget_->caretOrSelectionRange(&location, &length)) {
1932 range->set_start(location);
1933 range->set_end(location + length);
1934 } else {
1935 *range = gfx::Range::InvalidRange();
1936 }
1937 }
1938
1939 bool RenderWidget::ShouldUpdateCompositionInfo(
1940 const gfx::Range& range,
1941 const std::vector<gfx::Rect>& bounds) {
1942 if (composition_range_ != range)
1943 return true;
1944 if (bounds.size() != composition_character_bounds_.size())
1945 return true;
1946 for (size_t i = 0; i < bounds.size(); ++i) {
1947 if (bounds[i] != composition_character_bounds_[i])
1948 return true;
1949 }
1950 return false;
1951 }
1952 #endif
1953
1954 #if defined(OS_ANDROID)
1955 void RenderWidget::DidChangeBodyBackgroundColor(SkColor bg_color) {
1956 // If not initialized, default to white. Note that 0 is different from black
1957 // as black still has alpha 0xFF.
1958 if (!bg_color)
1959 bg_color = SK_ColorWHITE;
1960
1961 if (bg_color != body_background_color_) {
1962 body_background_color_ = bg_color;
1963 Send(new ViewHostMsg_DidChangeBodyBackgroundColor(routing_id(), bg_color));
1964 }
1965 }
1966 #endif
1967
1968 bool RenderWidget::CanComposeInline() {
1969 return true;
1970 }
1971
1972 WebScreenInfo RenderWidget::screenInfo() {
1973 return screen_info_;
1974 }
1975
1976 float RenderWidget::deviceScaleFactor() {
1977 return device_scale_factor_;
1978 }
1979
1980 void RenderWidget::resetInputMethod() {
1981 if (!input_method_is_active_)
1982 return;
1983
1984 ImeEventGuard guard(this);
1985 // If the last text input type is not None, then we should finish any
1986 // ongoing composition regardless of the new text input type.
1987 if (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE) {
1988 // If a composition text exists, then we need to let the browser process
1989 // to cancel the input method's ongoing composition session.
1990 if (webwidget_->confirmComposition())
1991 Send(new InputHostMsg_ImeCancelComposition(routing_id()));
1992 }
1993
1994 #if defined(OS_MACOSX) || defined(USE_AURA)
1995 UpdateCompositionInfo(true);
1996 #endif
1997 }
1998
1999 void RenderWidget::didHandleGestureEvent(
2000 const WebGestureEvent& event,
2001 bool event_cancelled) {
2002 #if defined(OS_ANDROID) || defined(USE_AURA)
2003 if (event_cancelled)
2004 return;
2005 if (event.type == WebInputEvent::GestureTap) {
2006 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
2007 } else if (event.type == WebInputEvent::GestureLongPress) {
2008 DCHECK(webwidget_);
2009 if (webwidget_->textInputInfo().value.isEmpty())
2010 UpdateTextInputState(NO_SHOW_IME, FROM_NON_IME);
2011 else
2012 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
2013 }
2014 #endif
2015 }
2016
2017 void RenderWidget::StartCompositor() {
2018 // For widgets that are never visible, we don't need the compositor to run
2019 // at all.
2020 if (never_visible_)
2021 return;
2022 compositor_->setSurfaceReady();
2023 }
2024
2025 void RenderWidget::SchedulePluginMove(const WebPluginGeometry& move) {
2026 size_t i = 0;
2027 for (; i < plugin_window_moves_.size(); ++i) {
2028 if (plugin_window_moves_[i].window == move.window) {
2029 if (move.rects_valid) {
2030 plugin_window_moves_[i] = move;
2031 } else {
2032 plugin_window_moves_[i].visible = move.visible;
2033 }
2034 break;
2035 }
2036 }
2037
2038 if (i == plugin_window_moves_.size())
2039 plugin_window_moves_.push_back(move);
2040 }
2041
2042 void RenderWidget::CleanupWindowInPluginMoves(gfx::PluginWindowHandle window) {
2043 for (WebPluginGeometryVector::iterator i = plugin_window_moves_.begin();
2044 i != plugin_window_moves_.end(); ++i) {
2045 if (i->window == window) {
2046 plugin_window_moves_.erase(i);
2047 break;
2048 }
2049 }
2050 }
2051
2052
2053 RenderWidgetCompositor* RenderWidget::compositor() const {
2054 return compositor_.get();
2055 }
2056
2057 bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
2058 return false;
2059 }
2060
2061 bool RenderWidget::WillHandleGestureEvent(
2062 const blink::WebGestureEvent& event) {
2063 return false;
2064 }
2065
2066 void RenderWidget::hasTouchEventHandlers(bool has_handlers) {
2067 Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
2068 }
2069
2070 void RenderWidget::setTouchAction(
2071 blink::WebTouchAction web_touch_action) {
2072
2073 // Ignore setTouchAction calls that result from synthetic touch events (eg.
2074 // when blink is emulating touch with mouse).
2075 if (handling_event_type_ != WebInputEvent::TouchStart)
2076 return;
2077
2078 // Verify the same values are used by the types so we can cast between them.
2079 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_AUTO) ==
2080 blink::WebTouchActionAuto,
2081 enum_values_must_match_for_touch_action);
2082 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_NONE) ==
2083 blink::WebTouchActionNone,
2084 enum_values_must_match_for_touch_action);
2085 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_PAN_X) ==
2086 blink::WebTouchActionPanX,
2087 enum_values_must_match_for_touch_action);
2088 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_PAN_Y) ==
2089 blink::WebTouchActionPanY,
2090 enum_values_must_match_for_touch_action);
2091 COMPILE_ASSERT(
2092 static_cast<blink::WebTouchAction>(TOUCH_ACTION_PINCH_ZOOM) ==
2093 blink::WebTouchActionPinchZoom,
2094 enum_values_must_match_for_touch_action);
2095
2096 content::TouchAction content_touch_action =
2097 static_cast<content::TouchAction>(web_touch_action);
2098 Send(new InputHostMsg_SetTouchAction(routing_id_, content_touch_action));
2099 }
2100
2101 void RenderWidget::didUpdateTextOfFocusedElementByNonUserInput() {
2102 #if defined(OS_ANDROID)
2103 text_field_is_dirty_ = true;
2104 #endif
2105 }
2106
2107 bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
2108 return true;
2109 }
2110
2111 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
2112 RenderWidget::CreateGraphicsContext3D() {
2113 if (!webwidget_)
2114 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
2115 if (CommandLine::ForCurrentProcess()->HasSwitch(
2116 switches::kDisableGpuCompositing))
2117 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
2118 if (!RenderThreadImpl::current())
2119 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
2120 CauseForGpuLaunch cause =
2121 CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
2122 scoped_refptr<GpuChannelHost> gpu_channel_host(
2123 RenderThreadImpl::current()->EstablishGpuChannelSync(cause));
2124 if (!gpu_channel_host.get())
2125 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
2126
2127 // Explicitly disable antialiasing for the compositor. As of the time of
2128 // this writing, the only platform that supported antialiasing for the
2129 // compositor was Mac OS X, because the on-screen OpenGL context creation
2130 // code paths on Windows and Linux didn't yet have multisampling support.
2131 // Mac OS X essentially always behaves as though it's rendering offscreen.
2132 // Multisampling has a heavy cost especially on devices with relatively low
2133 // fill rate like most notebooks, and the Mac implementation would need to
2134 // be optimized to resolve directly into the IOSurface shared between the
2135 // GPU and browser processes. For these reasons and to avoid platform
2136 // disparities we explicitly disable antialiasing.
2137 blink::WebGraphicsContext3D::Attributes attributes;
2138 attributes.antialias = false;
2139 attributes.shareResources = true;
2140 attributes.noAutomaticFlushes = true;
2141 attributes.depth = false;
2142 attributes.stencil = false;
2143 bool lose_context_when_out_of_memory = true;
2144 WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits limits;
2145 #if defined(OS_ANDROID)
2146 // If we raster too fast we become upload bound, and pending
2147 // uploads consume memory. For maximum upload throughput, we would
2148 // want to allow for upload_throughput * pipeline_time of pending
2149 // uploads, after which we are just wasting memory. Since we don't
2150 // know our upload throughput yet, this just caps our memory usage.
2151 size_t divider = 1;
2152 if (base::SysInfo::IsLowEndDevice())
2153 divider = 6;
2154 // For reference Nexus10 can upload 1MB in about 2.5ms.
2155 const double max_mb_uploaded_per_ms = 2.0 / (5 * divider);
2156 // Deadline to draw a frame to achieve 60 frames per second.
2157 const size_t kMillisecondsPerFrame = 16;
2158 // Assuming a two frame deep pipeline between the CPU and the GPU.
2159 size_t max_transfer_buffer_usage_mb =
2160 static_cast<size_t>(2 * kMillisecondsPerFrame * max_mb_uploaded_per_ms);
2161 static const size_t kBytesPerMegabyte = 1024 * 1024;
2162 // We keep the MappedMemoryReclaimLimit the same as the upload limit
2163 // to avoid unnecessarily stalling the compositor thread.
2164 limits.mapped_memory_reclaim_limit =
2165 max_transfer_buffer_usage_mb * kBytesPerMegabyte;
2166 #endif
2167
2168 scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
2169 new WebGraphicsContext3DCommandBufferImpl(surface_id(),
2170 GetURLForGraphicsContext3D(),
2171 gpu_channel_host.get(),
2172 attributes,
2173 lose_context_when_out_of_memory,
2174 limits,
2175 NULL));
2176 return context.Pass();
2177 }
2178
2179 void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
2180 render_frame_proxies_.AddObserver(proxy);
2181 }
2182
2183 void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
2184 render_frame_proxies_.RemoveObserver(proxy);
2185 }
2186
2187 void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
2188 render_frames_.AddObserver(frame);
2189 }
2190
2191 void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) {
2192 render_frames_.RemoveObserver(frame);
2193 }
2194
2195 #if defined(VIDEO_HOLE)
2196 void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
2197 video_hole_frames_.AddObserver(frame);
2198 }
2199
2200 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
2201 video_hole_frames_.RemoveObserver(frame);
2202 }
2203 #endif // defined(VIDEO_HOLE)
2204
2205 } // namespace content