blob: a1f2b33308ceb8f5ea5d16515ef83f0deef481c9 [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
danakj4b347212018-07-04 17:55:177#include <cmath>
8#include <limits>
dcheng07945f632015-12-26 07:59:329#include <utility>
10
[email protected]c27dd4f2014-05-22 18:05:1911#include "base/auto_reset.h"
danakj4b347212018-07-04 17:55:1712#include "base/base_switches.h"
[email protected]32876ae2011-11-15 22:25:2113#include "base/bind.h"
Sebastien Marchand17fa2782019-01-25 19:28:1014#include "base/bind_helpers.h"
[email protected]4fb66842009-12-04 21:41:0015#include "base/command_line.h"
changwan7ded3752016-03-09 23:25:1216#include "base/feature_list.h"
initial.commit09911bf2008-07-26 23:55:2917#include "base/logging.h"
avi1023d012015-12-25 02:39:1418#include "base/macros.h"
dchengcedca5612016-04-09 01:40:1519#include "base/memory/ptr_util.h"
[email protected]b256eca2013-07-11 10:57:4020#include "base/memory/singleton.h"
asvitkine8d51e9d2016-09-02 23:55:4321#include "base/metrics/histogram_macros.h"
[email protected]aa4117f2011-12-09 22:19:2122#include "base/stl_util.h"
danakj4b347212018-07-04 17:55:1723#include "base/strings/string_number_conversions.h"
[email protected]74ebfb12013-06-07 20:48:0024#include "base/strings/utf_string_conversions.h"
Sebastien Marchand75a7cdf2018-11-13 23:47:0325#include "base/system/sys_info.h"
fdoraya19b7702016-12-23 14:19:3126#include "base/threading/thread_task_runner_handle.h"
primiano9e38d552015-01-28 04:18:0127#include "base/trace_event/trace_event.h"
[email protected]661eb9d2009-02-03 02:11:4828#include "build/build_config.h"
loyso6e6efc42017-01-21 02:23:0329#include "cc/animation/animation_host.h"
danakj4b347212018-07-04 17:55:1730#include "cc/base/switches.h"
xidachenfa0199e72017-05-11 11:34:2631#include "cc/input/touch_action.h"
Erik Chend44f1632019-08-20 17:31:0632#include "cc/paint/paint_worklet_layer_painter.h"
danakjba65a0912017-09-21 16:38:4233#include "cc/trees/layer_tree_frame_sink.h"
loyso6e6efc42017-01-21 02:23:0334#include "cc/trees/layer_tree_host.h"
danakj4c987652018-07-05 15:49:4135#include "cc/trees/ukm_manager.h"
Eric Karlfc977f72019-09-19 16:59:5536#include "components/viz/common/display/de_jelly.h"
danakj4b347212018-07-04 17:55:1737#include "components/viz/common/features.h"
Fady Samuelc645ffe2017-07-24 17:28:2038#include "components/viz/common/frame_sinks/begin_frame_source.h"
danakjf20f4502017-09-26 17:13:3139#include "components/viz/common/frame_sinks/copy_output_request.h"
danakj4b347212018-07-04 17:55:1740#include "components/viz/common/switches.h"
41#include "content/common/content_switches_internal.h"
paulmeyer6ef5a792016-11-08 20:33:5842#include "content/common/drag_event_source_info.h"
43#include "content/common/drag_messages.h"
jonrossa2ff4f82018-02-16 17:27:4644#include "content/common/render_frame_metadata.mojom.h"
jcivelliae1560a2016-11-01 22:40:2345#include "content/common/render_message_filter.mojom.h"
Nasko Oskovf97e8b02017-07-25 02:45:4246#include "content/common/swapped_out_messages.h"
ekaramad9053e57b2016-04-26 20:00:3847#include "content/common/text_input_state.h"
Albert J. Wong3c93c182018-09-27 17:29:4348#include "content/common/widget_messages.h"
mlamouriafca06dd2017-01-27 23:35:1849#include "content/public/common/content_client.h"
changwan7ded3752016-03-09 23:25:1250#include "content/public/common/content_features.h"
[email protected]c08950d22011-10-13 22:20:2951#include "content/public/common/content_switches.h"
[email protected]a09d53ce2014-01-31 00:46:4252#include "content/public/common/context_menu_params.h"
paulmeyer90f6c31d2016-11-12 00:17:5953#include "content/public/common/drop_data.h"
Khushal3e96e662017-10-30 23:16:5054#include "content/public/common/service_names.mojom.h"
Jaebaek Seo655110e2017-12-19 23:27:3955#include "content/public/common/use_zoom_for_dsf_policy.h"
mlamouriafca06dd2017-01-27 23:35:1856#include "content/public/renderer/content_renderer_client.h"
Avi Drissman07d22452019-03-25 17:56:3957#include "content/public/renderer/render_thread.h"
Saman Samid189e5dfd2017-12-20 22:55:3158#include "content/renderer/browser_plugin/browser_plugin.h"
Erik Chene8e50c622019-08-28 01:57:4959#include "content/renderer/browser_plugin/browser_plugin_manager.h"
Sadrul Habib Chowdhury31c98712018-12-11 04:15:1360#include "content/renderer/compositor/layer_tree_view.h"
paulmeyer6ef5a792016-11-08 20:33:5861#include "content/renderer/drop_data_builder.h"
[email protected]b2e4c70132013-10-03 02:07:5162#include "content/renderer/external_popup_menu.h"
Sadrul Habib Chowdhury31c98712018-12-11 04:15:1363#include "content/renderer/frame_swap_message_queue.h"
[email protected]66fca5bc2013-05-23 06:58:2964#include "content/renderer/ime_event_guard.h"
dtapuska9ec1a912017-04-21 15:18:3165#include "content/renderer/input/main_thread_event_queue.h"
Dave Tapuska9db80842017-07-24 17:24:2666#include "content/renderer/input/widget_input_handler_manager.h"
[email protected]adab2332013-07-25 18:04:3267#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
Sadrul Habib Chowdhury31c98712018-12-11 04:15:1368#include "content/renderer/queue_message_swap_promise.h"
[email protected]bffc8302014-01-23 20:52:1669#include "content/renderer/render_frame_impl.h"
danakj4b347212018-07-04 17:55:1770#include "content/renderer/render_frame_metadata_observer_impl.h"
[email protected]e3244ed2014-06-20 20:04:2771#include "content/renderer/render_frame_proxy.h"
[email protected]8704f89b2011-04-15 00:30:0572#include "content/renderer/render_process.h"
[email protected]f1a29a02011-10-06 23:08:4473#include "content/renderer/render_thread_impl.h"
dcheng3ce04b62015-10-26 23:30:5574#include "content/renderer/render_view_impl.h"
Abhijeet Kandalkardccbd612019-04-08 17:37:0975#include "content/renderer/render_widget_screen_metrics_emulator.h"
tfarina556a7232014-10-05 01:02:0976#include "content/renderer/renderer_blink_platform_impl.h"
danakj4b347212018-07-04 17:55:1777#include "gpu/command_buffer/service/gpu_switches.h"
ekaramad330ba4232016-09-23 17:57:4778#include "ipc/ipc_message_start.h"
[email protected]484955942010-08-19 16:13:1879#include "ipc/ipc_sync_message.h"
Antoine Laboure55c9ef82017-11-10 18:51:2380#include "ipc/ipc_sync_message_filter.h"
danakj4b347212018-07-04 17:55:1781#include "media/base/media_switches.h"
Julie Jeongeun Kim6f4b7e02019-09-11 05:05:4682#include "mojo/public/cpp/bindings/pending_remote.h"
Scott Violet02e38b92018-03-27 23:42:1483#include "ppapi/buildflags/buildflags.h"
[email protected]661eb9d2009-02-03 02:11:4884#include "skia/ext/platform_canvas.h"
Blink Reformata30d4232018-04-07 15:31:0685#include "third_party/blink/public/platform/file_path_conversion.h"
Hajime Hoshi315a61f2018-08-14 17:27:2886#include "third_party/blink/public/platform/platform.h"
Blink Reformata30d4232018-04-07 15:31:0687#include "third_party/blink/public/platform/scheduler/web_render_widget_scheduling_state.h"
Yuta Kitamuradeb91bb2018-05-29 05:53:2088#include "third_party/blink/public/platform/scheduler/web_thread_scheduler.h"
Blink Reformata30d4232018-04-07 15:31:0689#include "third_party/blink/public/platform/web_cursor_info.h"
90#include "third_party/blink/public/platform/web_drag_data.h"
91#include "third_party/blink/public/platform/web_drag_operation.h"
92#include "third_party/blink/public/platform/web_mouse_event.h"
93#include "third_party/blink/public/platform/web_point.h"
94#include "third_party/blink/public/platform/web_rect.h"
95#include "third_party/blink/public/platform/web_runtime_features.h"
96#include "third_party/blink/public/platform/web_size.h"
97#include "third_party/blink/public/platform/web_string.h"
98#include "third_party/blink/public/web/web_autofill_client.h"
99#include "third_party/blink/public/web/web_device_emulation_params.h"
100#include "third_party/blink/public/web/web_frame_widget.h"
101#include "third_party/blink/public/web/web_input_method_controller.h"
102#include "third_party/blink/public/web/web_local_frame.h"
103#include "third_party/blink/public/web/web_node.h"
104#include "third_party/blink/public/web/web_page_popup.h"
105#include "third_party/blink/public/web/web_popup_menu_info.h"
106#include "third_party/blink/public/web/web_range.h"
107#include "third_party/blink/public/web/web_settings.h"
108#include "third_party/blink/public/web/web_view.h"
109#include "third_party/blink/public/web/web_widget.h"
[email protected]d353541f2012-05-03 22:45:41110#include "third_party/skia/include/core/SkShader.h"
Maksim Sisova33072d22019-01-24 15:44:25111#include "ui/base/clipboard/clipboard_constants.h"
Scott Violet8ff9c302018-02-22 22:28:35112#include "ui/base/ui_base_features.h"
danakj4b347212018-07-04 17:55:17113#include "ui/base/ui_base_switches.h"
dtapuska97286c882017-02-24 23:14:43114#include "ui/events/base_event_utils.h"
tfarina655f81d2014-12-23 02:38:50115#include "ui/gfx/geometry/point_conversions.h"
tfarina3b0452d2014-12-31 15:20:09116#include "ui/gfx/geometry/rect_conversions.h"
tfarinaebe974f02015-01-03 04:25:32117#include "ui/gfx/geometry/size_conversions.h"
[email protected]1835b9e2012-02-28 13:12:48118#include "ui/gfx/skia_util.h"
danakj4b347212018-07-04 17:55:17119#include "ui/gfx/switches.h"
[email protected]c9e2cbbb2012-05-12 21:17:27120#include "ui/gl/gl_switches.h"
danakj4b347212018-07-04 17:55:17121#include "ui/native_theme/native_theme_features.h"
122#include "ui/native_theme/overlay_scrollbar_constants_aura.h"
[email protected]d353541f2012-05-03 22:45:41123#include "ui/surface/transport_dib.h"
[email protected]661eb9d2009-02-03 02:11:48124
[email protected]eeb93112013-05-01 19:41:10125#if defined(OS_ANDROID)
[email protected]cefe9b152014-03-27 18:16:15126#include <android/keycodes.h>
wjmaclean1d970622017-01-21 22:28:24127#include "base/time/time.h"
[email protected]eeb93112013-05-01 19:41:10128#endif
129
[email protected]661eb9d2009-02-03 02:11:48130#if defined(OS_POSIX)
[email protected]d5282e72009-05-13 13:16:52131#include "third_party/skia/include/core/SkMallocPixelRef.h"
[email protected]d353541f2012-05-03 22:45:41132#include "third_party/skia/include/core/SkPixelRef.h"
[email protected]661eb9d2009-02-03 02:11:48133#endif // defined(OS_POSIX)
[email protected]8085dbc82008-09-26 22:53:44134
Ryan Landay9e42fd742017-08-12 01:59:11135using blink::WebImeTextSpan;
[email protected]180ef242013-11-07 06:50:46136using blink::WebCursorInfo;
[email protected]19193682014-04-03 15:01:43137using blink::WebDeviceEmulationParams;
paulmeyer90f6c31d2016-11-12 00:17:59138using blink::WebDragOperation;
paulmeyer6ef5a792016-11-08 20:33:58139using blink::WebDragOperationsMask;
140using blink::WebDragData;
paulmeyer90f6c31d2016-11-12 00:17:59141using blink::WebFrameWidget;
[email protected]180ef242013-11-07 06:50:46142using blink::WebGestureEvent;
143using blink::WebInputEvent;
dtapuska5d2e9c32015-12-03 16:39:49144using blink::WebInputEventResult;
ekaramad2daaf672016-11-10 20:29:01145using blink::WebInputMethodController;
paulmeyer6ef5a792016-11-08 20:33:58146using blink::WebLocalFrame;
[email protected]180ef242013-11-07 06:50:46147using blink::WebMouseEvent;
148using blink::WebMouseWheelEvent;
149using blink::WebNavigationPolicy;
donnda070f3c2015-01-16 19:54:11150using blink::WebNode;
[email protected]180ef242013-11-07 06:50:46151using blink::WebPagePopup;
dglazkove353a372016-09-01 01:33:48152using blink::WebRange;
[email protected]180ef242013-11-07 06:50:46153using blink::WebRect;
[email protected]180ef242013-11-07 06:50:46154using blink::WebSize;
paulmeyer90f6c31d2016-11-12 00:17:59155using blink::WebString;
[email protected]180ef242013-11-07 06:50:46156using blink::WebTextDirection;
157using blink::WebTouchEvent;
[email protected]f8ed4722013-12-03 03:27:25158using blink::WebTouchPoint;
[email protected]180ef242013-11-07 06:50:46159using blink::WebVector;
160using blink::WebWidget;
[email protected]e9ff79c2012-10-19 21:31:26161
paulmeyer90f6c31d2016-11-12 00:17:59162namespace content {
163
[email protected]6a4d7f62013-01-07 21:32:13164namespace {
[email protected]b256eca2013-07-11 10:57:40165
Albert J. Wong2727e8a82019-02-15 16:56:11166RenderWidget::CreateRenderWidgetFunction g_create_render_widget_for_frame =
167 nullptr;
168
Albert J. Wongcb004632018-07-10 22:58:25169using RoutingIDWidgetMap = std::map<int32_t, RenderWidget*>;
170base::LazyInstance<RoutingIDWidgetMap>::Leaky g_routing_id_widget_map =
171 LAZY_INSTANCE_INITIALIZER;
172
danakj4b347212018-07-04 17:55:17173const base::Feature kUnpremultiplyAndDitherLowBitDepthTiles = {
174 "UnpremultiplyAndDitherLowBitDepthTiles", base::FEATURE_ENABLED_BY_DEFAULT};
175
[email protected]b256eca2013-07-11 10:57:40176typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
177
AJITH KUMAR V041c0b02017-08-08 10:39:20178static const int kInvalidNextPreviousFlagsValue = -1;
yiyix6b90ef52018-10-09 19:55:30179static const char* kOOPIF = "OOPIF";
180static const char* kRenderer = "Renderer";
AJITH KUMAR V041c0b02017-08-08 10:39:20181
Ian Vollick7a847a82019-06-14 19:58:59182#if defined(OS_ANDROID)
183// With 32 bit pixels, this would mean less than 400kb per buffer. Much less
184// than required for, say, nHD.
185static const int kSmallScreenPixelThreshold = 1e5;
186bool IsSmallScreen(const gfx::Size& size) {
187 int area = 0;
188 if (!size.GetCheckedArea().AssignIfValid(&area))
189 return false;
190 return area < kSmallScreenPixelThreshold;
191}
192#endif
193
lfgbee1e0a2016-06-08 21:24:21194class WebWidgetLockTarget : public content::MouseLockDispatcher::LockTarget {
195 public:
Erik Chen7b985822019-08-30 00:39:12196 explicit WebWidgetLockTarget(RenderWidget* render_widget)
197 : render_widget_(render_widget) {}
lfgbee1e0a2016-06-08 21:24:21198
199 void OnLockMouseACK(bool succeeded) override {
Erik Chen7b985822019-08-30 00:39:12200 // TODO(https://crbug.com/995981): Once RenderWidget and WebWidget lifetimes
201 // are synchronized, we should remove these conditionals.
202 WebWidget* web_widget = render_widget_->GetWebWidget();
203 if (!web_widget)
204 return;
205
lfgbee1e0a2016-06-08 21:24:21206 if (succeeded)
Erik Chen7b985822019-08-30 00:39:12207 web_widget->DidAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21208 else
Erik Chen7b985822019-08-30 00:39:12209 web_widget->DidNotAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21210 }
211
Erik Chen7b985822019-08-30 00:39:12212 void OnMouseLockLost() override {
213 WebWidget* web_widget = render_widget_->GetWebWidget();
214 if (!web_widget)
215 return;
216
217 web_widget->DidLosePointerLock();
218 }
lfgbee1e0a2016-06-08 21:24:21219
220 bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event) override {
221 // The WebWidget handles mouse lock in Blink's handleInputEvent().
222 return false;
223 }
224
225 private:
Erik Chen7b985822019-08-30 00:39:12226 // The RenderWidget owns this instance and is guaranteed to outlive it.
227 RenderWidget* render_widget_;
lfgbee1e0a2016-06-08 21:24:21228};
229
Stephen Chenneyd56b5382019-01-29 00:37:02230class ScopedUkmRafAlignedInputTimer {
231 public:
232 explicit ScopedUkmRafAlignedInputTimer(blink::WebWidget* webwidget)
233 : webwidget_(webwidget) {
234 webwidget_->BeginRafAlignedInput();
235 }
236
237 ~ScopedUkmRafAlignedInputTimer() { webwidget_->EndRafAlignedInput(); }
238
239 private:
240 blink::WebWidget* webwidget_;
241
242 DISALLOW_COPY_AND_ASSIGN(ScopedUkmRafAlignedInputTimer);
243};
244
dglazkov97b6c2b2016-10-25 17:35:55245bool IsDateTimeInput(ui::TextInputType type) {
246 return type == ui::TEXT_INPUT_TYPE_DATE ||
247 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
248 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
249 type == ui::TEXT_INPUT_TYPE_MONTH ||
250 type == ui::TEXT_INPUT_TYPE_TIME || type == ui::TEXT_INPUT_TYPE_WEEK;
251}
252
paulmeyer90f6c31d2016-11-12 00:17:59253WebDragData DropMetaDataToWebDragData(
254 const std::vector<DropData::Metadata>& drop_meta_data) {
255 std::vector<WebDragData::Item> item_list;
256 for (const auto& meta_data_item : drop_meta_data) {
257 if (meta_data_item.kind == DropData::Kind::STRING) {
258 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54259 item.storage_type = WebDragData::Item::kStorageTypeString;
260 item.string_type = WebString::FromUTF16(meta_data_item.mime_type);
paulmeyer90f6c31d2016-11-12 00:17:59261 // Have to pass a dummy URL here instead of an empty URL because the
262 // DropData received by browser_plugins goes through a round trip:
263 // DropData::MetaData --> WebDragData-->DropData. In the end, DropData
264 // will contain an empty URL (which means no URL is dragged) if the URL in
265 // WebDragData is empty.
Maksim Sisova33072d22019-01-24 15:44:25266 if (base::EqualsASCII(meta_data_item.mime_type, ui::kMimeTypeURIList)) {
Blink Reformat1c4d759e2017-04-09 16:34:54267 item.string_data = WebString::FromUTF8("about:dragdrop-placeholder");
paulmeyer90f6c31d2016-11-12 00:17:59268 }
269 item_list.push_back(item);
270 continue;
271 }
272
273 // TODO(hush): crbug.com/584789. Blink needs to support creating a file with
274 // just the mimetype. This is needed to drag files to WebView on Android
275 // platform.
276 if ((meta_data_item.kind == DropData::Kind::FILENAME) &&
277 !meta_data_item.filename.empty()) {
278 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54279 item.storage_type = WebDragData::Item::kStorageTypeFilename;
280 item.filename_data = blink::FilePathToWebString(meta_data_item.filename);
paulmeyer90f6c31d2016-11-12 00:17:59281 item_list.push_back(item);
282 continue;
283 }
284
285 if (meta_data_item.kind == DropData::Kind::FILESYSTEMFILE) {
286 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54287 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
288 item.file_system_url = meta_data_item.file_system_url;
paulmeyer90f6c31d2016-11-12 00:17:59289 item_list.push_back(item);
290 continue;
291 }
292 }
293
294 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54295 result.Initialize();
296 result.SetItems(item_list);
paulmeyer90f6c31d2016-11-12 00:17:59297 return result;
298}
299
300WebDragData DropDataToWebDragData(const DropData& drop_data) {
301 std::vector<WebDragData::Item> item_list;
302
303 // These fields are currently unused when dragging into WebKit.
304 DCHECK(drop_data.download_metadata.empty());
305 DCHECK(drop_data.file_contents.empty());
dcheng3dd85612017-02-08 10:46:23306 DCHECK(drop_data.file_contents_content_disposition.empty());
paulmeyer90f6c31d2016-11-12 00:17:59307
308 if (!drop_data.text.is_null()) {
309 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54310 item.storage_type = WebDragData::Item::kStorageTypeString;
Maksim Sisova33072d22019-01-24 15:44:25311 item.string_type = WebString::FromUTF8(ui::kMimeTypeText);
Blink Reformat1c4d759e2017-04-09 16:34:54312 item.string_data = WebString::FromUTF16(drop_data.text.string());
paulmeyer90f6c31d2016-11-12 00:17:59313 item_list.push_back(item);
314 }
315
316 if (!drop_data.url.is_empty()) {
317 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54318 item.storage_type = WebDragData::Item::kStorageTypeString;
Maksim Sisova33072d22019-01-24 15:44:25319 item.string_type = WebString::FromUTF8(ui::kMimeTypeURIList);
Blink Reformat1c4d759e2017-04-09 16:34:54320 item.string_data = WebString::FromUTF8(drop_data.url.spec());
321 item.title = WebString::FromUTF16(drop_data.url_title);
paulmeyer90f6c31d2016-11-12 00:17:59322 item_list.push_back(item);
323 }
324
325 if (!drop_data.html.is_null()) {
326 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54327 item.storage_type = WebDragData::Item::kStorageTypeString;
Maksim Sisova33072d22019-01-24 15:44:25328 item.string_type = WebString::FromUTF8(ui::kMimeTypeHTML);
Blink Reformat1c4d759e2017-04-09 16:34:54329 item.string_data = WebString::FromUTF16(drop_data.html.string());
330 item.base_url = drop_data.html_base_url;
paulmeyer90f6c31d2016-11-12 00:17:59331 item_list.push_back(item);
332 }
333
Darwin Huangb2ad4892019-05-13 20:15:39334 for (const ui::FileInfo& filename : drop_data.filenames) {
paulmeyer90f6c31d2016-11-12 00:17:59335 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54336 item.storage_type = WebDragData::Item::kStorageTypeFilename;
Darwin Huangb2ad4892019-05-13 20:15:39337 item.filename_data = blink::FilePathToWebString(filename.path);
Blink Reformat1c4d759e2017-04-09 16:34:54338 item.display_name_data =
Darwin Huangb2ad4892019-05-13 20:15:39339 blink::FilePathToWebString(base::FilePath(filename.display_name));
paulmeyer90f6c31d2016-11-12 00:17:59340 item_list.push_back(item);
341 }
342
Darwin Huangb2ad4892019-05-13 20:15:39343 for (const DropData::FileSystemFileInfo& file : drop_data.file_system_files) {
paulmeyer90f6c31d2016-11-12 00:17:59344 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54345 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
Darwin Huangb2ad4892019-05-13 20:15:39346 item.file_system_url = file.url;
347 item.file_system_file_size = file.size;
348 item.file_system_id = blink::WebString::FromASCII(file.filesystem_id);
paulmeyer90f6c31d2016-11-12 00:17:59349 item_list.push_back(item);
350 }
351
Darwin Huangb2ad4892019-05-13 20:15:39352 for (const auto& data : drop_data.custom_data) {
paulmeyer90f6c31d2016-11-12 00:17:59353 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54354 item.storage_type = WebDragData::Item::kStorageTypeString;
Darwin Huangb2ad4892019-05-13 20:15:39355 item.string_type = WebString::FromUTF16(data.first);
356 item.string_data = WebString::FromUTF16(data.second);
paulmeyer90f6c31d2016-11-12 00:17:59357 item_list.push_back(item);
358 }
359
360 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54361 result.Initialize();
362 result.SetItems(item_list);
363 result.SetFilesystemId(WebString::FromUTF16(drop_data.filesystem_id));
paulmeyer90f6c31d2016-11-12 00:17:59364 return result;
365}
366
dtapuskac4dd5be2016-10-25 15:11:10367ui::TextInputType ConvertWebTextInputType(blink::WebTextInputType type) {
368 // Check the type is in the range representable by ui::TextInputType.
369 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX))
370 << "blink::WebTextInputType and ui::TextInputType not synchronized";
371 return static_cast<ui::TextInputType>(type);
372}
373
374ui::TextInputMode ConvertWebTextInputMode(blink::WebTextInputMode mode) {
375 // Check the mode is in the range representable by ui::TextInputMode.
376 DCHECK_LE(mode, static_cast<int>(ui::TEXT_INPUT_MODE_MAX))
377 << "blink::WebTextInputMode and ui::TextInputMode not synchronized";
378 return static_cast<ui::TextInputMode>(mode);
379}
380
Mitsuru Oshima3c07b332018-02-06 04:56:50381// Returns true if the device scale is high enough that losing subpixel
382// antialiasing won't have a noticeable effect on text quality.
383static bool DeviceScaleEnsuresTextQuality(float device_scale_factor) {
384#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
385 // On Android, we never have subpixel antialiasing. On Chrome OS we prefer to
386 // composite all scrollers so that we get animated overlay scrollbars.
387 return true;
388#else
389 // 1.5 is a common touchscreen tablet device scale factor. For such
390 // devices main thread antialiasing is a heavy burden.
391 return device_scale_factor >= 1.5f;
392#endif
393}
394
danakjcf409aa2019-09-20 15:22:30395static bool ComputePreferCompositingToLCDText(
396 CompositorDependencies* compositor_deps,
397 float device_scale_factor) {
Mitsuru Oshima3c07b332018-02-06 04:56:50398 const base::CommandLine& command_line =
399 *base::CommandLine::ForCurrentProcess();
400 if (command_line.HasSwitch(switches::kDisablePreferCompositingToLCDText))
401 return false;
402 if (command_line.HasSwitch(switches::kEnablePreferCompositingToLCDText))
403 return true;
404 if (!compositor_deps->IsLcdTextEnabled())
405 return true;
Sam Fortiner263211222019-08-09 16:44:41406 if (base::FeatureList::IsEnabled(features::kPreferCompositingToLCDText))
407 return true;
Mitsuru Oshima3c07b332018-02-06 04:56:50408 return DeviceScaleEnsuresTextQuality(device_scale_factor);
409}
410
[email protected]b256eca2013-07-11 10:57:40411} // namespace
412
[email protected]b2e4c70132013-10-03 02:07:51413// RenderWidget ---------------------------------------------------------------
414
Albert J. Wong2727e8a82019-02-15 16:56:11415// static
416void RenderWidget::InstallCreateForFrameHook(
417 CreateRenderWidgetFunction create_widget) {
418 g_create_render_widget_for_frame = create_widget;
419}
420
Erik Chen3433ee02019-08-05 20:14:26421std::unique_ptr<RenderWidget> RenderWidget::CreateForFrame(
Albert J. Wong2727e8a82019-02-15 16:56:11422 int32_t widget_routing_id,
423 CompositorDependencies* compositor_deps,
Albert J. Wongdd88f5e2019-09-11 19:22:04424 PageProperties* page_properties,
Albert J. Wong2727e8a82019-02-15 16:56:11425 blink::WebDisplayMode display_mode,
danakjbd1a86a2019-09-06 17:24:31426 bool is_undead,
Erik Chen10e9b022019-08-21 23:33:23427 bool never_visible) {
Albert J. Wong2727e8a82019-02-15 16:56:11428 if (g_create_render_widget_for_frame) {
Julie Jeongeun Kim02291d732019-09-07 03:08:58429 return g_create_render_widget_for_frame(
Albert J. Wonga3dbd5442019-09-18 10:38:28430 widget_routing_id, compositor_deps, page_properties, display_mode,
431 is_undead, never_visible, mojo::NullReceiver());
Albert J. Wong2727e8a82019-02-15 16:56:11432 }
433
Erik Chen3433ee02019-08-05 20:14:26434 return std::make_unique<RenderWidget>(
Albert J. Wonga3dbd5442019-09-18 10:38:28435 widget_routing_id, compositor_deps, page_properties, display_mode,
436 is_undead,
Julie Jeongeun Kim02291d732019-09-07 03:08:58437 /*hidden=*/true, never_visible, mojo::NullReceiver());
Albert J. Wong2727e8a82019-02-15 16:56:11438}
439
Erik Chen3433ee02019-08-05 20:14:26440RenderWidget* RenderWidget::CreateForPopup(
Albert J. Wong2727e8a82019-02-15 16:56:11441 int32_t widget_routing_id,
442 CompositorDependencies* compositor_deps,
Albert J. Wongdd88f5e2019-09-11 19:22:04443 PageProperties* page_properties,
Albert J. Wong2727e8a82019-02-15 16:56:11444 blink::WebDisplayMode display_mode,
Albert J. Wong2727e8a82019-02-15 16:56:11445 bool hidden,
446 bool never_visible,
Julie Jeongeun Kim02291d732019-09-07 03:08:58447 mojo::PendingReceiver<mojom::Widget> widget_receiver) {
Albert J. Wongdd88f5e2019-09-11 19:22:04448 return new RenderWidget(widget_routing_id, compositor_deps, page_properties,
Albert J. Wonga3dbd5442019-09-18 10:38:28449 display_mode, /*is_undead=*/false, hidden,
450 never_visible, std::move(widget_receiver));
Albert J. Wong2727e8a82019-02-15 16:56:11451}
452
danakj829cdd142018-09-14 21:13:27453RenderWidget::RenderWidget(int32_t widget_routing_id,
454 CompositorDependencies* compositor_deps,
Albert J. Wongdd88f5e2019-09-11 19:22:04455 PageProperties* page_properties,
danakj829cdd142018-09-14 21:13:27456 blink::WebDisplayMode display_mode,
danakjbd1a86a2019-09-06 17:24:31457 bool is_undead,
danakj829cdd142018-09-14 21:13:27458 bool hidden,
459 bool never_visible,
Julie Jeongeun Kim02291d732019-09-07 03:08:58460 mojo::PendingReceiver<mojom::Widget> widget_receiver)
nick8331f8ad2016-11-15 20:42:45461 : routing_id_(widget_routing_id),
dcheng35d31c112015-07-22 00:17:36462 compositor_deps_(compositor_deps),
Albert J. Wongdd88f5e2019-09-11 19:22:04463 page_properties_(page_properties),
[email protected]1ac10dca2013-08-20 20:47:04464 is_hidden_(hidden),
danakj2d2889a2019-04-05 21:22:08465 compositor_never_visible_(never_visible),
danakj73dd3032018-07-28 17:49:53466 display_mode_(display_mode),
danakjbd1a86a2019-09-06 17:24:31467 is_undead_(is_undead),
AJITH KUMAR V041c0b02017-08-08 10:39:20468 next_previous_flags_(kInvalidNextPreviousFlagsValue),
samans26510e442017-06-01 22:29:12469 frame_swap_message_queue_(new FrameSwapMessageQueue(routing_id_)),
Julie Jeongeun Kim02291d732019-09-07 03:08:58470 widget_receiver_(this, std::move(widget_receiver)) {
nick8331f8ad2016-11-15 20:42:45471 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
Avi Drissman07d22452019-03-25 17:56:39472 DCHECK(RenderThread::IsMainThread());
Albert J. Wongdd88f5e2019-09-11 19:22:04473 DCHECK(page_properties);
alexclarke7fa93942015-10-21 15:37:11474
475 // In tests there may not be a RenderThreadImpl.
476 if (RenderThreadImpl::current()) {
477 render_widget_scheduling_state_ = RenderThreadImpl::current()
Yuta Kitamura3331f5c2018-04-05 11:12:25478 ->GetWebMainThreadScheduler()
dcheng07945f632015-12-26 07:59:32479 ->NewRenderWidgetSchedulingState();
alexclarke7fa93942015-10-21 15:37:11480 render_widget_scheduling_state_->SetHidden(is_hidden_);
481 }
Albert J. Wongcb004632018-07-10 22:58:25482
483 if (routing_id_ != MSG_ROUTING_NONE)
484 g_routing_id_widget_map.Get().emplace(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29485}
486
487RenderWidget::~RenderWidget() {
danakj557248b2019-09-25 17:17:40488 DCHECK(!webwidget_) << "Leaking our WebWidget!";
Erik Chen3433ee02019-08-05 20:14:26489 DCHECK(closed_)
490 << " RenderWidget must be destroyed via RenderWidget::Close()";
Albert J. Wong7bbf22d2018-12-20 00:27:27491
Albert J. Wongcb004632018-07-10 22:58:25492 // TODO(ajwong): Add in check that routing_id_ has been removed from
493 // g_routing_id_widget_map once the shutdown semantics for RenderWidget
494 // and RenderViewImpl are rationalized. Currently, too many unit and
495 // browser tests delete a RenderWidget without correclty going through
496 // the shutdown. https://crbug.com/545684
initial.commit09911bf2008-07-26 23:55:29497}
498
[email protected]484955942010-08-19 16:13:18499// static
Albert J. Wongcb004632018-07-10 22:58:25500RenderWidget* RenderWidget::FromRoutingID(int32_t routing_id) {
Avi Drissman07d22452019-03-25 17:56:39501 DCHECK(RenderThread::IsMainThread());
Albert J. Wongcb004632018-07-10 22:58:25502 RoutingIDWidgetMap* widgets = g_routing_id_widget_map.Pointer();
jdoerrie5a73d0fa2018-10-02 23:54:05503 auto it = widgets->find(routing_id);
Albert J. Wongcb004632018-07-10 22:58:25504 return it == widgets->end() ? NULL : it->second;
505}
506
danakj25ec6e2b2018-09-26 17:01:31507void RenderWidget::InitForPopup(ShowCallback show_callback,
508 blink::WebPagePopup* web_page_popup) {
Erik Chen3433ee02019-08-05 20:14:26509 popup_ = true;
danakj25ec6e2b2018-09-26 17:01:31510 Init(std::move(show_callback), web_page_popup);
initial.commit09911bf2008-07-26 23:55:29511}
512
danakj872a96a12019-09-18 21:53:14513void RenderWidget::InitForPepperFullscreen(ShowCallback show_callback,
514 blink::WebWidget* web_widget) {
515 pepper_fullscreen_ = true;
516 Init(std::move(show_callback), web_widget);
517}
518
519void RenderWidget::InitForMainFrame(ShowCallback show_callback,
520 blink::WebFrameWidget* web_frame_widget) {
521 Init(std::move(show_callback), web_frame_widget);
522}
523
danakj6a816592018-09-25 18:30:56524void RenderWidget::InitForChildLocalRoot(
525 blink::WebFrameWidget* web_frame_widget) {
danakj6dcbc5962018-11-16 16:45:42526 for_child_local_root_frame_ = true;
danakj6a816592018-09-25 18:30:56527 Init(base::NullCallback(), web_frame_widget);
dchengda9b4bb2015-07-20 20:58:08528}
529
Erik Chen3433ee02019-08-05 20:14:26530void RenderWidget::CloseForFrame(std::unique_ptr<RenderWidget> widget) {
danakj8f0bd6c2019-03-14 15:35:24531 DCHECK(for_child_local_root_frame_);
danakj557248b2019-09-25 17:17:40532 DCHECK_EQ(widget.get(), this); // This method takes ownership of |this|.
533
Erik Chen3433ee02019-08-05 20:14:26534 PrepareForClose();
535
536 // The RenderWidget may be deattached from JS, which in turn may be called
537 // in a re-entrant context. We cannot synchronously destroy the object, so we
538 // post a task to do so later.
539 GetCleanupTaskRunner()->PostNonNestableTask(
540 FROM_HERE,
541 base::BindOnce(&RenderWidget::Close, close_weak_ptr_factory_.GetWeakPtr(),
542 std::move(widget)));
kenrba7199832015-01-22 23:44:59543}
544
Scott Violetae08f332018-07-27 17:37:23545void RenderWidget::Init(ShowCallback show_callback, WebWidget* web_widget) {
danakj557248b2019-09-25 17:17:40546 DCHECK(!webwidget_);
nick4df698d82016-11-11 20:39:23547 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29548
danakj17216f4d2018-10-16 22:57:32549 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
550
Jeremy Roman04f27c372017-10-27 15:20:55551 input_handler_ = std::make_unique<RenderWidgetInputHandler>(this, this);
nick8331f8ad2016-11-15 20:42:45552
danakj17216f4d2018-10-16 22:57:32553 LayerTreeView* layer_tree_view = InitializeLayerTreeView();
Erik Chena2819852019-08-28 01:02:28554
555 // TODO(https://crbug.com/995981): This conditional is temporary logic to
556 // handle the case of remote main frame RenderWidgets [which shouldn't exist
557 // to begin with].
558 if (web_widget)
559 web_widget->SetAnimationHost(layer_tree_view->animation_host());
Dave Tapuska9db80842017-07-24 17:24:26560
danakj31699d5b2018-09-18 15:39:17561 blink::scheduler::WebThreadScheduler* main_thread_scheduler = nullptr;
562 if (render_thread_impl)
563 main_thread_scheduler = render_thread_impl->GetWebMainThreadScheduler();
Alexander Timin41e917d2018-07-02 16:25:35564 blink::scheduler::WebThreadScheduler* compositor_thread_scheduler =
565 blink::scheduler::WebThreadScheduler::CompositorThreadScheduler();
danakj31699d5b2018-09-18 15:39:17566 scoped_refptr<base::SingleThreadTaskRunner> compositor_input_task_runner;
danakj89ae4532018-12-12 22:52:55567 // Use the compositor thread task runner unless this is a popup or other such
568 // non-frame widgets. The |compositor_thread_scheduler| can be null in tests
569 // without a compositor thread.
570 if (for_frame() && compositor_thread_scheduler) {
571 compositor_input_task_runner =
572 compositor_thread_scheduler->InputTaskRunner();
danakj31699d5b2018-09-18 15:39:17573 }
Alexander Timin41e917d2018-07-02 16:25:35574
David Bokan3fc68482019-03-13 04:48:49575 // We only use an external input handler for frame RenderWidgets because only
576 // frames use the compositor for input handling. Other kinds of RenderWidgets
577 // (e.g. popups, plugins) must forward their input directly through
578 // RenderWidgetInputHandler into Blink.
579 bool uses_input_handler = for_frame();
Dave Tapuska04bc5ee92018-04-17 19:03:31580 widget_input_handler_manager_ = WidgetInputHandlerManager::Create(
danakj31699d5b2018-09-18 15:39:17581 weak_ptr_factory_.GetWeakPtr(), std::move(compositor_input_task_runner),
David Bokan3fc68482019-03-13 04:48:49582 main_thread_scheduler, uses_input_handler);
Stephen Chenneybccdd0302019-08-15 12:21:28583 base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
584 if (command_line->HasSwitch(switches::kAllowPreCommitInput))
Stephen Chenney1b197822019-09-04 14:25:48585 widget_input_handler_manager_->AllowPreCommitInput();
Dave Tapuska9db80842017-07-24 17:24:26586
danakjdf1ceb72018-07-18 20:02:25587 show_callback_ = std::move(show_callback);
initial.commit09911bf2008-07-26 23:55:29588
danakj81d399b2019-09-05 15:02:37589#if defined(OS_MACOSX)
590 text_input_client_observer_ =
591 std::make_unique<TextInputClientObserver>(for_frame() ? this : nullptr);
592#endif
593
danakj557248b2019-09-25 17:17:40594 webwidget_ = web_widget;
Erik Chen7b985822019-08-30 00:39:12595 webwidget_mouse_lock_target_.reset(new WebWidgetLockTarget(this));
lfgbee1e0a2016-06-08 21:24:21596 mouse_lock_dispatcher_.reset(new RenderWidgetMouseLockDispatcher(this));
initial.commit09911bf2008-07-26 23:55:29597
nick4df698d82016-11-11 20:39:23598 RenderThread::Get()->AddRoute(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29599}
600
danakj53802692018-07-25 21:46:44601void RenderWidget::ApplyEmulatedScreenMetricsForPopupWidget(
602 RenderWidget* origin_widget) {
603 RenderWidgetScreenMetricsEmulator* emulator =
Erik Chen1dd127d2019-09-21 02:33:04604 page_properties_->ScreenMetricsEmulator();
danakj53802692018-07-25 21:46:44605 if (!emulator)
606 return;
[email protected]b2e4c70132013-10-03 02:07:51607 popup_origin_scale_for_emulation_ = emulator->scale();
[email protected]19193682014-04-03 15:01:43608 popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
Pavel Feldmancc099f72017-07-20 23:09:00609 popup_screen_origin_for_emulation_ =
Lei Zhang9b359d32017-11-28 00:57:02610 emulator->original_screen_rect().origin();
Fady Samuel1c1ad3692018-11-06 23:28:40611 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
W. James MacLean7df854c2019-08-28 16:17:53612 CompositorViewportRect(),
Fady Samuel1c1ad3692018-11-06 23:28:40613 emulator->original_screen_info());
[email protected]b2e4c70132013-10-03 02:07:51614}
615
thakis18e426412017-03-15 12:06:37616#if BUILDFLAG(USE_EXTERNAL_POPUP_MENU)
[email protected]b2e4c70132013-10-03 02:07:51617void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
Albert J. Wong7bbf22d2018-12-20 00:27:27618 ExternalPopupMenu* popup) {
Erik Chen1dd127d2019-09-21 02:33:04619 if (page_properties_->ScreenMetricsEmulator())
620 popup->SetOriginScaleForEmulation(
621 page_properties_->ScreenMetricsEmulator()->scale());
[email protected]b2e4c70132013-10-03 02:07:51622}
[email protected]53907862014-03-25 15:42:40623#endif
[email protected]b2e4c70132013-10-03 02:07:51624
625void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
Erik Chen1dd127d2019-09-21 02:33:04626 if (page_properties_->ScreenMetricsEmulator())
627 page_properties_->ScreenMetricsEmulator()->OnShowContextMenu(params);
[email protected]b2e4c70132013-10-03 02:07:51628}
629
[email protected]a95986a82010-12-24 06:19:28630bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
Erik Chenbcb4584a2019-09-16 18:45:27631 // TODO(https://crbug.com/1000502): Don't process IPC messages on undead
632 // RenderWidgets. We would like to eventually remove them altogether, so they
633 // won't be able to process IPC messages. An undead widget may become
634 // provisional again, so we must check for that too. Provisional frames don't
635 // receive messages until swapped in.
636 if (is_undead_)
637 return false;
638
Erik Chenfab10fd2019-09-05 07:21:30639 bool handled = false;
640 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
Erik Chenfab10fd2019-09-05 07:21:30641 IPC_MESSAGE_HANDLER(WidgetMsg_EnableDeviceEmulation,
642 OnEnableDeviceEmulation)
643 IPC_MESSAGE_HANDLER(WidgetMsg_DisableDeviceEmulation,
644 OnDisableDeviceEmulation)
645 IPC_END_MESSAGE_MAP()
646 if (handled)
647 return true;
648
Erik Chenbcb4584a2019-09-16 18:45:27649 // TODO(https://crbug.com/1000502): We shouldn't process IPC messages on
650 // provisional frames.
651 if (IsForProvisionalFrame())
Erik Chenfab10fd2019-09-05 07:21:30652 return false;
Erik Chenbcb4584a2019-09-16 18:45:27653
ekaramad330ba4232016-09-23 17:57:47654#if defined(OS_MACOSX)
655 if (IPC_MESSAGE_CLASS(message) == TextInputClientMsgStart)
656 return text_input_client_observer_->OnMessageReceived(message);
657#endif
lfgbee1e0a2016-06-08 21:24:21658 if (mouse_lock_dispatcher_ &&
659 mouse_lock_dispatcher_->OnMessageReceived(message))
660 return true;
661
[email protected]a95986a82010-12-24 06:19:28662 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
Albert J. Wong3c93c182018-09-27 17:29:43663 IPC_MESSAGE_HANDLER(WidgetMsg_ShowContextMenu, OnShowContextMenu)
664 IPC_MESSAGE_HANDLER(WidgetMsg_Close, OnClose)
Albert J. Wong3c93c182018-09-27 17:29:43665 IPC_MESSAGE_HANDLER(WidgetMsg_WasHidden, OnWasHidden)
666 IPC_MESSAGE_HANDLER(WidgetMsg_WasShown, OnWasShown)
667 IPC_MESSAGE_HANDLER(WidgetMsg_SetActive, OnSetActive)
Albert J. Wong3c93c182018-09-27 17:29:43668 IPC_MESSAGE_HANDLER(WidgetMsg_SetTextDirection, OnSetTextDirection)
669 IPC_MESSAGE_HANDLER(WidgetMsg_SetBounds_ACK, OnRequestSetBoundsAck)
670 IPC_MESSAGE_HANDLER(WidgetMsg_UpdateScreenRects, OnUpdateScreenRects)
671 IPC_MESSAGE_HANDLER(WidgetMsg_ForceRedraw, OnForceRedraw)
672 IPC_MESSAGE_HANDLER(WidgetMsg_SetViewportIntersection,
kenrbea731792017-01-13 15:10:48673 OnSetViewportIntersection)
Albert J. Wong3c93c182018-09-27 17:29:43674 IPC_MESSAGE_HANDLER(WidgetMsg_SetIsInert, OnSetIsInert)
675 IPC_MESSAGE_HANDLER(WidgetMsg_SetInheritedEffectiveTouchAction,
sunxd540a9962018-05-24 22:51:06676 OnSetInheritedEffectiveTouchAction)
Albert J. Wong3c93c182018-09-27 17:29:43677 IPC_MESSAGE_HANDLER(WidgetMsg_UpdateRenderThrottlingStatus,
Ken Buchanan8a319fb2017-11-15 18:37:12678 OnUpdateRenderThrottlingStatus)
Albert J. Wong3c93c182018-09-27 17:29:43679 IPC_MESSAGE_HANDLER(WidgetMsg_WaitForNextFrameForTests,
lfg43e08e62016-02-03 18:51:37680 OnWaitNextFrameForTests)
paulmeyer90f6c31d2016-11-12 00:17:59681 IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter)
682 IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver, OnDragTargetDragOver)
683 IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave, OnDragTargetDragLeave)
684 IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop)
paulmeyer8fc8ea92016-11-15 05:12:21685 IPC_MESSAGE_HANDLER(DragMsg_SourceEnded, OnDragSourceEnded)
686 IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded,
687 OnDragSourceSystemDragEnded)
[email protected]a95986a82010-12-24 06:19:28688 IPC_MESSAGE_UNHANDLED(handled = false)
689 IPC_END_MESSAGE_MAP()
690 return handled;
691}
initial.commit09911bf2008-07-26 23:55:29692
693bool RenderWidget::Send(IPC::Message* message) {
danakjbf3df73c2019-09-06 21:21:21694 // Undead RenderWidgets should not be used.
695 CHECK(!is_undead_);
696 // Provisional frames don't send IPCs until they are swapped in/committed.
697 CHECK(!IsForProvisionalFrame());
698
699 // Don't send any messages after the browser has told us to close.
danakj6dcbc5962018-11-16 16:45:42700 if (closing_) {
701 delete message;
702 return false;
703 }
initial.commit09911bf2008-07-26 23:55:29704
705 // If given a messsage without a routing ID, then assign our routing ID.
706 if (message->routing_id() == MSG_ROUTING_NONE)
707 message->set_routing_id(routing_id_);
708
[email protected]380244092011-10-07 17:26:27709 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44710}
711
dtapuska014ed082016-11-11 21:58:48712void RenderWidget::SendOrCrash(IPC::Message* message) {
713 bool result = Send(message);
714 CHECK(closing_ || result) << "Failed to send message";
715}
716
ekaramad5aff1942017-01-06 01:26:35717bool RenderWidget::ShouldHandleImeEvents() const {
Albert J. Wong7bbf22d2018-12-20 00:27:27718 if (delegate())
danakj89ae4532018-12-12 22:52:55719 return has_focus_;
720 if (for_child_local_root_frame_) {
721 // TODO(ekaramad): We track page focus in all RenderViews on the page but
722 // the RenderWidgets corresponding to child local roots do not get the
723 // update. For now, this method returns true when the RenderWidget is for a
724 // child local frame, i.e., IME events will be processed regardless of page
725 // focus. We should revisit this after page focus for OOPIFs has been fully
726 // resolved (https://crbug.com/689777).
727 return true;
728 }
729 // Not a frame widget.
730 return false;
ekaramad5aff1942017-01-06 01:26:35731}
732
initial.commit09911bf2008-07-26 23:55:29733void RenderWidget::OnClose() {
Erik Chen3433ee02019-08-05 20:14:26734 DCHECK(popup_ || pepper_fullscreen_);
735
Erik Chen3433ee02019-08-05 20:14:26736 PrepareForClose();
Erik Chen78d57ea2019-08-30 00:13:42737
738 // IPCs can be invoked from nested message loops. We must dispatch this
739 // task non-nested to avoid re-entrancy issues.
740 GetCleanupTaskRunner()->PostNonNestableTask(
741 FROM_HERE,
742 base::BindOnce(&RenderWidget::Close, close_weak_ptr_factory_.GetWeakPtr(),
743 base::WrapUnique(this)));
Erik Chen3433ee02019-08-05 20:14:26744}
745
746void RenderWidget::PrepareForClose() {
Avi Drissman07d22452019-03-25 17:56:39747 DCHECK(RenderThread::IsMainThread());
dchengd96a27a2015-07-24 20:17:32748 if (closing_)
749 return;
danakj292b63e2018-11-19 20:47:06750 for (auto& observer : render_frames_)
751 observer.WidgetWillClose();
dchengd96a27a2015-07-24 20:17:32752 closing_ = true;
753
754 // Browser correspondence is no longer needed at this point.
755 if (routing_id_ != MSG_ROUTING_NONE) {
756 RenderThread::Get()->RemoveRoute(routing_id_);
Albert J. Wongcb004632018-07-10 22:58:25757 g_routing_id_widget_map.Get().erase(routing_id_);
dchengd96a27a2015-07-24 20:17:32758 }
759
danakj327a4fe2019-01-26 00:00:35760 // Stop handling main thread input events immediately so we don't have them
761 // running while things are partly shut down.
762 if (input_event_queue_)
763 input_event_queue_->ClearClient();
764
danakj557248b2019-09-25 17:17:40765 // If the browser has not sent OnDisableDeviceEmulation, we have an emulator
766 // hanging out still. Destroying it must happen *after* the IPC route is
767 // removed so that another IPC does not arrive and re-create the emulator
768 // during closing.
769 //
770 // This destruction is normally part of an IPC and expects objects to be alive
771 // that would be alive while the IPC route is active such as the
772 // |layer_tree_view_|. So we ensure that it is the first thing to be
773 // destroyed here before deleting things from the RenderWidget or the
774 // delegate().
775 //
776 // TODO(danakj): The emulator could reset to non-emulated values in an
777 // explicit method call (instead of in the destructor) that occurs when
778 // emulation is disabled, but does not need to occur during RenderWidget
779 // closing. Then we would not have to destroy this so carefully.
780 //
781 // Screen metrics emulation can only be set by the local main frame render
782 // widget.
783 if (delegate_)
784 page_properties_->SetScreenMetricsEmulator(nullptr);
785
786 // TODO(https://crbug.com/995981): This logic is very confusing and should be
787 // fixed. When RenderWidget is owned by a RenderViewImpl, its lifetime is tied
788 // to the RenderViewImpl. In that case the RenderViewImpl takes responsibility
789 // for closing the WebWidget when the main frame is detached.
790 //
791 // For all other RenderWidgets, the RenderWidget is destroyed at the same
792 // time as the WebWidget, and the RenderWidget takes responsibility for doing
793 // that here.
794 if (!delegate())
795 webwidget_->Close();
796 webwidget_ = nullptr;
797
798 close_weak_ptr_factory_.InvalidateWeakPtrs();
initial.commit09911bf2008-07-26 23:55:29799}
800
Erik Chenc71b51fe2019-09-19 21:34:27801void RenderWidget::SynchronizeVisualPropertiesFromRenderView(
Albert J. Wong0a918192019-08-28 01:05:28802 const VisualProperties& visual_properties_from_browser) {
Erik Chenc71b51fe2019-09-19 21:34:27803 TRACE_EVENT0("renderer",
804 "RenderWidget::SynchronizeVisualPropertiesFromRenderView");
EhsanKbd2cea992017-11-23 18:49:08805
Albert J. Wong0a918192019-08-28 01:05:28806 VisualProperties visual_properties = visual_properties_from_browser;
danakj01474dd2019-01-28 10:46:04807 // Web tests can override the device scale factor in the renderer.
808 if (device_scale_factor_for_testing_) {
Albert J. Wong0a918192019-08-28 01:05:28809 visual_properties.screen_info.device_scale_factor =
810 device_scale_factor_for_testing_;
W. James MacLean73742842019-09-06 18:44:49811 visual_properties.compositor_viewport_pixel_rect =
812 gfx::Rect(gfx::ScaleToCeiledSize(
813 visual_properties.new_size,
814 visual_properties.screen_info.device_scale_factor));
danakj01474dd2019-01-28 10:46:04815 }
danakjcf409aa2019-09-20 15:22:30816 // Web tests can override the zoom level in the renderer.
817 if (zoom_level_for_testing_ != -INFINITY)
818 visual_properties.zoom_level = zoom_level_for_testing_;
danakj04d128a2019-01-25 02:10:20819
820 // Inform the rendering thread of the color space indicating the presence of
821 // HDR capabilities. The HDR bit happens to be globally true/false for all
822 // browser windows (on Windows OS) and thus would be the same for all
823 // RenderWidgets, so clobbering each other works out since only the HDR bit is
824 // used. See https://crbug.com/803451 and
825 // https://chromium-review.googlesource.com/c/chromium/src/+/852912/15#message-68bbd3e25c3b421a79cd028b2533629527d21fee
826 //
827 // The RenderThreadImpl can be null in tests.
828 {
829 RenderThreadImpl* render_thread = RenderThreadImpl::current();
830 if (render_thread)
Albert J. Wong0a918192019-08-28 01:05:28831 render_thread->SetRenderingColorSpace(
832 visual_properties.screen_info.color_space);
danakj04d128a2019-01-25 02:10:20833 }
834
Albert J. Wong7bbf22d2018-12-20 00:27:27835 if (delegate()) {
Albert J. Wong0a918192019-08-28 01:05:28836 if (size_ != visual_properties.new_size) {
danakj84bbf552019-01-21 21:33:31837 // Only hide popups when the size changes. Eg https://crbug.com/761908.
danakjcf409aa2019-09-20 15:22:30838 // TODO(danakj): If OnSynchronizeVisualProperties doesn't happen on an
839 // undead widget then this can go through the WebFrameWidget->WebView
840 // instead of through the delegate, letting us delete that delegate API.
danakj84bbf552019-01-21 21:33:31841 delegate()->CancelPagePopupForWidget();
842 }
danakja2c9d0a92018-07-25 20:01:18843
Albert J. Wong0a918192019-08-28 01:05:28844 if (display_mode_ != visual_properties.display_mode) {
845 display_mode_ = visual_properties.display_mode;
846 delegate()->ApplyNewDisplayModeForWidget(visual_properties.display_mode);
danakja2c9d0a92018-07-25 20:01:18847 }
848
danakjd990b4c2019-09-18 20:34:29849 SetAutoResizeMode(visual_properties.auto_resize_enabled,
850 visual_properties.min_size_for_auto_resize,
851 visual_properties.max_size_for_auto_resize,
852 visual_properties.screen_info.device_scale_factor);
danakja2c9d0a92018-07-25 20:01:18853
854 browser_controls_shrink_blink_size_ =
Albert J. Wong0a918192019-08-28 01:05:28855 visual_properties.browser_controls_shrink_blink_size;
856 top_controls_height_ = visual_properties.top_controls_height;
857 bottom_controls_height_ = visual_properties.bottom_controls_height;
[email protected]b2e4c70132013-10-03 02:07:51858 }
859
danakj3c2dfa52019-09-18 19:04:47860 if (for_frame()) {
danakjcf409aa2019-09-20 15:22:30861 SetZoomLevel(visual_properties.zoom_level);
862
danakj3c2dfa52019-09-18 19:04:47863 bool capture_sequence_number_changed =
864 visual_properties.capture_sequence_number !=
865 last_capture_sequence_number_;
866 if (capture_sequence_number_changed) {
867 last_capture_sequence_number_ = visual_properties.capture_sequence_number;
868
869 // Propagate changes down to child local root RenderWidgets and
870 // BrowserPlugins in other frame trees/processes.
871 for (auto& observer : render_frame_proxies_) {
872 observer.UpdateCaptureSequenceNumber(
873 visual_properties.capture_sequence_number);
874 }
875 for (auto& observer : browser_plugins_) {
876 observer.UpdateCaptureSequenceNumber(
877 visual_properties.capture_sequence_number);
878 }
879 }
880 }
881
danakj2db0b282019-09-20 15:09:20882 layer_tree_host_->SetBrowserControlsHeight(
danakj3c2dfa52019-09-18 19:04:47883 visual_properties.top_controls_height,
884 visual_properties.bottom_controls_height,
885 visual_properties.browser_controls_shrink_blink_size);
886
danakjd990b4c2019-09-18 20:34:29887 if (!auto_resize_mode_) {
danakj3c2dfa52019-09-18 19:04:47888 if (visual_properties.is_fullscreen_granted != is_fullscreen_granted_) {
889 is_fullscreen_granted_ = visual_properties.is_fullscreen_granted;
890 if (is_fullscreen_granted_)
891 GetWebWidget()->DidEnterFullscreen();
892 else
893 GetWebWidget()->DidExitFullscreen();
894 }
895 }
896
897 gfx::Size old_visible_viewport_size = visible_viewport_size_;
898
danakjcf409aa2019-09-20 15:22:30899 bool ignore_resize_ipc = false;
900 if (synchronous_resize_mode_for_testing_) {
901 // We can ignore browser-initialized resizing during synchronous
902 // (renderer-controlled) mode, unless it is switching us to/from
903 // fullsreen mode or changing the device scale factor.
904 // TODO(danakj): Does the browser actually change DSF inside a web test??
905 // TODO(danakj): Isn't the display mode check redundant with the fullscreen
906 // one?
907 if (visual_properties.is_fullscreen_granted == is_fullscreen_granted_ &&
908 visual_properties.display_mode == display_mode_ &&
909 visual_properties.screen_info.device_scale_factor ==
910 page_properties_->GetDeviceScaleFactor())
911 ignore_resize_ipc = true;
912 }
913
danakj7602f4f2019-01-31 18:03:23914 // When controlling the size in the renderer, we should ignore sizes given by
915 // the browser IPC here.
916 // TODO(danakj): There are many things also being ignored that aren't the
917 // widget's size params. It works because tests that use this mode don't
918 // change those parameters, I guess. But it's more complicated then because it
919 // looks like they are related to sync resize mode. Let's move them out of
920 // this block.
921 // TODO(danakj): It would be nice if we can still use the emulator to emulate
922 // things other than the size if we are in sync resize mode - if the emulator
923 // is even used in sync resize tests. It probably isn't though, so either way
924 // it'd be good to get the emulator out of this block (maybe by overwriting
Albert J. Wong0a918192019-08-28 01:05:28925 // some of |visual_properties| in sync resize mode instead of just
926 // skipping the emulator.
danakj7602f4f2019-01-31 18:03:23927 if (!ignore_resize_ipc) {
Erik Chen1dd127d2019-09-21 02:33:04928 if (delegate_ && page_properties_->ScreenMetricsEmulator()) {
danakj7602f4f2019-01-31 18:03:23929 // This will call our SynchronizeVisualProperties() method with a
930 // different set of VisualProperties, holding emulated values. Though not
931 // all VisualProperties are modified by the metrics emulator, so it's a
932 // bit unclear to do this with the full structure. Anything it does not
933 // modify can be consumed directly here instead of in
934 // SynchronizeVisualProperties().
Erik Chen1dd127d2019-09-21 02:33:04935 page_properties_->ScreenMetricsEmulator()->OnSynchronizeVisualProperties(
Albert J. Wong0a918192019-08-28 01:05:28936 visual_properties);
danakja2c9d0a92018-07-25 20:01:18937 } else {
danakj3c2dfa52019-09-18 19:04:47938 SynchronizeVisualProperties(visual_properties);
danakjb1f431b2019-09-26 15:54:06939 }
940 }
danakj3c2dfa52019-09-18 19:04:47941
danakjb1f431b2019-09-26 15:54:06942 if (!delegate()) {
943 // The main frame controls the page scale factor, from blink. For other
944 // frame widgets, the page scale is received from its parent as part of
945 // the visual properties here. While blink doesn't need to know this
946 // page scale factor outside the main frame, the compositor does in
947 // order to produce its output at the correct scale.
948 layer_tree_host_->SetExternalPageScaleFactor(
949 visual_properties.page_scale_factor,
950 visual_properties.is_pinch_gesture_active);
951
952 // Store the value to give to any new RenderFrameProxy that is
953 // registered.
954 page_scale_factor_from_mainframe_ = visual_properties.page_scale_factor;
955 // Similarly, only the main frame knows when a pinch gesture is active,
956 // but this information is needed in subframes so they can throttle
957 // re-rastering in the same manner as the main frame.
958 // |is_pinch_gesture_active| follows the same path to the subframe
959 // compositor(s) as |page_scale_factor|.
960 is_pinch_gesture_active_from_mainframe_ =
961 visual_properties.is_pinch_gesture_active;
962
963 // Push the page scale factor down to any child RenderWidgets via our
964 // child proxy frames.
965 // TODO(danakj): This ends up setting the page scale factor in the
966 // RenderWidgetHost of the child RenderWidget, so that it can bounce
967 // the value down to its RenderWidget. Since this is essentially a
968 // global value per-page, we could instead store it once in the browser
969 // (such as in RenderViewHost) and distribute it to each frame-hosted
970 // RenderWidget from there.
971 for (auto& child_proxy : render_frame_proxies_) {
972 if (!is_undead_) {
973 child_proxy.OnPageScaleFactorChanged(
Albert J. Wong0a918192019-08-28 01:05:28974 visual_properties.page_scale_factor,
975 visual_properties.is_pinch_gesture_active);
danakj0246bba02019-01-23 23:12:27976 }
danakja2c9d0a92018-07-25 20:01:18977 }
Fady Samuel799e72192018-04-25 21:16:57978 }
979
danakj3c2dfa52019-09-18 19:04:47980 if (old_visible_viewport_size != visible_viewport_size_) {
981 for (auto& render_frame : render_frames_)
982 render_frame.ResetHasScrolledFocusedEditableIntoView();
983 }
Sushanth Rajasankarceaee202019-03-18 15:44:17984 // TODO(crbug.com/939118): ScrollFocusedNodeIntoViewForWidget does not work
985 // when the focused node is inside an OOPIF. This code path where
986 // scroll_focused_node_into_view is set is used only for WebView, crbug
987 // 939118 tracks fixing webviews to not use scroll_focused_node_into_view.
Albert J. Wong0a918192019-08-28 01:05:28988 if (delegate() && visual_properties.scroll_focused_node_into_view)
Albert J. Wong7bbf22d2018-12-20 00:27:27989 delegate()->ScrollFocusedNodeIntoViewForWidget();
initial.commit09911bf2008-07-26 23:55:29990}
991
dgozman9260b0a12015-03-16 13:45:20992void RenderWidget::OnEnableDeviceEmulation(
Lei Zhang9b359d32017-11-28 00:57:02993 const blink::WebDeviceEmulationParams& params) {
Erik Chen1dd127d2019-09-21 02:33:04994 // Device emulation can only be applied to the local main frame render widget.
995 // TODO(https://crbug.com/1006052): We should fix the IPC to send to
996 // RenderView instead.
997 if (!delegate_)
998 return;
999
1000 if (!page_properties_->ScreenMetricsEmulator()) {
Fady Samuel4255c182018-05-24 20:42:361001 VisualProperties visual_properties;
Albert J. Wonga3dbd5442019-09-18 10:38:281002 visual_properties.screen_info = page_properties_->GetScreenInfo();
Fady Samuel4255c182018-05-24 20:42:361003 visual_properties.new_size = size_;
W. James MacLean73742842019-09-06 18:44:491004 visual_properties.compositor_viewport_pixel_rect = CompositorViewportRect();
Fady Samuel84d8a1f72018-11-08 00:26:171005 visual_properties.local_surface_id_allocation =
1006 local_surface_id_allocation_from_parent_;
Fady Samuel4255c182018-05-24 20:42:361007 visual_properties.visible_viewport_size = visible_viewport_size_;
1008 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
1009 visual_properties.display_mode = display_mode_;
Erik Chen1dd127d2019-09-21 02:33:041010 page_properties_->SetScreenMetricsEmulator(
1011 std::make_unique<RenderWidgetScreenMetricsEmulator>(
1012 this, params, visual_properties, widget_screen_rect_,
1013 window_screen_rect_));
1014 page_properties_->ScreenMetricsEmulator()->Apply();
mfomitchev2600fd7c2016-02-17 20:53:391015 } else {
Erik Chen1dd127d2019-09-21 02:33:041016 page_properties_->ScreenMetricsEmulator()->ChangeEmulationParams(params);
mfomitchev2600fd7c2016-02-17 20:53:391017 }
dgozman9260b0a12015-03-16 13:45:201018}
1019
danakjd990b4c2019-09-18 20:34:291020void RenderWidget::SetAutoResizeMode(bool auto_resize,
1021 const gfx::Size& min_size_before_dsf,
1022 const gfx::Size& max_size_before_dsf,
1023 float device_scale_factor) {
1024 bool was_changed = auto_resize_mode_ != auto_resize;
1025 auto_resize_mode_ = auto_resize;
1026
1027 min_size_for_auto_resize_ = min_size_before_dsf;
1028 max_size_for_auto_resize_ = max_size_before_dsf;
1029
1030 if (auto_resize) {
1031 gfx::Size min_auto_size = min_size_for_auto_resize_;
1032 gfx::Size max_auto_size = max_size_for_auto_resize_;
1033 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
1034 min_auto_size =
1035 gfx::ScaleToCeiledSize(min_auto_size, device_scale_factor);
1036 max_auto_size =
1037 gfx::ScaleToCeiledSize(max_auto_size, device_scale_factor);
1038 }
1039 delegate()->ApplyAutoResizeLimitsForWidget(min_auto_size, max_auto_size);
1040 } else if (was_changed) {
1041 delegate()->DisableAutoResizeForWidget();
1042 }
1043}
1044
danakjcf409aa2019-09-20 15:22:301045void RenderWidget::SetZoomLevel(double zoom_level) {
1046 // TODO(danakj): This should not need to go through RenderFrame to set
1047 // Page-level properties.
1048 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1049 DCHECK(frame_widget);
1050 RenderFrameImpl* render_frame =
1051 RenderFrameImpl::FromWebFrame(frame_widget->LocalRoot());
1052
1053 bool zoom_level_changed = render_frame->SetZoomLevelOnRenderView(zoom_level);
1054 if (zoom_level_changed) {
1055 // Hide popups when the zoom changes.
1056 blink::WebView* web_view = frame_widget->LocalRoot()->View();
1057 web_view->CancelPagePopup();
1058
1059 // Propagate changes down to child local root RenderWidgets and
1060 // BrowserPlugins in other frame trees/processes.
1061 for (auto& observer : render_frame_proxies_)
1062 observer.OnZoomLevelChanged(zoom_level);
1063 for (auto& plugin : browser_plugins_)
1064 plugin.OnZoomLevelChanged(zoom_level);
1065 }
1066}
1067
dgozman9260b0a12015-03-16 13:45:201068void RenderWidget::OnDisableDeviceEmulation() {
Erik Chen1dd127d2019-09-21 02:33:041069 // Device emulation can only be applied to the local main frame render widget.
1070 // TODO(https://crbug.com/1006052): We should fix the IPC to send to
1071 // RenderView instead.
1072 if (!delegate_)
1073 return;
1074 page_properties_->SetScreenMetricsEmulator(nullptr);
dgozman9260b0a12015-03-16 13:45:201075}
1076
initial.commit09911bf2008-07-26 23:55:291077void RenderWidget::OnWasHidden() {
danakjbd1a86a2019-09-06 17:24:311078 // An undead or provisional main frame widget will never be hidden since that
danakj1fe8e62d2019-09-05 23:21:561079 // would require it to be shown first. The main frame must be attached to the
1080 // frame tree before changing visibility.
danakjbd1a86a2019-09-06 17:24:311081 DCHECK(!is_undead_);
danakj1fe8e62d2019-09-05 23:21:561082 DCHECK(!IsForProvisionalFrame());
danakj14e00a8322019-02-07 17:12:061083
[email protected]9c3085f2011-06-09 02:10:311084 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
danakj14e00a8322019-02-07 17:12:061085
[email protected]bee16aab2009-08-26 15:55:031086 SetHidden(true);
danakj14e00a8322019-02-07 17:12:061087
Francois Doray687e70a2019-05-16 02:24:551088 tab_switch_time_recorder_.TabWasHidden();
1089
ericwilligers88e69742016-10-17 19:29:551090 for (auto& observer : render_frames_)
1091 observer.WasHidden();
initial.commit09911bf2008-07-26 23:55:291092}
1093
Sebastien Marchand5f06ca32019-05-17 18:03:421094void RenderWidget::OnWasShown(
1095 base::TimeTicks show_request_timestamp,
1096 bool was_evicted,
1097 const base::Optional<content::RecordTabSwitchTimeRequest>&
1098 record_tab_switch_time_request) {
danakjbd1a86a2019-09-06 17:24:311099 // An undead or provisional main frame widget will never be hidden since that
danakj1fe8e62d2019-09-05 23:21:561100 // would require it to be shown first. The main frame must be attached to the
1101 // frame tree before changing visibility.
danakjbd1a86a2019-09-06 17:24:311102 DCHECK(!is_undead_);
danakj1fe8e62d2019-09-05 23:21:561103 DCHECK(!IsForProvisionalFrame());
danakj14e00a8322019-02-07 17:12:061104
Edwin Joea4069f42019-02-20 15:06:241105 TRACE_EVENT_WITH_FLOW0("renderer", "RenderWidget::OnWasShown", routing_id(),
1106 TRACE_EVENT_FLAG_FLOW_IN);
danakj678f0252018-11-09 21:46:341107
tasakb95dbb50c2017-02-08 18:07:501108 was_shown_time_ = base::TimeTicks::Now();
danakj14e00a8322019-02-07 17:12:061109
[email protected]bee16aab2009-08-26 15:55:031110 SetHidden(false);
Sebastien Marchand5f06ca32019-05-17 18:03:421111 if (record_tab_switch_time_request) {
danakj2db0b282019-09-20 15:09:201112 layer_tree_host_->RequestPresentationTimeForNextFrame(
Sebastien Marchand5f06ca32019-05-17 18:03:421113 tab_switch_time_recorder_.TabWasShown(
1114 false /* has_saved_frames */,
1115 record_tab_switch_time_request.value(), show_request_timestamp));
[email protected]3399dd822014-08-09 11:14:241116 }
danakj14e00a8322019-02-07 17:12:061117
1118 for (auto& observer : render_frames_)
1119 observer.WasShown();
1120 if (was_evicted) {
1121 for (auto& observer : render_frame_proxies_)
1122 observer.WasEvicted();
1123 }
initial.commit09911bf2008-07-26 23:55:291124}
1125
Avi Drissman014dec72018-06-07 02:34:011126void RenderWidget::OnRequestSetBoundsAck() {
[email protected]53d3f302009-12-21 04:42:051127 DCHECK(pending_window_rect_count_);
1128 pending_window_rect_count_--;
1129}
1130
Albert J. Wongcb004632018-07-10 22:58:251131void RenderWidget::OnForceRedraw(int snapshot_id) {
David Bokanf92eaf22019-03-01 01:54:511132 RequestPresentation(base::BindOnce(&RenderWidget::DidPresentForceDrawFrame,
1133 weak_ptr_factory_.GetWeakPtr(),
1134 snapshot_id));
1135}
1136
1137void RenderWidget::RequestPresentation(PresentationTimeCallback callback) {
danakj2db0b282019-09-20 15:09:201138 layer_tree_host_->RequestPresentationTimeForNextFrame(std::move(callback));
1139 layer_tree_host_->SetNeedsCommitWithForcedRedraw();
Albert J. Wongcb004632018-07-10 22:58:251140}
1141
1142void RenderWidget::DidPresentForceDrawFrame(
1143 int snapshot_id,
1144 const gfx::PresentationFeedback& feedback) {
Albert J. Wong3c93c182018-09-27 17:29:431145 Send(new WidgetHostMsg_ForceRedrawComplete(routing_id(), snapshot_id));
Albert J. Wongcb004632018-07-10 22:58:251146}
1147
Xianzhu Wangf02017ac2018-10-17 01:47:331148viz::FrameSinkId RenderWidget::GetFrameSinkIdAtPoint(const gfx::PointF& point,
Ken Buchanan44d7e2f2018-08-23 14:18:051149 gfx::PointF* local_point) {
1150 return input_handler_->GetFrameSinkIdAtPoint(point, local_point);
Navid Zolghadr0d86e5f2017-10-23 18:09:221151}
1152
danakj77821e252019-03-27 19:58:041153bool RenderWidget::HasPendingPageScaleAnimation() const {
danakj2db0b282019-09-20 15:09:201154 return layer_tree_host_->HasPendingPageScaleAnimation();
danakj77821e252019-03-27 19:58:041155}
1156
danakj327a4fe2019-01-26 00:00:351157bool RenderWidget::HandleInputEvent(
dtapuska9ec1a912017-04-21 15:18:311158 const blink::WebCoalescedInputEvent& input_event,
1159 const ui::LatencyInfo& latency_info,
Dave Tapuskaea83d3bd2017-06-13 16:14:551160 HandledEventCallback callback) {
danakj69f23632019-09-20 15:17:371161 if (closing_)
1162 return false;
danakjbd1a86a2019-09-06 17:24:311163 if (IsUndeadOrProvisional())
danakj327a4fe2019-01-26 00:00:351164 return false;
Dave Tapuskaea83d3bd2017-06-13 16:14:551165 input_handler_->HandleInputEvent(input_event, latency_info,
1166 std::move(callback));
danakj327a4fe2019-01-26 00:00:351167 return true;
dtapuska9ec1a912017-04-21 15:18:311168}
1169
danakj125a29e2019-01-24 23:25:291170void RenderWidget::SetNeedsMainFrame() {
danakj0719e0652019-03-14 21:19:111171 ScheduleAnimation();
danakj125a29e2019-01-24 23:25:291172}
1173
dtapuska9d46ef7d2017-05-26 19:06:061174scoped_refptr<MainThreadEventQueue> RenderWidget::GetInputEventQueue() {
1175 return input_event_queue_;
1176}
1177
fsamuel78f86e42016-01-20 04:10:231178void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
danakj8eea64b12019-09-13 20:48:071179 // This is a mojo IPC entry point. We don't want IPCs when undead.
1180 if (IsUndeadOrProvisional())
1181 return;
1182
lfg8ff33912016-09-13 20:59:211183 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:541184 GetWebWidget()->SetCursorVisibilityState(is_visible);
fsamuel78f86e42016-01-20 04:10:231185}
1186
[email protected]76b082c2019-03-22 03:45:461187void RenderWidget::OnFallbackCursorModeToggled(bool is_on) {
danakj8eea64b12019-09-13 20:48:071188 // This is a mojo IPC entry point. We don't want IPCs when undead.
1189 if (IsUndeadOrProvisional())
1190 return;
1191
[email protected]76b082c2019-03-22 03:45:461192 if (GetWebWidget())
1193 GetWebWidget()->OnFallbackCursorModeToggled(is_on);
1194}
1195
fsamuel78f86e42016-01-20 04:10:231196void RenderWidget::OnMouseCaptureLost() {
danakj8eea64b12019-09-13 20:48:071197 // This is a mojo IPC entry point. We don't want IPCs when undead.
1198 if (IsUndeadOrProvisional())
1199 return;
1200
lfg8ff33912016-09-13 20:59:211201 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:541202 GetWebWidget()->MouseCaptureLost();
fsamuel78f86e42016-01-20 04:10:231203}
1204
alexmos56567492016-09-13 00:52:461205void RenderWidget::OnSetEditCommandsForNextKeyEvent(
1206 const EditCommands& edit_commands) {
danakj8eea64b12019-09-13 20:48:071207 // This is a mojo IPC entry point. We don't want IPCs when undead.
1208 if (IsUndeadOrProvisional())
1209 return;
1210
alexmos56567492016-09-13 00:52:461211 edit_commands_ = edit_commands;
1212}
1213
Albert J. Wongcb004632018-07-10 22:58:251214void RenderWidget::OnSetActive(bool active) {
Albert J. Wong7bbf22d2018-12-20 00:27:271215 if (delegate())
1216 delegate()->SetActiveForWidget(active);
Albert J. Wongcb004632018-07-10 22:58:251217}
1218
fsamuel78f86e42016-01-20 04:10:231219void RenderWidget::OnSetFocus(bool enable) {
danakj8eea64b12019-09-13 20:48:071220 // This is a mojo IPC entry point. We don't want IPCs when undead.
1221 if (IsUndeadOrProvisional())
1222 return;
1223
Albert J. Wong7bbf22d2018-12-20 00:27:271224 if (delegate())
1225 delegate()->DidReceiveSetFocusEventForWidget();
danakja2c9d0a92018-07-25 20:01:181226 SetFocus(enable);
1227}
1228
1229void RenderWidget::SetFocus(bool enable) {
lfge0c2792ec2016-05-11 18:52:081230 has_focus_ = enable;
1231
lfg8ff33912016-09-13 20:59:211232 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:541233 GetWebWidget()->SetFocus(enable);
lfge0c2792ec2016-05-11 18:52:081234
ericwilligers88e69742016-10-17 19:29:551235 for (auto& observer : render_frames_)
1236 observer.RenderWidgetSetFocus(enable);
danakja2c9d0a92018-07-25 20:01:181237
Erik Chene8e50c622019-08-28 01:57:491238 // Notify all BrowserPlugins of the RenderView's focus state.
1239 if (BrowserPluginManager::Get())
1240 BrowserPluginManager::Get()->UpdateFocusState();
fsamuel78f86e42016-01-20 04:10:231241}
1242
1243///////////////////////////////////////////////////////////////////////////////
danakja6c10012018-07-06 14:25:361244// LayerTreeViewDelegate
fsamuel78f86e42016-01-20 04:10:231245
David Bokanc8e38d02018-10-08 21:56:011246void RenderWidget::ApplyViewportChanges(
1247 const cc::ApplyViewportChangesArgs& args) {
Ken Buchananed449bb2018-02-01 21:02:051248 if (!GetWebWidget())
1249 return;
David Bokanc8e38d02018-10-08 21:56:011250 GetWebWidget()->ApplyViewportChanges(args);
fsamuel78f86e42016-01-20 04:10:231251}
1252
Allison Pastewka5ac6e7eb2019-06-11 23:13:471253void RenderWidget::RecordManipulationTypeCounts(cc::ManipulationInfo info) {
Ken Buchananed449bb2018-02-01 21:02:051254 if (!GetWebWidget())
1255 return;
Allison Pastewka5ac6e7eb2019-06-11 23:13:471256 GetWebWidget()->RecordManipulationTypeCounts(info);
sahel1b47fda72017-03-28 17:03:071257}
1258
Sahel Sharify676580c2019-01-10 21:49:491259void RenderWidget::SendOverscrollEventFromImplSide(
1260 const gfx::Vector2dF& overscroll_delta,
1261 cc::ElementId scroll_latched_element_id) {
1262 if (!GetWebWidget())
1263 return;
1264 GetWebWidget()->SendOverscrollEventFromImplSide(overscroll_delta,
1265 scroll_latched_element_id);
1266}
1267void RenderWidget::SendScrollEndEventFromImplSide(
1268 cc::ElementId scroll_latched_element_id) {
1269 if (!GetWebWidget())
1270 return;
1271 GetWebWidget()->SendScrollEndEventFromImplSide(scroll_latched_element_id);
1272}
1273
Daniel Cheng224569ee2018-04-25 05:45:061274void RenderWidget::BeginMainFrame(base::TimeTicks frame_time) {
Ken Buchananed449bb2018-02-01 21:02:051275 if (!GetWebWidget())
1276 return;
dtapuska3d5624d32016-08-30 04:34:001277
danakjbd1a86a2019-09-06 17:24:311278 DCHECK(!is_undead_);
danakj1fe8e62d2019-09-05 23:21:561279 DCHECK(!IsForProvisionalFrame());
danakj22b4e8b2019-08-01 23:14:391280
Stephen Chenneyd56b5382019-01-29 00:37:021281 // We record metrics only when running in multi-threaded mode, not
1282 // single-thread mode for testing.
1283 bool record_main_frame_metrics =
1284 !!compositor_deps_->GetCompositorImplThreadTaskRunner();
1285 if (input_event_queue_) {
1286 base::Optional<ScopedUkmRafAlignedInputTimer> ukm_timer;
Stephen Chenney1d064cf2019-06-06 14:54:101287 if (record_main_frame_metrics) {
Stephen Chenneyd56b5382019-01-29 00:37:021288 ukm_timer.emplace(GetWebWidget());
Stephen Chenney1d064cf2019-06-06 14:54:101289 }
Stephen Chenneyd56b5382019-01-29 00:37:021290 input_event_queue_->DispatchRafAlignedInput(frame_time);
1291 }
1292
1293 GetWebWidget()->BeginFrame(frame_time, record_main_frame_metrics);
fsamuel78f86e42016-01-20 04:10:231294}
1295
Stephen Chenney1b197822019-09-04 14:25:481296void RenderWidget::OnDeferMainFrameUpdatesChanged(bool deferral_state) {
1297 // The input handler wants to know about the mainframe update status to
1298 // enable/disable input and for metrics.
1299 if (widget_input_handler_manager_)
1300 widget_input_handler_manager_->OnDeferMainFrameUpdatesChanged(
1301 deferral_state);
1302}
1303
1304void RenderWidget::OnDeferCommitsChanged(bool deferral_state) {
1305 // The input handler wants to know about the commit status for metric purposes
1306 // and to enable/disable input.
1307 if (widget_input_handler_manager_)
1308 widget_input_handler_manager_->OnDeferCommitsChanged(deferral_state);
1309}
1310
Stefan Zager148248c2019-02-20 23:24:081311void RenderWidget::DidBeginMainFrame() {
1312 if (!GetWebWidget())
1313 return;
1314 GetWebWidget()->DidBeginFrame();
1315}
1316
danakjc7afae52017-06-20 21:12:411317void RenderWidget::RequestNewLayerTreeFrameSink(
danakja6c10012018-07-06 14:25:361318 LayerTreeFrameSinkCallback callback) {
[email protected]7912e822014-04-16 02:37:031319 // For widgets that are never visible, we don't start the compositor, so we
danakjc7afae52017-06-20 21:12:411320 // never get a request for a cc::LayerTreeFrameSink.
sievers71c62dd52015-10-07 01:44:391321 DCHECK(!compositor_never_visible_);
danakjbd1a86a2019-09-06 17:24:311322 // Undead RenderWidgets should not be doing any compositing. However note that
danakj1fe8e62d2019-09-05 23:21:561323 // widgets for provisional frames do start their compositor.
danakjbd1a86a2019-09-06 17:24:311324 DCHECK(!is_undead_);
danakj678f0252018-11-09 21:46:341325
danakj98773612019-09-20 17:32:281326 // If we early out, we drop the request which means the compositor waits
1327 // forever, which is fine since we're going to destroy it soon.
1328 if (closing_)
danakj678f0252018-11-09 21:46:341329 return;
jonrossa2ff4f82018-02-16 17:27:461330
Erik Chen15476cef2019-08-27 17:28:061331 // TODO:(https://crbug.com/995981): If there is no WebWidget, then the
1332 // RenderWidget should also be destroyed, and this DCHECK should not be
1333 // necessary.
1334 DCHECK(GetWebWidget());
1335
jonrossa2ff4f82018-02-16 17:27:461336 // TODO(jonross): have this generated by the LayerTreeFrameSink itself, which
1337 // would then handle binding.
Julie Jeongeun Kim6f4b7e02019-09-11 05:05:461338 mojo::PendingRemote<mojom::RenderFrameMetadataObserver> observer_remote;
Julie Jeongeun Kim4421c2e2019-09-11 06:34:391339 mojo::PendingRemote<mojom::RenderFrameMetadataObserverClient> client_remote;
1340 mojo::PendingReceiver<mojom::RenderFrameMetadataObserverClient>
1341 client_receiver = client_remote.InitWithNewPipeAndPassReceiver();
danakj4b347212018-07-04 17:55:171342 auto render_frame_metadata_observer =
Julie Jeongeun Kim6f4b7e02019-09-11 05:05:461343 std::make_unique<RenderFrameMetadataObserverImpl>(
1344 observer_remote.InitWithNewPipeAndPassReceiver(),
Julie Jeongeun Kim4421c2e2019-09-11 06:34:391345 std::move(client_remote));
danakj2db0b282019-09-20 15:09:201346 layer_tree_host_->SetRenderFrameObserver(
danakj4b347212018-07-04 17:55:171347 std::move(render_frame_metadata_observer));
danakjf51754372018-12-13 23:20:011348 GURL url = GetWebWidget()->GetURLForDebugTrace();
danakjefabf312018-10-05 19:03:071349 // The |url| is not always available, fallback to a fixed string.
1350 if (url.is_empty())
1351 url = GURL("chrome://gpu/RenderWidget::RequestNewLayerTreeFrameSink");
danakj6dcbc5962018-11-16 16:45:421352 // TODO(danakj): This may not be accurate, depending on the intent. A child
1353 // local root could be in the same process as the view, so if the client is
1354 // meant to designate the process type, it seems kRenderer would be the
1355 // correct choice. If client is meant to designate the widget type, then
1356 // kOOPIF would denote that it is not for the main frame. However, kRenderer
1357 // would also be used for other widgets such as popups.
1358 const char* client_name = for_child_local_root_frame_ ? kOOPIF : kRenderer;
danakj2d2889a2019-04-05 21:22:081359 compositor_deps_->RequestNewLayerTreeFrameSink(
Scott Violetb04f16c2018-11-27 00:48:461360 routing_id_, frame_swap_message_queue_, std::move(url),
Julie Jeongeun Kim4421c2e2019-09-11 06:34:391361 std::move(callback), std::move(client_receiver),
Julie Jeongeun Kim6f4b7e02019-09-11 05:05:461362 std::move(observer_remote), client_name);
[email protected]ba91a792013-02-06 09:48:281363}
1364
fsamuel78f86e42016-01-20 04:10:231365void RenderWidget::DidCommitAndDrawCompositorFrame() {
1366 // NOTE: Tests may break if this event is renamed or moved. See
1367 // tab_capture_performancetest.cc.
1368 TRACE_EVENT0("gpu", "RenderWidget::DidCommitAndDrawCompositorFrame");
lfge0c2792ec2016-05-11 18:52:081369
ericwilligers88e69742016-10-17 19:29:551370 for (auto& observer : render_frames_)
1371 observer.DidCommitAndDrawCompositorFrame();
lfge0c2792ec2016-05-11 18:52:081372
fsamuel78f86e42016-01-20 04:10:231373 // Notify subclasses that we initiated the paint operation.
1374 DidInitiatePaint();
fsamuel78f86e42016-01-20 04:10:231375}
1376
Stephen Chenney23880392019-04-02 18:36:541377void RenderWidget::WillCommitCompositorFrame() {
1378 if (GetWebWidget())
1379 GetWebWidget()->BeginCommitCompositorFrame();
1380}
1381
Saman Sami766e0b02018-01-31 17:19:201382void RenderWidget::DidCommitCompositorFrame() {
Albert J. Wong7bbf22d2018-12-20 00:27:271383 if (delegate())
1384 delegate()->DidCommitCompositorFrameForWidget();
Stephen Chenney23880392019-04-02 18:36:541385 if (GetWebWidget())
1386 GetWebWidget()->EndCommitCompositorFrame();
Saman Sami766e0b02018-01-31 17:19:201387}
fsamuel78f86e42016-01-20 04:10:231388
danakja2c9d0a92018-07-25 20:01:181389void RenderWidget::DidCompletePageScaleAnimation() {
Albert J. Wong7bbf22d2018-12-20 00:27:271390 if (delegate())
1391 delegate()->DidCompletePageScaleAnimationForWidget();
danakja2c9d0a92018-07-25 20:01:181392}
fsamuel78f86e42016-01-20 04:10:231393
danakjcd417502019-03-13 16:13:211394void RenderWidget::SetLayerTreeMutator(
1395 std::unique_ptr<cc::LayerTreeMutator> mutator) {
danakj2db0b282019-09-20 15:09:201396 layer_tree_host_->SetLayerTreeMutator(std::move(mutator));
danakjcd417502019-03-13 16:13:211397}
1398
Xida Chen83f1a0d12019-03-21 18:21:301399void RenderWidget::SetPaintWorkletLayerPainterClient(
1400 std::unique_ptr<cc::PaintWorkletLayerPainter> client) {
danakj2db0b282019-09-20 15:09:201401 layer_tree_host_->SetPaintWorkletLayerPainter(std::move(client));
Xida Chen83f1a0d12019-03-21 18:21:301402}
1403
danakj26b99912019-02-08 18:58:191404void RenderWidget::SetRootLayer(scoped_refptr<cc::Layer> layer) {
danakj2db0b282019-09-20 15:09:201405 layer_tree_host_->SetRootLayer(std::move(layer));
danakj26b99912019-02-08 18:58:191406}
1407
danakj53f46b82018-12-11 20:55:551408void RenderWidget::ScheduleAnimation() {
1409 // This call is not needed in single thread mode for tests without a
danakj0719e0652019-03-14 21:19:111410 // scheduler, but they override this method in order to schedule a synchronous
1411 // composite task themselves.
danakj2db0b282019-09-20 15:09:201412 layer_tree_host_->SetNeedsAnimate();
initial.commit09911bf2008-07-26 23:55:291413}
1414
danakjefcb8432019-01-16 18:47:141415void RenderWidget::SetShowFPSCounter(bool show) {
danakj2db0b282019-09-20 15:09:201416 cc::LayerTreeDebugState debug_state = layer_tree_host_->GetDebugState();
danakjefcb8432019-01-16 18:47:141417 debug_state.show_fps_counter = show;
danakj2db0b282019-09-20 15:09:201418 layer_tree_host_->SetDebugState(debug_state);
danakjefcb8432019-01-16 18:47:141419}
1420
rnasricabcba42019-06-07 15:30:331421void RenderWidget::SetShowLayoutShiftRegions(bool show) {
danakj2db0b282019-09-20 15:09:201422 cc::LayerTreeDebugState debug_state = layer_tree_host_->GetDebugState();
rnasricabcba42019-06-07 15:30:331423 debug_state.show_layout_shift_regions = show;
danakj2db0b282019-09-20 15:09:201424 layer_tree_host_->SetDebugState(debug_state);
rnasricabcba42019-06-07 15:30:331425}
1426
danakje691e852019-01-16 22:49:041427void RenderWidget::SetShowPaintRects(bool show) {
danakj2db0b282019-09-20 15:09:201428 cc::LayerTreeDebugState debug_state = layer_tree_host_->GetDebugState();
danakje691e852019-01-16 22:49:041429 debug_state.show_paint_rects = show;
danakj2db0b282019-09-20 15:09:201430 layer_tree_host_->SetDebugState(debug_state);
danakje691e852019-01-16 22:49:041431}
1432
1433void RenderWidget::SetShowDebugBorders(bool show) {
danakj2db0b282019-09-20 15:09:201434 cc::LayerTreeDebugState debug_state = layer_tree_host_->GetDebugState();
danakje691e852019-01-16 22:49:041435 if (show)
1436 debug_state.show_debug_borders.set();
1437 else
1438 debug_state.show_debug_borders.reset();
danakj2db0b282019-09-20 15:09:201439 layer_tree_host_->SetDebugState(debug_state);
danakje691e852019-01-16 22:49:041440}
1441
1442void RenderWidget::SetShowScrollBottleneckRects(bool show) {
danakj2db0b282019-09-20 15:09:201443 cc::LayerTreeDebugState debug_state = layer_tree_host_->GetDebugState();
danakje691e852019-01-16 22:49:041444 debug_state.show_touch_event_handler_rects = show;
1445 debug_state.show_wheel_event_handler_rects = show;
1446 debug_state.show_non_fast_scrollable_rects = show;
danakj2db0b282019-09-20 15:09:201447 layer_tree_host_->SetDebugState(debug_state);
danakje691e852019-01-16 22:49:041448}
1449
1450void RenderWidget::SetShowHitTestBorders(bool show) {
danakj2db0b282019-09-20 15:09:201451 cc::LayerTreeDebugState debug_state = layer_tree_host_->GetDebugState();
danakje691e852019-01-16 22:49:041452 debug_state.show_hit_test_borders = show;
danakj2db0b282019-09-20 15:09:201453 layer_tree_host_->SetDebugState(debug_state);
danakje691e852019-01-16 22:49:041454}
1455
danakj40d07932019-02-28 18:07:101456void RenderWidget::SetBackgroundColor(SkColor color) {
danakj2db0b282019-09-20 15:09:201457 layer_tree_host_->set_background_color(color);
danakj40d07932019-02-28 18:07:101458}
1459
Stephen Chenneyd56b5382019-01-29 00:37:021460void RenderWidget::UpdateVisualState() {
Ken Buchananed449bb2018-02-01 21:02:051461 if (!GetWebWidget())
1462 return;
1463
danakjbd1a86a2019-09-06 17:24:311464 DCHECK(!is_undead_);
danakj1fe8e62d2019-09-05 23:21:561465 DCHECK(!IsForProvisionalFrame());
danakj22b4e8b2019-08-01 23:14:391466
Stephen Chenneyd56b5382019-01-29 00:37:021467 // We record metrics only when running in multi-threaded mode, not
1468 // single-thread mode for testing.
1469 bool record_main_frame_metrics =
1470 !!compositor_deps_->GetCompositorImplThreadTaskRunner();
1471
Stephen Chenneyec4312612018-11-21 12:40:161472 // When recording main frame metrics set the lifecycle reason to
1473 // kBeginMainFrame, because this is the calller of UpdateLifecycle
1474 // for the main frame. Otherwise, set the reason to kTests, which is
Stephen Chenneybccdd0302019-08-15 12:21:281475 // the only other reason this method is called.
Stephen Chenneyec4312612018-11-21 12:40:161476 WebWidget::LifecycleUpdateReason lifecycle_reason =
1477 record_main_frame_metrics
1478 ? WebWidget::LifecycleUpdateReason::kBeginMainFrame
1479 : WebWidget::LifecycleUpdateReason::kTest;
1480 GetWebWidget()->UpdateLifecycle(WebWidget::LifecycleUpdate::kAll,
1481 lifecycle_reason);
Blink Reformat1c4d759e2017-04-09 16:34:541482 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(false);
tasakb95dbb50c2017-02-08 18:07:501483
Robert Flack3ef2ffb2018-09-06 20:38:201484 if (first_update_visual_state_after_hidden_) {
Takashi SAKAMOTO870f6262017-08-22 04:08:271485 RecordTimeToFirstActivePaint();
1486 first_update_visual_state_after_hidden_ = false;
1487 }
1488}
tasakb95dbb50c2017-02-08 18:07:501489
Takashi SAKAMOTO870f6262017-08-22 04:08:271490void RenderWidget::RecordTimeToFirstActivePaint() {
tasakb95dbb50c2017-02-08 18:07:501491 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
tasakb95dbb50c2017-02-08 18:07:501492 base::TimeDelta sample = base::TimeTicks::Now() - was_shown_time_;
Takashi SAKAMOTO870f6262017-08-22 04:08:271493 if (render_thread_impl->NeedsToRecordFirstActivePaint(TTFAP_AFTER_PURGED)) {
1494 UMA_HISTOGRAM_TIMES("PurgeAndSuspend.Experimental.TimeToFirstActivePaint",
1495 sample);
1496 }
1497 if (render_thread_impl->NeedsToRecordFirstActivePaint(
1498 TTFAP_5MIN_AFTER_BACKGROUNDED)) {
1499 UMA_HISTOGRAM_TIMES(
1500 "PurgeAndSuspend.Experimental.TimeToFirstActivePaint."
1501 "AfterBackgrounded.5min",
1502 sample);
1503 }
fsamuel78f86e42016-01-20 04:10:231504}
1505
Stephen Chenneyd56b5382019-01-29 00:37:021506void RenderWidget::RecordStartOfFrameMetrics() {
Stephen Chenney23880392019-04-02 18:36:541507 if (GetWebWidget())
1508 GetWebWidget()->RecordStartOfFrameMetrics();
Stephen Chenneyd56b5382019-01-29 00:37:021509}
1510
Stephen Chenney9879a5c2018-09-26 14:21:421511void RenderWidget::RecordEndOfFrameMetrics(base::TimeTicks frame_begin_time) {
Stephen Chenney23880392019-04-02 18:36:541512 if (GetWebWidget())
1513 GetWebWidget()->RecordEndOfFrameMetrics(frame_begin_time);
1514}
Stephen Chenney9879a5c2018-09-26 14:21:421515
Stephen Chenney23880392019-04-02 18:36:541516void RenderWidget::BeginUpdateLayers() {
1517 if (GetWebWidget())
1518 GetWebWidget()->BeginUpdateLayers();
1519}
1520
1521void RenderWidget::EndUpdateLayers() {
1522 if (GetWebWidget())
Stephen Chenneyc3c5987d2019-04-15 20:40:071523 GetWebWidget()->EndUpdateLayers();
Stephen Chenney9879a5c2018-09-26 14:21:421524}
1525
fsamuel78f86e42016-01-20 04:10:231526void RenderWidget::WillBeginCompositorFrame() {
1527 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
1528
Ken Buchananed449bb2018-02-01 21:02:051529 if (!GetWebWidget())
1530 return;
1531
Blink Reformat1c4d759e2017-04-09 16:34:541532 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(true);
alancutter317a8e02017-04-05 10:09:291533
dglazkov06854c5c2016-08-31 00:19:591534 // The UpdateTextInputState can result in further layout and possibly
1535 // enable GPU acceleration so they need to be called before any painting
1536 // is done.
changwan75e3b2072017-01-16 02:55:001537 UpdateTextInputState();
dglazkov06854c5c2016-08-31 00:19:591538 UpdateSelectionBounds();
initial.commit09911bf2008-07-26 23:55:291539}
1540
fsamuel72464894f2015-12-15 06:59:311541///////////////////////////////////////////////////////////////////////////////
1542// RenderWidgetInputHandlerDelegate
1543
avid7d6b2e2016-03-04 19:41:171544void RenderWidget::FocusChangeComplete() {
Ehsan Karamad655d7b8a2018-01-12 18:38:381545 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1546 if (!frame_widget)
ekaramad27ca69b12017-04-20 18:34:291547 return;
Ehsan Karamad655d7b8a2018-01-12 18:38:381548
ekaramad27ca69b12017-04-20 18:34:291549 blink::WebLocalFrame* focused =
Ehsan Karamad655d7b8a2018-01-12 18:38:381550 frame_widget->LocalRoot()->View()->FocusedFrame();
1551
ekaramad27ca69b12017-04-20 18:34:291552 if (focused && focused->AutofillClient())
1553 focused->AutofillClient()->DidCompleteFocusChangeInFrame();
avid7d6b2e2016-03-04 19:41:171554}
fsamuel72464894f2015-12-15 06:59:311555
dtapuska1827dd22016-03-11 15:24:591556void RenderWidget::ObserveGestureEventAndResult(
1557 const blink::WebGestureEvent& gesture_event,
1558 const gfx::Vector2dF& unused_delta,
Sandra Sunac5cdd832017-12-11 03:27:131559 const cc::OverscrollBehavior& overscroll_behavior,
dtapuska1827dd22016-03-11 15:24:591560 bool event_processed) {
1561 if (!compositor_deps_->IsElasticOverscrollEnabled())
1562 return;
1563
1564 cc::InputHandlerScrollResult scroll_result;
1565 scroll_result.did_scroll = event_processed;
1566 scroll_result.did_overscroll_root = !unused_delta.IsZero();
1567 scroll_result.unused_scroll_delta = unused_delta;
Sandra Sunac5cdd832017-12-11 03:27:131568 scroll_result.overscroll_behavior = overscroll_behavior;
dtapuska1827dd22016-03-11 15:24:591569
Dave Tapuska04bc5ee92018-04-17 19:03:311570 widget_input_handler_manager_->ObserveGestureEventOnMainThread(gesture_event,
1571 scroll_result);
dtapuska1827dd22016-03-11 15:24:591572}
1573
avid7d6b2e2016-03-04 19:41:171574void RenderWidget::OnDidHandleKeyEvent() {
alexmos56567492016-09-13 00:52:461575 ClearEditCommands();
1576}
1577
1578void RenderWidget::SetEditCommandForNextKeyEvent(const std::string& name,
1579 const std::string& value) {
1580 ClearEditCommands();
1581 edit_commands_.emplace_back(name, value);
1582}
1583
1584void RenderWidget::ClearEditCommands() {
1585 edit_commands_.clear();
avid7d6b2e2016-03-04 19:41:171586}
fsamuel72464894f2015-12-15 06:59:311587
chongza8ba91fc2016-08-16 21:39:171588void RenderWidget::OnDidOverscroll(const ui::DidOverscrollParams& params) {
Dave Tapuska04bc5ee92018-04-17 19:03:311589 if (mojom::WidgetInputHandlerHost* host =
1590 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
1591 host->DidOverscroll(params);
Dave Tapuska139a72f2017-09-06 21:57:031592 }
fsamuel72464894f2015-12-15 06:59:311593}
1594
fsamuele8326c742016-01-12 00:49:391595void RenderWidget::SetInputHandler(RenderWidgetInputHandler* input_handler) {
1596 // Nothing to do here. RenderWidget created the |input_handler| and will take
1597 // ownership of it. We just verify here that we don't already have an input
1598 // handler.
1599 DCHECK(!input_handler_);
1600}
1601
changwan75e3b2072017-01-16 02:55:001602void RenderWidget::ShowVirtualKeyboard() {
danakj125a29e2019-01-24 23:25:291603 // Blink can continue running and change input state between the Close IPC
1604 // and the task that actually closes this class.
1605 if (closing_)
1606 return;
changwan75e3b2072017-01-16 02:55:001607 UpdateTextInputStateInternal(true, false);
1608}
1609
changwan62f57292017-02-17 08:28:251610void RenderWidget::ClearTextInputState() {
1611 text_input_info_ = blink::WebTextInputInfo();
1612 text_input_type_ = ui::TextInputType::TEXT_INPUT_TYPE_NONE;
1613 text_input_mode_ = ui::TextInputMode::TEXT_INPUT_MODE_DEFAULT;
1614 can_compose_inline_ = false;
1615 text_input_flags_ = 0;
AJITH KUMAR V041c0b02017-08-08 10:39:201616 next_previous_flags_ = kInvalidNextPreviousFlagsValue;
changwan62f57292017-02-17 08:28:251617}
1618
changwan75e3b2072017-01-16 02:55:001619void RenderWidget::UpdateTextInputState() {
danakj125a29e2019-01-24 23:25:291620 // Blink can continue running and change input state between the Close IPC
1621 // and the task that actually closes this class.
1622 if (closing_)
1623 return;
changwan75e3b2072017-01-16 02:55:001624 UpdateTextInputStateInternal(false, false);
1625}
1626
1627void RenderWidget::UpdateTextInputStateInternal(bool show_virtual_keyboard,
1628 bool reply_to_request) {
fsamuel72464894f2015-12-15 06:59:311629 TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState");
changwan75e3b2072017-01-16 02:55:001630
fsamuel72464894f2015-12-15 06:59:311631 if (ime_event_guard_) {
changwan75e3b2072017-01-16 02:55:001632 DCHECK(!reply_to_request);
1633 // show_virtual_keyboard should still be effective even if it was set inside
1634 // the IME
fsamuel72464894f2015-12-15 06:59:311635 // event guard.
changwan75e3b2072017-01-16 02:55:001636 if (show_virtual_keyboard)
1637 ime_event_guard_->set_show_virtual_keyboard(true);
fsamuel72464894f2015-12-15 06:59:311638 return;
1639 }
1640
dglazkov97b6c2b2016-10-25 17:35:551641 ui::TextInputType new_type = GetTextInputType();
1642 if (IsDateTimeInput(new_type))
1643 return; // Not considered as a text input field in WebKit/Chromium.
fsamuel72464894f2015-12-15 06:59:311644
dglazkov97b6c2b2016-10-25 17:35:551645 blink::WebTextInputInfo new_info;
ekaramad5aff1942017-01-06 01:26:351646 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:541647 new_info = controller->TextInputInfo();
dtapuskac4dd5be2016-10-25 15:11:101648 const ui::TextInputMode new_mode =
Blink Reformat1c4d759e2017-04-09 16:34:541649 ConvertWebTextInputMode(new_info.input_mode);
fsamuel72464894f2015-12-15 06:59:311650
1651 bool new_can_compose_inline = CanComposeInline();
1652
Jan Wilken Dörrie3d4843c2019-08-02 14:30:281653 // Check whether the keyboard should always be hidden for the currently
1654 // focused element.
1655 auto* focused_frame = GetFocusedWebLocalFrameInWidget();
1656 bool always_hide_ime =
1657 focused_frame && focused_frame->ShouldSuppressKeyboardForFocusedElement();
1658
fsamuel72464894f2015-12-15 06:59:311659 // Only sends text input params if they are changed or if the ime should be
1660 // shown.
changwan75e3b2072017-01-16 02:55:001661 if (show_virtual_keyboard || reply_to_request ||
changwan38c3eb612016-12-09 01:45:561662 text_input_type_ != new_type || text_input_mode_ != new_mode ||
1663 text_input_info_ != new_info ||
Jan Wilken Dörrie3d4843c2019-08-02 14:30:281664 can_compose_inline_ != new_can_compose_inline ||
1665 always_hide_ime_ != always_hide_ime) {
ekaramad9053e57b2016-04-26 20:00:381666 TextInputState params;
dglazkov97b6c2b2016-10-25 17:35:551667 params.type = new_type;
fsamuel72464894f2015-12-15 06:59:311668 params.mode = new_mode;
Dave Tapuskaf0698ee2019-05-21 21:12:331669 params.action = new_info.action;
fsamuel72464894f2015-12-15 06:59:311670 params.flags = new_info.flags;
AJITH KUMAR V9e7b5572017-11-14 00:54:211671#if defined(OS_ANDROID)
AJITH KUMAR V041c0b02017-08-08 10:39:201672 if (next_previous_flags_ == kInvalidNextPreviousFlagsValue) {
1673 // Due to a focus change, values will be reset by the frame.
1674 // That case we only need fresh NEXT/PREVIOUS information.
Albert J. Wong3c93c182018-09-27 17:29:431675 // Also we won't send WidgetHostMsg_TextInputStateChanged if next/previous
AJITH KUMAR V041c0b02017-08-08 10:39:201676 // focusable status is changed.
1677 if (auto* controller = GetInputMethodController()) {
1678 next_previous_flags_ =
1679 controller->ComputeWebTextInputNextPreviousFlags();
1680 } else {
1681 // For safety in case GetInputMethodController() is null, because -1 is
1682 // invalid value to send to browser process.
1683 next_previous_flags_ = 0;
1684 }
1685 }
AJITH KUMAR V9e7b5572017-11-14 00:54:211686#else
1687 next_previous_flags_ = 0;
1688#endif
AJITH KUMAR V041c0b02017-08-08 10:39:201689 params.flags |= next_previous_flags_;
Yuichiro Hanada1b19cf852019-01-18 16:12:261690 params.value = new_info.value.Utf16();
Blink Reformat1c4d759e2017-04-09 16:34:541691 params.selection_start = new_info.selection_start;
1692 params.selection_end = new_info.selection_end;
1693 params.composition_start = new_info.composition_start;
1694 params.composition_end = new_info.composition_end;
fsamuel72464894f2015-12-15 06:59:311695 params.can_compose_inline = new_can_compose_inline;
changwan75e3b2072017-01-16 02:55:001696 // TODO(changwan): change instances of show_ime_if_needed to
1697 // show_virtual_keyboard.
1698 params.show_ime_if_needed = show_virtual_keyboard;
Jan Wilken Dörrie3d4843c2019-08-02 14:30:281699 params.always_hide_ime = always_hide_ime;
changwan75e3b2072017-01-16 02:55:001700 params.reply_to_request = reply_to_request;
Albert J. Wong3c93c182018-09-27 17:29:431701 Send(new WidgetHostMsg_TextInputStateChanged(routing_id(), params));
fsamuel72464894f2015-12-15 06:59:311702
1703 text_input_info_ = new_info;
dglazkov97b6c2b2016-10-25 17:35:551704 text_input_type_ = new_type;
fsamuel72464894f2015-12-15 06:59:311705 text_input_mode_ = new_mode;
1706 can_compose_inline_ = new_can_compose_inline;
Jan Wilken Dörrie3d4843c2019-08-02 14:30:281707 always_hide_ime_ = always_hide_ime;
fsamuel72464894f2015-12-15 06:59:311708 text_input_flags_ = new_info.flags;
Eric Karl706ea6712018-12-21 22:41:381709
1710#if defined(OS_ANDROID)
1711 // If we send a new TextInputStateChanged message, we must also deliver a
1712 // new RenderFrameMetadata, as the IME will need this info to be updated.
1713 // TODO(ericrk): Consider folding the above IPC into RenderFrameMetadata.
1714 // https://crbug.com/912309
danakj2db0b282019-09-20 15:09:201715 layer_tree_host_->RequestForceSendMetadata();
Eric Karl706ea6712018-12-21 22:41:381716#endif
fsamuel72464894f2015-12-15 06:59:311717 }
1718}
1719
1720bool RenderWidget::WillHandleGestureEvent(const blink::WebGestureEvent& event) {
paulmeyer6ef5a792016-11-08 20:33:581721 possible_drag_event_info_.event_source =
1722 ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH;
1723 possible_drag_event_info_.event_location =
Ella Ge1116059d2018-03-21 02:06:131724 gfx::ToFlooredPoint(event.PositionInScreen());
avid7d6b2e2016-03-04 19:41:171725
fsamuel72464894f2015-12-15 06:59:311726 return false;
1727}
1728
1729bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
ericwilligers88e69742016-10-17 19:29:551730 for (auto& observer : render_frames_)
1731 observer.RenderWidgetWillHandleMouseEvent();
lfge0c2792ec2016-05-11 18:52:081732
paulmeyer6ef5a792016-11-08 20:33:581733 possible_drag_event_info_.event_source =
1734 ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
1735 possible_drag_event_info_.event_location =
Blink Reformat1c4d759e2017-04-09 16:34:541736 gfx::Point(event.PositionInScreen().x, event.PositionInScreen().y);
paulmeyer6ef5a792016-11-08 20:33:581737
Erik Chena39aa2d2019-09-21 02:14:041738 return mouse_lock_dispatcher()->WillHandleMouseEvent(event);
[email protected]fd847792013-10-24 17:12:351739}
1740
initial.commit09911bf2008-07-26 23:55:291741///////////////////////////////////////////////////////////////////////////////
mfomitchev2600fd7c2016-02-17 20:53:391742// RenderWidgetScreenMetricsDelegate
1743
bokanc63441c2016-04-27 15:49:121744void RenderWidget::ResizeWebWidget() {
danakja2c9d0a92018-07-25 20:01:181745 gfx::Size size = GetSizeForWebWidget();
Albert J. Wong7bbf22d2018-12-20 00:27:271746 if (delegate()) {
1747 delegate()->ResizeWebWidgetForWidget(size, top_controls_height_,
1748 bottom_controls_height_,
1749 browser_controls_shrink_blink_size_);
danakja2c9d0a92018-07-25 20:01:181750 return;
1751 }
Erik Chen15476cef2019-08-27 17:28:061752 // TODO:(https://crbug.com/995981): If there is no WebWidget, then the
1753 // RenderWidget should also be destroyed, and this DCHECK should not be
1754 // necessary.
1755 DCHECK(GetWebWidget());
danakja2c9d0a92018-07-25 20:01:181756 GetWebWidget()->Resize(size);
bokanc63441c2016-04-27 15:49:121757}
1758
1759gfx::Size RenderWidget::GetSizeForWebWidget() const {
danakj4b347212018-07-04 17:55:171760 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:031761 return gfx::ScaleToCeiledSize(size_,
1762 GetOriginalScreenInfo().device_scale_factor);
1763 }
bokanc63441c2016-04-27 15:49:121764
1765 return size_;
1766}
1767
W. James MacLean7df854c2019-08-28 16:17:531768gfx::Rect RenderWidget::CompositorViewportRect() const {
danakj2db0b282019-09-20 15:09:201769 return layer_tree_host_->device_viewport_rect();
danakj0d963bd2019-02-20 18:00:461770}
1771
Albert J. Wong0a918192019-08-28 01:05:281772void RenderWidget::SynchronizeVisualProperties(
1773 const VisualProperties& visual_properties) {
danakj3c2dfa52019-09-18 19:04:471774 // This method needs to handle changes to the screen_info, new_size, and
1775 // visible_viewport_size fields in |visual_properties|, as this method is
Erik Chen1dd127d2019-09-21 02:33:041776 // called from the RenderWidgetScreenMetricsEmulator and it changes those
1777 // fields but not others.
danakj3c2dfa52019-09-18 19:04:471778
W. James MacLean73742842019-09-06 18:44:491779 gfx::Rect new_compositor_viewport_pixel_rect =
danakjd990b4c2019-09-18 20:34:291780 auto_resize_mode_
W. James MacLean73742842019-09-06 18:44:491781 ? gfx::Rect(gfx::ScaleToCeiledSize(
1782 size_, visual_properties.screen_info.device_scale_factor))
1783 : visual_properties.compositor_viewport_pixel_rect;
Albert J. Wong0a918192019-08-28 01:05:281784 UpdateSurfaceAndScreenInfo(
1785 visual_properties.local_surface_id_allocation.value_or(
1786 viz::LocalSurfaceIdAllocation()),
W. James MacLean73742842019-09-06 18:44:491787 new_compositor_viewport_pixel_rect, visual_properties.screen_info);
mfomitchev2600fd7c2016-02-17 20:53:391788
danakjcf409aa2019-09-20 15:22:301789 if (for_frame()) {
1790 // TODO(danakj): This should not need to go through RenderFrame to set
1791 // Page-level properties.
1792 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1793 // TODO(danakj): Stop doing SynchronizeVisualProperties() (due to emulation)
1794 // while undead, and change this to a DCHECK.
1795 if (frame_widget) {
1796 RenderFrameImpl* render_frame =
1797 RenderFrameImpl::FromWebFrame(frame_widget->LocalRoot());
1798
1799 // This causes compositing state to be modified which dirties the document
1800 // lifecycle. Android Webview relies on the document lifecycle being clean
1801 // after the RenderWidget is initialized, in order to send IPCs that query
1802 // and change compositing state. So ResizeWebWidget() must come after this
1803 // call, as it runs the entire document lifecycle.
1804 render_frame->SetPreferCompositingToLCDTextEnabledOnRenderView(
1805 ComputePreferCompositingToLCDText(
1806 compositor_deps_, page_properties_->GetDeviceScaleFactor()));
1807 }
1808 }
1809
danakjd990b4c2019-09-18 20:34:291810 if (!auto_resize_mode_) {
Albert J. Wong0a918192019-08-28 01:05:281811 visible_viewport_size_ = visual_properties.visible_viewport_size;
1812 display_mode_ = visual_properties.display_mode;
1813 size_ = visual_properties.new_size;
mfomitchev2600fd7c2016-02-17 20:53:391814
danakj21604ce2018-12-19 16:01:221815 ResizeWebWidget();
mfomitchev2600fd7c2016-02-17 20:53:391816
danakjb4cec102019-01-30 19:22:131817 gfx::Size visual_viewport_size = visible_viewport_size_;
danakj21604ce2018-12-19 16:01:221818 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
danakjb4cec102019-01-30 19:22:131819 visual_viewport_size = gfx::ScaleToCeiledSize(
1820 visual_viewport_size, GetOriginalScreenInfo().device_scale_factor);
danakj21604ce2018-12-19 16:01:221821 }
W. James MacLean7c8581072019-06-18 18:07:531822 // When this function is invoked for a main frame widget, it is only if
1823 // (i) we are initializing the widget, or (ii) the widget supports a local
1824 // mainframe. For widgets supporting a remote main frame, the visual
1825 // viewport is updated through the RenderView.
1826 if (delegate())
1827 delegate()->ResizeVisualViewportForWidget(visual_viewport_size);
mfomitchev2600fd7c2016-02-17 20:53:391828 }
mfomitchev2600fd7c2016-02-17 20:53:391829}
1830
1831void RenderWidget::SetScreenMetricsEmulationParameters(
1832 bool enabled,
1833 const blink::WebDeviceEmulationParams& params) {
Albert J. Wong7bbf22d2018-12-20 00:27:271834 // This is only supported in RenderView, which has an delegate().
1835 DCHECK(delegate());
1836 delegate()->SetScreenMetricsEmulationParametersForWidget(enabled, params);
mfomitchev2600fd7c2016-02-17 20:53:391837}
1838
Albert J. Wong3c93c182018-09-27 17:29:431839void RenderWidget::SetScreenRects(const gfx::Rect& widget_screen_rect,
mfomitchev2600fd7c2016-02-17 20:53:391840 const gfx::Rect& window_screen_rect) {
Albert J. Wong3c93c182018-09-27 17:29:431841 widget_screen_rect_ = widget_screen_rect;
mfomitchev2600fd7c2016-02-17 20:53:391842 window_screen_rect_ = window_screen_rect;
1843}
1844
1845///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461846// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291847
Chris Harrelsond7ab99b2018-01-24 17:51:361848void RenderWidget::IntrinsicSizingInfoChanged(
1849 const blink::WebIntrinsicSizingInfo& sizing_info) {
Albert J. Wong3c93c182018-09-27 17:29:431850 Send(new WidgetHostMsg_IntrinsicSizingInfoChanged(routing_id_, sizing_info));
Chris Harrelsond7ab99b2018-01-24 17:51:361851}
1852
Blink Reformat1c4d759e2017-04-09 16:34:541853void RenderWidget::DidMeaningfulLayout(blink::WebMeaningfulLayout layout_type) {
1854 if (layout_type == blink::WebMeaningfulLayout::kVisuallyNonEmpty) {
George Burgess IVbd843ec2019-09-05 02:50:361855 QueueMessage(std::make_unique<WidgetHostMsg_DidFirstVisuallyNonEmptyPaint>(
1856 routing_id_));
dglazkovf0e1d6d2015-10-10 02:13:481857 }
dglazkov79c426102015-08-31 21:22:431858
ericwilligers88e69742016-10-17 19:29:551859 for (auto& observer : render_frames_)
1860 observer.DidMeaningfulLayout(layout_type);
dglazkov79c426102015-08-31 21:22:431861}
1862
[email protected]586871b2014-07-22 17:05:111863// static
dchengcedca5612016-04-09 01:40:151864std::unique_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
George Burgess IVbd843ec2019-09-05 02:50:361865 std::unique_ptr<IPC::Message> msg,
[email protected]586871b2014-07-22 17:05:111866 FrameSwapMessageQueue* frame_swap_message_queue,
1867 scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
[email protected]586871b2014-07-22 17:05:111868 int source_frame_number) {
[email protected]586871b2014-07-22 17:05:111869 bool first_message_for_frame = false;
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491870 frame_swap_message_queue->QueueMessageForFrame(
George Burgess IVbd843ec2019-09-05 02:50:361871 source_frame_number, std::move(msg), &first_message_for_frame);
danakj2d2889a2019-04-05 21:22:081872 if (!first_message_for_frame)
1873 return nullptr;
1874 return std::make_unique<QueueMessageSwapPromise>(
1875 sync_message_filter, frame_swap_message_queue, source_frame_number);
[email protected]586871b2014-07-22 17:05:111876}
1877
danakj53802692018-07-25 21:46:441878void RenderWidget::SetHandlingInputEvent(bool handling_input_event) {
1879 input_handler_->set_handling_input_event(handling_input_event);
1880}
1881
George Burgess IVbd843ec2019-09-05 02:50:361882void RenderWidget::QueueMessage(std::unique_ptr<IPC::Message> msg) {
danakj125a29e2019-01-24 23:25:291883 if (closing_)
1884 return;
1885
[email protected]586871b2014-07-22 17:05:111886 // RenderThreadImpl::current() is NULL in some tests.
danakj125a29e2019-01-24 23:25:291887 if (!RenderThreadImpl::current()) {
George Burgess IVbd843ec2019-09-05 02:50:361888 Send(msg.release());
[email protected]586871b2014-07-22 17:05:111889 return;
1890 }
1891
dchengcedca5612016-04-09 01:40:151892 std::unique_ptr<cc::SwapPromise> swap_promise =
George Burgess IVbd843ec2019-09-05 02:50:361893 QueueMessageImpl(std::move(msg), frame_swap_message_queue_.get(),
[email protected]586871b2014-07-22 17:05:111894 RenderThreadImpl::current()->sync_message_filter(),
danakj2db0b282019-09-20 15:09:201895 layer_tree_host_->SourceFrameNumber());
danakj2d2889a2019-04-05 21:22:081896 if (swap_promise) {
danakj2db0b282019-09-20 15:09:201897 layer_tree_host_->QueueSwapPromise(std::move(swap_promise));
danakj2d2889a2019-04-05 21:22:081898 }
[email protected]586871b2014-07-22 17:05:111899}
1900
Blink Reformat1c4d759e2017-04-09 16:34:541901void RenderWidget::DidChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301902 // TODO(darin): Eliminate this temporary.
Mike Wassermanf95c2d9d2019-04-17 00:44:211903 WebCursor cursor((CursorInfo(cursor_info)));
initial.commit09911bf2008-07-26 23:55:291904 // Only send a SetCursor message if we need to make a change.
Navid Zolghadr293bb862018-12-12 18:15:411905 if (input_handler_->DidChangeCursor(cursor))
Albert J. Wong3c93c182018-09-27 17:29:431906 Send(new WidgetHostMsg_SetCursor(routing_id_, cursor));
initial.commit09911bf2008-07-26 23:55:291907}
1908
aelias5971e47d2017-06-16 02:39:381909void RenderWidget::AutoscrollStart(const blink::WebFloatPoint& point) {
Albert J. Wong3c93c182018-09-27 17:29:431910 Send(new WidgetHostMsg_AutoscrollStart(routing_id_, point));
aelias5971e47d2017-06-16 02:39:381911}
1912
1913void RenderWidget::AutoscrollFling(const blink::WebFloatSize& velocity) {
Albert J. Wong3c93c182018-09-27 17:29:431914 Send(new WidgetHostMsg_AutoscrollFling(routing_id_, velocity));
aelias5971e47d2017-06-16 02:39:381915}
1916
1917void RenderWidget::AutoscrollEnd() {
Albert J. Wong3c93c182018-09-27 17:29:431918 Send(new WidgetHostMsg_AutoscrollEnd(routing_id_));
aelias5971e47d2017-06-16 02:39:381919}
1920
initial.commit09911bf2008-07-26 23:55:291921// We are supposed to get a single call to Show for a newly created RenderWidget
1922// that was created via RenderWidget::CreateWebView. So, we wait until this
1923// point to dispatch the ShowWidget message.
1924//
1925// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281926// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291927//
Blink Reformat1c4d759e2017-04-09 16:34:541928void RenderWidget::Show(WebNavigationPolicy policy) {
danakj65f423b72018-10-10 17:21:201929 if (!show_callback_) {
Albert J. Wong7bbf22d2018-12-20 00:27:271930 if (delegate()) {
danakja2c9d0a92018-07-25 20:01:181931 // When SupportsMultipleWindows is disabled, popups are reusing
danakj65f423b72018-10-10 17:21:201932 // the view's RenderWidget. In some scenarios, this makes blink to call
1933 // Show() twice. But otherwise, if it is enabled, we should not visit
1934 // Show() more than once.
Albert J. Wong7bbf22d2018-12-20 00:27:271935 DCHECK(!delegate()->SupportsMultipleWindowsForWidget());
danakj65f423b72018-10-10 17:21:201936 return;
danakja2c9d0a92018-07-25 20:01:181937 } else {
danakj65f423b72018-10-10 17:21:201938 NOTREACHED() << "received extraneous Show call";
danakja2c9d0a92018-07-25 20:01:181939 }
danakja2c9d0a92018-07-25 20:01:181940 }
1941
initial.commit09911bf2008-07-26 23:55:291942 DCHECK(routing_id_ != MSG_ROUTING_NONE);
nickf7b38222016-11-22 21:59:351943
1944 // The opener is responsible for actually showing this widget.
danakjdf1ceb72018-07-18 20:02:251945 std::move(show_callback_).Run(this, policy, initial_rect_);
nickf7b38222016-11-22 21:59:351946
bokanc007c3a2015-02-03 07:15:561947 // NOTE: initial_rect_ may still have its default values at this point, but
[email protected]8de12d942010-11-17 20:42:441948 // that's okay. It'll be ignored if as_popup is false, or the browser
1949 // process will impose a default position otherwise.
bokanc007c3a2015-02-03 07:15:561950 SetPendingWindowRect(initial_rect_);
initial.commit09911bf2008-07-26 23:55:291951}
1952
danakj17216f4d2018-10-16 22:57:321953LayerTreeView* RenderWidget::InitializeLayerTreeView() {
1954 TRACE_EVENT0("blink", "RenderWidget::InitializeLayerTreeView");
danakj17216f4d2018-10-16 22:57:321955
1956 layer_tree_view_ = std::make_unique<LayerTreeView>(
1957 this, compositor_deps_->GetCompositorMainThreadTaskRunner(),
1958 compositor_deps_->GetCompositorImplThreadTaskRunner(),
1959 compositor_deps_->GetTaskGraphRunner(),
1960 compositor_deps_->GetWebMainThreadScheduler());
1961 layer_tree_view_->Initialize(
danakj6dcbc5962018-11-16 16:45:421962 GenerateLayerTreeSettings(compositor_deps_, for_child_local_root_frame_,
Albert J. Wonga3dbd5442019-09-18 10:38:281963 page_properties_->GetScreenInfo().rect.size(),
1964 page_properties_->GetDeviceScaleFactor()),
danakj17216f4d2018-10-16 22:57:321965 compositor_deps_->CreateUkmRecorderFactory());
danakj2db0b282019-09-20 15:09:201966 layer_tree_host_ = layer_tree_view_->layer_tree_host();
danakj17216f4d2018-10-16 22:57:321967
Fady Samuel1c1ad3692018-11-06 23:28:401968 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
Albert J. Wonga3dbd5442019-09-18 10:38:281969 CompositorViewportRect(),
1970 page_properties_->GetScreenInfo());
danakj953af052019-02-06 19:13:181971 // If the widget is hidden, delay starting the compositor until the user shows
danakjbd1a86a2019-09-06 17:24:311972 // it. Also if the RenderWidget is undead, we delay starting the compositor
danakj953af052019-02-06 19:13:181973 // until we expect to use the widget, which will be signaled through
danakjbd1a86a2019-09-06 17:24:311974 // reviving the undead RenderWidget.
1975 if (!is_hidden_ && !is_undead_)
danakj953af052019-02-06 19:13:181976 StartStopCompositor();
danakj17216f4d2018-10-16 22:57:321977
danakj17216f4d2018-10-16 22:57:321978 DCHECK_NE(MSG_ROUTING_NONE, routing_id_);
danakj17216f4d2018-10-16 22:57:321979
1980 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1981 if (render_thread) {
1982 input_event_queue_ = base::MakeRefCounted<MainThreadEventQueue>(
1983 this, render_thread->GetWebMainThreadScheduler()->InputTaskRunner(),
danakj953af052019-02-06 19:13:181984 render_thread->GetWebMainThreadScheduler(),
1985 /*allow_raf_aligned_input=*/!compositor_never_visible_);
danakj17216f4d2018-10-16 22:57:321986 }
1987
1988 return layer_tree_view_.get();
1989}
1990
danakj953af052019-02-06 19:13:181991void RenderWidget::StartStopCompositor() {
1992 if (compositor_never_visible_)
1993 return;
danakjde8b7482018-11-15 23:45:021994
danakj22b4e8b2019-08-01 23:14:391995 // TODO(danakj): We should start the compositor before becoming shown for
danakjbd1a86a2019-09-06 17:24:311996 // *all* provisional frames not just provisional main frames (as they come
1997 // back from being undead). However we need to also prevent BeginMainFrame
1998 // from occurring, in both cases, until the frame is attached at least. And in
1999 // the case of main frames, until blink requests them through
2000 // StopDeferringMainFrameUpdate().
2001 if (is_undead_) {
danakj953af052019-02-06 19:13:182002 layer_tree_view_->SetVisible(false);
2003 // Drop all gpu resources, this makes SetVisible(true) more expensive/slower
2004 // but we don't expect to use this RenderWidget again until some possible
2005 // future navigation. This brings us a bit closer to emulating deleting the
2006 // RenderWidget instead of just stopping the compositor.
danakj2db0b282019-09-20 15:09:202007 layer_tree_host_->ReleaseLayerTreeFrameSink();
danakj953af052019-02-06 19:13:182008 } else if (is_hidden_) {
2009 layer_tree_view_->SetVisible(false);
2010 } else {
2011 layer_tree_view_->SetVisible(true);
2012 }
danakjde8b7482018-11-15 23:45:022013}
2014
danakjbd1a86a2019-09-06 17:24:312015void RenderWidget::SetIsUndead(bool is_undead) {
2016 DCHECK_NE(is_undead, is_undead_);
2017 is_undead_ = is_undead;
2018 // If hidden, then changing undead state doesn't change anything with the
danakj953af052019-02-06 19:13:182019 // compositor since when hidden the compositor is always stopped.
2020 if (!is_hidden_)
2021 StartStopCompositor();
danakjde8b7482018-11-15 23:45:022022}
2023
danakj9e93f322019-08-02 22:56:582024// static
2025void RenderWidget::DoDeferredClose(int widget_routing_id) {
2026 // DoDeferredClose() was a posted task, which means the RenderWidget may have
danakjbd1a86a2019-09-06 17:24:312027 // become undead in the meantime. Undead RenderWidgets do not send messages,
danakj9e93f322019-08-02 22:56:582028 // so break the dependency on RenderWidget here, by making this method static
2029 // and going to RenderThread directly to send.
2030 RenderThread::Get()->Send(new WidgetHostMsg_Close(widget_routing_id));
[email protected]2533ce12009-05-09 00:02:242031}
2032
danakj45e4a4f2019-03-12 22:50:422033void RenderWidget::ClosePopupWidgetSoon() {
2034 // Only should be called for popup widgets.
2035 DCHECK(!for_child_local_root_frame_);
2036 DCHECK(!delegate_);
2037
2038 CloseWidgetSoon();
2039}
2040
Blink Reformat1c4d759e2017-04-09 16:34:542041void RenderWidget::CloseWidgetSoon() {
Avi Drissman07d22452019-03-25 17:56:392042 DCHECK(RenderThread::IsMainThread());
danakj292b63e2018-11-19 20:47:062043
initial.commit09911bf2008-07-26 23:55:292044 // If a page calls window.close() twice, we'll end up here twice, but that's
2045 // OK. It is safe to send multiple Close messages.
danakj292b63e2018-11-19 20:47:062046 //
[email protected]2533ce12009-05-09 00:02:242047 // Ask the RenderWidgetHost to initiate close. We could be called from deep
danakj295c43f182019-03-13 16:37:172048 // in Javascript. If we ask the RenderWidgetHost to close now, the window
2049 // could be closed before the JS finishes executing, thanks to nested message
2050 // loops running and handling the resuliting Close IPC. So instead, post a
[email protected]2533ce12009-05-09 00:02:242051 // message back to the message loop, which won't run until the JS is
danakj295c43f182019-03-13 16:37:172052 // complete, and then the Close request can be sent.
Hajime Hoshi315a61f2018-08-14 17:27:282053 GetCleanupTaskRunner()->PostTask(
danakj9e93f322019-08-02 22:56:582054 FROM_HERE, base::BindOnce(&RenderWidget::DoDeferredClose, routing_id_));
initial.commit09911bf2008-07-26 23:55:292055}
2056
Erik Chen3433ee02019-08-05 20:14:262057void RenderWidget::Close(std::unique_ptr<RenderWidget> widget) {
danakja6c10012018-07-06 14:25:362058 layer_tree_view_.reset();
Albert J. Wongd593de532018-09-06 05:42:152059 // Note the ACK is a control message going to the RenderProcessHost.
Albert J. Wong3c93c182018-09-27 17:29:432060 RenderThread::Get()->Send(new WidgetHostMsg_Close_ACK(routing_id()));
danakj6ec39d302019-03-15 22:43:222061 closed_ = true;
Erik Chen3433ee02019-08-05 20:14:262062
2063 // At the end of this method, |widget| which points to this is deleted.
2064 DCHECK_EQ(widget.get(), this);
Ken Buchananed449bb2018-02-01 21:02:052065}
2066
Ehsan Karamad655d7b8a2018-01-12 18:38:382067blink::WebFrameWidget* RenderWidget::GetFrameWidget() const {
danakj89ae4532018-12-12 22:52:552068 // TODO(danakj): Remove this check and don't call this method for non-frames.
2069 if (!for_frame())
2070 return nullptr;
2071 // TODO(danakj): Is this needed? IPCs stop after closing, but code used to
2072 // check for a null WebWidget.
2073 if (closing_)
Ehsan Karamad655d7b8a2018-01-12 18:38:382074 return nullptr;
danakj557248b2019-09-25 17:17:402075 return static_cast<blink::WebFrameWidget*>(webwidget_);
Ehsan Karamad655d7b8a2018-01-12 18:38:382076}
2077
danakj1fe8e62d2019-09-05 23:21:562078bool RenderWidget::IsForProvisionalFrame() const {
2079 if (!for_frame())
2080 return false;
2081 // No widget here means the main frame is remote and there is no
2082 // provisional frame at the moment.
danakj557248b2019-09-25 17:17:402083 if (!webwidget_)
danakj1fe8e62d2019-09-05 23:21:562084 return false;
danakj557248b2019-09-25 17:17:402085 auto* frame_widget = static_cast<blink::WebFrameWidget*>(webwidget_);
danakj1fe8e62d2019-09-05 23:21:562086 return frame_widget->LocalRoot()->IsProvisional();
2087}
2088
bokan841fdc72016-10-06 00:16:352089void RenderWidget::ScreenRectToEmulatedIfNeeded(WebRect* window_rect) const {
2090 DCHECK(window_rect);
2091 float scale = popup_origin_scale_for_emulation_;
2092 if (!scale)
2093 return;
2094 window_rect->x =
2095 popup_view_origin_for_emulation_.x() +
2096 (window_rect->x - popup_screen_origin_for_emulation_.x()) / scale;
2097 window_rect->y =
2098 popup_view_origin_for_emulation_.y() +
2099 (window_rect->y - popup_screen_origin_for_emulation_.y()) / scale;
2100}
2101
2102void RenderWidget::EmulatedToScreenRectIfNeeded(WebRect* window_rect) const {
2103 DCHECK(window_rect);
2104 float scale = popup_origin_scale_for_emulation_;
2105 if (!scale)
2106 return;
2107 window_rect->x =
2108 popup_screen_origin_for_emulation_.x() +
2109 (window_rect->x - popup_view_origin_for_emulation_.x()) * scale;
2110 window_rect->y =
2111 popup_screen_origin_for_emulation_.y() +
2112 (window_rect->y - popup_view_origin_for_emulation_.y()) * scale;
2113}
2114
Blink Reformat1c4d759e2017-04-09 16:34:542115WebRect RenderWidget::WindowRect() {
bokan841fdc72016-10-06 00:16:352116 WebRect rect;
bokan6b08cd22016-10-05 00:55:212117 if (pending_window_rect_count_) {
2118 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
2119 // the RootWindowRect is probably going to return wrong results since the
2120 // browser may not have processed the Move yet. There isn't really anything
2121 // good to do in this case, and it shouldn't happen - since this size is
2122 // only really needed for windowToScreen, which is only used for Popups.
bokan841fdc72016-10-06 00:16:352123 rect = pending_window_rect_;
2124 } else {
2125 rect = window_screen_rect_;
bokan6b08cd22016-10-05 00:55:212126 }
[email protected]2533ce12009-05-09 00:02:242127
bokan841fdc72016-10-06 00:16:352128 ScreenRectToEmulatedIfNeeded(&rect);
2129 return rect;
bokan6b08cd22016-10-05 00:55:212130}
2131
Blink Reformat1c4d759e2017-04-09 16:34:542132WebRect RenderWidget::ViewRect() {
Albert J. Wong3c93c182018-09-27 17:29:432133 WebRect rect = widget_screen_rect_;
bokan841fdc72016-10-06 00:16:352134 ScreenRectToEmulatedIfNeeded(&rect);
2135 return rect;
initial.commit09911bf2008-07-26 23:55:292136}
2137
Blink Reformat1c4d759e2017-04-09 16:34:542138void RenderWidget::SetToolTipText(const blink::WebString& text,
[email protected]8a9d6ca32011-06-06 20:11:302139 WebTextDirection hint) {
Albert J. Wong3c93c182018-09-27 17:29:432140 Send(new WidgetHostMsg_SetTooltipText(routing_id_, text.Utf16(), hint));
[email protected]8a9d6ca32011-06-06 20:11:302141}
2142
Blink Reformat1c4d759e2017-04-09 16:34:542143void RenderWidget::SetWindowRect(const WebRect& rect_in_screen) {
danakj81d601e62018-10-09 22:15:052144 // This path is for the renderer to change the on-screen position/size of
2145 // the widget by changing its window rect. This is not possible for
2146 // RenderWidgets whose position/size are controlled by layout from another
danakj6dcbc5962018-11-16 16:45:422147 // frame tree (ie. child local root frames), as the window rect can only be
2148 // set by the browser.
2149 if (for_child_local_root_frame_)
danakj81d601e62018-10-09 22:15:052150 return;
2151
oshima33ec97cd2015-12-14 19:40:242152 WebRect window_rect = rect_in_screen;
bokan841fdc72016-10-06 00:16:352153 EmulatedToScreenRectIfNeeded(&window_rect);
[email protected]b2e4c70132013-10-03 02:07:512154
danakj7602f4f2019-01-31 18:03:232155 if (synchronous_resize_mode_for_testing_) {
Kent Tamura21d1de62018-12-10 04:45:202156 // This is a web-test-only path. At one point, it was planned to be
danakj65f423b72018-10-10 17:21:202157 // removed. See https://crbug.com/309760.
bokanc007c3a2015-02-03 07:15:562158 SetWindowRectSynchronously(window_rect);
danakj65f423b72018-10-10 17:21:202159 return;
2160 }
2161
2162 if (show_callback_) {
2163 // The widget is not shown yet. Delay the |window_rect| being sent to the
2164 // browser until Show() is called so it can be sent with that IPC, once the
2165 // browser is ready for the info.
2166 initial_rect_ = window_rect;
2167 } else {
2168 Send(new WidgetHostMsg_RequestSetBounds(routing_id_, window_rect));
2169 SetPendingWindowRect(window_rect);
initial.commit09911bf2008-07-26 23:55:292170 }
2171}
2172
[email protected]2533ce12009-05-09 00:02:242173void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
2174 pending_window_rect_ = rect;
2175 pending_window_rect_count_++;
[email protected]2533ce12009-05-09 00:02:242176
bokan6b08cd22016-10-05 00:55:212177 // Popups don't get size updates back from the browser so just store the set
2178 // values.
danakj89ae4532018-12-12 22:52:552179 if (!for_frame()) {
Blink Reformat1c4d759e2017-04-09 16:34:542180 window_screen_rect_ = rect;
Albert J. Wong3c93c182018-09-27 17:29:432181 widget_screen_rect_ = rect;
[email protected]2533ce12009-05-09 00:02:242182 }
[email protected]d4547452008-08-28 18:36:372183}
2184
wjmacleanee244e02017-05-26 21:06:072185void RenderWidget::OnShowContextMenu(ui::MenuSourceType source_type,
2186 const gfx::Point& location) {
wjmacleanee244e02017-05-26 21:06:072187 has_host_context_menu_location_ = true;
2188 host_context_menu_location_ = location;
2189 if (GetWebWidget()) {
2190 GetWebWidget()->ShowContextMenu(
2191 static_cast<blink::WebMenuSourceType>(source_type));
2192 }
2193 has_host_context_menu_location_ = false;
2194}
2195
[email protected]fa7b1dc2010-06-23 17:53:042196void RenderWidget::OnImeSetComposition(
[email protected]fcf75d42013-12-03 20:11:262197 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:112198 const std::vector<WebImeTextSpan>& ime_text_spans,
chongz7eb752802016-01-27 21:28:072199 const gfx::Range& replacement_range,
Ryan Landay9e42fd742017-08-12 01:59:112200 int selection_start,
2201 int selection_end) {
ekaramad5aff1942017-01-06 01:26:352202 if (!ShouldHandleImeEvents())
2203 return;
2204
brettw4b461082016-11-19 18:55:162205#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492206 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
Ryan Landay9e42fd742017-08-12 01:59:112207 plugin->render_frame()->OnImeSetComposition(text, ime_text_spans,
EhsanK22d482e2017-08-10 17:29:492208 selection_start, selection_end);
ekaramad2a46d632016-07-19 13:33:092209 return;
2210 }
2211#endif
[email protected]66fca5bc2013-05-23 06:58:292212 ImeEventGuard guard(this);
ekaramad2daaf672016-11-10 20:29:012213 blink::WebInputMethodController* controller = GetInputMethodController();
ekaramad2daaf672016-11-10 20:29:012214 if (!controller ||
Blink Reformat1c4d759e2017-04-09 16:34:542215 !controller->SetComposition(
Ryan Landay9e42fd742017-08-12 01:59:112216 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:562217 replacement_range.IsValid()
2218 ? WebRange(replacement_range.start(), replacement_range.length())
2219 : WebRange(),
2220 selection_start, selection_end)) {
[email protected]fa7b1dc2010-06-23 17:53:042221 // If we failed to set the composition text, then we need to let the browser
2222 // process to cancel the input method's ongoing composition session, to make
2223 // sure we are in a consistent state.
Dave Tapuska04bc5ee92018-04-17 19:03:312224 if (mojom::WidgetInputHandlerHost* host =
2225 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
2226 host->ImeCancelComposition();
Dave Tapuska139a72f2017-09-06 21:57:032227 }
[email protected]7f00efa2010-04-15 05:01:262228 }
nonafa291792016-08-10 02:36:182229 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]fa7b1dc2010-06-23 17:53:042230}
2231
rlanday7efe2302017-01-11 00:14:282232void RenderWidget::OnImeCommitText(
2233 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:112234 const std::vector<WebImeTextSpan>& ime_text_spans,
rlanday7efe2302017-01-11 00:14:282235 const gfx::Range& replacement_range,
2236 int relative_cursor_pos) {
ekaramad5aff1942017-01-06 01:26:352237 if (!ShouldHandleImeEvents())
2238 return;
2239
brettw4b461082016-11-19 18:55:162240#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492241 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
2242 plugin->render_frame()->OnImeCommitText(text, replacement_range,
2243 relative_cursor_pos);
ekaramad2a46d632016-07-19 13:33:092244 return;
2245 }
2246#endif
[email protected]66fca5bc2013-05-23 06:58:292247 ImeEventGuard guard(this);
fsamuele8326c742016-01-12 00:49:392248 input_handler_->set_handling_input_event(true);
ekaramadb6483a052017-02-10 02:23:262249 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:542250 controller->CommitText(
Ryan Landay9e42fd742017-08-12 01:59:112251 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:562252 replacement_range.IsValid()
2253 ? WebRange(replacement_range.start(), replacement_range.length())
2254 : WebRange(),
2255 relative_cursor_pos);
ekaramadb6483a052017-02-10 02:23:262256 }
aelias87b8f7c2016-09-14 03:19:292257 input_handler_->set_handling_input_event(false);
2258 UpdateCompositionInfo(false /* not an immediate request */);
2259}
2260
2261void RenderWidget::OnImeFinishComposingText(bool keep_selection) {
ekaramad5aff1942017-01-06 01:26:352262 if (!ShouldHandleImeEvents())
2263 return;
2264
brettw4b461082016-11-19 18:55:162265#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492266 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
2267 plugin->render_frame()->OnImeFinishComposingText(keep_selection);
aelias87b8f7c2016-09-14 03:19:292268 return;
2269 }
2270#endif
2271
changwan38c3eb612016-12-09 01:45:562272 if (!GetWebWidget())
aelias87b8f7c2016-09-14 03:19:292273 return;
2274 ImeEventGuard guard(this);
2275 input_handler_->set_handling_input_event(true);
ekaramad2daaf672016-11-10 20:29:012276 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:542277 controller->FinishComposingText(
2278 keep_selection ? WebInputMethodController::kKeepSelection
2279 : WebInputMethodController::kDoNotKeepSelection);
ekaramad2daaf672016-11-10 20:29:012280 }
fsamuele8326c742016-01-12 00:49:392281 input_handler_->set_handling_input_event(false);
nonafa291792016-08-10 02:36:182282 UpdateCompositionInfo(false /* not an immediate request */);
initial.commit09911bf2008-07-26 23:55:292283}
2284
Christopher Camerone9a30c12018-03-07 08:23:382285void RenderWidget::UpdateSurfaceAndScreenInfo(
Fady Samuel1c1ad3692018-11-06 23:28:402286 const viz::LocalSurfaceIdAllocation& new_local_surface_id_allocation,
W. James MacLean7df854c2019-08-28 16:17:532287 const gfx::Rect& compositor_viewport_pixel_rect,
Christopher Camerone9a30c12018-03-07 08:23:382288 const ScreenInfo& new_screen_info) {
Christopher Camerone9a30c12018-03-07 08:23:382289 bool orientation_changed =
Albert J. Wonga3dbd5442019-09-18 10:38:282290 page_properties_->GetScreenInfo().orientation_angle !=
2291 new_screen_info.orientation_angle ||
2292 page_properties_->GetScreenInfo().orientation_type !=
2293 new_screen_info.orientation_type;
Fady Samuela863f152018-03-09 16:10:032294 ScreenInfo previous_original_screen_info = GetOriginalScreenInfo();
Christopher Cameronbe7ecea2018-02-27 00:47:192295
Fady Samuel1c1ad3692018-11-06 23:28:402296 local_surface_id_allocation_from_parent_ = new_local_surface_id_allocation;
Albert J. Wonga3dbd5442019-09-18 10:38:282297
2298 page_properties_->SetScreenInfo(new_screen_info);
Christopher Cameronbe7ecea2018-02-27 00:47:192299
danakj125a29e2019-01-24 23:25:292300 // Note carefully that the DSF specified in |new_screen_info| is not the
2301 // DSF used by the compositor during device emulation!
danakj2db0b282019-09-20 15:09:202302 layer_tree_host_->SetViewportRectAndScale(
W. James MacLean7df854c2019-08-28 16:17:532303 compositor_viewport_pixel_rect,
danakj125a29e2019-01-24 23:25:292304 GetOriginalScreenInfo().device_scale_factor,
2305 local_surface_id_allocation_from_parent_);
Tao Baic7546c4b2019-09-06 15:24:572306 // The ViewportVisibleRect derives from the LayerTreeView's viewport size,
2307 // which is set above.
danakj2db0b282019-09-20 15:09:202308 layer_tree_host_->SetViewportVisibleRect(ViewportVisibleRect());
2309 layer_tree_host_->SetRasterColorSpace(
Albert J. Wonga3dbd5442019-09-18 10:38:282310 page_properties_->GetScreenInfo().color_space.GetRasterColorSpace());
Christopher Cameronbe7ecea2018-02-27 00:47:192311
Christopher Camerone9a30c12018-03-07 08:23:382312 if (orientation_changed)
2313 OnOrientationChange();
Christopher Cameronbe7ecea2018-02-27 00:47:192314
danakjcf409aa2019-09-20 15:22:302315 if (for_frame()) {
2316 // TODO(danakj): This should not need to go through RenderFrame to set
2317 // Page-level properties.
2318 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2319 // TODO(danakj): Stop sending/receiving visual properties while undead, and
2320 // change this to a DCHECK.
2321 if (frame_widget) {
2322 RenderFrameImpl* render_frame =
2323 RenderFrameImpl::FromWebFrame(frame_widget->LocalRoot());
2324 // TODO(danakj): RenderWidget knows the DSF and could avoid calling into
2325 // blink when it hasn't changed, but it sets an initial |screen_info_|
2326 // during construction, so it is hard to tell if the value is not the
2327 // default value once we get to OnSynchronizeVisualProperties. Thus we
2328 // call into blink unconditionally and let it early out if it's already
2329 // set.
2330 render_frame->SetDeviceScaleFactorOnRenderView(
2331 compositor_deps_->IsUseZoomForDSFEnabled(),
2332 page_properties_->GetDeviceScaleFactor());
2333 }
2334 }
2335
2336 // Propagate changes down to child local root RenderWidgets and BrowserPlugins
2337 // in other frame trees/processes.
Fady Samuela863f152018-03-09 16:10:032338 if (previous_original_screen_info != GetOriginalScreenInfo()) {
Erik Chenb29e60ee2019-09-19 23:50:472339 for (auto& observer : render_frame_proxies_) {
2340 if (!is_undead_)
2341 observer.OnScreenInfoChanged(GetOriginalScreenInfo());
2342 }
Christopher Camerone9a30c12018-03-07 08:23:382343 for (auto& observer : browser_plugins_)
Fady Samuela863f152018-03-09 16:10:032344 observer.ScreenInfoChanged(GetOriginalScreenInfo());
Christopher Camerone9a30c12018-03-07 08:23:382345 }
oshimad5279032015-12-16 18:22:332346}
2347
danakja2c9d0a92018-07-25 20:01:182348void RenderWidget::SetWindowRectSynchronously(
2349 const gfx::Rect& new_window_rect) {
2350 VisualProperties visual_properties;
Albert J. Wonga3dbd5442019-09-18 10:38:282351 visual_properties.screen_info = page_properties_->GetScreenInfo();
danakja2c9d0a92018-07-25 20:01:182352 visual_properties.new_size = new_window_rect.size();
W. James MacLean73742842019-09-06 18:44:492353 visual_properties.compositor_viewport_pixel_rect =
Albert J. Wonga3dbd5442019-09-18 10:38:282354 gfx::Rect(gfx::ScaleToCeiledSize(
2355 new_window_rect.size(), page_properties_->GetDeviceScaleFactor()));
danakja2c9d0a92018-07-25 20:01:182356 visual_properties.visible_viewport_size = new_window_rect.size();
2357 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
2358 visual_properties.display_mode = display_mode_;
Fady Samuel84d8a1f72018-11-08 00:26:172359 visual_properties.local_surface_id_allocation =
2360 local_surface_id_allocation_from_parent_;
danakja2c9d0a92018-07-25 20:01:182361 // We are resizing the window from the renderer, so allocate a new
2362 // viz::LocalSurfaceId to avoid surface invariants violations in tests.
danakj2db0b282019-09-20 15:09:202363 layer_tree_host_->RequestNewLocalSurfaceId();
danakja2c9d0a92018-07-25 20:01:182364 SynchronizeVisualProperties(visual_properties);
2365
Albert J. Wong3c93c182018-09-27 17:29:432366 widget_screen_rect_ = new_window_rect;
danakja2c9d0a92018-07-25 20:01:182367 window_screen_rect_ = new_window_rect;
danakj65f423b72018-10-10 17:21:202368 if (show_callback_) {
2369 // Tests may call here directly to control the window rect. If
2370 // Show() did not happen yet, the rect is stored to be passed to the
2371 // browser when the RenderWidget requests Show().
danakja2c9d0a92018-07-25 20:01:182372 initial_rect_ = new_window_rect;
danakj65f423b72018-10-10 17:21:202373 }
danakja2c9d0a92018-07-25 20:01:182374}
2375
[email protected]4873c7d2009-07-16 06:36:282376void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
EhsanK955ba582017-11-30 21:14:402377 if (auto* frame = GetFocusedWebLocalFrameInWidget())
2378 frame->SetTextDirection(direction);
[email protected]07f953332009-03-25 04:31:112379}
2380
Albert J. Wong3c93c182018-09-27 17:29:432381void RenderWidget::OnUpdateScreenRects(const gfx::Rect& widget_screen_rect,
[email protected]80ad8622012-11-07 16:33:032382 const gfx::Rect& window_screen_rect) {
Erik Chen1dd127d2019-09-21 02:33:042383 if (delegate_ && page_properties_->ScreenMetricsEmulator()) {
2384 page_properties_->ScreenMetricsEmulator()->OnUpdateScreenRects(
2385 widget_screen_rect, window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:512386 } else {
Albert J. Wong3c93c182018-09-27 17:29:432387 SetScreenRects(widget_screen_rect, window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:512388 }
Albert J. Wong3c93c182018-09-27 17:29:432389 Send(new WidgetHostMsg_UpdateScreenRects_ACK(routing_id()));
[email protected]80ad8622012-11-07 16:33:032390}
2391
kenrbea731792017-01-13 15:10:482392void RenderWidget::OnSetViewportIntersection(
Ken Buchananb2c9e262018-03-10 16:53:312393 const gfx::Rect& viewport_intersection,
Stefan Zager54e25832018-08-14 22:15:312394 const gfx::Rect& compositor_visible_rect,
Stefan Zager0926c9c2019-03-12 02:46:092395 blink::FrameOcclusionState occlusion_state) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252396 if (auto* frame_widget = GetFrameWidget()) {
Ken Buchananb2c9e262018-03-10 16:53:312397 compositor_visible_rect_ = compositor_visible_rect;
Stefan Zager54e25832018-08-14 22:15:312398 frame_widget->SetRemoteViewportIntersection(viewport_intersection,
Stefan Zager0926c9c2019-03-12 02:46:092399 occlusion_state);
danakj2db0b282019-09-20 15:09:202400 layer_tree_host_->SetViewportVisibleRect(ViewportVisibleRect());
kenrbea731792017-01-13 15:10:482401 }
2402}
2403
kenrb04323782017-06-23 01:23:322404void RenderWidget::OnSetIsInert(bool inert) {
danakj89ae4532018-12-12 22:52:552405 if (auto* frame_widget = GetFrameWidget())
Ehsan Karamadf3ca2a82018-01-20 01:05:252406 frame_widget->SetIsInert(inert);
kenrb04323782017-06-23 01:23:322407}
2408
sunxd540a9962018-05-24 22:51:062409void RenderWidget::OnSetInheritedEffectiveTouchAction(
2410 cc::TouchAction touch_action) {
danakj89ae4532018-12-12 22:52:552411 if (auto* frame_widget = GetFrameWidget())
sunxd540a9962018-05-24 22:51:062412 frame_widget->SetInheritedEffectiveTouchAction(touch_action);
sunxd540a9962018-05-24 22:51:062413}
2414
Ken Buchanan8a319fb2017-11-15 18:37:122415void RenderWidget::OnUpdateRenderThrottlingStatus(bool is_throttled,
2416 bool subtree_throttled) {
danakj89ae4532018-12-12 22:52:552417 if (auto* frame_widget = GetFrameWidget())
Ehsan Karamadf3ca2a82018-01-20 01:05:252418 frame_widget->UpdateRenderThrottlingStatus(is_throttled, subtree_throttled);
Ken Buchanan8a319fb2017-11-15 18:37:122419}
2420
paulmeyer90f6c31d2016-11-12 00:17:592421void RenderWidget::OnDragTargetDragEnter(
2422 const std::vector<DropData::Metadata>& drop_meta_data,
Ella Ge80a52dce2017-11-15 18:01:522423 const gfx::PointF& client_point,
2424 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592425 WebDragOperationsMask ops,
2426 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252427 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2428 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592429 return;
2430
Ehsan Karamadf3ca2a82018-01-20 01:05:252431 WebDragOperation operation = frame_widget->DragTargetDragEnter(
2432 DropMetaDataToWebDragData(drop_meta_data), client_point, screen_point,
2433 ops, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592434
2435 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
2436}
2437
Ella Ge80a52dce2017-11-15 18:01:522438void RenderWidget::OnDragTargetDragOver(const gfx::PointF& client_point,
2439 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592440 WebDragOperationsMask ops,
2441 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252442 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2443 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592444 return;
2445
Ehsan Karamadf3ca2a82018-01-20 01:05:252446 WebDragOperation operation = frame_widget->DragTargetDragOver(
2447 ConvertWindowPointToViewport(client_point), screen_point, ops,
2448 key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592449
2450 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
2451}
2452
Ella Ge80a52dce2017-11-15 18:01:522453void RenderWidget::OnDragTargetDragLeave(const gfx::PointF& client_point,
2454 const gfx::PointF& screen_point) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252455 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2456 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592457 return;
Ehsan Karamadf3ca2a82018-01-20 01:05:252458
2459 frame_widget
Blink Reformat1c4d759e2017-04-09 16:34:542460 ->DragTargetDragLeave(ConvertWindowPointToViewport(client_point),
kenrb07c272802017-02-07 23:48:172461 screen_point);
paulmeyer90f6c31d2016-11-12 00:17:592462}
2463
2464void RenderWidget::OnDragTargetDrop(const DropData& drop_data,
Ella Ge80a52dce2017-11-15 18:01:522465 const gfx::PointF& client_point,
2466 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592467 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252468 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2469 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592470 return;
2471
Ehsan Karamadf3ca2a82018-01-20 01:05:252472 frame_widget->DragTargetDrop(DropDataToWebDragData(drop_data),
2473 ConvertWindowPointToViewport(client_point),
2474 screen_point, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592475}
2476
Ella Ge80a52dce2017-11-15 18:01:522477void RenderWidget::OnDragSourceEnded(const gfx::PointF& client_point,
2478 const gfx::PointF& screen_point,
paulmeyer8fc8ea92016-11-15 05:12:212479 WebDragOperation op) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252480 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2481 if (!frame_widget)
paulmeyer8fc8ea92016-11-15 05:12:212482 return;
2483
Ehsan Karamadf3ca2a82018-01-20 01:05:252484 frame_widget->DragSourceEndedAt(ConvertWindowPointToViewport(client_point),
2485 screen_point, op);
paulmeyer8fc8ea92016-11-15 05:12:212486}
2487
2488void RenderWidget::OnDragSourceSystemDragEnded() {
danakj503545c2019-01-11 19:03:092489 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2490 if (!frame_widget)
paulmeyer8fc8ea92016-11-15 05:12:212491 return;
2492
danakj503545c2019-01-11 19:03:092493 frame_widget->DragSourceSystemDragEnded();
paulmeyer8fc8ea92016-11-15 05:12:212494}
2495
Blink Reformat1c4d759e2017-04-09 16:34:542496void RenderWidget::ShowVirtualKeyboardOnElementFocus() {
okaa398f50b2017-03-21 06:30:262497#if defined(OS_CHROMEOS)
2498 // On ChromeOS, virtual keyboard is triggered only when users leave the
2499 // mouse button or the finger and a text input element is focused at that
2500 // time. Focus event itself shouldn't trigger virtual keyboard.
2501 UpdateTextInputState();
2502#else
changwan75e3b2072017-01-16 02:55:002503 ShowVirtualKeyboard();
okaa398f50b2017-03-21 06:30:262504#endif
boliu7b2be2f2016-11-04 04:58:312505
2506// TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
2507// virtual keyboard.
2508#if !defined(OS_ANDROID)
2509 FocusChangeComplete();
2510#endif
[email protected]0d1ebed12013-08-05 22:01:132511}
2512
fsamuel72464894f2015-12-15 06:59:312513ui::TextInputType RenderWidget::GetTextInputType() {
brettw4b461082016-11-19 18:55:162514#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492515 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2516 return plugin->text_input_type();
ekaramad2a46d632016-07-19 13:33:092517#endif
ekaramad5aff1942017-01-06 01:26:352518 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:542519 return ConvertWebTextInputType(controller->TextInputType());
fsamuel72464894f2015-12-15 06:59:312520 return ui::TEXT_INPUT_TYPE_NONE;
2521}
2522
nonafa291792016-08-10 02:36:182523void RenderWidget::UpdateCompositionInfo(bool immediate_request) {
2524 if (!monitor_composition_info_ && !immediate_request)
2525 return; // Do not calculate composition info if not requested.
nonadac0c7a2016-08-01 02:30:592526
nonafa291792016-08-10 02:36:182527 TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo");
2528 gfx::Range range;
2529 std::vector<gfx::Rect> character_bounds;
2530
2531 if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE) {
2532 // Composition information is only available on editable node.
2533 range = gfx::Range::InvalidRange();
2534 } else {
2535 GetCompositionRange(&range);
2536 GetCompositionCharacterBounds(&character_bounds);
2537 }
2538
2539 if (!immediate_request &&
2540 !ShouldUpdateCompositionInfo(range, character_bounds)) {
fsamuel72464894f2015-12-15 06:59:312541 return;
nonafa291792016-08-10 02:36:182542 }
fsamuel72464894f2015-12-15 06:59:312543 composition_character_bounds_ = character_bounds;
2544 composition_range_ = range;
Dave Tapuska04bc5ee92018-04-17 19:03:312545 if (mojom::WidgetInputHandlerHost* host =
2546 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
2547 host->ImeCompositionRangeChanged(composition_range_,
2548 composition_character_bounds_);
Dave Tapuska139a72f2017-09-06 21:57:032549 }
fsamuel72464894f2015-12-15 06:59:312550}
2551
Blink Reformat1c4d759e2017-04-09 16:34:542552void RenderWidget::ConvertViewportToWindow(blink::WebRect* rect) {
Erik Chena65fa752019-09-21 06:59:402553 return page_properties_->ConvertViewportToWindow(rect);
oshimaf866dab2015-12-05 00:41:542554}
2555
Nicolás Peña Moreno1b3f3f912019-07-16 17:04:132556void RenderWidget::ConvertViewportToWindow(blink::WebFloatRect* rect) {
Erik Chena65fa752019-09-21 06:59:402557 return page_properties_->ConvertViewportToWindow(rect);
Nicolás Peña Moreno1b3f3f912019-07-16 17:04:132558}
2559
Blink Reformat1c4d759e2017-04-09 16:34:542560void RenderWidget::ConvertWindowToViewport(blink::WebFloatRect* rect) {
Erik Chena65fa752019-09-21 06:59:402561 return page_properties_->ConvertWindowToViewport(rect);
oshimaa6985b62016-01-27 08:58:302562}
2563
changwan8c342742016-02-26 00:53:392564void RenderWidget::OnRequestTextInputStateUpdate() {
Dave Tapuska9db80842017-07-24 17:24:262565#if defined(OS_ANDROID)
danakj125a29e2019-01-24 23:25:292566 // This task may run between the Close IPC and the task that actually closes
2567 // this class.
2568 if (closing_)
2569 return;
changwan8c342742016-02-26 00:53:392570 DCHECK(!ime_event_guard_);
2571 UpdateSelectionBounds();
changwan75e3b2072017-01-16 02:55:002572 UpdateTextInputStateInternal(false, true /* reply_to_request */);
[email protected]105dffb42013-02-20 03:46:212573#endif
Dave Tapuska9db80842017-07-24 17:24:262574}
[email protected]105dffb42013-02-20 03:46:212575
ekaramadc9b70a72017-03-23 16:14:232576void RenderWidget::OnRequestCompositionUpdates(bool immediate_request,
2577 bool monitor_updates) {
2578 monitor_composition_info_ = monitor_updates;
nonafa291792016-08-10 02:36:182579 if (!immediate_request)
2580 return;
2581 UpdateCompositionInfo(true /* immediate request */);
2582}
2583
[email protected]fcdc5642014-05-09 14:32:242584void RenderWidget::OnOrientationChange() {
Ehsan Karamad655d7b8a2018-01-12 18:38:382585 if (auto* frame_widget = GetFrameWidget()) {
Alex Moshchuk0b409c42017-09-13 02:09:002586 // LocalRoot() might return null for provisional main frames. In this case,
2587 // the frame hasn't committed a navigation and is not swapped into the tree
2588 // yet, so it doesn't make sense to send orientation change events to it.
2589 //
2590 // TODO(https://crbug.com/578349): This check should be cleaned up
2591 // once provisional frames are gone.
Ehsan Karamad655d7b8a2018-01-12 18:38:382592 if (frame_widget->LocalRoot())
2593 frame_widget->LocalRoot()->SendOrientationChangeEvent();
lfg8d649cc2017-04-28 18:04:302594 }
[email protected]fcdc5642014-05-09 14:32:242595}
2596
[email protected]bee16aab2009-08-26 15:55:032597void RenderWidget::SetHidden(bool hidden) {
danakjbd1a86a2019-09-06 17:24:312598 // An undead or provisional main frame widget will never be hidden since that
danakj1fe8e62d2019-09-05 23:21:562599 // would require it to be shown first. The main frame must be attached to the
2600 // frame tree before changing visibility.
danakjbd1a86a2019-09-06 17:24:312601 DCHECK(!is_undead_);
danakj1fe8e62d2019-09-05 23:21:562602 DCHECK(!IsForProvisionalFrame());
danakj14e00a8322019-02-07 17:12:062603
[email protected]bee16aab2009-08-26 15:55:032604 if (is_hidden_ == hidden)
2605 return;
2606
jdduke8fac9d102014-12-20 02:40:132607 // The status has changed. Tell the RenderThread about it and ensure
2608 // throttled acks are released in case frame production ceases.
[email protected]bee16aab2009-08-26 15:55:032609 is_hidden_ = hidden;
jdduke8fac9d102014-12-20 02:40:132610
Scott Violete3b1a3cb2019-05-02 16:51:522611 if (is_hidden_)
Aditya Keerthic0d45b42019-02-25 18:53:002612 first_update_visual_state_after_hidden_ = true;
alexclarke7fa93942015-10-21 15:37:112613
2614 if (render_widget_scheduling_state_)
2615 render_widget_scheduling_state_->SetHidden(hidden);
danakj1b35e9d2018-11-07 19:09:282616
David Bokanf92eaf22019-03-01 01:54:512617 // If the renderer was hidden, resolve any pending synthetic gestures so they
2618 // aren't blocked waiting for a compositor frame to be generated.
2619 if (is_hidden_)
2620 widget_input_handler_manager_->InvokeInputProcessedCallback();
2621
danakj14e00a8322019-02-07 17:12:062622 StartStopCompositor();
[email protected]bee16aab2009-08-26 15:55:032623}
2624
changwanf2a707b2015-10-30 08:22:162625void RenderWidget::OnImeEventGuardStart(ImeEventGuard* guard) {
2626 if (!ime_event_guard_)
2627 ime_event_guard_ = guard;
[email protected]66fca5bc2013-05-23 06:58:292628}
2629
changwanf2a707b2015-10-30 08:22:162630void RenderWidget::OnImeEventGuardFinish(ImeEventGuard* guard) {
Jeremy Roman0b261f42018-08-28 15:36:012631 if (ime_event_guard_ != guard)
changwanf2a707b2015-10-30 08:22:162632 return;
changwanf2a707b2015-10-30 08:22:162633 ime_event_guard_ = nullptr;
2634
[email protected]66fca5bc2013-05-23 06:58:292635 // While handling an ime event, text input state and selection bounds updates
2636 // are ignored. These must explicitly be updated once finished handling the
2637 // ime event.
2638 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:472639#if defined(OS_ANDROID)
changwan75e3b2072017-01-16 02:55:002640 if (guard->show_virtual_keyboard())
2641 ShowVirtualKeyboard();
2642 else
2643 UpdateTextInputState();
[email protected]cb9e2632013-06-18 11:26:472644#endif
[email protected]66fca5bc2013-05-23 06:58:292645}
2646
[email protected]7c8873e2013-02-05 08:03:012647void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
brettw4b461082016-11-19 18:55:162648#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492649 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
ekaramad2a46d632016-07-19 13:33:092650 // TODO(kinaba) http://crbug.com/101101
2651 // Current Pepper IME API does not handle selection bounds. So we simply
2652 // use the caret position as an empty range for now. It will be updated
2653 // after Pepper API equips features related to surrounding text retrieval.
EhsanK22d482e2017-08-10 17:29:492654 blink::WebRect caret(plugin->GetCaretBounds());
Blink Reformat1c4d759e2017-04-09 16:34:542655 ConvertViewportToWindow(&caret);
ekaramad2a46d632016-07-19 13:33:092656 *focus = caret;
2657 *anchor = caret;
2658 return;
2659 }
2660#endif
[email protected]7c8873e2013-02-05 08:03:012661 WebRect focus_webrect;
2662 WebRect anchor_webrect;
Blink Reformat1c4d759e2017-04-09 16:34:542663 GetWebWidget()->SelectionBounds(focus_webrect, anchor_webrect);
2664 ConvertViewportToWindow(&focus_webrect);
2665 ConvertViewportToWindow(&anchor_webrect);
oshima33ec97cd2015-12-14 19:40:242666 *focus = focus_webrect;
2667 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:322668}
2669
[email protected]e99ef6f2011-10-16 01:13:002670void RenderWidget::UpdateSelectionBounds() {
jdduke1aebad8e2015-07-22 23:25:082671 TRACE_EVENT0("renderer", "RenderWidget::UpdateSelectionBounds");
lfg8ff33912016-09-13 20:59:212672 if (!GetWebWidget())
[email protected]e99ef6f2011-10-16 01:13:002673 return;
changwanf2a707b2015-10-30 08:22:162674 if (ime_event_guard_)
[email protected]66fca5bc2013-05-23 06:58:292675 return;
[email protected]e99ef6f2011-10-16 01:13:002676
mohsenb0eeba72015-08-09 06:20:082677#if defined(USE_AURA)
2678 // TODO(mohsen): For now, always send explicit selection IPC notifications for
2679 // Aura beucause composited selection updates are not working for webview tags
2680 // which regresses IME inside webview. Remove this when composited selection
2681 // updates are fixed for webviews. See, http://crbug.com/510568.
2682 bool send_ipc = true;
2683#else
jddukeacf809e2014-09-23 20:38:382684 // With composited selection updates, the selection bounds will be reported
2685 // directly by the compositor, in which case explicit IPC selection
2686 // notifications should be suppressed.
mohsenb0eeba72015-08-09 06:20:082687 bool send_ipc =
Blink Reformat1c4d759e2017-04-09 16:34:542688 !blink::WebRuntimeFeatures::IsCompositedSelectionUpdateEnabled();
mohsenb0eeba72015-08-09 06:20:082689#endif
2690 if (send_ipc) {
Albert J. Wong3c93c182018-09-27 17:29:432691 WidgetHostMsg_SelectionBounds_Params params;
EhsanK955ba582017-11-30 21:14:402692 params.is_anchor_first = false;
jddukeacf809e2014-09-23 20:38:382693 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
2694 if (selection_anchor_rect_ != params.anchor_rect ||
2695 selection_focus_rect_ != params.focus_rect) {
2696 selection_anchor_rect_ = params.anchor_rect;
2697 selection_focus_rect_ = params.focus_rect;
EhsanK955ba582017-11-30 21:14:402698 if (auto* focused_frame = GetFocusedWebLocalFrameInWidget()) {
2699 focused_frame->SelectionTextDirection(params.focus_dir,
2700 params.anchor_dir);
2701 params.is_anchor_first = focused_frame->IsSelectionAnchorFirst();
2702 }
Albert J. Wong3c93c182018-09-27 17:29:432703 Send(new WidgetHostMsg_SelectionBoundsChanged(routing_id_, params));
jddukeacf809e2014-09-23 20:38:382704 }
[email protected]58b48a0d2012-06-13 07:01:352705 }
jddukeacf809e2014-09-23 20:38:382706
nonafa291792016-08-10 02:36:182707 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]e99ef6f2011-10-16 01:13:002708}
2709
lfgb00fcad2016-07-14 14:16:332710void RenderWidget::DidAutoResize(const gfx::Size& new_size) {
danakj125a29e2019-01-24 23:25:292711 // Blink can continue running and do a layout/resize between the Close IPC
2712 // and the task that actually closes this class.
2713 if (closing_)
2714 return;
2715
lfgb00fcad2016-07-14 14:16:332716 WebRect new_size_in_window(0, 0, new_size.width(), new_size.height());
Blink Reformat1c4d759e2017-04-09 16:34:542717 ConvertViewportToWindow(&new_size_in_window);
lfgb00fcad2016-07-14 14:16:332718 if (size_.width() != new_size_in_window.width ||
2719 size_.height() != new_size_in_window.height) {
2720 size_ = gfx::Size(new_size_in_window.width, new_size_in_window.height);
2721
danakj7602f4f2019-01-31 18:03:232722 if (synchronous_resize_mode_for_testing_) {
Blink Reformat1c4d759e2017-04-09 16:34:542723 gfx::Rect new_pos(WindowRect().x, WindowRect().y, size_.width(),
2724 size_.height());
Albert J. Wong3c93c182018-09-27 17:29:432725 widget_screen_rect_ = new_pos;
lfgb00fcad2016-07-14 14:16:332726 window_screen_rect_ = new_pos;
2727 }
2728
Christopher Camerone9a30c12018-03-07 08:23:382729 // TODO(ccameron): Note that this destroys any information differentiating
danakj9c4e7b812019-02-19 22:04:272730 // |size_| from the compositor's viewport size. Also note that the
W. James MacLean73742842019-09-06 18:44:492731 // calculation of |new_compositor_viewport_pixel_rect| does not appear to
Christopher Cameronaad15a0d2018-03-09 03:47:332732 // take into account device emulation.
danakj2db0b282019-09-20 15:09:202733 layer_tree_host_->RequestNewLocalSurfaceId();
Albert J. Wonga3dbd5442019-09-18 10:38:282734 gfx::Rect new_compositor_viewport_pixel_rect =
2735 gfx::Rect(gfx::ScaleToCeiledSize(
2736 size_, page_properties_->GetDeviceScaleFactor()));
Fady Samuel1c1ad3692018-11-06 23:28:402737 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
W. James MacLean73742842019-09-06 18:44:492738 new_compositor_viewport_pixel_rect,
Albert J. Wonga3dbd5442019-09-18 10:38:282739 page_properties_->GetScreenInfo());
lfgb00fcad2016-07-14 14:16:332740 }
2741}
2742
[email protected]58b48a0d2012-06-13 07:01:352743void RenderWidget::GetCompositionCharacterBounds(
2744 std::vector<gfx::Rect>* bounds) {
2745 DCHECK(bounds);
2746 bounds->clear();
ekaramad2a46d632016-07-19 13:33:092747
brettw4b461082016-11-19 18:55:162748#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492749 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092750 return;
2751#endif
2752
Ehsan Karamad4975af6d2018-02-09 16:58:162753 blink::WebInputMethodController* controller = GetInputMethodController();
2754 if (!controller)
ekaramad2a46d632016-07-19 13:33:092755 return;
2756 blink::WebVector<blink::WebRect> bounds_from_blink;
Ehsan Karamad4975af6d2018-02-09 16:58:162757 if (!controller->GetCompositionCharacterBounds(bounds_from_blink))
ekaramad2a46d632016-07-19 13:33:092758 return;
2759
2760 for (size_t i = 0; i < bounds_from_blink.size(); ++i) {
Blink Reformat1c4d759e2017-04-09 16:34:542761 ConvertViewportToWindow(&bounds_from_blink[i]);
ekaramad2a46d632016-07-19 13:33:092762 bounds->push_back(bounds_from_blink[i]);
2763 }
[email protected]58b48a0d2012-06-13 07:01:352764}
2765
[email protected]db4fc1e2013-09-06 20:01:512766void RenderWidget::GetCompositionRange(gfx::Range* range) {
brettw4b461082016-11-19 18:55:162767#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492768 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092769 return;
2770#endif
EhsanKcdee7b72017-11-08 21:30:092771 blink::WebInputMethodController* controller = GetInputMethodController();
2772 WebRange web_range = controller ? controller->CompositionRange() : WebRange();
Blink Reformat1c4d759e2017-04-09 16:34:542773 if (web_range.IsNull()) {
nona2363a3d2016-11-09 03:26:212774 *range = gfx::Range::InvalidRange();
2775 return;
[email protected]88dbe32f2013-06-20 23:31:362776 }
Blink Reformat1c4d759e2017-04-09 16:34:542777 range->set_start(web_range.StartOffset());
2778 range->set_end(web_range.EndOffset());
[email protected]88dbe32f2013-06-20 23:31:362779}
2780
[email protected]501ea13d2013-07-09 17:03:292781bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:512782 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:292783 const std::vector<gfx::Rect>& bounds) {
changwan2418e1b2016-12-12 12:43:082784 if (!range.IsValid())
2785 return false;
[email protected]501ea13d2013-07-09 17:03:292786 if (composition_range_ != range)
2787 return true;
2788 if (bounds.size() != composition_character_bounds_.size())
2789 return true;
2790 for (size_t i = 0; i < bounds.size(); ++i) {
2791 if (bounds[i] != composition_character_bounds_[i])
2792 return true;
2793 }
2794 return false;
2795}
[email protected]501ea13d2013-07-09 17:03:292796
[email protected]ad26ef42011-06-17 07:59:452797bool RenderWidget::CanComposeInline() {
brettw4b461082016-11-19 18:55:162798#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492799 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2800 return plugin->IsPluginAcceptingCompositionEvents();
ekaramad2a46d632016-07-19 13:33:092801#endif
[email protected]ad26ef42011-06-17 07:59:452802 return true;
[email protected]56ea1a62011-05-30 07:05:572803}
2804
Blink Reformat1c4d759e2017-04-09 16:34:542805void RenderWidget::DidHandleGestureEvent(const WebGestureEvent& event,
2806 bool event_cancelled) {
danakja2c9d0a92018-07-25 20:01:182807 if (event_cancelled) {
Albert J. Wong7bbf22d2018-12-20 00:27:272808 // The delegate() doesn't need to hear about cancelled events.
[email protected]c68c3e4e2013-01-24 00:36:562809 return;
danakja2c9d0a92018-07-25 20:01:182810 }
2811
2812#if defined(OS_ANDROID) || defined(USE_AURA)
Blink Reformat1c4d759e2017-04-09 16:34:542813 if (event.GetType() == WebInputEvent::kGestureTap) {
changwan75e3b2072017-01-16 02:55:002814 ShowVirtualKeyboard();
Blink Reformat1c4d759e2017-04-09 16:34:542815 } else if (event.GetType() == WebInputEvent::kGestureLongPress) {
lfg8ff33912016-09-13 20:59:212816 DCHECK(GetWebWidget());
ekaramad5aff1942017-01-06 01:26:352817 blink::WebInputMethodController* controller = GetInputMethodController();
Blink Reformat1c4d759e2017-04-09 16:34:542818 if (!controller || controller->TextInputInfo().value.IsEmpty())
changwan75e3b2072017-01-16 02:55:002819 UpdateTextInputState();
[email protected]07c70d22014-08-21 08:33:462820 else
changwan75e3b2072017-01-16 02:55:002821 ShowVirtualKeyboard();
[email protected]c68c3e4e2013-01-24 00:36:562822 }
ekaramada110f642016-12-21 19:47:282823// TODO(ananta): Piggyback off existing IPCs to communicate this information,
2824// crbug/420130.
2825#if defined(OS_WIN)
danakja2c9d0a92018-07-25 20:01:182826 if (event.GetType() == blink::WebGestureEvent::kGestureTap) {
2827 // TODO(estade): hit test the event against focused node to make sure
2828 // the tap actually hit the focused node.
2829 blink::WebInputMethodController* controller = GetInputMethodController();
2830 blink::WebTextInputType text_input_type =
2831 controller ? controller->TextInputType() : blink::kWebTextInputTypeNone;
ekaramada110f642016-12-21 19:47:282832
Albert J. Wong3c93c182018-09-27 17:29:432833 Send(new WidgetHostMsg_FocusedNodeTouched(
danakja2c9d0a92018-07-25 20:01:182834 routing_id_, text_input_type != blink::kWebTextInputTypeNone));
2835 }
ekaramada110f642016-12-21 19:47:282836#endif
[email protected]c68c3e4e2013-01-24 00:36:562837#endif
2838}
2839
Blink Reformat1c4d759e2017-04-09 16:34:542840void RenderWidget::DidOverscroll(
danakj1b05cf22019-04-12 23:47:052841 const blink::WebFloatSize& overscroll_delta,
2842 const blink::WebFloatSize& accumulated_overscroll,
sataya.m582c9ce2015-06-09 08:03:422843 const blink::WebFloatPoint& position,
danakj1b05cf22019-04-12 23:47:052844 const blink::WebFloatSize& velocity) {
bokan731ec382016-04-07 03:16:482845#if defined(OS_MACOSX)
2846 // On OSX the user can disable the elastic overscroll effect. If that's the
2847 // case, don't forward the overscroll notification.
2848 DCHECK(compositor_deps());
2849 if (!compositor_deps()->IsElasticOverscrollEnabled())
2850 return;
2851#endif
danakj1b05cf22019-04-12 23:47:052852 input_handler_->DidOverscrollFromBlink(
2853 overscroll_delta, accumulated_overscroll, position, velocity,
danakj2db0b282019-09-20 15:09:202854 layer_tree_host_->overscroll_behavior());
danakj1b05cf22019-04-12 23:47:052855}
2856
Daniel Libby688fcb52019-05-25 01:08:472857void RenderWidget::InjectGestureScrollEvent(
2858 blink::WebGestureDevice device,
2859 const blink::WebFloatSize& delta,
2860 ui::input_types::ScrollGranularity granularity,
2861 cc::ElementId scrollable_area_element_id,
2862 blink::WebInputEvent::Type injected_type) {
2863 input_handler_->InjectGestureScrollEvent(
2864 device, delta, granularity, scrollable_area_element_id, injected_type);
2865}
2866
danakj1b05cf22019-04-12 23:47:052867void RenderWidget::SetOverscrollBehavior(
2868 const cc::OverscrollBehavior& behavior) {
danakj2db0b282019-09-20 15:09:202869 layer_tree_host_->SetOverscrollBehavior(behavior);
sataya.m582c9ce2015-06-09 08:03:422870}
2871
danakj4b347212018-07-04 17:55:172872// static
2873cc::LayerTreeSettings RenderWidget::GenerateLayerTreeSettings(
2874 CompositorDependencies* compositor_deps,
2875 bool is_for_subframe,
2876 const gfx::Size& initial_screen_size,
2877 float initial_device_scale_factor) {
2878 const bool is_threaded =
2879 !!compositor_deps->GetCompositorImplThreadTaskRunner();
2880
2881 const base::CommandLine& cmd = *base::CommandLine::ForCurrentProcess();
2882 cc::LayerTreeSettings settings;
2883
Rahul Arakerie510b8c2019-04-01 21:17:542884 settings.compositor_threaded_scrollbar_scrolling =
2885 base::FeatureList::IsEnabled(
2886 features::kCompositorThreadedScrollbarScrolling);
2887
danakj4b347212018-07-04 17:55:172888 settings.resource_settings.use_r16_texture =
2889 base::FeatureList::IsEnabled(media::kUseR16Texture);
2890
2891 settings.commit_to_active_tree = !is_threaded;
2892 settings.is_layer_tree_for_subframe = is_for_subframe;
2893
danakj4b347212018-07-04 17:55:172894 settings.main_frame_before_activation_enabled =
2895 cmd.HasSwitch(cc::switches::kEnableMainFrameBeforeActivation);
2896
2897 // Checkerimaging is not supported for synchronous single-threaded mode, which
2898 // is what the renderer uses if its not threaded.
2899 settings.enable_checker_imaging =
2900 !cmd.HasSwitch(cc::switches::kDisableCheckerImaging) && is_threaded;
2901
2902#if defined(OS_ANDROID)
2903 // We can use a more aggressive limit on Android since decodes tend to take
2904 // longer on these devices.
2905 settings.min_image_bytes_to_checker = 512 * 1024; // 512kB
2906
2907 // Re-rasterization of checker-imaged content with software raster can be too
2908 // costly on Android.
2909 settings.only_checker_images_with_gpu_raster = true;
2910#endif
2911
2912 auto switch_value_as_int = [](const base::CommandLine& command_line,
2913 const std::string& switch_string, int min_value,
2914 int max_value, int* result) {
2915 std::string string_value = command_line.GetSwitchValueASCII(switch_string);
2916 int int_value;
2917 if (base::StringToInt(string_value, &int_value) && int_value >= min_value &&
2918 int_value <= max_value) {
2919 *result = int_value;
2920 return true;
2921 } else {
danakjda15621e2019-04-05 20:34:432922 DLOG(WARNING) << "Failed to parse switch " << switch_string << ": "
2923 << string_value;
danakj4b347212018-07-04 17:55:172924 return false;
2925 }
2926 };
2927
2928 int default_tile_size = 256;
2929#if defined(OS_ANDROID)
2930 const gfx::Size screen_size =
2931 gfx::ScaleToFlooredSize(initial_screen_size, initial_device_scale_factor);
2932 int display_width = screen_size.width();
2933 int display_height = screen_size.height();
2934 int numTiles = (display_width * display_height) / (256 * 256);
2935 if (numTiles > 16)
2936 default_tile_size = 384;
2937 if (numTiles >= 40)
2938 default_tile_size = 512;
2939
2940 // Adjust for some resolutions that barely straddle an extra
2941 // tile when in portrait mode. This helps worst case scroll/raster
2942 // by not needing a full extra tile for each row.
2943 constexpr int tolerance = 10; // To avoid rounding errors.
2944 int portrait_width = std::min(display_width, display_height);
2945 if (default_tile_size == 256 && std::abs(portrait_width - 768) < tolerance)
2946 default_tile_size += 32;
2947 if (default_tile_size == 384 && std::abs(portrait_width - 1200) < tolerance)
2948 default_tile_size += 32;
2949#elif defined(OS_CHROMEOS) || defined(OS_MACOSX)
2950 // Use 512 for high DPI (dsf=2.0f) devices.
2951 if (initial_device_scale_factor >= 2.0f)
2952 default_tile_size = 512;
2953#endif
2954
2955 // TODO(danakj): This should not be a setting O_O; it should change when the
2956 // device scale factor on LayerTreeHost changes.
2957 settings.default_tile_size = gfx::Size(default_tile_size, default_tile_size);
2958 if (cmd.HasSwitch(switches::kDefaultTileWidth)) {
2959 int tile_width = 0;
2960 switch_value_as_int(cmd, switches::kDefaultTileWidth, 1,
2961 std::numeric_limits<int>::max(), &tile_width);
2962 settings.default_tile_size.set_width(tile_width);
2963 }
2964 if (cmd.HasSwitch(switches::kDefaultTileHeight)) {
2965 int tile_height = 0;
2966 switch_value_as_int(cmd, switches::kDefaultTileHeight, 1,
2967 std::numeric_limits<int>::max(), &tile_height);
2968 settings.default_tile_size.set_height(tile_height);
2969 }
2970
2971 int max_untiled_layer_width = settings.max_untiled_layer_size.width();
2972 if (cmd.HasSwitch(switches::kMaxUntiledLayerWidth)) {
2973 switch_value_as_int(cmd, switches::kMaxUntiledLayerWidth, 1,
2974 std::numeric_limits<int>::max(),
2975 &max_untiled_layer_width);
2976 }
2977 int max_untiled_layer_height = settings.max_untiled_layer_size.height();
2978 if (cmd.HasSwitch(switches::kMaxUntiledLayerHeight)) {
2979 switch_value_as_int(cmd, switches::kMaxUntiledLayerHeight, 1,
2980 std::numeric_limits<int>::max(),
2981 &max_untiled_layer_height);
2982 }
2983
2984 settings.max_untiled_layer_size =
2985 gfx::Size(max_untiled_layer_width, max_untiled_layer_height);
2986
2987 settings.gpu_rasterization_msaa_sample_count =
2988 compositor_deps->GetGpuRasterizationMSAASampleCount();
2989 settings.gpu_rasterization_forced =
2990 compositor_deps->IsGpuRasterizationForced();
2991
2992 settings.can_use_lcd_text = compositor_deps->IsLcdTextEnabled();
2993 settings.use_zero_copy = compositor_deps->IsZeroCopyEnabled();
2994 settings.use_partial_raster = compositor_deps->IsPartialRasterEnabled();
2995 settings.enable_elastic_overscroll =
2996 compositor_deps->IsElasticOverscrollEnabled();
2997 settings.resource_settings.use_gpu_memory_buffer_resources =
2998 compositor_deps->IsGpuMemoryBufferCompositorResourcesEnabled();
2999 settings.use_painted_device_scale_factor =
3000 compositor_deps->IsUseZoomForDSFEnabled();
3001
3002 // Build LayerTreeSettings from command line args.
3003 if (cmd.HasSwitch(cc::switches::kBrowserControlsShowThreshold)) {
3004 std::string top_threshold_str =
3005 cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsShowThreshold);
3006 double show_threshold;
3007 if (base::StringToDouble(top_threshold_str, &show_threshold) &&
3008 show_threshold >= 0.f && show_threshold <= 1.f)
3009 settings.top_controls_show_threshold = show_threshold;
3010 }
3011
3012 if (cmd.HasSwitch(cc::switches::kBrowserControlsHideThreshold)) {
3013 std::string top_threshold_str =
3014 cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsHideThreshold);
3015 double hide_threshold;
3016 if (base::StringToDouble(top_threshold_str, &hide_threshold) &&
3017 hide_threshold >= 0.f && hide_threshold <= 1.f)
3018 settings.top_controls_hide_threshold = hide_threshold;
3019 }
3020
Philip Rogers848424a2019-08-14 18:19:593021 // Blink sends cc a layer list and property trees.
3022 settings.use_layer_lists = true;
danakj4b347212018-07-04 17:55:173023
David Bokan163b6a72018-10-25 22:03:493024 // Blink currently doesn't support setting fractional scroll offsets so CC
3025 // must send integer values. We plan to eventually make Blink use fractional
3026 // offsets internally: https://crbug.com/414283.
3027 settings.commit_fractional_scroll_deltas =
3028 blink::WebRuntimeFeatures::IsFractionalScrollOffsetsEnabled();
3029
danakj4b347212018-07-04 17:55:173030 // The means the renderer compositor has 2 possible modes:
3031 // - Threaded compositing with a scheduler.
Kent Tamura21d1de62018-12-10 04:45:203032 // - Single threaded compositing without a scheduler (for web tests only).
3033 // Using the scheduler in web tests introduces additional composite steps
danakj4b347212018-07-04 17:55:173034 // that create flakiness.
3035 settings.single_thread_proxy_scheduler = false;
3036
3037 // These flags should be mirrored by UI versions in ui/compositor/.
3038 if (cmd.HasSwitch(cc::switches::kShowCompositedLayerBorders))
3039 settings.initial_debug_state.show_debug_borders.set();
3040 settings.initial_debug_state.show_layer_animation_bounds_rects =
3041 cmd.HasSwitch(cc::switches::kShowLayerAnimationBounds);
3042 settings.initial_debug_state.show_paint_rects =
3043 cmd.HasSwitch(switches::kShowPaintRects);
rnasri2e621942019-05-14 21:24:253044 settings.initial_debug_state.show_layout_shift_regions =
3045 cmd.HasSwitch(switches::kShowLayoutShiftRegions);
danakj4b347212018-07-04 17:55:173046 settings.initial_debug_state.show_property_changed_rects =
3047 cmd.HasSwitch(cc::switches::kShowPropertyChangedRects);
3048 settings.initial_debug_state.show_surface_damage_rects =
3049 cmd.HasSwitch(cc::switches::kShowSurfaceDamageRects);
3050 settings.initial_debug_state.show_screen_space_rects =
3051 cmd.HasSwitch(cc::switches::kShowScreenSpaceRects);
3052
3053 settings.initial_debug_state.SetRecordRenderingStats(
3054 cmd.HasSwitch(cc::switches::kEnableGpuBenchmarking));
kylechara352d2d12019-08-15 19:11:413055 settings.enable_surface_synchronization = true;
danakj4b347212018-07-04 17:55:173056 settings.build_hit_test_data = features::IsVizHitTestingSurfaceLayerEnabled();
3057
3058 if (cmd.HasSwitch(cc::switches::kSlowDownRasterScaleFactor)) {
3059 const int kMinSlowDownScaleFactor = 0;
3060 const int kMaxSlowDownScaleFactor = INT_MAX;
3061 switch_value_as_int(
3062 cmd, cc::switches::kSlowDownRasterScaleFactor, kMinSlowDownScaleFactor,
3063 kMaxSlowDownScaleFactor,
3064 &settings.initial_debug_state.slow_down_raster_scale_factor);
3065 }
3066
3067 // This is default overlay scrollbar settings for Android and DevTools mobile
3068 // emulator. Aura Overlay Scrollbar will override below.
3069 settings.scrollbar_animator = cc::LayerTreeSettings::ANDROID_OVERLAY;
3070 settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
3071 settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(300);
3072 settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(300);
3073
Daniel Libby43972d82019-02-28 21:35:363074 if (cmd.HasSwitch(cc::switches::kCCScrollAnimationDurationForTesting)) {
3075 const int kMinScrollAnimationDuration = 0;
3076 const int kMaxScrollAnimationDuration = INT_MAX;
3077 int duration;
3078 if (switch_value_as_int(cmd,
3079 cc::switches::kCCScrollAnimationDurationForTesting,
3080 kMinScrollAnimationDuration,
3081 kMaxScrollAnimationDuration, &duration)) {
3082 settings.scroll_animation_duration_for_testing =
3083 base::TimeDelta::FromSeconds(duration);
3084 }
3085 }
3086
danakj4b347212018-07-04 17:55:173087#if defined(OS_ANDROID)
3088 bool using_synchronous_compositor =
3089 compositor_deps->UsingSynchronousCompositing();
Ian Vollick7a847a82019-06-14 19:58:593090 bool using_low_memory_policy =
3091 base::SysInfo::IsLowEndDevice() && !IsSmallScreen(screen_size);
danakj4b347212018-07-04 17:55:173092
3093 settings.use_stream_video_draw_quad = true;
3094 settings.using_synchronous_renderer_compositor = using_synchronous_compositor;
3095 if (using_synchronous_compositor) {
3096 // Android WebView uses system scrollbars, so make ours invisible.
3097 // http://crbug.com/677348: This can't be done using hide_scrollbars
3098 // setting because supporting -webkit custom scrollbars is still desired
3099 // on sublayers.
3100 settings.scrollbar_animator = cc::LayerTreeSettings::NO_ANIMATOR;
3101 settings.solid_color_scrollbar_color = SK_ColorTRANSPARENT;
3102
3103 settings.enable_early_damage_check =
3104 cmd.HasSwitch(cc::switches::kCheckDamageEarly);
3105 }
3106 // Android WebView handles root layer flings itself.
3107 settings.ignore_root_layer_flings = using_synchronous_compositor;
3108 // Memory policy on Android WebView does not depend on whether device is
3109 // low end, so always use default policy.
3110 if (using_low_memory_policy && !using_synchronous_compositor) {
3111 // On low-end we want to be very carefull about killing other
3112 // apps. So initially we use 50% more memory to avoid flickering
3113 // or raster-on-demand.
3114 settings.max_memory_for_prepaint_percentage = 67;
3115 } else {
3116 // On other devices we have increased memory excessively to avoid
3117 // raster-on-demand already, so now we reserve 50% _only_ to avoid
3118 // raster-on-demand, and use 50% of the memory otherwise.
3119 settings.max_memory_for_prepaint_percentage = 50;
3120 }
3121
3122 // TODO(danakj): Only do this on low end devices.
3123 settings.create_low_res_tiling = true;
3124
3125#else // defined(OS_ANDROID)
3126 bool using_synchronous_compositor = false; // Only for Android WebView.
3127 // On desktop, we never use the low memory policy unless we are simulating
3128 // low-end mode via a switch.
3129 bool using_low_memory_policy =
3130 cmd.HasSwitch(switches::kEnableLowEndDeviceMode);
3131
3132 if (ui::IsOverlayScrollbarEnabled()) {
3133 settings.scrollbar_animator = cc::LayerTreeSettings::AURA_OVERLAY;
3134 settings.scrollbar_fade_delay = ui::kOverlayScrollbarFadeDelay;
3135 settings.scrollbar_fade_duration = ui::kOverlayScrollbarFadeDuration;
3136 settings.scrollbar_thinning_duration =
3137 ui::kOverlayScrollbarThinningDuration;
3138 settings.scrollbar_flash_after_any_scroll_update =
3139 ui::OverlayScrollbarFlashAfterAnyScrollUpdate();
3140 settings.scrollbar_flash_when_mouse_enter =
3141 ui::OverlayScrollbarFlashWhenMouseEnter();
3142 }
3143
3144 // On desktop, if there's over 4GB of memory on the machine, increase the
3145 // working set size to 256MB for both gpu and software.
3146 const int kImageDecodeMemoryThresholdMB = 4 * 1024;
3147 if (base::SysInfo::AmountOfPhysicalMemoryMB() >=
3148 kImageDecodeMemoryThresholdMB) {
3149 settings.decoded_image_working_set_budget_bytes = 256 * 1024 * 1024;
3150 } else {
3151 // This is the default, but recorded here as well.
3152 settings.decoded_image_working_set_budget_bytes = 128 * 1024 * 1024;
3153 }
3154#endif // defined(OS_ANDROID)
3155
3156 if (using_low_memory_policy) {
3157 // RGBA_4444 textures are only enabled:
3158 // - If the user hasn't explicitly disabled them
3159 // - If system ram is <= 512MB (1GB devices are sometimes low-end).
3160 // - If we are not running in a WebView, where 4444 isn't supported.
3161 if (!cmd.HasSwitch(switches::kDisableRGBA4444Textures) &&
3162 base::SysInfo::AmountOfPhysicalMemoryMB() <= 512 &&
3163 !using_synchronous_compositor) {
3164 settings.use_rgba_4444 = viz::RGBA_4444;
3165
3166 // If we are going to unpremultiply and dither these tiles, we need to
3167 // allocate an additional RGBA_8888 intermediate for each tile
3168 // rasterization when rastering to RGBA_4444 to allow for dithering.
3169 // Setting a reasonable sized max tile size allows this intermediate to
3170 // be consistently reused.
3171 if (base::FeatureList::IsEnabled(
3172 kUnpremultiplyAndDitherLowBitDepthTiles)) {
3173 settings.max_gpu_raster_tile_size = gfx::Size(512, 256);
3174 settings.unpremultiply_and_dither_low_bit_depth_tiles = true;
3175 }
3176 }
3177 }
3178
3179 if (cmd.HasSwitch(switches::kEnableLowResTiling))
3180 settings.create_low_res_tiling = true;
3181 if (cmd.HasSwitch(switches::kDisableLowResTiling))
3182 settings.create_low_res_tiling = false;
3183
3184 if (cmd.HasSwitch(switches::kEnableRGBA4444Textures) &&
3185 !cmd.HasSwitch(switches::kDisableRGBA4444Textures)) {
3186 settings.use_rgba_4444 = true;
3187 }
3188
3189 settings.max_staging_buffer_usage_in_bytes = 32 * 1024 * 1024; // 32MB
3190 // Use 1/4th of staging buffers on low-end devices.
3191 if (base::SysInfo::IsLowEndDevice())
3192 settings.max_staging_buffer_usage_in_bytes /= 4;
3193
3194 cc::ManagedMemoryPolicy defaults = settings.memory_policy;
3195 settings.memory_policy = GetGpuMemoryPolicy(defaults, initial_screen_size,
3196 initial_device_scale_factor);
3197
3198 settings.disallow_non_exact_resource_reuse =
3199 cmd.HasSwitch(switches::kDisallowNonExactResourceReuse);
3200#if defined(OS_ANDROID)
3201 // TODO(crbug.com/746931): This feature appears to be causing visual
3202 // corruption on certain android devices. Will investigate and re-enable.
3203 settings.disallow_non_exact_resource_reuse = true;
3204#endif
3205
3206 if (cmd.HasSwitch(switches::kRunAllCompositorStagesBeforeDraw)) {
3207 settings.wait_for_all_pipeline_stages_before_draw = true;
3208 settings.enable_latency_recovery = false;
3209 }
Eric Karl1e6ffca2019-02-23 22:08:503210#if defined(OS_ANDROID)
kylechara352d2d12019-08-15 19:11:413211 // TODO(crbug.com/933846): LatencyRecovery is causing jank on Android. Disable
3212 // in viz mode for now, with plan to disable more widely once viz launches.
3213 settings.enable_latency_recovery = false;
Eric Karl1e6ffca2019-02-23 22:08:503214#endif
danakj4b347212018-07-04 17:55:173215
3216 settings.enable_image_animation_resync =
3217 !cmd.HasSwitch(switches::kDisableImageAnimationResync);
3218
Karolina Soltys4d60b402018-10-01 19:28:203219 settings.send_compositor_frame_ack = false;
3220
Eric Karlfc977f72019-09-19 16:59:553221 // Renderer can de-jelly, browser UI can not. We do not know whether we are
3222 // going to apply de-jelly until we draw a frame in the Viz process. Because
3223 // of this, all changes in the renderer are based on whether de-jelly may be
3224 // active (viz::DeJellyEnabled) vs whether it is currently active
3225 // (viz::DeJellyActive).
3226 settings.allow_de_jelly_effect = viz::DeJellyEnabled();
3227 // Disable occlusion if de-jelly effect is enabled.
3228 settings.enable_occlusion &= !settings.allow_de_jelly_effect;
3229
danakj4b347212018-07-04 17:55:173230 return settings;
3231}
3232
3233// static
3234cc::ManagedMemoryPolicy RenderWidget::GetGpuMemoryPolicy(
3235 const cc::ManagedMemoryPolicy& default_policy,
3236 const gfx::Size& initial_screen_size,
3237 float initial_device_scale_factor) {
3238 cc::ManagedMemoryPolicy actual = default_policy;
3239 actual.bytes_limit_when_visible = 0;
3240
3241 // If the value was overridden on the command line, use the specified value.
3242 static bool client_hard_limit_bytes_overridden =
3243 base::CommandLine::ForCurrentProcess()->HasSwitch(
3244 switches::kForceGpuMemAvailableMb);
3245 if (client_hard_limit_bytes_overridden) {
3246 if (base::StringToSizeT(
3247 base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
3248 switches::kForceGpuMemAvailableMb),
3249 &actual.bytes_limit_when_visible))
3250 actual.bytes_limit_when_visible *= 1024 * 1024;
3251 return actual;
3252 }
3253
3254#if defined(OS_ANDROID)
3255 // We can't query available GPU memory from the system on Android.
3256 // Physical memory is also mis-reported sometimes (eg. Nexus 10 reports
3257 // 1262MB when it actually has 2GB, while Razr M has 1GB but only reports
3258 // 128MB java heap size). First we estimate physical memory using both.
3259 size_t dalvik_mb = base::SysInfo::DalvikHeapSizeMB();
3260 size_t physical_mb = base::SysInfo::AmountOfPhysicalMemoryMB();
3261 size_t physical_memory_mb = 0;
3262 if (base::SysInfo::IsLowEndDevice()) {
3263 // TODO(crbug.com/742534): The code below appears to no longer work.
3264 // |dalvik_mb| no longer follows the expected heuristic pattern, causing us
3265 // to over-estimate memory on low-end devices. This entire section probably
3266 // needs to be re-written, but for now we can address the low-end Android
3267 // issues by ignoring |dalvik_mb|.
3268 physical_memory_mb = physical_mb;
3269 } else if (dalvik_mb >= 256) {
3270 physical_memory_mb = dalvik_mb * 4;
3271 } else {
3272 physical_memory_mb = std::max(dalvik_mb * 4, (physical_mb * 4) / 3);
3273 }
3274
3275 // Now we take a default of 1/8th of memory on high-memory devices,
3276 // and gradually scale that back for low-memory devices (to be nicer
3277 // to other apps so they don't get killed). Examples:
3278 // Nexus 4/10(2GB) 256MB (normally 128MB)
3279 // Droid Razr M(1GB) 114MB (normally 57MB)
3280 // Galaxy Nexus(1GB) 100MB (normally 50MB)
3281 // Xoom(1GB) 100MB (normally 50MB)
3282 // Nexus S(low-end) 8MB (normally 8MB)
3283 // Note that the compositor now uses only some of this memory for
3284 // pre-painting and uses the rest only for 'emergencies'.
3285 if (actual.bytes_limit_when_visible == 0) {
3286 // NOTE: Non-low-end devices use only 50% of these limits,
3287 // except during 'emergencies' where 100% can be used.
3288 if (physical_memory_mb >= 1536)
3289 actual.bytes_limit_when_visible = physical_memory_mb / 8; // >192MB
3290 else if (physical_memory_mb >= 1152)
3291 actual.bytes_limit_when_visible = physical_memory_mb / 8; // >144MB
3292 else if (physical_memory_mb >= 768)
3293 actual.bytes_limit_when_visible = physical_memory_mb / 10; // >76MB
3294 else if (physical_memory_mb >= 513)
3295 actual.bytes_limit_when_visible = physical_memory_mb / 12; // <64MB
3296 else
3297 // Devices with this little RAM have very little headroom so we hardcode
3298 // the limit rather than relying on the heuristics above. (They also use
3299 // 4444 textures so we can use a lower limit.)
3300 actual.bytes_limit_when_visible = 8;
3301
3302 actual.bytes_limit_when_visible =
3303 actual.bytes_limit_when_visible * 1024 * 1024;
3304 // Clamp the observed value to a specific range on Android.
3305 actual.bytes_limit_when_visible = std::max(
3306 actual.bytes_limit_when_visible, static_cast<size_t>(8 * 1024 * 1024));
3307 actual.bytes_limit_when_visible =
3308 std::min(actual.bytes_limit_when_visible,
3309 static_cast<size_t>(256 * 1024 * 1024));
3310 }
3311 actual.priority_cutoff_when_visible =
3312 gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING;
3313#else
3314 // Ignore what the system said and give all clients the same maximum
3315 // allocation on desktop platforms.
3316 actual.bytes_limit_when_visible = 512 * 1024 * 1024;
3317 actual.priority_cutoff_when_visible =
3318 gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
3319
3320 // For large monitors (4k), double the tile memory to avoid frequent out of
3321 // memory problems. 4k could mean a screen width of anywhere from 3840 to 4096
3322 // (see https://en.wikipedia.org/wiki/4K_resolution). We use 3500 as a proxy
3323 // for "large enough".
3324 static const int kLargeDisplayThreshold = 3500;
3325 int display_width =
3326 std::round(initial_screen_size.width() * initial_device_scale_factor);
3327 if (display_width >= kLargeDisplayThreshold)
3328 actual.bytes_limit_when_visible *= 2;
3329#endif
3330 return actual;
3331}
3332
danakj2e87fd82019-07-05 16:42:293333void RenderWidget::SetHasPointerRawUpdateEventHandlers(bool has_handlers) {
Navid Zolghadr8fdb6114e2018-08-29 19:00:543334 if (input_event_queue_)
Navid Zolghadr4ed3ae42019-05-03 17:02:123335 input_event_queue_->HasPointerRawUpdateEventHandlers(has_handlers);
Navid Zolghadr8fdb6114e2018-08-29 19:00:543336}
3337
danakj2e87fd82019-07-05 16:42:293338void RenderWidget::SetHasTouchEventHandlers(bool has_handlers) {
W. James MacLean662d5382018-03-29 18:33:083339 if (has_touch_handlers_ && *has_touch_handlers_ == has_handlers)
3340 return;
3341
3342 has_touch_handlers_ = has_handlers;
alexclarke7fa93942015-10-21 15:37:113343 if (render_widget_scheduling_state_)
3344 render_widget_scheduling_state_->SetHasTouchHandler(has_handlers);
Albert J. Wongeb28e7e2018-10-12 00:57:433345 Send(new WidgetHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
[email protected]ce6689f2013-03-29 12:52:553346}
3347
danakj4645c022019-07-23 18:15:263348void RenderWidget::SetHaveScrollEventHandlers(bool have_handlers) {
danakj2db0b282019-09-20 15:09:203349 layer_tree_host_->SetHaveScrollEventHandlers(have_handlers);
danakj4645c022019-07-23 18:15:263350}
3351
Dave Tapuskadfe486c12017-06-09 16:53:133352void RenderWidget::SetNeedsLowLatencyInput(bool needs_low_latency) {
3353 if (input_event_queue_)
3354 input_event_queue_->SetNeedsLowLatency(needs_low_latency);
3355}
3356
Pavel Feldman6708eefa2019-01-17 03:14:323357void RenderWidget::SetNeedsUnbufferedInputForDebugger(bool unbuffered) {
3358 if (input_event_queue_)
3359 input_event_queue_->SetNeedsUnbufferedInputForDebugger(unbuffered);
3360}
3361
W. James MacLeand973a55b2018-11-29 21:39:133362void RenderWidget::AnimateDoubleTapZoomInMainFrame(
3363 const blink::WebPoint& point,
3364 const blink::WebRect& rect_to_zoom) {
3365 // Only oopif subframes should be sending this message.
Albert J. Wong7bbf22d2018-12-20 00:27:273366 DCHECK(!delegate());
W. James MacLeand973a55b2018-11-29 21:39:133367 Send(new WidgetHostMsg_AnimateDoubleTapZoomInMainFrame(routing_id(), point,
3368 rect_to_zoom));
3369}
3370
W. James MacLean5372eb72018-12-19 12:56:363371void RenderWidget::ZoomToFindInPageRectInMainFrame(
3372 const blink::WebRect& rect_to_zoom) {
3373 // Only oopif subframes should be sending this message.
Albert J. Wong7bbf22d2018-12-20 00:27:273374 DCHECK(!delegate_);
W. James MacLean5372eb72018-12-19 12:56:363375 Send(new WidgetHostMsg_ZoomToFindInPageRectInMainFrame(routing_id(),
3376 rect_to_zoom));
3377}
3378
danakj4886cad2019-02-26 22:15:563379void RenderWidget::RegisterViewportLayers(const cc::ViewportLayers& layers) {
danakj2db0b282019-09-20 15:09:203380 layer_tree_host_->RegisterViewportLayers(layers);
danakj4886cad2019-02-26 22:15:563381}
3382
3383void RenderWidget::RegisterSelection(const cc::LayerSelection& selection) {
danakj2db0b282019-09-20 15:09:203384 layer_tree_host_->RegisterSelection(selection);
danakj4886cad2019-02-26 22:15:563385}
3386
chaopeng161241b72019-03-21 18:25:173387void RenderWidget::FallbackCursorModeLockCursor(bool left,
3388 bool right,
3389 bool up,
3390 bool down) {
3391 widget_input_handler_manager_->FallbackCursorModeLockCursor(left, right, up,
3392 down);
3393}
3394
3395void RenderWidget::FallbackCursorModeSetCursorVisibility(bool visible) {
3396 widget_input_handler_manager_->FallbackCursorModeSetCursorVisibility(visible);
3397}
3398
danakj35c203a2019-04-16 17:12:393399void RenderWidget::SetAllowGpuRasterization(bool allow_gpu_raster) {
danakj2db0b282019-09-20 15:09:203400 layer_tree_host_->SetHasGpuRasterizationTrigger(allow_gpu_raster);
danakj35c203a2019-04-16 17:12:393401}
3402
W. James MacLean233a64ff2019-05-18 16:18:493403void RenderWidget::SetPageScaleStateAndLimits(float page_scale_factor,
3404 bool is_pinch_gesture_active,
3405 float minimum,
3406 float maximum) {
danakj2db0b282019-09-20 15:09:203407 layer_tree_host_->SetPageScaleFactorAndLimits(page_scale_factor, minimum,
3408 maximum);
W. James MacLean233a64ff2019-05-18 16:18:493409
3410 // Only continue if this is a mainframe, or something's actually changed.
3411 if (!delegate() ||
3412 (page_scale_factor == page_scale_factor_from_mainframe_ &&
3413 is_pinch_gesture_active == is_pinch_gesture_active_from_mainframe_)) {
3414 return;
3415 }
3416
danakjbd1a86a2019-09-06 17:24:313417 DCHECK(!is_undead_);
danakj1fe8e62d2019-09-05 23:21:563418 DCHECK(!IsForProvisionalFrame());
3419
W. James MacLean233a64ff2019-05-18 16:18:493420 // The page scale is controlled by the WebView for the local main frame of
danakjbd1a86a2019-09-06 17:24:313421 // the Page. So this is called from blink for the RenderWidget of that
W. James MacLean233a64ff2019-05-18 16:18:493422 // local main frame. We forward the value on to each child RenderWidget (each
3423 // of which will be via proxy child frame). These will each in turn forward
3424 // the message to their child RenderWidgets (through their proxy child
3425 // frames).
W. James MacLean233a64ff2019-05-18 16:18:493426 for (auto& observer : render_frame_proxies_) {
Erik Chenb29e60ee2019-09-19 23:50:473427 if (!is_undead_) {
3428 observer.OnPageScaleFactorChanged(page_scale_factor,
3429 is_pinch_gesture_active);
3430 }
W. James MacLean233a64ff2019-05-18 16:18:493431 }
3432 // Store the value to give to any new RenderFrameProxy that is registered.
3433 page_scale_factor_from_mainframe_ = page_scale_factor;
3434 is_pinch_gesture_active_from_mainframe_ = is_pinch_gesture_active;
danakj77821e252019-03-27 19:58:043435}
3436
3437void RenderWidget::StartPageScaleAnimation(const gfx::Vector2d& target_offset,
3438 bool use_anchor,
3439 float new_page_scale,
Sergio Villar Senin2127d7b2019-07-31 17:29:583440 base::TimeDelta duration) {
danakj2db0b282019-09-20 15:09:203441 layer_tree_host_->StartPageScaleAnimation(target_offset, use_anchor,
3442 new_page_scale, duration);
danakj77821e252019-03-27 19:58:043443}
3444
danakjd92cf59a42019-07-23 15:22:513445void RenderWidget::ForceRecalculateRasterScales() {
danakj2db0b282019-09-20 15:09:203446 layer_tree_host_->SetNeedsRecalculateRasterScales();
danakjd92cf59a42019-07-23 15:22:513447}
3448
danakjda15621e2019-04-05 20:34:433449void RenderWidget::RequestDecode(const cc::PaintImage& image,
3450 base::OnceCallback<void(bool)> callback) {
danakj2db0b282019-09-20 15:09:203451 layer_tree_host_->QueueImageDecode(image, std::move(callback));
danakjda15621e2019-04-05 20:34:433452}
3453
danakj2d2889a2019-04-05 21:22:083454// Enables measuring and reporting both presentation times and swap times in
3455// swap promises.
3456class ReportTimeSwapPromise : public cc::SwapPromise {
3457 using ReportTimeCallback = blink::WebWidgetClient::ReportTimeCallback;
3458
3459 public:
Mohsen Izadid6715832019-06-05 00:32:513460 ReportTimeSwapPromise(ReportTimeCallback swap_time_callback,
3461 ReportTimeCallback presentation_time_callback,
danakj2d2889a2019-04-05 21:22:083462 scoped_refptr<base::SingleThreadTaskRunner> task_runner,
3463 base::WeakPtr<RenderWidget> render_widget)
Mohsen Izadid6715832019-06-05 00:32:513464 : swap_time_callback_(std::move(swap_time_callback)),
3465 presentation_time_callback_(std::move(presentation_time_callback)),
danakj2d2889a2019-04-05 21:22:083466 task_runner_(std::move(task_runner)),
3467 render_widget_(std::move(render_widget)) {}
3468 ~ReportTimeSwapPromise() override = default;
3469
3470 void DidActivate() override {}
3471
3472 void WillSwap(viz::CompositorFrameMetadata* metadata) override {
3473 DCHECK_GT(metadata->frame_token, 0u);
3474 // The interval between the current swap and its presentation time is
3475 // reported in UMA (see corresponding code in DidSwap() below).
3476 frame_token_ = metadata->frame_token;
3477 }
3478 void DidSwap() override {
3479 DCHECK_GT(frame_token_, 0u);
3480 task_runner_->PostTask(
Mohsen Izadid6715832019-06-05 00:32:513481 FROM_HERE, base::BindOnce(&RunCallbackAfterSwap, base::TimeTicks::Now(),
3482 std::move(swap_time_callback_),
3483 std::move(presentation_time_callback_),
3484 std::move(render_widget_), frame_token_));
danakj2d2889a2019-04-05 21:22:083485 }
3486
Bo Liudef993a2019-04-24 20:08:493487 cc::SwapPromise::DidNotSwapAction DidNotSwap(
3488 DidNotSwapReason reason) override {
danakj2d2889a2019-04-05 21:22:083489 blink::WebWidgetClient::SwapResult result;
3490 switch (reason) {
3491 case cc::SwapPromise::DidNotSwapReason::SWAP_FAILS:
3492 result = blink::WebWidgetClient::SwapResult::kDidNotSwapSwapFails;
3493 break;
3494 case cc::SwapPromise::DidNotSwapReason::COMMIT_FAILS:
3495 result = blink::WebWidgetClient::SwapResult::kDidNotSwapCommitFails;
3496 break;
3497 case cc::SwapPromise::DidNotSwapReason::COMMIT_NO_UPDATE:
3498 result = blink::WebWidgetClient::SwapResult::kDidNotSwapCommitNoUpdate;
3499 break;
3500 case cc::SwapPromise::DidNotSwapReason::ACTIVATION_FAILS:
3501 result = blink::WebWidgetClient::SwapResult::kDidNotSwapActivationFails;
3502 break;
3503 }
3504 // During a failed swap, return the current time regardless of whether we're
3505 // using presentation or swap timestamps.
3506 task_runner_->PostTask(
3507 FROM_HERE,
Mohsen Izadid6715832019-06-05 00:32:513508 base::BindOnce(
3509 [](blink::WebWidgetClient::SwapResult result,
3510 base::TimeTicks swap_time, ReportTimeCallback swap_time_callback,
3511 ReportTimeCallback presentation_time_callback) {
3512 ReportTime(std::move(swap_time_callback), result, swap_time);
3513 ReportTime(std::move(presentation_time_callback), result,
3514 swap_time);
3515 },
3516 result, base::TimeTicks::Now(), std::move(swap_time_callback_),
3517 std::move(presentation_time_callback_)));
Bo Liudef993a2019-04-24 20:08:493518 return DidNotSwapAction::BREAK_PROMISE;
danakj2d2889a2019-04-05 21:22:083519 }
3520
3521 int64_t TraceId() const override { return 0; }
3522
3523 private:
Mohsen Izadid6715832019-06-05 00:32:513524 static void RunCallbackAfterSwap(
3525 base::TimeTicks swap_time,
3526 ReportTimeCallback swap_time_callback,
3527 ReportTimeCallback presentation_time_callback,
3528 base::WeakPtr<RenderWidget> render_widget,
3529 int frame_token) {
3530 if (render_widget) {
3531 render_widget->layer_tree_view()->AddPresentationCallback(
3532 frame_token,
3533 base::BindOnce(&RunCallbackAfterPresentation,
3534 std::move(presentation_time_callback), swap_time));
3535 ReportTime(std::move(swap_time_callback),
3536 blink::WebWidgetClient::SwapResult::kDidSwap, swap_time);
3537 } else {
3538 ReportTime(std::move(swap_time_callback),
3539 blink::WebWidgetClient::SwapResult::kDidSwap, swap_time);
3540 ReportTime(std::move(presentation_time_callback),
3541 blink::WebWidgetClient::SwapResult::kDidSwap, swap_time);
3542 }
3543 }
3544
3545 static void RunCallbackAfterPresentation(
3546 ReportTimeCallback presentation_time_callback,
danakj2d2889a2019-04-05 21:22:083547 base::TimeTicks swap_time,
3548 base::TimeTicks presentation_time) {
3549 DCHECK(!swap_time.is_null());
3550 bool presentation_time_is_valid =
3551 !presentation_time.is_null() && (presentation_time > swap_time);
3552 UMA_HISTOGRAM_BOOLEAN("PageLoad.Internal.Renderer.PresentationTime.Valid",
3553 presentation_time_is_valid);
3554 if (presentation_time_is_valid) {
3555 // This measures from 1ms to 10seconds.
3556 UMA_HISTOGRAM_TIMES(
3557 "PageLoad.Internal.Renderer.PresentationTime.DeltaFromSwapTime",
3558 presentation_time - swap_time);
3559 }
Mohsen Izadid6715832019-06-05 00:32:513560 ReportTime(std::move(presentation_time_callback),
3561 blink::WebWidgetClient::SwapResult::kDidSwap,
3562 presentation_time_is_valid ? presentation_time : swap_time);
danakj2d2889a2019-04-05 21:22:083563 }
3564
Mohsen Izadid6715832019-06-05 00:32:513565 static void ReportTime(ReportTimeCallback callback,
3566 blink::WebWidgetClient::SwapResult result,
3567 base::TimeTicks time) {
3568 if (callback)
3569 std::move(callback).Run(result, time);
3570 }
3571
3572 ReportTimeCallback swap_time_callback_;
3573 ReportTimeCallback presentation_time_callback_;
danakj2d2889a2019-04-05 21:22:083574 scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
3575 base::WeakPtr<RenderWidget> render_widget_;
3576 uint32_t frame_token_ = 0;
3577
3578 DISALLOW_COPY_AND_ASSIGN(ReportTimeSwapPromise);
3579};
3580
3581void RenderWidget::NotifySwapTime(ReportTimeCallback callback) {
Mohsen Izadid6715832019-06-05 00:32:513582 NotifySwapAndPresentationTime(base::NullCallback(), std::move(callback));
3583}
3584
danakj2e87fd82019-07-05 16:42:293585void RenderWidget::SetEventListenerProperties(
3586 cc::EventListenerClass event_class,
3587 cc::EventListenerProperties properties) {
danakj2db0b282019-09-20 15:09:203588 layer_tree_host_->SetEventListenerProperties(event_class, properties);
danakj2e87fd82019-07-05 16:42:293589}
3590
3591cc::EventListenerProperties RenderWidget::EventListenerProperties(
3592 cc::EventListenerClass event_class) const {
danakj2db0b282019-09-20 15:09:203593 return layer_tree_host_->event_listener_properties(event_class);
danakj2e87fd82019-07-05 16:42:293594}
3595
danakj2001a282019-07-18 19:12:323596std::unique_ptr<cc::ScopedDeferMainFrameUpdate>
3597RenderWidget::DeferMainFrameUpdate() {
danakj2db0b282019-09-20 15:09:203598 return layer_tree_host_->DeferMainFrameUpdate();
danakj2001a282019-07-18 19:12:323599}
3600
3601void RenderWidget::StartDeferringCommits(base::TimeDelta timeout) {
danakj2db0b282019-09-20 15:09:203602 layer_tree_host_->StartDeferringCommits(timeout);
danakj2001a282019-07-18 19:12:323603}
3604
3605void RenderWidget::StopDeferringCommits(cc::PaintHoldingCommitTrigger trigger) {
danakj2db0b282019-09-20 15:09:203606 layer_tree_host_->StopDeferringCommits(trigger);
danakj2001a282019-07-18 19:12:323607}
3608
danakjef7f7fa02019-07-26 22:50:063609void RenderWidget::RequestBeginMainFrameNotExpected(bool request) {
danakj2db0b282019-09-20 15:09:203610 layer_tree_host_->RequestBeginMainFrameNotExpected(request);
danakjef7f7fa02019-07-26 22:50:063611}
3612
3613int RenderWidget::GetLayerTreeId() const {
danakj2db0b282019-09-20 15:09:203614 return layer_tree_host_->GetId();
danakjef7f7fa02019-07-26 22:50:063615}
3616
Erik Chenad7f4a1e2019-08-05 20:38:053617void RenderWidget::SetBrowserControlsShownRatio(float ratio) {
danakj2db0b282019-09-20 15:09:203618 layer_tree_host_->SetBrowserControlsShownRatio(ratio);
Erik Chenad7f4a1e2019-08-05 20:38:053619}
3620
3621void RenderWidget::SetBrowserControlsHeight(float top_height,
3622 float bottom_height,
3623 bool shrink_viewport) {
danakj2db0b282019-09-20 15:09:203624 layer_tree_host_->SetBrowserControlsHeight(top_height, bottom_height,
3625 shrink_viewport);
Erik Chenad7f4a1e2019-08-05 20:38:053626}
3627
Erik Chen4f2f6f0d2019-08-14 23:17:233628viz::FrameSinkId RenderWidget::GetFrameSinkId() {
3629 return viz::FrameSinkId(RenderThread::Get()->GetClientId(), routing_id());
3630}
3631
Mohsen Izadid6715832019-06-05 00:32:513632void RenderWidget::NotifySwapAndPresentationTime(
3633 ReportTimeCallback swap_time_callback,
3634 ReportTimeCallback presentation_time_callback) {
danakj2d2889a2019-04-05 21:22:083635 // When the WebWidget is closed we cancel any pending SwapPromise that would
3636 // call back into blink, so we use |close_weak_ptr_factory_|.
danakj2db0b282019-09-20 15:09:203637 layer_tree_host_->QueueSwapPromise(std::make_unique<ReportTimeSwapPromise>(
Mohsen Izadid6715832019-06-05 00:32:513638 std::move(swap_time_callback), std::move(presentation_time_callback),
danakj2db0b282019-09-20 15:09:203639 layer_tree_host_->GetTaskRunnerProvider()->MainThreadTaskRunner(),
danakj2d2889a2019-04-05 21:22:083640 close_weak_ptr_factory_.GetWeakPtr()));
3641}
3642
Dave Tapuskabafc2ba32017-11-28 01:54:373643void RenderWidget::RequestUnbufferedInputEvents() {
3644 if (input_event_queue_)
3645 input_event_queue_->RequestUnbufferedInputEvents();
3646}
3647
xidachenfa0199e72017-05-11 11:34:263648void RenderWidget::SetTouchAction(cc::TouchAction touch_action) {
Dave Tapuskab28a1082017-08-30 15:37:263649 if (!input_handler_->ProcessTouchAction(touch_action))
[email protected]5d0bbdfa92013-12-10 00:35:513650 return;
3651
Dave Tapuska04bc5ee92018-04-17 19:03:313652 widget_input_handler_manager_->ProcessTouchAction(touch_action);
[email protected]5d0bbdfa92013-12-10 00:35:513653}
3654
[email protected]e3244ed2014-06-20 20:04:273655void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
3656 render_frame_proxies_.AddObserver(proxy);
danakj0246bba02019-01-23 23:12:273657 // Page scale factor is propagated down the RenderWidget tree (across
3658 // frame trees). A new RenderFrameProxy means there is a new child
3659 // RenderWidget in another frame tree. In order for it to hear about
3660 // the page scale factor we pass along the last seen value here.
W. James MacLean2cd99b62019-04-08 13:54:433661 proxy->OnPageScaleFactorChanged(page_scale_factor_from_mainframe_,
3662 is_pinch_gesture_active_from_mainframe_);
[email protected]bffc8302014-01-23 20:52:163663}
3664
[email protected]e3244ed2014-06-20 20:04:273665void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
3666 render_frame_proxies_.RemoveObserver(proxy);
[email protected]bffc8302014-01-23 20:52:163667}
3668
[email protected]de3c5d82014-05-28 22:12:593669void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
3670 render_frames_.AddObserver(frame);
3671}
3672
3673void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) {
3674 render_frames_.RemoveObserver(frame);
3675}
3676
Saman Samid189e5dfd2017-12-20 22:55:313677void RenderWidget::RegisterBrowserPlugin(BrowserPlugin* browser_plugin) {
3678 browser_plugins_.AddObserver(browser_plugin);
Saman Sami50d1e0c2018-03-13 20:03:493679 browser_plugin->ScreenInfoChanged(GetOriginalScreenInfo());
Saman Samid189e5dfd2017-12-20 22:55:313680}
3681
3682void RenderWidget::UnregisterBrowserPlugin(BrowserPlugin* browser_plugin) {
3683 browser_plugins_.RemoveObserver(browser_plugin);
3684}
3685
Albert J. Wong3c93c182018-09-27 17:29:433686void RenderWidget::OnWaitNextFrameForTests(
3687 int main_frame_thread_observer_routing_id) {
danakj53802692018-07-25 21:46:443688 // Sends an ACK to the browser process during the next compositor frame.
George Burgess IVbd843ec2019-09-05 02:50:363689 QueueMessage(std::make_unique<WidgetHostMsg_WaitForNextFrameForTests_ACK>(
Albert J. Wong3c93c182018-09-27 17:29:433690 main_frame_thread_observer_routing_id));
lfg43e08e62016-02-03 18:51:373691}
3692
Fady Samuela863f152018-03-09 16:10:033693const ScreenInfo& RenderWidget::GetOriginalScreenInfo() const {
Erik Chena65fa752019-09-21 06:59:403694 return page_properties_->GetOriginalScreenInfo();
oshima50872a72016-03-04 13:26:183695}
3696
Ella Ge80a52dce2017-11-15 18:01:523697gfx::PointF RenderWidget::ConvertWindowPointToViewport(
3698 const gfx::PointF& point) {
paulmeyer90f6c31d2016-11-12 00:17:593699 blink::WebFloatRect point_in_viewport(point.x(), point.y(), 0, 0);
Blink Reformat1c4d759e2017-04-09 16:34:543700 ConvertWindowToViewport(&point_in_viewport);
Ella Ge80a52dce2017-11-15 18:01:523701 return gfx::PointF(point_in_viewport.x, point_in_viewport.y);
3702}
3703
3704gfx::Point RenderWidget::ConvertWindowPointToViewport(const gfx::Point& point) {
3705 return gfx::ToRoundedPoint(ConvertWindowPointToViewport(gfx::PointF(point)));
paulmeyer90f6c31d2016-11-12 00:17:593706}
3707
Ella Ge3fa5c3f2019-09-05 19:00:063708bool RenderWidget::RequestPointerLock(WebLocalFrame* requester_frame,
3709 bool request_unadjusted_movement) {
Mustaq Ahmed32a0b152019-08-06 16:01:263710 return mouse_lock_dispatcher_->LockMouse(webwidget_mouse_lock_target_.get(),
Ella Ge3fa5c3f2019-09-05 19:00:063711 requester_frame,
3712 request_unadjusted_movement);
lfgbee1e0a2016-06-08 21:24:213713}
3714
Blink Reformat1c4d759e2017-04-09 16:34:543715void RenderWidget::RequestPointerUnlock() {
lfgbee1e0a2016-06-08 21:24:213716 mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
3717}
3718
Blink Reformat1c4d759e2017-04-09 16:34:543719bool RenderWidget::IsPointerLocked() {
lfgbee1e0a2016-06-08 21:24:213720 return mouse_lock_dispatcher_->IsMouseLockedTo(
3721 webwidget_mouse_lock_target_.get());
3722}
3723
Richard Li49fe04d2018-10-21 09:07:193724void RenderWidget::StartDragging(network::mojom::ReferrerPolicy policy,
paulmeyer6ef5a792016-11-08 20:33:583725 const WebDragData& data,
3726 WebDragOperationsMask mask,
danakj0c75ad82018-07-10 19:50:123727 const SkBitmap& drag_image,
danakjef1735a2018-11-13 19:34:443728 const gfx::Point& web_image_offset) {
3729 blink::WebRect offset_in_window(web_image_offset.x(), web_image_offset.y(), 0,
3730 0);
Blink Reformat1c4d759e2017-04-09 16:34:543731 ConvertViewportToWindow(&offset_in_window);
paulmeyer6ef5a792016-11-08 20:33:583732 DropData drop_data(DropDataBuilder::Build(data));
3733 drop_data.referrer_policy = policy;
danakj0c75ad82018-07-10 19:50:123734 gfx::Vector2d image_offset(offset_in_window.x, offset_in_window.y);
3735 Send(new DragHostMsg_StartDragging(routing_id(), drop_data, mask, drag_image,
3736 image_offset, possible_drag_event_info_));
paulmeyer6ef5a792016-11-08 20:33:583737}
3738
Saman Samif7731342018-01-24 22:18:443739void RenderWidget::DidNavigate() {
danakj125a29e2019-01-24 23:25:293740 // Blink may be navigating still between the Close IPC and the task that
3741 // actually closes this class, and for a main frame that would come through
3742 // this method. But since we are closing we can skip it.
3743 if (closing_)
Kinuko Yasudabef2b642019-01-24 04:53:333744 return;
danakj125a29e2019-01-24 23:25:293745
Stephen Chenneyf661f062019-08-02 20:12:423746 // The input handler wants to know about navigation so that it can
Stephen Chenneybccdd0302019-08-15 12:21:283747 // suppress input until the newly navigated page has a committed frame.
3748 // It also resets the state for UMA reporting of input arrival with respect
3749 // to document lifecycle.
Stephen Chenneyf661f062019-08-02 20:12:423750 DCHECK(widget_input_handler_manager_);
3751 widget_input_handler_manager_->DidNavigate();
3752
danakj2db0b282019-09-20 15:09:203753 layer_tree_host_->ClearCachesOnNextCommit();
kenrb5d78b842017-03-06 21:06:013754}
3755
ekaramad2daaf672016-11-10 20:29:013756blink::WebInputMethodController* RenderWidget::GetInputMethodController()
3757 const {
Ehsan Karamad655d7b8a2018-01-12 18:38:383758 if (auto* frame_widget = GetFrameWidget())
3759 return frame_widget->GetActiveWebInputMethodController();
3760
3761 return nullptr;
ekaramad2daaf672016-11-10 20:29:013762}
3763
Dave Tapuska139a72f2017-09-06 21:57:033764void RenderWidget::SetupWidgetInputHandler(
Dave Tapuskae782bea2019-07-09 16:21:513765 mojo::PendingReceiver<mojom::WidgetInputHandler> receiver,
3766 mojo::PendingRemote<mojom::WidgetInputHandlerHost> host) {
3767 widget_input_handler_manager_->AddInterface(std::move(receiver),
Dave Tapuskab66c28f2017-11-15 17:18:473768 std::move(host));
Dave Tapuska525eb15e2017-08-17 21:05:503769}
3770
Julie Jeongeun Kim02291d732019-09-07 03:08:583771void RenderWidget::SetWidgetReceiver(
3772 mojo::PendingReceiver<mojom::Widget> recevier) {
3773 // Close the old receiver if there was one.
Dave Tapuska485aca92017-08-08 00:47:583774 // A RenderWidgetHost should not need more than one channel.
Julie Jeongeun Kim02291d732019-09-07 03:08:583775 widget_receiver_.reset();
3776 widget_receiver_.Bind(std::move(recevier));
Dave Tapuska485aca92017-08-08 00:47:583777}
3778
Ken Buchanan94c0beb62018-06-22 19:56:243779void RenderWidget::SetMouseCapture(bool capture) {
3780 if (mojom::WidgetInputHandlerHost* host =
3781 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
3782 host->SetMouseCapture(capture);
3783 }
3784}
3785
danakj53802692018-07-25 21:46:443786void RenderWidget::UseSynchronousResizeModeForTesting(bool enable) {
danakj7602f4f2019-01-31 18:03:233787 synchronous_resize_mode_for_testing_ = enable;
danakja2c9d0a92018-07-25 20:01:183788}
3789
3790void RenderWidget::SetDeviceScaleFactorForTesting(float factor) {
danakjb4cec102019-01-30 19:22:133791 DCHECK_GT(factor, 0.f);
danakja2c9d0a92018-07-25 20:01:183792
danakja2c9d0a92018-07-25 20:01:183793 // We are changing the device scale factor from the renderer, so allocate a
3794 // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
danakj2db0b282019-09-20 15:09:203795 layer_tree_host_->RequestNewLocalSurfaceId();
danakjb4cec102019-01-30 19:22:133796
Albert J. Wonga3dbd5442019-09-18 10:38:283797 ScreenInfo info = page_properties_->GetScreenInfo();
danakjb4cec102019-01-30 19:22:133798 info.device_scale_factor = factor;
3799 gfx::Size viewport_pixel_size = gfx::ScaleToCeiledSize(size_, factor);
3800 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
W. James MacLean7df854c2019-08-28 16:17:533801 gfx::Rect(viewport_pixel_size), info);
danakjb4cec102019-01-30 19:22:133802
3803 ResizeWebWidget(); // This picks up the new device scale factor in |info|.
3804
3805 gfx::Size visible_viewport_size = visible_viewport_size_;
3806 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
3807 visible_viewport_size =
3808 gfx::ScaleToCeiledSize(visible_viewport_size, factor);
3809 }
W. James MacLean7c8581072019-06-18 18:07:533810
3811 DCHECK(delegate()) << "Resizing the viewport for a cross-process subframe "
3812 "must be done via the RenderView.";
3813 delegate()->ResizeVisualViewportForWidget(visible_viewport_size);
danakjb4cec102019-01-30 19:22:133814
danakjcf409aa2019-09-20 15:22:303815 // TODO(danakj): This should not need to go through RenderFrame to set
3816 // Page-level properties.
3817 blink::WebFrameWidget* frame_widget = GetFrameWidget();
3818 RenderFrameImpl* render_frame =
3819 RenderFrameImpl::FromWebFrame(frame_widget->LocalRoot());
3820 render_frame->SetPreferCompositingToLCDTextEnabledOnRenderView(
3821 ComputePreferCompositingToLCDText(
3822 compositor_deps_, page_properties_->GetDeviceScaleFactor()));
3823
3824 // Make sure to override any future OnSynchronizeVisualProperties IPCs.
danakjb4cec102019-01-30 19:22:133825 device_scale_factor_for_testing_ = factor;
danakja2c9d0a92018-07-25 20:01:183826}
3827
danakjcf409aa2019-09-20 15:22:303828void RenderWidget::SetZoomLevelForTesting(double zoom_level) {
3829 DCHECK_NE(zoom_level, -INFINITY);
3830 SetZoomLevel(zoom_level);
3831
3832 // Make sure to override any future OnSynchronizeVisualProperties IPCs.
3833 zoom_level_for_testing_ = zoom_level;
3834}
3835
3836void RenderWidget::ResetZoomLevelForTesting() {
3837 zoom_level_for_testing_ = -INFINITY;
3838 SetZoomLevel(0);
3839}
3840
danakja2c9d0a92018-07-25 20:01:183841void RenderWidget::SetDeviceColorSpaceForTesting(
3842 const gfx::ColorSpace& color_space) {
danakjb4cec102019-01-30 19:22:133843 // We are changing the device color space from the renderer, so allocate a
3844 // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
danakj2db0b282019-09-20 15:09:203845 layer_tree_host_->RequestNewLocalSurfaceId();
danakjb4cec102019-01-30 19:22:133846
Albert J. Wonga3dbd5442019-09-18 10:38:283847 ScreenInfo info = page_properties_->GetScreenInfo();
danakj04d128a2019-01-25 02:10:203848 info.color_space = color_space;
3849 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
W. James MacLean7df854c2019-08-28 16:17:533850 CompositorViewportRect(), info);
danakja2c9d0a92018-07-25 20:01:183851}
3852
3853void RenderWidget::SetWindowRectSynchronouslyForTesting(
3854 const gfx::Rect& new_window_rect) {
3855 SetWindowRectSynchronously(new_window_rect);
3856}
3857
3858void RenderWidget::EnableAutoResizeForTesting(const gfx::Size& min_size,
3859 const gfx::Size& max_size) {
danakjd990b4c2019-09-18 20:34:293860 SetAutoResizeMode(true, min_size, max_size,
3861 page_properties_->GetDeviceScaleFactor());
danakja2c9d0a92018-07-25 20:01:183862}
3863
3864void RenderWidget::DisableAutoResizeForTesting(const gfx::Size& new_size) {
3865 if (!auto_resize_mode_)
3866 return;
3867
danakjd990b4c2019-09-18 20:34:293868 SetAutoResizeMode(false, gfx::Size(), gfx::Size(),
3869 page_properties_->GetDeviceScaleFactor());
danakj83388a32019-09-11 16:28:313870
danakjd990b4c2019-09-18 20:34:293871 // The |new_size| is empty when resetting auto resize in between tests. In
3872 // this case the current size should just be preserved.
3873 if (!new_size.IsEmpty()) {
3874 size_ = new_size;
3875 ResizeWebWidget();
danakj83388a32019-09-11 16:28:313876 }
danakja2c9d0a92018-07-25 20:01:183877}
3878
EhsanK955ba582017-11-30 21:14:403879blink::WebLocalFrame* RenderWidget::GetFocusedWebLocalFrameInWidget() const {
Ehsan Karamad655d7b8a2018-01-12 18:38:383880 if (auto* frame_widget = GetFrameWidget())
3881 return frame_widget->FocusedWebLocalFrameInWidget();
3882 return nullptr;
EhsanK955ba582017-11-30 21:14:403883}
3884
EhsanK22d482e2017-08-10 17:29:493885#if BUILDFLAG(ENABLE_PLUGINS)
3886PepperPluginInstanceImpl* RenderWidget::GetFocusedPepperPluginInsideWidget() {
Ehsan Karamad655d7b8a2018-01-12 18:38:383887 blink::WebFrameWidget* frame_widget = GetFrameWidget();
3888 if (!frame_widget)
EhsanK22d482e2017-08-10 17:29:493889 return nullptr;
3890
3891 // Focused pepper instance might not always be in the focused frame. For
3892 // instance if a pepper instance and its embedder frame are focused an then
3893 // another frame takes focus using javascript, the embedder frame will no
3894 // longer be focused while the pepper instance is (the embedder frame's
3895 // |focused_pepper_plugin_| is not nullptr). Especially, if the pepper plugin
3896 // is fullscreen, clicking into the pepper will not refocus the embedder
3897 // frame. This is why we have to traverse the whole frame tree to find the
3898 // focused plugin.
Ehsan Karamad655d7b8a2018-01-12 18:38:383899 blink::WebFrame* current_frame = frame_widget->LocalRoot();
EhsanK22d482e2017-08-10 17:29:493900 while (current_frame) {
3901 RenderFrameImpl* render_frame =
3902 current_frame->IsWebLocalFrame()
3903 ? RenderFrameImpl::FromWebFrame(current_frame)
3904 : nullptr;
3905 if (render_frame && render_frame->focused_pepper_plugin())
3906 return render_frame->focused_pepper_plugin();
3907 current_frame = current_frame->TraverseNext();
3908 }
3909 return nullptr;
3910}
3911#endif
3912
Ken Buchananb2c9e262018-03-10 16:53:313913gfx::Rect RenderWidget::ViewportVisibleRect() {
danakj9c4e7b812019-02-19 22:04:273914 if (for_child_local_root_frame_)
3915 return compositor_visible_rect_;
W. James MacLean7df854c2019-08-28 16:17:533916 return CompositorViewportRect();
Ken Buchananb2c9e262018-03-10 16:53:313917}
3918
Hajime Hoshi315a61f2018-08-14 17:27:283919// static
3920scoped_refptr<base::SingleThreadTaskRunner>
3921RenderWidget::GetCleanupTaskRunner() {
3922 return RenderThreadImpl::current_blink_platform_impl()
3923 ->main_thread_scheduler()
3924 ->CleanupTaskRunner();
3925}
3926
Saman Sami50d1e0c2018-03-13 20:03:493927base::WeakPtr<RenderWidget> RenderWidget::AsWeakPtr() {
3928 return weak_ptr_factory_.GetWeakPtr();
3929}
3930
danakj557248b2019-09-25 17:17:403931void RenderWidget::SetWebWidgetInternal(blink::WebWidget* webwidget) {
Erik Chena2819852019-08-28 01:02:283932 // TODO(https://crbug.com/995981): This method should not need to exist, since
3933 // we should be creating and destroying a RenderWidget along with the
3934 // WebWidget.
danakj557248b2019-09-25 17:17:403935 if (webwidget)
3936 webwidget->SetAnimationHost(layer_tree_view_->animation_host());
3937 webwidget_ = webwidget;
Erik Chen7ee377b2019-08-22 23:38:343938}
3939
[email protected]e9ff79c2012-10-19 21:31:263940} // namespace content