blob: 44d2aaa810062759a17df25997d6991cc187f5a7 [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]c27dd4f2014-05-22 18:05:197#include "base/auto_reset.h"
[email protected]32876ae2011-11-15 22:25:218#include "base/bind.h"
[email protected]4fb66842009-12-04 21:41:009#include "base/command_line.h"
initial.commit09911bf2008-07-26 23:55:2910#include "base/logging.h"
[email protected]3b63f8f42011-03-28 01:54:1511#include "base/memory/scoped_ptr.h"
[email protected]b256eca2013-07-11 10:57:4012#include "base/memory/singleton.h"
[email protected]aaf68892013-07-18 00:11:3013#include "base/message_loop/message_loop.h"
[email protected]835d7c82010-10-14 04:38:3814#include "base/metrics/histogram.h"
[email protected]aa4117f2011-12-09 22:19:2115#include "base/stl_util.h"
[email protected]74ebfb12013-06-07 20:48:0016#include "base/strings/utf_string_conversions.h"
[email protected]35b4f0c2014-06-26 16:55:2717#include "base/sys_info.h"
primiano9e38d552015-01-28 04:18:0118#include "base/trace_event/trace_event.h"
19#include "base/trace_event/trace_event_synthetic_delay.h"
[email protected]661eb9d2009-02-03 02:11:4820#include "build/build_config.h"
[email protected]681ccff2013-03-18 06:13:5221#include "cc/base/switches.h"
[email protected]adbe30f2013-10-11 21:12:3322#include "cc/debug/benchmark_instrumentation.h"
[email protected]7f0d825f2013-03-18 07:24:3023#include "cc/output/output_surface.h"
[email protected]556fd292013-03-18 08:03:0424#include "cc/trees/layer_tree_host.h"
alexclarke7819e2552015-06-03 11:17:2125#include "components/scheduler/renderer/renderer_scheduler.h"
[email protected]29e2fb42013-07-19 01:13:4726#include "content/child/npapi/webplugin.h"
[email protected]0634cdd42013-08-16 00:46:0927#include "content/common/gpu/client/context_provider_command_buffer.h"
[email protected]ed7defa2013-03-12 21:29:5928#include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
[email protected]96ab016c2013-10-23 00:50:2929#include "content/common/gpu/gpu_process_launch_causes.h"
[email protected]9017d7852013-11-21 17:47:3530#include "content/common/input/synthetic_gesture_packet.h"
[email protected]8e299aa2013-10-16 18:17:4431#include "content/common/input/web_input_event_traits.h"
[email protected]c084330e02013-04-27 01:08:1532#include "content/common/input_messages.h"
[email protected]992db4c2011-05-12 15:37:1533#include "content/common/swapped_out_messages.h"
[email protected]778574e2011-03-21 22:03:5034#include "content/common/view_messages.h"
[email protected]c08950d22011-10-13 22:20:2935#include "content/public/common/content_switches.h"
[email protected]a09d53ce2014-01-31 00:46:4236#include "content/public/common/context_menu_params.h"
[email protected]953bd0062013-08-01 00:58:4037#include "content/renderer/cursor_utils.h"
[email protected]b2e4c70132013-10-03 02:07:5138#include "content/renderer/external_popup_menu.h"
[email protected]ed7defa2013-03-12 21:29:5939#include "content/renderer/gpu/compositor_output_surface.h"
[email protected]36e5ff12013-06-11 12:19:2940#include "content/renderer/gpu/delegated_compositor_output_surface.h"
[email protected]586871b2014-07-22 17:05:1141#include "content/renderer/gpu/frame_swap_message_queue.h"
[email protected]ed7defa2013-03-12 21:29:5942#include "content/renderer/gpu/mailbox_output_surface.h"
[email protected]586871b2014-07-22 17:05:1143#include "content/renderer/gpu/queue_message_swap_promise.h"
[email protected]ba91a792013-02-06 09:48:2844#include "content/renderer/gpu/render_widget_compositor.h"
[email protected]66fca5bc2013-05-23 06:58:2945#include "content/renderer/ime_event_guard.h"
[email protected]7a72d452013-12-13 10:01:1346#include "content/renderer/input/input_handler_manager.h"
[email protected]adab2332013-07-25 18:04:3247#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
[email protected]bffc8302014-01-23 20:52:1648#include "content/renderer/render_frame_impl.h"
[email protected]e3244ed2014-06-20 20:04:2749#include "content/renderer/render_frame_proxy.h"
[email protected]8704f89b2011-04-15 00:30:0550#include "content/renderer/render_process.h"
[email protected]f1a29a02011-10-06 23:08:4451#include "content/renderer/render_thread_impl.h"
tfarina556a7232014-10-05 01:02:0952#include "content/renderer/renderer_blink_platform_impl.h"
[email protected]5b45ad42013-10-25 00:42:0453#include "content/renderer/resizing_mode_selector.h"
[email protected]484955942010-08-19 16:13:1854#include "ipc/ipc_sync_message.h"
[email protected]661eb9d2009-02-03 02:11:4855#include "skia/ext/platform_canvas.h"
[email protected]ec173b522013-11-14 11:01:1856#include "third_party/WebKit/public/platform/WebCursorInfo.h"
[email protected]aaf68892013-07-18 00:11:3057#include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
donnda070f3c2015-01-16 19:54:1158#include "third_party/WebKit/public/platform/WebPoint.h"
[email protected]aaf68892013-07-18 00:11:3059#include "third_party/WebKit/public/platform/WebRect.h"
[email protected]ec173b522013-11-14 11:01:1860#include "third_party/WebKit/public/platform/WebScreenInfo.h"
[email protected]aaf68892013-07-18 00:11:3061#include "third_party/WebKit/public/platform/WebSize.h"
62#include "third_party/WebKit/public/platform/WebString.h"
[email protected]19193682014-04-03 15:01:4363#include "third_party/WebKit/public/web/WebDeviceEmulationParams.h"
kenrba7199832015-01-22 23:44:5964#include "third_party/WebKit/public/web/WebFrameWidget.h"
65#include "third_party/WebKit/public/web/WebLocalFrame.h"
donnda070f3c2015-01-16 19:54:1166#include "third_party/WebKit/public/web/WebNode.h"
[email protected]2255a9332013-06-17 05:12:3167#include "third_party/WebKit/public/web/WebPagePopup.h"
[email protected]2255a9332013-06-17 05:12:3168#include "third_party/WebKit/public/web/WebPopupMenuInfo.h"
69#include "third_party/WebKit/public/web/WebRange.h"
jddukeacf809e2014-09-23 20:38:3870#include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
kenrba7199832015-01-22 23:44:5971#include "third_party/WebKit/public/web/WebView.h"
[email protected]d353541f2012-05-03 22:45:4172#include "third_party/skia/include/core/SkShader.h"
[email protected]faec7b12012-06-19 14:42:1373#include "ui/base/ui_base_switches.h"
tfarina655f81d2014-12-23 02:38:5074#include "ui/gfx/geometry/point_conversions.h"
tfarina3b0452d2014-12-31 15:20:0975#include "ui/gfx/geometry/rect_conversions.h"
tfarinaebe974f02015-01-03 04:25:3276#include "ui/gfx/geometry/size_conversions.h"
[email protected]1835b9e2012-02-28 13:12:4877#include "ui/gfx/skia_util.h"
[email protected]c9e2cbbb2012-05-12 21:17:2778#include "ui/gl/gl_switches.h"
[email protected]d353541f2012-05-03 22:45:4179#include "ui/surface/transport_dib.h"
[email protected]661eb9d2009-02-03 02:11:4880
[email protected]eeb93112013-05-01 19:41:1081#if defined(OS_ANDROID)
[email protected]cefe9b152014-03-27 18:16:1582#include <android/keycodes.h>
[email protected]913d99a2013-05-31 07:16:0783#include "content/renderer/android/synchronous_compositor_factory.h"
[email protected]eeb93112013-05-01 19:41:1084#endif
85
[email protected]661eb9d2009-02-03 02:11:4886#if defined(OS_POSIX)
[email protected]6b889fb2010-03-23 20:09:4987#include "ipc/ipc_channel_posix.h"
[email protected]d5282e72009-05-13 13:16:5288#include "third_party/skia/include/core/SkMallocPixelRef.h"
[email protected]d353541f2012-05-03 22:45:4189#include "third_party/skia/include/core/SkPixelRef.h"
[email protected]661eb9d2009-02-03 02:11:4890#endif // defined(OS_POSIX)
[email protected]8085dbc82008-09-26 22:53:4491
[email protected]2255a9332013-06-17 05:12:3192#include "third_party/WebKit/public/web/WebWidget.h"
initial.commit09911bf2008-07-26 23:55:2993
[email protected]180ef242013-11-07 06:50:4694using blink::WebCompositionUnderline;
95using blink::WebCursorInfo;
[email protected]19193682014-04-03 15:01:4396using blink::WebDeviceEmulationParams;
[email protected]180ef242013-11-07 06:50:4697using blink::WebGestureEvent;
98using blink::WebInputEvent;
99using blink::WebKeyboardEvent;
100using blink::WebMouseEvent;
101using blink::WebMouseWheelEvent;
102using blink::WebNavigationPolicy;
donnda070f3c2015-01-16 19:54:11103using blink::WebNode;
[email protected]180ef242013-11-07 06:50:46104using blink::WebPagePopup;
donnda070f3c2015-01-16 19:54:11105using blink::WebPoint;
[email protected]180ef242013-11-07 06:50:46106using blink::WebPopupType;
107using blink::WebRange;
108using blink::WebRect;
109using blink::WebScreenInfo;
110using blink::WebSize;
111using blink::WebTextDirection;
112using blink::WebTouchEvent;
[email protected]f8ed4722013-12-03 03:27:25113using blink::WebTouchPoint;
[email protected]180ef242013-11-07 06:50:46114using blink::WebVector;
115using blink::WebWidget;
[email protected]e9ff79c2012-10-19 21:31:26116
[email protected]6a4d7f62013-01-07 21:32:13117namespace {
[email protected]b256eca2013-07-11 10:57:40118
119typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
120
121class TextInputModeMapSingleton {
122 public:
123 static TextInputModeMapSingleton* GetInstance() {
olli.raula36aa8be2015-09-10 11:14:22124 return base::Singleton<TextInputModeMapSingleton>::get();
[email protected]b256eca2013-07-11 10:57:40125 }
[email protected]dd705d4d2013-11-27 08:14:41126 TextInputModeMapSingleton() {
127 map_["verbatim"] = ui::TEXT_INPUT_MODE_VERBATIM;
128 map_["latin"] = ui::TEXT_INPUT_MODE_LATIN;
129 map_["latin-name"] = ui::TEXT_INPUT_MODE_LATIN_NAME;
130 map_["latin-prose"] = ui::TEXT_INPUT_MODE_LATIN_PROSE;
131 map_["full-width-latin"] = ui::TEXT_INPUT_MODE_FULL_WIDTH_LATIN;
132 map_["kana"] = ui::TEXT_INPUT_MODE_KANA;
133 map_["katakana"] = ui::TEXT_INPUT_MODE_KATAKANA;
134 map_["numeric"] = ui::TEXT_INPUT_MODE_NUMERIC;
135 map_["tel"] = ui::TEXT_INPUT_MODE_TEL;
136 map_["email"] = ui::TEXT_INPUT_MODE_EMAIL;
137 map_["url"] = ui::TEXT_INPUT_MODE_URL;
[email protected]b256eca2013-07-11 10:57:40138 }
[email protected]dd705d4d2013-11-27 08:14:41139 const TextInputModeMap& map() const { return map_; }
[email protected]b256eca2013-07-11 10:57:40140 private:
[email protected]dd705d4d2013-11-27 08:14:41141 TextInputModeMap map_;
[email protected]b256eca2013-07-11 10:57:40142
olli.raula36aa8be2015-09-10 11:14:22143 friend struct base::DefaultSingletonTraits<TextInputModeMapSingleton>;
[email protected]b256eca2013-07-11 10:57:40144
145 DISALLOW_COPY_AND_ASSIGN(TextInputModeMapSingleton);
146};
147
[email protected]dd705d4d2013-11-27 08:14:41148ui::TextInputMode ConvertInputMode(const blink::WebString& input_mode) {
[email protected]b256eca2013-07-11 10:57:40149 static TextInputModeMapSingleton* singleton =
150 TextInputModeMapSingleton::GetInstance();
[email protected]dd705d4d2013-11-27 08:14:41151 TextInputModeMap::const_iterator it =
152 singleton->map().find(input_mode.utf8());
153 if (it == singleton->map().end())
[email protected]b256eca2013-07-11 10:57:40154 return ui::TEXT_INPUT_MODE_DEFAULT;
155 return it->second;
[email protected]6a4d7f62013-01-07 21:32:13156}
[email protected]b256eca2013-07-11 10:57:40157
[email protected]fd847792013-10-24 17:12:35158// TODO(brianderson): Replace the hard-coded threshold with a fraction of
159// the BeginMainFrame interval.
160// 4166us will allow 1/4 of a 60Hz interval or 1/2 of a 120Hz interval to
161// be spent in input hanlders before input starts getting throttled.
162const int kInputHandlingTimeThrottlingThresholdMicroseconds = 4166;
163
miletus14a25642015-08-13 19:23:23164int64 GetEventLatencyMicros(double event_timestamp, base::TimeTicks now) {
165 return (now - base::TimeDelta::FromSecondsD(event_timestamp))
jdduke07788062014-12-05 03:16:30166 .ToInternalValue();
167}
168
miletus14a25642015-08-13 19:23:23169void LogInputEventLatencyUmaImpl(WebInputEvent::Type event_type,
170 double event_timestamp,
171 base::TimeTicks now) {
172 UMA_HISTOGRAM_CUSTOM_COUNTS("Event.AggregatedLatency.Renderer2",
173 GetEventLatencyMicros(event_timestamp, now), 1,
174 10000000, 100);
jdduke07788062014-12-05 03:16:30175
miletus14a25642015-08-13 19:23:23176#define CASE_TYPE(t) \
177 case WebInputEvent::t: \
178 UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.Renderer2." #t, \
179 GetEventLatencyMicros(event_timestamp, now), \
180 1, 10000000, 100); \
181 break;
jdduke07788062014-12-05 03:16:30182
miletus14a25642015-08-13 19:23:23183 switch (event_type) {
jdduke07788062014-12-05 03:16:30184 CASE_TYPE(Undefined);
185 CASE_TYPE(MouseDown);
186 CASE_TYPE(MouseUp);
187 CASE_TYPE(MouseMove);
188 CASE_TYPE(MouseEnter);
189 CASE_TYPE(MouseLeave);
190 CASE_TYPE(ContextMenu);
191 CASE_TYPE(MouseWheel);
192 CASE_TYPE(RawKeyDown);
193 CASE_TYPE(KeyDown);
194 CASE_TYPE(KeyUp);
195 CASE_TYPE(Char);
196 CASE_TYPE(GestureScrollBegin);
197 CASE_TYPE(GestureScrollEnd);
198 CASE_TYPE(GestureScrollUpdate);
199 CASE_TYPE(GestureFlingStart);
200 CASE_TYPE(GestureFlingCancel);
201 CASE_TYPE(GestureShowPress);
202 CASE_TYPE(GestureTap);
203 CASE_TYPE(GestureTapUnconfirmed);
204 CASE_TYPE(GestureTapDown);
205 CASE_TYPE(GestureTapCancel);
206 CASE_TYPE(GestureDoubleTap);
207 CASE_TYPE(GestureTwoFingerTap);
208 CASE_TYPE(GestureLongPress);
209 CASE_TYPE(GestureLongTap);
210 CASE_TYPE(GesturePinchBegin);
211 CASE_TYPE(GesturePinchEnd);
212 CASE_TYPE(GesturePinchUpdate);
213 CASE_TYPE(TouchStart);
214 CASE_TYPE(TouchMove);
215 CASE_TYPE(TouchEnd);
216 CASE_TYPE(TouchCancel);
217 default:
218 // Must include default to let blink::WebInputEvent add new event types
219 // before they're added here.
miletus14a25642015-08-13 19:23:23220 DLOG(WARNING) << "Unhandled WebInputEvent type: " << event_type;
jdduke07788062014-12-05 03:16:30221 break;
222 }
223
224#undef CASE_TYPE
225}
226
miletus14a25642015-08-13 19:23:23227void LogInputEventLatencyUma(const WebInputEvent& event, base::TimeTicks now,
228 const ui::LatencyInfo& latency_info) {
229 LogInputEventLatencyUmaImpl(event.type, event.timeStampSeconds, now);
230 for (size_t i = 0; i < latency_info.coalesced_events_size(); i++) {
231 LogInputEventLatencyUmaImpl(
232 event.type,
233 latency_info.timestamps_of_coalesced_events()[i],
234 now);
235 }
236}
237
[email protected]b256eca2013-07-11 10:57:40238} // namespace
239
[email protected]e9ff79c2012-10-19 21:31:26240namespace content {
[email protected]62cb33cae2009-03-27 23:30:22241
[email protected]b2e4c70132013-10-03 02:07:51242// RenderWidget::ScreenMetricsEmulator ----------------------------------------
243
244class RenderWidget::ScreenMetricsEmulator {
245 public:
246 ScreenMetricsEmulator(
247 RenderWidget* widget,
[email protected]19193682014-04-03 15:01:43248 const WebDeviceEmulationParams& params);
[email protected]b2e4c70132013-10-03 02:07:51249 virtual ~ScreenMetricsEmulator();
250
[email protected]19193682014-04-03 15:01:43251 // Scale and offset used to convert between host coordinates
252 // and webwidget coordinates.
[email protected]b2e4c70132013-10-03 02:07:51253 float scale() { return scale_; }
dgozman9260b0a12015-03-16 13:45:20254 gfx::PointF offset() { return offset_; }
[email protected]19193682014-04-03 15:01:43255 gfx::Rect applied_widget_rect() const { return applied_widget_rect_; }
[email protected]b2e4c70132013-10-03 02:07:51256 gfx::Rect original_screen_rect() const { return original_view_screen_rect_; }
[email protected]5f75aa42014-04-01 23:00:56257 const WebScreenInfo& original_screen_info() { return original_screen_info_; }
[email protected]b2e4c70132013-10-03 02:07:51258
259 void ChangeEmulationParams(
[email protected]19193682014-04-03 15:01:43260 const WebDeviceEmulationParams& params);
[email protected]b2e4c70132013-10-03 02:07:51261
262 // The following methods alter handlers' behavior for messages related to
263 // widget size and position.
264 void OnResizeMessage(const ViewMsg_Resize_Params& params);
265 void OnUpdateScreenRectsMessage(const gfx::Rect& view_screen_rect,
266 const gfx::Rect& window_screen_rect);
267 void OnShowContextMenu(ContextMenuParams* params);
[email protected]2d6836f42014-07-02 17:25:31268 gfx::Rect AdjustValidationMessageAnchor(const gfx::Rect& anchor);
[email protected]b2e4c70132013-10-03 02:07:51269
270 private:
[email protected]19193682014-04-03 15:01:43271 void Reapply();
dtrainorcb7779b82014-12-04 01:08:02272 void Apply(bool top_controls_shrink_blink_size,
273 float top_controls_height,
[email protected]bb6378fe2014-04-28 21:19:44274 gfx::Rect resizer_rect,
mikhail.pozdnyakovc0e251b2015-04-15 06:51:12275 bool is_fullscreen_granted,
276 blink::WebDisplayMode display_mode);
[email protected]b2e4c70132013-10-03 02:07:51277
278 RenderWidget* widget_;
279
[email protected]7f99fc22013-11-08 14:05:58280 // Parameters as passed by RenderWidget::EnableScreenMetricsEmulation.
[email protected]19193682014-04-03 15:01:43281 WebDeviceEmulationParams params_;
[email protected]b2e4c70132013-10-03 02:07:51282
[email protected]a179d3962013-11-12 14:44:40283 // The computed scale and offset used to fit widget into browser window.
[email protected]b2e4c70132013-10-03 02:07:51284 float scale_;
dgozman9260b0a12015-03-16 13:45:20285 gfx::PointF offset_;
[email protected]b2e4c70132013-10-03 02:07:51286
[email protected]19193682014-04-03 15:01:43287 // Widget rect as passed to webwidget.
288 gfx::Rect applied_widget_rect_;
289
[email protected]b2e4c70132013-10-03 02:07:51290 // Original values to restore back after emulation ends.
291 gfx::Size original_size_;
292 gfx::Size original_physical_backing_size_;
[email protected]6949e0d22014-06-02 22:39:28293 gfx::Size original_visible_viewport_size_;
[email protected]180ef242013-11-07 06:50:46294 blink::WebScreenInfo original_screen_info_;
[email protected]b2e4c70132013-10-03 02:07:51295 gfx::Rect original_view_screen_rect_;
296 gfx::Rect original_window_screen_rect_;
297};
298
299RenderWidget::ScreenMetricsEmulator::ScreenMetricsEmulator(
300 RenderWidget* widget,
[email protected]19193682014-04-03 15:01:43301 const WebDeviceEmulationParams& params)
[email protected]b2e4c70132013-10-03 02:07:51302 : widget_(widget),
[email protected]19193682014-04-03 15:01:43303 params_(params),
[email protected]b2e4c70132013-10-03 02:07:51304 scale_(1.f) {
305 original_size_ = widget_->size_;
306 original_physical_backing_size_ = widget_->physical_backing_size_;
[email protected]6949e0d22014-06-02 22:39:28307 original_visible_viewport_size_ = widget_->visible_viewport_size_;
[email protected]b2e4c70132013-10-03 02:07:51308 original_screen_info_ = widget_->screen_info_;
309 original_view_screen_rect_ = widget_->view_screen_rect_;
310 original_window_screen_rect_ = widget_->window_screen_rect_;
dtrainorcb7779b82014-12-04 01:08:02311 Apply(widget_->top_controls_shrink_blink_size_,
312 widget_->top_controls_height_,
313 widget_->resizer_rect_,
mikhail.pozdnyakovc0e251b2015-04-15 06:51:12314 widget_->is_fullscreen_granted_,
315 widget_->display_mode_);
[email protected]b2e4c70132013-10-03 02:07:51316}
317
318RenderWidget::ScreenMetricsEmulator::~ScreenMetricsEmulator() {
319 widget_->screen_info_ = original_screen_info_;
320
321 widget_->SetDeviceScaleFactor(original_screen_info_.deviceScaleFactor);
dgozman9260b0a12015-03-16 13:45:20322 widget_->SetScreenMetricsEmulationParameters(false, params_);
[email protected]b2e4c70132013-10-03 02:07:51323 widget_->view_screen_rect_ = original_view_screen_rect_;
324 widget_->window_screen_rect_ = original_window_screen_rect_;
[email protected]587941d2014-08-22 01:40:01325 widget_->Resize(original_size_,
326 original_physical_backing_size_,
dtrainorcb7779b82014-12-04 01:08:02327 widget_->top_controls_shrink_blink_size_,
328 widget_->top_controls_height_,
[email protected]587941d2014-08-22 01:40:01329 original_visible_viewport_size_,
330 widget_->resizer_rect_,
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12331 widget_->is_fullscreen_granted_,
mikhail.pozdnyakovc0e251b2015-04-15 06:51:12332 widget_->display_mode_,
[email protected]587941d2014-08-22 01:40:01333 NO_RESIZE_ACK);
[email protected]b2e4c70132013-10-03 02:07:51334}
335
336void RenderWidget::ScreenMetricsEmulator::ChangeEmulationParams(
[email protected]19193682014-04-03 15:01:43337 const WebDeviceEmulationParams& params) {
338 params_ = params;
339 Reapply();
340}
341
342void RenderWidget::ScreenMetricsEmulator::Reapply() {
dtrainorcb7779b82014-12-04 01:08:02343 Apply(widget_->top_controls_shrink_blink_size_,
344 widget_->top_controls_height_,
345 widget_->resizer_rect_,
mikhail.pozdnyakovc0e251b2015-04-15 06:51:12346 widget_->is_fullscreen_granted_,
347 widget_->display_mode_);
[email protected]b2e4c70132013-10-03 02:07:51348}
349
[email protected]19193682014-04-03 15:01:43350void RenderWidget::ScreenMetricsEmulator::Apply(
dtrainorcb7779b82014-12-04 01:08:02351 bool top_controls_shrink_blink_size,
352 float top_controls_height,
[email protected]bb6378fe2014-04-28 21:19:44353 gfx::Rect resizer_rect,
mikhail.pozdnyakovc0e251b2015-04-15 06:51:12354 bool is_fullscreen_granted,
355 blink::WebDisplayMode display_mode) {
[email protected]92d13b72014-05-09 14:42:31356 applied_widget_rect_.set_size(gfx::Size(params_.viewSize));
357 if (!applied_widget_rect_.width())
358 applied_widget_rect_.set_width(original_size_.width());
359 if (!applied_widget_rect_.height())
360 applied_widget_rect_.set_height(original_size_.height());
[email protected]19193682014-04-03 15:01:43361
[email protected]f442ee42014-05-14 11:53:12362 if (params_.fitToView && !original_size_.IsEmpty()) {
[email protected]0b3578c2014-06-20 18:29:02363 int original_width = std::max(original_size_.width(), 1);
364 int original_height = std::max(original_size_.height(), 1);
[email protected]b2e4c70132013-10-03 02:07:51365 float width_ratio =
[email protected]0b3578c2014-06-20 18:29:02366 static_cast<float>(applied_widget_rect_.width()) / original_width;
[email protected]b2e4c70132013-10-03 02:07:51367 float height_ratio =
[email protected]0b3578c2014-06-20 18:29:02368 static_cast<float>(applied_widget_rect_.height()) / original_height;
[email protected]b2e4c70132013-10-03 02:07:51369 float ratio = std::max(1.0f, std::max(width_ratio, height_ratio));
370 scale_ = 1.f / ratio;
[email protected]7f0e8fa2014-03-26 12:32:01371
372 // Center emulated view inside available view space.
[email protected]19193682014-04-03 15:01:43373 offset_.set_x(
374 (original_size_.width() - scale_ * applied_widget_rect_.width()) / 2);
[email protected]7f0e8fa2014-03-26 12:32:01375 offset_.set_y(
[email protected]19193682014-04-03 15:01:43376 (original_size_.height() - scale_ * applied_widget_rect_.height()) / 2);
[email protected]b2e4c70132013-10-03 02:07:51377 } else {
[email protected]0b3578c2014-06-20 18:29:02378 scale_ = params_.scale;
379 offset_.SetPoint(params_.offset.x, params_.offset.y);
[email protected]7f0e8fa2014-03-26 12:32:01380 }
[email protected]7f0e8fa2014-03-26 12:32:01381
[email protected]19193682014-04-03 15:01:43382 if (params_.screenPosition == WebDeviceEmulationParams::Desktop) {
383 applied_widget_rect_.set_origin(original_view_screen_rect_.origin());
[email protected]7f0e8fa2014-03-26 12:32:01384 widget_->screen_info_.rect = original_screen_info_.rect;
385 widget_->screen_info_.availableRect = original_screen_info_.availableRect;
386 widget_->window_screen_rect_ = original_window_screen_rect_;
387 } else {
dgozmanf28ccbe2015-06-24 08:50:49388 applied_widget_rect_.set_origin(params_.viewPosition);
389 gfx::Rect screen_rect = applied_widget_rect_;
390 if (!params_.screenSize.isEmpty()) {
391 screen_rect =
392 gfx::Rect(0, 0, params_.screenSize.width, params_.screenSize.height);
393 }
394 widget_->screen_info_.rect = screen_rect;
395 widget_->screen_info_.availableRect = screen_rect;
[email protected]19193682014-04-03 15:01:43396 widget_->window_screen_rect_ = applied_widget_rect_;
[email protected]7f0e8fa2014-03-26 12:32:01397 }
[email protected]a179d3962013-11-12 14:44:40398
[email protected]19193682014-04-03 15:01:43399 float applied_device_scale_factor = params_.deviceScaleFactor ?
400 params_.deviceScaleFactor : original_screen_info_.deviceScaleFactor;
[email protected]7f0e8fa2014-03-26 12:32:01401 widget_->screen_info_.deviceScaleFactor = applied_device_scale_factor;
[email protected]b2e4c70132013-10-03 02:07:51402
[email protected]7f99fc22013-11-08 14:05:58403 // Pass three emulation parameters to the blink side:
[email protected]b2e4c70132013-10-03 02:07:51404 // - we keep the real device scale factor in compositor to produce sharp image
405 // even when emulating different scale factor;
[email protected]7f99fc22013-11-08 14:05:58406 // - in order to fit into view, WebView applies offset and scale to the
[email protected]b2e4c70132013-10-03 02:07:51407 // root layer.
dgozman9260b0a12015-03-16 13:45:20408 blink::WebDeviceEmulationParams modified_params = params_;
409 modified_params.deviceScaleFactor = original_screen_info_.deviceScaleFactor;
410 modified_params.offset = blink::WebFloatPoint(offset_.x(), offset_.y());
411 modified_params.scale = scale_;
412 widget_->SetScreenMetricsEmulationParameters(true, modified_params);
[email protected]b2e4c70132013-10-03 02:07:51413
[email protected]7f0e8fa2014-03-26 12:32:01414 widget_->SetDeviceScaleFactor(applied_device_scale_factor);
[email protected]19193682014-04-03 15:01:43415 widget_->view_screen_rect_ = applied_widget_rect_;
[email protected]b2e4c70132013-10-03 02:07:51416
417 gfx::Size physical_backing_size = gfx::ToCeiledSize(gfx::ScaleSize(
418 original_size_, original_screen_info_.deviceScaleFactor));
dtrainorcb7779b82014-12-04 01:08:02419 widget_->Resize(applied_widget_rect_.size(),
420 physical_backing_size,
421 top_controls_shrink_blink_size,
422 top_controls_height,
423 applied_widget_rect_.size(),
424 resizer_rect,
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12425 is_fullscreen_granted,
mikhail.pozdnyakovc0e251b2015-04-15 06:51:12426 display_mode,
dtrainorcb7779b82014-12-04 01:08:02427 NO_RESIZE_ACK);
[email protected]b2e4c70132013-10-03 02:07:51428}
429
430void RenderWidget::ScreenMetricsEmulator::OnResizeMessage(
431 const ViewMsg_Resize_Params& params) {
432 bool need_ack = params.new_size != original_size_ &&
433 !params.new_size.IsEmpty() && !params.physical_backing_size.IsEmpty();
434 original_size_ = params.new_size;
435 original_physical_backing_size_ = params.physical_backing_size;
436 original_screen_info_ = params.screen_info;
[email protected]6949e0d22014-06-02 22:39:28437 original_visible_viewport_size_ = params.visible_viewport_size;
dtrainorcb7779b82014-12-04 01:08:02438 Apply(params.top_controls_shrink_blink_size,
439 params.top_controls_height,
440 params.resizer_rect,
mikhail.pozdnyakovc0e251b2015-04-15 06:51:12441 params.is_fullscreen_granted,
442 params.display_mode);
[email protected]b2e4c70132013-10-03 02:07:51443
444 if (need_ack) {
445 widget_->set_next_paint_is_resize_ack();
446 if (widget_->compositor_)
447 widget_->compositor_->SetNeedsRedrawRect(gfx::Rect(widget_->size_));
448 }
449}
450
451void RenderWidget::ScreenMetricsEmulator::OnUpdateScreenRectsMessage(
452 const gfx::Rect& view_screen_rect,
453 const gfx::Rect& window_screen_rect) {
454 original_view_screen_rect_ = view_screen_rect;
455 original_window_screen_rect_ = window_screen_rect;
[email protected]19193682014-04-03 15:01:43456 if (params_.screenPosition == WebDeviceEmulationParams::Desktop)
457 Reapply();
[email protected]b2e4c70132013-10-03 02:07:51458}
459
460void RenderWidget::ScreenMetricsEmulator::OnShowContextMenu(
461 ContextMenuParams* params) {
462 params->x *= scale_;
[email protected]a179d3962013-11-12 14:44:40463 params->x += offset_.x();
[email protected]b2e4c70132013-10-03 02:07:51464 params->y *= scale_;
[email protected]a179d3962013-11-12 14:44:40465 params->y += offset_.y();
[email protected]b2e4c70132013-10-03 02:07:51466}
467
[email protected]2d6836f42014-07-02 17:25:31468gfx::Rect RenderWidget::ScreenMetricsEmulator::AdjustValidationMessageAnchor(
469 const gfx::Rect& anchor) {
danakj4606f6332015-08-31 23:56:56470 gfx::Rect scaled = gfx::ScaleToEnclosedRect(anchor, scale_);
[email protected]2d6836f42014-07-02 17:25:31471 scaled.set_x(scaled.x() + offset_.x());
472 scaled.set_y(scaled.y() + offset_.y());
473 return scaled;
474}
475
[email protected]b2e4c70132013-10-03 02:07:51476// RenderWidget ---------------------------------------------------------------
477
dcheng35d31c112015-07-22 00:17:36478RenderWidget::RenderWidget(CompositorDependencies* compositor_deps,
479 blink::WebPopupType popup_type,
[email protected]180ef242013-11-07 06:50:46480 const blink::WebScreenInfo& screen_info,
[email protected]1ac10dca2013-08-20 20:47:04481 bool swapped_out,
[email protected]7912e822014-04-16 02:37:03482 bool hidden,
483 bool never_visible)
initial.commit09911bf2008-07-26 23:55:29484 : routing_id_(MSG_ROUTING_NONE),
dcheng35d31c112015-07-22 00:17:36485 compositor_deps_(compositor_deps),
danakj6e3bf8012014-12-16 18:27:53486 webwidget_(nullptr),
initial.commit09911bf2008-07-26 23:55:29487 opener_id_(MSG_ROUTING_NONE),
[email protected]fc4404d2012-11-07 19:53:30488 init_complete_(false),
dtrainorcb7779b82014-12-04 01:08:02489 top_controls_shrink_blink_size_(false),
490 top_controls_height_(0.f),
initial.commit09911bf2008-07-26 23:55:29491 next_paint_flags_(0),
[email protected]847a2582013-03-09 02:29:51492 auto_resize_mode_(false),
[email protected]ea3ee0a2012-05-15 03:43:09493 need_update_rect_for_auto_resize_(false),
initial.commit09911bf2008-07-26 23:55:29494 did_show_(false),
[email protected]1ac10dca2013-08-20 20:47:04495 is_hidden_(hidden),
[email protected]7912e822014-04-16 02:37:03496 never_visible_(never_visible),
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12497 is_fullscreen_granted_(false),
mikhail.pozdnyakovc0e251b2015-04-15 06:51:12498 display_mode_(blink::WebDisplayModeUndefined),
initial.commit09911bf2008-07-26 23:55:29499 has_focus_(false),
[email protected]5dd768212009-08-13 23:34:49500 handling_input_event_(false),
jddukec05612b2015-06-25 23:13:18501 handling_event_overscroll_(nullptr),
[email protected]e8f775f2013-02-14 21:00:50502 handling_ime_event_(false),
[email protected]c27dd4f2014-05-22 18:05:19503 handling_event_type_(WebInputEvent::Undefined),
504 ignore_ack_for_mouse_move_from_debugger_(false),
[email protected]661eb9d2009-02-03 02:11:48505 closing_(false),
[email protected]aeeedad2014-08-22 18:16:22506 host_closing_(false),
[email protected]14392a52012-05-02 20:28:44507 is_swapped_out_(swapped_out),
simonhong628f9812015-04-27 23:13:20508 for_oopif_(false),
[email protected]ad26ef42011-06-17 07:59:45509 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
[email protected]b256eca2013-07-11 10:57:40510 text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
shuchen82ce8c52014-10-23 01:55:20511 text_input_flags_(0),
[email protected]86ba5fcb2013-09-04 00:36:53512 can_compose_inline_(true),
[email protected]3e2b375b2010-04-07 17:03:12513 popup_type_(popup_type),
[email protected]867125a02009-12-10 06:01:48514 pending_window_rect_count_(0),
[email protected]b68a0e52011-12-08 15:11:12515 suppress_next_char_events_(false),
[email protected]842f10652012-06-06 01:54:04516 screen_info_(screen_info),
[email protected]3d779472012-11-15 20:49:52517 device_scale_factor_(screen_info_.deviceScaleFactor),
[email protected]53b4cc12013-07-18 23:02:30518 next_output_surface_id_(0),
[email protected]0d1ebed12013-08-05 22:01:13519#if defined(OS_ANDROID)
[email protected]90f24152014-04-09 12:41:36520 text_field_is_dirty_(false),
[email protected]0d1ebed12013-08-05 22:01:13521#endif
[email protected]b2e4c70132013-10-03 02:07:51522 popup_origin_scale_for_emulation_(0.f),
[email protected]586871b2014-07-22 17:05:11523 frame_swap_message_queue_(new FrameSwapMessageQueue()),
[email protected]a09d53ce2014-01-31 00:46:42524 resizing_mode_selector_(new ResizingModeSelector()),
[email protected]be1af0662014-07-29 19:55:51525 context_menu_source_type_(ui::MENU_SOURCE_MOUSE),
526 has_host_context_menu_location_(false) {
[email protected]8b3f0eb2012-05-03 19:15:05527 if (!swapped_out)
528 RenderProcess::current()->AddRefProcess();
[email protected]380244092011-10-07 17:26:27529 DCHECK(RenderThread::Get());
[email protected]3079c28a2014-06-24 03:38:53530 device_color_profile_.push_back('0');
changwan3a841162015-08-11 02:53:37531#if defined(OS_ANDROID)
532 text_input_info_history_.push_back(blink::WebTextInputInfo());
533#endif
initial.commit09911bf2008-07-26 23:55:29534}
535
536RenderWidget::~RenderWidget() {
[email protected]c5b3b5e2009-02-13 06:41:11537 DCHECK(!webwidget_) << "Leaking our WebWidget!";
[email protected]bffc8302014-01-23 20:52:16538
[email protected]992db4c2011-05-12 15:37:15539 // If we are swapped out, we have released already.
[email protected]d2e2f9ee2013-08-21 11:02:02540 if (!is_swapped_out_ && RenderProcess::current())
[email protected]992db4c2011-05-12 15:37:15541 RenderProcess::current()->ReleaseProcess();
initial.commit09911bf2008-07-26 23:55:29542}
543
[email protected]484955942010-08-19 16:13:18544// static
[email protected]8085dbc82008-09-26 22:53:44545RenderWidget* RenderWidget::Create(int32 opener_id,
danakj6e3bf8012014-12-16 18:27:53546 CompositorDependencies* compositor_deps,
[email protected]180ef242013-11-07 06:50:46547 blink::WebPopupType popup_type,
548 const blink::WebScreenInfo& screen_info) {
initial.commit09911bf2008-07-26 23:55:29549 DCHECK(opener_id != MSG_ROUTING_NONE);
dcheng35d31c112015-07-22 00:17:36550 scoped_refptr<RenderWidget> widget(new RenderWidget(
551 compositor_deps, popup_type, screen_info, false, false, false));
552 if (widget->Init(opener_id)) { // adds reference on success.
[email protected]fc72bb12013-06-02 21:13:46553 return widget.get();
[email protected]a635f942012-12-07 10:34:29554 }
555 return NULL;
initial.commit09911bf2008-07-26 23:55:29556}
557
[email protected]484955942010-08-19 16:13:18558// static
kenrba7199832015-01-22 23:44:59559RenderWidget* RenderWidget::CreateForFrame(
560 int routing_id,
kenrba7199832015-01-22 23:44:59561 bool hidden,
562 const blink::WebScreenInfo& screen_info,
563 CompositorDependencies* compositor_deps,
564 blink::WebLocalFrame* frame) {
565 CHECK_NE(routing_id, MSG_ROUTING_NONE);
dcheng35d31c112015-07-22 00:17:36566 scoped_refptr<RenderWidget> widget(
567 new RenderWidget(compositor_deps, blink::WebPopupTypeNone, screen_info,
568 false, hidden, false));
kenrba7199832015-01-22 23:44:59569 widget->routing_id_ = routing_id;
simonhong628f9812015-04-27 23:13:20570 widget->for_oopif_ = true;
kenrba7199832015-01-22 23:44:59571 // DoInit increments the reference count on |widget|, keeping it alive after
572 // this function returns.
dcheng35d31c112015-07-22 00:17:36573 if (widget->DoInit(MSG_ROUTING_NONE,
kenrba7199832015-01-22 23:44:59574 RenderWidget::CreateWebFrameWidget(widget.get(), frame),
575 nullptr)) {
576 widget->CompleteInit();
577 return widget.get();
578 }
579 return nullptr;
580}
581
582// static
dchengda9b4bb2015-07-20 20:58:08583blink::WebWidget* RenderWidget::CreateWebFrameWidget(
584 RenderWidget* render_widget,
585 blink::WebLocalFrame* frame) {
586 return blink::WebFrameWidget::create(render_widget, frame);
587}
588
589// static
kenrba7199832015-01-22 23:44:59590blink::WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) {
[email protected]484955942010-08-19 16:13:18591 switch (render_widget->popup_type_) {
[email protected]180ef242013-11-07 06:50:46592 case blink::WebPopupTypeNone: // Nothing to create.
[email protected]484955942010-08-19 16:13:18593 break;
[email protected]180ef242013-11-07 06:50:46594 case blink::WebPopupTypePage:
[email protected]a7547fb2012-03-08 04:43:44595 return WebPagePopup::create(render_widget);
[email protected]484955942010-08-19 16:13:18596 default:
597 NOTREACHED();
598 }
599 return NULL;
600}
601
dchengda9b4bb2015-07-20 20:58:08602void RenderWidget::CloseForFrame() {
dchengd96a27a2015-07-24 20:17:32603 OnClose();
kenrba7199832015-01-22 23:44:59604}
605
dcheng35d31c112015-07-22 00:17:36606bool RenderWidget::Init(int32 opener_id) {
piman5d36dae2015-09-24 22:47:05607 return DoInit(
608 opener_id, RenderWidget::CreateWebWidget(this),
609 new ViewHostMsg_CreateWidget(opener_id, popup_type_, &routing_id_));
[email protected]484955942010-08-19 16:13:18610}
611
[email protected]a635f942012-12-07 10:34:29612bool RenderWidget::DoInit(int32 opener_id,
[email protected]6a8ddba52010-09-05 04:38:06613 WebWidget* web_widget,
[email protected]484955942010-08-19 16:13:18614 IPC::SyncMessage* create_widget_message) {
initial.commit09911bf2008-07-26 23:55:29615 DCHECK(!webwidget_);
616
617 if (opener_id != MSG_ROUTING_NONE)
618 opener_id_ = opener_id;
619
[email protected]484955942010-08-19 16:13:18620 webwidget_ = web_widget;
initial.commit09911bf2008-07-26 23:55:29621
kenrba7199832015-01-22 23:44:59622 bool result = true;
623 if (create_widget_message)
624 result = RenderThread::Get()->Send(create_widget_message);
625
initial.commit09911bf2008-07-26 23:55:29626 if (result) {
[email protected]380244092011-10-07 17:26:27627 RenderThread::Get()->AddRoute(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29628 // Take a reference on behalf of the RenderThread. This will be balanced
629 // when we receive ViewMsg_Close.
630 AddRef();
[email protected]b2db9272014-01-10 17:42:00631 if (RenderThreadImpl::current()) {
632 RenderThreadImpl::current()->WidgetCreated();
633 if (is_hidden_)
634 RenderThreadImpl::current()->WidgetHidden();
635 }
[email protected]a635f942012-12-07 10:34:29636 return true;
initial.commit09911bf2008-07-26 23:55:29637 } else {
[email protected]a635f942012-12-07 10:34:29638 // The above Send can fail when the tab is closing.
639 return false;
initial.commit09911bf2008-07-26 23:55:29640 }
641}
642
[email protected]fc4404d2012-11-07 19:53:30643// This is used to complete pending inits and non-pending inits.
644void RenderWidget::CompleteInit() {
initial.commit09911bf2008-07-26 23:55:29645 DCHECK(routing_id_ != MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29646
[email protected]fc4404d2012-11-07 19:53:30647 init_complete_ = true;
[email protected]05a980d7a2012-02-07 22:16:42648
piman4db52c12015-09-24 21:12:29649 // TODO(piman): do we still need the 2-stage initialization? crbug.com/535339
[email protected]7912e822014-04-16 02:37:03650 if (compositor_)
651 StartCompositor();
initial.commit09911bf2008-07-26 23:55:29652
[email protected]6de74452009-02-25 18:04:59653 Send(new ViewHostMsg_RenderViewReady(routing_id_));
initial.commit09911bf2008-07-26 23:55:29654}
655
[email protected]992db4c2011-05-12 15:37:15656void RenderWidget::SetSwappedOut(bool is_swapped_out) {
657 // We should only toggle between states.
658 DCHECK(is_swapped_out_ != is_swapped_out);
659 is_swapped_out_ = is_swapped_out;
660
661 // If we are swapping out, we will call ReleaseProcess, allowing the process
662 // to exit if all of its RenderViews are swapped out. We wait until the
[email protected]949b6592014-08-20 13:17:52663 // WasSwappedOut call to do this, to allow the unload handler to finish.
[email protected]992db4c2011-05-12 15:37:15664 // If we are swapping in, we call AddRefProcess to prevent the process from
665 // exiting.
[email protected]949b6592014-08-20 13:17:52666 if (!is_swapped_out_)
[email protected]992db4c2011-05-12 15:37:15667 RenderProcess::current()->AddRefProcess();
668}
669
[email protected]949b6592014-08-20 13:17:52670void RenderWidget::WasSwappedOut() {
671 // If we have been swapped out and no one else is using this process,
672 // it's safe to exit now.
673 CHECK(is_swapped_out_);
674 RenderProcess::current()->ReleaseProcess();
675}
676
[email protected]b2e4c70132013-10-03 02:07:51677void RenderWidget::SetPopupOriginAdjustmentsForEmulation(
678 ScreenMetricsEmulator* emulator) {
679 popup_origin_scale_for_emulation_ = emulator->scale();
[email protected]19193682014-04-03 15:01:43680 popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
[email protected]9a2d7ee32013-12-05 12:15:49681 popup_screen_origin_for_emulation_ = gfx::Point(
682 emulator->original_screen_rect().origin().x() + emulator->offset().x(),
683 emulator->original_screen_rect().origin().y() + emulator->offset().y());
[email protected]5f75aa42014-04-01 23:00:56684 screen_info_ = emulator->original_screen_info();
685 device_scale_factor_ = screen_info_.deviceScaleFactor;
[email protected]b2e4c70132013-10-03 02:07:51686}
687
[email protected]2d6836f42014-07-02 17:25:31688gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) {
689 if (screen_metrics_emulator_)
690 return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor);
691 return anchor;
692}
693
[email protected]b2e4c70132013-10-03 02:07:51694void RenderWidget::SetScreenMetricsEmulationParameters(
dgozman9260b0a12015-03-16 13:45:20695 bool enabled,
696 const blink::WebDeviceEmulationParams& params) {
[email protected]b2e4c70132013-10-03 02:07:51697 // This is only supported in RenderView.
698 NOTREACHED();
699}
700
[email protected]53907862014-03-25 15:42:40701#if defined(OS_MACOSX) || defined(OS_ANDROID)
[email protected]b2e4c70132013-10-03 02:07:51702void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
703 ExternalPopupMenu* popup, ScreenMetricsEmulator* emulator) {
[email protected]9a2d7ee32013-12-05 12:15:49704 popup->SetOriginScaleAndOffsetForEmulation(
705 emulator->scale(), emulator->offset());
[email protected]b2e4c70132013-10-03 02:07:51706}
[email protected]53907862014-03-25 15:42:40707#endif
[email protected]b2e4c70132013-10-03 02:07:51708
709void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
710 if (screen_metrics_emulator_)
711 screen_metrics_emulator_->OnShowContextMenu(params);
712}
713
[email protected]a95986a82010-12-24 06:19:28714bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
715 bool handled = true;
716 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
[email protected]c084330e02013-04-27 01:08:15717 IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
[email protected]34202de2013-05-06 23:36:22718 IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
719 OnCursorVisibilityChange)
[email protected]a2214eb2014-06-23 18:31:22720 IPC_MESSAGE_HANDLER(InputMsg_ImeSetComposition, OnImeSetComposition)
721 IPC_MESSAGE_HANDLER(InputMsg_ImeConfirmComposition, OnImeConfirmComposition)
[email protected]c084330e02013-04-27 01:08:15722 IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
723 IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
[email protected]9017d7852013-11-21 17:47:35724 IPC_MESSAGE_HANDLER(InputMsg_SyntheticGestureCompleted,
725 OnSyntheticGestureCompleted)
[email protected]a95986a82010-12-24 06:19:28726 IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
727 IPC_MESSAGE_HANDLER(ViewMsg_CreatingNew_ACK, OnCreatingNewAck)
728 IPC_MESSAGE_HANDLER(ViewMsg_Resize, OnResize)
dgozman9260b0a12015-03-16 13:45:20729 IPC_MESSAGE_HANDLER(ViewMsg_EnableDeviceEmulation,
730 OnEnableDeviceEmulation)
731 IPC_MESSAGE_HANDLER(ViewMsg_DisableDeviceEmulation,
732 OnDisableDeviceEmulation)
noel89949e62014-09-30 01:12:41733 IPC_MESSAGE_HANDLER(ViewMsg_ColorProfile, OnColorProfile)
[email protected]b5913d72012-02-07 22:26:54734 IPC_MESSAGE_HANDLER(ViewMsg_ChangeResizeRect, OnChangeResizeRect)
[email protected]a95986a82010-12-24 06:19:28735 IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
[email protected]9e2e4632012-07-27 16:38:41736 IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
[email protected]3d9ec5052013-01-02 22:05:25737 IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
[email protected]a95986a82010-12-24 06:19:28738 IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
739 IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
[email protected]80ad8622012-11-07 16:33:03740 IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
kenrbb4e2a3b2015-05-14 15:05:05741 IPC_MESSAGE_HANDLER(ViewMsg_SetSurfaceIdNamespace, OnSetSurfaceIdNamespace)
[email protected]105dffb42013-02-20 03:46:21742#if defined(OS_ANDROID)
changwan3a841162015-08-11 02:53:37743 IPC_MESSAGE_HANDLER(InputMsg_ImeEventAck, OnImeEventAck)
[email protected]2384b6c2013-02-28 23:58:51744 IPC_MESSAGE_HANDLER(ViewMsg_ShowImeIfNeeded, OnShowImeIfNeeded)
[email protected]105dffb42013-02-20 03:46:21745#endif
[email protected]a95986a82010-12-24 06:19:28746 IPC_MESSAGE_UNHANDLED(handled = false)
747 IPC_END_MESSAGE_MAP()
748 return handled;
749}
initial.commit09911bf2008-07-26 23:55:29750
751bool RenderWidget::Send(IPC::Message* message) {
[email protected]992db4c2011-05-12 15:37:15752 // Don't send any messages after the browser has told us to close, and filter
753 // most outgoing messages while swapped out.
754 if ((is_swapped_out_ &&
[email protected]e9ff79c2012-10-19 21:31:26755 !SwappedOutMessages::CanSendWhileSwappedOut(message)) ||
[email protected]c6c921e92012-05-10 23:31:11756 closing_) {
initial.commit09911bf2008-07-26 23:55:29757 delete message;
758 return false;
759 }
760
761 // If given a messsage without a routing ID, then assign our routing ID.
762 if (message->routing_id() == MSG_ROUTING_NONE)
763 message->set_routing_id(routing_id_);
764
[email protected]380244092011-10-07 17:26:27765 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44766}
767
[email protected]61e2b3cc2012-03-02 16:13:34768void RenderWidget::Resize(const gfx::Size& new_size,
[email protected]60d47ac2013-03-01 23:42:44769 const gfx::Size& physical_backing_size,
dtrainorcb7779b82014-12-04 01:08:02770 bool top_controls_shrink_blink_size,
771 float top_controls_height,
[email protected]bb6378fe2014-04-28 21:19:44772 const gfx::Size& visible_viewport_size,
[email protected]61e2b3cc2012-03-02 16:13:34773 const gfx::Rect& resizer_rect,
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12774 bool is_fullscreen_granted,
mikhail.pozdnyakovc0e251b2015-04-15 06:51:12775 blink::WebDisplayMode display_mode,
sievers4e33dae2015-02-25 20:43:58776 const ResizeAck resize_ack) {
[email protected]f7c1f092013-11-05 20:20:56777 if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
[email protected]1c0008842013-06-06 08:35:48778 // A resize ack shouldn't be requested if we have not ACK'd the previous
779 // one.
780 DCHECK(resize_ack != SEND_RESIZE_ACK || !next_paint_is_resize_ack());
781 DCHECK(resize_ack == SEND_RESIZE_ACK || resize_ack == NO_RESIZE_ACK);
782 }
initial.commit09911bf2008-07-26 23:55:29783
[email protected]61e2b3cc2012-03-02 16:13:34784 // Ignore this during shutdown.
785 if (!webwidget_)
786 return;
787
[email protected]d9083762013-03-24 01:36:40788 if (compositor_) {
[email protected]60d47ac2013-03-01 23:42:44789 compositor_->setViewportSize(new_size, physical_backing_size);
[email protected]d9083762013-03-24 01:36:40790 }
[email protected]60d47ac2013-03-01 23:42:44791
[email protected]dade8992013-03-04 07:34:34792 physical_backing_size_ = physical_backing_size;
dtrainorcb7779b82014-12-04 01:08:02793 top_controls_shrink_blink_size_ = top_controls_shrink_blink_size;
794 top_controls_height_ = top_controls_height;
[email protected]39244e72014-05-14 04:20:28795 visible_viewport_size_ = visible_viewport_size;
[email protected]61e2b3cc2012-03-02 16:13:34796 resizer_rect_ = resizer_rect;
797
798 // NOTE: We may have entered fullscreen mode without changing our size.
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12799 bool fullscreen_change = is_fullscreen_granted_ != is_fullscreen_granted;
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12800 is_fullscreen_granted_ = is_fullscreen_granted;
mikhail.pozdnyakovc0e251b2015-04-15 06:51:12801 display_mode_ = display_mode;
[email protected]61e2b3cc2012-03-02 16:13:34802
aelias6004fe02015-02-07 21:43:01803 webwidget_->setTopControlsHeight(top_controls_height,
804 top_controls_shrink_blink_size_);
bokan0c93cd82014-09-30 19:20:43805
[email protected]61e2b3cc2012-03-02 16:13:34806 if (size_ != new_size) {
[email protected]61e2b3cc2012-03-02 16:13:34807 size_ = new_size;
808
[email protected]61e2b3cc2012-03-02 16:13:34809 // When resizing, we want to wait to paint before ACK'ing the resize. This
810 // ensures that we only resize as fast as we can paint. We only need to
811 // send an ACK if we are resized to a non-empty rect.
812 webwidget_->resize(new_size);
[email protected]632c4382013-05-15 08:58:45813 }
814
[email protected]bb6378fe2014-04-28 21:19:44815 webwidget()->resizePinchViewport(gfx::Size(
816 visible_viewport_size.width(),
817 visible_viewport_size.height()));
818
[email protected]632c4382013-05-15 08:58:45819 if (new_size.IsEmpty() || physical_backing_size.IsEmpty()) {
sievers4e33dae2015-02-25 20:43:58820 // In this case there is no paint/composite and therefore no
821 // ViewHostMsg_UpdateRect to send the resize ack with. We'd need to send the
822 // ack through a fake ViewHostMsg_UpdateRect or a different message.
823 DCHECK_EQ(resize_ack, NO_RESIZE_ACK);
[email protected]61e2b3cc2012-03-02 16:13:34824 }
825
[email protected]20fbfc22013-05-08 20:50:58826 // Send the Resize_ACK flag once we paint again if requested.
[email protected]632c4382013-05-15 08:58:45827 if (resize_ack == SEND_RESIZE_ACK)
[email protected]20fbfc22013-05-08 20:50:58828 set_next_paint_is_resize_ack();
829
[email protected]61e2b3cc2012-03-02 16:13:34830 if (fullscreen_change)
831 DidToggleFullscreen();
832
833 // If a resize ack is requested and it isn't set-up, then no more resizes will
834 // come in and in general things will go wrong.
[email protected]632c4382013-05-15 08:58:45835 DCHECK(resize_ack != SEND_RESIZE_ACK || next_paint_is_resize_ack());
initial.commit09911bf2008-07-26 23:55:29836}
837
bokanc007c3a2015-02-03 07:15:56838void RenderWidget::SetWindowRectSynchronously(
839 const gfx::Rect& new_window_rect) {
840 Resize(new_window_rect.size(),
841 new_window_rect.size(),
dtrainorcb7779b82014-12-04 01:08:02842 top_controls_shrink_blink_size_,
843 top_controls_height_,
bokanc007c3a2015-02-03 07:15:56844 new_window_rect.size(),
[email protected]587941d2014-08-22 01:40:01845 gfx::Rect(),
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12846 is_fullscreen_granted_,
mikhail.pozdnyakovc0e251b2015-04-15 06:51:12847 display_mode_,
[email protected]587941d2014-08-22 01:40:01848 NO_RESIZE_ACK);
bokanc007c3a2015-02-03 07:15:56849 view_screen_rect_ = new_window_rect;
850 window_screen_rect_ = new_window_rect;
[email protected]92650162013-10-30 03:31:02851 if (!did_show_)
bokanc007c3a2015-02-03 07:15:56852 initial_rect_ = new_window_rect;
[email protected]92650162013-10-30 03:31:02853}
854
initial.commit09911bf2008-07-26 23:55:29855void RenderWidget::OnClose() {
dchengd96a27a2015-07-24 20:17:32856 DCHECK(content::RenderThread::Get());
857 if (closing_)
858 return;
859 NotifyOnClose();
860 closing_ = true;
861
862 // Browser correspondence is no longer needed at this point.
863 if (routing_id_ != MSG_ROUTING_NONE) {
864 RenderThread::Get()->RemoveRoute(routing_id_);
865 SetHidden(false);
866 if (RenderThreadImpl::current())
867 RenderThreadImpl::current()->WidgetDestroyed();
868 }
869
870 if (for_oopif_) {
871 // Widgets for frames may be created and closed at any time while the frame
872 // is alive. However, the closing process must happen synchronously. Frame
873 // widget and frames hold pointers to each other. If Close() is deferred to
874 // the message loop like in the non-frame widget case, WebWidget::close()
875 // can end up accessing members of an already-deleted frame.
876 Close();
877 } else {
878 // If there is a Send call on the stack, then it could be dangerous to close
879 // now. Post a task that only gets invoked when there are no nested message
880 // loops.
881 base::ThreadTaskRunnerHandle::Get()->PostNonNestableTask(
882 FROM_HERE, base::Bind(&RenderWidget::Close, this));
883 }
884
885 // Balances the AddRef taken when we called AddRoute.
886 Release();
initial.commit09911bf2008-07-26 23:55:29887}
888
[email protected]61e2b3cc2012-03-02 16:13:34889// Got a response from the browser after the renderer decided to create a new
890// view.
[email protected]fc4404d2012-11-07 19:53:30891void RenderWidget::OnCreatingNewAck() {
[email protected]61e2b3cc2012-03-02 16:13:34892 DCHECK(routing_id_ != MSG_ROUTING_NONE);
893
[email protected]fc4404d2012-11-07 19:53:30894 CompleteInit();
[email protected]61e2b3cc2012-03-02 16:13:34895}
896
[email protected]0fdd5012013-05-29 08:05:56897void RenderWidget::OnResize(const ViewMsg_Resize_Params& params) {
[email protected]5b45ad42013-10-25 00:42:04898 if (resizing_mode_selector_->ShouldAbortOnResize(this, params))
[email protected]03e88672013-10-22 21:31:32899 return;
900
[email protected]b2e4c70132013-10-03 02:07:51901 if (screen_metrics_emulator_) {
902 screen_metrics_emulator_->OnResizeMessage(params);
903 return;
904 }
905
[email protected]fcdc5642014-05-09 14:32:24906 bool orientation_changed =
907 screen_info_.orientationAngle != params.screen_info.orientationAngle;
908
[email protected]0fdd5012013-05-29 08:05:56909 screen_info_ = params.screen_info;
910 SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
dtrainorcb7779b82014-12-04 01:08:02911 Resize(params.new_size,
912 params.physical_backing_size,
913 params.top_controls_shrink_blink_size,
914 params.top_controls_height,
915 params.visible_viewport_size,
916 params.resizer_rect,
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12917 params.is_fullscreen_granted,
mikhail.pozdnyakovc0e251b2015-04-15 06:51:12918 params.display_mode,
sievers4e33dae2015-02-25 20:43:58919 params.needs_resize_ack ? SEND_RESIZE_ACK : NO_RESIZE_ACK);
[email protected]fcdc5642014-05-09 14:32:24920
921 if (orientation_changed)
922 OnOrientationChange();
initial.commit09911bf2008-07-26 23:55:29923}
924
dgozman9260b0a12015-03-16 13:45:20925void RenderWidget::OnEnableDeviceEmulation(
926 const blink::WebDeviceEmulationParams& params) {
927 if (!screen_metrics_emulator_)
928 screen_metrics_emulator_.reset(new ScreenMetricsEmulator(this, params));
929 else
930 screen_metrics_emulator_->ChangeEmulationParams(params);
931}
932
933void RenderWidget::OnDisableDeviceEmulation() {
934 screen_metrics_emulator_.reset();
935}
936
noel89949e62014-09-30 01:12:41937void RenderWidget::OnColorProfile(const std::vector<char>& color_profile) {
938 SetDeviceColorProfile(color_profile);
939}
940
[email protected]b5913d72012-02-07 22:26:54941void RenderWidget::OnChangeResizeRect(const gfx::Rect& resizer_rect) {
[email protected]721e2302014-04-30 23:42:01942 if (resizer_rect_ == resizer_rect)
943 return;
944 resizer_rect_ = resizer_rect;
945 if (webwidget_)
946 webwidget_->didChangeWindowResizerRect();
[email protected]b5913d72012-02-07 22:26:54947}
948
initial.commit09911bf2008-07-26 23:55:29949void RenderWidget::OnWasHidden() {
[email protected]9c3085f2011-06-09 02:10:31950 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
initial.commit09911bf2008-07-26 23:55:29951 // Go into a mode where we stop generating paint and scrolling events.
[email protected]bee16aab2009-08-26 15:55:03952 SetHidden(true);
[email protected]de3c5d82014-05-28 22:12:59953 FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
954 WasHidden());
initial.commit09911bf2008-07-26 23:55:29955}
956
[email protected]3399dd822014-08-09 11:14:24957void RenderWidget::OnWasShown(bool needs_repainting,
958 const ui::LatencyInfo& latency_info) {
[email protected]9e2e4632012-07-27 16:38:41959 TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
initial.commit09911bf2008-07-26 23:55:29960 // During shutdown we can just ignore this message.
961 if (!webwidget_)
962 return;
963
964 // See OnWasHidden
[email protected]bee16aab2009-08-26 15:55:03965 SetHidden(false);
[email protected]de3c5d82014-05-28 22:12:59966 FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
967 WasShown());
initial.commit09911bf2008-07-26 23:55:29968
[email protected]8a23afb32014-04-30 22:40:23969 if (!needs_repainting)
initial.commit09911bf2008-07-26 23:55:29970 return;
initial.commit09911bf2008-07-26 23:55:29971
972 // Generate a full repaint.
[email protected]3399dd822014-08-09 11:14:24973 if (compositor_) {
974 ui::LatencyInfo swap_latency_info(latency_info);
975 scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor(
976 compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info));
[email protected]aca33f4f2014-05-17 17:08:05977 compositor_->SetNeedsForcedRedraw();
[email protected]3399dd822014-08-09 11:14:24978 }
jdduke491a3f0c2015-06-15 23:30:26979 ScheduleComposite();
initial.commit09911bf2008-07-26 23:55:29980}
981
[email protected]53d3f302009-12-21 04:42:05982void RenderWidget::OnRequestMoveAck() {
983 DCHECK(pending_window_rect_count_);
984 pending_window_rect_count_--;
985}
986
[email protected]ed7defa2013-03-12 21:29:59987GURL RenderWidget::GetURLForGraphicsContext3D() {
988 return GURL();
[email protected]65225772011-05-12 21:10:24989}
990
[email protected]ebc0e1df2013-08-01 02:46:22991scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(bool fallback) {
[email protected]7912e822014-04-16 02:37:03992 // For widgets that are never visible, we don't start the compositor, so we
993 // never get a request for a cc::OutputSurface.
994 DCHECK(!never_visible_);
[email protected]a1811b8912013-05-09 15:35:19995
996#if defined(OS_ANDROID)
[email protected]b6eb8e332013-09-10 00:51:01997 if (SynchronousCompositorFactory* factory =
998 SynchronousCompositorFactory::GetInstance()) {
piman5d36dae2015-09-24 22:47:05999 return factory->CreateOutputSurface(routing_id(),
[email protected]586871b2014-07-22 17:05:111000 frame_swap_message_queue_);
[email protected]a1811b8912013-05-09 15:35:191001 }
1002#endif
1003
avi83883c82014-12-23 00:08:491004 const base::CommandLine& command_line =
1005 *base::CommandLine::ForCurrentProcess();
[email protected]e09994a2014-03-26 19:59:331006 bool use_software = fallback;
1007 if (command_line.HasSwitch(switches::kDisableGpuCompositing))
1008 use_software = true;
1009
[email protected]0634cdd42013-08-16 00:46:091010 scoped_refptr<ContextProviderCommandBuffer> context_provider;
vmiura78b69282015-02-14 00:01:171011 scoped_refptr<ContextProviderCommandBuffer> worker_context_provider;
[email protected]e09994a2014-03-26 19:59:331012 if (!use_software) {
[email protected]0634cdd42013-08-16 00:46:091013 context_provider = ContextProviderCommandBuffer::Create(
jbauman5e420d32015-08-05 09:33:011014 CreateGraphicsContext3D(true), RENDER_COMPOSITOR_CONTEXT);
[email protected]e09994a2014-03-26 19:59:331015 if (!context_provider.get()) {
1016 // Cause the compositor to wait and try again.
piman8944e1c2015-09-22 21:10:341017 return nullptr;
[email protected]e09994a2014-03-26 19:59:331018 }
revemand180dfc32015-09-24 00:19:431019 worker_context_provider =
1020 RenderThreadImpl::current()->SharedWorkerContextProvider();
1021 if (!worker_context_provider) {
vmiura78b69282015-02-14 00:01:171022 // Cause the compositor to wait and try again.
piman8944e1c2015-09-22 21:10:341023 return nullptr;
vmiura78b69282015-02-14 00:01:171024 }
[email protected]0634cdd42013-08-16 00:46:091025 }
[email protected]ebc0e1df2013-08-01 02:46:221026
[email protected]b6eb8e332013-09-10 00:51:011027 uint32 output_surface_id = next_output_surface_id_++;
piman8944e1c2015-09-22 21:10:341028 // Composite-to-mailbox is currently used for layout tests in order to cause
1029 // them to draw inside in the renderer to do the readback there. This should
1030 // no longer be the case when crbug.com/311404 is fixed.
1031 if (!RenderThreadImpl::current() ||
1032 !RenderThreadImpl::current()->layout_test_mode()) {
danakj6e3bf8012014-12-16 18:27:531033 DCHECK(compositor_deps_->GetCompositorImplThreadTaskRunner());
piman8944e1c2015-09-22 21:10:341034 return make_scoped_ptr(new DelegatedCompositorOutputSurface(
vmiura78b69282015-02-14 00:01:171035 routing_id(), output_surface_id, context_provider,
1036 worker_context_provider, frame_swap_message_queue_));
[email protected]65a33ce2014-03-25 22:37:091037 }
piman8944e1c2015-09-22 21:10:341038
[email protected]0634cdd42013-08-16 00:46:091039 if (!context_provider.get()) {
[email protected]0634cdd42013-08-16 00:46:091040 scoped_ptr<cc::SoftwareOutputDevice> software_device(
jbauman7e15c6a2015-05-11 23:43:121041 new cc::SoftwareOutputDevice());
[email protected]0634cdd42013-08-16 00:46:091042
piman8944e1c2015-09-22 21:10:341043 return make_scoped_ptr(new CompositorOutputSurface(
caseqff9c74c2015-02-10 14:56:291044 routing_id(), output_surface_id, nullptr, nullptr,
1045 software_device.Pass(), frame_swap_message_queue_, true));
[email protected]ebc0e1df2013-08-01 02:46:221046 }
[email protected]ed7defa2013-03-12 21:29:591047
piman8944e1c2015-09-22 21:10:341048 return make_scoped_ptr(new MailboxOutputSurface(
vmiura78b69282015-02-14 00:01:171049 routing_id(), output_surface_id, context_provider,
piman8944e1c2015-09-22 21:10:341050 worker_context_provider, frame_swap_message_queue_, cc::RGBA_8888));
[email protected]ba91a792013-02-06 09:48:281051}
1052
[email protected]4d7e46a2013-11-08 05:33:401053void RenderWidget::OnSwapBuffersAborted() {
[email protected]65225772011-05-12 21:10:241054 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
[email protected]65225772011-05-12 21:10:241055 // Schedule another frame so the compositor learns about it.
jdduke491a3f0c2015-06-15 23:30:261056 ScheduleComposite();
[email protected]65225772011-05-12 21:10:241057}
1058
[email protected]4d7e46a2013-11-08 05:33:401059void RenderWidget::OnSwapBuffersPosted() {
[email protected]37a6f302011-07-11 23:43:081060 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
[email protected]37a6f302011-07-11 23:43:081061}
1062
[email protected]4d7e46a2013-11-08 05:33:401063void RenderWidget::OnSwapBuffersComplete() {
[email protected]65225772011-05-12 21:10:241064 TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersComplete");
[email protected]29ed96a2012-02-04 18:12:161065
[email protected]404939f2012-06-01 04:06:181066 // Notify subclasses that composited rendering was flushed to the screen.
[email protected]29ed96a2012-02-04 18:12:161067 DidFlushPaint();
initial.commit09911bf2008-07-26 23:55:291068}
1069
[email protected]180ef242013-11-07 06:50:461070void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event,
[email protected]205294b2014-03-18 20:48:351071 const ui::LatencyInfo& latency_info,
[email protected]0dea1652012-12-14 00:09:091072 bool is_keyboard_shortcut) {
[email protected]c27dd4f2014-05-22 18:05:191073 if (!input_event)
initial.commit09911bf2008-07-26 23:55:291074 return;
jddukec05612b2015-06-25 23:13:181075 base::AutoReset<bool> handling_input_event_resetter(&handling_input_event_,
1076 true);
[email protected]c27dd4f2014-05-22 18:05:191077 base::AutoReset<WebInputEvent::Type> handling_event_type_resetter(
1078 &handling_event_type_, input_event->type);
jddukec05612b2015-06-25 23:13:181079
1080 // Calls into |didOverscroll()| while handling this event will populate
1081 // |event_overscroll|, which in turn will be bundled with the event ack.
1082 scoped_ptr<DidOverscrollParams> event_overscroll;
1083 base::AutoReset<scoped_ptr<DidOverscrollParams>*>
1084 handling_event_overscroll_resetter(&handling_event_overscroll_,
1085 &event_overscroll);
1086
[email protected]25402eb2014-07-18 03:09:521087#if defined(OS_ANDROID)
bcwhited21e6ff2014-09-05 18:48:541088 // On Android, when a key is pressed or sent from the Keyboard using IME,
[email protected]25402eb2014-07-18 03:09:521089 // |AdapterInputConnection| generates input key events to make sure all JS
1090 // listeners that monitor KeyUp and KeyDown events receive the proper key
1091 // code. Since this input key event comes from IME, we need to set the
1092 // IME event guard here to make sure it does not interfere with other IME
1093 // events.
1094 scoped_ptr<ImeEventGuard> ime_event_guard_maybe;
1095 if (WebInputEvent::isKeyboardEventType(input_event->type)) {
1096 const WebKeyboardEvent& key_event =
1097 *static_cast<const WebKeyboardEvent*>(input_event);
bcwhited21e6ff2014-09-05 18:48:541098 // Some keys are special and it's essential that no events get blocked.
bcwhite5752e442014-10-07 00:05:171099 if (key_event.nativeKeyCode != AKEYCODE_TAB &&
bcwhite796d5ac2014-11-22 02:32:091100 key_event.nativeKeyCode != AKEYCODE_DPAD_CENTER &&
1101 key_event.nativeKeyCode != AKEYCODE_DPAD_LEFT &&
1102 key_event.nativeKeyCode != AKEYCODE_DPAD_RIGHT &&
1103 key_event.nativeKeyCode != AKEYCODE_DPAD_UP &&
1104 key_event.nativeKeyCode != AKEYCODE_DPAD_DOWN)
[email protected]25402eb2014-07-18 03:09:521105 ime_event_guard_maybe.reset(new ImeEventGuard(this));
[email protected]25402eb2014-07-18 03:09:521106 }
1107#endif
initial.commit09911bf2008-07-26 23:55:291108
[email protected]fd847792013-10-24 17:12:351109 base::TimeTicks start_time;
charliea3be839702015-01-26 17:35:411110 if (base::TimeTicks::IsHighResolution())
1111 start_time = base::TimeTicks::Now();
[email protected]fd847792013-10-24 17:12:351112
miletusfed8c43b2015-01-26 20:04:521113 TRACE_EVENT1("renderer,benchmark", "RenderWidget::OnHandleInputEvent",
jdduke07788062014-12-05 03:16:301114 "event", WebInputEventTraits::GetName(input_event->type));
[email protected]b2e92592014-01-10 15:47:151115 TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("blink.HandleInputEvent");
yuhaoz8df9334c2015-08-18 17:48:511116 TRACE_EVENT_WITH_FLOW1("input,benchmark",
1117 "LatencyInfo.Flow",
1118 TRACE_ID_DONT_MANGLE(latency_info.trace_id()),
1119 TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
1120 "step", "HandleInputEventMain");
[email protected]b4841e1c2013-05-16 22:30:101121
jdduke07788062014-12-05 03:16:301122 // If we don't have a high res timer, these metrics won't be accurate enough
1123 // to be worth collecting. Note that this does introduce some sampling bias.
1124 if (!start_time.is_null())
miletus14a25642015-08-13 19:23:231125 LogInputEventLatencyUma(*input_event, start_time, latency_info);
jdduke07788062014-12-05 03:16:301126
[email protected]6be422b2013-12-08 06:47:311127 scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor;
[email protected]205294b2014-03-18 20:48:351128 ui::LatencyInfo swap_latency_info(latency_info);
[email protected]6be422b2013-12-08 06:47:311129 if (compositor_) {
1130 latency_info_swap_promise_monitor =
[email protected]205294b2014-03-18 20:48:351131 compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info)
1132 .Pass();
[email protected]6be422b2013-12-08 06:47:311133 }
[email protected]c2eaa8f2013-05-10 02:41:551134
[email protected]67bfb83f2011-09-22 03:36:371135 bool prevent_default = false;
1136 if (WebInputEvent::isMouseEventType(input_event->type)) {
[email protected]936c6f52011-12-13 01:35:261137 const WebMouseEvent& mouse_event =
1138 *static_cast<const WebMouseEvent*>(input_event);
1139 TRACE_EVENT2("renderer", "HandleMouseMove",
1140 "x", mouse_event.x, "y", mouse_event.y);
[email protected]a09d53ce2014-01-31 00:46:421141 context_menu_source_type_ = ui::MENU_SOURCE_MOUSE;
[email protected]936c6f52011-12-13 01:35:261142 prevent_default = WillHandleMouseEvent(mouse_event);
[email protected]67bfb83f2011-09-22 03:36:371143 }
1144
[email protected]cefe9b152014-03-27 18:16:151145 if (WebInputEvent::isKeyboardEventType(input_event->type)) {
[email protected]a09d53ce2014-01-31 00:46:421146 context_menu_source_type_ = ui::MENU_SOURCE_KEYBOARD;
[email protected]cefe9b152014-03-27 18:16:151147#if defined(OS_ANDROID)
1148 // The DPAD_CENTER key on Android has a dual semantic: (1) in the general
1149 // case it should behave like a select key (i.e. causing a click if a button
1150 // is focused). However, if a text field is focused (2), its intended
1151 // behavior is to just show the IME and don't propagate the key.
1152 // A typical use case is a web form: the DPAD_CENTER should bring up the IME
1153 // when clicked on an input text field and cause the form submit if clicked
1154 // when the submit button is focused, but not vice-versa.
1155 // The UI layer takes care of translating DPAD_CENTER into a RETURN key,
1156 // but at this point we have to swallow the event for the scenario (2).
1157 const WebKeyboardEvent& key_event =
1158 *static_cast<const WebKeyboardEvent*>(input_event);
1159 if (key_event.nativeKeyCode == AKEYCODE_DPAD_CENTER &&
1160 GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE) {
1161 OnShowImeIfNeeded();
1162 prevent_default = true;
1163 }
1164#endif
1165 }
[email protected]f56c7872013-06-18 12:31:571166
[email protected]41d86852012-11-07 12:23:241167 if (WebInputEvent::isGestureEventType(input_event->type)) {
1168 const WebGestureEvent& gesture_event =
1169 *static_cast<const WebGestureEvent*>(input_event);
[email protected]a09d53ce2014-01-31 00:46:421170 context_menu_source_type_ = ui::MENU_SOURCE_TOUCH;
[email protected]41d86852012-11-07 12:23:241171 prevent_default = prevent_default || WillHandleGestureEvent(gesture_event);
1172 }
1173
[email protected]67bfb83f2011-09-22 03:36:371174 bool processed = prevent_default;
[email protected]b68a0e52011-12-08 15:11:121175 if (input_event->type != WebInputEvent::Char || !suppress_next_char_events_) {
1176 suppress_next_char_events_ = false;
1177 if (!processed && webwidget_)
1178 processed = webwidget_->handleInputEvent(*input_event);
1179 }
1180
1181 // If this RawKeyDown event corresponds to a browser keyboard shortcut and
1182 // it's not processed by webkit, then we need to suppress the upcoming Char
1183 // events.
1184 if (!processed && is_keyboard_shortcut)
1185 suppress_next_char_events_ = true;
initial.commit09911bf2008-07-26 23:55:291186
[email protected]3d5c243b2012-11-30 00:26:011187 InputEventAckState ack_result = processed ?
1188 INPUT_EVENT_ACK_STATE_CONSUMED : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1189 if (!processed && input_event->type == WebInputEvent::TouchStart) {
1190 const WebTouchEvent& touch_event =
1191 *static_cast<const WebTouchEvent*>(input_event);
[email protected]f8ed4722013-12-03 03:27:251192 // Hit-test for all the pressed touch points. If there is a touch-handler
1193 // for any of the touch points, then the renderer should continue to receive
1194 // touch events.
1195 ack_result = INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
1196 for (size_t i = 0; i < touch_event.touchesLength; ++i) {
1197 if (touch_event.touches[i].state == WebTouchPoint::StatePressed &&
[email protected]a66e18e2014-01-29 20:58:271198 HasTouchEventHandlersAt(
[email protected]9c769d412014-03-20 18:27:391199 gfx::ToFlooredPoint(touch_event.touches[i].position))) {
[email protected]f8ed4722013-12-03 03:27:251200 ack_result = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
1201 break;
1202 }
1203 }
[email protected]3d5c243b2012-11-30 00:26:011204 }
1205
ccamerond4ba47902014-12-17 07:20:311206 // Send mouse wheel events and their disposition to the compositor thread, so
1207 // that they can be used to produce the elastic overscroll effect on Mac.
1208 if (input_event->type == WebInputEvent::MouseWheel) {
ccamerona7644752014-12-30 01:16:311209 ObserveWheelEventAndResult(
sataya.mf405d0e2015-07-07 16:51:111210 static_cast<const WebMouseWheelEvent&>(*input_event),
1211 event_overscroll ? event_overscroll->latest_overscroll_delta
1212 : gfx::Vector2dF(),
1213 processed);
ccamerond4ba47902014-12-17 07:20:311214 }
1215
[email protected]721e2302014-04-30 23:42:011216 bool frame_pending = compositor_ && compositor_->BeginMainFrameRequested();
[email protected]8926c602013-01-23 05:32:061217
charliea3be839702015-01-26 17:35:411218 // If we don't have a fast and accurate Now(), we assume the input handlers
1219 // are heavy and rate limit them.
jdduke07788062014-12-05 03:16:301220 bool rate_limiting_wanted =
1221 input_event->type == WebInputEvent::MouseMove ||
1222 input_event->type == WebInputEvent::MouseWheel;
1223 if (rate_limiting_wanted && !start_time.is_null()) {
charliea3be839702015-01-26 17:35:411224 base::TimeTicks end_time = base::TimeTicks::Now();
[email protected]fd847792013-10-24 17:12:351225 total_input_handling_time_this_frame_ += (end_time - start_time);
1226 rate_limiting_wanted =
1227 total_input_handling_time_this_frame_.InMicroseconds() >
1228 kInputHandlingTimeThrottlingThresholdMicroseconds;
1229 }
1230
[email protected]7f19e9d2014-05-09 15:16:291231 TRACE_EVENT_SYNTHETIC_DELAY_END("blink.HandleInputEvent");
1232
[email protected]c27dd4f2014-05-22 18:05:191233 // Note that we can't use handling_event_type_ here since it will be overriden
1234 // by reentrant calls for events after the paused one.
1235 bool no_ack = ignore_ack_for_mouse_move_from_debugger_ &&
1236 input_event->type == WebInputEvent::MouseMove;
lanweif1a22832015-05-19 17:24:101237 if (WebInputEventTraits::WillReceiveAckFromRenderer(*input_event) &&
1238 !no_ack) {
1239 InputEventAck ack(input_event->type, ack_result, swap_latency_info,
jddukec05612b2015-06-25 23:13:181240 event_overscroll.Pass(),
lanweif1a22832015-05-19 17:24:101241 WebInputEventTraits::GetUniqueTouchEventId(*input_event));
[email protected]34afe102013-12-13 17:24:551242 scoped_ptr<IPC::Message> response(
[email protected]8e431f2032014-05-20 02:34:561243 new InputHostMsg_HandleInputEvent_ACK(routing_id_, ack));
jdduke07788062014-12-05 03:16:301244 if (rate_limiting_wanted && frame_pending && !is_hidden_) {
[email protected]34afe102013-12-13 17:24:551245 // We want to rate limit the input events in this case, so we'll wait for
1246 // painting to finish before ACKing this message.
1247 TRACE_EVENT_INSTANT0("renderer",
1248 "RenderWidget::OnHandleInputEvent ack throttled",
1249 TRACE_EVENT_SCOPE_THREAD);
1250 if (pending_input_event_ack_) {
jddukefffb67c2015-01-07 22:32:291251 TRACE_EVENT_ASYNC_END0("input", "RenderWidget::ThrottledInputEventAck",
1252 pending_input_event_ack_.get());
[email protected]34afe102013-12-13 17:24:551253 // As two different kinds of events could cause us to postpone an ack
1254 // we send it now, if we have one pending. The Browser should never
1255 // send us the same kind of event we are delaying the ack for.
1256 Send(pending_input_event_ack_.release());
1257 }
1258 pending_input_event_ack_ = response.Pass();
jddukefffb67c2015-01-07 22:32:291259 TRACE_EVENT_ASYNC_BEGIN0("input", "RenderWidget::ThrottledInputEventAck",
1260 pending_input_event_ack_.get());
[email protected]34afe102013-12-13 17:24:551261 if (compositor_)
1262 compositor_->NotifyInputThrottledUntilCommit();
1263 } else {
1264 Send(response.release());
[email protected]353a34c2010-05-28 23:35:171265 }
jddukec05612b2015-06-25 23:13:181266 } else {
1267 DCHECK(!event_overscroll) << "Unexpected overscroll for un-acked event";
[email protected]12fbad812009-09-01 18:21:241268 }
alexclarke7819e2552015-06-03 11:17:211269 if (!no_ack && RenderThreadImpl::current()) {
1270 RenderThreadImpl::current()
1271 ->GetRendererScheduler()
1272 ->DidHandleInputEventOnMainThread(*input_event);
1273 }
[email protected]5fea4a52014-05-27 00:17:521274 if (input_event->type == WebInputEvent::MouseMove)
1275 ignore_ack_for_mouse_move_from_debugger_ = false;
[email protected]12fbad812009-09-01 18:21:241276
[email protected]3306f262012-09-21 19:20:421277#if defined(OS_ANDROID)
1278 // Allow the IME to be shown when the focus changes as a consequence
1279 // of a processed touch end event.
1280 if (input_event->type == WebInputEvent::TouchEnd && processed)
[email protected]90f24152014-04-09 12:41:361281 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
[email protected]183e28d2014-01-20 18:18:021282#elif defined(USE_AURA)
1283 // Show the virtual keyboard if enabled and a user gesture triggers a focus
1284 // change.
1285 if (processed && (input_event->type == WebInputEvent::TouchEnd ||
rouslanf7ebd8832015-01-22 01:54:141286 input_event->type == WebInputEvent::MouseUp)) {
[email protected]90f24152014-04-09 12:41:361287 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_IME);
rouslanf7ebd8832015-01-22 01:54:141288 }
[email protected]3306f262012-09-21 19:20:421289#endif
1290
[email protected]67bfb83f2011-09-22 03:36:371291 if (!prevent_default) {
1292 if (WebInputEvent::isKeyboardEventType(input_event->type))
1293 DidHandleKeyEvent();
[email protected]67bfb83f2011-09-22 03:36:371294 }
rouslanf7ebd8832015-01-22 01:54:141295
1296// TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
1297// virtual keyboard.
1298#if !defined(OS_ANDROID)
1299 // Virtual keyboard is not supported, so react to focus change immediately.
1300 if (processed && (input_event->type == WebInputEvent::TouchEnd ||
1301 input_event->type == WebInputEvent::MouseUp)) {
1302 FocusChangeComplete();
1303 }
1304#endif
initial.commit09911bf2008-07-26 23:55:291305}
1306
[email protected]34202de2013-05-06 23:36:221307void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
1308 if (webwidget_)
1309 webwidget_->setCursorVisibilityState(is_visible);
1310}
1311
initial.commit09911bf2008-07-26 23:55:291312void RenderWidget::OnMouseCaptureLost() {
1313 if (webwidget_)
[email protected]4873c7d2009-07-16 06:36:281314 webwidget_->mouseCaptureLost();
initial.commit09911bf2008-07-26 23:55:291315}
1316
1317void RenderWidget::OnSetFocus(bool enable) {
1318 has_focus_ = enable;
[email protected]9d166af2010-03-02 22:04:331319 if (webwidget_)
1320 webwidget_->setFocus(enable);
initial.commit09911bf2008-07-26 23:55:291321}
1322
1323void RenderWidget::ClearFocus() {
1324 // We may have got the focus from the browser before this gets processed, in
1325 // which case we do not want to unfocus ourself.
1326 if (!has_focus_ && webwidget_)
[email protected]4873c7d2009-07-16 06:36:281327 webwidget_->setFocus(false);
initial.commit09911bf2008-07-26 23:55:291328}
1329
[email protected]fd847792013-10-24 17:12:351330void RenderWidget::FlushPendingInputEventAck() {
jddukefffb67c2015-01-07 22:32:291331 if (pending_input_event_ack_) {
1332 TRACE_EVENT_ASYNC_END0("input", "RenderWidget::ThrottledInputEventAck",
1333 pending_input_event_ack_.get());
[email protected]d8a8ecb2013-10-23 18:03:071334 Send(pending_input_event_ack_.release());
jddukefffb67c2015-01-07 22:32:291335 }
[email protected]fd847792013-10-24 17:12:351336 total_input_handling_time_this_frame_ = base::TimeDelta();
1337}
1338
initial.commit09911bf2008-07-26 23:55:291339///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461340// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291341
[email protected]244ac1892011-12-02 17:04:471342void RenderWidget::didAutoResize(const WebSize& new_size) {
[email protected]ea3ee0a2012-05-15 03:43:091343 if (size_.width() != new_size.width || size_.height() != new_size.height) {
[email protected]eac2b362013-05-22 07:01:451344 size_ = new_size;
[email protected]20fbfc22013-05-08 20:50:581345
[email protected]5b45ad42013-10-25 00:42:041346 if (resizing_mode_selector_->is_synchronous_mode()) {
[email protected]eac2b362013-05-22 07:01:451347 WebRect new_pos(rootWindowRect().x,
1348 rootWindowRect().y,
1349 new_size.width,
1350 new_size.height);
1351 view_screen_rect_ = new_pos;
1352 window_screen_rect_ = new_pos;
[email protected]8be1c582013-03-06 00:55:031353 }
[email protected]20fbfc22013-05-08 20:50:581354
[email protected]eac2b362013-05-22 07:01:451355 AutoResizeCompositor();
[email protected]20fbfc22013-05-08 20:50:581356
[email protected]5b45ad42013-10-25 00:42:041357 if (!resizing_mode_selector_->is_synchronous_mode())
[email protected]20fbfc22013-05-08 20:50:581358 need_update_rect_for_auto_resize_ = true;
[email protected]ea3ee0a2012-05-15 03:43:091359 }
[email protected]244ac1892011-12-02 17:04:471360}
1361
[email protected]3a1c8a8032013-03-18 22:35:321362void RenderWidget::AutoResizeCompositor() {
[email protected]97e1bf72013-03-06 14:06:051363 physical_backing_size_ = gfx::ToCeiledSize(gfx::ScaleSize(size_,
1364 device_scale_factor_));
1365 if (compositor_)
1366 compositor_->setViewportSize(size_, physical_backing_size_);
1367}
1368
[email protected]e195e582013-03-08 01:32:591369void RenderWidget::initializeLayerTreeView() {
[email protected]aeeedad2014-08-22 18:16:221370 DCHECK(!host_closing_);
1371
danakj6e3bf8012014-12-16 18:27:531372 compositor_ = RenderWidgetCompositor::Create(this, compositor_deps_);
[email protected]e195e582013-03-08 01:32:591373 compositor_->setViewportSize(size_, physical_backing_size_);
1374 if (init_complete_)
[email protected]7912e822014-04-16 02:37:031375 StartCompositor();
[email protected]e195e582013-03-08 01:32:591376}
1377
ennef3c58142014-12-09 21:44:381378void RenderWidget::WillCloseLayerTreeView() {
1379 if (host_closing_)
1380 return;
1381
1382 // Prevent new compositors or output surfaces from being created.
1383 host_closing_ = true;
1384
[email protected]aeeedad2014-08-22 18:16:221385 // Always send this notification to prevent new layer tree views from
1386 // being created, even if one hasn't been created yet.
1387 if (webwidget_)
1388 webwidget_->willCloseLayerTreeView();
[email protected]aeeedad2014-08-22 18:16:221389}
1390
[email protected]180ef242013-11-07 06:50:461391blink::WebLayerTreeView* RenderWidget::layerTreeView() {
[email protected]ba91a792013-02-06 09:48:281392 return compositor_.get();
[email protected]8926c602013-01-23 05:32:061393}
1394
dglazkov79c426102015-08-31 21:22:431395void RenderWidget::didFirstVisuallyNonEmptyLayout() {
dglazkov79c426102015-08-31 21:22:431396 QueueMessage(
1397 new ViewHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_),
1398 MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE);
1399}
1400
1401void RenderWidget::didFirstLayoutAfterFinishedParsing() {
1402 // TODO(dglazkov): Use this hook to drive CapturePageInfo.
1403}
1404
jdduke491a3f0c2015-06-15 23:30:261405void RenderWidget::WillBeginCompositorFrame() {
[email protected]9cd43a62012-03-26 08:03:561406 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
[email protected]abe8b3a2012-03-28 21:19:371407
shuchen913f8b622015-07-31 13:22:431408 // The UpdateTextInputState can result in further layout and possibly
[email protected]abe8b3a2012-03-28 21:19:371409 // enable GPU acceleration so they need to be called before any painting
1410 // is done.
[email protected]90f24152014-04-09 12:41:361411 UpdateTextInputState(NO_SHOW_IME, FROM_NON_IME);
[email protected]abe8b3a2012-03-28 21:19:371412 UpdateSelectionBounds();
[email protected]9cd43a62012-03-26 08:03:561413}
1414
[email protected]6fceb912013-02-15 06:24:151415void RenderWidget::DidCommitCompositorFrame() {
fsamuel2e9413d2015-02-25 01:25:441416 FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
1417 DidCommitCompositorFrame());
[email protected]e3244ed2014-06-20 20:04:271418 FOR_EACH_OBSERVER(RenderFrameProxy, render_frame_proxies_,
[email protected]bffc8302014-01-23 20:52:161419 DidCommitCompositorFrame());
[email protected]a017938b2014-05-27 21:17:171420#if defined(VIDEO_HOLE)
[email protected]e3244ed2014-06-20 20:04:271421 FOR_EACH_OBSERVER(RenderFrameImpl, video_hole_frames_,
1422 DidCommitCompositorFrame());
[email protected]a017938b2014-05-27 21:17:171423#endif // defined(VIDEO_HOLE)
jdduke491a3f0c2015-06-15 23:30:261424 FlushPendingInputEventAck();
1425}
1426
1427void RenderWidget::DidCommitAndDrawCompositorFrame() {
1428 // NOTE: Tests may break if this event is renamed or moved. See
1429 // tab_capture_performancetest.cc.
1430 TRACE_EVENT0("gpu", "RenderWidget::DidCommitAndDrawCompositorFrame");
1431 // Notify subclasses that we initiated the paint operation.
1432 DidInitiatePaint();
1433}
1434
1435void RenderWidget::DidCompleteSwapBuffers() {
1436 TRACE_EVENT0("renderer", "RenderWidget::DidCompleteSwapBuffers");
1437
1438 // Notify subclasses threaded composited rendering was flushed to the screen.
1439 DidFlushPaint();
1440
1441 if (!next_paint_flags_ &&
1442 !need_update_rect_for_auto_resize_ &&
1443 !plugin_window_moves_.size()) {
1444 return;
1445 }
1446
1447 ViewHostMsg_UpdateRect_Params params;
1448 params.view_size = size_;
1449 params.plugin_window_moves.swap(plugin_window_moves_);
1450 params.flags = next_paint_flags_;
1451
1452 Send(new ViewHostMsg_UpdateRect(routing_id_, params));
1453 next_paint_flags_ = 0;
1454 need_update_rect_for_auto_resize_ = false;
1455}
1456
1457void RenderWidget::ScheduleComposite() {
1458 if (compositor_ &&
1459 compositor_deps_->GetCompositorImplThreadTaskRunner().get()) {
1460 compositor_->setNeedsAnimate();
1461 }
1462}
1463
1464void RenderWidget::ScheduleCompositeWithForcedRedraw() {
1465 if (compositor_) {
1466 // Regardless of whether threaded compositing is enabled, always
1467 // use this mechanism to force the compositor to redraw. However,
1468 // the invalidation code path below is still needed for the
1469 // non-threaded case.
1470 compositor_->SetNeedsForcedRedraw();
1471 }
1472 ScheduleComposite();
[email protected]6fceb912013-02-15 06:24:151473}
1474
[email protected]586871b2014-07-22 17:05:111475// static
1476scoped_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
1477 IPC::Message* msg,
1478 MessageDeliveryPolicy policy,
1479 FrameSwapMessageQueue* frame_swap_message_queue,
1480 scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
[email protected]586871b2014-07-22 17:05:111481 int source_frame_number) {
[email protected]586871b2014-07-22 17:05:111482 bool first_message_for_frame = false;
1483 frame_swap_message_queue->QueueMessageForFrame(policy,
1484 source_frame_number,
1485 make_scoped_ptr(msg),
1486 &first_message_for_frame);
1487 if (first_message_for_frame) {
1488 scoped_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
1489 sync_message_filter, frame_swap_message_queue, source_frame_number));
dcheng4b6b5ff2014-10-16 00:42:061490 return promise;
[email protected]586871b2014-07-22 17:05:111491 }
dcheng4b6b5ff2014-10-16 00:42:061492 return nullptr;
[email protected]586871b2014-07-22 17:05:111493}
1494
1495void RenderWidget::QueueMessage(IPC::Message* msg,
1496 MessageDeliveryPolicy policy) {
1497 // RenderThreadImpl::current() is NULL in some tests.
1498 if (!compositor_ || !RenderThreadImpl::current()) {
1499 Send(msg);
1500 return;
1501 }
1502
1503 scoped_ptr<cc::SwapPromise> swap_promise =
1504 QueueMessageImpl(msg,
1505 policy,
dcheng58867a92014-08-26 02:50:221506 frame_swap_message_queue_.get(),
[email protected]586871b2014-07-22 17:05:111507 RenderThreadImpl::current()->sync_message_filter(),
[email protected]586871b2014-07-22 17:05:111508 compositor_->GetSourceFrameNumber());
1509
1510 if (swap_promise) {
1511 compositor_->QueueSwapPromise(swap_promise.Pass());
igsollaeab34cc2015-02-20 11:33:351512 // Request a commit. This might either A) request a commit ahead of time
1513 // or B) request a commit which is not needed because there are not
1514 // pending updates. If B) then the commit will be skipped and the swap
1515 // promises will be broken (see EarlyOut_NoUpdates). To achieve that we
1516 // call SetNeedsUpdateLayers instead of SetNeedsCommit so that
1517 // can_cancel_commit is not unset.
1518 compositor_->SetNeedsUpdateLayers();
[email protected]586871b2014-07-22 17:05:111519 }
1520}
1521
[email protected]4873c7d2009-07-16 06:36:281522void RenderWidget::didChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301523 // TODO(darin): Eliminate this temporary.
[email protected]9ec87712013-05-24 23:23:521524 WebCursor cursor;
[email protected]953bd0062013-08-01 00:58:401525 InitializeCursorFromWebKitCursorInfo(&cursor, cursor_info);
initial.commit09911bf2008-07-26 23:55:291526 // Only send a SetCursor message if we need to make a change.
1527 if (!current_cursor_.IsEqual(cursor)) {
1528 current_cursor_ = cursor;
1529 Send(new ViewHostMsg_SetCursor(routing_id_, cursor));
1530 }
1531}
1532
1533// We are supposed to get a single call to Show for a newly created RenderWidget
1534// that was created via RenderWidget::CreateWebView. So, we wait until this
1535// point to dispatch the ShowWidget message.
1536//
1537// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281538// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291539//
[email protected]4873c7d2009-07-16 06:36:281540void RenderWidget::show(WebNavigationPolicy) {
initial.commit09911bf2008-07-26 23:55:291541 DCHECK(!did_show_) << "received extraneous Show call";
1542 DCHECK(routing_id_ != MSG_ROUTING_NONE);
1543 DCHECK(opener_id_ != MSG_ROUTING_NONE);
1544
[email protected]8de12d942010-11-17 20:42:441545 if (did_show_)
1546 return;
1547
1548 did_show_ = true;
bokanc007c3a2015-02-03 07:15:561549 // NOTE: initial_rect_ may still have its default values at this point, but
[email protected]8de12d942010-11-17 20:42:441550 // that's okay. It'll be ignored if as_popup is false, or the browser
1551 // process will impose a default position otherwise.
bokanc007c3a2015-02-03 07:15:561552 Send(new ViewHostMsg_ShowWidget(opener_id_, routing_id_, initial_rect_));
1553 SetPendingWindowRect(initial_rect_);
initial.commit09911bf2008-07-26 23:55:291554}
1555
[email protected]4873c7d2009-07-16 06:36:281556void RenderWidget::didFocus() {
initial.commit09911bf2008-07-26 23:55:291557}
1558
[email protected]4873c7d2009-07-16 06:36:281559void RenderWidget::didBlur() {
initial.commit09911bf2008-07-26 23:55:291560}
1561
[email protected]2533ce12009-05-09 00:02:241562void RenderWidget::DoDeferredClose() {
ennef3c58142014-12-09 21:44:381563 WillCloseLayerTreeView();
[email protected]2533ce12009-05-09 00:02:241564 Send(new ViewHostMsg_Close(routing_id_));
1565}
1566
dgozmancf9039cd2015-04-06 12:01:311567void RenderWidget::NotifyOnClose() {
1568 FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_, WidgetWillClose());
1569}
1570
[email protected]4873c7d2009-07-16 06:36:281571void RenderWidget::closeWidgetSoon() {
skyostiled8969c2015-07-20 16:57:081572 DCHECK(content::RenderThread::Get());
[email protected]e1c3a552012-05-04 20:51:321573 if (is_swapped_out_) {
1574 // This widget is currently swapped out, and the active widget is in a
1575 // different process. Have the browser route the close request to the
1576 // active widget instead, so that the correct unload handlers are run.
1577 Send(new ViewHostMsg_RouteCloseEvent(routing_id_));
1578 return;
1579 }
1580
initial.commit09911bf2008-07-26 23:55:291581 // If a page calls window.close() twice, we'll end up here twice, but that's
1582 // OK. It is safe to send multiple Close messages.
1583
[email protected]2533ce12009-05-09 00:02:241584 // Ask the RenderWidgetHost to initiate close. We could be called from deep
1585 // in Javascript. If we ask the RendwerWidgetHost to close now, the window
1586 // could be closed before the JS finishes executing. So instead, post a
1587 // message back to the message loop, which won't run until the JS is
1588 // complete, and then the Close message can be sent.
skyostiled8969c2015-07-20 16:57:081589 base::ThreadTaskRunnerHandle::Get()->PostTask(
[email protected]32876ae2011-11-15 22:25:211590 FROM_HERE, base::Bind(&RenderWidget::DoDeferredClose, this));
initial.commit09911bf2008-07-26 23:55:291591}
1592
[email protected]9017d7852013-11-21 17:47:351593void RenderWidget::QueueSyntheticGesture(
1594 scoped_ptr<SyntheticGestureParams> gesture_params,
1595 const SyntheticGestureCompletionCallback& callback) {
1596 DCHECK(!callback.is_null());
1597
1598 pending_synthetic_gesture_callbacks_.push(callback);
1599
1600 SyntheticGesturePacket gesture_packet;
1601 gesture_packet.set_gesture_params(gesture_params.Pass());
1602
1603 Send(new InputHostMsg_QueueSyntheticGesture(routing_id_, gesture_packet));
1604}
1605
initial.commit09911bf2008-07-26 23:55:291606void RenderWidget::Close() {
[email protected]404630b2014-07-03 19:33:031607 screen_metrics_emulator_.reset();
ennef3c58142014-12-09 21:44:381608 WillCloseLayerTreeView();
1609 compositor_.reset();
initial.commit09911bf2008-07-26 23:55:291610 if (webwidget_) {
[email protected]4873c7d2009-07-16 06:36:281611 webwidget_->close();
initial.commit09911bf2008-07-26 23:55:291612 webwidget_ = NULL;
1613 }
1614}
1615
[email protected]4873c7d2009-07-16 06:36:281616WebRect RenderWidget::windowRect() {
1617 if (pending_window_rect_count_)
1618 return pending_window_rect_;
[email protected]2533ce12009-05-09 00:02:241619
[email protected]80ad8622012-11-07 16:33:031620 return view_screen_rect_;
initial.commit09911bf2008-07-26 23:55:291621}
1622
[email protected]180ef242013-11-07 06:50:461623void RenderWidget::setToolTipText(const blink::WebString& text,
[email protected]8a9d6ca32011-06-06 20:11:301624 WebTextDirection hint) {
[email protected]5a395b72011-08-08 19:13:541625 Send(new ViewHostMsg_SetTooltipText(routing_id_, text, hint));
[email protected]8a9d6ca32011-06-06 20:11:301626}
1627
[email protected]b2e4c70132013-10-03 02:07:511628void RenderWidget::setWindowRect(const WebRect& rect) {
bokanc007c3a2015-02-03 07:15:561629 WebRect window_rect = rect;
[email protected]b2e4c70132013-10-03 02:07:511630 if (popup_origin_scale_for_emulation_) {
1631 float scale = popup_origin_scale_for_emulation_;
bokanc007c3a2015-02-03 07:15:561632 window_rect.x = popup_screen_origin_for_emulation_.x() +
1633 (window_rect.x - popup_view_origin_for_emulation_.x()) * scale;
1634 window_rect.y = popup_screen_origin_for_emulation_.y() +
1635 (window_rect.y - popup_view_origin_for_emulation_.y()) * scale;
[email protected]b2e4c70132013-10-03 02:07:511636 }
1637
[email protected]5b45ad42013-10-25 00:42:041638 if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]ec951b9d2013-10-20 06:21:201639 if (did_show_) {
bokanc007c3a2015-02-03 07:15:561640 Send(new ViewHostMsg_RequestMove(routing_id_, window_rect));
1641 SetPendingWindowRect(window_rect);
[email protected]8be1c582013-03-06 00:55:031642 } else {
bokanc007c3a2015-02-03 07:15:561643 initial_rect_ = window_rect;
[email protected]8be1c582013-03-06 00:55:031644 }
initial.commit09911bf2008-07-26 23:55:291645 } else {
bokanc007c3a2015-02-03 07:15:561646 SetWindowRectSynchronously(window_rect);
initial.commit09911bf2008-07-26 23:55:291647 }
1648}
1649
[email protected]2533ce12009-05-09 00:02:241650void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
1651 pending_window_rect_ = rect;
1652 pending_window_rect_count_++;
1653}
1654
[email protected]4873c7d2009-07-16 06:36:281655WebRect RenderWidget::rootWindowRect() {
[email protected]2533ce12009-05-09 00:02:241656 if (pending_window_rect_count_) {
1657 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
1658 // the RootWindowRect is probably going to return wrong results since the
1659 // browser may not have processed the Move yet. There isn't really anything
1660 // good to do in this case, and it shouldn't happen - since this size is
1661 // only really needed for windowToScreen, which is only used for Popups.
[email protected]4873c7d2009-07-16 06:36:281662 return pending_window_rect_;
[email protected]2533ce12009-05-09 00:02:241663 }
1664
[email protected]80ad8622012-11-07 16:33:031665 return window_screen_rect_;
[email protected]d4547452008-08-28 18:36:371666}
1667
[email protected]4873c7d2009-07-16 06:36:281668WebRect RenderWidget::windowResizerRect() {
1669 return resizer_rect_;
[email protected]c04b6362008-11-21 18:54:191670}
1671
[email protected]fa7b1dc2010-06-23 17:53:041672void RenderWidget::OnImeSetComposition(
[email protected]fcf75d42013-12-03 20:11:261673 const base::string16& text,
[email protected]fa7b1dc2010-06-23 17:53:041674 const std::vector<WebCompositionUnderline>& underlines,
1675 int selection_start, int selection_end) {
[email protected]0d1ebed12013-08-05 22:01:131676 if (!ShouldHandleImeEvent())
[email protected]4873c7d2009-07-16 06:36:281677 return;
[email protected]66fca5bc2013-05-23 06:58:291678 ImeEventGuard guard(this);
[email protected]88dbe32f2013-06-20 23:31:361679 if (!webwidget_->setComposition(
[email protected]fa7b1dc2010-06-23 17:53:041680 text, WebVector<WebCompositionUnderline>(underlines),
1681 selection_start, selection_end)) {
1682 // If we failed to set the composition text, then we need to let the browser
1683 // process to cancel the input method's ongoing composition session, to make
1684 // sure we are in a consistent state.
[email protected]a2214eb2014-06-23 18:31:221685 Send(new InputHostMsg_ImeCancelComposition(routing_id()));
[email protected]7f00efa2010-04-15 05:01:261686 }
[email protected]88dbe32f2013-06-20 23:31:361687 UpdateCompositionInfo(true);
[email protected]fa7b1dc2010-06-23 17:53:041688}
1689
[email protected]fcf75d42013-12-03 20:11:261690void RenderWidget::OnImeConfirmComposition(const base::string16& text,
[email protected]db4fc1e2013-09-06 20:01:511691 const gfx::Range& replacement_range,
[email protected]0e45bd02013-07-12 20:20:021692 bool keep_selection) {
[email protected]0d1ebed12013-08-05 22:01:131693 if (!ShouldHandleImeEvent())
[email protected]d0be63772011-12-20 23:18:041694 return;
[email protected]66fca5bc2013-05-23 06:58:291695 ImeEventGuard guard(this);
[email protected]d0be63772011-12-20 23:18:041696 handling_input_event_ = true;
[email protected]0e45bd02013-07-12 20:20:021697 if (text.length())
1698 webwidget_->confirmComposition(text);
1699 else if (keep_selection)
1700 webwidget_->confirmComposition(WebWidget::KeepSelection);
1701 else
1702 webwidget_->confirmComposition(WebWidget::DoNotKeepSelection);
[email protected]d0be63772011-12-20 23:18:041703 handling_input_event_ = false;
[email protected]88dbe32f2013-06-20 23:31:361704 UpdateCompositionInfo(true);
initial.commit09911bf2008-07-26 23:55:291705}
1706
[email protected]0bc1f572013-04-17 01:46:311707void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
[email protected]ec7dc112008-08-06 05:30:121708 // During shutdown we can just ignore this message.
1709 if (!webwidget_)
1710 return;
1711
[email protected]0bc1f572013-04-17 01:46:311712 // Even if the browser provides an empty damage rect, it's still expecting to
1713 // receive a repaint ack so just damage the entire widget bounds.
1714 if (size_to_paint.IsEmpty()) {
1715 size_to_paint = size_;
1716 }
1717
[email protected]ec7dc112008-08-06 05:30:121718 set_next_paint_is_repaint_ack();
[email protected]aca33f4f2014-05-17 17:08:051719 if (compositor_)
[email protected]0bc1f572013-04-17 01:46:311720 compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint));
[email protected]ec7dc112008-08-06 05:30:121721}
1722
[email protected]79fa22e2013-08-23 15:18:121723void RenderWidget::OnSyntheticGestureCompleted() {
[email protected]9017d7852013-11-21 17:47:351724 DCHECK(!pending_synthetic_gesture_callbacks_.empty());
1725
1726 pending_synthetic_gesture_callbacks_.front().Run();
1727 pending_synthetic_gesture_callbacks_.pop();
[email protected]0e241b4b2012-08-18 09:06:271728}
1729
[email protected]4873c7d2009-07-16 06:36:281730void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
[email protected]07f953332009-03-25 04:31:111731 if (!webwidget_)
1732 return;
[email protected]4873c7d2009-07-16 06:36:281733 webwidget_->setTextDirection(direction);
[email protected]07f953332009-03-25 04:31:111734}
1735
[email protected]80ad8622012-11-07 16:33:031736void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
1737 const gfx::Rect& window_screen_rect) {
[email protected]b2e4c70132013-10-03 02:07:511738 if (screen_metrics_emulator_) {
1739 screen_metrics_emulator_->OnUpdateScreenRectsMessage(
1740 view_screen_rect, window_screen_rect);
1741 } else {
1742 view_screen_rect_ = view_screen_rect;
1743 window_screen_rect_ = window_screen_rect;
1744 }
[email protected]80ad8622012-11-07 16:33:031745 Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
1746}
1747
kenrbb4e2a3b2015-05-14 15:05:051748void RenderWidget::OnSetSurfaceIdNamespace(uint32_t surface_id_namespace) {
1749 if (compositor_)
1750 compositor_->SetSurfaceIdNamespace(surface_id_namespace);
1751}
1752
[email protected]adb362312014-06-28 06:04:241753void RenderWidget::showImeIfNeeded() {
1754 OnShowImeIfNeeded();
[email protected]0d1ebed12013-08-05 22:01:131755}
1756
[email protected]adb362312014-06-28 06:04:241757void RenderWidget::OnShowImeIfNeeded() {
1758#if defined(OS_ANDROID) || defined(USE_AURA)
1759 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
1760#endif
rouslanf7ebd8832015-01-22 01:54:141761
1762// TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
1763// virtual keyboard.
1764#if !defined(OS_ANDROID)
1765 FocusChangeComplete();
1766#endif
[email protected]adb362312014-06-28 06:04:241767}
1768
1769#if defined(OS_ANDROID)
changwan3a841162015-08-11 02:53:371770void RenderWidget::OnImeEventSentForAck(const blink::WebTextInputInfo& info) {
1771 text_input_info_history_.push_back(info);
[email protected]0d1ebed12013-08-05 22:01:131772}
1773
1774void RenderWidget::OnImeEventAck() {
changwan3a841162015-08-11 02:53:371775 DCHECK_GE(text_input_info_history_.size(), 1u);
1776 text_input_info_history_.pop_front();
[email protected]2384b6c2013-02-28 23:58:511777}
[email protected]105dffb42013-02-20 03:46:211778#endif
1779
[email protected]0d1ebed12013-08-05 22:01:131780bool RenderWidget::ShouldHandleImeEvent() {
1781#if defined(OS_ANDROID)
changwan3a841162015-08-11 02:53:371782 if (!webwidget_)
1783 return false;
1784
1785 // We cannot handle IME events if there is any chance that the event we are
1786 // receiving here from the browser is based on the state that is different
1787 // from our current one as indicated by |text_input_info_|.
1788 // The states the browser might be in are:
1789 // text_input_info_history_[0] - current state ack'd by browser
1790 // text_input_info_history_[1...N] - pending state changes
1791 for (size_t i = 0u; i < text_input_info_history_.size() - 1u; ++i) {
1792 if (text_input_info_history_[i] != text_input_info_)
1793 return false;
1794 }
1795 return true;
[email protected]0d1ebed12013-08-05 22:01:131796#else
1797 return !!webwidget_;
1798#endif
1799}
1800
[email protected]c27dd4f2014-05-22 18:05:191801bool RenderWidget::SendAckForMouseMoveFromDebugger() {
1802 if (handling_event_type_ == WebInputEvent::MouseMove) {
[email protected]5fea4a52014-05-27 00:17:521803 // If we pause multiple times during a single mouse move event, we should
1804 // only send ACK once.
1805 if (!ignore_ack_for_mouse_move_from_debugger_) {
lanweif1a22832015-05-19 17:24:101806 InputEventAck ack(handling_event_type_, INPUT_EVENT_ACK_STATE_CONSUMED);
[email protected]5fea4a52014-05-27 00:17:521807 Send(new InputHostMsg_HandleInputEvent_ACK(routing_id_, ack));
dgozmanb739185d2015-04-10 15:04:021808 return true;
[email protected]5fea4a52014-05-27 00:17:521809 }
[email protected]c27dd4f2014-05-22 18:05:191810 }
1811 return false;
1812}
1813
1814void RenderWidget::IgnoreAckForMouseMoveFromDebugger() {
1815 ignore_ack_for_mouse_move_from_debugger_ = true;
1816}
1817
[email protected]468ac582012-11-20 00:53:191818void RenderWidget::SetDeviceScaleFactor(float device_scale_factor) {
1819 if (device_scale_factor_ == device_scale_factor)
1820 return;
1821
1822 device_scale_factor_ = device_scale_factor;
jdduke491a3f0c2015-06-15 23:30:261823 ScheduleComposite();
[email protected]468ac582012-11-20 00:53:191824}
1825
[email protected]28ed6b32014-06-08 02:16:271826bool RenderWidget::SetDeviceColorProfile(
1827 const std::vector<char>& color_profile) {
1828 if (device_color_profile_ == color_profile)
1829 return false;
1830
1831 device_color_profile_ = color_profile;
1832 return true;
1833}
1834
noeldb4df152014-09-16 17:45:201835void RenderWidget::ResetDeviceColorProfileForTesting() {
1836 if (!device_color_profile_.empty())
1837 device_color_profile_.clear();
1838 device_color_profile_.push_back('0');
1839}
1840
[email protected]fcdc5642014-05-09 14:32:241841void RenderWidget::OnOrientationChange() {
1842}
1843
[email protected]ceb36f7d2012-10-31 18:33:241844gfx::Vector2d RenderWidget::GetScrollOffset() {
[email protected]d54169e92011-01-21 09:19:521845 // Bare RenderWidgets don't support scroll offset.
[email protected]ceb36f7d2012-10-31 18:33:241846 return gfx::Vector2d();
[email protected]d54169e92011-01-21 09:19:521847}
1848
[email protected]bee16aab2009-08-26 15:55:031849void RenderWidget::SetHidden(bool hidden) {
1850 if (is_hidden_ == hidden)
1851 return;
1852
jdduke8fac9d102014-12-20 02:40:131853 // The status has changed. Tell the RenderThread about it and ensure
1854 // throttled acks are released in case frame production ceases.
[email protected]bee16aab2009-08-26 15:55:031855 is_hidden_ = hidden;
jdduke8fac9d102014-12-20 02:40:131856 FlushPendingInputEventAck();
1857
[email protected]bee16aab2009-08-26 15:55:031858 if (is_hidden_)
[email protected]b2db9272014-01-10 17:42:001859 RenderThreadImpl::current()->WidgetHidden();
[email protected]bee16aab2009-08-26 15:55:031860 else
[email protected]b2db9272014-01-10 17:42:001861 RenderThreadImpl::current()->WidgetRestored();
[email protected]bee16aab2009-08-26 15:55:031862}
1863
[email protected]2b624c562011-10-27 22:58:261864void RenderWidget::DidToggleFullscreen() {
[email protected]2b624c562011-10-27 22:58:261865 if (!webwidget_)
1866 return;
1867
mikhail.pozdnyakovf2c902a2015-04-14 08:09:121868 if (is_fullscreen_granted_) {
[email protected]2b624c562011-10-27 22:58:261869 webwidget_->didEnterFullScreen();
1870 } else {
1871 webwidget_->didExitFullScreen();
1872 }
[email protected]2b624c562011-10-27 22:58:261873}
1874
[email protected]674741932009-02-04 23:44:461875bool RenderWidget::next_paint_is_resize_ack() const {
[email protected]53d3f302009-12-21 04:42:051876 return ViewHostMsg_UpdateRect_Flags::is_resize_ack(next_paint_flags_);
[email protected]674741932009-02-04 23:44:461877}
1878
[email protected]674741932009-02-04 23:44:461879void RenderWidget::set_next_paint_is_resize_ack() {
[email protected]53d3f302009-12-21 04:42:051880 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
[email protected]674741932009-02-04 23:44:461881}
1882
[email protected]674741932009-02-04 23:44:461883void RenderWidget::set_next_paint_is_repaint_ack() {
[email protected]53d3f302009-12-21 04:42:051884 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK;
[email protected]674741932009-02-04 23:44:461885}
1886
[email protected]b18583c2012-12-18 06:55:271887static bool IsDateTimeInput(ui::TextInputType type) {
1888 return type == ui::TEXT_INPUT_TYPE_DATE ||
1889 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
1890 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
1891 type == ui::TEXT_INPUT_TYPE_MONTH ||
1892 type == ui::TEXT_INPUT_TYPE_TIME ||
1893 type == ui::TEXT_INPUT_TYPE_WEEK;
1894}
1895
[email protected]66fca5bc2013-05-23 06:58:291896
1897void RenderWidget::StartHandlingImeEvent() {
1898 DCHECK(!handling_ime_event_);
1899 handling_ime_event_ = true;
1900}
1901
1902void RenderWidget::FinishHandlingImeEvent() {
1903 DCHECK(handling_ime_event_);
1904 handling_ime_event_ = false;
1905 // While handling an ime event, text input state and selection bounds updates
1906 // are ignored. These must explicitly be updated once finished handling the
1907 // ime event.
1908 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:471909#if defined(OS_ANDROID)
[email protected]90f24152014-04-09 12:41:361910 UpdateTextInputState(NO_SHOW_IME, FROM_IME);
[email protected]cb9e2632013-06-18 11:26:471911#endif
[email protected]66fca5bc2013-05-23 06:58:291912}
1913
[email protected]90f24152014-04-09 12:41:361914void RenderWidget::UpdateTextInputState(ShowIme show_ime,
1915 ChangeSource change_source) {
jdduke1aebad8e2015-07-22 23:25:081916 TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState");
[email protected]e8f775f2013-02-14 21:00:501917 if (handling_ime_event_)
1918 return;
[email protected]ad26ef42011-06-17 07:59:451919 ui::TextInputType new_type = GetTextInputType();
[email protected]b18583c2012-12-18 06:55:271920 if (IsDateTimeInput(new_type))
1921 return; // Not considered as a text input field in WebKit/Chromium.
1922
[email protected]180ef242013-11-07 06:50:461923 blink::WebTextInputInfo new_info;
[email protected]5b739cb2012-08-21 20:35:211924 if (webwidget_)
1925 new_info = webwidget_->textInputInfo();
shuchen913f8b622015-07-31 13:22:431926 const ui::TextInputMode new_mode = ConvertInputMode(new_info.inputMode);
[email protected]5b739cb2012-08-21 20:35:211927
[email protected]ad26ef42011-06-17 07:59:451928 bool new_can_compose_inline = CanComposeInline();
[email protected]5b739cb2012-08-21 20:35:211929
[email protected]3306f262012-09-21 19:20:421930 // Only sends text input params if they are changed or if the ime should be
1931 // shown.
[email protected]90f24152014-04-09 12:41:361932 if (show_ime == SHOW_IME_IF_NEEDED ||
1933 (text_input_type_ != new_type ||
shuchen913f8b622015-07-31 13:22:431934 text_input_mode_ != new_mode ||
[email protected]90f24152014-04-09 12:41:361935 text_input_info_ != new_info ||
1936 can_compose_inline_ != new_can_compose_inline)
1937#if defined(OS_ANDROID)
1938 || text_field_is_dirty_
[email protected]183e28d2014-01-20 18:18:021939#endif
[email protected]90f24152014-04-09 12:41:361940 ) {
shuchen913f8b622015-07-31 13:22:431941 ViewHostMsg_TextInputState_Params params;
1942 params.type = new_type;
1943 params.mode = new_mode;
1944 params.flags = new_info.flags;
1945 params.value = new_info.value.utf8();
1946 params.selection_start = new_info.selectionStart;
1947 params.selection_end = new_info.selectionEnd;
1948 params.composition_start = new_info.compositionStart;
1949 params.composition_end = new_info.compositionEnd;
1950 params.can_compose_inline = new_can_compose_inline;
1951 params.show_ime_if_needed = (show_ime == SHOW_IME_IF_NEEDED);
[email protected]90f24152014-04-09 12:41:361952#if defined(USE_AURA)
shuchen913f8b622015-07-31 13:22:431953 params.is_non_ime_change = true;
[email protected]90f24152014-04-09 12:41:361954#endif
[email protected]183e28d2014-01-20 18:18:021955#if defined(OS_ANDROID)
shuchen913f8b622015-07-31 13:22:431956 params.is_non_ime_change = (change_source == FROM_NON_IME) ||
[email protected]90f24152014-04-09 12:41:361957 text_field_is_dirty_;
shuchen913f8b622015-07-31 13:22:431958 if (params.is_non_ime_change)
changwan3a841162015-08-11 02:53:371959 OnImeEventSentForAck(new_info);
[email protected]90f24152014-04-09 12:41:361960 text_field_is_dirty_ = false;
[email protected]183e28d2014-01-20 18:18:021961#endif
shuchen913f8b622015-07-31 13:22:431962 Send(new ViewHostMsg_TextInputStateChanged(routing_id(), params));
[email protected]5b739cb2012-08-21 20:35:211963
1964 text_input_info_ = new_info;
[email protected]fa7b1dc2010-06-23 17:53:041965 text_input_type_ = new_type;
shuchen913f8b622015-07-31 13:22:431966 text_input_mode_ = new_mode;
[email protected]ad26ef42011-06-17 07:59:451967 can_compose_inline_ = new_can_compose_inline;
shuchen82ce8c52014-10-23 01:55:201968 text_input_flags_ = new_info.flags;
initial.commit09911bf2008-07-26 23:55:291969 }
initial.commit09911bf2008-07-26 23:55:291970}
1971
[email protected]7c8873e2013-02-05 08:03:011972void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
1973 WebRect focus_webrect;
1974 WebRect anchor_webrect;
1975 webwidget_->selectionBounds(focus_webrect, anchor_webrect);
1976 *focus = focus_webrect;
1977 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:321978}
1979
[email protected]e99ef6f2011-10-16 01:13:001980void RenderWidget::UpdateSelectionBounds() {
jdduke1aebad8e2015-07-22 23:25:081981 TRACE_EVENT0("renderer", "RenderWidget::UpdateSelectionBounds");
[email protected]e99ef6f2011-10-16 01:13:001982 if (!webwidget_)
1983 return;
[email protected]66fca5bc2013-05-23 06:58:291984 if (handling_ime_event_)
1985 return;
[email protected]e99ef6f2011-10-16 01:13:001986
mohsenb0eeba72015-08-09 06:20:081987#if defined(USE_AURA)
1988 // TODO(mohsen): For now, always send explicit selection IPC notifications for
1989 // Aura beucause composited selection updates are not working for webview tags
1990 // which regresses IME inside webview. Remove this when composited selection
1991 // updates are fixed for webviews. See, http://crbug.com/510568.
1992 bool send_ipc = true;
1993#else
jddukeacf809e2014-09-23 20:38:381994 // With composited selection updates, the selection bounds will be reported
1995 // directly by the compositor, in which case explicit IPC selection
1996 // notifications should be suppressed.
mohsenb0eeba72015-08-09 06:20:081997 bool send_ipc =
1998 !blink::WebRuntimeFeatures::isCompositedSelectionUpdateEnabled();
1999#endif
2000 if (send_ipc) {
jddukeacf809e2014-09-23 20:38:382001 ViewHostMsg_SelectionBounds_Params params;
2002 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
2003 if (selection_anchor_rect_ != params.anchor_rect ||
2004 selection_focus_rect_ != params.focus_rect) {
2005 selection_anchor_rect_ = params.anchor_rect;
2006 selection_focus_rect_ = params.focus_rect;
2007 webwidget_->selectionTextDirection(params.focus_dir, params.anchor_dir);
2008 params.is_anchor_first = webwidget_->isSelectionAnchorFirst();
2009 Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
2010 }
[email protected]58b48a0d2012-06-13 07:01:352011 }
jddukeacf809e2014-09-23 20:38:382012
[email protected]88dbe32f2013-06-20 23:31:362013 UpdateCompositionInfo(false);
[email protected]e99ef6f2011-10-16 01:13:002014}
2015
[email protected]180ef242013-11-07 06:50:462016// Check blink::WebTextInputType and ui::TextInputType is kept in sync.
mostynbe29b6882015-01-13 09:59:172017#define STATIC_ASSERT_WTIT_ENUM_MATCH(a, b) \
2018 static_assert(int(blink::WebTextInputType##a) \
2019 == int(ui::TEXT_INPUT_TYPE_##b), \
2020 "mismatching enums: " #a)
2021
2022STATIC_ASSERT_WTIT_ENUM_MATCH(None, NONE);
2023STATIC_ASSERT_WTIT_ENUM_MATCH(Text, TEXT);
2024STATIC_ASSERT_WTIT_ENUM_MATCH(Password, PASSWORD);
2025STATIC_ASSERT_WTIT_ENUM_MATCH(Search, SEARCH);
2026STATIC_ASSERT_WTIT_ENUM_MATCH(Email, EMAIL);
2027STATIC_ASSERT_WTIT_ENUM_MATCH(Number, NUMBER);
2028STATIC_ASSERT_WTIT_ENUM_MATCH(Telephone, TELEPHONE);
2029STATIC_ASSERT_WTIT_ENUM_MATCH(URL, URL);
2030STATIC_ASSERT_WTIT_ENUM_MATCH(Date, DATE);
2031STATIC_ASSERT_WTIT_ENUM_MATCH(DateTime, DATE_TIME);
2032STATIC_ASSERT_WTIT_ENUM_MATCH(DateTimeLocal, DATE_TIME_LOCAL);
2033STATIC_ASSERT_WTIT_ENUM_MATCH(Month, MONTH);
2034STATIC_ASSERT_WTIT_ENUM_MATCH(Time, TIME);
2035STATIC_ASSERT_WTIT_ENUM_MATCH(Week, WEEK);
2036STATIC_ASSERT_WTIT_ENUM_MATCH(TextArea, TEXT_AREA);
2037STATIC_ASSERT_WTIT_ENUM_MATCH(ContentEditable, CONTENT_EDITABLE);
2038STATIC_ASSERT_WTIT_ENUM_MATCH(DateTimeField, DATE_TIME_FIELD);
[email protected]ad26ef42011-06-17 07:59:452039
[email protected]5b739cb2012-08-21 20:35:212040ui::TextInputType RenderWidget::WebKitToUiTextInputType(
[email protected]180ef242013-11-07 06:50:462041 blink::WebTextInputType type) {
[email protected]5b739cb2012-08-21 20:35:212042 // Check the type is in the range representable by ui::TextInputType.
2043 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX)) <<
[email protected]180ef242013-11-07 06:50:462044 "blink::WebTextInputType and ui::TextInputType not synchronized";
[email protected]5b739cb2012-08-21 20:35:212045 return static_cast<ui::TextInputType>(type);
2046}
2047
[email protected]ad26ef42011-06-17 07:59:452048ui::TextInputType RenderWidget::GetTextInputType() {
[email protected]8969bb3f2012-11-30 21:49:272049 if (webwidget_)
2050 return WebKitToUiTextInputType(webwidget_->textInputInfo().type);
[email protected]ad26ef42011-06-17 07:59:452051 return ui::TEXT_INPUT_TYPE_NONE;
2052}
2053
[email protected]501ea13d2013-07-09 17:03:292054void RenderWidget::UpdateCompositionInfo(bool should_update_range) {
yukawa5f21c6a2014-10-27 17:09:302055#if defined(OS_ANDROID)
yukawa6f899b22014-12-15 18:56:112056 // TODO(yukawa): Start sending character bounds when the browser side
2057 // implementation becomes ready (crbug.com/424866).
2058#else
jdduke1aebad8e2015-07-22 23:25:082059 TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo");
[email protected]db4fc1e2013-09-06 20:01:512060 gfx::Range range = gfx::Range();
[email protected]501ea13d2013-07-09 17:03:292061 if (should_update_range) {
2062 GetCompositionRange(&range);
2063 } else {
2064 range = composition_range_;
2065 }
2066 std::vector<gfx::Rect> character_bounds;
2067 GetCompositionCharacterBounds(&character_bounds);
2068
2069 if (!ShouldUpdateCompositionInfo(range, character_bounds))
2070 return;
2071 composition_character_bounds_ = character_bounds;
2072 composition_range_ = range;
[email protected]a2214eb2014-06-23 18:31:222073 Send(new InputHostMsg_ImeCompositionRangeChanged(
[email protected]501ea13d2013-07-09 17:03:292074 routing_id(), composition_range_, composition_character_bounds_));
yukawa6f899b22014-12-15 18:56:112075#endif
[email protected]501ea13d2013-07-09 17:03:292076}
2077
[email protected]58b48a0d2012-06-13 07:01:352078void RenderWidget::GetCompositionCharacterBounds(
2079 std::vector<gfx::Rect>* bounds) {
2080 DCHECK(bounds);
2081 bounds->clear();
2082}
2083
[email protected]db4fc1e2013-09-06 20:01:512084void RenderWidget::GetCompositionRange(gfx::Range* range) {
[email protected]88dbe32f2013-06-20 23:31:362085 size_t location, length;
2086 if (webwidget_->compositionRange(&location, &length)) {
2087 range->set_start(location);
2088 range->set_end(location + length);
2089 } else if (webwidget_->caretOrSelectionRange(&location, &length)) {
2090 range->set_start(location);
2091 range->set_end(location + length);
2092 } else {
[email protected]db4fc1e2013-09-06 20:01:512093 *range = gfx::Range::InvalidRange();
[email protected]88dbe32f2013-06-20 23:31:362094 }
2095}
2096
[email protected]501ea13d2013-07-09 17:03:292097bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:512098 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:292099 const std::vector<gfx::Rect>& bounds) {
2100 if (composition_range_ != range)
2101 return true;
2102 if (bounds.size() != composition_character_bounds_.size())
2103 return true;
2104 for (size_t i = 0; i < bounds.size(); ++i) {
2105 if (bounds[i] != composition_character_bounds_[i])
2106 return true;
2107 }
2108 return false;
2109}
[email protected]501ea13d2013-07-09 17:03:292110
[email protected]a4f0d882014-05-01 23:48:102111#if defined(OS_ANDROID)
timav7a5032e2014-12-05 01:59:432112bool RenderWidget::DoesRecordFullLayer() const {
boliu15ca2652015-09-04 23:33:402113 return false;
timav7a5032e2014-12-05 01:59:432114}
[email protected]a4f0d882014-05-01 23:48:102115#endif
2116
[email protected]ad26ef42011-06-17 07:59:452117bool RenderWidget::CanComposeInline() {
2118 return true;
[email protected]56ea1a62011-05-30 07:05:572119}
2120
[email protected]4873c7d2009-07-16 06:36:282121WebScreenInfo RenderWidget::screenInfo() {
[email protected]842f10652012-06-06 01:54:042122 return screen_info_;
[email protected]4873c7d2009-07-16 06:36:282123}
2124
[email protected]f660d9c2012-06-06 18:31:212125float RenderWidget::deviceScaleFactor() {
2126 return device_scale_factor_;
2127}
2128
[email protected]fa7b1dc2010-06-23 17:53:042129void RenderWidget::resetInputMethod() {
[email protected]0e45bd02013-07-12 20:20:022130 ImeEventGuard guard(this);
[email protected]fa7b1dc2010-06-23 17:53:042131 // If the last text input type is not None, then we should finish any
2132 // ongoing composition regardless of the new text input type.
[email protected]ad26ef42011-06-17 07:59:452133 if (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE) {
[email protected]fa7b1dc2010-06-23 17:53:042134 // If a composition text exists, then we need to let the browser process
2135 // to cancel the input method's ongoing composition session.
2136 if (webwidget_->confirmComposition())
[email protected]a2214eb2014-06-23 18:31:222137 Send(new InputHostMsg_ImeCancelComposition(routing_id()));
[email protected]fa7b1dc2010-06-23 17:53:042138 }
[email protected]d4cff272011-05-02 15:46:012139
[email protected]88dbe32f2013-06-20 23:31:362140 UpdateCompositionInfo(true);
[email protected]fa7b1dc2010-06-23 17:53:042141}
2142
donnda070f3c2015-01-16 19:54:112143#if defined(OS_ANDROID)
2144void RenderWidget::showUnhandledTapUIIfNeeded(
2145 const WebPoint& tapped_position,
2146 const WebNode& tapped_node,
2147 bool page_changed) {
2148 DCHECK(handling_input_event_);
2149 bool should_trigger = !page_changed && tapped_node.isTextNode() &&
donnd57e54f52015-02-26 19:03:372150 !tapped_node.isContentEditable() &&
2151 !tapped_node.isInsideFocusableElementOrARIAWidget();
donnda070f3c2015-01-16 19:54:112152 if (should_trigger) {
2153 Send(new ViewHostMsg_ShowUnhandledTapUIIfNeeded(routing_id_,
2154 tapped_position.x, tapped_position.y));
2155 }
2156}
2157#endif
2158
[email protected]c68c3e4e2013-01-24 00:36:562159void RenderWidget::didHandleGestureEvent(
2160 const WebGestureEvent& event,
2161 bool event_cancelled) {
[email protected]183e28d2014-01-20 18:18:022162#if defined(OS_ANDROID) || defined(USE_AURA)
[email protected]c68c3e4e2013-01-24 00:36:562163 if (event_cancelled)
2164 return;
[email protected]07c70d22014-08-21 08:33:462165 if (event.type == WebInputEvent::GestureTap) {
[email protected]90f24152014-04-09 12:41:362166 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
[email protected]07c70d22014-08-21 08:33:462167 } else if (event.type == WebInputEvent::GestureLongPress) {
2168 DCHECK(webwidget_);
2169 if (webwidget_->textInputInfo().value.isEmpty())
2170 UpdateTextInputState(NO_SHOW_IME, FROM_NON_IME);
2171 else
2172 UpdateTextInputState(SHOW_IME_IF_NEEDED, FROM_NON_IME);
[email protected]c68c3e4e2013-01-24 00:36:562173 }
2174#endif
2175}
2176
sataya.m582c9ce2015-06-09 08:03:422177void RenderWidget::didOverscroll(
2178 const blink::WebFloatSize& unusedDelta,
2179 const blink::WebFloatSize& accumulatedRootOverScroll,
2180 const blink::WebFloatPoint& position,
2181 const blink::WebFloatSize& velocity) {
2182 DidOverscrollParams params;
sataya.m582c9ce2015-06-09 08:03:422183 params.accumulated_overscroll = gfx::Vector2dF(
2184 accumulatedRootOverScroll.width, accumulatedRootOverScroll.height);
2185 params.latest_overscroll_delta =
2186 gfx::Vector2dF(unusedDelta.width, unusedDelta.height);
sataya.ma5cc13a2015-06-13 11:06:022187 // TODO(sataya.m): don't negate velocity once http://crbug.com/499743 is
2188 // fixed.
sataya.m582c9ce2015-06-09 08:03:422189 params.current_fling_velocity =
sataya.ma5cc13a2015-06-13 11:06:022190 gfx::Vector2dF(-velocity.width, -velocity.height);
sataya.m582c9ce2015-06-09 08:03:422191 params.causal_event_viewport_point = gfx::PointF(position.x, position.y);
jddukec05612b2015-06-25 23:13:182192
2193 // If we're currently handling an event, stash the overscroll data such that
2194 // it can be bundled in the event ack.
2195 if (handling_event_overscroll_) {
2196 handling_event_overscroll_->reset(new DidOverscrollParams(params));
2197 return;
2198 }
2199
sataya.m582c9ce2015-06-09 08:03:422200 Send(new InputHostMsg_DidOverscroll(routing_id_, params));
2201}
2202
[email protected]7912e822014-04-16 02:37:032203void RenderWidget::StartCompositor() {
2204 // For widgets that are never visible, we don't need the compositor to run
2205 // at all.
2206 if (never_visible_)
2207 return;
danakj6e3bf8012014-12-16 18:27:532208 // In tests without a RenderThreadImpl, don't set ready as this kicks
2209 // off creating output surfaces that the test can't create.
2210 if (!RenderThreadImpl::current())
2211 return;
danakj018271e32014-12-16 21:17:262212 compositor_->StartCompositor();
[email protected]7912e822014-04-16 02:37:032213}
2214
[email protected]29e2fb42013-07-19 01:13:472215void RenderWidget::SchedulePluginMove(const WebPluginGeometry& move) {
initial.commit09911bf2008-07-26 23:55:292216 size_t i = 0;
2217 for (; i < plugin_window_moves_.size(); ++i) {
2218 if (plugin_window_moves_[i].window == move.window) {
[email protected]16f89d02009-08-26 17:17:582219 if (move.rects_valid) {
2220 plugin_window_moves_[i] = move;
2221 } else {
2222 plugin_window_moves_[i].visible = move.visible;
2223 }
initial.commit09911bf2008-07-26 23:55:292224 break;
2225 }
2226 }
2227
2228 if (i == plugin_window_moves_.size())
2229 plugin_window_moves_.push_back(move);
2230}
[email protected]268654772009-08-06 23:02:042231
2232void RenderWidget::CleanupWindowInPluginMoves(gfx::PluginWindowHandle window) {
2233 for (WebPluginGeometryVector::iterator i = plugin_window_moves_.begin();
2234 i != plugin_window_moves_.end(); ++i) {
2235 if (i->window == window) {
2236 plugin_window_moves_.erase(i);
2237 break;
2238 }
2239 }
2240}
[email protected]67bfb83f2011-09-22 03:36:372241
[email protected]63b465922012-09-06 02:04:522242
[email protected]24ed0432013-04-24 07:50:312243RenderWidgetCompositor* RenderWidget::compositor() const {
2244 return compositor_.get();
2245}
2246
[email protected]180ef242013-11-07 06:50:462247bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
[email protected]67bfb83f2011-09-22 03:36:372248 return false;
2249}
[email protected]c3d45532011-10-07 19:20:402250
[email protected]41d86852012-11-07 12:23:242251bool RenderWidget::WillHandleGestureEvent(
[email protected]180ef242013-11-07 06:50:462252 const blink::WebGestureEvent& event) {
[email protected]41d86852012-11-07 12:23:242253 return false;
2254}
2255
ccamerona7644752014-12-30 01:16:312256void RenderWidget::ObserveWheelEventAndResult(
ccamerond4ba47902014-12-17 07:20:312257 const blink::WebMouseWheelEvent& wheel_event,
sataya.mf405d0e2015-07-07 16:51:112258 const gfx::Vector2dF& wheel_unused_delta,
ccamerond4ba47902014-12-17 07:20:312259 bool event_processed) {
ccamerona7644752014-12-30 01:16:312260 if (!compositor_deps_->IsElasticOverscrollEnabled())
ccamerond4ba47902014-12-17 07:20:312261 return;
2262
ccamerond4ba47902014-12-17 07:20:312263 cc::InputHandlerScrollResult scroll_result;
sataya.mf405d0e2015-07-07 16:51:112264 scroll_result.did_scroll = event_processed;
2265 scroll_result.did_overscroll_root = !wheel_unused_delta.IsZero();
2266 scroll_result.unused_scroll_delta = wheel_unused_delta;
ccamerond4ba47902014-12-17 07:20:312267
2268 RenderThreadImpl* render_thread = RenderThreadImpl::current();
2269 InputHandlerManager* input_handler_manager =
2270 render_thread ? render_thread->input_handler_manager() : NULL;
2271 if (input_handler_manager) {
2272 input_handler_manager->ObserveWheelEventAndResultOnMainThread(
2273 routing_id_, wheel_event, scroll_result);
2274 }
2275}
2276
[email protected]ce6689f2013-03-29 12:52:552277void RenderWidget::hasTouchEventHandlers(bool has_handlers) {
2278 Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
2279}
2280
mostynbe29b6882015-01-13 09:59:172281// Check blink::WebTouchAction and blink::WebTouchActionAuto is kept in sync
2282#define STATIC_ASSERT_WTI_ENUM_MATCH(a, b) \
2283 static_assert(int(blink::WebTouchAction##a) == int(TOUCH_ACTION_##b), \
2284 "mismatching enums: " #a)
2285
dtapuskaa98ac8d72015-05-08 19:29:092286inline content::TouchAction& operator|=(content::TouchAction& a,
2287 content::TouchAction b) {
2288 a = static_cast<content::TouchAction>(static_cast<int>(a) |
2289 static_cast<int>(b));
2290 return a;
2291}
2292
[email protected]5d0bbdfa92013-12-10 00:35:512293void RenderWidget::setTouchAction(
2294 blink::WebTouchAction web_touch_action) {
2295
2296 // Ignore setTouchAction calls that result from synthetic touch events (eg.
2297 // when blink is emulating touch with mouse).
[email protected]c27dd4f2014-05-22 18:05:192298 if (handling_event_type_ != WebInputEvent::TouchStart)
[email protected]5d0bbdfa92013-12-10 00:35:512299 return;
2300
dtapuskaa98ac8d72015-05-08 19:29:092301 // Verify the same values are used by the types so we can cast between them.
mostynbe29b6882015-01-13 09:59:172302 STATIC_ASSERT_WTI_ENUM_MATCH(Auto, AUTO);
2303 STATIC_ASSERT_WTI_ENUM_MATCH(None, NONE);
dtapuskaa98ac8d72015-05-08 19:29:092304 STATIC_ASSERT_WTI_ENUM_MATCH(PanLeft, PAN_LEFT);
2305 STATIC_ASSERT_WTI_ENUM_MATCH(PanRight, PAN_RIGHT);
mostynbe29b6882015-01-13 09:59:172306 STATIC_ASSERT_WTI_ENUM_MATCH(PanX, PAN_X);
dtapuskaa98ac8d72015-05-08 19:29:092307 STATIC_ASSERT_WTI_ENUM_MATCH(PanUp, PAN_UP);
2308 STATIC_ASSERT_WTI_ENUM_MATCH(PanDown, PAN_DOWN);
mostynbe29b6882015-01-13 09:59:172309 STATIC_ASSERT_WTI_ENUM_MATCH(PanY, PAN_Y);
2310 STATIC_ASSERT_WTI_ENUM_MATCH(PinchZoom, PINCH_ZOOM);
[email protected]a18f67a2013-12-20 19:44:362311
2312 content::TouchAction content_touch_action =
2313 static_cast<content::TouchAction>(web_touch_action);
[email protected]5d0bbdfa92013-12-10 00:35:512314 Send(new InputHostMsg_SetTouchAction(routing_id_, content_touch_action));
2315}
2316
[email protected]90f24152014-04-09 12:41:362317void RenderWidget::didUpdateTextOfFocusedElementByNonUserInput() {
2318#if defined(OS_ANDROID)
2319 text_field_is_dirty_ = true;
2320#endif
2321}
2322
[email protected]3d5c243b2012-11-30 00:26:012323bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
2324 return true;
2325}
2326
[email protected]0634cdd42013-08-16 00:46:092327scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
jbauman5e420d32015-08-05 09:33:012328RenderWidget::CreateGraphicsContext3D(bool compositor) {
[email protected]ed7defa2013-03-12 21:29:592329 if (!webwidget_)
[email protected]0634cdd42013-08-16 00:46:092330 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
avi83883c82014-12-23 00:08:492331 if (base::CommandLine::ForCurrentProcess()->HasSwitch(
[email protected]ebc0e1df2013-08-01 02:46:222332 switches::kDisableGpuCompositing))
[email protected]0634cdd42013-08-16 00:46:092333 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]96ab016c2013-10-23 00:50:292334 if (!RenderThreadImpl::current())
2335 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]4d7e46a2013-11-08 05:33:402336 CauseForGpuLaunch cause =
2337 CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
[email protected]96ab016c2013-10-23 00:50:292338 scoped_refptr<GpuChannelHost> gpu_channel_host(
[email protected]4d7e46a2013-11-08 05:33:402339 RenderThreadImpl::current()->EstablishGpuChannelSync(cause));
dcheng58867a92014-08-26 02:50:222340 if (!gpu_channel_host.get())
[email protected]96ab016c2013-10-23 00:50:292341 return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
[email protected]ed7defa2013-03-12 21:29:592342
[email protected]828a3932014-04-02 14:43:132343 // Explicitly disable antialiasing for the compositor. As of the time of
2344 // this writing, the only platform that supported antialiasing for the
2345 // compositor was Mac OS X, because the on-screen OpenGL context creation
2346 // code paths on Windows and Linux didn't yet have multisampling support.
2347 // Mac OS X essentially always behaves as though it's rendering offscreen.
2348 // Multisampling has a heavy cost especially on devices with relatively low
2349 // fill rate like most notebooks, and the Mac implementation would need to
2350 // be optimized to resolve directly into the IOSurface shared between the
2351 // GPU and browser processes. For these reasons and to avoid platform
2352 // disparities we explicitly disable antialiasing.
2353 blink::WebGraphicsContext3D::Attributes attributes;
2354 attributes.antialias = false;
2355 attributes.shareResources = true;
2356 attributes.noAutomaticFlushes = true;
2357 attributes.depth = false;
2358 attributes.stencil = false;
[email protected]828a3932014-04-02 14:43:132359 bool lose_context_when_out_of_memory = true;
[email protected]96ab016c2013-10-23 00:50:292360 WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits limits;
[email protected]b6eb8e332013-09-10 00:51:012361#if defined(OS_ANDROID)
2362 // If we raster too fast we become upload bound, and pending
2363 // uploads consume memory. For maximum upload throughput, we would
2364 // want to allow for upload_throughput * pipeline_time of pending
2365 // uploads, after which we are just wasting memory. Since we don't
2366 // know our upload throughput yet, this just caps our memory usage.
2367 size_t divider = 1;
[email protected]35b4f0c2014-06-26 16:55:272368 if (base::SysInfo::IsLowEndDevice())
[email protected]657be322013-09-20 08:50:032369 divider = 6;
[email protected]b6eb8e332013-09-10 00:51:012370 // For reference Nexus10 can upload 1MB in about 2.5ms.
[email protected]657be322013-09-20 08:50:032371 const double max_mb_uploaded_per_ms = 2.0 / (5 * divider);
[email protected]b6eb8e332013-09-10 00:51:012372 // Deadline to draw a frame to achieve 60 frames per second.
2373 const size_t kMillisecondsPerFrame = 16;
2374 // Assuming a two frame deep pipeline between the CPU and the GPU.
[email protected]657be322013-09-20 08:50:032375 size_t max_transfer_buffer_usage_mb =
2376 static_cast<size_t>(2 * kMillisecondsPerFrame * max_mb_uploaded_per_ms);
2377 static const size_t kBytesPerMegabyte = 1024 * 1024;
[email protected]b6eb8e332013-09-10 00:51:012378 // We keep the MappedMemoryReclaimLimit the same as the upload limit
2379 // to avoid unnecessarily stalling the compositor thread.
[email protected]96ab016c2013-10-23 00:50:292380 limits.mapped_memory_reclaim_limit =
[email protected]657be322013-09-20 08:50:032381 max_transfer_buffer_usage_mb * kBytesPerMegabyte;
[email protected]b6eb8e332013-09-10 00:51:012382#endif
jbauman00ca2dc2015-08-10 23:21:152383 if (compositor) {
jbauman5e420d32015-08-05 09:33:012384 limits.command_buffer_size = 64 * 1024;
jbauman00ca2dc2015-08-10 23:21:152385 limits.start_transfer_buffer_size = 64 * 1024;
2386 limits.min_transfer_buffer_size = 64 * 1024;
2387 }
[email protected]96ab016c2013-10-23 00:50:292388
piman5d36dae2015-09-24 22:47:052389 // TODO(piman): we still need to create a View command buffer until
2390 // crbug.com/526196 is fixed. The surface_id doesn't matter, it just needs to
2391 // be !0.
2392 const int32 kDummySurfaceId = 1;
[email protected]96ab016c2013-10-23 00:50:292393 scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
piman5d36dae2015-09-24 22:47:052394 new WebGraphicsContext3DCommandBufferImpl(
2395 kDummySurfaceId, GetURLForGraphicsContext3D(),
2396 gpu_channel_host.get(), attributes, lose_context_when_out_of_memory,
2397 limits, NULL));
[email protected]0634cdd42013-08-16 00:46:092398 return context.Pass();
[email protected]ed7defa2013-03-12 21:29:592399}
2400
[email protected]e3244ed2014-06-20 20:04:272401void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
2402 render_frame_proxies_.AddObserver(proxy);
[email protected]bffc8302014-01-23 20:52:162403}
2404
[email protected]e3244ed2014-06-20 20:04:272405void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
2406 render_frame_proxies_.RemoveObserver(proxy);
[email protected]bffc8302014-01-23 20:52:162407}
2408
[email protected]de3c5d82014-05-28 22:12:592409void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
2410 render_frames_.AddObserver(frame);
2411}
2412
2413void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) {
2414 render_frames_.RemoveObserver(frame);
2415}
2416
[email protected]a017938b2014-05-27 21:17:172417#if defined(VIDEO_HOLE)
2418void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
2419 video_hole_frames_.AddObserver(frame);
2420}
2421
2422void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
2423 video_hole_frames_.RemoveObserver(frame);
2424}
2425#endif // defined(VIDEO_HOLE)
2426
[email protected]e9ff79c2012-10-19 21:31:262427} // namespace content