blob: fb1c011b7c0520d5dfaf8f6aa100f226f6da108f [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,
[email protected]bb6378fe2014-04-28 21:19:44190 const gfx::Size& visible_viewport_size,
191 gfx::Rect resizer_rect,
192 bool is_fullscreen);
[email protected]b2e4c70132013-10-03 02:07:51193
194 RenderWidget* widget_;
195
[email protected]7f99fc22013-11-08 14:05:58196 // Parameters as passed by RenderWidget::EnableScreenMetricsEmulation.
[email protected]19193682014-04-03 15:01:43197 WebDeviceEmulationParams params_;
[email protected]b2e4c70132013-10-03 02:07:51198
[email protected]a179d3962013-11-12 14:44:40199 // The computed scale and offset used to fit widget into browser window.
[email protected]b2e4c70132013-10-03 02:07:51200 float scale_;
[email protected]a179d3962013-11-12 14:44:40201 gfx::Point offset_;
[email protected]b2e4c70132013-10-03 02:07:51202
[email protected]19193682014-04-03 15:01:43203 // Widget rect as passed to webwidget.
204 gfx::Rect applied_widget_rect_;
205
[email protected]b2e4c70132013-10-03 02:07:51206 // Original values to restore back after emulation ends.
207 gfx::Size original_size_;
208 gfx::Size original_physical_backing_size_;
[email protected]180ef242013-11-07 06:50:46209 blink::WebScreenInfo original_screen_info_;
[email protected]b2e4c70132013-10-03 02:07:51210 gfx::Rect original_view_screen_rect_;
211 gfx::Rect original_window_screen_rect_;
212};
213
214RenderWidget::ScreenMetricsEmulator::ScreenMetricsEmulator(
215 RenderWidget* widget,
[email protected]19193682014-04-03 15:01:43216 const WebDeviceEmulationParams& params)
[email protected]b2e4c70132013-10-03 02:07:51217 : widget_(widget),
[email protected]19193682014-04-03 15:01:43218 params_(params),
[email protected]b2e4c70132013-10-03 02:07:51219 scale_(1.f) {
220 original_size_ = widget_->size_;
221 original_physical_backing_size_ = widget_->physical_backing_size_;
222 original_screen_info_ = widget_->screen_info_;
223 original_view_screen_rect_ = widget_->view_screen_rect_;
224 original_window_screen_rect_ = widget_->window_screen_rect_;
[email protected]bb6378fe2014-04-28 21:19:44225 Apply(widget_->overdraw_bottom_height_, widget_->visible_viewport_size_,
[email protected]b2e4c70132013-10-03 02:07:51226 widget_->resizer_rect_, widget_->is_fullscreen_);
227}
228
229RenderWidget::ScreenMetricsEmulator::~ScreenMetricsEmulator() {
230 widget_->screen_info_ = original_screen_info_;
231
232 widget_->SetDeviceScaleFactor(original_screen_info_.deviceScaleFactor);
[email protected]7f99fc22013-11-08 14:05:58233 widget_->SetScreenMetricsEmulationParameters(0.f, gfx::Point(), 1.f);
[email protected]b2e4c70132013-10-03 02:07:51234 widget_->view_screen_rect_ = original_view_screen_rect_;
235 widget_->window_screen_rect_ = original_window_screen_rect_;
236 widget_->Resize(original_size_, original_physical_backing_size_,
[email protected]bb6378fe2014-04-28 21:19:44237 widget_->overdraw_bottom_height_, widget_->visible_viewport_size_,
238 widget_->resizer_rect_, widget_->is_fullscreen_, NO_RESIZE_ACK);
[email protected]b2e4c70132013-10-03 02:07:51239}
240
241void RenderWidget::ScreenMetricsEmulator::ChangeEmulationParams(
[email protected]19193682014-04-03 15:01:43242 const WebDeviceEmulationParams& params) {
243 params_ = params;
244 Reapply();
245}
246
247void RenderWidget::ScreenMetricsEmulator::Reapply() {
[email protected]bb6378fe2014-04-28 21:19:44248 Apply(widget_->overdraw_bottom_height_, widget_->visible_viewport_size_,
[email protected]b2e4c70132013-10-03 02:07:51249 widget_->resizer_rect_, widget_->is_fullscreen_);
250}
251
[email protected]19193682014-04-03 15:01:43252void RenderWidget::ScreenMetricsEmulator::Apply(
[email protected]bb6378fe2014-04-28 21:19:44253 float overdraw_bottom_height,
254 const gfx::Size& visible_viewport_size,
255 gfx::Rect resizer_rect,
256 bool is_fullscreen) {
[email protected]92d13b72014-05-09 14:42:31257 applied_widget_rect_.set_size(gfx::Size(params_.viewSize));
258 if (!applied_widget_rect_.width())
259 applied_widget_rect_.set_width(original_size_.width());
260 if (!applied_widget_rect_.height())
261 applied_widget_rect_.set_height(original_size_.height());
[email protected]19193682014-04-03 15:01:43262
263 if (params_.fitToView) {
[email protected]b2e4c70132013-10-03 02:07:51264 DCHECK(!original_size_.IsEmpty());
[email protected]4328f3c2013-11-02 02:26:23265
[email protected]4328f3c2013-11-02 02:26:23266 int width_with_gutter =
[email protected]19193682014-04-03 15:01:43267 std::max(original_size_.width() - 2 * params_.viewInsets.width, 1);
[email protected]4328f3c2013-11-02 02:26:23268 int height_with_gutter =
[email protected]19193682014-04-03 15:01:43269 std::max(original_size_.height() - 2 * params_.viewInsets.height, 1);
[email protected]b2e4c70132013-10-03 02:07:51270 float width_ratio =
[email protected]19193682014-04-03 15:01:43271 static_cast<float>(applied_widget_rect_.width()) / width_with_gutter;
[email protected]b2e4c70132013-10-03 02:07:51272 float height_ratio =
[email protected]19193682014-04-03 15:01:43273 static_cast<float>(applied_widget_rect_.height()) / height_with_gutter;
[email protected]b2e4c70132013-10-03 02:07:51274 float ratio = std::max(1.0f, std::max(width_ratio, height_ratio));
275 scale_ = 1.f / ratio;
[email protected]7f0e8fa2014-03-26 12:32:01276
277 // Center emulated view inside available view space.
[email protected]19193682014-04-03 15:01:43278 offset_.set_x(
279 (original_size_.width() - scale_ * applied_widget_rect_.width()) / 2);
[email protected]7f0e8fa2014-03-26 12:32:01280 offset_.set_y(
[email protected]19193682014-04-03 15:01:43281 (original_size_.height() - scale_ * applied_widget_rect_.height()) / 2);
[email protected]b2e4c70132013-10-03 02:07:51282 } else {
283 scale_ = 1.f;
[email protected]7f0e8fa2014-03-26 12:32:01284 offset_.SetPoint(0, 0);
285 }
[email protected]7f0e8fa2014-03-26 12:32:01286
[email protected]19193682014-04-03 15:01:43287 if (params_.screenPosition == WebDeviceEmulationParams::Desktop) {
288 applied_widget_rect_.set_origin(original_view_screen_rect_.origin());
[email protected]7f0e8fa2014-03-26 12:32:01289 widget_->screen_info_.rect = original_screen_info_.rect;
290 widget_->screen_info_.availableRect = original_screen_info_.availableRect;
291 widget_->window_screen_rect_ = original_window_screen_rect_;
292 } else {
[email protected]19193682014-04-03 15:01:43293 applied_widget_rect_.set_origin(gfx::Point(0, 0));
294 widget_->screen_info_.rect = applied_widget_rect_;
295 widget_->screen_info_.availableRect = applied_widget_rect_;
296 widget_->window_screen_rect_ = applied_widget_rect_;
[email protected]7f0e8fa2014-03-26 12:32:01297 }
[email protected]a179d3962013-11-12 14:44:40298
[email protected]19193682014-04-03 15:01:43299 float applied_device_scale_factor = params_.deviceScaleFactor ?
300 params_.deviceScaleFactor : original_screen_info_.deviceScaleFactor;
[email protected]7f0e8fa2014-03-26 12:32:01301 widget_->screen_info_.deviceScaleFactor = applied_device_scale_factor;
[email protected]b2e4c70132013-10-03 02:07:51302
[email protected]7f99fc22013-11-08 14:05:58303 // Pass three emulation parameters to the blink side:
[email protected]b2e4c70132013-10-03 02:07:51304 // - we keep the real device scale factor in compositor to produce sharp image
305 // even when emulating different scale factor;
[email protected]7f99fc22013-11-08 14:05:58306 // - in order to fit into view, WebView applies offset and scale to the
[email protected]b2e4c70132013-10-03 02:07:51307 // root layer.
308 widget_->SetScreenMetricsEmulationParameters(
[email protected]a179d3962013-11-12 14:44:40309 original_screen_info_.deviceScaleFactor, offset_, scale_);
[email protected]b2e4c70132013-10-03 02:07:51310
[email protected]7f0e8fa2014-03-26 12:32:01311 widget_->SetDeviceScaleFactor(applied_device_scale_factor);
[email protected]19193682014-04-03 15:01:43312 widget_->view_screen_rect_ = applied_widget_rect_;
[email protected]b2e4c70132013-10-03 02:07:51313
314 gfx::Size physical_backing_size = gfx::ToCeiledSize(gfx::ScaleSize(
315 original_size_, original_screen_info_.deviceScaleFactor));
[email protected]19193682014-04-03 15:01:43316 widget_->Resize(applied_widget_rect_.size(), physical_backing_size,
[email protected]bb6378fe2014-04-28 21:19:44317 overdraw_bottom_height, visible_viewport_size, resizer_rect,
318 is_fullscreen, NO_RESIZE_ACK);
[email protected]b2e4c70132013-10-03 02:07:51319}
320
321void RenderWidget::ScreenMetricsEmulator::OnResizeMessage(
322 const ViewMsg_Resize_Params& params) {
323 bool need_ack = params.new_size != original_size_ &&
324 !params.new_size.IsEmpty() && !params.physical_backing_size.IsEmpty();
325 original_size_ = params.new_size;
326 original_physical_backing_size_ = params.physical_backing_size;
327 original_screen_info_ = params.screen_info;
[email protected]bb6378fe2014-04-28 21:19:44328 Apply(params.overdraw_bottom_height, params.visible_viewport_size,
329 params.resizer_rect, params.is_fullscreen);
[email protected]b2e4c70132013-10-03 02:07:51330
331 if (need_ack) {
332 widget_->set_next_paint_is_resize_ack();
333 if (widget_->compositor_)
334 widget_->compositor_->SetNeedsRedrawRect(gfx::Rect(widget_->size_));
335 }
336}
337
338void RenderWidget::ScreenMetricsEmulator::OnUpdateScreenRectsMessage(
339 const gfx::Rect& view_screen_rect,
340 const gfx::Rect& window_screen_rect) {
341 original_view_screen_rect_ = view_screen_rect;
342 original_window_screen_rect_ = window_screen_rect;
[email protected]19193682014-04-03 15:01:43343 if (params_.screenPosition == WebDeviceEmulationParams::Desktop)
344 Reapply();
[email protected]b2e4c70132013-10-03 02:07:51345}
346
347void RenderWidget::ScreenMetricsEmulator::OnShowContextMenu(
348 ContextMenuParams* params) {
349 params->x *= scale_;
[email protected]a179d3962013-11-12 14:44:40350 params->x += offset_.x();
[email protected]b2e4c70132013-10-03 02:07:51351 params->y *= scale_;
[email protected]a179d3962013-11-12 14:44:40352 params->y += offset_.y();
[email protected]b2e4c70132013-10-03 02:07:51353}
354
355// RenderWidget ---------------------------------------------------------------
356
[email protected]180ef242013-11-07 06:50:46357RenderWidget::RenderWidget(blink::WebPopupType popup_type,
358 const blink::WebScreenInfo& screen_info,
[email protected]1ac10dca2013-08-20 20:47:04359 bool swapped_out,
[email protected]7912e822014-04-16 02:37:03360 bool hidden,
361 bool never_visible)
initial.commit09911bf2008-07-26 23:55:29362 : routing_id_(MSG_ROUTING_NONE),
[email protected]9f4f3322012-01-18 22:29:56363 surface_id_(0),
[email protected]c5b3b5e2009-02-13 06:41:11364 webwidget_(NULL),
initial.commit09911bf2008-07-26 23:55:29365 opener_id_(MSG_ROUTING_NONE),
[email protected]fc4404d2012-11-07 19:53:30366 init_complete_(false),
[email protected]d9083762013-03-24 01:36:40367 overdraw_bottom_height_(0.f),
initial.commit09911bf2008-07-26 23:55:29368 next_paint_flags_(0),
[email protected]847a2582013-03-09 02:29:51369 auto_resize_mode_(false),
[email protected]ea3ee0a2012-05-15 03:43:09370 need_update_rect_for_auto_resize_(false),
initial.commit09911bf2008-07-26 23:55:29371 did_show_(false),
[email protected]1ac10dca2013-08-20 20:47:04372 is_hidden_(hidden),
[email protected]7912e822014-04-16 02:37:03373 never_visible_(never_visible),
[email protected]ee41e7d22011-10-14 19:34:09374 is_fullscreen_(false),
initial.commit09911bf2008-07-26 23:55:29375 has_focus_(false),
[email protected]5dd768212009-08-13 23:34:49376 handling_input_event_(false),
[email protected]e8f775f2013-02-14 21:00:50377 handling_ime_event_(false),
[email protected]5d0bbdfa92013-12-10 00:35:51378 handling_touchstart_event_(false),
[email protected]661eb9d2009-02-03 02:11:48379 closing_(false),
[email protected]14392a52012-05-02 20:28:44380 is_swapped_out_(swapped_out),
[email protected]fa7b1dc2010-06-23 17:53:04381 input_method_is_active_(false),
[email protected]ad26ef42011-06-17 07:59:45382 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
[email protected]b256eca2013-07-11 10:57:40383 text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
[email protected]86ba5fcb2013-09-04 00:36:53384 can_compose_inline_(true),
[email protected]3e2b375b2010-04-07 17:03:12385 popup_type_(popup_type),
[email protected]867125a02009-12-10 06:01:48386 pending_window_rect_count_(0),
[email protected]b68a0e52011-12-08 15:11:12387 suppress_next_char_events_(false),
[email protected]5f8b1022011-01-21 23:34:50388 is_accelerated_compositing_active_(false),
[email protected]842f10652012-06-06 01:54:04389 screen_info_(screen_info),
[email protected]3d779472012-11-15 20:49:52390 device_scale_factor_(screen_info_.deviceScaleFactor),
[email protected]ed7defa2013-03-12 21:29:59391 is_threaded_compositing_enabled_(false),
[email protected]53b4cc12013-07-18 23:02:30392 next_output_surface_id_(0),
[email protected]0d1ebed12013-08-05 22:01:13393#if defined(OS_ANDROID)
[email protected]90f24152014-04-09 12:41:36394 text_field_is_dirty_(false),
[email protected]0d1ebed12013-08-05 22:01:13395 outstanding_ime_acks_(0),
[email protected]a4f0d882014-05-01 23:48:10396 body_background_color_(SK_ColorWHITE),
[email protected]0d1ebed12013-08-05 22:01:13397#endif
[email protected]70b73b2c2014-05-01 04:31:39398#if defined(OS_MACOSX)
399 cached_has_main_frame_horizontal_scrollbar_(false),
400 cached_has_main_frame_vertical_scrollbar_(false),
401#endif
[email protected]b2e4c70132013-10-03 02:07:51402 popup_origin_scale_for_emulation_(0.f),
[email protected]a09d53ce2014-01-31 00:46:42403 resizing_mode_selector_(new ResizingModeSelector()),
404 context_menu_source_type_(ui::MENU_SOURCE_MOUSE) {
[email protected]8b3f0eb2012-05-03 19:15:05405 if (!swapped_out)
406 RenderProcess::current()->AddRefProcess();
[email protected]380244092011-10-07 17:26:27407 DCHECK(RenderThread::Get());
[email protected]cb6430932012-10-31 00:53:36408 is_threaded_compositing_enabled_ =
409 CommandLine::ForCurrentProcess()->HasSwitch(
410 switches::kEnableThreadedCompositing);
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]bffc8302014-01-23 20:52:16415
[email protected]992db4c2011-05-12 15:37:15416 // If we are swapped out, we have released already.
[email protected]d2e2f9ee2013-08-21 11:02:02417 if (!is_swapped_out_ && RenderProcess::current())
[email protected]992db4c2011-05-12 15:37:15418 RenderProcess::current()->ReleaseProcess();
initial.commit09911bf2008-07-26 23:55:29419}
420
[email protected]484955942010-08-19 16:13:18421// static
[email protected]8085dbc82008-09-26 22:53:44422RenderWidget* RenderWidget::Create(int32 opener_id,
[email protected]180ef242013-11-07 06:50:46423 blink::WebPopupType popup_type,
424 const blink::WebScreenInfo& screen_info) {
initial.commit09911bf2008-07-26 23:55:29425 DCHECK(opener_id != MSG_ROUTING_NONE);
[email protected]6fd35b72012-03-01 19:46:41426 scoped_refptr<RenderWidget> widget(
[email protected]7912e822014-04-16 02:37:03427 new RenderWidget(popup_type, screen_info, false, false, false));
[email protected]a635f942012-12-07 10:34:29428 if (widget->Init(opener_id)) { // adds reference on success.
[email protected]fc72bb12013-06-02 21:13:46429 return widget.get();
[email protected]a635f942012-12-07 10:34:29430 }
431 return NULL;
initial.commit09911bf2008-07-26 23:55:29432}
433
[email protected]484955942010-08-19 16:13:18434// static
435WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) {
436 switch (render_widget->popup_type_) {
[email protected]180ef242013-11-07 06:50:46437 case blink::WebPopupTypeNone: // Nothing to create.
[email protected]484955942010-08-19 16:13:18438 break;
[email protected]180ef242013-11-07 06:50:46439 case blink::WebPopupTypeSelect:
440 case blink::WebPopupTypeSuggestion:
[email protected]484955942010-08-19 16:13:18441 return WebPopupMenu::create(render_widget);
[email protected]180ef242013-11-07 06:50:46442 case blink::WebPopupTypePage:
[email protected]a7547fb2012-03-08 04:43:44443 return WebPagePopup::create(render_widget);
[email protected]484955942010-08-19 16:13:18444 default:
445 NOTREACHED();
446 }
447 return NULL;
448}
449
[email protected]a635f942012-12-07 10:34:29450bool RenderWidget::Init(int32 opener_id) {
451 return DoInit(opener_id,
452 RenderWidget::CreateWebWidget(this),
453 new ViewHostMsg_CreateWidget(opener_id, popup_type_,
454 &routing_id_, &surface_id_));
[email protected]484955942010-08-19 16:13:18455}
456
[email protected]a635f942012-12-07 10:34:29457bool RenderWidget::DoInit(int32 opener_id,
[email protected]6a8ddba52010-09-05 04:38:06458 WebWidget* web_widget,
[email protected]484955942010-08-19 16:13:18459 IPC::SyncMessage* create_widget_message) {
initial.commit09911bf2008-07-26 23:55:29460 DCHECK(!webwidget_);
461
462 if (opener_id != MSG_ROUTING_NONE)
463 opener_id_ = opener_id;
464
[email protected]484955942010-08-19 16:13:18465 webwidget_ = web_widget;
initial.commit09911bf2008-07-26 23:55:29466
[email protected]380244092011-10-07 17:26:27467 bool result = RenderThread::Get()->Send(create_widget_message);
initial.commit09911bf2008-07-26 23:55:29468 if (result) {
[email protected]380244092011-10-07 17:26:27469 RenderThread::Get()->AddRoute(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29470 // Take a reference on behalf of the RenderThread. This will be balanced
471 // when we receive ViewMsg_Close.
472 AddRef();
[email protected]b2db9272014-01-10 17:42:00473 if (RenderThreadImpl::current()) {
474 RenderThreadImpl::current()->WidgetCreated();
475 if (is_hidden_)
476 RenderThreadImpl::current()->WidgetHidden();
477 }
[email protected]a635f942012-12-07 10:34:29478 return true;
initial.commit09911bf2008-07-26 23:55:29479 } else {
[email protected]a635f942012-12-07 10:34:29480 // The above Send can fail when the tab is closing.
481 return false;
initial.commit09911bf2008-07-26 23:55:29482 }
483}
484
[email protected]fc4404d2012-11-07 19:53:30485// This is used to complete pending inits and non-pending inits.
486void RenderWidget::CompleteInit() {
initial.commit09911bf2008-07-26 23:55:29487 DCHECK(routing_id_ != MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29488
[email protected]fc4404d2012-11-07 19:53:30489 init_complete_ = true;
[email protected]05a980d7a2012-02-07 22:16:42490
[email protected]c255c552014-04-17 21:16:33491 if (webwidget_) {
492 if (is_threaded_compositing_enabled_ || ForceCompositingModeEnabled()) {
493 webwidget_->enterForceCompositingMode(true);
494 }
[email protected]8926c602013-01-23 05:32:06495 }
[email protected]7912e822014-04-16 02:37:03496 if (compositor_)
497 StartCompositor();
initial.commit09911bf2008-07-26 23:55:29498
[email protected]6de74452009-02-25 18:04:59499 Send(new ViewHostMsg_RenderViewReady(routing_id_));
initial.commit09911bf2008-07-26 23:55:29500}
501
[email protected]992db4c2011-05-12 15:37:15502void RenderWidget::SetSwappedOut(bool is_swapped_out) {
503 // We should only toggle between states.
504 DCHECK(is_swapped_out_ != is_swapped_out);
505 is_swapped_out_ = is_swapped_out;
506
507 // If we are swapping out, we will call ReleaseProcess, allowing the process
508 // to exit if all of its RenderViews are swapped out. We wait until the
509 // WasSwappedOut call to do this, to avoid showing the sad tab.
510 // If we are swapping in, we call AddRefProcess to prevent the process from
511 // exiting.
512 if (!is_swapped_out)
513 RenderProcess::current()->AddRefProcess();
514}
515
[email protected]c8cbae72013-05-23 10:45:03516bool RenderWidget::UsingSynchronousRendererCompositor() const {
[email protected]ccc1722e2013-05-06 19:43:07517#if defined(OS_ANDROID)
[email protected]913d99a2013-05-31 07:16:07518 return SynchronousCompositorFactory::GetInstance() != NULL;
519#else
[email protected]ccc1722e2013-05-06 19:43:07520 return false;
[email protected]913d99a2013-05-31 07:16:07521#endif
[email protected]ccc1722e2013-05-06 19:43:07522}
523
[email protected]b2e4c70132013-10-03 02:07:51524void RenderWidget::EnableScreenMetricsEmulation(
[email protected]19193682014-04-03 15:01:43525 const WebDeviceEmulationParams& params) {
526 if (!screen_metrics_emulator_)
527 screen_metrics_emulator_.reset(new ScreenMetricsEmulator(this, params));
528 else
529 screen_metrics_emulator_->ChangeEmulationParams(params);
[email protected]b2e4c70132013-10-03 02:07:51530}
531
532void RenderWidget::DisableScreenMetricsEmulation() {
533 screen_metrics_emulator_.reset();
534}
535
536void RenderWidget::SetPopupOriginAdjustmentsForEmulation(
537 ScreenMetricsEmulator* emulator) {
538 popup_origin_scale_for_emulation_ = emulator->scale();
[email protected]19193682014-04-03 15:01:43539 popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
[email protected]9a2d7ee32013-12-05 12:15:49540 popup_screen_origin_for_emulation_ = gfx::Point(
541 emulator->original_screen_rect().origin().x() + emulator->offset().x(),
542 emulator->original_screen_rect().origin().y() + emulator->offset().y());
[email protected]5f75aa42014-04-01 23:00:56543 screen_info_ = emulator->original_screen_info();
544 device_scale_factor_ = screen_info_.deviceScaleFactor;
[email protected]b2e4c70132013-10-03 02:07:51545}
546
547void RenderWidget::SetScreenMetricsEmulationParameters(
[email protected]7f99fc22013-11-08 14:05:58548 float device_scale_factor,
549 const gfx::Point& root_layer_offset,
550 float root_layer_scale) {
[email protected]b2e4c70132013-10-03 02:07:51551 // This is only supported in RenderView.
552 NOTREACHED();
553}
554
[email protected]53907862014-03-25 15:42:40555#if defined(OS_MACOSX) || defined(OS_ANDROID)
[email protected]b2e4c70132013-10-03 02:07:51556void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
557 ExternalPopupMenu* popup, ScreenMetricsEmulator* emulator) {
[email protected]9a2d7ee32013-12-05 12:15:49558 popup->SetOriginScaleAndOffsetForEmulation(
559 emulator->scale(), emulator->offset());
[email protected]b2e4c70132013-10-03 02:07:51560}
[email protected]53907862014-03-25 15:42:40561#endif
[email protected]b2e4c70132013-10-03 02:07:51562
563void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
564 if (screen_metrics_emulator_)
565 screen_metrics_emulator_->OnShowContextMenu(params);
566}
567
[email protected]7d08a9352013-10-15 08:24:56568void RenderWidget::ScheduleCompositeWithForcedRedraw() {
569 if (compositor_) {
570 // Regardless of whether threaded compositing is enabled, always
571 // use this mechanism to force the compositor to redraw. However,
572 // the invalidation code path below is still needed for the
573 // non-threaded case.
574 compositor_->SetNeedsForcedRedraw();
575 }
[email protected]8b9e52b2014-01-17 16:35:31576 scheduleComposite();
[email protected]7d08a9352013-10-15 08:24:56577}
578
[email protected]a95986a82010-12-24 06:19:28579bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
580 bool handled = true;
581 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
[email protected]c084330e02013-04-27 01:08:15582 IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
[email protected]34202de2013-05-06 23:36:22583 IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
584 OnCursorVisibilityChange)
[email protected]c084330e02013-04-27 01:08:15585 IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
586 IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
[email protected]9017d7852013-11-21 17:47:35587 IPC_MESSAGE_HANDLER(InputMsg_SyntheticGestureCompleted,
588 OnSyntheticGestureCompleted)
[email protected]a95986a82010-12-24 06:19:28589 IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
590 IPC_MESSAGE_HANDLER(ViewMsg_CreatingNew_ACK, OnCreatingNewAck)
591 IPC_MESSAGE_HANDLER(ViewMsg_Resize, OnResize)
[email protected]b5913d72012-02-07 22:26:54592 IPC_MESSAGE_HANDLER(ViewMsg_ChangeResizeRect, OnChangeResizeRect)
[email protected]a95986a82010-12-24 06:19:28593 IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
[email protected]9e2e4632012-07-27 16:38:41594 IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
[email protected]992db4c2011-05-12 15:37:15595 IPC_MESSAGE_HANDLER(ViewMsg_WasSwappedOut, OnWasSwappedOut)
[email protected]a95986a82010-12-24 06:19:28596 IPC_MESSAGE_HANDLER(ViewMsg_SetInputMethodActive, OnSetInputMethodActive)
[email protected]37a241c2013-12-03 03:16:17597 IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowShown, OnCandidateWindowShown)
598 IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowUpdated,
599 OnCandidateWindowUpdated)
600 IPC_MESSAGE_HANDLER(ViewMsg_CandidateWindowHidden, OnCandidateWindowHidden)
[email protected]a95986a82010-12-24 06:19:28601 IPC_MESSAGE_HANDLER(ViewMsg_ImeSetComposition, OnImeSetComposition)
602 IPC_MESSAGE_HANDLER(ViewMsg_ImeConfirmComposition, OnImeConfirmComposition)
[email protected]3d9ec5052013-01-02 22:05:25603 IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
[email protected]a95986a82010-12-24 06:19:28604 IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
605 IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
[email protected]80ad8622012-11-07 16:33:03606 IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
[email protected]105dffb42013-02-20 03:46:21607#if defined(OS_ANDROID)
[email protected]2384b6c2013-02-28 23:58:51608 IPC_MESSAGE_HANDLER(ViewMsg_ShowImeIfNeeded, OnShowImeIfNeeded)
[email protected]0d1ebed12013-08-05 22:01:13609 IPC_MESSAGE_HANDLER(ViewMsg_ImeEventAck, OnImeEventAck)
[email protected]105dffb42013-02-20 03:46:21610#endif
[email protected]a95986a82010-12-24 06:19:28611 IPC_MESSAGE_UNHANDLED(handled = false)
612 IPC_END_MESSAGE_MAP()
613 return handled;
614}
initial.commit09911bf2008-07-26 23:55:29615
616bool RenderWidget::Send(IPC::Message* message) {
[email protected]992db4c2011-05-12 15:37:15617 // Don't send any messages after the browser has told us to close, and filter
618 // most outgoing messages while swapped out.
619 if ((is_swapped_out_ &&
[email protected]e9ff79c2012-10-19 21:31:26620 !SwappedOutMessages::CanSendWhileSwappedOut(message)) ||
[email protected]c6c921e92012-05-10 23:31:11621 closing_) {
initial.commit09911bf2008-07-26 23:55:29622 delete message;
623 return false;
624 }
625
626 // If given a messsage without a routing ID, then assign our routing ID.
627 if (message->routing_id() == MSG_ROUTING_NONE)
628 message->set_routing_id(routing_id_);
629
[email protected]380244092011-10-07 17:26:27630 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44631}
632
[email protected]61e2b3cc2012-03-02 16:13:34633void RenderWidget::Resize(const gfx::Size& new_size,
[email protected]60d47ac2013-03-01 23:42:44634 const gfx::Size& physical_backing_size,
[email protected]d9083762013-03-24 01:36:40635 float overdraw_bottom_height,
[email protected]bb6378fe2014-04-28 21:19:44636 const gfx::Size& visible_viewport_size,
[email protected]61e2b3cc2012-03-02 16:13:34637 const gfx::Rect& resizer_rect,
638 bool is_fullscreen,
639 ResizeAck resize_ack) {
[email protected]f7c1f092013-11-05 20:20:56640 if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
[email protected]1c0008842013-06-06 08:35:48641 // A resize ack shouldn't be requested if we have not ACK'd the previous
642 // one.
643 DCHECK(resize_ack != SEND_RESIZE_ACK || !next_paint_is_resize_ack());
644 DCHECK(resize_ack == SEND_RESIZE_ACK || resize_ack == NO_RESIZE_ACK);
645 }
initial.commit09911bf2008-07-26 23:55:29646
[email protected]61e2b3cc2012-03-02 16:13:34647 // Ignore this during shutdown.
648 if (!webwidget_)
649 return;
650
[email protected]d9083762013-03-24 01:36:40651 if (compositor_) {
[email protected]60d47ac2013-03-01 23:42:44652 compositor_->setViewportSize(new_size, physical_backing_size);
[email protected]d9083762013-03-24 01:36:40653 compositor_->SetOverdrawBottomHeight(overdraw_bottom_height);
654 }
[email protected]60d47ac2013-03-01 23:42:44655
[email protected]dade8992013-03-04 07:34:34656 physical_backing_size_ = physical_backing_size;
[email protected]d9083762013-03-24 01:36:40657 overdraw_bottom_height_ = overdraw_bottom_height;
[email protected]61e2b3cc2012-03-02 16:13:34658 resizer_rect_ = resizer_rect;
659
660 // NOTE: We may have entered fullscreen mode without changing our size.
661 bool fullscreen_change = is_fullscreen_ != is_fullscreen;
662 if (fullscreen_change)
663 WillToggleFullscreen();
664 is_fullscreen_ = is_fullscreen;
665
666 if (size_ != new_size) {
[email protected]61e2b3cc2012-03-02 16:13:34667 size_ = new_size;
668
[email protected]61e2b3cc2012-03-02 16:13:34669 // When resizing, we want to wait to paint before ACK'ing the resize. This
670 // ensures that we only resize as fast as we can paint. We only need to
671 // send an ACK if we are resized to a non-empty rect.
672 webwidget_->resize(new_size);
[email protected]5b45ad42013-10-25 00:42:04673 } else if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]632c4382013-05-15 08:58:45674 resize_ack = NO_RESIZE_ACK;
675 }
676
[email protected]bb6378fe2014-04-28 21:19:44677 webwidget()->resizePinchViewport(gfx::Size(
678 visible_viewport_size.width(),
679 visible_viewport_size.height()));
680
[email protected]632c4382013-05-15 08:58:45681 if (new_size.IsEmpty() || physical_backing_size.IsEmpty()) {
682 // For empty size or empty physical_backing_size, there is no next paint
683 // (along with which to send the ack) until they are set to non-empty.
[email protected]ff475a322012-03-14 00:05:35684 resize_ack = NO_RESIZE_ACK;
[email protected]61e2b3cc2012-03-02 16:13:34685 }
686
[email protected]20fbfc22013-05-08 20:50:58687 // Send the Resize_ACK flag once we paint again if requested.
[email protected]632c4382013-05-15 08:58:45688 if (resize_ack == SEND_RESIZE_ACK)
[email protected]20fbfc22013-05-08 20:50:58689 set_next_paint_is_resize_ack();
690
[email protected]61e2b3cc2012-03-02 16:13:34691 if (fullscreen_change)
692 DidToggleFullscreen();
693
694 // If a resize ack is requested and it isn't set-up, then no more resizes will
695 // come in and in general things will go wrong.
[email protected]632c4382013-05-15 08:58:45696 DCHECK(resize_ack != SEND_RESIZE_ACK || next_paint_is_resize_ack());
initial.commit09911bf2008-07-26 23:55:29697}
698
[email protected]92650162013-10-30 03:31:02699void RenderWidget::ResizeSynchronously(const gfx::Rect& new_position) {
700 Resize(new_position.size(), new_position.size(), overdraw_bottom_height_,
[email protected]bb6378fe2014-04-28 21:19:44701 visible_viewport_size_, gfx::Rect(), is_fullscreen_, NO_RESIZE_ACK);
[email protected]92650162013-10-30 03:31:02702 view_screen_rect_ = new_position;
703 window_screen_rect_ = new_position;
704 if (!did_show_)
705 initial_pos_ = new_position;
706}
707
initial.commit09911bf2008-07-26 23:55:29708void RenderWidget::OnClose() {
709 if (closing_)
710 return;
711 closing_ = true;
712
713 // Browser correspondence is no longer needed at this point.
[email protected]bee16aab2009-08-26 15:55:03714 if (routing_id_ != MSG_ROUTING_NONE) {
[email protected]b2db9272014-01-10 17:42:00715 if (RenderThreadImpl::current())
716 RenderThreadImpl::current()->WidgetDestroyed();
[email protected]380244092011-10-07 17:26:27717 RenderThread::Get()->RemoveRoute(routing_id_);
[email protected]bee16aab2009-08-26 15:55:03718 SetHidden(false);
719 }
initial.commit09911bf2008-07-26 23:55:29720
initial.commit09911bf2008-07-26 23:55:29721 // If there is a Send call on the stack, then it could be dangerous to close
[email protected]d3fc25652009-02-24 22:31:25722 // now. Post a task that only gets invoked when there are no nested message
723 // loops.
[email protected]dd32b1272013-05-04 14:17:11724 base::MessageLoop::current()->PostNonNestableTask(
[email protected]3a5a7822011-12-23 18:27:29725 FROM_HERE, base::Bind(&RenderWidget::Close, this));
[email protected]d3fc25652009-02-24 22:31:25726
727 // Balances the AddRef taken when we called AddRoute.
728 Release();
initial.commit09911bf2008-07-26 23:55:29729}
730
[email protected]61e2b3cc2012-03-02 16:13:34731// Got a response from the browser after the renderer decided to create a new
732// view.
[email protected]fc4404d2012-11-07 19:53:30733void RenderWidget::OnCreatingNewAck() {
[email protected]61e2b3cc2012-03-02 16:13:34734 DCHECK(routing_id_ != MSG_ROUTING_NONE);
735
[email protected]fc4404d2012-11-07 19:53:30736 CompleteInit();
[email protected]61e2b3cc2012-03-02 16:13:34737}
738
[email protected]0fdd5012013-05-29 08:05:56739void RenderWidget::OnResize(const ViewMsg_Resize_Params& params) {
[email protected]5b45ad42013-10-25 00:42:04740 if (resizing_mode_selector_->ShouldAbortOnResize(this, params))
[email protected]03e88672013-10-22 21:31:32741 return;
742
[email protected]b2e4c70132013-10-03 02:07:51743 if (screen_metrics_emulator_) {
744 screen_metrics_emulator_->OnResizeMessage(params);
745 return;
746 }
747
[email protected]fcdc5642014-05-09 14:32:24748 bool orientation_changed =
749 screen_info_.orientationAngle != params.screen_info.orientationAngle;
750
[email protected]0fdd5012013-05-29 08:05:56751 screen_info_ = params.screen_info;
752 SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
753 Resize(params.new_size, params.physical_backing_size,
[email protected]bb6378fe2014-04-28 21:19:44754 params.overdraw_bottom_height, params.visible_viewport_size,
755 params.resizer_rect, params.is_fullscreen, SEND_RESIZE_ACK);
[email protected]fcdc5642014-05-09 14:32:24756
757 if (orientation_changed)
758 OnOrientationChange();
initial.commit09911bf2008-07-26 23:55:29759}
760
[email protected]b5913d72012-02-07 22:26:54761void RenderWidget::OnChangeResizeRect(const gfx::Rect& resizer_rect) {
[email protected]721e2302014-04-30 23:42:01762 if (resizer_rect_ == resizer_rect)
763 return;
764 resizer_rect_ = resizer_rect;
765 if (webwidget_)
766 webwidget_->didChangeWindowResizerRect();
[email protected]b5913d72012-02-07 22:26:54767}
768
initial.commit09911bf2008-07-26 23:55:29769void RenderWidget::OnWasHidden() {
[email protected]9c3085f2011-06-09 02:10:31770 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
initial.commit09911bf2008-07-26 23:55:29771 // Go into a mode where we stop generating paint and scrolling events.
[email protected]bee16aab2009-08-26 15:55:03772 SetHidden(true);
initial.commit09911bf2008-07-26 23:55:29773}
774
[email protected]9e2e4632012-07-27 16:38:41775void RenderWidget::OnWasShown(bool needs_repainting) {
776 TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
initial.commit09911bf2008-07-26 23:55:29777 // During shutdown we can just ignore this message.
778 if (!webwidget_)
779 return;
780
781 // See OnWasHidden
[email protected]bee16aab2009-08-26 15:55:03782 SetHidden(false);
initial.commit09911bf2008-07-26 23:55:29783
[email protected]8a23afb32014-04-30 22:40:23784 if (!needs_repainting)
initial.commit09911bf2008-07-26 23:55:29785 return;
initial.commit09911bf2008-07-26 23:55:29786
787 // Generate a full repaint.
[email protected]a79d8a632010-11-18 22:35:56788 if (!is_accelerated_compositing_active_) {
[email protected]f98d7e3c2010-09-13 22:30:46789 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
790 } else {
[email protected]8b9e52b2014-01-17 16:35:31791 if (compositor_)
792 compositor_->SetNeedsForcedRedraw();
793 scheduleComposite();
[email protected]f98d7e3c2010-09-13 22:30:46794 }
initial.commit09911bf2008-07-26 23:55:29795}
796
[email protected]992db4c2011-05-12 15:37:15797void RenderWidget::OnWasSwappedOut() {
798 // If we have been swapped out and no one else is using this process,
799 // it's safe to exit now. If we get swapped back in, we will call
800 // AddRefProcess in SetSwappedOut.
801 if (is_swapped_out_)
802 RenderProcess::current()->ReleaseProcess();
803}
804
[email protected]53d3f302009-12-21 04:42:05805void RenderWidget::OnRequestMoveAck() {
806 DCHECK(pending_window_rect_count_);
807 pending_window_rect_count_--;
808}
809
[email protected]ed7defa2013-03-12 21:29:59810GURL RenderWidget::GetURLForGraphicsContext3D() {
811 return GURL();
[email protected]65225772011-05-12 21:10:24812}
813
[email protected]479b0172012-10-29 19:27:09814bool RenderWidget::ForceCompositingModeEnabled() {
815 return false;
816}
817
[email protected]ebc0e1df2013-08-01 02:46:22818scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(bool fallback) {
[email protected]7912e822014-04-16 02:37:03819 // For widgets that are never visible, we don't start the compositor, so we
820 // never get a request for a cc::OutputSurface.
821 DCHECK(!never_visible_);
[email protected]a1811b8912013-05-09 15:35:19822
823#if defined(OS_ANDROID)
[email protected]b6eb8e332013-09-10 00:51:01824 if (SynchronousCompositorFactory* factory =
825 SynchronousCompositorFactory::GetInstance()) {
[email protected]913d99a2013-05-31 07:16:07826 return factory->CreateOutputSurface(routing_id());
[email protected]a1811b8912013-05-09 15:35:19827 }
828#endif
829
[email protected]b6eb8e332013-09-10 00:51:01830 const CommandLine& command_line = *CommandLine::ForCurrentProcess();
[email protected]e09994a2014-03-26 19:59:33831 bool use_software = fallback;
832 if (command_line.HasSwitch(switches::kDisableGpuCompositing))
833 use_software = true;
834
[email protected]0634cdd42013-08-16 00:46:09835 scoped_refptr<ContextProviderCommandBuffer> context_provider;
[email protected]e09994a2014-03-26 19:59:33836 if (!use_software) {
[email protected]0634cdd42013-08-16 00:46:09837 context_provider = ContextProviderCommandBuffer::Create(
[email protected]828a3932014-04-02 14:43:13838 CreateGraphicsContext3D(), "RenderCompositor");
[email protected]e09994a2014-03-26 19:59:33839 if (!context_provider.get()) {
840 // Cause the compositor to wait and try again.
841 return scoped_ptr<cc::OutputSurface>();
842 }
[email protected]0634cdd42013-08-16 00:46:09843 }
[email protected]ebc0e1df2013-08-01 02:46:22844
[email protected]b6eb8e332013-09-10 00:51:01845 uint32 output_surface_id = next_output_surface_id_++;
[email protected]50cf1992014-03-29 00:06:00846 if (command_line.HasSwitch(switches::kEnableDelegatedRenderer)) {
[email protected]65a33ce2014-03-25 22:37:09847 DCHECK(is_threaded_compositing_enabled_);
848 return scoped_ptr<cc::OutputSurface>(
849 new DelegatedCompositorOutputSurface(
850 routing_id(),
851 output_surface_id,
852 context_provider));
853 }
[email protected]0634cdd42013-08-16 00:46:09854 if (!context_provider.get()) {
[email protected]0634cdd42013-08-16 00:46:09855 scoped_ptr<cc::SoftwareOutputDevice> software_device(
856 new CompositorSoftwareOutputDevice());
857
858 return scoped_ptr<cc::OutputSurface>(new CompositorOutputSurface(
859 routing_id(),
860 output_surface_id,
861 NULL,
862 software_device.Pass(),
863 true));
[email protected]ebc0e1df2013-08-01 02:46:22864 }
[email protected]ed7defa2013-03-12 21:29:59865
[email protected]36e5ff12013-06-11 12:19:29866 if (command_line.HasSwitch(cc::switches::kCompositeToMailbox)) {
[email protected]758efb02014-04-05 07:53:45867 // Composite-to-mailbox is currently used for layout tests in order to cause
868 // them to draw inside in the renderer to do the readback there. This should
869 // no longer be the case when crbug.com/311404 is fixed.
870 DCHECK(is_threaded_compositing_enabled_ ||
871 RenderThreadImpl::current()->layout_test_mode());
[email protected]186f09602013-09-24 07:13:16872 cc::ResourceFormat format = cc::RGBA_8888;
873#if defined(OS_ANDROID)
874 if (base::android::SysUtils::IsLowEndDevice())
875 format = cc::RGB_565;
876#endif
[email protected]36e5ff12013-06-11 12:19:29877 return scoped_ptr<cc::OutputSurface>(
[email protected]0634cdd42013-08-16 00:46:09878 new MailboxOutputSurface(
879 routing_id(),
880 output_surface_id,
881 context_provider,
[email protected]186f09602013-09-24 07:13:16882 scoped_ptr<cc::SoftwareOutputDevice>(),
883 format));
[email protected]36e5ff12013-06-11 12:19:29884 }
[email protected]0634cdd42013-08-16 00:46:09885 bool use_swap_compositor_frame_message = false;
[email protected]36e5ff12013-06-11 12:19:29886 return scoped_ptr<cc::OutputSurface>(
[email protected]0634cdd42013-08-16 00:46:09887 new CompositorOutputSurface(
888 routing_id(),
889 output_surface_id,
890 context_provider,
891 scoped_ptr<cc::SoftwareOutputDevice>(),
892 use_swap_compositor_frame_message));
[email protected]ba91a792013-02-06 09:48:28893}
894
[email protected]4d7e46a2013-11-08 05:33:40895void RenderWidget::OnSwapBuffersAborted() {
[email protected]65225772011-05-12 21:10:24896 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
[email protected]65225772011-05-12 21:10:24897 // Schedule another frame so the compositor learns about it.
[email protected]8b9e52b2014-01-17 16:35:31898 scheduleComposite();
[email protected]65225772011-05-12 21:10:24899}
900
[email protected]4d7e46a2013-11-08 05:33:40901void RenderWidget::OnSwapBuffersPosted() {
[email protected]37a6f302011-07-11 23:43:08902 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
[email protected]37a6f302011-07-11 23:43:08903}
904
[email protected]4d7e46a2013-11-08 05:33:40905void RenderWidget::OnSwapBuffersComplete() {
[email protected]65225772011-05-12 21:10:24906 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersComplete");
[email protected]29ed96a2012-02-04 18:12:16907
[email protected]404939f2012-06-01 04:06:18908 // Notify subclasses that composited rendering was flushed to the screen.
[email protected]29ed96a2012-02-04 18:12:16909 DidFlushPaint();
initial.commit09911bf2008-07-26 23:55:29910}
911
[email protected]180ef242013-11-07 06:50:46912void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event,
[email protected]205294b2014-03-18 20:48:35913 const ui::LatencyInfo& latency_info,
[email protected]0dea1652012-12-14 00:09:09914 bool is_keyboard_shortcut) {
[email protected]5dd768212009-08-13 23:34:49915 handling_input_event_ = true;
[email protected]0dea1652012-12-14 00:09:09916 if (!input_event) {
[email protected]5dd768212009-08-13 23:34:49917 handling_input_event_ = false;
initial.commit09911bf2008-07-26 23:55:29918 return;
[email protected]5dd768212009-08-13 23:34:49919 }
initial.commit09911bf2008-07-26 23:55:29920
[email protected]fd847792013-10-24 17:12:35921 base::TimeTicks start_time;
922 if (base::TimeTicks::IsHighResNowFastAndReliable())
923 start_time = base::TimeTicks::HighResNow();
924
[email protected]8e299aa2013-10-16 18:17:44925 const char* const event_name =
926 WebInputEventTraits::GetName(input_event->type);
[email protected]b4841e1c2013-05-16 22:30:10927 TRACE_EVENT1("renderer", "RenderWidget::OnHandleInputEvent",
928 "event", event_name);
[email protected]b2e92592014-01-10 15:47:15929 TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("blink.HandleInputEvent");
[email protected]15ba6dea2014-04-02 01:44:13930 TRACE_EVENT_FLOW_STEP0(
931 "input",
932 "LatencyInfo.Flow",
933 TRACE_ID_DONT_MANGLE(latency_info.trace_id),
934 "HanldeInputEventMain");
[email protected]b4841e1c2013-05-16 22:30:10935
[email protected]6be422b2013-12-08 06:47:31936 scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor;
[email protected]205294b2014-03-18 20:48:35937 ui::LatencyInfo swap_latency_info(latency_info);
[email protected]6be422b2013-12-08 06:47:31938 if (compositor_) {
939 latency_info_swap_promise_monitor =
[email protected]205294b2014-03-18 20:48:35940 compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info)
941 .Pass();
[email protected]6be422b2013-12-08 06:47:31942 }
[email protected]c2eaa8f2013-05-10 02:41:55943
[email protected]6bb8e8a2014-04-04 20:02:44944 if (base::TimeTicks::IsHighResNowFastAndReliable()) {
945 // If we don't have a high res timer, these metrics won't be accurate enough
946 // to be worth collecting. Note that this does introduce some sampling bias.
[email protected]6a4d7f62013-01-07 21:32:13947
[email protected]6bb8e8a2014-04-04 20:02:44948 base::TimeDelta now = base::TimeDelta::FromInternalValue(
949 base::TimeTicks::HighResNow().ToInternalValue());
950
951 int64 delta =
952 static_cast<int64>((now.InSecondsF() - input_event->timeStampSeconds) *
953 base::Time::kMicrosecondsPerSecond);
954
955 UMA_HISTOGRAM_CUSTOM_COUNTS(
956 "Event.AggregatedLatency.Renderer2", delta, 1, 10000000, 100);
957 base::HistogramBase* counter_for_type = base::Histogram::FactoryGet(
958 base::StringPrintf("Event.Latency.Renderer2.%s", event_name),
959 1,
960 10000000,
961 100,
962 base::HistogramBase::kUmaTargetedHistogramFlag);
963 counter_for_type->Add(delta);
964 }
[email protected]6a4d7f62013-01-07 21:32:13965
[email protected]67bfb83f2011-09-22 03:36:37966 bool prevent_default = false;
967 if (WebInputEvent::isMouseEventType(input_event->type)) {
[email protected]936c6f52011-12-13 01:35:26968 const WebMouseEvent& mouse_event =
969 *static_cast<const WebMouseEvent*>(input_event);
970 TRACE_EVENT2("renderer", "HandleMouseMove",
971 "x", mouse_event.x, "y", mouse_event.y);
[email protected]a09d53ce2014-01-31 00:46:42972 context_menu_source_type_ = ui::MENU_SOURCE_MOUSE;
[email protected]936c6f52011-12-13 01:35:26973 prevent_default = WillHandleMouseEvent(mouse_event);
[email protected]67bfb83f2011-09-22 03:36:37974 }
975
[email protected]cefe9b152014-03-27 18:16:15976 if (WebInputEvent::isKeyboardEventType(input_event->type)) {
[email protected]a09d53ce2014-01-31 00:46:42977 context_menu_source_type_ = ui::MENU_SOURCE_KEYBOARD;
[email protected]cefe9b152014-03-27 18:16:15978#if defined(OS_ANDROID)
979 // The DPAD_CENTER key on Android has a dual semantic: (1) in the general
980 // case it should behave like a select key (i.e. causing a click if a button
981 // is focused). However, if a text field is focused (2), its intended
982 // behavior is to just show the IME and don't propagate the key.
983 // A typical use case is a web form: the DPAD_CENTER should bring up the IME
984 // when clicked on an input text field and cause the form submit if clicked
985 // when the submit button is focused, but not vice-versa.
986 // The UI layer takes care of translating DPAD_CENTER into a RETURN key,
987 // but at this point we have to swallow the event for the scenario (2).
988 const WebKeyboardEvent& key_event =
989 *static_cast<const WebKeyboardEvent*>(input_event);
990 if (key_event.nativeKeyCode == AKEYCODE_DPAD_CENTER &&
991 GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE) {
992 OnShowImeIfNeeded();
993 prevent_default = true;
994 }
995#endif
996 }
[email protected]f56c7872013-06-18 12:31:57997
[email protected]41d86852012-11-07 12:23:24998 if (WebInputEvent::isGestureEventType(input_event->type)) {
999 const WebGestureEvent& gesture_event =
1000 *static_cast<const WebGestureEvent*>(input_event);
[email protected]a09d53ce2014-01-31 00:46:421001 context_menu_source_type_ = ui::MENU_SOURCE_TOUCH;
[email protected]41d86852012-11-07 12:23:241002 prevent_default = prevent_default || WillHandleGestureEvent(gesture_event);
1003 }
1004
[email protected]5d0bbdfa92013-12-10 00:35:511005 if (input_event->type == WebInputEvent::TouchStart)
1006 handling_touchstart_event_ = true;
1007
[email protected]67bfb83f2011-09-22 03:36:371008 bool processed = prevent_default;
[email protected]b68a0e52011-12-08 15:11:121009 if (input_event->type != WebInputEvent::Char || !suppress_next_char_events_) {
1010 suppress_next_char_events_ = false;
1011 if (!processed && webwidget_)
1012 processed = webwidget_->handleInputEvent(*input_event);
1013 }
1014
[email protected]5d0bbdfa92013-12-10 00:35:511015 handling_touchstart_event_ = false;
1016
[email protected]b68a0e52011-12-08 15:11:121017 // If this RawKeyDown event corresponds to a browser keyboard shortcut and
1018 // it's not processed by webkit, then we need to suppress the upcoming Char
1019 // events.
1020 if (!processed && is_keyboard_shortcut)
1021 suppress_next_char_events_ = true;
initial.commit09911bf2008-07-26 23:55:291022
[email protected]3d5c243b2012-11-30 00:26:011023 InputEventAckState ack_result = processed ?
1024 INPUT_EVENT_ACK_STATE_CONSUMED : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1025 if (!processed && input_event->type == WebInputEvent::TouchStart) {
1026 const WebTouchEvent& touch_event =
1027 *static_cast<const WebTouchEvent*>(input_event);
[email protected]f8ed4722013-12-03 03:27:251028 // Hit-test for all the pressed touch points. If there is a touch-handler
1029 // for any of the touch points, then the renderer should continue to receive
1030 // touch events.
1031 ack_result = INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
1032 for (size_t i = 0; i < touch_event.touchesLength; ++i) {
1033 if (touch_event.touches[i].state == WebTouchPoint::StatePressed &&
[email protected]a66e18e2014-01-29 20:58:271034 HasTouchEventHandlersAt(
[email protected]9c769d412014-03-20 18:27:391035 gfx::ToFlooredPoint(touch_event.touches[i].position))) {
[email protected]f8ed4722013-12-03 03:27:251036 ack_result = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1037 break;
1038 }
1039 }
[email protected]3d5c243b2012-11-30 00:26:011040 }
1041
[email protected]1beb0d112014-04-25 03:17:201042 // Unconsumed touchmove acks should never be throttled as they're required to
1043 // dispatch compositor-handled scroll gestures.
[email protected]fd847792013-10-24 17:12:351044 bool event_type_can_be_rate_limited =
[email protected]3391a0772012-03-28 00:32:071045 input_event->type == WebInputEvent::MouseMove ||
1046 input_event->type == WebInputEvent::MouseWheel ||
[email protected]1beb0d112014-04-25 03:17:201047 (input_event->type == WebInputEvent::TouchMove &&
1048 ack_result == INPUT_EVENT_ACK_STATE_CONSUMED);
[email protected]8926c602013-01-23 05:32:061049
[email protected]721e2302014-04-30 23:42:011050 bool frame_pending = compositor_ && compositor_->BeginMainFrameRequested();
[email protected]8926c602013-01-23 05:32:061051
[email protected]fd847792013-10-24 17:12:351052 // If we don't have a fast and accurate HighResNow, we assume the input
1053 // handlers are heavy and rate limit them.
1054 bool rate_limiting_wanted = true;
1055 if (base::TimeTicks::IsHighResNowFastAndReliable()) {
1056 base::TimeTicks end_time = base::TimeTicks::HighResNow();
1057 total_input_handling_time_this_frame_ += (end_time - start_time);
1058 rate_limiting_wanted =
1059 total_input_handling_time_this_frame_.InMicroseconds() >
1060 kInputHandlingTimeThrottlingThresholdMicroseconds;
1061 }
1062
[email protected]7f19e9d2014-05-09 15:16:291063 TRACE_EVENT_SYNTHETIC_DELAY_END("blink.HandleInputEvent");
1064
[email protected]372f52e2014-04-28 16:15:491065 if (!WebInputEventTraits::IgnoresAckDisposition(*input_event)) {
[email protected]34afe102013-12-13 17:24:551066 scoped_ptr<IPC::Message> response(
1067 new InputHostMsg_HandleInputEvent_ACK(routing_id_,
1068 input_event->type,
1069 ack_result,
[email protected]205294b2014-03-18 20:48:351070 swap_latency_info));
[email protected]34afe102013-12-13 17:24:551071 if (rate_limiting_wanted && event_type_can_be_rate_limited &&
1072 frame_pending && !is_hidden_) {
1073 // We want to rate limit the input events in this case, so we'll wait for
1074 // painting to finish before ACKing this message.
1075 TRACE_EVENT_INSTANT0("renderer",
1076 "RenderWidget::OnHandleInputEvent ack throttled",
1077 TRACE_EVENT_SCOPE_THREAD);
1078 if (pending_input_event_ack_) {
1079 // As two different kinds of events could cause us to postpone an ack
1080 // we send it now, if we have one pending. The Browser should never
1081 // send us the same kind of event we are delaying the ack for.
1082 Send(pending_input_event_ack_.release());
1083 }
1084 pending_input_event_ack_ = response.Pass();
1085 if (compositor_)
1086 compositor_->NotifyInputThrottledUntilCommit();
1087 } else {
1088 Send(response.release());
[email protected]353a34c2010-05-28 23:35:171089 }
[email protected]12fbad812009-09-01 18:21:241090 }
1091
[email protected]3306f262012-09-21 19:20:421092#if defined(OS_ANDROID)
1093 // Allow the IME to be shown when the focus changes as a consequence
1094 // of a processed touch end event.
1095 if (input_event->type == WebInputEvent::TouchEnd && processed)
[email protected]90f24152014-04-09 12:41:361096 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
[email protected]183e28d2014-01-20 18:18:021097#elif defined(USE_AURA)
1098 // Show the virtual keyboard if enabled and a user gesture triggers a focus
1099 // change.
1100 if (processed && (input_event->type == WebInputEvent::TouchEnd ||
1101 input_event->type == WebInputEvent::MouseUp))
[email protected]90f24152014-04-09 12:41:361102 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_IME);
[email protected]3306f262012-09-21 19:20:421103#endif
1104
[email protected]5dd768212009-08-13 23:34:491105 handling_input_event_ = false;
[email protected]446705872009-09-10 07:22:481106
[email protected]67bfb83f2011-09-22 03:36:371107 if (!prevent_default) {
1108 if (WebInputEvent::isKeyboardEventType(input_event->type))
1109 DidHandleKeyEvent();
1110 if (WebInputEvent::isMouseEventType(input_event->type))
1111 DidHandleMouseEvent(*(static_cast<const WebMouseEvent*>(input_event)));
[email protected]2d0f2e92011-10-03 09:02:241112 if (WebInputEvent::isTouchEventType(input_event->type))
1113 DidHandleTouchEvent(*(static_cast<const WebTouchEvent*>(input_event)));
[email protected]67bfb83f2011-09-22 03:36:371114 }
initial.commit09911bf2008-07-26 23:55:291115}
1116
[email protected]34202de2013-05-06 23:36:221117void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
1118 if (webwidget_)
1119 webwidget_->setCursorVisibilityState(is_visible);
1120}
1121
initial.commit09911bf2008-07-26 23:55:291122void RenderWidget::OnMouseCaptureLost() {
1123 if (webwidget_)
[email protected]4873c7d2009-07-16 06:36:281124 webwidget_->mouseCaptureLost();
initial.commit09911bf2008-07-26 23:55:291125}
1126
1127void RenderWidget::OnSetFocus(bool enable) {
1128 has_focus_ = enable;
[email protected]9d166af2010-03-02 22:04:331129 if (webwidget_)
1130 webwidget_->setFocus(enable);
initial.commit09911bf2008-07-26 23:55:291131}
1132
1133void RenderWidget::ClearFocus() {
1134 // We may have got the focus from the browser before this gets processed, in
1135 // which case we do not want to unfocus ourself.
1136 if (!has_focus_ && webwidget_)
[email protected]4873c7d2009-07-16 06:36:281137 webwidget_->setFocus(false);
initial.commit09911bf2008-07-26 23:55:291138}
1139
[email protected]fd847792013-10-24 17:12:351140void RenderWidget::FlushPendingInputEventAck() {
[email protected]d8a8ecb2013-10-23 18:03:071141 if (pending_input_event_ack_)
1142 Send(pending_input_event_ack_.release());
[email protected]fd847792013-10-24 17:12:351143 total_input_handling_time_this_frame_ = base::TimeDelta();
1144}
1145
initial.commit09911bf2008-07-26 23:55:291146///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461147// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291148
[email protected]244ac1892011-12-02 17:04:471149void RenderWidget::didAutoResize(const WebSize& new_size) {
[email protected]ea3ee0a2012-05-15 03:43:091150 if (size_.width() != new_size.width || size_.height() != new_size.height) {
[email protected]eac2b362013-05-22 07:01:451151 size_ = new_size;
[email protected]20fbfc22013-05-08 20:50:581152
[email protected]5b45ad42013-10-25 00:42:041153 if (resizing_mode_selector_->is_synchronous_mode()) {
[email protected]eac2b362013-05-22 07:01:451154 WebRect new_pos(rootWindowRect().x,
1155 rootWindowRect().y,
1156 new_size.width,
1157 new_size.height);
1158 view_screen_rect_ = new_pos;
1159 window_screen_rect_ = new_pos;
[email protected]8be1c582013-03-06 00:55:031160 }
[email protected]20fbfc22013-05-08 20:50:581161
[email protected]eac2b362013-05-22 07:01:451162 AutoResizeCompositor();
[email protected]20fbfc22013-05-08 20:50:581163
[email protected]5b45ad42013-10-25 00:42:041164 if (!resizing_mode_selector_->is_synchronous_mode())
[email protected]20fbfc22013-05-08 20:50:581165 need_update_rect_for_auto_resize_ = true;
[email protected]ea3ee0a2012-05-15 03:43:091166 }
[email protected]244ac1892011-12-02 17:04:471167}
1168
[email protected]3a1c8a8032013-03-18 22:35:321169void RenderWidget::AutoResizeCompositor() {
[email protected]97e1bf72013-03-06 14:06:051170 physical_backing_size_ = gfx::ToCeiledSize(gfx::ScaleSize(size_,
1171 device_scale_factor_));
1172 if (compositor_)
1173 compositor_->setViewportSize(size_, physical_backing_size_);
1174}
1175
[email protected]c0b0bd12014-03-13 00:39:581176void RenderWidget::didActivateCompositor() {
1177 TRACE_EVENT0("gpu", "RenderWidget::didActivateCompositor");
1178
[email protected]c0b0bd12014-03-13 00:39:581179 is_accelerated_compositing_active_ = true;
1180 Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
1181 routing_id_, is_accelerated_compositing_active_));
[email protected]13d6e31d2014-05-09 07:06:361182 webwidget_->enterForceCompositingMode(true);
[email protected]c0b0bd12014-03-13 00:39:581183}
1184
[email protected]ea162f92011-10-04 23:08:221185void RenderWidget::didDeactivateCompositor() {
1186 TRACE_EVENT0("gpu", "RenderWidget::didDeactivateCompositor");
1187
1188 is_accelerated_compositing_active_ = false;
1189 Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
1190 routing_id_, is_accelerated_compositing_active_));
[email protected]a79d8a632010-11-18 22:35:561191}
1192
[email protected]e195e582013-03-08 01:32:591193void RenderWidget::initializeLayerTreeView() {
[email protected]c5fa4c42013-07-20 05:47:371194 compositor_ = RenderWidgetCompositor::Create(
1195 this, is_threaded_compositing_enabled_);
[email protected]e195e582013-03-08 01:32:591196 compositor_->setViewportSize(size_, physical_backing_size_);
1197 if (init_complete_)
[email protected]7912e822014-04-16 02:37:031198 StartCompositor();
[email protected]e195e582013-03-08 01:32:591199}
1200
[email protected]180ef242013-11-07 06:50:461201blink::WebLayerTreeView* RenderWidget::layerTreeView() {
[email protected]ba91a792013-02-06 09:48:281202 return compositor_.get();
[email protected]8926c602013-01-23 05:32:061203}
1204
[email protected]9ed83fe2013-02-27 01:52:281205void RenderWidget::suppressCompositorScheduling(bool enable) {
1206 if (compositor_)
1207 compositor_->SetSuppressScheduleComposite(enable);
1208}
1209
[email protected]9cd43a62012-03-26 08:03:561210void RenderWidget::willBeginCompositorFrame() {
1211 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
[email protected]abe8b3a2012-03-28 21:19:371212
[email protected]cadac622013-06-11 16:46:361213 DCHECK(RenderThreadImpl::current()->compositor_message_loop_proxy().get());
[email protected]abe8b3a2012-03-28 21:19:371214
1215 // The following two can result in further layout and possibly
1216 // enable GPU acceleration so they need to be called before any painting
1217 // is done.
[email protected]cb9e2632013-06-18 11:26:471218 UpdateTextInputType();
1219#if defined(OS_ANDROID)
[email protected]90f24152014-04-09 12:41:361220 UpdateTextInputState(NO_SHOW_IME, FROM_NON_IME);
[email protected]a80aea72014-03-14 21:10:151221 UpdateSelectionRootBounds();
[email protected]cb9e2632013-06-18 11:26:471222#endif
[email protected]abe8b3a2012-03-28 21:19:371223 UpdateSelectionBounds();
[email protected]9cd43a62012-03-26 08:03:561224}
1225
[email protected]3391a0772012-03-28 00:32:071226void RenderWidget::didBecomeReadyForAdditionalInput() {
1227 TRACE_EVENT0("renderer", "RenderWidget::didBecomeReadyForAdditionalInput");
[email protected]fd847792013-10-24 17:12:351228 FlushPendingInputEventAck();
[email protected]3391a0772012-03-28 00:32:071229}
1230
[email protected]6fceb912013-02-15 06:24:151231void RenderWidget::DidCommitCompositorFrame() {
[email protected]bffc8302014-01-23 20:52:161232 FOR_EACH_OBSERVER(RenderFrameImpl, swapped_out_frames_,
1233 DidCommitCompositorFrame());
[email protected]6fceb912013-02-15 06:24:151234}
1235
[email protected]58264a32011-11-17 23:36:151236void RenderWidget::didCommitAndDrawCompositorFrame() {
[email protected]b5db7eb2011-11-29 09:11:501237 TRACE_EVENT0("gpu", "RenderWidget::didCommitAndDrawCompositorFrame");
[email protected]bea16ce2014-01-11 23:01:291238 // Accelerated FPS tick for performance tests. See
1239 // tab_capture_performancetest.cc. NOTE: Tests may break if this event is
1240 // renamed or moved.
[email protected]c76faea2013-03-26 07:42:421241 UNSHIPPED_TRACE_EVENT_INSTANT0("test_fps", "TestFrameTickGPU",
1242 TRACE_EVENT_SCOPE_THREAD);
[email protected]29ed96a2012-02-04 18:12:161243 // Notify subclasses that we initiated the paint operation.
1244 DidInitiatePaint();
[email protected]58264a32011-11-17 23:36:151245}
1246
1247void RenderWidget::didCompleteSwapBuffers() {
[email protected]404939f2012-06-01 04:06:181248 TRACE_EVENT0("renderer", "RenderWidget::didCompleteSwapBuffers");
1249
1250 // Notify subclasses threaded composited rendering was flushed to the screen.
[email protected]9cd43a62012-03-26 08:03:561251 DidFlushPaint();
1252
[email protected]ea3ee0a2012-05-15 03:43:091253 if (!next_paint_flags_ &&
1254 !need_update_rect_for_auto_resize_ &&
1255 !plugin_window_moves_.size()) {
[email protected]58264a32011-11-17 23:36:151256 return;
[email protected]ea3ee0a2012-05-15 03:43:091257 }
[email protected]58264a32011-11-17 23:36:151258
1259 ViewHostMsg_UpdateRect_Params params;
1260 params.view_size = size_;
[email protected]58264a32011-11-17 23:36:151261 params.plugin_window_moves.swap(plugin_window_moves_);
1262 params.flags = next_paint_flags_;
1263 params.scroll_offset = GetScrollOffset();
[email protected]7ded9f12012-06-13 20:47:091264 params.scale_factor = device_scale_factor_;
[email protected]58264a32011-11-17 23:36:151265
1266 Send(new ViewHostMsg_UpdateRect(routing_id_, params));
1267 next_paint_flags_ = 0;
[email protected]ea3ee0a2012-05-15 03:43:091268 need_update_rect_for_auto_resize_ = false;
[email protected]58264a32011-11-17 23:36:151269}
1270
[email protected]8b9e52b2014-01-17 16:35:311271void RenderWidget::scheduleComposite() {
[email protected]57178962014-04-24 08:52:351272 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1273 // render_thread may be NULL in tests.
1274 if (render_thread && render_thread->compositor_message_loop_proxy().get() &&
[email protected]8b9e52b2014-01-17 16:35:311275 compositor_) {
[email protected]e221f9f2014-05-13 02:47:221276 compositor_->setNeedsAnimate();
[email protected]8b9e52b2014-01-17 16:35:311277 }
1278}
1279
[email protected]4873c7d2009-07-16 06:36:281280void RenderWidget::didChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301281 // TODO(darin): Eliminate this temporary.
[email protected]9ec87712013-05-24 23:23:521282 WebCursor cursor;
[email protected]953bd0062013-08-01 00:58:401283 InitializeCursorFromWebKitCursorInfo(&cursor, cursor_info);
initial.commit09911bf2008-07-26 23:55:291284 // Only send a SetCursor message if we need to make a change.
1285 if (!current_cursor_.IsEqual(cursor)) {
1286 current_cursor_ = cursor;
1287 Send(new ViewHostMsg_SetCursor(routing_id_, cursor));
1288 }
1289}
1290
1291// We are supposed to get a single call to Show for a newly created RenderWidget
1292// that was created via RenderWidget::CreateWebView. So, we wait until this
1293// point to dispatch the ShowWidget message.
1294//
1295// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281296// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291297//
[email protected]4873c7d2009-07-16 06:36:281298void RenderWidget::show(WebNavigationPolicy) {
initial.commit09911bf2008-07-26 23:55:291299 DCHECK(!did_show_) << "received extraneous Show call";
1300 DCHECK(routing_id_ != MSG_ROUTING_NONE);
1301 DCHECK(opener_id_ != MSG_ROUTING_NONE);
1302
[email protected]8de12d942010-11-17 20:42:441303 if (did_show_)
1304 return;
1305
1306 did_show_ = true;
1307 // NOTE: initial_pos_ may still have its default values at this point, but
1308 // that's okay. It'll be ignored if as_popup is false, or the browser
1309 // process will impose a default position otherwise.
1310 Send(new ViewHostMsg_ShowWidget(opener_id_, routing_id_, initial_pos_));
1311 SetPendingWindowRect(initial_pos_);
initial.commit09911bf2008-07-26 23:55:291312}
1313
[email protected]4873c7d2009-07-16 06:36:281314void RenderWidget::didFocus() {
initial.commit09911bf2008-07-26 23:55:291315}
1316
[email protected]4873c7d2009-07-16 06:36:281317void RenderWidget::didBlur() {
initial.commit09911bf2008-07-26 23:55:291318}
1319
[email protected]2533ce12009-05-09 00:02:241320void RenderWidget::DoDeferredClose() {
1321 Send(new ViewHostMsg_Close(routing_id_));
1322}
1323
[email protected]4873c7d2009-07-16 06:36:281324void RenderWidget::closeWidgetSoon() {
[email protected]e1c3a552012-05-04 20:51:321325 if (is_swapped_out_) {
1326 // This widget is currently swapped out, and the active widget is in a
1327 // different process. Have the browser route the close request to the
1328 // active widget instead, so that the correct unload handlers are run.
1329 Send(new ViewHostMsg_RouteCloseEvent(routing_id_));
1330 return;
1331 }
1332
initial.commit09911bf2008-07-26 23:55:291333 // If a page calls window.close() twice, we'll end up here twice, but that's
1334 // OK. It is safe to send multiple Close messages.
1335
[email protected]2533ce12009-05-09 00:02:241336 // Ask the RenderWidgetHost to initiate close. We could be called from deep
1337 // in Javascript. If we ask the RendwerWidgetHost to close now, the window
1338 // could be closed before the JS finishes executing. So instead, post a
1339 // message back to the message loop, which won't run until the JS is
1340 // complete, and then the Close message can be sent.
[email protected]dd32b1272013-05-04 14:17:111341 base::MessageLoop::current()->PostTask(
[email protected]32876ae2011-11-15 22:25:211342 FROM_HERE, base::Bind(&RenderWidget::DoDeferredClose, this));
initial.commit09911bf2008-07-26 23:55:291343}
1344
[email protected]9017d7852013-11-21 17:47:351345void RenderWidget::QueueSyntheticGesture(
1346 scoped_ptr<SyntheticGestureParams> gesture_params,
1347 const SyntheticGestureCompletionCallback& callback) {
1348 DCHECK(!callback.is_null());
1349
1350 pending_synthetic_gesture_callbacks_.push(callback);
1351
1352 SyntheticGesturePacket gesture_packet;
1353 gesture_packet.set_gesture_params(gesture_params.Pass());
1354
1355 Send(new InputHostMsg_QueueSyntheticGesture(routing_id_, gesture_packet));
1356}
1357
initial.commit09911bf2008-07-26 23:55:291358void RenderWidget::Close() {
1359 if (webwidget_) {
[email protected]8926c602013-01-23 05:32:061360 webwidget_->willCloseLayerTreeView();
[email protected]ba91a792013-02-06 09:48:281361 compositor_.reset();
[email protected]4873c7d2009-07-16 06:36:281362 webwidget_->close();
initial.commit09911bf2008-07-26 23:55:291363 webwidget_ = NULL;
1364 }
1365}
1366
[email protected]4873c7d2009-07-16 06:36:281367WebRect RenderWidget::windowRect() {
1368 if (pending_window_rect_count_)
1369 return pending_window_rect_;
[email protected]2533ce12009-05-09 00:02:241370
[email protected]80ad8622012-11-07 16:33:031371 return view_screen_rect_;
initial.commit09911bf2008-07-26 23:55:291372}
1373
[email protected]180ef242013-11-07 06:50:461374void RenderWidget::setToolTipText(const blink::WebString& text,
[email protected]8a9d6ca32011-06-06 20:11:301375 WebTextDirection hint) {
[email protected]5a395b72011-08-08 19:13:541376 Send(new ViewHostMsg_SetTooltipText(routing_id_, text, hint));
[email protected]8a9d6ca32011-06-06 20:11:301377}
1378
[email protected]b2e4c70132013-10-03 02:07:511379void RenderWidget::setWindowRect(const WebRect& rect) {
1380 WebRect pos = rect;
1381 if (popup_origin_scale_for_emulation_) {
1382 float scale = popup_origin_scale_for_emulation_;
1383 pos.x = popup_screen_origin_for_emulation_.x() +
1384 (pos.x - popup_view_origin_for_emulation_.x()) * scale;
1385 pos.y = popup_screen_origin_for_emulation_.y() +
1386 (pos.y - popup_view_origin_for_emulation_.y()) * scale;
1387 }
1388
[email protected]5b45ad42013-10-25 00:42:041389 if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]ec951b9d2013-10-20 06:21:201390 if (did_show_) {
[email protected]8be1c582013-03-06 00:55:031391 Send(new ViewHostMsg_RequestMove(routing_id_, pos));
1392 SetPendingWindowRect(pos);
1393 } else {
[email protected]ec951b9d2013-10-20 06:21:201394 initial_pos_ = pos;
[email protected]8be1c582013-03-06 00:55:031395 }
initial.commit09911bf2008-07-26 23:55:291396 } else {
[email protected]92650162013-10-30 03:31:021397 ResizeSynchronously(pos);
initial.commit09911bf2008-07-26 23:55:291398 }
1399}
1400
[email protected]2533ce12009-05-09 00:02:241401void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
1402 pending_window_rect_ = rect;
1403 pending_window_rect_count_++;
1404}
1405
[email protected]4873c7d2009-07-16 06:36:281406WebRect RenderWidget::rootWindowRect() {
[email protected]2533ce12009-05-09 00:02:241407 if (pending_window_rect_count_) {
1408 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
1409 // the RootWindowRect is probably going to return wrong results since the
1410 // browser may not have processed the Move yet. There isn't really anything
1411 // good to do in this case, and it shouldn't happen - since this size is
1412 // only really needed for windowToScreen, which is only used for Popups.
[email protected]4873c7d2009-07-16 06:36:281413 return pending_window_rect_;
[email protected]2533ce12009-05-09 00:02:241414 }
1415
[email protected]80ad8622012-11-07 16:33:031416 return window_screen_rect_;
[email protected]d4547452008-08-28 18:36:371417}
1418
[email protected]4873c7d2009-07-16 06:36:281419WebRect RenderWidget::windowResizerRect() {
1420 return resizer_rect_;
[email protected]c04b6362008-11-21 18:54:191421}
1422
[email protected]fa7b1dc2010-06-23 17:53:041423void RenderWidget::OnSetInputMethodActive(bool is_active) {
[email protected]c4bb35a2008-10-31 17:54:031424 // To prevent this renderer process from sending unnecessary IPC messages to
1425 // a browser process, we permit the renderer process to send IPC messages
[email protected]fa7b1dc2010-06-23 17:53:041426 // only during the input method attached to the browser process is active.
1427 input_method_is_active_ = is_active;
initial.commit09911bf2008-07-26 23:55:291428}
1429
[email protected]37a241c2013-12-03 03:16:171430void RenderWidget::OnCandidateWindowShown() {
1431 webwidget_->didShowCandidateWindow();
1432}
1433
1434void RenderWidget::OnCandidateWindowUpdated() {
1435 webwidget_->didUpdateCandidateWindow();
1436}
1437
1438void RenderWidget::OnCandidateWindowHidden() {
1439 webwidget_->didHideCandidateWindow();
1440}
1441
[email protected]fa7b1dc2010-06-23 17:53:041442void RenderWidget::OnImeSetComposition(
[email protected]fcf75d42013-12-03 20:11:261443 const base::string16& text,
[email protected]fa7b1dc2010-06-23 17:53:041444 const std::vector<WebCompositionUnderline>& underlines,
1445 int selection_start, int selection_end) {
[email protected]0d1ebed12013-08-05 22:01:131446 if (!ShouldHandleImeEvent())
[email protected]4873c7d2009-07-16 06:36:281447 return;
[email protected]66fca5bc2013-05-23 06:58:291448 ImeEventGuard guard(this);
[email protected]88dbe32f2013-06-20 23:31:361449 if (!webwidget_->setComposition(
[email protected]fa7b1dc2010-06-23 17:53:041450 text, WebVector<WebCompositionUnderline>(underlines),
1451 selection_start, selection_end)) {
1452 // If we failed to set the composition text, then we need to let the browser
1453 // process to cancel the input method's ongoing composition session, to make
1454 // sure we are in a consistent state.
1455 Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
[email protected]7f00efa2010-04-15 05:01:261456 }
[email protected]f9db7d2d2014-04-11 16:07:111457#if defined(OS_MACOSX) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:361458 UpdateCompositionInfo(true);
[email protected]501ea13d2013-07-09 17:03:291459#endif
[email protected]fa7b1dc2010-06-23 17:53:041460}
1461
[email protected]fcf75d42013-12-03 20:11:261462void RenderWidget::OnImeConfirmComposition(const base::string16& text,
[email protected]db4fc1e2013-09-06 20:01:511463 const gfx::Range& replacement_range,
[email protected]0e45bd02013-07-12 20:20:021464 bool keep_selection) {
[email protected]0d1ebed12013-08-05 22:01:131465 if (!ShouldHandleImeEvent())
[email protected]d0be63772011-12-20 23:18:041466 return;
[email protected]66fca5bc2013-05-23 06:58:291467 ImeEventGuard guard(this);
[email protected]d0be63772011-12-20 23:18:041468 handling_input_event_ = true;
[email protected]0e45bd02013-07-12 20:20:021469 if (text.length())
1470 webwidget_->confirmComposition(text);
1471 else if (keep_selection)
1472 webwidget_->confirmComposition(WebWidget::KeepSelection);
1473 else
1474 webwidget_->confirmComposition(WebWidget::DoNotKeepSelection);
[email protected]d0be63772011-12-20 23:18:041475 handling_input_event_ = false;
[email protected]f9db7d2d2014-04-11 16:07:111476#if defined(OS_MACOSX) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:361477 UpdateCompositionInfo(true);
[email protected]501ea13d2013-07-09 17:03:291478#endif
initial.commit09911bf2008-07-26 23:55:291479}
1480
[email protected]0bc1f572013-04-17 01:46:311481void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
[email protected]ec7dc112008-08-06 05:30:121482 // During shutdown we can just ignore this message.
1483 if (!webwidget_)
1484 return;
1485
[email protected]0bc1f572013-04-17 01:46:311486 // Even if the browser provides an empty damage rect, it's still expecting to
1487 // receive a repaint ack so just damage the entire widget bounds.
1488 if (size_to_paint.IsEmpty()) {
1489 size_to_paint = size_;
1490 }
1491
[email protected]ec7dc112008-08-06 05:30:121492 set_next_paint_is_repaint_ack();
[email protected]0bc1f572013-04-17 01:46:311493 if (is_accelerated_compositing_active_ && compositor_) {
1494 compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint));
[email protected]f98d7e3c2010-09-13 22:30:461495 } else {
1496 gfx::Rect repaint_rect(size_to_paint.width(), size_to_paint.height());
1497 didInvalidateRect(repaint_rect);
1498 }
[email protected]ec7dc112008-08-06 05:30:121499}
1500
[email protected]79fa22e2013-08-23 15:18:121501void RenderWidget::OnSyntheticGestureCompleted() {
[email protected]9017d7852013-11-21 17:47:351502 DCHECK(!pending_synthetic_gesture_callbacks_.empty());
1503
1504 pending_synthetic_gesture_callbacks_.front().Run();
1505 pending_synthetic_gesture_callbacks_.pop();
[email protected]0e241b4b2012-08-18 09:06:271506}
1507
[email protected]4873c7d2009-07-16 06:36:281508void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
[email protected]07f953332009-03-25 04:31:111509 if (!webwidget_)
1510 return;
[email protected]4873c7d2009-07-16 06:36:281511 webwidget_->setTextDirection(direction);
[email protected]07f953332009-03-25 04:31:111512}
1513
[email protected]80ad8622012-11-07 16:33:031514void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
1515 const gfx::Rect& window_screen_rect) {
[email protected]b2e4c70132013-10-03 02:07:511516 if (screen_metrics_emulator_) {
1517 screen_metrics_emulator_->OnUpdateScreenRectsMessage(
1518 view_screen_rect, window_screen_rect);
1519 } else {
1520 view_screen_rect_ = view_screen_rect;
1521 window_screen_rect_ = window_screen_rect;
1522 }
[email protected]80ad8622012-11-07 16:33:031523 Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
1524}
1525
[email protected]105dffb42013-02-20 03:46:211526#if defined(OS_ANDROID)
[email protected]2384b6c2013-02-28 23:58:511527void RenderWidget::OnShowImeIfNeeded() {
[email protected]90f24152014-04-09 12:41:361528 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
[email protected]0d1ebed12013-08-05 22:01:131529}
1530
1531void RenderWidget::IncrementOutstandingImeEventAcks() {
1532 ++outstanding_ime_acks_;
1533}
1534
1535void RenderWidget::OnImeEventAck() {
1536 --outstanding_ime_acks_;
1537 DCHECK(outstanding_ime_acks_ >= 0);
[email protected]2384b6c2013-02-28 23:58:511538}
[email protected]105dffb42013-02-20 03:46:211539#endif
1540
[email protected]0d1ebed12013-08-05 22:01:131541bool RenderWidget::ShouldHandleImeEvent() {
1542#if defined(OS_ANDROID)
1543 return !!webwidget_ && outstanding_ime_acks_ == 0;
1544#else
1545 return !!webwidget_;
1546#endif
1547}
1548
[email protected]468ac582012-11-20 00:53:191549void RenderWidget::SetDeviceScaleFactor(float device_scale_factor) {
1550 if (device_scale_factor_ == device_scale_factor)
1551 return;
1552
1553 device_scale_factor_ = device_scale_factor;
1554
1555 if (!is_accelerated_compositing_active_) {
1556 didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
1557 } else {
[email protected]8b9e52b2014-01-17 16:35:311558 scheduleComposite();
[email protected]468ac582012-11-20 00:53:191559 }
1560}
1561
[email protected]fcdc5642014-05-09 14:32:241562void RenderWidget::OnOrientationChange() {
1563}
1564
[email protected]ceb36f7d2012-10-31 18:33:241565gfx::Vector2d RenderWidget::GetScrollOffset() {
[email protected]d54169e92011-01-21 09:19:521566 // Bare RenderWidgets don't support scroll offset.
[email protected]ceb36f7d2012-10-31 18:33:241567 return gfx::Vector2d();
[email protected]d54169e92011-01-21 09:19:521568}
1569
[email protected]bee16aab2009-08-26 15:55:031570void RenderWidget::SetHidden(bool hidden) {
1571 if (is_hidden_ == hidden)
1572 return;
1573
1574 // The status has changed. Tell the RenderThread about it.
1575 is_hidden_ = hidden;
1576 if (is_hidden_)
[email protected]b2db9272014-01-10 17:42:001577 RenderThreadImpl::current()->WidgetHidden();
[email protected]bee16aab2009-08-26 15:55:031578 else
[email protected]b2db9272014-01-10 17:42:001579 RenderThreadImpl::current()->WidgetRestored();
[email protected]bee16aab2009-08-26 15:55:031580}
1581
[email protected]2b624c562011-10-27 22:58:261582void RenderWidget::WillToggleFullscreen() {
[email protected]2b624c562011-10-27 22:58:261583 if (!webwidget_)
1584 return;
1585
1586 if (is_fullscreen_) {
1587 webwidget_->willExitFullScreen();
1588 } else {
1589 webwidget_->willEnterFullScreen();
1590 }
[email protected]2b624c562011-10-27 22:58:261591}
1592
1593void RenderWidget::DidToggleFullscreen() {
[email protected]2b624c562011-10-27 22:58:261594 if (!webwidget_)
1595 return;
1596
1597 if (is_fullscreen_) {
1598 webwidget_->didEnterFullScreen();
1599 } else {
1600 webwidget_->didExitFullScreen();
1601 }
[email protected]2b624c562011-10-27 22:58:261602}
1603
[email protected]674741932009-02-04 23:44:461604bool RenderWidget::next_paint_is_resize_ack() const {
[email protected]53d3f302009-12-21 04:42:051605 return ViewHostMsg_UpdateRect_Flags::is_resize_ack(next_paint_flags_);
[email protected]674741932009-02-04 23:44:461606}
1607
[email protected]674741932009-02-04 23:44:461608void RenderWidget::set_next_paint_is_resize_ack() {
[email protected]53d3f302009-12-21 04:42:051609 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
[email protected]674741932009-02-04 23:44:461610}
1611
[email protected]674741932009-02-04 23:44:461612void RenderWidget::set_next_paint_is_repaint_ack() {
[email protected]53d3f302009-12-21 04:42:051613 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK;
[email protected]674741932009-02-04 23:44:461614}
1615
[email protected]b18583c2012-12-18 06:55:271616static bool IsDateTimeInput(ui::TextInputType type) {
1617 return type == ui::TEXT_INPUT_TYPE_DATE ||
1618 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
1619 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
1620 type == ui::TEXT_INPUT_TYPE_MONTH ||
1621 type == ui::TEXT_INPUT_TYPE_TIME ||
1622 type == ui::TEXT_INPUT_TYPE_WEEK;
1623}
1624
[email protected]66fca5bc2013-05-23 06:58:291625
1626void RenderWidget::StartHandlingImeEvent() {
1627 DCHECK(!handling_ime_event_);
1628 handling_ime_event_ = true;
1629}
1630
1631void RenderWidget::FinishHandlingImeEvent() {
1632 DCHECK(handling_ime_event_);
1633 handling_ime_event_ = false;
1634 // While handling an ime event, text input state and selection bounds updates
1635 // are ignored. These must explicitly be updated once finished handling the
1636 // ime event.
[email protected]a80aea72014-03-14 21:10:151637#if defined(OS_ANDROID)
1638 UpdateSelectionRootBounds();
1639#endif
[email protected]66fca5bc2013-05-23 06:58:291640 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:471641#if defined(OS_ANDROID)
[email protected]90f24152014-04-09 12:41:361642 UpdateTextInputState(NO_SHOW_IME, FROM_IME);
[email protected]cb9e2632013-06-18 11:26:471643#endif
[email protected]66fca5bc2013-05-23 06:58:291644}
1645
[email protected]cb9e2632013-06-18 11:26:471646void RenderWidget::UpdateTextInputType() {
[email protected]11f22bb62013-09-24 04:59:061647 // On Windows, not only an IME but also an on-screen keyboard relies on the
1648 // latest TextInputType to optimize its layout and functionality. Thus
1649 // |input_method_is_active_| is no longer an appropriate condition to suppress
1650 // TextInputTypeChanged IPC on Windows.
1651 // TODO(yukawa, yoichio): Consider to stop checking |input_method_is_active_|
1652 // on other platforms as well as Windows if the overhead is acceptable.
1653#if !defined(OS_WIN)
[email protected]cb9e2632013-06-18 11:26:471654 if (!input_method_is_active_)
1655 return;
[email protected]11f22bb62013-09-24 04:59:061656#endif
[email protected]cb9e2632013-06-18 11:26:471657
[email protected]e7c569d2013-07-17 16:00:361658 ui::TextInputType new_type = GetTextInputType();
[email protected]cb9e2632013-06-18 11:26:471659 if (IsDateTimeInput(new_type))
1660 return; // Not considered as a text input field in WebKit/Chromium.
1661
1662 bool new_can_compose_inline = CanComposeInline();
1663
[email protected]180ef242013-11-07 06:50:461664 blink::WebTextInputInfo new_info;
[email protected]e7c569d2013-07-17 16:00:361665 if (webwidget_)
1666 new_info = webwidget_->textInputInfo();
[email protected]b256eca2013-07-11 10:57:401667 const ui::TextInputMode new_mode = ConvertInputMode(new_info.inputMode);
1668
[email protected]cb9e2632013-06-18 11:26:471669 if (text_input_type_ != new_type
[email protected]b256eca2013-07-11 10:57:401670 || can_compose_inline_ != new_can_compose_inline
1671 || text_input_mode_ != new_mode) {
[email protected]cb9e2632013-06-18 11:26:471672 Send(new ViewHostMsg_TextInputTypeChanged(routing_id(),
1673 new_type,
[email protected]86ba5fcb2013-09-04 00:36:531674 new_mode,
1675 new_can_compose_inline));
[email protected]cb9e2632013-06-18 11:26:471676 text_input_type_ = new_type;
1677 can_compose_inline_ = new_can_compose_inline;
[email protected]b256eca2013-07-11 10:57:401678 text_input_mode_ = new_mode;
[email protected]cb9e2632013-06-18 11:26:471679 }
1680}
1681
[email protected]183e28d2014-01-20 18:18:021682#if defined(OS_ANDROID) || defined(USE_AURA)
[email protected]90f24152014-04-09 12:41:361683void RenderWidget::UpdateTextInputState(ShowIme show_ime,
1684 ChangeSource change_source) {
[email protected]e8f775f2013-02-14 21:00:501685 if (handling_ime_event_)
1686 return;
[email protected]90f24152014-04-09 12:41:361687 if (show_ime == NO_SHOW_IME && !input_method_is_active_)
initial.commit09911bf2008-07-26 23:55:291688 return;
[email protected]ad26ef42011-06-17 07:59:451689 ui::TextInputType new_type = GetTextInputType();
[email protected]b18583c2012-12-18 06:55:271690 if (IsDateTimeInput(new_type))
1691 return; // Not considered as a text input field in WebKit/Chromium.
1692
[email protected]180ef242013-11-07 06:50:461693 blink::WebTextInputInfo new_info;
[email protected]5b739cb2012-08-21 20:35:211694 if (webwidget_)
1695 new_info = webwidget_->textInputInfo();
1696
[email protected]ad26ef42011-06-17 07:59:451697 bool new_can_compose_inline = CanComposeInline();
[email protected]5b739cb2012-08-21 20:35:211698
[email protected]3306f262012-09-21 19:20:421699 // Only sends text input params if they are changed or if the ime should be
1700 // shown.
[email protected]90f24152014-04-09 12:41:361701 if (show_ime == SHOW_IME_IF_NEEDED ||
1702 (text_input_type_ != new_type ||
1703 text_input_info_ != new_info ||
1704 can_compose_inline_ != new_can_compose_inline)
1705#if defined(OS_ANDROID)
1706 || text_field_is_dirty_
[email protected]183e28d2014-01-20 18:18:021707#endif
[email protected]90f24152014-04-09 12:41:361708 ) {
1709 ViewHostMsg_TextInputState_Params p;
[email protected]5b739cb2012-08-21 20:35:211710 p.type = new_type;
1711 p.value = new_info.value.utf8();
1712 p.selection_start = new_info.selectionStart;
1713 p.selection_end = new_info.selectionEnd;
1714 p.composition_start = new_info.compositionStart;
1715 p.composition_end = new_info.compositionEnd;
1716 p.can_compose_inline = new_can_compose_inline;
[email protected]90f24152014-04-09 12:41:361717 p.show_ime_if_needed = (show_ime == SHOW_IME_IF_NEEDED);
1718#if defined(USE_AURA)
1719 p.is_non_ime_change = true;
1720#endif
[email protected]183e28d2014-01-20 18:18:021721#if defined(OS_ANDROID)
[email protected]90f24152014-04-09 12:41:361722 p.is_non_ime_change = (change_source == FROM_NON_IME) ||
1723 text_field_is_dirty_;
1724 if (p.is_non_ime_change)
[email protected]0d1ebed12013-08-05 22:01:131725 IncrementOutstandingImeEventAcks();
[email protected]90f24152014-04-09 12:41:361726 text_field_is_dirty_ = false;
[email protected]183e28d2014-01-20 18:18:021727#endif
[email protected]5b739cb2012-08-21 20:35:211728 Send(new ViewHostMsg_TextInputStateChanged(routing_id(), p));
1729
1730 text_input_info_ = new_info;
[email protected]fa7b1dc2010-06-23 17:53:041731 text_input_type_ = new_type;
[email protected]ad26ef42011-06-17 07:59:451732 can_compose_inline_ = new_can_compose_inline;
initial.commit09911bf2008-07-26 23:55:291733 }
initial.commit09911bf2008-07-26 23:55:291734}
[email protected]cb9e2632013-06-18 11:26:471735#endif
initial.commit09911bf2008-07-26 23:55:291736
[email protected]7c8873e2013-02-05 08:03:011737void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
1738 WebRect focus_webrect;
1739 WebRect anchor_webrect;
1740 webwidget_->selectionBounds(focus_webrect, anchor_webrect);
1741 *focus = focus_webrect;
1742 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:321743}
1744
[email protected]e99ef6f2011-10-16 01:13:001745void RenderWidget::UpdateSelectionBounds() {
1746 if (!webwidget_)
1747 return;
[email protected]66fca5bc2013-05-23 06:58:291748 if (handling_ime_event_)
1749 return;
[email protected]e99ef6f2011-10-16 01:13:001750
[email protected]7c8873e2013-02-05 08:03:011751 ViewHostMsg_SelectionBounds_Params params;
1752 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
1753 if (selection_anchor_rect_ != params.anchor_rect ||
1754 selection_focus_rect_ != params.focus_rect) {
1755 selection_anchor_rect_ = params.anchor_rect;
1756 selection_focus_rect_ = params.focus_rect;
1757 webwidget_->selectionTextDirection(params.focus_dir, params.anchor_dir);
[email protected]129b7382013-02-12 02:14:291758 params.is_anchor_first = webwidget_->isSelectionAnchorFirst();
[email protected]7c8873e2013-02-05 08:03:011759 Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
[email protected]58b48a0d2012-06-13 07:01:351760 }
[email protected]f9db7d2d2014-04-11 16:07:111761#if defined(OS_MACOSX) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:361762 UpdateCompositionInfo(false);
[email protected]501ea13d2013-07-09 17:03:291763#endif
[email protected]e99ef6f2011-10-16 01:13:001764}
1765
[email protected]180ef242013-11-07 06:50:461766// Check blink::WebTextInputType and ui::TextInputType is kept in sync.
1767COMPILE_ASSERT(int(blink::WebTextInputTypeNone) == \
[email protected]ad26ef42011-06-17 07:59:451768 int(ui::TEXT_INPUT_TYPE_NONE), mismatching_enums);
[email protected]180ef242013-11-07 06:50:461769COMPILE_ASSERT(int(blink::WebTextInputTypeText) == \
[email protected]ad26ef42011-06-17 07:59:451770 int(ui::TEXT_INPUT_TYPE_TEXT), mismatching_enums);
[email protected]180ef242013-11-07 06:50:461771COMPILE_ASSERT(int(blink::WebTextInputTypePassword) == \
[email protected]ad26ef42011-06-17 07:59:451772 int(ui::TEXT_INPUT_TYPE_PASSWORD), mismatching_enums);
[email protected]180ef242013-11-07 06:50:461773COMPILE_ASSERT(int(blink::WebTextInputTypeSearch) == \
[email protected]caf38ed2011-07-28 13:15:181774 int(ui::TEXT_INPUT_TYPE_SEARCH), mismatching_enums);
[email protected]180ef242013-11-07 06:50:461775COMPILE_ASSERT(int(blink::WebTextInputTypeEmail) == \
[email protected]caf38ed2011-07-28 13:15:181776 int(ui::TEXT_INPUT_TYPE_EMAIL), mismatching_enums);
[email protected]180ef242013-11-07 06:50:461777COMPILE_ASSERT(int(blink::WebTextInputTypeNumber) == \
[email protected]caf38ed2011-07-28 13:15:181778 int(ui::TEXT_INPUT_TYPE_NUMBER), mismatching_enums);
[email protected]180ef242013-11-07 06:50:461779COMPILE_ASSERT(int(blink::WebTextInputTypeTelephone) == \
[email protected]caf38ed2011-07-28 13:15:181780 int(ui::TEXT_INPUT_TYPE_TELEPHONE), mismatching_enums);
[email protected]180ef242013-11-07 06:50:461781COMPILE_ASSERT(int(blink::WebTextInputTypeURL) == \
[email protected]caf38ed2011-07-28 13:15:181782 int(ui::TEXT_INPUT_TYPE_URL), mismatching_enums);
[email protected]180ef242013-11-07 06:50:461783COMPILE_ASSERT(int(blink::WebTextInputTypeDate) == \
[email protected]feb8cf752012-06-08 04:48:001784 int(ui::TEXT_INPUT_TYPE_DATE), mismatching_enum);
[email protected]180ef242013-11-07 06:50:461785COMPILE_ASSERT(int(blink::WebTextInputTypeDateTime) == \
[email protected]feb8cf752012-06-08 04:48:001786 int(ui::TEXT_INPUT_TYPE_DATE_TIME), mismatching_enum);
[email protected]180ef242013-11-07 06:50:461787COMPILE_ASSERT(int(blink::WebTextInputTypeDateTimeLocal) == \
[email protected]feb8cf752012-06-08 04:48:001788 int(ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL), mismatching_enum);
[email protected]180ef242013-11-07 06:50:461789COMPILE_ASSERT(int(blink::WebTextInputTypeMonth) == \
[email protected]feb8cf752012-06-08 04:48:001790 int(ui::TEXT_INPUT_TYPE_MONTH), mismatching_enum);
[email protected]180ef242013-11-07 06:50:461791COMPILE_ASSERT(int(blink::WebTextInputTypeTime) == \
[email protected]feb8cf752012-06-08 04:48:001792 int(ui::TEXT_INPUT_TYPE_TIME), mismatching_enum);
[email protected]180ef242013-11-07 06:50:461793COMPILE_ASSERT(int(blink::WebTextInputTypeWeek) == \
[email protected]feb8cf752012-06-08 04:48:001794 int(ui::TEXT_INPUT_TYPE_WEEK), mismatching_enum);
[email protected]180ef242013-11-07 06:50:461795COMPILE_ASSERT(int(blink::WebTextInputTypeTextArea) == \
[email protected]2a9893672012-11-09 20:33:011796 int(ui::TEXT_INPUT_TYPE_TEXT_AREA), mismatching_enums);
[email protected]180ef242013-11-07 06:50:461797COMPILE_ASSERT(int(blink::WebTextInputTypeContentEditable) == \
[email protected]2a9893672012-11-09 20:33:011798 int(ui::TEXT_INPUT_TYPE_CONTENT_EDITABLE), mismatching_enums);
[email protected]180ef242013-11-07 06:50:461799COMPILE_ASSERT(int(blink::WebTextInputTypeDateTimeField) == \
[email protected]8b4992e2013-03-01 15:42:151800 int(ui::TEXT_INPUT_TYPE_DATE_TIME_FIELD), mismatching_enums);
[email protected]ad26ef42011-06-17 07:59:451801
[email protected]5b739cb2012-08-21 20:35:211802ui::TextInputType RenderWidget::WebKitToUiTextInputType(
[email protected]180ef242013-11-07 06:50:461803 blink::WebTextInputType type) {
[email protected]5b739cb2012-08-21 20:35:211804 // Check the type is in the range representable by ui::TextInputType.
1805 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX)) <<
[email protected]180ef242013-11-07 06:50:461806 "blink::WebTextInputType and ui::TextInputType not synchronized";
[email protected]5b739cb2012-08-21 20:35:211807 return static_cast<ui::TextInputType>(type);
1808}
1809
[email protected]ad26ef42011-06-17 07:59:451810ui::TextInputType RenderWidget::GetTextInputType() {
[email protected]8969bb3f2012-11-30 21:49:271811 if (webwidget_)
1812 return WebKitToUiTextInputType(webwidget_->textInputInfo().type);
[email protected]ad26ef42011-06-17 07:59:451813 return ui::TEXT_INPUT_TYPE_NONE;
1814}
1815
[email protected]f9db7d2d2014-04-11 16:07:111816#if defined(OS_MACOSX) || defined(USE_AURA)
[email protected]501ea13d2013-07-09 17:03:291817void RenderWidget::UpdateCompositionInfo(bool should_update_range) {
[email protected]db4fc1e2013-09-06 20:01:511818 gfx::Range range = gfx::Range();
[email protected]501ea13d2013-07-09 17:03:291819 if (should_update_range) {
1820 GetCompositionRange(&range);
1821 } else {
1822 range = composition_range_;
1823 }
1824 std::vector<gfx::Rect> character_bounds;
1825 GetCompositionCharacterBounds(&character_bounds);
1826
1827 if (!ShouldUpdateCompositionInfo(range, character_bounds))
1828 return;
1829 composition_character_bounds_ = character_bounds;
1830 composition_range_ = range;
1831 Send(new ViewHostMsg_ImeCompositionRangeChanged(
1832 routing_id(), composition_range_, composition_character_bounds_));
1833}
1834
[email protected]58b48a0d2012-06-13 07:01:351835void RenderWidget::GetCompositionCharacterBounds(
1836 std::vector<gfx::Rect>* bounds) {
1837 DCHECK(bounds);
1838 bounds->clear();
1839}
1840
[email protected]db4fc1e2013-09-06 20:01:511841void RenderWidget::GetCompositionRange(gfx::Range* range) {
[email protected]88dbe32f2013-06-20 23:31:361842 size_t location, length;
1843 if (webwidget_->compositionRange(&location, &length)) {
1844 range->set_start(location);
1845 range->set_end(location + length);
1846 } else if (webwidget_->caretOrSelectionRange(&location, &length)) {
1847 range->set_start(location);
1848 range->set_end(location + length);
1849 } else {
[email protected]db4fc1e2013-09-06 20:01:511850 *range = gfx::Range::InvalidRange();
[email protected]88dbe32f2013-06-20 23:31:361851 }
1852}
1853
[email protected]501ea13d2013-07-09 17:03:291854bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:511855 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:291856 const std::vector<gfx::Rect>& bounds) {
1857 if (composition_range_ != range)
1858 return true;
1859 if (bounds.size() != composition_character_bounds_.size())
1860 return true;
1861 for (size_t i = 0; i < bounds.size(); ++i) {
1862 if (bounds[i] != composition_character_bounds_[i])
1863 return true;
1864 }
1865 return false;
1866}
1867#endif
1868
[email protected]a4f0d882014-05-01 23:48:101869#if defined(OS_ANDROID)
1870void RenderWidget::DidChangeBodyBackgroundColor(SkColor bg_color) {
1871 // If not initialized, default to white. Note that 0 is different from black
1872 // as black still has alpha 0xFF.
1873 if (!bg_color)
1874 bg_color = SK_ColorWHITE;
1875
1876 if (bg_color != body_background_color_) {
1877 body_background_color_ = bg_color;
1878 Send(new ViewHostMsg_DidChangeBodyBackgroundColor(routing_id(), bg_color));
1879 }
1880}
1881#endif
1882
[email protected]ad26ef42011-06-17 07:59:451883bool RenderWidget::CanComposeInline() {
1884 return true;
[email protected]56ea1a62011-05-30 07:05:571885}
1886
[email protected]70b73b2c2014-05-01 04:31:391887#if defined(OS_MACOSX)
1888void RenderWidget::DidChangeScrollbarsForMainFrame(
1889 bool has_horizontal_scrollbar,
1890 bool has_vertical_scrollbar) {
1891 if (has_horizontal_scrollbar != cached_has_main_frame_horizontal_scrollbar_ ||
1892 has_vertical_scrollbar != cached_has_main_frame_vertical_scrollbar_) {
1893 Send(new ViewHostMsg_DidChangeScrollbarsForMainFrame(
1894 routing_id_, has_horizontal_scrollbar, has_vertical_scrollbar));
1895
1896 cached_has_main_frame_horizontal_scrollbar_ = has_horizontal_scrollbar;
1897 cached_has_main_frame_vertical_scrollbar_ = has_vertical_scrollbar;
1898 }
1899}
1900#endif // defined(OS_MACOSX)
1901
[email protected]4873c7d2009-07-16 06:36:281902WebScreenInfo RenderWidget::screenInfo() {
[email protected]842f10652012-06-06 01:54:041903 return screen_info_;
[email protected]4873c7d2009-07-16 06:36:281904}
1905
[email protected]f660d9c2012-06-06 18:31:211906float RenderWidget::deviceScaleFactor() {
1907 return device_scale_factor_;
1908}
1909
[email protected]fa7b1dc2010-06-23 17:53:041910void RenderWidget::resetInputMethod() {
1911 if (!input_method_is_active_)
1912 return;
1913
[email protected]0e45bd02013-07-12 20:20:021914 ImeEventGuard guard(this);
[email protected]fa7b1dc2010-06-23 17:53:041915 // If the last text input type is not None, then we should finish any
1916 // ongoing composition regardless of the new text input type.
[email protected]ad26ef42011-06-17 07:59:451917 if (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE) {
[email protected]fa7b1dc2010-06-23 17:53:041918 // If a composition text exists, then we need to let the browser process
1919 // to cancel the input method's ongoing composition session.
1920 if (webwidget_->confirmComposition())
1921 Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
1922 }
[email protected]d4cff272011-05-02 15:46:011923
[email protected]f9db7d2d2014-04-11 16:07:111924#if defined(OS_MACOSX) || defined(USE_AURA)
[email protected]88dbe32f2013-06-20 23:31:361925 UpdateCompositionInfo(true);
[email protected]501ea13d2013-07-09 17:03:291926#endif
[email protected]fa7b1dc2010-06-23 17:53:041927}
1928
[email protected]c68c3e4e2013-01-24 00:36:561929void RenderWidget::didHandleGestureEvent(
1930 const WebGestureEvent& event,
1931 bool event_cancelled) {
[email protected]183e28d2014-01-20 18:18:021932#if defined(OS_ANDROID) || defined(USE_AURA)
[email protected]c68c3e4e2013-01-24 00:36:561933 if (event_cancelled)
1934 return;
1935 if (event.type == WebInputEvent::GestureTap ||
1936 event.type == WebInputEvent::GestureLongPress) {
[email protected]90f24152014-04-09 12:41:361937 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
[email protected]c68c3e4e2013-01-24 00:36:561938 }
1939#endif
1940}
1941
[email protected]7912e822014-04-16 02:37:031942void RenderWidget::StartCompositor() {
1943 // For widgets that are never visible, we don't need the compositor to run
1944 // at all.
1945 if (never_visible_)
1946 return;
1947 compositor_->setSurfaceReady();
1948}
1949
[email protected]29e2fb42013-07-19 01:13:471950void RenderWidget::SchedulePluginMove(const WebPluginGeometry& move) {
initial.commit09911bf2008-07-26 23:55:291951 size_t i = 0;
1952 for (; i < plugin_window_moves_.size(); ++i) {
1953 if (plugin_window_moves_[i].window == move.window) {
[email protected]16f89d02009-08-26 17:17:581954 if (move.rects_valid) {
1955 plugin_window_moves_[i] = move;
1956 } else {
1957 plugin_window_moves_[i].visible = move.visible;
1958 }
initial.commit09911bf2008-07-26 23:55:291959 break;
1960 }
1961 }
1962
1963 if (i == plugin_window_moves_.size())
1964 plugin_window_moves_.push_back(move);
1965}
[email protected]268654772009-08-06 23:02:041966
1967void RenderWidget::CleanupWindowInPluginMoves(gfx::PluginWindowHandle window) {
1968 for (WebPluginGeometryVector::iterator i = plugin_window_moves_.begin();
1969 i != plugin_window_moves_.end(); ++i) {
1970 if (i->window == window) {
1971 plugin_window_moves_.erase(i);
1972 break;
1973 }
1974 }
1975}
[email protected]67bfb83f2011-09-22 03:36:371976
[email protected]63b465922012-09-06 02:04:521977
[email protected]24ed0432013-04-24 07:50:311978RenderWidgetCompositor* RenderWidget::compositor() const {
1979 return compositor_.get();
1980}
1981
[email protected]180ef242013-11-07 06:50:461982bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
[email protected]67bfb83f2011-09-22 03:36:371983 return false;
1984}
[email protected]c3d45532011-10-07 19:20:401985
[email protected]41d86852012-11-07 12:23:241986bool RenderWidget::WillHandleGestureEvent(
[email protected]180ef242013-11-07 06:50:461987 const blink::WebGestureEvent& event) {
[email protected]41d86852012-11-07 12:23:241988 return false;
1989}
1990
[email protected]ce6689f2013-03-29 12:52:551991void RenderWidget::hasTouchEventHandlers(bool has_handlers) {
1992 Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
1993}
1994
[email protected]5d0bbdfa92013-12-10 00:35:511995void RenderWidget::setTouchAction(
1996 blink::WebTouchAction web_touch_action) {
1997
1998 // Ignore setTouchAction calls that result from synthetic touch events (eg.
1999 // when blink is emulating touch with mouse).
2000 if (!handling_touchstart_event_)
2001 return;
2002
[email protected]a18f67a2013-12-20 19:44:362003 // Verify the same values are used by the types so we can cast between them.
2004 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_AUTO) ==
2005 blink::WebTouchActionAuto,
2006 enum_values_must_match_for_touch_action);
2007 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_NONE) ==
2008 blink::WebTouchActionNone,
2009 enum_values_must_match_for_touch_action);
2010 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_PAN_X) ==
2011 blink::WebTouchActionPanX,
2012 enum_values_must_match_for_touch_action);
2013 COMPILE_ASSERT(static_cast<blink::WebTouchAction>(TOUCH_ACTION_PAN_Y) ==
2014 blink::WebTouchActionPanY,
2015 enum_values_must_match_for_touch_action);
[email protected]2bd73272014-03-13 19:36:112016 COMPILE_ASSERT(
2017 static_cast<blink::WebTouchAction>(TOUCH_ACTION_PINCH_ZOOM) ==
2018 blink::WebTouchActionPinchZoom,
2019 enum_values_must_match_for_touch_action);
[email protected]a18f67a2013-12-20 19:44:362020
2021 content::TouchAction content_touch_action =
2022 static_cast<content::TouchAction>(web_touch_action);
[email protected]5d0bbdfa92013-12-10 00:35:512023 Send(new InputHostMsg_SetTouchAction(routing_id_, content_touch_action));
2024}
2025
[email protected]90f24152014-04-09 12:41:362026void RenderWidget::didUpdateTextOfFocusedElementByNonUserInput() {
2027#if defined(OS_ANDROID)
2028 text_field_is_dirty_ = true;
2029#endif
2030}
2031
[email protected]a80aea72014-03-14 21:10:152032#if defined(OS_ANDROID)
2033void RenderWidget::UpdateSelectionRootBounds() {
2034}
2035#endif
2036
[email protected]3d5c243b2012-11-30 00:26:012037bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
2038 return true;
2039}
2040
[email protected]0634cdd42013-08-16 00:46:092041scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
[email protected]828a3932014-04-02 14:43:132042RenderWidget::CreateGraphicsContext3D() {
[email protected]ed7defa2013-03-12 21:29:592043 if (!webwidget_)
[email protected]0634cdd42013-08-16 00:46:092044 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]ebc0e1df2013-08-01 02:46:222045 if (CommandLine::ForCurrentProcess()->HasSwitch(
2046 switches::kDisableGpuCompositing))
[email protected]0634cdd42013-08-16 00:46:092047 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]96ab016c2013-10-23 00:50:292048 if (!RenderThreadImpl::current())
2049 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]4d7e46a2013-11-08 05:33:402050 CauseForGpuLaunch cause =
2051 CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
[email protected]96ab016c2013-10-23 00:50:292052 scoped_refptr<GpuChannelHost> gpu_channel_host(
[email protected]4d7e46a2013-11-08 05:33:402053 RenderThreadImpl::current()->EstablishGpuChannelSync(cause));
[email protected]96ab016c2013-10-23 00:50:292054 if (!gpu_channel_host)
2055 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]ed7defa2013-03-12 21:29:592056
[email protected]828a3932014-04-02 14:43:132057 // Explicitly disable antialiasing for the compositor. As of the time of
2058 // this writing, the only platform that supported antialiasing for the
2059 // compositor was Mac OS X, because the on-screen OpenGL context creation
2060 // code paths on Windows and Linux didn't yet have multisampling support.
2061 // Mac OS X essentially always behaves as though it's rendering offscreen.
2062 // Multisampling has a heavy cost especially on devices with relatively low
2063 // fill rate like most notebooks, and the Mac implementation would need to
2064 // be optimized to resolve directly into the IOSurface shared between the
2065 // GPU and browser processes. For these reasons and to avoid platform
2066 // disparities we explicitly disable antialiasing.
2067 blink::WebGraphicsContext3D::Attributes attributes;
2068 attributes.antialias = false;
2069 attributes.shareResources = true;
2070 attributes.noAutomaticFlushes = true;
2071 attributes.depth = false;
2072 attributes.stencil = false;
[email protected]828a3932014-04-02 14:43:132073 bool lose_context_when_out_of_memory = true;
[email protected]96ab016c2013-10-23 00:50:292074 WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits limits;
[email protected]b6eb8e332013-09-10 00:51:012075#if defined(OS_ANDROID)
2076 // If we raster too fast we become upload bound, and pending
2077 // uploads consume memory. For maximum upload throughput, we would
2078 // want to allow for upload_throughput * pipeline_time of pending
2079 // uploads, after which we are just wasting memory. Since we don't
2080 // know our upload throughput yet, this just caps our memory usage.
2081 size_t divider = 1;
2082 if (base::android::SysUtils::IsLowEndDevice())
[email protected]657be322013-09-20 08:50:032083 divider = 6;
[email protected]b6eb8e332013-09-10 00:51:012084 // For reference Nexus10 can upload 1MB in about 2.5ms.
[email protected]657be322013-09-20 08:50:032085 const double max_mb_uploaded_per_ms = 2.0 / (5 * divider);
[email protected]b6eb8e332013-09-10 00:51:012086 // Deadline to draw a frame to achieve 60 frames per second.
2087 const size_t kMillisecondsPerFrame = 16;
2088 // Assuming a two frame deep pipeline between the CPU and the GPU.
[email protected]657be322013-09-20 08:50:032089 size_t max_transfer_buffer_usage_mb =
2090 static_cast<size_t>(2 * kMillisecondsPerFrame * max_mb_uploaded_per_ms);
2091 static const size_t kBytesPerMegabyte = 1024 * 1024;
[email protected]b6eb8e332013-09-10 00:51:012092 // We keep the MappedMemoryReclaimLimit the same as the upload limit
2093 // to avoid unnecessarily stalling the compositor thread.
[email protected]96ab016c2013-10-23 00:50:292094 limits.mapped_memory_reclaim_limit =
[email protected]657be322013-09-20 08:50:032095 max_transfer_buffer_usage_mb * kBytesPerMegabyte;
[email protected]b6eb8e332013-09-10 00:51:012096#endif
[email protected]96ab016c2013-10-23 00:50:292097
[email protected]96ab016c2013-10-23 00:50:292098 scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
[email protected]828a3932014-04-02 14:43:132099 new WebGraphicsContext3DCommandBufferImpl(surface_id(),
2100 GetURLForGraphicsContext3D(),
2101 gpu_channel_host.get(),
2102 attributes,
[email protected]828a3932014-04-02 14:43:132103 lose_context_when_out_of_memory,
2104 limits,
2105 NULL));
[email protected]0634cdd42013-08-16 00:46:092106 return context.Pass();
[email protected]ed7defa2013-03-12 21:29:592107}
2108
[email protected]bffc8302014-01-23 20:52:162109void RenderWidget::RegisterSwappedOutChildFrame(RenderFrameImpl* frame) {
2110 swapped_out_frames_.AddObserver(frame);
2111}
2112
2113void RenderWidget::UnregisterSwappedOutChildFrame(RenderFrameImpl* frame) {
2114 swapped_out_frames_.RemoveObserver(frame);
2115}
2116
[email protected]e9ff79c2012-10-19 21:31:262117} // namespace content