blob: 903ee5a55a3d700e7919b1de1e1b662224adc151 [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"
[email protected]b256eca2013-07-11 10:57:4012#include "base/memory/singleton.h"
[email protected]aaf68892013-07-18 00:11:3013#include "base/message_loop/message_loop.h"
[email protected]835d7c82010-10-14 04:38:3814#include "base/metrics/histogram.h"
[email protected]aa4117f2011-12-09 22:19:2115#include "base/stl_util.h"
[email protected]74ebfb12013-06-07 20:48:0016#include "base/strings/utf_string_conversions.h"
[email protected]661eb9d2009-02-03 02:11:4817#include "build/build_config.h"
[email protected]681ccff2013-03-18 06:13:5218#include "cc/base/switches.h"
[email protected]adbe30f2013-10-11 21:12:3319#include "cc/debug/benchmark_instrumentation.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]29e2fb42013-07-19 01:13:4722#include "content/child/npapi/webplugin.h"
[email protected]0634cdd42013-08-16 00:46:0923#include "content/common/gpu/client/context_provider_command_buffer.h"
[email protected]ed7defa2013-03-12 21:29:5924#include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
[email protected]96ab016c2013-10-23 00:50:2925#include "content/common/gpu/gpu_process_launch_causes.h"
[email protected]8e299aa2013-10-16 18:17:4426#include "content/common/input/web_input_event_traits.h"
[email protected]c084330e02013-04-27 01:08:1527#include "content/common/input_messages.h"
[email protected]992db4c2011-05-12 15:37:1528#include "content/common/swapped_out_messages.h"
[email protected]778574e2011-03-21 22:03:5029#include "content/common/view_messages.h"
[email protected]c08950d22011-10-13 22:20:2930#include "content/public/common/content_switches.h"
[email protected]953bd0062013-08-01 00:58:4031#include "content/renderer/cursor_utils.h"
[email protected]b2e4c70132013-10-03 02:07:5132#include "content/renderer/external_popup_menu.h"
[email protected]ed7defa2013-03-12 21:29:5933#include "content/renderer/gpu/compositor_output_surface.h"
[email protected]2847b222013-04-06 00:59:2434#include "content/renderer/gpu/compositor_software_output_device.h"
[email protected]36e5ff12013-06-11 12:19:2935#include "content/renderer/gpu/delegated_compositor_output_surface.h"
[email protected]ea5f70a2013-03-07 12:30:3636#include "content/renderer/gpu/input_handler_manager.h"
[email protected]ed7defa2013-03-12 21:29:5937#include "content/renderer/gpu/mailbox_output_surface.h"
[email protected]ba91a792013-02-06 09:48:2838#include "content/renderer/gpu/render_widget_compositor.h"
[email protected]66fca5bc2013-05-23 06:58:2939#include "content/renderer/ime_event_guard.h"
[email protected]adab2332013-07-25 18:04:3240#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
[email protected]8704f89b2011-04-15 00:30:0541#include "content/renderer/render_process.h"
[email protected]f1a29a02011-10-06 23:08:4442#include "content/renderer/render_thread_impl.h"
[email protected]8d6cba42011-09-02 10:05:1943#include "content/renderer/renderer_webkitplatformsupport_impl.h"
[email protected]5b45ad42013-10-25 00:42:0444#include "content/renderer/resizing_mode_selector.h"
[email protected]484955942010-08-19 16:13:1845#include "ipc/ipc_sync_message.h"
[email protected]661eb9d2009-02-03 02:11:4846#include "skia/ext/platform_canvas.h"
[email protected]aaf68892013-07-18 00:11:3047#include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
[email protected]aaf68892013-07-18 00:11:3048#include "third_party/WebKit/public/platform/WebRect.h"
49#include "third_party/WebKit/public/platform/WebSize.h"
50#include "third_party/WebKit/public/platform/WebString.h"
[email protected]2255a9332013-06-17 05:12:3151#include "third_party/WebKit/public/web/WebCursorInfo.h"
52#include "third_party/WebKit/public/web/WebHelperPlugin.h"
53#include "third_party/WebKit/public/web/WebPagePopup.h"
54#include "third_party/WebKit/public/web/WebPopupMenu.h"
55#include "third_party/WebKit/public/web/WebPopupMenuInfo.h"
56#include "third_party/WebKit/public/web/WebRange.h"
57#include "third_party/WebKit/public/web/WebScreenInfo.h"
[email protected]d353541f2012-05-03 22:45:4158#include "third_party/skia/include/core/SkShader.h"
[email protected]faec7b12012-06-19 14:42:1359#include "ui/base/ui_base_switches.h"
[email protected]de2cf8c2013-10-25 19:46:4660#include "ui/gfx/frame_time.h"
[email protected]a25e25b2012-09-28 14:32:3761#include "ui/gfx/rect_conversions.h"
[email protected]4b01b962012-10-09 23:17:3562#include "ui/gfx/size_conversions.h"
[email protected]1835b9e2012-02-28 13:12:4863#include "ui/gfx/skia_util.h"
[email protected]c9e2cbbb2012-05-12 21:17:2764#include "ui/gl/gl_switches.h"
[email protected]d353541f2012-05-03 22:45:4165#include "ui/surface/transport_dib.h"
[email protected]799fd732013-05-15 21:18:5266#include "webkit/renderer/compositor_bindings/web_rendering_stats_impl.h"
[email protected]661eb9d2009-02-03 02:11:4867
[email protected]eeb93112013-05-01 19:41:1068#if defined(OS_ANDROID)
[email protected]b6eb8e332013-09-10 00:51:0169#include "base/android/sys_utils.h"
[email protected]913d99a2013-05-31 07:16:0770#include "content/renderer/android/synchronous_compositor_factory.h"
[email protected]eeb93112013-05-01 19:41:1071#endif
72
[email protected]661eb9d2009-02-03 02:11:4873#if defined(OS_POSIX)
[email protected]6b889fb2010-03-23 20:09:4974#include "ipc/ipc_channel_posix.h"
[email protected]d5282e72009-05-13 13:16:5275#include "third_party/skia/include/core/SkMallocPixelRef.h"
[email protected]d353541f2012-05-03 22:45:4176#include "third_party/skia/include/core/SkPixelRef.h"
[email protected]661eb9d2009-02-03 02:11:4877#endif // defined(OS_POSIX)
[email protected]8085dbc82008-09-26 22:53:4478
[email protected]2255a9332013-06-17 05:12:3179#include "third_party/WebKit/public/web/WebWidget.h"
initial.commit09911bf2008-07-26 23:55:2980
[email protected]fa7b1dc2010-06-23 17:53:0481using WebKit::WebCompositionUnderline;
[email protected]7c51b0ee2009-07-08 21:49:3082using WebKit::WebCursorInfo;
[email protected]41d86852012-11-07 12:23:2483using WebKit::WebGestureEvent;
[email protected]62cb33cae2009-03-27 23:30:2284using WebKit::WebInputEvent;
[email protected]f56c7872013-06-18 12:31:5785using WebKit::WebKeyboardEvent;
[email protected]6a8ddba52010-09-05 04:38:0686using WebKit::WebMouseEvent;
[email protected]b2e4c70132013-10-03 02:07:5187using WebKit::WebMouseWheelEvent;
[email protected]4873c7d2009-07-16 06:36:2888using WebKit::WebNavigationPolicy;
[email protected]a7547fb2012-03-08 04:43:4489using WebKit::WebPagePopup;
[email protected]4873c7d2009-07-16 06:36:2890using WebKit::WebPopupMenu;
[email protected]88efb7ec2009-07-14 16:32:5991using WebKit::WebPopupMenuInfo;
[email protected]484955942010-08-19 16:13:1892using WebKit::WebPopupType;
[email protected]d4cff272011-05-02 15:46:0193using WebKit::WebRange;
[email protected]b3f2b912009-04-09 16:18:5294using WebKit::WebRect;
[email protected]12456fa2009-04-01 23:07:1995using WebKit::WebScreenInfo;
[email protected]b3f2b912009-04-09 16:18:5296using WebKit::WebSize;
[email protected]4873c7d2009-07-16 06:36:2897using WebKit::WebTextDirection;
[email protected]2d0f2e92011-10-03 09:02:2498using WebKit::WebTouchEvent;
[email protected]fa7b1dc2010-06-23 17:53:0499using WebKit::WebVector;
[email protected]484955942010-08-19 16:13:18100using WebKit::WebWidget;
[email protected]e9ff79c2012-10-19 21:31:26101
[email protected]6a4d7f62013-01-07 21:32:13102namespace {
[email protected]b256eca2013-07-11 10:57:40103
104typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
105
106class TextInputModeMapSingleton {
107 public:
108 static TextInputModeMapSingleton* GetInstance() {
109 return Singleton<TextInputModeMapSingleton>::get();
110 }
111 TextInputModeMapSingleton()
112 : map() {
113 map["verbatim"] = ui::TEXT_INPUT_MODE_VERBATIM;
114 map["latin"] = ui::TEXT_INPUT_MODE_LATIN;
115 map["latin-name"] = ui::TEXT_INPUT_MODE_LATIN_NAME;
116 map["latin-prose"] = ui::TEXT_INPUT_MODE_LATIN_PROSE;
117 map["full-width-latin"] = ui::TEXT_INPUT_MODE_FULL_WIDTH_LATIN;
118 map["kana"] = ui::TEXT_INPUT_MODE_KANA;
119 map["katakana"] = ui::TEXT_INPUT_MODE_KATAKANA;
120 map["numeric"] = ui::TEXT_INPUT_MODE_NUMERIC;
121 map["tel"] = ui::TEXT_INPUT_MODE_TEL;
122 map["email"] = ui::TEXT_INPUT_MODE_EMAIL;
123 map["url"] = ui::TEXT_INPUT_MODE_URL;
124 }
125 TextInputModeMap& Map() {
126 return map;
127 }
128 private:
129 TextInputModeMap map;
130
131 friend struct DefaultSingletonTraits<TextInputModeMapSingleton>;
132
133 DISALLOW_COPY_AND_ASSIGN(TextInputModeMapSingleton);
134};
135
136ui::TextInputMode ConvertInputMode(
137 const WebKit::WebString& input_mode) {
138 static TextInputModeMapSingleton* singleton =
139 TextInputModeMapSingleton::GetInstance();
140 TextInputModeMap::iterator it = singleton->Map().find(input_mode.utf8());
141 if (it == singleton->Map().end())
142 return ui::TEXT_INPUT_MODE_DEFAULT;
143 return it->second;
[email protected]6a4d7f62013-01-07 21:32:13144}
[email protected]b256eca2013-07-11 10:57:40145
[email protected]fd847792013-10-24 17:12:35146// TODO(brianderson): Replace the hard-coded threshold with a fraction of
147// the BeginMainFrame interval.
148// 4166us will allow 1/4 of a 60Hz interval or 1/2 of a 120Hz interval to
149// be spent in input hanlders before input starts getting throttled.
150const int kInputHandlingTimeThrottlingThresholdMicroseconds = 4166;
151
[email protected]b256eca2013-07-11 10:57:40152} // namespace
153
[email protected]e9ff79c2012-10-19 21:31:26154namespace content {
[email protected]62cb33cae2009-03-27 23:30:22155
[email protected]b2e4c70132013-10-03 02:07:51156// RenderWidget::ScreenMetricsEmulator ----------------------------------------
157
158class RenderWidget::ScreenMetricsEmulator {
159 public:
160 ScreenMetricsEmulator(
161 RenderWidget* widget,
162 const gfx::Size& device_size,
163 const gfx::Rect& widget_rect,
164 float device_scale_factor,
165 bool fit_to_view);
166 virtual ~ScreenMetricsEmulator();
167
168 float scale() { return scale_; }
169 gfx::Rect widget_rect() const { return widget_rect_; }
170 gfx::Rect original_screen_rect() const { return original_view_screen_rect_; }
171
172 void ChangeEmulationParams(
173 const gfx::Size& device_size,
174 const gfx::Rect& widget_rect,
175 float device_scale_factor,
176 bool fit_to_view);
177
178 // The following methods alter handlers' behavior for messages related to
179 // widget size and position.
180 void OnResizeMessage(const ViewMsg_Resize_Params& params);
181 void OnUpdateScreenRectsMessage(const gfx::Rect& view_screen_rect,
182 const gfx::Rect& window_screen_rect);
183 void OnShowContextMenu(ContextMenuParams* params);
184
185 private:
186 void Apply(float overdraw_bottom_height,
187 gfx::Rect resizer_rect, bool is_fullscreen);
188
189 RenderWidget* widget_;
190
191 // Parameters as passed by RenderWidget::EmulateScreenMetrics.
192 gfx::Size device_size_;
193 gfx::Rect widget_rect_;
194 float device_scale_factor_;
195 bool fit_to_view_;
196
197 // The computed scaled used to fit widget into browser window.
198 float scale_;
199
200 // Original values to restore back after emulation ends.
201 gfx::Size original_size_;
202 gfx::Size original_physical_backing_size_;
203 WebKit::WebScreenInfo original_screen_info_;
204 gfx::Rect original_view_screen_rect_;
205 gfx::Rect original_window_screen_rect_;
206};
207
208RenderWidget::ScreenMetricsEmulator::ScreenMetricsEmulator(
209 RenderWidget* widget,
210 const gfx::Size& device_size,
211 const gfx::Rect& widget_rect,
212 float device_scale_factor,
213 bool fit_to_view)
214 : widget_(widget),
215 device_size_(device_size),
216 widget_rect_(widget_rect),
217 device_scale_factor_(device_scale_factor),
218 fit_to_view_(fit_to_view),
219 scale_(1.f) {
220 original_size_ = widget_->size_;
221 original_physical_backing_size_ = widget_->physical_backing_size_;
222 original_screen_info_ = widget_->screen_info_;
223 original_view_screen_rect_ = widget_->view_screen_rect_;
224 original_window_screen_rect_ = widget_->window_screen_rect_;
225 Apply(widget_->overdraw_bottom_height_,
226 widget_->resizer_rect_, widget_->is_fullscreen_);
227}
228
229RenderWidget::ScreenMetricsEmulator::~ScreenMetricsEmulator() {
230 widget_->screen_info_ = original_screen_info_;
231
232 widget_->SetDeviceScaleFactor(original_screen_info_.deviceScaleFactor);
233 widget_->SetScreenMetricsEmulationParameters(0.f, 1.f);
234 widget_->view_screen_rect_ = original_view_screen_rect_;
235 widget_->window_screen_rect_ = original_window_screen_rect_;
236 widget_->Resize(original_size_, original_physical_backing_size_,
237 widget_->overdraw_bottom_height_, widget_->resizer_rect_,
238 widget_->is_fullscreen_, NO_RESIZE_ACK);
239}
240
241void RenderWidget::ScreenMetricsEmulator::ChangeEmulationParams(
242 const gfx::Size& device_size,
243 const gfx::Rect& widget_rect,
244 float device_scale_factor,
245 bool fit_to_view) {
246 device_size_ = device_size;
247 widget_rect_ = widget_rect;
248 device_scale_factor_ = device_scale_factor;
249 fit_to_view_ = fit_to_view;
250 Apply(widget_->overdraw_bottom_height_,
251 widget_->resizer_rect_, widget_->is_fullscreen_);
252}
253
254void RenderWidget::ScreenMetricsEmulator::Apply(
255 float overdraw_bottom_height, gfx::Rect resizer_rect, bool is_fullscreen) {
256 if (fit_to_view_) {
257 DCHECK(!original_size_.IsEmpty());
258 float width_ratio =
259 static_cast<float>(widget_rect_.width()) / original_size_.width();
260 float height_ratio =
261 static_cast<float>(widget_rect_.height()) / original_size_.height();
262 float ratio = std::max(1.0f, std::max(width_ratio, height_ratio));
263 scale_ = 1.f / ratio;
264 } else {
265 scale_ = 1.f;
266 }
267
268 widget_->screen_info_.rect = gfx::Rect(device_size_);
269 widget_->screen_info_.availableRect = gfx::Rect(device_size_);
270 widget_->screen_info_.deviceScaleFactor = device_scale_factor_;
271
272 // Pass two emulation parameters to the blink side:
273 // - we keep the real device scale factor in compositor to produce sharp image
274 // even when emulating different scale factor;
275 // - in order to fit into view, WebView applies scaling transform to the
276 // root layer.
277 widget_->SetScreenMetricsEmulationParameters(
278 original_screen_info_.deviceScaleFactor, scale_);
279
280 widget_->SetDeviceScaleFactor(device_scale_factor_);
281 widget_->view_screen_rect_ = widget_rect_;
282 widget_->window_screen_rect_ = widget_->screen_info_.availableRect;
283
284 gfx::Size physical_backing_size = gfx::ToCeiledSize(gfx::ScaleSize(
285 original_size_, original_screen_info_.deviceScaleFactor));
286 widget_->Resize(widget_rect_.size(), physical_backing_size,
287 overdraw_bottom_height, resizer_rect, is_fullscreen, NO_RESIZE_ACK);
288}
289
290void RenderWidget::ScreenMetricsEmulator::OnResizeMessage(
291 const ViewMsg_Resize_Params& params) {
292 bool need_ack = params.new_size != original_size_ &&
293 !params.new_size.IsEmpty() && !params.physical_backing_size.IsEmpty();
294 original_size_ = params.new_size;
295 original_physical_backing_size_ = params.physical_backing_size;
296 original_screen_info_ = params.screen_info;
297 Apply(params.overdraw_bottom_height, params.resizer_rect,
298 params.is_fullscreen);
299
300 if (need_ack) {
301 widget_->set_next_paint_is_resize_ack();
302 if (widget_->compositor_)
303 widget_->compositor_->SetNeedsRedrawRect(gfx::Rect(widget_->size_));
304 }
305}
306
307void RenderWidget::ScreenMetricsEmulator::OnUpdateScreenRectsMessage(
308 const gfx::Rect& view_screen_rect,
309 const gfx::Rect& window_screen_rect) {
310 original_view_screen_rect_ = view_screen_rect;
311 original_window_screen_rect_ = window_screen_rect;
312}
313
314void RenderWidget::ScreenMetricsEmulator::OnShowContextMenu(
315 ContextMenuParams* params) {
316 params->x *= scale_;
317 params->y *= scale_;
318}
319
320// RenderWidget ---------------------------------------------------------------
321
[email protected]6fd35b72012-03-01 19:46:41322RenderWidget::RenderWidget(WebKit::WebPopupType popup_type,
[email protected]842f10652012-06-06 01:54:04323 const WebKit::WebScreenInfo& screen_info,
[email protected]1ac10dca2013-08-20 20:47:04324 bool swapped_out,
325 bool hidden)
initial.commit09911bf2008-07-26 23:55:29326 : routing_id_(MSG_ROUTING_NONE),
[email protected]9f4f3322012-01-18 22:29:56327 surface_id_(0),
[email protected]c5b3b5e2009-02-13 06:41:11328 webwidget_(NULL),
initial.commit09911bf2008-07-26 23:55:29329 opener_id_(MSG_ROUTING_NONE),
[email protected]fc4404d2012-11-07 19:53:30330 init_complete_(false),
[email protected]b4d08452010-10-05 17:34:35331 current_paint_buf_(NULL),
[email protected]d9083762013-03-24 01:36:40332 overdraw_bottom_height_(0.f),
initial.commit09911bf2008-07-26 23:55:29333 next_paint_flags_(0),
[email protected]0cff69e2011-11-22 22:26:06334 filtered_time_per_frame_(0.0f),
[email protected]53d3f302009-12-21 04:42:05335 update_reply_pending_(false),
[email protected]847a2582013-03-09 02:29:51336 auto_resize_mode_(false),
[email protected]ea3ee0a2012-05-15 03:43:09337 need_update_rect_for_auto_resize_(false),
[email protected]65225772011-05-12 21:10:24338 using_asynchronous_swapbuffers_(false),
339 num_swapbuffers_complete_pending_(0),
initial.commit09911bf2008-07-26 23:55:29340 did_show_(false),
[email protected]1ac10dca2013-08-20 20:47:04341 is_hidden_(hidden),
[email protected]ee41e7d22011-10-14 19:34:09342 is_fullscreen_(false),
initial.commit09911bf2008-07-26 23:55:29343 needs_repainting_on_restore_(false),
344 has_focus_(false),
[email protected]5dd768212009-08-13 23:34:49345 handling_input_event_(false),
[email protected]e8f775f2013-02-14 21:00:50346 handling_ime_event_(false),
[email protected]661eb9d2009-02-03 02:11:48347 closing_(false),
[email protected]14392a52012-05-02 20:28:44348 is_swapped_out_(swapped_out),
[email protected]fa7b1dc2010-06-23 17:53:04349 input_method_is_active_(false),
[email protected]ad26ef42011-06-17 07:59:45350 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
[email protected]b256eca2013-07-11 10:57:40351 text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
[email protected]86ba5fcb2013-09-04 00:36:53352 can_compose_inline_(true),
[email protected]3e2b375b2010-04-07 17:03:12353 popup_type_(popup_type),
[email protected]867125a02009-12-10 06:01:48354 pending_window_rect_count_(0),
[email protected]b68a0e52011-12-08 15:11:12355 suppress_next_char_events_(false),
[email protected]5f8b1022011-01-21 23:34:50356 is_accelerated_compositing_active_(false),
[email protected]d8a6c5d12013-09-23 04:37:10357 was_accelerated_compositing_ever_active_(false),
[email protected]ee3d3ad2011-02-04 00:42:21358 animation_update_pending_(false),
[email protected]4b03e292012-02-13 18:40:07359 invalidation_task_posted_(false),
[email protected]842f10652012-06-06 01:54:04360 screen_info_(screen_info),
[email protected]3d779472012-11-15 20:49:52361 device_scale_factor_(screen_info_.deviceScaleFactor),
[email protected]ed7defa2013-03-12 21:29:59362 is_threaded_compositing_enabled_(false),
[email protected]53b4cc12013-07-18 23:02:30363 next_output_surface_id_(0),
[email protected]0d1ebed12013-08-05 22:01:13364#if defined(OS_ANDROID)
365 outstanding_ime_acks_(0),
366#endif
[email protected]b2e4c70132013-10-03 02:07:51367 popup_origin_scale_for_emulation_(0.f),
[email protected]5b45ad42013-10-25 00:42:04368 resizing_mode_selector_(new ResizingModeSelector()),
[email protected]69e797f2013-04-30 01:10:22369 weak_ptr_factory_(this) {
[email protected]8b3f0eb2012-05-03 19:15:05370 if (!swapped_out)
371 RenderProcess::current()->AddRefProcess();
[email protected]380244092011-10-07 17:26:27372 DCHECK(RenderThread::Get());
[email protected]bd37ae252011-06-03 01:28:18373 has_disable_gpu_vsync_switch_ = CommandLine::ForCurrentProcess()->HasSwitch(
374 switches::kDisableGpuVsync);
[email protected]cb6430932012-10-31 00:53:36375 is_threaded_compositing_enabled_ =
376 CommandLine::ForCurrentProcess()->HasSwitch(
377 switches::kEnableThreadedCompositing);
[email protected]c1e6cc062013-08-24 03:35:35378
379 legacy_software_mode_stats_ = cc::RenderingStatsInstrumentation::Create();
380 if (CommandLine::ForCurrentProcess()->HasSwitch(
381 switches::kEnableGpuBenchmarking))
382 legacy_software_mode_stats_->set_record_rendering_stats(true);
initial.commit09911bf2008-07-26 23:55:29383}
384
385RenderWidget::~RenderWidget() {
[email protected]c5b3b5e2009-02-13 06:41:11386 DCHECK(!webwidget_) << "Leaking our WebWidget!";
[email protected]aa4117f2011-12-09 22:19:21387 STLDeleteElements(&updates_pending_swap_);
[email protected]b4d08452010-10-05 17:34:35388 if (current_paint_buf_) {
[email protected]467414eb2013-07-30 20:32:29389 if (RenderProcess::current()) {
390 // If the RenderProcess is already gone, it will have released all DIBs
391 // in its destructor anyway.
392 RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
393 }
[email protected]b4d08452010-10-05 17:34:35394 current_paint_buf_ = NULL;
initial.commit09911bf2008-07-26 23:55:29395 }
[email protected]992db4c2011-05-12 15:37:15396 // If we are swapped out, we have released already.
[email protected]d2e2f9ee2013-08-21 11:02:02397 if (!is_swapped_out_ && RenderProcess::current())
[email protected]992db4c2011-05-12 15:37:15398 RenderProcess::current()->ReleaseProcess();
initial.commit09911bf2008-07-26 23:55:29399}
400
[email protected]484955942010-08-19 16:13:18401// static
[email protected]8085dbc82008-09-26 22:53:44402RenderWidget* RenderWidget::Create(int32 opener_id,
[email protected]842f10652012-06-06 01:54:04403 WebKit::WebPopupType popup_type,
404 const WebKit::WebScreenInfo& screen_info) {
initial.commit09911bf2008-07-26 23:55:29405 DCHECK(opener_id != MSG_ROUTING_NONE);
[email protected]6fd35b72012-03-01 19:46:41406 scoped_refptr<RenderWidget> widget(
[email protected]1ac10dca2013-08-20 20:47:04407 new RenderWidget(popup_type, screen_info, false, false));
[email protected]a635f942012-12-07 10:34:29408 if (widget->Init(opener_id)) { // adds reference on success.
[email protected]fc72bb12013-06-02 21:13:46409 return widget.get();
[email protected]a635f942012-12-07 10:34:29410 }
411 return NULL;
initial.commit09911bf2008-07-26 23:55:29412}
413
[email protected]484955942010-08-19 16:13:18414// static
415WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) {
416 switch (render_widget->popup_type_) {
[email protected]e2356242010-11-16 22:33:03417 case WebKit::WebPopupTypeNone: // Nothing to create.
[email protected]484955942010-08-19 16:13:18418 break;
419 case WebKit::WebPopupTypeSelect:
420 case WebKit::WebPopupTypeSuggestion:
421 return WebPopupMenu::create(render_widget);
[email protected]a7547fb2012-03-08 04:43:44422 case WebKit::WebPopupTypePage:
423 return WebPagePopup::create(render_widget);
[email protected]4b1146bc2012-07-10 18:46:03424 case WebKit::WebPopupTypeHelperPlugin:
425 return WebKit::WebHelperPlugin::create(render_widget);
[email protected]484955942010-08-19 16:13:18426 default:
427 NOTREACHED();
428 }
429 return NULL;
430}
431
[email protected]a635f942012-12-07 10:34:29432bool RenderWidget::Init(int32 opener_id) {
433 return DoInit(opener_id,
434 RenderWidget::CreateWebWidget(this),
435 new ViewHostMsg_CreateWidget(opener_id, popup_type_,
436 &routing_id_, &surface_id_));
[email protected]484955942010-08-19 16:13:18437}
438
[email protected]a635f942012-12-07 10:34:29439bool RenderWidget::DoInit(int32 opener_id,
[email protected]6a8ddba52010-09-05 04:38:06440 WebWidget* web_widget,
[email protected]484955942010-08-19 16:13:18441 IPC::SyncMessage* create_widget_message) {
initial.commit09911bf2008-07-26 23:55:29442 DCHECK(!webwidget_);
443
444 if (opener_id != MSG_ROUTING_NONE)
445 opener_id_ = opener_id;
446
[email protected]484955942010-08-19 16:13:18447 webwidget_ = web_widget;
initial.commit09911bf2008-07-26 23:55:29448
[email protected]380244092011-10-07 17:26:27449 bool result = RenderThread::Get()->Send(create_widget_message);
initial.commit09911bf2008-07-26 23:55:29450 if (result) {
[email protected]380244092011-10-07 17:26:27451 RenderThread::Get()->AddRoute(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29452 // Take a reference on behalf of the RenderThread. This will be balanced
453 // when we receive ViewMsg_Close.
454 AddRef();
[email protected]1ac10dca2013-08-20 20:47:04455 if (is_hidden_)
456 RenderThread::Get()->WidgetHidden();
[email protected]a635f942012-12-07 10:34:29457 return true;
initial.commit09911bf2008-07-26 23:55:29458 } else {
[email protected]a635f942012-12-07 10:34:29459 // The above Send can fail when the tab is closing.
460 return false;
initial.commit09911bf2008-07-26 23:55:29461 }
462}
463
[email protected]fc4404d2012-11-07 19:53:30464// This is used to complete pending inits and non-pending inits.
465void RenderWidget::CompleteInit() {
initial.commit09911bf2008-07-26 23:55:29466 DCHECK(routing_id_ != MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29467
[email protected]fc4404d2012-11-07 19:53:30468 init_complete_ = true;
[email protected]05a980d7a2012-02-07 22:16:42469
[email protected]8926c602013-01-23 05:32:06470 if (webwidget_ && is_threaded_compositing_enabled_) {
471 webwidget_->enterForceCompositingMode(true);
472 }
[email protected]ba91a792013-02-06 09:48:28473 if (compositor_) {
474 compositor_->setSurfaceReady();
[email protected]479b0172012-10-29 19:27:09475 }
[email protected]05a980d7a2012-02-07 22:16:42476 DoDeferredUpdate();
initial.commit09911bf2008-07-26 23:55:29477
[email protected]6de74452009-02-25 18:04:59478 Send(new ViewHostMsg_RenderViewReady(routing_id_));
initial.commit09911bf2008-07-26 23:55:29479}
480
[email protected]992db4c2011-05-12 15:37:15481void RenderWidget::SetSwappedOut(bool is_swapped_out) {
482 // We should only toggle between states.
483 DCHECK(is_swapped_out_ != is_swapped_out);
484 is_swapped_out_ = is_swapped_out;
485
486 // If we are swapping out, we will call ReleaseProcess, allowing the process
487 // to exit if all of its RenderViews are swapped out. We wait until the
488 // WasSwappedOut call to do this, to avoid showing the sad tab.
489 // If we are swapping in, we call AddRefProcess to prevent the process from
490 // exiting.
491 if (!is_swapped_out)
492 RenderProcess::current()->AddRefProcess();
493}
494
[email protected]34bb3ac2013-03-08 02:41:28495bool RenderWidget::AllowPartialSwap() const {
496 return true;
497}
498
[email protected]c8cbae72013-05-23 10:45:03499bool RenderWidget::UsingSynchronousRendererCompositor() const {
[email protected]ccc1722e2013-05-06 19:43:07500#if defined(OS_ANDROID)
[email protected]913d99a2013-05-31 07:16:07501 return SynchronousCompositorFactory::GetInstance() != NULL;
502#else
[email protected]ccc1722e2013-05-06 19:43:07503 return false;
[email protected]913d99a2013-05-31 07:16:07504#endif
[email protected]ccc1722e2013-05-06 19:43:07505}
506
[email protected]b2e4c70132013-10-03 02:07:51507void RenderWidget::EnableScreenMetricsEmulation(
508 const gfx::Size& device_size,
509 const gfx::Rect& widget_rect,
510 float device_scale_factor,
511 bool fit_to_view) {
512 if (!screen_metrics_emulator_) {
513 screen_metrics_emulator_.reset(new ScreenMetricsEmulator(this,
514 device_size, widget_rect, device_scale_factor, fit_to_view));
515 } else {
516 screen_metrics_emulator_->ChangeEmulationParams(device_size,
517 widget_rect, device_scale_factor, fit_to_view);
518 }
519}
520
521void RenderWidget::DisableScreenMetricsEmulation() {
522 screen_metrics_emulator_.reset();
523}
524
525void RenderWidget::SetPopupOriginAdjustmentsForEmulation(
526 ScreenMetricsEmulator* emulator) {
527 popup_origin_scale_for_emulation_ = emulator->scale();
528 popup_view_origin_for_emulation_ = emulator->widget_rect().origin();
529 popup_screen_origin_for_emulation_ =
530 emulator->original_screen_rect().origin();
531}
532
533void RenderWidget::SetScreenMetricsEmulationParameters(
534 float device_scale_factor, float root_layer_scale) {
535 // This is only supported in RenderView.
536 NOTREACHED();
537}
538
539void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
540 ExternalPopupMenu* popup, ScreenMetricsEmulator* emulator) {
541 popup->SetOriginScaleForEmulation(emulator->scale());
542}
543
544void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
545 if (screen_metrics_emulator_)
546 screen_metrics_emulator_->OnShowContextMenu(params);
547}
548
[email protected]7d08a9352013-10-15 08:24:56549void RenderWidget::ScheduleCompositeWithForcedRedraw() {
550 if (compositor_) {
551 // Regardless of whether threaded compositing is enabled, always
552 // use this mechanism to force the compositor to redraw. However,
553 // the invalidation code path below is still needed for the
554 // non-threaded case.
555 compositor_->SetNeedsForcedRedraw();
556 }
557 ScheduleCompositeImpl(true);
558}
559
560void RenderWidget::ScheduleCompositeImpl(bool force_redraw) {
561 if (RenderThreadImpl::current()->compositor_message_loop_proxy().get() &&
562 compositor_) {
563 if (!force_redraw) {
564 compositor_->setNeedsRedraw();
565 }
566 } else {
567 // TODO(nduca): replace with something a little less hacky. The reason this
568 // hack is still used is because the Invalidate-DoDeferredUpdate loop
569 // contains a lot of host-renderer synchronization logic that is still
570 // important for the accelerated compositing case. The option of simply
571 // duplicating all that code is less desirable than "faking out" the
572 // invalidation path using a magical damage rect.
573 didInvalidateRect(WebRect(0, 0, 1, 1));
574 }
575}
576
[email protected]a95986a82010-12-24 06:19:28577bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
578 bool handled = true;
579 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
[email protected]c084330e02013-04-27 01:08:15580 IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
[email protected]34202de2013-05-06 23:36:22581 IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
582 OnCursorVisibilityChange)
[email protected]c084330e02013-04-27 01:08:15583 IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
584 IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
[email protected]a95986a82010-12-24 06:19:28585 IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
586 IPC_MESSAGE_HANDLER(ViewMsg_CreatingNew_ACK, OnCreatingNewAck)
587 IPC_MESSAGE_HANDLER(ViewMsg_Resize, OnResize)
[email protected]b5913d72012-02-07 22:26:54588 IPC_MESSAGE_HANDLER(ViewMsg_ChangeResizeRect, OnChangeResizeRect)
[email protected]a95986a82010-12-24 06:19:28589 IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
[email protected]9e2e4632012-07-27 16:38:41590 IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
[email protected]992db4c2011-05-12 15:37:15591 IPC_MESSAGE_HANDLER(ViewMsg_WasSwappedOut, OnWasSwappedOut)
[email protected]a95986a82010-12-24 06:19:28592 IPC_MESSAGE_HANDLER(ViewMsg_UpdateRect_ACK, OnUpdateRectAck)
[email protected]ed7defa2013-03-12 21:29:59593 IPC_MESSAGE_HANDLER(ViewMsg_SwapBuffers_ACK,
594 OnViewContextSwapBuffersComplete)
[email protected]a95986a82010-12-24 06:19:28595 IPC_MESSAGE_HANDLER(ViewMsg_SetInputMethodActive, OnSetInputMethodActive)
596 IPC_MESSAGE_HANDLER(ViewMsg_ImeSetComposition, OnImeSetComposition)
597 IPC_MESSAGE_HANDLER(ViewMsg_ImeConfirmComposition, OnImeConfirmComposition)
[email protected]3d9ec5052013-01-02 22:05:25598 IPC_MESSAGE_HANDLER(ViewMsg_PaintAtSize, OnPaintAtSize)
599 IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
[email protected]79fa22e2013-08-23 15:18:12600 IPC_MESSAGE_HANDLER(ViewMsg_SyntheticGestureCompleted,
601 OnSyntheticGestureCompleted)
[email protected]a95986a82010-12-24 06:19:28602 IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
603 IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
[email protected]80ad8622012-11-07 16:33:03604 IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
[email protected]105dffb42013-02-20 03:46:21605#if defined(OS_ANDROID)
[email protected]2384b6c2013-02-28 23:58:51606 IPC_MESSAGE_HANDLER(ViewMsg_ShowImeIfNeeded, OnShowImeIfNeeded)
[email protected]0d1ebed12013-08-05 22:01:13607 IPC_MESSAGE_HANDLER(ViewMsg_ImeEventAck, OnImeEventAck)
[email protected]105dffb42013-02-20 03:46:21608#endif
[email protected]51a49502013-03-23 01:50:19609 IPC_MESSAGE_HANDLER(ViewMsg_Snapshot, OnSnapshot)
[email protected]3639aa82013-06-04 11:00:04610 IPC_MESSAGE_HANDLER(ViewMsg_SetBrowserRenderingStats,
611 OnSetBrowserRenderingStats)
[email protected]a95986a82010-12-24 06:19:28612 IPC_MESSAGE_UNHANDLED(handled = false)
613 IPC_END_MESSAGE_MAP()
614 return handled;
615}
initial.commit09911bf2008-07-26 23:55:29616
617bool RenderWidget::Send(IPC::Message* message) {
[email protected]992db4c2011-05-12 15:37:15618 // Don't send any messages after the browser has told us to close, and filter
619 // most outgoing messages while swapped out.
620 if ((is_swapped_out_ &&
[email protected]e9ff79c2012-10-19 21:31:26621 !SwappedOutMessages::CanSendWhileSwappedOut(message)) ||
[email protected]c6c921e92012-05-10 23:31:11622 closing_) {
initial.commit09911bf2008-07-26 23:55:29623 delete message;
624 return false;
625 }
626
627 // If given a messsage without a routing ID, then assign our routing ID.
628 if (message->routing_id() == MSG_ROUTING_NONE)
629 message->set_routing_id(routing_id_);
630
[email protected]380244092011-10-07 17:26:27631 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44632}
633
[email protected]61e2b3cc2012-03-02 16:13:34634void RenderWidget::Resize(const gfx::Size& new_size,
[email protected]60d47ac2013-03-01 23:42:44635 const gfx::Size& physical_backing_size,
[email protected]d9083762013-03-24 01:36:40636 float overdraw_bottom_height,
[email protected]61e2b3cc2012-03-02 16:13:34637 const gfx::Rect& resizer_rect,
638 bool is_fullscreen,
639 ResizeAck resize_ack) {
[email protected]5b45ad42013-10-25 00:42:04640 if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]1c0008842013-06-06 08:35:48641 // A resize ack shouldn't be requested if we have not ACK'd the previous
642 // one.
643 DCHECK(resize_ack != SEND_RESIZE_ACK || !next_paint_is_resize_ack());
644 DCHECK(resize_ack == SEND_RESIZE_ACK || resize_ack == NO_RESIZE_ACK);
645 }
initial.commit09911bf2008-07-26 23:55:29646
[email protected]61e2b3cc2012-03-02 16:13:34647 // Ignore this during shutdown.
648 if (!webwidget_)
649 return;
650
[email protected]d9083762013-03-24 01:36:40651 if (compositor_) {
[email protected]60d47ac2013-03-01 23:42:44652 compositor_->setViewportSize(new_size, physical_backing_size);
[email protected]d9083762013-03-24 01:36:40653 compositor_->SetOverdrawBottomHeight(overdraw_bottom_height);
654 }
[email protected]60d47ac2013-03-01 23:42:44655
[email protected]dade8992013-03-04 07:34:34656 physical_backing_size_ = physical_backing_size;
[email protected]d9083762013-03-24 01:36:40657 overdraw_bottom_height_ = overdraw_bottom_height;
[email protected]61e2b3cc2012-03-02 16:13:34658 resizer_rect_ = resizer_rect;
659
660 // NOTE: We may have entered fullscreen mode without changing our size.
661 bool fullscreen_change = is_fullscreen_ != is_fullscreen;
662 if (fullscreen_change)
663 WillToggleFullscreen();
664 is_fullscreen_ = is_fullscreen;
665
666 if (size_ != new_size) {
667 // TODO(darin): We should not need to reset this here.
[email protected]61e2b3cc2012-03-02 16:13:34668 needs_repainting_on_restore_ = false;
669
670 size_ = new_size;
671
672 paint_aggregator_.ClearPendingUpdate();
673
674 // When resizing, we want to wait to paint before ACK'ing the resize. This
675 // ensures that we only resize as fast as we can paint. We only need to
676 // send an ACK if we are resized to a non-empty rect.
677 webwidget_->resize(new_size);
[email protected]0b70dbe2013-05-10 19:06:32678
[email protected]5b45ad42013-10-25 00:42:04679 if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]92201e32013-06-08 06:14:52680 // Resize should have caused an invalidation of the entire view.
681 DCHECK(new_size.IsEmpty() || is_accelerated_compositing_active_ ||
682 paint_aggregator_.HasPendingUpdate());
683 }
[email protected]5b45ad42013-10-25 00:42:04684 } else if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]632c4382013-05-15 08:58:45685 resize_ack = NO_RESIZE_ACK;
686 }
687
688 if (new_size.IsEmpty() || physical_backing_size.IsEmpty()) {
689 // For empty size or empty physical_backing_size, there is no next paint
690 // (along with which to send the ack) until they are set to non-empty.
[email protected]ff475a322012-03-14 00:05:35691 resize_ack = NO_RESIZE_ACK;
[email protected]61e2b3cc2012-03-02 16:13:34692 }
693
[email protected]20fbfc22013-05-08 20:50:58694 // Send the Resize_ACK flag once we paint again if requested.
[email protected]632c4382013-05-15 08:58:45695 if (resize_ack == SEND_RESIZE_ACK)
[email protected]20fbfc22013-05-08 20:50:58696 set_next_paint_is_resize_ack();
697
[email protected]61e2b3cc2012-03-02 16:13:34698 if (fullscreen_change)
699 DidToggleFullscreen();
700
701 // If a resize ack is requested and it isn't set-up, then no more resizes will
702 // come in and in general things will go wrong.
[email protected]632c4382013-05-15 08:58:45703 DCHECK(resize_ack != SEND_RESIZE_ACK || next_paint_is_resize_ack());
initial.commit09911bf2008-07-26 23:55:29704}
705
706void RenderWidget::OnClose() {
707 if (closing_)
708 return;
709 closing_ = true;
710
711 // Browser correspondence is no longer needed at this point.
[email protected]bee16aab2009-08-26 15:55:03712 if (routing_id_ != MSG_ROUTING_NONE) {
[email protected]380244092011-10-07 17:26:27713 RenderThread::Get()->RemoveRoute(routing_id_);
[email protected]bee16aab2009-08-26 15:55:03714 SetHidden(false);
715 }
initial.commit09911bf2008-07-26 23:55:29716
initial.commit09911bf2008-07-26 23:55:29717 // If there is a Send call on the stack, then it could be dangerous to close
[email protected]d3fc25652009-02-24 22:31:25718 // now. Post a task that only gets invoked when there are no nested message
719 // loops.
[email protected]dd32b1272013-05-04 14:17:11720 base::MessageLoop::current()->PostNonNestableTask(
[email protected]3a5a7822011-12-23 18:27:29721 FROM_HERE, base::Bind(&RenderWidget::Close, this));
[email protected]d3fc25652009-02-24 22:31:25722
723 // Balances the AddRef taken when we called AddRoute.
724 Release();
initial.commit09911bf2008-07-26 23:55:29725}
726
[email protected]61e2b3cc2012-03-02 16:13:34727// Got a response from the browser after the renderer decided to create a new
728// view.
[email protected]fc4404d2012-11-07 19:53:30729void RenderWidget::OnCreatingNewAck() {
[email protected]61e2b3cc2012-03-02 16:13:34730 DCHECK(routing_id_ != MSG_ROUTING_NONE);
731
[email protected]fc4404d2012-11-07 19:53:30732 CompleteInit();
[email protected]61e2b3cc2012-03-02 16:13:34733}
734
[email protected]0fdd5012013-05-29 08:05:56735void RenderWidget::OnResize(const ViewMsg_Resize_Params& params) {
[email protected]5b45ad42013-10-25 00:42:04736 if (resizing_mode_selector_->ShouldAbortOnResize(this, params))
[email protected]03e88672013-10-22 21:31:32737 return;
738
[email protected]b2e4c70132013-10-03 02:07:51739 if (screen_metrics_emulator_) {
740 screen_metrics_emulator_->OnResizeMessage(params);
741 return;
742 }
743
[email protected]0fdd5012013-05-29 08:05:56744 screen_info_ = params.screen_info;
745 SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
746 Resize(params.new_size, params.physical_backing_size,
747 params.overdraw_bottom_height, params.resizer_rect,
748 params.is_fullscreen, SEND_RESIZE_ACK);
initial.commit09911bf2008-07-26 23:55:29749}
750
[email protected]b5913d72012-02-07 22:26:54751void RenderWidget::OnChangeResizeRect(const gfx::Rect& resizer_rect) {
752 if (resizer_rect_ != resizer_rect) {
[email protected]b9769d82012-02-10 00:23:59753 gfx::Rect view_rect(size_);
754
[email protected]ce112fe2012-10-29 22:52:18755 gfx::Rect old_damage_rect = gfx::IntersectRects(view_rect, resizer_rect_);
[email protected]b9769d82012-02-10 00:23:59756 if (!old_damage_rect.IsEmpty())
757 paint_aggregator_.InvalidateRect(old_damage_rect);
758
[email protected]ce112fe2012-10-29 22:52:18759 gfx::Rect new_damage_rect = gfx::IntersectRects(view_rect, resizer_rect);
[email protected]b9769d82012-02-10 00:23:59760 if (!new_damage_rect.IsEmpty())
761 paint_aggregator_.InvalidateRect(new_damage_rect);
762
[email protected]b5913d72012-02-07 22:26:54763 resizer_rect_ = resizer_rect;
[email protected]b9769d82012-02-10 00:23:59764
[email protected]b5913d72012-02-07 22:26:54765 if (webwidget_)
766 webwidget_->didChangeWindowResizerRect();
767 }
768}
769
initial.commit09911bf2008-07-26 23:55:29770void RenderWidget::OnWasHidden() {
[email protected]9c3085f2011-06-09 02:10:31771 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
initial.commit09911bf2008-07-26 23:55:29772 // Go into a mode where we stop generating paint and scrolling events.
[email protected]bee16aab2009-08-26 15:55:03773 SetHidden(true);
initial.commit09911bf2008-07-26 23:55:29774}
775
[email protected]9e2e4632012-07-27 16:38:41776void RenderWidget::OnWasShown(bool needs_repainting) {
777 TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
initial.commit09911bf2008-07-26 23:55:29778 // During shutdown we can just ignore this message.
779 if (!webwidget_)
780 return;
781
782 // See OnWasHidden
[email protected]bee16aab2009-08-26 15:55:03783 SetHidden(false);
initial.commit09911bf2008-07-26 23:55:29784
785 if (!needs_repainting && !needs_repainting_on_restore_)
786 return;
787 needs_repainting_on_restore_ = false;
788
[email protected]d65adb12010-04-28 17:26:49789 // Tag the next paint as a restore ack, which is picked up by
790 // DoDeferredUpdate when it sends out the next PaintRect message.
initial.commit09911bf2008-07-26 23:55:29791 set_next_paint_is_restore_ack();
792
793 // Generate a full repaint.
[email protected]a79d8a632010-11-18 22:35:56794 if (!is_accelerated_compositing_active_) {
[email protected]f98d7e3c2010-09-13 22:30:46795 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
796 } else {
797 scheduleComposite();
798 }
initial.commit09911bf2008-07-26 23:55:29799}
800
[email protected]992db4c2011-05-12 15:37:15801void RenderWidget::OnWasSwappedOut() {
802 // If we have been swapped out and no one else is using this process,
803 // it's safe to exit now. If we get swapped back in, we will call
804 // AddRefProcess in SetSwappedOut.
805 if (is_swapped_out_)
806 RenderProcess::current()->ReleaseProcess();
807}
808
[email protected]53d3f302009-12-21 04:42:05809void RenderWidget::OnRequestMoveAck() {
810 DCHECK(pending_window_rect_count_);
811 pending_window_rect_count_--;
812}
813
814void RenderWidget::OnUpdateRectAck() {
[email protected]366ae242011-05-10 02:23:58815 TRACE_EVENT0("renderer", "RenderWidget::OnUpdateRectAck");
[email protected]aa4117f2011-12-09 22:19:21816 DCHECK(update_reply_pending_);
[email protected]53d3f302009-12-21 04:42:05817 update_reply_pending_ = false;
818
[email protected]b4d08452010-10-05 17:34:35819 // If we sent an UpdateRect message with a zero-sized bitmap, then we should
820 // have no current paint buffer.
821 if (current_paint_buf_) {
822 RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
823 current_paint_buf_ = NULL;
824 }
825
[email protected]65225772011-05-12 21:10:24826 // If swapbuffers is still pending, then defer the update until the
827 // swapbuffers occurs.
828 if (num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending) {
829 TRACE_EVENT0("renderer", "EarlyOut_SwapStillPending");
830 return;
831 }
832
[email protected]29ed96a2012-02-04 18:12:16833 // Notify subclasses that software rendering was flushed to the screen.
[email protected]404939f2012-06-01 04:06:18834 if (!is_accelerated_compositing_active_) {
835 DidFlushPaint();
836 }
[email protected]a2f6bc112009-06-27 16:27:25837
initial.commit09911bf2008-07-26 23:55:29838 // Continue painting if necessary...
[email protected]65225772011-05-12 21:10:24839 DoDeferredUpdateAndSendInputAck();
840}
841
[email protected]d0be63772011-12-20 23:18:04842bool RenderWidget::SupportsAsynchronousSwapBuffers() {
[email protected]ed7defa2013-03-12 21:29:59843 // Contexts using the command buffer support asynchronous swapbuffers.
844 // See RenderWidget::CreateOutputSurface().
[email protected]cadac622013-06-11 16:46:36845 if (RenderThreadImpl::current()->compositor_message_loop_proxy().get())
[email protected]ed7defa2013-03-12 21:29:59846 return false;
847
848 return true;
849}
850
851GURL RenderWidget::GetURLForGraphicsContext3D() {
852 return GURL();
[email protected]65225772011-05-12 21:10:24853}
854
[email protected]479b0172012-10-29 19:27:09855bool RenderWidget::ForceCompositingModeEnabled() {
856 return false;
857}
858
[email protected]ebc0e1df2013-08-01 02:46:22859scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(bool fallback) {
[email protected]a1811b8912013-05-09 15:35:19860
861#if defined(OS_ANDROID)
[email protected]b6eb8e332013-09-10 00:51:01862 if (SynchronousCompositorFactory* factory =
863 SynchronousCompositorFactory::GetInstance()) {
[email protected]913d99a2013-05-31 07:16:07864 return factory->CreateOutputSurface(routing_id());
[email protected]a1811b8912013-05-09 15:35:19865 }
866#endif
867
[email protected]ed7defa2013-03-12 21:29:59868 // Explicitly disable antialiasing for the compositor. As of the time of
869 // this writing, the only platform that supported antialiasing for the
870 // compositor was Mac OS X, because the on-screen OpenGL context creation
871 // code paths on Windows and Linux didn't yet have multisampling support.
872 // Mac OS X essentially always behaves as though it's rendering offscreen.
873 // Multisampling has a heavy cost especially on devices with relatively low
874 // fill rate like most notebooks, and the Mac implementation would need to
875 // be optimized to resolve directly into the IOSurface shared between the
876 // GPU and browser processes. For these reasons and to avoid platform
877 // disparities we explicitly disable antialiasing.
878 WebKit::WebGraphicsContext3D::Attributes attributes;
879 attributes.antialias = false;
880 attributes.shareResources = true;
881 attributes.noAutomaticFlushes = true;
[email protected]a6886502013-05-16 20:59:18882 attributes.depth = false;
883 attributes.stencil = false;
[email protected]b6eb8e332013-09-10 00:51:01884
885 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
[email protected]bec084292013-05-21 21:31:44886 if (command_line.HasSwitch(cc::switches::kForceDirectLayerDrawing))
887 attributes.stencil = true;
[email protected]b6eb8e332013-09-10 00:51:01888
[email protected]0634cdd42013-08-16 00:46:09889 scoped_refptr<ContextProviderCommandBuffer> context_provider;
890 if (!fallback) {
891 context_provider = ContextProviderCommandBuffer::Create(
[email protected]af13d832013-09-13 06:56:27892 CreateGraphicsContext3D(attributes),
893 "RenderCompositor");
[email protected]0634cdd42013-08-16 00:46:09894 }
[email protected]ebc0e1df2013-08-01 02:46:22895
[email protected]b6eb8e332013-09-10 00:51:01896 uint32 output_surface_id = next_output_surface_id_++;
[email protected]0634cdd42013-08-16 00:46:09897 if (!context_provider.get()) {
[email protected]ebc0e1df2013-08-01 02:46:22898 if (!command_line.HasSwitch(switches::kEnableSoftwareCompositing))
899 return scoped_ptr<cc::OutputSurface>();
[email protected]0634cdd42013-08-16 00:46:09900
901 scoped_ptr<cc::SoftwareOutputDevice> software_device(
902 new CompositorSoftwareOutputDevice());
903
904 return scoped_ptr<cc::OutputSurface>(new CompositorOutputSurface(
905 routing_id(),
906 output_surface_id,
907 NULL,
908 software_device.Pass(),
909 true));
[email protected]ebc0e1df2013-08-01 02:46:22910 }
[email protected]ed7defa2013-03-12 21:29:59911
[email protected]0c04d1c2013-07-10 00:02:32912 if (command_line.HasSwitch(switches::kEnableDelegatedRenderer) &&
913 !command_line.HasSwitch(switches::kDisableDelegatedRenderer)) {
[email protected]36e5ff12013-06-11 12:19:29914 DCHECK(is_threaded_compositing_enabled_);
915 return scoped_ptr<cc::OutputSurface>(
[email protected]0634cdd42013-08-16 00:46:09916 new DelegatedCompositorOutputSurface(
917 routing_id(),
918 output_surface_id,
919 context_provider,
920 scoped_ptr<cc::SoftwareOutputDevice>()));
[email protected]36e5ff12013-06-11 12:19:29921 }
922 if (command_line.HasSwitch(cc::switches::kCompositeToMailbox)) {
923 DCHECK(is_threaded_compositing_enabled_);
[email protected]186f09602013-09-24 07:13:16924 cc::ResourceFormat format = cc::RGBA_8888;
925#if defined(OS_ANDROID)
926 if (base::android::SysUtils::IsLowEndDevice())
927 format = cc::RGB_565;
928#endif
[email protected]36e5ff12013-06-11 12:19:29929 return scoped_ptr<cc::OutputSurface>(
[email protected]0634cdd42013-08-16 00:46:09930 new MailboxOutputSurface(
931 routing_id(),
932 output_surface_id,
933 context_provider,
[email protected]186f09602013-09-24 07:13:16934 scoped_ptr<cc::SoftwareOutputDevice>(),
935 format));
[email protected]36e5ff12013-06-11 12:19:29936 }
[email protected]0634cdd42013-08-16 00:46:09937 bool use_swap_compositor_frame_message = false;
[email protected]36e5ff12013-06-11 12:19:29938 return scoped_ptr<cc::OutputSurface>(
[email protected]0634cdd42013-08-16 00:46:09939 new CompositorOutputSurface(
940 routing_id(),
941 output_surface_id,
942 context_provider,
943 scoped_ptr<cc::SoftwareOutputDevice>(),
944 use_swap_compositor_frame_message));
[email protected]ba91a792013-02-06 09:48:28945}
946
[email protected]ed7defa2013-03-12 21:29:59947void RenderWidget::OnViewContextSwapBuffersAborted() {
[email protected]65225772011-05-12 21:10:24948 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
[email protected]aa4117f2011-12-09 22:19:21949 while (!updates_pending_swap_.empty()) {
950 ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
951 updates_pending_swap_.pop_front();
952 // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
953 // compositing pass, hence doesn't require an UpdateRect message.
954 if (msg)
955 Send(msg);
956 }
[email protected]65225772011-05-12 21:10:24957 num_swapbuffers_complete_pending_ = 0;
958 using_asynchronous_swapbuffers_ = false;
959 // Schedule another frame so the compositor learns about it.
960 scheduleComposite();
961}
962
[email protected]ed7defa2013-03-12 21:29:59963void RenderWidget::OnViewContextSwapBuffersPosted() {
[email protected]37a6f302011-07-11 23:43:08964 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
[email protected]aa4117f2011-12-09 22:19:21965
966 if (using_asynchronous_swapbuffers_) {
967 ViewHostMsg_UpdateRect* msg = NULL;
968 // pending_update_params_ can be NULL if the swap doesn't correspond to an
969 // DoDeferredUpdate compositing pass, hence doesn't require an UpdateRect
970 // message.
[email protected]59383c782013-04-17 16:43:27971 if (pending_update_params_) {
[email protected]aa4117f2011-12-09 22:19:21972 msg = new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_);
973 pending_update_params_.reset();
974 }
975 updates_pending_swap_.push_back(msg);
[email protected]37a6f302011-07-11 23:43:08976 num_swapbuffers_complete_pending_++;
[email protected]aa4117f2011-12-09 22:19:21977 }
[email protected]37a6f302011-07-11 23:43:08978}
979
[email protected]ed7defa2013-03-12 21:29:59980void RenderWidget::OnViewContextSwapBuffersComplete() {
[email protected]65225772011-05-12 21:10:24981 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersComplete");
[email protected]29ed96a2012-02-04 18:12:16982
[email protected]404939f2012-06-01 04:06:18983 // Notify subclasses that composited rendering was flushed to the screen.
[email protected]29ed96a2012-02-04 18:12:16984 DidFlushPaint();
985
[email protected]65225772011-05-12 21:10:24986 // When compositing deactivates, we reset the swapbuffers pending count. The
987 // swapbuffers acks may still arrive, however.
988 if (num_swapbuffers_complete_pending_ == 0) {
989 TRACE_EVENT0("renderer", "EarlyOut_ZeroSwapbuffersPending");
990 return;
991 }
[email protected]aa4117f2011-12-09 22:19:21992 DCHECK(!updates_pending_swap_.empty());
993 ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
994 updates_pending_swap_.pop_front();
995 // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
996 // compositing pass, hence doesn't require an UpdateRect message.
997 if (msg)
998 Send(msg);
[email protected]65225772011-05-12 21:10:24999 num_swapbuffers_complete_pending_--;
1000
1001 // If update reply is still pending, then defer the update until that reply
1002 // occurs.
[email protected]d0be63772011-12-20 23:18:041003 if (update_reply_pending_) {
[email protected]65225772011-05-12 21:10:241004 TRACE_EVENT0("renderer", "EarlyOut_UpdateReplyPending");
1005 return;
1006 }
1007
1008 // If we are not accelerated rendering, then this is a stale swapbuffers from
[email protected]50312bf2011-06-22 23:30:061009 // when we were previously rendering. However, if an invalidation task is not
1010 // posted, there may be software rendering work pending. In that case, don't
1011 // early out.
1012 if (!is_accelerated_compositing_active_ && invalidation_task_posted_) {
[email protected]65225772011-05-12 21:10:241013 TRACE_EVENT0("renderer", "EarlyOut_AcceleratedCompositingOff");
1014 return;
1015 }
1016
[email protected]cc66e682012-10-02 06:48:181017 // Do not call DoDeferredUpdate unless there's animation work to be done or
1018 // a real invalidation. This prevents rendering in response to a swapbuffers
1019 // callback coming back after we've navigated away from the page that
1020 // generated it.
1021 if (!animation_update_pending_ && !paint_aggregator_.HasPendingUpdate()) {
1022 TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
1023 return;
1024 }
1025
[email protected]65225772011-05-12 21:10:241026 // Continue painting if necessary...
1027 DoDeferredUpdateAndSendInputAck();
initial.commit09911bf2008-07-26 23:55:291028}
1029
[email protected]0dea1652012-12-14 00:09:091030void RenderWidget::OnHandleInputEvent(const WebKit::WebInputEvent* input_event,
[email protected]4b157662013-05-29 04:05:051031 const ui::LatencyInfo& latency_info,
[email protected]0dea1652012-12-14 00:09:091032 bool is_keyboard_shortcut) {
[email protected]5dd768212009-08-13 23:34:491033 handling_input_event_ = true;
[email protected]0dea1652012-12-14 00:09:091034 if (!input_event) {
[email protected]5dd768212009-08-13 23:34:491035 handling_input_event_ = false;
initial.commit09911bf2008-07-26 23:55:291036 return;
[email protected]5dd768212009-08-13 23:34:491037 }
initial.commit09911bf2008-07-26 23:55:291038
[email protected]fd847792013-10-24 17:12:351039 base::TimeTicks start_time;
1040 if (base::TimeTicks::IsHighResNowFastAndReliable())
1041 start_time = base::TimeTicks::HighResNow();
1042
[email protected]8e299aa2013-10-16 18:17:441043 const char* const event_name =
1044 WebInputEventTraits::GetName(input_event->type);
[email protected]b4841e1c2013-05-16 22:30:101045 TRACE_EVENT1("renderer", "RenderWidget::OnHandleInputEvent",
1046 "event", event_name);
1047
[email protected]c2eaa8f2013-05-10 02:41:551048 if (compositor_)
1049 compositor_->SetLatencyInfo(latency_info);
[email protected]256737c2013-06-08 04:39:101050 else
1051 latency_info_.MergeWith(latency_info);
[email protected]c2eaa8f2013-05-10 02:41:551052
[email protected]6a4d7f62013-01-07 21:32:131053 base::TimeDelta now = base::TimeDelta::FromInternalValue(
1054 base::TimeTicks::Now().ToInternalValue());
1055
1056 int64 delta = static_cast<int64>(
1057 (now.InSecondsF() - input_event->timeStampSeconds) *
1058 base::Time::kMicrosecondsPerSecond);
1059 UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.Renderer", delta, 0, 1000000, 100);
[email protected]de415552013-01-23 04:12:171060 base::HistogramBase* counter_for_type =
[email protected]bafdc5d52013-02-27 18:18:481061 base::Histogram::FactoryGet(
[email protected]b4841e1c2013-05-16 22:30:101062 base::StringPrintf("Event.Latency.Renderer.%s", event_name),
[email protected]bafdc5d52013-02-27 18:18:481063 0,
1064 1000000,
[email protected]6a4d7f62013-01-07 21:32:131065 100,
[email protected]de415552013-01-23 04:12:171066 base::HistogramBase::kUmaTargetedHistogramFlag);
[email protected]bafdc5d52013-02-27 18:18:481067 counter_for_type->Add(delta);
[email protected]6a4d7f62013-01-07 21:32:131068
[email protected]67bfb83f2011-09-22 03:36:371069 bool prevent_default = false;
1070 if (WebInputEvent::isMouseEventType(input_event->type)) {
[email protected]936c6f52011-12-13 01:35:261071 const WebMouseEvent& mouse_event =
1072 *static_cast<const WebMouseEvent*>(input_event);
1073 TRACE_EVENT2("renderer", "HandleMouseMove",
1074 "x", mouse_event.x, "y", mouse_event.y);
1075 prevent_default = WillHandleMouseEvent(mouse_event);
[email protected]67bfb83f2011-09-22 03:36:371076 }
1077
[email protected]f56c7872013-06-18 12:31:571078 if (WebInputEvent::isKeyboardEventType(input_event->type)) {
1079 const WebKeyboardEvent& key_event =
1080 *static_cast<const WebKeyboardEvent*>(input_event);
1081 prevent_default = WillHandleKeyEvent(key_event);
1082 }
1083
[email protected]41d86852012-11-07 12:23:241084 if (WebInputEvent::isGestureEventType(input_event->type)) {
1085 const WebGestureEvent& gesture_event =
1086 *static_cast<const WebGestureEvent*>(input_event);
1087 prevent_default = prevent_default || WillHandleGestureEvent(gesture_event);
1088 }
1089
[email protected]3ebcc7c2013-01-09 05:34:461090 if (input_event->type == WebInputEvent::GestureTap ||
1091 input_event->type == WebInputEvent::GestureLongPress)
1092 resetInputMethod();
1093
[email protected]67bfb83f2011-09-22 03:36:371094 bool processed = prevent_default;
[email protected]b68a0e52011-12-08 15:11:121095 if (input_event->type != WebInputEvent::Char || !suppress_next_char_events_) {
1096 suppress_next_char_events_ = false;
1097 if (!processed && webwidget_)
1098 processed = webwidget_->handleInputEvent(*input_event);
1099 }
1100
1101 // If this RawKeyDown event corresponds to a browser keyboard shortcut and
1102 // it's not processed by webkit, then we need to suppress the upcoming Char
1103 // events.
1104 if (!processed && is_keyboard_shortcut)
1105 suppress_next_char_events_ = true;
initial.commit09911bf2008-07-26 23:55:291106
[email protected]3d5c243b2012-11-30 00:26:011107 InputEventAckState ack_result = processed ?
1108 INPUT_EVENT_ACK_STATE_CONSUMED : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1109 if (!processed && input_event->type == WebInputEvent::TouchStart) {
1110 const WebTouchEvent& touch_event =
1111 *static_cast<const WebTouchEvent*>(input_event);
1112 ack_result = HasTouchEventHandlersAt(touch_event.touches[0].position) ?
1113 INPUT_EVENT_ACK_STATE_NOT_CONSUMED :
1114 INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
1115 }
1116
[email protected]a9fb30aa2011-10-06 06:58:461117 IPC::Message* response =
[email protected]f6df0edf2013-08-07 00:27:021118 new InputHostMsg_HandleInputEvent_ACK(routing_id_,
1119 input_event->type,
1120 ack_result,
1121 latency_info);
[email protected]fd847792013-10-24 17:12:351122 bool event_type_can_be_rate_limited =
[email protected]3391a0772012-03-28 00:32:071123 input_event->type == WebInputEvent::MouseMove ||
1124 input_event->type == WebInputEvent::MouseWheel ||
[email protected]3475bb52013-10-03 08:25:161125 input_event->type == WebInputEvent::TouchMove;
[email protected]8926c602013-01-23 05:32:061126
1127 bool frame_pending = paint_aggregator_.HasPendingUpdate();
1128 if (is_accelerated_compositing_active_) {
[email protected]ba91a792013-02-06 09:48:281129 frame_pending = compositor_ &&
1130 compositor_->commitRequested();
[email protected]8926c602013-01-23 05:32:061131 }
1132
[email protected]fd847792013-10-24 17:12:351133 // If we don't have a fast and accurate HighResNow, we assume the input
1134 // handlers are heavy and rate limit them.
1135 bool rate_limiting_wanted = true;
1136 if (base::TimeTicks::IsHighResNowFastAndReliable()) {
1137 base::TimeTicks end_time = base::TimeTicks::HighResNow();
1138 total_input_handling_time_this_frame_ += (end_time - start_time);
1139 rate_limiting_wanted =
1140 total_input_handling_time_this_frame_.InMicroseconds() >
1141 kInputHandlingTimeThrottlingThresholdMicroseconds;
1142 }
1143
1144 if (rate_limiting_wanted && event_type_can_be_rate_limited &&
1145 frame_pending && !is_hidden_) {
[email protected]12fbad812009-09-01 18:21:241146 // We want to rate limit the input events in this case, so we'll wait for
1147 // painting to finish before ACKing this message.
[email protected]fd847792013-10-24 17:12:351148 TRACE_EVENT_INSTANT0("renderer",
1149 "RenderWidget::OnHandleInputEvent ack throttled",
1150 TRACE_EVENT_SCOPE_THREAD);
[email protected]59383c782013-04-17 16:43:271151 if (pending_input_event_ack_) {
[email protected]353a34c2010-05-28 23:35:171152 // As two different kinds of events could cause us to postpone an ack
1153 // we send it now, if we have one pending. The Browser should never
1154 // send us the same kind of event we are delaying the ack for.
1155 Send(pending_input_event_ack_.release());
1156 }
[email protected]12fbad812009-09-01 18:21:241157 pending_input_event_ack_.reset(response);
[email protected]df09e052013-07-31 18:59:501158 if (compositor_)
1159 compositor_->NotifyInputThrottledUntilCommit();
[email protected]12fbad812009-09-01 18:21:241160 } else {
1161 Send(response);
1162 }
1163
[email protected]3306f262012-09-21 19:20:421164#if defined(OS_ANDROID)
1165 // Allow the IME to be shown when the focus changes as a consequence
1166 // of a processed touch end event.
1167 if (input_event->type == WebInputEvent::TouchEnd && processed)
[email protected]0d1ebed12013-08-05 22:01:131168 UpdateTextInputState(true, true);
[email protected]3306f262012-09-21 19:20:421169#endif
1170
[email protected]5dd768212009-08-13 23:34:491171 handling_input_event_ = false;
[email protected]446705872009-09-10 07:22:481172
[email protected]67bfb83f2011-09-22 03:36:371173 if (!prevent_default) {
1174 if (WebInputEvent::isKeyboardEventType(input_event->type))
1175 DidHandleKeyEvent();
1176 if (WebInputEvent::isMouseEventType(input_event->type))
1177 DidHandleMouseEvent(*(static_cast<const WebMouseEvent*>(input_event)));
[email protected]2d0f2e92011-10-03 09:02:241178 if (WebInputEvent::isTouchEventType(input_event->type))
1179 DidHandleTouchEvent(*(static_cast<const WebTouchEvent*>(input_event)));
[email protected]67bfb83f2011-09-22 03:36:371180 }
initial.commit09911bf2008-07-26 23:55:291181}
1182
[email protected]34202de2013-05-06 23:36:221183void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
1184 if (webwidget_)
1185 webwidget_->setCursorVisibilityState(is_visible);
1186}
1187
initial.commit09911bf2008-07-26 23:55:291188void RenderWidget::OnMouseCaptureLost() {
1189 if (webwidget_)
[email protected]4873c7d2009-07-16 06:36:281190 webwidget_->mouseCaptureLost();
initial.commit09911bf2008-07-26 23:55:291191}
1192
1193void RenderWidget::OnSetFocus(bool enable) {
1194 has_focus_ = enable;
[email protected]9d166af2010-03-02 22:04:331195 if (webwidget_)
1196 webwidget_->setFocus(enable);
initial.commit09911bf2008-07-26 23:55:291197}
1198
1199void RenderWidget::ClearFocus() {
1200 // We may have got the focus from the browser before this gets processed, in
1201 // which case we do not want to unfocus ourself.
1202 if (!has_focus_ && webwidget_)
[email protected]4873c7d2009-07-16 06:36:281203 webwidget_->setFocus(false);
initial.commit09911bf2008-07-26 23:55:291204}
1205
[email protected]2d5d09d52009-06-15 14:29:211206void RenderWidget::PaintRect(const gfx::Rect& rect,
[email protected]4fb66842009-12-04 21:41:001207 const gfx::Point& canvas_origin,
[email protected]2d5d09d52009-06-15 14:29:211208 skia::PlatformCanvas* canvas) {
[email protected]50312bf2011-06-22 23:30:061209 TRACE_EVENT2("renderer", "PaintRect",
1210 "width", rect.width(), "height", rect.height());
[email protected]63ab54262012-11-09 15:58:451211
[email protected]4fb66842009-12-04 21:41:001212 canvas->save();
[email protected]2d5d09d52009-06-15 14:29:211213
1214 // Bring the canvas into the coordinate system of the paint rect.
[email protected]4fb66842009-12-04 21:41:001215 canvas->translate(static_cast<SkScalar>(-canvas_origin.x()),
1216 static_cast<SkScalar>(-canvas_origin.y()));
[email protected]96c3499a2009-05-02 18:31:031217
[email protected]699ab0d2009-04-23 23:19:141218 // If there is a custom background, tile it.
1219 if (!background_.empty()) {
[email protected]699ab0d2009-04-23 23:19:141220 SkPaint paint;
[email protected]4e29afd2012-12-04 04:07:111221 skia::RefPtr<SkShader> shader = skia::AdoptRef(
1222 SkShader::CreateBitmapShader(background_,
1223 SkShader::kRepeat_TileMode,
1224 SkShader::kRepeat_TileMode));
1225 paint.setShader(shader.get());
[email protected]fb10ec5b2011-10-24 17:54:201226
1227 // Use kSrc_Mode to handle background_ transparency properly.
1228 paint.setXfermodeMode(SkXfermode::kSrc_Mode);
1229
1230 // Canvas could contain multiple update rects. Clip to given rect so that
1231 // we don't accidentally clear other update rects.
1232 canvas->save();
[email protected]aa7e7a12013-02-22 13:37:441233 canvas->scale(device_scale_factor_, device_scale_factor_);
[email protected]1835b9e2012-02-28 13:12:481234 canvas->clipRect(gfx::RectToSkRect(rect));
[email protected]699ab0d2009-04-23 23:19:141235 canvas->drawPaint(paint);
[email protected]fb10ec5b2011-10-24 17:54:201236 canvas->restore();
[email protected]699ab0d2009-04-23 23:19:141237 }
1238
[email protected]719b36f2010-12-22 20:36:461239 // First see if this rect is a plugin that can paint itself faster.
1240 TransportDIB* optimized_dib = NULL;
1241 gfx::Rect optimized_copy_rect, optimized_copy_location;
[email protected]0f3a2d12012-09-01 03:37:201242 float dib_scale_factor;
[email protected]adab2332013-07-25 18:04:321243 PepperPluginInstanceImpl* optimized_instance =
[email protected]719b36f2010-12-22 20:36:461244 GetBitmapForOptimizedPluginPaint(rect, &optimized_dib,
1245 &optimized_copy_location,
[email protected]0f3a2d12012-09-01 03:37:201246 &optimized_copy_rect,
1247 &dib_scale_factor);
[email protected]719b36f2010-12-22 20:36:461248 if (optimized_instance) {
[email protected]20790a222013-07-25 02:23:051249#if defined(ENABLE_PLUGINS)
[email protected]719b36f2010-12-22 20:36:461250 // This plugin can be optimize-painted and we can just ask it to paint
1251 // itself. We don't actually need the TransportDIB in this case.
1252 //
1253 // This is an optimization for PPAPI plugins that know they're on top of
1254 // the page content. If this rect is inside such a plugin, we can save some
1255 // time and avoid re-rendering the page content which we know will be
1256 // covered by the plugin later (this time can be significant, especially
1257 // for a playing movie that is invalidating a lot).
1258 //
1259 // In the plugin movie case, hopefully the similar call to
1260 // GetBitmapForOptimizedPluginPaint in DoDeferredUpdate handles the
1261 // painting, because that avoids copying the plugin image to a different
1262 // paint rect. Unfortunately, if anything on the page is animating other
1263 // than the movie, it break this optimization since the union of the
1264 // invalid regions will be larger than the plugin.
1265 //
1266 // This code optimizes that case, where we can still avoid painting in
1267 // WebKit and filling the background (which can be slow) and just painting
1268 // the plugin. Unlike the DoDeferredUpdate case, an extra copy is still
1269 // required.
[email protected]df59dd42012-09-14 22:56:301270 SkAutoCanvasRestore auto_restore(canvas, true);
1271 canvas->scale(device_scale_factor_, device_scale_factor_);
[email protected]6bd867b2013-07-24 22:10:201272 optimized_instance->Paint(canvas, optimized_copy_location, rect);
[email protected]ea43e752012-09-06 22:39:211273 canvas->restore();
[email protected]20790a222013-07-25 02:23:051274#endif
[email protected]719b36f2010-12-22 20:36:461275 } else {
1276 // Normal painting case.
[email protected]c1e6cc062013-08-24 03:35:351277 base::TimeTicks start_time;
1278 if (!is_accelerated_compositing_active_)
1279 start_time = legacy_software_mode_stats_->StartRecording();
[email protected]63ab54262012-11-09 15:58:451280
[email protected]6bd867b2013-07-24 22:10:201281 webwidget_->paint(canvas, rect);
[email protected]63ab54262012-11-09 15:58:451282
[email protected]c1e6cc062013-08-24 03:35:351283 if (!is_accelerated_compositing_active_) {
[email protected]63ab54262012-11-09 15:58:451284 base::TimeDelta paint_time =
[email protected]c1e6cc062013-08-24 03:35:351285 legacy_software_mode_stats_->EndRecording(start_time);
1286 int64 painted_pixel_count = rect.width() * rect.height();
1287 legacy_software_mode_stats_->AddPaint(paint_time, painted_pixel_count);
[email protected]63ab54262012-11-09 15:58:451288 }
[email protected]719b36f2010-12-22 20:36:461289
1290 // Flush to underlying bitmap. TODO(darin): is this needed?
[email protected]62f2e802011-05-26 14:28:351291 skia::GetTopDevice(*canvas)->accessBitmap(false);
[email protected]719b36f2010-12-22 20:36:461292 }
initial.commit09911bf2008-07-26 23:55:291293
[email protected]4fb66842009-12-04 21:41:001294 PaintDebugBorder(rect, canvas);
[email protected]4fb66842009-12-04 21:41:001295 canvas->restore();
1296}
1297
1298void RenderWidget::PaintDebugBorder(const gfx::Rect& rect,
1299 skia::PlatformCanvas* canvas) {
1300 static bool kPaintBorder =
1301 CommandLine::ForCurrentProcess()->HasSwitch(switches::kShowPaintRects);
1302 if (!kPaintBorder)
1303 return;
1304
[email protected]53d3f302009-12-21 04:42:051305 // Cycle through these colors to help distinguish new paint rects.
1306 const SkColor colors[] = {
1307 SkColorSetARGB(0x3F, 0xFF, 0, 0),
1308 SkColorSetARGB(0x3F, 0xFF, 0, 0xFF),
1309 SkColorSetARGB(0x3F, 0, 0, 0xFF),
1310 };
1311 static int color_selector = 0;
1312
[email protected]4fb66842009-12-04 21:41:001313 SkPaint paint;
1314 paint.setStyle(SkPaint::kStroke_Style);
[email protected]53d3f302009-12-21 04:42:051315 paint.setColor(colors[color_selector++ % arraysize(colors)]);
[email protected]4fb66842009-12-04 21:41:001316 paint.setStrokeWidth(1);
1317
1318 SkIRect irect;
1319 irect.set(rect.x(), rect.y(), rect.right() - 1, rect.bottom() - 1);
1320 canvas->drawIRect(irect, paint);
initial.commit09911bf2008-07-26 23:55:291321}
1322
[email protected]52ccd0ea2011-02-16 01:09:051323void RenderWidget::AnimationCallback() {
[email protected]921244e42011-07-20 16:36:301324 TRACE_EVENT0("renderer", "RenderWidget::AnimationCallback");
[email protected]921244e42011-07-20 16:36:301325 if (!animation_update_pending_) {
1326 TRACE_EVENT0("renderer", "EarlyOut_NoAnimationUpdatePending");
[email protected]7c4329e2011-02-18 22:02:591327 return;
[email protected]921244e42011-07-20 16:36:301328 }
[email protected]bd37ae252011-06-03 01:28:181329 if (!animation_floor_time_.is_null() && IsRenderingVSynced()) {
[email protected]7c4329e2011-02-18 22:02:591330 // Record when we fired (according to base::Time::Now()) relative to when
1331 // we posted the task to quantify how much the base::Time/base::TimeTicks
1332 // skew is affecting animations.
1333 base::TimeDelta animation_callback_delay = base::Time::Now() -
1334 (animation_floor_time_ - base::TimeDelta::FromMilliseconds(16));
1335 UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.AnimationCallbackDelayTime",
1336 animation_callback_delay,
1337 base::TimeDelta::FromMilliseconds(0),
1338 base::TimeDelta::FromMilliseconds(30),
1339 25);
1340 }
[email protected]65225772011-05-12 21:10:241341 DoDeferredUpdateAndSendInputAck();
[email protected]12fbad812009-09-01 18:21:241342}
1343
[email protected]52ccd0ea2011-02-16 01:09:051344void RenderWidget::AnimateIfNeeded() {
[email protected]7c4329e2011-02-18 22:02:591345 if (!animation_update_pending_)
1346 return;
[email protected]bd37ae252011-06-03 01:28:181347
1348 // Target 60FPS if vsync is on. Go as fast as we can if vsync is off.
[email protected]02798a982012-01-27 00:45:331349 base::TimeDelta animationInterval = IsRenderingVSynced() ?
1350 base::TimeDelta::FromMilliseconds(16) : base::TimeDelta();
[email protected]bd37ae252011-06-03 01:28:181351
[email protected]7c4329e2011-02-18 22:02:591352 base::Time now = base::Time::Now();
[email protected]51e403bb2012-03-02 21:09:451353
1354 // animation_floor_time_ is the earliest time that we should animate when
1355 // using the dead reckoning software scheduler. If we're using swapbuffers
1356 // complete callbacks to rate limit, we can ignore this floor.
1357 if (now >= animation_floor_time_ || num_swapbuffers_complete_pending_ > 0) {
[email protected]921244e42011-07-20 16:36:301358 TRACE_EVENT0("renderer", "RenderWidget::AnimateIfNeeded")
[email protected]02798a982012-01-27 00:45:331359 animation_floor_time_ = now + animationInterval;
[email protected]bd37ae252011-06-03 01:28:181360 // Set a timer to call us back after animationInterval before
[email protected]7c4329e2011-02-18 22:02:591361 // running animation callbacks so that if a callback requests another
1362 // we'll be sure to run it at the proper time.
[email protected]350ce8702012-03-09 04:23:381363 animation_timer_.Stop();
1364 animation_timer_.Start(FROM_HERE, animationInterval, this,
1365 &RenderWidget::AnimationCallback);
[email protected]7c4329e2011-02-18 22:02:591366 animation_update_pending_ = false;
[email protected]ba91a792013-02-06 09:48:281367 if (is_accelerated_compositing_active_ && compositor_) {
[email protected]635353c2013-03-06 09:11:201368 compositor_->Animate(base::TimeTicks::Now());
[email protected]8926c602013-01-23 05:32:061369 } else {
[email protected]635353c2013-03-06 09:11:201370 double frame_begin_time =
1371 (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
1372 webwidget_->animate(frame_begin_time);
[email protected]8926c602013-01-23 05:32:061373 }
[email protected]7c4329e2011-02-18 22:02:591374 return;
[email protected]5f8b1022011-01-21 23:34:501375 }
[email protected]bd37ae252011-06-03 01:28:181376 TRACE_EVENT0("renderer", "EarlyOut_AnimatedTooRecently");
[email protected]350ce8702012-03-09 04:23:381377 if (!animation_timer_.IsRunning()) {
1378 // This code uses base::Time::Now() to calculate the floor and next fire
1379 // time because javascript's Date object uses base::Time::Now(). The
1380 // message loop uses base::TimeTicks, which on windows can have a
1381 // different granularity than base::Time.
1382 // The upshot of all this is that this function might be called before
1383 // base::Time::Now() has advanced past the animation_floor_time_. To
1384 // avoid exposing this delay to javascript, we keep posting delayed
1385 // tasks until base::Time::Now() has advanced far enough.
1386 base::TimeDelta delay = animation_floor_time_ - now;
1387 animation_timer_.Start(FROM_HERE, delay, this,
1388 &RenderWidget::AnimationCallback);
1389 }
[email protected]5f8b1022011-01-21 23:34:501390}
1391
[email protected]bd37ae252011-06-03 01:28:181392bool RenderWidget::IsRenderingVSynced() {
1393 // TODO(nduca): Forcing a driver to disable vsync (e.g. in a control panel) is
1394 // not caught by this check. This will lead to artificially low frame rates
1395 // for people who force vsync off at a driver level and expect Chrome to speed
1396 // up.
1397 return !has_disable_gpu_vsync_switch_;
1398}
1399
[email protected]65225772011-05-12 21:10:241400void RenderWidget::InvalidationCallback() {
[email protected]50312bf2011-06-22 23:30:061401 TRACE_EVENT0("renderer", "RenderWidget::InvalidationCallback");
[email protected]65225772011-05-12 21:10:241402 invalidation_task_posted_ = false;
1403 DoDeferredUpdateAndSendInputAck();
1404}
1405
[email protected]fd847792013-10-24 17:12:351406void RenderWidget::FlushPendingInputEventAck() {
[email protected]d8a8ecb2013-10-23 18:03:071407 if (pending_input_event_ack_)
1408 Send(pending_input_event_ack_.release());
[email protected]fd847792013-10-24 17:12:351409 total_input_handling_time_this_frame_ = base::TimeDelta();
1410}
1411
1412void RenderWidget::DoDeferredUpdateAndSendInputAck() {
1413 DoDeferredUpdate();
1414 FlushPendingInputEventAck();
[email protected]ee3d3ad2011-02-04 00:42:211415}
1416
[email protected]552e6002009-11-19 05:24:571417void RenderWidget::DoDeferredUpdate() {
[email protected]366ae242011-05-10 02:23:581418 TRACE_EVENT0("renderer", "RenderWidget::DoDeferredUpdate");
[email protected]fc8bde1a2013-07-04 08:54:071419 TRACE_EVENT_SCOPED_SAMPLING_STATE("Chrome", "Paint");
[email protected]71e2f0a2011-03-15 22:25:081420
[email protected]65225772011-05-12 21:10:241421 if (!webwidget_)
initial.commit09911bf2008-07-26 23:55:291422 return;
[email protected]05a980d7a2012-02-07 22:16:421423
[email protected]fc4404d2012-11-07 19:53:301424 if (!init_complete_) {
1425 TRACE_EVENT0("renderer", "EarlyOut_InitNotComplete");
[email protected]05a980d7a2012-02-07 22:16:421426 return;
1427 }
[email protected]aa4117f2011-12-09 22:19:211428 if (update_reply_pending_) {
[email protected]65225772011-05-12 21:10:241429 TRACE_EVENT0("renderer", "EarlyOut_UpdateReplyPending");
1430 return;
1431 }
[email protected]9ca84622011-06-02 23:46:391432 if (is_accelerated_compositing_active_ &&
1433 num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending) {
[email protected]65225772011-05-12 21:10:241434 TRACE_EVENT0("renderer", "EarlyOut_MaxSwapBuffersPending");
1435 return;
1436 }
initial.commit09911bf2008-07-26 23:55:291437
[email protected]552e6002009-11-19 05:24:571438 // Suppress updating when we are hidden.
[email protected]e3d92a7f2013-01-10 02:35:051439 if (is_hidden_ || size_.IsEmpty() || is_swapped_out_) {
[email protected]552e6002009-11-19 05:24:571440 paint_aggregator_.ClearPendingUpdate();
initial.commit09911bf2008-07-26 23:55:291441 needs_repainting_on_restore_ = true;
[email protected]65225772011-05-12 21:10:241442 TRACE_EVENT0("renderer", "EarlyOut_NotVisible");
initial.commit09911bf2008-07-26 23:55:291443 return;
1444 }
1445
[email protected]0fb93f52011-05-18 23:13:561446 // Tracking of frame rate jitter
[email protected]de2cf8c2013-10-25 19:46:461447 base::TimeTicks frame_begin_ticks = gfx::FrameTime::Now();
[email protected]38ce4e7b2013-02-23 06:17:371448 InstrumentWillBeginFrame();
[email protected]52ccd0ea2011-02-16 01:09:051449 AnimateIfNeeded();
[email protected]5f8b1022011-01-21 23:34:501450
[email protected]f98d7e3c2010-09-13 22:30:461451 // Layout may generate more invalidation. It may also enable the
1452 // GPU acceleration, so make sure to run layout before we send the
1453 // GpuRenderingActivated message.
1454 webwidget_->layout();
1455
[email protected]793b2d62013-06-11 00:43:251456 // Check for whether we need to track swap buffers. We need to do that after
1457 // layout() because it may have switched us to accelerated compositing.
1458 if (is_accelerated_compositing_active_)
1459 using_asynchronous_swapbuffers_ = SupportsAsynchronousSwapBuffers();
1460
[email protected]dcca3aa92012-02-17 23:03:371461 // The following two can result in further layout and possibly
1462 // enable GPU acceleration so they need to be called before any painting
1463 // is done.
[email protected]cb9e2632013-06-18 11:26:471464 UpdateTextInputType();
[email protected]dcca3aa92012-02-17 23:03:371465 UpdateSelectionBounds();
1466
[email protected]5f8b1022011-01-21 23:34:501467 // Suppress painting if nothing is dirty. This has to be done after updating
1468 // animations running layout as these may generate further invalidations.
[email protected]65225772011-05-12 21:10:241469 if (!paint_aggregator_.HasPendingUpdate()) {
1470 TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
[email protected]38ce4e7b2013-02-23 06:17:371471 InstrumentDidCancelFrame();
[email protected]5f8b1022011-01-21 23:34:501472 return;
[email protected]65225772011-05-12 21:10:241473 }
[email protected]5f8b1022011-01-21 23:34:501474
[email protected]479b0172012-10-29 19:27:091475 if (!is_accelerated_compositing_active_ &&
[email protected]cb6430932012-10-31 00:53:361476 !is_threaded_compositing_enabled_ &&
[email protected]d8a6c5d12013-09-23 04:37:101477 (ForceCompositingModeEnabled() ||
1478 was_accelerated_compositing_ever_active_)) {
[email protected]479b0172012-10-29 19:27:091479 webwidget_->enterForceCompositingMode(true);
1480 }
1481
[email protected]872ae5b2011-05-26 20:20:501482 if (!last_do_deferred_update_time_.is_null()) {
[email protected]0fb93f52011-05-18 23:13:561483 base::TimeDelta delay = frame_begin_ticks - last_do_deferred_update_time_;
[email protected]d0be63772011-12-20 23:18:041484 if (is_accelerated_compositing_active_) {
[email protected]0fb93f52011-05-18 23:13:561485 UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.AccelDoDeferredUpdateDelay",
1486 delay,
1487 base::TimeDelta::FromMilliseconds(1),
[email protected]b604cf82012-07-19 05:31:411488 base::TimeDelta::FromMilliseconds(120),
1489 60);
[email protected]d0be63772011-12-20 23:18:041490 } else {
[email protected]0fb93f52011-05-18 23:13:561491 UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.SoftwareDoDeferredUpdateDelay",
1492 delay,
1493 base::TimeDelta::FromMilliseconds(1),
[email protected]b604cf82012-07-19 05:31:411494 base::TimeDelta::FromMilliseconds(120),
1495 60);
[email protected]d0be63772011-12-20 23:18:041496 }
[email protected]872ae5b2011-05-26 20:20:501497
1498 // Calculate filtered time per frame:
1499 float frame_time_elapsed = static_cast<float>(delay.InSecondsF());
1500 filtered_time_per_frame_ =
1501 0.9f * filtered_time_per_frame_ + 0.1f * frame_time_elapsed;
[email protected]0fb93f52011-05-18 23:13:561502 }
1503 last_do_deferred_update_time_ = frame_begin_ticks;
1504
[email protected]fef5e3972012-08-07 03:59:471505 if (!is_accelerated_compositing_active_) {
[email protected]922c6e1f2013-10-09 04:04:091506 legacy_software_mode_stats_->IncrementFrameCount(1, true);
[email protected]adbe30f2013-10-11 21:12:331507 cc::BenchmarkInstrumentation::IssueMainThreadRenderingStatsEvent(
1508 legacy_software_mode_stats_->main_thread_rendering_stats());
[email protected]c1e6cc062013-08-24 03:35:351509 legacy_software_mode_stats_->AccumulateAndClearMainThreadStats();
[email protected]fef5e3972012-08-07 03:59:471510 }
1511
[email protected]552e6002009-11-19 05:24:571512 // OK, save the pending update to a local since painting may cause more
initial.commit09911bf2008-07-26 23:55:291513 // invalidation. Some WebCore rendering objects only layout when painted.
[email protected]dd015812010-12-06 23:39:301514 PaintAggregator::PendingUpdate update;
1515 paint_aggregator_.PopPendingUpdate(&update);
initial.commit09911bf2008-07-26 23:55:291516
[email protected]53d3f302009-12-21 04:42:051517 gfx::Rect scroll_damage = update.GetScrollDamage();
[email protected]ce112fe2012-10-29 22:52:181518 gfx::Rect bounds = gfx::UnionRects(update.GetPaintBounds(), scroll_damage);
initial.commit09911bf2008-07-26 23:55:291519
[email protected]ca4847f2010-09-24 05:39:151520 // A plugin may be able to do an optimized paint. First check this, in which
1521 // case we can skip all of the bitmap generation and regular paint code.
[email protected]719b36f2010-12-22 20:36:461522 // This optimization allows PPAPI plugins that declare themselves on top of
1523 // the page (like a traditional windowed plugin) to be able to animate (think
1524 // movie playing) without repeatedly re-painting the page underneath, or
1525 // copying the plugin backing store (since we can send the plugin's backing
1526 // store directly to the browser).
1527 //
1528 // This optimization only works when the entire invalid region is contained
1529 // within the plugin. There is a related optimization in PaintRect for the
1530 // case where there may be multiple invalid regions.
[email protected]ca4847f2010-09-24 05:39:151531 TransportDIB* dib = NULL;
[email protected]ca4847f2010-09-24 05:39:151532 gfx::Rect optimized_copy_rect, optimized_copy_location;
[email protected]0f3a2d12012-09-01 03:37:201533 float dib_scale_factor = 1;
[email protected]aa4117f2011-12-09 22:19:211534 DCHECK(!pending_update_params_.get());
1535 pending_update_params_.reset(new ViewHostMsg_UpdateRect_Params);
[email protected]990278ff2012-11-13 02:12:551536 pending_update_params_->scroll_delta = update.scroll_delta;
[email protected]aa4117f2011-12-09 22:19:211537 pending_update_params_->scroll_rect = update.scroll_rect;
1538 pending_update_params_->view_size = size_;
[email protected]aa4117f2011-12-09 22:19:211539 pending_update_params_->plugin_window_moves.swap(plugin_window_moves_);
1540 pending_update_params_->flags = next_paint_flags_;
1541 pending_update_params_->scroll_offset = GetScrollOffset();
1542 pending_update_params_->needs_ack = true;
[email protected]7ded9f12012-06-13 20:47:091543 pending_update_params_->scale_factor = device_scale_factor_;
[email protected]aa4117f2011-12-09 22:19:211544 next_paint_flags_ = 0;
[email protected]ea3ee0a2012-05-15 03:43:091545 need_update_rect_for_auto_resize_ = false;
[email protected]aa4117f2011-12-09 22:19:211546
[email protected]256737c2013-06-08 04:39:101547 if (!is_accelerated_compositing_active_)
1548 pending_update_params_->latency_info = latency_info_;
1549
1550 latency_info_.Clear();
1551
[email protected]ca4847f2010-09-24 05:39:151552 if (update.scroll_rect.IsEmpty() &&
[email protected]a79d8a632010-11-18 22:35:561553 !is_accelerated_compositing_active_ &&
[email protected]ca4847f2010-09-24 05:39:151554 GetBitmapForOptimizedPluginPaint(bounds, &dib, &optimized_copy_location,
[email protected]0f3a2d12012-09-01 03:37:201555 &optimized_copy_rect,
1556 &dib_scale_factor)) {
[email protected]2df1b362011-01-21 21:22:271557 // Only update the part of the plugin that actually changed.
[email protected]d4030502012-10-23 16:51:471558 optimized_copy_rect.Intersect(bounds);
[email protected]aa4117f2011-12-09 22:19:211559 pending_update_params_->bitmap = dib->id();
1560 pending_update_params_->bitmap_rect = optimized_copy_location;
1561 pending_update_params_->copy_rects.push_back(optimized_copy_rect);
[email protected]0f3a2d12012-09-01 03:37:201562 pending_update_params_->scale_factor = dib_scale_factor;
[email protected]a79d8a632010-11-18 22:35:561563 } else if (!is_accelerated_compositing_active_) {
[email protected]f98d7e3c2010-09-13 22:30:461564 // Compute a buffer for painting and cache it.
[email protected]4889bd212013-02-11 22:23:101565
1566 bool fractional_scale = device_scale_factor_ -
1567 static_cast<int>(device_scale_factor_) != 0;
1568 if (fractional_scale) {
1569 // Damage might not be DIP aligned. Inflate damage to compensate.
1570 bounds.Inset(-1, -1);
1571 bounds.Intersect(gfx::Rect(size_));
1572 }
1573
1574 gfx::Rect pixel_bounds = gfx::ToEnclosingRect(
[email protected]ce112fe2012-10-29 22:52:181575 gfx::ScaleRect(bounds, device_scale_factor_));
[email protected]4889bd212013-02-11 22:23:101576
[email protected]ca4847f2010-09-24 05:39:151577 scoped_ptr<skia::PlatformCanvas> canvas(
[email protected]b4d08452010-10-05 17:34:351578 RenderProcess::current()->GetDrawingCanvas(&current_paint_buf_,
[email protected]f1cccb32012-06-06 18:29:591579 pixel_bounds));
[email protected]59383c782013-04-17 16:43:271580 if (!canvas) {
[email protected]f98d7e3c2010-09-13 22:30:461581 NOTREACHED();
1582 return;
1583 }
[email protected]cef3362f2009-12-21 17:48:451584
[email protected]f98d7e3c2010-09-13 22:30:461585 // We may get back a smaller canvas than we asked for.
1586 // TODO(darin): This seems like it could cause painting problems!
[email protected]f1cccb32012-06-06 18:29:591587 DCHECK_EQ(pixel_bounds.width(), canvas->getDevice()->width());
1588 DCHECK_EQ(pixel_bounds.height(), canvas->getDevice()->height());
1589 pixel_bounds.set_width(canvas->getDevice()->width());
1590 pixel_bounds.set_height(canvas->getDevice()->height());
1591 bounds.set_width(pixel_bounds.width() / device_scale_factor_);
1592 bounds.set_height(pixel_bounds.height() / device_scale_factor_);
[email protected]53d3f302009-12-21 04:42:051593
[email protected]f98d7e3c2010-09-13 22:30:461594 HISTOGRAM_COUNTS_100("MPArch.RW_PaintRectCount", update.paint_rects.size());
1595
[email protected]aa4117f2011-12-09 22:19:211596 pending_update_params_->bitmap = current_paint_buf_->id();
1597 pending_update_params_->bitmap_rect = bounds;
1598
1599 std::vector<gfx::Rect>& copy_rects = pending_update_params_->copy_rects;
[email protected]f98d7e3c2010-09-13 22:30:461600 // The scroll damage is just another rectangle to paint and copy.
1601 copy_rects.swap(update.paint_rects);
1602 if (!scroll_damage.IsEmpty())
1603 copy_rects.push_back(scroll_damage);
1604
[email protected]4889bd212013-02-11 22:23:101605 for (size_t i = 0; i < copy_rects.size(); ++i) {
1606 gfx::Rect rect = copy_rects[i];
1607 if (fractional_scale) {
1608 // Damage might not be DPI aligned. Inflate rect to compensate.
1609 rect.Inset(-1, -1);
1610 }
1611 PaintRect(rect, pixel_bounds.origin(), canvas.get());
1612 }
[email protected]60a50072012-01-11 02:05:351613
1614 // Software FPS tick for performance tests. The accelerated path traces the
1615 // frame events in didCommitAndDrawCompositorFrame. See throughput_tests.cc.
1616 // NOTE: Tests may break if this event is renamed or moved.
[email protected]c76faea2013-03-26 07:42:421617 UNSHIPPED_TRACE_EVENT_INSTANT0("test_fps", "TestFrameTickSW",
1618 TRACE_EVENT_SCOPE_THREAD);
[email protected]f98d7e3c2010-09-13 22:30:461619 } else { // Accelerated compositing path
1620 // Begin painting.
[email protected]aa4117f2011-12-09 22:19:211621 // If painting is done via the gpu process then we don't set any damage
1622 // rects to save the browser process from doing unecessary work.
1623 pending_update_params_->bitmap_rect = bounds;
1624 pending_update_params_->scroll_rect = gfx::Rect();
1625 // We don't need an ack, because we're not sharing a DIB with the browser.
1626 // If it needs to (e.g. composited UI), the GPU process does its own ACK
1627 // with the browser for the GPU surface.
1628 pending_update_params_->needs_ack = false;
[email protected]f0c2a242013-03-15 19:34:521629 Composite(frame_begin_ticks);
[email protected]f98d7e3c2010-09-13 22:30:461630 }
1631
[email protected]936c6f52011-12-13 01:35:261632 // If we're holding a pending input event ACK, send the ACK before sending the
1633 // UpdateReply message so we can receive another input event before the
1634 // UpdateRect_ACK on platforms where the UpdateRect_ACK is sent from within
1635 // the UpdateRect IPC message handler.
[email protected]fd847792013-10-24 17:12:351636 FlushPendingInputEventAck();
[email protected]936c6f52011-12-13 01:35:261637
[email protected]ab543072013-01-25 04:38:151638 // If Composite() called SwapBuffers, pending_update_params_ will be reset (in
[email protected]aa4117f2011-12-09 22:19:211639 // OnSwapBuffersPosted), meaning a message has been added to the
1640 // updates_pending_swap_ queue, that will be sent later. Otherwise, we send
1641 // the message now.
[email protected]59383c782013-04-17 16:43:271642 if (pending_update_params_) {
[email protected]aa4117f2011-12-09 22:19:211643 // sending an ack to browser process that the paint is complete...
1644 update_reply_pending_ = pending_update_params_->needs_ack;
1645 Send(new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_));
1646 pending_update_params_.reset();
[email protected]b167ca662010-05-14 00:05:341647 }
[email protected]53d3f302009-12-21 04:42:051648
[email protected]29ed96a2012-02-04 18:12:161649 // If we're software rendering then we're done initiating the paint.
1650 if (!is_accelerated_compositing_active_)
1651 DidInitiatePaint();
initial.commit09911bf2008-07-26 23:55:291652}
1653
[email protected]f0c2a242013-03-15 19:34:521654void RenderWidget::Composite(base::TimeTicks frame_begin_time) {
[email protected]ab543072013-01-25 04:38:151655 DCHECK(is_accelerated_compositing_active_);
[email protected]ba91a792013-02-06 09:48:281656 if (compositor_) // TODO(jamesr): Figure out how this can be null.
[email protected]f0c2a242013-03-15 19:34:521657 compositor_->Composite(frame_begin_time);
[email protected]ab543072013-01-25 04:38:151658}
1659
initial.commit09911bf2008-07-26 23:55:291660///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461661// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291662
[email protected]4873c7d2009-07-16 06:36:281663void RenderWidget::didInvalidateRect(const WebRect& rect) {
[email protected]552e6002009-11-19 05:24:571664 // The invalidated rect might be outside the bounds of the view.
[email protected]ee8d6fd2010-05-26 17:05:481665 gfx::Rect view_rect(size_);
[email protected]ce112fe2012-10-29 22:52:181666 gfx::Rect damaged_rect = gfx::IntersectRects(view_rect, rect);
[email protected]552e6002009-11-19 05:24:571667 if (damaged_rect.IsEmpty())
initial.commit09911bf2008-07-26 23:55:291668 return;
1669
[email protected]552e6002009-11-19 05:24:571670 paint_aggregator_.InvalidateRect(damaged_rect);
1671
1672 // We may not need to schedule another call to DoDeferredUpdate.
[email protected]65225772011-05-12 21:10:241673 if (invalidation_task_posted_)
[email protected]552e6002009-11-19 05:24:571674 return;
1675 if (!paint_aggregator_.HasPendingUpdate())
1676 return;
[email protected]aa4117f2011-12-09 22:19:211677 if (update_reply_pending_ ||
[email protected]65225772011-05-12 21:10:241678 num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending)
1679 return;
1680
1681 // When GPU rendering, combine pending animations and invalidations into
1682 // a single update.
[email protected]816edc62012-03-17 01:27:221683 if (is_accelerated_compositing_active_ &&
1684 animation_update_pending_ &&
1685 animation_timer_.IsRunning())
[email protected]552e6002009-11-19 05:24:571686 return;
1687
1688 // Perform updating asynchronously. This serves two purposes:
initial.commit09911bf2008-07-26 23:55:291689 // 1) Ensures that we call WebView::Paint without a bunch of other junk
1690 // on the call stack.
1691 // 2) Allows us to collect more damage rects before painting to help coalesce
1692 // the work that we will need to do.
[email protected]65225772011-05-12 21:10:241693 invalidation_task_posted_ = true;
[email protected]dd32b1272013-05-04 14:17:111694 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:211695 FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
initial.commit09911bf2008-07-26 23:55:291696}
1697
[email protected]990278ff2012-11-13 02:12:551698void RenderWidget::didScrollRect(int dx, int dy,
1699 const WebRect& clip_rect) {
[email protected]f98d7e3c2010-09-13 22:30:461700 // Drop scrolls on the floor when we are in compositing mode.
1701 // TODO(nduca): stop WebViewImpl from sending scrolls in the first place.
[email protected]a79d8a632010-11-18 22:35:561702 if (is_accelerated_compositing_active_)
[email protected]f98d7e3c2010-09-13 22:30:461703 return;
1704
[email protected]552e6002009-11-19 05:24:571705 // The scrolled rect might be outside the bounds of the view.
[email protected]ee8d6fd2010-05-26 17:05:481706 gfx::Rect view_rect(size_);
[email protected]ce112fe2012-10-29 22:52:181707 gfx::Rect damaged_rect = gfx::IntersectRects(view_rect, clip_rect);
[email protected]552e6002009-11-19 05:24:571708 if (damaged_rect.IsEmpty())
initial.commit09911bf2008-07-26 23:55:291709 return;
1710
[email protected]990278ff2012-11-13 02:12:551711 paint_aggregator_.ScrollRect(gfx::Vector2d(dx, dy), damaged_rect);
[email protected]552e6002009-11-19 05:24:571712
1713 // We may not need to schedule another call to DoDeferredUpdate.
[email protected]65225772011-05-12 21:10:241714 if (invalidation_task_posted_)
[email protected]552e6002009-11-19 05:24:571715 return;
1716 if (!paint_aggregator_.HasPendingUpdate())
1717 return;
[email protected]aa4117f2011-12-09 22:19:211718 if (update_reply_pending_ ||
[email protected]65225772011-05-12 21:10:241719 num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending)
1720 return;
1721
1722 // When GPU rendering, combine pending animations and invalidations into
1723 // a single update.
[email protected]816edc62012-03-17 01:27:221724 if (is_accelerated_compositing_active_ &&
1725 animation_update_pending_ &&
1726 animation_timer_.IsRunning())
[email protected]552e6002009-11-19 05:24:571727 return;
1728
1729 // Perform updating asynchronously. This serves two purposes:
1730 // 1) Ensures that we call WebView::Paint without a bunch of other junk
1731 // on the call stack.
1732 // 2) Allows us to collect more damage rects before painting to help coalesce
1733 // the work that we will need to do.
[email protected]65225772011-05-12 21:10:241734 invalidation_task_posted_ = true;
[email protected]dd32b1272013-05-04 14:17:111735 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:211736 FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
initial.commit09911bf2008-07-26 23:55:291737}
1738
[email protected]244ac1892011-12-02 17:04:471739void RenderWidget::didAutoResize(const WebSize& new_size) {
[email protected]ea3ee0a2012-05-15 03:43:091740 if (size_.width() != new_size.width || size_.height() != new_size.height) {
[email protected]eac2b362013-05-22 07:01:451741 size_ = new_size;
[email protected]20fbfc22013-05-08 20:50:581742
[email protected]eac2b362013-05-22 07:01:451743 // If we don't clear PaintAggregator after changing autoResize state, then
1744 // we might end up in a situation where bitmap_rect is larger than the
1745 // view_size. By clearing PaintAggregator, we ensure that we don't end up
1746 // with invalid damage rects.
1747 paint_aggregator_.ClearPendingUpdate();
1748
[email protected]5b45ad42013-10-25 00:42:041749 if (resizing_mode_selector_->is_synchronous_mode()) {
[email protected]eac2b362013-05-22 07:01:451750 WebRect new_pos(rootWindowRect().x,
1751 rootWindowRect().y,
1752 new_size.width,
1753 new_size.height);
1754 view_screen_rect_ = new_pos;
1755 window_screen_rect_ = new_pos;
[email protected]8be1c582013-03-06 00:55:031756 }
[email protected]20fbfc22013-05-08 20:50:581757
[email protected]eac2b362013-05-22 07:01:451758 AutoResizeCompositor();
[email protected]20fbfc22013-05-08 20:50:581759
[email protected]5b45ad42013-10-25 00:42:041760 if (!resizing_mode_selector_->is_synchronous_mode())
[email protected]20fbfc22013-05-08 20:50:581761 need_update_rect_for_auto_resize_ = true;
[email protected]ea3ee0a2012-05-15 03:43:091762 }
[email protected]244ac1892011-12-02 17:04:471763}
1764
[email protected]3a1c8a8032013-03-18 22:35:321765void RenderWidget::AutoResizeCompositor() {
[email protected]97e1bf72013-03-06 14:06:051766 physical_backing_size_ = gfx::ToCeiledSize(gfx::ScaleSize(size_,
1767 device_scale_factor_));
1768 if (compositor_)
1769 compositor_->setViewportSize(size_, physical_backing_size_);
1770}
1771
[email protected]91acd1c2012-03-14 08:32:391772void RenderWidget::didActivateCompositor(int input_handler_identifier) {
[email protected]ea162f92011-10-04 23:08:221773 TRACE_EVENT0("gpu", "RenderWidget::didActivateCompositor");
1774
[email protected]c63b4d42012-04-26 01:01:071775#if !defined(OS_MACOSX)
[email protected]aa4117f2011-12-09 22:19:211776 if (!is_accelerated_compositing_active_) {
1777 // When not in accelerated compositing mode, in certain cases (e.g. waiting
1778 // for a resize or if no backing store) the RenderWidgetHost is blocking the
1779 // browser's UI thread for some time, waiting for an UpdateRect. If we are
1780 // going to switch to accelerated compositing, the GPU process may need
1781 // round-trips to the browser's UI thread before finishing the frame,
1782 // causing deadlocks if we delay the UpdateRect until we receive the
1783 // OnSwapBuffersComplete. So send a dummy message that will unblock the
[email protected]c63b4d42012-04-26 01:01:071784 // browser's UI thread. This is not necessary on Mac, because SwapBuffers
1785 // now unblocks GetBackingStore on Mac.
[email protected]aa4117f2011-12-09 22:19:211786 Send(new ViewHostMsg_UpdateIsDelayed(routing_id_));
1787 }
[email protected]c63b4d42012-04-26 01:01:071788#endif
[email protected]aa4117f2011-12-09 22:19:211789
[email protected]ea162f92011-10-04 23:08:221790 is_accelerated_compositing_active_ = true;
[email protected]50bd6452010-11-27 19:39:421791 Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
[email protected]65225772011-05-12 21:10:241792 routing_id_, is_accelerated_compositing_active_));
[email protected]d8a6c5d12013-09-23 04:37:101793
1794 if (!was_accelerated_compositing_ever_active_) {
1795 was_accelerated_compositing_ever_active_ = true;
1796 webwidget_->enterForceCompositingMode(true);
1797 }
[email protected]ea162f92011-10-04 23:08:221798}
1799
1800void RenderWidget::didDeactivateCompositor() {
1801 TRACE_EVENT0("gpu", "RenderWidget::didDeactivateCompositor");
1802
1803 is_accelerated_compositing_active_ = false;
1804 Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
1805 routing_id_, is_accelerated_compositing_active_));
1806
[email protected]ea162f92011-10-04 23:08:221807 if (using_asynchronous_swapbuffers_)
[email protected]65225772011-05-12 21:10:241808 using_asynchronous_swapbuffers_ = false;
[email protected]479b0172012-10-29 19:27:091809
1810 // In single-threaded mode, we exit force compositing mode and re-enter in
1811 // DoDeferredUpdate() if appropriate. In threaded compositing mode,
1812 // DoDeferredUpdate() is bypassed and WebKit is responsible for exiting and
1813 // entering force compositing mode at the appropriate times.
[email protected]cb6430932012-10-31 00:53:361814 if (!is_threaded_compositing_enabled_)
[email protected]479b0172012-10-29 19:27:091815 webwidget_->enterForceCompositingMode(false);
[email protected]a79d8a632010-11-18 22:35:561816}
1817
[email protected]e195e582013-03-08 01:32:591818void RenderWidget::initializeLayerTreeView() {
[email protected]c5fa4c42013-07-20 05:47:371819 compositor_ = RenderWidgetCompositor::Create(
1820 this, is_threaded_compositing_enabled_);
[email protected]e195e582013-03-08 01:32:591821 if (!compositor_)
1822 return;
1823
1824 compositor_->setViewportSize(size_, physical_backing_size_);
1825 if (init_complete_)
1826 compositor_->setSurfaceReady();
1827}
1828
[email protected]8926c602013-01-23 05:32:061829WebKit::WebLayerTreeView* RenderWidget::layerTreeView() {
[email protected]ba91a792013-02-06 09:48:281830 return compositor_.get();
[email protected]8926c602013-01-23 05:32:061831}
1832
[email protected]9ed83fe2013-02-27 01:52:281833void RenderWidget::suppressCompositorScheduling(bool enable) {
1834 if (compositor_)
1835 compositor_->SetSuppressScheduleComposite(enable);
1836}
1837
[email protected]9cd43a62012-03-26 08:03:561838void RenderWidget::willBeginCompositorFrame() {
1839 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
[email protected]abe8b3a2012-03-28 21:19:371840
[email protected]cadac622013-06-11 16:46:361841 DCHECK(RenderThreadImpl::current()->compositor_message_loop_proxy().get());
[email protected]abe8b3a2012-03-28 21:19:371842
1843 // The following two can result in further layout and possibly
1844 // enable GPU acceleration so they need to be called before any painting
1845 // is done.
[email protected]cb9e2632013-06-18 11:26:471846 UpdateTextInputType();
1847#if defined(OS_ANDROID)
[email protected]0d1ebed12013-08-05 22:01:131848 UpdateTextInputState(false, true);
[email protected]cb9e2632013-06-18 11:26:471849#endif
[email protected]abe8b3a2012-03-28 21:19:371850 UpdateSelectionBounds();
[email protected]9cd43a62012-03-26 08:03:561851}
1852
[email protected]3391a0772012-03-28 00:32:071853void RenderWidget::didBecomeReadyForAdditionalInput() {
1854 TRACE_EVENT0("renderer", "RenderWidget::didBecomeReadyForAdditionalInput");
[email protected]fd847792013-10-24 17:12:351855 FlushPendingInputEventAck();
[email protected]3391a0772012-03-28 00:32:071856}
1857
[email protected]6fceb912013-02-15 06:24:151858void RenderWidget::DidCommitCompositorFrame() {
1859}
1860
[email protected]58264a32011-11-17 23:36:151861void RenderWidget::didCommitAndDrawCompositorFrame() {
[email protected]b5db7eb2011-11-29 09:11:501862 TRACE_EVENT0("gpu", "RenderWidget::didCommitAndDrawCompositorFrame");
[email protected]60a50072012-01-11 02:05:351863 // Accelerated FPS tick for performance tests. See throughput_tests.cc.
1864 // NOTE: Tests may break if this event is renamed or moved.
[email protected]c76faea2013-03-26 07:42:421865 UNSHIPPED_TRACE_EVENT_INSTANT0("test_fps", "TestFrameTickGPU",
1866 TRACE_EVENT_SCOPE_THREAD);
[email protected]29ed96a2012-02-04 18:12:161867 // Notify subclasses that we initiated the paint operation.
1868 DidInitiatePaint();
[email protected]58264a32011-11-17 23:36:151869}
1870
1871void RenderWidget::didCompleteSwapBuffers() {
[email protected]404939f2012-06-01 04:06:181872 TRACE_EVENT0("renderer", "RenderWidget::didCompleteSwapBuffers");
1873
1874 // Notify subclasses threaded composited rendering was flushed to the screen.
[email protected]9cd43a62012-03-26 08:03:561875 DidFlushPaint();
1876
[email protected]aa4117f2011-12-09 22:19:211877 if (update_reply_pending_)
[email protected]58264a32011-11-17 23:36:151878 return;
1879
[email protected]ea3ee0a2012-05-15 03:43:091880 if (!next_paint_flags_ &&
1881 !need_update_rect_for_auto_resize_ &&
1882 !plugin_window_moves_.size()) {
[email protected]58264a32011-11-17 23:36:151883 return;
[email protected]ea3ee0a2012-05-15 03:43:091884 }
[email protected]58264a32011-11-17 23:36:151885
1886 ViewHostMsg_UpdateRect_Params params;
1887 params.view_size = size_;
[email protected]58264a32011-11-17 23:36:151888 params.plugin_window_moves.swap(plugin_window_moves_);
1889 params.flags = next_paint_flags_;
1890 params.scroll_offset = GetScrollOffset();
[email protected]b0dda9e22011-12-13 20:30:121891 params.needs_ack = false;
[email protected]7ded9f12012-06-13 20:47:091892 params.scale_factor = device_scale_factor_;
[email protected]58264a32011-11-17 23:36:151893
1894 Send(new ViewHostMsg_UpdateRect(routing_id_, params));
1895 next_paint_flags_ = 0;
[email protected]ea3ee0a2012-05-15 03:43:091896 need_update_rect_for_auto_resize_ = false;
[email protected]58264a32011-11-17 23:36:151897}
1898
[email protected]f98d7e3c2010-09-13 22:30:461899void RenderWidget::scheduleComposite() {
[email protected]7d08a9352013-10-15 08:24:561900 ScheduleCompositeImpl(false);
[email protected]f98d7e3c2010-09-13 22:30:461901}
1902
[email protected]5f8b1022011-01-21 23:34:501903void RenderWidget::scheduleAnimation() {
[email protected]ce65fb782012-04-19 05:01:201904 if (animation_update_pending_)
1905 return;
1906
[email protected]921244e42011-07-20 16:36:301907 TRACE_EVENT0("gpu", "RenderWidget::scheduleAnimation");
[email protected]ce65fb782012-04-19 05:01:201908 animation_update_pending_ = true;
1909 if (!animation_timer_.IsRunning()) {
1910 animation_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(0), this,
1911 &RenderWidget::AnimationCallback);
[email protected]ee3d3ad2011-02-04 00:42:211912 }
[email protected]5f8b1022011-01-21 23:34:501913}
1914
[email protected]4873c7d2009-07-16 06:36:281915void RenderWidget::didChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301916 // TODO(darin): Eliminate this temporary.
[email protected]9ec87712013-05-24 23:23:521917 WebCursor cursor;
[email protected]953bd0062013-08-01 00:58:401918 InitializeCursorFromWebKitCursorInfo(&cursor, cursor_info);
initial.commit09911bf2008-07-26 23:55:291919 // Only send a SetCursor message if we need to make a change.
1920 if (!current_cursor_.IsEqual(cursor)) {
1921 current_cursor_ = cursor;
1922 Send(new ViewHostMsg_SetCursor(routing_id_, cursor));
1923 }
1924}
1925
1926// We are supposed to get a single call to Show for a newly created RenderWidget
1927// that was created via RenderWidget::CreateWebView. So, we wait until this
1928// point to dispatch the ShowWidget message.
1929//
1930// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281931// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291932//
[email protected]4873c7d2009-07-16 06:36:281933void RenderWidget::show(WebNavigationPolicy) {
initial.commit09911bf2008-07-26 23:55:291934 DCHECK(!did_show_) << "received extraneous Show call";
1935 DCHECK(routing_id_ != MSG_ROUTING_NONE);
1936 DCHECK(opener_id_ != MSG_ROUTING_NONE);
1937
[email protected]8de12d942010-11-17 20:42:441938 if (did_show_)
1939 return;
1940
1941 did_show_ = true;
1942 // NOTE: initial_pos_ may still have its default values at this point, but
1943 // that's okay. It'll be ignored if as_popup is false, or the browser
1944 // process will impose a default position otherwise.
1945 Send(new ViewHostMsg_ShowWidget(opener_id_, routing_id_, initial_pos_));
1946 SetPendingWindowRect(initial_pos_);
initial.commit09911bf2008-07-26 23:55:291947}
1948
[email protected]4873c7d2009-07-16 06:36:281949void RenderWidget::didFocus() {
initial.commit09911bf2008-07-26 23:55:291950}
1951
[email protected]4873c7d2009-07-16 06:36:281952void RenderWidget::didBlur() {
initial.commit09911bf2008-07-26 23:55:291953}
1954
[email protected]2533ce12009-05-09 00:02:241955void RenderWidget::DoDeferredClose() {
1956 Send(new ViewHostMsg_Close(routing_id_));
1957}
1958
[email protected]4873c7d2009-07-16 06:36:281959void RenderWidget::closeWidgetSoon() {
[email protected]e1c3a552012-05-04 20:51:321960 if (is_swapped_out_) {
1961 // This widget is currently swapped out, and the active widget is in a
1962 // different process. Have the browser route the close request to the
1963 // active widget instead, so that the correct unload handlers are run.
1964 Send(new ViewHostMsg_RouteCloseEvent(routing_id_));
1965 return;
1966 }
1967
initial.commit09911bf2008-07-26 23:55:291968 // If a page calls window.close() twice, we'll end up here twice, but that's
1969 // OK. It is safe to send multiple Close messages.
1970
[email protected]2533ce12009-05-09 00:02:241971 // Ask the RenderWidgetHost to initiate close. We could be called from deep
1972 // in Javascript. If we ask the RendwerWidgetHost to close now, the window
1973 // could be closed before the JS finishes executing. So instead, post a
1974 // message back to the message loop, which won't run until the JS is
1975 // complete, and then the Close message can be sent.
[email protected]dd32b1272013-05-04 14:17:111976 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:211977 FROM_HERE, base::Bind(&RenderWidget::DoDeferredClose, this));
initial.commit09911bf2008-07-26 23:55:291978}
1979
1980void RenderWidget::Close() {
1981 if (webwidget_) {
[email protected]8926c602013-01-23 05:32:061982 webwidget_->willCloseLayerTreeView();
[email protected]ba91a792013-02-06 09:48:281983 compositor_.reset();
[email protected]4873c7d2009-07-16 06:36:281984 webwidget_->close();
initial.commit09911bf2008-07-26 23:55:291985 webwidget_ = NULL;
1986 }
1987}
1988
[email protected]4873c7d2009-07-16 06:36:281989WebRect RenderWidget::windowRect() {
1990 if (pending_window_rect_count_)
1991 return pending_window_rect_;
[email protected]2533ce12009-05-09 00:02:241992
[email protected]80ad8622012-11-07 16:33:031993 return view_screen_rect_;
initial.commit09911bf2008-07-26 23:55:291994}
1995
[email protected]8a9d6ca32011-06-06 20:11:301996void RenderWidget::setToolTipText(const WebKit::WebString& text,
1997 WebTextDirection hint) {
[email protected]5a395b72011-08-08 19:13:541998 Send(new ViewHostMsg_SetTooltipText(routing_id_, text, hint));
[email protected]8a9d6ca32011-06-06 20:11:301999}
2000
[email protected]b2e4c70132013-10-03 02:07:512001void RenderWidget::setWindowRect(const WebRect& rect) {
2002 WebRect pos = rect;
2003 if (popup_origin_scale_for_emulation_) {
2004 float scale = popup_origin_scale_for_emulation_;
2005 pos.x = popup_screen_origin_for_emulation_.x() +
2006 (pos.x - popup_view_origin_for_emulation_.x()) * scale;
2007 pos.y = popup_screen_origin_for_emulation_.y() +
2008 (pos.y - popup_view_origin_for_emulation_.y()) * scale;
2009 }
2010
[email protected]5b45ad42013-10-25 00:42:042011 if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]ec951b9d2013-10-20 06:21:202012 if (did_show_) {
[email protected]8be1c582013-03-06 00:55:032013 Send(new ViewHostMsg_RequestMove(routing_id_, pos));
2014 SetPendingWindowRect(pos);
2015 } else {
[email protected]ec951b9d2013-10-20 06:21:202016 initial_pos_ = pos;
[email protected]8be1c582013-03-06 00:55:032017 }
initial.commit09911bf2008-07-26 23:55:292018 } else {
[email protected]ec951b9d2013-10-20 06:21:202019 WebSize new_size(pos.width, pos.height);
2020 Resize(new_size, new_size, overdraw_bottom_height_,
2021 WebRect(), is_fullscreen_, NO_RESIZE_ACK);
2022 view_screen_rect_ = pos;
2023 window_screen_rect_ = pos;
2024 if (!did_show_)
2025 initial_pos_ = pos;
initial.commit09911bf2008-07-26 23:55:292026 }
2027}
2028
[email protected]2533ce12009-05-09 00:02:242029void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
2030 pending_window_rect_ = rect;
2031 pending_window_rect_count_++;
2032}
2033
[email protected]4873c7d2009-07-16 06:36:282034WebRect RenderWidget::rootWindowRect() {
[email protected]2533ce12009-05-09 00:02:242035 if (pending_window_rect_count_) {
2036 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
2037 // the RootWindowRect is probably going to return wrong results since the
2038 // browser may not have processed the Move yet. There isn't really anything
2039 // good to do in this case, and it shouldn't happen - since this size is
2040 // only really needed for windowToScreen, which is only used for Popups.
[email protected]4873c7d2009-07-16 06:36:282041 return pending_window_rect_;
[email protected]2533ce12009-05-09 00:02:242042 }
2043
[email protected]80ad8622012-11-07 16:33:032044 return window_screen_rect_;
[email protected]d4547452008-08-28 18:36:372045}
2046
[email protected]4873c7d2009-07-16 06:36:282047WebRect RenderWidget::windowResizerRect() {
2048 return resizer_rect_;
[email protected]c04b6362008-11-21 18:54:192049}
2050
[email protected]fa7b1dc2010-06-23 17:53:042051void RenderWidget::OnSetInputMethodActive(bool is_active) {
[email protected]c4bb35a2008-10-31 17:54:032052 // To prevent this renderer process from sending unnecessary IPC messages to
2053 // a browser process, we permit the renderer process to send IPC messages
[email protected]fa7b1dc2010-06-23 17:53:042054 // only during the input method attached to the browser process is active.
2055 input_method_is_active_ = is_active;
initial.commit09911bf2008-07-26 23:55:292056}
2057
[email protected]fa7b1dc2010-06-23 17:53:042058void RenderWidget::OnImeSetComposition(
2059 const string16& text,
2060 const std::vector<WebCompositionUnderline>& underlines,
2061 int selection_start, int selection_end) {
[email protected]0d1ebed12013-08-05 22:01:132062 if (!ShouldHandleImeEvent())
[email protected]4873c7d2009-07-16 06:36:282063 return;
[email protected]66fca5bc2013-05-23 06:58:292064 ImeEventGuard guard(this);
[email protected]88dbe32f2013-06-20 23:31:362065 if (!webwidget_->setComposition(
[email protected]fa7b1dc2010-06-23 17:53:042066 text, WebVector<WebCompositionUnderline>(underlines),
2067 selection_start, selection_end)) {
2068 // If we failed to set the composition text, then we need to let the browser
2069 // process to cancel the input method's ongoing composition session, to make
2070 // sure we are in a consistent state.
2071 Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
[email protected]7f00efa2010-04-15 05:01:262072 }
[email protected]501ea13d2013-07-09 17:03:292073#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362074 UpdateCompositionInfo(true);
[email protected]501ea13d2013-07-09 17:03:292075#endif
[email protected]fa7b1dc2010-06-23 17:53:042076}
2077
[email protected]0e45bd02013-07-12 20:20:022078void RenderWidget::OnImeConfirmComposition(const string16& text,
[email protected]db4fc1e2013-09-06 20:01:512079 const gfx::Range& replacement_range,
[email protected]0e45bd02013-07-12 20:20:022080 bool keep_selection) {
[email protected]0d1ebed12013-08-05 22:01:132081 if (!ShouldHandleImeEvent())
[email protected]d0be63772011-12-20 23:18:042082 return;
[email protected]66fca5bc2013-05-23 06:58:292083 ImeEventGuard guard(this);
[email protected]d0be63772011-12-20 23:18:042084 handling_input_event_ = true;
[email protected]0e45bd02013-07-12 20:20:022085 if (text.length())
2086 webwidget_->confirmComposition(text);
2087 else if (keep_selection)
2088 webwidget_->confirmComposition(WebWidget::KeepSelection);
2089 else
2090 webwidget_->confirmComposition(WebWidget::DoNotKeepSelection);
[email protected]d0be63772011-12-20 23:18:042091 handling_input_event_ = false;
[email protected]501ea13d2013-07-09 17:03:292092#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362093 UpdateCompositionInfo(true);
[email protected]501ea13d2013-07-09 17:03:292094#endif
initial.commit09911bf2008-07-26 23:55:292095}
2096
[email protected]948f7ab72010-05-28 23:48:082097// This message causes the renderer to render an image of the
2098// desired_size, regardless of whether the tab is hidden or not.
[email protected]3d9ec5052013-01-02 22:05:252099void RenderWidget::OnPaintAtSize(const TransportDIB::Handle& dib_handle,
2100 int tag,
2101 const gfx::Size& page_size,
2102 const gfx::Size& desired_size) {
[email protected]27543452011-03-25 00:14:002103 if (!webwidget_ || !TransportDIB::is_valid_handle(dib_handle)) {
2104 if (TransportDIB::is_valid_handle(dib_handle)) {
[email protected]45c6aad32010-11-11 04:46:252105 // Close our unused handle.
2106#if defined(OS_WIN)
2107 ::CloseHandle(dib_handle);
2108#elif defined(OS_MACOSX)
2109 base::SharedMemory::CloseHandle(dib_handle);
2110#endif
2111 }
[email protected]d65adb12010-04-28 17:26:492112 return;
[email protected]45c6aad32010-11-11 04:46:252113 }
[email protected]d65adb12010-04-28 17:26:492114
[email protected]948f7ab72010-05-28 23:48:082115 if (page_size.IsEmpty() || desired_size.IsEmpty()) {
[email protected]d65adb12010-04-28 17:26:492116 // If one of these is empty, then we just return the dib we were
2117 // given, to avoid leaking it.
[email protected]c88c9442010-07-19 18:55:092118 Send(new ViewHostMsg_PaintAtSize_ACK(routing_id_, tag, desired_size));
[email protected]d65adb12010-04-28 17:26:492119 return;
2120 }
2121
2122 // Map the given DIB ID into this process, and unmap it at the end
2123 // of this function.
[email protected]45c6aad32010-11-11 04:46:252124 scoped_ptr<TransportDIB> paint_at_size_buffer(
2125 TransportDIB::CreateWithHandle(dib_handle));
[email protected]36808ad2010-10-20 19:18:302126
[email protected]4b01b962012-10-09 23:17:352127 gfx::Size page_size_in_pixel = gfx::ToFlooredSize(
[email protected]01a15a72012-11-10 09:34:282128 gfx::ScaleSize(page_size, device_scale_factor_));
[email protected]4b01b962012-10-09 23:17:352129 gfx::Size desired_size_in_pixel = gfx::ToFlooredSize(
[email protected]01a15a72012-11-10 09:34:282130 gfx::ScaleSize(desired_size, device_scale_factor_));
[email protected]8f640512012-08-07 23:52:512131 gfx::Size canvas_size = page_size_in_pixel;
2132 float x_scale = static_cast<float>(desired_size_in_pixel.width()) /
[email protected]d65adb12010-04-28 17:26:492133 static_cast<float>(canvas_size.width());
[email protected]8f640512012-08-07 23:52:512134 float y_scale = static_cast<float>(desired_size_in_pixel.height()) /
[email protected]d65adb12010-04-28 17:26:492135 static_cast<float>(canvas_size.height());
2136
[email protected]ee8d6fd2010-05-26 17:05:482137 gfx::Rect orig_bounds(canvas_size);
[email protected]d65adb12010-04-28 17:26:492138 canvas_size.set_width(static_cast<int>(canvas_size.width() * x_scale));
2139 canvas_size.set_height(static_cast<int>(canvas_size.height() * y_scale));
[email protected]ee8d6fd2010-05-26 17:05:482140 gfx::Rect bounds(canvas_size);
[email protected]d65adb12010-04-28 17:26:492141
[email protected]36808ad2010-10-20 19:18:302142 scoped_ptr<skia::PlatformCanvas> canvas(
2143 paint_at_size_buffer->GetPlatformCanvas(canvas_size.width(),
2144 canvas_size.height()));
[email protected]59383c782013-04-17 16:43:272145 if (!canvas) {
[email protected]36808ad2010-10-20 19:18:302146 NOTREACHED();
2147 return;
2148 }
2149
[email protected]d65adb12010-04-28 17:26:492150 // Reset bounds to what we actually received, but they should be the
2151 // same.
2152 DCHECK_EQ(bounds.width(), canvas->getDevice()->width());
2153 DCHECK_EQ(bounds.height(), canvas->getDevice()->height());
2154 bounds.set_width(canvas->getDevice()->width());
2155 bounds.set_height(canvas->getDevice()->height());
2156
2157 canvas->save();
[email protected]948f7ab72010-05-28 23:48:082158 // Add the scale factor to the canvas, so that we'll get the desired size.
[email protected]d65adb12010-04-28 17:26:492159 canvas->scale(SkFloatToScalar(x_scale), SkFloatToScalar(y_scale));
2160
[email protected]948f7ab72010-05-28 23:48:082161 // Have to make sure we're laid out at the right size before
2162 // rendering.
2163 gfx::Size old_size = webwidget_->size();
2164 webwidget_->resize(page_size);
2165 webwidget_->layout();
2166
[email protected]d65adb12010-04-28 17:26:492167 // Paint the entire thing (using original bounds, not scaled bounds).
2168 PaintRect(orig_bounds, orig_bounds.origin(), canvas.get());
2169 canvas->restore();
2170
[email protected]948f7ab72010-05-28 23:48:082171 // Return the widget to its previous size.
2172 webwidget_->resize(old_size);
2173
[email protected]c88c9442010-07-19 18:55:092174 Send(new ViewHostMsg_PaintAtSize_ACK(routing_id_, tag, bounds.size()));
[email protected]d65adb12010-04-28 17:26:492175}
2176
[email protected]51a49502013-03-23 01:50:192177void RenderWidget::OnSnapshot(const gfx::Rect& src_subrect) {
2178 SkBitmap snapshot;
2179
2180 if (OnSnapshotHelper(src_subrect, &snapshot)) {
2181 Send(new ViewHostMsg_Snapshot(routing_id(), true, snapshot));
2182 } else {
2183 Send(new ViewHostMsg_Snapshot(routing_id(), false, SkBitmap()));
2184 }
2185}
2186
2187bool RenderWidget::OnSnapshotHelper(const gfx::Rect& src_subrect,
2188 SkBitmap* snapshot) {
2189 base::TimeTicks beginning_time = base::TimeTicks::Now();
2190
2191 if (!webwidget_ || src_subrect.IsEmpty())
2192 return false;
2193
2194 gfx::Rect viewport_size = gfx::IntersectRects(
2195 src_subrect, gfx::Rect(physical_backing_size_));
2196
2197 skia::RefPtr<SkCanvas> canvas = skia::AdoptRef(
2198 skia::CreatePlatformCanvas(viewport_size.width(),
2199 viewport_size.height(),
2200 true,
2201 NULL,
2202 skia::RETURN_NULL_ON_FAILURE));
[email protected]59383c782013-04-17 16:43:272203 if (!canvas)
[email protected]51a49502013-03-23 01:50:192204 return false;
2205
2206 canvas->save();
2207 webwidget_->layout();
2208
2209 PaintRect(viewport_size, viewport_size.origin(), canvas.get());
2210 canvas->restore();
2211
2212 const SkBitmap& bitmap = skia::GetTopDevice(*canvas)->accessBitmap(false);
2213 if (!bitmap.copyTo(snapshot, SkBitmap::kARGB_8888_Config))
2214 return false;
2215
2216 UMA_HISTOGRAM_TIMES("Renderer4.Snapshot",
2217 base::TimeTicks::Now() - beginning_time);
2218 return true;
2219}
2220
[email protected]0bc1f572013-04-17 01:46:312221void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
[email protected]ec7dc112008-08-06 05:30:122222 // During shutdown we can just ignore this message.
2223 if (!webwidget_)
2224 return;
2225
[email protected]0bc1f572013-04-17 01:46:312226 // Even if the browser provides an empty damage rect, it's still expecting to
2227 // receive a repaint ack so just damage the entire widget bounds.
2228 if (size_to_paint.IsEmpty()) {
2229 size_to_paint = size_;
2230 }
2231
[email protected]ec7dc112008-08-06 05:30:122232 set_next_paint_is_repaint_ack();
[email protected]0bc1f572013-04-17 01:46:312233 if (is_accelerated_compositing_active_ && compositor_) {
2234 compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint));
[email protected]f98d7e3c2010-09-13 22:30:462235 } else {
2236 gfx::Rect repaint_rect(size_to_paint.width(), size_to_paint.height());
2237 didInvalidateRect(repaint_rect);
2238 }
[email protected]ec7dc112008-08-06 05:30:122239}
2240
[email protected]79fa22e2013-08-23 15:18:122241void RenderWidget::OnSyntheticGestureCompleted() {
2242 pending_synthetic_gesture_.Run();
[email protected]0e241b4b2012-08-18 09:06:272243}
2244
[email protected]4873c7d2009-07-16 06:36:282245void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
[email protected]07f953332009-03-25 04:31:112246 if (!webwidget_)
2247 return;
[email protected]4873c7d2009-07-16 06:36:282248 webwidget_->setTextDirection(direction);
[email protected]07f953332009-03-25 04:31:112249}
2250
[email protected]80ad8622012-11-07 16:33:032251void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
2252 const gfx::Rect& window_screen_rect) {
[email protected]b2e4c70132013-10-03 02:07:512253 if (screen_metrics_emulator_) {
2254 screen_metrics_emulator_->OnUpdateScreenRectsMessage(
2255 view_screen_rect, window_screen_rect);
2256 } else {
2257 view_screen_rect_ = view_screen_rect;
2258 window_screen_rect_ = window_screen_rect;
2259 }
[email protected]80ad8622012-11-07 16:33:032260 Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
2261}
2262
[email protected]105dffb42013-02-20 03:46:212263#if defined(OS_ANDROID)
[email protected]2384b6c2013-02-28 23:58:512264void RenderWidget::OnShowImeIfNeeded() {
[email protected]0d1ebed12013-08-05 22:01:132265 UpdateTextInputState(true, true);
2266}
2267
2268void RenderWidget::IncrementOutstandingImeEventAcks() {
2269 ++outstanding_ime_acks_;
2270}
2271
2272void RenderWidget::OnImeEventAck() {
2273 --outstanding_ime_acks_;
2274 DCHECK(outstanding_ime_acks_ >= 0);
[email protected]2384b6c2013-02-28 23:58:512275}
[email protected]105dffb42013-02-20 03:46:212276#endif
2277
[email protected]0d1ebed12013-08-05 22:01:132278bool RenderWidget::ShouldHandleImeEvent() {
2279#if defined(OS_ANDROID)
2280 return !!webwidget_ && outstanding_ime_acks_ == 0;
2281#else
2282 return !!webwidget_;
2283#endif
2284}
2285
[email protected]468ac582012-11-20 00:53:192286void RenderWidget::SetDeviceScaleFactor(float device_scale_factor) {
2287 if (device_scale_factor_ == device_scale_factor)
2288 return;
2289
2290 device_scale_factor_ = device_scale_factor;
2291
2292 if (!is_accelerated_compositing_active_) {
2293 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
2294 } else {
2295 scheduleComposite();
2296 }
2297}
2298
[email protected]adab2332013-07-25 18:04:322299PepperPluginInstanceImpl* RenderWidget::GetBitmapForOptimizedPluginPaint(
2300 const gfx::Rect& paint_bounds,
2301 TransportDIB** dib,
2302 gfx::Rect* location,
2303 gfx::Rect* clip,
2304 float* scale_factor) {
[email protected]719b36f2010-12-22 20:36:462305 // Bare RenderWidgets don't support optimized plugin painting.
2306 return NULL;
[email protected]ca4847f2010-09-24 05:39:152307}
2308
[email protected]ceb36f7d2012-10-31 18:33:242309gfx::Vector2d RenderWidget::GetScrollOffset() {
[email protected]d54169e92011-01-21 09:19:522310 // Bare RenderWidgets don't support scroll offset.
[email protected]ceb36f7d2012-10-31 18:33:242311 return gfx::Vector2d();
[email protected]d54169e92011-01-21 09:19:522312}
2313
[email protected]bee16aab2009-08-26 15:55:032314void RenderWidget::SetHidden(bool hidden) {
2315 if (is_hidden_ == hidden)
2316 return;
2317
2318 // The status has changed. Tell the RenderThread about it.
2319 is_hidden_ = hidden;
2320 if (is_hidden_)
[email protected]380244092011-10-07 17:26:272321 RenderThread::Get()->WidgetHidden();
[email protected]bee16aab2009-08-26 15:55:032322 else
[email protected]380244092011-10-07 17:26:272323 RenderThread::Get()->WidgetRestored();
[email protected]bee16aab2009-08-26 15:55:032324}
2325
[email protected]2b624c562011-10-27 22:58:262326void RenderWidget::WillToggleFullscreen() {
[email protected]2b624c562011-10-27 22:58:262327 if (!webwidget_)
2328 return;
2329
2330 if (is_fullscreen_) {
2331 webwidget_->willExitFullScreen();
2332 } else {
2333 webwidget_->willEnterFullScreen();
2334 }
[email protected]2b624c562011-10-27 22:58:262335}
2336
2337void RenderWidget::DidToggleFullscreen() {
[email protected]2b624c562011-10-27 22:58:262338 if (!webwidget_)
2339 return;
2340
2341 if (is_fullscreen_) {
2342 webwidget_->didEnterFullScreen();
2343 } else {
2344 webwidget_->didExitFullScreen();
2345 }
[email protected]2b624c562011-10-27 22:58:262346}
2347
[email protected]699ab0d2009-04-23 23:19:142348void RenderWidget::SetBackground(const SkBitmap& background) {
2349 background_ = background;
[email protected]f98d7e3c2010-09-13 22:30:462350
[email protected]699ab0d2009-04-23 23:19:142351 // Generate a full repaint.
[email protected]4873c7d2009-07-16 06:36:282352 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
[email protected]699ab0d2009-04-23 23:19:142353}
2354
[email protected]674741932009-02-04 23:44:462355bool RenderWidget::next_paint_is_resize_ack() const {
[email protected]53d3f302009-12-21 04:42:052356 return ViewHostMsg_UpdateRect_Flags::is_resize_ack(next_paint_flags_);
[email protected]674741932009-02-04 23:44:462357}
2358
2359bool RenderWidget::next_paint_is_restore_ack() const {
[email protected]53d3f302009-12-21 04:42:052360 return ViewHostMsg_UpdateRect_Flags::is_restore_ack(next_paint_flags_);
[email protected]674741932009-02-04 23:44:462361}
2362
2363void RenderWidget::set_next_paint_is_resize_ack() {
[email protected]53d3f302009-12-21 04:42:052364 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
[email protected]674741932009-02-04 23:44:462365}
2366
2367void RenderWidget::set_next_paint_is_restore_ack() {
[email protected]53d3f302009-12-21 04:42:052368 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESTORE_ACK;
[email protected]674741932009-02-04 23:44:462369}
2370
2371void RenderWidget::set_next_paint_is_repaint_ack() {
[email protected]53d3f302009-12-21 04:42:052372 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK;
[email protected]674741932009-02-04 23:44:462373}
2374
[email protected]b18583c2012-12-18 06:55:272375static bool IsDateTimeInput(ui::TextInputType type) {
2376 return type == ui::TEXT_INPUT_TYPE_DATE ||
2377 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
2378 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
2379 type == ui::TEXT_INPUT_TYPE_MONTH ||
2380 type == ui::TEXT_INPUT_TYPE_TIME ||
2381 type == ui::TEXT_INPUT_TYPE_WEEK;
2382}
2383
[email protected]66fca5bc2013-05-23 06:58:292384
2385void RenderWidget::StartHandlingImeEvent() {
2386 DCHECK(!handling_ime_event_);
2387 handling_ime_event_ = true;
2388}
2389
2390void RenderWidget::FinishHandlingImeEvent() {
2391 DCHECK(handling_ime_event_);
2392 handling_ime_event_ = false;
2393 // While handling an ime event, text input state and selection bounds updates
2394 // are ignored. These must explicitly be updated once finished handling the
2395 // ime event.
2396 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:472397#if defined(OS_ANDROID)
[email protected]0d1ebed12013-08-05 22:01:132398 UpdateTextInputState(false, false);
[email protected]cb9e2632013-06-18 11:26:472399#endif
[email protected]66fca5bc2013-05-23 06:58:292400}
2401
[email protected]cb9e2632013-06-18 11:26:472402void RenderWidget::UpdateTextInputType() {
[email protected]11f22bb62013-09-24 04:59:062403 // On Windows, not only an IME but also an on-screen keyboard relies on the
2404 // latest TextInputType to optimize its layout and functionality. Thus
2405 // |input_method_is_active_| is no longer an appropriate condition to suppress
2406 // TextInputTypeChanged IPC on Windows.
2407 // TODO(yukawa, yoichio): Consider to stop checking |input_method_is_active_|
2408 // on other platforms as well as Windows if the overhead is acceptable.
2409#if !defined(OS_WIN)
[email protected]cb9e2632013-06-18 11:26:472410 if (!input_method_is_active_)
2411 return;
[email protected]11f22bb62013-09-24 04:59:062412#endif
[email protected]cb9e2632013-06-18 11:26:472413
[email protected]e7c569d2013-07-17 16:00:362414 ui::TextInputType new_type = GetTextInputType();
[email protected]cb9e2632013-06-18 11:26:472415 if (IsDateTimeInput(new_type))
2416 return; // Not considered as a text input field in WebKit/Chromium.
2417
2418 bool new_can_compose_inline = CanComposeInline();
2419
[email protected]e7c569d2013-07-17 16:00:362420 WebKit::WebTextInputInfo new_info;
2421 if (webwidget_)
2422 new_info = webwidget_->textInputInfo();
[email protected]b256eca2013-07-11 10:57:402423 const ui::TextInputMode new_mode = ConvertInputMode(new_info.inputMode);
2424
[email protected]cb9e2632013-06-18 11:26:472425 if (text_input_type_ != new_type
[email protected]b256eca2013-07-11 10:57:402426 || can_compose_inline_ != new_can_compose_inline
2427 || text_input_mode_ != new_mode) {
[email protected]cb9e2632013-06-18 11:26:472428 Send(new ViewHostMsg_TextInputTypeChanged(routing_id(),
2429 new_type,
[email protected]86ba5fcb2013-09-04 00:36:532430 new_mode,
2431 new_can_compose_inline));
[email protected]cb9e2632013-06-18 11:26:472432 text_input_type_ = new_type;
2433 can_compose_inline_ = new_can_compose_inline;
[email protected]b256eca2013-07-11 10:57:402434 text_input_mode_ = new_mode;
[email protected]cb9e2632013-06-18 11:26:472435 }
2436}
2437
2438#if defined(OS_ANDROID)
[email protected]0d1ebed12013-08-05 22:01:132439void RenderWidget::UpdateTextInputState(bool show_ime_if_needed,
2440 bool send_ime_ack) {
[email protected]e8f775f2013-02-14 21:00:502441 if (handling_ime_event_)
2442 return;
[email protected]3306f262012-09-21 19:20:422443 if (!show_ime_if_needed && !input_method_is_active_)
initial.commit09911bf2008-07-26 23:55:292444 return;
[email protected]ad26ef42011-06-17 07:59:452445 ui::TextInputType new_type = GetTextInputType();
[email protected]b18583c2012-12-18 06:55:272446 if (IsDateTimeInput(new_type))
2447 return; // Not considered as a text input field in WebKit/Chromium.
2448
[email protected]5b739cb2012-08-21 20:35:212449 WebKit::WebTextInputInfo new_info;
2450 if (webwidget_)
2451 new_info = webwidget_->textInputInfo();
2452
[email protected]ad26ef42011-06-17 07:59:452453 bool new_can_compose_inline = CanComposeInline();
[email protected]5b739cb2012-08-21 20:35:212454
[email protected]3306f262012-09-21 19:20:422455 // Only sends text input params if they are changed or if the ime should be
2456 // shown.
2457 if (show_ime_if_needed || (text_input_type_ != new_type
2458 || text_input_info_ != new_info
2459 || can_compose_inline_ != new_can_compose_inline)) {
[email protected]5b739cb2012-08-21 20:35:212460 ViewHostMsg_TextInputState_Params p;
2461 p.type = new_type;
2462 p.value = new_info.value.utf8();
2463 p.selection_start = new_info.selectionStart;
2464 p.selection_end = new_info.selectionEnd;
2465 p.composition_start = new_info.compositionStart;
2466 p.composition_end = new_info.compositionEnd;
2467 p.can_compose_inline = new_can_compose_inline;
[email protected]3306f262012-09-21 19:20:422468 p.show_ime_if_needed = show_ime_if_needed;
[email protected]0d1ebed12013-08-05 22:01:132469 p.require_ack = send_ime_ack;
2470 if (p.require_ack)
2471 IncrementOutstandingImeEventAcks();
[email protected]5b739cb2012-08-21 20:35:212472 Send(new ViewHostMsg_TextInputStateChanged(routing_id(), p));
2473
2474 text_input_info_ = new_info;
[email protected]fa7b1dc2010-06-23 17:53:042475 text_input_type_ = new_type;
[email protected]ad26ef42011-06-17 07:59:452476 can_compose_inline_ = new_can_compose_inline;
initial.commit09911bf2008-07-26 23:55:292477 }
initial.commit09911bf2008-07-26 23:55:292478}
[email protected]cb9e2632013-06-18 11:26:472479#endif
initial.commit09911bf2008-07-26 23:55:292480
[email protected]7c8873e2013-02-05 08:03:012481void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
2482 WebRect focus_webrect;
2483 WebRect anchor_webrect;
2484 webwidget_->selectionBounds(focus_webrect, anchor_webrect);
2485 *focus = focus_webrect;
2486 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:322487}
2488
[email protected]e99ef6f2011-10-16 01:13:002489void RenderWidget::UpdateSelectionBounds() {
2490 if (!webwidget_)
2491 return;
[email protected]66fca5bc2013-05-23 06:58:292492 if (handling_ime_event_)
2493 return;
[email protected]e99ef6f2011-10-16 01:13:002494
[email protected]7c8873e2013-02-05 08:03:012495 ViewHostMsg_SelectionBounds_Params params;
2496 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
2497 if (selection_anchor_rect_ != params.anchor_rect ||
2498 selection_focus_rect_ != params.focus_rect) {
2499 selection_anchor_rect_ = params.anchor_rect;
2500 selection_focus_rect_ = params.focus_rect;
2501 webwidget_->selectionTextDirection(params.focus_dir, params.anchor_dir);
[email protected]129b7382013-02-12 02:14:292502 params.is_anchor_first = webwidget_->isSelectionAnchorFirst();
[email protected]7c8873e2013-02-05 08:03:012503 Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
[email protected]58b48a0d2012-06-13 07:01:352504 }
[email protected]501ea13d2013-07-09 17:03:292505#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362506 UpdateCompositionInfo(false);
[email protected]501ea13d2013-07-09 17:03:292507#endif
[email protected]e99ef6f2011-10-16 01:13:002508}
2509
[email protected]73bf95812011-10-12 11:38:322510// Check WebKit::WebTextInputType and ui::TextInputType is kept in sync.
[email protected]ad26ef42011-06-17 07:59:452511COMPILE_ASSERT(int(WebKit::WebTextInputTypeNone) == \
2512 int(ui::TEXT_INPUT_TYPE_NONE), mismatching_enums);
2513COMPILE_ASSERT(int(WebKit::WebTextInputTypeText) == \
2514 int(ui::TEXT_INPUT_TYPE_TEXT), mismatching_enums);
2515COMPILE_ASSERT(int(WebKit::WebTextInputTypePassword) == \
2516 int(ui::TEXT_INPUT_TYPE_PASSWORD), mismatching_enums);
[email protected]caf38ed2011-07-28 13:15:182517COMPILE_ASSERT(int(WebKit::WebTextInputTypeSearch) == \
2518 int(ui::TEXT_INPUT_TYPE_SEARCH), mismatching_enums);
2519COMPILE_ASSERT(int(WebKit::WebTextInputTypeEmail) == \
2520 int(ui::TEXT_INPUT_TYPE_EMAIL), mismatching_enums);
2521COMPILE_ASSERT(int(WebKit::WebTextInputTypeNumber) == \
2522 int(ui::TEXT_INPUT_TYPE_NUMBER), mismatching_enums);
2523COMPILE_ASSERT(int(WebKit::WebTextInputTypeTelephone) == \
2524 int(ui::TEXT_INPUT_TYPE_TELEPHONE), mismatching_enums);
2525COMPILE_ASSERT(int(WebKit::WebTextInputTypeURL) == \
2526 int(ui::TEXT_INPUT_TYPE_URL), mismatching_enums);
[email protected]feb8cf752012-06-08 04:48:002527COMPILE_ASSERT(int(WebKit::WebTextInputTypeDate) == \
2528 int(ui::TEXT_INPUT_TYPE_DATE), mismatching_enum);
2529COMPILE_ASSERT(int(WebKit::WebTextInputTypeDateTime) == \
2530 int(ui::TEXT_INPUT_TYPE_DATE_TIME), mismatching_enum);
2531COMPILE_ASSERT(int(WebKit::WebTextInputTypeDateTimeLocal) == \
2532 int(ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL), mismatching_enum);
2533COMPILE_ASSERT(int(WebKit::WebTextInputTypeMonth) == \
2534 int(ui::TEXT_INPUT_TYPE_MONTH), mismatching_enum);
2535COMPILE_ASSERT(int(WebKit::WebTextInputTypeTime) == \
2536 int(ui::TEXT_INPUT_TYPE_TIME), mismatching_enum);
2537COMPILE_ASSERT(int(WebKit::WebTextInputTypeWeek) == \
2538 int(ui::TEXT_INPUT_TYPE_WEEK), mismatching_enum);
[email protected]2a9893672012-11-09 20:33:012539COMPILE_ASSERT(int(WebKit::WebTextInputTypeTextArea) == \
2540 int(ui::TEXT_INPUT_TYPE_TEXT_AREA), mismatching_enums);
2541COMPILE_ASSERT(int(WebKit::WebTextInputTypeContentEditable) == \
2542 int(ui::TEXT_INPUT_TYPE_CONTENT_EDITABLE), mismatching_enums);
[email protected]8b4992e2013-03-01 15:42:152543COMPILE_ASSERT(int(WebKit::WebTextInputTypeDateTimeField) == \
2544 int(ui::TEXT_INPUT_TYPE_DATE_TIME_FIELD), mismatching_enums);
[email protected]ad26ef42011-06-17 07:59:452545
[email protected]5b739cb2012-08-21 20:35:212546ui::TextInputType RenderWidget::WebKitToUiTextInputType(
2547 WebKit::WebTextInputType type) {
2548 // Check the type is in the range representable by ui::TextInputType.
2549 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX)) <<
2550 "WebKit::WebTextInputType and ui::TextInputType not synchronized";
2551 return static_cast<ui::TextInputType>(type);
2552}
2553
[email protected]ad26ef42011-06-17 07:59:452554ui::TextInputType RenderWidget::GetTextInputType() {
[email protected]8969bb3f2012-11-30 21:49:272555 if (webwidget_)
2556 return WebKitToUiTextInputType(webwidget_->textInputInfo().type);
[email protected]ad26ef42011-06-17 07:59:452557 return ui::TEXT_INPUT_TYPE_NONE;
2558}
2559
[email protected]501ea13d2013-07-09 17:03:292560#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
2561void RenderWidget::UpdateCompositionInfo(bool should_update_range) {
[email protected]db4fc1e2013-09-06 20:01:512562 gfx::Range range = gfx::Range();
[email protected]501ea13d2013-07-09 17:03:292563 if (should_update_range) {
2564 GetCompositionRange(&range);
2565 } else {
2566 range = composition_range_;
2567 }
2568 std::vector<gfx::Rect> character_bounds;
2569 GetCompositionCharacterBounds(&character_bounds);
2570
2571 if (!ShouldUpdateCompositionInfo(range, character_bounds))
2572 return;
2573 composition_character_bounds_ = character_bounds;
2574 composition_range_ = range;
2575 Send(new ViewHostMsg_ImeCompositionRangeChanged(
2576 routing_id(), composition_range_, composition_character_bounds_));
2577}
2578
[email protected]58b48a0d2012-06-13 07:01:352579void RenderWidget::GetCompositionCharacterBounds(
2580 std::vector<gfx::Rect>* bounds) {
2581 DCHECK(bounds);
2582 bounds->clear();
2583}
2584
[email protected]db4fc1e2013-09-06 20:01:512585void RenderWidget::GetCompositionRange(gfx::Range* range) {
[email protected]88dbe32f2013-06-20 23:31:362586 size_t location, length;
2587 if (webwidget_->compositionRange(&location, &length)) {
2588 range->set_start(location);
2589 range->set_end(location + length);
2590 } else if (webwidget_->caretOrSelectionRange(&location, &length)) {
2591 range->set_start(location);
2592 range->set_end(location + length);
2593 } else {
[email protected]db4fc1e2013-09-06 20:01:512594 *range = gfx::Range::InvalidRange();
[email protected]88dbe32f2013-06-20 23:31:362595 }
2596}
2597
[email protected]501ea13d2013-07-09 17:03:292598bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:512599 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:292600 const std::vector<gfx::Rect>& bounds) {
2601 if (composition_range_ != range)
2602 return true;
2603 if (bounds.size() != composition_character_bounds_.size())
2604 return true;
2605 for (size_t i = 0; i < bounds.size(); ++i) {
2606 if (bounds[i] != composition_character_bounds_[i])
2607 return true;
2608 }
2609 return false;
2610}
2611#endif
2612
[email protected]ad26ef42011-06-17 07:59:452613bool RenderWidget::CanComposeInline() {
2614 return true;
[email protected]56ea1a62011-05-30 07:05:572615}
2616
[email protected]4873c7d2009-07-16 06:36:282617WebScreenInfo RenderWidget::screenInfo() {
[email protected]842f10652012-06-06 01:54:042618 return screen_info_;
[email protected]4873c7d2009-07-16 06:36:282619}
2620
[email protected]f660d9c2012-06-06 18:31:212621float RenderWidget::deviceScaleFactor() {
2622 return device_scale_factor_;
2623}
2624
[email protected]fa7b1dc2010-06-23 17:53:042625void RenderWidget::resetInputMethod() {
2626 if (!input_method_is_active_)
2627 return;
2628
[email protected]0e45bd02013-07-12 20:20:022629 ImeEventGuard guard(this);
[email protected]fa7b1dc2010-06-23 17:53:042630 // If the last text input type is not None, then we should finish any
2631 // ongoing composition regardless of the new text input type.
[email protected]ad26ef42011-06-17 07:59:452632 if (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE) {
[email protected]fa7b1dc2010-06-23 17:53:042633 // If a composition text exists, then we need to let the browser process
2634 // to cancel the input method's ongoing composition session.
2635 if (webwidget_->confirmComposition())
2636 Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
2637 }
[email protected]d4cff272011-05-02 15:46:012638
[email protected]501ea13d2013-07-09 17:03:292639#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362640 UpdateCompositionInfo(true);
[email protected]501ea13d2013-07-09 17:03:292641#endif
[email protected]fa7b1dc2010-06-23 17:53:042642}
2643
[email protected]c68c3e4e2013-01-24 00:36:562644void RenderWidget::didHandleGestureEvent(
2645 const WebGestureEvent& event,
2646 bool event_cancelled) {
2647#if defined(OS_ANDROID)
2648 if (event_cancelled)
2649 return;
2650 if (event.type == WebInputEvent::GestureTap ||
2651 event.type == WebInputEvent::GestureLongPress) {
[email protected]0d1ebed12013-08-05 22:01:132652 UpdateTextInputState(true, true);
[email protected]c68c3e4e2013-01-24 00:36:562653 }
2654#endif
2655}
2656
[email protected]29e2fb42013-07-19 01:13:472657void RenderWidget::SchedulePluginMove(const WebPluginGeometry& move) {
initial.commit09911bf2008-07-26 23:55:292658 size_t i = 0;
2659 for (; i < plugin_window_moves_.size(); ++i) {
2660 if (plugin_window_moves_[i].window == move.window) {
[email protected]16f89d02009-08-26 17:17:582661 if (move.rects_valid) {
2662 plugin_window_moves_[i] = move;
2663 } else {
2664 plugin_window_moves_[i].visible = move.visible;
2665 }
initial.commit09911bf2008-07-26 23:55:292666 break;
2667 }
2668 }
2669
2670 if (i == plugin_window_moves_.size())
2671 plugin_window_moves_.push_back(move);
2672}
[email protected]268654772009-08-06 23:02:042673
2674void RenderWidget::CleanupWindowInPluginMoves(gfx::PluginWindowHandle window) {
2675 for (WebPluginGeometryVector::iterator i = plugin_window_moves_.begin();
2676 i != plugin_window_moves_.end(); ++i) {
2677 if (i->window == window) {
2678 plugin_window_moves_.erase(i);
2679 break;
2680 }
2681 }
2682}
[email protected]67bfb83f2011-09-22 03:36:372683
[email protected]b63d58d2012-11-26 22:37:442684void RenderWidget::GetRenderingStats(
2685 WebKit::WebRenderingStatsImpl& stats) const {
[email protected]ba91a792013-02-06 09:48:282686 if (compositor_)
[email protected]635353c2013-03-06 09:11:202687 compositor_->GetRenderingStats(&stats.rendering_stats);
[email protected]b63d58d2012-11-26 22:37:442688
[email protected]c1e6cc062013-08-24 03:35:352689 stats.rendering_stats.Add(
2690 legacy_software_mode_stats_->GetRenderingStats());
[email protected]fef5e3972012-08-07 03:59:472691}
2692
[email protected]e9ff79c2012-10-19 21:31:262693bool RenderWidget::GetGpuRenderingStats(GpuRenderingStats* stats) const {
[email protected]63b465922012-09-06 02:04:522694 GpuChannelHost* gpu_channel = RenderThreadImpl::current()->GetGpuChannel();
2695 if (!gpu_channel)
2696 return false;
2697
2698 return gpu_channel->CollectRenderingStatsForSurface(surface_id(), stats);
2699}
2700
[email protected]24ed0432013-04-24 07:50:312701RenderWidgetCompositor* RenderWidget::compositor() const {
2702 return compositor_.get();
2703}
2704
[email protected]3639aa82013-06-04 11:00:042705void RenderWidget::OnSetBrowserRenderingStats(
2706 const BrowserRenderingStats& stats) {
2707 browser_rendering_stats_ = stats;
2708}
2709
2710void RenderWidget::GetBrowserRenderingStats(BrowserRenderingStats* stats) {
2711 *stats = browser_rendering_stats_;
2712}
2713
[email protected]0c2ebef2013-04-03 12:14:102714void RenderWidget::BeginSmoothScroll(
[email protected]0e241b4b2012-08-18 09:06:272715 bool down,
[email protected]79fa22e2013-08-23 15:18:122716 const SyntheticGestureCompletionCallback& callback,
[email protected]267909d2012-10-20 04:36:192717 int pixels_to_scroll,
[email protected]ebd8b562012-10-09 14:44:292718 int mouse_event_x,
2719 int mouse_event_y) {
[email protected]0e241b4b2012-08-18 09:06:272720 DCHECK(!callback.is_null());
[email protected]267909d2012-10-20 04:36:192721
2722 ViewHostMsg_BeginSmoothScroll_Params params;
2723 params.scroll_down = down;
2724 params.pixels_to_scroll = pixels_to_scroll;
2725 params.mouse_event_x = mouse_event_x;
2726 params.mouse_event_y = mouse_event_y;
2727
[email protected]4a9dba42013-04-29 18:24:222728 Send(new ViewHostMsg_BeginSmoothScroll(routing_id_, params));
[email protected]79fa22e2013-08-23 15:18:122729 pending_synthetic_gesture_ = callback;
[email protected]a39ca1652012-07-13 21:30:582730}
2731
[email protected]1e1dd182013-09-12 01:51:152732void RenderWidget::BeginPinch(
2733 bool zoom_in,
2734 int pixels_to_move,
2735 int anchor_x,
2736 int anchor_y,
2737 const SyntheticGestureCompletionCallback& callback) {
2738 DCHECK(!callback.is_null());
2739
2740 ViewHostMsg_BeginPinch_Params params;
2741 params.zoom_in = zoom_in;
2742 params.pixels_to_move = pixels_to_move;
2743 params.anchor_x = anchor_x;
2744 params.anchor_y = anchor_y;
2745
2746 Send(new ViewHostMsg_BeginPinch(routing_id_, params));
2747 pending_synthetic_gesture_ = callback;
2748}
2749
[email protected]67bfb83f2011-09-22 03:36:372750bool RenderWidget::WillHandleMouseEvent(const WebKit::WebMouseEvent& event) {
2751 return false;
2752}
[email protected]c3d45532011-10-07 19:20:402753
[email protected]f56c7872013-06-18 12:31:572754bool RenderWidget::WillHandleKeyEvent(const WebKit::WebKeyboardEvent& event) {
2755 return false;
2756}
2757
[email protected]41d86852012-11-07 12:23:242758bool RenderWidget::WillHandleGestureEvent(
2759 const WebKit::WebGestureEvent& event) {
2760 return false;
2761}
2762
[email protected]ce6689f2013-03-29 12:52:552763void RenderWidget::hasTouchEventHandlers(bool has_handlers) {
2764 Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
2765}
2766
[email protected]3d5c243b2012-11-30 00:26:012767bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
2768 return true;
2769}
2770
[email protected]0634cdd42013-08-16 00:46:092771scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
2772RenderWidget::CreateGraphicsContext3D(
[email protected]92fd8c02013-03-29 08:54:152773 const WebKit::WebGraphicsContext3D::Attributes& attributes) {
[email protected]ed7defa2013-03-12 21:29:592774 if (!webwidget_)
[email protected]0634cdd42013-08-16 00:46:092775 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]ebc0e1df2013-08-01 02:46:222776 if (CommandLine::ForCurrentProcess()->HasSwitch(
2777 switches::kDisableGpuCompositing))
[email protected]0634cdd42013-08-16 00:46:092778 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]96ab016c2013-10-23 00:50:292779 if (!RenderThreadImpl::current())
2780 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
2781 scoped_refptr<GpuChannelHost> gpu_channel_host(
2782 RenderThreadImpl::current()->EstablishGpuChannelSync(
2783 CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE));
2784 if (!gpu_channel_host)
2785 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]ed7defa2013-03-12 21:29:592786
[email protected]96ab016c2013-10-23 00:50:292787 WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits limits;
[email protected]b6eb8e332013-09-10 00:51:012788#if defined(OS_ANDROID)
2789 // If we raster too fast we become upload bound, and pending
2790 // uploads consume memory. For maximum upload throughput, we would
2791 // want to allow for upload_throughput * pipeline_time of pending
2792 // uploads, after which we are just wasting memory. Since we don't
2793 // know our upload throughput yet, this just caps our memory usage.
2794 size_t divider = 1;
2795 if (base::android::SysUtils::IsLowEndDevice())
[email protected]657be322013-09-20 08:50:032796 divider = 6;
[email protected]b6eb8e332013-09-10 00:51:012797 // For reference Nexus10 can upload 1MB in about 2.5ms.
[email protected]657be322013-09-20 08:50:032798 const double max_mb_uploaded_per_ms = 2.0 / (5 * divider);
[email protected]b6eb8e332013-09-10 00:51:012799 // Deadline to draw a frame to achieve 60 frames per second.
2800 const size_t kMillisecondsPerFrame = 16;
2801 // Assuming a two frame deep pipeline between the CPU and the GPU.
[email protected]657be322013-09-20 08:50:032802 size_t max_transfer_buffer_usage_mb =
2803 static_cast<size_t>(2 * kMillisecondsPerFrame * max_mb_uploaded_per_ms);
2804 static const size_t kBytesPerMegabyte = 1024 * 1024;
[email protected]b6eb8e332013-09-10 00:51:012805 // We keep the MappedMemoryReclaimLimit the same as the upload limit
2806 // to avoid unnecessarily stalling the compositor thread.
[email protected]96ab016c2013-10-23 00:50:292807 limits.mapped_memory_reclaim_limit =
[email protected]657be322013-09-20 08:50:032808 max_transfer_buffer_usage_mb * kBytesPerMegabyte;
[email protected]b6eb8e332013-09-10 00:51:012809#endif
[email protected]96ab016c2013-10-23 00:50:292810
2811 base::WeakPtr<WebGraphicsContext3DSwapBuffersClient> swap_client;
2812
[email protected]9ee022782013-10-24 01:27:562813 if (!is_threaded_compositing_enabled_)
2814 swap_client = weak_ptr_factory_.GetWeakPtr();
[email protected]96ab016c2013-10-23 00:50:292815
2816 scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
2817 new WebGraphicsContext3DCommandBufferImpl(
2818 surface_id(),
2819 GetURLForGraphicsContext3D(),
2820 gpu_channel_host.get(),
2821 swap_client,
[email protected]8f746982013-03-21 06:28:032822 attributes,
2823 false /* bind generates resources */,
[email protected]96ab016c2013-10-23 00:50:292824 limits));
[email protected]0634cdd42013-08-16 00:46:092825 return context.Pass();
[email protected]ed7defa2013-03-12 21:29:592826}
2827
[email protected]e9ff79c2012-10-19 21:31:262828} // namespace content