blob: d96787991157ad8e25ee3c69923c9b403a0a687b [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]180ef242013-11-07 06:50:4681using blink::WebCompositionUnderline;
82using blink::WebCursorInfo;
83using blink::WebGestureEvent;
84using blink::WebInputEvent;
85using blink::WebKeyboardEvent;
86using blink::WebMouseEvent;
87using blink::WebMouseWheelEvent;
88using blink::WebNavigationPolicy;
89using blink::WebPagePopup;
90using blink::WebPopupMenu;
91using blink::WebPopupMenuInfo;
92using blink::WebPopupType;
93using blink::WebRange;
94using blink::WebRect;
95using blink::WebScreenInfo;
96using blink::WebSize;
97using blink::WebTextDirection;
98using blink::WebTouchEvent;
99using blink::WebVector;
100using blink::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(
[email protected]180ef242013-11-07 06:50:46137 const blink::WebString& input_mode) {
[email protected]b256eca2013-07-11 10:57:40138 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,
[email protected]7f99fc22013-11-08 14:05:58162 const gfx::Rect& device_rect,
[email protected]b2e4c70132013-10-03 02:07:51163 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(
[email protected]7f99fc22013-11-08 14:05:58173 const gfx::Rect& device_rect,
[email protected]b2e4c70132013-10-03 02:07:51174 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
[email protected]7f99fc22013-11-08 14:05:58191 // Parameters as passed by RenderWidget::EnableScreenMetricsEmulation.
192 gfx::Rect device_rect_;
[email protected]b2e4c70132013-10-03 02:07:51193 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_;
[email protected]180ef242013-11-07 06:50:46203 blink::WebScreenInfo original_screen_info_;
[email protected]b2e4c70132013-10-03 02:07:51204 gfx::Rect original_view_screen_rect_;
205 gfx::Rect original_window_screen_rect_;
206};
207
208RenderWidget::ScreenMetricsEmulator::ScreenMetricsEmulator(
209 RenderWidget* widget,
[email protected]7f99fc22013-11-08 14:05:58210 const gfx::Rect& device_rect,
[email protected]b2e4c70132013-10-03 02:07:51211 const gfx::Rect& widget_rect,
212 float device_scale_factor,
213 bool fit_to_view)
214 : widget_(widget),
[email protected]7f99fc22013-11-08 14:05:58215 device_rect_(device_rect),
[email protected]b2e4c70132013-10-03 02:07:51216 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);
[email protected]7f99fc22013-11-08 14:05:58233 widget_->SetScreenMetricsEmulationParameters(0.f, gfx::Point(), 1.f);
[email protected]b2e4c70132013-10-03 02:07:51234 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(
[email protected]7f99fc22013-11-08 14:05:58242 const gfx::Rect& device_rect,
[email protected]b2e4c70132013-10-03 02:07:51243 const gfx::Rect& widget_rect,
244 float device_scale_factor,
245 bool fit_to_view) {
[email protected]7f99fc22013-11-08 14:05:58246 device_rect_ = device_rect;
[email protected]b2e4c70132013-10-03 02:07:51247 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());
[email protected]4328f3c2013-11-02 02:26:23258
[email protected]4328f3c2013-11-02 02:26:23259 int width_with_gutter =
[email protected]7f99fc22013-11-08 14:05:58260 std::max(original_size_.width() - 2 * device_rect_.x(), 1);
[email protected]4328f3c2013-11-02 02:26:23261 int height_with_gutter =
[email protected]7f99fc22013-11-08 14:05:58262 std::max(original_size_.height() - 2 * device_rect_.y(), 1);
[email protected]b2e4c70132013-10-03 02:07:51263 float width_ratio =
[email protected]4328f3c2013-11-02 02:26:23264 static_cast<float>(widget_rect_.width()) / width_with_gutter;
[email protected]b2e4c70132013-10-03 02:07:51265 float height_ratio =
[email protected]4328f3c2013-11-02 02:26:23266 static_cast<float>(widget_rect_.height()) / height_with_gutter;
[email protected]b2e4c70132013-10-03 02:07:51267 float ratio = std::max(1.0f, std::max(width_ratio, height_ratio));
268 scale_ = 1.f / ratio;
269 } else {
270 scale_ = 1.f;
271 }
272
[email protected]7f99fc22013-11-08 14:05:58273 widget_->screen_info_.rect = gfx::Rect(device_rect_.size());
274 widget_->screen_info_.availableRect = gfx::Rect(device_rect_.size());
[email protected]b2e4c70132013-10-03 02:07:51275 widget_->screen_info_.deviceScaleFactor = device_scale_factor_;
276
[email protected]7f99fc22013-11-08 14:05:58277 // Pass three emulation parameters to the blink side:
[email protected]b2e4c70132013-10-03 02:07:51278 // - we keep the real device scale factor in compositor to produce sharp image
279 // even when emulating different scale factor;
[email protected]7f99fc22013-11-08 14:05:58280 // - in order to fit into view, WebView applies offset and scale to the
[email protected]b2e4c70132013-10-03 02:07:51281 // root layer.
282 widget_->SetScreenMetricsEmulationParameters(
[email protected]7f99fc22013-11-08 14:05:58283 original_screen_info_.deviceScaleFactor, device_rect_.origin(), scale_);
[email protected]b2e4c70132013-10-03 02:07:51284
285 widget_->SetDeviceScaleFactor(device_scale_factor_);
286 widget_->view_screen_rect_ = widget_rect_;
287 widget_->window_screen_rect_ = widget_->screen_info_.availableRect;
288
289 gfx::Size physical_backing_size = gfx::ToCeiledSize(gfx::ScaleSize(
290 original_size_, original_screen_info_.deviceScaleFactor));
291 widget_->Resize(widget_rect_.size(), physical_backing_size,
292 overdraw_bottom_height, resizer_rect, is_fullscreen, NO_RESIZE_ACK);
293}
294
295void RenderWidget::ScreenMetricsEmulator::OnResizeMessage(
296 const ViewMsg_Resize_Params& params) {
297 bool need_ack = params.new_size != original_size_ &&
298 !params.new_size.IsEmpty() && !params.physical_backing_size.IsEmpty();
299 original_size_ = params.new_size;
300 original_physical_backing_size_ = params.physical_backing_size;
301 original_screen_info_ = params.screen_info;
302 Apply(params.overdraw_bottom_height, params.resizer_rect,
303 params.is_fullscreen);
304
305 if (need_ack) {
306 widget_->set_next_paint_is_resize_ack();
307 if (widget_->compositor_)
308 widget_->compositor_->SetNeedsRedrawRect(gfx::Rect(widget_->size_));
309 }
310}
311
312void RenderWidget::ScreenMetricsEmulator::OnUpdateScreenRectsMessage(
313 const gfx::Rect& view_screen_rect,
314 const gfx::Rect& window_screen_rect) {
315 original_view_screen_rect_ = view_screen_rect;
316 original_window_screen_rect_ = window_screen_rect;
317}
318
319void RenderWidget::ScreenMetricsEmulator::OnShowContextMenu(
320 ContextMenuParams* params) {
[email protected]b2e4c70132013-10-03 02:07:51321 params->x *= scale_;
[email protected]7f99fc22013-11-08 14:05:58322 params->x += device_rect_.x();
[email protected]b2e4c70132013-10-03 02:07:51323 params->y *= scale_;
[email protected]7f99fc22013-11-08 14:05:58324 params->y += device_rect_.y();
[email protected]b2e4c70132013-10-03 02:07:51325}
326
327// RenderWidget ---------------------------------------------------------------
328
[email protected]180ef242013-11-07 06:50:46329RenderWidget::RenderWidget(blink::WebPopupType popup_type,
330 const blink::WebScreenInfo& screen_info,
[email protected]1ac10dca2013-08-20 20:47:04331 bool swapped_out,
332 bool hidden)
initial.commit09911bf2008-07-26 23:55:29333 : routing_id_(MSG_ROUTING_NONE),
[email protected]9f4f3322012-01-18 22:29:56334 surface_id_(0),
[email protected]c5b3b5e2009-02-13 06:41:11335 webwidget_(NULL),
initial.commit09911bf2008-07-26 23:55:29336 opener_id_(MSG_ROUTING_NONE),
[email protected]fc4404d2012-11-07 19:53:30337 init_complete_(false),
[email protected]b4d08452010-10-05 17:34:35338 current_paint_buf_(NULL),
[email protected]d9083762013-03-24 01:36:40339 overdraw_bottom_height_(0.f),
initial.commit09911bf2008-07-26 23:55:29340 next_paint_flags_(0),
[email protected]0cff69e2011-11-22 22:26:06341 filtered_time_per_frame_(0.0f),
[email protected]53d3f302009-12-21 04:42:05342 update_reply_pending_(false),
[email protected]847a2582013-03-09 02:29:51343 auto_resize_mode_(false),
[email protected]ea3ee0a2012-05-15 03:43:09344 need_update_rect_for_auto_resize_(false),
[email protected]65225772011-05-12 21:10:24345 using_asynchronous_swapbuffers_(false),
346 num_swapbuffers_complete_pending_(0),
initial.commit09911bf2008-07-26 23:55:29347 did_show_(false),
[email protected]1ac10dca2013-08-20 20:47:04348 is_hidden_(hidden),
[email protected]ee41e7d22011-10-14 19:34:09349 is_fullscreen_(false),
initial.commit09911bf2008-07-26 23:55:29350 needs_repainting_on_restore_(false),
351 has_focus_(false),
[email protected]5dd768212009-08-13 23:34:49352 handling_input_event_(false),
[email protected]e8f775f2013-02-14 21:00:50353 handling_ime_event_(false),
[email protected]661eb9d2009-02-03 02:11:48354 closing_(false),
[email protected]14392a52012-05-02 20:28:44355 is_swapped_out_(swapped_out),
[email protected]fa7b1dc2010-06-23 17:53:04356 input_method_is_active_(false),
[email protected]ad26ef42011-06-17 07:59:45357 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
[email protected]b256eca2013-07-11 10:57:40358 text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
[email protected]86ba5fcb2013-09-04 00:36:53359 can_compose_inline_(true),
[email protected]3e2b375b2010-04-07 17:03:12360 popup_type_(popup_type),
[email protected]867125a02009-12-10 06:01:48361 pending_window_rect_count_(0),
[email protected]b68a0e52011-12-08 15:11:12362 suppress_next_char_events_(false),
[email protected]5f8b1022011-01-21 23:34:50363 is_accelerated_compositing_active_(false),
[email protected]d8a6c5d12013-09-23 04:37:10364 was_accelerated_compositing_ever_active_(false),
[email protected]ee3d3ad2011-02-04 00:42:21365 animation_update_pending_(false),
[email protected]4b03e292012-02-13 18:40:07366 invalidation_task_posted_(false),
[email protected]842f10652012-06-06 01:54:04367 screen_info_(screen_info),
[email protected]3d779472012-11-15 20:49:52368 device_scale_factor_(screen_info_.deviceScaleFactor),
[email protected]ed7defa2013-03-12 21:29:59369 is_threaded_compositing_enabled_(false),
[email protected]53b4cc12013-07-18 23:02:30370 next_output_surface_id_(0),
[email protected]0d1ebed12013-08-05 22:01:13371#if defined(OS_ANDROID)
372 outstanding_ime_acks_(0),
373#endif
[email protected]b2e4c70132013-10-03 02:07:51374 popup_origin_scale_for_emulation_(0.f),
[email protected]4d7e46a2013-11-08 05:33:40375 resizing_mode_selector_(new ResizingModeSelector()) {
[email protected]8b3f0eb2012-05-03 19:15:05376 if (!swapped_out)
377 RenderProcess::current()->AddRefProcess();
[email protected]380244092011-10-07 17:26:27378 DCHECK(RenderThread::Get());
[email protected]bd37ae252011-06-03 01:28:18379 has_disable_gpu_vsync_switch_ = CommandLine::ForCurrentProcess()->HasSwitch(
380 switches::kDisableGpuVsync);
[email protected]cb6430932012-10-31 00:53:36381 is_threaded_compositing_enabled_ =
382 CommandLine::ForCurrentProcess()->HasSwitch(
383 switches::kEnableThreadedCompositing);
[email protected]c1e6cc062013-08-24 03:35:35384
385 legacy_software_mode_stats_ = cc::RenderingStatsInstrumentation::Create();
386 if (CommandLine::ForCurrentProcess()->HasSwitch(
387 switches::kEnableGpuBenchmarking))
388 legacy_software_mode_stats_->set_record_rendering_stats(true);
initial.commit09911bf2008-07-26 23:55:29389}
390
391RenderWidget::~RenderWidget() {
[email protected]c5b3b5e2009-02-13 06:41:11392 DCHECK(!webwidget_) << "Leaking our WebWidget!";
[email protected]aa4117f2011-12-09 22:19:21393 STLDeleteElements(&updates_pending_swap_);
[email protected]b4d08452010-10-05 17:34:35394 if (current_paint_buf_) {
[email protected]467414eb2013-07-30 20:32:29395 if (RenderProcess::current()) {
396 // If the RenderProcess is already gone, it will have released all DIBs
397 // in its destructor anyway.
398 RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
399 }
[email protected]b4d08452010-10-05 17:34:35400 current_paint_buf_ = NULL;
initial.commit09911bf2008-07-26 23:55:29401 }
[email protected]992db4c2011-05-12 15:37:15402 // If we are swapped out, we have released already.
[email protected]d2e2f9ee2013-08-21 11:02:02403 if (!is_swapped_out_ && RenderProcess::current())
[email protected]992db4c2011-05-12 15:37:15404 RenderProcess::current()->ReleaseProcess();
initial.commit09911bf2008-07-26 23:55:29405}
406
[email protected]484955942010-08-19 16:13:18407// static
[email protected]8085dbc82008-09-26 22:53:44408RenderWidget* RenderWidget::Create(int32 opener_id,
[email protected]180ef242013-11-07 06:50:46409 blink::WebPopupType popup_type,
410 const blink::WebScreenInfo& screen_info) {
initial.commit09911bf2008-07-26 23:55:29411 DCHECK(opener_id != MSG_ROUTING_NONE);
[email protected]6fd35b72012-03-01 19:46:41412 scoped_refptr<RenderWidget> widget(
[email protected]1ac10dca2013-08-20 20:47:04413 new RenderWidget(popup_type, screen_info, false, false));
[email protected]a635f942012-12-07 10:34:29414 if (widget->Init(opener_id)) { // adds reference on success.
[email protected]fc72bb12013-06-02 21:13:46415 return widget.get();
[email protected]a635f942012-12-07 10:34:29416 }
417 return NULL;
initial.commit09911bf2008-07-26 23:55:29418}
419
[email protected]484955942010-08-19 16:13:18420// static
421WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) {
422 switch (render_widget->popup_type_) {
[email protected]180ef242013-11-07 06:50:46423 case blink::WebPopupTypeNone: // Nothing to create.
[email protected]484955942010-08-19 16:13:18424 break;
[email protected]180ef242013-11-07 06:50:46425 case blink::WebPopupTypeSelect:
426 case blink::WebPopupTypeSuggestion:
[email protected]484955942010-08-19 16:13:18427 return WebPopupMenu::create(render_widget);
[email protected]180ef242013-11-07 06:50:46428 case blink::WebPopupTypePage:
[email protected]a7547fb2012-03-08 04:43:44429 return WebPagePopup::create(render_widget);
[email protected]180ef242013-11-07 06:50:46430 case blink::WebPopupTypeHelperPlugin:
431 return blink::WebHelperPlugin::create(render_widget);
[email protected]484955942010-08-19 16:13:18432 default:
433 NOTREACHED();
434 }
435 return NULL;
436}
437
[email protected]a635f942012-12-07 10:34:29438bool RenderWidget::Init(int32 opener_id) {
439 return DoInit(opener_id,
440 RenderWidget::CreateWebWidget(this),
441 new ViewHostMsg_CreateWidget(opener_id, popup_type_,
442 &routing_id_, &surface_id_));
[email protected]484955942010-08-19 16:13:18443}
444
[email protected]a635f942012-12-07 10:34:29445bool RenderWidget::DoInit(int32 opener_id,
[email protected]6a8ddba52010-09-05 04:38:06446 WebWidget* web_widget,
[email protected]484955942010-08-19 16:13:18447 IPC::SyncMessage* create_widget_message) {
initial.commit09911bf2008-07-26 23:55:29448 DCHECK(!webwidget_);
449
450 if (opener_id != MSG_ROUTING_NONE)
451 opener_id_ = opener_id;
452
[email protected]484955942010-08-19 16:13:18453 webwidget_ = web_widget;
initial.commit09911bf2008-07-26 23:55:29454
[email protected]380244092011-10-07 17:26:27455 bool result = RenderThread::Get()->Send(create_widget_message);
initial.commit09911bf2008-07-26 23:55:29456 if (result) {
[email protected]380244092011-10-07 17:26:27457 RenderThread::Get()->AddRoute(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29458 // Take a reference on behalf of the RenderThread. This will be balanced
459 // when we receive ViewMsg_Close.
460 AddRef();
[email protected]1ac10dca2013-08-20 20:47:04461 if (is_hidden_)
462 RenderThread::Get()->WidgetHidden();
[email protected]a635f942012-12-07 10:34:29463 return true;
initial.commit09911bf2008-07-26 23:55:29464 } else {
[email protected]a635f942012-12-07 10:34:29465 // The above Send can fail when the tab is closing.
466 return false;
initial.commit09911bf2008-07-26 23:55:29467 }
468}
469
[email protected]fc4404d2012-11-07 19:53:30470// This is used to complete pending inits and non-pending inits.
471void RenderWidget::CompleteInit() {
initial.commit09911bf2008-07-26 23:55:29472 DCHECK(routing_id_ != MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29473
[email protected]fc4404d2012-11-07 19:53:30474 init_complete_ = true;
[email protected]05a980d7a2012-02-07 22:16:42475
[email protected]8926c602013-01-23 05:32:06476 if (webwidget_ && is_threaded_compositing_enabled_) {
477 webwidget_->enterForceCompositingMode(true);
478 }
[email protected]ba91a792013-02-06 09:48:28479 if (compositor_) {
480 compositor_->setSurfaceReady();
[email protected]479b0172012-10-29 19:27:09481 }
[email protected]05a980d7a2012-02-07 22:16:42482 DoDeferredUpdate();
initial.commit09911bf2008-07-26 23:55:29483
[email protected]6de74452009-02-25 18:04:59484 Send(new ViewHostMsg_RenderViewReady(routing_id_));
initial.commit09911bf2008-07-26 23:55:29485}
486
[email protected]992db4c2011-05-12 15:37:15487void RenderWidget::SetSwappedOut(bool is_swapped_out) {
488 // We should only toggle between states.
489 DCHECK(is_swapped_out_ != is_swapped_out);
490 is_swapped_out_ = is_swapped_out;
491
492 // If we are swapping out, we will call ReleaseProcess, allowing the process
493 // to exit if all of its RenderViews are swapped out. We wait until the
494 // WasSwappedOut call to do this, to avoid showing the sad tab.
495 // If we are swapping in, we call AddRefProcess to prevent the process from
496 // exiting.
497 if (!is_swapped_out)
498 RenderProcess::current()->AddRefProcess();
499}
500
[email protected]34bb3ac2013-03-08 02:41:28501bool RenderWidget::AllowPartialSwap() const {
502 return true;
503}
504
[email protected]c8cbae72013-05-23 10:45:03505bool RenderWidget::UsingSynchronousRendererCompositor() const {
[email protected]ccc1722e2013-05-06 19:43:07506#if defined(OS_ANDROID)
[email protected]913d99a2013-05-31 07:16:07507 return SynchronousCompositorFactory::GetInstance() != NULL;
508#else
[email protected]ccc1722e2013-05-06 19:43:07509 return false;
[email protected]913d99a2013-05-31 07:16:07510#endif
[email protected]ccc1722e2013-05-06 19:43:07511}
512
[email protected]b2e4c70132013-10-03 02:07:51513void RenderWidget::EnableScreenMetricsEmulation(
[email protected]7f99fc22013-11-08 14:05:58514 const gfx::Rect& device_rect,
[email protected]b2e4c70132013-10-03 02:07:51515 const gfx::Rect& widget_rect,
516 float device_scale_factor,
517 bool fit_to_view) {
518 if (!screen_metrics_emulator_) {
519 screen_metrics_emulator_.reset(new ScreenMetricsEmulator(this,
[email protected]7f99fc22013-11-08 14:05:58520 device_rect, widget_rect, device_scale_factor, fit_to_view));
[email protected]b2e4c70132013-10-03 02:07:51521 } else {
[email protected]7f99fc22013-11-08 14:05:58522 screen_metrics_emulator_->ChangeEmulationParams(device_rect,
[email protected]b2e4c70132013-10-03 02:07:51523 widget_rect, device_scale_factor, fit_to_view);
524 }
525}
526
527void RenderWidget::DisableScreenMetricsEmulation() {
528 screen_metrics_emulator_.reset();
529}
530
531void RenderWidget::SetPopupOriginAdjustmentsForEmulation(
532 ScreenMetricsEmulator* emulator) {
533 popup_origin_scale_for_emulation_ = emulator->scale();
534 popup_view_origin_for_emulation_ = emulator->widget_rect().origin();
535 popup_screen_origin_for_emulation_ =
536 emulator->original_screen_rect().origin();
537}
538
539void RenderWidget::SetScreenMetricsEmulationParameters(
[email protected]7f99fc22013-11-08 14:05:58540 float device_scale_factor,
541 const gfx::Point& root_layer_offset,
542 float root_layer_scale) {
[email protected]b2e4c70132013-10-03 02:07:51543 // This is only supported in RenderView.
544 NOTREACHED();
545}
546
547void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
548 ExternalPopupMenu* popup, ScreenMetricsEmulator* emulator) {
549 popup->SetOriginScaleForEmulation(emulator->scale());
550}
551
552void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
553 if (screen_metrics_emulator_)
554 screen_metrics_emulator_->OnShowContextMenu(params);
555}
556
[email protected]7d08a9352013-10-15 08:24:56557void RenderWidget::ScheduleCompositeWithForcedRedraw() {
558 if (compositor_) {
559 // Regardless of whether threaded compositing is enabled, always
560 // use this mechanism to force the compositor to redraw. However,
561 // the invalidation code path below is still needed for the
562 // non-threaded case.
563 compositor_->SetNeedsForcedRedraw();
564 }
565 ScheduleCompositeImpl(true);
566}
567
568void RenderWidget::ScheduleCompositeImpl(bool force_redraw) {
569 if (RenderThreadImpl::current()->compositor_message_loop_proxy().get() &&
570 compositor_) {
571 if (!force_redraw) {
572 compositor_->setNeedsRedraw();
573 }
574 } else {
575 // TODO(nduca): replace with something a little less hacky. The reason this
576 // hack is still used is because the Invalidate-DoDeferredUpdate loop
577 // contains a lot of host-renderer synchronization logic that is still
578 // important for the accelerated compositing case. The option of simply
579 // duplicating all that code is less desirable than "faking out" the
580 // invalidation path using a magical damage rect.
581 didInvalidateRect(WebRect(0, 0, 1, 1));
582 }
583}
584
[email protected]a95986a82010-12-24 06:19:28585bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
586 bool handled = true;
587 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
[email protected]c084330e02013-04-27 01:08:15588 IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
[email protected]34202de2013-05-06 23:36:22589 IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
590 OnCursorVisibilityChange)
[email protected]c084330e02013-04-27 01:08:15591 IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
592 IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
[email protected]a95986a82010-12-24 06:19:28593 IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
594 IPC_MESSAGE_HANDLER(ViewMsg_CreatingNew_ACK, OnCreatingNewAck)
595 IPC_MESSAGE_HANDLER(ViewMsg_Resize, OnResize)
[email protected]b5913d72012-02-07 22:26:54596 IPC_MESSAGE_HANDLER(ViewMsg_ChangeResizeRect, OnChangeResizeRect)
[email protected]a95986a82010-12-24 06:19:28597 IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
[email protected]9e2e4632012-07-27 16:38:41598 IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
[email protected]992db4c2011-05-12 15:37:15599 IPC_MESSAGE_HANDLER(ViewMsg_WasSwappedOut, OnWasSwappedOut)
[email protected]a95986a82010-12-24 06:19:28600 IPC_MESSAGE_HANDLER(ViewMsg_UpdateRect_ACK, OnUpdateRectAck)
[email protected]4d7e46a2013-11-08 05:33:40601 IPC_MESSAGE_HANDLER(ViewMsg_SwapBuffers_ACK, OnSwapBuffersComplete)
[email protected]a95986a82010-12-24 06:19:28602 IPC_MESSAGE_HANDLER(ViewMsg_SetInputMethodActive, OnSetInputMethodActive)
603 IPC_MESSAGE_HANDLER(ViewMsg_ImeSetComposition, OnImeSetComposition)
604 IPC_MESSAGE_HANDLER(ViewMsg_ImeConfirmComposition, OnImeConfirmComposition)
[email protected]3d9ec5052013-01-02 22:05:25605 IPC_MESSAGE_HANDLER(ViewMsg_PaintAtSize, OnPaintAtSize)
606 IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
[email protected]79fa22e2013-08-23 15:18:12607 IPC_MESSAGE_HANDLER(ViewMsg_SyntheticGestureCompleted,
608 OnSyntheticGestureCompleted)
[email protected]a95986a82010-12-24 06:19:28609 IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
610 IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
[email protected]80ad8622012-11-07 16:33:03611 IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
[email protected]105dffb42013-02-20 03:46:21612#if defined(OS_ANDROID)
[email protected]2384b6c2013-02-28 23:58:51613 IPC_MESSAGE_HANDLER(ViewMsg_ShowImeIfNeeded, OnShowImeIfNeeded)
[email protected]0d1ebed12013-08-05 22:01:13614 IPC_MESSAGE_HANDLER(ViewMsg_ImeEventAck, OnImeEventAck)
[email protected]105dffb42013-02-20 03:46:21615#endif
[email protected]51a49502013-03-23 01:50:19616 IPC_MESSAGE_HANDLER(ViewMsg_Snapshot, OnSnapshot)
[email protected]3639aa82013-06-04 11:00:04617 IPC_MESSAGE_HANDLER(ViewMsg_SetBrowserRenderingStats,
618 OnSetBrowserRenderingStats)
[email protected]a95986a82010-12-24 06:19:28619 IPC_MESSAGE_UNHANDLED(handled = false)
620 IPC_END_MESSAGE_MAP()
621 return handled;
622}
initial.commit09911bf2008-07-26 23:55:29623
624bool RenderWidget::Send(IPC::Message* message) {
[email protected]992db4c2011-05-12 15:37:15625 // Don't send any messages after the browser has told us to close, and filter
626 // most outgoing messages while swapped out.
627 if ((is_swapped_out_ &&
[email protected]e9ff79c2012-10-19 21:31:26628 !SwappedOutMessages::CanSendWhileSwappedOut(message)) ||
[email protected]c6c921e92012-05-10 23:31:11629 closing_) {
initial.commit09911bf2008-07-26 23:55:29630 delete message;
631 return false;
632 }
633
634 // If given a messsage without a routing ID, then assign our routing ID.
635 if (message->routing_id() == MSG_ROUTING_NONE)
636 message->set_routing_id(routing_id_);
637
[email protected]380244092011-10-07 17:26:27638 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44639}
640
[email protected]61e2b3cc2012-03-02 16:13:34641void RenderWidget::Resize(const gfx::Size& new_size,
[email protected]60d47ac2013-03-01 23:42:44642 const gfx::Size& physical_backing_size,
[email protected]d9083762013-03-24 01:36:40643 float overdraw_bottom_height,
[email protected]61e2b3cc2012-03-02 16:13:34644 const gfx::Rect& resizer_rect,
645 bool is_fullscreen,
646 ResizeAck resize_ack) {
[email protected]f7c1f092013-11-05 20:20:56647 if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
[email protected]1c0008842013-06-06 08:35:48648 // A resize ack shouldn't be requested if we have not ACK'd the previous
649 // one.
650 DCHECK(resize_ack != SEND_RESIZE_ACK || !next_paint_is_resize_ack());
651 DCHECK(resize_ack == SEND_RESIZE_ACK || resize_ack == NO_RESIZE_ACK);
652 }
initial.commit09911bf2008-07-26 23:55:29653
[email protected]61e2b3cc2012-03-02 16:13:34654 // Ignore this during shutdown.
655 if (!webwidget_)
656 return;
657
[email protected]d9083762013-03-24 01:36:40658 if (compositor_) {
[email protected]60d47ac2013-03-01 23:42:44659 compositor_->setViewportSize(new_size, physical_backing_size);
[email protected]d9083762013-03-24 01:36:40660 compositor_->SetOverdrawBottomHeight(overdraw_bottom_height);
661 }
[email protected]60d47ac2013-03-01 23:42:44662
[email protected]dade8992013-03-04 07:34:34663 physical_backing_size_ = physical_backing_size;
[email protected]d9083762013-03-24 01:36:40664 overdraw_bottom_height_ = overdraw_bottom_height;
[email protected]61e2b3cc2012-03-02 16:13:34665 resizer_rect_ = resizer_rect;
666
667 // NOTE: We may have entered fullscreen mode without changing our size.
668 bool fullscreen_change = is_fullscreen_ != is_fullscreen;
669 if (fullscreen_change)
670 WillToggleFullscreen();
671 is_fullscreen_ = is_fullscreen;
672
673 if (size_ != new_size) {
674 // TODO(darin): We should not need to reset this here.
[email protected]61e2b3cc2012-03-02 16:13:34675 needs_repainting_on_restore_ = false;
676
677 size_ = new_size;
678
679 paint_aggregator_.ClearPendingUpdate();
680
681 // When resizing, we want to wait to paint before ACK'ing the resize. This
682 // ensures that we only resize as fast as we can paint. We only need to
683 // send an ACK if we are resized to a non-empty rect.
684 webwidget_->resize(new_size);
[email protected]0b70dbe2013-05-10 19:06:32685
[email protected]f7c1f092013-11-05 20:20:56686 if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
[email protected]92201e32013-06-08 06:14:52687 // Resize should have caused an invalidation of the entire view.
688 DCHECK(new_size.IsEmpty() || is_accelerated_compositing_active_ ||
689 paint_aggregator_.HasPendingUpdate());
690 }
[email protected]5b45ad42013-10-25 00:42:04691 } else if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]632c4382013-05-15 08:58:45692 resize_ack = NO_RESIZE_ACK;
693 }
694
695 if (new_size.IsEmpty() || physical_backing_size.IsEmpty()) {
696 // For empty size or empty physical_backing_size, there is no next paint
697 // (along with which to send the ack) until they are set to non-empty.
[email protected]ff475a322012-03-14 00:05:35698 resize_ack = NO_RESIZE_ACK;
[email protected]61e2b3cc2012-03-02 16:13:34699 }
700
[email protected]20fbfc22013-05-08 20:50:58701 // Send the Resize_ACK flag once we paint again if requested.
[email protected]632c4382013-05-15 08:58:45702 if (resize_ack == SEND_RESIZE_ACK)
[email protected]20fbfc22013-05-08 20:50:58703 set_next_paint_is_resize_ack();
704
[email protected]61e2b3cc2012-03-02 16:13:34705 if (fullscreen_change)
706 DidToggleFullscreen();
707
708 // If a resize ack is requested and it isn't set-up, then no more resizes will
709 // come in and in general things will go wrong.
[email protected]632c4382013-05-15 08:58:45710 DCHECK(resize_ack != SEND_RESIZE_ACK || next_paint_is_resize_ack());
initial.commit09911bf2008-07-26 23:55:29711}
712
[email protected]92650162013-10-30 03:31:02713void RenderWidget::ResizeSynchronously(const gfx::Rect& new_position) {
714 Resize(new_position.size(), new_position.size(), overdraw_bottom_height_,
715 gfx::Rect(), is_fullscreen_, NO_RESIZE_ACK);
716 view_screen_rect_ = new_position;
717 window_screen_rect_ = new_position;
718 if (!did_show_)
719 initial_pos_ = new_position;
720}
721
initial.commit09911bf2008-07-26 23:55:29722void RenderWidget::OnClose() {
723 if (closing_)
724 return;
725 closing_ = true;
726
727 // Browser correspondence is no longer needed at this point.
[email protected]bee16aab2009-08-26 15:55:03728 if (routing_id_ != MSG_ROUTING_NONE) {
[email protected]380244092011-10-07 17:26:27729 RenderThread::Get()->RemoveRoute(routing_id_);
[email protected]bee16aab2009-08-26 15:55:03730 SetHidden(false);
731 }
initial.commit09911bf2008-07-26 23:55:29732
initial.commit09911bf2008-07-26 23:55:29733 // If there is a Send call on the stack, then it could be dangerous to close
[email protected]d3fc25652009-02-24 22:31:25734 // now. Post a task that only gets invoked when there are no nested message
735 // loops.
[email protected]dd32b1272013-05-04 14:17:11736 base::MessageLoop::current()->PostNonNestableTask(
[email protected]3a5a7822011-12-23 18:27:29737 FROM_HERE, base::Bind(&RenderWidget::Close, this));
[email protected]d3fc25652009-02-24 22:31:25738
739 // Balances the AddRef taken when we called AddRoute.
740 Release();
initial.commit09911bf2008-07-26 23:55:29741}
742
[email protected]61e2b3cc2012-03-02 16:13:34743// Got a response from the browser after the renderer decided to create a new
744// view.
[email protected]fc4404d2012-11-07 19:53:30745void RenderWidget::OnCreatingNewAck() {
[email protected]61e2b3cc2012-03-02 16:13:34746 DCHECK(routing_id_ != MSG_ROUTING_NONE);
747
[email protected]fc4404d2012-11-07 19:53:30748 CompleteInit();
[email protected]61e2b3cc2012-03-02 16:13:34749}
750
[email protected]0fdd5012013-05-29 08:05:56751void RenderWidget::OnResize(const ViewMsg_Resize_Params& params) {
[email protected]5b45ad42013-10-25 00:42:04752 if (resizing_mode_selector_->ShouldAbortOnResize(this, params))
[email protected]03e88672013-10-22 21:31:32753 return;
754
[email protected]b2e4c70132013-10-03 02:07:51755 if (screen_metrics_emulator_) {
756 screen_metrics_emulator_->OnResizeMessage(params);
757 return;
758 }
759
[email protected]0fdd5012013-05-29 08:05:56760 screen_info_ = params.screen_info;
761 SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
762 Resize(params.new_size, params.physical_backing_size,
763 params.overdraw_bottom_height, params.resizer_rect,
764 params.is_fullscreen, SEND_RESIZE_ACK);
initial.commit09911bf2008-07-26 23:55:29765}
766
[email protected]b5913d72012-02-07 22:26:54767void RenderWidget::OnChangeResizeRect(const gfx::Rect& resizer_rect) {
768 if (resizer_rect_ != resizer_rect) {
[email protected]b9769d82012-02-10 00:23:59769 gfx::Rect view_rect(size_);
770
[email protected]ce112fe2012-10-29 22:52:18771 gfx::Rect old_damage_rect = gfx::IntersectRects(view_rect, resizer_rect_);
[email protected]b9769d82012-02-10 00:23:59772 if (!old_damage_rect.IsEmpty())
773 paint_aggregator_.InvalidateRect(old_damage_rect);
774
[email protected]ce112fe2012-10-29 22:52:18775 gfx::Rect new_damage_rect = gfx::IntersectRects(view_rect, resizer_rect);
[email protected]b9769d82012-02-10 00:23:59776 if (!new_damage_rect.IsEmpty())
777 paint_aggregator_.InvalidateRect(new_damage_rect);
778
[email protected]b5913d72012-02-07 22:26:54779 resizer_rect_ = resizer_rect;
[email protected]b9769d82012-02-10 00:23:59780
[email protected]b5913d72012-02-07 22:26:54781 if (webwidget_)
782 webwidget_->didChangeWindowResizerRect();
783 }
784}
785
initial.commit09911bf2008-07-26 23:55:29786void RenderWidget::OnWasHidden() {
[email protected]9c3085f2011-06-09 02:10:31787 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
initial.commit09911bf2008-07-26 23:55:29788 // Go into a mode where we stop generating paint and scrolling events.
[email protected]bee16aab2009-08-26 15:55:03789 SetHidden(true);
initial.commit09911bf2008-07-26 23:55:29790}
791
[email protected]9e2e4632012-07-27 16:38:41792void RenderWidget::OnWasShown(bool needs_repainting) {
793 TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
initial.commit09911bf2008-07-26 23:55:29794 // During shutdown we can just ignore this message.
795 if (!webwidget_)
796 return;
797
798 // See OnWasHidden
[email protected]bee16aab2009-08-26 15:55:03799 SetHidden(false);
initial.commit09911bf2008-07-26 23:55:29800
801 if (!needs_repainting && !needs_repainting_on_restore_)
802 return;
803 needs_repainting_on_restore_ = false;
804
[email protected]d65adb12010-04-28 17:26:49805 // Tag the next paint as a restore ack, which is picked up by
806 // DoDeferredUpdate when it sends out the next PaintRect message.
initial.commit09911bf2008-07-26 23:55:29807 set_next_paint_is_restore_ack();
808
809 // Generate a full repaint.
[email protected]a79d8a632010-11-18 22:35:56810 if (!is_accelerated_compositing_active_) {
[email protected]f98d7e3c2010-09-13 22:30:46811 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
812 } else {
[email protected]989d7fc12013-11-01 09:16:06813 if (compositor_)
814 compositor_->SetNeedsForcedRedraw();
[email protected]f98d7e3c2010-09-13 22:30:46815 scheduleComposite();
816 }
initial.commit09911bf2008-07-26 23:55:29817}
818
[email protected]992db4c2011-05-12 15:37:15819void RenderWidget::OnWasSwappedOut() {
820 // If we have been swapped out and no one else is using this process,
821 // it's safe to exit now. If we get swapped back in, we will call
822 // AddRefProcess in SetSwappedOut.
823 if (is_swapped_out_)
824 RenderProcess::current()->ReleaseProcess();
825}
826
[email protected]53d3f302009-12-21 04:42:05827void RenderWidget::OnRequestMoveAck() {
828 DCHECK(pending_window_rect_count_);
829 pending_window_rect_count_--;
830}
831
832void RenderWidget::OnUpdateRectAck() {
[email protected]366ae242011-05-10 02:23:58833 TRACE_EVENT0("renderer", "RenderWidget::OnUpdateRectAck");
[email protected]aa4117f2011-12-09 22:19:21834 DCHECK(update_reply_pending_);
[email protected]53d3f302009-12-21 04:42:05835 update_reply_pending_ = false;
836
[email protected]b4d08452010-10-05 17:34:35837 // If we sent an UpdateRect message with a zero-sized bitmap, then we should
838 // have no current paint buffer.
839 if (current_paint_buf_) {
840 RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
841 current_paint_buf_ = NULL;
842 }
843
[email protected]65225772011-05-12 21:10:24844 // If swapbuffers is still pending, then defer the update until the
845 // swapbuffers occurs.
846 if (num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending) {
847 TRACE_EVENT0("renderer", "EarlyOut_SwapStillPending");
848 return;
849 }
850
[email protected]29ed96a2012-02-04 18:12:16851 // Notify subclasses that software rendering was flushed to the screen.
[email protected]404939f2012-06-01 04:06:18852 if (!is_accelerated_compositing_active_) {
853 DidFlushPaint();
854 }
[email protected]a2f6bc112009-06-27 16:27:25855
initial.commit09911bf2008-07-26 23:55:29856 // Continue painting if necessary...
[email protected]65225772011-05-12 21:10:24857 DoDeferredUpdateAndSendInputAck();
858}
859
[email protected]d0be63772011-12-20 23:18:04860bool RenderWidget::SupportsAsynchronousSwapBuffers() {
[email protected]ed7defa2013-03-12 21:29:59861 // Contexts using the command buffer support asynchronous swapbuffers.
862 // See RenderWidget::CreateOutputSurface().
[email protected]cadac622013-06-11 16:46:36863 if (RenderThreadImpl::current()->compositor_message_loop_proxy().get())
[email protected]ed7defa2013-03-12 21:29:59864 return false;
865
866 return true;
867}
868
869GURL RenderWidget::GetURLForGraphicsContext3D() {
870 return GURL();
[email protected]65225772011-05-12 21:10:24871}
872
[email protected]479b0172012-10-29 19:27:09873bool RenderWidget::ForceCompositingModeEnabled() {
874 return false;
875}
876
[email protected]ebc0e1df2013-08-01 02:46:22877scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(bool fallback) {
[email protected]a1811b8912013-05-09 15:35:19878
879#if defined(OS_ANDROID)
[email protected]b6eb8e332013-09-10 00:51:01880 if (SynchronousCompositorFactory* factory =
881 SynchronousCompositorFactory::GetInstance()) {
[email protected]913d99a2013-05-31 07:16:07882 return factory->CreateOutputSurface(routing_id());
[email protected]a1811b8912013-05-09 15:35:19883 }
884#endif
885
[email protected]ed7defa2013-03-12 21:29:59886 // Explicitly disable antialiasing for the compositor. As of the time of
887 // this writing, the only platform that supported antialiasing for the
888 // compositor was Mac OS X, because the on-screen OpenGL context creation
889 // code paths on Windows and Linux didn't yet have multisampling support.
890 // Mac OS X essentially always behaves as though it's rendering offscreen.
891 // Multisampling has a heavy cost especially on devices with relatively low
892 // fill rate like most notebooks, and the Mac implementation would need to
893 // be optimized to resolve directly into the IOSurface shared between the
894 // GPU and browser processes. For these reasons and to avoid platform
895 // disparities we explicitly disable antialiasing.
[email protected]180ef242013-11-07 06:50:46896 blink::WebGraphicsContext3D::Attributes attributes;
[email protected]ed7defa2013-03-12 21:29:59897 attributes.antialias = false;
898 attributes.shareResources = true;
899 attributes.noAutomaticFlushes = true;
[email protected]a6886502013-05-16 20:59:18900 attributes.depth = false;
901 attributes.stencil = false;
[email protected]b6eb8e332013-09-10 00:51:01902
903 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
[email protected]bec084292013-05-21 21:31:44904 if (command_line.HasSwitch(cc::switches::kForceDirectLayerDrawing))
905 attributes.stencil = true;
[email protected]b6eb8e332013-09-10 00:51:01906
[email protected]0634cdd42013-08-16 00:46:09907 scoped_refptr<ContextProviderCommandBuffer> context_provider;
908 if (!fallback) {
909 context_provider = ContextProviderCommandBuffer::Create(
[email protected]af13d832013-09-13 06:56:27910 CreateGraphicsContext3D(attributes),
911 "RenderCompositor");
[email protected]0634cdd42013-08-16 00:46:09912 }
[email protected]ebc0e1df2013-08-01 02:46:22913
[email protected]b6eb8e332013-09-10 00:51:01914 uint32 output_surface_id = next_output_surface_id_++;
[email protected]0634cdd42013-08-16 00:46:09915 if (!context_provider.get()) {
[email protected]ebc0e1df2013-08-01 02:46:22916 if (!command_line.HasSwitch(switches::kEnableSoftwareCompositing))
917 return scoped_ptr<cc::OutputSurface>();
[email protected]0634cdd42013-08-16 00:46:09918
919 scoped_ptr<cc::SoftwareOutputDevice> software_device(
920 new CompositorSoftwareOutputDevice());
921
922 return scoped_ptr<cc::OutputSurface>(new CompositorOutputSurface(
923 routing_id(),
924 output_surface_id,
925 NULL,
926 software_device.Pass(),
927 true));
[email protected]ebc0e1df2013-08-01 02:46:22928 }
[email protected]ed7defa2013-03-12 21:29:59929
[email protected]0c04d1c2013-07-10 00:02:32930 if (command_line.HasSwitch(switches::kEnableDelegatedRenderer) &&
931 !command_line.HasSwitch(switches::kDisableDelegatedRenderer)) {
[email protected]36e5ff12013-06-11 12:19:29932 DCHECK(is_threaded_compositing_enabled_);
933 return scoped_ptr<cc::OutputSurface>(
[email protected]0634cdd42013-08-16 00:46:09934 new DelegatedCompositorOutputSurface(
935 routing_id(),
936 output_surface_id,
937 context_provider,
938 scoped_ptr<cc::SoftwareOutputDevice>()));
[email protected]36e5ff12013-06-11 12:19:29939 }
940 if (command_line.HasSwitch(cc::switches::kCompositeToMailbox)) {
941 DCHECK(is_threaded_compositing_enabled_);
[email protected]186f09602013-09-24 07:13:16942 cc::ResourceFormat format = cc::RGBA_8888;
943#if defined(OS_ANDROID)
944 if (base::android::SysUtils::IsLowEndDevice())
945 format = cc::RGB_565;
946#endif
[email protected]36e5ff12013-06-11 12:19:29947 return scoped_ptr<cc::OutputSurface>(
[email protected]0634cdd42013-08-16 00:46:09948 new MailboxOutputSurface(
949 routing_id(),
950 output_surface_id,
951 context_provider,
[email protected]186f09602013-09-24 07:13:16952 scoped_ptr<cc::SoftwareOutputDevice>(),
953 format));
[email protected]36e5ff12013-06-11 12:19:29954 }
[email protected]0634cdd42013-08-16 00:46:09955 bool use_swap_compositor_frame_message = false;
[email protected]36e5ff12013-06-11 12:19:29956 return scoped_ptr<cc::OutputSurface>(
[email protected]0634cdd42013-08-16 00:46:09957 new CompositorOutputSurface(
958 routing_id(),
959 output_surface_id,
960 context_provider,
961 scoped_ptr<cc::SoftwareOutputDevice>(),
962 use_swap_compositor_frame_message));
[email protected]ba91a792013-02-06 09:48:28963}
964
[email protected]4d7e46a2013-11-08 05:33:40965void RenderWidget::OnSwapBuffersAborted() {
[email protected]65225772011-05-12 21:10:24966 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
[email protected]aa4117f2011-12-09 22:19:21967 while (!updates_pending_swap_.empty()) {
968 ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
969 updates_pending_swap_.pop_front();
970 // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
971 // compositing pass, hence doesn't require an UpdateRect message.
972 if (msg)
973 Send(msg);
974 }
[email protected]65225772011-05-12 21:10:24975 num_swapbuffers_complete_pending_ = 0;
976 using_asynchronous_swapbuffers_ = false;
977 // Schedule another frame so the compositor learns about it.
978 scheduleComposite();
979}
980
[email protected]4d7e46a2013-11-08 05:33:40981void RenderWidget::OnSwapBuffersPosted() {
[email protected]37a6f302011-07-11 23:43:08982 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
[email protected]aa4117f2011-12-09 22:19:21983
984 if (using_asynchronous_swapbuffers_) {
985 ViewHostMsg_UpdateRect* msg = NULL;
986 // pending_update_params_ can be NULL if the swap doesn't correspond to an
987 // DoDeferredUpdate compositing pass, hence doesn't require an UpdateRect
988 // message.
[email protected]59383c782013-04-17 16:43:27989 if (pending_update_params_) {
[email protected]aa4117f2011-12-09 22:19:21990 msg = new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_);
991 pending_update_params_.reset();
992 }
993 updates_pending_swap_.push_back(msg);
[email protected]37a6f302011-07-11 23:43:08994 num_swapbuffers_complete_pending_++;
[email protected]aa4117f2011-12-09 22:19:21995 }
[email protected]37a6f302011-07-11 23:43:08996}
997
[email protected]4d7e46a2013-11-08 05:33:40998void RenderWidget::OnSwapBuffersComplete() {
[email protected]65225772011-05-12 21:10:24999 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersComplete");
[email protected]29ed96a2012-02-04 18:12:161000
[email protected]404939f2012-06-01 04:06:181001 // Notify subclasses that composited rendering was flushed to the screen.
[email protected]29ed96a2012-02-04 18:12:161002 DidFlushPaint();
1003
[email protected]65225772011-05-12 21:10:241004 // When compositing deactivates, we reset the swapbuffers pending count. The
1005 // swapbuffers acks may still arrive, however.
1006 if (num_swapbuffers_complete_pending_ == 0) {
1007 TRACE_EVENT0("renderer", "EarlyOut_ZeroSwapbuffersPending");
1008 return;
1009 }
[email protected]aa4117f2011-12-09 22:19:211010 DCHECK(!updates_pending_swap_.empty());
1011 ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
1012 updates_pending_swap_.pop_front();
1013 // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
1014 // compositing pass, hence doesn't require an UpdateRect message.
1015 if (msg)
1016 Send(msg);
[email protected]65225772011-05-12 21:10:241017 num_swapbuffers_complete_pending_--;
1018
1019 // If update reply is still pending, then defer the update until that reply
1020 // occurs.
[email protected]d0be63772011-12-20 23:18:041021 if (update_reply_pending_) {
[email protected]65225772011-05-12 21:10:241022 TRACE_EVENT0("renderer", "EarlyOut_UpdateReplyPending");
1023 return;
1024 }
1025
1026 // If we are not accelerated rendering, then this is a stale swapbuffers from
[email protected]50312bf2011-06-22 23:30:061027 // when we were previously rendering. However, if an invalidation task is not
1028 // posted, there may be software rendering work pending. In that case, don't
1029 // early out.
1030 if (!is_accelerated_compositing_active_ && invalidation_task_posted_) {
[email protected]65225772011-05-12 21:10:241031 TRACE_EVENT0("renderer", "EarlyOut_AcceleratedCompositingOff");
1032 return;
1033 }
1034
[email protected]cc66e682012-10-02 06:48:181035 // Do not call DoDeferredUpdate unless there's animation work to be done or
1036 // a real invalidation. This prevents rendering in response to a swapbuffers
1037 // callback coming back after we've navigated away from the page that
1038 // generated it.
1039 if (!animation_update_pending_ && !paint_aggregator_.HasPendingUpdate()) {
1040 TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
1041 return;
1042 }
1043
[email protected]65225772011-05-12 21:10:241044 // Continue painting if necessary...
1045 DoDeferredUpdateAndSendInputAck();
initial.commit09911bf2008-07-26 23:55:291046}
1047
[email protected]180ef242013-11-07 06:50:461048void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event,
[email protected]4b157662013-05-29 04:05:051049 const ui::LatencyInfo& latency_info,
[email protected]0dea1652012-12-14 00:09:091050 bool is_keyboard_shortcut) {
[email protected]5dd768212009-08-13 23:34:491051 handling_input_event_ = true;
[email protected]0dea1652012-12-14 00:09:091052 if (!input_event) {
[email protected]5dd768212009-08-13 23:34:491053 handling_input_event_ = false;
initial.commit09911bf2008-07-26 23:55:291054 return;
[email protected]5dd768212009-08-13 23:34:491055 }
initial.commit09911bf2008-07-26 23:55:291056
[email protected]fd847792013-10-24 17:12:351057 base::TimeTicks start_time;
1058 if (base::TimeTicks::IsHighResNowFastAndReliable())
1059 start_time = base::TimeTicks::HighResNow();
1060
[email protected]8e299aa2013-10-16 18:17:441061 const char* const event_name =
1062 WebInputEventTraits::GetName(input_event->type);
[email protected]b4841e1c2013-05-16 22:30:101063 TRACE_EVENT1("renderer", "RenderWidget::OnHandleInputEvent",
1064 "event", event_name);
1065
[email protected]c2eaa8f2013-05-10 02:41:551066 if (compositor_)
1067 compositor_->SetLatencyInfo(latency_info);
[email protected]256737c2013-06-08 04:39:101068 else
1069 latency_info_.MergeWith(latency_info);
[email protected]c2eaa8f2013-05-10 02:41:551070
[email protected]6a4d7f62013-01-07 21:32:131071 base::TimeDelta now = base::TimeDelta::FromInternalValue(
1072 base::TimeTicks::Now().ToInternalValue());
1073
1074 int64 delta = static_cast<int64>(
1075 (now.InSecondsF() - input_event->timeStampSeconds) *
1076 base::Time::kMicrosecondsPerSecond);
1077 UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.Renderer", delta, 0, 1000000, 100);
[email protected]de415552013-01-23 04:12:171078 base::HistogramBase* counter_for_type =
[email protected]bafdc5d52013-02-27 18:18:481079 base::Histogram::FactoryGet(
[email protected]b4841e1c2013-05-16 22:30:101080 base::StringPrintf("Event.Latency.Renderer.%s", event_name),
[email protected]bafdc5d52013-02-27 18:18:481081 0,
1082 1000000,
[email protected]6a4d7f62013-01-07 21:32:131083 100,
[email protected]de415552013-01-23 04:12:171084 base::HistogramBase::kUmaTargetedHistogramFlag);
[email protected]bafdc5d52013-02-27 18:18:481085 counter_for_type->Add(delta);
[email protected]6a4d7f62013-01-07 21:32:131086
[email protected]67bfb83f2011-09-22 03:36:371087 bool prevent_default = false;
1088 if (WebInputEvent::isMouseEventType(input_event->type)) {
[email protected]936c6f52011-12-13 01:35:261089 const WebMouseEvent& mouse_event =
1090 *static_cast<const WebMouseEvent*>(input_event);
1091 TRACE_EVENT2("renderer", "HandleMouseMove",
1092 "x", mouse_event.x, "y", mouse_event.y);
1093 prevent_default = WillHandleMouseEvent(mouse_event);
[email protected]67bfb83f2011-09-22 03:36:371094 }
1095
[email protected]f56c7872013-06-18 12:31:571096 if (WebInputEvent::isKeyboardEventType(input_event->type)) {
1097 const WebKeyboardEvent& key_event =
1098 *static_cast<const WebKeyboardEvent*>(input_event);
1099 prevent_default = WillHandleKeyEvent(key_event);
1100 }
1101
[email protected]41d86852012-11-07 12:23:241102 if (WebInputEvent::isGestureEventType(input_event->type)) {
1103 const WebGestureEvent& gesture_event =
1104 *static_cast<const WebGestureEvent*>(input_event);
1105 prevent_default = prevent_default || WillHandleGestureEvent(gesture_event);
1106 }
1107
[email protected]3ebcc7c2013-01-09 05:34:461108 if (input_event->type == WebInputEvent::GestureTap ||
1109 input_event->type == WebInputEvent::GestureLongPress)
1110 resetInputMethod();
1111
[email protected]67bfb83f2011-09-22 03:36:371112 bool processed = prevent_default;
[email protected]b68a0e52011-12-08 15:11:121113 if (input_event->type != WebInputEvent::Char || !suppress_next_char_events_) {
1114 suppress_next_char_events_ = false;
1115 if (!processed && webwidget_)
1116 processed = webwidget_->handleInputEvent(*input_event);
1117 }
1118
1119 // If this RawKeyDown event corresponds to a browser keyboard shortcut and
1120 // it's not processed by webkit, then we need to suppress the upcoming Char
1121 // events.
1122 if (!processed && is_keyboard_shortcut)
1123 suppress_next_char_events_ = true;
initial.commit09911bf2008-07-26 23:55:291124
[email protected]3d5c243b2012-11-30 00:26:011125 InputEventAckState ack_result = processed ?
1126 INPUT_EVENT_ACK_STATE_CONSUMED : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1127 if (!processed && input_event->type == WebInputEvent::TouchStart) {
1128 const WebTouchEvent& touch_event =
1129 *static_cast<const WebTouchEvent*>(input_event);
1130 ack_result = HasTouchEventHandlersAt(touch_event.touches[0].position) ?
1131 INPUT_EVENT_ACK_STATE_NOT_CONSUMED :
1132 INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
1133 }
1134
[email protected]a9fb30aa2011-10-06 06:58:461135 IPC::Message* response =
[email protected]f6df0edf2013-08-07 00:27:021136 new InputHostMsg_HandleInputEvent_ACK(routing_id_,
1137 input_event->type,
1138 ack_result,
1139 latency_info);
[email protected]fd847792013-10-24 17:12:351140 bool event_type_can_be_rate_limited =
[email protected]3391a0772012-03-28 00:32:071141 input_event->type == WebInputEvent::MouseMove ||
1142 input_event->type == WebInputEvent::MouseWheel ||
[email protected]3475bb52013-10-03 08:25:161143 input_event->type == WebInputEvent::TouchMove;
[email protected]8926c602013-01-23 05:32:061144
1145 bool frame_pending = paint_aggregator_.HasPendingUpdate();
1146 if (is_accelerated_compositing_active_) {
[email protected]ba91a792013-02-06 09:48:281147 frame_pending = compositor_ &&
[email protected]971728d2013-10-26 10:39:311148 compositor_->BeginMainFrameRequested();
[email protected]8926c602013-01-23 05:32:061149 }
1150
[email protected]fd847792013-10-24 17:12:351151 // If we don't have a fast and accurate HighResNow, we assume the input
1152 // handlers are heavy and rate limit them.
1153 bool rate_limiting_wanted = true;
1154 if (base::TimeTicks::IsHighResNowFastAndReliable()) {
1155 base::TimeTicks end_time = base::TimeTicks::HighResNow();
1156 total_input_handling_time_this_frame_ += (end_time - start_time);
1157 rate_limiting_wanted =
1158 total_input_handling_time_this_frame_.InMicroseconds() >
1159 kInputHandlingTimeThrottlingThresholdMicroseconds;
1160 }
1161
1162 if (rate_limiting_wanted && event_type_can_be_rate_limited &&
1163 frame_pending && !is_hidden_) {
[email protected]12fbad812009-09-01 18:21:241164 // We want to rate limit the input events in this case, so we'll wait for
1165 // painting to finish before ACKing this message.
[email protected]fd847792013-10-24 17:12:351166 TRACE_EVENT_INSTANT0("renderer",
1167 "RenderWidget::OnHandleInputEvent ack throttled",
1168 TRACE_EVENT_SCOPE_THREAD);
[email protected]59383c782013-04-17 16:43:271169 if (pending_input_event_ack_) {
[email protected]353a34c2010-05-28 23:35:171170 // As two different kinds of events could cause us to postpone an ack
1171 // we send it now, if we have one pending. The Browser should never
1172 // send us the same kind of event we are delaying the ack for.
1173 Send(pending_input_event_ack_.release());
1174 }
[email protected]12fbad812009-09-01 18:21:241175 pending_input_event_ack_.reset(response);
[email protected]df09e052013-07-31 18:59:501176 if (compositor_)
1177 compositor_->NotifyInputThrottledUntilCommit();
[email protected]12fbad812009-09-01 18:21:241178 } else {
1179 Send(response);
1180 }
1181
[email protected]3306f262012-09-21 19:20:421182#if defined(OS_ANDROID)
1183 // Allow the IME to be shown when the focus changes as a consequence
1184 // of a processed touch end event.
1185 if (input_event->type == WebInputEvent::TouchEnd && processed)
[email protected]0d1ebed12013-08-05 22:01:131186 UpdateTextInputState(true, true);
[email protected]3306f262012-09-21 19:20:421187#endif
1188
[email protected]5dd768212009-08-13 23:34:491189 handling_input_event_ = false;
[email protected]446705872009-09-10 07:22:481190
[email protected]67bfb83f2011-09-22 03:36:371191 if (!prevent_default) {
1192 if (WebInputEvent::isKeyboardEventType(input_event->type))
1193 DidHandleKeyEvent();
1194 if (WebInputEvent::isMouseEventType(input_event->type))
1195 DidHandleMouseEvent(*(static_cast<const WebMouseEvent*>(input_event)));
[email protected]2d0f2e92011-10-03 09:02:241196 if (WebInputEvent::isTouchEventType(input_event->type))
1197 DidHandleTouchEvent(*(static_cast<const WebTouchEvent*>(input_event)));
[email protected]67bfb83f2011-09-22 03:36:371198 }
initial.commit09911bf2008-07-26 23:55:291199}
1200
[email protected]34202de2013-05-06 23:36:221201void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
1202 if (webwidget_)
1203 webwidget_->setCursorVisibilityState(is_visible);
1204}
1205
initial.commit09911bf2008-07-26 23:55:291206void RenderWidget::OnMouseCaptureLost() {
1207 if (webwidget_)
[email protected]4873c7d2009-07-16 06:36:281208 webwidget_->mouseCaptureLost();
initial.commit09911bf2008-07-26 23:55:291209}
1210
1211void RenderWidget::OnSetFocus(bool enable) {
1212 has_focus_ = enable;
[email protected]9d166af2010-03-02 22:04:331213 if (webwidget_)
1214 webwidget_->setFocus(enable);
initial.commit09911bf2008-07-26 23:55:291215}
1216
1217void RenderWidget::ClearFocus() {
1218 // We may have got the focus from the browser before this gets processed, in
1219 // which case we do not want to unfocus ourself.
1220 if (!has_focus_ && webwidget_)
[email protected]4873c7d2009-07-16 06:36:281221 webwidget_->setFocus(false);
initial.commit09911bf2008-07-26 23:55:291222}
1223
[email protected]2d5d09d52009-06-15 14:29:211224void RenderWidget::PaintRect(const gfx::Rect& rect,
[email protected]4fb66842009-12-04 21:41:001225 const gfx::Point& canvas_origin,
[email protected]2d5d09d52009-06-15 14:29:211226 skia::PlatformCanvas* canvas) {
[email protected]50312bf2011-06-22 23:30:061227 TRACE_EVENT2("renderer", "PaintRect",
1228 "width", rect.width(), "height", rect.height());
[email protected]63ab54262012-11-09 15:58:451229
[email protected]4fb66842009-12-04 21:41:001230 canvas->save();
[email protected]2d5d09d52009-06-15 14:29:211231
1232 // Bring the canvas into the coordinate system of the paint rect.
[email protected]4fb66842009-12-04 21:41:001233 canvas->translate(static_cast<SkScalar>(-canvas_origin.x()),
1234 static_cast<SkScalar>(-canvas_origin.y()));
[email protected]96c3499a2009-05-02 18:31:031235
[email protected]699ab0d2009-04-23 23:19:141236 // If there is a custom background, tile it.
1237 if (!background_.empty()) {
[email protected]699ab0d2009-04-23 23:19:141238 SkPaint paint;
[email protected]4e29afd2012-12-04 04:07:111239 skia::RefPtr<SkShader> shader = skia::AdoptRef(
1240 SkShader::CreateBitmapShader(background_,
1241 SkShader::kRepeat_TileMode,
1242 SkShader::kRepeat_TileMode));
1243 paint.setShader(shader.get());
[email protected]fb10ec5b2011-10-24 17:54:201244
1245 // Use kSrc_Mode to handle background_ transparency properly.
1246 paint.setXfermodeMode(SkXfermode::kSrc_Mode);
1247
1248 // Canvas could contain multiple update rects. Clip to given rect so that
1249 // we don't accidentally clear other update rects.
1250 canvas->save();
[email protected]aa7e7a12013-02-22 13:37:441251 canvas->scale(device_scale_factor_, device_scale_factor_);
[email protected]1835b9e2012-02-28 13:12:481252 canvas->clipRect(gfx::RectToSkRect(rect));
[email protected]699ab0d2009-04-23 23:19:141253 canvas->drawPaint(paint);
[email protected]fb10ec5b2011-10-24 17:54:201254 canvas->restore();
[email protected]699ab0d2009-04-23 23:19:141255 }
1256
[email protected]719b36f2010-12-22 20:36:461257 // First see if this rect is a plugin that can paint itself faster.
1258 TransportDIB* optimized_dib = NULL;
1259 gfx::Rect optimized_copy_rect, optimized_copy_location;
[email protected]0f3a2d12012-09-01 03:37:201260 float dib_scale_factor;
[email protected]adab2332013-07-25 18:04:321261 PepperPluginInstanceImpl* optimized_instance =
[email protected]719b36f2010-12-22 20:36:461262 GetBitmapForOptimizedPluginPaint(rect, &optimized_dib,
1263 &optimized_copy_location,
[email protected]0f3a2d12012-09-01 03:37:201264 &optimized_copy_rect,
1265 &dib_scale_factor);
[email protected]719b36f2010-12-22 20:36:461266 if (optimized_instance) {
[email protected]20790a222013-07-25 02:23:051267#if defined(ENABLE_PLUGINS)
[email protected]719b36f2010-12-22 20:36:461268 // This plugin can be optimize-painted and we can just ask it to paint
1269 // itself. We don't actually need the TransportDIB in this case.
1270 //
1271 // This is an optimization for PPAPI plugins that know they're on top of
1272 // the page content. If this rect is inside such a plugin, we can save some
1273 // time and avoid re-rendering the page content which we know will be
1274 // covered by the plugin later (this time can be significant, especially
1275 // for a playing movie that is invalidating a lot).
1276 //
1277 // In the plugin movie case, hopefully the similar call to
1278 // GetBitmapForOptimizedPluginPaint in DoDeferredUpdate handles the
1279 // painting, because that avoids copying the plugin image to a different
1280 // paint rect. Unfortunately, if anything on the page is animating other
1281 // than the movie, it break this optimization since the union of the
1282 // invalid regions will be larger than the plugin.
1283 //
1284 // This code optimizes that case, where we can still avoid painting in
1285 // WebKit and filling the background (which can be slow) and just painting
1286 // the plugin. Unlike the DoDeferredUpdate case, an extra copy is still
1287 // required.
[email protected]df59dd42012-09-14 22:56:301288 SkAutoCanvasRestore auto_restore(canvas, true);
1289 canvas->scale(device_scale_factor_, device_scale_factor_);
[email protected]6bd867b2013-07-24 22:10:201290 optimized_instance->Paint(canvas, optimized_copy_location, rect);
[email protected]ea43e752012-09-06 22:39:211291 canvas->restore();
[email protected]20790a222013-07-25 02:23:051292#endif
[email protected]719b36f2010-12-22 20:36:461293 } else {
1294 // Normal painting case.
[email protected]c1e6cc062013-08-24 03:35:351295 base::TimeTicks start_time;
1296 if (!is_accelerated_compositing_active_)
1297 start_time = legacy_software_mode_stats_->StartRecording();
[email protected]63ab54262012-11-09 15:58:451298
[email protected]6bd867b2013-07-24 22:10:201299 webwidget_->paint(canvas, rect);
[email protected]63ab54262012-11-09 15:58:451300
[email protected]c1e6cc062013-08-24 03:35:351301 if (!is_accelerated_compositing_active_) {
[email protected]63ab54262012-11-09 15:58:451302 base::TimeDelta paint_time =
[email protected]c1e6cc062013-08-24 03:35:351303 legacy_software_mode_stats_->EndRecording(start_time);
1304 int64 painted_pixel_count = rect.width() * rect.height();
1305 legacy_software_mode_stats_->AddPaint(paint_time, painted_pixel_count);
[email protected]63ab54262012-11-09 15:58:451306 }
[email protected]719b36f2010-12-22 20:36:461307
1308 // Flush to underlying bitmap. TODO(darin): is this needed?
[email protected]62f2e802011-05-26 14:28:351309 skia::GetTopDevice(*canvas)->accessBitmap(false);
[email protected]719b36f2010-12-22 20:36:461310 }
initial.commit09911bf2008-07-26 23:55:291311
[email protected]4fb66842009-12-04 21:41:001312 PaintDebugBorder(rect, canvas);
[email protected]4fb66842009-12-04 21:41:001313 canvas->restore();
1314}
1315
1316void RenderWidget::PaintDebugBorder(const gfx::Rect& rect,
1317 skia::PlatformCanvas* canvas) {
1318 static bool kPaintBorder =
1319 CommandLine::ForCurrentProcess()->HasSwitch(switches::kShowPaintRects);
1320 if (!kPaintBorder)
1321 return;
1322
[email protected]53d3f302009-12-21 04:42:051323 // Cycle through these colors to help distinguish new paint rects.
1324 const SkColor colors[] = {
1325 SkColorSetARGB(0x3F, 0xFF, 0, 0),
1326 SkColorSetARGB(0x3F, 0xFF, 0, 0xFF),
1327 SkColorSetARGB(0x3F, 0, 0, 0xFF),
1328 };
1329 static int color_selector = 0;
1330
[email protected]4fb66842009-12-04 21:41:001331 SkPaint paint;
1332 paint.setStyle(SkPaint::kStroke_Style);
[email protected]53d3f302009-12-21 04:42:051333 paint.setColor(colors[color_selector++ % arraysize(colors)]);
[email protected]4fb66842009-12-04 21:41:001334 paint.setStrokeWidth(1);
1335
1336 SkIRect irect;
1337 irect.set(rect.x(), rect.y(), rect.right() - 1, rect.bottom() - 1);
1338 canvas->drawIRect(irect, paint);
initial.commit09911bf2008-07-26 23:55:291339}
1340
[email protected]52ccd0ea2011-02-16 01:09:051341void RenderWidget::AnimationCallback() {
[email protected]921244e42011-07-20 16:36:301342 TRACE_EVENT0("renderer", "RenderWidget::AnimationCallback");
[email protected]921244e42011-07-20 16:36:301343 if (!animation_update_pending_) {
1344 TRACE_EVENT0("renderer", "EarlyOut_NoAnimationUpdatePending");
[email protected]7c4329e2011-02-18 22:02:591345 return;
[email protected]921244e42011-07-20 16:36:301346 }
[email protected]bd37ae252011-06-03 01:28:181347 if (!animation_floor_time_.is_null() && IsRenderingVSynced()) {
[email protected]7c4329e2011-02-18 22:02:591348 // Record when we fired (according to base::Time::Now()) relative to when
1349 // we posted the task to quantify how much the base::Time/base::TimeTicks
1350 // skew is affecting animations.
1351 base::TimeDelta animation_callback_delay = base::Time::Now() -
1352 (animation_floor_time_ - base::TimeDelta::FromMilliseconds(16));
1353 UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.AnimationCallbackDelayTime",
1354 animation_callback_delay,
1355 base::TimeDelta::FromMilliseconds(0),
1356 base::TimeDelta::FromMilliseconds(30),
1357 25);
1358 }
[email protected]65225772011-05-12 21:10:241359 DoDeferredUpdateAndSendInputAck();
[email protected]12fbad812009-09-01 18:21:241360}
1361
[email protected]52ccd0ea2011-02-16 01:09:051362void RenderWidget::AnimateIfNeeded() {
[email protected]7c4329e2011-02-18 22:02:591363 if (!animation_update_pending_)
1364 return;
[email protected]bd37ae252011-06-03 01:28:181365
1366 // Target 60FPS if vsync is on. Go as fast as we can if vsync is off.
[email protected]02798a982012-01-27 00:45:331367 base::TimeDelta animationInterval = IsRenderingVSynced() ?
1368 base::TimeDelta::FromMilliseconds(16) : base::TimeDelta();
[email protected]bd37ae252011-06-03 01:28:181369
[email protected]7c4329e2011-02-18 22:02:591370 base::Time now = base::Time::Now();
[email protected]51e403bb2012-03-02 21:09:451371
1372 // animation_floor_time_ is the earliest time that we should animate when
1373 // using the dead reckoning software scheduler. If we're using swapbuffers
1374 // complete callbacks to rate limit, we can ignore this floor.
1375 if (now >= animation_floor_time_ || num_swapbuffers_complete_pending_ > 0) {
[email protected]921244e42011-07-20 16:36:301376 TRACE_EVENT0("renderer", "RenderWidget::AnimateIfNeeded")
[email protected]02798a982012-01-27 00:45:331377 animation_floor_time_ = now + animationInterval;
[email protected]bd37ae252011-06-03 01:28:181378 // Set a timer to call us back after animationInterval before
[email protected]7c4329e2011-02-18 22:02:591379 // running animation callbacks so that if a callback requests another
1380 // we'll be sure to run it at the proper time.
[email protected]350ce8702012-03-09 04:23:381381 animation_timer_.Stop();
1382 animation_timer_.Start(FROM_HERE, animationInterval, this,
1383 &RenderWidget::AnimationCallback);
[email protected]7c4329e2011-02-18 22:02:591384 animation_update_pending_ = false;
[email protected]ba91a792013-02-06 09:48:281385 if (is_accelerated_compositing_active_ && compositor_) {
[email protected]635353c2013-03-06 09:11:201386 compositor_->Animate(base::TimeTicks::Now());
[email protected]8926c602013-01-23 05:32:061387 } else {
[email protected]635353c2013-03-06 09:11:201388 double frame_begin_time =
1389 (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
1390 webwidget_->animate(frame_begin_time);
[email protected]8926c602013-01-23 05:32:061391 }
[email protected]7c4329e2011-02-18 22:02:591392 return;
[email protected]5f8b1022011-01-21 23:34:501393 }
[email protected]bd37ae252011-06-03 01:28:181394 TRACE_EVENT0("renderer", "EarlyOut_AnimatedTooRecently");
[email protected]350ce8702012-03-09 04:23:381395 if (!animation_timer_.IsRunning()) {
1396 // This code uses base::Time::Now() to calculate the floor and next fire
1397 // time because javascript's Date object uses base::Time::Now(). The
1398 // message loop uses base::TimeTicks, which on windows can have a
1399 // different granularity than base::Time.
1400 // The upshot of all this is that this function might be called before
1401 // base::Time::Now() has advanced past the animation_floor_time_. To
1402 // avoid exposing this delay to javascript, we keep posting delayed
1403 // tasks until base::Time::Now() has advanced far enough.
1404 base::TimeDelta delay = animation_floor_time_ - now;
1405 animation_timer_.Start(FROM_HERE, delay, this,
1406 &RenderWidget::AnimationCallback);
1407 }
[email protected]5f8b1022011-01-21 23:34:501408}
1409
[email protected]bd37ae252011-06-03 01:28:181410bool RenderWidget::IsRenderingVSynced() {
1411 // TODO(nduca): Forcing a driver to disable vsync (e.g. in a control panel) is
1412 // not caught by this check. This will lead to artificially low frame rates
1413 // for people who force vsync off at a driver level and expect Chrome to speed
1414 // up.
1415 return !has_disable_gpu_vsync_switch_;
1416}
1417
[email protected]65225772011-05-12 21:10:241418void RenderWidget::InvalidationCallback() {
[email protected]50312bf2011-06-22 23:30:061419 TRACE_EVENT0("renderer", "RenderWidget::InvalidationCallback");
[email protected]65225772011-05-12 21:10:241420 invalidation_task_posted_ = false;
1421 DoDeferredUpdateAndSendInputAck();
1422}
1423
[email protected]fd847792013-10-24 17:12:351424void RenderWidget::FlushPendingInputEventAck() {
[email protected]d8a8ecb2013-10-23 18:03:071425 if (pending_input_event_ack_)
1426 Send(pending_input_event_ack_.release());
[email protected]fd847792013-10-24 17:12:351427 total_input_handling_time_this_frame_ = base::TimeDelta();
1428}
1429
1430void RenderWidget::DoDeferredUpdateAndSendInputAck() {
1431 DoDeferredUpdate();
1432 FlushPendingInputEventAck();
[email protected]ee3d3ad2011-02-04 00:42:211433}
1434
[email protected]552e6002009-11-19 05:24:571435void RenderWidget::DoDeferredUpdate() {
[email protected]366ae242011-05-10 02:23:581436 TRACE_EVENT0("renderer", "RenderWidget::DoDeferredUpdate");
[email protected]fc8bde1a2013-07-04 08:54:071437 TRACE_EVENT_SCOPED_SAMPLING_STATE("Chrome", "Paint");
[email protected]71e2f0a2011-03-15 22:25:081438
[email protected]65225772011-05-12 21:10:241439 if (!webwidget_)
initial.commit09911bf2008-07-26 23:55:291440 return;
[email protected]05a980d7a2012-02-07 22:16:421441
[email protected]fc4404d2012-11-07 19:53:301442 if (!init_complete_) {
1443 TRACE_EVENT0("renderer", "EarlyOut_InitNotComplete");
[email protected]05a980d7a2012-02-07 22:16:421444 return;
1445 }
[email protected]aa4117f2011-12-09 22:19:211446 if (update_reply_pending_) {
[email protected]65225772011-05-12 21:10:241447 TRACE_EVENT0("renderer", "EarlyOut_UpdateReplyPending");
1448 return;
1449 }
[email protected]9ca84622011-06-02 23:46:391450 if (is_accelerated_compositing_active_ &&
1451 num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending) {
[email protected]65225772011-05-12 21:10:241452 TRACE_EVENT0("renderer", "EarlyOut_MaxSwapBuffersPending");
1453 return;
1454 }
initial.commit09911bf2008-07-26 23:55:291455
[email protected]552e6002009-11-19 05:24:571456 // Suppress updating when we are hidden.
[email protected]e3d92a7f2013-01-10 02:35:051457 if (is_hidden_ || size_.IsEmpty() || is_swapped_out_) {
[email protected]552e6002009-11-19 05:24:571458 paint_aggregator_.ClearPendingUpdate();
initial.commit09911bf2008-07-26 23:55:291459 needs_repainting_on_restore_ = true;
[email protected]65225772011-05-12 21:10:241460 TRACE_EVENT0("renderer", "EarlyOut_NotVisible");
initial.commit09911bf2008-07-26 23:55:291461 return;
1462 }
1463
[email protected]0fb93f52011-05-18 23:13:561464 // Tracking of frame rate jitter
[email protected]de2cf8c2013-10-25 19:46:461465 base::TimeTicks frame_begin_ticks = gfx::FrameTime::Now();
[email protected]38ce4e7b2013-02-23 06:17:371466 InstrumentWillBeginFrame();
[email protected]52ccd0ea2011-02-16 01:09:051467 AnimateIfNeeded();
[email protected]5f8b1022011-01-21 23:34:501468
[email protected]f98d7e3c2010-09-13 22:30:461469 // Layout may generate more invalidation. It may also enable the
1470 // GPU acceleration, so make sure to run layout before we send the
1471 // GpuRenderingActivated message.
1472 webwidget_->layout();
1473
[email protected]793b2d62013-06-11 00:43:251474 // Check for whether we need to track swap buffers. We need to do that after
1475 // layout() because it may have switched us to accelerated compositing.
1476 if (is_accelerated_compositing_active_)
1477 using_asynchronous_swapbuffers_ = SupportsAsynchronousSwapBuffers();
1478
[email protected]dcca3aa92012-02-17 23:03:371479 // The following two can result in further layout and possibly
1480 // enable GPU acceleration so they need to be called before any painting
1481 // is done.
[email protected]cb9e2632013-06-18 11:26:471482 UpdateTextInputType();
[email protected]dcca3aa92012-02-17 23:03:371483 UpdateSelectionBounds();
1484
[email protected]5f8b1022011-01-21 23:34:501485 // Suppress painting if nothing is dirty. This has to be done after updating
1486 // animations running layout as these may generate further invalidations.
[email protected]65225772011-05-12 21:10:241487 if (!paint_aggregator_.HasPendingUpdate()) {
1488 TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
[email protected]38ce4e7b2013-02-23 06:17:371489 InstrumentDidCancelFrame();
[email protected]5f8b1022011-01-21 23:34:501490 return;
[email protected]65225772011-05-12 21:10:241491 }
[email protected]5f8b1022011-01-21 23:34:501492
[email protected]479b0172012-10-29 19:27:091493 if (!is_accelerated_compositing_active_ &&
[email protected]cb6430932012-10-31 00:53:361494 !is_threaded_compositing_enabled_ &&
[email protected]d8a6c5d12013-09-23 04:37:101495 (ForceCompositingModeEnabled() ||
1496 was_accelerated_compositing_ever_active_)) {
[email protected]479b0172012-10-29 19:27:091497 webwidget_->enterForceCompositingMode(true);
1498 }
1499
[email protected]872ae5b2011-05-26 20:20:501500 if (!last_do_deferred_update_time_.is_null()) {
[email protected]0fb93f52011-05-18 23:13:561501 base::TimeDelta delay = frame_begin_ticks - last_do_deferred_update_time_;
[email protected]d0be63772011-12-20 23:18:041502 if (is_accelerated_compositing_active_) {
[email protected]0fb93f52011-05-18 23:13:561503 UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.AccelDoDeferredUpdateDelay",
1504 delay,
1505 base::TimeDelta::FromMilliseconds(1),
[email protected]b604cf82012-07-19 05:31:411506 base::TimeDelta::FromMilliseconds(120),
1507 60);
[email protected]d0be63772011-12-20 23:18:041508 } else {
[email protected]0fb93f52011-05-18 23:13:561509 UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.SoftwareDoDeferredUpdateDelay",
1510 delay,
1511 base::TimeDelta::FromMilliseconds(1),
[email protected]b604cf82012-07-19 05:31:411512 base::TimeDelta::FromMilliseconds(120),
1513 60);
[email protected]d0be63772011-12-20 23:18:041514 }
[email protected]872ae5b2011-05-26 20:20:501515
1516 // Calculate filtered time per frame:
1517 float frame_time_elapsed = static_cast<float>(delay.InSecondsF());
1518 filtered_time_per_frame_ =
1519 0.9f * filtered_time_per_frame_ + 0.1f * frame_time_elapsed;
[email protected]0fb93f52011-05-18 23:13:561520 }
1521 last_do_deferred_update_time_ = frame_begin_ticks;
1522
[email protected]fef5e3972012-08-07 03:59:471523 if (!is_accelerated_compositing_active_) {
[email protected]922c6e1f2013-10-09 04:04:091524 legacy_software_mode_stats_->IncrementFrameCount(1, true);
[email protected]adbe30f2013-10-11 21:12:331525 cc::BenchmarkInstrumentation::IssueMainThreadRenderingStatsEvent(
1526 legacy_software_mode_stats_->main_thread_rendering_stats());
[email protected]c1e6cc062013-08-24 03:35:351527 legacy_software_mode_stats_->AccumulateAndClearMainThreadStats();
[email protected]fef5e3972012-08-07 03:59:471528 }
1529
[email protected]552e6002009-11-19 05:24:571530 // OK, save the pending update to a local since painting may cause more
initial.commit09911bf2008-07-26 23:55:291531 // invalidation. Some WebCore rendering objects only layout when painted.
[email protected]dd015812010-12-06 23:39:301532 PaintAggregator::PendingUpdate update;
1533 paint_aggregator_.PopPendingUpdate(&update);
initial.commit09911bf2008-07-26 23:55:291534
[email protected]53d3f302009-12-21 04:42:051535 gfx::Rect scroll_damage = update.GetScrollDamage();
[email protected]ce112fe2012-10-29 22:52:181536 gfx::Rect bounds = gfx::UnionRects(update.GetPaintBounds(), scroll_damage);
initial.commit09911bf2008-07-26 23:55:291537
[email protected]ca4847f2010-09-24 05:39:151538 // A plugin may be able to do an optimized paint. First check this, in which
1539 // case we can skip all of the bitmap generation and regular paint code.
[email protected]719b36f2010-12-22 20:36:461540 // This optimization allows PPAPI plugins that declare themselves on top of
1541 // the page (like a traditional windowed plugin) to be able to animate (think
1542 // movie playing) without repeatedly re-painting the page underneath, or
1543 // copying the plugin backing store (since we can send the plugin's backing
1544 // store directly to the browser).
1545 //
1546 // This optimization only works when the entire invalid region is contained
1547 // within the plugin. There is a related optimization in PaintRect for the
1548 // case where there may be multiple invalid regions.
[email protected]ca4847f2010-09-24 05:39:151549 TransportDIB* dib = NULL;
[email protected]ca4847f2010-09-24 05:39:151550 gfx::Rect optimized_copy_rect, optimized_copy_location;
[email protected]0f3a2d12012-09-01 03:37:201551 float dib_scale_factor = 1;
[email protected]aa4117f2011-12-09 22:19:211552 DCHECK(!pending_update_params_.get());
1553 pending_update_params_.reset(new ViewHostMsg_UpdateRect_Params);
[email protected]990278ff2012-11-13 02:12:551554 pending_update_params_->scroll_delta = update.scroll_delta;
[email protected]aa4117f2011-12-09 22:19:211555 pending_update_params_->scroll_rect = update.scroll_rect;
1556 pending_update_params_->view_size = size_;
[email protected]aa4117f2011-12-09 22:19:211557 pending_update_params_->plugin_window_moves.swap(plugin_window_moves_);
1558 pending_update_params_->flags = next_paint_flags_;
1559 pending_update_params_->scroll_offset = GetScrollOffset();
1560 pending_update_params_->needs_ack = true;
[email protected]7ded9f12012-06-13 20:47:091561 pending_update_params_->scale_factor = device_scale_factor_;
[email protected]aa4117f2011-12-09 22:19:211562 next_paint_flags_ = 0;
[email protected]ea3ee0a2012-05-15 03:43:091563 need_update_rect_for_auto_resize_ = false;
[email protected]aa4117f2011-12-09 22:19:211564
[email protected]256737c2013-06-08 04:39:101565 if (!is_accelerated_compositing_active_)
1566 pending_update_params_->latency_info = latency_info_;
1567
1568 latency_info_.Clear();
1569
[email protected]ca4847f2010-09-24 05:39:151570 if (update.scroll_rect.IsEmpty() &&
[email protected]a79d8a632010-11-18 22:35:561571 !is_accelerated_compositing_active_ &&
[email protected]ca4847f2010-09-24 05:39:151572 GetBitmapForOptimizedPluginPaint(bounds, &dib, &optimized_copy_location,
[email protected]0f3a2d12012-09-01 03:37:201573 &optimized_copy_rect,
1574 &dib_scale_factor)) {
[email protected]2df1b362011-01-21 21:22:271575 // Only update the part of the plugin that actually changed.
[email protected]d4030502012-10-23 16:51:471576 optimized_copy_rect.Intersect(bounds);
[email protected]aa4117f2011-12-09 22:19:211577 pending_update_params_->bitmap = dib->id();
1578 pending_update_params_->bitmap_rect = optimized_copy_location;
1579 pending_update_params_->copy_rects.push_back(optimized_copy_rect);
[email protected]0f3a2d12012-09-01 03:37:201580 pending_update_params_->scale_factor = dib_scale_factor;
[email protected]a79d8a632010-11-18 22:35:561581 } else if (!is_accelerated_compositing_active_) {
[email protected]f98d7e3c2010-09-13 22:30:461582 // Compute a buffer for painting and cache it.
[email protected]4889bd212013-02-11 22:23:101583
1584 bool fractional_scale = device_scale_factor_ -
1585 static_cast<int>(device_scale_factor_) != 0;
1586 if (fractional_scale) {
1587 // Damage might not be DIP aligned. Inflate damage to compensate.
1588 bounds.Inset(-1, -1);
1589 bounds.Intersect(gfx::Rect(size_));
1590 }
1591
1592 gfx::Rect pixel_bounds = gfx::ToEnclosingRect(
[email protected]ce112fe2012-10-29 22:52:181593 gfx::ScaleRect(bounds, device_scale_factor_));
[email protected]4889bd212013-02-11 22:23:101594
[email protected]ca4847f2010-09-24 05:39:151595 scoped_ptr<skia::PlatformCanvas> canvas(
[email protected]b4d08452010-10-05 17:34:351596 RenderProcess::current()->GetDrawingCanvas(&current_paint_buf_,
[email protected]f1cccb32012-06-06 18:29:591597 pixel_bounds));
[email protected]59383c782013-04-17 16:43:271598 if (!canvas) {
[email protected]f98d7e3c2010-09-13 22:30:461599 NOTREACHED();
1600 return;
1601 }
[email protected]cef3362f2009-12-21 17:48:451602
[email protected]f98d7e3c2010-09-13 22:30:461603 // We may get back a smaller canvas than we asked for.
1604 // TODO(darin): This seems like it could cause painting problems!
[email protected]f1cccb32012-06-06 18:29:591605 DCHECK_EQ(pixel_bounds.width(), canvas->getDevice()->width());
1606 DCHECK_EQ(pixel_bounds.height(), canvas->getDevice()->height());
1607 pixel_bounds.set_width(canvas->getDevice()->width());
1608 pixel_bounds.set_height(canvas->getDevice()->height());
1609 bounds.set_width(pixel_bounds.width() / device_scale_factor_);
1610 bounds.set_height(pixel_bounds.height() / device_scale_factor_);
[email protected]53d3f302009-12-21 04:42:051611
[email protected]f98d7e3c2010-09-13 22:30:461612 HISTOGRAM_COUNTS_100("MPArch.RW_PaintRectCount", update.paint_rects.size());
1613
[email protected]aa4117f2011-12-09 22:19:211614 pending_update_params_->bitmap = current_paint_buf_->id();
1615 pending_update_params_->bitmap_rect = bounds;
1616
1617 std::vector<gfx::Rect>& copy_rects = pending_update_params_->copy_rects;
[email protected]f98d7e3c2010-09-13 22:30:461618 // The scroll damage is just another rectangle to paint and copy.
1619 copy_rects.swap(update.paint_rects);
1620 if (!scroll_damage.IsEmpty())
1621 copy_rects.push_back(scroll_damage);
1622
[email protected]4889bd212013-02-11 22:23:101623 for (size_t i = 0; i < copy_rects.size(); ++i) {
1624 gfx::Rect rect = copy_rects[i];
1625 if (fractional_scale) {
1626 // Damage might not be DPI aligned. Inflate rect to compensate.
1627 rect.Inset(-1, -1);
1628 }
1629 PaintRect(rect, pixel_bounds.origin(), canvas.get());
1630 }
[email protected]60a50072012-01-11 02:05:351631
1632 // Software FPS tick for performance tests. The accelerated path traces the
1633 // frame events in didCommitAndDrawCompositorFrame. See throughput_tests.cc.
1634 // NOTE: Tests may break if this event is renamed or moved.
[email protected]c76faea2013-03-26 07:42:421635 UNSHIPPED_TRACE_EVENT_INSTANT0("test_fps", "TestFrameTickSW",
1636 TRACE_EVENT_SCOPE_THREAD);
[email protected]f98d7e3c2010-09-13 22:30:461637 } else { // Accelerated compositing path
1638 // Begin painting.
[email protected]aa4117f2011-12-09 22:19:211639 // If painting is done via the gpu process then we don't set any damage
1640 // rects to save the browser process from doing unecessary work.
1641 pending_update_params_->bitmap_rect = bounds;
1642 pending_update_params_->scroll_rect = gfx::Rect();
1643 // We don't need an ack, because we're not sharing a DIB with the browser.
1644 // If it needs to (e.g. composited UI), the GPU process does its own ACK
1645 // with the browser for the GPU surface.
1646 pending_update_params_->needs_ack = false;
[email protected]f0c2a242013-03-15 19:34:521647 Composite(frame_begin_ticks);
[email protected]f98d7e3c2010-09-13 22:30:461648 }
1649
[email protected]936c6f52011-12-13 01:35:261650 // If we're holding a pending input event ACK, send the ACK before sending the
1651 // UpdateReply message so we can receive another input event before the
1652 // UpdateRect_ACK on platforms where the UpdateRect_ACK is sent from within
1653 // the UpdateRect IPC message handler.
[email protected]fd847792013-10-24 17:12:351654 FlushPendingInputEventAck();
[email protected]936c6f52011-12-13 01:35:261655
[email protected]ab543072013-01-25 04:38:151656 // If Composite() called SwapBuffers, pending_update_params_ will be reset (in
[email protected]aa4117f2011-12-09 22:19:211657 // OnSwapBuffersPosted), meaning a message has been added to the
1658 // updates_pending_swap_ queue, that will be sent later. Otherwise, we send
1659 // the message now.
[email protected]59383c782013-04-17 16:43:271660 if (pending_update_params_) {
[email protected]aa4117f2011-12-09 22:19:211661 // sending an ack to browser process that the paint is complete...
1662 update_reply_pending_ = pending_update_params_->needs_ack;
1663 Send(new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_));
1664 pending_update_params_.reset();
[email protected]b167ca662010-05-14 00:05:341665 }
[email protected]53d3f302009-12-21 04:42:051666
[email protected]29ed96a2012-02-04 18:12:161667 // If we're software rendering then we're done initiating the paint.
1668 if (!is_accelerated_compositing_active_)
1669 DidInitiatePaint();
initial.commit09911bf2008-07-26 23:55:291670}
1671
[email protected]f0c2a242013-03-15 19:34:521672void RenderWidget::Composite(base::TimeTicks frame_begin_time) {
[email protected]ab543072013-01-25 04:38:151673 DCHECK(is_accelerated_compositing_active_);
[email protected]ba91a792013-02-06 09:48:281674 if (compositor_) // TODO(jamesr): Figure out how this can be null.
[email protected]f0c2a242013-03-15 19:34:521675 compositor_->Composite(frame_begin_time);
[email protected]ab543072013-01-25 04:38:151676}
1677
initial.commit09911bf2008-07-26 23:55:291678///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461679// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291680
[email protected]4873c7d2009-07-16 06:36:281681void RenderWidget::didInvalidateRect(const WebRect& rect) {
[email protected]552e6002009-11-19 05:24:571682 // The invalidated rect might be outside the bounds of the view.
[email protected]ee8d6fd2010-05-26 17:05:481683 gfx::Rect view_rect(size_);
[email protected]ce112fe2012-10-29 22:52:181684 gfx::Rect damaged_rect = gfx::IntersectRects(view_rect, rect);
[email protected]552e6002009-11-19 05:24:571685 if (damaged_rect.IsEmpty())
initial.commit09911bf2008-07-26 23:55:291686 return;
1687
[email protected]552e6002009-11-19 05:24:571688 paint_aggregator_.InvalidateRect(damaged_rect);
1689
1690 // We may not need to schedule another call to DoDeferredUpdate.
[email protected]65225772011-05-12 21:10:241691 if (invalidation_task_posted_)
[email protected]552e6002009-11-19 05:24:571692 return;
1693 if (!paint_aggregator_.HasPendingUpdate())
1694 return;
[email protected]aa4117f2011-12-09 22:19:211695 if (update_reply_pending_ ||
[email protected]65225772011-05-12 21:10:241696 num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending)
1697 return;
1698
1699 // When GPU rendering, combine pending animations and invalidations into
1700 // a single update.
[email protected]816edc62012-03-17 01:27:221701 if (is_accelerated_compositing_active_ &&
1702 animation_update_pending_ &&
1703 animation_timer_.IsRunning())
[email protected]552e6002009-11-19 05:24:571704 return;
1705
1706 // Perform updating asynchronously. This serves two purposes:
initial.commit09911bf2008-07-26 23:55:291707 // 1) Ensures that we call WebView::Paint without a bunch of other junk
1708 // on the call stack.
1709 // 2) Allows us to collect more damage rects before painting to help coalesce
1710 // the work that we will need to do.
[email protected]65225772011-05-12 21:10:241711 invalidation_task_posted_ = true;
[email protected]dd32b1272013-05-04 14:17:111712 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:211713 FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
initial.commit09911bf2008-07-26 23:55:291714}
1715
[email protected]990278ff2012-11-13 02:12:551716void RenderWidget::didScrollRect(int dx, int dy,
1717 const WebRect& clip_rect) {
[email protected]f98d7e3c2010-09-13 22:30:461718 // Drop scrolls on the floor when we are in compositing mode.
1719 // TODO(nduca): stop WebViewImpl from sending scrolls in the first place.
[email protected]a79d8a632010-11-18 22:35:561720 if (is_accelerated_compositing_active_)
[email protected]f98d7e3c2010-09-13 22:30:461721 return;
1722
[email protected]552e6002009-11-19 05:24:571723 // The scrolled rect might be outside the bounds of the view.
[email protected]ee8d6fd2010-05-26 17:05:481724 gfx::Rect view_rect(size_);
[email protected]ce112fe2012-10-29 22:52:181725 gfx::Rect damaged_rect = gfx::IntersectRects(view_rect, clip_rect);
[email protected]552e6002009-11-19 05:24:571726 if (damaged_rect.IsEmpty())
initial.commit09911bf2008-07-26 23:55:291727 return;
1728
[email protected]990278ff2012-11-13 02:12:551729 paint_aggregator_.ScrollRect(gfx::Vector2d(dx, dy), damaged_rect);
[email protected]552e6002009-11-19 05:24:571730
1731 // We may not need to schedule another call to DoDeferredUpdate.
[email protected]65225772011-05-12 21:10:241732 if (invalidation_task_posted_)
[email protected]552e6002009-11-19 05:24:571733 return;
1734 if (!paint_aggregator_.HasPendingUpdate())
1735 return;
[email protected]aa4117f2011-12-09 22:19:211736 if (update_reply_pending_ ||
[email protected]65225772011-05-12 21:10:241737 num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending)
1738 return;
1739
1740 // When GPU rendering, combine pending animations and invalidations into
1741 // a single update.
[email protected]816edc62012-03-17 01:27:221742 if (is_accelerated_compositing_active_ &&
1743 animation_update_pending_ &&
1744 animation_timer_.IsRunning())
[email protected]552e6002009-11-19 05:24:571745 return;
1746
1747 // Perform updating asynchronously. This serves two purposes:
1748 // 1) Ensures that we call WebView::Paint without a bunch of other junk
1749 // on the call stack.
1750 // 2) Allows us to collect more damage rects before painting to help coalesce
1751 // the work that we will need to do.
[email protected]65225772011-05-12 21:10:241752 invalidation_task_posted_ = true;
[email protected]dd32b1272013-05-04 14:17:111753 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:211754 FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
initial.commit09911bf2008-07-26 23:55:291755}
1756
[email protected]244ac1892011-12-02 17:04:471757void RenderWidget::didAutoResize(const WebSize& new_size) {
[email protected]ea3ee0a2012-05-15 03:43:091758 if (size_.width() != new_size.width || size_.height() != new_size.height) {
[email protected]eac2b362013-05-22 07:01:451759 size_ = new_size;
[email protected]20fbfc22013-05-08 20:50:581760
[email protected]eac2b362013-05-22 07:01:451761 // If we don't clear PaintAggregator after changing autoResize state, then
1762 // we might end up in a situation where bitmap_rect is larger than the
1763 // view_size. By clearing PaintAggregator, we ensure that we don't end up
1764 // with invalid damage rects.
1765 paint_aggregator_.ClearPendingUpdate();
1766
[email protected]5b45ad42013-10-25 00:42:041767 if (resizing_mode_selector_->is_synchronous_mode()) {
[email protected]eac2b362013-05-22 07:01:451768 WebRect new_pos(rootWindowRect().x,
1769 rootWindowRect().y,
1770 new_size.width,
1771 new_size.height);
1772 view_screen_rect_ = new_pos;
1773 window_screen_rect_ = new_pos;
[email protected]8be1c582013-03-06 00:55:031774 }
[email protected]20fbfc22013-05-08 20:50:581775
[email protected]eac2b362013-05-22 07:01:451776 AutoResizeCompositor();
[email protected]20fbfc22013-05-08 20:50:581777
[email protected]5b45ad42013-10-25 00:42:041778 if (!resizing_mode_selector_->is_synchronous_mode())
[email protected]20fbfc22013-05-08 20:50:581779 need_update_rect_for_auto_resize_ = true;
[email protected]ea3ee0a2012-05-15 03:43:091780 }
[email protected]244ac1892011-12-02 17:04:471781}
1782
[email protected]3a1c8a8032013-03-18 22:35:321783void RenderWidget::AutoResizeCompositor() {
[email protected]97e1bf72013-03-06 14:06:051784 physical_backing_size_ = gfx::ToCeiledSize(gfx::ScaleSize(size_,
1785 device_scale_factor_));
1786 if (compositor_)
1787 compositor_->setViewportSize(size_, physical_backing_size_);
1788}
1789
[email protected]91acd1c2012-03-14 08:32:391790void RenderWidget::didActivateCompositor(int input_handler_identifier) {
[email protected]ea162f92011-10-04 23:08:221791 TRACE_EVENT0("gpu", "RenderWidget::didActivateCompositor");
1792
[email protected]c63b4d42012-04-26 01:01:071793#if !defined(OS_MACOSX)
[email protected]aa4117f2011-12-09 22:19:211794 if (!is_accelerated_compositing_active_) {
1795 // When not in accelerated compositing mode, in certain cases (e.g. waiting
1796 // for a resize or if no backing store) the RenderWidgetHost is blocking the
1797 // browser's UI thread for some time, waiting for an UpdateRect. If we are
1798 // going to switch to accelerated compositing, the GPU process may need
1799 // round-trips to the browser's UI thread before finishing the frame,
1800 // causing deadlocks if we delay the UpdateRect until we receive the
1801 // OnSwapBuffersComplete. So send a dummy message that will unblock the
[email protected]c63b4d42012-04-26 01:01:071802 // browser's UI thread. This is not necessary on Mac, because SwapBuffers
1803 // now unblocks GetBackingStore on Mac.
[email protected]aa4117f2011-12-09 22:19:211804 Send(new ViewHostMsg_UpdateIsDelayed(routing_id_));
1805 }
[email protected]c63b4d42012-04-26 01:01:071806#endif
[email protected]aa4117f2011-12-09 22:19:211807
[email protected]ea162f92011-10-04 23:08:221808 is_accelerated_compositing_active_ = true;
[email protected]50bd6452010-11-27 19:39:421809 Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
[email protected]65225772011-05-12 21:10:241810 routing_id_, is_accelerated_compositing_active_));
[email protected]d8a6c5d12013-09-23 04:37:101811
1812 if (!was_accelerated_compositing_ever_active_) {
1813 was_accelerated_compositing_ever_active_ = true;
1814 webwidget_->enterForceCompositingMode(true);
1815 }
[email protected]ea162f92011-10-04 23:08:221816}
1817
1818void RenderWidget::didDeactivateCompositor() {
1819 TRACE_EVENT0("gpu", "RenderWidget::didDeactivateCompositor");
1820
1821 is_accelerated_compositing_active_ = false;
1822 Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
1823 routing_id_, is_accelerated_compositing_active_));
1824
[email protected]ea162f92011-10-04 23:08:221825 if (using_asynchronous_swapbuffers_)
[email protected]65225772011-05-12 21:10:241826 using_asynchronous_swapbuffers_ = false;
[email protected]479b0172012-10-29 19:27:091827
1828 // In single-threaded mode, we exit force compositing mode and re-enter in
1829 // DoDeferredUpdate() if appropriate. In threaded compositing mode,
1830 // DoDeferredUpdate() is bypassed and WebKit is responsible for exiting and
1831 // entering force compositing mode at the appropriate times.
[email protected]cb6430932012-10-31 00:53:361832 if (!is_threaded_compositing_enabled_)
[email protected]479b0172012-10-29 19:27:091833 webwidget_->enterForceCompositingMode(false);
[email protected]a79d8a632010-11-18 22:35:561834}
1835
[email protected]e195e582013-03-08 01:32:591836void RenderWidget::initializeLayerTreeView() {
[email protected]c5fa4c42013-07-20 05:47:371837 compositor_ = RenderWidgetCompositor::Create(
1838 this, is_threaded_compositing_enabled_);
[email protected]e195e582013-03-08 01:32:591839 if (!compositor_)
1840 return;
1841
1842 compositor_->setViewportSize(size_, physical_backing_size_);
1843 if (init_complete_)
1844 compositor_->setSurfaceReady();
1845}
1846
[email protected]180ef242013-11-07 06:50:461847blink::WebLayerTreeView* RenderWidget::layerTreeView() {
[email protected]ba91a792013-02-06 09:48:281848 return compositor_.get();
[email protected]8926c602013-01-23 05:32:061849}
1850
[email protected]9ed83fe2013-02-27 01:52:281851void RenderWidget::suppressCompositorScheduling(bool enable) {
1852 if (compositor_)
1853 compositor_->SetSuppressScheduleComposite(enable);
1854}
1855
[email protected]9cd43a62012-03-26 08:03:561856void RenderWidget::willBeginCompositorFrame() {
1857 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
[email protected]abe8b3a2012-03-28 21:19:371858
[email protected]cadac622013-06-11 16:46:361859 DCHECK(RenderThreadImpl::current()->compositor_message_loop_proxy().get());
[email protected]abe8b3a2012-03-28 21:19:371860
1861 // The following two can result in further layout and possibly
1862 // enable GPU acceleration so they need to be called before any painting
1863 // is done.
[email protected]cb9e2632013-06-18 11:26:471864 UpdateTextInputType();
1865#if defined(OS_ANDROID)
[email protected]0d1ebed12013-08-05 22:01:131866 UpdateTextInputState(false, true);
[email protected]cb9e2632013-06-18 11:26:471867#endif
[email protected]abe8b3a2012-03-28 21:19:371868 UpdateSelectionBounds();
[email protected]9cd43a62012-03-26 08:03:561869}
1870
[email protected]3391a0772012-03-28 00:32:071871void RenderWidget::didBecomeReadyForAdditionalInput() {
1872 TRACE_EVENT0("renderer", "RenderWidget::didBecomeReadyForAdditionalInput");
[email protected]fd847792013-10-24 17:12:351873 FlushPendingInputEventAck();
[email protected]3391a0772012-03-28 00:32:071874}
1875
[email protected]6fceb912013-02-15 06:24:151876void RenderWidget::DidCommitCompositorFrame() {
1877}
1878
[email protected]58264a32011-11-17 23:36:151879void RenderWidget::didCommitAndDrawCompositorFrame() {
[email protected]b5db7eb2011-11-29 09:11:501880 TRACE_EVENT0("gpu", "RenderWidget::didCommitAndDrawCompositorFrame");
[email protected]60a50072012-01-11 02:05:351881 // Accelerated FPS tick for performance tests. See throughput_tests.cc.
1882 // NOTE: Tests may break if this event is renamed or moved.
[email protected]c76faea2013-03-26 07:42:421883 UNSHIPPED_TRACE_EVENT_INSTANT0("test_fps", "TestFrameTickGPU",
1884 TRACE_EVENT_SCOPE_THREAD);
[email protected]29ed96a2012-02-04 18:12:161885 // Notify subclasses that we initiated the paint operation.
1886 DidInitiatePaint();
[email protected]58264a32011-11-17 23:36:151887}
1888
1889void RenderWidget::didCompleteSwapBuffers() {
[email protected]404939f2012-06-01 04:06:181890 TRACE_EVENT0("renderer", "RenderWidget::didCompleteSwapBuffers");
1891
1892 // Notify subclasses threaded composited rendering was flushed to the screen.
[email protected]9cd43a62012-03-26 08:03:561893 DidFlushPaint();
1894
[email protected]aa4117f2011-12-09 22:19:211895 if (update_reply_pending_)
[email protected]58264a32011-11-17 23:36:151896 return;
1897
[email protected]ea3ee0a2012-05-15 03:43:091898 if (!next_paint_flags_ &&
1899 !need_update_rect_for_auto_resize_ &&
1900 !plugin_window_moves_.size()) {
[email protected]58264a32011-11-17 23:36:151901 return;
[email protected]ea3ee0a2012-05-15 03:43:091902 }
[email protected]58264a32011-11-17 23:36:151903
1904 ViewHostMsg_UpdateRect_Params params;
1905 params.view_size = size_;
[email protected]58264a32011-11-17 23:36:151906 params.plugin_window_moves.swap(plugin_window_moves_);
1907 params.flags = next_paint_flags_;
1908 params.scroll_offset = GetScrollOffset();
[email protected]b0dda9e22011-12-13 20:30:121909 params.needs_ack = false;
[email protected]7ded9f12012-06-13 20:47:091910 params.scale_factor = device_scale_factor_;
[email protected]58264a32011-11-17 23:36:151911
1912 Send(new ViewHostMsg_UpdateRect(routing_id_, params));
1913 next_paint_flags_ = 0;
[email protected]ea3ee0a2012-05-15 03:43:091914 need_update_rect_for_auto_resize_ = false;
[email protected]58264a32011-11-17 23:36:151915}
1916
[email protected]f98d7e3c2010-09-13 22:30:461917void RenderWidget::scheduleComposite() {
[email protected]7d08a9352013-10-15 08:24:561918 ScheduleCompositeImpl(false);
[email protected]f98d7e3c2010-09-13 22:30:461919}
1920
[email protected]5f8b1022011-01-21 23:34:501921void RenderWidget::scheduleAnimation() {
[email protected]ce65fb782012-04-19 05:01:201922 if (animation_update_pending_)
1923 return;
1924
[email protected]921244e42011-07-20 16:36:301925 TRACE_EVENT0("gpu", "RenderWidget::scheduleAnimation");
[email protected]ce65fb782012-04-19 05:01:201926 animation_update_pending_ = true;
1927 if (!animation_timer_.IsRunning()) {
1928 animation_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(0), this,
1929 &RenderWidget::AnimationCallback);
[email protected]ee3d3ad2011-02-04 00:42:211930 }
[email protected]5f8b1022011-01-21 23:34:501931}
1932
[email protected]4873c7d2009-07-16 06:36:281933void RenderWidget::didChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301934 // TODO(darin): Eliminate this temporary.
[email protected]9ec87712013-05-24 23:23:521935 WebCursor cursor;
[email protected]953bd0062013-08-01 00:58:401936 InitializeCursorFromWebKitCursorInfo(&cursor, cursor_info);
initial.commit09911bf2008-07-26 23:55:291937 // Only send a SetCursor message if we need to make a change.
1938 if (!current_cursor_.IsEqual(cursor)) {
1939 current_cursor_ = cursor;
1940 Send(new ViewHostMsg_SetCursor(routing_id_, cursor));
1941 }
1942}
1943
1944// We are supposed to get a single call to Show for a newly created RenderWidget
1945// that was created via RenderWidget::CreateWebView. So, we wait until this
1946// point to dispatch the ShowWidget message.
1947//
1948// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281949// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291950//
[email protected]4873c7d2009-07-16 06:36:281951void RenderWidget::show(WebNavigationPolicy) {
initial.commit09911bf2008-07-26 23:55:291952 DCHECK(!did_show_) << "received extraneous Show call";
1953 DCHECK(routing_id_ != MSG_ROUTING_NONE);
1954 DCHECK(opener_id_ != MSG_ROUTING_NONE);
1955
[email protected]8de12d942010-11-17 20:42:441956 if (did_show_)
1957 return;
1958
1959 did_show_ = true;
1960 // NOTE: initial_pos_ may still have its default values at this point, but
1961 // that's okay. It'll be ignored if as_popup is false, or the browser
1962 // process will impose a default position otherwise.
1963 Send(new ViewHostMsg_ShowWidget(opener_id_, routing_id_, initial_pos_));
1964 SetPendingWindowRect(initial_pos_);
initial.commit09911bf2008-07-26 23:55:291965}
1966
[email protected]4873c7d2009-07-16 06:36:281967void RenderWidget::didFocus() {
initial.commit09911bf2008-07-26 23:55:291968}
1969
[email protected]4873c7d2009-07-16 06:36:281970void RenderWidget::didBlur() {
initial.commit09911bf2008-07-26 23:55:291971}
1972
[email protected]2533ce12009-05-09 00:02:241973void RenderWidget::DoDeferredClose() {
1974 Send(new ViewHostMsg_Close(routing_id_));
1975}
1976
[email protected]4873c7d2009-07-16 06:36:281977void RenderWidget::closeWidgetSoon() {
[email protected]e1c3a552012-05-04 20:51:321978 if (is_swapped_out_) {
1979 // This widget is currently swapped out, and the active widget is in a
1980 // different process. Have the browser route the close request to the
1981 // active widget instead, so that the correct unload handlers are run.
1982 Send(new ViewHostMsg_RouteCloseEvent(routing_id_));
1983 return;
1984 }
1985
initial.commit09911bf2008-07-26 23:55:291986 // If a page calls window.close() twice, we'll end up here twice, but that's
1987 // OK. It is safe to send multiple Close messages.
1988
[email protected]2533ce12009-05-09 00:02:241989 // Ask the RenderWidgetHost to initiate close. We could be called from deep
1990 // in Javascript. If we ask the RendwerWidgetHost to close now, the window
1991 // could be closed before the JS finishes executing. So instead, post a
1992 // message back to the message loop, which won't run until the JS is
1993 // complete, and then the Close message can be sent.
[email protected]dd32b1272013-05-04 14:17:111994 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:211995 FROM_HERE, base::Bind(&RenderWidget::DoDeferredClose, this));
initial.commit09911bf2008-07-26 23:55:291996}
1997
1998void RenderWidget::Close() {
1999 if (webwidget_) {
[email protected]8926c602013-01-23 05:32:062000 webwidget_->willCloseLayerTreeView();
[email protected]ba91a792013-02-06 09:48:282001 compositor_.reset();
[email protected]4873c7d2009-07-16 06:36:282002 webwidget_->close();
initial.commit09911bf2008-07-26 23:55:292003 webwidget_ = NULL;
2004 }
2005}
2006
[email protected]4873c7d2009-07-16 06:36:282007WebRect RenderWidget::windowRect() {
2008 if (pending_window_rect_count_)
2009 return pending_window_rect_;
[email protected]2533ce12009-05-09 00:02:242010
[email protected]80ad8622012-11-07 16:33:032011 return view_screen_rect_;
initial.commit09911bf2008-07-26 23:55:292012}
2013
[email protected]180ef242013-11-07 06:50:462014void RenderWidget::setToolTipText(const blink::WebString& text,
[email protected]8a9d6ca32011-06-06 20:11:302015 WebTextDirection hint) {
[email protected]5a395b72011-08-08 19:13:542016 Send(new ViewHostMsg_SetTooltipText(routing_id_, text, hint));
[email protected]8a9d6ca32011-06-06 20:11:302017}
2018
[email protected]b2e4c70132013-10-03 02:07:512019void RenderWidget::setWindowRect(const WebRect& rect) {
2020 WebRect pos = rect;
2021 if (popup_origin_scale_for_emulation_) {
2022 float scale = popup_origin_scale_for_emulation_;
2023 pos.x = popup_screen_origin_for_emulation_.x() +
2024 (pos.x - popup_view_origin_for_emulation_.x()) * scale;
2025 pos.y = popup_screen_origin_for_emulation_.y() +
2026 (pos.y - popup_view_origin_for_emulation_.y()) * scale;
2027 }
2028
[email protected]5b45ad42013-10-25 00:42:042029 if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]ec951b9d2013-10-20 06:21:202030 if (did_show_) {
[email protected]8be1c582013-03-06 00:55:032031 Send(new ViewHostMsg_RequestMove(routing_id_, pos));
2032 SetPendingWindowRect(pos);
2033 } else {
[email protected]ec951b9d2013-10-20 06:21:202034 initial_pos_ = pos;
[email protected]8be1c582013-03-06 00:55:032035 }
initial.commit09911bf2008-07-26 23:55:292036 } else {
[email protected]92650162013-10-30 03:31:022037 ResizeSynchronously(pos);
initial.commit09911bf2008-07-26 23:55:292038 }
2039}
2040
[email protected]2533ce12009-05-09 00:02:242041void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
2042 pending_window_rect_ = rect;
2043 pending_window_rect_count_++;
2044}
2045
[email protected]4873c7d2009-07-16 06:36:282046WebRect RenderWidget::rootWindowRect() {
[email protected]2533ce12009-05-09 00:02:242047 if (pending_window_rect_count_) {
2048 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
2049 // the RootWindowRect is probably going to return wrong results since the
2050 // browser may not have processed the Move yet. There isn't really anything
2051 // good to do in this case, and it shouldn't happen - since this size is
2052 // only really needed for windowToScreen, which is only used for Popups.
[email protected]4873c7d2009-07-16 06:36:282053 return pending_window_rect_;
[email protected]2533ce12009-05-09 00:02:242054 }
2055
[email protected]80ad8622012-11-07 16:33:032056 return window_screen_rect_;
[email protected]d4547452008-08-28 18:36:372057}
2058
[email protected]4873c7d2009-07-16 06:36:282059WebRect RenderWidget::windowResizerRect() {
2060 return resizer_rect_;
[email protected]c04b6362008-11-21 18:54:192061}
2062
[email protected]fa7b1dc2010-06-23 17:53:042063void RenderWidget::OnSetInputMethodActive(bool is_active) {
[email protected]c4bb35a2008-10-31 17:54:032064 // To prevent this renderer process from sending unnecessary IPC messages to
2065 // a browser process, we permit the renderer process to send IPC messages
[email protected]fa7b1dc2010-06-23 17:53:042066 // only during the input method attached to the browser process is active.
2067 input_method_is_active_ = is_active;
initial.commit09911bf2008-07-26 23:55:292068}
2069
[email protected]fa7b1dc2010-06-23 17:53:042070void RenderWidget::OnImeSetComposition(
2071 const string16& text,
2072 const std::vector<WebCompositionUnderline>& underlines,
2073 int selection_start, int selection_end) {
[email protected]0d1ebed12013-08-05 22:01:132074 if (!ShouldHandleImeEvent())
[email protected]4873c7d2009-07-16 06:36:282075 return;
[email protected]66fca5bc2013-05-23 06:58:292076 ImeEventGuard guard(this);
[email protected]88dbe32f2013-06-20 23:31:362077 if (!webwidget_->setComposition(
[email protected]fa7b1dc2010-06-23 17:53:042078 text, WebVector<WebCompositionUnderline>(underlines),
2079 selection_start, selection_end)) {
2080 // If we failed to set the composition text, then we need to let the browser
2081 // process to cancel the input method's ongoing composition session, to make
2082 // sure we are in a consistent state.
2083 Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
[email protected]7f00efa2010-04-15 05:01:262084 }
[email protected]501ea13d2013-07-09 17:03:292085#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362086 UpdateCompositionInfo(true);
[email protected]501ea13d2013-07-09 17:03:292087#endif
[email protected]fa7b1dc2010-06-23 17:53:042088}
2089
[email protected]0e45bd02013-07-12 20:20:022090void RenderWidget::OnImeConfirmComposition(const string16& text,
[email protected]db4fc1e2013-09-06 20:01:512091 const gfx::Range& replacement_range,
[email protected]0e45bd02013-07-12 20:20:022092 bool keep_selection) {
[email protected]0d1ebed12013-08-05 22:01:132093 if (!ShouldHandleImeEvent())
[email protected]d0be63772011-12-20 23:18:042094 return;
[email protected]66fca5bc2013-05-23 06:58:292095 ImeEventGuard guard(this);
[email protected]d0be63772011-12-20 23:18:042096 handling_input_event_ = true;
[email protected]0e45bd02013-07-12 20:20:022097 if (text.length())
2098 webwidget_->confirmComposition(text);
2099 else if (keep_selection)
2100 webwidget_->confirmComposition(WebWidget::KeepSelection);
2101 else
2102 webwidget_->confirmComposition(WebWidget::DoNotKeepSelection);
[email protected]d0be63772011-12-20 23:18:042103 handling_input_event_ = false;
[email protected]501ea13d2013-07-09 17:03:292104#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362105 UpdateCompositionInfo(true);
[email protected]501ea13d2013-07-09 17:03:292106#endif
initial.commit09911bf2008-07-26 23:55:292107}
2108
[email protected]948f7ab72010-05-28 23:48:082109// This message causes the renderer to render an image of the
2110// desired_size, regardless of whether the tab is hidden or not.
[email protected]3d9ec5052013-01-02 22:05:252111void RenderWidget::OnPaintAtSize(const TransportDIB::Handle& dib_handle,
2112 int tag,
2113 const gfx::Size& page_size,
2114 const gfx::Size& desired_size) {
[email protected]27543452011-03-25 00:14:002115 if (!webwidget_ || !TransportDIB::is_valid_handle(dib_handle)) {
2116 if (TransportDIB::is_valid_handle(dib_handle)) {
[email protected]45c6aad32010-11-11 04:46:252117 // Close our unused handle.
2118#if defined(OS_WIN)
2119 ::CloseHandle(dib_handle);
2120#elif defined(OS_MACOSX)
2121 base::SharedMemory::CloseHandle(dib_handle);
2122#endif
2123 }
[email protected]d65adb12010-04-28 17:26:492124 return;
[email protected]45c6aad32010-11-11 04:46:252125 }
[email protected]d65adb12010-04-28 17:26:492126
[email protected]948f7ab72010-05-28 23:48:082127 if (page_size.IsEmpty() || desired_size.IsEmpty()) {
[email protected]d65adb12010-04-28 17:26:492128 // If one of these is empty, then we just return the dib we were
2129 // given, to avoid leaking it.
[email protected]c88c9442010-07-19 18:55:092130 Send(new ViewHostMsg_PaintAtSize_ACK(routing_id_, tag, desired_size));
[email protected]d65adb12010-04-28 17:26:492131 return;
2132 }
2133
2134 // Map the given DIB ID into this process, and unmap it at the end
2135 // of this function.
[email protected]45c6aad32010-11-11 04:46:252136 scoped_ptr<TransportDIB> paint_at_size_buffer(
2137 TransportDIB::CreateWithHandle(dib_handle));
[email protected]36808ad2010-10-20 19:18:302138
[email protected]4b01b962012-10-09 23:17:352139 gfx::Size page_size_in_pixel = gfx::ToFlooredSize(
[email protected]01a15a72012-11-10 09:34:282140 gfx::ScaleSize(page_size, device_scale_factor_));
[email protected]4b01b962012-10-09 23:17:352141 gfx::Size desired_size_in_pixel = gfx::ToFlooredSize(
[email protected]01a15a72012-11-10 09:34:282142 gfx::ScaleSize(desired_size, device_scale_factor_));
[email protected]8f640512012-08-07 23:52:512143 gfx::Size canvas_size = page_size_in_pixel;
2144 float x_scale = static_cast<float>(desired_size_in_pixel.width()) /
[email protected]d65adb12010-04-28 17:26:492145 static_cast<float>(canvas_size.width());
[email protected]8f640512012-08-07 23:52:512146 float y_scale = static_cast<float>(desired_size_in_pixel.height()) /
[email protected]d65adb12010-04-28 17:26:492147 static_cast<float>(canvas_size.height());
2148
[email protected]ee8d6fd2010-05-26 17:05:482149 gfx::Rect orig_bounds(canvas_size);
[email protected]d65adb12010-04-28 17:26:492150 canvas_size.set_width(static_cast<int>(canvas_size.width() * x_scale));
2151 canvas_size.set_height(static_cast<int>(canvas_size.height() * y_scale));
[email protected]ee8d6fd2010-05-26 17:05:482152 gfx::Rect bounds(canvas_size);
[email protected]d65adb12010-04-28 17:26:492153
[email protected]36808ad2010-10-20 19:18:302154 scoped_ptr<skia::PlatformCanvas> canvas(
2155 paint_at_size_buffer->GetPlatformCanvas(canvas_size.width(),
2156 canvas_size.height()));
[email protected]59383c782013-04-17 16:43:272157 if (!canvas) {
[email protected]36808ad2010-10-20 19:18:302158 NOTREACHED();
2159 return;
2160 }
2161
[email protected]d65adb12010-04-28 17:26:492162 // Reset bounds to what we actually received, but they should be the
2163 // same.
2164 DCHECK_EQ(bounds.width(), canvas->getDevice()->width());
2165 DCHECK_EQ(bounds.height(), canvas->getDevice()->height());
2166 bounds.set_width(canvas->getDevice()->width());
2167 bounds.set_height(canvas->getDevice()->height());
2168
2169 canvas->save();
[email protected]948f7ab72010-05-28 23:48:082170 // Add the scale factor to the canvas, so that we'll get the desired size.
[email protected]d65adb12010-04-28 17:26:492171 canvas->scale(SkFloatToScalar(x_scale), SkFloatToScalar(y_scale));
2172
[email protected]948f7ab72010-05-28 23:48:082173 // Have to make sure we're laid out at the right size before
2174 // rendering.
2175 gfx::Size old_size = webwidget_->size();
2176 webwidget_->resize(page_size);
2177 webwidget_->layout();
2178
[email protected]d65adb12010-04-28 17:26:492179 // Paint the entire thing (using original bounds, not scaled bounds).
2180 PaintRect(orig_bounds, orig_bounds.origin(), canvas.get());
2181 canvas->restore();
2182
[email protected]948f7ab72010-05-28 23:48:082183 // Return the widget to its previous size.
2184 webwidget_->resize(old_size);
2185
[email protected]c88c9442010-07-19 18:55:092186 Send(new ViewHostMsg_PaintAtSize_ACK(routing_id_, tag, bounds.size()));
[email protected]d65adb12010-04-28 17:26:492187}
2188
[email protected]51a49502013-03-23 01:50:192189void RenderWidget::OnSnapshot(const gfx::Rect& src_subrect) {
2190 SkBitmap snapshot;
2191
2192 if (OnSnapshotHelper(src_subrect, &snapshot)) {
2193 Send(new ViewHostMsg_Snapshot(routing_id(), true, snapshot));
2194 } else {
2195 Send(new ViewHostMsg_Snapshot(routing_id(), false, SkBitmap()));
2196 }
2197}
2198
2199bool RenderWidget::OnSnapshotHelper(const gfx::Rect& src_subrect,
2200 SkBitmap* snapshot) {
2201 base::TimeTicks beginning_time = base::TimeTicks::Now();
2202
2203 if (!webwidget_ || src_subrect.IsEmpty())
2204 return false;
2205
2206 gfx::Rect viewport_size = gfx::IntersectRects(
2207 src_subrect, gfx::Rect(physical_backing_size_));
2208
2209 skia::RefPtr<SkCanvas> canvas = skia::AdoptRef(
2210 skia::CreatePlatformCanvas(viewport_size.width(),
2211 viewport_size.height(),
2212 true,
2213 NULL,
2214 skia::RETURN_NULL_ON_FAILURE));
[email protected]59383c782013-04-17 16:43:272215 if (!canvas)
[email protected]51a49502013-03-23 01:50:192216 return false;
2217
2218 canvas->save();
2219 webwidget_->layout();
2220
2221 PaintRect(viewport_size, viewport_size.origin(), canvas.get());
2222 canvas->restore();
2223
2224 const SkBitmap& bitmap = skia::GetTopDevice(*canvas)->accessBitmap(false);
2225 if (!bitmap.copyTo(snapshot, SkBitmap::kARGB_8888_Config))
2226 return false;
2227
2228 UMA_HISTOGRAM_TIMES("Renderer4.Snapshot",
2229 base::TimeTicks::Now() - beginning_time);
2230 return true;
2231}
2232
[email protected]0bc1f572013-04-17 01:46:312233void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
[email protected]ec7dc112008-08-06 05:30:122234 // During shutdown we can just ignore this message.
2235 if (!webwidget_)
2236 return;
2237
[email protected]0bc1f572013-04-17 01:46:312238 // Even if the browser provides an empty damage rect, it's still expecting to
2239 // receive a repaint ack so just damage the entire widget bounds.
2240 if (size_to_paint.IsEmpty()) {
2241 size_to_paint = size_;
2242 }
2243
[email protected]ec7dc112008-08-06 05:30:122244 set_next_paint_is_repaint_ack();
[email protected]0bc1f572013-04-17 01:46:312245 if (is_accelerated_compositing_active_ && compositor_) {
2246 compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint));
[email protected]f98d7e3c2010-09-13 22:30:462247 } else {
2248 gfx::Rect repaint_rect(size_to_paint.width(), size_to_paint.height());
2249 didInvalidateRect(repaint_rect);
2250 }
[email protected]ec7dc112008-08-06 05:30:122251}
2252
[email protected]79fa22e2013-08-23 15:18:122253void RenderWidget::OnSyntheticGestureCompleted() {
2254 pending_synthetic_gesture_.Run();
[email protected]0e241b4b2012-08-18 09:06:272255}
2256
[email protected]4873c7d2009-07-16 06:36:282257void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
[email protected]07f953332009-03-25 04:31:112258 if (!webwidget_)
2259 return;
[email protected]4873c7d2009-07-16 06:36:282260 webwidget_->setTextDirection(direction);
[email protected]07f953332009-03-25 04:31:112261}
2262
[email protected]80ad8622012-11-07 16:33:032263void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
2264 const gfx::Rect& window_screen_rect) {
[email protected]b2e4c70132013-10-03 02:07:512265 if (screen_metrics_emulator_) {
2266 screen_metrics_emulator_->OnUpdateScreenRectsMessage(
2267 view_screen_rect, window_screen_rect);
2268 } else {
2269 view_screen_rect_ = view_screen_rect;
2270 window_screen_rect_ = window_screen_rect;
2271 }
[email protected]80ad8622012-11-07 16:33:032272 Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
2273}
2274
[email protected]105dffb42013-02-20 03:46:212275#if defined(OS_ANDROID)
[email protected]2384b6c2013-02-28 23:58:512276void RenderWidget::OnShowImeIfNeeded() {
[email protected]0d1ebed12013-08-05 22:01:132277 UpdateTextInputState(true, true);
2278}
2279
2280void RenderWidget::IncrementOutstandingImeEventAcks() {
2281 ++outstanding_ime_acks_;
2282}
2283
2284void RenderWidget::OnImeEventAck() {
2285 --outstanding_ime_acks_;
2286 DCHECK(outstanding_ime_acks_ >= 0);
[email protected]2384b6c2013-02-28 23:58:512287}
[email protected]105dffb42013-02-20 03:46:212288#endif
2289
[email protected]0d1ebed12013-08-05 22:01:132290bool RenderWidget::ShouldHandleImeEvent() {
2291#if defined(OS_ANDROID)
2292 return !!webwidget_ && outstanding_ime_acks_ == 0;
2293#else
2294 return !!webwidget_;
2295#endif
2296}
2297
[email protected]468ac582012-11-20 00:53:192298void RenderWidget::SetDeviceScaleFactor(float device_scale_factor) {
2299 if (device_scale_factor_ == device_scale_factor)
2300 return;
2301
2302 device_scale_factor_ = device_scale_factor;
2303
2304 if (!is_accelerated_compositing_active_) {
2305 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
2306 } else {
2307 scheduleComposite();
2308 }
2309}
2310
[email protected]adab2332013-07-25 18:04:322311PepperPluginInstanceImpl* RenderWidget::GetBitmapForOptimizedPluginPaint(
2312 const gfx::Rect& paint_bounds,
2313 TransportDIB** dib,
2314 gfx::Rect* location,
2315 gfx::Rect* clip,
2316 float* scale_factor) {
[email protected]719b36f2010-12-22 20:36:462317 // Bare RenderWidgets don't support optimized plugin painting.
2318 return NULL;
[email protected]ca4847f2010-09-24 05:39:152319}
2320
[email protected]ceb36f7d2012-10-31 18:33:242321gfx::Vector2d RenderWidget::GetScrollOffset() {
[email protected]d54169e92011-01-21 09:19:522322 // Bare RenderWidgets don't support scroll offset.
[email protected]ceb36f7d2012-10-31 18:33:242323 return gfx::Vector2d();
[email protected]d54169e92011-01-21 09:19:522324}
2325
[email protected]bee16aab2009-08-26 15:55:032326void RenderWidget::SetHidden(bool hidden) {
2327 if (is_hidden_ == hidden)
2328 return;
2329
2330 // The status has changed. Tell the RenderThread about it.
2331 is_hidden_ = hidden;
2332 if (is_hidden_)
[email protected]380244092011-10-07 17:26:272333 RenderThread::Get()->WidgetHidden();
[email protected]bee16aab2009-08-26 15:55:032334 else
[email protected]380244092011-10-07 17:26:272335 RenderThread::Get()->WidgetRestored();
[email protected]bee16aab2009-08-26 15:55:032336}
2337
[email protected]2b624c562011-10-27 22:58:262338void RenderWidget::WillToggleFullscreen() {
[email protected]2b624c562011-10-27 22:58:262339 if (!webwidget_)
2340 return;
2341
2342 if (is_fullscreen_) {
2343 webwidget_->willExitFullScreen();
2344 } else {
2345 webwidget_->willEnterFullScreen();
2346 }
[email protected]2b624c562011-10-27 22:58:262347}
2348
2349void RenderWidget::DidToggleFullscreen() {
[email protected]2b624c562011-10-27 22:58:262350 if (!webwidget_)
2351 return;
2352
2353 if (is_fullscreen_) {
2354 webwidget_->didEnterFullScreen();
2355 } else {
2356 webwidget_->didExitFullScreen();
2357 }
[email protected]2b624c562011-10-27 22:58:262358}
2359
[email protected]699ab0d2009-04-23 23:19:142360void RenderWidget::SetBackground(const SkBitmap& background) {
2361 background_ = background;
[email protected]f98d7e3c2010-09-13 22:30:462362
[email protected]699ab0d2009-04-23 23:19:142363 // Generate a full repaint.
[email protected]4873c7d2009-07-16 06:36:282364 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
[email protected]699ab0d2009-04-23 23:19:142365}
2366
[email protected]674741932009-02-04 23:44:462367bool RenderWidget::next_paint_is_resize_ack() const {
[email protected]53d3f302009-12-21 04:42:052368 return ViewHostMsg_UpdateRect_Flags::is_resize_ack(next_paint_flags_);
[email protected]674741932009-02-04 23:44:462369}
2370
2371bool RenderWidget::next_paint_is_restore_ack() const {
[email protected]53d3f302009-12-21 04:42:052372 return ViewHostMsg_UpdateRect_Flags::is_restore_ack(next_paint_flags_);
[email protected]674741932009-02-04 23:44:462373}
2374
2375void RenderWidget::set_next_paint_is_resize_ack() {
[email protected]53d3f302009-12-21 04:42:052376 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
[email protected]674741932009-02-04 23:44:462377}
2378
2379void RenderWidget::set_next_paint_is_restore_ack() {
[email protected]53d3f302009-12-21 04:42:052380 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESTORE_ACK;
[email protected]674741932009-02-04 23:44:462381}
2382
2383void RenderWidget::set_next_paint_is_repaint_ack() {
[email protected]53d3f302009-12-21 04:42:052384 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK;
[email protected]674741932009-02-04 23:44:462385}
2386
[email protected]b18583c2012-12-18 06:55:272387static bool IsDateTimeInput(ui::TextInputType type) {
2388 return type == ui::TEXT_INPUT_TYPE_DATE ||
2389 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
2390 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
2391 type == ui::TEXT_INPUT_TYPE_MONTH ||
2392 type == ui::TEXT_INPUT_TYPE_TIME ||
2393 type == ui::TEXT_INPUT_TYPE_WEEK;
2394}
2395
[email protected]66fca5bc2013-05-23 06:58:292396
2397void RenderWidget::StartHandlingImeEvent() {
2398 DCHECK(!handling_ime_event_);
2399 handling_ime_event_ = true;
2400}
2401
2402void RenderWidget::FinishHandlingImeEvent() {
2403 DCHECK(handling_ime_event_);
2404 handling_ime_event_ = false;
2405 // While handling an ime event, text input state and selection bounds updates
2406 // are ignored. These must explicitly be updated once finished handling the
2407 // ime event.
2408 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:472409#if defined(OS_ANDROID)
[email protected]0d1ebed12013-08-05 22:01:132410 UpdateTextInputState(false, false);
[email protected]cb9e2632013-06-18 11:26:472411#endif
[email protected]66fca5bc2013-05-23 06:58:292412}
2413
[email protected]cb9e2632013-06-18 11:26:472414void RenderWidget::UpdateTextInputType() {
[email protected]11f22bb62013-09-24 04:59:062415 // On Windows, not only an IME but also an on-screen keyboard relies on the
2416 // latest TextInputType to optimize its layout and functionality. Thus
2417 // |input_method_is_active_| is no longer an appropriate condition to suppress
2418 // TextInputTypeChanged IPC on Windows.
2419 // TODO(yukawa, yoichio): Consider to stop checking |input_method_is_active_|
2420 // on other platforms as well as Windows if the overhead is acceptable.
2421#if !defined(OS_WIN)
[email protected]cb9e2632013-06-18 11:26:472422 if (!input_method_is_active_)
2423 return;
[email protected]11f22bb62013-09-24 04:59:062424#endif
[email protected]cb9e2632013-06-18 11:26:472425
[email protected]e7c569d2013-07-17 16:00:362426 ui::TextInputType new_type = GetTextInputType();
[email protected]cb9e2632013-06-18 11:26:472427 if (IsDateTimeInput(new_type))
2428 return; // Not considered as a text input field in WebKit/Chromium.
2429
2430 bool new_can_compose_inline = CanComposeInline();
2431
[email protected]180ef242013-11-07 06:50:462432 blink::WebTextInputInfo new_info;
[email protected]e7c569d2013-07-17 16:00:362433 if (webwidget_)
2434 new_info = webwidget_->textInputInfo();
[email protected]b256eca2013-07-11 10:57:402435 const ui::TextInputMode new_mode = ConvertInputMode(new_info.inputMode);
2436
[email protected]cb9e2632013-06-18 11:26:472437 if (text_input_type_ != new_type
[email protected]b256eca2013-07-11 10:57:402438 || can_compose_inline_ != new_can_compose_inline
2439 || text_input_mode_ != new_mode) {
[email protected]cb9e2632013-06-18 11:26:472440 Send(new ViewHostMsg_TextInputTypeChanged(routing_id(),
2441 new_type,
[email protected]86ba5fcb2013-09-04 00:36:532442 new_mode,
2443 new_can_compose_inline));
[email protected]cb9e2632013-06-18 11:26:472444 text_input_type_ = new_type;
2445 can_compose_inline_ = new_can_compose_inline;
[email protected]b256eca2013-07-11 10:57:402446 text_input_mode_ = new_mode;
[email protected]cb9e2632013-06-18 11:26:472447 }
2448}
2449
2450#if defined(OS_ANDROID)
[email protected]0d1ebed12013-08-05 22:01:132451void RenderWidget::UpdateTextInputState(bool show_ime_if_needed,
2452 bool send_ime_ack) {
[email protected]e8f775f2013-02-14 21:00:502453 if (handling_ime_event_)
2454 return;
[email protected]3306f262012-09-21 19:20:422455 if (!show_ime_if_needed && !input_method_is_active_)
initial.commit09911bf2008-07-26 23:55:292456 return;
[email protected]ad26ef42011-06-17 07:59:452457 ui::TextInputType new_type = GetTextInputType();
[email protected]b18583c2012-12-18 06:55:272458 if (IsDateTimeInput(new_type))
2459 return; // Not considered as a text input field in WebKit/Chromium.
2460
[email protected]180ef242013-11-07 06:50:462461 blink::WebTextInputInfo new_info;
[email protected]5b739cb2012-08-21 20:35:212462 if (webwidget_)
2463 new_info = webwidget_->textInputInfo();
2464
[email protected]ad26ef42011-06-17 07:59:452465 bool new_can_compose_inline = CanComposeInline();
[email protected]5b739cb2012-08-21 20:35:212466
[email protected]3306f262012-09-21 19:20:422467 // Only sends text input params if they are changed or if the ime should be
2468 // shown.
2469 if (show_ime_if_needed || (text_input_type_ != new_type
2470 || text_input_info_ != new_info
2471 || can_compose_inline_ != new_can_compose_inline)) {
[email protected]5b739cb2012-08-21 20:35:212472 ViewHostMsg_TextInputState_Params p;
2473 p.type = new_type;
2474 p.value = new_info.value.utf8();
2475 p.selection_start = new_info.selectionStart;
2476 p.selection_end = new_info.selectionEnd;
2477 p.composition_start = new_info.compositionStart;
2478 p.composition_end = new_info.compositionEnd;
2479 p.can_compose_inline = new_can_compose_inline;
[email protected]3306f262012-09-21 19:20:422480 p.show_ime_if_needed = show_ime_if_needed;
[email protected]0d1ebed12013-08-05 22:01:132481 p.require_ack = send_ime_ack;
2482 if (p.require_ack)
2483 IncrementOutstandingImeEventAcks();
[email protected]5b739cb2012-08-21 20:35:212484 Send(new ViewHostMsg_TextInputStateChanged(routing_id(), p));
2485
2486 text_input_info_ = new_info;
[email protected]fa7b1dc2010-06-23 17:53:042487 text_input_type_ = new_type;
[email protected]ad26ef42011-06-17 07:59:452488 can_compose_inline_ = new_can_compose_inline;
initial.commit09911bf2008-07-26 23:55:292489 }
initial.commit09911bf2008-07-26 23:55:292490}
[email protected]cb9e2632013-06-18 11:26:472491#endif
initial.commit09911bf2008-07-26 23:55:292492
[email protected]7c8873e2013-02-05 08:03:012493void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
2494 WebRect focus_webrect;
2495 WebRect anchor_webrect;
2496 webwidget_->selectionBounds(focus_webrect, anchor_webrect);
2497 *focus = focus_webrect;
2498 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:322499}
2500
[email protected]e99ef6f2011-10-16 01:13:002501void RenderWidget::UpdateSelectionBounds() {
2502 if (!webwidget_)
2503 return;
[email protected]66fca5bc2013-05-23 06:58:292504 if (handling_ime_event_)
2505 return;
[email protected]e99ef6f2011-10-16 01:13:002506
[email protected]7c8873e2013-02-05 08:03:012507 ViewHostMsg_SelectionBounds_Params params;
2508 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
2509 if (selection_anchor_rect_ != params.anchor_rect ||
2510 selection_focus_rect_ != params.focus_rect) {
2511 selection_anchor_rect_ = params.anchor_rect;
2512 selection_focus_rect_ = params.focus_rect;
2513 webwidget_->selectionTextDirection(params.focus_dir, params.anchor_dir);
[email protected]129b7382013-02-12 02:14:292514 params.is_anchor_first = webwidget_->isSelectionAnchorFirst();
[email protected]7c8873e2013-02-05 08:03:012515 Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
[email protected]58b48a0d2012-06-13 07:01:352516 }
[email protected]501ea13d2013-07-09 17:03:292517#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362518 UpdateCompositionInfo(false);
[email protected]501ea13d2013-07-09 17:03:292519#endif
[email protected]e99ef6f2011-10-16 01:13:002520}
2521
[email protected]180ef242013-11-07 06:50:462522// Check blink::WebTextInputType and ui::TextInputType is kept in sync.
2523COMPILE_ASSERT(int(blink::WebTextInputTypeNone) == \
[email protected]ad26ef42011-06-17 07:59:452524 int(ui::TEXT_INPUT_TYPE_NONE), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462525COMPILE_ASSERT(int(blink::WebTextInputTypeText) == \
[email protected]ad26ef42011-06-17 07:59:452526 int(ui::TEXT_INPUT_TYPE_TEXT), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462527COMPILE_ASSERT(int(blink::WebTextInputTypePassword) == \
[email protected]ad26ef42011-06-17 07:59:452528 int(ui::TEXT_INPUT_TYPE_PASSWORD), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462529COMPILE_ASSERT(int(blink::WebTextInputTypeSearch) == \
[email protected]caf38ed2011-07-28 13:15:182530 int(ui::TEXT_INPUT_TYPE_SEARCH), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462531COMPILE_ASSERT(int(blink::WebTextInputTypeEmail) == \
[email protected]caf38ed2011-07-28 13:15:182532 int(ui::TEXT_INPUT_TYPE_EMAIL), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462533COMPILE_ASSERT(int(blink::WebTextInputTypeNumber) == \
[email protected]caf38ed2011-07-28 13:15:182534 int(ui::TEXT_INPUT_TYPE_NUMBER), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462535COMPILE_ASSERT(int(blink::WebTextInputTypeTelephone) == \
[email protected]caf38ed2011-07-28 13:15:182536 int(ui::TEXT_INPUT_TYPE_TELEPHONE), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462537COMPILE_ASSERT(int(blink::WebTextInputTypeURL) == \
[email protected]caf38ed2011-07-28 13:15:182538 int(ui::TEXT_INPUT_TYPE_URL), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462539COMPILE_ASSERT(int(blink::WebTextInputTypeDate) == \
[email protected]feb8cf752012-06-08 04:48:002540 int(ui::TEXT_INPUT_TYPE_DATE), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462541COMPILE_ASSERT(int(blink::WebTextInputTypeDateTime) == \
[email protected]feb8cf752012-06-08 04:48:002542 int(ui::TEXT_INPUT_TYPE_DATE_TIME), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462543COMPILE_ASSERT(int(blink::WebTextInputTypeDateTimeLocal) == \
[email protected]feb8cf752012-06-08 04:48:002544 int(ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462545COMPILE_ASSERT(int(blink::WebTextInputTypeMonth) == \
[email protected]feb8cf752012-06-08 04:48:002546 int(ui::TEXT_INPUT_TYPE_MONTH), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462547COMPILE_ASSERT(int(blink::WebTextInputTypeTime) == \
[email protected]feb8cf752012-06-08 04:48:002548 int(ui::TEXT_INPUT_TYPE_TIME), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462549COMPILE_ASSERT(int(blink::WebTextInputTypeWeek) == \
[email protected]feb8cf752012-06-08 04:48:002550 int(ui::TEXT_INPUT_TYPE_WEEK), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462551COMPILE_ASSERT(int(blink::WebTextInputTypeTextArea) == \
[email protected]2a9893672012-11-09 20:33:012552 int(ui::TEXT_INPUT_TYPE_TEXT_AREA), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462553COMPILE_ASSERT(int(blink::WebTextInputTypeContentEditable) == \
[email protected]2a9893672012-11-09 20:33:012554 int(ui::TEXT_INPUT_TYPE_CONTENT_EDITABLE), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462555COMPILE_ASSERT(int(blink::WebTextInputTypeDateTimeField) == \
[email protected]8b4992e2013-03-01 15:42:152556 int(ui::TEXT_INPUT_TYPE_DATE_TIME_FIELD), mismatching_enums);
[email protected]ad26ef42011-06-17 07:59:452557
[email protected]5b739cb2012-08-21 20:35:212558ui::TextInputType RenderWidget::WebKitToUiTextInputType(
[email protected]180ef242013-11-07 06:50:462559 blink::WebTextInputType type) {
[email protected]5b739cb2012-08-21 20:35:212560 // Check the type is in the range representable by ui::TextInputType.
2561 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX)) <<
[email protected]180ef242013-11-07 06:50:462562 "blink::WebTextInputType and ui::TextInputType not synchronized";
[email protected]5b739cb2012-08-21 20:35:212563 return static_cast<ui::TextInputType>(type);
2564}
2565
[email protected]ad26ef42011-06-17 07:59:452566ui::TextInputType RenderWidget::GetTextInputType() {
[email protected]8969bb3f2012-11-30 21:49:272567 if (webwidget_)
2568 return WebKitToUiTextInputType(webwidget_->textInputInfo().type);
[email protected]ad26ef42011-06-17 07:59:452569 return ui::TEXT_INPUT_TYPE_NONE;
2570}
2571
[email protected]501ea13d2013-07-09 17:03:292572#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
2573void RenderWidget::UpdateCompositionInfo(bool should_update_range) {
[email protected]db4fc1e2013-09-06 20:01:512574 gfx::Range range = gfx::Range();
[email protected]501ea13d2013-07-09 17:03:292575 if (should_update_range) {
2576 GetCompositionRange(&range);
2577 } else {
2578 range = composition_range_;
2579 }
2580 std::vector<gfx::Rect> character_bounds;
2581 GetCompositionCharacterBounds(&character_bounds);
2582
2583 if (!ShouldUpdateCompositionInfo(range, character_bounds))
2584 return;
2585 composition_character_bounds_ = character_bounds;
2586 composition_range_ = range;
2587 Send(new ViewHostMsg_ImeCompositionRangeChanged(
2588 routing_id(), composition_range_, composition_character_bounds_));
2589}
2590
[email protected]58b48a0d2012-06-13 07:01:352591void RenderWidget::GetCompositionCharacterBounds(
2592 std::vector<gfx::Rect>* bounds) {
2593 DCHECK(bounds);
2594 bounds->clear();
2595}
2596
[email protected]db4fc1e2013-09-06 20:01:512597void RenderWidget::GetCompositionRange(gfx::Range* range) {
[email protected]88dbe32f2013-06-20 23:31:362598 size_t location, length;
2599 if (webwidget_->compositionRange(&location, &length)) {
2600 range->set_start(location);
2601 range->set_end(location + length);
2602 } else if (webwidget_->caretOrSelectionRange(&location, &length)) {
2603 range->set_start(location);
2604 range->set_end(location + length);
2605 } else {
[email protected]db4fc1e2013-09-06 20:01:512606 *range = gfx::Range::InvalidRange();
[email protected]88dbe32f2013-06-20 23:31:362607 }
2608}
2609
[email protected]501ea13d2013-07-09 17:03:292610bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:512611 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:292612 const std::vector<gfx::Rect>& bounds) {
2613 if (composition_range_ != range)
2614 return true;
2615 if (bounds.size() != composition_character_bounds_.size())
2616 return true;
2617 for (size_t i = 0; i < bounds.size(); ++i) {
2618 if (bounds[i] != composition_character_bounds_[i])
2619 return true;
2620 }
2621 return false;
2622}
2623#endif
2624
[email protected]ad26ef42011-06-17 07:59:452625bool RenderWidget::CanComposeInline() {
2626 return true;
[email protected]56ea1a62011-05-30 07:05:572627}
2628
[email protected]4873c7d2009-07-16 06:36:282629WebScreenInfo RenderWidget::screenInfo() {
[email protected]842f10652012-06-06 01:54:042630 return screen_info_;
[email protected]4873c7d2009-07-16 06:36:282631}
2632
[email protected]f660d9c2012-06-06 18:31:212633float RenderWidget::deviceScaleFactor() {
2634 return device_scale_factor_;
2635}
2636
[email protected]fa7b1dc2010-06-23 17:53:042637void RenderWidget::resetInputMethod() {
2638 if (!input_method_is_active_)
2639 return;
2640
[email protected]0e45bd02013-07-12 20:20:022641 ImeEventGuard guard(this);
[email protected]fa7b1dc2010-06-23 17:53:042642 // If the last text input type is not None, then we should finish any
2643 // ongoing composition regardless of the new text input type.
[email protected]ad26ef42011-06-17 07:59:452644 if (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE) {
[email protected]fa7b1dc2010-06-23 17:53:042645 // If a composition text exists, then we need to let the browser process
2646 // to cancel the input method's ongoing composition session.
2647 if (webwidget_->confirmComposition())
2648 Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
2649 }
[email protected]d4cff272011-05-02 15:46:012650
[email protected]501ea13d2013-07-09 17:03:292651#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362652 UpdateCompositionInfo(true);
[email protected]501ea13d2013-07-09 17:03:292653#endif
[email protected]fa7b1dc2010-06-23 17:53:042654}
2655
[email protected]c68c3e4e2013-01-24 00:36:562656void RenderWidget::didHandleGestureEvent(
2657 const WebGestureEvent& event,
2658 bool event_cancelled) {
2659#if defined(OS_ANDROID)
2660 if (event_cancelled)
2661 return;
2662 if (event.type == WebInputEvent::GestureTap ||
2663 event.type == WebInputEvent::GestureLongPress) {
[email protected]0d1ebed12013-08-05 22:01:132664 UpdateTextInputState(true, true);
[email protected]c68c3e4e2013-01-24 00:36:562665 }
2666#endif
2667}
2668
[email protected]29e2fb42013-07-19 01:13:472669void RenderWidget::SchedulePluginMove(const WebPluginGeometry& move) {
initial.commit09911bf2008-07-26 23:55:292670 size_t i = 0;
2671 for (; i < plugin_window_moves_.size(); ++i) {
2672 if (plugin_window_moves_[i].window == move.window) {
[email protected]16f89d02009-08-26 17:17:582673 if (move.rects_valid) {
2674 plugin_window_moves_[i] = move;
2675 } else {
2676 plugin_window_moves_[i].visible = move.visible;
2677 }
initial.commit09911bf2008-07-26 23:55:292678 break;
2679 }
2680 }
2681
2682 if (i == plugin_window_moves_.size())
2683 plugin_window_moves_.push_back(move);
2684}
[email protected]268654772009-08-06 23:02:042685
2686void RenderWidget::CleanupWindowInPluginMoves(gfx::PluginWindowHandle window) {
2687 for (WebPluginGeometryVector::iterator i = plugin_window_moves_.begin();
2688 i != plugin_window_moves_.end(); ++i) {
2689 if (i->window == window) {
2690 plugin_window_moves_.erase(i);
2691 break;
2692 }
2693 }
2694}
[email protected]67bfb83f2011-09-22 03:36:372695
[email protected]b63d58d2012-11-26 22:37:442696void RenderWidget::GetRenderingStats(
[email protected]180ef242013-11-07 06:50:462697 blink::WebRenderingStatsImpl& stats) const {
[email protected]ba91a792013-02-06 09:48:282698 if (compositor_)
[email protected]635353c2013-03-06 09:11:202699 compositor_->GetRenderingStats(&stats.rendering_stats);
[email protected]b63d58d2012-11-26 22:37:442700
[email protected]c1e6cc062013-08-24 03:35:352701 stats.rendering_stats.Add(
2702 legacy_software_mode_stats_->GetRenderingStats());
[email protected]fef5e3972012-08-07 03:59:472703}
2704
[email protected]e9ff79c2012-10-19 21:31:262705bool RenderWidget::GetGpuRenderingStats(GpuRenderingStats* stats) const {
[email protected]63b465922012-09-06 02:04:522706 GpuChannelHost* gpu_channel = RenderThreadImpl::current()->GetGpuChannel();
2707 if (!gpu_channel)
2708 return false;
2709
2710 return gpu_channel->CollectRenderingStatsForSurface(surface_id(), stats);
2711}
2712
[email protected]24ed0432013-04-24 07:50:312713RenderWidgetCompositor* RenderWidget::compositor() const {
2714 return compositor_.get();
2715}
2716
[email protected]3639aa82013-06-04 11:00:042717void RenderWidget::OnSetBrowserRenderingStats(
2718 const BrowserRenderingStats& stats) {
2719 browser_rendering_stats_ = stats;
2720}
2721
2722void RenderWidget::GetBrowserRenderingStats(BrowserRenderingStats* stats) {
2723 *stats = browser_rendering_stats_;
2724}
2725
[email protected]0c2ebef2013-04-03 12:14:102726void RenderWidget::BeginSmoothScroll(
[email protected]0e241b4b2012-08-18 09:06:272727 bool down,
[email protected]79fa22e2013-08-23 15:18:122728 const SyntheticGestureCompletionCallback& callback,
[email protected]267909d2012-10-20 04:36:192729 int pixels_to_scroll,
[email protected]ebd8b562012-10-09 14:44:292730 int mouse_event_x,
2731 int mouse_event_y) {
[email protected]0e241b4b2012-08-18 09:06:272732 DCHECK(!callback.is_null());
[email protected]267909d2012-10-20 04:36:192733
2734 ViewHostMsg_BeginSmoothScroll_Params params;
2735 params.scroll_down = down;
2736 params.pixels_to_scroll = pixels_to_scroll;
2737 params.mouse_event_x = mouse_event_x;
2738 params.mouse_event_y = mouse_event_y;
2739
[email protected]4a9dba42013-04-29 18:24:222740 Send(new ViewHostMsg_BeginSmoothScroll(routing_id_, params));
[email protected]79fa22e2013-08-23 15:18:122741 pending_synthetic_gesture_ = callback;
[email protected]a39ca1652012-07-13 21:30:582742}
2743
[email protected]1e1dd182013-09-12 01:51:152744void RenderWidget::BeginPinch(
2745 bool zoom_in,
2746 int pixels_to_move,
2747 int anchor_x,
2748 int anchor_y,
2749 const SyntheticGestureCompletionCallback& callback) {
2750 DCHECK(!callback.is_null());
2751
2752 ViewHostMsg_BeginPinch_Params params;
2753 params.zoom_in = zoom_in;
2754 params.pixels_to_move = pixels_to_move;
2755 params.anchor_x = anchor_x;
2756 params.anchor_y = anchor_y;
2757
2758 Send(new ViewHostMsg_BeginPinch(routing_id_, params));
2759 pending_synthetic_gesture_ = callback;
2760}
2761
[email protected]180ef242013-11-07 06:50:462762bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
[email protected]67bfb83f2011-09-22 03:36:372763 return false;
2764}
[email protected]c3d45532011-10-07 19:20:402765
[email protected]180ef242013-11-07 06:50:462766bool RenderWidget::WillHandleKeyEvent(const blink::WebKeyboardEvent& event) {
[email protected]f56c7872013-06-18 12:31:572767 return false;
2768}
2769
[email protected]41d86852012-11-07 12:23:242770bool RenderWidget::WillHandleGestureEvent(
[email protected]180ef242013-11-07 06:50:462771 const blink::WebGestureEvent& event) {
[email protected]41d86852012-11-07 12:23:242772 return false;
2773}
2774
[email protected]ce6689f2013-03-29 12:52:552775void RenderWidget::hasTouchEventHandlers(bool has_handlers) {
2776 Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
2777}
2778
[email protected]3d5c243b2012-11-30 00:26:012779bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
2780 return true;
2781}
2782
[email protected]0634cdd42013-08-16 00:46:092783scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
2784RenderWidget::CreateGraphicsContext3D(
[email protected]180ef242013-11-07 06:50:462785 const blink::WebGraphicsContext3D::Attributes& attributes) {
[email protected]ed7defa2013-03-12 21:29:592786 if (!webwidget_)
[email protected]0634cdd42013-08-16 00:46:092787 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]ebc0e1df2013-08-01 02:46:222788 if (CommandLine::ForCurrentProcess()->HasSwitch(
2789 switches::kDisableGpuCompositing))
[email protected]0634cdd42013-08-16 00:46:092790 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]96ab016c2013-10-23 00:50:292791 if (!RenderThreadImpl::current())
2792 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]4d7e46a2013-11-08 05:33:402793 CauseForGpuLaunch cause =
2794 CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
[email protected]96ab016c2013-10-23 00:50:292795 scoped_refptr<GpuChannelHost> gpu_channel_host(
[email protected]4d7e46a2013-11-08 05:33:402796 RenderThreadImpl::current()->EstablishGpuChannelSync(cause));
[email protected]96ab016c2013-10-23 00:50:292797 if (!gpu_channel_host)
2798 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]ed7defa2013-03-12 21:29:592799
[email protected]96ab016c2013-10-23 00:50:292800 WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits limits;
[email protected]b6eb8e332013-09-10 00:51:012801#if defined(OS_ANDROID)
2802 // If we raster too fast we become upload bound, and pending
2803 // uploads consume memory. For maximum upload throughput, we would
2804 // want to allow for upload_throughput * pipeline_time of pending
2805 // uploads, after which we are just wasting memory. Since we don't
2806 // know our upload throughput yet, this just caps our memory usage.
2807 size_t divider = 1;
2808 if (base::android::SysUtils::IsLowEndDevice())
[email protected]657be322013-09-20 08:50:032809 divider = 6;
[email protected]b6eb8e332013-09-10 00:51:012810 // For reference Nexus10 can upload 1MB in about 2.5ms.
[email protected]657be322013-09-20 08:50:032811 const double max_mb_uploaded_per_ms = 2.0 / (5 * divider);
[email protected]b6eb8e332013-09-10 00:51:012812 // Deadline to draw a frame to achieve 60 frames per second.
2813 const size_t kMillisecondsPerFrame = 16;
2814 // Assuming a two frame deep pipeline between the CPU and the GPU.
[email protected]657be322013-09-20 08:50:032815 size_t max_transfer_buffer_usage_mb =
2816 static_cast<size_t>(2 * kMillisecondsPerFrame * max_mb_uploaded_per_ms);
2817 static const size_t kBytesPerMegabyte = 1024 * 1024;
[email protected]b6eb8e332013-09-10 00:51:012818 // We keep the MappedMemoryReclaimLimit the same as the upload limit
2819 // to avoid unnecessarily stalling the compositor thread.
[email protected]96ab016c2013-10-23 00:50:292820 limits.mapped_memory_reclaim_limit =
[email protected]657be322013-09-20 08:50:032821 max_transfer_buffer_usage_mb * kBytesPerMegabyte;
[email protected]b6eb8e332013-09-10 00:51:012822#endif
[email protected]96ab016c2013-10-23 00:50:292823
[email protected]fbe382a2013-11-06 22:45:412824 bool use_echo_for_swap_ack = true;
2825 if (!is_threaded_compositing_enabled_) {
[email protected]fbe382a2013-11-06 22:45:412826#if (defined(OS_MACOSX) || defined(OS_WIN)) && !defined(USE_AURA)
2827 // ViewMsg_SwapBuffers_ACK is used instead for single-threaded path.
2828 use_echo_for_swap_ack = false;
2829#endif
2830 }
[email protected]96ab016c2013-10-23 00:50:292831
2832 scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
2833 new WebGraphicsContext3DCommandBufferImpl(
2834 surface_id(),
2835 GetURLForGraphicsContext3D(),
2836 gpu_channel_host.get(),
[email protected]fbe382a2013-11-06 22:45:412837 use_echo_for_swap_ack,
[email protected]8f746982013-03-21 06:28:032838 attributes,
2839 false /* bind generates resources */,
[email protected]96ab016c2013-10-23 00:50:292840 limits));
[email protected]0634cdd42013-08-16 00:46:092841 return context.Pass();
[email protected]ed7defa2013-03-12 21:29:592842}
2843
[email protected]e9ff79c2012-10-19 21:31:262844} // namespace content