blob: 21f19c262c5ba3c72aad53945d6d370b738790c7 [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"
[email protected]b2e92592014-01-10 15:47:1510#include "base/debug/trace_event_synthetic_delay.h"
initial.commit09911bf2008-07-26 23:55:2911#include "base/logging.h"
[email protected]3b63f8f42011-03-28 01:54:1512#include "base/memory/scoped_ptr.h"
[email protected]b256eca2013-07-11 10:57:4013#include "base/memory/singleton.h"
[email protected]aaf68892013-07-18 00:11:3014#include "base/message_loop/message_loop.h"
[email protected]835d7c82010-10-14 04:38:3815#include "base/metrics/histogram.h"
[email protected]aa4117f2011-12-09 22:19:2116#include "base/stl_util.h"
[email protected]74ebfb12013-06-07 20:48:0017#include "base/strings/utf_string_conversions.h"
[email protected]661eb9d2009-02-03 02:11:4818#include "build/build_config.h"
[email protected]681ccff2013-03-18 06:13:5219#include "cc/base/switches.h"
[email protected]adbe30f2013-10-11 21:12:3320#include "cc/debug/benchmark_instrumentation.h"
[email protected]7f0d825f2013-03-18 07:24:3021#include "cc/output/output_surface.h"
[email protected]556fd292013-03-18 08:03:0422#include "cc/trees/layer_tree_host.h"
[email protected]29e2fb42013-07-19 01:13:4723#include "content/child/npapi/webplugin.h"
[email protected]0634cdd42013-08-16 00:46:0924#include "content/common/gpu/client/context_provider_command_buffer.h"
[email protected]ed7defa2013-03-12 21:29:5925#include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
[email protected]96ab016c2013-10-23 00:50:2926#include "content/common/gpu/gpu_process_launch_causes.h"
[email protected]9017d7852013-11-21 17:47:3527#include "content/common/input/synthetic_gesture_packet.h"
[email protected]8e299aa2013-10-16 18:17:4428#include "content/common/input/web_input_event_traits.h"
[email protected]c084330e02013-04-27 01:08:1529#include "content/common/input_messages.h"
[email protected]992db4c2011-05-12 15:37:1530#include "content/common/swapped_out_messages.h"
[email protected]778574e2011-03-21 22:03:5031#include "content/common/view_messages.h"
[email protected]c08950d22011-10-13 22:20:2932#include "content/public/common/content_switches.h"
[email protected]a09d53ce2014-01-31 00:46:4233#include "content/public/common/context_menu_params.h"
[email protected]953bd0062013-08-01 00:58:4034#include "content/renderer/cursor_utils.h"
[email protected]b2e4c70132013-10-03 02:07:5135#include "content/renderer/external_popup_menu.h"
[email protected]ed7defa2013-03-12 21:29:5936#include "content/renderer/gpu/compositor_output_surface.h"
[email protected]2847b222013-04-06 00:59:2437#include "content/renderer/gpu/compositor_software_output_device.h"
[email protected]36e5ff12013-06-11 12:19:2938#include "content/renderer/gpu/delegated_compositor_output_surface.h"
[email protected]ed7defa2013-03-12 21:29:5939#include "content/renderer/gpu/mailbox_output_surface.h"
[email protected]ba91a792013-02-06 09:48:2840#include "content/renderer/gpu/render_widget_compositor.h"
[email protected]66fca5bc2013-05-23 06:58:2941#include "content/renderer/ime_event_guard.h"
[email protected]7a72d452013-12-13 10:01:1342#include "content/renderer/input/input_handler_manager.h"
[email protected]adab2332013-07-25 18:04:3243#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
[email protected]bffc8302014-01-23 20:52:1644#include "content/renderer/render_frame_impl.h"
[email protected]8704f89b2011-04-15 00:30:0545#include "content/renderer/render_process.h"
[email protected]f1a29a02011-10-06 23:08:4446#include "content/renderer/render_thread_impl.h"
[email protected]8d6cba42011-09-02 10:05:1947#include "content/renderer/renderer_webkitplatformsupport_impl.h"
[email protected]5b45ad42013-10-25 00:42:0448#include "content/renderer/resizing_mode_selector.h"
[email protected]484955942010-08-19 16:13:1849#include "ipc/ipc_sync_message.h"
[email protected]661eb9d2009-02-03 02:11:4850#include "skia/ext/platform_canvas.h"
[email protected]ec173b522013-11-14 11:01:1851#include "third_party/WebKit/public/platform/WebCursorInfo.h"
[email protected]aaf68892013-07-18 00:11:3052#include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
[email protected]aaf68892013-07-18 00:11:3053#include "third_party/WebKit/public/platform/WebRect.h"
[email protected]ec173b522013-11-14 11:01:1854#include "third_party/WebKit/public/platform/WebScreenInfo.h"
[email protected]aaf68892013-07-18 00:11:3055#include "third_party/WebKit/public/platform/WebSize.h"
56#include "third_party/WebKit/public/platform/WebString.h"
[email protected]2255a9332013-06-17 05:12:3157#include "third_party/WebKit/public/web/WebPagePopup.h"
58#include "third_party/WebKit/public/web/WebPopupMenu.h"
59#include "third_party/WebKit/public/web/WebPopupMenuInfo.h"
60#include "third_party/WebKit/public/web/WebRange.h"
[email protected]d353541f2012-05-03 22:45:4161#include "third_party/skia/include/core/SkShader.h"
[email protected]faec7b12012-06-19 14:42:1362#include "ui/base/ui_base_switches.h"
[email protected]de2cf8c2013-10-25 19:46:4663#include "ui/gfx/frame_time.h"
[email protected]9c769d412014-03-20 18:27:3964#include "ui/gfx/point_conversions.h"
[email protected]a25e25b2012-09-28 14:32:3765#include "ui/gfx/rect_conversions.h"
[email protected]4b01b962012-10-09 23:17:3566#include "ui/gfx/size_conversions.h"
[email protected]1835b9e2012-02-28 13:12:4867#include "ui/gfx/skia_util.h"
[email protected]c9e2cbbb2012-05-12 21:17:2768#include "ui/gl/gl_switches.h"
[email protected]d353541f2012-05-03 22:45:4169#include "ui/surface/transport_dib.h"
[email protected]661eb9d2009-02-03 02:11:4870
[email protected]eeb93112013-05-01 19:41:1071#if defined(OS_ANDROID)
[email protected]cefe9b152014-03-27 18:16:1572#include <android/keycodes.h>
[email protected]b6eb8e332013-09-10 00:51:0173#include "base/android/sys_utils.h"
[email protected]913d99a2013-05-31 07:16:0774#include "content/renderer/android/synchronous_compositor_factory.h"
[email protected]eeb93112013-05-01 19:41:1075#endif
76
[email protected]661eb9d2009-02-03 02:11:4877#if defined(OS_POSIX)
[email protected]6b889fb2010-03-23 20:09:4978#include "ipc/ipc_channel_posix.h"
[email protected]d5282e72009-05-13 13:16:5279#include "third_party/skia/include/core/SkMallocPixelRef.h"
[email protected]d353541f2012-05-03 22:45:4180#include "third_party/skia/include/core/SkPixelRef.h"
[email protected]661eb9d2009-02-03 02:11:4881#endif // defined(OS_POSIX)
[email protected]8085dbc82008-09-26 22:53:4482
[email protected]2255a9332013-06-17 05:12:3183#include "third_party/WebKit/public/web/WebWidget.h"
initial.commit09911bf2008-07-26 23:55:2984
[email protected]180ef242013-11-07 06:50:4685using blink::WebCompositionUnderline;
86using blink::WebCursorInfo;
87using blink::WebGestureEvent;
88using blink::WebInputEvent;
89using blink::WebKeyboardEvent;
90using blink::WebMouseEvent;
91using blink::WebMouseWheelEvent;
92using blink::WebNavigationPolicy;
93using blink::WebPagePopup;
94using blink::WebPopupMenu;
95using blink::WebPopupMenuInfo;
96using blink::WebPopupType;
97using blink::WebRange;
98using blink::WebRect;
99using blink::WebScreenInfo;
100using blink::WebSize;
101using blink::WebTextDirection;
102using blink::WebTouchEvent;
[email protected]f8ed4722013-12-03 03:27:25103using blink::WebTouchPoint;
[email protected]180ef242013-11-07 06:50:46104using blink::WebVector;
105using blink::WebWidget;
[email protected]e9ff79c2012-10-19 21:31:26106
[email protected]6a4d7f62013-01-07 21:32:13107namespace {
[email protected]b256eca2013-07-11 10:57:40108
109typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
110
111class TextInputModeMapSingleton {
112 public:
113 static TextInputModeMapSingleton* GetInstance() {
114 return Singleton<TextInputModeMapSingleton>::get();
115 }
[email protected]dd705d4d2013-11-27 08:14:41116 TextInputModeMapSingleton() {
117 map_["verbatim"] = ui::TEXT_INPUT_MODE_VERBATIM;
118 map_["latin"] = ui::TEXT_INPUT_MODE_LATIN;
119 map_["latin-name"] = ui::TEXT_INPUT_MODE_LATIN_NAME;
120 map_["latin-prose"] = ui::TEXT_INPUT_MODE_LATIN_PROSE;
121 map_["full-width-latin"] = ui::TEXT_INPUT_MODE_FULL_WIDTH_LATIN;
122 map_["kana"] = ui::TEXT_INPUT_MODE_KANA;
123 map_["katakana"] = ui::TEXT_INPUT_MODE_KATAKANA;
124 map_["numeric"] = ui::TEXT_INPUT_MODE_NUMERIC;
125 map_["tel"] = ui::TEXT_INPUT_MODE_TEL;
126 map_["email"] = ui::TEXT_INPUT_MODE_EMAIL;
127 map_["url"] = ui::TEXT_INPUT_MODE_URL;
[email protected]b256eca2013-07-11 10:57:40128 }
[email protected]dd705d4d2013-11-27 08:14:41129 const TextInputModeMap& map() const { return map_; }
[email protected]b256eca2013-07-11 10:57:40130 private:
[email protected]dd705d4d2013-11-27 08:14:41131 TextInputModeMap map_;
[email protected]b256eca2013-07-11 10:57:40132
133 friend struct DefaultSingletonTraits<TextInputModeMapSingleton>;
134
135 DISALLOW_COPY_AND_ASSIGN(TextInputModeMapSingleton);
136};
137
[email protected]dd705d4d2013-11-27 08:14:41138ui::TextInputMode ConvertInputMode(const blink::WebString& input_mode) {
[email protected]b256eca2013-07-11 10:57:40139 static TextInputModeMapSingleton* singleton =
140 TextInputModeMapSingleton::GetInstance();
[email protected]dd705d4d2013-11-27 08:14:41141 TextInputModeMap::const_iterator it =
142 singleton->map().find(input_mode.utf8());
143 if (it == singleton->map().end())
[email protected]b256eca2013-07-11 10:57:40144 return ui::TEXT_INPUT_MODE_DEFAULT;
145 return it->second;
[email protected]6a4d7f62013-01-07 21:32:13146}
[email protected]b256eca2013-07-11 10:57:40147
[email protected]fd847792013-10-24 17:12:35148// TODO(brianderson): Replace the hard-coded threshold with a fraction of
149// the BeginMainFrame interval.
150// 4166us will allow 1/4 of a 60Hz interval or 1/2 of a 120Hz interval to
151// be spent in input hanlders before input starts getting throttled.
152const int kInputHandlingTimeThrottlingThresholdMicroseconds = 4166;
153
[email protected]b256eca2013-07-11 10:57:40154} // namespace
155
[email protected]e9ff79c2012-10-19 21:31:26156namespace content {
[email protected]62cb33cae2009-03-27 23:30:22157
[email protected]b2e4c70132013-10-03 02:07:51158// RenderWidget::ScreenMetricsEmulator ----------------------------------------
159
160class RenderWidget::ScreenMetricsEmulator {
161 public:
162 ScreenMetricsEmulator(
163 RenderWidget* widget,
[email protected]7f99fc22013-11-08 14:05:58164 const gfx::Rect& device_rect,
[email protected]b2e4c70132013-10-03 02:07:51165 const gfx::Rect& widget_rect,
166 float device_scale_factor,
167 bool fit_to_view);
168 virtual ~ScreenMetricsEmulator();
169
170 float scale() { return scale_; }
[email protected]9a2d7ee32013-12-05 12:15:49171 gfx::Point offset() { return offset_; }
[email protected]b2e4c70132013-10-03 02:07:51172 gfx::Rect widget_rect() const { return widget_rect_; }
173 gfx::Rect original_screen_rect() const { return original_view_screen_rect_; }
[email protected]5f75aa42014-04-01 23:00:56174 const WebScreenInfo& original_screen_info() { return original_screen_info_; }
[email protected]b2e4c70132013-10-03 02:07:51175
176 void ChangeEmulationParams(
[email protected]7f99fc22013-11-08 14:05:58177 const gfx::Rect& device_rect,
[email protected]b2e4c70132013-10-03 02:07:51178 const gfx::Rect& widget_rect,
179 float device_scale_factor,
180 bool fit_to_view);
181
182 // The following methods alter handlers' behavior for messages related to
183 // widget size and position.
184 void OnResizeMessage(const ViewMsg_Resize_Params& params);
185 void OnUpdateScreenRectsMessage(const gfx::Rect& view_screen_rect,
186 const gfx::Rect& window_screen_rect);
187 void OnShowContextMenu(ContextMenuParams* params);
188
189 private:
[email protected]7f0e8fa2014-03-26 12:32:01190 void CalculateScaleAndOffset();
[email protected]b2e4c70132013-10-03 02:07:51191 void Apply(float overdraw_bottom_height,
192 gfx::Rect resizer_rect, bool is_fullscreen);
193
194 RenderWidget* widget_;
195
[email protected]7f99fc22013-11-08 14:05:58196 // Parameters as passed by RenderWidget::EnableScreenMetricsEmulation.
197 gfx::Rect device_rect_;
[email protected]b2e4c70132013-10-03 02:07:51198 gfx::Rect widget_rect_;
199 float device_scale_factor_;
200 bool fit_to_view_;
201
[email protected]a179d3962013-11-12 14:44:40202 // The computed scale and offset used to fit widget into browser window.
[email protected]b2e4c70132013-10-03 02:07:51203 float scale_;
[email protected]a179d3962013-11-12 14:44:40204 gfx::Point offset_;
[email protected]b2e4c70132013-10-03 02:07:51205
206 // Original values to restore back after emulation ends.
207 gfx::Size original_size_;
208 gfx::Size original_physical_backing_size_;
[email protected]180ef242013-11-07 06:50:46209 blink::WebScreenInfo original_screen_info_;
[email protected]b2e4c70132013-10-03 02:07:51210 gfx::Rect original_view_screen_rect_;
211 gfx::Rect original_window_screen_rect_;
212};
213
214RenderWidget::ScreenMetricsEmulator::ScreenMetricsEmulator(
215 RenderWidget* widget,
[email protected]7f99fc22013-11-08 14:05:58216 const gfx::Rect& device_rect,
[email protected]b2e4c70132013-10-03 02:07:51217 const gfx::Rect& widget_rect,
218 float device_scale_factor,
219 bool fit_to_view)
220 : widget_(widget),
[email protected]7f99fc22013-11-08 14:05:58221 device_rect_(device_rect),
[email protected]b2e4c70132013-10-03 02:07:51222 widget_rect_(widget_rect),
223 device_scale_factor_(device_scale_factor),
224 fit_to_view_(fit_to_view),
225 scale_(1.f) {
226 original_size_ = widget_->size_;
227 original_physical_backing_size_ = widget_->physical_backing_size_;
228 original_screen_info_ = widget_->screen_info_;
229 original_view_screen_rect_ = widget_->view_screen_rect_;
230 original_window_screen_rect_ = widget_->window_screen_rect_;
231 Apply(widget_->overdraw_bottom_height_,
232 widget_->resizer_rect_, widget_->is_fullscreen_);
233}
234
235RenderWidget::ScreenMetricsEmulator::~ScreenMetricsEmulator() {
236 widget_->screen_info_ = original_screen_info_;
237
238 widget_->SetDeviceScaleFactor(original_screen_info_.deviceScaleFactor);
[email protected]7f99fc22013-11-08 14:05:58239 widget_->SetScreenMetricsEmulationParameters(0.f, gfx::Point(), 1.f);
[email protected]b2e4c70132013-10-03 02:07:51240 widget_->view_screen_rect_ = original_view_screen_rect_;
241 widget_->window_screen_rect_ = original_window_screen_rect_;
242 widget_->Resize(original_size_, original_physical_backing_size_,
243 widget_->overdraw_bottom_height_, widget_->resizer_rect_,
244 widget_->is_fullscreen_, NO_RESIZE_ACK);
245}
246
247void RenderWidget::ScreenMetricsEmulator::ChangeEmulationParams(
[email protected]7f99fc22013-11-08 14:05:58248 const gfx::Rect& device_rect,
[email protected]b2e4c70132013-10-03 02:07:51249 const gfx::Rect& widget_rect,
250 float device_scale_factor,
251 bool fit_to_view) {
[email protected]7f99fc22013-11-08 14:05:58252 device_rect_ = device_rect;
[email protected]b2e4c70132013-10-03 02:07:51253 widget_rect_ = widget_rect;
254 device_scale_factor_ = device_scale_factor;
255 fit_to_view_ = fit_to_view;
256 Apply(widget_->overdraw_bottom_height_,
257 widget_->resizer_rect_, widget_->is_fullscreen_);
258}
259
[email protected]7f0e8fa2014-03-26 12:32:01260void RenderWidget::ScreenMetricsEmulator::CalculateScaleAndOffset() {
[email protected]b2e4c70132013-10-03 02:07:51261 if (fit_to_view_) {
262 DCHECK(!original_size_.IsEmpty());
[email protected]4328f3c2013-11-02 02:26:23263
[email protected]4328f3c2013-11-02 02:26:23264 int width_with_gutter =
[email protected]7f99fc22013-11-08 14:05:58265 std::max(original_size_.width() - 2 * device_rect_.x(), 1);
[email protected]4328f3c2013-11-02 02:26:23266 int height_with_gutter =
[email protected]7f99fc22013-11-08 14:05:58267 std::max(original_size_.height() - 2 * device_rect_.y(), 1);
[email protected]b2e4c70132013-10-03 02:07:51268 float width_ratio =
[email protected]4328f3c2013-11-02 02:26:23269 static_cast<float>(widget_rect_.width()) / width_with_gutter;
[email protected]b2e4c70132013-10-03 02:07:51270 float height_ratio =
[email protected]4328f3c2013-11-02 02:26:23271 static_cast<float>(widget_rect_.height()) / height_with_gutter;
[email protected]b2e4c70132013-10-03 02:07:51272 float ratio = std::max(1.0f, std::max(width_ratio, height_ratio));
273 scale_ = 1.f / ratio;
[email protected]7f0e8fa2014-03-26 12:32:01274
275 // Center emulated view inside available view space.
276 offset_.set_x((original_size_.width() - scale_ * widget_rect_.width()) / 2);
277 offset_.set_y(
278 (original_size_.height() - scale_ * widget_rect_.height()) / 2);
[email protected]b2e4c70132013-10-03 02:07:51279 } else {
280 scale_ = 1.f;
[email protected]7f0e8fa2014-03-26 12:32:01281 offset_.SetPoint(0, 0);
282 }
283}
284
285void RenderWidget::ScreenMetricsEmulator::Apply(
286 float overdraw_bottom_height, gfx::Rect resizer_rect, bool is_fullscreen) {
287 gfx::Rect applied_widget_rect = widget_rect_;
288 if (widget_rect_.size().IsEmpty()) {
289 scale_ = 1.f;
290 offset_.SetPoint(0, 0);
291 applied_widget_rect =
292 gfx::Rect(original_view_screen_rect_.origin(), original_size_);
293 } else {
294 CalculateScaleAndOffset();
[email protected]b2e4c70132013-10-03 02:07:51295 }
296
[email protected]7f0e8fa2014-03-26 12:32:01297 if (device_rect_.size().IsEmpty()) {
298 widget_->screen_info_.rect = original_screen_info_.rect;
299 widget_->screen_info_.availableRect = original_screen_info_.availableRect;
300 widget_->window_screen_rect_ = original_window_screen_rect_;
301 } else {
302 widget_->screen_info_.rect = gfx::Rect(device_rect_.size());
303 widget_->screen_info_.availableRect = gfx::Rect(device_rect_.size());
304 widget_->window_screen_rect_ = widget_->screen_info_.availableRect;
305 }
[email protected]a179d3962013-11-12 14:44:40306
[email protected]7f0e8fa2014-03-26 12:32:01307 float applied_device_scale_factor = device_scale_factor_ ?
308 device_scale_factor_ : original_screen_info_.deviceScaleFactor;
309 widget_->screen_info_.deviceScaleFactor = applied_device_scale_factor;
[email protected]b2e4c70132013-10-03 02:07:51310
[email protected]7f99fc22013-11-08 14:05:58311 // Pass three emulation parameters to the blink side:
[email protected]b2e4c70132013-10-03 02:07:51312 // - we keep the real device scale factor in compositor to produce sharp image
313 // even when emulating different scale factor;
[email protected]7f99fc22013-11-08 14:05:58314 // - in order to fit into view, WebView applies offset and scale to the
[email protected]b2e4c70132013-10-03 02:07:51315 // root layer.
316 widget_->SetScreenMetricsEmulationParameters(
[email protected]a179d3962013-11-12 14:44:40317 original_screen_info_.deviceScaleFactor, offset_, scale_);
[email protected]b2e4c70132013-10-03 02:07:51318
[email protected]7f0e8fa2014-03-26 12:32:01319 widget_->SetDeviceScaleFactor(applied_device_scale_factor);
320 widget_->view_screen_rect_ = applied_widget_rect;
[email protected]b2e4c70132013-10-03 02:07:51321
322 gfx::Size physical_backing_size = gfx::ToCeiledSize(gfx::ScaleSize(
323 original_size_, original_screen_info_.deviceScaleFactor));
[email protected]7f0e8fa2014-03-26 12:32:01324 widget_->Resize(applied_widget_rect.size(), physical_backing_size,
[email protected]b2e4c70132013-10-03 02:07:51325 overdraw_bottom_height, resizer_rect, is_fullscreen, NO_RESIZE_ACK);
326}
327
328void RenderWidget::ScreenMetricsEmulator::OnResizeMessage(
329 const ViewMsg_Resize_Params& params) {
330 bool need_ack = params.new_size != original_size_ &&
331 !params.new_size.IsEmpty() && !params.physical_backing_size.IsEmpty();
332 original_size_ = params.new_size;
333 original_physical_backing_size_ = params.physical_backing_size;
334 original_screen_info_ = params.screen_info;
335 Apply(params.overdraw_bottom_height, params.resizer_rect,
336 params.is_fullscreen);
337
338 if (need_ack) {
339 widget_->set_next_paint_is_resize_ack();
340 if (widget_->compositor_)
341 widget_->compositor_->SetNeedsRedrawRect(gfx::Rect(widget_->size_));
342 }
343}
344
345void RenderWidget::ScreenMetricsEmulator::OnUpdateScreenRectsMessage(
346 const gfx::Rect& view_screen_rect,
347 const gfx::Rect& window_screen_rect) {
348 original_view_screen_rect_ = view_screen_rect;
349 original_window_screen_rect_ = window_screen_rect;
[email protected]7f0e8fa2014-03-26 12:32:01350 if (device_rect_.size().IsEmpty())
351 widget_->window_screen_rect_ = window_screen_rect;
352 if (widget_rect_.size().IsEmpty())
353 widget_->view_screen_rect_ = view_screen_rect;
[email protected]b2e4c70132013-10-03 02:07:51354}
355
356void RenderWidget::ScreenMetricsEmulator::OnShowContextMenu(
357 ContextMenuParams* params) {
358 params->x *= scale_;
[email protected]a179d3962013-11-12 14:44:40359 params->x += offset_.x();
[email protected]b2e4c70132013-10-03 02:07:51360 params->y *= scale_;
[email protected]a179d3962013-11-12 14:44:40361 params->y += offset_.y();
[email protected]b2e4c70132013-10-03 02:07:51362}
363
364// RenderWidget ---------------------------------------------------------------
365
[email protected]180ef242013-11-07 06:50:46366RenderWidget::RenderWidget(blink::WebPopupType popup_type,
367 const blink::WebScreenInfo& screen_info,
[email protected]1ac10dca2013-08-20 20:47:04368 bool swapped_out,
369 bool hidden)
initial.commit09911bf2008-07-26 23:55:29370 : routing_id_(MSG_ROUTING_NONE),
[email protected]9f4f3322012-01-18 22:29:56371 surface_id_(0),
[email protected]c5b3b5e2009-02-13 06:41:11372 webwidget_(NULL),
initial.commit09911bf2008-07-26 23:55:29373 opener_id_(MSG_ROUTING_NONE),
[email protected]fc4404d2012-11-07 19:53:30374 init_complete_(false),
[email protected]b4d08452010-10-05 17:34:35375 current_paint_buf_(NULL),
[email protected]d9083762013-03-24 01:36:40376 overdraw_bottom_height_(0.f),
initial.commit09911bf2008-07-26 23:55:29377 next_paint_flags_(0),
[email protected]0cff69e2011-11-22 22:26:06378 filtered_time_per_frame_(0.0f),
[email protected]53d3f302009-12-21 04:42:05379 update_reply_pending_(false),
[email protected]847a2582013-03-09 02:29:51380 auto_resize_mode_(false),
[email protected]ea3ee0a2012-05-15 03:43:09381 need_update_rect_for_auto_resize_(false),
[email protected]65225772011-05-12 21:10:24382 using_asynchronous_swapbuffers_(false),
383 num_swapbuffers_complete_pending_(0),
initial.commit09911bf2008-07-26 23:55:29384 did_show_(false),
[email protected]1ac10dca2013-08-20 20:47:04385 is_hidden_(hidden),
[email protected]ee41e7d22011-10-14 19:34:09386 is_fullscreen_(false),
initial.commit09911bf2008-07-26 23:55:29387 needs_repainting_on_restore_(false),
388 has_focus_(false),
[email protected]5dd768212009-08-13 23:34:49389 handling_input_event_(false),
[email protected]e8f775f2013-02-14 21:00:50390 handling_ime_event_(false),
[email protected]5d0bbdfa92013-12-10 00:35:51391 handling_touchstart_event_(false),
[email protected]661eb9d2009-02-03 02:11:48392 closing_(false),
[email protected]14392a52012-05-02 20:28:44393 is_swapped_out_(swapped_out),
[email protected]fa7b1dc2010-06-23 17:53:04394 input_method_is_active_(false),
[email protected]ad26ef42011-06-17 07:59:45395 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
[email protected]b256eca2013-07-11 10:57:40396 text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
[email protected]86ba5fcb2013-09-04 00:36:53397 can_compose_inline_(true),
[email protected]3e2b375b2010-04-07 17:03:12398 popup_type_(popup_type),
[email protected]867125a02009-12-10 06:01:48399 pending_window_rect_count_(0),
[email protected]b68a0e52011-12-08 15:11:12400 suppress_next_char_events_(false),
[email protected]5f8b1022011-01-21 23:34:50401 is_accelerated_compositing_active_(false),
[email protected]d8a6c5d12013-09-23 04:37:10402 was_accelerated_compositing_ever_active_(false),
[email protected]ee3d3ad2011-02-04 00:42:21403 animation_update_pending_(false),
[email protected]4b03e292012-02-13 18:40:07404 invalidation_task_posted_(false),
[email protected]842f10652012-06-06 01:54:04405 screen_info_(screen_info),
[email protected]3d779472012-11-15 20:49:52406 device_scale_factor_(screen_info_.deviceScaleFactor),
[email protected]ed7defa2013-03-12 21:29:59407 is_threaded_compositing_enabled_(false),
[email protected]53b4cc12013-07-18 23:02:30408 next_output_surface_id_(0),
[email protected]0d1ebed12013-08-05 22:01:13409#if defined(OS_ANDROID)
410 outstanding_ime_acks_(0),
411#endif
[email protected]b2e4c70132013-10-03 02:07:51412 popup_origin_scale_for_emulation_(0.f),
[email protected]a09d53ce2014-01-31 00:46:42413 resizing_mode_selector_(new ResizingModeSelector()),
414 context_menu_source_type_(ui::MENU_SOURCE_MOUSE) {
[email protected]8b3f0eb2012-05-03 19:15:05415 if (!swapped_out)
416 RenderProcess::current()->AddRefProcess();
[email protected]380244092011-10-07 17:26:27417 DCHECK(RenderThread::Get());
[email protected]bd37ae252011-06-03 01:28:18418 has_disable_gpu_vsync_switch_ = CommandLine::ForCurrentProcess()->HasSwitch(
419 switches::kDisableGpuVsync);
[email protected]cb6430932012-10-31 00:53:36420 is_threaded_compositing_enabled_ =
421 CommandLine::ForCurrentProcess()->HasSwitch(
422 switches::kEnableThreadedCompositing);
[email protected]c1e6cc062013-08-24 03:35:35423
424 legacy_software_mode_stats_ = cc::RenderingStatsInstrumentation::Create();
425 if (CommandLine::ForCurrentProcess()->HasSwitch(
[email protected]fe3beef2014-02-06 09:20:53426 cc::switches::kEnableGpuBenchmarking))
[email protected]c1e6cc062013-08-24 03:35:35427 legacy_software_mode_stats_->set_record_rendering_stats(true);
initial.commit09911bf2008-07-26 23:55:29428}
429
430RenderWidget::~RenderWidget() {
[email protected]c5b3b5e2009-02-13 06:41:11431 DCHECK(!webwidget_) << "Leaking our WebWidget!";
[email protected]aa4117f2011-12-09 22:19:21432 STLDeleteElements(&updates_pending_swap_);
[email protected]b4d08452010-10-05 17:34:35433 if (current_paint_buf_) {
[email protected]467414eb2013-07-30 20:32:29434 if (RenderProcess::current()) {
435 // If the RenderProcess is already gone, it will have released all DIBs
436 // in its destructor anyway.
437 RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
438 }
[email protected]b4d08452010-10-05 17:34:35439 current_paint_buf_ = NULL;
initial.commit09911bf2008-07-26 23:55:29440 }
[email protected]bffc8302014-01-23 20:52:16441
[email protected]992db4c2011-05-12 15:37:15442 // If we are swapped out, we have released already.
[email protected]d2e2f9ee2013-08-21 11:02:02443 if (!is_swapped_out_ && RenderProcess::current())
[email protected]992db4c2011-05-12 15:37:15444 RenderProcess::current()->ReleaseProcess();
initial.commit09911bf2008-07-26 23:55:29445}
446
[email protected]484955942010-08-19 16:13:18447// static
[email protected]8085dbc82008-09-26 22:53:44448RenderWidget* RenderWidget::Create(int32 opener_id,
[email protected]180ef242013-11-07 06:50:46449 blink::WebPopupType popup_type,
450 const blink::WebScreenInfo& screen_info) {
initial.commit09911bf2008-07-26 23:55:29451 DCHECK(opener_id != MSG_ROUTING_NONE);
[email protected]6fd35b72012-03-01 19:46:41452 scoped_refptr<RenderWidget> widget(
[email protected]1ac10dca2013-08-20 20:47:04453 new RenderWidget(popup_type, screen_info, false, false));
[email protected]a635f942012-12-07 10:34:29454 if (widget->Init(opener_id)) { // adds reference on success.
[email protected]fc72bb12013-06-02 21:13:46455 return widget.get();
[email protected]a635f942012-12-07 10:34:29456 }
457 return NULL;
initial.commit09911bf2008-07-26 23:55:29458}
459
[email protected]484955942010-08-19 16:13:18460// static
461WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) {
462 switch (render_widget->popup_type_) {
[email protected]180ef242013-11-07 06:50:46463 case blink::WebPopupTypeNone: // Nothing to create.
[email protected]484955942010-08-19 16:13:18464 break;
[email protected]180ef242013-11-07 06:50:46465 case blink::WebPopupTypeSelect:
466 case blink::WebPopupTypeSuggestion:
[email protected]484955942010-08-19 16:13:18467 return WebPopupMenu::create(render_widget);
[email protected]180ef242013-11-07 06:50:46468 case blink::WebPopupTypePage:
[email protected]a7547fb2012-03-08 04:43:44469 return WebPagePopup::create(render_widget);
[email protected]484955942010-08-19 16:13:18470 default:
471 NOTREACHED();
472 }
473 return NULL;
474}
475
[email protected]a635f942012-12-07 10:34:29476bool RenderWidget::Init(int32 opener_id) {
477 return DoInit(opener_id,
478 RenderWidget::CreateWebWidget(this),
479 new ViewHostMsg_CreateWidget(opener_id, popup_type_,
480 &routing_id_, &surface_id_));
[email protected]484955942010-08-19 16:13:18481}
482
[email protected]a635f942012-12-07 10:34:29483bool RenderWidget::DoInit(int32 opener_id,
[email protected]6a8ddba52010-09-05 04:38:06484 WebWidget* web_widget,
[email protected]484955942010-08-19 16:13:18485 IPC::SyncMessage* create_widget_message) {
initial.commit09911bf2008-07-26 23:55:29486 DCHECK(!webwidget_);
487
488 if (opener_id != MSG_ROUTING_NONE)
489 opener_id_ = opener_id;
490
[email protected]484955942010-08-19 16:13:18491 webwidget_ = web_widget;
initial.commit09911bf2008-07-26 23:55:29492
[email protected]380244092011-10-07 17:26:27493 bool result = RenderThread::Get()->Send(create_widget_message);
initial.commit09911bf2008-07-26 23:55:29494 if (result) {
[email protected]380244092011-10-07 17:26:27495 RenderThread::Get()->AddRoute(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29496 // Take a reference on behalf of the RenderThread. This will be balanced
497 // when we receive ViewMsg_Close.
498 AddRef();
[email protected]b2db9272014-01-10 17:42:00499 if (RenderThreadImpl::current()) {
500 RenderThreadImpl::current()->WidgetCreated();
501 if (is_hidden_)
502 RenderThreadImpl::current()->WidgetHidden();
503 }
[email protected]a635f942012-12-07 10:34:29504 return true;
initial.commit09911bf2008-07-26 23:55:29505 } else {
[email protected]a635f942012-12-07 10:34:29506 // The above Send can fail when the tab is closing.
507 return false;
initial.commit09911bf2008-07-26 23:55:29508 }
509}
510
[email protected]fc4404d2012-11-07 19:53:30511// This is used to complete pending inits and non-pending inits.
512void RenderWidget::CompleteInit() {
initial.commit09911bf2008-07-26 23:55:29513 DCHECK(routing_id_ != MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29514
[email protected]fc4404d2012-11-07 19:53:30515 init_complete_ = true;
[email protected]05a980d7a2012-02-07 22:16:42516
[email protected]8926c602013-01-23 05:32:06517 if (webwidget_ && is_threaded_compositing_enabled_) {
518 webwidget_->enterForceCompositingMode(true);
519 }
[email protected]ba91a792013-02-06 09:48:28520 if (compositor_) {
521 compositor_->setSurfaceReady();
[email protected]479b0172012-10-29 19:27:09522 }
[email protected]05a980d7a2012-02-07 22:16:42523 DoDeferredUpdate();
initial.commit09911bf2008-07-26 23:55:29524
[email protected]6de74452009-02-25 18:04:59525 Send(new ViewHostMsg_RenderViewReady(routing_id_));
initial.commit09911bf2008-07-26 23:55:29526}
527
[email protected]992db4c2011-05-12 15:37:15528void RenderWidget::SetSwappedOut(bool is_swapped_out) {
529 // We should only toggle between states.
530 DCHECK(is_swapped_out_ != is_swapped_out);
531 is_swapped_out_ = is_swapped_out;
532
533 // If we are swapping out, we will call ReleaseProcess, allowing the process
534 // to exit if all of its RenderViews are swapped out. We wait until the
535 // WasSwappedOut call to do this, to avoid showing the sad tab.
536 // If we are swapping in, we call AddRefProcess to prevent the process from
537 // exiting.
538 if (!is_swapped_out)
539 RenderProcess::current()->AddRefProcess();
540}
541
[email protected]c8cbae72013-05-23 10:45:03542bool RenderWidget::UsingSynchronousRendererCompositor() const {
[email protected]ccc1722e2013-05-06 19:43:07543#if defined(OS_ANDROID)
[email protected]913d99a2013-05-31 07:16:07544 return SynchronousCompositorFactory::GetInstance() != NULL;
545#else
[email protected]ccc1722e2013-05-06 19:43:07546 return false;
[email protected]913d99a2013-05-31 07:16:07547#endif
[email protected]ccc1722e2013-05-06 19:43:07548}
549
[email protected]b2e4c70132013-10-03 02:07:51550void RenderWidget::EnableScreenMetricsEmulation(
[email protected]7f99fc22013-11-08 14:05:58551 const gfx::Rect& device_rect,
[email protected]b2e4c70132013-10-03 02:07:51552 const gfx::Rect& widget_rect,
553 float device_scale_factor,
554 bool fit_to_view) {
555 if (!screen_metrics_emulator_) {
556 screen_metrics_emulator_.reset(new ScreenMetricsEmulator(this,
[email protected]7f99fc22013-11-08 14:05:58557 device_rect, widget_rect, device_scale_factor, fit_to_view));
[email protected]b2e4c70132013-10-03 02:07:51558 } else {
[email protected]7f99fc22013-11-08 14:05:58559 screen_metrics_emulator_->ChangeEmulationParams(device_rect,
[email protected]b2e4c70132013-10-03 02:07:51560 widget_rect, device_scale_factor, fit_to_view);
561 }
562}
563
564void RenderWidget::DisableScreenMetricsEmulation() {
565 screen_metrics_emulator_.reset();
566}
567
568void RenderWidget::SetPopupOriginAdjustmentsForEmulation(
569 ScreenMetricsEmulator* emulator) {
570 popup_origin_scale_for_emulation_ = emulator->scale();
571 popup_view_origin_for_emulation_ = emulator->widget_rect().origin();
[email protected]9a2d7ee32013-12-05 12:15:49572 popup_screen_origin_for_emulation_ = gfx::Point(
573 emulator->original_screen_rect().origin().x() + emulator->offset().x(),
574 emulator->original_screen_rect().origin().y() + emulator->offset().y());
[email protected]5f75aa42014-04-01 23:00:56575 screen_info_ = emulator->original_screen_info();
576 device_scale_factor_ = screen_info_.deviceScaleFactor;
[email protected]b2e4c70132013-10-03 02:07:51577}
578
579void RenderWidget::SetScreenMetricsEmulationParameters(
[email protected]7f99fc22013-11-08 14:05:58580 float device_scale_factor,
581 const gfx::Point& root_layer_offset,
582 float root_layer_scale) {
[email protected]b2e4c70132013-10-03 02:07:51583 // This is only supported in RenderView.
584 NOTREACHED();
585}
586
[email protected]53907862014-03-25 15:42:40587#if defined(OS_MACOSX) || defined(OS_ANDROID)
[email protected]b2e4c70132013-10-03 02:07:51588void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
589 ExternalPopupMenu* popup, ScreenMetricsEmulator* emulator) {
[email protected]9a2d7ee32013-12-05 12:15:49590 popup->SetOriginScaleAndOffsetForEmulation(
591 emulator->scale(), emulator->offset());
[email protected]b2e4c70132013-10-03 02:07:51592}
[email protected]53907862014-03-25 15:42:40593#endif
[email protected]b2e4c70132013-10-03 02:07:51594
595void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
596 if (screen_metrics_emulator_)
597 screen_metrics_emulator_->OnShowContextMenu(params);
598}
599
[email protected]7d08a9352013-10-15 08:24:56600void RenderWidget::ScheduleCompositeWithForcedRedraw() {
601 if (compositor_) {
602 // Regardless of whether threaded compositing is enabled, always
603 // use this mechanism to force the compositor to redraw. However,
604 // the invalidation code path below is still needed for the
605 // non-threaded case.
606 compositor_->SetNeedsForcedRedraw();
607 }
[email protected]8b9e52b2014-01-17 16:35:31608 scheduleComposite();
[email protected]7d08a9352013-10-15 08:24:56609}
610
[email protected]a95986a82010-12-24 06:19:28611bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
612 bool handled = true;
613 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
[email protected]c084330e02013-04-27 01:08:15614 IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
[email protected]34202de2013-05-06 23:36:22615 IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
616 OnCursorVisibilityChange)
[email protected]c084330e02013-04-27 01:08:15617 IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
618 IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
[email protected]9017d7852013-11-21 17:47:35619 IPC_MESSAGE_HANDLER(InputMsg_SyntheticGestureCompleted,
620 OnSyntheticGestureCompleted)
[email protected]a95986a82010-12-24 06:19:28621 IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
622 IPC_MESSAGE_HANDLER(ViewMsg_CreatingNew_ACK, OnCreatingNewAck)
623 IPC_MESSAGE_HANDLER(ViewMsg_Resize, OnResize)
[email protected]b5913d72012-02-07 22:26:54624 IPC_MESSAGE_HANDLER(ViewMsg_ChangeResizeRect, OnChangeResizeRect)
[email protected]a95986a82010-12-24 06:19:28625 IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
[email protected]9e2e4632012-07-27 16:38:41626 IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
[email protected]992db4c2011-05-12 15:37:15627 IPC_MESSAGE_HANDLER(ViewMsg_WasSwappedOut, OnWasSwappedOut)
[email protected]a95986a82010-12-24 06:19:28628 IPC_MESSAGE_HANDLER(ViewMsg_UpdateRect_ACK, OnUpdateRectAck)
[email protected]4d7e46a2013-11-08 05:33:40629 IPC_MESSAGE_HANDLER(ViewMsg_SwapBuffers_ACK, OnSwapBuffersComplete)
[email protected]a95986a82010-12-24 06:19:28630 IPC_MESSAGE_HANDLER(ViewMsg_SetInputMethodActive, OnSetInputMethodActive)
[email protected]37a241c2013-12-03 03:16:17631 IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowShown, OnCandidateWindowShown)
632 IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowUpdated,
633 OnCandidateWindowUpdated)
634 IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowHidden, OnCandidateWindowHidden)
[email protected]a95986a82010-12-24 06:19:28635 IPC_MESSAGE_HANDLER(ViewMsg_ImeSetComposition, OnImeSetComposition)
636 IPC_MESSAGE_HANDLER(ViewMsg_ImeConfirmComposition, OnImeConfirmComposition)
[email protected]3d9ec5052013-01-02 22:05:25637 IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
[email protected]a95986a82010-12-24 06:19:28638 IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
639 IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
[email protected]80ad8622012-11-07 16:33:03640 IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
[email protected]105dffb42013-02-20 03:46:21641#if defined(OS_ANDROID)
[email protected]2384b6c2013-02-28 23:58:51642 IPC_MESSAGE_HANDLER(ViewMsg_ShowImeIfNeeded, OnShowImeIfNeeded)
[email protected]0d1ebed12013-08-05 22:01:13643 IPC_MESSAGE_HANDLER(ViewMsg_ImeEventAck, OnImeEventAck)
[email protected]105dffb42013-02-20 03:46:21644#endif
[email protected]51a49502013-03-23 01:50:19645 IPC_MESSAGE_HANDLER(ViewMsg_Snapshot, OnSnapshot)
[email protected]a95986a82010-12-24 06:19:28646 IPC_MESSAGE_UNHANDLED(handled = false)
647 IPC_END_MESSAGE_MAP()
648 return handled;
649}
initial.commit09911bf2008-07-26 23:55:29650
651bool RenderWidget::Send(IPC::Message* message) {
[email protected]992db4c2011-05-12 15:37:15652 // Don't send any messages after the browser has told us to close, and filter
653 // most outgoing messages while swapped out.
654 if ((is_swapped_out_ &&
[email protected]e9ff79c2012-10-19 21:31:26655 !SwappedOutMessages::CanSendWhileSwappedOut(message)) ||
[email protected]c6c921e92012-05-10 23:31:11656 closing_) {
initial.commit09911bf2008-07-26 23:55:29657 delete message;
658 return false;
659 }
660
661 // If given a messsage without a routing ID, then assign our routing ID.
662 if (message->routing_id() == MSG_ROUTING_NONE)
663 message->set_routing_id(routing_id_);
664
[email protected]380244092011-10-07 17:26:27665 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44666}
667
[email protected]61e2b3cc2012-03-02 16:13:34668void RenderWidget::Resize(const gfx::Size& new_size,
[email protected]60d47ac2013-03-01 23:42:44669 const gfx::Size& physical_backing_size,
[email protected]d9083762013-03-24 01:36:40670 float overdraw_bottom_height,
[email protected]61e2b3cc2012-03-02 16:13:34671 const gfx::Rect& resizer_rect,
672 bool is_fullscreen,
673 ResizeAck resize_ack) {
[email protected]f7c1f092013-11-05 20:20:56674 if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
[email protected]1c0008842013-06-06 08:35:48675 // A resize ack shouldn't be requested if we have not ACK'd the previous
676 // one.
677 DCHECK(resize_ack != SEND_RESIZE_ACK || !next_paint_is_resize_ack());
678 DCHECK(resize_ack == SEND_RESIZE_ACK || resize_ack == NO_RESIZE_ACK);
679 }
initial.commit09911bf2008-07-26 23:55:29680
[email protected]61e2b3cc2012-03-02 16:13:34681 // Ignore this during shutdown.
682 if (!webwidget_)
683 return;
684
[email protected]d9083762013-03-24 01:36:40685 if (compositor_) {
[email protected]60d47ac2013-03-01 23:42:44686 compositor_->setViewportSize(new_size, physical_backing_size);
[email protected]d9083762013-03-24 01:36:40687 compositor_->SetOverdrawBottomHeight(overdraw_bottom_height);
688 }
[email protected]60d47ac2013-03-01 23:42:44689
[email protected]dade8992013-03-04 07:34:34690 physical_backing_size_ = physical_backing_size;
[email protected]d9083762013-03-24 01:36:40691 overdraw_bottom_height_ = overdraw_bottom_height;
[email protected]61e2b3cc2012-03-02 16:13:34692 resizer_rect_ = resizer_rect;
693
694 // NOTE: We may have entered fullscreen mode without changing our size.
695 bool fullscreen_change = is_fullscreen_ != is_fullscreen;
696 if (fullscreen_change)
697 WillToggleFullscreen();
698 is_fullscreen_ = is_fullscreen;
699
700 if (size_ != new_size) {
701 // TODO(darin): We should not need to reset this here.
[email protected]61e2b3cc2012-03-02 16:13:34702 needs_repainting_on_restore_ = false;
703
704 size_ = new_size;
705
706 paint_aggregator_.ClearPendingUpdate();
707
708 // When resizing, we want to wait to paint before ACK'ing the resize. This
709 // ensures that we only resize as fast as we can paint. We only need to
710 // send an ACK if we are resized to a non-empty rect.
711 webwidget_->resize(new_size);
[email protected]0b70dbe2013-05-10 19:06:32712
[email protected]f7c1f092013-11-05 20:20:56713 if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
[email protected]92201e32013-06-08 06:14:52714 // Resize should have caused an invalidation of the entire view.
715 DCHECK(new_size.IsEmpty() || is_accelerated_compositing_active_ ||
716 paint_aggregator_.HasPendingUpdate());
717 }
[email protected]5b45ad42013-10-25 00:42:04718 } else if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]632c4382013-05-15 08:58:45719 resize_ack = NO_RESIZE_ACK;
720 }
721
722 if (new_size.IsEmpty() || physical_backing_size.IsEmpty()) {
723 // For empty size or empty physical_backing_size, there is no next paint
724 // (along with which to send the ack) until they are set to non-empty.
[email protected]ff475a322012-03-14 00:05:35725 resize_ack = NO_RESIZE_ACK;
[email protected]61e2b3cc2012-03-02 16:13:34726 }
727
[email protected]20fbfc22013-05-08 20:50:58728 // Send the Resize_ACK flag once we paint again if requested.
[email protected]632c4382013-05-15 08:58:45729 if (resize_ack == SEND_RESIZE_ACK)
[email protected]20fbfc22013-05-08 20:50:58730 set_next_paint_is_resize_ack();
731
[email protected]61e2b3cc2012-03-02 16:13:34732 if (fullscreen_change)
733 DidToggleFullscreen();
734
735 // If a resize ack is requested and it isn't set-up, then no more resizes will
736 // come in and in general things will go wrong.
[email protected]632c4382013-05-15 08:58:45737 DCHECK(resize_ack != SEND_RESIZE_ACK || next_paint_is_resize_ack());
initial.commit09911bf2008-07-26 23:55:29738}
739
[email protected]92650162013-10-30 03:31:02740void RenderWidget::ResizeSynchronously(const gfx::Rect& new_position) {
741 Resize(new_position.size(), new_position.size(), overdraw_bottom_height_,
742 gfx::Rect(), is_fullscreen_, NO_RESIZE_ACK);
743 view_screen_rect_ = new_position;
744 window_screen_rect_ = new_position;
745 if (!did_show_)
746 initial_pos_ = new_position;
747}
748
initial.commit09911bf2008-07-26 23:55:29749void RenderWidget::OnClose() {
750 if (closing_)
751 return;
752 closing_ = true;
753
754 // Browser correspondence is no longer needed at this point.
[email protected]bee16aab2009-08-26 15:55:03755 if (routing_id_ != MSG_ROUTING_NONE) {
[email protected]b2db9272014-01-10 17:42:00756 if (RenderThreadImpl::current())
757 RenderThreadImpl::current()->WidgetDestroyed();
[email protected]380244092011-10-07 17:26:27758 RenderThread::Get()->RemoveRoute(routing_id_);
[email protected]bee16aab2009-08-26 15:55:03759 SetHidden(false);
760 }
initial.commit09911bf2008-07-26 23:55:29761
initial.commit09911bf2008-07-26 23:55:29762 // If there is a Send call on the stack, then it could be dangerous to close
[email protected]d3fc25652009-02-24 22:31:25763 // now. Post a task that only gets invoked when there are no nested message
764 // loops.
[email protected]dd32b1272013-05-04 14:17:11765 base::MessageLoop::current()->PostNonNestableTask(
[email protected]3a5a7822011-12-23 18:27:29766 FROM_HERE, base::Bind(&RenderWidget::Close, this));
[email protected]d3fc25652009-02-24 22:31:25767
768 // Balances the AddRef taken when we called AddRoute.
769 Release();
initial.commit09911bf2008-07-26 23:55:29770}
771
[email protected]61e2b3cc2012-03-02 16:13:34772// Got a response from the browser after the renderer decided to create a new
773// view.
[email protected]fc4404d2012-11-07 19:53:30774void RenderWidget::OnCreatingNewAck() {
[email protected]61e2b3cc2012-03-02 16:13:34775 DCHECK(routing_id_ != MSG_ROUTING_NONE);
776
[email protected]fc4404d2012-11-07 19:53:30777 CompleteInit();
[email protected]61e2b3cc2012-03-02 16:13:34778}
779
[email protected]0fdd5012013-05-29 08:05:56780void RenderWidget::OnResize(const ViewMsg_Resize_Params& params) {
[email protected]5b45ad42013-10-25 00:42:04781 if (resizing_mode_selector_->ShouldAbortOnResize(this, params))
[email protected]03e88672013-10-22 21:31:32782 return;
783
[email protected]b2e4c70132013-10-03 02:07:51784 if (screen_metrics_emulator_) {
785 screen_metrics_emulator_->OnResizeMessage(params);
786 return;
787 }
788
[email protected]0fdd5012013-05-29 08:05:56789 screen_info_ = params.screen_info;
790 SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
791 Resize(params.new_size, params.physical_backing_size,
792 params.overdraw_bottom_height, params.resizer_rect,
793 params.is_fullscreen, SEND_RESIZE_ACK);
initial.commit09911bf2008-07-26 23:55:29794}
795
[email protected]b5913d72012-02-07 22:26:54796void RenderWidget::OnChangeResizeRect(const gfx::Rect& resizer_rect) {
797 if (resizer_rect_ != resizer_rect) {
[email protected]b9769d82012-02-10 00:23:59798 gfx::Rect view_rect(size_);
799
[email protected]ce112fe2012-10-29 22:52:18800 gfx::Rect old_damage_rect = gfx::IntersectRects(view_rect, resizer_rect_);
[email protected]b9769d82012-02-10 00:23:59801 if (!old_damage_rect.IsEmpty())
802 paint_aggregator_.InvalidateRect(old_damage_rect);
803
[email protected]ce112fe2012-10-29 22:52:18804 gfx::Rect new_damage_rect = gfx::IntersectRects(view_rect, resizer_rect);
[email protected]b9769d82012-02-10 00:23:59805 if (!new_damage_rect.IsEmpty())
806 paint_aggregator_.InvalidateRect(new_damage_rect);
807
[email protected]b5913d72012-02-07 22:26:54808 resizer_rect_ = resizer_rect;
[email protected]b9769d82012-02-10 00:23:59809
[email protected]b5913d72012-02-07 22:26:54810 if (webwidget_)
811 webwidget_->didChangeWindowResizerRect();
812 }
813}
814
initial.commit09911bf2008-07-26 23:55:29815void RenderWidget::OnWasHidden() {
[email protected]9c3085f2011-06-09 02:10:31816 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
initial.commit09911bf2008-07-26 23:55:29817 // Go into a mode where we stop generating paint and scrolling events.
[email protected]bee16aab2009-08-26 15:55:03818 SetHidden(true);
initial.commit09911bf2008-07-26 23:55:29819}
820
[email protected]9e2e4632012-07-27 16:38:41821void RenderWidget::OnWasShown(bool needs_repainting) {
822 TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
initial.commit09911bf2008-07-26 23:55:29823 // During shutdown we can just ignore this message.
824 if (!webwidget_)
825 return;
826
827 // See OnWasHidden
[email protected]bee16aab2009-08-26 15:55:03828 SetHidden(false);
initial.commit09911bf2008-07-26 23:55:29829
830 if (!needs_repainting && !needs_repainting_on_restore_)
831 return;
832 needs_repainting_on_restore_ = false;
833
[email protected]d65adb12010-04-28 17:26:49834 // Tag the next paint as a restore ack, which is picked up by
835 // DoDeferredUpdate when it sends out the next PaintRect message.
initial.commit09911bf2008-07-26 23:55:29836 set_next_paint_is_restore_ack();
837
838 // Generate a full repaint.
[email protected]a79d8a632010-11-18 22:35:56839 if (!is_accelerated_compositing_active_) {
[email protected]f98d7e3c2010-09-13 22:30:46840 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
841 } else {
[email protected]8b9e52b2014-01-17 16:35:31842 if (compositor_)
843 compositor_->SetNeedsForcedRedraw();
844 scheduleComposite();
[email protected]f98d7e3c2010-09-13 22:30:46845 }
initial.commit09911bf2008-07-26 23:55:29846}
847
[email protected]992db4c2011-05-12 15:37:15848void RenderWidget::OnWasSwappedOut() {
849 // If we have been swapped out and no one else is using this process,
850 // it's safe to exit now. If we get swapped back in, we will call
851 // AddRefProcess in SetSwappedOut.
852 if (is_swapped_out_)
853 RenderProcess::current()->ReleaseProcess();
854}
855
[email protected]53d3f302009-12-21 04:42:05856void RenderWidget::OnRequestMoveAck() {
857 DCHECK(pending_window_rect_count_);
858 pending_window_rect_count_--;
859}
860
861void RenderWidget::OnUpdateRectAck() {
[email protected]366ae242011-05-10 02:23:58862 TRACE_EVENT0("renderer", "RenderWidget::OnUpdateRectAck");
[email protected]aa4117f2011-12-09 22:19:21863 DCHECK(update_reply_pending_);
[email protected]53d3f302009-12-21 04:42:05864 update_reply_pending_ = false;
865
[email protected]b4d08452010-10-05 17:34:35866 // If we sent an UpdateRect message with a zero-sized bitmap, then we should
867 // have no current paint buffer.
868 if (current_paint_buf_) {
869 RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
870 current_paint_buf_ = NULL;
871 }
872
[email protected]65225772011-05-12 21:10:24873 // If swapbuffers is still pending, then defer the update until the
874 // swapbuffers occurs.
875 if (num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending) {
876 TRACE_EVENT0("renderer", "EarlyOut_SwapStillPending");
877 return;
878 }
879
[email protected]29ed96a2012-02-04 18:12:16880 // Notify subclasses that software rendering was flushed to the screen.
[email protected]404939f2012-06-01 04:06:18881 if (!is_accelerated_compositing_active_) {
882 DidFlushPaint();
883 }
[email protected]a2f6bc112009-06-27 16:27:25884
initial.commit09911bf2008-07-26 23:55:29885 // Continue painting if necessary...
[email protected]65225772011-05-12 21:10:24886 DoDeferredUpdateAndSendInputAck();
887}
888
[email protected]d0be63772011-12-20 23:18:04889bool RenderWidget::SupportsAsynchronousSwapBuffers() {
[email protected]ed7defa2013-03-12 21:29:59890 // Contexts using the command buffer support asynchronous swapbuffers.
891 // See RenderWidget::CreateOutputSurface().
[email protected]cadac622013-06-11 16:46:36892 if (RenderThreadImpl::current()->compositor_message_loop_proxy().get())
[email protected]ed7defa2013-03-12 21:29:59893 return false;
894
895 return true;
896}
897
898GURL RenderWidget::GetURLForGraphicsContext3D() {
899 return GURL();
[email protected]65225772011-05-12 21:10:24900}
901
[email protected]479b0172012-10-29 19:27:09902bool RenderWidget::ForceCompositingModeEnabled() {
903 return false;
904}
905
[email protected]ebc0e1df2013-08-01 02:46:22906scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(bool fallback) {
[email protected]a1811b8912013-05-09 15:35:19907
908#if defined(OS_ANDROID)
[email protected]b6eb8e332013-09-10 00:51:01909 if (SynchronousCompositorFactory* factory =
910 SynchronousCompositorFactory::GetInstance()) {
[email protected]913d99a2013-05-31 07:16:07911 return factory->CreateOutputSurface(routing_id());
[email protected]a1811b8912013-05-09 15:35:19912 }
913#endif
914
[email protected]b6eb8e332013-09-10 00:51:01915 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
[email protected]e09994a2014-03-26 19:59:33916 bool use_software = fallback;
917 if (command_line.HasSwitch(switches::kDisableGpuCompositing))
918 use_software = true;
919
[email protected]0634cdd42013-08-16 00:46:09920 scoped_refptr<ContextProviderCommandBuffer> context_provider;
[email protected]e09994a2014-03-26 19:59:33921 if (!use_software) {
922 // Explicitly disable antialiasing for the compositor. As of the time of
923 // this writing, the only platform that supported antialiasing for the
924 // compositor was Mac OS X, because the on-screen OpenGL context creation
925 // code paths on Windows and Linux didn't yet have multisampling support.
926 // Mac OS X essentially always behaves as though it's rendering offscreen.
927 // Multisampling has a heavy cost especially on devices with relatively low
928 // fill rate like most notebooks, and the Mac implementation would need to
929 // be optimized to resolve directly into the IOSurface shared between the
930 // GPU and browser processes. For these reasons and to avoid platform
931 // disparities we explicitly disable antialiasing.
932 blink::WebGraphicsContext3D::Attributes attributes;
933 attributes.antialias = false;
934 attributes.shareResources = true;
935 attributes.noAutomaticFlushes = true;
936 attributes.depth = false;
937 attributes.stencil = false;
[email protected]0634cdd42013-08-16 00:46:09938 context_provider = ContextProviderCommandBuffer::Create(
[email protected]af13d832013-09-13 06:56:27939 CreateGraphicsContext3D(attributes),
940 "RenderCompositor");
[email protected]e09994a2014-03-26 19:59:33941 if (!context_provider.get()) {
942 // Cause the compositor to wait and try again.
943 return scoped_ptr<cc::OutputSurface>();
944 }
[email protected]0634cdd42013-08-16 00:46:09945 }
[email protected]ebc0e1df2013-08-01 02:46:22946
[email protected]b6eb8e332013-09-10 00:51:01947 uint32 output_surface_id = next_output_surface_id_++;
[email protected]50cf1992014-03-29 00:06:00948 if (command_line.HasSwitch(switches::kEnableDelegatedRenderer)) {
[email protected]65a33ce2014-03-25 22:37:09949 DCHECK(is_threaded_compositing_enabled_);
950 return scoped_ptr<cc::OutputSurface>(
951 new DelegatedCompositorOutputSurface(
952 routing_id(),
953 output_surface_id,
954 context_provider));
955 }
[email protected]0634cdd42013-08-16 00:46:09956 if (!context_provider.get()) {
[email protected]ebc0e1df2013-08-01 02:46:22957 if (!command_line.HasSwitch(switches::kEnableSoftwareCompositing))
958 return scoped_ptr<cc::OutputSurface>();
[email protected]0634cdd42013-08-16 00:46:09959
960 scoped_ptr<cc::SoftwareOutputDevice> software_device(
961 new CompositorSoftwareOutputDevice());
962
963 return scoped_ptr<cc::OutputSurface>(new CompositorOutputSurface(
964 routing_id(),
965 output_surface_id,
966 NULL,
967 software_device.Pass(),
968 true));
[email protected]ebc0e1df2013-08-01 02:46:22969 }
[email protected]ed7defa2013-03-12 21:29:59970
[email protected]36e5ff12013-06-11 12:19:29971 if (command_line.HasSwitch(cc::switches::kCompositeToMailbox)) {
[email protected]9ce650e2014-03-24 08:42:50972 DCHECK(is_threaded_compositing_enabled_);
[email protected]186f09602013-09-24 07:13:16973 cc::ResourceFormat format = cc::RGBA_8888;
974#if defined(OS_ANDROID)
975 if (base::android::SysUtils::IsLowEndDevice())
976 format = cc::RGB_565;
977#endif
[email protected]36e5ff12013-06-11 12:19:29978 return scoped_ptr<cc::OutputSurface>(
[email protected]0634cdd42013-08-16 00:46:09979 new MailboxOutputSurface(
980 routing_id(),
981 output_surface_id,
982 context_provider,
[email protected]186f09602013-09-24 07:13:16983 scoped_ptr<cc::SoftwareOutputDevice>(),
984 format));
[email protected]36e5ff12013-06-11 12:19:29985 }
[email protected]0634cdd42013-08-16 00:46:09986 bool use_swap_compositor_frame_message = false;
[email protected]36e5ff12013-06-11 12:19:29987 return scoped_ptr<cc::OutputSurface>(
[email protected]0634cdd42013-08-16 00:46:09988 new CompositorOutputSurface(
989 routing_id(),
990 output_surface_id,
991 context_provider,
992 scoped_ptr<cc::SoftwareOutputDevice>(),
993 use_swap_compositor_frame_message));
[email protected]ba91a792013-02-06 09:48:28994}
995
[email protected]4d7e46a2013-11-08 05:33:40996void RenderWidget::OnSwapBuffersAborted() {
[email protected]65225772011-05-12 21:10:24997 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
[email protected]aa4117f2011-12-09 22:19:21998 while (!updates_pending_swap_.empty()) {
999 ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
1000 updates_pending_swap_.pop_front();
1001 // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
1002 // compositing pass, hence doesn't require an UpdateRect message.
1003 if (msg)
1004 Send(msg);
1005 }
[email protected]65225772011-05-12 21:10:241006 num_swapbuffers_complete_pending_ = 0;
1007 using_asynchronous_swapbuffers_ = false;
1008 // Schedule another frame so the compositor learns about it.
[email protected]8b9e52b2014-01-17 16:35:311009 scheduleComposite();
[email protected]65225772011-05-12 21:10:241010}
1011
[email protected]4d7e46a2013-11-08 05:33:401012void RenderWidget::OnSwapBuffersPosted() {
[email protected]37a6f302011-07-11 23:43:081013 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
[email protected]aa4117f2011-12-09 22:19:211014
1015 if (using_asynchronous_swapbuffers_) {
1016 ViewHostMsg_UpdateRect* msg = NULL;
1017 // pending_update_params_ can be NULL if the swap doesn't correspond to an
1018 // DoDeferredUpdate compositing pass, hence doesn't require an UpdateRect
1019 // message.
[email protected]59383c782013-04-17 16:43:271020 if (pending_update_params_) {
[email protected]aa4117f2011-12-09 22:19:211021 msg = new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_);
1022 pending_update_params_.reset();
1023 }
1024 updates_pending_swap_.push_back(msg);
[email protected]37a6f302011-07-11 23:43:081025 num_swapbuffers_complete_pending_++;
[email protected]aa4117f2011-12-09 22:19:211026 }
[email protected]37a6f302011-07-11 23:43:081027}
1028
[email protected]4d7e46a2013-11-08 05:33:401029void RenderWidget::OnSwapBuffersComplete() {
[email protected]65225772011-05-12 21:10:241030 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersComplete");
[email protected]29ed96a2012-02-04 18:12:161031
[email protected]404939f2012-06-01 04:06:181032 // Notify subclasses that composited rendering was flushed to the screen.
[email protected]29ed96a2012-02-04 18:12:161033 DidFlushPaint();
1034
[email protected]65225772011-05-12 21:10:241035 // When compositing deactivates, we reset the swapbuffers pending count. The
1036 // swapbuffers acks may still arrive, however.
1037 if (num_swapbuffers_complete_pending_ == 0) {
1038 TRACE_EVENT0("renderer", "EarlyOut_ZeroSwapbuffersPending");
1039 return;
1040 }
[email protected]aa4117f2011-12-09 22:19:211041 DCHECK(!updates_pending_swap_.empty());
1042 ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
1043 updates_pending_swap_.pop_front();
1044 // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
1045 // compositing pass, hence doesn't require an UpdateRect message.
1046 if (msg)
1047 Send(msg);
[email protected]65225772011-05-12 21:10:241048 num_swapbuffers_complete_pending_--;
1049
1050 // If update reply is still pending, then defer the update until that reply
1051 // occurs.
[email protected]d0be63772011-12-20 23:18:041052 if (update_reply_pending_) {
[email protected]65225772011-05-12 21:10:241053 TRACE_EVENT0("renderer", "EarlyOut_UpdateReplyPending");
1054 return;
1055 }
1056
1057 // If we are not accelerated rendering, then this is a stale swapbuffers from
[email protected]50312bf2011-06-22 23:30:061058 // when we were previously rendering. However, if an invalidation task is not
1059 // posted, there may be software rendering work pending. In that case, don't
1060 // early out.
1061 if (!is_accelerated_compositing_active_ && invalidation_task_posted_) {
[email protected]65225772011-05-12 21:10:241062 TRACE_EVENT0("renderer", "EarlyOut_AcceleratedCompositingOff");
1063 return;
1064 }
1065
[email protected]cc66e682012-10-02 06:48:181066 // Do not call DoDeferredUpdate unless there's animation work to be done or
1067 // a real invalidation. This prevents rendering in response to a swapbuffers
1068 // callback coming back after we've navigated away from the page that
1069 // generated it.
1070 if (!animation_update_pending_ && !paint_aggregator_.HasPendingUpdate()) {
1071 TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
1072 return;
1073 }
1074
[email protected]65225772011-05-12 21:10:241075 // Continue painting if necessary...
1076 DoDeferredUpdateAndSendInputAck();
initial.commit09911bf2008-07-26 23:55:291077}
1078
[email protected]180ef242013-11-07 06:50:461079void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event,
[email protected]205294b2014-03-18 20:48:351080 const ui::LatencyInfo& latency_info,
[email protected]0dea1652012-12-14 00:09:091081 bool is_keyboard_shortcut) {
[email protected]5dd768212009-08-13 23:34:491082 handling_input_event_ = true;
[email protected]0dea1652012-12-14 00:09:091083 if (!input_event) {
[email protected]5dd768212009-08-13 23:34:491084 handling_input_event_ = false;
initial.commit09911bf2008-07-26 23:55:291085 return;
[email protected]5dd768212009-08-13 23:34:491086 }
initial.commit09911bf2008-07-26 23:55:291087
[email protected]fd847792013-10-24 17:12:351088 base::TimeTicks start_time;
1089 if (base::TimeTicks::IsHighResNowFastAndReliable())
1090 start_time = base::TimeTicks::HighResNow();
1091
[email protected]8e299aa2013-10-16 18:17:441092 const char* const event_name =
1093 WebInputEventTraits::GetName(input_event->type);
[email protected]b4841e1c2013-05-16 22:30:101094 TRACE_EVENT1("renderer", "RenderWidget::OnHandleInputEvent",
1095 "event", event_name);
[email protected]b2e92592014-01-10 15:47:151096 TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("blink.HandleInputEvent");
[email protected]15ba6dea2014-04-02 01:44:131097 TRACE_EVENT_FLOW_STEP0(
1098 "input",
1099 "LatencyInfo.Flow",
1100 TRACE_ID_DONT_MANGLE(latency_info.trace_id),
1101 "HanldeInputEventMain");
[email protected]b4841e1c2013-05-16 22:30:101102
[email protected]6be422b2013-12-08 06:47:311103 scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor;
[email protected]205294b2014-03-18 20:48:351104 ui::LatencyInfo swap_latency_info(latency_info);
[email protected]6be422b2013-12-08 06:47:311105 if (compositor_) {
1106 latency_info_swap_promise_monitor =
[email protected]205294b2014-03-18 20:48:351107 compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info)
1108 .Pass();
[email protected]6be422b2013-12-08 06:47:311109 } else {
[email protected]98a04472013-12-23 20:42:501110 latency_info_.push_back(latency_info);
[email protected]6be422b2013-12-08 06:47:311111 }
[email protected]c2eaa8f2013-05-10 02:41:551112
[email protected]6a4d7f62013-01-07 21:32:131113 base::TimeDelta now = base::TimeDelta::FromInternalValue(
1114 base::TimeTicks::Now().ToInternalValue());
1115
1116 int64 delta = static_cast<int64>(
1117 (now.InSecondsF() - input_event->timeStampSeconds) *
1118 base::Time::kMicrosecondsPerSecond);
[email protected]e3d4b312014-01-22 10:22:351119 UMA_HISTOGRAM_CUSTOM_COUNTS("Event.AggregatedLatency.Renderer2",
[email protected]da72744a2014-02-13 14:52:131120 delta, 1, 10000000, 100);
[email protected]de415552013-01-23 04:12:171121 base::HistogramBase* counter_for_type =
[email protected]bafdc5d52013-02-27 18:18:481122 base::Histogram::FactoryGet(
[email protected]e3d4b312014-01-22 10:22:351123 base::StringPrintf("Event.Latency.Renderer2.%s", event_name),
[email protected]da72744a2014-02-13 14:52:131124 1,
[email protected]e3d4b312014-01-22 10:22:351125 10000000,
[email protected]6a4d7f62013-01-07 21:32:131126 100,
[email protected]de415552013-01-23 04:12:171127 base::HistogramBase::kUmaTargetedHistogramFlag);
[email protected]bafdc5d52013-02-27 18:18:481128 counter_for_type->Add(delta);
[email protected]6a4d7f62013-01-07 21:32:131129
[email protected]72aee842014-02-20 19:41:411130 if (WebInputEvent::isUserGestureEventType(input_event->type))
1131 WillProcessUserGesture();
1132
[email protected]67bfb83f2011-09-22 03:36:371133 bool prevent_default = false;
1134 if (WebInputEvent::isMouseEventType(input_event->type)) {
[email protected]936c6f52011-12-13 01:35:261135 const WebMouseEvent& mouse_event =
1136 *static_cast<const WebMouseEvent*>(input_event);
1137 TRACE_EVENT2("renderer", "HandleMouseMove",
1138 "x", mouse_event.x, "y", mouse_event.y);
[email protected]a09d53ce2014-01-31 00:46:421139 context_menu_source_type_ = ui::MENU_SOURCE_MOUSE;
[email protected]936c6f52011-12-13 01:35:261140 prevent_default = WillHandleMouseEvent(mouse_event);
[email protected]67bfb83f2011-09-22 03:36:371141 }
1142
[email protected]cefe9b152014-03-27 18:16:151143 if (WebInputEvent::isKeyboardEventType(input_event->type)) {
[email protected]a09d53ce2014-01-31 00:46:421144 context_menu_source_type_ = ui::MENU_SOURCE_KEYBOARD;
[email protected]cefe9b152014-03-27 18:16:151145#if defined(OS_ANDROID)
1146 // The DPAD_CENTER key on Android has a dual semantic: (1) in the general
1147 // case it should behave like a select key (i.e. causing a click if a button
1148 // is focused). However, if a text field is focused (2), its intended
1149 // behavior is to just show the IME and don't propagate the key.
1150 // A typical use case is a web form: the DPAD_CENTER should bring up the IME
1151 // when clicked on an input text field and cause the form submit if clicked
1152 // when the submit button is focused, but not vice-versa.
1153 // The UI layer takes care of translating DPAD_CENTER into a RETURN key,
1154 // but at this point we have to swallow the event for the scenario (2).
1155 const WebKeyboardEvent& key_event =
1156 *static_cast<const WebKeyboardEvent*>(input_event);
1157 if (key_event.nativeKeyCode == AKEYCODE_DPAD_CENTER &&
1158 GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE) {
1159 OnShowImeIfNeeded();
1160 prevent_default = true;
1161 }
1162#endif
1163 }
[email protected]f56c7872013-06-18 12:31:571164
[email protected]41d86852012-11-07 12:23:241165 if (WebInputEvent::isGestureEventType(input_event->type)) {
1166 const WebGestureEvent& gesture_event =
1167 *static_cast<const WebGestureEvent*>(input_event);
[email protected]a09d53ce2014-01-31 00:46:421168 context_menu_source_type_ = ui::MENU_SOURCE_TOUCH;
[email protected]41d86852012-11-07 12:23:241169 prevent_default = prevent_default || WillHandleGestureEvent(gesture_event);
1170 }
1171
[email protected]5d0bbdfa92013-12-10 00:35:511172 if (input_event->type == WebInputEvent::TouchStart)
1173 handling_touchstart_event_ = true;
1174
[email protected]67bfb83f2011-09-22 03:36:371175 bool processed = prevent_default;
[email protected]b68a0e52011-12-08 15:11:121176 if (input_event->type != WebInputEvent::Char || !suppress_next_char_events_) {
1177 suppress_next_char_events_ = false;
1178 if (!processed && webwidget_)
1179 processed = webwidget_->handleInputEvent(*input_event);
1180 }
1181
[email protected]5d0bbdfa92013-12-10 00:35:511182 handling_touchstart_event_ = false;
1183
[email protected]b68a0e52011-12-08 15:11:121184 // If this RawKeyDown event corresponds to a browser keyboard shortcut and
1185 // it's not processed by webkit, then we need to suppress the upcoming Char
1186 // events.
1187 if (!processed && is_keyboard_shortcut)
1188 suppress_next_char_events_ = true;
initial.commit09911bf2008-07-26 23:55:291189
[email protected]3d5c243b2012-11-30 00:26:011190 InputEventAckState ack_result = processed ?
1191 INPUT_EVENT_ACK_STATE_CONSUMED : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1192 if (!processed && input_event->type == WebInputEvent::TouchStart) {
1193 const WebTouchEvent& touch_event =
1194 *static_cast<const WebTouchEvent*>(input_event);
[email protected]f8ed4722013-12-03 03:27:251195 // Hit-test for all the pressed touch points. If there is a touch-handler
1196 // for any of the touch points, then the renderer should continue to receive
1197 // touch events.
1198 ack_result = INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
1199 for (size_t i = 0; i < touch_event.touchesLength; ++i) {
1200 if (touch_event.touches[i].state == WebTouchPoint::StatePressed &&
[email protected]a66e18e2014-01-29 20:58:271201 HasTouchEventHandlersAt(
[email protected]9c769d412014-03-20 18:27:391202 gfx::ToFlooredPoint(touch_event.touches[i].position))) {
[email protected]f8ed4722013-12-03 03:27:251203 ack_result = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1204 break;
1205 }
1206 }
[email protected]3d5c243b2012-11-30 00:26:011207 }
1208
[email protected]fd847792013-10-24 17:12:351209 bool event_type_can_be_rate_limited =
[email protected]3391a0772012-03-28 00:32:071210 input_event->type == WebInputEvent::MouseMove ||
1211 input_event->type == WebInputEvent::MouseWheel ||
[email protected]3475bb52013-10-03 08:25:161212 input_event->type == WebInputEvent::TouchMove;
[email protected]8926c602013-01-23 05:32:061213
1214 bool frame_pending = paint_aggregator_.HasPendingUpdate();
1215 if (is_accelerated_compositing_active_) {
[email protected]ba91a792013-02-06 09:48:281216 frame_pending = compositor_ &&
[email protected]971728d2013-10-26 10:39:311217 compositor_->BeginMainFrameRequested();
[email protected]8926c602013-01-23 05:32:061218 }
1219
[email protected]fd847792013-10-24 17:12:351220 // If we don't have a fast and accurate HighResNow, we assume the input
1221 // handlers are heavy and rate limit them.
1222 bool rate_limiting_wanted = true;
1223 if (base::TimeTicks::IsHighResNowFastAndReliable()) {
1224 base::TimeTicks end_time = base::TimeTicks::HighResNow();
1225 total_input_handling_time_this_frame_ += (end_time - start_time);
1226 rate_limiting_wanted =
1227 total_input_handling_time_this_frame_.InMicroseconds() >
1228 kInputHandlingTimeThrottlingThresholdMicroseconds;
1229 }
1230
[email protected]34afe102013-12-13 17:24:551231 if (!WebInputEventTraits::IgnoresAckDisposition(input_event->type)) {
1232 scoped_ptr<IPC::Message> response(
1233 new InputHostMsg_HandleInputEvent_ACK(routing_id_,
1234 input_event->type,
1235 ack_result,
[email protected]205294b2014-03-18 20:48:351236 swap_latency_info));
[email protected]34afe102013-12-13 17:24:551237 if (rate_limiting_wanted && event_type_can_be_rate_limited &&
1238 frame_pending && !is_hidden_) {
1239 // We want to rate limit the input events in this case, so we'll wait for
1240 // painting to finish before ACKing this message.
1241 TRACE_EVENT_INSTANT0("renderer",
1242 "RenderWidget::OnHandleInputEvent ack throttled",
1243 TRACE_EVENT_SCOPE_THREAD);
1244 if (pending_input_event_ack_) {
1245 // As two different kinds of events could cause us to postpone an ack
1246 // we send it now, if we have one pending. The Browser should never
1247 // send us the same kind of event we are delaying the ack for.
1248 Send(pending_input_event_ack_.release());
1249 }
1250 pending_input_event_ack_ = response.Pass();
1251 if (compositor_)
1252 compositor_->NotifyInputThrottledUntilCommit();
1253 } else {
1254 Send(response.release());
[email protected]353a34c2010-05-28 23:35:171255 }
[email protected]12fbad812009-09-01 18:21:241256 }
1257
[email protected]3306f262012-09-21 19:20:421258#if defined(OS_ANDROID)
1259 // Allow the IME to be shown when the focus changes as a consequence
1260 // of a processed touch end event.
1261 if (input_event->type == WebInputEvent::TouchEnd && processed)
[email protected]0d1ebed12013-08-05 22:01:131262 UpdateTextInputState(true, true);
[email protected]183e28d2014-01-20 18:18:021263#elif defined(USE_AURA)
1264 // Show the virtual keyboard if enabled and a user gesture triggers a focus
1265 // change.
1266 if (processed && (input_event->type == WebInputEvent::TouchEnd ||
1267 input_event->type == WebInputEvent::MouseUp))
1268 UpdateTextInputState(true, false);
[email protected]3306f262012-09-21 19:20:421269#endif
1270
[email protected]b2e92592014-01-10 15:47:151271 TRACE_EVENT_SYNTHETIC_DELAY_END("blink.HandleInputEvent");
[email protected]5dd768212009-08-13 23:34:491272 handling_input_event_ = false;
[email protected]446705872009-09-10 07:22:481273
[email protected]67bfb83f2011-09-22 03:36:371274 if (!prevent_default) {
1275 if (WebInputEvent::isKeyboardEventType(input_event->type))
1276 DidHandleKeyEvent();
1277 if (WebInputEvent::isMouseEventType(input_event->type))
1278 DidHandleMouseEvent(*(static_cast<const WebMouseEvent*>(input_event)));
[email protected]2d0f2e92011-10-03 09:02:241279 if (WebInputEvent::isTouchEventType(input_event->type))
1280 DidHandleTouchEvent(*(static_cast<const WebTouchEvent*>(input_event)));
[email protected]67bfb83f2011-09-22 03:36:371281 }
initial.commit09911bf2008-07-26 23:55:291282}
1283
[email protected]34202de2013-05-06 23:36:221284void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
1285 if (webwidget_)
1286 webwidget_->setCursorVisibilityState(is_visible);
1287}
1288
initial.commit09911bf2008-07-26 23:55:291289void RenderWidget::OnMouseCaptureLost() {
1290 if (webwidget_)
[email protected]4873c7d2009-07-16 06:36:281291 webwidget_->mouseCaptureLost();
initial.commit09911bf2008-07-26 23:55:291292}
1293
1294void RenderWidget::OnSetFocus(bool enable) {
1295 has_focus_ = enable;
[email protected]9d166af2010-03-02 22:04:331296 if (webwidget_)
1297 webwidget_->setFocus(enable);
initial.commit09911bf2008-07-26 23:55:291298}
1299
1300void RenderWidget::ClearFocus() {
1301 // We may have got the focus from the browser before this gets processed, in
1302 // which case we do not want to unfocus ourself.
1303 if (!has_focus_ && webwidget_)
[email protected]4873c7d2009-07-16 06:36:281304 webwidget_->setFocus(false);
initial.commit09911bf2008-07-26 23:55:291305}
1306
[email protected]2d5d09d52009-06-15 14:29:211307void RenderWidget::PaintRect(const gfx::Rect& rect,
[email protected]4fb66842009-12-04 21:41:001308 const gfx::Point& canvas_origin,
[email protected]2d5d09d52009-06-15 14:29:211309 skia::PlatformCanvas* canvas) {
[email protected]50312bf2011-06-22 23:30:061310 TRACE_EVENT2("renderer", "PaintRect",
1311 "width", rect.width(), "height", rect.height());
[email protected]63ab54262012-11-09 15:58:451312
[email protected]4fb66842009-12-04 21:41:001313 canvas->save();
[email protected]2d5d09d52009-06-15 14:29:211314
1315 // Bring the canvas into the coordinate system of the paint rect.
[email protected]4fb66842009-12-04 21:41:001316 canvas->translate(static_cast<SkScalar>(-canvas_origin.x()),
1317 static_cast<SkScalar>(-canvas_origin.y()));
[email protected]96c3499a2009-05-02 18:31:031318
[email protected]699ab0d2009-04-23 23:19:141319 // If there is a custom background, tile it.
1320 if (!background_.empty()) {
[email protected]699ab0d2009-04-23 23:19:141321 SkPaint paint;
[email protected]4e29afd2012-12-04 04:07:111322 skia::RefPtr<SkShader> shader = skia::AdoptRef(
1323 SkShader::CreateBitmapShader(background_,
1324 SkShader::kRepeat_TileMode,
1325 SkShader::kRepeat_TileMode));
1326 paint.setShader(shader.get());
[email protected]fb10ec5b2011-10-24 17:54:201327
1328 // Use kSrc_Mode to handle background_ transparency properly.
1329 paint.setXfermodeMode(SkXfermode::kSrc_Mode);
1330
1331 // Canvas could contain multiple update rects. Clip to given rect so that
1332 // we don't accidentally clear other update rects.
1333 canvas->save();
[email protected]aa7e7a12013-02-22 13:37:441334 canvas->scale(device_scale_factor_, device_scale_factor_);
[email protected]1835b9e2012-02-28 13:12:481335 canvas->clipRect(gfx::RectToSkRect(rect));
[email protected]699ab0d2009-04-23 23:19:141336 canvas->drawPaint(paint);
[email protected]fb10ec5b2011-10-24 17:54:201337 canvas->restore();
[email protected]699ab0d2009-04-23 23:19:141338 }
1339
[email protected]719b36f2010-12-22 20:36:461340 // First see if this rect is a plugin that can paint itself faster.
1341 TransportDIB* optimized_dib = NULL;
1342 gfx::Rect optimized_copy_rect, optimized_copy_location;
[email protected]0f3a2d12012-09-01 03:37:201343 float dib_scale_factor;
[email protected]adab2332013-07-25 18:04:321344 PepperPluginInstanceImpl* optimized_instance =
[email protected]719b36f2010-12-22 20:36:461345 GetBitmapForOptimizedPluginPaint(rect, &optimized_dib,
1346 &optimized_copy_location,
[email protected]0f3a2d12012-09-01 03:37:201347 &optimized_copy_rect,
1348 &dib_scale_factor);
[email protected]719b36f2010-12-22 20:36:461349 if (optimized_instance) {
[email protected]20790a222013-07-25 02:23:051350#if defined(ENABLE_PLUGINS)
[email protected]719b36f2010-12-22 20:36:461351 // This plugin can be optimize-painted and we can just ask it to paint
1352 // itself. We don't actually need the TransportDIB in this case.
1353 //
1354 // This is an optimization for PPAPI plugins that know they're on top of
1355 // the page content. If this rect is inside such a plugin, we can save some
1356 // time and avoid re-rendering the page content which we know will be
1357 // covered by the plugin later (this time can be significant, especially
1358 // for a playing movie that is invalidating a lot).
1359 //
1360 // In the plugin movie case, hopefully the similar call to
1361 // GetBitmapForOptimizedPluginPaint in DoDeferredUpdate handles the
1362 // painting, because that avoids copying the plugin image to a different
1363 // paint rect. Unfortunately, if anything on the page is animating other
1364 // than the movie, it break this optimization since the union of the
1365 // invalid regions will be larger than the plugin.
1366 //
1367 // This code optimizes that case, where we can still avoid painting in
1368 // WebKit and filling the background (which can be slow) and just painting
1369 // the plugin. Unlike the DoDeferredUpdate case, an extra copy is still
1370 // required.
[email protected]df59dd42012-09-14 22:56:301371 SkAutoCanvasRestore auto_restore(canvas, true);
1372 canvas->scale(device_scale_factor_, device_scale_factor_);
[email protected]6bd867b2013-07-24 22:10:201373 optimized_instance->Paint(canvas, optimized_copy_location, rect);
[email protected]ea43e752012-09-06 22:39:211374 canvas->restore();
[email protected]20790a222013-07-25 02:23:051375#endif
[email protected]719b36f2010-12-22 20:36:461376 } else {
1377 // Normal painting case.
[email protected]c1e6cc062013-08-24 03:35:351378 base::TimeTicks start_time;
1379 if (!is_accelerated_compositing_active_)
1380 start_time = legacy_software_mode_stats_->StartRecording();
[email protected]63ab54262012-11-09 15:58:451381
[email protected]6bd867b2013-07-24 22:10:201382 webwidget_->paint(canvas, rect);
[email protected]63ab54262012-11-09 15:58:451383
[email protected]c1e6cc062013-08-24 03:35:351384 if (!is_accelerated_compositing_active_) {
[email protected]63ab54262012-11-09 15:58:451385 base::TimeDelta paint_time =
[email protected]c1e6cc062013-08-24 03:35:351386 legacy_software_mode_stats_->EndRecording(start_time);
1387 int64 painted_pixel_count = rect.width() * rect.height();
1388 legacy_software_mode_stats_->AddPaint(paint_time, painted_pixel_count);
[email protected]63ab54262012-11-09 15:58:451389 }
[email protected]719b36f2010-12-22 20:36:461390
1391 // Flush to underlying bitmap. TODO(darin): is this needed?
[email protected]62f2e802011-05-26 14:28:351392 skia::GetTopDevice(*canvas)->accessBitmap(false);
[email protected]719b36f2010-12-22 20:36:461393 }
initial.commit09911bf2008-07-26 23:55:291394
[email protected]4fb66842009-12-04 21:41:001395 PaintDebugBorder(rect, canvas);
[email protected]4fb66842009-12-04 21:41:001396 canvas->restore();
1397}
1398
1399void RenderWidget::PaintDebugBorder(const gfx::Rect& rect,
1400 skia::PlatformCanvas* canvas) {
1401 static bool kPaintBorder =
1402 CommandLine::ForCurrentProcess()->HasSwitch(switches::kShowPaintRects);
1403 if (!kPaintBorder)
1404 return;
1405
[email protected]53d3f302009-12-21 04:42:051406 // Cycle through these colors to help distinguish new paint rects.
1407 const SkColor colors[] = {
1408 SkColorSetARGB(0x3F, 0xFF, 0, 0),
1409 SkColorSetARGB(0x3F, 0xFF, 0, 0xFF),
1410 SkColorSetARGB(0x3F, 0, 0, 0xFF),
1411 };
1412 static int color_selector = 0;
1413
[email protected]4fb66842009-12-04 21:41:001414 SkPaint paint;
1415 paint.setStyle(SkPaint::kStroke_Style);
[email protected]53d3f302009-12-21 04:42:051416 paint.setColor(colors[color_selector++ % arraysize(colors)]);
[email protected]4fb66842009-12-04 21:41:001417 paint.setStrokeWidth(1);
1418
1419 SkIRect irect;
1420 irect.set(rect.x(), rect.y(), rect.right() - 1, rect.bottom() - 1);
1421 canvas->drawIRect(irect, paint);
initial.commit09911bf2008-07-26 23:55:291422}
1423
[email protected]52ccd0ea2011-02-16 01:09:051424void RenderWidget::AnimationCallback() {
[email protected]921244e42011-07-20 16:36:301425 TRACE_EVENT0("renderer", "RenderWidget::AnimationCallback");
[email protected]921244e42011-07-20 16:36:301426 if (!animation_update_pending_) {
1427 TRACE_EVENT0("renderer", "EarlyOut_NoAnimationUpdatePending");
[email protected]7c4329e2011-02-18 22:02:591428 return;
[email protected]921244e42011-07-20 16:36:301429 }
[email protected]bd37ae252011-06-03 01:28:181430 if (!animation_floor_time_.is_null() && IsRenderingVSynced()) {
[email protected]7c4329e2011-02-18 22:02:591431 // Record when we fired (according to base::Time::Now()) relative to when
1432 // we posted the task to quantify how much the base::Time/base::TimeTicks
1433 // skew is affecting animations.
1434 base::TimeDelta animation_callback_delay = base::Time::Now() -
1435 (animation_floor_time_ - base::TimeDelta::FromMilliseconds(16));
1436 UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.AnimationCallbackDelayTime",
1437 animation_callback_delay,
1438 base::TimeDelta::FromMilliseconds(0),
1439 base::TimeDelta::FromMilliseconds(30),
1440 25);
1441 }
[email protected]65225772011-05-12 21:10:241442 DoDeferredUpdateAndSendInputAck();
[email protected]12fbad812009-09-01 18:21:241443}
1444
[email protected]52ccd0ea2011-02-16 01:09:051445void RenderWidget::AnimateIfNeeded() {
[email protected]7c4329e2011-02-18 22:02:591446 if (!animation_update_pending_)
1447 return;
[email protected]bd37ae252011-06-03 01:28:181448
1449 // Target 60FPS if vsync is on. Go as fast as we can if vsync is off.
[email protected]02798a982012-01-27 00:45:331450 base::TimeDelta animationInterval = IsRenderingVSynced() ?
1451 base::TimeDelta::FromMilliseconds(16) : base::TimeDelta();
[email protected]bd37ae252011-06-03 01:28:181452
[email protected]7c4329e2011-02-18 22:02:591453 base::Time now = base::Time::Now();
[email protected]51e403bb2012-03-02 21:09:451454
1455 // animation_floor_time_ is the earliest time that we should animate when
1456 // using the dead reckoning software scheduler. If we're using swapbuffers
1457 // complete callbacks to rate limit, we can ignore this floor.
1458 if (now >= animation_floor_time_ || num_swapbuffers_complete_pending_ > 0) {
[email protected]921244e42011-07-20 16:36:301459 TRACE_EVENT0("renderer", "RenderWidget::AnimateIfNeeded")
[email protected]02798a982012-01-27 00:45:331460 animation_floor_time_ = now + animationInterval;
[email protected]bd37ae252011-06-03 01:28:181461 // Set a timer to call us back after animationInterval before
[email protected]7c4329e2011-02-18 22:02:591462 // running animation callbacks so that if a callback requests another
1463 // we'll be sure to run it at the proper time.
[email protected]350ce8702012-03-09 04:23:381464 animation_timer_.Stop();
1465 animation_timer_.Start(FROM_HERE, animationInterval, this,
1466 &RenderWidget::AnimationCallback);
[email protected]7c4329e2011-02-18 22:02:591467 animation_update_pending_ = false;
[email protected]ba91a792013-02-06 09:48:281468 if (is_accelerated_compositing_active_ && compositor_) {
[email protected]e197af302014-02-07 09:36:491469 compositor_->UpdateAnimations(base::TimeTicks::Now());
[email protected]8926c602013-01-23 05:32:061470 } else {
[email protected]635353c2013-03-06 09:11:201471 double frame_begin_time =
1472 (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
1473 webwidget_->animate(frame_begin_time);
[email protected]8926c602013-01-23 05:32:061474 }
[email protected]7c4329e2011-02-18 22:02:591475 return;
[email protected]5f8b1022011-01-21 23:34:501476 }
[email protected]bd37ae252011-06-03 01:28:181477 TRACE_EVENT0("renderer", "EarlyOut_AnimatedTooRecently");
[email protected]350ce8702012-03-09 04:23:381478 if (!animation_timer_.IsRunning()) {
1479 // This code uses base::Time::Now() to calculate the floor and next fire
1480 // time because javascript's Date object uses base::Time::Now(). The
1481 // message loop uses base::TimeTicks, which on windows can have a
1482 // different granularity than base::Time.
1483 // The upshot of all this is that this function might be called before
1484 // base::Time::Now() has advanced past the animation_floor_time_. To
1485 // avoid exposing this delay to javascript, we keep posting delayed
1486 // tasks until base::Time::Now() has advanced far enough.
1487 base::TimeDelta delay = animation_floor_time_ - now;
1488 animation_timer_.Start(FROM_HERE, delay, this,
1489 &RenderWidget::AnimationCallback);
1490 }
[email protected]5f8b1022011-01-21 23:34:501491}
1492
[email protected]bd37ae252011-06-03 01:28:181493bool RenderWidget::IsRenderingVSynced() {
1494 // TODO(nduca): Forcing a driver to disable vsync (e.g. in a control panel) is
1495 // not caught by this check. This will lead to artificially low frame rates
1496 // for people who force vsync off at a driver level and expect Chrome to speed
1497 // up.
1498 return !has_disable_gpu_vsync_switch_;
1499}
1500
[email protected]65225772011-05-12 21:10:241501void RenderWidget::InvalidationCallback() {
[email protected]50312bf2011-06-22 23:30:061502 TRACE_EVENT0("renderer", "RenderWidget::InvalidationCallback");
[email protected]65225772011-05-12 21:10:241503 invalidation_task_posted_ = false;
1504 DoDeferredUpdateAndSendInputAck();
1505}
1506
[email protected]fd847792013-10-24 17:12:351507void RenderWidget::FlushPendingInputEventAck() {
[email protected]d8a8ecb2013-10-23 18:03:071508 if (pending_input_event_ack_)
1509 Send(pending_input_event_ack_.release());
[email protected]fd847792013-10-24 17:12:351510 total_input_handling_time_this_frame_ = base::TimeDelta();
1511}
1512
1513void RenderWidget::DoDeferredUpdateAndSendInputAck() {
1514 DoDeferredUpdate();
1515 FlushPendingInputEventAck();
[email protected]ee3d3ad2011-02-04 00:42:211516}
1517
[email protected]552e6002009-11-19 05:24:571518void RenderWidget::DoDeferredUpdate() {
[email protected]366ae242011-05-10 02:23:581519 TRACE_EVENT0("renderer", "RenderWidget::DoDeferredUpdate");
[email protected]fc8bde1a2013-07-04 08:54:071520 TRACE_EVENT_SCOPED_SAMPLING_STATE("Chrome", "Paint");
[email protected]71e2f0a2011-03-15 22:25:081521
[email protected]65225772011-05-12 21:10:241522 if (!webwidget_)
initial.commit09911bf2008-07-26 23:55:291523 return;
[email protected]05a980d7a2012-02-07 22:16:421524
[email protected]fc4404d2012-11-07 19:53:301525 if (!init_complete_) {
1526 TRACE_EVENT0("renderer", "EarlyOut_InitNotComplete");
[email protected]05a980d7a2012-02-07 22:16:421527 return;
1528 }
[email protected]aa4117f2011-12-09 22:19:211529 if (update_reply_pending_) {
[email protected]65225772011-05-12 21:10:241530 TRACE_EVENT0("renderer", "EarlyOut_UpdateReplyPending");
1531 return;
1532 }
[email protected]9ca84622011-06-02 23:46:391533 if (is_accelerated_compositing_active_ &&
1534 num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending) {
[email protected]65225772011-05-12 21:10:241535 TRACE_EVENT0("renderer", "EarlyOut_MaxSwapBuffersPending");
1536 return;
1537 }
initial.commit09911bf2008-07-26 23:55:291538
[email protected]552e6002009-11-19 05:24:571539 // Suppress updating when we are hidden.
[email protected]e3d92a7f2013-01-10 02:35:051540 if (is_hidden_ || size_.IsEmpty() || is_swapped_out_) {
[email protected]552e6002009-11-19 05:24:571541 paint_aggregator_.ClearPendingUpdate();
initial.commit09911bf2008-07-26 23:55:291542 needs_repainting_on_restore_ = true;
[email protected]65225772011-05-12 21:10:241543 TRACE_EVENT0("renderer", "EarlyOut_NotVisible");
initial.commit09911bf2008-07-26 23:55:291544 return;
1545 }
1546
[email protected]0fb93f52011-05-18 23:13:561547 // Tracking of frame rate jitter
[email protected]de2cf8c2013-10-25 19:46:461548 base::TimeTicks frame_begin_ticks = gfx::FrameTime::Now();
[email protected]33004772013-11-12 09:49:231549 InstrumentWillBeginFrame(0);
[email protected]52ccd0ea2011-02-16 01:09:051550 AnimateIfNeeded();
[email protected]5f8b1022011-01-21 23:34:501551
[email protected]f98d7e3c2010-09-13 22:30:461552 // Layout may generate more invalidation. It may also enable the
1553 // GPU acceleration, so make sure to run layout before we send the
1554 // GpuRenderingActivated message.
1555 webwidget_->layout();
1556
[email protected]793b2d62013-06-11 00:43:251557 // Check for whether we need to track swap buffers. We need to do that after
1558 // layout() because it may have switched us to accelerated compositing.
1559 if (is_accelerated_compositing_active_)
1560 using_asynchronous_swapbuffers_ = SupportsAsynchronousSwapBuffers();
1561
[email protected]dcca3aa92012-02-17 23:03:371562 // The following two can result in further layout and possibly
1563 // enable GPU acceleration so they need to be called before any painting
1564 // is done.
[email protected]cb9e2632013-06-18 11:26:471565 UpdateTextInputType();
[email protected]a80aea72014-03-14 21:10:151566#if defined(OS_ANDROID)
1567 UpdateSelectionRootBounds();
1568#endif
[email protected]dcca3aa92012-02-17 23:03:371569 UpdateSelectionBounds();
1570
[email protected]5f8b1022011-01-21 23:34:501571 // Suppress painting if nothing is dirty. This has to be done after updating
1572 // animations running layout as these may generate further invalidations.
[email protected]65225772011-05-12 21:10:241573 if (!paint_aggregator_.HasPendingUpdate()) {
1574 TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
[email protected]38ce4e7b2013-02-23 06:17:371575 InstrumentDidCancelFrame();
[email protected]5f8b1022011-01-21 23:34:501576 return;
[email protected]65225772011-05-12 21:10:241577 }
[email protected]5f8b1022011-01-21 23:34:501578
[email protected]479b0172012-10-29 19:27:091579 if (!is_accelerated_compositing_active_ &&
[email protected]cb6430932012-10-31 00:53:361580 !is_threaded_compositing_enabled_ &&
[email protected]d8a6c5d12013-09-23 04:37:101581 (ForceCompositingModeEnabled() ||
1582 was_accelerated_compositing_ever_active_)) {
[email protected]479b0172012-10-29 19:27:091583 webwidget_->enterForceCompositingMode(true);
1584 }
1585
[email protected]872ae5b2011-05-26 20:20:501586 if (!last_do_deferred_update_time_.is_null()) {
[email protected]0fb93f52011-05-18 23:13:561587 base::TimeDelta delay = frame_begin_ticks - last_do_deferred_update_time_;
[email protected]d0be63772011-12-20 23:18:041588 if (is_accelerated_compositing_active_) {
[email protected]0fb93f52011-05-18 23:13:561589 UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.AccelDoDeferredUpdateDelay",
1590 delay,
1591 base::TimeDelta::FromMilliseconds(1),
[email protected]b604cf82012-07-19 05:31:411592 base::TimeDelta::FromMilliseconds(120),
1593 60);
[email protected]d0be63772011-12-20 23:18:041594 } else {
[email protected]0fb93f52011-05-18 23:13:561595 UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.SoftwareDoDeferredUpdateDelay",
1596 delay,
1597 base::TimeDelta::FromMilliseconds(1),
[email protected]b604cf82012-07-19 05:31:411598 base::TimeDelta::FromMilliseconds(120),
1599 60);
[email protected]d0be63772011-12-20 23:18:041600 }
[email protected]872ae5b2011-05-26 20:20:501601
1602 // Calculate filtered time per frame:
1603 float frame_time_elapsed = static_cast<float>(delay.InSecondsF());
1604 filtered_time_per_frame_ =
1605 0.9f * filtered_time_per_frame_ + 0.1f * frame_time_elapsed;
[email protected]0fb93f52011-05-18 23:13:561606 }
1607 last_do_deferred_update_time_ = frame_begin_ticks;
1608
[email protected]fef5e3972012-08-07 03:59:471609 if (!is_accelerated_compositing_active_) {
[email protected]922c6e1f2013-10-09 04:04:091610 legacy_software_mode_stats_->IncrementFrameCount(1, true);
[email protected]adbe30f2013-10-11 21:12:331611 cc::BenchmarkInstrumentation::IssueMainThreadRenderingStatsEvent(
1612 legacy_software_mode_stats_->main_thread_rendering_stats());
[email protected]c1e6cc062013-08-24 03:35:351613 legacy_software_mode_stats_->AccumulateAndClearMainThreadStats();
[email protected]fef5e3972012-08-07 03:59:471614 }
1615
[email protected]552e6002009-11-19 05:24:571616 // OK, save the pending update to a local since painting may cause more
initial.commit09911bf2008-07-26 23:55:291617 // invalidation. Some WebCore rendering objects only layout when painted.
[email protected]dd015812010-12-06 23:39:301618 PaintAggregator::PendingUpdate update;
1619 paint_aggregator_.PopPendingUpdate(&update);
initial.commit09911bf2008-07-26 23:55:291620
[email protected]53d3f302009-12-21 04:42:051621 gfx::Rect scroll_damage = update.GetScrollDamage();
[email protected]ce112fe2012-10-29 22:52:181622 gfx::Rect bounds = gfx::UnionRects(update.GetPaintBounds(), scroll_damage);
initial.commit09911bf2008-07-26 23:55:291623
[email protected]ca4847f2010-09-24 05:39:151624 // A plugin may be able to do an optimized paint. First check this, in which
1625 // case we can skip all of the bitmap generation and regular paint code.
[email protected]719b36f2010-12-22 20:36:461626 // This optimization allows PPAPI plugins that declare themselves on top of
1627 // the page (like a traditional windowed plugin) to be able to animate (think
1628 // movie playing) without repeatedly re-painting the page underneath, or
1629 // copying the plugin backing store (since we can send the plugin's backing
1630 // store directly to the browser).
1631 //
1632 // This optimization only works when the entire invalid region is contained
1633 // within the plugin. There is a related optimization in PaintRect for the
1634 // case where there may be multiple invalid regions.
[email protected]ca4847f2010-09-24 05:39:151635 TransportDIB* dib = NULL;
[email protected]ca4847f2010-09-24 05:39:151636 gfx::Rect optimized_copy_rect, optimized_copy_location;
[email protected]0f3a2d12012-09-01 03:37:201637 float dib_scale_factor = 1;
[email protected]aa4117f2011-12-09 22:19:211638 DCHECK(!pending_update_params_.get());
1639 pending_update_params_.reset(new ViewHostMsg_UpdateRect_Params);
[email protected]990278ff2012-11-13 02:12:551640 pending_update_params_->scroll_delta = update.scroll_delta;
[email protected]aa4117f2011-12-09 22:19:211641 pending_update_params_->scroll_rect = update.scroll_rect;
1642 pending_update_params_->view_size = size_;
[email protected]aa4117f2011-12-09 22:19:211643 pending_update_params_->plugin_window_moves.swap(plugin_window_moves_);
1644 pending_update_params_->flags = next_paint_flags_;
1645 pending_update_params_->scroll_offset = GetScrollOffset();
1646 pending_update_params_->needs_ack = true;
[email protected]7ded9f12012-06-13 20:47:091647 pending_update_params_->scale_factor = device_scale_factor_;
[email protected]aa4117f2011-12-09 22:19:211648 next_paint_flags_ = 0;
[email protected]ea3ee0a2012-05-15 03:43:091649 need_update_rect_for_auto_resize_ = false;
[email protected]aa4117f2011-12-09 22:19:211650
[email protected]256737c2013-06-08 04:39:101651 if (!is_accelerated_compositing_active_)
[email protected]98a04472013-12-23 20:42:501652 pending_update_params_->latency_info.swap(latency_info_);
[email protected]256737c2013-06-08 04:39:101653
[email protected]98a04472013-12-23 20:42:501654 latency_info_.clear();
[email protected]256737c2013-06-08 04:39:101655
[email protected]ca4847f2010-09-24 05:39:151656 if (update.scroll_rect.IsEmpty() &&
[email protected]a79d8a632010-11-18 22:35:561657 !is_accelerated_compositing_active_ &&
[email protected]ca4847f2010-09-24 05:39:151658 GetBitmapForOptimizedPluginPaint(bounds, &dib, &optimized_copy_location,
[email protected]0f3a2d12012-09-01 03:37:201659 &optimized_copy_rect,
1660 &dib_scale_factor)) {
[email protected]2df1b362011-01-21 21:22:271661 // Only update the part of the plugin that actually changed.
[email protected]d4030502012-10-23 16:51:471662 optimized_copy_rect.Intersect(bounds);
[email protected]aa4117f2011-12-09 22:19:211663 pending_update_params_->bitmap = dib->id();
1664 pending_update_params_->bitmap_rect = optimized_copy_location;
1665 pending_update_params_->copy_rects.push_back(optimized_copy_rect);
[email protected]0f3a2d12012-09-01 03:37:201666 pending_update_params_->scale_factor = dib_scale_factor;
[email protected]a79d8a632010-11-18 22:35:561667 } else if (!is_accelerated_compositing_active_) {
[email protected]f98d7e3c2010-09-13 22:30:461668 // Compute a buffer for painting and cache it.
[email protected]4889bd212013-02-11 22:23:101669
1670 bool fractional_scale = device_scale_factor_ -
1671 static_cast<int>(device_scale_factor_) != 0;
1672 if (fractional_scale) {
1673 // Damage might not be DIP aligned. Inflate damage to compensate.
1674 bounds.Inset(-1, -1);
1675 bounds.Intersect(gfx::Rect(size_));
1676 }
1677
1678 gfx::Rect pixel_bounds = gfx::ToEnclosingRect(
[email protected]ce112fe2012-10-29 22:52:181679 gfx::ScaleRect(bounds, device_scale_factor_));
[email protected]4889bd212013-02-11 22:23:101680
[email protected]ca4847f2010-09-24 05:39:151681 scoped_ptr<skia::PlatformCanvas> canvas(
[email protected]b4d08452010-10-05 17:34:351682 RenderProcess::current()->GetDrawingCanvas(&current_paint_buf_,
[email protected]f1cccb32012-06-06 18:29:591683 pixel_bounds));
[email protected]59383c782013-04-17 16:43:271684 if (!canvas) {
[email protected]f98d7e3c2010-09-13 22:30:461685 NOTREACHED();
1686 return;
1687 }
[email protected]cef3362f2009-12-21 17:48:451688
[email protected]f98d7e3c2010-09-13 22:30:461689 // We may get back a smaller canvas than we asked for.
1690 // TODO(darin): This seems like it could cause painting problems!
[email protected]f1cccb32012-06-06 18:29:591691 DCHECK_EQ(pixel_bounds.width(), canvas->getDevice()->width());
1692 DCHECK_EQ(pixel_bounds.height(), canvas->getDevice()->height());
1693 pixel_bounds.set_width(canvas->getDevice()->width());
1694 pixel_bounds.set_height(canvas->getDevice()->height());
1695 bounds.set_width(pixel_bounds.width() / device_scale_factor_);
1696 bounds.set_height(pixel_bounds.height() / device_scale_factor_);
[email protected]53d3f302009-12-21 04:42:051697
[email protected]f98d7e3c2010-09-13 22:30:461698 HISTOGRAM_COUNTS_100("MPArch.RW_PaintRectCount", update.paint_rects.size());
1699
[email protected]aa4117f2011-12-09 22:19:211700 pending_update_params_->bitmap = current_paint_buf_->id();
1701 pending_update_params_->bitmap_rect = bounds;
1702
1703 std::vector<gfx::Rect>& copy_rects = pending_update_params_->copy_rects;
[email protected]f98d7e3c2010-09-13 22:30:461704 // The scroll damage is just another rectangle to paint and copy.
1705 copy_rects.swap(update.paint_rects);
1706 if (!scroll_damage.IsEmpty())
1707 copy_rects.push_back(scroll_damage);
1708
[email protected]4889bd212013-02-11 22:23:101709 for (size_t i = 0; i < copy_rects.size(); ++i) {
1710 gfx::Rect rect = copy_rects[i];
1711 if (fractional_scale) {
1712 // Damage might not be DPI aligned. Inflate rect to compensate.
1713 rect.Inset(-1, -1);
1714 }
1715 PaintRect(rect, pixel_bounds.origin(), canvas.get());
1716 }
[email protected]60a50072012-01-11 02:05:351717
1718 // Software FPS tick for performance tests. The accelerated path traces the
[email protected]bea16ce2014-01-11 23:01:291719 // frame events in didCommitAndDrawCompositorFrame. See
1720 // tab_capture_performancetest.cc.
[email protected]60a50072012-01-11 02:05:351721 // NOTE: Tests may break if this event is renamed or moved.
[email protected]c76faea2013-03-26 07:42:421722 UNSHIPPED_TRACE_EVENT_INSTANT0("test_fps", "TestFrameTickSW",
1723 TRACE_EVENT_SCOPE_THREAD);
[email protected]f98d7e3c2010-09-13 22:30:461724 } else { // Accelerated compositing path
1725 // Begin painting.
[email protected]aa4117f2011-12-09 22:19:211726 // If painting is done via the gpu process then we don't set any damage
1727 // rects to save the browser process from doing unecessary work.
1728 pending_update_params_->bitmap_rect = bounds;
1729 pending_update_params_->scroll_rect = gfx::Rect();
1730 // We don't need an ack, because we're not sharing a DIB with the browser.
1731 // If it needs to (e.g. composited UI), the GPU process does its own ACK
1732 // with the browser for the GPU surface.
1733 pending_update_params_->needs_ack = false;
[email protected]f0c2a242013-03-15 19:34:521734 Composite(frame_begin_ticks);
[email protected]f98d7e3c2010-09-13 22:30:461735 }
1736
[email protected]936c6f52011-12-13 01:35:261737 // If we're holding a pending input event ACK, send the ACK before sending the
1738 // UpdateReply message so we can receive another input event before the
1739 // UpdateRect_ACK on platforms where the UpdateRect_ACK is sent from within
1740 // the UpdateRect IPC message handler.
[email protected]fd847792013-10-24 17:12:351741 FlushPendingInputEventAck();
[email protected]936c6f52011-12-13 01:35:261742
[email protected]ab543072013-01-25 04:38:151743 // If Composite() called SwapBuffers, pending_update_params_ will be reset (in
[email protected]aa4117f2011-12-09 22:19:211744 // OnSwapBuffersPosted), meaning a message has been added to the
1745 // updates_pending_swap_ queue, that will be sent later. Otherwise, we send
1746 // the message now.
[email protected]59383c782013-04-17 16:43:271747 if (pending_update_params_) {
[email protected]aa4117f2011-12-09 22:19:211748 // sending an ack to browser process that the paint is complete...
1749 update_reply_pending_ = pending_update_params_->needs_ack;
1750 Send(new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_));
1751 pending_update_params_.reset();
[email protected]b167ca662010-05-14 00:05:341752 }
[email protected]53d3f302009-12-21 04:42:051753
[email protected]29ed96a2012-02-04 18:12:161754 // If we're software rendering then we're done initiating the paint.
1755 if (!is_accelerated_compositing_active_)
1756 DidInitiatePaint();
initial.commit09911bf2008-07-26 23:55:291757}
1758
[email protected]f0c2a242013-03-15 19:34:521759void RenderWidget::Composite(base::TimeTicks frame_begin_time) {
[email protected]ab543072013-01-25 04:38:151760 DCHECK(is_accelerated_compositing_active_);
[email protected]ba91a792013-02-06 09:48:281761 if (compositor_) // TODO(jamesr): Figure out how this can be null.
[email protected]f0c2a242013-03-15 19:34:521762 compositor_->Composite(frame_begin_time);
[email protected]ab543072013-01-25 04:38:151763}
1764
initial.commit09911bf2008-07-26 23:55:291765///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461766// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291767
[email protected]4873c7d2009-07-16 06:36:281768void RenderWidget::didInvalidateRect(const WebRect& rect) {
[email protected]552e6002009-11-19 05:24:571769 // The invalidated rect might be outside the bounds of the view.
[email protected]ee8d6fd2010-05-26 17:05:481770 gfx::Rect view_rect(size_);
[email protected]ce112fe2012-10-29 22:52:181771 gfx::Rect damaged_rect = gfx::IntersectRects(view_rect, rect);
[email protected]552e6002009-11-19 05:24:571772 if (damaged_rect.IsEmpty())
initial.commit09911bf2008-07-26 23:55:291773 return;
1774
[email protected]552e6002009-11-19 05:24:571775 paint_aggregator_.InvalidateRect(damaged_rect);
1776
1777 // We may not need to schedule another call to DoDeferredUpdate.
[email protected]65225772011-05-12 21:10:241778 if (invalidation_task_posted_)
[email protected]552e6002009-11-19 05:24:571779 return;
1780 if (!paint_aggregator_.HasPendingUpdate())
1781 return;
[email protected]aa4117f2011-12-09 22:19:211782 if (update_reply_pending_ ||
[email protected]65225772011-05-12 21:10:241783 num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending)
1784 return;
1785
1786 // When GPU rendering, combine pending animations and invalidations into
1787 // a single update.
[email protected]816edc62012-03-17 01:27:221788 if (is_accelerated_compositing_active_ &&
1789 animation_update_pending_ &&
1790 animation_timer_.IsRunning())
[email protected]552e6002009-11-19 05:24:571791 return;
1792
1793 // Perform updating asynchronously. This serves two purposes:
initial.commit09911bf2008-07-26 23:55:291794 // 1) Ensures that we call WebView::Paint without a bunch of other junk
1795 // on the call stack.
1796 // 2) Allows us to collect more damage rects before painting to help coalesce
1797 // the work that we will need to do.
[email protected]65225772011-05-12 21:10:241798 invalidation_task_posted_ = true;
[email protected]dd32b1272013-05-04 14:17:111799 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:211800 FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
initial.commit09911bf2008-07-26 23:55:291801}
1802
[email protected]990278ff2012-11-13 02:12:551803void RenderWidget::didScrollRect(int dx, int dy,
1804 const WebRect& clip_rect) {
[email protected]f98d7e3c2010-09-13 22:30:461805 // Drop scrolls on the floor when we are in compositing mode.
1806 // TODO(nduca): stop WebViewImpl from sending scrolls in the first place.
[email protected]a79d8a632010-11-18 22:35:561807 if (is_accelerated_compositing_active_)
[email protected]f98d7e3c2010-09-13 22:30:461808 return;
1809
[email protected]552e6002009-11-19 05:24:571810 // The scrolled rect might be outside the bounds of the view.
[email protected]ee8d6fd2010-05-26 17:05:481811 gfx::Rect view_rect(size_);
[email protected]ce112fe2012-10-29 22:52:181812 gfx::Rect damaged_rect = gfx::IntersectRects(view_rect, clip_rect);
[email protected]552e6002009-11-19 05:24:571813 if (damaged_rect.IsEmpty())
initial.commit09911bf2008-07-26 23:55:291814 return;
1815
[email protected]990278ff2012-11-13 02:12:551816 paint_aggregator_.ScrollRect(gfx::Vector2d(dx, dy), damaged_rect);
[email protected]552e6002009-11-19 05:24:571817
1818 // We may not need to schedule another call to DoDeferredUpdate.
[email protected]65225772011-05-12 21:10:241819 if (invalidation_task_posted_)
[email protected]552e6002009-11-19 05:24:571820 return;
1821 if (!paint_aggregator_.HasPendingUpdate())
1822 return;
[email protected]aa4117f2011-12-09 22:19:211823 if (update_reply_pending_ ||
[email protected]65225772011-05-12 21:10:241824 num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending)
1825 return;
1826
1827 // When GPU rendering, combine pending animations and invalidations into
1828 // a single update.
[email protected]816edc62012-03-17 01:27:221829 if (is_accelerated_compositing_active_ &&
1830 animation_update_pending_ &&
1831 animation_timer_.IsRunning())
[email protected]552e6002009-11-19 05:24:571832 return;
1833
1834 // Perform updating asynchronously. This serves two purposes:
1835 // 1) Ensures that we call WebView::Paint without a bunch of other junk
1836 // on the call stack.
1837 // 2) Allows us to collect more damage rects before painting to help coalesce
1838 // the work that we will need to do.
[email protected]65225772011-05-12 21:10:241839 invalidation_task_posted_ = true;
[email protected]dd32b1272013-05-04 14:17:111840 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:211841 FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
initial.commit09911bf2008-07-26 23:55:291842}
1843
[email protected]244ac1892011-12-02 17:04:471844void RenderWidget::didAutoResize(const WebSize& new_size) {
[email protected]ea3ee0a2012-05-15 03:43:091845 if (size_.width() != new_size.width || size_.height() != new_size.height) {
[email protected]eac2b362013-05-22 07:01:451846 size_ = new_size;
[email protected]20fbfc22013-05-08 20:50:581847
[email protected]eac2b362013-05-22 07:01:451848 // If we don't clear PaintAggregator after changing autoResize state, then
1849 // we might end up in a situation where bitmap_rect is larger than the
1850 // view_size. By clearing PaintAggregator, we ensure that we don't end up
1851 // with invalid damage rects.
1852 paint_aggregator_.ClearPendingUpdate();
1853
[email protected]5b45ad42013-10-25 00:42:041854 if (resizing_mode_selector_->is_synchronous_mode()) {
[email protected]eac2b362013-05-22 07:01:451855 WebRect new_pos(rootWindowRect().x,
1856 rootWindowRect().y,
1857 new_size.width,
1858 new_size.height);
1859 view_screen_rect_ = new_pos;
1860 window_screen_rect_ = new_pos;
[email protected]8be1c582013-03-06 00:55:031861 }
[email protected]20fbfc22013-05-08 20:50:581862
[email protected]eac2b362013-05-22 07:01:451863 AutoResizeCompositor();
[email protected]20fbfc22013-05-08 20:50:581864
[email protected]5b45ad42013-10-25 00:42:041865 if (!resizing_mode_selector_->is_synchronous_mode())
[email protected]20fbfc22013-05-08 20:50:581866 need_update_rect_for_auto_resize_ = true;
[email protected]ea3ee0a2012-05-15 03:43:091867 }
[email protected]244ac1892011-12-02 17:04:471868}
1869
[email protected]3a1c8a8032013-03-18 22:35:321870void RenderWidget::AutoResizeCompositor() {
[email protected]97e1bf72013-03-06 14:06:051871 physical_backing_size_ = gfx::ToCeiledSize(gfx::ScaleSize(size_,
1872 device_scale_factor_));
1873 if (compositor_)
1874 compositor_->setViewportSize(size_, physical_backing_size_);
1875}
1876
[email protected]c0b0bd12014-03-13 00:39:581877// FIXME: To be removed as soon as chromium and blink side changes land
1878// didActivateCompositor with parameters is still kept in order to land
1879// these changes s-chromium - https://codereview.chromium.org/137893025/.
1880// s-blink - https://codereview.chromium.org/138523003/
[email protected]91acd1c2012-03-14 08:32:391881void RenderWidget::didActivateCompositor(int input_handler_identifier) {
[email protected]ea162f92011-10-04 23:08:221882 TRACE_EVENT0("gpu", "RenderWidget::didActivateCompositor");
1883
[email protected]c63b4d42012-04-26 01:01:071884#if !defined(OS_MACOSX)
[email protected]aa4117f2011-12-09 22:19:211885 if (!is_accelerated_compositing_active_) {
1886 // When not in accelerated compositing mode, in certain cases (e.g. waiting
1887 // for a resize or if no backing store) the RenderWidgetHost is blocking the
1888 // browser's UI thread for some time, waiting for an UpdateRect. If we are
1889 // going to switch to accelerated compositing, the GPU process may need
1890 // round-trips to the browser's UI thread before finishing the frame,
1891 // causing deadlocks if we delay the UpdateRect until we receive the
1892 // OnSwapBuffersComplete. So send a dummy message that will unblock the
[email protected]c63b4d42012-04-26 01:01:071893 // browser's UI thread. This is not necessary on Mac, because SwapBuffers
1894 // now unblocks GetBackingStore on Mac.
[email protected]aa4117f2011-12-09 22:19:211895 Send(new ViewHostMsg_UpdateIsDelayed(routing_id_));
1896 }
[email protected]c63b4d42012-04-26 01:01:071897#endif
[email protected]aa4117f2011-12-09 22:19:211898
[email protected]ea162f92011-10-04 23:08:221899 is_accelerated_compositing_active_ = true;
[email protected]50bd6452010-11-27 19:39:421900 Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
[email protected]65225772011-05-12 21:10:241901 routing_id_, is_accelerated_compositing_active_));
[email protected]d8a6c5d12013-09-23 04:37:101902
1903 if (!was_accelerated_compositing_ever_active_) {
1904 was_accelerated_compositing_ever_active_ = true;
1905 webwidget_->enterForceCompositingMode(true);
1906 }
[email protected]ea162f92011-10-04 23:08:221907}
1908
[email protected]c0b0bd12014-03-13 00:39:581909void RenderWidget::didActivateCompositor() {
1910 TRACE_EVENT0("gpu", "RenderWidget::didActivateCompositor");
1911
1912#if !defined(OS_MACOSX)
1913 if (!is_accelerated_compositing_active_) {
1914 // When not in accelerated compositing mode, in certain cases (e.g. waiting
1915 // for a resize or if no backing store) the RenderWidgetHost is blocking the
1916 // browser's UI thread for some time, waiting for an UpdateRect. If we are
1917 // going to switch to accelerated compositing, the GPU process may need
1918 // round-trips to the browser's UI thread before finishing the frame,
1919 // causing deadlocks if we delay the UpdateRect until we receive the
1920 // OnSwapBuffersComplete. So send a dummy message that will unblock the
1921 // browser's UI thread. This is not necessary on Mac, because SwapBuffers
1922 // now unblocks GetBackingStore on Mac.
1923 Send(new ViewHostMsg_UpdateIsDelayed(routing_id_));
1924 }
1925#endif
1926
1927 is_accelerated_compositing_active_ = true;
1928 Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
1929 routing_id_, is_accelerated_compositing_active_));
1930
1931 if (!was_accelerated_compositing_ever_active_) {
1932 was_accelerated_compositing_ever_active_ = true;
1933 webwidget_->enterForceCompositingMode(true);
1934 }
1935}
1936
[email protected]ea162f92011-10-04 23:08:221937void RenderWidget::didDeactivateCompositor() {
1938 TRACE_EVENT0("gpu", "RenderWidget::didDeactivateCompositor");
1939
1940 is_accelerated_compositing_active_ = false;
1941 Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
1942 routing_id_, is_accelerated_compositing_active_));
1943
[email protected]ea162f92011-10-04 23:08:221944 if (using_asynchronous_swapbuffers_)
[email protected]65225772011-05-12 21:10:241945 using_asynchronous_swapbuffers_ = false;
[email protected]479b0172012-10-29 19:27:091946
1947 // In single-threaded mode, we exit force compositing mode and re-enter in
1948 // DoDeferredUpdate() if appropriate. In threaded compositing mode,
1949 // DoDeferredUpdate() is bypassed and WebKit is responsible for exiting and
1950 // entering force compositing mode at the appropriate times.
[email protected]cb6430932012-10-31 00:53:361951 if (!is_threaded_compositing_enabled_)
[email protected]479b0172012-10-29 19:27:091952 webwidget_->enterForceCompositingMode(false);
[email protected]a79d8a632010-11-18 22:35:561953}
1954
[email protected]e195e582013-03-08 01:32:591955void RenderWidget::initializeLayerTreeView() {
[email protected]c5fa4c42013-07-20 05:47:371956 compositor_ = RenderWidgetCompositor::Create(
1957 this, is_threaded_compositing_enabled_);
[email protected]e195e582013-03-08 01:32:591958 if (!compositor_)
1959 return;
1960
1961 compositor_->setViewportSize(size_, physical_backing_size_);
1962 if (init_complete_)
1963 compositor_->setSurfaceReady();
1964}
1965
[email protected]180ef242013-11-07 06:50:461966blink::WebLayerTreeView* RenderWidget::layerTreeView() {
[email protected]ba91a792013-02-06 09:48:281967 return compositor_.get();
[email protected]8926c602013-01-23 05:32:061968}
1969
[email protected]9ed83fe2013-02-27 01:52:281970void RenderWidget::suppressCompositorScheduling(bool enable) {
1971 if (compositor_)
1972 compositor_->SetSuppressScheduleComposite(enable);
1973}
1974
[email protected]9cd43a62012-03-26 08:03:561975void RenderWidget::willBeginCompositorFrame() {
1976 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
[email protected]abe8b3a2012-03-28 21:19:371977
[email protected]cadac622013-06-11 16:46:361978 DCHECK(RenderThreadImpl::current()->compositor_message_loop_proxy().get());
[email protected]abe8b3a2012-03-28 21:19:371979
1980 // The following two can result in further layout and possibly
1981 // enable GPU acceleration so they need to be called before any painting
1982 // is done.
[email protected]cb9e2632013-06-18 11:26:471983 UpdateTextInputType();
1984#if defined(OS_ANDROID)
[email protected]0d1ebed12013-08-05 22:01:131985 UpdateTextInputState(false, true);
[email protected]a80aea72014-03-14 21:10:151986 UpdateSelectionRootBounds();
[email protected]cb9e2632013-06-18 11:26:471987#endif
[email protected]abe8b3a2012-03-28 21:19:371988 UpdateSelectionBounds();
[email protected]9cd43a62012-03-26 08:03:561989}
1990
[email protected]3391a0772012-03-28 00:32:071991void RenderWidget::didBecomeReadyForAdditionalInput() {
1992 TRACE_EVENT0("renderer", "RenderWidget::didBecomeReadyForAdditionalInput");
[email protected]fd847792013-10-24 17:12:351993 FlushPendingInputEventAck();
[email protected]3391a0772012-03-28 00:32:071994}
1995
[email protected]6fceb912013-02-15 06:24:151996void RenderWidget::DidCommitCompositorFrame() {
[email protected]bffc8302014-01-23 20:52:161997 FOR_EACH_OBSERVER(RenderFrameImpl, swapped_out_frames_,
1998 DidCommitCompositorFrame());
[email protected]6fceb912013-02-15 06:24:151999}
2000
[email protected]58264a32011-11-17 23:36:152001void RenderWidget::didCommitAndDrawCompositorFrame() {
[email protected]b5db7eb2011-11-29 09:11:502002 TRACE_EVENT0("gpu", "RenderWidget::didCommitAndDrawCompositorFrame");
[email protected]bea16ce2014-01-11 23:01:292003 // Accelerated FPS tick for performance tests. See
2004 // tab_capture_performancetest.cc. NOTE: Tests may break if this event is
2005 // renamed or moved.
[email protected]c76faea2013-03-26 07:42:422006 UNSHIPPED_TRACE_EVENT_INSTANT0("test_fps", "TestFrameTickGPU",
2007 TRACE_EVENT_SCOPE_THREAD);
[email protected]29ed96a2012-02-04 18:12:162008 // Notify subclasses that we initiated the paint operation.
2009 DidInitiatePaint();
[email protected]58264a32011-11-17 23:36:152010}
2011
2012void RenderWidget::didCompleteSwapBuffers() {
[email protected]404939f2012-06-01 04:06:182013 TRACE_EVENT0("renderer", "RenderWidget::didCompleteSwapBuffers");
2014
2015 // Notify subclasses threaded composited rendering was flushed to the screen.
[email protected]9cd43a62012-03-26 08:03:562016 DidFlushPaint();
2017
[email protected]aa4117f2011-12-09 22:19:212018 if (update_reply_pending_)
[email protected]58264a32011-11-17 23:36:152019 return;
2020
[email protected]ea3ee0a2012-05-15 03:43:092021 if (!next_paint_flags_ &&
2022 !need_update_rect_for_auto_resize_ &&
2023 !plugin_window_moves_.size()) {
[email protected]58264a32011-11-17 23:36:152024 return;
[email protected]ea3ee0a2012-05-15 03:43:092025 }
[email protected]58264a32011-11-17 23:36:152026
2027 ViewHostMsg_UpdateRect_Params params;
2028 params.view_size = size_;
[email protected]58264a32011-11-17 23:36:152029 params.plugin_window_moves.swap(plugin_window_moves_);
2030 params.flags = next_paint_flags_;
2031 params.scroll_offset = GetScrollOffset();
[email protected]b0dda9e22011-12-13 20:30:122032 params.needs_ack = false;
[email protected]7ded9f12012-06-13 20:47:092033 params.scale_factor = device_scale_factor_;
[email protected]58264a32011-11-17 23:36:152034
2035 Send(new ViewHostMsg_UpdateRect(routing_id_, params));
2036 next_paint_flags_ = 0;
[email protected]ea3ee0a2012-05-15 03:43:092037 need_update_rect_for_auto_resize_ = false;
[email protected]58264a32011-11-17 23:36:152038}
2039
[email protected]8b9e52b2014-01-17 16:35:312040void RenderWidget::scheduleComposite() {
2041 if (RenderThreadImpl::current()->compositor_message_loop_proxy().get() &&
2042 compositor_) {
2043 compositor_->setNeedsAnimate();
[email protected]e3067e32013-11-22 07:51:452044 } else {
[email protected]8b9e52b2014-01-17 16:35:312045 // TODO(nduca): replace with something a little less hacky. The reason this
2046 // hack is still used is because the Invalidate-DoDeferredUpdate loop
2047 // contains a lot of host-renderer synchronization logic that is still
2048 // important for the accelerated compositing case. The option of simply
2049 // duplicating all that code is less desirable than "faking out" the
2050 // invalidation path using a magical damage rect.
2051 didInvalidateRect(WebRect(0, 0, 1, 1));
2052 }
2053}
2054
2055void RenderWidget::scheduleAnimation() {
2056 if (animation_update_pending_)
2057 return;
2058
2059 TRACE_EVENT0("gpu", "RenderWidget::scheduleAnimation");
2060 animation_update_pending_ = true;
2061 if (!animation_timer_.IsRunning()) {
2062 animation_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(0), this,
2063 &RenderWidget::AnimationCallback);
[email protected]ee3d3ad2011-02-04 00:42:212064 }
[email protected]5f8b1022011-01-21 23:34:502065}
2066
[email protected]4873c7d2009-07-16 06:36:282067void RenderWidget::didChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:302068 // TODO(darin): Eliminate this temporary.
[email protected]9ec87712013-05-24 23:23:522069 WebCursor cursor;
[email protected]953bd0062013-08-01 00:58:402070 InitializeCursorFromWebKitCursorInfo(&cursor, cursor_info);
initial.commit09911bf2008-07-26 23:55:292071 // Only send a SetCursor message if we need to make a change.
2072 if (!current_cursor_.IsEqual(cursor)) {
2073 current_cursor_ = cursor;
2074 Send(new ViewHostMsg_SetCursor(routing_id_, cursor));
2075 }
2076}
2077
2078// We are supposed to get a single call to Show for a newly created RenderWidget
2079// that was created via RenderWidget::CreateWebView. So, we wait until this
2080// point to dispatch the ShowWidget message.
2081//
2082// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:282083// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:292084//
[email protected]4873c7d2009-07-16 06:36:282085void RenderWidget::show(WebNavigationPolicy) {
initial.commit09911bf2008-07-26 23:55:292086 DCHECK(!did_show_) << "received extraneous Show call";
2087 DCHECK(routing_id_ != MSG_ROUTING_NONE);
2088 DCHECK(opener_id_ != MSG_ROUTING_NONE);
2089
[email protected]8de12d942010-11-17 20:42:442090 if (did_show_)
2091 return;
2092
2093 did_show_ = true;
2094 // NOTE: initial_pos_ may still have its default values at this point, but
2095 // that's okay. It'll be ignored if as_popup is false, or the browser
2096 // process will impose a default position otherwise.
2097 Send(new ViewHostMsg_ShowWidget(opener_id_, routing_id_, initial_pos_));
2098 SetPendingWindowRect(initial_pos_);
initial.commit09911bf2008-07-26 23:55:292099}
2100
[email protected]4873c7d2009-07-16 06:36:282101void RenderWidget::didFocus() {
initial.commit09911bf2008-07-26 23:55:292102}
2103
[email protected]4873c7d2009-07-16 06:36:282104void RenderWidget::didBlur() {
initial.commit09911bf2008-07-26 23:55:292105}
2106
[email protected]2533ce12009-05-09 00:02:242107void RenderWidget::DoDeferredClose() {
2108 Send(new ViewHostMsg_Close(routing_id_));
2109}
2110
[email protected]4873c7d2009-07-16 06:36:282111void RenderWidget::closeWidgetSoon() {
[email protected]e1c3a552012-05-04 20:51:322112 if (is_swapped_out_) {
2113 // This widget is currently swapped out, and the active widget is in a
2114 // different process. Have the browser route the close request to the
2115 // active widget instead, so that the correct unload handlers are run.
2116 Send(new ViewHostMsg_RouteCloseEvent(routing_id_));
2117 return;
2118 }
2119
initial.commit09911bf2008-07-26 23:55:292120 // If a page calls window.close() twice, we'll end up here twice, but that's
2121 // OK. It is safe to send multiple Close messages.
2122
[email protected]2533ce12009-05-09 00:02:242123 // Ask the RenderWidgetHost to initiate close. We could be called from deep
2124 // in Javascript. If we ask the RendwerWidgetHost to close now, the window
2125 // could be closed before the JS finishes executing. So instead, post a
2126 // message back to the message loop, which won't run until the JS is
2127 // complete, and then the Close message can be sent.
[email protected]dd32b1272013-05-04 14:17:112128 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:212129 FROM_HERE, base::Bind(&RenderWidget::DoDeferredClose, this));
initial.commit09911bf2008-07-26 23:55:292130}
2131
[email protected]9017d7852013-11-21 17:47:352132void RenderWidget::QueueSyntheticGesture(
2133 scoped_ptr<SyntheticGestureParams> gesture_params,
2134 const SyntheticGestureCompletionCallback& callback) {
2135 DCHECK(!callback.is_null());
2136
2137 pending_synthetic_gesture_callbacks_.push(callback);
2138
2139 SyntheticGesturePacket gesture_packet;
2140 gesture_packet.set_gesture_params(gesture_params.Pass());
2141
2142 Send(new InputHostMsg_QueueSyntheticGesture(routing_id_, gesture_packet));
2143}
2144
initial.commit09911bf2008-07-26 23:55:292145void RenderWidget::Close() {
2146 if (webwidget_) {
[email protected]8926c602013-01-23 05:32:062147 webwidget_->willCloseLayerTreeView();
[email protected]ba91a792013-02-06 09:48:282148 compositor_.reset();
[email protected]4873c7d2009-07-16 06:36:282149 webwidget_->close();
initial.commit09911bf2008-07-26 23:55:292150 webwidget_ = NULL;
2151 }
2152}
2153
[email protected]4873c7d2009-07-16 06:36:282154WebRect RenderWidget::windowRect() {
2155 if (pending_window_rect_count_)
2156 return pending_window_rect_;
[email protected]2533ce12009-05-09 00:02:242157
[email protected]80ad8622012-11-07 16:33:032158 return view_screen_rect_;
initial.commit09911bf2008-07-26 23:55:292159}
2160
[email protected]180ef242013-11-07 06:50:462161void RenderWidget::setToolTipText(const blink::WebString& text,
[email protected]8a9d6ca32011-06-06 20:11:302162 WebTextDirection hint) {
[email protected]5a395b72011-08-08 19:13:542163 Send(new ViewHostMsg_SetTooltipText(routing_id_, text, hint));
[email protected]8a9d6ca32011-06-06 20:11:302164}
2165
[email protected]b2e4c70132013-10-03 02:07:512166void RenderWidget::setWindowRect(const WebRect& rect) {
2167 WebRect pos = rect;
2168 if (popup_origin_scale_for_emulation_) {
2169 float scale = popup_origin_scale_for_emulation_;
2170 pos.x = popup_screen_origin_for_emulation_.x() +
2171 (pos.x - popup_view_origin_for_emulation_.x()) * scale;
2172 pos.y = popup_screen_origin_for_emulation_.y() +
2173 (pos.y - popup_view_origin_for_emulation_.y()) * scale;
2174 }
2175
[email protected]5b45ad42013-10-25 00:42:042176 if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]ec951b9d2013-10-20 06:21:202177 if (did_show_) {
[email protected]8be1c582013-03-06 00:55:032178 Send(new ViewHostMsg_RequestMove(routing_id_, pos));
2179 SetPendingWindowRect(pos);
2180 } else {
[email protected]ec951b9d2013-10-20 06:21:202181 initial_pos_ = pos;
[email protected]8be1c582013-03-06 00:55:032182 }
initial.commit09911bf2008-07-26 23:55:292183 } else {
[email protected]92650162013-10-30 03:31:022184 ResizeSynchronously(pos);
initial.commit09911bf2008-07-26 23:55:292185 }
2186}
2187
[email protected]2533ce12009-05-09 00:02:242188void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
2189 pending_window_rect_ = rect;
2190 pending_window_rect_count_++;
2191}
2192
[email protected]4873c7d2009-07-16 06:36:282193WebRect RenderWidget::rootWindowRect() {
[email protected]2533ce12009-05-09 00:02:242194 if (pending_window_rect_count_) {
2195 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
2196 // the RootWindowRect is probably going to return wrong results since the
2197 // browser may not have processed the Move yet. There isn't really anything
2198 // good to do in this case, and it shouldn't happen - since this size is
2199 // only really needed for windowToScreen, which is only used for Popups.
[email protected]4873c7d2009-07-16 06:36:282200 return pending_window_rect_;
[email protected]2533ce12009-05-09 00:02:242201 }
2202
[email protected]80ad8622012-11-07 16:33:032203 return window_screen_rect_;
[email protected]d4547452008-08-28 18:36:372204}
2205
[email protected]4873c7d2009-07-16 06:36:282206WebRect RenderWidget::windowResizerRect() {
2207 return resizer_rect_;
[email protected]c04b6362008-11-21 18:54:192208}
2209
[email protected]fa7b1dc2010-06-23 17:53:042210void RenderWidget::OnSetInputMethodActive(bool is_active) {
[email protected]c4bb35a2008-10-31 17:54:032211 // To prevent this renderer process from sending unnecessary IPC messages to
2212 // a browser process, we permit the renderer process to send IPC messages
[email protected]fa7b1dc2010-06-23 17:53:042213 // only during the input method attached to the browser process is active.
2214 input_method_is_active_ = is_active;
initial.commit09911bf2008-07-26 23:55:292215}
2216
[email protected]37a241c2013-12-03 03:16:172217void RenderWidget::OnCandidateWindowShown() {
2218 webwidget_->didShowCandidateWindow();
2219}
2220
2221void RenderWidget::OnCandidateWindowUpdated() {
2222 webwidget_->didUpdateCandidateWindow();
2223}
2224
2225void RenderWidget::OnCandidateWindowHidden() {
2226 webwidget_->didHideCandidateWindow();
2227}
2228
[email protected]fa7b1dc2010-06-23 17:53:042229void RenderWidget::OnImeSetComposition(
[email protected]fcf75d42013-12-03 20:11:262230 const base::string16& text,
[email protected]fa7b1dc2010-06-23 17:53:042231 const std::vector<WebCompositionUnderline>& underlines,
2232 int selection_start, int selection_end) {
[email protected]0d1ebed12013-08-05 22:01:132233 if (!ShouldHandleImeEvent())
[email protected]4873c7d2009-07-16 06:36:282234 return;
[email protected]66fca5bc2013-05-23 06:58:292235 ImeEventGuard guard(this);
[email protected]88dbe32f2013-06-20 23:31:362236 if (!webwidget_->setComposition(
[email protected]fa7b1dc2010-06-23 17:53:042237 text, WebVector<WebCompositionUnderline>(underlines),
2238 selection_start, selection_end)) {
2239 // If we failed to set the composition text, then we need to let the browser
2240 // process to cancel the input method's ongoing composition session, to make
2241 // sure we are in a consistent state.
2242 Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
[email protected]7f00efa2010-04-15 05:01:262243 }
[email protected]501ea13d2013-07-09 17:03:292244#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362245 UpdateCompositionInfo(true);
[email protected]501ea13d2013-07-09 17:03:292246#endif
[email protected]fa7b1dc2010-06-23 17:53:042247}
2248
[email protected]fcf75d42013-12-03 20:11:262249void RenderWidget::OnImeConfirmComposition(const base::string16& text,
[email protected]db4fc1e2013-09-06 20:01:512250 const gfx::Range& replacement_range,
[email protected]0e45bd02013-07-12 20:20:022251 bool keep_selection) {
[email protected]0d1ebed12013-08-05 22:01:132252 if (!ShouldHandleImeEvent())
[email protected]d0be63772011-12-20 23:18:042253 return;
[email protected]66fca5bc2013-05-23 06:58:292254 ImeEventGuard guard(this);
[email protected]d0be63772011-12-20 23:18:042255 handling_input_event_ = true;
[email protected]0e45bd02013-07-12 20:20:022256 if (text.length())
2257 webwidget_->confirmComposition(text);
2258 else if (keep_selection)
2259 webwidget_->confirmComposition(WebWidget::KeepSelection);
2260 else
2261 webwidget_->confirmComposition(WebWidget::DoNotKeepSelection);
[email protected]d0be63772011-12-20 23:18:042262 handling_input_event_ = false;
[email protected]501ea13d2013-07-09 17:03:292263#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362264 UpdateCompositionInfo(true);
[email protected]501ea13d2013-07-09 17:03:292265#endif
initial.commit09911bf2008-07-26 23:55:292266}
2267
[email protected]51a49502013-03-23 01:50:192268void RenderWidget::OnSnapshot(const gfx::Rect& src_subrect) {
2269 SkBitmap snapshot;
2270
2271 if (OnSnapshotHelper(src_subrect, &snapshot)) {
2272 Send(new ViewHostMsg_Snapshot(routing_id(), true, snapshot));
2273 } else {
2274 Send(new ViewHostMsg_Snapshot(routing_id(), false, SkBitmap()));
2275 }
2276}
2277
2278bool RenderWidget::OnSnapshotHelper(const gfx::Rect& src_subrect,
2279 SkBitmap* snapshot) {
2280 base::TimeTicks beginning_time = base::TimeTicks::Now();
2281
2282 if (!webwidget_ || src_subrect.IsEmpty())
2283 return false;
2284
2285 gfx::Rect viewport_size = gfx::IntersectRects(
2286 src_subrect, gfx::Rect(physical_backing_size_));
2287
2288 skia::RefPtr<SkCanvas> canvas = skia::AdoptRef(
2289 skia::CreatePlatformCanvas(viewport_size.width(),
2290 viewport_size.height(),
2291 true,
2292 NULL,
2293 skia::RETURN_NULL_ON_FAILURE));
[email protected]59383c782013-04-17 16:43:272294 if (!canvas)
[email protected]51a49502013-03-23 01:50:192295 return false;
2296
2297 canvas->save();
2298 webwidget_->layout();
2299
2300 PaintRect(viewport_size, viewport_size.origin(), canvas.get());
2301 canvas->restore();
2302
2303 const SkBitmap& bitmap = skia::GetTopDevice(*canvas)->accessBitmap(false);
[email protected]8dca6e02014-03-04 04:21:392304 if (!bitmap.copyTo(snapshot, kPMColor_SkColorType))
[email protected]51a49502013-03-23 01:50:192305 return false;
2306
2307 UMA_HISTOGRAM_TIMES("Renderer4.Snapshot",
2308 base::TimeTicks::Now() - beginning_time);
2309 return true;
2310}
2311
[email protected]0bc1f572013-04-17 01:46:312312void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
[email protected]ec7dc112008-08-06 05:30:122313 // During shutdown we can just ignore this message.
2314 if (!webwidget_)
2315 return;
2316
[email protected]0bc1f572013-04-17 01:46:312317 // Even if the browser provides an empty damage rect, it's still expecting to
2318 // receive a repaint ack so just damage the entire widget bounds.
2319 if (size_to_paint.IsEmpty()) {
2320 size_to_paint = size_;
2321 }
2322
[email protected]ec7dc112008-08-06 05:30:122323 set_next_paint_is_repaint_ack();
[email protected]0bc1f572013-04-17 01:46:312324 if (is_accelerated_compositing_active_ && compositor_) {
2325 compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint));
[email protected]f98d7e3c2010-09-13 22:30:462326 } else {
2327 gfx::Rect repaint_rect(size_to_paint.width(), size_to_paint.height());
2328 didInvalidateRect(repaint_rect);
2329 }
[email protected]ec7dc112008-08-06 05:30:122330}
2331
[email protected]79fa22e2013-08-23 15:18:122332void RenderWidget::OnSyntheticGestureCompleted() {
[email protected]9017d7852013-11-21 17:47:352333 DCHECK(!pending_synthetic_gesture_callbacks_.empty());
2334
2335 pending_synthetic_gesture_callbacks_.front().Run();
2336 pending_synthetic_gesture_callbacks_.pop();
[email protected]0e241b4b2012-08-18 09:06:272337}
2338
[email protected]4873c7d2009-07-16 06:36:282339void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
[email protected]07f953332009-03-25 04:31:112340 if (!webwidget_)
2341 return;
[email protected]4873c7d2009-07-16 06:36:282342 webwidget_->setTextDirection(direction);
[email protected]07f953332009-03-25 04:31:112343}
2344
[email protected]80ad8622012-11-07 16:33:032345void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
2346 const gfx::Rect& window_screen_rect) {
[email protected]b2e4c70132013-10-03 02:07:512347 if (screen_metrics_emulator_) {
2348 screen_metrics_emulator_->OnUpdateScreenRectsMessage(
2349 view_screen_rect, window_screen_rect);
2350 } else {
2351 view_screen_rect_ = view_screen_rect;
2352 window_screen_rect_ = window_screen_rect;
2353 }
[email protected]80ad8622012-11-07 16:33:032354 Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
2355}
2356
[email protected]105dffb42013-02-20 03:46:212357#if defined(OS_ANDROID)
[email protected]2384b6c2013-02-28 23:58:512358void RenderWidget::OnShowImeIfNeeded() {
[email protected]0d1ebed12013-08-05 22:01:132359 UpdateTextInputState(true, true);
2360}
2361
2362void RenderWidget::IncrementOutstandingImeEventAcks() {
2363 ++outstanding_ime_acks_;
2364}
2365
2366void RenderWidget::OnImeEventAck() {
2367 --outstanding_ime_acks_;
2368 DCHECK(outstanding_ime_acks_ >= 0);
[email protected]2384b6c2013-02-28 23:58:512369}
[email protected]105dffb42013-02-20 03:46:212370#endif
2371
[email protected]0d1ebed12013-08-05 22:01:132372bool RenderWidget::ShouldHandleImeEvent() {
2373#if defined(OS_ANDROID)
2374 return !!webwidget_ && outstanding_ime_acks_ == 0;
2375#else
2376 return !!webwidget_;
2377#endif
2378}
2379
[email protected]468ac582012-11-20 00:53:192380void RenderWidget::SetDeviceScaleFactor(float device_scale_factor) {
2381 if (device_scale_factor_ == device_scale_factor)
2382 return;
2383
2384 device_scale_factor_ = device_scale_factor;
2385
2386 if (!is_accelerated_compositing_active_) {
2387 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
2388 } else {
[email protected]8b9e52b2014-01-17 16:35:312389 scheduleComposite();
[email protected]468ac582012-11-20 00:53:192390 }
2391}
2392
[email protected]adab2332013-07-25 18:04:322393PepperPluginInstanceImpl* RenderWidget::GetBitmapForOptimizedPluginPaint(
2394 const gfx::Rect& paint_bounds,
2395 TransportDIB** dib,
2396 gfx::Rect* location,
2397 gfx::Rect* clip,
2398 float* scale_factor) {
[email protected]719b36f2010-12-22 20:36:462399 // Bare RenderWidgets don't support optimized plugin painting.
2400 return NULL;
[email protected]ca4847f2010-09-24 05:39:152401}
2402
[email protected]ceb36f7d2012-10-31 18:33:242403gfx::Vector2d RenderWidget::GetScrollOffset() {
[email protected]d54169e92011-01-21 09:19:522404 // Bare RenderWidgets don't support scroll offset.
[email protected]ceb36f7d2012-10-31 18:33:242405 return gfx::Vector2d();
[email protected]d54169e92011-01-21 09:19:522406}
2407
[email protected]bee16aab2009-08-26 15:55:032408void RenderWidget::SetHidden(bool hidden) {
2409 if (is_hidden_ == hidden)
2410 return;
2411
2412 // The status has changed. Tell the RenderThread about it.
2413 is_hidden_ = hidden;
2414 if (is_hidden_)
[email protected]b2db9272014-01-10 17:42:002415 RenderThreadImpl::current()->WidgetHidden();
[email protected]bee16aab2009-08-26 15:55:032416 else
[email protected]b2db9272014-01-10 17:42:002417 RenderThreadImpl::current()->WidgetRestored();
[email protected]bee16aab2009-08-26 15:55:032418}
2419
[email protected]2b624c562011-10-27 22:58:262420void RenderWidget::WillToggleFullscreen() {
[email protected]2b624c562011-10-27 22:58:262421 if (!webwidget_)
2422 return;
2423
2424 if (is_fullscreen_) {
2425 webwidget_->willExitFullScreen();
2426 } else {
2427 webwidget_->willEnterFullScreen();
2428 }
[email protected]2b624c562011-10-27 22:58:262429}
2430
2431void RenderWidget::DidToggleFullscreen() {
[email protected]2b624c562011-10-27 22:58:262432 if (!webwidget_)
2433 return;
2434
2435 if (is_fullscreen_) {
2436 webwidget_->didEnterFullScreen();
2437 } else {
2438 webwidget_->didExitFullScreen();
2439 }
[email protected]2b624c562011-10-27 22:58:262440}
2441
[email protected]699ab0d2009-04-23 23:19:142442void RenderWidget::SetBackground(const SkBitmap& background) {
2443 background_ = background;
[email protected]f98d7e3c2010-09-13 22:30:462444
[email protected]699ab0d2009-04-23 23:19:142445 // Generate a full repaint.
[email protected]4873c7d2009-07-16 06:36:282446 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
[email protected]699ab0d2009-04-23 23:19:142447}
2448
[email protected]674741932009-02-04 23:44:462449bool RenderWidget::next_paint_is_resize_ack() const {
[email protected]53d3f302009-12-21 04:42:052450 return ViewHostMsg_UpdateRect_Flags::is_resize_ack(next_paint_flags_);
[email protected]674741932009-02-04 23:44:462451}
2452
2453bool RenderWidget::next_paint_is_restore_ack() const {
[email protected]53d3f302009-12-21 04:42:052454 return ViewHostMsg_UpdateRect_Flags::is_restore_ack(next_paint_flags_);
[email protected]674741932009-02-04 23:44:462455}
2456
2457void RenderWidget::set_next_paint_is_resize_ack() {
[email protected]53d3f302009-12-21 04:42:052458 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
[email protected]674741932009-02-04 23:44:462459}
2460
2461void RenderWidget::set_next_paint_is_restore_ack() {
[email protected]53d3f302009-12-21 04:42:052462 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESTORE_ACK;
[email protected]674741932009-02-04 23:44:462463}
2464
2465void RenderWidget::set_next_paint_is_repaint_ack() {
[email protected]53d3f302009-12-21 04:42:052466 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK;
[email protected]674741932009-02-04 23:44:462467}
2468
[email protected]b18583c2012-12-18 06:55:272469static bool IsDateTimeInput(ui::TextInputType type) {
2470 return type == ui::TEXT_INPUT_TYPE_DATE ||
2471 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
2472 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
2473 type == ui::TEXT_INPUT_TYPE_MONTH ||
2474 type == ui::TEXT_INPUT_TYPE_TIME ||
2475 type == ui::TEXT_INPUT_TYPE_WEEK;
2476}
2477
[email protected]66fca5bc2013-05-23 06:58:292478
2479void RenderWidget::StartHandlingImeEvent() {
2480 DCHECK(!handling_ime_event_);
2481 handling_ime_event_ = true;
2482}
2483
2484void RenderWidget::FinishHandlingImeEvent() {
2485 DCHECK(handling_ime_event_);
2486 handling_ime_event_ = false;
2487 // While handling an ime event, text input state and selection bounds updates
2488 // are ignored. These must explicitly be updated once finished handling the
2489 // ime event.
[email protected]a80aea72014-03-14 21:10:152490#if defined(OS_ANDROID)
2491 UpdateSelectionRootBounds();
2492#endif
[email protected]66fca5bc2013-05-23 06:58:292493 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:472494#if defined(OS_ANDROID)
[email protected]0d1ebed12013-08-05 22:01:132495 UpdateTextInputState(false, false);
[email protected]cb9e2632013-06-18 11:26:472496#endif
[email protected]66fca5bc2013-05-23 06:58:292497}
2498
[email protected]cb9e2632013-06-18 11:26:472499void RenderWidget::UpdateTextInputType() {
[email protected]11f22bb62013-09-24 04:59:062500 // On Windows, not only an IME but also an on-screen keyboard relies on the
2501 // latest TextInputType to optimize its layout and functionality. Thus
2502 // |input_method_is_active_| is no longer an appropriate condition to suppress
2503 // TextInputTypeChanged IPC on Windows.
2504 // TODO(yukawa, yoichio): Consider to stop checking |input_method_is_active_|
2505 // on other platforms as well as Windows if the overhead is acceptable.
2506#if !defined(OS_WIN)
[email protected]cb9e2632013-06-18 11:26:472507 if (!input_method_is_active_)
2508 return;
[email protected]11f22bb62013-09-24 04:59:062509#endif
[email protected]cb9e2632013-06-18 11:26:472510
[email protected]e7c569d2013-07-17 16:00:362511 ui::TextInputType new_type = GetTextInputType();
[email protected]cb9e2632013-06-18 11:26:472512 if (IsDateTimeInput(new_type))
2513 return; // Not considered as a text input field in WebKit/Chromium.
2514
2515 bool new_can_compose_inline = CanComposeInline();
2516
[email protected]180ef242013-11-07 06:50:462517 blink::WebTextInputInfo new_info;
[email protected]e7c569d2013-07-17 16:00:362518 if (webwidget_)
2519 new_info = webwidget_->textInputInfo();
[email protected]b256eca2013-07-11 10:57:402520 const ui::TextInputMode new_mode = ConvertInputMode(new_info.inputMode);
2521
[email protected]cb9e2632013-06-18 11:26:472522 if (text_input_type_ != new_type
[email protected]b256eca2013-07-11 10:57:402523 || can_compose_inline_ != new_can_compose_inline
2524 || text_input_mode_ != new_mode) {
[email protected]cb9e2632013-06-18 11:26:472525 Send(new ViewHostMsg_TextInputTypeChanged(routing_id(),
2526 new_type,
[email protected]86ba5fcb2013-09-04 00:36:532527 new_mode,
2528 new_can_compose_inline));
[email protected]cb9e2632013-06-18 11:26:472529 text_input_type_ = new_type;
2530 can_compose_inline_ = new_can_compose_inline;
[email protected]b256eca2013-07-11 10:57:402531 text_input_mode_ = new_mode;
[email protected]cb9e2632013-06-18 11:26:472532 }
2533}
2534
[email protected]183e28d2014-01-20 18:18:022535#if defined(OS_ANDROID) || defined(USE_AURA)
[email protected]0d1ebed12013-08-05 22:01:132536void RenderWidget::UpdateTextInputState(bool show_ime_if_needed,
2537 bool send_ime_ack) {
[email protected]e8f775f2013-02-14 21:00:502538 if (handling_ime_event_)
2539 return;
[email protected]3306f262012-09-21 19:20:422540 if (!show_ime_if_needed && !input_method_is_active_)
initial.commit09911bf2008-07-26 23:55:292541 return;
[email protected]ad26ef42011-06-17 07:59:452542 ui::TextInputType new_type = GetTextInputType();
[email protected]b18583c2012-12-18 06:55:272543 if (IsDateTimeInput(new_type))
2544 return; // Not considered as a text input field in WebKit/Chromium.
2545
[email protected]180ef242013-11-07 06:50:462546 blink::WebTextInputInfo new_info;
[email protected]5b739cb2012-08-21 20:35:212547 if (webwidget_)
2548 new_info = webwidget_->textInputInfo();
2549
[email protected]ad26ef42011-06-17 07:59:452550 bool new_can_compose_inline = CanComposeInline();
[email protected]5b739cb2012-08-21 20:35:212551
[email protected]3306f262012-09-21 19:20:422552 // Only sends text input params if they are changed or if the ime should be
2553 // shown.
2554 if (show_ime_if_needed || (text_input_type_ != new_type
2555 || text_input_info_ != new_info
2556 || can_compose_inline_ != new_can_compose_inline)) {
[email protected]5b739cb2012-08-21 20:35:212557 ViewHostMsg_TextInputState_Params p;
[email protected]183e28d2014-01-20 18:18:022558#if defined(USE_AURA)
2559 p.require_ack = false;
2560#endif
[email protected]5b739cb2012-08-21 20:35:212561 p.type = new_type;
2562 p.value = new_info.value.utf8();
2563 p.selection_start = new_info.selectionStart;
2564 p.selection_end = new_info.selectionEnd;
2565 p.composition_start = new_info.compositionStart;
2566 p.composition_end = new_info.compositionEnd;
2567 p.can_compose_inline = new_can_compose_inline;
[email protected]3306f262012-09-21 19:20:422568 p.show_ime_if_needed = show_ime_if_needed;
[email protected]183e28d2014-01-20 18:18:022569#if defined(OS_ANDROID)
[email protected]0d1ebed12013-08-05 22:01:132570 p.require_ack = send_ime_ack;
2571 if (p.require_ack)
2572 IncrementOutstandingImeEventAcks();
[email protected]183e28d2014-01-20 18:18:022573#endif
[email protected]5b739cb2012-08-21 20:35:212574 Send(new ViewHostMsg_TextInputStateChanged(routing_id(), p));
2575
2576 text_input_info_ = new_info;
[email protected]fa7b1dc2010-06-23 17:53:042577 text_input_type_ = new_type;
[email protected]ad26ef42011-06-17 07:59:452578 can_compose_inline_ = new_can_compose_inline;
initial.commit09911bf2008-07-26 23:55:292579 }
initial.commit09911bf2008-07-26 23:55:292580}
[email protected]cb9e2632013-06-18 11:26:472581#endif
initial.commit09911bf2008-07-26 23:55:292582
[email protected]7c8873e2013-02-05 08:03:012583void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
2584 WebRect focus_webrect;
2585 WebRect anchor_webrect;
2586 webwidget_->selectionBounds(focus_webrect, anchor_webrect);
2587 *focus = focus_webrect;
2588 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:322589}
2590
[email protected]e99ef6f2011-10-16 01:13:002591void RenderWidget::UpdateSelectionBounds() {
2592 if (!webwidget_)
2593 return;
[email protected]66fca5bc2013-05-23 06:58:292594 if (handling_ime_event_)
2595 return;
[email protected]e99ef6f2011-10-16 01:13:002596
[email protected]7c8873e2013-02-05 08:03:012597 ViewHostMsg_SelectionBounds_Params params;
2598 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
2599 if (selection_anchor_rect_ != params.anchor_rect ||
2600 selection_focus_rect_ != params.focus_rect) {
2601 selection_anchor_rect_ = params.anchor_rect;
2602 selection_focus_rect_ = params.focus_rect;
2603 webwidget_->selectionTextDirection(params.focus_dir, params.anchor_dir);
[email protected]129b7382013-02-12 02:14:292604 params.is_anchor_first = webwidget_->isSelectionAnchorFirst();
[email protected]7c8873e2013-02-05 08:03:012605 Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
[email protected]58b48a0d2012-06-13 07:01:352606 }
[email protected]501ea13d2013-07-09 17:03:292607#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362608 UpdateCompositionInfo(false);
[email protected]501ea13d2013-07-09 17:03:292609#endif
[email protected]e99ef6f2011-10-16 01:13:002610}
2611
[email protected]180ef242013-11-07 06:50:462612// Check blink::WebTextInputType and ui::TextInputType is kept in sync.
2613COMPILE_ASSERT(int(blink::WebTextInputTypeNone) == \
[email protected]ad26ef42011-06-17 07:59:452614 int(ui::TEXT_INPUT_TYPE_NONE), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462615COMPILE_ASSERT(int(blink::WebTextInputTypeText) == \
[email protected]ad26ef42011-06-17 07:59:452616 int(ui::TEXT_INPUT_TYPE_TEXT), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462617COMPILE_ASSERT(int(blink::WebTextInputTypePassword) == \
[email protected]ad26ef42011-06-17 07:59:452618 int(ui::TEXT_INPUT_TYPE_PASSWORD), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462619COMPILE_ASSERT(int(blink::WebTextInputTypeSearch) == \
[email protected]caf38ed2011-07-28 13:15:182620 int(ui::TEXT_INPUT_TYPE_SEARCH), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462621COMPILE_ASSERT(int(blink::WebTextInputTypeEmail) == \
[email protected]caf38ed2011-07-28 13:15:182622 int(ui::TEXT_INPUT_TYPE_EMAIL), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462623COMPILE_ASSERT(int(blink::WebTextInputTypeNumber) == \
[email protected]caf38ed2011-07-28 13:15:182624 int(ui::TEXT_INPUT_TYPE_NUMBER), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462625COMPILE_ASSERT(int(blink::WebTextInputTypeTelephone) == \
[email protected]caf38ed2011-07-28 13:15:182626 int(ui::TEXT_INPUT_TYPE_TELEPHONE), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462627COMPILE_ASSERT(int(blink::WebTextInputTypeURL) == \
[email protected]caf38ed2011-07-28 13:15:182628 int(ui::TEXT_INPUT_TYPE_URL), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462629COMPILE_ASSERT(int(blink::WebTextInputTypeDate) == \
[email protected]feb8cf752012-06-08 04:48:002630 int(ui::TEXT_INPUT_TYPE_DATE), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462631COMPILE_ASSERT(int(blink::WebTextInputTypeDateTime) == \
[email protected]feb8cf752012-06-08 04:48:002632 int(ui::TEXT_INPUT_TYPE_DATE_TIME), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462633COMPILE_ASSERT(int(blink::WebTextInputTypeDateTimeLocal) == \
[email protected]feb8cf752012-06-08 04:48:002634 int(ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462635COMPILE_ASSERT(int(blink::WebTextInputTypeMonth) == \
[email protected]feb8cf752012-06-08 04:48:002636 int(ui::TEXT_INPUT_TYPE_MONTH), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462637COMPILE_ASSERT(int(blink::WebTextInputTypeTime) == \
[email protected]feb8cf752012-06-08 04:48:002638 int(ui::TEXT_INPUT_TYPE_TIME), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462639COMPILE_ASSERT(int(blink::WebTextInputTypeWeek) == \
[email protected]feb8cf752012-06-08 04:48:002640 int(ui::TEXT_INPUT_TYPE_WEEK), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462641COMPILE_ASSERT(int(blink::WebTextInputTypeTextArea) == \
[email protected]2a9893672012-11-09 20:33:012642 int(ui::TEXT_INPUT_TYPE_TEXT_AREA), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462643COMPILE_ASSERT(int(blink::WebTextInputTypeContentEditable) == \
[email protected]2a9893672012-11-09 20:33:012644 int(ui::TEXT_INPUT_TYPE_CONTENT_EDITABLE), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462645COMPILE_ASSERT(int(blink::WebTextInputTypeDateTimeField) == \
[email protected]8b4992e2013-03-01 15:42:152646 int(ui::TEXT_INPUT_TYPE_DATE_TIME_FIELD), mismatching_enums);
[email protected]ad26ef42011-06-17 07:59:452647
[email protected]5b739cb2012-08-21 20:35:212648ui::TextInputType RenderWidget::WebKitToUiTextInputType(
[email protected]180ef242013-11-07 06:50:462649 blink::WebTextInputType type) {
[email protected]5b739cb2012-08-21 20:35:212650 // Check the type is in the range representable by ui::TextInputType.
2651 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX)) <<
[email protected]180ef242013-11-07 06:50:462652 "blink::WebTextInputType and ui::TextInputType not synchronized";
[email protected]5b739cb2012-08-21 20:35:212653 return static_cast<ui::TextInputType>(type);
2654}
2655
[email protected]ad26ef42011-06-17 07:59:452656ui::TextInputType RenderWidget::GetTextInputType() {
[email protected]8969bb3f2012-11-30 21:49:272657 if (webwidget_)
2658 return WebKitToUiTextInputType(webwidget_->textInputInfo().type);
[email protected]ad26ef42011-06-17 07:59:452659 return ui::TEXT_INPUT_TYPE_NONE;
2660}
2661
[email protected]501ea13d2013-07-09 17:03:292662#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
2663void RenderWidget::UpdateCompositionInfo(bool should_update_range) {
[email protected]db4fc1e2013-09-06 20:01:512664 gfx::Range range = gfx::Range();
[email protected]501ea13d2013-07-09 17:03:292665 if (should_update_range) {
2666 GetCompositionRange(&range);
2667 } else {
2668 range = composition_range_;
2669 }
2670 std::vector<gfx::Rect> character_bounds;
2671 GetCompositionCharacterBounds(&character_bounds);
2672
2673 if (!ShouldUpdateCompositionInfo(range, character_bounds))
2674 return;
2675 composition_character_bounds_ = character_bounds;
2676 composition_range_ = range;
2677 Send(new ViewHostMsg_ImeCompositionRangeChanged(
2678 routing_id(), composition_range_, composition_character_bounds_));
2679}
2680
[email protected]58b48a0d2012-06-13 07:01:352681void RenderWidget::GetCompositionCharacterBounds(
2682 std::vector<gfx::Rect>* bounds) {
2683 DCHECK(bounds);
2684 bounds->clear();
2685}
2686
[email protected]db4fc1e2013-09-06 20:01:512687void RenderWidget::GetCompositionRange(gfx::Range* range) {
[email protected]88dbe32f2013-06-20 23:31:362688 size_t location, length;
2689 if (webwidget_->compositionRange(&location, &length)) {
2690 range->set_start(location);
2691 range->set_end(location + length);
2692 } else if (webwidget_->caretOrSelectionRange(&location, &length)) {
2693 range->set_start(location);
2694 range->set_end(location + length);
2695 } else {
[email protected]db4fc1e2013-09-06 20:01:512696 *range = gfx::Range::InvalidRange();
[email protected]88dbe32f2013-06-20 23:31:362697 }
2698}
2699
[email protected]501ea13d2013-07-09 17:03:292700bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:512701 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:292702 const std::vector<gfx::Rect>& bounds) {
2703 if (composition_range_ != range)
2704 return true;
2705 if (bounds.size() != composition_character_bounds_.size())
2706 return true;
2707 for (size_t i = 0; i < bounds.size(); ++i) {
2708 if (bounds[i] != composition_character_bounds_[i])
2709 return true;
2710 }
2711 return false;
2712}
2713#endif
2714
[email protected]ad26ef42011-06-17 07:59:452715bool RenderWidget::CanComposeInline() {
2716 return true;
[email protected]56ea1a62011-05-30 07:05:572717}
2718
[email protected]4873c7d2009-07-16 06:36:282719WebScreenInfo RenderWidget::screenInfo() {
[email protected]842f10652012-06-06 01:54:042720 return screen_info_;
[email protected]4873c7d2009-07-16 06:36:282721}
2722
[email protected]f660d9c2012-06-06 18:31:212723float RenderWidget::deviceScaleFactor() {
2724 return device_scale_factor_;
2725}
2726
[email protected]fa7b1dc2010-06-23 17:53:042727void RenderWidget::resetInputMethod() {
2728 if (!input_method_is_active_)
2729 return;
2730
[email protected]0e45bd02013-07-12 20:20:022731 ImeEventGuard guard(this);
[email protected]fa7b1dc2010-06-23 17:53:042732 // If the last text input type is not None, then we should finish any
2733 // ongoing composition regardless of the new text input type.
[email protected]ad26ef42011-06-17 07:59:452734 if (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE) {
[email protected]fa7b1dc2010-06-23 17:53:042735 // If a composition text exists, then we need to let the browser process
2736 // to cancel the input method's ongoing composition session.
2737 if (webwidget_->confirmComposition())
2738 Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
2739 }
[email protected]d4cff272011-05-02 15:46:012740
[email protected]501ea13d2013-07-09 17:03:292741#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362742 UpdateCompositionInfo(true);
[email protected]501ea13d2013-07-09 17:03:292743#endif
[email protected]fa7b1dc2010-06-23 17:53:042744}
2745
[email protected]c68c3e4e2013-01-24 00:36:562746void RenderWidget::didHandleGestureEvent(
2747 const WebGestureEvent& event,
2748 bool event_cancelled) {
[email protected]183e28d2014-01-20 18:18:022749#if defined(OS_ANDROID) || defined(USE_AURA)
[email protected]c68c3e4e2013-01-24 00:36:562750 if (event_cancelled)
2751 return;
2752 if (event.type == WebInputEvent::GestureTap ||
2753 event.type == WebInputEvent::GestureLongPress) {
[email protected]0d1ebed12013-08-05 22:01:132754 UpdateTextInputState(true, true);
[email protected]c68c3e4e2013-01-24 00:36:562755 }
2756#endif
2757}
2758
[email protected]29e2fb42013-07-19 01:13:472759void RenderWidget::SchedulePluginMove(const WebPluginGeometry& move) {
initial.commit09911bf2008-07-26 23:55:292760 size_t i = 0;
2761 for (; i < plugin_window_moves_.size(); ++i) {
2762 if (plugin_window_moves_[i].window == move.window) {
[email protected]16f89d02009-08-26 17:17:582763 if (move.rects_valid) {
2764 plugin_window_moves_[i] = move;
2765 } else {
2766 plugin_window_moves_[i].visible = move.visible;
2767 }
initial.commit09911bf2008-07-26 23:55:292768 break;
2769 }
2770 }
2771
2772 if (i == plugin_window_moves_.size())
2773 plugin_window_moves_.push_back(move);
2774}
[email protected]268654772009-08-06 23:02:042775
2776void RenderWidget::CleanupWindowInPluginMoves(gfx::PluginWindowHandle window) {
2777 for (WebPluginGeometryVector::iterator i = plugin_window_moves_.begin();
2778 i != plugin_window_moves_.end(); ++i) {
2779 if (i->window == window) {
2780 plugin_window_moves_.erase(i);
2781 break;
2782 }
2783 }
2784}
[email protected]67bfb83f2011-09-22 03:36:372785
[email protected]63b465922012-09-06 02:04:522786
[email protected]24ed0432013-04-24 07:50:312787RenderWidgetCompositor* RenderWidget::compositor() const {
2788 return compositor_.get();
2789}
2790
[email protected]180ef242013-11-07 06:50:462791bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
[email protected]67bfb83f2011-09-22 03:36:372792 return false;
2793}
[email protected]c3d45532011-10-07 19:20:402794
[email protected]41d86852012-11-07 12:23:242795bool RenderWidget::WillHandleGestureEvent(
[email protected]180ef242013-11-07 06:50:462796 const blink::WebGestureEvent& event) {
[email protected]41d86852012-11-07 12:23:242797 return false;
2798}
2799
[email protected]ce6689f2013-03-29 12:52:552800void RenderWidget::hasTouchEventHandlers(bool has_handlers) {
2801 Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
2802}
2803
[email protected]5d0bbdfa92013-12-10 00:35:512804void RenderWidget::setTouchAction(
2805 blink::WebTouchAction web_touch_action) {
2806
2807 // Ignore setTouchAction calls that result from synthetic touch events (eg.
2808 // when blink is emulating touch with mouse).
2809 if (!handling_touchstart_event_)
2810 return;
2811
[email protected]a18f67a2013-12-20 19:44:362812 // Verify the same values are used by the types so we can cast between them.
2813 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_AUTO) ==
2814 blink::WebTouchActionAuto,
2815 enum_values_must_match_for_touch_action);
2816 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_NONE) ==
2817 blink::WebTouchActionNone,
2818 enum_values_must_match_for_touch_action);
2819 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_PAN_X) ==
2820 blink::WebTouchActionPanX,
2821 enum_values_must_match_for_touch_action);
2822 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_PAN_Y) ==
2823 blink::WebTouchActionPanY,
2824 enum_values_must_match_for_touch_action);
[email protected]2bd73272014-03-13 19:36:112825 COMPILE_ASSERT(
2826 static_cast<blink::WebTouchAction>(TOUCH_ACTION_PINCH_ZOOM) ==
2827 blink::WebTouchActionPinchZoom,
2828 enum_values_must_match_for_touch_action);
[email protected]a18f67a2013-12-20 19:44:362829
2830 content::TouchAction content_touch_action =
2831 static_cast<content::TouchAction>(web_touch_action);
[email protected]5d0bbdfa92013-12-10 00:35:512832 Send(new InputHostMsg_SetTouchAction(routing_id_, content_touch_action));
2833}
2834
[email protected]a80aea72014-03-14 21:10:152835#if defined(OS_ANDROID)
2836void RenderWidget::UpdateSelectionRootBounds() {
2837}
2838#endif
2839
[email protected]3d5c243b2012-11-30 00:26:012840bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
2841 return true;
2842}
2843
[email protected]0634cdd42013-08-16 00:46:092844scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
2845RenderWidget::CreateGraphicsContext3D(
[email protected]180ef242013-11-07 06:50:462846 const blink::WebGraphicsContext3D::Attributes& attributes) {
[email protected]ed7defa2013-03-12 21:29:592847 if (!webwidget_)
[email protected]0634cdd42013-08-16 00:46:092848 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]ebc0e1df2013-08-01 02:46:222849 if (CommandLine::ForCurrentProcess()->HasSwitch(
2850 switches::kDisableGpuCompositing))
[email protected]0634cdd42013-08-16 00:46:092851 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]96ab016c2013-10-23 00:50:292852 if (!RenderThreadImpl::current())
2853 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]4d7e46a2013-11-08 05:33:402854 CauseForGpuLaunch cause =
2855 CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
[email protected]96ab016c2013-10-23 00:50:292856 scoped_refptr<GpuChannelHost> gpu_channel_host(
[email protected]4d7e46a2013-11-08 05:33:402857 RenderThreadImpl::current()->EstablishGpuChannelSync(cause));
[email protected]96ab016c2013-10-23 00:50:292858 if (!gpu_channel_host)
2859 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]ed7defa2013-03-12 21:29:592860
[email protected]96ab016c2013-10-23 00:50:292861 WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits limits;
[email protected]b6eb8e332013-09-10 00:51:012862#if defined(OS_ANDROID)
2863 // If we raster too fast we become upload bound, and pending
2864 // uploads consume memory. For maximum upload throughput, we would
2865 // want to allow for upload_throughput * pipeline_time of pending
2866 // uploads, after which we are just wasting memory. Since we don't
2867 // know our upload throughput yet, this just caps our memory usage.
2868 size_t divider = 1;
2869 if (base::android::SysUtils::IsLowEndDevice())
[email protected]657be322013-09-20 08:50:032870 divider = 6;
[email protected]b6eb8e332013-09-10 00:51:012871 // For reference Nexus10 can upload 1MB in about 2.5ms.
[email protected]657be322013-09-20 08:50:032872 const double max_mb_uploaded_per_ms = 2.0 / (5 * divider);
[email protected]b6eb8e332013-09-10 00:51:012873 // Deadline to draw a frame to achieve 60 frames per second.
2874 const size_t kMillisecondsPerFrame = 16;
2875 // Assuming a two frame deep pipeline between the CPU and the GPU.
[email protected]657be322013-09-20 08:50:032876 size_t max_transfer_buffer_usage_mb =
2877 static_cast<size_t>(2 * kMillisecondsPerFrame * max_mb_uploaded_per_ms);
2878 static const size_t kBytesPerMegabyte = 1024 * 1024;
[email protected]b6eb8e332013-09-10 00:51:012879 // We keep the MappedMemoryReclaimLimit the same as the upload limit
2880 // to avoid unnecessarily stalling the compositor thread.
[email protected]96ab016c2013-10-23 00:50:292881 limits.mapped_memory_reclaim_limit =
[email protected]657be322013-09-20 08:50:032882 max_transfer_buffer_usage_mb * kBytesPerMegabyte;
[email protected]b6eb8e332013-09-10 00:51:012883#endif
[email protected]96ab016c2013-10-23 00:50:292884
[email protected]96ab016c2013-10-23 00:50:292885 scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
2886 new WebGraphicsContext3DCommandBufferImpl(
2887 surface_id(),
2888 GetURLForGraphicsContext3D(),
2889 gpu_channel_host.get(),
[email protected]8f746982013-03-21 06:28:032890 attributes,
2891 false /* bind generates resources */,
[email protected]4f8fd7802014-02-25 18:19:362892 limits,
2893 NULL));
[email protected]0634cdd42013-08-16 00:46:092894 return context.Pass();
[email protected]ed7defa2013-03-12 21:29:592895}
2896
[email protected]bffc8302014-01-23 20:52:162897void RenderWidget::RegisterSwappedOutChildFrame(RenderFrameImpl* frame) {
2898 swapped_out_frames_.AddObserver(frame);
2899}
2900
2901void RenderWidget::UnregisterSwappedOutChildFrame(RenderFrameImpl* frame) {
2902 swapped_out_frames_.RemoveObserver(frame);
2903}
2904
[email protected]e9ff79c2012-10-19 21:31:262905} // namespace content