blob: 30667939eefad3bfbecd4928b4d4a877d1e02e03 [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]19193682014-04-03 15:01:4357#include "third_party/WebKit/public/web/WebDeviceEmulationParams.h"
[email protected]2255a9332013-06-17 05:12:3158#include "third_party/WebKit/public/web/WebPagePopup.h"
59#include "third_party/WebKit/public/web/WebPopupMenu.h"
60#include "third_party/WebKit/public/web/WebPopupMenuInfo.h"
61#include "third_party/WebKit/public/web/WebRange.h"
[email protected]d353541f2012-05-03 22:45:4162#include "third_party/skia/include/core/SkShader.h"
[email protected]faec7b12012-06-19 14:42:1363#include "ui/base/ui_base_switches.h"
[email protected]de2cf8c2013-10-25 19:46:4664#include "ui/gfx/frame_time.h"
[email protected]9c769d412014-03-20 18:27:3965#include "ui/gfx/point_conversions.h"
[email protected]a25e25b2012-09-28 14:32:3766#include "ui/gfx/rect_conversions.h"
[email protected]4b01b962012-10-09 23:17:3567#include "ui/gfx/size_conversions.h"
[email protected]1835b9e2012-02-28 13:12:4868#include "ui/gfx/skia_util.h"
[email protected]c9e2cbbb2012-05-12 21:17:2769#include "ui/gl/gl_switches.h"
[email protected]d353541f2012-05-03 22:45:4170#include "ui/surface/transport_dib.h"
[email protected]661eb9d2009-02-03 02:11:4871
[email protected]eeb93112013-05-01 19:41:1072#if defined(OS_ANDROID)
[email protected]cefe9b152014-03-27 18:16:1573#include <android/keycodes.h>
[email protected]b6eb8e332013-09-10 00:51:0174#include "base/android/sys_utils.h"
[email protected]913d99a2013-05-31 07:16:0775#include "content/renderer/android/synchronous_compositor_factory.h"
[email protected]eeb93112013-05-01 19:41:1076#endif
77
[email protected]661eb9d2009-02-03 02:11:4878#if defined(OS_POSIX)
[email protected]6b889fb2010-03-23 20:09:4979#include "ipc/ipc_channel_posix.h"
[email protected]d5282e72009-05-13 13:16:5280#include "third_party/skia/include/core/SkMallocPixelRef.h"
[email protected]d353541f2012-05-03 22:45:4181#include "third_party/skia/include/core/SkPixelRef.h"
[email protected]661eb9d2009-02-03 02:11:4882#endif // defined(OS_POSIX)
[email protected]8085dbc82008-09-26 22:53:4483
[email protected]2255a9332013-06-17 05:12:3184#include "third_party/WebKit/public/web/WebWidget.h"
initial.commit09911bf2008-07-26 23:55:2985
[email protected]180ef242013-11-07 06:50:4686using blink::WebCompositionUnderline;
87using blink::WebCursorInfo;
[email protected]19193682014-04-03 15:01:4388using blink::WebDeviceEmulationParams;
[email protected]180ef242013-11-07 06:50:4689using blink::WebGestureEvent;
90using blink::WebInputEvent;
91using blink::WebKeyboardEvent;
92using blink::WebMouseEvent;
93using blink::WebMouseWheelEvent;
94using blink::WebNavigationPolicy;
95using blink::WebPagePopup;
96using blink::WebPopupMenu;
97using blink::WebPopupMenuInfo;
98using blink::WebPopupType;
99using blink::WebRange;
100using blink::WebRect;
101using blink::WebScreenInfo;
102using blink::WebSize;
103using blink::WebTextDirection;
104using blink::WebTouchEvent;
[email protected]f8ed4722013-12-03 03:27:25105using blink::WebTouchPoint;
[email protected]180ef242013-11-07 06:50:46106using blink::WebVector;
107using blink::WebWidget;
[email protected]e9ff79c2012-10-19 21:31:26108
[email protected]6a4d7f62013-01-07 21:32:13109namespace {
[email protected]b256eca2013-07-11 10:57:40110
111typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
112
113class TextInputModeMapSingleton {
114 public:
115 static TextInputModeMapSingleton* GetInstance() {
116 return Singleton<TextInputModeMapSingleton>::get();
117 }
[email protected]dd705d4d2013-11-27 08:14:41118 TextInputModeMapSingleton() {
119 map_["verbatim"] = ui::TEXT_INPUT_MODE_VERBATIM;
120 map_["latin"] = ui::TEXT_INPUT_MODE_LATIN;
121 map_["latin-name"] = ui::TEXT_INPUT_MODE_LATIN_NAME;
122 map_["latin-prose"] = ui::TEXT_INPUT_MODE_LATIN_PROSE;
123 map_["full-width-latin"] = ui::TEXT_INPUT_MODE_FULL_WIDTH_LATIN;
124 map_["kana"] = ui::TEXT_INPUT_MODE_KANA;
125 map_["katakana"] = ui::TEXT_INPUT_MODE_KATAKANA;
126 map_["numeric"] = ui::TEXT_INPUT_MODE_NUMERIC;
127 map_["tel"] = ui::TEXT_INPUT_MODE_TEL;
128 map_["email"] = ui::TEXT_INPUT_MODE_EMAIL;
129 map_["url"] = ui::TEXT_INPUT_MODE_URL;
[email protected]b256eca2013-07-11 10:57:40130 }
[email protected]dd705d4d2013-11-27 08:14:41131 const TextInputModeMap& map() const { return map_; }
[email protected]b256eca2013-07-11 10:57:40132 private:
[email protected]dd705d4d2013-11-27 08:14:41133 TextInputModeMap map_;
[email protected]b256eca2013-07-11 10:57:40134
135 friend struct DefaultSingletonTraits<TextInputModeMapSingleton>;
136
137 DISALLOW_COPY_AND_ASSIGN(TextInputModeMapSingleton);
138};
139
[email protected]dd705d4d2013-11-27 08:14:41140ui::TextInputMode ConvertInputMode(const blink::WebString& input_mode) {
[email protected]b256eca2013-07-11 10:57:40141 static TextInputModeMapSingleton* singleton =
142 TextInputModeMapSingleton::GetInstance();
[email protected]dd705d4d2013-11-27 08:14:41143 TextInputModeMap::const_iterator it =
144 singleton->map().find(input_mode.utf8());
145 if (it == singleton->map().end())
[email protected]b256eca2013-07-11 10:57:40146 return ui::TEXT_INPUT_MODE_DEFAULT;
147 return it->second;
[email protected]6a4d7f62013-01-07 21:32:13148}
[email protected]b256eca2013-07-11 10:57:40149
[email protected]fd847792013-10-24 17:12:35150// TODO(brianderson): Replace the hard-coded threshold with a fraction of
151// the BeginMainFrame interval.
152// 4166us will allow 1/4 of a 60Hz interval or 1/2 of a 120Hz interval to
153// be spent in input hanlders before input starts getting throttled.
154const int kInputHandlingTimeThrottlingThresholdMicroseconds = 4166;
155
[email protected]b256eca2013-07-11 10:57:40156} // namespace
157
[email protected]e9ff79c2012-10-19 21:31:26158namespace content {
[email protected]62cb33cae2009-03-27 23:30:22159
[email protected]b2e4c70132013-10-03 02:07:51160// RenderWidget::ScreenMetricsEmulator ----------------------------------------
161
162class RenderWidget::ScreenMetricsEmulator {
163 public:
164 ScreenMetricsEmulator(
165 RenderWidget* widget,
[email protected]19193682014-04-03 15:01:43166 const WebDeviceEmulationParams& params);
[email protected]b2e4c70132013-10-03 02:07:51167 virtual ~ScreenMetricsEmulator();
168
[email protected]19193682014-04-03 15:01:43169 // Scale and offset used to convert between host coordinates
170 // and webwidget coordinates.
[email protected]b2e4c70132013-10-03 02:07:51171 float scale() { return scale_; }
[email protected]9a2d7ee32013-12-05 12:15:49172 gfx::Point offset() { return offset_; }
[email protected]19193682014-04-03 15:01:43173 gfx::Rect applied_widget_rect() const { return applied_widget_rect_; }
[email protected]b2e4c70132013-10-03 02:07:51174 gfx::Rect original_screen_rect() const { return original_view_screen_rect_; }
[email protected]5f75aa42014-04-01 23:00:56175 const WebScreenInfo& original_screen_info() { return original_screen_info_; }
[email protected]b2e4c70132013-10-03 02:07:51176
177 void ChangeEmulationParams(
[email protected]19193682014-04-03 15:01:43178 const WebDeviceEmulationParams& params);
[email protected]b2e4c70132013-10-03 02:07:51179
180 // The following methods alter handlers' behavior for messages related to
181 // widget size and position.
182 void OnResizeMessage(const ViewMsg_Resize_Params& params);
183 void OnUpdateScreenRectsMessage(const gfx::Rect& view_screen_rect,
184 const gfx::Rect& window_screen_rect);
185 void OnShowContextMenu(ContextMenuParams* params);
186
187 private:
[email protected]19193682014-04-03 15:01:43188 void Reapply();
[email protected]b2e4c70132013-10-03 02:07:51189 void Apply(float overdraw_bottom_height,
190 gfx::Rect resizer_rect, bool is_fullscreen);
191
192 RenderWidget* widget_;
193
[email protected]7f99fc22013-11-08 14:05:58194 // Parameters as passed by RenderWidget::EnableScreenMetricsEmulation.
[email protected]19193682014-04-03 15:01:43195 WebDeviceEmulationParams params_;
[email protected]b2e4c70132013-10-03 02:07:51196
[email protected]a179d3962013-11-12 14:44:40197 // The computed scale and offset used to fit widget into browser window.
[email protected]b2e4c70132013-10-03 02:07:51198 float scale_;
[email protected]a179d3962013-11-12 14:44:40199 gfx::Point offset_;
[email protected]b2e4c70132013-10-03 02:07:51200
[email protected]19193682014-04-03 15:01:43201 // Widget rect as passed to webwidget.
202 gfx::Rect applied_widget_rect_;
203
[email protected]b2e4c70132013-10-03 02:07:51204 // Original values to restore back after emulation ends.
205 gfx::Size original_size_;
206 gfx::Size original_physical_backing_size_;
[email protected]180ef242013-11-07 06:50:46207 blink::WebScreenInfo original_screen_info_;
[email protected]b2e4c70132013-10-03 02:07:51208 gfx::Rect original_view_screen_rect_;
209 gfx::Rect original_window_screen_rect_;
210};
211
212RenderWidget::ScreenMetricsEmulator::ScreenMetricsEmulator(
213 RenderWidget* widget,
[email protected]19193682014-04-03 15:01:43214 const WebDeviceEmulationParams& params)
[email protected]b2e4c70132013-10-03 02:07:51215 : widget_(widget),
[email protected]19193682014-04-03 15:01:43216 params_(params),
[email protected]b2e4c70132013-10-03 02:07:51217 scale_(1.f) {
218 original_size_ = widget_->size_;
219 original_physical_backing_size_ = widget_->physical_backing_size_;
220 original_screen_info_ = widget_->screen_info_;
221 original_view_screen_rect_ = widget_->view_screen_rect_;
222 original_window_screen_rect_ = widget_->window_screen_rect_;
223 Apply(widget_->overdraw_bottom_height_,
224 widget_->resizer_rect_, widget_->is_fullscreen_);
225}
226
227RenderWidget::ScreenMetricsEmulator::~ScreenMetricsEmulator() {
228 widget_->screen_info_ = original_screen_info_;
229
230 widget_->SetDeviceScaleFactor(original_screen_info_.deviceScaleFactor);
[email protected]7f99fc22013-11-08 14:05:58231 widget_->SetScreenMetricsEmulationParameters(0.f, gfx::Point(), 1.f);
[email protected]b2e4c70132013-10-03 02:07:51232 widget_->view_screen_rect_ = original_view_screen_rect_;
233 widget_->window_screen_rect_ = original_window_screen_rect_;
234 widget_->Resize(original_size_, original_physical_backing_size_,
235 widget_->overdraw_bottom_height_, widget_->resizer_rect_,
236 widget_->is_fullscreen_, NO_RESIZE_ACK);
237}
238
239void RenderWidget::ScreenMetricsEmulator::ChangeEmulationParams(
[email protected]19193682014-04-03 15:01:43240 const WebDeviceEmulationParams& params) {
241 params_ = params;
242 Reapply();
243}
244
245void RenderWidget::ScreenMetricsEmulator::Reapply() {
[email protected]b2e4c70132013-10-03 02:07:51246 Apply(widget_->overdraw_bottom_height_,
247 widget_->resizer_rect_, widget_->is_fullscreen_);
248}
249
[email protected]19193682014-04-03 15:01:43250void RenderWidget::ScreenMetricsEmulator::Apply(
251 float overdraw_bottom_height, gfx::Rect resizer_rect, bool is_fullscreen) {
252 applied_widget_rect_.set_size(params_.viewSize.isEmpty() ?
253 original_size_ : gfx::Size(params_.viewSize));
254
255 if (params_.fitToView) {
[email protected]b2e4c70132013-10-03 02:07:51256 DCHECK(!original_size_.IsEmpty());
[email protected]4328f3c2013-11-02 02:26:23257
[email protected]4328f3c2013-11-02 02:26:23258 int width_with_gutter =
[email protected]19193682014-04-03 15:01:43259 std::max(original_size_.width() - 2 * params_.viewInsets.width, 1);
[email protected]4328f3c2013-11-02 02:26:23260 int height_with_gutter =
[email protected]19193682014-04-03 15:01:43261 std::max(original_size_.height() - 2 * params_.viewInsets.height, 1);
[email protected]b2e4c70132013-10-03 02:07:51262 float width_ratio =
[email protected]19193682014-04-03 15:01:43263 static_cast<float>(applied_widget_rect_.width()) / width_with_gutter;
[email protected]b2e4c70132013-10-03 02:07:51264 float height_ratio =
[email protected]19193682014-04-03 15:01:43265 static_cast<float>(applied_widget_rect_.height()) / height_with_gutter;
[email protected]b2e4c70132013-10-03 02:07:51266 float ratio = std::max(1.0f, std::max(width_ratio, height_ratio));
267 scale_ = 1.f / ratio;
[email protected]7f0e8fa2014-03-26 12:32:01268
269 // Center emulated view inside available view space.
[email protected]19193682014-04-03 15:01:43270 offset_.set_x(
271 (original_size_.width() - scale_ * applied_widget_rect_.width()) / 2);
[email protected]7f0e8fa2014-03-26 12:32:01272 offset_.set_y(
[email protected]19193682014-04-03 15:01:43273 (original_size_.height() - scale_ * applied_widget_rect_.height()) / 2);
[email protected]b2e4c70132013-10-03 02:07:51274 } else {
275 scale_ = 1.f;
[email protected]7f0e8fa2014-03-26 12:32:01276 offset_.SetPoint(0, 0);
277 }
[email protected]7f0e8fa2014-03-26 12:32:01278
[email protected]19193682014-04-03 15:01:43279 if (params_.screenPosition == WebDeviceEmulationParams::Desktop) {
280 applied_widget_rect_.set_origin(original_view_screen_rect_.origin());
[email protected]7f0e8fa2014-03-26 12:32:01281 widget_->screen_info_.rect = original_screen_info_.rect;
282 widget_->screen_info_.availableRect = original_screen_info_.availableRect;
283 widget_->window_screen_rect_ = original_window_screen_rect_;
284 } else {
[email protected]19193682014-04-03 15:01:43285 applied_widget_rect_.set_origin(gfx::Point(0, 0));
286 widget_->screen_info_.rect = applied_widget_rect_;
287 widget_->screen_info_.availableRect = applied_widget_rect_;
288 widget_->window_screen_rect_ = applied_widget_rect_;
[email protected]7f0e8fa2014-03-26 12:32:01289 }
[email protected]a179d3962013-11-12 14:44:40290
[email protected]19193682014-04-03 15:01:43291 float applied_device_scale_factor = params_.deviceScaleFactor ?
292 params_.deviceScaleFactor : original_screen_info_.deviceScaleFactor;
[email protected]7f0e8fa2014-03-26 12:32:01293 widget_->screen_info_.deviceScaleFactor = applied_device_scale_factor;
[email protected]b2e4c70132013-10-03 02:07:51294
[email protected]7f99fc22013-11-08 14:05:58295 // Pass three emulation parameters to the blink side:
[email protected]b2e4c70132013-10-03 02:07:51296 // - we keep the real device scale factor in compositor to produce sharp image
297 // even when emulating different scale factor;
[email protected]7f99fc22013-11-08 14:05:58298 // - in order to fit into view, WebView applies offset and scale to the
[email protected]b2e4c70132013-10-03 02:07:51299 // root layer.
300 widget_->SetScreenMetricsEmulationParameters(
[email protected]a179d3962013-11-12 14:44:40301 original_screen_info_.deviceScaleFactor, offset_, scale_);
[email protected]b2e4c70132013-10-03 02:07:51302
[email protected]7f0e8fa2014-03-26 12:32:01303 widget_->SetDeviceScaleFactor(applied_device_scale_factor);
[email protected]19193682014-04-03 15:01:43304 widget_->view_screen_rect_ = applied_widget_rect_;
[email protected]b2e4c70132013-10-03 02:07:51305
306 gfx::Size physical_backing_size = gfx::ToCeiledSize(gfx::ScaleSize(
307 original_size_, original_screen_info_.deviceScaleFactor));
[email protected]19193682014-04-03 15:01:43308 widget_->Resize(applied_widget_rect_.size(), physical_backing_size,
[email protected]b2e4c70132013-10-03 02:07:51309 overdraw_bottom_height, resizer_rect, is_fullscreen, NO_RESIZE_ACK);
310}
311
312void RenderWidget::ScreenMetricsEmulator::OnResizeMessage(
313 const ViewMsg_Resize_Params& params) {
314 bool need_ack = params.new_size != original_size_ &&
315 !params.new_size.IsEmpty() && !params.physical_backing_size.IsEmpty();
316 original_size_ = params.new_size;
317 original_physical_backing_size_ = params.physical_backing_size;
318 original_screen_info_ = params.screen_info;
319 Apply(params.overdraw_bottom_height, params.resizer_rect,
320 params.is_fullscreen);
321
322 if (need_ack) {
323 widget_->set_next_paint_is_resize_ack();
324 if (widget_->compositor_)
325 widget_->compositor_->SetNeedsRedrawRect(gfx::Rect(widget_->size_));
326 }
327}
328
329void RenderWidget::ScreenMetricsEmulator::OnUpdateScreenRectsMessage(
330 const gfx::Rect& view_screen_rect,
331 const gfx::Rect& window_screen_rect) {
332 original_view_screen_rect_ = view_screen_rect;
333 original_window_screen_rect_ = window_screen_rect;
[email protected]19193682014-04-03 15:01:43334 if (params_.screenPosition == WebDeviceEmulationParams::Desktop)
335 Reapply();
[email protected]b2e4c70132013-10-03 02:07:51336}
337
338void RenderWidget::ScreenMetricsEmulator::OnShowContextMenu(
339 ContextMenuParams* params) {
340 params->x *= scale_;
[email protected]a179d3962013-11-12 14:44:40341 params->x += offset_.x();
[email protected]b2e4c70132013-10-03 02:07:51342 params->y *= scale_;
[email protected]a179d3962013-11-12 14:44:40343 params->y += offset_.y();
[email protected]b2e4c70132013-10-03 02:07:51344}
345
346// RenderWidget ---------------------------------------------------------------
347
[email protected]180ef242013-11-07 06:50:46348RenderWidget::RenderWidget(blink::WebPopupType popup_type,
349 const blink::WebScreenInfo& screen_info,
[email protected]1ac10dca2013-08-20 20:47:04350 bool swapped_out,
351 bool hidden)
initial.commit09911bf2008-07-26 23:55:29352 : routing_id_(MSG_ROUTING_NONE),
[email protected]9f4f3322012-01-18 22:29:56353 surface_id_(0),
[email protected]c5b3b5e2009-02-13 06:41:11354 webwidget_(NULL),
initial.commit09911bf2008-07-26 23:55:29355 opener_id_(MSG_ROUTING_NONE),
[email protected]fc4404d2012-11-07 19:53:30356 init_complete_(false),
[email protected]b4d08452010-10-05 17:34:35357 current_paint_buf_(NULL),
[email protected]d9083762013-03-24 01:36:40358 overdraw_bottom_height_(0.f),
initial.commit09911bf2008-07-26 23:55:29359 next_paint_flags_(0),
[email protected]0cff69e2011-11-22 22:26:06360 filtered_time_per_frame_(0.0f),
[email protected]53d3f302009-12-21 04:42:05361 update_reply_pending_(false),
[email protected]847a2582013-03-09 02:29:51362 auto_resize_mode_(false),
[email protected]ea3ee0a2012-05-15 03:43:09363 need_update_rect_for_auto_resize_(false),
[email protected]65225772011-05-12 21:10:24364 using_asynchronous_swapbuffers_(false),
365 num_swapbuffers_complete_pending_(0),
initial.commit09911bf2008-07-26 23:55:29366 did_show_(false),
[email protected]1ac10dca2013-08-20 20:47:04367 is_hidden_(hidden),
[email protected]ee41e7d22011-10-14 19:34:09368 is_fullscreen_(false),
initial.commit09911bf2008-07-26 23:55:29369 needs_repainting_on_restore_(false),
370 has_focus_(false),
[email protected]5dd768212009-08-13 23:34:49371 handling_input_event_(false),
[email protected]e8f775f2013-02-14 21:00:50372 handling_ime_event_(false),
[email protected]5d0bbdfa92013-12-10 00:35:51373 handling_touchstart_event_(false),
[email protected]661eb9d2009-02-03 02:11:48374 closing_(false),
[email protected]14392a52012-05-02 20:28:44375 is_swapped_out_(swapped_out),
[email protected]fa7b1dc2010-06-23 17:53:04376 input_method_is_active_(false),
[email protected]ad26ef42011-06-17 07:59:45377 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
[email protected]b256eca2013-07-11 10:57:40378 text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
[email protected]86ba5fcb2013-09-04 00:36:53379 can_compose_inline_(true),
[email protected]3e2b375b2010-04-07 17:03:12380 popup_type_(popup_type),
[email protected]867125a02009-12-10 06:01:48381 pending_window_rect_count_(0),
[email protected]b68a0e52011-12-08 15:11:12382 suppress_next_char_events_(false),
[email protected]5f8b1022011-01-21 23:34:50383 is_accelerated_compositing_active_(false),
[email protected]d8a6c5d12013-09-23 04:37:10384 was_accelerated_compositing_ever_active_(false),
[email protected]ee3d3ad2011-02-04 00:42:21385 animation_update_pending_(false),
[email protected]4b03e292012-02-13 18:40:07386 invalidation_task_posted_(false),
[email protected]842f10652012-06-06 01:54:04387 screen_info_(screen_info),
[email protected]3d779472012-11-15 20:49:52388 device_scale_factor_(screen_info_.deviceScaleFactor),
[email protected]ed7defa2013-03-12 21:29:59389 is_threaded_compositing_enabled_(false),
[email protected]53b4cc12013-07-18 23:02:30390 next_output_surface_id_(0),
[email protected]0d1ebed12013-08-05 22:01:13391#if defined(OS_ANDROID)
[email protected]90f24152014-04-09 12:41:36392 text_field_is_dirty_(false),
[email protected]0d1ebed12013-08-05 22:01:13393 outstanding_ime_acks_(0),
394#endif
[email protected]b2e4c70132013-10-03 02:07:51395 popup_origin_scale_for_emulation_(0.f),
[email protected]a09d53ce2014-01-31 00:46:42396 resizing_mode_selector_(new ResizingModeSelector()),
397 context_menu_source_type_(ui::MENU_SOURCE_MOUSE) {
[email protected]8b3f0eb2012-05-03 19:15:05398 if (!swapped_out)
399 RenderProcess::current()->AddRefProcess();
[email protected]380244092011-10-07 17:26:27400 DCHECK(RenderThread::Get());
[email protected]bd37ae252011-06-03 01:28:18401 has_disable_gpu_vsync_switch_ = CommandLine::ForCurrentProcess()->HasSwitch(
402 switches::kDisableGpuVsync);
[email protected]cb6430932012-10-31 00:53:36403 is_threaded_compositing_enabled_ =
404 CommandLine::ForCurrentProcess()->HasSwitch(
405 switches::kEnableThreadedCompositing);
[email protected]c1e6cc062013-08-24 03:35:35406
407 legacy_software_mode_stats_ = cc::RenderingStatsInstrumentation::Create();
408 if (CommandLine::ForCurrentProcess()->HasSwitch(
[email protected]fe3beef2014-02-06 09:20:53409 cc::switches::kEnableGpuBenchmarking))
[email protected]c1e6cc062013-08-24 03:35:35410 legacy_software_mode_stats_->set_record_rendering_stats(true);
initial.commit09911bf2008-07-26 23:55:29411}
412
413RenderWidget::~RenderWidget() {
[email protected]c5b3b5e2009-02-13 06:41:11414 DCHECK(!webwidget_) << "Leaking our WebWidget!";
[email protected]aa4117f2011-12-09 22:19:21415 STLDeleteElements(&updates_pending_swap_);
[email protected]b4d08452010-10-05 17:34:35416 if (current_paint_buf_) {
[email protected]467414eb2013-07-30 20:32:29417 if (RenderProcess::current()) {
418 // If the RenderProcess is already gone, it will have released all DIBs
419 // in its destructor anyway.
420 RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
421 }
[email protected]b4d08452010-10-05 17:34:35422 current_paint_buf_ = NULL;
initial.commit09911bf2008-07-26 23:55:29423 }
[email protected]bffc8302014-01-23 20:52:16424
[email protected]992db4c2011-05-12 15:37:15425 // If we are swapped out, we have released already.
[email protected]d2e2f9ee2013-08-21 11:02:02426 if (!is_swapped_out_ && RenderProcess::current())
[email protected]992db4c2011-05-12 15:37:15427 RenderProcess::current()->ReleaseProcess();
initial.commit09911bf2008-07-26 23:55:29428}
429
[email protected]484955942010-08-19 16:13:18430// static
[email protected]8085dbc82008-09-26 22:53:44431RenderWidget* RenderWidget::Create(int32 opener_id,
[email protected]180ef242013-11-07 06:50:46432 blink::WebPopupType popup_type,
433 const blink::WebScreenInfo& screen_info) {
initial.commit09911bf2008-07-26 23:55:29434 DCHECK(opener_id != MSG_ROUTING_NONE);
[email protected]6fd35b72012-03-01 19:46:41435 scoped_refptr<RenderWidget> widget(
[email protected]1ac10dca2013-08-20 20:47:04436 new RenderWidget(popup_type, screen_info, false, false));
[email protected]a635f942012-12-07 10:34:29437 if (widget->Init(opener_id)) { // adds reference on success.
[email protected]fc72bb12013-06-02 21:13:46438 return widget.get();
[email protected]a635f942012-12-07 10:34:29439 }
440 return NULL;
initial.commit09911bf2008-07-26 23:55:29441}
442
[email protected]484955942010-08-19 16:13:18443// static
444WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) {
445 switch (render_widget->popup_type_) {
[email protected]180ef242013-11-07 06:50:46446 case blink::WebPopupTypeNone: // Nothing to create.
[email protected]484955942010-08-19 16:13:18447 break;
[email protected]180ef242013-11-07 06:50:46448 case blink::WebPopupTypeSelect:
449 case blink::WebPopupTypeSuggestion:
[email protected]484955942010-08-19 16:13:18450 return WebPopupMenu::create(render_widget);
[email protected]180ef242013-11-07 06:50:46451 case blink::WebPopupTypePage:
[email protected]a7547fb2012-03-08 04:43:44452 return WebPagePopup::create(render_widget);
[email protected]484955942010-08-19 16:13:18453 default:
454 NOTREACHED();
455 }
456 return NULL;
457}
458
[email protected]a635f942012-12-07 10:34:29459bool RenderWidget::Init(int32 opener_id) {
460 return DoInit(opener_id,
461 RenderWidget::CreateWebWidget(this),
462 new ViewHostMsg_CreateWidget(opener_id, popup_type_,
463 &routing_id_, &surface_id_));
[email protected]484955942010-08-19 16:13:18464}
465
[email protected]a635f942012-12-07 10:34:29466bool RenderWidget::DoInit(int32 opener_id,
[email protected]6a8ddba52010-09-05 04:38:06467 WebWidget* web_widget,
[email protected]484955942010-08-19 16:13:18468 IPC::SyncMessage* create_widget_message) {
initial.commit09911bf2008-07-26 23:55:29469 DCHECK(!webwidget_);
470
471 if (opener_id != MSG_ROUTING_NONE)
472 opener_id_ = opener_id;
473
[email protected]484955942010-08-19 16:13:18474 webwidget_ = web_widget;
initial.commit09911bf2008-07-26 23:55:29475
[email protected]380244092011-10-07 17:26:27476 bool result = RenderThread::Get()->Send(create_widget_message);
initial.commit09911bf2008-07-26 23:55:29477 if (result) {
[email protected]380244092011-10-07 17:26:27478 RenderThread::Get()->AddRoute(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29479 // Take a reference on behalf of the RenderThread. This will be balanced
480 // when we receive ViewMsg_Close.
481 AddRef();
[email protected]b2db9272014-01-10 17:42:00482 if (RenderThreadImpl::current()) {
483 RenderThreadImpl::current()->WidgetCreated();
484 if (is_hidden_)
485 RenderThreadImpl::current()->WidgetHidden();
486 }
[email protected]a635f942012-12-07 10:34:29487 return true;
initial.commit09911bf2008-07-26 23:55:29488 } else {
[email protected]a635f942012-12-07 10:34:29489 // The above Send can fail when the tab is closing.
490 return false;
initial.commit09911bf2008-07-26 23:55:29491 }
492}
493
[email protected]fc4404d2012-11-07 19:53:30494// This is used to complete pending inits and non-pending inits.
495void RenderWidget::CompleteInit() {
initial.commit09911bf2008-07-26 23:55:29496 DCHECK(routing_id_ != MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29497
[email protected]fc4404d2012-11-07 19:53:30498 init_complete_ = true;
[email protected]05a980d7a2012-02-07 22:16:42499
[email protected]8926c602013-01-23 05:32:06500 if (webwidget_ && is_threaded_compositing_enabled_) {
501 webwidget_->enterForceCompositingMode(true);
502 }
[email protected]ba91a792013-02-06 09:48:28503 if (compositor_) {
504 compositor_->setSurfaceReady();
[email protected]479b0172012-10-29 19:27:09505 }
[email protected]05a980d7a2012-02-07 22:16:42506 DoDeferredUpdate();
initial.commit09911bf2008-07-26 23:55:29507
[email protected]6de74452009-02-25 18:04:59508 Send(new ViewHostMsg_RenderViewReady(routing_id_));
initial.commit09911bf2008-07-26 23:55:29509}
510
[email protected]992db4c2011-05-12 15:37:15511void RenderWidget::SetSwappedOut(bool is_swapped_out) {
512 // We should only toggle between states.
513 DCHECK(is_swapped_out_ != is_swapped_out);
514 is_swapped_out_ = is_swapped_out;
515
516 // If we are swapping out, we will call ReleaseProcess, allowing the process
517 // to exit if all of its RenderViews are swapped out. We wait until the
518 // WasSwappedOut call to do this, to avoid showing the sad tab.
519 // If we are swapping in, we call AddRefProcess to prevent the process from
520 // exiting.
521 if (!is_swapped_out)
522 RenderProcess::current()->AddRefProcess();
523}
524
[email protected]c8cbae72013-05-23 10:45:03525bool RenderWidget::UsingSynchronousRendererCompositor() const {
[email protected]ccc1722e2013-05-06 19:43:07526#if defined(OS_ANDROID)
[email protected]913d99a2013-05-31 07:16:07527 return SynchronousCompositorFactory::GetInstance() != NULL;
528#else
[email protected]ccc1722e2013-05-06 19:43:07529 return false;
[email protected]913d99a2013-05-31 07:16:07530#endif
[email protected]ccc1722e2013-05-06 19:43:07531}
532
[email protected]b2e4c70132013-10-03 02:07:51533void RenderWidget::EnableScreenMetricsEmulation(
[email protected]19193682014-04-03 15:01:43534 const WebDeviceEmulationParams& params) {
535 if (!screen_metrics_emulator_)
536 screen_metrics_emulator_.reset(new ScreenMetricsEmulator(this, params));
537 else
538 screen_metrics_emulator_->ChangeEmulationParams(params);
[email protected]b2e4c70132013-10-03 02:07:51539}
540
541void RenderWidget::DisableScreenMetricsEmulation() {
542 screen_metrics_emulator_.reset();
543}
544
545void RenderWidget::SetPopupOriginAdjustmentsForEmulation(
546 ScreenMetricsEmulator* emulator) {
547 popup_origin_scale_for_emulation_ = emulator->scale();
[email protected]19193682014-04-03 15:01:43548 popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
[email protected]9a2d7ee32013-12-05 12:15:49549 popup_screen_origin_for_emulation_ = gfx::Point(
550 emulator->original_screen_rect().origin().x() + emulator->offset().x(),
551 emulator->original_screen_rect().origin().y() + emulator->offset().y());
[email protected]5f75aa42014-04-01 23:00:56552 screen_info_ = emulator->original_screen_info();
553 device_scale_factor_ = screen_info_.deviceScaleFactor;
[email protected]b2e4c70132013-10-03 02:07:51554}
555
556void RenderWidget::SetScreenMetricsEmulationParameters(
[email protected]7f99fc22013-11-08 14:05:58557 float device_scale_factor,
558 const gfx::Point& root_layer_offset,
559 float root_layer_scale) {
[email protected]b2e4c70132013-10-03 02:07:51560 // This is only supported in RenderView.
561 NOTREACHED();
562}
563
[email protected]53907862014-03-25 15:42:40564#if defined(OS_MACOSX) || defined(OS_ANDROID)
[email protected]b2e4c70132013-10-03 02:07:51565void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
566 ExternalPopupMenu* popup, ScreenMetricsEmulator* emulator) {
[email protected]9a2d7ee32013-12-05 12:15:49567 popup->SetOriginScaleAndOffsetForEmulation(
568 emulator->scale(), emulator->offset());
[email protected]b2e4c70132013-10-03 02:07:51569}
[email protected]53907862014-03-25 15:42:40570#endif
[email protected]b2e4c70132013-10-03 02:07:51571
572void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
573 if (screen_metrics_emulator_)
574 screen_metrics_emulator_->OnShowContextMenu(params);
575}
576
[email protected]7d08a9352013-10-15 08:24:56577void RenderWidget::ScheduleCompositeWithForcedRedraw() {
578 if (compositor_) {
579 // Regardless of whether threaded compositing is enabled, always
580 // use this mechanism to force the compositor to redraw. However,
581 // the invalidation code path below is still needed for the
582 // non-threaded case.
583 compositor_->SetNeedsForcedRedraw();
584 }
[email protected]8b9e52b2014-01-17 16:35:31585 scheduleComposite();
[email protected]7d08a9352013-10-15 08:24:56586}
587
[email protected]a95986a82010-12-24 06:19:28588bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
589 bool handled = true;
590 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
[email protected]c084330e02013-04-27 01:08:15591 IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
[email protected]34202de2013-05-06 23:36:22592 IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
593 OnCursorVisibilityChange)
[email protected]c084330e02013-04-27 01:08:15594 IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
595 IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
[email protected]9017d7852013-11-21 17:47:35596 IPC_MESSAGE_HANDLER(InputMsg_SyntheticGestureCompleted,
597 OnSyntheticGestureCompleted)
[email protected]a95986a82010-12-24 06:19:28598 IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
599 IPC_MESSAGE_HANDLER(ViewMsg_CreatingNew_ACK, OnCreatingNewAck)
600 IPC_MESSAGE_HANDLER(ViewMsg_Resize, OnResize)
[email protected]b5913d72012-02-07 22:26:54601 IPC_MESSAGE_HANDLER(ViewMsg_ChangeResizeRect, OnChangeResizeRect)
[email protected]a95986a82010-12-24 06:19:28602 IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
[email protected]9e2e4632012-07-27 16:38:41603 IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
[email protected]992db4c2011-05-12 15:37:15604 IPC_MESSAGE_HANDLER(ViewMsg_WasSwappedOut, OnWasSwappedOut)
[email protected]a95986a82010-12-24 06:19:28605 IPC_MESSAGE_HANDLER(ViewMsg_UpdateRect_ACK, OnUpdateRectAck)
[email protected]4d7e46a2013-11-08 05:33:40606 IPC_MESSAGE_HANDLER(ViewMsg_SwapBuffers_ACK, OnSwapBuffersComplete)
[email protected]a95986a82010-12-24 06:19:28607 IPC_MESSAGE_HANDLER(ViewMsg_SetInputMethodActive, OnSetInputMethodActive)
[email protected]37a241c2013-12-03 03:16:17608 IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowShown, OnCandidateWindowShown)
609 IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowUpdated,
610 OnCandidateWindowUpdated)
611 IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowHidden, OnCandidateWindowHidden)
[email protected]a95986a82010-12-24 06:19:28612 IPC_MESSAGE_HANDLER(ViewMsg_ImeSetComposition, OnImeSetComposition)
613 IPC_MESSAGE_HANDLER(ViewMsg_ImeConfirmComposition, OnImeConfirmComposition)
[email protected]3d9ec5052013-01-02 22:05:25614 IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
[email protected]a95986a82010-12-24 06:19:28615 IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
616 IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
[email protected]80ad8622012-11-07 16:33:03617 IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
[email protected]105dffb42013-02-20 03:46:21618#if defined(OS_ANDROID)
[email protected]2384b6c2013-02-28 23:58:51619 IPC_MESSAGE_HANDLER(ViewMsg_ShowImeIfNeeded, OnShowImeIfNeeded)
[email protected]0d1ebed12013-08-05 22:01:13620 IPC_MESSAGE_HANDLER(ViewMsg_ImeEventAck, OnImeEventAck)
[email protected]105dffb42013-02-20 03:46:21621#endif
[email protected]51a49502013-03-23 01:50:19622 IPC_MESSAGE_HANDLER(ViewMsg_Snapshot, OnSnapshot)
[email protected]a95986a82010-12-24 06:19:28623 IPC_MESSAGE_UNHANDLED(handled = false)
624 IPC_END_MESSAGE_MAP()
625 return handled;
626}
initial.commit09911bf2008-07-26 23:55:29627
628bool RenderWidget::Send(IPC::Message* message) {
[email protected]992db4c2011-05-12 15:37:15629 // Don't send any messages after the browser has told us to close, and filter
630 // most outgoing messages while swapped out.
631 if ((is_swapped_out_ &&
[email protected]e9ff79c2012-10-19 21:31:26632 !SwappedOutMessages::CanSendWhileSwappedOut(message)) ||
[email protected]c6c921e92012-05-10 23:31:11633 closing_) {
initial.commit09911bf2008-07-26 23:55:29634 delete message;
635 return false;
636 }
637
638 // If given a messsage without a routing ID, then assign our routing ID.
639 if (message->routing_id() == MSG_ROUTING_NONE)
640 message->set_routing_id(routing_id_);
641
[email protected]380244092011-10-07 17:26:27642 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44643}
644
[email protected]61e2b3cc2012-03-02 16:13:34645void RenderWidget::Resize(const gfx::Size& new_size,
[email protected]60d47ac2013-03-01 23:42:44646 const gfx::Size& physical_backing_size,
[email protected]d9083762013-03-24 01:36:40647 float overdraw_bottom_height,
[email protected]61e2b3cc2012-03-02 16:13:34648 const gfx::Rect& resizer_rect,
649 bool is_fullscreen,
650 ResizeAck resize_ack) {
[email protected]f7c1f092013-11-05 20:20:56651 if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
[email protected]1c0008842013-06-06 08:35:48652 // A resize ack shouldn't be requested if we have not ACK'd the previous
653 // one.
654 DCHECK(resize_ack != SEND_RESIZE_ACK || !next_paint_is_resize_ack());
655 DCHECK(resize_ack == SEND_RESIZE_ACK || resize_ack == NO_RESIZE_ACK);
656 }
initial.commit09911bf2008-07-26 23:55:29657
[email protected]61e2b3cc2012-03-02 16:13:34658 // Ignore this during shutdown.
659 if (!webwidget_)
660 return;
661
[email protected]d9083762013-03-24 01:36:40662 if (compositor_) {
[email protected]60d47ac2013-03-01 23:42:44663 compositor_->setViewportSize(new_size, physical_backing_size);
[email protected]d9083762013-03-24 01:36:40664 compositor_->SetOverdrawBottomHeight(overdraw_bottom_height);
665 }
[email protected]60d47ac2013-03-01 23:42:44666
[email protected]dade8992013-03-04 07:34:34667 physical_backing_size_ = physical_backing_size;
[email protected]d9083762013-03-24 01:36:40668 overdraw_bottom_height_ = overdraw_bottom_height;
[email protected]61e2b3cc2012-03-02 16:13:34669 resizer_rect_ = resizer_rect;
670
671 // NOTE: We may have entered fullscreen mode without changing our size.
672 bool fullscreen_change = is_fullscreen_ != is_fullscreen;
673 if (fullscreen_change)
674 WillToggleFullscreen();
675 is_fullscreen_ = is_fullscreen;
676
677 if (size_ != new_size) {
678 // TODO(darin): We should not need to reset this here.
[email protected]61e2b3cc2012-03-02 16:13:34679 needs_repainting_on_restore_ = false;
680
681 size_ = new_size;
682
683 paint_aggregator_.ClearPendingUpdate();
684
685 // When resizing, we want to wait to paint before ACK'ing the resize. This
686 // ensures that we only resize as fast as we can paint. We only need to
687 // send an ACK if we are resized to a non-empty rect.
688 webwidget_->resize(new_size);
[email protected]0b70dbe2013-05-10 19:06:32689
[email protected]f7c1f092013-11-05 20:20:56690 if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
[email protected]92201e32013-06-08 06:14:52691 // Resize should have caused an invalidation of the entire view.
692 DCHECK(new_size.IsEmpty() || is_accelerated_compositing_active_ ||
693 paint_aggregator_.HasPendingUpdate());
694 }
[email protected]5b45ad42013-10-25 00:42:04695 } else if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]632c4382013-05-15 08:58:45696 resize_ack = NO_RESIZE_ACK;
697 }
698
699 if (new_size.IsEmpty() || physical_backing_size.IsEmpty()) {
700 // For empty size or empty physical_backing_size, there is no next paint
701 // (along with which to send the ack) until they are set to non-empty.
[email protected]ff475a322012-03-14 00:05:35702 resize_ack = NO_RESIZE_ACK;
[email protected]61e2b3cc2012-03-02 16:13:34703 }
704
[email protected]20fbfc22013-05-08 20:50:58705 // Send the Resize_ACK flag once we paint again if requested.
[email protected]632c4382013-05-15 08:58:45706 if (resize_ack == SEND_RESIZE_ACK)
[email protected]20fbfc22013-05-08 20:50:58707 set_next_paint_is_resize_ack();
708
[email protected]61e2b3cc2012-03-02 16:13:34709 if (fullscreen_change)
710 DidToggleFullscreen();
711
712 // If a resize ack is requested and it isn't set-up, then no more resizes will
713 // come in and in general things will go wrong.
[email protected]632c4382013-05-15 08:58:45714 DCHECK(resize_ack != SEND_RESIZE_ACK || next_paint_is_resize_ack());
initial.commit09911bf2008-07-26 23:55:29715}
716
[email protected]92650162013-10-30 03:31:02717void RenderWidget::ResizeSynchronously(const gfx::Rect& new_position) {
718 Resize(new_position.size(), new_position.size(), overdraw_bottom_height_,
719 gfx::Rect(), is_fullscreen_, NO_RESIZE_ACK);
720 view_screen_rect_ = new_position;
721 window_screen_rect_ = new_position;
722 if (!did_show_)
723 initial_pos_ = new_position;
724}
725
initial.commit09911bf2008-07-26 23:55:29726void RenderWidget::OnClose() {
727 if (closing_)
728 return;
729 closing_ = true;
730
731 // Browser correspondence is no longer needed at this point.
[email protected]bee16aab2009-08-26 15:55:03732 if (routing_id_ != MSG_ROUTING_NONE) {
[email protected]b2db9272014-01-10 17:42:00733 if (RenderThreadImpl::current())
734 RenderThreadImpl::current()->WidgetDestroyed();
[email protected]380244092011-10-07 17:26:27735 RenderThread::Get()->RemoveRoute(routing_id_);
[email protected]bee16aab2009-08-26 15:55:03736 SetHidden(false);
737 }
initial.commit09911bf2008-07-26 23:55:29738
initial.commit09911bf2008-07-26 23:55:29739 // If there is a Send call on the stack, then it could be dangerous to close
[email protected]d3fc25652009-02-24 22:31:25740 // now. Post a task that only gets invoked when there are no nested message
741 // loops.
[email protected]dd32b1272013-05-04 14:17:11742 base::MessageLoop::current()->PostNonNestableTask(
[email protected]3a5a7822011-12-23 18:27:29743 FROM_HERE, base::Bind(&RenderWidget::Close, this));
[email protected]d3fc25652009-02-24 22:31:25744
745 // Balances the AddRef taken when we called AddRoute.
746 Release();
initial.commit09911bf2008-07-26 23:55:29747}
748
[email protected]61e2b3cc2012-03-02 16:13:34749// Got a response from the browser after the renderer decided to create a new
750// view.
[email protected]fc4404d2012-11-07 19:53:30751void RenderWidget::OnCreatingNewAck() {
[email protected]61e2b3cc2012-03-02 16:13:34752 DCHECK(routing_id_ != MSG_ROUTING_NONE);
753
[email protected]fc4404d2012-11-07 19:53:30754 CompleteInit();
[email protected]61e2b3cc2012-03-02 16:13:34755}
756
[email protected]0fdd5012013-05-29 08:05:56757void RenderWidget::OnResize(const ViewMsg_Resize_Params& params) {
[email protected]5b45ad42013-10-25 00:42:04758 if (resizing_mode_selector_->ShouldAbortOnResize(this, params))
[email protected]03e88672013-10-22 21:31:32759 return;
760
[email protected]b2e4c70132013-10-03 02:07:51761 if (screen_metrics_emulator_) {
762 screen_metrics_emulator_->OnResizeMessage(params);
763 return;
764 }
765
[email protected]0fdd5012013-05-29 08:05:56766 screen_info_ = params.screen_info;
767 SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
768 Resize(params.new_size, params.physical_backing_size,
769 params.overdraw_bottom_height, params.resizer_rect,
770 params.is_fullscreen, SEND_RESIZE_ACK);
initial.commit09911bf2008-07-26 23:55:29771}
772
[email protected]b5913d72012-02-07 22:26:54773void RenderWidget::OnChangeResizeRect(const gfx::Rect& resizer_rect) {
774 if (resizer_rect_ != resizer_rect) {
[email protected]b9769d82012-02-10 00:23:59775 gfx::Rect view_rect(size_);
776
[email protected]ce112fe2012-10-29 22:52:18777 gfx::Rect old_damage_rect = gfx::IntersectRects(view_rect, resizer_rect_);
[email protected]b9769d82012-02-10 00:23:59778 if (!old_damage_rect.IsEmpty())
779 paint_aggregator_.InvalidateRect(old_damage_rect);
780
[email protected]ce112fe2012-10-29 22:52:18781 gfx::Rect new_damage_rect = gfx::IntersectRects(view_rect, resizer_rect);
[email protected]b9769d82012-02-10 00:23:59782 if (!new_damage_rect.IsEmpty())
783 paint_aggregator_.InvalidateRect(new_damage_rect);
784
[email protected]b5913d72012-02-07 22:26:54785 resizer_rect_ = resizer_rect;
[email protected]b9769d82012-02-10 00:23:59786
[email protected]b5913d72012-02-07 22:26:54787 if (webwidget_)
788 webwidget_->didChangeWindowResizerRect();
789 }
790}
791
initial.commit09911bf2008-07-26 23:55:29792void RenderWidget::OnWasHidden() {
[email protected]9c3085f2011-06-09 02:10:31793 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
initial.commit09911bf2008-07-26 23:55:29794 // Go into a mode where we stop generating paint and scrolling events.
[email protected]bee16aab2009-08-26 15:55:03795 SetHidden(true);
initial.commit09911bf2008-07-26 23:55:29796}
797
[email protected]9e2e4632012-07-27 16:38:41798void RenderWidget::OnWasShown(bool needs_repainting) {
799 TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
initial.commit09911bf2008-07-26 23:55:29800 // During shutdown we can just ignore this message.
801 if (!webwidget_)
802 return;
803
804 // See OnWasHidden
[email protected]bee16aab2009-08-26 15:55:03805 SetHidden(false);
initial.commit09911bf2008-07-26 23:55:29806
807 if (!needs_repainting && !needs_repainting_on_restore_)
808 return;
809 needs_repainting_on_restore_ = false;
810
[email protected]d65adb12010-04-28 17:26:49811 // Tag the next paint as a restore ack, which is picked up by
812 // DoDeferredUpdate when it sends out the next PaintRect message.
initial.commit09911bf2008-07-26 23:55:29813 set_next_paint_is_restore_ack();
814
815 // Generate a full repaint.
[email protected]a79d8a632010-11-18 22:35:56816 if (!is_accelerated_compositing_active_) {
[email protected]f98d7e3c2010-09-13 22:30:46817 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
818 } else {
[email protected]8b9e52b2014-01-17 16:35:31819 if (compositor_)
820 compositor_->SetNeedsForcedRedraw();
821 scheduleComposite();
[email protected]f98d7e3c2010-09-13 22:30:46822 }
initial.commit09911bf2008-07-26 23:55:29823}
824
[email protected]992db4c2011-05-12 15:37:15825void RenderWidget::OnWasSwappedOut() {
826 // If we have been swapped out and no one else is using this process,
827 // it's safe to exit now. If we get swapped back in, we will call
828 // AddRefProcess in SetSwappedOut.
829 if (is_swapped_out_)
830 RenderProcess::current()->ReleaseProcess();
831}
832
[email protected]53d3f302009-12-21 04:42:05833void RenderWidget::OnRequestMoveAck() {
834 DCHECK(pending_window_rect_count_);
835 pending_window_rect_count_--;
836}
837
838void RenderWidget::OnUpdateRectAck() {
[email protected]366ae242011-05-10 02:23:58839 TRACE_EVENT0("renderer", "RenderWidget::OnUpdateRectAck");
[email protected]aa4117f2011-12-09 22:19:21840 DCHECK(update_reply_pending_);
[email protected]53d3f302009-12-21 04:42:05841 update_reply_pending_ = false;
842
[email protected]b4d08452010-10-05 17:34:35843 // If we sent an UpdateRect message with a zero-sized bitmap, then we should
844 // have no current paint buffer.
845 if (current_paint_buf_) {
846 RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
847 current_paint_buf_ = NULL;
848 }
849
[email protected]65225772011-05-12 21:10:24850 // If swapbuffers is still pending, then defer the update until the
851 // swapbuffers occurs.
852 if (num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending) {
853 TRACE_EVENT0("renderer", "EarlyOut_SwapStillPending");
854 return;
855 }
856
[email protected]29ed96a2012-02-04 18:12:16857 // Notify subclasses that software rendering was flushed to the screen.
[email protected]404939f2012-06-01 04:06:18858 if (!is_accelerated_compositing_active_) {
859 DidFlushPaint();
860 }
[email protected]a2f6bc112009-06-27 16:27:25861
initial.commit09911bf2008-07-26 23:55:29862 // Continue painting if necessary...
[email protected]65225772011-05-12 21:10:24863 DoDeferredUpdateAndSendInputAck();
864}
865
[email protected]d0be63772011-12-20 23:18:04866bool RenderWidget::SupportsAsynchronousSwapBuffers() {
[email protected]ed7defa2013-03-12 21:29:59867 // Contexts using the command buffer support asynchronous swapbuffers.
868 // See RenderWidget::CreateOutputSurface().
[email protected]cadac622013-06-11 16:46:36869 if (RenderThreadImpl::current()->compositor_message_loop_proxy().get())
[email protected]ed7defa2013-03-12 21:29:59870 return false;
871
872 return true;
873}
874
875GURL RenderWidget::GetURLForGraphicsContext3D() {
876 return GURL();
[email protected]65225772011-05-12 21:10:24877}
878
[email protected]479b0172012-10-29 19:27:09879bool RenderWidget::ForceCompositingModeEnabled() {
880 return false;
881}
882
[email protected]ebc0e1df2013-08-01 02:46:22883scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(bool fallback) {
[email protected]a1811b8912013-05-09 15:35:19884
885#if defined(OS_ANDROID)
[email protected]b6eb8e332013-09-10 00:51:01886 if (SynchronousCompositorFactory* factory =
887 SynchronousCompositorFactory::GetInstance()) {
[email protected]913d99a2013-05-31 07:16:07888 return factory->CreateOutputSurface(routing_id());
[email protected]a1811b8912013-05-09 15:35:19889 }
890#endif
891
[email protected]b6eb8e332013-09-10 00:51:01892 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
[email protected]e09994a2014-03-26 19:59:33893 bool use_software = fallback;
894 if (command_line.HasSwitch(switches::kDisableGpuCompositing))
895 use_software = true;
896
[email protected]0634cdd42013-08-16 00:46:09897 scoped_refptr<ContextProviderCommandBuffer> context_provider;
[email protected]e09994a2014-03-26 19:59:33898 if (!use_software) {
[email protected]0634cdd42013-08-16 00:46:09899 context_provider = ContextProviderCommandBuffer::Create(
[email protected]828a3932014-04-02 14:43:13900 CreateGraphicsContext3D(), "RenderCompositor");
[email protected]e09994a2014-03-26 19:59:33901 if (!context_provider.get()) {
902 // Cause the compositor to wait and try again.
903 return scoped_ptr<cc::OutputSurface>();
904 }
[email protected]0634cdd42013-08-16 00:46:09905 }
[email protected]ebc0e1df2013-08-01 02:46:22906
[email protected]b6eb8e332013-09-10 00:51:01907 uint32 output_surface_id = next_output_surface_id_++;
[email protected]50cf1992014-03-29 00:06:00908 if (command_line.HasSwitch(switches::kEnableDelegatedRenderer)) {
[email protected]65a33ce2014-03-25 22:37:09909 DCHECK(is_threaded_compositing_enabled_);
910 return scoped_ptr<cc::OutputSurface>(
911 new DelegatedCompositorOutputSurface(
912 routing_id(),
913 output_surface_id,
914 context_provider));
915 }
[email protected]0634cdd42013-08-16 00:46:09916 if (!context_provider.get()) {
[email protected]ebc0e1df2013-08-01 02:46:22917 if (!command_line.HasSwitch(switches::kEnableSoftwareCompositing))
918 return scoped_ptr<cc::OutputSurface>();
[email protected]0634cdd42013-08-16 00:46:09919
920 scoped_ptr<cc::SoftwareOutputDevice> software_device(
921 new CompositorSoftwareOutputDevice());
922
923 return scoped_ptr<cc::OutputSurface>(new CompositorOutputSurface(
924 routing_id(),
925 output_surface_id,
926 NULL,
927 software_device.Pass(),
928 true));
[email protected]ebc0e1df2013-08-01 02:46:22929 }
[email protected]ed7defa2013-03-12 21:29:59930
[email protected]36e5ff12013-06-11 12:19:29931 if (command_line.HasSwitch(cc::switches::kCompositeToMailbox)) {
[email protected]758efb02014-04-05 07:53:45932 // Composite-to-mailbox is currently used for layout tests in order to cause
933 // them to draw inside in the renderer to do the readback there. This should
934 // no longer be the case when crbug.com/311404 is fixed.
935 DCHECK(is_threaded_compositing_enabled_ ||
936 RenderThreadImpl::current()->layout_test_mode());
[email protected]186f09602013-09-24 07:13:16937 cc::ResourceFormat format = cc::RGBA_8888;
938#if defined(OS_ANDROID)
939 if (base::android::SysUtils::IsLowEndDevice())
940 format = cc::RGB_565;
941#endif
[email protected]36e5ff12013-06-11 12:19:29942 return scoped_ptr<cc::OutputSurface>(
[email protected]0634cdd42013-08-16 00:46:09943 new MailboxOutputSurface(
944 routing_id(),
945 output_surface_id,
946 context_provider,
[email protected]186f09602013-09-24 07:13:16947 scoped_ptr<cc::SoftwareOutputDevice>(),
948 format));
[email protected]36e5ff12013-06-11 12:19:29949 }
[email protected]0634cdd42013-08-16 00:46:09950 bool use_swap_compositor_frame_message = false;
[email protected]36e5ff12013-06-11 12:19:29951 return scoped_ptr<cc::OutputSurface>(
[email protected]0634cdd42013-08-16 00:46:09952 new CompositorOutputSurface(
953 routing_id(),
954 output_surface_id,
955 context_provider,
956 scoped_ptr<cc::SoftwareOutputDevice>(),
957 use_swap_compositor_frame_message));
[email protected]ba91a792013-02-06 09:48:28958}
959
[email protected]4d7e46a2013-11-08 05:33:40960void RenderWidget::OnSwapBuffersAborted() {
[email protected]65225772011-05-12 21:10:24961 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
[email protected]aa4117f2011-12-09 22:19:21962 while (!updates_pending_swap_.empty()) {
963 ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
964 updates_pending_swap_.pop_front();
965 // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
966 // compositing pass, hence doesn't require an UpdateRect message.
967 if (msg)
968 Send(msg);
969 }
[email protected]65225772011-05-12 21:10:24970 num_swapbuffers_complete_pending_ = 0;
971 using_asynchronous_swapbuffers_ = false;
972 // Schedule another frame so the compositor learns about it.
[email protected]8b9e52b2014-01-17 16:35:31973 scheduleComposite();
[email protected]65225772011-05-12 21:10:24974}
975
[email protected]4d7e46a2013-11-08 05:33:40976void RenderWidget::OnSwapBuffersPosted() {
[email protected]37a6f302011-07-11 23:43:08977 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
[email protected]aa4117f2011-12-09 22:19:21978
979 if (using_asynchronous_swapbuffers_) {
980 ViewHostMsg_UpdateRect* msg = NULL;
981 // pending_update_params_ can be NULL if the swap doesn't correspond to an
982 // DoDeferredUpdate compositing pass, hence doesn't require an UpdateRect
983 // message.
[email protected]59383c782013-04-17 16:43:27984 if (pending_update_params_) {
[email protected]aa4117f2011-12-09 22:19:21985 msg = new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_);
986 pending_update_params_.reset();
987 }
988 updates_pending_swap_.push_back(msg);
[email protected]37a6f302011-07-11 23:43:08989 num_swapbuffers_complete_pending_++;
[email protected]aa4117f2011-12-09 22:19:21990 }
[email protected]37a6f302011-07-11 23:43:08991}
992
[email protected]4d7e46a2013-11-08 05:33:40993void RenderWidget::OnSwapBuffersComplete() {
[email protected]65225772011-05-12 21:10:24994 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersComplete");
[email protected]29ed96a2012-02-04 18:12:16995
[email protected]404939f2012-06-01 04:06:18996 // Notify subclasses that composited rendering was flushed to the screen.
[email protected]29ed96a2012-02-04 18:12:16997 DidFlushPaint();
998
[email protected]65225772011-05-12 21:10:24999 // When compositing deactivates, we reset the swapbuffers pending count. The
1000 // swapbuffers acks may still arrive, however.
1001 if (num_swapbuffers_complete_pending_ == 0) {
1002 TRACE_EVENT0("renderer", "EarlyOut_ZeroSwapbuffersPending");
1003 return;
1004 }
[email protected]aa4117f2011-12-09 22:19:211005 DCHECK(!updates_pending_swap_.empty());
1006 ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
1007 updates_pending_swap_.pop_front();
1008 // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
1009 // compositing pass, hence doesn't require an UpdateRect message.
1010 if (msg)
1011 Send(msg);
[email protected]65225772011-05-12 21:10:241012 num_swapbuffers_complete_pending_--;
1013
1014 // If update reply is still pending, then defer the update until that reply
1015 // occurs.
[email protected]d0be63772011-12-20 23:18:041016 if (update_reply_pending_) {
[email protected]65225772011-05-12 21:10:241017 TRACE_EVENT0("renderer", "EarlyOut_UpdateReplyPending");
1018 return;
1019 }
1020
1021 // If we are not accelerated rendering, then this is a stale swapbuffers from
[email protected]50312bf2011-06-22 23:30:061022 // when we were previously rendering. However, if an invalidation task is not
1023 // posted, there may be software rendering work pending. In that case, don't
1024 // early out.
1025 if (!is_accelerated_compositing_active_ && invalidation_task_posted_) {
[email protected]65225772011-05-12 21:10:241026 TRACE_EVENT0("renderer", "EarlyOut_AcceleratedCompositingOff");
1027 return;
1028 }
1029
[email protected]cc66e682012-10-02 06:48:181030 // Do not call DoDeferredUpdate unless there's animation work to be done or
1031 // a real invalidation. This prevents rendering in response to a swapbuffers
1032 // callback coming back after we've navigated away from the page that
1033 // generated it.
1034 if (!animation_update_pending_ && !paint_aggregator_.HasPendingUpdate()) {
1035 TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
1036 return;
1037 }
1038
[email protected]65225772011-05-12 21:10:241039 // Continue painting if necessary...
1040 DoDeferredUpdateAndSendInputAck();
initial.commit09911bf2008-07-26 23:55:291041}
1042
[email protected]180ef242013-11-07 06:50:461043void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event,
[email protected]205294b2014-03-18 20:48:351044 const ui::LatencyInfo& latency_info,
[email protected]0dea1652012-12-14 00:09:091045 bool is_keyboard_shortcut) {
[email protected]5dd768212009-08-13 23:34:491046 handling_input_event_ = true;
[email protected]0dea1652012-12-14 00:09:091047 if (!input_event) {
[email protected]5dd768212009-08-13 23:34:491048 handling_input_event_ = false;
initial.commit09911bf2008-07-26 23:55:291049 return;
[email protected]5dd768212009-08-13 23:34:491050 }
initial.commit09911bf2008-07-26 23:55:291051
[email protected]fd847792013-10-24 17:12:351052 base::TimeTicks start_time;
1053 if (base::TimeTicks::IsHighResNowFastAndReliable())
1054 start_time = base::TimeTicks::HighResNow();
1055
[email protected]8e299aa2013-10-16 18:17:441056 const char* const event_name =
1057 WebInputEventTraits::GetName(input_event->type);
[email protected]b4841e1c2013-05-16 22:30:101058 TRACE_EVENT1("renderer", "RenderWidget::OnHandleInputEvent",
1059 "event", event_name);
[email protected]b2e92592014-01-10 15:47:151060 TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("blink.HandleInputEvent");
[email protected]15ba6dea2014-04-02 01:44:131061 TRACE_EVENT_FLOW_STEP0(
1062 "input",
1063 "LatencyInfo.Flow",
1064 TRACE_ID_DONT_MANGLE(latency_info.trace_id),
1065 "HanldeInputEventMain");
[email protected]b4841e1c2013-05-16 22:30:101066
[email protected]6be422b2013-12-08 06:47:311067 scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor;
[email protected]205294b2014-03-18 20:48:351068 ui::LatencyInfo swap_latency_info(latency_info);
[email protected]6be422b2013-12-08 06:47:311069 if (compositor_) {
1070 latency_info_swap_promise_monitor =
[email protected]205294b2014-03-18 20:48:351071 compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info)
1072 .Pass();
[email protected]6be422b2013-12-08 06:47:311073 } else {
[email protected]98a04472013-12-23 20:42:501074 latency_info_.push_back(latency_info);
[email protected]6be422b2013-12-08 06:47:311075 }
[email protected]c2eaa8f2013-05-10 02:41:551076
[email protected]6bb8e8a2014-04-04 20:02:441077 if (base::TimeTicks::IsHighResNowFastAndReliable()) {
1078 // If we don't have a high res timer, these metrics won't be accurate enough
1079 // to be worth collecting. Note that this does introduce some sampling bias.
[email protected]6a4d7f62013-01-07 21:32:131080
[email protected]6bb8e8a2014-04-04 20:02:441081 base::TimeDelta now = base::TimeDelta::FromInternalValue(
1082 base::TimeTicks::HighResNow().ToInternalValue());
1083
1084 int64 delta =
1085 static_cast<int64>((now.InSecondsF() - input_event->timeStampSeconds) *
1086 base::Time::kMicrosecondsPerSecond);
1087
1088 UMA_HISTOGRAM_CUSTOM_COUNTS(
1089 "Event.AggregatedLatency.Renderer2", delta, 1, 10000000, 100);
1090 base::HistogramBase* counter_for_type = base::Histogram::FactoryGet(
1091 base::StringPrintf("Event.Latency.Renderer2.%s", event_name),
1092 1,
1093 10000000,
1094 100,
1095 base::HistogramBase::kUmaTargetedHistogramFlag);
1096 counter_for_type->Add(delta);
1097 }
[email protected]6a4d7f62013-01-07 21:32:131098
[email protected]72aee842014-02-20 19:41:411099 if (WebInputEvent::isUserGestureEventType(input_event->type))
1100 WillProcessUserGesture();
1101
[email protected]67bfb83f2011-09-22 03:36:371102 bool prevent_default = false;
1103 if (WebInputEvent::isMouseEventType(input_event->type)) {
[email protected]936c6f52011-12-13 01:35:261104 const WebMouseEvent& mouse_event =
1105 *static_cast<const WebMouseEvent*>(input_event);
1106 TRACE_EVENT2("renderer", "HandleMouseMove",
1107 "x", mouse_event.x, "y", mouse_event.y);
[email protected]a09d53ce2014-01-31 00:46:421108 context_menu_source_type_ = ui::MENU_SOURCE_MOUSE;
[email protected]936c6f52011-12-13 01:35:261109 prevent_default = WillHandleMouseEvent(mouse_event);
[email protected]67bfb83f2011-09-22 03:36:371110 }
1111
[email protected]cefe9b152014-03-27 18:16:151112 if (WebInputEvent::isKeyboardEventType(input_event->type)) {
[email protected]a09d53ce2014-01-31 00:46:421113 context_menu_source_type_ = ui::MENU_SOURCE_KEYBOARD;
[email protected]cefe9b152014-03-27 18:16:151114#if defined(OS_ANDROID)
1115 // The DPAD_CENTER key on Android has a dual semantic: (1) in the general
1116 // case it should behave like a select key (i.e. causing a click if a button
1117 // is focused). However, if a text field is focused (2), its intended
1118 // behavior is to just show the IME and don't propagate the key.
1119 // A typical use case is a web form: the DPAD_CENTER should bring up the IME
1120 // when clicked on an input text field and cause the form submit if clicked
1121 // when the submit button is focused, but not vice-versa.
1122 // The UI layer takes care of translating DPAD_CENTER into a RETURN key,
1123 // but at this point we have to swallow the event for the scenario (2).
1124 const WebKeyboardEvent& key_event =
1125 *static_cast<const WebKeyboardEvent*>(input_event);
1126 if (key_event.nativeKeyCode == AKEYCODE_DPAD_CENTER &&
1127 GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE) {
1128 OnShowImeIfNeeded();
1129 prevent_default = true;
1130 }
1131#endif
1132 }
[email protected]f56c7872013-06-18 12:31:571133
[email protected]41d86852012-11-07 12:23:241134 if (WebInputEvent::isGestureEventType(input_event->type)) {
1135 const WebGestureEvent& gesture_event =
1136 *static_cast<const WebGestureEvent*>(input_event);
[email protected]a09d53ce2014-01-31 00:46:421137 context_menu_source_type_ = ui::MENU_SOURCE_TOUCH;
[email protected]41d86852012-11-07 12:23:241138 prevent_default = prevent_default || WillHandleGestureEvent(gesture_event);
1139 }
1140
[email protected]5d0bbdfa92013-12-10 00:35:511141 if (input_event->type == WebInputEvent::TouchStart)
1142 handling_touchstart_event_ = true;
1143
[email protected]67bfb83f2011-09-22 03:36:371144 bool processed = prevent_default;
[email protected]b68a0e52011-12-08 15:11:121145 if (input_event->type != WebInputEvent::Char || !suppress_next_char_events_) {
1146 suppress_next_char_events_ = false;
1147 if (!processed && webwidget_)
1148 processed = webwidget_->handleInputEvent(*input_event);
1149 }
1150
[email protected]5d0bbdfa92013-12-10 00:35:511151 handling_touchstart_event_ = false;
1152
[email protected]b68a0e52011-12-08 15:11:121153 // If this RawKeyDown event corresponds to a browser keyboard shortcut and
1154 // it's not processed by webkit, then we need to suppress the upcoming Char
1155 // events.
1156 if (!processed && is_keyboard_shortcut)
1157 suppress_next_char_events_ = true;
initial.commit09911bf2008-07-26 23:55:291158
[email protected]3d5c243b2012-11-30 00:26:011159 InputEventAckState ack_result = processed ?
1160 INPUT_EVENT_ACK_STATE_CONSUMED : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1161 if (!processed && input_event->type == WebInputEvent::TouchStart) {
1162 const WebTouchEvent& touch_event =
1163 *static_cast<const WebTouchEvent*>(input_event);
[email protected]f8ed4722013-12-03 03:27:251164 // Hit-test for all the pressed touch points. If there is a touch-handler
1165 // for any of the touch points, then the renderer should continue to receive
1166 // touch events.
1167 ack_result = INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
1168 for (size_t i = 0; i < touch_event.touchesLength; ++i) {
1169 if (touch_event.touches[i].state == WebTouchPoint::StatePressed &&
[email protected]a66e18e2014-01-29 20:58:271170 HasTouchEventHandlersAt(
[email protected]9c769d412014-03-20 18:27:391171 gfx::ToFlooredPoint(touch_event.touches[i].position))) {
[email protected]f8ed4722013-12-03 03:27:251172 ack_result = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1173 break;
1174 }
1175 }
[email protected]3d5c243b2012-11-30 00:26:011176 }
1177
[email protected]fd847792013-10-24 17:12:351178 bool event_type_can_be_rate_limited =
[email protected]3391a0772012-03-28 00:32:071179 input_event->type == WebInputEvent::MouseMove ||
1180 input_event->type == WebInputEvent::MouseWheel ||
[email protected]3475bb52013-10-03 08:25:161181 input_event->type == WebInputEvent::TouchMove;
[email protected]8926c602013-01-23 05:32:061182
1183 bool frame_pending = paint_aggregator_.HasPendingUpdate();
1184 if (is_accelerated_compositing_active_) {
[email protected]ba91a792013-02-06 09:48:281185 frame_pending = compositor_ &&
[email protected]971728d2013-10-26 10:39:311186 compositor_->BeginMainFrameRequested();
[email protected]8926c602013-01-23 05:32:061187 }
1188
[email protected]fd847792013-10-24 17:12:351189 // If we don't have a fast and accurate HighResNow, we assume the input
1190 // handlers are heavy and rate limit them.
1191 bool rate_limiting_wanted = true;
1192 if (base::TimeTicks::IsHighResNowFastAndReliable()) {
1193 base::TimeTicks end_time = base::TimeTicks::HighResNow();
1194 total_input_handling_time_this_frame_ += (end_time - start_time);
1195 rate_limiting_wanted =
1196 total_input_handling_time_this_frame_.InMicroseconds() >
1197 kInputHandlingTimeThrottlingThresholdMicroseconds;
1198 }
1199
[email protected]34afe102013-12-13 17:24:551200 if (!WebInputEventTraits::IgnoresAckDisposition(input_event->type)) {
1201 scoped_ptr<IPC::Message> response(
1202 new InputHostMsg_HandleInputEvent_ACK(routing_id_,
1203 input_event->type,
1204 ack_result,
[email protected]205294b2014-03-18 20:48:351205 swap_latency_info));
[email protected]34afe102013-12-13 17:24:551206 if (rate_limiting_wanted && event_type_can_be_rate_limited &&
1207 frame_pending && !is_hidden_) {
1208 // We want to rate limit the input events in this case, so we'll wait for
1209 // painting to finish before ACKing this message.
1210 TRACE_EVENT_INSTANT0("renderer",
1211 "RenderWidget::OnHandleInputEvent ack throttled",
1212 TRACE_EVENT_SCOPE_THREAD);
1213 if (pending_input_event_ack_) {
1214 // As two different kinds of events could cause us to postpone an ack
1215 // we send it now, if we have one pending. The Browser should never
1216 // send us the same kind of event we are delaying the ack for.
1217 Send(pending_input_event_ack_.release());
1218 }
1219 pending_input_event_ack_ = response.Pass();
1220 if (compositor_)
1221 compositor_->NotifyInputThrottledUntilCommit();
1222 } else {
1223 Send(response.release());
[email protected]353a34c2010-05-28 23:35:171224 }
[email protected]12fbad812009-09-01 18:21:241225 }
1226
[email protected]3306f262012-09-21 19:20:421227#if defined(OS_ANDROID)
1228 // Allow the IME to be shown when the focus changes as a consequence
1229 // of a processed touch end event.
1230 if (input_event->type == WebInputEvent::TouchEnd && processed)
[email protected]90f24152014-04-09 12:41:361231 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
[email protected]183e28d2014-01-20 18:18:021232#elif defined(USE_AURA)
1233 // Show the virtual keyboard if enabled and a user gesture triggers a focus
1234 // change.
1235 if (processed && (input_event->type == WebInputEvent::TouchEnd ||
1236 input_event->type == WebInputEvent::MouseUp))
[email protected]90f24152014-04-09 12:41:361237 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_IME);
[email protected]3306f262012-09-21 19:20:421238#endif
1239
[email protected]b2e92592014-01-10 15:47:151240 TRACE_EVENT_SYNTHETIC_DELAY_END("blink.HandleInputEvent");
[email protected]5dd768212009-08-13 23:34:491241 handling_input_event_ = false;
[email protected]446705872009-09-10 07:22:481242
[email protected]67bfb83f2011-09-22 03:36:371243 if (!prevent_default) {
1244 if (WebInputEvent::isKeyboardEventType(input_event->type))
1245 DidHandleKeyEvent();
1246 if (WebInputEvent::isMouseEventType(input_event->type))
1247 DidHandleMouseEvent(*(static_cast<const WebMouseEvent*>(input_event)));
[email protected]2d0f2e92011-10-03 09:02:241248 if (WebInputEvent::isTouchEventType(input_event->type))
1249 DidHandleTouchEvent(*(static_cast<const WebTouchEvent*>(input_event)));
[email protected]67bfb83f2011-09-22 03:36:371250 }
initial.commit09911bf2008-07-26 23:55:291251}
1252
[email protected]34202de2013-05-06 23:36:221253void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
1254 if (webwidget_)
1255 webwidget_->setCursorVisibilityState(is_visible);
1256}
1257
initial.commit09911bf2008-07-26 23:55:291258void RenderWidget::OnMouseCaptureLost() {
1259 if (webwidget_)
[email protected]4873c7d2009-07-16 06:36:281260 webwidget_->mouseCaptureLost();
initial.commit09911bf2008-07-26 23:55:291261}
1262
1263void RenderWidget::OnSetFocus(bool enable) {
1264 has_focus_ = enable;
[email protected]9d166af2010-03-02 22:04:331265 if (webwidget_)
1266 webwidget_->setFocus(enable);
initial.commit09911bf2008-07-26 23:55:291267}
1268
1269void RenderWidget::ClearFocus() {
1270 // We may have got the focus from the browser before this gets processed, in
1271 // which case we do not want to unfocus ourself.
1272 if (!has_focus_ && webwidget_)
[email protected]4873c7d2009-07-16 06:36:281273 webwidget_->setFocus(false);
initial.commit09911bf2008-07-26 23:55:291274}
1275
[email protected]2d5d09d52009-06-15 14:29:211276void RenderWidget::PaintRect(const gfx::Rect& rect,
[email protected]4fb66842009-12-04 21:41:001277 const gfx::Point& canvas_origin,
[email protected]2d5d09d52009-06-15 14:29:211278 skia::PlatformCanvas* canvas) {
[email protected]50312bf2011-06-22 23:30:061279 TRACE_EVENT2("renderer", "PaintRect",
1280 "width", rect.width(), "height", rect.height());
[email protected]63ab54262012-11-09 15:58:451281
[email protected]4fb66842009-12-04 21:41:001282 canvas->save();
[email protected]2d5d09d52009-06-15 14:29:211283
1284 // Bring the canvas into the coordinate system of the paint rect.
[email protected]4fb66842009-12-04 21:41:001285 canvas->translate(static_cast<SkScalar>(-canvas_origin.x()),
1286 static_cast<SkScalar>(-canvas_origin.y()));
[email protected]96c3499a2009-05-02 18:31:031287
[email protected]699ab0d2009-04-23 23:19:141288 // If there is a custom background, tile it.
1289 if (!background_.empty()) {
[email protected]699ab0d2009-04-23 23:19:141290 SkPaint paint;
[email protected]4e29afd2012-12-04 04:07:111291 skia::RefPtr<SkShader> shader = skia::AdoptRef(
1292 SkShader::CreateBitmapShader(background_,
1293 SkShader::kRepeat_TileMode,
1294 SkShader::kRepeat_TileMode));
1295 paint.setShader(shader.get());
[email protected]fb10ec5b2011-10-24 17:54:201296
1297 // Use kSrc_Mode to handle background_ transparency properly.
1298 paint.setXfermodeMode(SkXfermode::kSrc_Mode);
1299
1300 // Canvas could contain multiple update rects. Clip to given rect so that
1301 // we don't accidentally clear other update rects.
1302 canvas->save();
[email protected]aa7e7a12013-02-22 13:37:441303 canvas->scale(device_scale_factor_, device_scale_factor_);
[email protected]1835b9e2012-02-28 13:12:481304 canvas->clipRect(gfx::RectToSkRect(rect));
[email protected]699ab0d2009-04-23 23:19:141305 canvas->drawPaint(paint);
[email protected]fb10ec5b2011-10-24 17:54:201306 canvas->restore();
[email protected]699ab0d2009-04-23 23:19:141307 }
1308
[email protected]9fcec0a2014-04-09 04:22:181309 // Normal painting case.
1310 base::TimeTicks start_time;
1311 if (!is_accelerated_compositing_active_)
1312 start_time = legacy_software_mode_stats_->StartRecording();
[email protected]63ab54262012-11-09 15:58:451313
[email protected]9fcec0a2014-04-09 04:22:181314 webwidget_->paint(canvas, rect);
[email protected]63ab54262012-11-09 15:58:451315
[email protected]9fcec0a2014-04-09 04:22:181316 if (!is_accelerated_compositing_active_) {
1317 base::TimeDelta paint_time =
1318 legacy_software_mode_stats_->EndRecording(start_time);
1319 int64 painted_pixel_count = rect.width() * rect.height();
1320 legacy_software_mode_stats_->AddPaint(paint_time, painted_pixel_count);
[email protected]719b36f2010-12-22 20:36:461321 }
initial.commit09911bf2008-07-26 23:55:291322
[email protected]9fcec0a2014-04-09 04:22:181323 // Flush to underlying bitmap. TODO(darin): is this needed?
1324 skia::GetTopDevice(*canvas)->accessBitmap(false);
1325
[email protected]4fb66842009-12-04 21:41:001326 PaintDebugBorder(rect, canvas);
[email protected]4fb66842009-12-04 21:41:001327 canvas->restore();
1328}
1329
1330void RenderWidget::PaintDebugBorder(const gfx::Rect& rect,
1331 skia::PlatformCanvas* canvas) {
1332 static bool kPaintBorder =
1333 CommandLine::ForCurrentProcess()->HasSwitch(switches::kShowPaintRects);
1334 if (!kPaintBorder)
1335 return;
1336
[email protected]53d3f302009-12-21 04:42:051337 // Cycle through these colors to help distinguish new paint rects.
1338 const SkColor colors[] = {
1339 SkColorSetARGB(0x3F, 0xFF, 0, 0),
1340 SkColorSetARGB(0x3F, 0xFF, 0, 0xFF),
1341 SkColorSetARGB(0x3F, 0, 0, 0xFF),
1342 };
1343 static int color_selector = 0;
1344
[email protected]4fb66842009-12-04 21:41:001345 SkPaint paint;
1346 paint.setStyle(SkPaint::kStroke_Style);
[email protected]53d3f302009-12-21 04:42:051347 paint.setColor(colors[color_selector++ % arraysize(colors)]);
[email protected]4fb66842009-12-04 21:41:001348 paint.setStrokeWidth(1);
1349
1350 SkIRect irect;
1351 irect.set(rect.x(), rect.y(), rect.right() - 1, rect.bottom() - 1);
1352 canvas->drawIRect(irect, paint);
initial.commit09911bf2008-07-26 23:55:291353}
1354
[email protected]52ccd0ea2011-02-16 01:09:051355void RenderWidget::AnimationCallback() {
[email protected]921244e42011-07-20 16:36:301356 TRACE_EVENT0("renderer", "RenderWidget::AnimationCallback");
[email protected]921244e42011-07-20 16:36:301357 if (!animation_update_pending_) {
1358 TRACE_EVENT0("renderer", "EarlyOut_NoAnimationUpdatePending");
[email protected]7c4329e2011-02-18 22:02:591359 return;
[email protected]921244e42011-07-20 16:36:301360 }
[email protected]bd37ae252011-06-03 01:28:181361 if (!animation_floor_time_.is_null() && IsRenderingVSynced()) {
[email protected]7c4329e2011-02-18 22:02:591362 // Record when we fired (according to base::Time::Now()) relative to when
1363 // we posted the task to quantify how much the base::Time/base::TimeTicks
1364 // skew is affecting animations.
1365 base::TimeDelta animation_callback_delay = base::Time::Now() -
1366 (animation_floor_time_ - base::TimeDelta::FromMilliseconds(16));
1367 UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.AnimationCallbackDelayTime",
1368 animation_callback_delay,
1369 base::TimeDelta::FromMilliseconds(0),
1370 base::TimeDelta::FromMilliseconds(30),
1371 25);
1372 }
[email protected]65225772011-05-12 21:10:241373 DoDeferredUpdateAndSendInputAck();
[email protected]12fbad812009-09-01 18:21:241374}
1375
[email protected]52ccd0ea2011-02-16 01:09:051376void RenderWidget::AnimateIfNeeded() {
[email protected]7c4329e2011-02-18 22:02:591377 if (!animation_update_pending_)
1378 return;
[email protected]bd37ae252011-06-03 01:28:181379
1380 // Target 60FPS if vsync is on. Go as fast as we can if vsync is off.
[email protected]02798a982012-01-27 00:45:331381 base::TimeDelta animationInterval = IsRenderingVSynced() ?
1382 base::TimeDelta::FromMilliseconds(16) : base::TimeDelta();
[email protected]bd37ae252011-06-03 01:28:181383
[email protected]7c4329e2011-02-18 22:02:591384 base::Time now = base::Time::Now();
[email protected]51e403bb2012-03-02 21:09:451385
1386 // animation_floor_time_ is the earliest time that we should animate when
1387 // using the dead reckoning software scheduler. If we're using swapbuffers
1388 // complete callbacks to rate limit, we can ignore this floor.
1389 if (now >= animation_floor_time_ || num_swapbuffers_complete_pending_ > 0) {
[email protected]921244e42011-07-20 16:36:301390 TRACE_EVENT0("renderer", "RenderWidget::AnimateIfNeeded")
[email protected]02798a982012-01-27 00:45:331391 animation_floor_time_ = now + animationInterval;
[email protected]bd37ae252011-06-03 01:28:181392 // Set a timer to call us back after animationInterval before
[email protected]7c4329e2011-02-18 22:02:591393 // running animation callbacks so that if a callback requests another
1394 // we'll be sure to run it at the proper time.
[email protected]350ce8702012-03-09 04:23:381395 animation_timer_.Stop();
1396 animation_timer_.Start(FROM_HERE, animationInterval, this,
1397 &RenderWidget::AnimationCallback);
[email protected]7c4329e2011-02-18 22:02:591398 animation_update_pending_ = false;
[email protected]ba91a792013-02-06 09:48:281399 if (is_accelerated_compositing_active_ && compositor_) {
[email protected]e197af302014-02-07 09:36:491400 compositor_->UpdateAnimations(base::TimeTicks::Now());
[email protected]8926c602013-01-23 05:32:061401 } else {
[email protected]635353c2013-03-06 09:11:201402 double frame_begin_time =
1403 (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
1404 webwidget_->animate(frame_begin_time);
[email protected]8926c602013-01-23 05:32:061405 }
[email protected]7c4329e2011-02-18 22:02:591406 return;
[email protected]5f8b1022011-01-21 23:34:501407 }
[email protected]bd37ae252011-06-03 01:28:181408 TRACE_EVENT0("renderer", "EarlyOut_AnimatedTooRecently");
[email protected]350ce8702012-03-09 04:23:381409 if (!animation_timer_.IsRunning()) {
1410 // This code uses base::Time::Now() to calculate the floor and next fire
1411 // time because javascript's Date object uses base::Time::Now(). The
1412 // message loop uses base::TimeTicks, which on windows can have a
1413 // different granularity than base::Time.
1414 // The upshot of all this is that this function might be called before
1415 // base::Time::Now() has advanced past the animation_floor_time_. To
1416 // avoid exposing this delay to javascript, we keep posting delayed
1417 // tasks until base::Time::Now() has advanced far enough.
1418 base::TimeDelta delay = animation_floor_time_ - now;
1419 animation_timer_.Start(FROM_HERE, delay, this,
1420 &RenderWidget::AnimationCallback);
1421 }
[email protected]5f8b1022011-01-21 23:34:501422}
1423
[email protected]bd37ae252011-06-03 01:28:181424bool RenderWidget::IsRenderingVSynced() {
1425 // TODO(nduca): Forcing a driver to disable vsync (e.g. in a control panel) is
1426 // not caught by this check. This will lead to artificially low frame rates
1427 // for people who force vsync off at a driver level and expect Chrome to speed
1428 // up.
1429 return !has_disable_gpu_vsync_switch_;
1430}
1431
[email protected]65225772011-05-12 21:10:241432void RenderWidget::InvalidationCallback() {
[email protected]50312bf2011-06-22 23:30:061433 TRACE_EVENT0("renderer", "RenderWidget::InvalidationCallback");
[email protected]65225772011-05-12 21:10:241434 invalidation_task_posted_ = false;
1435 DoDeferredUpdateAndSendInputAck();
1436}
1437
[email protected]fd847792013-10-24 17:12:351438void RenderWidget::FlushPendingInputEventAck() {
[email protected]d8a8ecb2013-10-23 18:03:071439 if (pending_input_event_ack_)
1440 Send(pending_input_event_ack_.release());
[email protected]fd847792013-10-24 17:12:351441 total_input_handling_time_this_frame_ = base::TimeDelta();
1442}
1443
1444void RenderWidget::DoDeferredUpdateAndSendInputAck() {
1445 DoDeferredUpdate();
1446 FlushPendingInputEventAck();
[email protected]ee3d3ad2011-02-04 00:42:211447}
1448
[email protected]552e6002009-11-19 05:24:571449void RenderWidget::DoDeferredUpdate() {
[email protected]366ae242011-05-10 02:23:581450 TRACE_EVENT0("renderer", "RenderWidget::DoDeferredUpdate");
[email protected]fc8bde1a2013-07-04 08:54:071451 TRACE_EVENT_SCOPED_SAMPLING_STATE("Chrome", "Paint");
[email protected]71e2f0a2011-03-15 22:25:081452
[email protected]65225772011-05-12 21:10:241453 if (!webwidget_)
initial.commit09911bf2008-07-26 23:55:291454 return;
[email protected]05a980d7a2012-02-07 22:16:421455
[email protected]fc4404d2012-11-07 19:53:301456 if (!init_complete_) {
1457 TRACE_EVENT0("renderer", "EarlyOut_InitNotComplete");
[email protected]05a980d7a2012-02-07 22:16:421458 return;
1459 }
[email protected]aa4117f2011-12-09 22:19:211460 if (update_reply_pending_) {
[email protected]65225772011-05-12 21:10:241461 TRACE_EVENT0("renderer", "EarlyOut_UpdateReplyPending");
1462 return;
1463 }
[email protected]9ca84622011-06-02 23:46:391464 if (is_accelerated_compositing_active_ &&
1465 num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending) {
[email protected]65225772011-05-12 21:10:241466 TRACE_EVENT0("renderer", "EarlyOut_MaxSwapBuffersPending");
1467 return;
1468 }
initial.commit09911bf2008-07-26 23:55:291469
[email protected]552e6002009-11-19 05:24:571470 // Suppress updating when we are hidden.
[email protected]e3d92a7f2013-01-10 02:35:051471 if (is_hidden_ || size_.IsEmpty() || is_swapped_out_) {
[email protected]552e6002009-11-19 05:24:571472 paint_aggregator_.ClearPendingUpdate();
initial.commit09911bf2008-07-26 23:55:291473 needs_repainting_on_restore_ = true;
[email protected]65225772011-05-12 21:10:241474 TRACE_EVENT0("renderer", "EarlyOut_NotVisible");
initial.commit09911bf2008-07-26 23:55:291475 return;
1476 }
1477
[email protected]0fb93f52011-05-18 23:13:561478 // Tracking of frame rate jitter
[email protected]de2cf8c2013-10-25 19:46:461479 base::TimeTicks frame_begin_ticks = gfx::FrameTime::Now();
[email protected]33004772013-11-12 09:49:231480 InstrumentWillBeginFrame(0);
[email protected]52ccd0ea2011-02-16 01:09:051481 AnimateIfNeeded();
[email protected]5f8b1022011-01-21 23:34:501482
[email protected]f98d7e3c2010-09-13 22:30:461483 // Layout may generate more invalidation. It may also enable the
1484 // GPU acceleration, so make sure to run layout before we send the
1485 // GpuRenderingActivated message.
1486 webwidget_->layout();
1487
[email protected]793b2d62013-06-11 00:43:251488 // Check for whether we need to track swap buffers. We need to do that after
1489 // layout() because it may have switched us to accelerated compositing.
1490 if (is_accelerated_compositing_active_)
1491 using_asynchronous_swapbuffers_ = SupportsAsynchronousSwapBuffers();
1492
[email protected]dcca3aa92012-02-17 23:03:371493 // The following two can result in further layout and possibly
1494 // enable GPU acceleration so they need to be called before any painting
1495 // is done.
[email protected]cb9e2632013-06-18 11:26:471496 UpdateTextInputType();
[email protected]a80aea72014-03-14 21:10:151497#if defined(OS_ANDROID)
1498 UpdateSelectionRootBounds();
1499#endif
[email protected]dcca3aa92012-02-17 23:03:371500 UpdateSelectionBounds();
1501
[email protected]5f8b1022011-01-21 23:34:501502 // Suppress painting if nothing is dirty. This has to be done after updating
1503 // animations running layout as these may generate further invalidations.
[email protected]65225772011-05-12 21:10:241504 if (!paint_aggregator_.HasPendingUpdate()) {
1505 TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
[email protected]38ce4e7b2013-02-23 06:17:371506 InstrumentDidCancelFrame();
[email protected]5f8b1022011-01-21 23:34:501507 return;
[email protected]65225772011-05-12 21:10:241508 }
[email protected]5f8b1022011-01-21 23:34:501509
[email protected]479b0172012-10-29 19:27:091510 if (!is_accelerated_compositing_active_ &&
[email protected]cb6430932012-10-31 00:53:361511 !is_threaded_compositing_enabled_ &&
[email protected]d8a6c5d12013-09-23 04:37:101512 (ForceCompositingModeEnabled() ||
1513 was_accelerated_compositing_ever_active_)) {
[email protected]479b0172012-10-29 19:27:091514 webwidget_->enterForceCompositingMode(true);
1515 }
1516
[email protected]872ae5b2011-05-26 20:20:501517 if (!last_do_deferred_update_time_.is_null()) {
[email protected]0fb93f52011-05-18 23:13:561518 base::TimeDelta delay = frame_begin_ticks - last_do_deferred_update_time_;
[email protected]d0be63772011-12-20 23:18:041519 if (is_accelerated_compositing_active_) {
[email protected]0fb93f52011-05-18 23:13:561520 UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.AccelDoDeferredUpdateDelay",
1521 delay,
1522 base::TimeDelta::FromMilliseconds(1),
[email protected]b604cf82012-07-19 05:31:411523 base::TimeDelta::FromMilliseconds(120),
1524 60);
[email protected]d0be63772011-12-20 23:18:041525 } else {
[email protected]0fb93f52011-05-18 23:13:561526 UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.SoftwareDoDeferredUpdateDelay",
1527 delay,
1528 base::TimeDelta::FromMilliseconds(1),
[email protected]b604cf82012-07-19 05:31:411529 base::TimeDelta::FromMilliseconds(120),
1530 60);
[email protected]d0be63772011-12-20 23:18:041531 }
[email protected]872ae5b2011-05-26 20:20:501532
1533 // Calculate filtered time per frame:
1534 float frame_time_elapsed = static_cast<float>(delay.InSecondsF());
1535 filtered_time_per_frame_ =
1536 0.9f * filtered_time_per_frame_ + 0.1f * frame_time_elapsed;
[email protected]0fb93f52011-05-18 23:13:561537 }
1538 last_do_deferred_update_time_ = frame_begin_ticks;
1539
[email protected]fef5e3972012-08-07 03:59:471540 if (!is_accelerated_compositing_active_) {
[email protected]922c6e1f2013-10-09 04:04:091541 legacy_software_mode_stats_->IncrementFrameCount(1, true);
[email protected]adbe30f2013-10-11 21:12:331542 cc::BenchmarkInstrumentation::IssueMainThreadRenderingStatsEvent(
1543 legacy_software_mode_stats_->main_thread_rendering_stats());
[email protected]c1e6cc062013-08-24 03:35:351544 legacy_software_mode_stats_->AccumulateAndClearMainThreadStats();
[email protected]fef5e3972012-08-07 03:59:471545 }
1546
[email protected]552e6002009-11-19 05:24:571547 // OK, save the pending update to a local since painting may cause more
initial.commit09911bf2008-07-26 23:55:291548 // invalidation. Some WebCore rendering objects only layout when painted.
[email protected]dd015812010-12-06 23:39:301549 PaintAggregator::PendingUpdate update;
1550 paint_aggregator_.PopPendingUpdate(&update);
initial.commit09911bf2008-07-26 23:55:291551
[email protected]53d3f302009-12-21 04:42:051552 gfx::Rect scroll_damage = update.GetScrollDamage();
[email protected]ce112fe2012-10-29 22:52:181553 gfx::Rect bounds = gfx::UnionRects(update.GetPaintBounds(), scroll_damage);
initial.commit09911bf2008-07-26 23:55:291554
[email protected]aa4117f2011-12-09 22:19:211555 DCHECK(!pending_update_params_.get());
1556 pending_update_params_.reset(new ViewHostMsg_UpdateRect_Params);
[email protected]990278ff2012-11-13 02:12:551557 pending_update_params_->scroll_delta = update.scroll_delta;
[email protected]aa4117f2011-12-09 22:19:211558 pending_update_params_->scroll_rect = update.scroll_rect;
1559 pending_update_params_->view_size = size_;
[email protected]aa4117f2011-12-09 22:19:211560 pending_update_params_->plugin_window_moves.swap(plugin_window_moves_);
1561 pending_update_params_->flags = next_paint_flags_;
1562 pending_update_params_->scroll_offset = GetScrollOffset();
1563 pending_update_params_->needs_ack = true;
[email protected]7ded9f12012-06-13 20:47:091564 pending_update_params_->scale_factor = device_scale_factor_;
[email protected]aa4117f2011-12-09 22:19:211565 next_paint_flags_ = 0;
[email protected]ea3ee0a2012-05-15 03:43:091566 need_update_rect_for_auto_resize_ = false;
[email protected]aa4117f2011-12-09 22:19:211567
[email protected]256737c2013-06-08 04:39:101568 if (!is_accelerated_compositing_active_)
[email protected]98a04472013-12-23 20:42:501569 pending_update_params_->latency_info.swap(latency_info_);
[email protected]256737c2013-06-08 04:39:101570
[email protected]98a04472013-12-23 20:42:501571 latency_info_.clear();
[email protected]256737c2013-06-08 04:39:101572
[email protected]9fcec0a2014-04-09 04:22:181573 if (!is_accelerated_compositing_active_) {
[email protected]f98d7e3c2010-09-13 22:30:461574 // Compute a buffer for painting and cache it.
[email protected]4889bd212013-02-11 22:23:101575
1576 bool fractional_scale = device_scale_factor_ -
1577 static_cast<int>(device_scale_factor_) != 0;
1578 if (fractional_scale) {
1579 // Damage might not be DIP aligned. Inflate damage to compensate.
1580 bounds.Inset(-1, -1);
1581 bounds.Intersect(gfx::Rect(size_));
1582 }
1583
1584 gfx::Rect pixel_bounds = gfx::ToEnclosingRect(
[email protected]ce112fe2012-10-29 22:52:181585 gfx::ScaleRect(bounds, device_scale_factor_));
[email protected]4889bd212013-02-11 22:23:101586
[email protected]ca4847f2010-09-24 05:39:151587 scoped_ptr<skia::PlatformCanvas> canvas(
[email protected]b4d08452010-10-05 17:34:351588 RenderProcess::current()->GetDrawingCanvas(&current_paint_buf_,
[email protected]f1cccb32012-06-06 18:29:591589 pixel_bounds));
[email protected]59383c782013-04-17 16:43:271590 if (!canvas) {
[email protected]f98d7e3c2010-09-13 22:30:461591 NOTREACHED();
1592 return;
1593 }
[email protected]cef3362f2009-12-21 17:48:451594
[email protected]f98d7e3c2010-09-13 22:30:461595 // We may get back a smaller canvas than we asked for.
1596 // TODO(darin): This seems like it could cause painting problems!
[email protected]f1cccb32012-06-06 18:29:591597 DCHECK_EQ(pixel_bounds.width(), canvas->getDevice()->width());
1598 DCHECK_EQ(pixel_bounds.height(), canvas->getDevice()->height());
1599 pixel_bounds.set_width(canvas->getDevice()->width());
1600 pixel_bounds.set_height(canvas->getDevice()->height());
1601 bounds.set_width(pixel_bounds.width() / device_scale_factor_);
1602 bounds.set_height(pixel_bounds.height() / device_scale_factor_);
[email protected]53d3f302009-12-21 04:42:051603
[email protected]f98d7e3c2010-09-13 22:30:461604 HISTOGRAM_COUNTS_100("MPArch.RW_PaintRectCount", update.paint_rects.size());
1605
[email protected]aa4117f2011-12-09 22:19:211606 pending_update_params_->bitmap = current_paint_buf_->id();
1607 pending_update_params_->bitmap_rect = bounds;
1608
1609 std::vector<gfx::Rect>& copy_rects = pending_update_params_->copy_rects;
[email protected]f98d7e3c2010-09-13 22:30:461610 // The scroll damage is just another rectangle to paint and copy.
1611 copy_rects.swap(update.paint_rects);
1612 if (!scroll_damage.IsEmpty())
1613 copy_rects.push_back(scroll_damage);
1614
[email protected]4889bd212013-02-11 22:23:101615 for (size_t i = 0; i < copy_rects.size(); ++i) {
1616 gfx::Rect rect = copy_rects[i];
1617 if (fractional_scale) {
1618 // Damage might not be DPI aligned. Inflate rect to compensate.
1619 rect.Inset(-1, -1);
1620 }
1621 PaintRect(rect, pixel_bounds.origin(), canvas.get());
1622 }
[email protected]60a50072012-01-11 02:05:351623
1624 // Software FPS tick for performance tests. The accelerated path traces the
[email protected]bea16ce2014-01-11 23:01:291625 // frame events in didCommitAndDrawCompositorFrame. See
1626 // tab_capture_performancetest.cc.
[email protected]60a50072012-01-11 02:05:351627 // NOTE: Tests may break if this event is renamed or moved.
[email protected]c76faea2013-03-26 07:42:421628 UNSHIPPED_TRACE_EVENT_INSTANT0("test_fps", "TestFrameTickSW",
1629 TRACE_EVENT_SCOPE_THREAD);
[email protected]f98d7e3c2010-09-13 22:30:461630 } else { // Accelerated compositing path
1631 // Begin painting.
[email protected]aa4117f2011-12-09 22:19:211632 // If painting is done via the gpu process then we don't set any damage
1633 // rects to save the browser process from doing unecessary work.
1634 pending_update_params_->bitmap_rect = bounds;
1635 pending_update_params_->scroll_rect = gfx::Rect();
1636 // We don't need an ack, because we're not sharing a DIB with the browser.
1637 // If it needs to (e.g. composited UI), the GPU process does its own ACK
1638 // with the browser for the GPU surface.
1639 pending_update_params_->needs_ack = false;
[email protected]f0c2a242013-03-15 19:34:521640 Composite(frame_begin_ticks);
[email protected]f98d7e3c2010-09-13 22:30:461641 }
1642
[email protected]936c6f52011-12-13 01:35:261643 // If we're holding a pending input event ACK, send the ACK before sending the
1644 // UpdateReply message so we can receive another input event before the
1645 // UpdateRect_ACK on platforms where the UpdateRect_ACK is sent from within
1646 // the UpdateRect IPC message handler.
[email protected]fd847792013-10-24 17:12:351647 FlushPendingInputEventAck();
[email protected]936c6f52011-12-13 01:35:261648
[email protected]ab543072013-01-25 04:38:151649 // If Composite() called SwapBuffers, pending_update_params_ will be reset (in
[email protected]aa4117f2011-12-09 22:19:211650 // OnSwapBuffersPosted), meaning a message has been added to the
1651 // updates_pending_swap_ queue, that will be sent later. Otherwise, we send
1652 // the message now.
[email protected]59383c782013-04-17 16:43:271653 if (pending_update_params_) {
[email protected]aa4117f2011-12-09 22:19:211654 // sending an ack to browser process that the paint is complete...
1655 update_reply_pending_ = pending_update_params_->needs_ack;
1656 Send(new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_));
1657 pending_update_params_.reset();
[email protected]b167ca662010-05-14 00:05:341658 }
[email protected]53d3f302009-12-21 04:42:051659
[email protected]29ed96a2012-02-04 18:12:161660 // If we're software rendering then we're done initiating the paint.
1661 if (!is_accelerated_compositing_active_)
1662 DidInitiatePaint();
initial.commit09911bf2008-07-26 23:55:291663}
1664
[email protected]f0c2a242013-03-15 19:34:521665void RenderWidget::Composite(base::TimeTicks frame_begin_time) {
[email protected]ab543072013-01-25 04:38:151666 DCHECK(is_accelerated_compositing_active_);
[email protected]ba91a792013-02-06 09:48:281667 if (compositor_) // TODO(jamesr): Figure out how this can be null.
[email protected]f0c2a242013-03-15 19:34:521668 compositor_->Composite(frame_begin_time);
[email protected]ab543072013-01-25 04:38:151669}
1670
initial.commit09911bf2008-07-26 23:55:291671///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461672// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291673
[email protected]4873c7d2009-07-16 06:36:281674void RenderWidget::didInvalidateRect(const WebRect& rect) {
[email protected]552e6002009-11-19 05:24:571675 // The invalidated rect might be outside the bounds of the view.
[email protected]ee8d6fd2010-05-26 17:05:481676 gfx::Rect view_rect(size_);
[email protected]ce112fe2012-10-29 22:52:181677 gfx::Rect damaged_rect = gfx::IntersectRects(view_rect, rect);
[email protected]552e6002009-11-19 05:24:571678 if (damaged_rect.IsEmpty())
initial.commit09911bf2008-07-26 23:55:291679 return;
1680
[email protected]552e6002009-11-19 05:24:571681 paint_aggregator_.InvalidateRect(damaged_rect);
1682
1683 // We may not need to schedule another call to DoDeferredUpdate.
[email protected]65225772011-05-12 21:10:241684 if (invalidation_task_posted_)
[email protected]552e6002009-11-19 05:24:571685 return;
1686 if (!paint_aggregator_.HasPendingUpdate())
1687 return;
[email protected]aa4117f2011-12-09 22:19:211688 if (update_reply_pending_ ||
[email protected]65225772011-05-12 21:10:241689 num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending)
1690 return;
1691
1692 // When GPU rendering, combine pending animations and invalidations into
1693 // a single update.
[email protected]816edc62012-03-17 01:27:221694 if (is_accelerated_compositing_active_ &&
1695 animation_update_pending_ &&
1696 animation_timer_.IsRunning())
[email protected]552e6002009-11-19 05:24:571697 return;
1698
1699 // Perform updating asynchronously. This serves two purposes:
initial.commit09911bf2008-07-26 23:55:291700 // 1) Ensures that we call WebView::Paint without a bunch of other junk
1701 // on the call stack.
1702 // 2) Allows us to collect more damage rects before painting to help coalesce
1703 // the work that we will need to do.
[email protected]65225772011-05-12 21:10:241704 invalidation_task_posted_ = true;
[email protected]dd32b1272013-05-04 14:17:111705 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:211706 FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
initial.commit09911bf2008-07-26 23:55:291707}
1708
[email protected]990278ff2012-11-13 02:12:551709void RenderWidget::didScrollRect(int dx, int dy,
1710 const WebRect& clip_rect) {
[email protected]f98d7e3c2010-09-13 22:30:461711 // Drop scrolls on the floor when we are in compositing mode.
1712 // TODO(nduca): stop WebViewImpl from sending scrolls in the first place.
[email protected]a79d8a632010-11-18 22:35:561713 if (is_accelerated_compositing_active_)
[email protected]f98d7e3c2010-09-13 22:30:461714 return;
1715
[email protected]552e6002009-11-19 05:24:571716 // The scrolled rect might be outside the bounds of the view.
[email protected]ee8d6fd2010-05-26 17:05:481717 gfx::Rect view_rect(size_);
[email protected]ce112fe2012-10-29 22:52:181718 gfx::Rect damaged_rect = gfx::IntersectRects(view_rect, clip_rect);
[email protected]552e6002009-11-19 05:24:571719 if (damaged_rect.IsEmpty())
initial.commit09911bf2008-07-26 23:55:291720 return;
1721
[email protected]990278ff2012-11-13 02:12:551722 paint_aggregator_.ScrollRect(gfx::Vector2d(dx, dy), damaged_rect);
[email protected]552e6002009-11-19 05:24:571723
1724 // We may not need to schedule another call to DoDeferredUpdate.
[email protected]65225772011-05-12 21:10:241725 if (invalidation_task_posted_)
[email protected]552e6002009-11-19 05:24:571726 return;
1727 if (!paint_aggregator_.HasPendingUpdate())
1728 return;
[email protected]aa4117f2011-12-09 22:19:211729 if (update_reply_pending_ ||
[email protected]65225772011-05-12 21:10:241730 num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending)
1731 return;
1732
1733 // When GPU rendering, combine pending animations and invalidations into
1734 // a single update.
[email protected]816edc62012-03-17 01:27:221735 if (is_accelerated_compositing_active_ &&
1736 animation_update_pending_ &&
1737 animation_timer_.IsRunning())
[email protected]552e6002009-11-19 05:24:571738 return;
1739
1740 // Perform updating asynchronously. This serves two purposes:
1741 // 1) Ensures that we call WebView::Paint without a bunch of other junk
1742 // on the call stack.
1743 // 2) Allows us to collect more damage rects before painting to help coalesce
1744 // the work that we will need to do.
[email protected]65225772011-05-12 21:10:241745 invalidation_task_posted_ = true;
[email protected]dd32b1272013-05-04 14:17:111746 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:211747 FROM_HERE, base::Bind(&RenderWidget::InvalidationCallback, this));
initial.commit09911bf2008-07-26 23:55:291748}
1749
[email protected]244ac1892011-12-02 17:04:471750void RenderWidget::didAutoResize(const WebSize& new_size) {
[email protected]ea3ee0a2012-05-15 03:43:091751 if (size_.width() != new_size.width || size_.height() != new_size.height) {
[email protected]eac2b362013-05-22 07:01:451752 size_ = new_size;
[email protected]20fbfc22013-05-08 20:50:581753
[email protected]eac2b362013-05-22 07:01:451754 // If we don't clear PaintAggregator after changing autoResize state, then
1755 // we might end up in a situation where bitmap_rect is larger than the
1756 // view_size. By clearing PaintAggregator, we ensure that we don't end up
1757 // with invalid damage rects.
1758 paint_aggregator_.ClearPendingUpdate();
1759
[email protected]5b45ad42013-10-25 00:42:041760 if (resizing_mode_selector_->is_synchronous_mode()) {
[email protected]eac2b362013-05-22 07:01:451761 WebRect new_pos(rootWindowRect().x,
1762 rootWindowRect().y,
1763 new_size.width,
1764 new_size.height);
1765 view_screen_rect_ = new_pos;
1766 window_screen_rect_ = new_pos;
[email protected]8be1c582013-03-06 00:55:031767 }
[email protected]20fbfc22013-05-08 20:50:581768
[email protected]eac2b362013-05-22 07:01:451769 AutoResizeCompositor();
[email protected]20fbfc22013-05-08 20:50:581770
[email protected]5b45ad42013-10-25 00:42:041771 if (!resizing_mode_selector_->is_synchronous_mode())
[email protected]20fbfc22013-05-08 20:50:581772 need_update_rect_for_auto_resize_ = true;
[email protected]ea3ee0a2012-05-15 03:43:091773 }
[email protected]244ac1892011-12-02 17:04:471774}
1775
[email protected]3a1c8a8032013-03-18 22:35:321776void RenderWidget::AutoResizeCompositor() {
[email protected]97e1bf72013-03-06 14:06:051777 physical_backing_size_ = gfx::ToCeiledSize(gfx::ScaleSize(size_,
1778 device_scale_factor_));
1779 if (compositor_)
1780 compositor_->setViewportSize(size_, physical_backing_size_);
1781}
1782
[email protected]c0b0bd12014-03-13 00:39:581783// FIXME: To be removed as soon as chromium and blink side changes land
1784// didActivateCompositor with parameters is still kept in order to land
1785// these changes s-chromium - https://codereview.chromium.org/137893025/.
1786// s-blink - https://codereview.chromium.org/138523003/
[email protected]91acd1c2012-03-14 08:32:391787void RenderWidget::didActivateCompositor(int input_handler_identifier) {
[email protected]ea162f92011-10-04 23:08:221788 TRACE_EVENT0("gpu", "RenderWidget::didActivateCompositor");
1789
[email protected]c63b4d42012-04-26 01:01:071790#if !defined(OS_MACOSX)
[email protected]aa4117f2011-12-09 22:19:211791 if (!is_accelerated_compositing_active_) {
1792 // When not in accelerated compositing mode, in certain cases (e.g. waiting
1793 // for a resize or if no backing store) the RenderWidgetHost is blocking the
1794 // browser's UI thread for some time, waiting for an UpdateRect. If we are
1795 // going to switch to accelerated compositing, the GPU process may need
1796 // round-trips to the browser's UI thread before finishing the frame,
1797 // causing deadlocks if we delay the UpdateRect until we receive the
1798 // OnSwapBuffersComplete. So send a dummy message that will unblock the
[email protected]c63b4d42012-04-26 01:01:071799 // browser's UI thread. This is not necessary on Mac, because SwapBuffers
1800 // now unblocks GetBackingStore on Mac.
[email protected]aa4117f2011-12-09 22:19:211801 Send(new ViewHostMsg_UpdateIsDelayed(routing_id_));
1802 }
[email protected]c63b4d42012-04-26 01:01:071803#endif
[email protected]aa4117f2011-12-09 22:19:211804
[email protected]ea162f92011-10-04 23:08:221805 is_accelerated_compositing_active_ = true;
[email protected]50bd6452010-11-27 19:39:421806 Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
[email protected]65225772011-05-12 21:10:241807 routing_id_, is_accelerated_compositing_active_));
[email protected]d8a6c5d12013-09-23 04:37:101808
1809 if (!was_accelerated_compositing_ever_active_) {
1810 was_accelerated_compositing_ever_active_ = true;
1811 webwidget_->enterForceCompositingMode(true);
1812 }
[email protected]ea162f92011-10-04 23:08:221813}
1814
[email protected]c0b0bd12014-03-13 00:39:581815void RenderWidget::didActivateCompositor() {
1816 TRACE_EVENT0("gpu", "RenderWidget::didActivateCompositor");
1817
1818#if !defined(OS_MACOSX)
1819 if (!is_accelerated_compositing_active_) {
1820 // When not in accelerated compositing mode, in certain cases (e.g. waiting
1821 // for a resize or if no backing store) the RenderWidgetHost is blocking the
1822 // browser's UI thread for some time, waiting for an UpdateRect. If we are
1823 // going to switch to accelerated compositing, the GPU process may need
1824 // round-trips to the browser's UI thread before finishing the frame,
1825 // causing deadlocks if we delay the UpdateRect until we receive the
1826 // OnSwapBuffersComplete. So send a dummy message that will unblock the
1827 // browser's UI thread. This is not necessary on Mac, because SwapBuffers
1828 // now unblocks GetBackingStore on Mac.
1829 Send(new ViewHostMsg_UpdateIsDelayed(routing_id_));
1830 }
1831#endif
1832
1833 is_accelerated_compositing_active_ = true;
1834 Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
1835 routing_id_, is_accelerated_compositing_active_));
1836
1837 if (!was_accelerated_compositing_ever_active_) {
1838 was_accelerated_compositing_ever_active_ = true;
1839 webwidget_->enterForceCompositingMode(true);
1840 }
1841}
1842
[email protected]ea162f92011-10-04 23:08:221843void RenderWidget::didDeactivateCompositor() {
1844 TRACE_EVENT0("gpu", "RenderWidget::didDeactivateCompositor");
1845
1846 is_accelerated_compositing_active_ = false;
1847 Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
1848 routing_id_, is_accelerated_compositing_active_));
1849
[email protected]ea162f92011-10-04 23:08:221850 if (using_asynchronous_swapbuffers_)
[email protected]65225772011-05-12 21:10:241851 using_asynchronous_swapbuffers_ = false;
[email protected]479b0172012-10-29 19:27:091852
1853 // In single-threaded mode, we exit force compositing mode and re-enter in
1854 // DoDeferredUpdate() if appropriate. In threaded compositing mode,
1855 // DoDeferredUpdate() is bypassed and WebKit is responsible for exiting and
1856 // entering force compositing mode at the appropriate times.
[email protected]cb6430932012-10-31 00:53:361857 if (!is_threaded_compositing_enabled_)
[email protected]479b0172012-10-29 19:27:091858 webwidget_->enterForceCompositingMode(false);
[email protected]a79d8a632010-11-18 22:35:561859}
1860
[email protected]e195e582013-03-08 01:32:591861void RenderWidget::initializeLayerTreeView() {
[email protected]c5fa4c42013-07-20 05:47:371862 compositor_ = RenderWidgetCompositor::Create(
1863 this, is_threaded_compositing_enabled_);
[email protected]e195e582013-03-08 01:32:591864 if (!compositor_)
1865 return;
1866
1867 compositor_->setViewportSize(size_, physical_backing_size_);
1868 if (init_complete_)
1869 compositor_->setSurfaceReady();
1870}
1871
[email protected]180ef242013-11-07 06:50:461872blink::WebLayerTreeView* RenderWidget::layerTreeView() {
[email protected]ba91a792013-02-06 09:48:281873 return compositor_.get();
[email protected]8926c602013-01-23 05:32:061874}
1875
[email protected]9ed83fe2013-02-27 01:52:281876void RenderWidget::suppressCompositorScheduling(bool enable) {
1877 if (compositor_)
1878 compositor_->SetSuppressScheduleComposite(enable);
1879}
1880
[email protected]9cd43a62012-03-26 08:03:561881void RenderWidget::willBeginCompositorFrame() {
1882 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
[email protected]abe8b3a2012-03-28 21:19:371883
[email protected]cadac622013-06-11 16:46:361884 DCHECK(RenderThreadImpl::current()->compositor_message_loop_proxy().get());
[email protected]abe8b3a2012-03-28 21:19:371885
1886 // The following two can result in further layout and possibly
1887 // enable GPU acceleration so they need to be called before any painting
1888 // is done.
[email protected]cb9e2632013-06-18 11:26:471889 UpdateTextInputType();
1890#if defined(OS_ANDROID)
[email protected]90f24152014-04-09 12:41:361891 UpdateTextInputState(NO_SHOW_IME, FROM_NON_IME);
[email protected]a80aea72014-03-14 21:10:151892 UpdateSelectionRootBounds();
[email protected]cb9e2632013-06-18 11:26:471893#endif
[email protected]abe8b3a2012-03-28 21:19:371894 UpdateSelectionBounds();
[email protected]9cd43a62012-03-26 08:03:561895}
1896
[email protected]3391a0772012-03-28 00:32:071897void RenderWidget::didBecomeReadyForAdditionalInput() {
1898 TRACE_EVENT0("renderer", "RenderWidget::didBecomeReadyForAdditionalInput");
[email protected]fd847792013-10-24 17:12:351899 FlushPendingInputEventAck();
[email protected]3391a0772012-03-28 00:32:071900}
1901
[email protected]6fceb912013-02-15 06:24:151902void RenderWidget::DidCommitCompositorFrame() {
[email protected]bffc8302014-01-23 20:52:161903 FOR_EACH_OBSERVER(RenderFrameImpl, swapped_out_frames_,
1904 DidCommitCompositorFrame());
[email protected]6fceb912013-02-15 06:24:151905}
1906
[email protected]58264a32011-11-17 23:36:151907void RenderWidget::didCommitAndDrawCompositorFrame() {
[email protected]b5db7eb2011-11-29 09:11:501908 TRACE_EVENT0("gpu", "RenderWidget::didCommitAndDrawCompositorFrame");
[email protected]bea16ce2014-01-11 23:01:291909 // Accelerated FPS tick for performance tests. See
1910 // tab_capture_performancetest.cc. NOTE: Tests may break if this event is
1911 // renamed or moved.
[email protected]c76faea2013-03-26 07:42:421912 UNSHIPPED_TRACE_EVENT_INSTANT0("test_fps", "TestFrameTickGPU",
1913 TRACE_EVENT_SCOPE_THREAD);
[email protected]29ed96a2012-02-04 18:12:161914 // Notify subclasses that we initiated the paint operation.
1915 DidInitiatePaint();
[email protected]58264a32011-11-17 23:36:151916}
1917
1918void RenderWidget::didCompleteSwapBuffers() {
[email protected]404939f2012-06-01 04:06:181919 TRACE_EVENT0("renderer", "RenderWidget::didCompleteSwapBuffers");
1920
1921 // Notify subclasses threaded composited rendering was flushed to the screen.
[email protected]9cd43a62012-03-26 08:03:561922 DidFlushPaint();
1923
[email protected]aa4117f2011-12-09 22:19:211924 if (update_reply_pending_)
[email protected]58264a32011-11-17 23:36:151925 return;
1926
[email protected]ea3ee0a2012-05-15 03:43:091927 if (!next_paint_flags_ &&
1928 !need_update_rect_for_auto_resize_ &&
1929 !plugin_window_moves_.size()) {
[email protected]58264a32011-11-17 23:36:151930 return;
[email protected]ea3ee0a2012-05-15 03:43:091931 }
[email protected]58264a32011-11-17 23:36:151932
1933 ViewHostMsg_UpdateRect_Params params;
1934 params.view_size = size_;
[email protected]58264a32011-11-17 23:36:151935 params.plugin_window_moves.swap(plugin_window_moves_);
1936 params.flags = next_paint_flags_;
1937 params.scroll_offset = GetScrollOffset();
[email protected]b0dda9e22011-12-13 20:30:121938 params.needs_ack = false;
[email protected]7ded9f12012-06-13 20:47:091939 params.scale_factor = device_scale_factor_;
[email protected]58264a32011-11-17 23:36:151940
1941 Send(new ViewHostMsg_UpdateRect(routing_id_, params));
1942 next_paint_flags_ = 0;
[email protected]ea3ee0a2012-05-15 03:43:091943 need_update_rect_for_auto_resize_ = false;
[email protected]58264a32011-11-17 23:36:151944}
1945
[email protected]8b9e52b2014-01-17 16:35:311946void RenderWidget::scheduleComposite() {
1947 if (RenderThreadImpl::current()->compositor_message_loop_proxy().get() &&
1948 compositor_) {
1949 compositor_->setNeedsAnimate();
[email protected]e3067e32013-11-22 07:51:451950 } else {
[email protected]8b9e52b2014-01-17 16:35:311951 // TODO(nduca): replace with something a little less hacky. The reason this
1952 // hack is still used is because the Invalidate-DoDeferredUpdate loop
1953 // contains a lot of host-renderer synchronization logic that is still
1954 // important for the accelerated compositing case. The option of simply
1955 // duplicating all that code is less desirable than "faking out" the
1956 // invalidation path using a magical damage rect.
1957 didInvalidateRect(WebRect(0, 0, 1, 1));
1958 }
1959}
1960
1961void RenderWidget::scheduleAnimation() {
1962 if (animation_update_pending_)
1963 return;
1964
1965 TRACE_EVENT0("gpu", "RenderWidget::scheduleAnimation");
1966 animation_update_pending_ = true;
1967 if (!animation_timer_.IsRunning()) {
1968 animation_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(0), this,
1969 &RenderWidget::AnimationCallback);
[email protected]ee3d3ad2011-02-04 00:42:211970 }
[email protected]5f8b1022011-01-21 23:34:501971}
1972
[email protected]4873c7d2009-07-16 06:36:281973void RenderWidget::didChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301974 // TODO(darin): Eliminate this temporary.
[email protected]9ec87712013-05-24 23:23:521975 WebCursor cursor;
[email protected]953bd0062013-08-01 00:58:401976 InitializeCursorFromWebKitCursorInfo(&cursor, cursor_info);
initial.commit09911bf2008-07-26 23:55:291977 // Only send a SetCursor message if we need to make a change.
1978 if (!current_cursor_.IsEqual(cursor)) {
1979 current_cursor_ = cursor;
1980 Send(new ViewHostMsg_SetCursor(routing_id_, cursor));
1981 }
1982}
1983
1984// We are supposed to get a single call to Show for a newly created RenderWidget
1985// that was created via RenderWidget::CreateWebView. So, we wait until this
1986// point to dispatch the ShowWidget message.
1987//
1988// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281989// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291990//
[email protected]4873c7d2009-07-16 06:36:281991void RenderWidget::show(WebNavigationPolicy) {
initial.commit09911bf2008-07-26 23:55:291992 DCHECK(!did_show_) << "received extraneous Show call";
1993 DCHECK(routing_id_ != MSG_ROUTING_NONE);
1994 DCHECK(opener_id_ != MSG_ROUTING_NONE);
1995
[email protected]8de12d942010-11-17 20:42:441996 if (did_show_)
1997 return;
1998
1999 did_show_ = true;
2000 // NOTE: initial_pos_ may still have its default values at this point, but
2001 // that's okay. It'll be ignored if as_popup is false, or the browser
2002 // process will impose a default position otherwise.
2003 Send(new ViewHostMsg_ShowWidget(opener_id_, routing_id_, initial_pos_));
2004 SetPendingWindowRect(initial_pos_);
initial.commit09911bf2008-07-26 23:55:292005}
2006
[email protected]4873c7d2009-07-16 06:36:282007void RenderWidget::didFocus() {
initial.commit09911bf2008-07-26 23:55:292008}
2009
[email protected]4873c7d2009-07-16 06:36:282010void RenderWidget::didBlur() {
initial.commit09911bf2008-07-26 23:55:292011}
2012
[email protected]2533ce12009-05-09 00:02:242013void RenderWidget::DoDeferredClose() {
2014 Send(new ViewHostMsg_Close(routing_id_));
2015}
2016
[email protected]4873c7d2009-07-16 06:36:282017void RenderWidget::closeWidgetSoon() {
[email protected]e1c3a552012-05-04 20:51:322018 if (is_swapped_out_) {
2019 // This widget is currently swapped out, and the active widget is in a
2020 // different process. Have the browser route the close request to the
2021 // active widget instead, so that the correct unload handlers are run.
2022 Send(new ViewHostMsg_RouteCloseEvent(routing_id_));
2023 return;
2024 }
2025
initial.commit09911bf2008-07-26 23:55:292026 // If a page calls window.close() twice, we'll end up here twice, but that's
2027 // OK. It is safe to send multiple Close messages.
2028
[email protected]2533ce12009-05-09 00:02:242029 // Ask the RenderWidgetHost to initiate close. We could be called from deep
2030 // in Javascript. If we ask the RendwerWidgetHost to close now, the window
2031 // could be closed before the JS finishes executing. So instead, post a
2032 // message back to the message loop, which won't run until the JS is
2033 // complete, and then the Close message can be sent.
[email protected]dd32b1272013-05-04 14:17:112034 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:212035 FROM_HERE, base::Bind(&RenderWidget::DoDeferredClose, this));
initial.commit09911bf2008-07-26 23:55:292036}
2037
[email protected]9017d7852013-11-21 17:47:352038void RenderWidget::QueueSyntheticGesture(
2039 scoped_ptr<SyntheticGestureParams> gesture_params,
2040 const SyntheticGestureCompletionCallback& callback) {
2041 DCHECK(!callback.is_null());
2042
2043 pending_synthetic_gesture_callbacks_.push(callback);
2044
2045 SyntheticGesturePacket gesture_packet;
2046 gesture_packet.set_gesture_params(gesture_params.Pass());
2047
2048 Send(new InputHostMsg_QueueSyntheticGesture(routing_id_, gesture_packet));
2049}
2050
initial.commit09911bf2008-07-26 23:55:292051void RenderWidget::Close() {
2052 if (webwidget_) {
[email protected]8926c602013-01-23 05:32:062053 webwidget_->willCloseLayerTreeView();
[email protected]ba91a792013-02-06 09:48:282054 compositor_.reset();
[email protected]4873c7d2009-07-16 06:36:282055 webwidget_->close();
initial.commit09911bf2008-07-26 23:55:292056 webwidget_ = NULL;
2057 }
2058}
2059
[email protected]4873c7d2009-07-16 06:36:282060WebRect RenderWidget::windowRect() {
2061 if (pending_window_rect_count_)
2062 return pending_window_rect_;
[email protected]2533ce12009-05-09 00:02:242063
[email protected]80ad8622012-11-07 16:33:032064 return view_screen_rect_;
initial.commit09911bf2008-07-26 23:55:292065}
2066
[email protected]180ef242013-11-07 06:50:462067void RenderWidget::setToolTipText(const blink::WebString& text,
[email protected]8a9d6ca32011-06-06 20:11:302068 WebTextDirection hint) {
[email protected]5a395b72011-08-08 19:13:542069 Send(new ViewHostMsg_SetTooltipText(routing_id_, text, hint));
[email protected]8a9d6ca32011-06-06 20:11:302070}
2071
[email protected]b2e4c70132013-10-03 02:07:512072void RenderWidget::setWindowRect(const WebRect& rect) {
2073 WebRect pos = rect;
2074 if (popup_origin_scale_for_emulation_) {
2075 float scale = popup_origin_scale_for_emulation_;
2076 pos.x = popup_screen_origin_for_emulation_.x() +
2077 (pos.x - popup_view_origin_for_emulation_.x()) * scale;
2078 pos.y = popup_screen_origin_for_emulation_.y() +
2079 (pos.y - popup_view_origin_for_emulation_.y()) * scale;
2080 }
2081
[email protected]5b45ad42013-10-25 00:42:042082 if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]ec951b9d2013-10-20 06:21:202083 if (did_show_) {
[email protected]8be1c582013-03-06 00:55:032084 Send(new ViewHostMsg_RequestMove(routing_id_, pos));
2085 SetPendingWindowRect(pos);
2086 } else {
[email protected]ec951b9d2013-10-20 06:21:202087 initial_pos_ = pos;
[email protected]8be1c582013-03-06 00:55:032088 }
initial.commit09911bf2008-07-26 23:55:292089 } else {
[email protected]92650162013-10-30 03:31:022090 ResizeSynchronously(pos);
initial.commit09911bf2008-07-26 23:55:292091 }
2092}
2093
[email protected]2533ce12009-05-09 00:02:242094void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
2095 pending_window_rect_ = rect;
2096 pending_window_rect_count_++;
2097}
2098
[email protected]4873c7d2009-07-16 06:36:282099WebRect RenderWidget::rootWindowRect() {
[email protected]2533ce12009-05-09 00:02:242100 if (pending_window_rect_count_) {
2101 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
2102 // the RootWindowRect is probably going to return wrong results since the
2103 // browser may not have processed the Move yet. There isn't really anything
2104 // good to do in this case, and it shouldn't happen - since this size is
2105 // only really needed for windowToScreen, which is only used for Popups.
[email protected]4873c7d2009-07-16 06:36:282106 return pending_window_rect_;
[email protected]2533ce12009-05-09 00:02:242107 }
2108
[email protected]80ad8622012-11-07 16:33:032109 return window_screen_rect_;
[email protected]d4547452008-08-28 18:36:372110}
2111
[email protected]4873c7d2009-07-16 06:36:282112WebRect RenderWidget::windowResizerRect() {
2113 return resizer_rect_;
[email protected]c04b6362008-11-21 18:54:192114}
2115
[email protected]fa7b1dc2010-06-23 17:53:042116void RenderWidget::OnSetInputMethodActive(bool is_active) {
[email protected]c4bb35a2008-10-31 17:54:032117 // To prevent this renderer process from sending unnecessary IPC messages to
2118 // a browser process, we permit the renderer process to send IPC messages
[email protected]fa7b1dc2010-06-23 17:53:042119 // only during the input method attached to the browser process is active.
2120 input_method_is_active_ = is_active;
initial.commit09911bf2008-07-26 23:55:292121}
2122
[email protected]37a241c2013-12-03 03:16:172123void RenderWidget::OnCandidateWindowShown() {
2124 webwidget_->didShowCandidateWindow();
2125}
2126
2127void RenderWidget::OnCandidateWindowUpdated() {
2128 webwidget_->didUpdateCandidateWindow();
2129}
2130
2131void RenderWidget::OnCandidateWindowHidden() {
2132 webwidget_->didHideCandidateWindow();
2133}
2134
[email protected]fa7b1dc2010-06-23 17:53:042135void RenderWidget::OnImeSetComposition(
[email protected]fcf75d42013-12-03 20:11:262136 const base::string16& text,
[email protected]fa7b1dc2010-06-23 17:53:042137 const std::vector<WebCompositionUnderline>& underlines,
2138 int selection_start, int selection_end) {
[email protected]0d1ebed12013-08-05 22:01:132139 if (!ShouldHandleImeEvent())
[email protected]4873c7d2009-07-16 06:36:282140 return;
[email protected]66fca5bc2013-05-23 06:58:292141 ImeEventGuard guard(this);
[email protected]88dbe32f2013-06-20 23:31:362142 if (!webwidget_->setComposition(
[email protected]fa7b1dc2010-06-23 17:53:042143 text, WebVector<WebCompositionUnderline>(underlines),
2144 selection_start, selection_end)) {
2145 // If we failed to set the composition text, then we need to let the browser
2146 // process to cancel the input method's ongoing composition session, to make
2147 // sure we are in a consistent state.
2148 Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
[email protected]7f00efa2010-04-15 05:01:262149 }
[email protected]501ea13d2013-07-09 17:03:292150#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362151 UpdateCompositionInfo(true);
[email protected]501ea13d2013-07-09 17:03:292152#endif
[email protected]fa7b1dc2010-06-23 17:53:042153}
2154
[email protected]fcf75d42013-12-03 20:11:262155void RenderWidget::OnImeConfirmComposition(const base::string16& text,
[email protected]db4fc1e2013-09-06 20:01:512156 const gfx::Range& replacement_range,
[email protected]0e45bd02013-07-12 20:20:022157 bool keep_selection) {
[email protected]0d1ebed12013-08-05 22:01:132158 if (!ShouldHandleImeEvent())
[email protected]d0be63772011-12-20 23:18:042159 return;
[email protected]66fca5bc2013-05-23 06:58:292160 ImeEventGuard guard(this);
[email protected]d0be63772011-12-20 23:18:042161 handling_input_event_ = true;
[email protected]0e45bd02013-07-12 20:20:022162 if (text.length())
2163 webwidget_->confirmComposition(text);
2164 else if (keep_selection)
2165 webwidget_->confirmComposition(WebWidget::KeepSelection);
2166 else
2167 webwidget_->confirmComposition(WebWidget::DoNotKeepSelection);
[email protected]d0be63772011-12-20 23:18:042168 handling_input_event_ = false;
[email protected]501ea13d2013-07-09 17:03:292169#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362170 UpdateCompositionInfo(true);
[email protected]501ea13d2013-07-09 17:03:292171#endif
initial.commit09911bf2008-07-26 23:55:292172}
2173
[email protected]51a49502013-03-23 01:50:192174void RenderWidget::OnSnapshot(const gfx::Rect& src_subrect) {
2175 SkBitmap snapshot;
2176
2177 if (OnSnapshotHelper(src_subrect, &snapshot)) {
2178 Send(new ViewHostMsg_Snapshot(routing_id(), true, snapshot));
2179 } else {
2180 Send(new ViewHostMsg_Snapshot(routing_id(), false, SkBitmap()));
2181 }
2182}
2183
2184bool RenderWidget::OnSnapshotHelper(const gfx::Rect& src_subrect,
2185 SkBitmap* snapshot) {
2186 base::TimeTicks beginning_time = base::TimeTicks::Now();
2187
2188 if (!webwidget_ || src_subrect.IsEmpty())
2189 return false;
2190
2191 gfx::Rect viewport_size = gfx::IntersectRects(
2192 src_subrect, gfx::Rect(physical_backing_size_));
2193
2194 skia::RefPtr<SkCanvas> canvas = skia::AdoptRef(
2195 skia::CreatePlatformCanvas(viewport_size.width(),
2196 viewport_size.height(),
2197 true,
2198 NULL,
2199 skia::RETURN_NULL_ON_FAILURE));
[email protected]59383c782013-04-17 16:43:272200 if (!canvas)
[email protected]51a49502013-03-23 01:50:192201 return false;
2202
2203 canvas->save();
2204 webwidget_->layout();
2205
2206 PaintRect(viewport_size, viewport_size.origin(), canvas.get());
2207 canvas->restore();
2208
2209 const SkBitmap& bitmap = skia::GetTopDevice(*canvas)->accessBitmap(false);
[email protected]8dca6e02014-03-04 04:21:392210 if (!bitmap.copyTo(snapshot, kPMColor_SkColorType))
[email protected]51a49502013-03-23 01:50:192211 return false;
2212
2213 UMA_HISTOGRAM_TIMES("Renderer4.Snapshot",
2214 base::TimeTicks::Now() - beginning_time);
2215 return true;
2216}
2217
[email protected]0bc1f572013-04-17 01:46:312218void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
[email protected]ec7dc112008-08-06 05:30:122219 // During shutdown we can just ignore this message.
2220 if (!webwidget_)
2221 return;
2222
[email protected]0bc1f572013-04-17 01:46:312223 // Even if the browser provides an empty damage rect, it's still expecting to
2224 // receive a repaint ack so just damage the entire widget bounds.
2225 if (size_to_paint.IsEmpty()) {
2226 size_to_paint = size_;
2227 }
2228
[email protected]ec7dc112008-08-06 05:30:122229 set_next_paint_is_repaint_ack();
[email protected]0bc1f572013-04-17 01:46:312230 if (is_accelerated_compositing_active_ && compositor_) {
2231 compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint));
[email protected]f98d7e3c2010-09-13 22:30:462232 } else {
2233 gfx::Rect repaint_rect(size_to_paint.width(), size_to_paint.height());
2234 didInvalidateRect(repaint_rect);
2235 }
[email protected]ec7dc112008-08-06 05:30:122236}
2237
[email protected]79fa22e2013-08-23 15:18:122238void RenderWidget::OnSyntheticGestureCompleted() {
[email protected]9017d7852013-11-21 17:47:352239 DCHECK(!pending_synthetic_gesture_callbacks_.empty());
2240
2241 pending_synthetic_gesture_callbacks_.front().Run();
2242 pending_synthetic_gesture_callbacks_.pop();
[email protected]0e241b4b2012-08-18 09:06:272243}
2244
[email protected]4873c7d2009-07-16 06:36:282245void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
[email protected]07f953332009-03-25 04:31:112246 if (!webwidget_)
2247 return;
[email protected]4873c7d2009-07-16 06:36:282248 webwidget_->setTextDirection(direction);
[email protected]07f953332009-03-25 04:31:112249}
2250
[email protected]80ad8622012-11-07 16:33:032251void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
2252 const gfx::Rect& window_screen_rect) {
[email protected]b2e4c70132013-10-03 02:07:512253 if (screen_metrics_emulator_) {
2254 screen_metrics_emulator_->OnUpdateScreenRectsMessage(
2255 view_screen_rect, window_screen_rect);
2256 } else {
2257 view_screen_rect_ = view_screen_rect;
2258 window_screen_rect_ = window_screen_rect;
2259 }
[email protected]80ad8622012-11-07 16:33:032260 Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
2261}
2262
[email protected]105dffb42013-02-20 03:46:212263#if defined(OS_ANDROID)
[email protected]2384b6c2013-02-28 23:58:512264void RenderWidget::OnShowImeIfNeeded() {
[email protected]90f24152014-04-09 12:41:362265 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
[email protected]0d1ebed12013-08-05 22:01:132266}
2267
2268void RenderWidget::IncrementOutstandingImeEventAcks() {
2269 ++outstanding_ime_acks_;
2270}
2271
2272void RenderWidget::OnImeEventAck() {
2273 --outstanding_ime_acks_;
2274 DCHECK(outstanding_ime_acks_ >= 0);
[email protected]2384b6c2013-02-28 23:58:512275}
[email protected]105dffb42013-02-20 03:46:212276#endif
2277
[email protected]0d1ebed12013-08-05 22:01:132278bool RenderWidget::ShouldHandleImeEvent() {
2279#if defined(OS_ANDROID)
2280 return !!webwidget_ && outstanding_ime_acks_ == 0;
2281#else
2282 return !!webwidget_;
2283#endif
2284}
2285
[email protected]468ac582012-11-20 00:53:192286void RenderWidget::SetDeviceScaleFactor(float device_scale_factor) {
2287 if (device_scale_factor_ == device_scale_factor)
2288 return;
2289
2290 device_scale_factor_ = device_scale_factor;
2291
2292 if (!is_accelerated_compositing_active_) {
2293 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
2294 } else {
[email protected]8b9e52b2014-01-17 16:35:312295 scheduleComposite();
[email protected]468ac582012-11-20 00:53:192296 }
2297}
2298
[email protected]ceb36f7d2012-10-31 18:33:242299gfx::Vector2d RenderWidget::GetScrollOffset() {
[email protected]d54169e92011-01-21 09:19:522300 // Bare RenderWidgets don't support scroll offset.
[email protected]ceb36f7d2012-10-31 18:33:242301 return gfx::Vector2d();
[email protected]d54169e92011-01-21 09:19:522302}
2303
[email protected]bee16aab2009-08-26 15:55:032304void RenderWidget::SetHidden(bool hidden) {
2305 if (is_hidden_ == hidden)
2306 return;
2307
2308 // The status has changed. Tell the RenderThread about it.
2309 is_hidden_ = hidden;
2310 if (is_hidden_)
[email protected]b2db9272014-01-10 17:42:002311 RenderThreadImpl::current()->WidgetHidden();
[email protected]bee16aab2009-08-26 15:55:032312 else
[email protected]b2db9272014-01-10 17:42:002313 RenderThreadImpl::current()->WidgetRestored();
[email protected]bee16aab2009-08-26 15:55:032314}
2315
[email protected]2b624c562011-10-27 22:58:262316void RenderWidget::WillToggleFullscreen() {
[email protected]2b624c562011-10-27 22:58:262317 if (!webwidget_)
2318 return;
2319
2320 if (is_fullscreen_) {
2321 webwidget_->willExitFullScreen();
2322 } else {
2323 webwidget_->willEnterFullScreen();
2324 }
[email protected]2b624c562011-10-27 22:58:262325}
2326
2327void RenderWidget::DidToggleFullscreen() {
[email protected]2b624c562011-10-27 22:58:262328 if (!webwidget_)
2329 return;
2330
2331 if (is_fullscreen_) {
2332 webwidget_->didEnterFullScreen();
2333 } else {
2334 webwidget_->didExitFullScreen();
2335 }
[email protected]2b624c562011-10-27 22:58:262336}
2337
[email protected]699ab0d2009-04-23 23:19:142338void RenderWidget::SetBackground(const SkBitmap& background) {
2339 background_ = background;
[email protected]f98d7e3c2010-09-13 22:30:462340
[email protected]699ab0d2009-04-23 23:19:142341 // Generate a full repaint.
[email protected]4873c7d2009-07-16 06:36:282342 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
[email protected]699ab0d2009-04-23 23:19:142343}
2344
[email protected]674741932009-02-04 23:44:462345bool RenderWidget::next_paint_is_resize_ack() const {
[email protected]53d3f302009-12-21 04:42:052346 return ViewHostMsg_UpdateRect_Flags::is_resize_ack(next_paint_flags_);
[email protected]674741932009-02-04 23:44:462347}
2348
2349bool RenderWidget::next_paint_is_restore_ack() const {
[email protected]53d3f302009-12-21 04:42:052350 return ViewHostMsg_UpdateRect_Flags::is_restore_ack(next_paint_flags_);
[email protected]674741932009-02-04 23:44:462351}
2352
2353void RenderWidget::set_next_paint_is_resize_ack() {
[email protected]53d3f302009-12-21 04:42:052354 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
[email protected]674741932009-02-04 23:44:462355}
2356
2357void RenderWidget::set_next_paint_is_restore_ack() {
[email protected]53d3f302009-12-21 04:42:052358 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESTORE_ACK;
[email protected]674741932009-02-04 23:44:462359}
2360
2361void RenderWidget::set_next_paint_is_repaint_ack() {
[email protected]53d3f302009-12-21 04:42:052362 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK;
[email protected]674741932009-02-04 23:44:462363}
2364
[email protected]b18583c2012-12-18 06:55:272365static bool IsDateTimeInput(ui::TextInputType type) {
2366 return type == ui::TEXT_INPUT_TYPE_DATE ||
2367 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
2368 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
2369 type == ui::TEXT_INPUT_TYPE_MONTH ||
2370 type == ui::TEXT_INPUT_TYPE_TIME ||
2371 type == ui::TEXT_INPUT_TYPE_WEEK;
2372}
2373
[email protected]66fca5bc2013-05-23 06:58:292374
2375void RenderWidget::StartHandlingImeEvent() {
2376 DCHECK(!handling_ime_event_);
2377 handling_ime_event_ = true;
2378}
2379
2380void RenderWidget::FinishHandlingImeEvent() {
2381 DCHECK(handling_ime_event_);
2382 handling_ime_event_ = false;
2383 // While handling an ime event, text input state and selection bounds updates
2384 // are ignored. These must explicitly be updated once finished handling the
2385 // ime event.
[email protected]a80aea72014-03-14 21:10:152386#if defined(OS_ANDROID)
2387 UpdateSelectionRootBounds();
2388#endif
[email protected]66fca5bc2013-05-23 06:58:292389 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:472390#if defined(OS_ANDROID)
[email protected]90f24152014-04-09 12:41:362391 UpdateTextInputState(NO_SHOW_IME, FROM_IME);
[email protected]cb9e2632013-06-18 11:26:472392#endif
[email protected]66fca5bc2013-05-23 06:58:292393}
2394
[email protected]cb9e2632013-06-18 11:26:472395void RenderWidget::UpdateTextInputType() {
[email protected]11f22bb62013-09-24 04:59:062396 // On Windows, not only an IME but also an on-screen keyboard relies on the
2397 // latest TextInputType to optimize its layout and functionality. Thus
2398 // |input_method_is_active_| is no longer an appropriate condition to suppress
2399 // TextInputTypeChanged IPC on Windows.
2400 // TODO(yukawa, yoichio): Consider to stop checking |input_method_is_active_|
2401 // on other platforms as well as Windows if the overhead is acceptable.
2402#if !defined(OS_WIN)
[email protected]cb9e2632013-06-18 11:26:472403 if (!input_method_is_active_)
2404 return;
[email protected]11f22bb62013-09-24 04:59:062405#endif
[email protected]cb9e2632013-06-18 11:26:472406
[email protected]e7c569d2013-07-17 16:00:362407 ui::TextInputType new_type = GetTextInputType();
[email protected]cb9e2632013-06-18 11:26:472408 if (IsDateTimeInput(new_type))
2409 return; // Not considered as a text input field in WebKit/Chromium.
2410
2411 bool new_can_compose_inline = CanComposeInline();
2412
[email protected]180ef242013-11-07 06:50:462413 blink::WebTextInputInfo new_info;
[email protected]e7c569d2013-07-17 16:00:362414 if (webwidget_)
2415 new_info = webwidget_->textInputInfo();
[email protected]b256eca2013-07-11 10:57:402416 const ui::TextInputMode new_mode = ConvertInputMode(new_info.inputMode);
2417
[email protected]cb9e2632013-06-18 11:26:472418 if (text_input_type_ != new_type
[email protected]b256eca2013-07-11 10:57:402419 || can_compose_inline_ != new_can_compose_inline
2420 || text_input_mode_ != new_mode) {
[email protected]cb9e2632013-06-18 11:26:472421 Send(new ViewHostMsg_TextInputTypeChanged(routing_id(),
2422 new_type,
[email protected]86ba5fcb2013-09-04 00:36:532423 new_mode,
2424 new_can_compose_inline));
[email protected]cb9e2632013-06-18 11:26:472425 text_input_type_ = new_type;
2426 can_compose_inline_ = new_can_compose_inline;
[email protected]b256eca2013-07-11 10:57:402427 text_input_mode_ = new_mode;
[email protected]cb9e2632013-06-18 11:26:472428 }
2429}
2430
[email protected]183e28d2014-01-20 18:18:022431#if defined(OS_ANDROID) || defined(USE_AURA)
[email protected]90f24152014-04-09 12:41:362432void RenderWidget::UpdateTextInputState(ShowIme show_ime,
2433 ChangeSource change_source) {
[email protected]e8f775f2013-02-14 21:00:502434 if (handling_ime_event_)
2435 return;
[email protected]90f24152014-04-09 12:41:362436 if (show_ime == NO_SHOW_IME && !input_method_is_active_)
initial.commit09911bf2008-07-26 23:55:292437 return;
[email protected]ad26ef42011-06-17 07:59:452438 ui::TextInputType new_type = GetTextInputType();
[email protected]b18583c2012-12-18 06:55:272439 if (IsDateTimeInput(new_type))
2440 return; // Not considered as a text input field in WebKit/Chromium.
2441
[email protected]180ef242013-11-07 06:50:462442 blink::WebTextInputInfo new_info;
[email protected]5b739cb2012-08-21 20:35:212443 if (webwidget_)
2444 new_info = webwidget_->textInputInfo();
2445
[email protected]ad26ef42011-06-17 07:59:452446 bool new_can_compose_inline = CanComposeInline();
[email protected]5b739cb2012-08-21 20:35:212447
[email protected]3306f262012-09-21 19:20:422448 // Only sends text input params if they are changed or if the ime should be
2449 // shown.
[email protected]90f24152014-04-09 12:41:362450 if (show_ime == SHOW_IME_IF_NEEDED ||
2451 (text_input_type_ != new_type ||
2452 text_input_info_ != new_info ||
2453 can_compose_inline_ != new_can_compose_inline)
2454#if defined(OS_ANDROID)
2455 || text_field_is_dirty_
[email protected]183e28d2014-01-20 18:18:022456#endif
[email protected]90f24152014-04-09 12:41:362457 ) {
2458 ViewHostMsg_TextInputState_Params p;
[email protected]5b739cb2012-08-21 20:35:212459 p.type = new_type;
2460 p.value = new_info.value.utf8();
2461 p.selection_start = new_info.selectionStart;
2462 p.selection_end = new_info.selectionEnd;
2463 p.composition_start = new_info.compositionStart;
2464 p.composition_end = new_info.compositionEnd;
2465 p.can_compose_inline = new_can_compose_inline;
[email protected]90f24152014-04-09 12:41:362466 p.show_ime_if_needed = (show_ime == SHOW_IME_IF_NEEDED);
2467#if defined(USE_AURA)
2468 p.is_non_ime_change = true;
2469#endif
[email protected]183e28d2014-01-20 18:18:022470#if defined(OS_ANDROID)
[email protected]90f24152014-04-09 12:41:362471 p.is_non_ime_change = (change_source == FROM_NON_IME) ||
2472 text_field_is_dirty_;
2473 if (p.is_non_ime_change)
[email protected]0d1ebed12013-08-05 22:01:132474 IncrementOutstandingImeEventAcks();
[email protected]90f24152014-04-09 12:41:362475 text_field_is_dirty_ = false;
[email protected]183e28d2014-01-20 18:18:022476#endif
[email protected]5b739cb2012-08-21 20:35:212477 Send(new ViewHostMsg_TextInputStateChanged(routing_id(), p));
2478
2479 text_input_info_ = new_info;
[email protected]fa7b1dc2010-06-23 17:53:042480 text_input_type_ = new_type;
[email protected]ad26ef42011-06-17 07:59:452481 can_compose_inline_ = new_can_compose_inline;
initial.commit09911bf2008-07-26 23:55:292482 }
initial.commit09911bf2008-07-26 23:55:292483}
[email protected]cb9e2632013-06-18 11:26:472484#endif
initial.commit09911bf2008-07-26 23:55:292485
[email protected]7c8873e2013-02-05 08:03:012486void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
2487 WebRect focus_webrect;
2488 WebRect anchor_webrect;
2489 webwidget_->selectionBounds(focus_webrect, anchor_webrect);
2490 *focus = focus_webrect;
2491 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:322492}
2493
[email protected]e99ef6f2011-10-16 01:13:002494void RenderWidget::UpdateSelectionBounds() {
2495 if (!webwidget_)
2496 return;
[email protected]66fca5bc2013-05-23 06:58:292497 if (handling_ime_event_)
2498 return;
[email protected]e99ef6f2011-10-16 01:13:002499
[email protected]7c8873e2013-02-05 08:03:012500 ViewHostMsg_SelectionBounds_Params params;
2501 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
2502 if (selection_anchor_rect_ != params.anchor_rect ||
2503 selection_focus_rect_ != params.focus_rect) {
2504 selection_anchor_rect_ = params.anchor_rect;
2505 selection_focus_rect_ = params.focus_rect;
2506 webwidget_->selectionTextDirection(params.focus_dir, params.anchor_dir);
[email protected]129b7382013-02-12 02:14:292507 params.is_anchor_first = webwidget_->isSelectionAnchorFirst();
[email protected]7c8873e2013-02-05 08:03:012508 Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
[email protected]58b48a0d2012-06-13 07:01:352509 }
[email protected]501ea13d2013-07-09 17:03:292510#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362511 UpdateCompositionInfo(false);
[email protected]501ea13d2013-07-09 17:03:292512#endif
[email protected]e99ef6f2011-10-16 01:13:002513}
2514
[email protected]180ef242013-11-07 06:50:462515// Check blink::WebTextInputType and ui::TextInputType is kept in sync.
2516COMPILE_ASSERT(int(blink::WebTextInputTypeNone) == \
[email protected]ad26ef42011-06-17 07:59:452517 int(ui::TEXT_INPUT_TYPE_NONE), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462518COMPILE_ASSERT(int(blink::WebTextInputTypeText) == \
[email protected]ad26ef42011-06-17 07:59:452519 int(ui::TEXT_INPUT_TYPE_TEXT), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462520COMPILE_ASSERT(int(blink::WebTextInputTypePassword) == \
[email protected]ad26ef42011-06-17 07:59:452521 int(ui::TEXT_INPUT_TYPE_PASSWORD), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462522COMPILE_ASSERT(int(blink::WebTextInputTypeSearch) == \
[email protected]caf38ed2011-07-28 13:15:182523 int(ui::TEXT_INPUT_TYPE_SEARCH), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462524COMPILE_ASSERT(int(blink::WebTextInputTypeEmail) == \
[email protected]caf38ed2011-07-28 13:15:182525 int(ui::TEXT_INPUT_TYPE_EMAIL), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462526COMPILE_ASSERT(int(blink::WebTextInputTypeNumber) == \
[email protected]caf38ed2011-07-28 13:15:182527 int(ui::TEXT_INPUT_TYPE_NUMBER), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462528COMPILE_ASSERT(int(blink::WebTextInputTypeTelephone) == \
[email protected]caf38ed2011-07-28 13:15:182529 int(ui::TEXT_INPUT_TYPE_TELEPHONE), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462530COMPILE_ASSERT(int(blink::WebTextInputTypeURL) == \
[email protected]caf38ed2011-07-28 13:15:182531 int(ui::TEXT_INPUT_TYPE_URL), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462532COMPILE_ASSERT(int(blink::WebTextInputTypeDate) == \
[email protected]feb8cf752012-06-08 04:48:002533 int(ui::TEXT_INPUT_TYPE_DATE), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462534COMPILE_ASSERT(int(blink::WebTextInputTypeDateTime) == \
[email protected]feb8cf752012-06-08 04:48:002535 int(ui::TEXT_INPUT_TYPE_DATE_TIME), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462536COMPILE_ASSERT(int(blink::WebTextInputTypeDateTimeLocal) == \
[email protected]feb8cf752012-06-08 04:48:002537 int(ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462538COMPILE_ASSERT(int(blink::WebTextInputTypeMonth) == \
[email protected]feb8cf752012-06-08 04:48:002539 int(ui::TEXT_INPUT_TYPE_MONTH), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462540COMPILE_ASSERT(int(blink::WebTextInputTypeTime) == \
[email protected]feb8cf752012-06-08 04:48:002541 int(ui::TEXT_INPUT_TYPE_TIME), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462542COMPILE_ASSERT(int(blink::WebTextInputTypeWeek) == \
[email protected]feb8cf752012-06-08 04:48:002543 int(ui::TEXT_INPUT_TYPE_WEEK), mismatching_enum);
[email protected]180ef242013-11-07 06:50:462544COMPILE_ASSERT(int(blink::WebTextInputTypeTextArea) == \
[email protected]2a9893672012-11-09 20:33:012545 int(ui::TEXT_INPUT_TYPE_TEXT_AREA), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462546COMPILE_ASSERT(int(blink::WebTextInputTypeContentEditable) == \
[email protected]2a9893672012-11-09 20:33:012547 int(ui::TEXT_INPUT_TYPE_CONTENT_EDITABLE), mismatching_enums);
[email protected]180ef242013-11-07 06:50:462548COMPILE_ASSERT(int(blink::WebTextInputTypeDateTimeField) == \
[email protected]8b4992e2013-03-01 15:42:152549 int(ui::TEXT_INPUT_TYPE_DATE_TIME_FIELD), mismatching_enums);
[email protected]ad26ef42011-06-17 07:59:452550
[email protected]5b739cb2012-08-21 20:35:212551ui::TextInputType RenderWidget::WebKitToUiTextInputType(
[email protected]180ef242013-11-07 06:50:462552 blink::WebTextInputType type) {
[email protected]5b739cb2012-08-21 20:35:212553 // Check the type is in the range representable by ui::TextInputType.
2554 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX)) <<
[email protected]180ef242013-11-07 06:50:462555 "blink::WebTextInputType and ui::TextInputType not synchronized";
[email protected]5b739cb2012-08-21 20:35:212556 return static_cast<ui::TextInputType>(type);
2557}
2558
[email protected]ad26ef42011-06-17 07:59:452559ui::TextInputType RenderWidget::GetTextInputType() {
[email protected]8969bb3f2012-11-30 21:49:272560 if (webwidget_)
2561 return WebKitToUiTextInputType(webwidget_->textInputInfo().type);
[email protected]ad26ef42011-06-17 07:59:452562 return ui::TEXT_INPUT_TYPE_NONE;
2563}
2564
[email protected]501ea13d2013-07-09 17:03:292565#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
2566void RenderWidget::UpdateCompositionInfo(bool should_update_range) {
[email protected]db4fc1e2013-09-06 20:01:512567 gfx::Range range = gfx::Range();
[email protected]501ea13d2013-07-09 17:03:292568 if (should_update_range) {
2569 GetCompositionRange(&range);
2570 } else {
2571 range = composition_range_;
2572 }
2573 std::vector<gfx::Rect> character_bounds;
2574 GetCompositionCharacterBounds(&character_bounds);
2575
2576 if (!ShouldUpdateCompositionInfo(range, character_bounds))
2577 return;
2578 composition_character_bounds_ = character_bounds;
2579 composition_range_ = range;
2580 Send(new ViewHostMsg_ImeCompositionRangeChanged(
2581 routing_id(), composition_range_, composition_character_bounds_));
2582}
2583
[email protected]58b48a0d2012-06-13 07:01:352584void RenderWidget::GetCompositionCharacterBounds(
2585 std::vector<gfx::Rect>* bounds) {
2586 DCHECK(bounds);
2587 bounds->clear();
2588}
2589
[email protected]db4fc1e2013-09-06 20:01:512590void RenderWidget::GetCompositionRange(gfx::Range* range) {
[email protected]88dbe32f2013-06-20 23:31:362591 size_t location, length;
2592 if (webwidget_->compositionRange(&location, &length)) {
2593 range->set_start(location);
2594 range->set_end(location + length);
2595 } else if (webwidget_->caretOrSelectionRange(&location, &length)) {
2596 range->set_start(location);
2597 range->set_end(location + length);
2598 } else {
[email protected]db4fc1e2013-09-06 20:01:512599 *range = gfx::Range::InvalidRange();
[email protected]88dbe32f2013-06-20 23:31:362600 }
2601}
2602
[email protected]501ea13d2013-07-09 17:03:292603bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:512604 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:292605 const std::vector<gfx::Rect>& bounds) {
2606 if (composition_range_ != range)
2607 return true;
2608 if (bounds.size() != composition_character_bounds_.size())
2609 return true;
2610 for (size_t i = 0; i < bounds.size(); ++i) {
2611 if (bounds[i] != composition_character_bounds_[i])
2612 return true;
2613 }
2614 return false;
2615}
2616#endif
2617
[email protected]ad26ef42011-06-17 07:59:452618bool RenderWidget::CanComposeInline() {
2619 return true;
[email protected]56ea1a62011-05-30 07:05:572620}
2621
[email protected]4873c7d2009-07-16 06:36:282622WebScreenInfo RenderWidget::screenInfo() {
[email protected]842f10652012-06-06 01:54:042623 return screen_info_;
[email protected]4873c7d2009-07-16 06:36:282624}
2625
[email protected]f660d9c2012-06-06 18:31:212626float RenderWidget::deviceScaleFactor() {
2627 return device_scale_factor_;
2628}
2629
[email protected]fa7b1dc2010-06-23 17:53:042630void RenderWidget::resetInputMethod() {
2631 if (!input_method_is_active_)
2632 return;
2633
[email protected]0e45bd02013-07-12 20:20:022634 ImeEventGuard guard(this);
[email protected]fa7b1dc2010-06-23 17:53:042635 // If the last text input type is not None, then we should finish any
2636 // ongoing composition regardless of the new text input type.
[email protected]ad26ef42011-06-17 07:59:452637 if (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE) {
[email protected]fa7b1dc2010-06-23 17:53:042638 // If a composition text exists, then we need to let the browser process
2639 // to cancel the input method's ongoing composition session.
2640 if (webwidget_->confirmComposition())
2641 Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
2642 }
[email protected]d4cff272011-05-02 15:46:012643
[email protected]501ea13d2013-07-09 17:03:292644#if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:362645 UpdateCompositionInfo(true);
[email protected]501ea13d2013-07-09 17:03:292646#endif
[email protected]fa7b1dc2010-06-23 17:53:042647}
2648
[email protected]c68c3e4e2013-01-24 00:36:562649void RenderWidget::didHandleGestureEvent(
2650 const WebGestureEvent& event,
2651 bool event_cancelled) {
[email protected]183e28d2014-01-20 18:18:022652#if defined(OS_ANDROID) || defined(USE_AURA)
[email protected]c68c3e4e2013-01-24 00:36:562653 if (event_cancelled)
2654 return;
2655 if (event.type == WebInputEvent::GestureTap ||
2656 event.type == WebInputEvent::GestureLongPress) {
[email protected]90f24152014-04-09 12:41:362657 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
[email protected]c68c3e4e2013-01-24 00:36:562658 }
2659#endif
2660}
2661
[email protected]29e2fb42013-07-19 01:13:472662void RenderWidget::SchedulePluginMove(const WebPluginGeometry& move) {
initial.commit09911bf2008-07-26 23:55:292663 size_t i = 0;
2664 for (; i < plugin_window_moves_.size(); ++i) {
2665 if (plugin_window_moves_[i].window == move.window) {
[email protected]16f89d02009-08-26 17:17:582666 if (move.rects_valid) {
2667 plugin_window_moves_[i] = move;
2668 } else {
2669 plugin_window_moves_[i].visible = move.visible;
2670 }
initial.commit09911bf2008-07-26 23:55:292671 break;
2672 }
2673 }
2674
2675 if (i == plugin_window_moves_.size())
2676 plugin_window_moves_.push_back(move);
2677}
[email protected]268654772009-08-06 23:02:042678
2679void RenderWidget::CleanupWindowInPluginMoves(gfx::PluginWindowHandle window) {
2680 for (WebPluginGeometryVector::iterator i = plugin_window_moves_.begin();
2681 i != plugin_window_moves_.end(); ++i) {
2682 if (i->window == window) {
2683 plugin_window_moves_.erase(i);
2684 break;
2685 }
2686 }
2687}
[email protected]67bfb83f2011-09-22 03:36:372688
[email protected]63b465922012-09-06 02:04:522689
[email protected]24ed0432013-04-24 07:50:312690RenderWidgetCompositor* RenderWidget::compositor() const {
2691 return compositor_.get();
2692}
2693
[email protected]180ef242013-11-07 06:50:462694bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
[email protected]67bfb83f2011-09-22 03:36:372695 return false;
2696}
[email protected]c3d45532011-10-07 19:20:402697
[email protected]41d86852012-11-07 12:23:242698bool RenderWidget::WillHandleGestureEvent(
[email protected]180ef242013-11-07 06:50:462699 const blink::WebGestureEvent& event) {
[email protected]41d86852012-11-07 12:23:242700 return false;
2701}
2702
[email protected]ce6689f2013-03-29 12:52:552703void RenderWidget::hasTouchEventHandlers(bool has_handlers) {
2704 Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
2705}
2706
[email protected]5d0bbdfa92013-12-10 00:35:512707void RenderWidget::setTouchAction(
2708 blink::WebTouchAction web_touch_action) {
2709
2710 // Ignore setTouchAction calls that result from synthetic touch events (eg.
2711 // when blink is emulating touch with mouse).
2712 if (!handling_touchstart_event_)
2713 return;
2714
[email protected]a18f67a2013-12-20 19:44:362715 // Verify the same values are used by the types so we can cast between them.
2716 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_AUTO) ==
2717 blink::WebTouchActionAuto,
2718 enum_values_must_match_for_touch_action);
2719 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_NONE) ==
2720 blink::WebTouchActionNone,
2721 enum_values_must_match_for_touch_action);
2722 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_PAN_X) ==
2723 blink::WebTouchActionPanX,
2724 enum_values_must_match_for_touch_action);
2725 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_PAN_Y) ==
2726 blink::WebTouchActionPanY,
2727 enum_values_must_match_for_touch_action);
[email protected]2bd73272014-03-13 19:36:112728 COMPILE_ASSERT(
2729 static_cast<blink::WebTouchAction>(TOUCH_ACTION_PINCH_ZOOM) ==
2730 blink::WebTouchActionPinchZoom,
2731 enum_values_must_match_for_touch_action);
[email protected]a18f67a2013-12-20 19:44:362732
2733 content::TouchAction content_touch_action =
2734 static_cast<content::TouchAction>(web_touch_action);
[email protected]5d0bbdfa92013-12-10 00:35:512735 Send(new InputHostMsg_SetTouchAction(routing_id_, content_touch_action));
2736}
2737
[email protected]90f24152014-04-09 12:41:362738void RenderWidget::didUpdateTextOfFocusedElementByNonUserInput() {
2739#if defined(OS_ANDROID)
2740 text_field_is_dirty_ = true;
2741#endif
2742}
2743
[email protected]a80aea72014-03-14 21:10:152744#if defined(OS_ANDROID)
2745void RenderWidget::UpdateSelectionRootBounds() {
2746}
2747#endif
2748
[email protected]3d5c243b2012-11-30 00:26:012749bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
2750 return true;
2751}
2752
[email protected]0634cdd42013-08-16 00:46:092753scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
[email protected]828a3932014-04-02 14:43:132754RenderWidget::CreateGraphicsContext3D() {
[email protected]ed7defa2013-03-12 21:29:592755 if (!webwidget_)
[email protected]0634cdd42013-08-16 00:46:092756 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]ebc0e1df2013-08-01 02:46:222757 if (CommandLine::ForCurrentProcess()->HasSwitch(
2758 switches::kDisableGpuCompositing))
[email protected]0634cdd42013-08-16 00:46:092759 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]96ab016c2013-10-23 00:50:292760 if (!RenderThreadImpl::current())
2761 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]4d7e46a2013-11-08 05:33:402762 CauseForGpuLaunch cause =
2763 CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
[email protected]96ab016c2013-10-23 00:50:292764 scoped_refptr<GpuChannelHost> gpu_channel_host(
[email protected]4d7e46a2013-11-08 05:33:402765 RenderThreadImpl::current()->EstablishGpuChannelSync(cause));
[email protected]96ab016c2013-10-23 00:50:292766 if (!gpu_channel_host)
2767 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]ed7defa2013-03-12 21:29:592768
[email protected]828a3932014-04-02 14:43:132769 // Explicitly disable antialiasing for the compositor. As of the time of
2770 // this writing, the only platform that supported antialiasing for the
2771 // compositor was Mac OS X, because the on-screen OpenGL context creation
2772 // code paths on Windows and Linux didn't yet have multisampling support.
2773 // Mac OS X essentially always behaves as though it's rendering offscreen.
2774 // Multisampling has a heavy cost especially on devices with relatively low
2775 // fill rate like most notebooks, and the Mac implementation would need to
2776 // be optimized to resolve directly into the IOSurface shared between the
2777 // GPU and browser processes. For these reasons and to avoid platform
2778 // disparities we explicitly disable antialiasing.
2779 blink::WebGraphicsContext3D::Attributes attributes;
2780 attributes.antialias = false;
2781 attributes.shareResources = true;
2782 attributes.noAutomaticFlushes = true;
2783 attributes.depth = false;
2784 attributes.stencil = false;
[email protected]828a3932014-04-02 14:43:132785 bool lose_context_when_out_of_memory = true;
[email protected]96ab016c2013-10-23 00:50:292786 WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits limits;
[email protected]b6eb8e332013-09-10 00:51:012787#if defined(OS_ANDROID)
2788 // If we raster too fast we become upload bound, and pending
2789 // uploads consume memory. For maximum upload throughput, we would
2790 // want to allow for upload_throughput * pipeline_time of pending
2791 // uploads, after which we are just wasting memory. Since we don't
2792 // know our upload throughput yet, this just caps our memory usage.
2793 size_t divider = 1;
2794 if (base::android::SysUtils::IsLowEndDevice())
[email protected]657be322013-09-20 08:50:032795 divider = 6;
[email protected]b6eb8e332013-09-10 00:51:012796 // For reference Nexus10 can upload 1MB in about 2.5ms.
[email protected]657be322013-09-20 08:50:032797 const double max_mb_uploaded_per_ms = 2.0 / (5 * divider);
[email protected]b6eb8e332013-09-10 00:51:012798 // Deadline to draw a frame to achieve 60 frames per second.
2799 const size_t kMillisecondsPerFrame = 16;
2800 // Assuming a two frame deep pipeline between the CPU and the GPU.
[email protected]657be322013-09-20 08:50:032801 size_t max_transfer_buffer_usage_mb =
2802 static_cast<size_t>(2 * kMillisecondsPerFrame * max_mb_uploaded_per_ms);
2803 static const size_t kBytesPerMegabyte = 1024 * 1024;
[email protected]b6eb8e332013-09-10 00:51:012804 // We keep the MappedMemoryReclaimLimit the same as the upload limit
2805 // to avoid unnecessarily stalling the compositor thread.
[email protected]96ab016c2013-10-23 00:50:292806 limits.mapped_memory_reclaim_limit =
[email protected]657be322013-09-20 08:50:032807 max_transfer_buffer_usage_mb * kBytesPerMegabyte;
[email protected]b6eb8e332013-09-10 00:51:012808#endif
[email protected]96ab016c2013-10-23 00:50:292809
[email protected]96ab016c2013-10-23 00:50:292810 scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
[email protected]828a3932014-04-02 14:43:132811 new WebGraphicsContext3DCommandBufferImpl(surface_id(),
2812 GetURLForGraphicsContext3D(),
2813 gpu_channel_host.get(),
2814 attributes,
[email protected]828a3932014-04-02 14:43:132815 lose_context_when_out_of_memory,
2816 limits,
2817 NULL));
[email protected]0634cdd42013-08-16 00:46:092818 return context.Pass();
[email protected]ed7defa2013-03-12 21:29:592819}
2820
[email protected]bffc8302014-01-23 20:52:162821void RenderWidget::RegisterSwappedOutChildFrame(RenderFrameImpl* frame) {
2822 swapped_out_frames_.AddObserver(frame);
2823}
2824
2825void RenderWidget::UnregisterSwappedOutChildFrame(RenderFrameImpl* frame) {
2826 swapped_out_frames_.RemoveObserver(frame);
2827}
2828
[email protected]e9ff79c2012-10-19 21:31:262829} // namespace content