blob: 58875568f4fccaf6661df518e1e8a486ae13871d [file] [log] [blame]
[email protected]60a50072012-01-11 02:05:351// Copyright (c) 2012 The Chromium Authors. All rights reserved.
license.botbf09a502008-08-24 00:55:552// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commit09911bf2008-07-26 23:55:294
[email protected]2cff0052011-03-18 16:51:445#include "content/renderer/render_widget.h"
initial.commit09911bf2008-07-26 23:55:296
[email protected]32876ae2011-11-15 22:25:217#include "base/bind.h"
[email protected]4fb66842009-12-04 21:41:008#include "base/command_line.h"
[email protected]366ae242011-05-10 02:23:589#include "base/debug/trace_event.h"
initial.commit09911bf2008-07-26 23:55:2910#include "base/logging.h"
[email protected]3b63f8f42011-03-28 01:54:1511#include "base/memory/scoped_ptr.h"
initial.commit09911bf2008-07-26 23:55:2912#include "base/message_loop.h"
[email protected]835d7c82010-10-14 04:38:3813#include "base/metrics/histogram.h"
[email protected]aa4117f2011-12-09 22:19:2114#include "base/stl_util.h"
[email protected]8a9d6ca32011-06-06 20:11:3015#include "base/utf_string_conversions.h"
[email protected]661eb9d2009-02-03 02:11:4816#include "build/build_config.h"
[email protected]681ccff2013-03-18 06:13:5217#include "cc/base/switches.h"
18#include "cc/base/thread.h"
19#include "cc/base/thread_impl.h"
[email protected]7f0d825f2013-03-18 07:24:3020#include "cc/output/output_surface.h"
[email protected]556fd292013-03-18 08:03:0421#include "cc/trees/layer_tree_host.h"
[email protected]ed7defa2013-03-12 21:29:5922#include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
[email protected]c084330e02013-04-27 01:08:1523#include "content/common/input_messages.h"
[email protected]992db4c2011-05-12 15:37:1524#include "content/common/swapped_out_messages.h"
[email protected]778574e2011-03-21 22:03:5025#include "content/common/view_messages.h"
[email protected]c08950d22011-10-13 22:20:2926#include "content/public/common/content_switches.h"
[email protected]ed7defa2013-03-12 21:29:5927#include "content/renderer/gpu/compositor_output_surface.h"
[email protected]2847b222013-04-06 00:59:2428#include "content/renderer/gpu/compositor_software_output_device.h"
[email protected]ea5f70a2013-03-07 12:30:3629#include "content/renderer/gpu/input_handler_manager.h"
[email protected]ed7defa2013-03-12 21:29:5930#include "content/renderer/gpu/mailbox_output_surface.h"
[email protected]ba91a792013-02-06 09:48:2831#include "content/renderer/gpu/render_widget_compositor.h"
[email protected]8704f89b2011-04-15 00:30:0532#include "content/renderer/render_process.h"
[email protected]f1a29a02011-10-06 23:08:4433#include "content/renderer/render_thread_impl.h"
[email protected]8d6cba42011-09-02 10:05:1934#include "content/renderer/renderer_webkitplatformsupport_impl.h"
[email protected]484955942010-08-19 16:13:1835#include "ipc/ipc_sync_message.h"
[email protected]661eb9d2009-02-03 02:11:4836#include "skia/ext/platform_canvas.h"
[email protected]ed7defa2013-03-12 21:29:5937#include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
[email protected]debc8e52013-01-15 03:43:1238#include "third_party/WebKit/Source/Platform/chromium/public/WebPoint.h"
39#include "third_party/WebKit/Source/Platform/chromium/public/WebRect.h"
40#include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
41#include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
[email protected]8bd0fe62011-01-17 06:44:3742#include "third_party/WebKit/Source/WebKit/chromium/public/WebCursorInfo.h"
[email protected]4b1146bc2012-07-10 18:46:0343#include "third_party/WebKit/Source/WebKit/chromium/public/WebHelperPlugin.h"
[email protected]a7547fb2012-03-08 04:43:4444#include "third_party/WebKit/Source/WebKit/chromium/public/WebPagePopup.h"
[email protected]8bd0fe62011-01-17 06:44:3745#include "third_party/WebKit/Source/WebKit/chromium/public/WebPopupMenu.h"
46#include "third_party/WebKit/Source/WebKit/chromium/public/WebPopupMenuInfo.h"
[email protected]d4cff272011-05-02 15:46:0147#include "third_party/WebKit/Source/WebKit/chromium/public/WebRange.h"
[email protected]8bd0fe62011-01-17 06:44:3748#include "third_party/WebKit/Source/WebKit/chromium/public/WebScreenInfo.h"
[email protected]d353541f2012-05-03 22:45:4149#include "third_party/skia/include/core/SkShader.h"
[email protected]faec7b12012-06-19 14:42:1350#include "ui/base/ui_base_switches.h"
[email protected]a25e25b2012-09-28 14:32:3751#include "ui/gfx/rect_conversions.h"
[email protected]4b01b962012-10-09 23:17:3552#include "ui/gfx/size_conversions.h"
[email protected]1835b9e2012-02-28 13:12:4853#include "ui/gfx/skia_util.h"
[email protected]c9e2cbbb2012-05-12 21:17:2754#include "ui/gl/gl_switches.h"
[email protected]d353541f2012-05-03 22:45:4155#include "ui/surface/transport_dib.h"
[email protected]b63d58d2012-11-26 22:37:4456#include "webkit/compositor_bindings/web_rendering_stats_impl.h"
[email protected]8c89e7792009-08-19 21:18:3457#include "webkit/glue/webkit_glue.h"
[email protected]191eb3f72010-12-21 06:27:5058#include "webkit/plugins/npapi/webplugin.h"
[email protected]719b36f2010-12-22 20:36:4659#include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
[email protected]661eb9d2009-02-03 02:11:4860
[email protected]eeb93112013-05-01 19:41:1061#if defined(OS_ANDROID)
62#include "content/renderer/android/synchronous_compositor_output_surface.h"
63#endif
64
[email protected]661eb9d2009-02-03 02:11:4865#if defined(OS_POSIX)
[email protected]6b889fb2010-03-23 20:09:4966#include "ipc/ipc_channel_posix.h"
[email protected]d5282e72009-05-13 13:16:5267#include "third_party/skia/include/core/SkMallocPixelRef.h"
[email protected]d353541f2012-05-03 22:45:4168#include "third_party/skia/include/core/SkPixelRef.h"
[email protected]661eb9d2009-02-03 02:11:4869#endif // defined(OS_POSIX)
[email protected]8085dbc82008-09-26 22:53:4470
[email protected]8bd0fe62011-01-17 06:44:3771#include "third_party/WebKit/Source/WebKit/chromium/public/WebWidget.h"
initial.commit09911bf2008-07-26 23:55:2972
[email protected]fa7b1dc2010-06-23 17:53:0473using WebKit::WebCompositionUnderline;
[email protected]7c51b0ee2009-07-08 21:49:3074using WebKit::WebCursorInfo;
[email protected]41d86852012-11-07 12:23:2475using WebKit::WebGestureEvent;
[email protected]62cb33cae2009-03-27 23:30:2276using WebKit::WebInputEvent;
[email protected]6a8ddba52010-09-05 04:38:0677using WebKit::WebMouseEvent;
[email protected]4873c7d2009-07-16 06:36:2878using WebKit::WebNavigationPolicy;
[email protected]a7547fb2012-03-08 04:43:4479using WebKit::WebPagePopup;
[email protected]e99ef6f2011-10-16 01:13:0080using WebKit::WebPoint;
[email protected]4873c7d2009-07-16 06:36:2881using WebKit::WebPopupMenu;
[email protected]88efb7ec2009-07-14 16:32:5982using WebKit::WebPopupMenuInfo;
[email protected]484955942010-08-19 16:13:1883using WebKit::WebPopupType;
[email protected]d4cff272011-05-02 15:46:0184using WebKit::WebRange;
[email protected]b3f2b912009-04-09 16:18:5285using WebKit::WebRect;
[email protected]12456fa2009-04-01 23:07:1986using WebKit::WebScreenInfo;
[email protected]b3f2b912009-04-09 16:18:5287using WebKit::WebSize;
[email protected]4873c7d2009-07-16 06:36:2888using WebKit::WebTextDirection;
[email protected]2d0f2e92011-10-03 09:02:2489using WebKit::WebTouchEvent;
[email protected]fa7b1dc2010-06-23 17:53:0490using WebKit::WebVector;
[email protected]484955942010-08-19 16:13:1891using WebKit::WebWidget;
[email protected]e9ff79c2012-10-19 21:31:2692
[email protected]6a4d7f62013-01-07 21:32:1393namespace {
94const char* GetEventName(WebInputEvent::Type type) {
95#define CASE_TYPE(t) case WebInputEvent::t: return #t
96 switch(type) {
97 CASE_TYPE(Undefined);
98 CASE_TYPE(MouseDown);
99 CASE_TYPE(MouseUp);
100 CASE_TYPE(MouseMove);
101 CASE_TYPE(MouseEnter);
102 CASE_TYPE(MouseLeave);
103 CASE_TYPE(ContextMenu);
104 CASE_TYPE(MouseWheel);
105 CASE_TYPE(RawKeyDown);
106 CASE_TYPE(KeyDown);
107 CASE_TYPE(KeyUp);
108 CASE_TYPE(Char);
109 CASE_TYPE(GestureScrollBegin);
110 CASE_TYPE(GestureScrollEnd);
111 CASE_TYPE(GestureScrollUpdate);
112 CASE_TYPE(GestureFlingStart);
113 CASE_TYPE(GestureFlingCancel);
114 CASE_TYPE(GestureTap);
115 CASE_TYPE(GestureTapDown);
116 CASE_TYPE(GestureTapCancel);
117 CASE_TYPE(GestureDoubleTap);
118 CASE_TYPE(GestureTwoFingerTap);
119 CASE_TYPE(GestureLongPress);
120 CASE_TYPE(GestureLongTap);
121 CASE_TYPE(GesturePinchBegin);
122 CASE_TYPE(GesturePinchEnd);
123 CASE_TYPE(GesturePinchUpdate);
124 CASE_TYPE(TouchStart);
125 CASE_TYPE(TouchMove);
126 CASE_TYPE(TouchEnd);
127 CASE_TYPE(TouchCancel);
[email protected]3ec08ed2013-01-11 15:59:57128 default:
129 // Must include default to let WebKit::WebInputEvent add new event types
130 // before they're added here.
131 DLOG(WARNING) << "Unhandled WebInputEvent type in GetEventName.\n";
132 break;
[email protected]6a4d7f62013-01-07 21:32:13133 }
134#undef CASE_TYPE
[email protected]3ec08ed2013-01-11 15:59:57135 return "";
[email protected]6a4d7f62013-01-07 21:32:13136}
137}
[email protected]e9ff79c2012-10-19 21:31:26138namespace content {
[email protected]62cb33cae2009-03-27 23:30:22139
[email protected]6fd35b72012-03-01 19:46:41140RenderWidget::RenderWidget(WebKit::WebPopupType popup_type,
[email protected]842f10652012-06-06 01:54:04141 const WebKit::WebScreenInfo& screen_info,
[email protected]14392a52012-05-02 20:28:44142 bool swapped_out)
initial.commit09911bf2008-07-26 23:55:29143 : routing_id_(MSG_ROUTING_NONE),
[email protected]9f4f3322012-01-18 22:29:56144 surface_id_(0),
[email protected]c5b3b5e2009-02-13 06:41:11145 webwidget_(NULL),
initial.commit09911bf2008-07-26 23:55:29146 opener_id_(MSG_ROUTING_NONE),
[email protected]fc4404d2012-11-07 19:53:30147 init_complete_(false),
[email protected]b4d08452010-10-05 17:34:35148 current_paint_buf_(NULL),
[email protected]d9083762013-03-24 01:36:40149 overdraw_bottom_height_(0.f),
initial.commit09911bf2008-07-26 23:55:29150 next_paint_flags_(0),
[email protected]0cff69e2011-11-22 22:26:06151 filtered_time_per_frame_(0.0f),
[email protected]53d3f302009-12-21 04:42:05152 update_reply_pending_(false),
[email protected]847a2582013-03-09 02:29:51153 auto_resize_mode_(false),
[email protected]ea3ee0a2012-05-15 03:43:09154 need_update_rect_for_auto_resize_(false),
[email protected]65225772011-05-12 21:10:24155 using_asynchronous_swapbuffers_(false),
156 num_swapbuffers_complete_pending_(0),
initial.commit09911bf2008-07-26 23:55:29157 did_show_(false),
initial.commit09911bf2008-07-26 23:55:29158 is_hidden_(false),
[email protected]ee41e7d22011-10-14 19:34:09159 is_fullscreen_(false),
initial.commit09911bf2008-07-26 23:55:29160 needs_repainting_on_restore_(false),
161 has_focus_(false),
[email protected]5dd768212009-08-13 23:34:49162 handling_input_event_(false),
[email protected]e8f775f2013-02-14 21:00:50163 handling_ime_event_(false),
[email protected]661eb9d2009-02-03 02:11:48164 closing_(false),
[email protected]14392a52012-05-02 20:28:44165 is_swapped_out_(swapped_out),
[email protected]fa7b1dc2010-06-23 17:53:04166 input_method_is_active_(false),
[email protected]ad26ef42011-06-17 07:59:45167 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
168 can_compose_inline_(true),
[email protected]3e2b375b2010-04-07 17:03:12169 popup_type_(popup_type),
[email protected]867125a02009-12-10 06:01:48170 pending_window_rect_count_(0),
[email protected]b68a0e52011-12-08 15:11:12171 suppress_next_char_events_(false),
[email protected]5f8b1022011-01-21 23:34:50172 is_accelerated_compositing_active_(false),
[email protected]ee3d3ad2011-02-04 00:42:21173 animation_update_pending_(false),
[email protected]4b03e292012-02-13 18:40:07174 invalidation_task_posted_(false),
[email protected]842f10652012-06-06 01:54:04175 screen_info_(screen_info),
[email protected]3d779472012-11-15 20:49:52176 device_scale_factor_(screen_info_.deviceScaleFactor),
[email protected]0e241b4b2012-08-18 09:06:27177 throttle_input_events_(true),
[email protected]ed7defa2013-03-12 21:29:59178 is_threaded_compositing_enabled_(false),
[email protected]69e797f2013-04-30 01:10:22179 weak_ptr_factory_(this) {
[email protected]8b3f0eb2012-05-03 19:15:05180 if (!swapped_out)
181 RenderProcess::current()->AddRefProcess();
[email protected]380244092011-10-07 17:26:27182 DCHECK(RenderThread::Get());
[email protected]bd37ae252011-06-03 01:28:18183 has_disable_gpu_vsync_switch_ = CommandLine::ForCurrentProcess()->HasSwitch(
184 switches::kDisableGpuVsync);
[email protected]cb6430932012-10-31 00:53:36185 is_threaded_compositing_enabled_ =
186 CommandLine::ForCurrentProcess()->HasSwitch(
187 switches::kEnableThreadedCompositing);
initial.commit09911bf2008-07-26 23:55:29188}
189
190RenderWidget::~RenderWidget() {
[email protected]c5b3b5e2009-02-13 06:41:11191 DCHECK(!webwidget_) << "Leaking our WebWidget!";
[email protected]aa4117f2011-12-09 22:19:21192 STLDeleteElements(&updates_pending_swap_);
[email protected]b4d08452010-10-05 17:34:35193 if (current_paint_buf_) {
194 RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
195 current_paint_buf_ = NULL;
initial.commit09911bf2008-07-26 23:55:29196 }
[email protected]992db4c2011-05-12 15:37:15197 // If we are swapped out, we have released already.
198 if (!is_swapped_out_)
199 RenderProcess::current()->ReleaseProcess();
initial.commit09911bf2008-07-26 23:55:29200}
201
[email protected]484955942010-08-19 16:13:18202// static
[email protected]8085dbc82008-09-26 22:53:44203RenderWidget* RenderWidget::Create(int32 opener_id,
[email protected]842f10652012-06-06 01:54:04204 WebKit::WebPopupType popup_type,
205 const WebKit::WebScreenInfo& screen_info) {
initial.commit09911bf2008-07-26 23:55:29206 DCHECK(opener_id != MSG_ROUTING_NONE);
[email protected]6fd35b72012-03-01 19:46:41207 scoped_refptr<RenderWidget> widget(
[email protected]842f10652012-06-06 01:54:04208 new RenderWidget(popup_type, screen_info, false));
[email protected]a635f942012-12-07 10:34:29209 if (widget->Init(opener_id)) { // adds reference on success.
210 return widget;
211 }
212 return NULL;
initial.commit09911bf2008-07-26 23:55:29213}
214
[email protected]484955942010-08-19 16:13:18215// static
216WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) {
217 switch (render_widget->popup_type_) {
[email protected]e2356242010-11-16 22:33:03218 case WebKit::WebPopupTypeNone: // Nothing to create.
[email protected]484955942010-08-19 16:13:18219 break;
220 case WebKit::WebPopupTypeSelect:
221 case WebKit::WebPopupTypeSuggestion:
222 return WebPopupMenu::create(render_widget);
[email protected]a7547fb2012-03-08 04:43:44223 case WebKit::WebPopupTypePage:
224 return WebPagePopup::create(render_widget);
[email protected]4b1146bc2012-07-10 18:46:03225 case WebKit::WebPopupTypeHelperPlugin:
226 return WebKit::WebHelperPlugin::create(render_widget);
[email protected]484955942010-08-19 16:13:18227 default:
228 NOTREACHED();
229 }
230 return NULL;
231}
232
[email protected]a635f942012-12-07 10:34:29233bool RenderWidget::Init(int32 opener_id) {
234 return DoInit(opener_id,
235 RenderWidget::CreateWebWidget(this),
236 new ViewHostMsg_CreateWidget(opener_id, popup_type_,
237 &routing_id_, &surface_id_));
[email protected]484955942010-08-19 16:13:18238}
239
[email protected]a635f942012-12-07 10:34:29240bool RenderWidget::DoInit(int32 opener_id,
[email protected]6a8ddba52010-09-05 04:38:06241 WebWidget* web_widget,
[email protected]484955942010-08-19 16:13:18242 IPC::SyncMessage* create_widget_message) {
initial.commit09911bf2008-07-26 23:55:29243 DCHECK(!webwidget_);
244
245 if (opener_id != MSG_ROUTING_NONE)
246 opener_id_ = opener_id;
247
[email protected]484955942010-08-19 16:13:18248 webwidget_ = web_widget;
initial.commit09911bf2008-07-26 23:55:29249
[email protected]380244092011-10-07 17:26:27250 bool result = RenderThread::Get()->Send(create_widget_message);
initial.commit09911bf2008-07-26 23:55:29251 if (result) {
[email protected]380244092011-10-07 17:26:27252 RenderThread::Get()->AddRoute(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29253 // Take a reference on behalf of the RenderThread. This will be balanced
254 // when we receive ViewMsg_Close.
255 AddRef();
[email protected]a635f942012-12-07 10:34:29256 return true;
initial.commit09911bf2008-07-26 23:55:29257 } else {
[email protected]a635f942012-12-07 10:34:29258 // The above Send can fail when the tab is closing.
259 return false;
initial.commit09911bf2008-07-26 23:55:29260 }
261}
262
[email protected]fc4404d2012-11-07 19:53:30263// This is used to complete pending inits and non-pending inits.
264void RenderWidget::CompleteInit() {
initial.commit09911bf2008-07-26 23:55:29265 DCHECK(routing_id_ != MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29266
[email protected]fc4404d2012-11-07 19:53:30267 init_complete_ = true;
[email protected]05a980d7a2012-02-07 22:16:42268
[email protected]8926c602013-01-23 05:32:06269 if (webwidget_ && is_threaded_compositing_enabled_) {
270 webwidget_->enterForceCompositingMode(true);
271 }
[email protected]ba91a792013-02-06 09:48:28272 if (compositor_) {
273 compositor_->setSurfaceReady();
[email protected]479b0172012-10-29 19:27:09274 }
[email protected]05a980d7a2012-02-07 22:16:42275 DoDeferredUpdate();
initial.commit09911bf2008-07-26 23:55:29276
[email protected]6de74452009-02-25 18:04:59277 Send(new ViewHostMsg_RenderViewReady(routing_id_));
initial.commit09911bf2008-07-26 23:55:29278}
279
[email protected]992db4c2011-05-12 15:37:15280void RenderWidget::SetSwappedOut(bool is_swapped_out) {
281 // We should only toggle between states.
282 DCHECK(is_swapped_out_ != is_swapped_out);
283 is_swapped_out_ = is_swapped_out;
284
285 // If we are swapping out, we will call ReleaseProcess, allowing the process
286 // to exit if all of its RenderViews are swapped out. We wait until the
287 // WasSwappedOut call to do this, to avoid showing the sad tab.
288 // If we are swapping in, we call AddRefProcess to prevent the process from
289 // exiting.
290 if (!is_swapped_out)
291 RenderProcess::current()->AddRefProcess();
292}
293
[email protected]34bb3ac2013-03-08 02:41:28294bool RenderWidget::AllowPartialSwap() const {
295 return true;
296}
297
[email protected]ccc1722e2013-05-06 19:43:07298bool RenderWidget::SynchronouslyDisableVSync() const {
299#if defined(OS_ANDROID)
300 if (CommandLine::ForCurrentProcess()->HasSwitch(
301 switches::kEnableSynchronousRendererCompositor)) {
302 return true;
303 }
304#endif
305 return false;
306}
307
[email protected]a95986a82010-12-24 06:19:28308bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
309 bool handled = true;
310 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
[email protected]c084330e02013-04-27 01:08:15311 IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
[email protected]34202de2013-05-06 23:36:22312 IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
313 OnCursorVisibilityChange)
[email protected]c084330e02013-04-27 01:08:15314 IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
315 IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
[email protected]a95986a82010-12-24 06:19:28316 IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
317 IPC_MESSAGE_HANDLER(ViewMsg_CreatingNew_ACK, OnCreatingNewAck)
318 IPC_MESSAGE_HANDLER(ViewMsg_Resize, OnResize)
[email protected]b5913d72012-02-07 22:26:54319 IPC_MESSAGE_HANDLER(ViewMsg_ChangeResizeRect, OnChangeResizeRect)
[email protected]a95986a82010-12-24 06:19:28320 IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
[email protected]9e2e4632012-07-27 16:38:41321 IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
[email protected]992db4c2011-05-12 15:37:15322 IPC_MESSAGE_HANDLER(ViewMsg_WasSwappedOut, OnWasSwappedOut)
[email protected]a95986a82010-12-24 06:19:28323 IPC_MESSAGE_HANDLER(ViewMsg_UpdateRect_ACK, OnUpdateRectAck)
[email protected]ed7defa2013-03-12 21:29:59324 IPC_MESSAGE_HANDLER(ViewMsg_SwapBuffers_ACK,
325 OnViewContextSwapBuffersComplete)
[email protected]a95986a82010-12-24 06:19:28326 IPC_MESSAGE_HANDLER(ViewMsg_SetInputMethodActive, OnSetInputMethodActive)
327 IPC_MESSAGE_HANDLER(ViewMsg_ImeSetComposition, OnImeSetComposition)
328 IPC_MESSAGE_HANDLER(ViewMsg_ImeConfirmComposition, OnImeConfirmComposition)
[email protected]3d9ec5052013-01-02 22:05:25329 IPC_MESSAGE_HANDLER(ViewMsg_PaintAtSize, OnPaintAtSize)
330 IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
331 IPC_MESSAGE_HANDLER(ViewMsg_SmoothScrollCompleted, OnSmoothScrollCompleted)
[email protected]a95986a82010-12-24 06:19:28332 IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
333 IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
[email protected]6131a642012-06-15 23:26:53334 IPC_MESSAGE_HANDLER(ViewMsg_ScreenInfoChanged, OnScreenInfoChanged)
[email protected]80ad8622012-11-07 16:33:03335 IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
[email protected]105dffb42013-02-20 03:46:21336#if defined(OS_ANDROID)
337 IPC_MESSAGE_HANDLER(ViewMsg_ImeBatchStateChanged, OnImeBatchStateChanged)
[email protected]2384b6c2013-02-28 23:58:51338 IPC_MESSAGE_HANDLER(ViewMsg_ShowImeIfNeeded, OnShowImeIfNeeded)
[email protected]105dffb42013-02-20 03:46:21339#endif
[email protected]51a49502013-03-23 01:50:19340 IPC_MESSAGE_HANDLER(ViewMsg_Snapshot, OnSnapshot)
[email protected]a95986a82010-12-24 06:19:28341 IPC_MESSAGE_UNHANDLED(handled = false)
342 IPC_END_MESSAGE_MAP()
343 return handled;
344}
initial.commit09911bf2008-07-26 23:55:29345
346bool RenderWidget::Send(IPC::Message* message) {
[email protected]992db4c2011-05-12 15:37:15347 // Don't send any messages after the browser has told us to close, and filter
348 // most outgoing messages while swapped out.
349 if ((is_swapped_out_ &&
[email protected]e9ff79c2012-10-19 21:31:26350 !SwappedOutMessages::CanSendWhileSwappedOut(message)) ||
[email protected]c6c921e92012-05-10 23:31:11351 closing_) {
initial.commit09911bf2008-07-26 23:55:29352 delete message;
353 return false;
354 }
355
356 // If given a messsage without a routing ID, then assign our routing ID.
357 if (message->routing_id() == MSG_ROUTING_NONE)
358 message->set_routing_id(routing_id_);
359
[email protected]380244092011-10-07 17:26:27360 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44361}
362
[email protected]61e2b3cc2012-03-02 16:13:34363void RenderWidget::Resize(const gfx::Size& new_size,
[email protected]60d47ac2013-03-01 23:42:44364 const gfx::Size& physical_backing_size,
[email protected]d9083762013-03-24 01:36:40365 float overdraw_bottom_height,
[email protected]61e2b3cc2012-03-02 16:13:34366 const gfx::Rect& resizer_rect,
367 bool is_fullscreen,
368 ResizeAck resize_ack) {
369 // A resize ack shouldn't be requested if we have not ACK'd the previous one.
370 DCHECK(resize_ack != SEND_RESIZE_ACK || !next_paint_is_resize_ack());
371 DCHECK(resize_ack == SEND_RESIZE_ACK || resize_ack == NO_RESIZE_ACK);
initial.commit09911bf2008-07-26 23:55:29372
[email protected]61e2b3cc2012-03-02 16:13:34373 // Ignore this during shutdown.
374 if (!webwidget_)
375 return;
376
[email protected]d9083762013-03-24 01:36:40377 if (compositor_) {
[email protected]60d47ac2013-03-01 23:42:44378 compositor_->setViewportSize(new_size, physical_backing_size);
[email protected]d9083762013-03-24 01:36:40379 compositor_->SetOverdrawBottomHeight(overdraw_bottom_height);
380 }
[email protected]60d47ac2013-03-01 23:42:44381
[email protected]dade8992013-03-04 07:34:34382 physical_backing_size_ = physical_backing_size;
[email protected]d9083762013-03-24 01:36:40383 overdraw_bottom_height_ = overdraw_bottom_height;
[email protected]61e2b3cc2012-03-02 16:13:34384 resizer_rect_ = resizer_rect;
385
386 // NOTE: We may have entered fullscreen mode without changing our size.
387 bool fullscreen_change = is_fullscreen_ != is_fullscreen;
388 if (fullscreen_change)
389 WillToggleFullscreen();
390 is_fullscreen_ = is_fullscreen;
391
392 if (size_ != new_size) {
393 // TODO(darin): We should not need to reset this here.
[email protected]61e2b3cc2012-03-02 16:13:34394 needs_repainting_on_restore_ = false;
395
396 size_ = new_size;
397
398 paint_aggregator_.ClearPendingUpdate();
399
400 // When resizing, we want to wait to paint before ACK'ing the resize. This
401 // ensures that we only resize as fast as we can paint. We only need to
402 // send an ACK if we are resized to a non-empty rect.
403 webwidget_->resize(new_size);
404 if (!new_size.IsEmpty()) {
405 if (!is_accelerated_compositing_active_) {
406 // Resize should have caused an invalidation of the entire view.
407 DCHECK(paint_aggregator_.HasPendingUpdate());
408 }
[email protected]61e2b3cc2012-03-02 16:13:34409 }
[email protected]20fbfc22013-05-08 20:50:58410 } else if (!RenderThreadImpl::current()->short_circuit_size_updates()) {
[email protected]ff475a322012-03-14 00:05:35411 resize_ack = NO_RESIZE_ACK;
[email protected]61e2b3cc2012-03-02 16:13:34412 }
413
[email protected]20fbfc22013-05-08 20:50:58414 // Send the Resize_ACK flag once we paint again if requested.
415 if (resize_ack == SEND_RESIZE_ACK)
416 set_next_paint_is_resize_ack();
417
[email protected]61e2b3cc2012-03-02 16:13:34418 if (fullscreen_change)
419 DidToggleFullscreen();
420
421 // If a resize ack is requested and it isn't set-up, then no more resizes will
422 // come in and in general things will go wrong.
423 DCHECK(resize_ack != SEND_RESIZE_ACK || new_size.IsEmpty() ||
424 next_paint_is_resize_ack());
initial.commit09911bf2008-07-26 23:55:29425}
426
427void RenderWidget::OnClose() {
428 if (closing_)
429 return;
430 closing_ = true;
431
432 // Browser correspondence is no longer needed at this point.
[email protected]bee16aab2009-08-26 15:55:03433 if (routing_id_ != MSG_ROUTING_NONE) {
[email protected]380244092011-10-07 17:26:27434 RenderThread::Get()->RemoveRoute(routing_id_);
[email protected]bee16aab2009-08-26 15:55:03435 SetHidden(false);
436 }
initial.commit09911bf2008-07-26 23:55:29437
initial.commit09911bf2008-07-26 23:55:29438 // If there is a Send call on the stack, then it could be dangerous to close
[email protected]d3fc25652009-02-24 22:31:25439 // now. Post a task that only gets invoked when there are no nested message
440 // loops.
[email protected]dd32b1272013-05-04 14:17:11441 base::MessageLoop::current()->PostNonNestableTask(
[email protected]3a5a7822011-12-23 18:27:29442 FROM_HERE, base::Bind(&RenderWidget::Close, this));
[email protected]d3fc25652009-02-24 22:31:25443
444 // Balances the AddRef taken when we called AddRoute.
445 Release();
initial.commit09911bf2008-07-26 23:55:29446}
447
[email protected]61e2b3cc2012-03-02 16:13:34448// Got a response from the browser after the renderer decided to create a new
449// view.
[email protected]fc4404d2012-11-07 19:53:30450void RenderWidget::OnCreatingNewAck() {
[email protected]61e2b3cc2012-03-02 16:13:34451 DCHECK(routing_id_ != MSG_ROUTING_NONE);
452
[email protected]fc4404d2012-11-07 19:53:30453 CompleteInit();
[email protected]61e2b3cc2012-03-02 16:13:34454}
455
[email protected]f21c613a2009-02-12 14:46:17456void RenderWidget::OnResize(const gfx::Size& new_size,
[email protected]60d47ac2013-03-01 23:42:44457 const gfx::Size& physical_backing_size,
[email protected]d9083762013-03-24 01:36:40458 float overdraw_bottom_height,
[email protected]ee41e7d22011-10-14 19:34:09459 const gfx::Rect& resizer_rect,
460 bool is_fullscreen) {
[email protected]d9083762013-03-24 01:36:40461 Resize(new_size, physical_backing_size, overdraw_bottom_height, resizer_rect,
462 is_fullscreen, SEND_RESIZE_ACK);
initial.commit09911bf2008-07-26 23:55:29463}
464
[email protected]b5913d72012-02-07 22:26:54465void RenderWidget::OnChangeResizeRect(const gfx::Rect& resizer_rect) {
466 if (resizer_rect_ != resizer_rect) {
[email protected]b9769d82012-02-10 00:23:59467 gfx::Rect view_rect(size_);
468
[email protected]ce112fe2012-10-29 22:52:18469 gfx::Rect old_damage_rect = gfx::IntersectRects(view_rect, resizer_rect_);
[email protected]b9769d82012-02-10 00:23:59470 if (!old_damage_rect.IsEmpty())
471 paint_aggregator_.InvalidateRect(old_damage_rect);
472
[email protected]ce112fe2012-10-29 22:52:18473 gfx::Rect new_damage_rect = gfx::IntersectRects(view_rect, resizer_rect);
[email protected]b9769d82012-02-10 00:23:59474 if (!new_damage_rect.IsEmpty())
475 paint_aggregator_.InvalidateRect(new_damage_rect);
476
[email protected]b5913d72012-02-07 22:26:54477 resizer_rect_ = resizer_rect;
[email protected]b9769d82012-02-10 00:23:59478
[email protected]b5913d72012-02-07 22:26:54479 if (webwidget_)
480 webwidget_->didChangeWindowResizerRect();
481 }
482}
483
initial.commit09911bf2008-07-26 23:55:29484void RenderWidget::OnWasHidden() {
[email protected]9c3085f2011-06-09 02:10:31485 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
initial.commit09911bf2008-07-26 23:55:29486 // Go into a mode where we stop generating paint and scrolling events.
[email protected]bee16aab2009-08-26 15:55:03487 SetHidden(true);
initial.commit09911bf2008-07-26 23:55:29488}
489
[email protected]9e2e4632012-07-27 16:38:41490void RenderWidget::OnWasShown(bool needs_repainting) {
491 TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
initial.commit09911bf2008-07-26 23:55:29492 // During shutdown we can just ignore this message.
493 if (!webwidget_)
494 return;
495
496 // See OnWasHidden
[email protected]bee16aab2009-08-26 15:55:03497 SetHidden(false);
initial.commit09911bf2008-07-26 23:55:29498
499 if (!needs_repainting && !needs_repainting_on_restore_)
500 return;
501 needs_repainting_on_restore_ = false;
502
[email protected]d65adb12010-04-28 17:26:49503 // Tag the next paint as a restore ack, which is picked up by
504 // DoDeferredUpdate when it sends out the next PaintRect message.
initial.commit09911bf2008-07-26 23:55:29505 set_next_paint_is_restore_ack();
506
507 // Generate a full repaint.
[email protected]a79d8a632010-11-18 22:35:56508 if (!is_accelerated_compositing_active_) {
[email protected]f98d7e3c2010-09-13 22:30:46509 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
510 } else {
511 scheduleComposite();
512 }
initial.commit09911bf2008-07-26 23:55:29513}
514
[email protected]992db4c2011-05-12 15:37:15515void RenderWidget::OnWasSwappedOut() {
516 // If we have been swapped out and no one else is using this process,
517 // it's safe to exit now. If we get swapped back in, we will call
518 // AddRefProcess in SetSwappedOut.
519 if (is_swapped_out_)
520 RenderProcess::current()->ReleaseProcess();
521}
522
[email protected]53d3f302009-12-21 04:42:05523void RenderWidget::OnRequestMoveAck() {
524 DCHECK(pending_window_rect_count_);
525 pending_window_rect_count_--;
526}
527
528void RenderWidget::OnUpdateRectAck() {
[email protected]366ae242011-05-10 02:23:58529 TRACE_EVENT0("renderer", "RenderWidget::OnUpdateRectAck");
[email protected]aa4117f2011-12-09 22:19:21530 DCHECK(update_reply_pending_);
[email protected]53d3f302009-12-21 04:42:05531 update_reply_pending_ = false;
532
[email protected]b4d08452010-10-05 17:34:35533 // If we sent an UpdateRect message with a zero-sized bitmap, then we should
534 // have no current paint buffer.
535 if (current_paint_buf_) {
536 RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
537 current_paint_buf_ = NULL;
538 }
539
[email protected]65225772011-05-12 21:10:24540 // If swapbuffers is still pending, then defer the update until the
541 // swapbuffers occurs.
542 if (num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending) {
543 TRACE_EVENT0("renderer", "EarlyOut_SwapStillPending");
544 return;
545 }
546
[email protected]29ed96a2012-02-04 18:12:16547 // Notify subclasses that software rendering was flushed to the screen.
[email protected]404939f2012-06-01 04:06:18548 if (!is_accelerated_compositing_active_) {
549 DidFlushPaint();
550 }
[email protected]a2f6bc112009-06-27 16:27:25551
initial.commit09911bf2008-07-26 23:55:29552 // Continue painting if necessary...
[email protected]65225772011-05-12 21:10:24553 DoDeferredUpdateAndSendInputAck();
554}
555
[email protected]d0be63772011-12-20 23:18:04556bool RenderWidget::SupportsAsynchronousSwapBuffers() {
[email protected]ed7defa2013-03-12 21:29:59557 // Contexts using the command buffer support asynchronous swapbuffers.
558 // See RenderWidget::CreateOutputSurface().
[email protected]8f746982013-03-21 06:28:03559 if (RenderThreadImpl::current()->compositor_message_loop_proxy())
[email protected]ed7defa2013-03-12 21:29:59560 return false;
561
562 return true;
563}
564
565GURL RenderWidget::GetURLForGraphicsContext3D() {
566 return GURL();
[email protected]65225772011-05-12 21:10:24567}
568
[email protected]479b0172012-10-29 19:27:09569bool RenderWidget::ForceCompositingModeEnabled() {
570 return false;
571}
572
[email protected]ba91a792013-02-06 09:48:28573scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface() {
[email protected]c3e32ed42013-05-02 05:07:13574 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
[email protected]a1811b8912013-05-09 15:35:19575
576#if defined(OS_ANDROID)
577 if (command_line.HasSwitch(switches::kEnableSynchronousRendererCompositor)) {
578 return scoped_ptr<cc::OutputSurface>(
579 new SynchronousCompositorOutputSurface(routing_id()));
580 }
581#endif
582
[email protected]c3e32ed42013-05-02 05:07:13583 if (command_line.HasSwitch(switches::kEnableSoftwareCompositingGLAdapter)) {
584 return scoped_ptr<cc::OutputSurface>(
585 new CompositorOutputSurface(routing_id(), NULL,
586 new CompositorSoftwareOutputDevice()));
587 }
588
[email protected]ed7defa2013-03-12 21:29:59589 // Explicitly disable antialiasing for the compositor. As of the time of
590 // this writing, the only platform that supported antialiasing for the
591 // compositor was Mac OS X, because the on-screen OpenGL context creation
592 // code paths on Windows and Linux didn't yet have multisampling support.
593 // Mac OS X essentially always behaves as though it's rendering offscreen.
594 // Multisampling has a heavy cost especially on devices with relatively low
595 // fill rate like most notebooks, and the Mac implementation would need to
596 // be optimized to resolve directly into the IOSurface shared between the
597 // GPU and browser processes. For these reasons and to avoid platform
598 // disparities we explicitly disable antialiasing.
599 WebKit::WebGraphicsContext3D::Attributes attributes;
600 attributes.antialias = false;
601 attributes.shareResources = true;
602 attributes.noAutomaticFlushes = true;
[email protected]3ae68c52013-04-12 06:10:05603 WebGraphicsContext3DCommandBufferImpl* context =
604 CreateGraphicsContext3D(attributes);
[email protected]c3e32ed42013-05-02 05:07:13605 if (!context)
606 return scoped_ptr<cc::OutputSurface>();
[email protected]ed7defa2013-03-12 21:29:59607
[email protected]2847b222013-04-06 00:59:24608 bool composite_to_mailbox =
[email protected]7b45b5762013-05-08 14:36:56609 command_line.HasSwitch(cc::switches::kCompositeToMailbox) &&
610 !command_line.HasSwitch(switches::kEnableDelegatedRenderer);
[email protected]2847b222013-04-06 00:59:24611 DCHECK(!composite_to_mailbox || command_line.HasSwitch(
612 cc::switches::kEnableCompositorFrameMessage));
613 // No swap throttling yet when compositing on the main thread.
614 DCHECK(!composite_to_mailbox || is_threaded_compositing_enabled_);
615 return scoped_ptr<cc::OutputSurface>(composite_to_mailbox ?
616 new MailboxOutputSurface(routing_id(), context, NULL) :
617 new CompositorOutputSurface(routing_id(), context, NULL));
[email protected]ba91a792013-02-06 09:48:28618}
619
[email protected]ed7defa2013-03-12 21:29:59620void RenderWidget::OnViewContextSwapBuffersAborted() {
[email protected]65225772011-05-12 21:10:24621 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
[email protected]aa4117f2011-12-09 22:19:21622 while (!updates_pending_swap_.empty()) {
623 ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
624 updates_pending_swap_.pop_front();
625 // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
626 // compositing pass, hence doesn't require an UpdateRect message.
627 if (msg)
628 Send(msg);
629 }
[email protected]65225772011-05-12 21:10:24630 num_swapbuffers_complete_pending_ = 0;
631 using_asynchronous_swapbuffers_ = false;
632 // Schedule another frame so the compositor learns about it.
633 scheduleComposite();
634}
635
[email protected]ed7defa2013-03-12 21:29:59636void RenderWidget::OnViewContextSwapBuffersPosted() {
[email protected]37a6f302011-07-11 23:43:08637 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
[email protected]aa4117f2011-12-09 22:19:21638
639 if (using_asynchronous_swapbuffers_) {
640 ViewHostMsg_UpdateRect* msg = NULL;
641 // pending_update_params_ can be NULL if the swap doesn't correspond to an
642 // DoDeferredUpdate compositing pass, hence doesn't require an UpdateRect
643 // message.
[email protected]59383c782013-04-17 16:43:27644 if (pending_update_params_) {
[email protected]aa4117f2011-12-09 22:19:21645 msg = new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_);
646 pending_update_params_.reset();
647 }
648 updates_pending_swap_.push_back(msg);
[email protected]37a6f302011-07-11 23:43:08649 num_swapbuffers_complete_pending_++;
[email protected]aa4117f2011-12-09 22:19:21650 }
[email protected]37a6f302011-07-11 23:43:08651}
652
[email protected]ed7defa2013-03-12 21:29:59653void RenderWidget::OnViewContextSwapBuffersComplete() {
[email protected]65225772011-05-12 21:10:24654 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersComplete");
[email protected]29ed96a2012-02-04 18:12:16655
[email protected]404939f2012-06-01 04:06:18656 // Notify subclasses that composited rendering was flushed to the screen.
[email protected]29ed96a2012-02-04 18:12:16657 DidFlushPaint();
658
[email protected]65225772011-05-12 21:10:24659 // When compositing deactivates, we reset the swapbuffers pending count. The
660 // swapbuffers acks may still arrive, however.
661 if (num_swapbuffers_complete_pending_ == 0) {
662 TRACE_EVENT0("renderer", "EarlyOut_ZeroSwapbuffersPending");
663 return;
664 }
[email protected]aa4117f2011-12-09 22:19:21665 DCHECK(!updates_pending_swap_.empty());
666 ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
667 updates_pending_swap_.pop_front();
668 // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
669 // compositing pass, hence doesn't require an UpdateRect message.
670 if (msg)
671 Send(msg);
[email protected]65225772011-05-12 21:10:24672 num_swapbuffers_complete_pending_--;
673
674 // If update reply is still pending, then defer the update until that reply
675 // occurs.
[email protected]d0be63772011-12-20 23:18:04676 if (update_reply_pending_) {
[email protected]65225772011-05-12 21:10:24677 TRACE_EVENT0("renderer", "EarlyOut_UpdateReplyPending");
678 return;
679 }
680
681 // If we are not accelerated rendering, then this is a stale swapbuffers from
[email protected]50312bf2011-06-22 23:30:06682 // when we were previously rendering. However, if an invalidation task is not
683 // posted, there may be software rendering work pending. In that case, don't
684 // early out.
685 if (!is_accelerated_compositing_active_ && invalidation_task_posted_) {
[email protected]65225772011-05-12 21:10:24686 TRACE_EVENT0("renderer", "EarlyOut_AcceleratedCompositingOff");
687 return;
688 }
689
[email protected]cc66e682012-10-02 06:48:18690 // Do not call DoDeferredUpdate unless there's animation work to be done or
691 // a real invalidation. This prevents rendering in response to a swapbuffers
692 // callback coming back after we've navigated away from the page that
693 // generated it.
694 if (!animation_update_pending_ && !paint_aggregator_.HasPendingUpdate()) {
695 TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
696 return;
697 }
698
[email protected]65225772011-05-12 21:10:24699 // Continue painting if necessary...
700 DoDeferredUpdateAndSendInputAck();
initial.commit09911bf2008-07-26 23:55:29701}
702
[email protected]0dea1652012-12-14 00:09:09703void RenderWidget::OnHandleInputEvent(const WebKit::WebInputEvent* input_event,
704 bool is_keyboard_shortcut) {
[email protected]65225772011-05-12 21:10:24705 TRACE_EVENT0("renderer", "RenderWidget::OnHandleInputEvent");
initial.commit09911bf2008-07-26 23:55:29706
[email protected]5dd768212009-08-13 23:34:49707 handling_input_event_ = true;
[email protected]0dea1652012-12-14 00:09:09708 if (!input_event) {
[email protected]5dd768212009-08-13 23:34:49709 handling_input_event_ = false;
initial.commit09911bf2008-07-26 23:55:29710 return;
[email protected]5dd768212009-08-13 23:34:49711 }
initial.commit09911bf2008-07-26 23:55:29712
[email protected]6a4d7f62013-01-07 21:32:13713 base::TimeDelta now = base::TimeDelta::FromInternalValue(
714 base::TimeTicks::Now().ToInternalValue());
715
716 int64 delta = static_cast<int64>(
717 (now.InSecondsF() - input_event->timeStampSeconds) *
718 base::Time::kMicrosecondsPerSecond);
719 UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.Renderer", delta, 0, 1000000, 100);
720 std::string name_for_event =
721 base::StringPrintf("Event.Latency.Renderer.%s",
722 GetEventName(input_event->type));
[email protected]de415552013-01-23 04:12:17723 base::HistogramBase* counter_for_type =
[email protected]bafdc5d52013-02-27 18:18:48724 base::Histogram::FactoryGet(
[email protected]6a4d7f62013-01-07 21:32:13725 name_for_event,
[email protected]bafdc5d52013-02-27 18:18:48726 0,
727 1000000,
[email protected]6a4d7f62013-01-07 21:32:13728 100,
[email protected]de415552013-01-23 04:12:17729 base::HistogramBase::kUmaTargetedHistogramFlag);
[email protected]bafdc5d52013-02-27 18:18:48730 counter_for_type->Add(delta);
[email protected]6a4d7f62013-01-07 21:32:13731
[email protected]67bfb83f2011-09-22 03:36:37732 bool prevent_default = false;
733 if (WebInputEvent::isMouseEventType(input_event->type)) {
[email protected]936c6f52011-12-13 01:35:26734 const WebMouseEvent& mouse_event =
735 *static_cast<const WebMouseEvent*>(input_event);
736 TRACE_EVENT2("renderer", "HandleMouseMove",
737 "x", mouse_event.x, "y", mouse_event.y);
738 prevent_default = WillHandleMouseEvent(mouse_event);
[email protected]67bfb83f2011-09-22 03:36:37739 }
740
[email protected]41d86852012-11-07 12:23:24741 if (WebInputEvent::isGestureEventType(input_event->type)) {
742 const WebGestureEvent& gesture_event =
743 *static_cast<const WebGestureEvent*>(input_event);
744 prevent_default = prevent_default || WillHandleGestureEvent(gesture_event);
745 }
746
[email protected]3ebcc7c2013-01-09 05:34:46747 if (input_event->type == WebInputEvent::GestureTap ||
748 input_event->type == WebInputEvent::GestureLongPress)
749 resetInputMethod();
750
[email protected]67bfb83f2011-09-22 03:36:37751 bool processed = prevent_default;
[email protected]b68a0e52011-12-08 15:11:12752 if (input_event->type != WebInputEvent::Char || !suppress_next_char_events_) {
753 suppress_next_char_events_ = false;
754 if (!processed && webwidget_)
755 processed = webwidget_->handleInputEvent(*input_event);
756 }
757
758 // If this RawKeyDown event corresponds to a browser keyboard shortcut and
759 // it's not processed by webkit, then we need to suppress the upcoming Char
760 // events.
761 if (!processed && is_keyboard_shortcut)
762 suppress_next_char_events_ = true;
initial.commit09911bf2008-07-26 23:55:29763
[email protected]3d5c243b2012-11-30 00:26:01764 InputEventAckState ack_result = processed ?
765 INPUT_EVENT_ACK_STATE_CONSUMED : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
766 if (!processed && input_event->type == WebInputEvent::TouchStart) {
767 const WebTouchEvent& touch_event =
768 *static_cast<const WebTouchEvent*>(input_event);
769 ack_result = HasTouchEventHandlersAt(touch_event.touches[0].position) ?
770 INPUT_EVENT_ACK_STATE_NOT_CONSUMED :
771 INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
772 }
773
[email protected]a9fb30aa2011-10-06 06:58:46774 IPC::Message* response =
[email protected]c084330e02013-04-27 01:08:15775 new InputHostMsg_HandleInputEvent_ACK(routing_id_, input_event->type,
776 ack_result);
[email protected]3391a0772012-03-28 00:32:07777 bool event_type_gets_rate_limited =
778 input_event->type == WebInputEvent::MouseMove ||
779 input_event->type == WebInputEvent::MouseWheel ||
780 WebInputEvent::isTouchEventType(input_event->type);
[email protected]8926c602013-01-23 05:32:06781
782 bool frame_pending = paint_aggregator_.HasPendingUpdate();
783 if (is_accelerated_compositing_active_) {
[email protected]ba91a792013-02-06 09:48:28784 frame_pending = compositor_ &&
785 compositor_->commitRequested();
[email protected]8926c602013-01-23 05:32:06786 }
787
[email protected]3391a0772012-03-28 00:32:07788 bool is_input_throttled =
[email protected]ce2b28e2012-08-09 15:53:57789 throttle_input_events_ &&
[email protected]8926c602013-01-23 05:32:06790 frame_pending;
[email protected]e2824412009-02-27 01:57:05791
[email protected]f8868d72012-04-27 19:13:03792 if (event_type_gets_rate_limited && is_input_throttled && !is_hidden_) {
[email protected]12fbad812009-09-01 18:21:24793 // We want to rate limit the input events in this case, so we'll wait for
794 // painting to finish before ACKing this message.
[email protected]59383c782013-04-17 16:43:27795 if (pending_input_event_ack_) {
[email protected]353a34c2010-05-28 23:35:17796 // As two different kinds of events could cause us to postpone an ack
797 // we send it now, if we have one pending. The Browser should never
798 // send us the same kind of event we are delaying the ack for.
799 Send(pending_input_event_ack_.release());
800 }
[email protected]12fbad812009-09-01 18:21:24801 pending_input_event_ack_.reset(response);
802 } else {
803 Send(response);
804 }
805
[email protected]3306f262012-09-21 19:20:42806#if defined(OS_ANDROID)
807 // Allow the IME to be shown when the focus changes as a consequence
808 // of a processed touch end event.
809 if (input_event->type == WebInputEvent::TouchEnd && processed)
810 UpdateTextInputState(SHOW_IME_IF_NEEDED);
811#endif
812
[email protected]5dd768212009-08-13 23:34:49813 handling_input_event_ = false;
[email protected]446705872009-09-10 07:22:48814
[email protected]67bfb83f2011-09-22 03:36:37815 if (!prevent_default) {
816 if (WebInputEvent::isKeyboardEventType(input_event->type))
817 DidHandleKeyEvent();
818 if (WebInputEvent::isMouseEventType(input_event->type))
819 DidHandleMouseEvent(*(static_cast<const WebMouseEvent*>(input_event)));
[email protected]2d0f2e92011-10-03 09:02:24820 if (WebInputEvent::isTouchEventType(input_event->type))
821 DidHandleTouchEvent(*(static_cast<const WebTouchEvent*>(input_event)));
[email protected]67bfb83f2011-09-22 03:36:37822 }
initial.commit09911bf2008-07-26 23:55:29823}
824
[email protected]34202de2013-05-06 23:36:22825void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
826 if (webwidget_)
827 webwidget_->setCursorVisibilityState(is_visible);
828}
829
initial.commit09911bf2008-07-26 23:55:29830void RenderWidget::OnMouseCaptureLost() {
831 if (webwidget_)
[email protected]4873c7d2009-07-16 06:36:28832 webwidget_->mouseCaptureLost();
initial.commit09911bf2008-07-26 23:55:29833}
834
835void RenderWidget::OnSetFocus(bool enable) {
836 has_focus_ = enable;
[email protected]9d166af2010-03-02 22:04:33837 if (webwidget_)
838 webwidget_->setFocus(enable);
initial.commit09911bf2008-07-26 23:55:29839}
840
841void RenderWidget::ClearFocus() {
842 // We may have got the focus from the browser before this gets processed, in
843 // which case we do not want to unfocus ourself.
844 if (!has_focus_ && webwidget_)
[email protected]4873c7d2009-07-16 06:36:28845 webwidget_->setFocus(false);
initial.commit09911bf2008-07-26 23:55:29846}
847
[email protected]2d5d09d52009-06-15 14:29:21848void RenderWidget::PaintRect(const gfx::Rect& rect,
[email protected]4fb66842009-12-04 21:41:00849 const gfx::Point& canvas_origin,
[email protected]2d5d09d52009-06-15 14:29:21850 skia::PlatformCanvas* canvas) {
[email protected]50312bf2011-06-22 23:30:06851 TRACE_EVENT2("renderer", "PaintRect",
852 "width", rect.width(), "height", rect.height());
[email protected]63ab54262012-11-09 15:58:45853
854 const bool kEnableGpuBenchmarking =
855 CommandLine::ForCurrentProcess()->HasSwitch(
856 switches::kEnableGpuBenchmarking);
[email protected]4fb66842009-12-04 21:41:00857 canvas->save();
[email protected]2d5d09d52009-06-15 14:29:21858
859 // Bring the canvas into the coordinate system of the paint rect.
[email protected]4fb66842009-12-04 21:41:00860 canvas->translate(static_cast<SkScalar>(-canvas_origin.x()),
861 static_cast<SkScalar>(-canvas_origin.y()));
[email protected]96c3499a2009-05-02 18:31:03862
[email protected]699ab0d2009-04-23 23:19:14863 // If there is a custom background, tile it.
864 if (!background_.empty()) {
[email protected]699ab0d2009-04-23 23:19:14865 SkPaint paint;
[email protected]4e29afd2012-12-04 04:07:11866 skia::RefPtr<SkShader> shader = skia::AdoptRef(
867 SkShader::CreateBitmapShader(background_,
868 SkShader::kRepeat_TileMode,
869 SkShader::kRepeat_TileMode));
870 paint.setShader(shader.get());
[email protected]fb10ec5b2011-10-24 17:54:20871
872 // Use kSrc_Mode to handle background_ transparency properly.
873 paint.setXfermodeMode(SkXfermode::kSrc_Mode);
874
875 // Canvas could contain multiple update rects. Clip to given rect so that
876 // we don't accidentally clear other update rects.
877 canvas->save();
[email protected]aa7e7a12013-02-22 13:37:44878 canvas->scale(device_scale_factor_, device_scale_factor_);
[email protected]1835b9e2012-02-28 13:12:48879 canvas->clipRect(gfx::RectToSkRect(rect));
[email protected]699ab0d2009-04-23 23:19:14880 canvas->drawPaint(paint);
[email protected]fb10ec5b2011-10-24 17:54:20881 canvas->restore();
[email protected]699ab0d2009-04-23 23:19:14882 }
883
[email protected]719b36f2010-12-22 20:36:46884 // First see if this rect is a plugin that can paint itself faster.
885 TransportDIB* optimized_dib = NULL;
886 gfx::Rect optimized_copy_rect, optimized_copy_location;
[email protected]0f3a2d12012-09-01 03:37:20887 float dib_scale_factor;
[email protected]719b36f2010-12-22 20:36:46888 webkit::ppapi::PluginInstance* optimized_instance =
889 GetBitmapForOptimizedPluginPaint(rect, &optimized_dib,
890 &optimized_copy_location,
[email protected]0f3a2d12012-09-01 03:37:20891 &optimized_copy_rect,
892 &dib_scale_factor);
[email protected]719b36f2010-12-22 20:36:46893 if (optimized_instance) {
894 // This plugin can be optimize-painted and we can just ask it to paint
895 // itself. We don't actually need the TransportDIB in this case.
896 //
897 // This is an optimization for PPAPI plugins that know they're on top of
898 // the page content. If this rect is inside such a plugin, we can save some
899 // time and avoid re-rendering the page content which we know will be
900 // covered by the plugin later (this time can be significant, especially
901 // for a playing movie that is invalidating a lot).
902 //
903 // In the plugin movie case, hopefully the similar call to
904 // GetBitmapForOptimizedPluginPaint in DoDeferredUpdate handles the
905 // painting, because that avoids copying the plugin image to a different
906 // paint rect. Unfortunately, if anything on the page is animating other
907 // than the movie, it break this optimization since the union of the
908 // invalid regions will be larger than the plugin.
909 //
910 // This code optimizes that case, where we can still avoid painting in
911 // WebKit and filling the background (which can be slow) and just painting
912 // the plugin. Unlike the DoDeferredUpdate case, an extra copy is still
913 // required.
[email protected]63ab54262012-11-09 15:58:45914 base::TimeTicks paint_begin_ticks;
915 if (kEnableGpuBenchmarking)
916 paint_begin_ticks = base::TimeTicks::HighResNow();
917
[email protected]df59dd42012-09-14 22:56:30918 SkAutoCanvasRestore auto_restore(canvas, true);
919 canvas->scale(device_scale_factor_, device_scale_factor_);
[email protected]719b36f2010-12-22 20:36:46920 optimized_instance->Paint(webkit_glue::ToWebCanvas(canvas),
[email protected]2df1b362011-01-21 21:22:27921 optimized_copy_location, rect);
[email protected]ea43e752012-09-06 22:39:21922 canvas->restore();
[email protected]63ab54262012-11-09 15:58:45923 if (kEnableGpuBenchmarking) {
924 base::TimeDelta paint_time =
925 base::TimeTicks::HighResNow() - paint_begin_ticks;
926 if (!is_accelerated_compositing_active_)
[email protected]62049562013-03-24 00:39:01927 software_stats_.total_paint_time += paint_time;
[email protected]63ab54262012-11-09 15:58:45928 }
[email protected]719b36f2010-12-22 20:36:46929 } else {
930 // Normal painting case.
[email protected]63ab54262012-11-09 15:58:45931 base::TimeTicks paint_begin_ticks;
932 if (kEnableGpuBenchmarking)
933 paint_begin_ticks = base::TimeTicks::HighResNow();
934
[email protected]719b36f2010-12-22 20:36:46935 webwidget_->paint(webkit_glue::ToWebCanvas(canvas), rect);
[email protected]63ab54262012-11-09 15:58:45936
937 if (kEnableGpuBenchmarking) {
938 base::TimeDelta paint_time =
939 base::TimeTicks::HighResNow() - paint_begin_ticks;
940 if (!is_accelerated_compositing_active_)
[email protected]62049562013-03-24 00:39:01941 software_stats_.total_paint_time += paint_time;
[email protected]63ab54262012-11-09 15:58:45942 }
[email protected]719b36f2010-12-22 20:36:46943
944 // Flush to underlying bitmap. TODO(darin): is this needed?
[email protected]62f2e802011-05-26 14:28:35945 skia::GetTopDevice(*canvas)->accessBitmap(false);
[email protected]719b36f2010-12-22 20:36:46946 }
initial.commit09911bf2008-07-26 23:55:29947
[email protected]4fb66842009-12-04 21:41:00948 PaintDebugBorder(rect, canvas);
[email protected]4fb66842009-12-04 21:41:00949 canvas->restore();
[email protected]63ab54262012-11-09 15:58:45950
951 if (kEnableGpuBenchmarking) {
[email protected]63ab54262012-11-09 15:58:45952 int64 num_pixels_processed = rect.width() * rect.height();
[email protected]62049562013-03-24 00:39:01953 software_stats_.total_pixels_painted += num_pixels_processed;
[email protected]63ab54262012-11-09 15:58:45954 }
[email protected]4fb66842009-12-04 21:41:00955}
956
957void RenderWidget::PaintDebugBorder(const gfx::Rect& rect,
958 skia::PlatformCanvas* canvas) {
959 static bool kPaintBorder =
960 CommandLine::ForCurrentProcess()->HasSwitch(switches::kShowPaintRects);
961 if (!kPaintBorder)
962 return;
963
[email protected]53d3f302009-12-21 04:42:05964 // Cycle through these colors to help distinguish new paint rects.
965 const SkColor colors[] = {
966 SkColorSetARGB(0x3F, 0xFF, 0, 0),
967 SkColorSetARGB(0x3F, 0xFF, 0, 0xFF),
968 SkColorSetARGB(0x3F, 0, 0, 0xFF),
969 };
970 static int color_selector = 0;
971
[email protected]4fb66842009-12-04 21:41:00972 SkPaint paint;
973 paint.setStyle(SkPaint::kStroke_Style);
[email protected]53d3f302009-12-21 04:42:05974 paint.setColor(colors[color_selector++ % arraysize(colors)]);
[email protected]4fb66842009-12-04 21:41:00975 paint.setStrokeWidth(1);
976
977 SkIRect irect;
978 irect.set(rect.x(), rect.y(), rect.right() - 1, rect.bottom() - 1);
979 canvas->drawIRect(irect, paint);
initial.commit09911bf2008-07-26 23:55:29980}
981
[email protected]52ccd0ea2011-02-16 01:09:05982void RenderWidget::AnimationCallback() {
[email protected]921244e42011-07-20 16:36:30983 TRACE_EVENT0("renderer", "RenderWidget::AnimationCallback");
[email protected]921244e42011-07-20 16:36:30984 if (!animation_update_pending_) {
985 TRACE_EVENT0("renderer", "EarlyOut_NoAnimationUpdatePending");
[email protected]7c4329e2011-02-18 22:02:59986 return;
[email protected]921244e42011-07-20 16:36:30987 }
[email protected]bd37ae252011-06-03 01:28:18988 if (!animation_floor_time_.is_null() && IsRenderingVSynced()) {
[email protected]7c4329e2011-02-18 22:02:59989 // Record when we fired (according to base::Time::Now()) relative to when
990 // we posted the task to quantify how much the base::Time/base::TimeTicks
991 // skew is affecting animations.
992 base::TimeDelta animation_callback_delay = base::Time::Now() -
993 (animation_floor_time_ - base::TimeDelta::FromMilliseconds(16));
994 UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.AnimationCallbackDelayTime",
995 animation_callback_delay,
996 base::TimeDelta::FromMilliseconds(0),
997 base::TimeDelta::FromMilliseconds(30),
998 25);
999 }
[email protected]65225772011-05-12 21:10:241000 DoDeferredUpdateAndSendInputAck();
[email protected]12fbad812009-09-01 18:21:241001}
1002
[email protected]52ccd0ea2011-02-16 01:09:051003void RenderWidget::AnimateIfNeeded() {
[email protected]7c4329e2011-02-18 22:02:591004 if (!animation_update_pending_)
1005 return;
[email protected]bd37ae252011-06-03 01:28:181006
1007 // Target 60FPS if vsync is on. Go as fast as we can if vsync is off.
[email protected]02798a982012-01-27 00:45:331008 base::TimeDelta animationInterval = IsRenderingVSynced() ?
1009 base::TimeDelta::FromMilliseconds(16) : base::TimeDelta();
[email protected]bd37ae252011-06-03 01:28:181010
[email protected]7c4329e2011-02-18 22:02:591011 base::Time now = base::Time::Now();
[email protected]51e403bb2012-03-02 21:09:451012
1013 // animation_floor_time_ is the earliest time that we should animate when
1014 // using the dead reckoning software scheduler. If we're using swapbuffers
1015 // complete callbacks to rate limit, we can ignore this floor.
1016 if (now >= animation_floor_time_ || num_swapbuffers_complete_pending_ > 0) {
[email protected]921244e42011-07-20 16:36:301017 TRACE_EVENT0("renderer", "RenderWidget::AnimateIfNeeded")
[email protected]02798a982012-01-27 00:45:331018 animation_floor_time_ = now + animationInterval;
[email protected]bd37ae252011-06-03 01:28:181019 // Set a timer to call us back after animationInterval before
[email protected]7c4329e2011-02-18 22:02:591020 // running animation callbacks so that if a callback requests another
1021 // we'll be sure to run it at the proper time.
[email protected]350ce8702012-03-09 04:23:381022 animation_timer_.Stop();
1023 animation_timer_.Start(FROM_HERE, animationInterval, this,
1024 &RenderWidget::AnimationCallback);
[email protected]7c4329e2011-02-18 22:02:591025 animation_update_pending_ = false;
[email protected]ba91a792013-02-06 09:48:281026 if (is_accelerated_compositing_active_ && compositor_) {
[email protected]635353c2013-03-06 09:11:201027 compositor_->Animate(base::TimeTicks::Now());
[email protected]8926c602013-01-23 05:32:061028 } else {
[email protected]635353c2013-03-06 09:11:201029 double frame_begin_time =
1030 (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
1031 webwidget_->animate(frame_begin_time);
[email protected]8926c602013-01-23 05:32:061032 }
[email protected]7c4329e2011-02-18 22:02:591033 return;
[email protected]5f8b1022011-01-21 23:34:501034 }
[email protected]bd37ae252011-06-03 01:28:181035 TRACE_EVENT0("renderer", "EarlyOut_AnimatedTooRecently");
[email protected]350ce8702012-03-09 04:23:381036 if (!animation_timer_.IsRunning()) {
1037 // This code uses base::Time::Now() to calculate the floor and next fire
1038 // time because javascript's Date object uses base::Time::Now(). The
1039 // message loop uses base::TimeTicks, which on windows can have a
1040 // different granularity than base::Time.
1041 // The upshot of all this is that this function might be called before
1042 // base::Time::Now() has advanced past the animation_floor_time_. To
1043 // avoid exposing this delay to javascript, we keep posting delayed
1044 // tasks until base::Time::Now() has advanced far enough.
1045 base::TimeDelta delay = animation_floor_time_ - now;
1046 animation_timer_.Start(FROM_HERE, delay, this,
1047 &RenderWidget::AnimationCallback);
1048 }
[email protected]5f8b1022011-01-21 23:34:501049}
1050
[email protected]bd37ae252011-06-03 01:28:181051bool RenderWidget::IsRenderingVSynced() {
1052 // TODO(nduca): Forcing a driver to disable vsync (e.g. in a control panel) is
1053 // not caught by this check. This will lead to artificially low frame rates
1054 // for people who force vsync off at a driver level and expect Chrome to speed
1055 // up.
1056 return !has_disable_gpu_vsync_switch_;
1057}
1058
[email protected]65225772011-05-12 21:10:241059void RenderWidget::InvalidationCallback() {
[email protected]50312bf2011-06-22 23:30:061060 TRACE_EVENT0("renderer", "RenderWidget::InvalidationCallback");
[email protected]65225772011-05-12 21:10:241061 invalidation_task_posted_ = false;
1062 DoDeferredUpdateAndSendInputAck();
1063}
1064
1065void RenderWidget::DoDeferredUpdateAndSendInputAck() {
[email protected]52ccd0ea2011-02-16 01:09:051066 DoDeferredUpdate();
1067
[email protected]59383c782013-04-17 16:43:271068 if (pending_input_event_ack_)
[email protected]52ccd0ea2011-02-16 01:09:051069 Send(pending_input_event_ack_.release());
[email protected]ee3d3ad2011-02-04 00:42:211070}
1071
[email protected]552e6002009-11-19 05:24:571072void RenderWidget::DoDeferredUpdate() {
[email protected]366ae242011-05-10 02:23:581073 TRACE_EVENT0("renderer", "RenderWidget::DoDeferredUpdate");
[email protected]71e2f0a2011-03-15 22:25:081074
[email protected]65225772011-05-12 21:10:241075 if (!webwidget_)
initial.commit09911bf2008-07-26 23:55:291076 return;
[email protected]05a980d7a2012-02-07 22:16:421077
[email protected]fc4404d2012-11-07 19:53:301078 if (!init_complete_) {
1079 TRACE_EVENT0("renderer", "EarlyOut_InitNotComplete");
[email protected]05a980d7a2012-02-07 22:16:421080 return;
1081 }
[email protected]aa4117f2011-12-09 22:19:211082 if (update_reply_pending_) {
[email protected]65225772011-05-12 21:10:241083 TRACE_EVENT0("renderer", "EarlyOut_UpdateReplyPending");
1084 return;
1085 }
[email protected]9ca84622011-06-02 23:46:391086 if (is_accelerated_compositing_active_ &&
1087 num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending) {
[email protected]65225772011-05-12 21:10:241088 TRACE_EVENT0("renderer", "EarlyOut_MaxSwapBuffersPending");
1089 return;
1090 }
initial.commit09911bf2008-07-26 23:55:291091
[email protected]552e6002009-11-19 05:24:571092 // Suppress updating when we are hidden.
[email protected]e3d92a7f2013-01-10 02:35:051093 if (is_hidden_ || size_.IsEmpty() || is_swapped_out_) {
[email protected]552e6002009-11-19 05:24:571094 paint_aggregator_.ClearPendingUpdate();
initial.commit09911bf2008-07-26 23:55:291095 needs_repainting_on_restore_ = true;
[email protected]65225772011-05-12 21:10:241096 TRACE_EVENT0("renderer", "EarlyOut_NotVisible");
initial.commit09911bf2008-07-26 23:55:291097 return;
1098 }
1099
[email protected]05a980d7a2012-02-07 22:16:421100 if (is_accelerated_compositing_active_)
1101 using_asynchronous_swapbuffers_ = SupportsAsynchronousSwapBuffers();
1102
[email protected]0fb93f52011-05-18 23:13:561103 // Tracking of frame rate jitter
1104 base::TimeTicks frame_begin_ticks = base::TimeTicks::Now();
[email protected]38ce4e7b2013-02-23 06:17:371105 InstrumentWillBeginFrame();
[email protected]52ccd0ea2011-02-16 01:09:051106 AnimateIfNeeded();
[email protected]5f8b1022011-01-21 23:34:501107
[email protected]f98d7e3c2010-09-13 22:30:461108 // Layout may generate more invalidation. It may also enable the
1109 // GPU acceleration, so make sure to run layout before we send the
1110 // GpuRenderingActivated message.
1111 webwidget_->layout();
1112
[email protected]dcca3aa92012-02-17 23:03:371113 // The following two can result in further layout and possibly
1114 // enable GPU acceleration so they need to be called before any painting
1115 // is done.
[email protected]3306f262012-09-21 19:20:421116 UpdateTextInputState(DO_NOT_SHOW_IME);
[email protected]dcca3aa92012-02-17 23:03:371117 UpdateSelectionBounds();
1118
[email protected]5f8b1022011-01-21 23:34:501119 // Suppress painting if nothing is dirty. This has to be done after updating
1120 // animations running layout as these may generate further invalidations.
[email protected]65225772011-05-12 21:10:241121 if (!paint_aggregator_.HasPendingUpdate()) {
1122 TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
[email protected]38ce4e7b2013-02-23 06:17:371123 InstrumentDidCancelFrame();
[email protected]5f8b1022011-01-21 23:34:501124 return;
[email protected]65225772011-05-12 21:10:241125 }
[email protected]5f8b1022011-01-21 23:34:501126
[email protected]479b0172012-10-29 19:27:091127 if (!is_accelerated_compositing_active_ &&
[email protected]cb6430932012-10-31 00:53:361128 !is_threaded_compositing_enabled_ &&
[email protected]479b0172012-10-29 19:27:091129 ForceCompositingModeEnabled()) {
1130 webwidget_->enterForceCompositingMode(true);
1131 }
1132
[email protected]872ae5b2011-05-26 20:20:501133 if (!last_do_deferred_update_time_.is_null()) {
[email protected]0fb93f52011-05-18 23:13:561134 base::TimeDelta delay = frame_begin_ticks - last_do_deferred_update_time_;
[email protected]d0be63772011-12-20 23:18:041135 if (is_accelerated_compositing_active_) {
[email protected]0fb93f52011-05-18 23:13:561136 UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.AccelDoDeferredUpdateDelay",
1137 delay,
1138 base::TimeDelta::FromMilliseconds(1),
[email protected]b604cf82012-07-19 05:31:411139 base::TimeDelta::FromMilliseconds(120),
1140 60);
[email protected]d0be63772011-12-20 23:18:041141 } else {
[email protected]0fb93f52011-05-18 23:13:561142 UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.SoftwareDoDeferredUpdateDelay",
1143 delay,
1144 base::TimeDelta::FromMilliseconds(1),
[email protected]b604cf82012-07-19 05:31:411145 base::TimeDelta::FromMilliseconds(120),
1146 60);
[email protected]d0be63772011-12-20 23:18:041147 }
[email protected]872ae5b2011-05-26 20:20:501148
1149 // Calculate filtered time per frame:
1150 float frame_time_elapsed = static_cast<float>(delay.InSecondsF());
1151 filtered_time_per_frame_ =
1152 0.9f * filtered_time_per_frame_ + 0.1f * frame_time_elapsed;
[email protected]0fb93f52011-05-18 23:13:561153 }
1154 last_do_deferred_update_time_ = frame_begin_ticks;
1155
[email protected]fef5e3972012-08-07 03:59:471156 if (!is_accelerated_compositing_active_) {
[email protected]62049562013-03-24 00:39:011157 software_stats_.animation_frame_count++;
1158 software_stats_.screen_frame_count++;
[email protected]fef5e3972012-08-07 03:59:471159 }
1160
[email protected]552e6002009-11-19 05:24:571161 // OK, save the pending update to a local since painting may cause more
initial.commit09911bf2008-07-26 23:55:291162 // invalidation. Some WebCore rendering objects only layout when painted.
[email protected]dd015812010-12-06 23:39:301163 PaintAggregator::PendingUpdate update;
1164 paint_aggregator_.PopPendingUpdate(&update);
initial.commit09911bf2008-07-26 23:55:291165
[email protected]53d3f302009-12-21 04:42:051166 gfx::Rect scroll_damage = update.GetScrollDamage();
[email protected]ce112fe2012-10-29 22:52:181167 gfx::Rect bounds = gfx::UnionRects(update.GetPaintBounds(), scroll_damage);
initial.commit09911bf2008-07-26 23:55:291168
[email protected]29ed96a2012-02-04 18:12:161169 // Notify derived classes that we're about to initiate a paint.
1170 WillInitiatePaint();
1171
[email protected]ca4847f2010-09-24 05:39:151172 // A plugin may be able to do an optimized paint. First check this, in which
1173 // case we can skip all of the bitmap generation and regular paint code.
[email protected]719b36f2010-12-22 20:36:461174 // This optimization allows PPAPI plugins that declare themselves on top of
1175 // the page (like a traditional windowed plugin) to be able to animate (think
1176 // movie playing) without repeatedly re-painting the page underneath, or
1177 // copying the plugin backing store (since we can send the plugin's backing
1178 // store directly to the browser).
1179 //
1180 // This optimization only works when the entire invalid region is contained
1181 // within the plugin. There is a related optimization in PaintRect for the
1182 // case where there may be multiple invalid regions.
[email protected]ca4847f2010-09-24 05:39:151183 TransportDIB* dib = NULL;
[email protected]ca4847f2010-09-24 05:39:151184 gfx::Rect optimized_copy_rect, optimized_copy_location;
[email protected]0f3a2d12012-09-01 03:37:201185 float dib_scale_factor = 1;
[email protected]aa4117f2011-12-09 22:19:211186 DCHECK(!pending_update_params_.get());
1187 pending_update_params_.reset(new ViewHostMsg_UpdateRect_Params);
[email protected]990278ff2012-11-13 02:12:551188 pending_update_params_->scroll_delta = update.scroll_delta;
[email protected]aa4117f2011-12-09 22:19:211189 pending_update_params_->scroll_rect = update.scroll_rect;
1190 pending_update_params_->view_size = size_;
[email protected]aa4117f2011-12-09 22:19:211191 pending_update_params_->plugin_window_moves.swap(plugin_window_moves_);
1192 pending_update_params_->flags = next_paint_flags_;
1193 pending_update_params_->scroll_offset = GetScrollOffset();
1194 pending_update_params_->needs_ack = true;
[email protected]7ded9f12012-06-13 20:47:091195 pending_update_params_->scale_factor = device_scale_factor_;
[email protected]aa4117f2011-12-09 22:19:211196 next_paint_flags_ = 0;
[email protected]ea3ee0a2012-05-15 03:43:091197 need_update_rect_for_auto_resize_ = false;
[email protected]aa4117f2011-12-09 22:19:211198
[email protected]ca4847f2010-09-24 05:39:151199 if (update.scroll_rect.IsEmpty() &&
[email protected]a79d8a632010-11-18 22:35:561200 !is_accelerated_compositing_active_ &&
[email protected]ca4847f2010-09-24 05:39:151201 GetBitmapForOptimizedPluginPaint(bounds, &dib, &optimized_copy_location,
[email protected]0f3a2d12012-09-01 03:37:201202 &optimized_copy_rect,
1203 &dib_scale_factor)) {
[email protected]2df1b362011-01-21 21:22:271204 // Only update the part of the plugin that actually changed.
[email protected]d4030502012-10-23 16:51:471205 optimized_copy_rect.Intersect(bounds);
[email protected]aa4117f2011-12-09 22:19:211206 pending_update_params_->bitmap = dib->id();
1207 pending_update_params_->bitmap_rect = optimized_copy_location;
1208 pending_update_params_->copy_rects.push_back(optimized_copy_rect);
[email protected]0f3a2d12012-09-01 03:37:201209 pending_update_params_->scale_factor = dib_scale_factor;
[email protected]a79d8a632010-11-18 22:35:561210 } else if (!is_accelerated_compositing_active_) {
[email protected]f98d7e3c2010-09-13 22:30:461211 // Compute a buffer for painting and cache it.
[email protected]4889bd212013-02-11 22:23:101212
1213 bool fractional_scale = device_scale_factor_ -
1214 static_cast<int>(device_scale_factor_) != 0;
1215 if (fractional_scale) {
1216 // Damage might not be DIP aligned. Inflate damage to compensate.
1217 bounds.Inset(-1, -1);
1218 bounds.Intersect(gfx::Rect(size_));
1219 }
1220
1221 gfx::Rect pixel_bounds = gfx::ToEnclosingRect(
[email protected]ce112fe2012-10-29 22:52:181222 gfx::ScaleRect(bounds, device_scale_factor_));
[email protected]4889bd212013-02-11 22:23:101223
[email protected]ca4847f2010-09-24 05:39:151224 scoped_ptr<skia::PlatformCanvas> canvas(
[email protected]b4d08452010-10-05 17:34:351225 RenderProcess::current()->GetDrawingCanvas(&current_paint_buf_,
[email protected]f1cccb32012-06-06 18:29:591226 pixel_bounds));
[email protected]59383c782013-04-17 16:43:271227 if (!canvas) {
[email protected]f98d7e3c2010-09-13 22:30:461228 NOTREACHED();
1229 return;
1230 }
[email protected]cef3362f2009-12-21 17:48:451231
[email protected]f98d7e3c2010-09-13 22:30:461232 // We may get back a smaller canvas than we asked for.
1233 // TODO(darin): This seems like it could cause painting problems!
[email protected]f1cccb32012-06-06 18:29:591234 DCHECK_EQ(pixel_bounds.width(), canvas->getDevice()->width());
1235 DCHECK_EQ(pixel_bounds.height(), canvas->getDevice()->height());
1236 pixel_bounds.set_width(canvas->getDevice()->width());
1237 pixel_bounds.set_height(canvas->getDevice()->height());
1238 bounds.set_width(pixel_bounds.width() / device_scale_factor_);
1239 bounds.set_height(pixel_bounds.height() / device_scale_factor_);
[email protected]53d3f302009-12-21 04:42:051240
[email protected]f98d7e3c2010-09-13 22:30:461241 HISTOGRAM_COUNTS_100("MPArch.RW_PaintRectCount", update.paint_rects.size());
1242
[email protected]aa4117f2011-12-09 22:19:211243 pending_update_params_->bitmap = current_paint_buf_->id();
1244 pending_update_params_->bitmap_rect = bounds;
1245
1246 std::vector<gfx::Rect>& copy_rects = pending_update_params_->copy_rects;
[email protected]f98d7e3c2010-09-13 22:30:461247 // The scroll damage is just another rectangle to paint and copy.
1248 copy_rects.swap(update.paint_rects);
1249 if (!scroll_damage.IsEmpty())
1250 copy_rects.push_back(scroll_damage);
1251
[email protected]4889bd212013-02-11 22:23:101252 for (size_t i = 0; i < copy_rects.size(); ++i) {
1253 gfx::Rect rect = copy_rects[i];
1254 if (fractional_scale) {
1255 // Damage might not be DPI aligned. Inflate rect to compensate.
1256 rect.Inset(-1, -1);
1257 }
1258 PaintRect(rect, pixel_bounds.origin(), canvas.get());
1259 }
[email protected]60a50072012-01-11 02:05:351260
1261 // Software FPS tick for performance tests. The accelerated path traces the
1262 // frame events in didCommitAndDrawCompositorFrame. See throughput_tests.cc.
1263 // NOTE: Tests may break if this event is renamed or moved.
[email protected]c76faea2013-03-26 07:42:421264 UNSHIPPED_TRACE_EVENT_INSTANT0("test_fps", "TestFrameTickSW",
1265 TRACE_EVENT_SCOPE_THREAD);
[email protected]f98d7e3c2010-09-13 22:30:461266 } else { // Accelerated compositing path
1267 // Begin painting.
[email protected]aa4117f2011-12-09 22:19:211268 // If painting is done via the gpu process then we don't set any damage
1269 // rects to save the browser process from doing unecessary work.
1270 pending_update_params_->bitmap_rect = bounds;
1271 pending_update_params_->scroll_rect = gfx::Rect();
1272 // We don't need an ack, because we're not sharing a DIB with the browser.
1273 // If it needs to (e.g. composited UI), the GPU process does its own ACK
1274 // with the browser for the GPU surface.
1275 pending_update_params_->needs_ack = false;
[email protected]f0c2a242013-03-15 19:34:521276 Composite(frame_begin_ticks);
[email protected]f98d7e3c2010-09-13 22:30:461277 }
1278
[email protected]936c6f52011-12-13 01:35:261279 // If we're holding a pending input event ACK, send the ACK before sending the
1280 // UpdateReply message so we can receive another input event before the
1281 // UpdateRect_ACK on platforms where the UpdateRect_ACK is sent from within
1282 // the UpdateRect IPC message handler.
[email protected]59383c782013-04-17 16:43:271283 if (pending_input_event_ack_)
[email protected]936c6f52011-12-13 01:35:261284 Send(pending_input_event_ack_.release());
1285
[email protected]ab543072013-01-25 04:38:151286 // If Composite() called SwapBuffers, pending_update_params_ will be reset (in
[email protected]aa4117f2011-12-09 22:19:211287 // OnSwapBuffersPosted), meaning a message has been added to the
1288 // updates_pending_swap_ queue, that will be sent later. Otherwise, we send
1289 // the message now.
[email protected]59383c782013-04-17 16:43:271290 if (pending_update_params_) {
[email protected]aa4117f2011-12-09 22:19:211291 // sending an ack to browser process that the paint is complete...
1292 update_reply_pending_ = pending_update_params_->needs_ack;
1293 Send(new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_));
1294 pending_update_params_.reset();
[email protected]b167ca662010-05-14 00:05:341295 }
[email protected]53d3f302009-12-21 04:42:051296
[email protected]29ed96a2012-02-04 18:12:161297 // If we're software rendering then we're done initiating the paint.
1298 if (!is_accelerated_compositing_active_)
1299 DidInitiatePaint();
initial.commit09911bf2008-07-26 23:55:291300}
1301
[email protected]f0c2a242013-03-15 19:34:521302void RenderWidget::Composite(base::TimeTicks frame_begin_time) {
[email protected]ab543072013-01-25 04:38:151303 DCHECK(is_accelerated_compositing_active_);
[email protected]ba91a792013-02-06 09:48:281304 if (compositor_) // TODO(jamesr): Figure out how this can be null.
[email protected]f0c2a242013-03-15 19:34:521305 compositor_->Composite(frame_begin_time);
[email protected]ab543072013-01-25 04:38:151306}
1307
initial.commit09911bf2008-07-26 23:55:291308///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461309// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291310
[email protected]4873c7d2009-07-16 06:36:281311void RenderWidget::didInvalidateRect(const WebRect& rect) {
[email protected]479b0172012-10-29 19:27:091312 TRACE_EVENT2("renderer", "RenderWidget::didInvalidateRect",
1313 "width", rect.width, "height", rect.height);
[email protected]552e6002009-11-19 05:24:571314 // The invalidated rect might be outside the bounds of the view.
[email protected]ee8d6fd2010-05-26 17:05:481315 gfx::Rect view_rect(size_);
[email protected]ce112fe2012-10-29 22:52:181316 gfx::Rect damaged_rect = gfx::IntersectRects(view_rect, rect);
[email protected]552e6002009-11-19 05:24:571317 if (damaged_rect.IsEmpty())
initial.commit09911bf2008-07-26 23:55:291318 return;
1319
[email protected]552e6002009-11-19 05:24:571320 paint_aggregator_.InvalidateRect(damaged_rect);
1321
1322 // We may not need to schedule another call to DoDeferredUpdate.
[email protected]65225772011-05-12 21:10:241323 if (invalidation_task_posted_)
[email protected]552e6002009-11-19 05:24:571324 return;
1325 if (!paint_aggregator_.HasPendingUpdate())
1326 return;
[email protected]aa4117f2011-12-09 22:19:211327 if (update_reply_pending_ ||
[email protected]65225772011-05-12 21:10:241328 num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending)
1329 return;
1330
1331 // When GPU rendering, combine pending animations and invalidations into
1332 // a single update.
[email protected]816edc62012-03-17 01:27:221333 if (is_accelerated_compositing_active_ &&
1334 animation_update_pending_ &&
1335 animation_timer_.IsRunning())
[email protected]552e6002009-11-19 05:24:571336 return;
1337
1338 // Perform updating asynchronously. This serves two purposes:
initial.commit09911bf2008-07-26 23:55:291339 // 1) Ensures that we call WebView::Paint without a bunch of other junk
1340 // on the call stack.
1341 // 2) Allows us to collect more damage rects before painting to help coalesce
1342 // the work that we will need to do.
[email protected]65225772011-05-12 21:10:241343 invalidation_task_posted_ = true;
[email protected]dd32b1272013-05-04 14:17:111344 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:211345 FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
initial.commit09911bf2008-07-26 23:55:291346}
1347
[email protected]990278ff2012-11-13 02:12:551348void RenderWidget::didScrollRect(int dx, int dy,
1349 const WebRect& clip_rect) {
[email protected]f98d7e3c2010-09-13 22:30:461350 // Drop scrolls on the floor when we are in compositing mode.
1351 // TODO(nduca): stop WebViewImpl from sending scrolls in the first place.
[email protected]a79d8a632010-11-18 22:35:561352 if (is_accelerated_compositing_active_)
[email protected]f98d7e3c2010-09-13 22:30:461353 return;
1354
[email protected]552e6002009-11-19 05:24:571355 // The scrolled rect might be outside the bounds of the view.
[email protected]ee8d6fd2010-05-26 17:05:481356 gfx::Rect view_rect(size_);
[email protected]ce112fe2012-10-29 22:52:181357 gfx::Rect damaged_rect = gfx::IntersectRects(view_rect, clip_rect);
[email protected]552e6002009-11-19 05:24:571358 if (damaged_rect.IsEmpty())
initial.commit09911bf2008-07-26 23:55:291359 return;
1360
[email protected]990278ff2012-11-13 02:12:551361 paint_aggregator_.ScrollRect(gfx::Vector2d(dx, dy), damaged_rect);
[email protected]552e6002009-11-19 05:24:571362
1363 // We may not need to schedule another call to DoDeferredUpdate.
[email protected]65225772011-05-12 21:10:241364 if (invalidation_task_posted_)
[email protected]552e6002009-11-19 05:24:571365 return;
1366 if (!paint_aggregator_.HasPendingUpdate())
1367 return;
[email protected]aa4117f2011-12-09 22:19:211368 if (update_reply_pending_ ||
[email protected]65225772011-05-12 21:10:241369 num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending)
1370 return;
1371
1372 // When GPU rendering, combine pending animations and invalidations into
1373 // a single update.
[email protected]816edc62012-03-17 01:27:221374 if (is_accelerated_compositing_active_ &&
1375 animation_update_pending_ &&
1376 animation_timer_.IsRunning())
[email protected]552e6002009-11-19 05:24:571377 return;
1378
1379 // Perform updating asynchronously. This serves two purposes:
1380 // 1) Ensures that we call WebView::Paint without a bunch of other junk
1381 // on the call stack.
1382 // 2) Allows us to collect more damage rects before painting to help coalesce
1383 // the work that we will need to do.
[email protected]65225772011-05-12 21:10:241384 invalidation_task_posted_ = true;
[email protected]dd32b1272013-05-04 14:17:111385 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:211386 FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
initial.commit09911bf2008-07-26 23:55:291387}
1388
[email protected]244ac1892011-12-02 17:04:471389void RenderWidget::didAutoResize(const WebSize& new_size) {
[email protected]ea3ee0a2012-05-15 03:43:091390 if (size_.width() != new_size.width || size_.height() != new_size.height) {
[email protected]8be1c582013-03-06 00:55:031391 if (RenderThreadImpl::current()->short_circuit_size_updates()) {
1392 setWindowRect(WebRect(rootWindowRect().x,
1393 rootWindowRect().y,
1394 new_size.width,
1395 new_size.height));
1396 } else {
[email protected]20fbfc22013-05-08 20:50:581397 size_ = new_size;
1398
1399 // If we don't clear PaintAggregator after changing autoResize state, then
1400 // we might end up in a situation where bitmap_rect is larger than the
1401 // view_size. By clearing PaintAggregator, we ensure that we don't end up
1402 // with invalid damage rects.
1403 paint_aggregator_.ClearPendingUpdate();
[email protected]8be1c582013-03-06 00:55:031404 }
[email protected]20fbfc22013-05-08 20:50:581405
1406 if (auto_resize_mode_)
1407 AutoResizeCompositor();
1408
1409 if (!RenderThreadImpl::current()->short_circuit_size_updates())
1410 need_update_rect_for_auto_resize_ = true;
[email protected]ea3ee0a2012-05-15 03:43:091411 }
[email protected]244ac1892011-12-02 17:04:471412}
1413
[email protected]3a1c8a8032013-03-18 22:35:321414void RenderWidget::AutoResizeCompositor() {
[email protected]97e1bf72013-03-06 14:06:051415 physical_backing_size_ = gfx::ToCeiledSize(gfx::ScaleSize(size_,
1416 device_scale_factor_));
1417 if (compositor_)
1418 compositor_->setViewportSize(size_, physical_backing_size_);
1419}
1420
[email protected]91acd1c2012-03-14 08:32:391421void RenderWidget::didActivateCompositor(int input_handler_identifier) {
[email protected]ea162f92011-10-04 23:08:221422 TRACE_EVENT0("gpu", "RenderWidget::didActivateCompositor");
1423
[email protected]c63b4d42012-04-26 01:01:071424#if !defined(OS_MACOSX)
[email protected]aa4117f2011-12-09 22:19:211425 if (!is_accelerated_compositing_active_) {
1426 // When not in accelerated compositing mode, in certain cases (e.g. waiting
1427 // for a resize or if no backing store) the RenderWidgetHost is blocking the
1428 // browser's UI thread for some time, waiting for an UpdateRect. If we are
1429 // going to switch to accelerated compositing, the GPU process may need
1430 // round-trips to the browser's UI thread before finishing the frame,
1431 // causing deadlocks if we delay the UpdateRect until we receive the
1432 // OnSwapBuffersComplete. So send a dummy message that will unblock the
[email protected]c63b4d42012-04-26 01:01:071433 // browser's UI thread. This is not necessary on Mac, because SwapBuffers
1434 // now unblocks GetBackingStore on Mac.
[email protected]aa4117f2011-12-09 22:19:211435 Send(new ViewHostMsg_UpdateIsDelayed(routing_id_));
1436 }
[email protected]c63b4d42012-04-26 01:01:071437#endif
[email protected]aa4117f2011-12-09 22:19:211438
[email protected]ea162f92011-10-04 23:08:221439 is_accelerated_compositing_active_ = true;
[email protected]50bd6452010-11-27 19:39:421440 Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
[email protected]65225772011-05-12 21:10:241441 routing_id_, is_accelerated_compositing_active_));
[email protected]ea162f92011-10-04 23:08:221442}
1443
1444void RenderWidget::didDeactivateCompositor() {
1445 TRACE_EVENT0("gpu", "RenderWidget::didDeactivateCompositor");
1446
1447 is_accelerated_compositing_active_ = false;
1448 Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
1449 routing_id_, is_accelerated_compositing_active_));
1450
[email protected]ea162f92011-10-04 23:08:221451 if (using_asynchronous_swapbuffers_)
[email protected]65225772011-05-12 21:10:241452 using_asynchronous_swapbuffers_ = false;
[email protected]479b0172012-10-29 19:27:091453
1454 // In single-threaded mode, we exit force compositing mode and re-enter in
1455 // DoDeferredUpdate() if appropriate. In threaded compositing mode,
1456 // DoDeferredUpdate() is bypassed and WebKit is responsible for exiting and
1457 // entering force compositing mode at the appropriate times.
[email protected]cb6430932012-10-31 00:53:361458 if (!is_threaded_compositing_enabled_)
[email protected]479b0172012-10-29 19:27:091459 webwidget_->enterForceCompositingMode(false);
[email protected]a79d8a632010-11-18 22:35:561460}
1461
[email protected]e195e582013-03-08 01:32:591462void RenderWidget::initializeLayerTreeView() {
1463 compositor_ = RenderWidgetCompositor::Create(this);
1464 if (!compositor_)
1465 return;
1466
1467 compositor_->setViewportSize(size_, physical_backing_size_);
1468 if (init_complete_)
1469 compositor_->setSurfaceReady();
1470}
1471
[email protected]8926c602013-01-23 05:32:061472WebKit::WebLayerTreeView* RenderWidget::layerTreeView() {
[email protected]ba91a792013-02-06 09:48:281473 return compositor_.get();
[email protected]8926c602013-01-23 05:32:061474}
1475
[email protected]9ed83fe2013-02-27 01:52:281476void RenderWidget::suppressCompositorScheduling(bool enable) {
1477 if (compositor_)
1478 compositor_->SetSuppressScheduleComposite(enable);
1479}
1480
[email protected]9cd43a62012-03-26 08:03:561481void RenderWidget::willBeginCompositorFrame() {
1482 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
[email protected]abe8b3a2012-03-28 21:19:371483
[email protected]ea5f70a2013-03-07 12:30:361484 DCHECK(RenderThreadImpl::current()->compositor_message_loop_proxy());
[email protected]abe8b3a2012-03-28 21:19:371485
1486 // The following two can result in further layout and possibly
1487 // enable GPU acceleration so they need to be called before any painting
1488 // is done.
[email protected]2d354272013-01-14 00:59:061489 UpdateTextInputState(DO_NOT_SHOW_IME);
[email protected]abe8b3a2012-03-28 21:19:371490 UpdateSelectionBounds();
1491
[email protected]9cd43a62012-03-26 08:03:561492 WillInitiatePaint();
1493}
1494
[email protected]3391a0772012-03-28 00:32:071495void RenderWidget::didBecomeReadyForAdditionalInput() {
1496 TRACE_EVENT0("renderer", "RenderWidget::didBecomeReadyForAdditionalInput");
[email protected]59383c782013-04-17 16:43:271497 if (pending_input_event_ack_)
[email protected]3391a0772012-03-28 00:32:071498 Send(pending_input_event_ack_.release());
1499}
1500
[email protected]6fceb912013-02-15 06:24:151501void RenderWidget::DidCommitCompositorFrame() {
1502}
1503
[email protected]58264a32011-11-17 23:36:151504void RenderWidget::didCommitAndDrawCompositorFrame() {
[email protected]b5db7eb2011-11-29 09:11:501505 TRACE_EVENT0("gpu", "RenderWidget::didCommitAndDrawCompositorFrame");
[email protected]60a50072012-01-11 02:05:351506 // Accelerated FPS tick for performance tests. See throughput_tests.cc.
1507 // NOTE: Tests may break if this event is renamed or moved.
[email protected]c76faea2013-03-26 07:42:421508 UNSHIPPED_TRACE_EVENT_INSTANT0("test_fps", "TestFrameTickGPU",
1509 TRACE_EVENT_SCOPE_THREAD);
[email protected]29ed96a2012-02-04 18:12:161510 // Notify subclasses that we initiated the paint operation.
1511 DidInitiatePaint();
[email protected]58264a32011-11-17 23:36:151512}
1513
1514void RenderWidget::didCompleteSwapBuffers() {
[email protected]404939f2012-06-01 04:06:181515 TRACE_EVENT0("renderer", "RenderWidget::didCompleteSwapBuffers");
1516
1517 // Notify subclasses threaded composited rendering was flushed to the screen.
[email protected]9cd43a62012-03-26 08:03:561518 DidFlushPaint();
1519
[email protected]aa4117f2011-12-09 22:19:211520 if (update_reply_pending_)
[email protected]58264a32011-11-17 23:36:151521 return;
1522
[email protected]ea3ee0a2012-05-15 03:43:091523 if (!next_paint_flags_ &&
1524 !need_update_rect_for_auto_resize_ &&
1525 !plugin_window_moves_.size()) {
[email protected]58264a32011-11-17 23:36:151526 return;
[email protected]ea3ee0a2012-05-15 03:43:091527 }
[email protected]58264a32011-11-17 23:36:151528
1529 ViewHostMsg_UpdateRect_Params params;
1530 params.view_size = size_;
[email protected]58264a32011-11-17 23:36:151531 params.plugin_window_moves.swap(plugin_window_moves_);
1532 params.flags = next_paint_flags_;
1533 params.scroll_offset = GetScrollOffset();
[email protected]b0dda9e22011-12-13 20:30:121534 params.needs_ack = false;
[email protected]7ded9f12012-06-13 20:47:091535 params.scale_factor = device_scale_factor_;
[email protected]58264a32011-11-17 23:36:151536
1537 Send(new ViewHostMsg_UpdateRect(routing_id_, params));
1538 next_paint_flags_ = 0;
[email protected]ea3ee0a2012-05-15 03:43:091539 need_update_rect_for_auto_resize_ = false;
[email protected]58264a32011-11-17 23:36:151540}
1541
[email protected]f98d7e3c2010-09-13 22:30:461542void RenderWidget::scheduleComposite() {
[email protected]479b0172012-10-29 19:27:091543 TRACE_EVENT0("gpu", "RenderWidget::scheduleComposite");
[email protected]ea5f70a2013-03-07 12:30:361544 if (RenderThreadImpl::current()->compositor_message_loop_proxy() &&
[email protected]ba91a792013-02-06 09:48:281545 compositor_) {
1546 compositor_->setNeedsRedraw();
[email protected]d0be63772011-12-20 23:18:041547 } else {
[email protected]c3d45532011-10-07 19:20:401548 // TODO(nduca): replace with something a little less hacky. The reason this
1549 // hack is still used is because the Invalidate-DoDeferredUpdate loop
1550 // contains a lot of host-renderer synchronization logic that is still
1551 // important for the accelerated compositing case. The option of simply
1552 // duplicating all that code is less desirable than "faking out" the
1553 // invalidation path using a magical damage rect.
1554 didInvalidateRect(WebRect(0, 0, 1, 1));
1555 }
[email protected]f98d7e3c2010-09-13 22:30:461556}
1557
[email protected]5f8b1022011-01-21 23:34:501558void RenderWidget::scheduleAnimation() {
[email protected]ce65fb782012-04-19 05:01:201559 if (animation_update_pending_)
1560 return;
1561
[email protected]921244e42011-07-20 16:36:301562 TRACE_EVENT0("gpu", "RenderWidget::scheduleAnimation");
[email protected]ce65fb782012-04-19 05:01:201563 animation_update_pending_ = true;
1564 if (!animation_timer_.IsRunning()) {
1565 animation_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(0), this,
1566 &RenderWidget::AnimationCallback);
[email protected]ee3d3ad2011-02-04 00:42:211567 }
[email protected]5f8b1022011-01-21 23:34:501568}
1569
[email protected]4873c7d2009-07-16 06:36:281570void RenderWidget::didChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301571 // TODO(darin): Eliminate this temporary.
1572 WebCursor cursor(cursor_info);
1573
initial.commit09911bf2008-07-26 23:55:291574 // Only send a SetCursor message if we need to make a change.
1575 if (!current_cursor_.IsEqual(cursor)) {
1576 current_cursor_ = cursor;
1577 Send(new ViewHostMsg_SetCursor(routing_id_, cursor));
1578 }
1579}
1580
1581// We are supposed to get a single call to Show for a newly created RenderWidget
1582// that was created via RenderWidget::CreateWebView. So, we wait until this
1583// point to dispatch the ShowWidget message.
1584//
1585// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281586// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291587//
[email protected]4873c7d2009-07-16 06:36:281588void RenderWidget::show(WebNavigationPolicy) {
initial.commit09911bf2008-07-26 23:55:291589 DCHECK(!did_show_) << "received extraneous Show call";
1590 DCHECK(routing_id_ != MSG_ROUTING_NONE);
1591 DCHECK(opener_id_ != MSG_ROUTING_NONE);
1592
[email protected]8de12d942010-11-17 20:42:441593 if (did_show_)
1594 return;
1595
1596 did_show_ = true;
1597 // NOTE: initial_pos_ may still have its default values at this point, but
1598 // that's okay. It'll be ignored if as_popup is false, or the browser
1599 // process will impose a default position otherwise.
1600 Send(new ViewHostMsg_ShowWidget(opener_id_, routing_id_, initial_pos_));
1601 SetPendingWindowRect(initial_pos_);
initial.commit09911bf2008-07-26 23:55:291602}
1603
[email protected]4873c7d2009-07-16 06:36:281604void RenderWidget::didFocus() {
initial.commit09911bf2008-07-26 23:55:291605}
1606
[email protected]4873c7d2009-07-16 06:36:281607void RenderWidget::didBlur() {
initial.commit09911bf2008-07-26 23:55:291608}
1609
[email protected]2533ce12009-05-09 00:02:241610void RenderWidget::DoDeferredClose() {
1611 Send(new ViewHostMsg_Close(routing_id_));
1612}
1613
[email protected]4873c7d2009-07-16 06:36:281614void RenderWidget::closeWidgetSoon() {
[email protected]e1c3a552012-05-04 20:51:321615 if (is_swapped_out_) {
1616 // This widget is currently swapped out, and the active widget is in a
1617 // different process. Have the browser route the close request to the
1618 // active widget instead, so that the correct unload handlers are run.
1619 Send(new ViewHostMsg_RouteCloseEvent(routing_id_));
1620 return;
1621 }
1622
initial.commit09911bf2008-07-26 23:55:291623 // If a page calls window.close() twice, we'll end up here twice, but that's
1624 // OK. It is safe to send multiple Close messages.
1625
[email protected]2533ce12009-05-09 00:02:241626 // Ask the RenderWidgetHost to initiate close. We could be called from deep
1627 // in Javascript. If we ask the RendwerWidgetHost to close now, the window
1628 // could be closed before the JS finishes executing. So instead, post a
1629 // message back to the message loop, which won't run until the JS is
1630 // complete, and then the Close message can be sent.
[email protected]dd32b1272013-05-04 14:17:111631 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:211632 FROM_HERE, base::Bind(&RenderWidget::DoDeferredClose, this));
initial.commit09911bf2008-07-26 23:55:291633}
1634
1635void RenderWidget::Close() {
1636 if (webwidget_) {
[email protected]8926c602013-01-23 05:32:061637 webwidget_->willCloseLayerTreeView();
[email protected]ba91a792013-02-06 09:48:281638 compositor_.reset();
[email protected]4873c7d2009-07-16 06:36:281639 webwidget_->close();
initial.commit09911bf2008-07-26 23:55:291640 webwidget_ = NULL;
1641 }
1642}
1643
[email protected]4873c7d2009-07-16 06:36:281644WebRect RenderWidget::windowRect() {
1645 if (pending_window_rect_count_)
1646 return pending_window_rect_;
[email protected]2533ce12009-05-09 00:02:241647
[email protected]80ad8622012-11-07 16:33:031648 return view_screen_rect_;
initial.commit09911bf2008-07-26 23:55:291649}
1650
[email protected]8a9d6ca32011-06-06 20:11:301651void RenderWidget::setToolTipText(const WebKit::WebString& text,
1652 WebTextDirection hint) {
[email protected]5a395b72011-08-08 19:13:541653 Send(new ViewHostMsg_SetTooltipText(routing_id_, text, hint));
[email protected]8a9d6ca32011-06-06 20:11:301654}
1655
[email protected]4873c7d2009-07-16 06:36:281656void RenderWidget::setWindowRect(const WebRect& pos) {
initial.commit09911bf2008-07-26 23:55:291657 if (did_show_) {
[email protected]8be1c582013-03-06 00:55:031658 if (!RenderThreadImpl::current()->short_circuit_size_updates()) {
1659 Send(new ViewHostMsg_RequestMove(routing_id_, pos));
1660 SetPendingWindowRect(pos);
1661 } else {
1662 WebSize new_size(pos.width, pos.height);
[email protected]d9083762013-03-24 01:36:401663 Resize(new_size, new_size, overdraw_bottom_height_,
1664 WebRect(), is_fullscreen_, NO_RESIZE_ACK);
[email protected]8be1c582013-03-06 00:55:031665 view_screen_rect_ = pos;
1666 window_screen_rect_ = pos;
1667 }
initial.commit09911bf2008-07-26 23:55:291668 } else {
1669 initial_pos_ = pos;
1670 }
1671}
1672
[email protected]2533ce12009-05-09 00:02:241673void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
1674 pending_window_rect_ = rect;
1675 pending_window_rect_count_++;
1676}
1677
[email protected]4873c7d2009-07-16 06:36:281678WebRect RenderWidget::rootWindowRect() {
[email protected]2533ce12009-05-09 00:02:241679 if (pending_window_rect_count_) {
1680 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
1681 // the RootWindowRect is probably going to return wrong results since the
1682 // browser may not have processed the Move yet. There isn't really anything
1683 // good to do in this case, and it shouldn't happen - since this size is
1684 // only really needed for windowToScreen, which is only used for Popups.
[email protected]4873c7d2009-07-16 06:36:281685 return pending_window_rect_;
[email protected]2533ce12009-05-09 00:02:241686 }
1687
[email protected]80ad8622012-11-07 16:33:031688 return window_screen_rect_;
[email protected]d4547452008-08-28 18:36:371689}
1690
[email protected]4873c7d2009-07-16 06:36:281691WebRect RenderWidget::windowResizerRect() {
1692 return resizer_rect_;
[email protected]c04b6362008-11-21 18:54:191693}
1694
[email protected]fa7b1dc2010-06-23 17:53:041695void RenderWidget::OnSetInputMethodActive(bool is_active) {
[email protected]c4bb35a2008-10-31 17:54:031696 // To prevent this renderer process from sending unnecessary IPC messages to
1697 // a browser process, we permit the renderer process to send IPC messages
[email protected]fa7b1dc2010-06-23 17:53:041698 // only during the input method attached to the browser process is active.
1699 input_method_is_active_ = is_active;
initial.commit09911bf2008-07-26 23:55:291700}
1701
[email protected]58b48a0d2012-06-13 07:01:351702void RenderWidget::UpdateCompositionInfo(
1703 const ui::Range& range,
1704 const std::vector<gfx::Rect>& character_bounds) {
1705 if (!ShouldUpdateCompositionInfo(range, character_bounds))
1706 return;
1707 composition_character_bounds_ = character_bounds;
1708 composition_range_ = range;
1709 Send(new ViewHostMsg_ImeCompositionRangeChanged(
1710 routing_id(), composition_range_, composition_character_bounds_));
1711}
1712
[email protected]fa7b1dc2010-06-23 17:53:041713void RenderWidget::OnImeSetComposition(
1714 const string16& text,
1715 const std::vector<WebCompositionUnderline>& underlines,
1716 int selection_start, int selection_end) {
[email protected]4873c7d2009-07-16 06:36:281717 if (!webwidget_)
1718 return;
[email protected]e8f775f2013-02-14 21:00:501719 DCHECK(!handling_ime_event_);
1720 handling_ime_event_ = true;
[email protected]d4cff272011-05-02 15:46:011721 if (webwidget_->setComposition(
[email protected]fa7b1dc2010-06-23 17:53:041722 text, WebVector<WebCompositionUnderline>(underlines),
1723 selection_start, selection_end)) {
[email protected]d4cff272011-05-02 15:46:011724 // Setting the IME composition was successful. Send the new composition
1725 // range to the browser.
1726 ui::Range range(ui::Range::InvalidRange());
1727 size_t location, length;
1728 if (webwidget_->compositionRange(&location, &length)) {
1729 range.set_start(location);
1730 range.set_end(location + length);
1731 }
1732 // The IME was cancelled via the Esc key, so just send back the caret.
1733 else if (webwidget_->caretOrSelectionRange(&location, &length)) {
1734 range.set_start(location);
1735 range.set_end(location + length);
1736 }
[email protected]58b48a0d2012-06-13 07:01:351737 std::vector<gfx::Rect> character_bounds;
1738 GetCompositionCharacterBounds(&character_bounds);
1739 UpdateCompositionInfo(range, character_bounds);
[email protected]d4cff272011-05-02 15:46:011740 } else {
[email protected]fa7b1dc2010-06-23 17:53:041741 // If we failed to set the composition text, then we need to let the browser
1742 // process to cancel the input method's ongoing composition session, to make
1743 // sure we are in a consistent state.
1744 Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
[email protected]d4cff272011-05-02 15:46:011745
1746 // Send an updated IME range with just the caret range.
1747 ui::Range range(ui::Range::InvalidRange());
1748 size_t location, length;
1749 if (webwidget_->caretOrSelectionRange(&location, &length)) {
1750 range.set_start(location);
1751 range.set_end(location + length);
1752 }
[email protected]58b48a0d2012-06-13 07:01:351753 UpdateCompositionInfo(range, std::vector<gfx::Rect>());
[email protected]7f00efa2010-04-15 05:01:261754 }
[email protected]e8f775f2013-02-14 21:00:501755 handling_ime_event_ = false;
1756 UpdateTextInputState(DO_NOT_SHOW_IME);
[email protected]fa7b1dc2010-06-23 17:53:041757}
1758
[email protected]4de6d1692011-10-12 08:45:441759void RenderWidget::OnImeConfirmComposition(
1760 const string16& text, const ui::Range& replacement_range) {
[email protected]d0be63772011-12-20 23:18:041761 if (!webwidget_)
1762 return;
[email protected]e8f775f2013-02-14 21:00:501763 DCHECK(!handling_ime_event_);
1764 handling_ime_event_ = true;
[email protected]d0be63772011-12-20 23:18:041765 handling_input_event_ = true;
1766 webwidget_->confirmComposition(text);
1767 handling_input_event_ = false;
1768
[email protected]d4cff272011-05-02 15:46:011769 // Send an updated IME range with just the caret range.
1770 ui::Range range(ui::Range::InvalidRange());
1771 size_t location, length;
1772 if (webwidget_->caretOrSelectionRange(&location, &length)) {
1773 range.set_start(location);
1774 range.set_end(location + length);
1775 }
[email protected]58b48a0d2012-06-13 07:01:351776 UpdateCompositionInfo(range, std::vector<gfx::Rect>());
[email protected]e8f775f2013-02-14 21:00:501777 handling_ime_event_ = false;
1778 UpdateTextInputState(DO_NOT_SHOW_IME);
initial.commit09911bf2008-07-26 23:55:291779}
1780
[email protected]948f7ab72010-05-28 23:48:081781// This message causes the renderer to render an image of the
1782// desired_size, regardless of whether the tab is hidden or not.
[email protected]3d9ec5052013-01-02 22:05:251783void RenderWidget::OnPaintAtSize(const TransportDIB::Handle& dib_handle,
1784 int tag,
1785 const gfx::Size& page_size,
1786 const gfx::Size& desired_size) {
[email protected]27543452011-03-25 00:14:001787 if (!webwidget_ || !TransportDIB::is_valid_handle(dib_handle)) {
1788 if (TransportDIB::is_valid_handle(dib_handle)) {
[email protected]45c6aad32010-11-11 04:46:251789 // Close our unused handle.
1790#if defined(OS_WIN)
1791 ::CloseHandle(dib_handle);
1792#elif defined(OS_MACOSX)
1793 base::SharedMemory::CloseHandle(dib_handle);
1794#endif
1795 }
[email protected]d65adb12010-04-28 17:26:491796 return;
[email protected]45c6aad32010-11-11 04:46:251797 }
[email protected]d65adb12010-04-28 17:26:491798
[email protected]948f7ab72010-05-28 23:48:081799 if (page_size.IsEmpty() || desired_size.IsEmpty()) {
[email protected]d65adb12010-04-28 17:26:491800 // If one of these is empty, then we just return the dib we were
1801 // given, to avoid leaking it.
[email protected]c88c9442010-07-19 18:55:091802 Send(new ViewHostMsg_PaintAtSize_ACK(routing_id_, tag, desired_size));
[email protected]d65adb12010-04-28 17:26:491803 return;
1804 }
1805
1806 // Map the given DIB ID into this process, and unmap it at the end
1807 // of this function.
[email protected]45c6aad32010-11-11 04:46:251808 scoped_ptr<TransportDIB> paint_at_size_buffer(
1809 TransportDIB::CreateWithHandle(dib_handle));
[email protected]36808ad2010-10-20 19:18:301810
[email protected]4b01b962012-10-09 23:17:351811 gfx::Size page_size_in_pixel = gfx::ToFlooredSize(
[email protected]01a15a72012-11-10 09:34:281812 gfx::ScaleSize(page_size, device_scale_factor_));
[email protected]4b01b962012-10-09 23:17:351813 gfx::Size desired_size_in_pixel = gfx::ToFlooredSize(
[email protected]01a15a72012-11-10 09:34:281814 gfx::ScaleSize(desired_size, device_scale_factor_));
[email protected]8f640512012-08-07 23:52:511815 gfx::Size canvas_size = page_size_in_pixel;
1816 float x_scale = static_cast<float>(desired_size_in_pixel.width()) /
[email protected]d65adb12010-04-28 17:26:491817 static_cast<float>(canvas_size.width());
[email protected]8f640512012-08-07 23:52:511818 float y_scale = static_cast<float>(desired_size_in_pixel.height()) /
[email protected]d65adb12010-04-28 17:26:491819 static_cast<float>(canvas_size.height());
1820
[email protected]ee8d6fd2010-05-26 17:05:481821 gfx::Rect orig_bounds(canvas_size);
[email protected]d65adb12010-04-28 17:26:491822 canvas_size.set_width(static_cast<int>(canvas_size.width() * x_scale));
1823 canvas_size.set_height(static_cast<int>(canvas_size.height() * y_scale));
[email protected]ee8d6fd2010-05-26 17:05:481824 gfx::Rect bounds(canvas_size);
[email protected]d65adb12010-04-28 17:26:491825
[email protected]36808ad2010-10-20 19:18:301826 scoped_ptr<skia::PlatformCanvas> canvas(
1827 paint_at_size_buffer->GetPlatformCanvas(canvas_size.width(),
1828 canvas_size.height()));
[email protected]59383c782013-04-17 16:43:271829 if (!canvas) {
[email protected]36808ad2010-10-20 19:18:301830 NOTREACHED();
1831 return;
1832 }
1833
[email protected]d65adb12010-04-28 17:26:491834 // Reset bounds to what we actually received, but they should be the
1835 // same.
1836 DCHECK_EQ(bounds.width(), canvas->getDevice()->width());
1837 DCHECK_EQ(bounds.height(), canvas->getDevice()->height());
1838 bounds.set_width(canvas->getDevice()->width());
1839 bounds.set_height(canvas->getDevice()->height());
1840
1841 canvas->save();
[email protected]948f7ab72010-05-28 23:48:081842 // Add the scale factor to the canvas, so that we'll get the desired size.
[email protected]d65adb12010-04-28 17:26:491843 canvas->scale(SkFloatToScalar(x_scale), SkFloatToScalar(y_scale));
1844
[email protected]948f7ab72010-05-28 23:48:081845 // Have to make sure we're laid out at the right size before
1846 // rendering.
1847 gfx::Size old_size = webwidget_->size();
1848 webwidget_->resize(page_size);
1849 webwidget_->layout();
1850
[email protected]d65adb12010-04-28 17:26:491851 // Paint the entire thing (using original bounds, not scaled bounds).
1852 PaintRect(orig_bounds, orig_bounds.origin(), canvas.get());
1853 canvas->restore();
1854
[email protected]948f7ab72010-05-28 23:48:081855 // Return the widget to its previous size.
1856 webwidget_->resize(old_size);
1857
[email protected]c88c9442010-07-19 18:55:091858 Send(new ViewHostMsg_PaintAtSize_ACK(routing_id_, tag, bounds.size()));
[email protected]d65adb12010-04-28 17:26:491859}
1860
[email protected]51a49502013-03-23 01:50:191861void RenderWidget::OnSnapshot(const gfx::Rect& src_subrect) {
1862 SkBitmap snapshot;
1863
1864 if (OnSnapshotHelper(src_subrect, &snapshot)) {
1865 Send(new ViewHostMsg_Snapshot(routing_id(), true, snapshot));
1866 } else {
1867 Send(new ViewHostMsg_Snapshot(routing_id(), false, SkBitmap()));
1868 }
1869}
1870
1871bool RenderWidget::OnSnapshotHelper(const gfx::Rect& src_subrect,
1872 SkBitmap* snapshot) {
1873 base::TimeTicks beginning_time = base::TimeTicks::Now();
1874
1875 if (!webwidget_ || src_subrect.IsEmpty())
1876 return false;
1877
1878 gfx::Rect viewport_size = gfx::IntersectRects(
1879 src_subrect, gfx::Rect(physical_backing_size_));
1880
1881 skia::RefPtr<SkCanvas> canvas = skia::AdoptRef(
1882 skia::CreatePlatformCanvas(viewport_size.width(),
1883 viewport_size.height(),
1884 true,
1885 NULL,
1886 skia::RETURN_NULL_ON_FAILURE));
[email protected]59383c782013-04-17 16:43:271887 if (!canvas)
[email protected]51a49502013-03-23 01:50:191888 return false;
1889
1890 canvas->save();
1891 webwidget_->layout();
1892
1893 PaintRect(viewport_size, viewport_size.origin(), canvas.get());
1894 canvas->restore();
1895
1896 const SkBitmap& bitmap = skia::GetTopDevice(*canvas)->accessBitmap(false);
1897 if (!bitmap.copyTo(snapshot, SkBitmap::kARGB_8888_Config))
1898 return false;
1899
1900 UMA_HISTOGRAM_TIMES("Renderer4.Snapshot",
1901 base::TimeTicks::Now() - beginning_time);
1902 return true;
1903}
1904
[email protected]0bc1f572013-04-17 01:46:311905void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
[email protected]ec7dc112008-08-06 05:30:121906 // During shutdown we can just ignore this message.
1907 if (!webwidget_)
1908 return;
1909
[email protected]0bc1f572013-04-17 01:46:311910 // Even if the browser provides an empty damage rect, it's still expecting to
1911 // receive a repaint ack so just damage the entire widget bounds.
1912 if (size_to_paint.IsEmpty()) {
1913 size_to_paint = size_;
1914 }
1915
[email protected]ec7dc112008-08-06 05:30:121916 set_next_paint_is_repaint_ack();
[email protected]0bc1f572013-04-17 01:46:311917 if (is_accelerated_compositing_active_ && compositor_) {
1918 compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint));
[email protected]f98d7e3c2010-09-13 22:30:461919 } else {
1920 gfx::Rect repaint_rect(size_to_paint.width(), size_to_paint.height());
1921 didInvalidateRect(repaint_rect);
1922 }
[email protected]ec7dc112008-08-06 05:30:121923}
1924
[email protected]4a9dba42013-04-29 18:24:221925void RenderWidget::OnSmoothScrollCompleted() {
1926 pending_smooth_scroll_gesture_.Run();
[email protected]0e241b4b2012-08-18 09:06:271927}
1928
[email protected]4873c7d2009-07-16 06:36:281929void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
[email protected]07f953332009-03-25 04:31:111930 if (!webwidget_)
1931 return;
[email protected]4873c7d2009-07-16 06:36:281932 webwidget_->setTextDirection(direction);
[email protected]07f953332009-03-25 04:31:111933}
1934
[email protected]6131a642012-06-15 23:26:531935void RenderWidget::OnScreenInfoChanged(
1936 const WebKit::WebScreenInfo& screen_info) {
1937 screen_info_ = screen_info;
[email protected]468ac582012-11-20 00:53:191938 SetDeviceScaleFactor(screen_info.deviceScaleFactor);
[email protected]6131a642012-06-15 23:26:531939}
1940
[email protected]80ad8622012-11-07 16:33:031941void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
1942 const gfx::Rect& window_screen_rect) {
1943 view_screen_rect_ = view_screen_rect;
1944 window_screen_rect_ = window_screen_rect;
1945 Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
1946}
1947
[email protected]105dffb42013-02-20 03:46:211948#if defined(OS_ANDROID)
1949void RenderWidget::OnImeBatchStateChanged(bool is_begin) {
1950 Send(new ViewHostMsg_ImeBatchStateChanged_ACK(routing_id(), is_begin));
1951}
[email protected]2384b6c2013-02-28 23:58:511952
1953void RenderWidget::OnShowImeIfNeeded() {
1954 UpdateTextInputState(SHOW_IME_IF_NEEDED);
1955}
[email protected]105dffb42013-02-20 03:46:211956#endif
1957
[email protected]468ac582012-11-20 00:53:191958void RenderWidget::SetDeviceScaleFactor(float device_scale_factor) {
1959 if (device_scale_factor_ == device_scale_factor)
1960 return;
1961
1962 device_scale_factor_ = device_scale_factor;
1963
1964 if (!is_accelerated_compositing_active_) {
1965 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
1966 } else {
1967 scheduleComposite();
1968 }
1969}
1970
[email protected]719b36f2010-12-22 20:36:461971webkit::ppapi::PluginInstance* RenderWidget::GetBitmapForOptimizedPluginPaint(
[email protected]ca4847f2010-09-24 05:39:151972 const gfx::Rect& paint_bounds,
1973 TransportDIB** dib,
1974 gfx::Rect* location,
[email protected]0f3a2d12012-09-01 03:37:201975 gfx::Rect* clip,
1976 float* scale_factor) {
[email protected]719b36f2010-12-22 20:36:461977 // Bare RenderWidgets don't support optimized plugin painting.
1978 return NULL;
[email protected]ca4847f2010-09-24 05:39:151979}
1980
[email protected]ceb36f7d2012-10-31 18:33:241981gfx::Vector2d RenderWidget::GetScrollOffset() {
[email protected]d54169e92011-01-21 09:19:521982 // Bare RenderWidgets don't support scroll offset.
[email protected]ceb36f7d2012-10-31 18:33:241983 return gfx::Vector2d();
[email protected]d54169e92011-01-21 09:19:521984}
1985
[email protected]bee16aab2009-08-26 15:55:031986void RenderWidget::SetHidden(bool hidden) {
1987 if (is_hidden_ == hidden)
1988 return;
1989
1990 // The status has changed. Tell the RenderThread about it.
1991 is_hidden_ = hidden;
1992 if (is_hidden_)
[email protected]380244092011-10-07 17:26:271993 RenderThread::Get()->WidgetHidden();
[email protected]bee16aab2009-08-26 15:55:031994 else
[email protected]380244092011-10-07 17:26:271995 RenderThread::Get()->WidgetRestored();
[email protected]bee16aab2009-08-26 15:55:031996}
1997
[email protected]2b624c562011-10-27 22:58:261998void RenderWidget::WillToggleFullscreen() {
[email protected]2b624c562011-10-27 22:58:261999 if (!webwidget_)
2000 return;
2001
2002 if (is_fullscreen_) {
2003 webwidget_->willExitFullScreen();
2004 } else {
2005 webwidget_->willEnterFullScreen();
2006 }
[email protected]2b624c562011-10-27 22:58:262007}
2008
2009void RenderWidget::DidToggleFullscreen() {
[email protected]2b624c562011-10-27 22:58:262010 if (!webwidget_)
2011 return;
2012
2013 if (is_fullscreen_) {
2014 webwidget_->didEnterFullScreen();
2015 } else {
2016 webwidget_->didExitFullScreen();
2017 }
[email protected]2b624c562011-10-27 22:58:262018}
2019
[email protected]699ab0d2009-04-23 23:19:142020void RenderWidget::SetBackground(const SkBitmap& background) {
2021 background_ = background;
[email protected]f98d7e3c2010-09-13 22:30:462022
[email protected]699ab0d2009-04-23 23:19:142023 // Generate a full repaint.
[email protected]4873c7d2009-07-16 06:36:282024 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
[email protected]699ab0d2009-04-23 23:19:142025}
2026
[email protected]674741932009-02-04 23:44:462027bool RenderWidget::next_paint_is_resize_ack() const {
[email protected]53d3f302009-12-21 04:42:052028 return ViewHostMsg_UpdateRect_Flags::is_resize_ack(next_paint_flags_);
[email protected]674741932009-02-04 23:44:462029}
2030
2031bool RenderWidget::next_paint_is_restore_ack() const {
[email protected]53d3f302009-12-21 04:42:052032 return ViewHostMsg_UpdateRect_Flags::is_restore_ack(next_paint_flags_);
[email protected]674741932009-02-04 23:44:462033}
2034
2035void RenderWidget::set_next_paint_is_resize_ack() {
[email protected]53d3f302009-12-21 04:42:052036 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
[email protected]674741932009-02-04 23:44:462037}
2038
2039void RenderWidget::set_next_paint_is_restore_ack() {
[email protected]53d3f302009-12-21 04:42:052040 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESTORE_ACK;
[email protected]674741932009-02-04 23:44:462041}
2042
2043void RenderWidget::set_next_paint_is_repaint_ack() {
[email protected]53d3f302009-12-21 04:42:052044 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK;
[email protected]674741932009-02-04 23:44:462045}
2046
[email protected]b18583c2012-12-18 06:55:272047static bool IsDateTimeInput(ui::TextInputType type) {
2048 return type == ui::TEXT_INPUT_TYPE_DATE ||
2049 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
2050 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
2051 type == ui::TEXT_INPUT_TYPE_MONTH ||
2052 type == ui::TEXT_INPUT_TYPE_TIME ||
2053 type == ui::TEXT_INPUT_TYPE_WEEK;
2054}
2055
[email protected]3306f262012-09-21 19:20:422056void RenderWidget::UpdateTextInputState(ShowIme show_ime) {
[email protected]e8f775f2013-02-14 21:00:502057 if (handling_ime_event_)
2058 return;
[email protected]3306f262012-09-21 19:20:422059 bool show_ime_if_needed = (show_ime == SHOW_IME_IF_NEEDED);
2060 if (!show_ime_if_needed && !input_method_is_active_)
initial.commit09911bf2008-07-26 23:55:292061 return;
[email protected]ad26ef42011-06-17 07:59:452062 ui::TextInputType new_type = GetTextInputType();
[email protected]b18583c2012-12-18 06:55:272063 if (IsDateTimeInput(new_type))
2064 return; // Not considered as a text input field in WebKit/Chromium.
2065
[email protected]5b739cb2012-08-21 20:35:212066 WebKit::WebTextInputInfo new_info;
2067 if (webwidget_)
2068 new_info = webwidget_->textInputInfo();
2069
[email protected]ad26ef42011-06-17 07:59:452070 bool new_can_compose_inline = CanComposeInline();
[email protected]5b739cb2012-08-21 20:35:212071
[email protected]3306f262012-09-21 19:20:422072 // Only sends text input params if they are changed or if the ime should be
2073 // shown.
2074 if (show_ime_if_needed || (text_input_type_ != new_type
2075 || text_input_info_ != new_info
2076 || can_compose_inline_ != new_can_compose_inline)) {
[email protected]5b739cb2012-08-21 20:35:212077 ViewHostMsg_TextInputState_Params p;
2078 p.type = new_type;
2079 p.value = new_info.value.utf8();
2080 p.selection_start = new_info.selectionStart;
2081 p.selection_end = new_info.selectionEnd;
2082 p.composition_start = new_info.compositionStart;
2083 p.composition_end = new_info.compositionEnd;
2084 p.can_compose_inline = new_can_compose_inline;
[email protected]3306f262012-09-21 19:20:422085 p.show_ime_if_needed = show_ime_if_needed;
[email protected]5b739cb2012-08-21 20:35:212086 Send(new ViewHostMsg_TextInputStateChanged(routing_id(), p));
2087
2088 text_input_info_ = new_info;
[email protected]fa7b1dc2010-06-23 17:53:042089 text_input_type_ = new_type;
[email protected]ad26ef42011-06-17 07:59:452090 can_compose_inline_ = new_can_compose_inline;
initial.commit09911bf2008-07-26 23:55:292091 }
initial.commit09911bf2008-07-26 23:55:292092}
2093
[email protected]7c8873e2013-02-05 08:03:012094void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
2095 WebRect focus_webrect;
2096 WebRect anchor_webrect;
2097 webwidget_->selectionBounds(focus_webrect, anchor_webrect);
2098 *focus = focus_webrect;
2099 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:322100}
2101
[email protected]e99ef6f2011-10-16 01:13:002102void RenderWidget::UpdateSelectionBounds() {
2103 if (!webwidget_)
2104 return;
2105
[email protected]7c8873e2013-02-05 08:03:012106 ViewHostMsg_SelectionBounds_Params params;
2107 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
2108 if (selection_anchor_rect_ != params.anchor_rect ||
2109 selection_focus_rect_ != params.focus_rect) {
2110 selection_anchor_rect_ = params.anchor_rect;
2111 selection_focus_rect_ = params.focus_rect;
2112 webwidget_->selectionTextDirection(params.focus_dir, params.anchor_dir);
[email protected]129b7382013-02-12 02:14:292113 params.is_anchor_first = webwidget_->isSelectionAnchorFirst();
[email protected]7c8873e2013-02-05 08:03:012114 Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
[email protected]58b48a0d2012-06-13 07:01:352115 }
[email protected]e99ef6f2011-10-16 01:13:002116
[email protected]58b48a0d2012-06-13 07:01:352117 std::vector<gfx::Rect> character_bounds;
2118 GetCompositionCharacterBounds(&character_bounds);
2119 UpdateCompositionInfo(composition_range_, character_bounds);
2120}
2121
2122bool RenderWidget::ShouldUpdateCompositionInfo(
2123 const ui::Range& range,
2124 const std::vector<gfx::Rect>& bounds) {
2125 if (composition_range_ != range)
2126 return true;
2127 if (bounds.size() != composition_character_bounds_.size())
2128 return true;
2129 for (size_t i = 0; i < bounds.size(); ++i) {
2130 if (bounds[i] != composition_character_bounds_[i])
2131 return true;
2132 }
2133 return false;
[email protected]e99ef6f2011-10-16 01:13:002134}
2135
[email protected]73bf95812011-10-12 11:38:322136// Check WebKit::WebTextInputType and ui::TextInputType is kept in sync.
[email protected]ad26ef42011-06-17 07:59:452137COMPILE_ASSERT(int(WebKit::WebTextInputTypeNone) == \
2138 int(ui::TEXT_INPUT_TYPE_NONE), mismatching_enums);
2139COMPILE_ASSERT(int(WebKit::WebTextInputTypeText) == \
2140 int(ui::TEXT_INPUT_TYPE_TEXT), mismatching_enums);
2141COMPILE_ASSERT(int(WebKit::WebTextInputTypePassword) == \
2142 int(ui::TEXT_INPUT_TYPE_PASSWORD), mismatching_enums);
[email protected]caf38ed2011-07-28 13:15:182143COMPILE_ASSERT(int(WebKit::WebTextInputTypeSearch) == \
2144 int(ui::TEXT_INPUT_TYPE_SEARCH), mismatching_enums);
2145COMPILE_ASSERT(int(WebKit::WebTextInputTypeEmail) == \
2146 int(ui::TEXT_INPUT_TYPE_EMAIL), mismatching_enums);
2147COMPILE_ASSERT(int(WebKit::WebTextInputTypeNumber) == \
2148 int(ui::TEXT_INPUT_TYPE_NUMBER), mismatching_enums);
2149COMPILE_ASSERT(int(WebKit::WebTextInputTypeTelephone) == \
2150 int(ui::TEXT_INPUT_TYPE_TELEPHONE), mismatching_enums);
2151COMPILE_ASSERT(int(WebKit::WebTextInputTypeURL) == \
2152 int(ui::TEXT_INPUT_TYPE_URL), mismatching_enums);
[email protected]feb8cf752012-06-08 04:48:002153COMPILE_ASSERT(int(WebKit::WebTextInputTypeDate) == \
2154 int(ui::TEXT_INPUT_TYPE_DATE), mismatching_enum);
2155COMPILE_ASSERT(int(WebKit::WebTextInputTypeDateTime) == \
2156 int(ui::TEXT_INPUT_TYPE_DATE_TIME), mismatching_enum);
2157COMPILE_ASSERT(int(WebKit::WebTextInputTypeDateTimeLocal) == \
2158 int(ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL), mismatching_enum);
2159COMPILE_ASSERT(int(WebKit::WebTextInputTypeMonth) == \
2160 int(ui::TEXT_INPUT_TYPE_MONTH), mismatching_enum);
2161COMPILE_ASSERT(int(WebKit::WebTextInputTypeTime) == \
2162 int(ui::TEXT_INPUT_TYPE_TIME), mismatching_enum);
2163COMPILE_ASSERT(int(WebKit::WebTextInputTypeWeek) == \
2164 int(ui::TEXT_INPUT_TYPE_WEEK), mismatching_enum);
[email protected]2a9893672012-11-09 20:33:012165COMPILE_ASSERT(int(WebKit::WebTextInputTypeTextArea) == \
2166 int(ui::TEXT_INPUT_TYPE_TEXT_AREA), mismatching_enums);
2167COMPILE_ASSERT(int(WebKit::WebTextInputTypeContentEditable) == \
2168 int(ui::TEXT_INPUT_TYPE_CONTENT_EDITABLE), mismatching_enums);
[email protected]8b4992e2013-03-01 15:42:152169COMPILE_ASSERT(int(WebKit::WebTextInputTypeDateTimeField) == \
2170 int(ui::TEXT_INPUT_TYPE_DATE_TIME_FIELD), mismatching_enums);
[email protected]ad26ef42011-06-17 07:59:452171
[email protected]5b739cb2012-08-21 20:35:212172ui::TextInputType RenderWidget::WebKitToUiTextInputType(
2173 WebKit::WebTextInputType type) {
2174 // Check the type is in the range representable by ui::TextInputType.
2175 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX)) <<
2176 "WebKit::WebTextInputType and ui::TextInputType not synchronized";
2177 return static_cast<ui::TextInputType>(type);
2178}
2179
[email protected]ad26ef42011-06-17 07:59:452180ui::TextInputType RenderWidget::GetTextInputType() {
[email protected]8969bb3f2012-11-30 21:49:272181 if (webwidget_)
2182 return WebKitToUiTextInputType(webwidget_->textInputInfo().type);
[email protected]ad26ef42011-06-17 07:59:452183 return ui::TEXT_INPUT_TYPE_NONE;
2184}
2185
[email protected]58b48a0d2012-06-13 07:01:352186void RenderWidget::GetCompositionCharacterBounds(
2187 std::vector<gfx::Rect>* bounds) {
2188 DCHECK(bounds);
2189 bounds->clear();
2190}
2191
[email protected]ad26ef42011-06-17 07:59:452192bool RenderWidget::CanComposeInline() {
2193 return true;
[email protected]56ea1a62011-05-30 07:05:572194}
2195
[email protected]4873c7d2009-07-16 06:36:282196WebScreenInfo RenderWidget::screenInfo() {
[email protected]842f10652012-06-06 01:54:042197 return screen_info_;
[email protected]4873c7d2009-07-16 06:36:282198}
2199
[email protected]f660d9c2012-06-06 18:31:212200float RenderWidget::deviceScaleFactor() {
2201 return device_scale_factor_;
2202}
2203
[email protected]fa7b1dc2010-06-23 17:53:042204void RenderWidget::resetInputMethod() {
2205 if (!input_method_is_active_)
2206 return;
2207
2208 // If the last text input type is not None, then we should finish any
2209 // ongoing composition regardless of the new text input type.
[email protected]ad26ef42011-06-17 07:59:452210 if (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE) {
[email protected]fa7b1dc2010-06-23 17:53:042211 // If a composition text exists, then we need to let the browser process
2212 // to cancel the input method's ongoing composition session.
2213 if (webwidget_->confirmComposition())
2214 Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
2215 }
[email protected]d4cff272011-05-02 15:46:012216
2217 // Send an updated IME range with the current caret rect.
2218 ui::Range range(ui::Range::InvalidRange());
2219 size_t location, length;
2220 if (webwidget_->caretOrSelectionRange(&location, &length)) {
2221 range.set_start(location);
2222 range.set_end(location + length);
2223 }
[email protected]58b48a0d2012-06-13 07:01:352224
2225 UpdateCompositionInfo(range, std::vector<gfx::Rect>());
[email protected]fa7b1dc2010-06-23 17:53:042226}
2227
[email protected]c68c3e4e2013-01-24 00:36:562228void RenderWidget::didHandleGestureEvent(
2229 const WebGestureEvent& event,
2230 bool event_cancelled) {
2231#if defined(OS_ANDROID)
2232 if (event_cancelled)
2233 return;
2234 if (event.type == WebInputEvent::GestureTap ||
2235 event.type == WebInputEvent::GestureLongPress) {
2236 UpdateTextInputState(SHOW_IME_IF_NEEDED);
2237 }
2238#endif
2239}
2240
[email protected]f103ab72009-09-02 17:10:592241void RenderWidget::SchedulePluginMove(
[email protected]191eb3f72010-12-21 06:27:502242 const webkit::npapi::WebPluginGeometry& move) {
initial.commit09911bf2008-07-26 23:55:292243 size_t i = 0;
2244 for (; i < plugin_window_moves_.size(); ++i) {
2245 if (plugin_window_moves_[i].window == move.window) {
[email protected]16f89d02009-08-26 17:17:582246 if (move.rects_valid) {
2247 plugin_window_moves_[i] = move;
2248 } else {
2249 plugin_window_moves_[i].visible = move.visible;
2250 }
initial.commit09911bf2008-07-26 23:55:292251 break;
2252 }
2253 }
2254
2255 if (i == plugin_window_moves_.size())
2256 plugin_window_moves_.push_back(move);
2257}
[email protected]268654772009-08-06 23:02:042258
2259void RenderWidget::CleanupWindowInPluginMoves(gfx::PluginWindowHandle window) {
2260 for (WebPluginGeometryVector::iterator i = plugin_window_moves_.begin();
2261 i != plugin_window_moves_.end(); ++i) {
2262 if (i->window == window) {
2263 plugin_window_moves_.erase(i);
2264 break;
2265 }
2266 }
2267}
[email protected]67bfb83f2011-09-22 03:36:372268
[email protected]b63d58d2012-11-26 22:37:442269void RenderWidget::GetRenderingStats(
2270 WebKit::WebRenderingStatsImpl& stats) const {
[email protected]ba91a792013-02-06 09:48:282271 if (compositor_)
[email protected]635353c2013-03-06 09:11:202272 compositor_->GetRenderingStats(&stats.rendering_stats);
[email protected]b63d58d2012-11-26 22:37:442273
[email protected]62049562013-03-24 00:39:012274 stats.rendering_stats.animation_frame_count +=
2275 software_stats_.animation_frame_count;
2276 stats.rendering_stats.screen_frame_count +=
2277 software_stats_.screen_frame_count;
2278 stats.rendering_stats.total_paint_time +=
2279 software_stats_.total_paint_time;
2280 stats.rendering_stats.total_pixels_painted +=
2281 software_stats_.total_pixels_painted;
[email protected]fef5e3972012-08-07 03:59:472282}
2283
[email protected]e9ff79c2012-10-19 21:31:262284bool RenderWidget::GetGpuRenderingStats(GpuRenderingStats* stats) const {
[email protected]63b465922012-09-06 02:04:522285 GpuChannelHost* gpu_channel = RenderThreadImpl::current()->GetGpuChannel();
2286 if (!gpu_channel)
2287 return false;
2288
2289 return gpu_channel->CollectRenderingStatsForSurface(surface_id(), stats);
2290}
2291
[email protected]24ed0432013-04-24 07:50:312292RenderWidgetCompositor* RenderWidget::compositor() const {
2293 return compositor_.get();
2294}
2295
[email protected]0c2ebef2013-04-03 12:14:102296void RenderWidget::BeginSmoothScroll(
[email protected]0e241b4b2012-08-18 09:06:272297 bool down,
[email protected]ebd8b562012-10-09 14:44:292298 const SmoothScrollCompletionCallback& callback,
[email protected]267909d2012-10-20 04:36:192299 int pixels_to_scroll,
[email protected]ebd8b562012-10-09 14:44:292300 int mouse_event_x,
2301 int mouse_event_y) {
[email protected]0e241b4b2012-08-18 09:06:272302 DCHECK(!callback.is_null());
[email protected]267909d2012-10-20 04:36:192303
2304 ViewHostMsg_BeginSmoothScroll_Params params;
2305 params.scroll_down = down;
2306 params.pixels_to_scroll = pixels_to_scroll;
2307 params.mouse_event_x = mouse_event_x;
2308 params.mouse_event_y = mouse_event_y;
2309
[email protected]4a9dba42013-04-29 18:24:222310 Send(new ViewHostMsg_BeginSmoothScroll(routing_id_, params));
2311 pending_smooth_scroll_gesture_ = callback;
[email protected]a39ca1652012-07-13 21:30:582312}
2313
[email protected]67bfb83f2011-09-22 03:36:372314bool RenderWidget::WillHandleMouseEvent(const WebKit::WebMouseEvent& event) {
2315 return false;
2316}
[email protected]c3d45532011-10-07 19:20:402317
[email protected]41d86852012-11-07 12:23:242318bool RenderWidget::WillHandleGestureEvent(
2319 const WebKit::WebGestureEvent& event) {
2320 return false;
2321}
2322
[email protected]ce6689f2013-03-29 12:52:552323void RenderWidget::hasTouchEventHandlers(bool has_handlers) {
2324 Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
2325}
2326
[email protected]3d5c243b2012-11-30 00:26:012327bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
2328 return true;
2329}
2330
[email protected]3ae68c52013-04-12 06:10:052331WebGraphicsContext3DCommandBufferImpl* RenderWidget::CreateGraphicsContext3D(
[email protected]92fd8c02013-03-29 08:54:152332 const WebKit::WebGraphicsContext3D::Attributes& attributes) {
[email protected]ed7defa2013-03-12 21:29:592333 if (!webwidget_)
2334 return NULL;
[email protected]8f746982013-03-21 06:28:032335 scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
2336 new WebGraphicsContext3DCommandBufferImpl(
2337 surface_id(),
2338 GetURLForGraphicsContext3D(),
2339 RenderThreadImpl::current(),
2340 weak_ptr_factory_.GetWeakPtr()));
[email protected]ed7defa2013-03-12 21:29:592341
[email protected]8f746982013-03-21 06:28:032342 if (!context->Initialize(
2343 attributes,
2344 false /* bind generates resources */,
2345 CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
2346 return NULL;
2347 return context.release();
[email protected]ed7defa2013-03-12 21:29:592348}
2349
[email protected]e9ff79c2012-10-19 21:31:262350} // namespace content