blob: 3adc1947469d827d044748382a44fce3ead31b43 [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"
danakj4b347212018-07-04 17:55:1736#include "components/viz/common/features.h"
Fady Samuelc645ffe2017-07-24 17:28:2037#include "components/viz/common/frame_sinks/begin_frame_source.h"
danakjf20f4502017-09-26 17:13:3138#include "components/viz/common/frame_sinks/copy_output_request.h"
danakj4b347212018-07-04 17:55:1739#include "components/viz/common/switches.h"
40#include "content/common/content_switches_internal.h"
paulmeyer6ef5a792016-11-08 20:33:5841#include "content/common/drag_event_source_info.h"
42#include "content/common/drag_messages.h"
jonrossa2ff4f82018-02-16 17:27:4643#include "content/common/render_frame_metadata.mojom.h"
jcivelliae1560a2016-11-01 22:40:2344#include "content/common/render_message_filter.mojom.h"
Nasko Oskovf97e8b02017-07-25 02:45:4245#include "content/common/swapped_out_messages.h"
ekaramad9053e57b2016-04-26 20:00:3846#include "content/common/text_input_state.h"
Albert J. Wong3c93c182018-09-27 17:29:4347#include "content/common/widget_messages.h"
mlamouriafca06dd2017-01-27 23:35:1848#include "content/public/common/content_client.h"
changwan7ded3752016-03-09 23:25:1249#include "content/public/common/content_features.h"
[email protected]c08950d22011-10-13 22:20:2950#include "content/public/common/content_switches.h"
[email protected]a09d53ce2014-01-31 00:46:4251#include "content/public/common/context_menu_params.h"
paulmeyer90f6c31d2016-11-12 00:17:5952#include "content/public/common/drop_data.h"
Khushal3e96e662017-10-30 23:16:5053#include "content/public/common/service_names.mojom.h"
Jaebaek Seo655110e2017-12-19 23:27:3954#include "content/public/common/use_zoom_for_dsf_policy.h"
mlamouriafca06dd2017-01-27 23:35:1855#include "content/public/renderer/content_renderer_client.h"
Avi Drissman07d22452019-03-25 17:56:3956#include "content/public/renderer/render_thread.h"
Saman Samid189e5dfd2017-12-20 22:55:3157#include "content/renderer/browser_plugin/browser_plugin.h"
Erik Chene8e50c622019-08-28 01:57:4958#include "content/renderer/browser_plugin/browser_plugin_manager.h"
Sadrul Habib Chowdhury31c98712018-12-11 04:15:1359#include "content/renderer/compositor/layer_tree_view.h"
paulmeyer6ef5a792016-11-08 20:33:5860#include "content/renderer/drop_data_builder.h"
[email protected]b2e4c70132013-10-03 02:07:5161#include "content/renderer/external_popup_menu.h"
Sadrul Habib Chowdhury31c98712018-12-11 04:15:1362#include "content/renderer/frame_swap_message_queue.h"
[email protected]66fca5bc2013-05-23 06:58:2963#include "content/renderer/ime_event_guard.h"
dtapuska9ec1a912017-04-21 15:18:3164#include "content/renderer/input/main_thread_event_queue.h"
Dave Tapuska9db80842017-07-24 17:24:2665#include "content/renderer/input/widget_input_handler_manager.h"
[email protected]adab2332013-07-25 18:04:3266#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
Sadrul Habib Chowdhury31c98712018-12-11 04:15:1367#include "content/renderer/queue_message_swap_promise.h"
[email protected]bffc8302014-01-23 20:52:1668#include "content/renderer/render_frame_impl.h"
danakj4b347212018-07-04 17:55:1769#include "content/renderer/render_frame_metadata_observer_impl.h"
[email protected]e3244ed2014-06-20 20:04:2770#include "content/renderer/render_frame_proxy.h"
[email protected]8704f89b2011-04-15 00:30:0571#include "content/renderer/render_process.h"
[email protected]f1a29a02011-10-06 23:08:4472#include "content/renderer/render_thread_impl.h"
dcheng3ce04b62015-10-26 23:30:5573#include "content/renderer/render_view_impl.h"
Abhijeet Kandalkardccbd612019-04-08 17:37:0974#include "content/renderer/render_widget_screen_metrics_emulator.h"
tfarina556a7232014-10-05 01:02:0975#include "content/renderer/renderer_blink_platform_impl.h"
danakj4b347212018-07-04 17:55:1776#include "gpu/command_buffer/service/gpu_switches.h"
ekaramad330ba4232016-09-23 17:57:4777#include "ipc/ipc_message_start.h"
[email protected]484955942010-08-19 16:13:1878#include "ipc/ipc_sync_message.h"
Antoine Laboure55c9ef82017-11-10 18:51:2379#include "ipc/ipc_sync_message_filter.h"
danakj4b347212018-07-04 17:55:1780#include "media/base/media_switches.h"
Scott Violet02e38b92018-03-27 23:42:1481#include "ppapi/buildflags/buildflags.h"
[email protected]661eb9d2009-02-03 02:11:4882#include "skia/ext/platform_canvas.h"
Blink Reformata30d4232018-04-07 15:31:0683#include "third_party/blink/public/platform/file_path_conversion.h"
Hajime Hoshi315a61f2018-08-14 17:27:2884#include "third_party/blink/public/platform/platform.h"
Blink Reformata30d4232018-04-07 15:31:0685#include "third_party/blink/public/platform/scheduler/web_render_widget_scheduling_state.h"
Yuta Kitamuradeb91bb2018-05-29 05:53:2086#include "third_party/blink/public/platform/scheduler/web_thread_scheduler.h"
Blink Reformata30d4232018-04-07 15:31:0687#include "third_party/blink/public/platform/web_cursor_info.h"
88#include "third_party/blink/public/platform/web_drag_data.h"
89#include "third_party/blink/public/platform/web_drag_operation.h"
90#include "third_party/blink/public/platform/web_mouse_event.h"
91#include "third_party/blink/public/platform/web_point.h"
92#include "third_party/blink/public/platform/web_rect.h"
93#include "third_party/blink/public/platform/web_runtime_features.h"
94#include "third_party/blink/public/platform/web_size.h"
95#include "third_party/blink/public/platform/web_string.h"
96#include "third_party/blink/public/web/web_autofill_client.h"
97#include "third_party/blink/public/web/web_device_emulation_params.h"
98#include "third_party/blink/public/web/web_frame_widget.h"
99#include "third_party/blink/public/web/web_input_method_controller.h"
100#include "third_party/blink/public/web/web_local_frame.h"
101#include "third_party/blink/public/web/web_node.h"
102#include "third_party/blink/public/web/web_page_popup.h"
103#include "third_party/blink/public/web/web_popup_menu_info.h"
104#include "third_party/blink/public/web/web_range.h"
105#include "third_party/blink/public/web/web_settings.h"
106#include "third_party/blink/public/web/web_view.h"
107#include "third_party/blink/public/web/web_widget.h"
[email protected]d353541f2012-05-03 22:45:41108#include "third_party/skia/include/core/SkShader.h"
Maksim Sisova33072d22019-01-24 15:44:25109#include "ui/base/clipboard/clipboard_constants.h"
Scott Violet8ff9c302018-02-22 22:28:35110#include "ui/base/ui_base_features.h"
danakj4b347212018-07-04 17:55:17111#include "ui/base/ui_base_switches.h"
dtapuska97286c882017-02-24 23:14:43112#include "ui/events/base_event_utils.h"
tfarina655f81d2014-12-23 02:38:50113#include "ui/gfx/geometry/point_conversions.h"
tfarina3b0452d2014-12-31 15:20:09114#include "ui/gfx/geometry/rect_conversions.h"
tfarinaebe974f02015-01-03 04:25:32115#include "ui/gfx/geometry/size_conversions.h"
[email protected]1835b9e2012-02-28 13:12:48116#include "ui/gfx/skia_util.h"
danakj4b347212018-07-04 17:55:17117#include "ui/gfx/switches.h"
[email protected]c9e2cbbb2012-05-12 21:17:27118#include "ui/gl/gl_switches.h"
danakj4b347212018-07-04 17:55:17119#include "ui/native_theme/native_theme_features.h"
120#include "ui/native_theme/overlay_scrollbar_constants_aura.h"
[email protected]d353541f2012-05-03 22:45:41121#include "ui/surface/transport_dib.h"
[email protected]661eb9d2009-02-03 02:11:48122
[email protected]eeb93112013-05-01 19:41:10123#if defined(OS_ANDROID)
[email protected]cefe9b152014-03-27 18:16:15124#include <android/keycodes.h>
wjmaclean1d970622017-01-21 22:28:24125#include "base/time/time.h"
[email protected]eeb93112013-05-01 19:41:10126#endif
127
[email protected]661eb9d2009-02-03 02:11:48128#if defined(OS_POSIX)
[email protected]d5282e72009-05-13 13:16:52129#include "third_party/skia/include/core/SkMallocPixelRef.h"
[email protected]d353541f2012-05-03 22:45:41130#include "third_party/skia/include/core/SkPixelRef.h"
[email protected]661eb9d2009-02-03 02:11:48131#endif // defined(OS_POSIX)
[email protected]8085dbc82008-09-26 22:53:44132
Ryan Landay9e42fd742017-08-12 01:59:11133using blink::WebImeTextSpan;
[email protected]180ef242013-11-07 06:50:46134using blink::WebCursorInfo;
[email protected]19193682014-04-03 15:01:43135using blink::WebDeviceEmulationParams;
paulmeyer90f6c31d2016-11-12 00:17:59136using blink::WebDragOperation;
paulmeyer6ef5a792016-11-08 20:33:58137using blink::WebDragOperationsMask;
138using blink::WebDragData;
paulmeyer90f6c31d2016-11-12 00:17:59139using blink::WebFrameWidget;
[email protected]180ef242013-11-07 06:50:46140using blink::WebGestureEvent;
141using blink::WebInputEvent;
dtapuska5d2e9c32015-12-03 16:39:49142using blink::WebInputEventResult;
ekaramad2daaf672016-11-10 20:29:01143using blink::WebInputMethodController;
paulmeyer6ef5a792016-11-08 20:33:58144using blink::WebLocalFrame;
[email protected]180ef242013-11-07 06:50:46145using blink::WebMouseEvent;
146using blink::WebMouseWheelEvent;
147using blink::WebNavigationPolicy;
donnda070f3c2015-01-16 19:54:11148using blink::WebNode;
[email protected]180ef242013-11-07 06:50:46149using blink::WebPagePopup;
dglazkove353a372016-09-01 01:33:48150using blink::WebRange;
[email protected]180ef242013-11-07 06:50:46151using blink::WebRect;
[email protected]180ef242013-11-07 06:50:46152using blink::WebSize;
paulmeyer90f6c31d2016-11-12 00:17:59153using blink::WebString;
[email protected]180ef242013-11-07 06:50:46154using blink::WebTextDirection;
155using blink::WebTouchEvent;
[email protected]f8ed4722013-12-03 03:27:25156using blink::WebTouchPoint;
[email protected]180ef242013-11-07 06:50:46157using blink::WebVector;
158using blink::WebWidget;
[email protected]e9ff79c2012-10-19 21:31:26159
paulmeyer90f6c31d2016-11-12 00:17:59160namespace content {
161
[email protected]6a4d7f62013-01-07 21:32:13162namespace {
[email protected]b256eca2013-07-11 10:57:40163
Albert J. Wong2727e8a82019-02-15 16:56:11164RenderWidget::CreateRenderWidgetFunction g_create_render_widget_for_frame =
165 nullptr;
166
Albert J. Wongcb004632018-07-10 22:58:25167using RoutingIDWidgetMap = std::map<int32_t, RenderWidget*>;
168base::LazyInstance<RoutingIDWidgetMap>::Leaky g_routing_id_widget_map =
169 LAZY_INSTANCE_INITIALIZER;
170
danakj4b347212018-07-04 17:55:17171const base::Feature kUnpremultiplyAndDitherLowBitDepthTiles = {
172 "UnpremultiplyAndDitherLowBitDepthTiles", base::FEATURE_ENABLED_BY_DEFAULT};
173
[email protected]b256eca2013-07-11 10:57:40174typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
175
AJITH KUMAR V041c0b02017-08-08 10:39:20176static const int kInvalidNextPreviousFlagsValue = -1;
yiyix6b90ef52018-10-09 19:55:30177static const char* kOOPIF = "OOPIF";
178static const char* kRenderer = "Renderer";
AJITH KUMAR V041c0b02017-08-08 10:39:20179
Ian Vollick7a847a82019-06-14 19:58:59180#if defined(OS_ANDROID)
181// With 32 bit pixels, this would mean less than 400kb per buffer. Much less
182// than required for, say, nHD.
183static const int kSmallScreenPixelThreshold = 1e5;
184bool IsSmallScreen(const gfx::Size& size) {
185 int area = 0;
186 if (!size.GetCheckedArea().AssignIfValid(&area))
187 return false;
188 return area < kSmallScreenPixelThreshold;
189}
190#endif
191
lfgbee1e0a2016-06-08 21:24:21192class WebWidgetLockTarget : public content::MouseLockDispatcher::LockTarget {
193 public:
Erik Chen7b985822019-08-30 00:39:12194 explicit WebWidgetLockTarget(RenderWidget* render_widget)
195 : render_widget_(render_widget) {}
lfgbee1e0a2016-06-08 21:24:21196
197 void OnLockMouseACK(bool succeeded) override {
Erik Chen7b985822019-08-30 00:39:12198 // TODO(https://crbug.com/995981): Once RenderWidget and WebWidget lifetimes
199 // are synchronized, we should remove these conditionals.
200 WebWidget* web_widget = render_widget_->GetWebWidget();
201 if (!web_widget)
202 return;
203
lfgbee1e0a2016-06-08 21:24:21204 if (succeeded)
Erik Chen7b985822019-08-30 00:39:12205 web_widget->DidAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21206 else
Erik Chen7b985822019-08-30 00:39:12207 web_widget->DidNotAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21208 }
209
Erik Chen7b985822019-08-30 00:39:12210 void OnMouseLockLost() override {
211 WebWidget* web_widget = render_widget_->GetWebWidget();
212 if (!web_widget)
213 return;
214
215 web_widget->DidLosePointerLock();
216 }
lfgbee1e0a2016-06-08 21:24:21217
218 bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event) override {
219 // The WebWidget handles mouse lock in Blink's handleInputEvent().
220 return false;
221 }
222
223 private:
Erik Chen7b985822019-08-30 00:39:12224 // The RenderWidget owns this instance and is guaranteed to outlive it.
225 RenderWidget* render_widget_;
lfgbee1e0a2016-06-08 21:24:21226};
227
Stephen Chenneyd56b5382019-01-29 00:37:02228class ScopedUkmRafAlignedInputTimer {
229 public:
230 explicit ScopedUkmRafAlignedInputTimer(blink::WebWidget* webwidget)
231 : webwidget_(webwidget) {
232 webwidget_->BeginRafAlignedInput();
233 }
234
235 ~ScopedUkmRafAlignedInputTimer() { webwidget_->EndRafAlignedInput(); }
236
237 private:
238 blink::WebWidget* webwidget_;
239
240 DISALLOW_COPY_AND_ASSIGN(ScopedUkmRafAlignedInputTimer);
241};
242
dglazkov97b6c2b2016-10-25 17:35:55243bool IsDateTimeInput(ui::TextInputType type) {
244 return type == ui::TEXT_INPUT_TYPE_DATE ||
245 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
246 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
247 type == ui::TEXT_INPUT_TYPE_MONTH ||
248 type == ui::TEXT_INPUT_TYPE_TIME || type == ui::TEXT_INPUT_TYPE_WEEK;
249}
250
paulmeyer90f6c31d2016-11-12 00:17:59251WebDragData DropMetaDataToWebDragData(
252 const std::vector<DropData::Metadata>& drop_meta_data) {
253 std::vector<WebDragData::Item> item_list;
254 for (const auto& meta_data_item : drop_meta_data) {
255 if (meta_data_item.kind == DropData::Kind::STRING) {
256 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54257 item.storage_type = WebDragData::Item::kStorageTypeString;
258 item.string_type = WebString::FromUTF16(meta_data_item.mime_type);
paulmeyer90f6c31d2016-11-12 00:17:59259 // Have to pass a dummy URL here instead of an empty URL because the
260 // DropData received by browser_plugins goes through a round trip:
261 // DropData::MetaData --> WebDragData-->DropData. In the end, DropData
262 // will contain an empty URL (which means no URL is dragged) if the URL in
263 // WebDragData is empty.
Maksim Sisova33072d22019-01-24 15:44:25264 if (base::EqualsASCII(meta_data_item.mime_type, ui::kMimeTypeURIList)) {
Blink Reformat1c4d759e2017-04-09 16:34:54265 item.string_data = WebString::FromUTF8("about:dragdrop-placeholder");
paulmeyer90f6c31d2016-11-12 00:17:59266 }
267 item_list.push_back(item);
268 continue;
269 }
270
271 // TODO(hush): crbug.com/584789. Blink needs to support creating a file with
272 // just the mimetype. This is needed to drag files to WebView on Android
273 // platform.
274 if ((meta_data_item.kind == DropData::Kind::FILENAME) &&
275 !meta_data_item.filename.empty()) {
276 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54277 item.storage_type = WebDragData::Item::kStorageTypeFilename;
278 item.filename_data = blink::FilePathToWebString(meta_data_item.filename);
paulmeyer90f6c31d2016-11-12 00:17:59279 item_list.push_back(item);
280 continue;
281 }
282
283 if (meta_data_item.kind == DropData::Kind::FILESYSTEMFILE) {
284 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54285 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
286 item.file_system_url = meta_data_item.file_system_url;
paulmeyer90f6c31d2016-11-12 00:17:59287 item_list.push_back(item);
288 continue;
289 }
290 }
291
292 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54293 result.Initialize();
294 result.SetItems(item_list);
paulmeyer90f6c31d2016-11-12 00:17:59295 return result;
296}
297
298WebDragData DropDataToWebDragData(const DropData& drop_data) {
299 std::vector<WebDragData::Item> item_list;
300
301 // These fields are currently unused when dragging into WebKit.
302 DCHECK(drop_data.download_metadata.empty());
303 DCHECK(drop_data.file_contents.empty());
dcheng3dd85612017-02-08 10:46:23304 DCHECK(drop_data.file_contents_content_disposition.empty());
paulmeyer90f6c31d2016-11-12 00:17:59305
306 if (!drop_data.text.is_null()) {
307 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54308 item.storage_type = WebDragData::Item::kStorageTypeString;
Maksim Sisova33072d22019-01-24 15:44:25309 item.string_type = WebString::FromUTF8(ui::kMimeTypeText);
Blink Reformat1c4d759e2017-04-09 16:34:54310 item.string_data = WebString::FromUTF16(drop_data.text.string());
paulmeyer90f6c31d2016-11-12 00:17:59311 item_list.push_back(item);
312 }
313
314 if (!drop_data.url.is_empty()) {
315 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54316 item.storage_type = WebDragData::Item::kStorageTypeString;
Maksim Sisova33072d22019-01-24 15:44:25317 item.string_type = WebString::FromUTF8(ui::kMimeTypeURIList);
Blink Reformat1c4d759e2017-04-09 16:34:54318 item.string_data = WebString::FromUTF8(drop_data.url.spec());
319 item.title = WebString::FromUTF16(drop_data.url_title);
paulmeyer90f6c31d2016-11-12 00:17:59320 item_list.push_back(item);
321 }
322
323 if (!drop_data.html.is_null()) {
324 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54325 item.storage_type = WebDragData::Item::kStorageTypeString;
Maksim Sisova33072d22019-01-24 15:44:25326 item.string_type = WebString::FromUTF8(ui::kMimeTypeHTML);
Blink Reformat1c4d759e2017-04-09 16:34:54327 item.string_data = WebString::FromUTF16(drop_data.html.string());
328 item.base_url = drop_data.html_base_url;
paulmeyer90f6c31d2016-11-12 00:17:59329 item_list.push_back(item);
330 }
331
Darwin Huangb2ad4892019-05-13 20:15:39332 for (const ui::FileInfo& filename : drop_data.filenames) {
paulmeyer90f6c31d2016-11-12 00:17:59333 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54334 item.storage_type = WebDragData::Item::kStorageTypeFilename;
Darwin Huangb2ad4892019-05-13 20:15:39335 item.filename_data = blink::FilePathToWebString(filename.path);
Blink Reformat1c4d759e2017-04-09 16:34:54336 item.display_name_data =
Darwin Huangb2ad4892019-05-13 20:15:39337 blink::FilePathToWebString(base::FilePath(filename.display_name));
paulmeyer90f6c31d2016-11-12 00:17:59338 item_list.push_back(item);
339 }
340
Darwin Huangb2ad4892019-05-13 20:15:39341 for (const DropData::FileSystemFileInfo& file : drop_data.file_system_files) {
paulmeyer90f6c31d2016-11-12 00:17:59342 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54343 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
Darwin Huangb2ad4892019-05-13 20:15:39344 item.file_system_url = file.url;
345 item.file_system_file_size = file.size;
346 item.file_system_id = blink::WebString::FromASCII(file.filesystem_id);
paulmeyer90f6c31d2016-11-12 00:17:59347 item_list.push_back(item);
348 }
349
Darwin Huangb2ad4892019-05-13 20:15:39350 for (const auto& data : drop_data.custom_data) {
paulmeyer90f6c31d2016-11-12 00:17:59351 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54352 item.storage_type = WebDragData::Item::kStorageTypeString;
Darwin Huangb2ad4892019-05-13 20:15:39353 item.string_type = WebString::FromUTF16(data.first);
354 item.string_data = WebString::FromUTF16(data.second);
paulmeyer90f6c31d2016-11-12 00:17:59355 item_list.push_back(item);
356 }
357
358 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54359 result.Initialize();
360 result.SetItems(item_list);
361 result.SetFilesystemId(WebString::FromUTF16(drop_data.filesystem_id));
paulmeyer90f6c31d2016-11-12 00:17:59362 return result;
363}
364
dtapuskac4dd5be2016-10-25 15:11:10365ui::TextInputType ConvertWebTextInputType(blink::WebTextInputType type) {
366 // Check the type is in the range representable by ui::TextInputType.
367 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX))
368 << "blink::WebTextInputType and ui::TextInputType not synchronized";
369 return static_cast<ui::TextInputType>(type);
370}
371
372ui::TextInputMode ConvertWebTextInputMode(blink::WebTextInputMode mode) {
373 // Check the mode is in the range representable by ui::TextInputMode.
374 DCHECK_LE(mode, static_cast<int>(ui::TEXT_INPUT_MODE_MAX))
375 << "blink::WebTextInputMode and ui::TextInputMode not synchronized";
376 return static_cast<ui::TextInputMode>(mode);
377}
378
Mitsuru Oshima3c07b332018-02-06 04:56:50379// Returns true if the device scale is high enough that losing subpixel
380// antialiasing won't have a noticeable effect on text quality.
381static bool DeviceScaleEnsuresTextQuality(float device_scale_factor) {
382#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
383 // On Android, we never have subpixel antialiasing. On Chrome OS we prefer to
384 // composite all scrollers so that we get animated overlay scrollbars.
385 return true;
386#else
387 // 1.5 is a common touchscreen tablet device scale factor. For such
388 // devices main thread antialiasing is a heavy burden.
389 return device_scale_factor >= 1.5f;
390#endif
391}
392
393static bool PreferCompositingToLCDText(CompositorDependencies* compositor_deps,
394 float device_scale_factor) {
395 const base::CommandLine& command_line =
396 *base::CommandLine::ForCurrentProcess();
397 if (command_line.HasSwitch(switches::kDisablePreferCompositingToLCDText))
398 return false;
399 if (command_line.HasSwitch(switches::kEnablePreferCompositingToLCDText))
400 return true;
401 if (!compositor_deps->IsLcdTextEnabled())
402 return true;
Sam Fortiner263211222019-08-09 16:44:41403 if (base::FeatureList::IsEnabled(features::kPreferCompositingToLCDText))
404 return true;
Mitsuru Oshima3c07b332018-02-06 04:56:50405 return DeviceScaleEnsuresTextQuality(device_scale_factor);
406}
407
[email protected]b256eca2013-07-11 10:57:40408} // namespace
409
[email protected]b2e4c70132013-10-03 02:07:51410// RenderWidget ---------------------------------------------------------------
411
Albert J. Wong2727e8a82019-02-15 16:56:11412// static
413void RenderWidget::InstallCreateForFrameHook(
414 CreateRenderWidgetFunction create_widget) {
415 g_create_render_widget_for_frame = create_widget;
416}
417
Erik Chen3433ee02019-08-05 20:14:26418std::unique_ptr<RenderWidget> RenderWidget::CreateForFrame(
Albert J. Wong2727e8a82019-02-15 16:56:11419 int32_t widget_routing_id,
420 CompositorDependencies* compositor_deps,
421 const ScreenInfo& screen_info,
422 blink::WebDisplayMode display_mode,
423 bool is_frozen,
Erik Chen10e9b022019-08-21 23:33:23424 bool never_visible) {
Albert J. Wong2727e8a82019-02-15 16:56:11425 if (g_create_render_widget_for_frame) {
Erik Chen10e9b022019-08-21 23:33:23426 return g_create_render_widget_for_frame(widget_routing_id, compositor_deps,
427 screen_info, display_mode,
428 is_frozen, never_visible, nullptr);
Albert J. Wong2727e8a82019-02-15 16:56:11429 }
430
Erik Chen3433ee02019-08-05 20:14:26431 return std::make_unique<RenderWidget>(
Albert J. Wong2727e8a82019-02-15 16:56:11432 widget_routing_id, compositor_deps, screen_info, display_mode, is_frozen,
Erik Chen10e9b022019-08-21 23:33:23433 /*hidden=*/true, never_visible, nullptr);
Albert J. Wong2727e8a82019-02-15 16:56:11434}
435
Erik Chen3433ee02019-08-05 20:14:26436RenderWidget* RenderWidget::CreateForPopup(
Albert J. Wong2727e8a82019-02-15 16:56:11437 int32_t widget_routing_id,
438 CompositorDependencies* compositor_deps,
439 const ScreenInfo& screen_info,
440 blink::WebDisplayMode display_mode,
441 bool is_frozen,
442 bool hidden,
443 bool never_visible,
444 mojom::WidgetRequest widget_request) {
Erik Chen3433ee02019-08-05 20:14:26445 return new RenderWidget(widget_routing_id, compositor_deps, screen_info,
446 display_mode, is_frozen, hidden, never_visible,
447 std::move(widget_request));
Albert J. Wong2727e8a82019-02-15 16:56:11448}
449
danakj829cdd142018-09-14 21:13:27450RenderWidget::RenderWidget(int32_t widget_routing_id,
451 CompositorDependencies* compositor_deps,
danakj829cdd142018-09-14 21:13:27452 const ScreenInfo& screen_info,
453 blink::WebDisplayMode display_mode,
danakj6dcbc5962018-11-16 16:45:42454 bool is_frozen,
danakj829cdd142018-09-14 21:13:27455 bool hidden,
456 bool never_visible,
457 mojom::WidgetRequest widget_request)
nick8331f8ad2016-11-15 20:42:45458 : routing_id_(widget_routing_id),
dcheng35d31c112015-07-22 00:17:36459 compositor_deps_(compositor_deps),
[email protected]1ac10dca2013-08-20 20:47:04460 is_hidden_(hidden),
danakj2d2889a2019-04-05 21:22:08461 compositor_never_visible_(never_visible),
danakj73dd3032018-07-28 17:49:53462 display_mode_(display_mode),
danakj6dcbc5962018-11-16 16:45:42463 is_frozen_(is_frozen),
AJITH KUMAR V041c0b02017-08-08 10:39:20464 next_previous_flags_(kInvalidNextPreviousFlagsValue),
Scott Violetae08f332018-07-27 17:37:23465 screen_info_(screen_info),
samans26510e442017-06-01 22:29:12466 frame_swap_message_queue_(new FrameSwapMessageQueue(routing_id_)),
danakj2d2889a2019-04-05 21:22:08467 widget_binding_(this, std::move(widget_request)) {
nick8331f8ad2016-11-15 20:42:45468 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
Avi Drissman07d22452019-03-25 17:56:39469 DCHECK(RenderThread::IsMainThread());
alexclarke7fa93942015-10-21 15:37:11470
471 // In tests there may not be a RenderThreadImpl.
472 if (RenderThreadImpl::current()) {
473 render_widget_scheduling_state_ = RenderThreadImpl::current()
Yuta Kitamura3331f5c2018-04-05 11:12:25474 ->GetWebMainThreadScheduler()
dcheng07945f632015-12-26 07:59:32475 ->NewRenderWidgetSchedulingState();
alexclarke7fa93942015-10-21 15:37:11476 render_widget_scheduling_state_->SetHidden(is_hidden_);
477 }
Albert J. Wongcb004632018-07-10 22:58:25478
479 if (routing_id_ != MSG_ROUTING_NONE)
480 g_routing_id_widget_map.Get().emplace(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29481}
482
483RenderWidget::~RenderWidget() {
lfg8ff33912016-09-13 20:59:21484 DCHECK(!webwidget_internal_) << "Leaking our WebWidget!";
Erik Chen3433ee02019-08-05 20:14:26485 DCHECK(closed_)
486 << " RenderWidget must be destroyed via RenderWidget::Close()";
Albert J. Wong7bbf22d2018-12-20 00:27:27487
Albert J. Wongcb004632018-07-10 22:58:25488 // TODO(ajwong): Add in check that routing_id_ has been removed from
489 // g_routing_id_widget_map once the shutdown semantics for RenderWidget
490 // and RenderViewImpl are rationalized. Currently, too many unit and
491 // browser tests delete a RenderWidget without correclty going through
492 // the shutdown. https://crbug.com/545684
initial.commit09911bf2008-07-26 23:55:29493}
494
[email protected]484955942010-08-19 16:13:18495// static
Albert J. Wongcb004632018-07-10 22:58:25496RenderWidget* RenderWidget::FromRoutingID(int32_t routing_id) {
Avi Drissman07d22452019-03-25 17:56:39497 DCHECK(RenderThread::IsMainThread());
Albert J. Wongcb004632018-07-10 22:58:25498 RoutingIDWidgetMap* widgets = g_routing_id_widget_map.Pointer();
jdoerrie5a73d0fa2018-10-02 23:54:05499 auto it = widgets->find(routing_id);
Albert J. Wongcb004632018-07-10 22:58:25500 return it == widgets->end() ? NULL : it->second;
501}
502
danakj25ec6e2b2018-09-26 17:01:31503void RenderWidget::InitForPopup(ShowCallback show_callback,
504 blink::WebPagePopup* web_page_popup) {
Erik Chen3433ee02019-08-05 20:14:26505 popup_ = true;
danakj25ec6e2b2018-09-26 17:01:31506 Init(std::move(show_callback), web_page_popup);
initial.commit09911bf2008-07-26 23:55:29507}
508
danakj6a816592018-09-25 18:30:56509void RenderWidget::InitForChildLocalRoot(
510 blink::WebFrameWidget* web_frame_widget) {
danakj6dcbc5962018-11-16 16:45:42511 for_child_local_root_frame_ = true;
danakj6a816592018-09-25 18:30:56512 // Init() increments the reference count on |this|, making it
513 // self-referencing.
514 Init(base::NullCallback(), web_frame_widget);
dchengda9b4bb2015-07-20 20:58:08515}
516
Erik Chen3433ee02019-08-05 20:14:26517void RenderWidget::CloseForFrame(std::unique_ptr<RenderWidget> widget) {
danakj8f0bd6c2019-03-14 15:35:24518 DCHECK(for_child_local_root_frame_);
Erik Chen3433ee02019-08-05 20:14:26519 PrepareForClose();
520
521 // The RenderWidget may be deattached from JS, which in turn may be called
522 // in a re-entrant context. We cannot synchronously destroy the object, so we
523 // post a task to do so later.
524 GetCleanupTaskRunner()->PostNonNestableTask(
525 FROM_HERE,
526 base::BindOnce(&RenderWidget::Close, close_weak_ptr_factory_.GetWeakPtr(),
527 std::move(widget)));
kenrba7199832015-01-22 23:44:59528}
529
Scott Violetae08f332018-07-27 17:37:23530void RenderWidget::Init(ShowCallback show_callback, WebWidget* web_widget) {
lfg8ff33912016-09-13 20:59:21531 DCHECK(!webwidget_internal_);
nick4df698d82016-11-11 20:39:23532 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29533
danakj17216f4d2018-10-16 22:57:32534 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
535
Jeremy Roman04f27c372017-10-27 15:20:55536 input_handler_ = std::make_unique<RenderWidgetInputHandler>(this, this);
nick8331f8ad2016-11-15 20:42:45537
danakj17216f4d2018-10-16 22:57:32538 LayerTreeView* layer_tree_view = InitializeLayerTreeView();
Erik Chena2819852019-08-28 01:02:28539
540 // TODO(https://crbug.com/995981): This conditional is temporary logic to
541 // handle the case of remote main frame RenderWidgets [which shouldn't exist
542 // to begin with].
543 if (web_widget)
544 web_widget->SetAnimationHost(layer_tree_view->animation_host());
Dave Tapuska9db80842017-07-24 17:24:26545
danakj31699d5b2018-09-18 15:39:17546 blink::scheduler::WebThreadScheduler* main_thread_scheduler = nullptr;
547 if (render_thread_impl)
548 main_thread_scheduler = render_thread_impl->GetWebMainThreadScheduler();
Alexander Timin41e917d2018-07-02 16:25:35549 blink::scheduler::WebThreadScheduler* compositor_thread_scheduler =
550 blink::scheduler::WebThreadScheduler::CompositorThreadScheduler();
danakj31699d5b2018-09-18 15:39:17551 scoped_refptr<base::SingleThreadTaskRunner> compositor_input_task_runner;
danakj89ae4532018-12-12 22:52:55552 // Use the compositor thread task runner unless this is a popup or other such
553 // non-frame widgets. The |compositor_thread_scheduler| can be null in tests
554 // without a compositor thread.
555 if (for_frame() && compositor_thread_scheduler) {
556 compositor_input_task_runner =
557 compositor_thread_scheduler->InputTaskRunner();
danakj31699d5b2018-09-18 15:39:17558 }
Alexander Timin41e917d2018-07-02 16:25:35559
David Bokan3fc68482019-03-13 04:48:49560 // We only use an external input handler for frame RenderWidgets because only
561 // frames use the compositor for input handling. Other kinds of RenderWidgets
562 // (e.g. popups, plugins) must forward their input directly through
563 // RenderWidgetInputHandler into Blink.
564 bool uses_input_handler = for_frame();
Dave Tapuska04bc5ee92018-04-17 19:03:31565 widget_input_handler_manager_ = WidgetInputHandlerManager::Create(
danakj31699d5b2018-09-18 15:39:17566 weak_ptr_factory_.GetWeakPtr(), std::move(compositor_input_task_runner),
David Bokan3fc68482019-03-13 04:48:49567 main_thread_scheduler, uses_input_handler);
Stephen Chenneybccdd0302019-08-15 12:21:28568 base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
569 if (command_line->HasSwitch(switches::kAllowPreCommitInput))
Stephen Chenney1b197822019-09-04 14:25:48570 widget_input_handler_manager_->AllowPreCommitInput();
Dave Tapuska9db80842017-07-24 17:24:26571
danakjdf1ceb72018-07-18 20:02:25572 show_callback_ = std::move(show_callback);
initial.commit09911bf2008-07-26 23:55:29573
lfg8ff33912016-09-13 20:59:21574 webwidget_internal_ = web_widget;
Erik Chen7b985822019-08-30 00:39:12575 webwidget_mouse_lock_target_.reset(new WebWidgetLockTarget(this));
lfgbee1e0a2016-06-08 21:24:21576 mouse_lock_dispatcher_.reset(new RenderWidgetMouseLockDispatcher(this));
initial.commit09911bf2008-07-26 23:55:29577
nick4df698d82016-11-11 20:39:23578 RenderThread::Get()->AddRoute(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29579}
580
danakj53802692018-07-25 21:46:44581void RenderWidget::ApplyEmulatedScreenMetricsForPopupWidget(
582 RenderWidget* origin_widget) {
583 RenderWidgetScreenMetricsEmulator* emulator =
584 origin_widget->screen_metrics_emulator_.get();
585 if (!emulator)
586 return;
[email protected]b2e4c70132013-10-03 02:07:51587 popup_origin_scale_for_emulation_ = emulator->scale();
[email protected]19193682014-04-03 15:01:43588 popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
Pavel Feldmancc099f72017-07-20 23:09:00589 popup_screen_origin_for_emulation_ =
Lei Zhang9b359d32017-11-28 00:57:02590 emulator->original_screen_rect().origin();
Fady Samuel1c1ad3692018-11-06 23:28:40591 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
W. James MacLean7df854c2019-08-28 16:17:53592 CompositorViewportRect(),
Fady Samuel1c1ad3692018-11-06 23:28:40593 emulator->original_screen_info());
[email protected]b2e4c70132013-10-03 02:07:51594}
595
[email protected]2d6836f42014-07-02 17:25:31596gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) {
597 if (screen_metrics_emulator_)
598 return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor);
599 return anchor;
600}
601
thakis18e426412017-03-15 12:06:37602#if BUILDFLAG(USE_EXTERNAL_POPUP_MENU)
[email protected]b2e4c70132013-10-03 02:07:51603void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
Albert J. Wong7bbf22d2018-12-20 00:27:27604 ExternalPopupMenu* popup) {
605 if (screen_metrics_emulator_)
606 popup->SetOriginScaleForEmulation(screen_metrics_emulator_->scale());
[email protected]b2e4c70132013-10-03 02:07:51607}
[email protected]53907862014-03-25 15:42:40608#endif
[email protected]b2e4c70132013-10-03 02:07:51609
610void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
611 if (screen_metrics_emulator_)
612 screen_metrics_emulator_->OnShowContextMenu(params);
613}
614
[email protected]a95986a82010-12-24 06:19:28615bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
ekaramad330ba4232016-09-23 17:57:47616#if defined(OS_MACOSX)
617 if (IPC_MESSAGE_CLASS(message) == TextInputClientMsgStart)
618 return text_input_client_observer_->OnMessageReceived(message);
619#endif
lfgbee1e0a2016-06-08 21:24:21620 if (mouse_lock_dispatcher_ &&
621 mouse_lock_dispatcher_->OnMessageReceived(message))
622 return true;
623
[email protected]a95986a82010-12-24 06:19:28624 bool handled = true;
625 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
Albert J. Wong3c93c182018-09-27 17:29:43626 IPC_MESSAGE_HANDLER(WidgetMsg_ShowContextMenu, OnShowContextMenu)
627 IPC_MESSAGE_HANDLER(WidgetMsg_Close, OnClose)
628 IPC_MESSAGE_HANDLER(WidgetMsg_SynchronizeVisualProperties,
Fady Samuel799e72192018-04-25 21:16:57629 OnSynchronizeVisualProperties)
Albert J. Wong3c93c182018-09-27 17:29:43630 IPC_MESSAGE_HANDLER(WidgetMsg_EnableDeviceEmulation,
dgozman9260b0a12015-03-16 13:45:20631 OnEnableDeviceEmulation)
Albert J. Wong3c93c182018-09-27 17:29:43632 IPC_MESSAGE_HANDLER(WidgetMsg_DisableDeviceEmulation,
dgozman9260b0a12015-03-16 13:45:20633 OnDisableDeviceEmulation)
Albert J. Wong3c93c182018-09-27 17:29:43634 IPC_MESSAGE_HANDLER(WidgetMsg_WasHidden, OnWasHidden)
635 IPC_MESSAGE_HANDLER(WidgetMsg_WasShown, OnWasShown)
636 IPC_MESSAGE_HANDLER(WidgetMsg_SetActive, OnSetActive)
Albert J. Wong3c93c182018-09-27 17:29:43637 IPC_MESSAGE_HANDLER(WidgetMsg_SetTextDirection, OnSetTextDirection)
638 IPC_MESSAGE_HANDLER(WidgetMsg_SetBounds_ACK, OnRequestSetBoundsAck)
639 IPC_MESSAGE_HANDLER(WidgetMsg_UpdateScreenRects, OnUpdateScreenRects)
640 IPC_MESSAGE_HANDLER(WidgetMsg_ForceRedraw, OnForceRedraw)
641 IPC_MESSAGE_HANDLER(WidgetMsg_SetViewportIntersection,
kenrbea731792017-01-13 15:10:48642 OnSetViewportIntersection)
Albert J. Wong3c93c182018-09-27 17:29:43643 IPC_MESSAGE_HANDLER(WidgetMsg_SetIsInert, OnSetIsInert)
644 IPC_MESSAGE_HANDLER(WidgetMsg_SetInheritedEffectiveTouchAction,
sunxd540a9962018-05-24 22:51:06645 OnSetInheritedEffectiveTouchAction)
Albert J. Wong3c93c182018-09-27 17:29:43646 IPC_MESSAGE_HANDLER(WidgetMsg_UpdateRenderThrottlingStatus,
Ken Buchanan8a319fb2017-11-15 18:37:12647 OnUpdateRenderThrottlingStatus)
Albert J. Wong3c93c182018-09-27 17:29:43648 IPC_MESSAGE_HANDLER(WidgetMsg_WaitForNextFrameForTests,
lfg43e08e62016-02-03 18:51:37649 OnWaitNextFrameForTests)
paulmeyer90f6c31d2016-11-12 00:17:59650 IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter)
651 IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver, OnDragTargetDragOver)
652 IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave, OnDragTargetDragLeave)
653 IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop)
paulmeyer8fc8ea92016-11-15 05:12:21654 IPC_MESSAGE_HANDLER(DragMsg_SourceEnded, OnDragSourceEnded)
655 IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded,
656 OnDragSourceSystemDragEnded)
[email protected]a95986a82010-12-24 06:19:28657 IPC_MESSAGE_UNHANDLED(handled = false)
658 IPC_END_MESSAGE_MAP()
659 return handled;
660}
initial.commit09911bf2008-07-26 23:55:29661
662bool RenderWidget::Send(IPC::Message* message) {
Nasko Oskovf97e8b02017-07-25 02:45:42663 // Don't send any messages after the browser has told us to close, and filter
danakj6dcbc5962018-11-16 16:45:42664 // most outgoing messages when frozen.
665 if (closing_) {
666 delete message;
667 return false;
668 }
danakj3130f122019-07-16 17:49:47669 // TODO(danakj): We believe that we should be able to not block IPC sending.
670 // When there's a provisional main frame using this widget, we should not be
671 // sending messages with the RenderWidget yet. And when the widget is frozen
672 // because there is no local main frame, there should be no code using
673 // RenderWidget and sending messages through it.
674 // We should CHECK() that the RenderWidget is not frozen and that the frame
675 // attached to it is not provisional, instead of dropping messages.
676 if (is_frozen_) {
initial.commit09911bf2008-07-26 23:55:29677 delete message;
678 return false;
679 }
680
681 // If given a messsage without a routing ID, then assign our routing ID.
682 if (message->routing_id() == MSG_ROUTING_NONE)
683 message->set_routing_id(routing_id_);
684
[email protected]380244092011-10-07 17:26:27685 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44686}
687
dtapuska014ed082016-11-11 21:58:48688void RenderWidget::SendOrCrash(IPC::Message* message) {
689 bool result = Send(message);
690 CHECK(closing_ || result) << "Failed to send message";
691}
692
ekaramad5aff1942017-01-06 01:26:35693bool RenderWidget::ShouldHandleImeEvents() const {
Albert J. Wong7bbf22d2018-12-20 00:27:27694 if (delegate())
danakj89ae4532018-12-12 22:52:55695 return has_focus_;
696 if (for_child_local_root_frame_) {
697 // TODO(ekaramad): We track page focus in all RenderViews on the page but
698 // the RenderWidgets corresponding to child local roots do not get the
699 // update. For now, this method returns true when the RenderWidget is for a
700 // child local frame, i.e., IME events will be processed regardless of page
701 // focus. We should revisit this after page focus for OOPIFs has been fully
702 // resolved (https://crbug.com/689777).
703 return true;
704 }
705 // Not a frame widget.
706 return false;
ekaramad5aff1942017-01-06 01:26:35707}
708
initial.commit09911bf2008-07-26 23:55:29709void RenderWidget::OnClose() {
Erik Chen3433ee02019-08-05 20:14:26710 DCHECK(popup_ || pepper_fullscreen_);
711
Erik Chen3433ee02019-08-05 20:14:26712 PrepareForClose();
Erik Chen78d57ea2019-08-30 00:13:42713
714 // IPCs can be invoked from nested message loops. We must dispatch this
715 // task non-nested to avoid re-entrancy issues.
716 GetCleanupTaskRunner()->PostNonNestableTask(
717 FROM_HERE,
718 base::BindOnce(&RenderWidget::Close, close_weak_ptr_factory_.GetWeakPtr(),
719 base::WrapUnique(this)));
Erik Chen3433ee02019-08-05 20:14:26720}
721
722void RenderWidget::PrepareForClose() {
Avi Drissman07d22452019-03-25 17:56:39723 DCHECK(RenderThread::IsMainThread());
dchengd96a27a2015-07-24 20:17:32724 if (closing_)
725 return;
danakj292b63e2018-11-19 20:47:06726 for (auto& observer : render_frames_)
727 observer.WidgetWillClose();
dchengd96a27a2015-07-24 20:17:32728 closing_ = true;
729
730 // Browser correspondence is no longer needed at this point.
731 if (routing_id_ != MSG_ROUTING_NONE) {
732 RenderThread::Get()->RemoveRoute(routing_id_);
Albert J. Wongcb004632018-07-10 22:58:25733 g_routing_id_widget_map.Get().erase(routing_id_);
dchengd96a27a2015-07-24 20:17:32734 }
735
danakj327a4fe2019-01-26 00:00:35736 // Stop handling main thread input events immediately so we don't have them
737 // running while things are partly shut down.
738 if (input_event_queue_)
739 input_event_queue_->ClearClient();
740
Erik Chen3433ee02019-08-05 20:14:26741 CloseWebWidget();
initial.commit09911bf2008-07-26 23:55:29742}
743
Fady Samuel799e72192018-04-25 21:16:57744void RenderWidget::OnSynchronizeVisualProperties(
Albert J. Wong0a918192019-08-28 01:05:28745 const VisualProperties& visual_properties_from_browser) {
danakja2c9d0a92018-07-25 20:01:18746 TRACE_EVENT0("renderer", "RenderWidget::OnSynchronizeVisualProperties");
EhsanKbd2cea992017-11-23 18:49:08747
Albert J. Wong0a918192019-08-28 01:05:28748 VisualProperties visual_properties = visual_properties_from_browser;
danakj01474dd2019-01-28 10:46:04749 // Web tests can override the device scale factor in the renderer.
750 if (device_scale_factor_for_testing_) {
Albert J. Wong0a918192019-08-28 01:05:28751 visual_properties.screen_info.device_scale_factor =
752 device_scale_factor_for_testing_;
753 visual_properties.compositor_viewport_pixel_size = gfx::ScaleToCeiledSize(
754 visual_properties.new_size,
755 visual_properties.screen_info.device_scale_factor);
danakj01474dd2019-01-28 10:46:04756 }
danakj04d128a2019-01-25 02:10:20757
758 // Inform the rendering thread of the color space indicating the presence of
759 // HDR capabilities. The HDR bit happens to be globally true/false for all
760 // browser windows (on Windows OS) and thus would be the same for all
761 // RenderWidgets, so clobbering each other works out since only the HDR bit is
762 // used. See https://crbug.com/803451 and
763 // https://chromium-review.googlesource.com/c/chromium/src/+/852912/15#message-68bbd3e25c3b421a79cd028b2533629527d21fee
764 //
765 // The RenderThreadImpl can be null in tests.
766 {
767 RenderThreadImpl* render_thread = RenderThreadImpl::current();
768 if (render_thread)
Albert J. Wong0a918192019-08-28 01:05:28769 render_thread->SetRenderingColorSpace(
770 visual_properties.screen_info.color_space);
danakj04d128a2019-01-25 02:10:20771 }
772
Albert J. Wong7bbf22d2018-12-20 00:27:27773 if (delegate()) {
Albert J. Wong0a918192019-08-28 01:05:28774 if (size_ != visual_properties.new_size) {
danakj84bbf552019-01-21 21:33:31775 // Only hide popups when the size changes. Eg https://crbug.com/761908.
776 delegate()->CancelPagePopupForWidget();
777 }
danakja2c9d0a92018-07-25 20:01:18778
Albert J. Wong0a918192019-08-28 01:05:28779 if (display_mode_ != visual_properties.display_mode) {
780 display_mode_ = visual_properties.display_mode;
781 delegate()->ApplyNewDisplayModeForWidget(visual_properties.display_mode);
danakja2c9d0a92018-07-25 20:01:18782 }
783
784 bool auto_resize_mode_changed =
Albert J. Wong0a918192019-08-28 01:05:28785 auto_resize_mode_ != visual_properties.auto_resize_enabled;
786 auto_resize_mode_ = visual_properties.auto_resize_enabled;
787 min_size_for_auto_resize_ = visual_properties.min_size_for_auto_resize;
788 max_size_for_auto_resize_ = visual_properties.max_size_for_auto_resize;
danakja2c9d0a92018-07-25 20:01:18789
790 if (auto_resize_mode_) {
791 gfx::Size min_auto_size = min_size_for_auto_resize_;
792 gfx::Size max_auto_size = max_size_for_auto_resize_;
793 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
794 min_auto_size = gfx::ScaleToCeiledSize(
Albert J. Wong0a918192019-08-28 01:05:28795 min_auto_size, visual_properties.screen_info.device_scale_factor);
danakja2c9d0a92018-07-25 20:01:18796 max_auto_size = gfx::ScaleToCeiledSize(
Albert J. Wong0a918192019-08-28 01:05:28797 max_auto_size, visual_properties.screen_info.device_scale_factor);
danakja2c9d0a92018-07-25 20:01:18798 }
Albert J. Wong7bbf22d2018-12-20 00:27:27799 delegate()->ApplyAutoResizeLimitsForWidget(min_auto_size, max_auto_size);
danakja2c9d0a92018-07-25 20:01:18800 } else if (auto_resize_mode_changed) {
Albert J. Wong7bbf22d2018-12-20 00:27:27801 delegate()->DisableAutoResizeForWidget();
Albert J. Wong0a918192019-08-28 01:05:28802 if (visual_properties.new_size.IsEmpty())
danakja2c9d0a92018-07-25 20:01:18803 return;
804 }
805
806 browser_controls_shrink_blink_size_ =
Albert J. Wong0a918192019-08-28 01:05:28807 visual_properties.browser_controls_shrink_blink_size;
808 top_controls_height_ = visual_properties.top_controls_height;
809 bottom_controls_height_ = visual_properties.bottom_controls_height;
[email protected]b2e4c70132013-10-03 02:07:51810 }
811
danakj7602f4f2019-01-31 18:03:23812 bool ignore_resize_ipc = false;
813 if (synchronous_resize_mode_for_testing_) {
814 // We can ignore browser-initialized resizing during synchronous
815 // (renderer-controlled) mode, unless it is switching us to/from
816 // fullsreen mode or changing the device scale factor.
817 // TODO(danakj): Does the browser actually change DSF inside a web test??
818 // TODO(danakj): Isn't the display mode check redundant with the fullscreen
819 // one?
Albert J. Wong0a918192019-08-28 01:05:28820 if (visual_properties.is_fullscreen_granted == is_fullscreen_granted_ &&
821 visual_properties.display_mode == display_mode_ &&
822 visual_properties.screen_info.device_scale_factor ==
danakj7602f4f2019-01-31 18:03:23823 screen_info_.device_scale_factor)
824 ignore_resize_ipc = true;
825 }
826
827 // When controlling the size in the renderer, we should ignore sizes given by
828 // the browser IPC here.
829 // TODO(danakj): There are many things also being ignored that aren't the
830 // widget's size params. It works because tests that use this mode don't
831 // change those parameters, I guess. But it's more complicated then because it
832 // looks like they are related to sync resize mode. Let's move them out of
833 // this block.
834 // TODO(danakj): It would be nice if we can still use the emulator to emulate
835 // things other than the size if we are in sync resize mode - if the emulator
836 // is even used in sync resize tests. It probably isn't though, so either way
837 // it'd be good to get the emulator out of this block (maybe by overwriting
Albert J. Wong0a918192019-08-28 01:05:28838 // some of |visual_properties| in sync resize mode instead of just
839 // skipping the emulator.
danakj7602f4f2019-01-31 18:03:23840 if (!ignore_resize_ipc) {
danakja2c9d0a92018-07-25 20:01:18841 if (screen_metrics_emulator_) {
danakj7602f4f2019-01-31 18:03:23842 // This will call our SynchronizeVisualProperties() method with a
843 // different set of VisualProperties, holding emulated values. Though not
844 // all VisualProperties are modified by the metrics emulator, so it's a
845 // bit unclear to do this with the full structure. Anything it does not
846 // modify can be consumed directly here instead of in
847 // SynchronizeVisualProperties().
Albert J. Wong0a918192019-08-28 01:05:28848 screen_metrics_emulator_->OnSynchronizeVisualProperties(
849 visual_properties);
danakja2c9d0a92018-07-25 20:01:18850 } else {
danakj0246bba02019-01-23 23:12:27851 if (!delegate()) {
852 // The main frame controls the page scale factor, from blink. For other
853 // frame widgets, the page scale is received from its parent as part of
854 // the visual properties here. While blink doesn't need to know this
855 // page scale factor outside the main frame, the compositor does in
856 // order to produce its output at the correct scale.
W. James MacLean2cd99b62019-04-08 13:54:43857 layer_tree_view_->SetExternalPageScaleFactor(
Albert J. Wong0a918192019-08-28 01:05:28858 visual_properties.page_scale_factor,
859 visual_properties.is_pinch_gesture_active);
danakj0246bba02019-01-23 23:12:27860 // Store the value to give to any new RenderFrameProxy that is
861 // registered.
Albert J. Wong0a918192019-08-28 01:05:28862 page_scale_factor_from_mainframe_ = visual_properties.page_scale_factor;
W. James MacLean2cd99b62019-04-08 13:54:43863 // Similarly, only the main frame knows when a pinch gesture is active,
864 // but this information is needed in subframes so they can throttle
865 // re-rastering in the same manner as the main frame.
866 // |is_pinch_gesture_active| follows the same path to the subframe
867 // compositor(s) as |page_scale_factor|.
868 is_pinch_gesture_active_from_mainframe_ =
Albert J. Wong0a918192019-08-28 01:05:28869 visual_properties.is_pinch_gesture_active;
danakj0246bba02019-01-23 23:12:27870 // Push the page scale factor down to any child RenderWidgets via our
871 // child proxy frames.
872 // TODO(danakj): This ends up setting the page scale factor in the
873 // RenderWidgetHost of the child RenderWidget, so that it can bounce
874 // the value down to its RenderWidget. Since this is essentially a
875 // global value per-page, we could instead store it once in the browser
876 // (such as in RenderViewHost) and distribute it to each frame-hosted
877 // RenderWidget from there.
W. James MacLean2cd99b62019-04-08 13:54:43878 for (auto& child_proxy : render_frame_proxies_) {
Albert J. Wong0a918192019-08-28 01:05:28879 child_proxy.OnPageScaleFactorChanged(
880 visual_properties.page_scale_factor,
881 visual_properties.is_pinch_gesture_active);
W. James MacLean2cd99b62019-04-08 13:54:43882 }
danakj0246bba02019-01-23 23:12:27883 }
884
danakja2c9d0a92018-07-25 20:01:18885 gfx::Size old_visible_viewport_size = visible_viewport_size_;
Albert J. Wong0a918192019-08-28 01:05:28886 SynchronizeVisualProperties(visual_properties);
danakja2c9d0a92018-07-25 20:01:18887 if (old_visible_viewport_size != visible_viewport_size_) {
888 for (auto& render_frame : render_frames_)
Sushanth Rajasankarceaee202019-03-18 15:44:17889 render_frame.ResetHasScrolledFocusedEditableIntoView();
danakja2c9d0a92018-07-25 20:01:18890 }
891 }
Fady Samuel799e72192018-04-25 21:16:57892 }
893
Sushanth Rajasankarceaee202019-03-18 15:44:17894 // TODO(crbug.com/939118): ScrollFocusedNodeIntoViewForWidget does not work
895 // when the focused node is inside an OOPIF. This code path where
896 // scroll_focused_node_into_view is set is used only for WebView, crbug
897 // 939118 tracks fixing webviews to not use scroll_focused_node_into_view.
Albert J. Wong0a918192019-08-28 01:05:28898 if (delegate() && visual_properties.scroll_focused_node_into_view)
Albert J. Wong7bbf22d2018-12-20 00:27:27899 delegate()->ScrollFocusedNodeIntoViewForWidget();
initial.commit09911bf2008-07-26 23:55:29900}
901
dgozman9260b0a12015-03-16 13:45:20902void RenderWidget::OnEnableDeviceEmulation(
Lei Zhang9b359d32017-11-28 00:57:02903 const blink::WebDeviceEmulationParams& params) {
mfomitchev2600fd7c2016-02-17 20:53:39904 if (!screen_metrics_emulator_) {
Fady Samuel4255c182018-05-24 20:42:36905 VisualProperties visual_properties;
906 visual_properties.screen_info = screen_info_;
907 visual_properties.new_size = size_;
W. James MacLean7df854c2019-08-28 16:17:53908 visual_properties.compositor_viewport_pixel_size =
909 CompositorViewportRect().size();
Fady Samuel84d8a1f72018-11-08 00:26:17910 visual_properties.local_surface_id_allocation =
911 local_surface_id_allocation_from_parent_;
Fady Samuel4255c182018-05-24 20:42:36912 visual_properties.visible_viewport_size = visible_viewport_size_;
913 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
914 visual_properties.display_mode = display_mode_;
mfomitchev2600fd7c2016-02-17 20:53:39915 screen_metrics_emulator_.reset(new RenderWidgetScreenMetricsEmulator(
Albert J. Wong3c93c182018-09-27 17:29:43916 this, params, visual_properties, widget_screen_rect_,
Fady Samuel4255c182018-05-24 20:42:36917 window_screen_rect_));
oshima50872a72016-03-04 13:26:18918 screen_metrics_emulator_->Apply();
mfomitchev2600fd7c2016-02-17 20:53:39919 } else {
dgozman9260b0a12015-03-16 13:45:20920 screen_metrics_emulator_->ChangeEmulationParams(params);
mfomitchev2600fd7c2016-02-17 20:53:39921 }
dgozman9260b0a12015-03-16 13:45:20922}
923
924void RenderWidget::OnDisableDeviceEmulation() {
925 screen_metrics_emulator_.reset();
926}
927
initial.commit09911bf2008-07-26 23:55:29928void RenderWidget::OnWasHidden() {
danakj14e00a8322019-02-07 17:12:06929 // A frozen main frame widget will never be hidden since that would require it
930 // to be shown first. It must be thawed before changing visibility.
931 DCHECK(!is_frozen_);
932
[email protected]9c3085f2011-06-09 02:10:31933 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
danakj14e00a8322019-02-07 17:12:06934
[email protected]bee16aab2009-08-26 15:55:03935 SetHidden(true);
danakj14e00a8322019-02-07 17:12:06936
Francois Doray687e70a2019-05-16 02:24:55937 tab_switch_time_recorder_.TabWasHidden();
938
ericwilligers88e69742016-10-17 19:29:55939 for (auto& observer : render_frames_)
940 observer.WasHidden();
initial.commit09911bf2008-07-26 23:55:29941}
942
Sebastien Marchand5f06ca32019-05-17 18:03:42943void RenderWidget::OnWasShown(
944 base::TimeTicks show_request_timestamp,
945 bool was_evicted,
946 const base::Optional<content::RecordTabSwitchTimeRequest>&
947 record_tab_switch_time_request) {
danakj14e00a8322019-02-07 17:12:06948 // A frozen main frame widget does not become shown, since it has no frame
949 // associated with it. It must be thawed before changing visibility.
950 DCHECK(!is_frozen_);
951
Edwin Joea4069f42019-02-20 15:06:24952 TRACE_EVENT_WITH_FLOW0("renderer", "RenderWidget::OnWasShown", routing_id(),
953 TRACE_EVENT_FLAG_FLOW_IN);
danakj678f0252018-11-09 21:46:34954
tasakb95dbb50c2017-02-08 18:07:50955 was_shown_time_ = base::TimeTicks::Now();
danakj14e00a8322019-02-07 17:12:06956
[email protected]bee16aab2009-08-26 15:55:03957 SetHidden(false);
Sebastien Marchand5f06ca32019-05-17 18:03:42958 if (record_tab_switch_time_request) {
danakja6c10012018-07-06 14:25:36959 layer_tree_view_->layer_tree_host()->RequestPresentationTimeForNextFrame(
Sebastien Marchand5f06ca32019-05-17 18:03:42960 tab_switch_time_recorder_.TabWasShown(
961 false /* has_saved_frames */,
962 record_tab_switch_time_request.value(), show_request_timestamp));
[email protected]3399dd822014-08-09 11:14:24963 }
danakj14e00a8322019-02-07 17:12:06964
965 for (auto& observer : render_frames_)
966 observer.WasShown();
967 if (was_evicted) {
968 for (auto& observer : render_frame_proxies_)
969 observer.WasEvicted();
970 }
initial.commit09911bf2008-07-26 23:55:29971}
972
Avi Drissman014dec72018-06-07 02:34:01973void RenderWidget::OnRequestSetBoundsAck() {
[email protected]53d3f302009-12-21 04:42:05974 DCHECK(pending_window_rect_count_);
975 pending_window_rect_count_--;
976}
977
Albert J. Wongcb004632018-07-10 22:58:25978void RenderWidget::OnForceRedraw(int snapshot_id) {
David Bokanf92eaf22019-03-01 01:54:51979 RequestPresentation(base::BindOnce(&RenderWidget::DidPresentForceDrawFrame,
980 weak_ptr_factory_.GetWeakPtr(),
981 snapshot_id));
982}
983
984void RenderWidget::RequestPresentation(PresentationTimeCallback callback) {
danakj125a29e2019-01-24 23:25:29985 layer_tree_view_->layer_tree_host()->RequestPresentationTimeForNextFrame(
David Bokanf92eaf22019-03-01 01:54:51986 std::move(callback));
danakjda15621e2019-04-05 20:34:43987 layer_tree_view_->layer_tree_host()->SetNeedsCommitWithForcedRedraw();
Albert J. Wongcb004632018-07-10 22:58:25988}
989
990void RenderWidget::DidPresentForceDrawFrame(
991 int snapshot_id,
992 const gfx::PresentationFeedback& feedback) {
Albert J. Wong3c93c182018-09-27 17:29:43993 Send(new WidgetHostMsg_ForceRedrawComplete(routing_id(), snapshot_id));
Albert J. Wongcb004632018-07-10 22:58:25994}
995
Xianzhu Wangf02017ac2018-10-17 01:47:33996viz::FrameSinkId RenderWidget::GetFrameSinkIdAtPoint(const gfx::PointF& point,
Ken Buchanan44d7e2f2018-08-23 14:18:05997 gfx::PointF* local_point) {
998 return input_handler_->GetFrameSinkIdAtPoint(point, local_point);
Navid Zolghadr0d86e5f2017-10-23 18:09:22999}
1000
danakj77821e252019-03-27 19:58:041001bool RenderWidget::HasPendingPageScaleAnimation() const {
1002 return layer_tree_view_->layer_tree_host()->HasPendingPageScaleAnimation();
1003}
1004
danakj327a4fe2019-01-26 00:00:351005bool RenderWidget::HandleInputEvent(
dtapuska9ec1a912017-04-21 15:18:311006 const blink::WebCoalescedInputEvent& input_event,
1007 const ui::LatencyInfo& latency_info,
Dave Tapuskaea83d3bd2017-06-13 16:14:551008 HandledEventCallback callback) {
danakj327a4fe2019-01-26 00:00:351009 if (is_frozen_)
1010 return false;
Dave Tapuskaea83d3bd2017-06-13 16:14:551011 input_handler_->HandleInputEvent(input_event, latency_info,
1012 std::move(callback));
danakj327a4fe2019-01-26 00:00:351013 return true;
dtapuska9ec1a912017-04-21 15:18:311014}
1015
danakj125a29e2019-01-24 23:25:291016void RenderWidget::SetNeedsMainFrame() {
danakj0719e0652019-03-14 21:19:111017 ScheduleAnimation();
danakj125a29e2019-01-24 23:25:291018}
1019
dtapuska9d46ef7d2017-05-26 19:06:061020scoped_refptr<MainThreadEventQueue> RenderWidget::GetInputEventQueue() {
1021 return input_event_queue_;
1022}
1023
fsamuel78f86e42016-01-20 04:10:231024void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
lfg8ff33912016-09-13 20:59:211025 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:541026 GetWebWidget()->SetCursorVisibilityState(is_visible);
fsamuel78f86e42016-01-20 04:10:231027}
1028
[email protected]76b082c2019-03-22 03:45:461029void RenderWidget::OnFallbackCursorModeToggled(bool is_on) {
1030 if (GetWebWidget())
1031 GetWebWidget()->OnFallbackCursorModeToggled(is_on);
1032}
1033
fsamuel78f86e42016-01-20 04:10:231034void RenderWidget::OnMouseCaptureLost() {
lfg8ff33912016-09-13 20:59:211035 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:541036 GetWebWidget()->MouseCaptureLost();
fsamuel78f86e42016-01-20 04:10:231037}
1038
alexmos56567492016-09-13 00:52:461039void RenderWidget::OnSetEditCommandsForNextKeyEvent(
1040 const EditCommands& edit_commands) {
1041 edit_commands_ = edit_commands;
1042}
1043
Albert J. Wongcb004632018-07-10 22:58:251044void RenderWidget::OnSetActive(bool active) {
Albert J. Wong7bbf22d2018-12-20 00:27:271045 if (delegate())
1046 delegate()->SetActiveForWidget(active);
Albert J. Wongcb004632018-07-10 22:58:251047}
1048
fsamuel78f86e42016-01-20 04:10:231049void RenderWidget::OnSetFocus(bool enable) {
Albert J. Wong7bbf22d2018-12-20 00:27:271050 if (delegate())
1051 delegate()->DidReceiveSetFocusEventForWidget();
danakja2c9d0a92018-07-25 20:01:181052 SetFocus(enable);
1053}
1054
1055void RenderWidget::SetFocus(bool enable) {
lfge0c2792ec2016-05-11 18:52:081056 has_focus_ = enable;
1057
lfg8ff33912016-09-13 20:59:211058 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:541059 GetWebWidget()->SetFocus(enable);
lfge0c2792ec2016-05-11 18:52:081060
ericwilligers88e69742016-10-17 19:29:551061 for (auto& observer : render_frames_)
1062 observer.RenderWidgetSetFocus(enable);
danakja2c9d0a92018-07-25 20:01:181063
Erik Chene8e50c622019-08-28 01:57:491064 // Notify all BrowserPlugins of the RenderView's focus state.
1065 if (BrowserPluginManager::Get())
1066 BrowserPluginManager::Get()->UpdateFocusState();
fsamuel78f86e42016-01-20 04:10:231067}
1068
1069///////////////////////////////////////////////////////////////////////////////
danakja6c10012018-07-06 14:25:361070// LayerTreeViewDelegate
fsamuel78f86e42016-01-20 04:10:231071
David Bokanc8e38d02018-10-08 21:56:011072void RenderWidget::ApplyViewportChanges(
1073 const cc::ApplyViewportChangesArgs& args) {
Ken Buchananed449bb2018-02-01 21:02:051074 if (!GetWebWidget())
1075 return;
David Bokanc8e38d02018-10-08 21:56:011076 GetWebWidget()->ApplyViewportChanges(args);
fsamuel78f86e42016-01-20 04:10:231077}
1078
Allison Pastewka5ac6e7eb2019-06-11 23:13:471079void RenderWidget::RecordManipulationTypeCounts(cc::ManipulationInfo info) {
Ken Buchananed449bb2018-02-01 21:02:051080 if (!GetWebWidget())
1081 return;
Allison Pastewka5ac6e7eb2019-06-11 23:13:471082 GetWebWidget()->RecordManipulationTypeCounts(info);
sahel1b47fda72017-03-28 17:03:071083}
1084
Sahel Sharify676580c2019-01-10 21:49:491085void RenderWidget::SendOverscrollEventFromImplSide(
1086 const gfx::Vector2dF& overscroll_delta,
1087 cc::ElementId scroll_latched_element_id) {
1088 if (!GetWebWidget())
1089 return;
1090 GetWebWidget()->SendOverscrollEventFromImplSide(overscroll_delta,
1091 scroll_latched_element_id);
1092}
1093void RenderWidget::SendScrollEndEventFromImplSide(
1094 cc::ElementId scroll_latched_element_id) {
1095 if (!GetWebWidget())
1096 return;
1097 GetWebWidget()->SendScrollEndEventFromImplSide(scroll_latched_element_id);
1098}
1099
Daniel Cheng224569ee2018-04-25 05:45:061100void RenderWidget::BeginMainFrame(base::TimeTicks frame_time) {
Ken Buchananed449bb2018-02-01 21:02:051101 if (!GetWebWidget())
1102 return;
dtapuska3d5624d32016-08-30 04:34:001103
danakj22b4e8b2019-08-01 23:14:391104 DCHECK(!is_frozen_);
1105
Stephen Chenneyd56b5382019-01-29 00:37:021106 // We record metrics only when running in multi-threaded mode, not
1107 // single-thread mode for testing.
1108 bool record_main_frame_metrics =
1109 !!compositor_deps_->GetCompositorImplThreadTaskRunner();
1110 if (input_event_queue_) {
1111 base::Optional<ScopedUkmRafAlignedInputTimer> ukm_timer;
Stephen Chenney1d064cf2019-06-06 14:54:101112 if (record_main_frame_metrics) {
Stephen Chenneyd56b5382019-01-29 00:37:021113 ukm_timer.emplace(GetWebWidget());
Stephen Chenney1d064cf2019-06-06 14:54:101114 }
Stephen Chenneyd56b5382019-01-29 00:37:021115 input_event_queue_->DispatchRafAlignedInput(frame_time);
1116 }
1117
Stephen Chenneyd56b5382019-01-29 00:37:021118 GetWebWidget()->BeginFrame(frame_time, record_main_frame_metrics);
fsamuel78f86e42016-01-20 04:10:231119}
1120
Stephen Chenney1b197822019-09-04 14:25:481121void RenderWidget::OnDeferMainFrameUpdatesChanged(bool deferral_state) {
1122 // The input handler wants to know about the mainframe update status to
1123 // enable/disable input and for metrics.
1124 if (widget_input_handler_manager_)
1125 widget_input_handler_manager_->OnDeferMainFrameUpdatesChanged(
1126 deferral_state);
1127}
1128
1129void RenderWidget::OnDeferCommitsChanged(bool deferral_state) {
1130 // The input handler wants to know about the commit status for metric purposes
1131 // and to enable/disable input.
1132 if (widget_input_handler_manager_)
1133 widget_input_handler_manager_->OnDeferCommitsChanged(deferral_state);
1134}
1135
Stefan Zager148248c2019-02-20 23:24:081136void RenderWidget::DidBeginMainFrame() {
1137 if (!GetWebWidget())
1138 return;
1139 GetWebWidget()->DidBeginFrame();
1140}
1141
danakjc7afae52017-06-20 21:12:411142void RenderWidget::RequestNewLayerTreeFrameSink(
danakja6c10012018-07-06 14:25:361143 LayerTreeFrameSinkCallback callback) {
[email protected]7912e822014-04-16 02:37:031144 // For widgets that are never visible, we don't start the compositor, so we
danakjc7afae52017-06-20 21:12:411145 // never get a request for a cc::LayerTreeFrameSink.
sievers71c62dd52015-10-07 01:44:391146 DCHECK(!compositor_never_visible_);
danakjf87460792018-12-04 20:14:221147 // Frozen RenderWidgets should not be doing any compositing.
Scott Violetb04f16c2018-11-27 00:48:461148 DCHECK(!is_frozen_);
danakj678f0252018-11-09 21:46:341149
1150 if (is_closing()) {
1151 // In this case, we drop the request which means the compositor waits
1152 // forever, which is fine since we're going to destroy it.
1153 return;
1154 }
jonrossa2ff4f82018-02-16 17:27:461155
danakjf87460792018-12-04 20:14:221156 // If we have a warmup in progress, wait for that and store the callback
1157 // to be run when the warmup completes.
1158 if (warmup_frame_sink_request_pending_) {
1159 after_warmup_callback_ = std::move(callback);
1160 return;
1161 }
1162 // If a warmup previously completed, use the result.
1163 if (warmup_frame_sink_) {
1164 std::move(callback).Run(std::move(warmup_frame_sink_));
1165 return;
1166 }
1167
1168 DoRequestNewLayerTreeFrameSink(std::move(callback));
1169}
1170
1171void RenderWidget::DoRequestNewLayerTreeFrameSink(
1172 LayerTreeFrameSinkCallback callback) {
Erik Chen15476cef2019-08-27 17:28:061173 // TODO:(https://crbug.com/995981): If there is no WebWidget, then the
1174 // RenderWidget should also be destroyed, and this DCHECK should not be
1175 // necessary.
1176 DCHECK(GetWebWidget());
1177
jonrossa2ff4f82018-02-16 17:27:461178 // TODO(jonross): have this generated by the LayerTreeFrameSink itself, which
1179 // would then handle binding.
1180 mojom::RenderFrameMetadataObserverPtr ptr;
1181 mojom::RenderFrameMetadataObserverRequest request = mojo::MakeRequest(&ptr);
1182 mojom::RenderFrameMetadataObserverClientPtrInfo client_info;
1183 mojom::RenderFrameMetadataObserverClientRequest client_request =
1184 mojo::MakeRequest(&client_info);
danakj4b347212018-07-04 17:55:171185 auto render_frame_metadata_observer =
1186 std::make_unique<RenderFrameMetadataObserverImpl>(std::move(request),
1187 std::move(client_info));
danakja6c10012018-07-06 14:25:361188 layer_tree_view_->SetRenderFrameObserver(
danakj4b347212018-07-04 17:55:171189 std::move(render_frame_metadata_observer));
danakjf51754372018-12-13 23:20:011190 GURL url = GetWebWidget()->GetURLForDebugTrace();
danakjefabf312018-10-05 19:03:071191 // The |url| is not always available, fallback to a fixed string.
1192 if (url.is_empty())
1193 url = GURL("chrome://gpu/RenderWidget::RequestNewLayerTreeFrameSink");
danakj6dcbc5962018-11-16 16:45:421194 // TODO(danakj): This may not be accurate, depending on the intent. A child
1195 // local root could be in the same process as the view, so if the client is
1196 // meant to designate the process type, it seems kRenderer would be the
1197 // correct choice. If client is meant to designate the widget type, then
1198 // kOOPIF would denote that it is not for the main frame. However, kRenderer
1199 // would also be used for other widgets such as popups.
1200 const char* client_name = for_child_local_root_frame_ ? kOOPIF : kRenderer;
danakj2d2889a2019-04-05 21:22:081201 compositor_deps_->RequestNewLayerTreeFrameSink(
Scott Violetb04f16c2018-11-27 00:48:461202 routing_id_, frame_swap_message_queue_, std::move(url),
1203 std::move(callback), std::move(client_request), std::move(ptr),
1204 client_name);
[email protected]ba91a792013-02-06 09:48:281205}
1206
fsamuel78f86e42016-01-20 04:10:231207void RenderWidget::DidCommitAndDrawCompositorFrame() {
1208 // NOTE: Tests may break if this event is renamed or moved. See
1209 // tab_capture_performancetest.cc.
1210 TRACE_EVENT0("gpu", "RenderWidget::DidCommitAndDrawCompositorFrame");
lfge0c2792ec2016-05-11 18:52:081211
ericwilligers88e69742016-10-17 19:29:551212 for (auto& observer : render_frames_)
1213 observer.DidCommitAndDrawCompositorFrame();
lfge0c2792ec2016-05-11 18:52:081214
fsamuel78f86e42016-01-20 04:10:231215 // Notify subclasses that we initiated the paint operation.
1216 DidInitiatePaint();
Yiming Zhou0f8836c22018-09-13 22:22:111217
Albert J. Wongfb64e142018-10-16 01:10:451218 Send(new WidgetHostMsg_DidCommitAndDrawCompositorFrame(routing_id_));
fsamuel78f86e42016-01-20 04:10:231219}
1220
Stephen Chenney23880392019-04-02 18:36:541221void RenderWidget::WillCommitCompositorFrame() {
1222 if (GetWebWidget())
1223 GetWebWidget()->BeginCommitCompositorFrame();
1224}
1225
Saman Sami766e0b02018-01-31 17:19:201226void RenderWidget::DidCommitCompositorFrame() {
Albert J. Wong7bbf22d2018-12-20 00:27:271227 if (delegate())
1228 delegate()->DidCommitCompositorFrameForWidget();
Stephen Chenney23880392019-04-02 18:36:541229 if (GetWebWidget())
1230 GetWebWidget()->EndCommitCompositorFrame();
Saman Sami766e0b02018-01-31 17:19:201231}
fsamuel78f86e42016-01-20 04:10:231232
danakja2c9d0a92018-07-25 20:01:181233void RenderWidget::DidCompletePageScaleAnimation() {
Albert J. Wong7bbf22d2018-12-20 00:27:271234 if (delegate())
1235 delegate()->DidCompletePageScaleAnimationForWidget();
danakja2c9d0a92018-07-25 20:01:181236}
fsamuel78f86e42016-01-20 04:10:231237
danakjcd417502019-03-13 16:13:211238void RenderWidget::SetLayerTreeMutator(
1239 std::unique_ptr<cc::LayerTreeMutator> mutator) {
1240 layer_tree_view_->layer_tree_host()->SetLayerTreeMutator(std::move(mutator));
1241}
1242
Xida Chen83f1a0d12019-03-21 18:21:301243void RenderWidget::SetPaintWorkletLayerPainterClient(
1244 std::unique_ptr<cc::PaintWorkletLayerPainter> client) {
1245 layer_tree_view_->layer_tree_host()->SetPaintWorkletLayerPainter(
1246 std::move(client));
1247}
1248
danakj26b99912019-02-08 18:58:191249void RenderWidget::SetRootLayer(scoped_refptr<cc::Layer> layer) {
1250 layer_tree_view_->layer_tree_host()->SetRootLayer(std::move(layer));
1251}
1252
danakj53f46b82018-12-11 20:55:551253void RenderWidget::ScheduleAnimation() {
1254 // This call is not needed in single thread mode for tests without a
danakj0719e0652019-03-14 21:19:111255 // scheduler, but they override this method in order to schedule a synchronous
1256 // composite task themselves.
danakj53f46b82018-12-11 20:55:551257 layer_tree_view_->SetNeedsBeginFrame();
initial.commit09911bf2008-07-26 23:55:291258}
1259
danakjefcb8432019-01-16 18:47:141260void RenderWidget::SetShowFPSCounter(bool show) {
1261 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1262 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1263 debug_state.show_fps_counter = show;
1264 host->SetDebugState(debug_state);
1265}
1266
rnasricabcba42019-06-07 15:30:331267void RenderWidget::SetShowLayoutShiftRegions(bool show) {
1268 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1269 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1270 debug_state.show_layout_shift_regions = show;
1271 host->SetDebugState(debug_state);
1272}
1273
danakje691e852019-01-16 22:49:041274void RenderWidget::SetShowPaintRects(bool show) {
1275 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1276 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1277 debug_state.show_paint_rects = show;
1278 host->SetDebugState(debug_state);
1279}
1280
1281void RenderWidget::SetShowDebugBorders(bool show) {
1282 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1283 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1284 if (show)
1285 debug_state.show_debug_borders.set();
1286 else
1287 debug_state.show_debug_borders.reset();
1288 host->SetDebugState(debug_state);
1289}
1290
1291void RenderWidget::SetShowScrollBottleneckRects(bool show) {
1292 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1293 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1294 debug_state.show_touch_event_handler_rects = show;
1295 debug_state.show_wheel_event_handler_rects = show;
1296 debug_state.show_non_fast_scrollable_rects = show;
1297 host->SetDebugState(debug_state);
1298}
1299
1300void RenderWidget::SetShowHitTestBorders(bool show) {
1301 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1302 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1303 debug_state.show_hit_test_borders = show;
1304 host->SetDebugState(debug_state);
1305}
1306
danakj40d07932019-02-28 18:07:101307void RenderWidget::SetBackgroundColor(SkColor color) {
1308 layer_tree_view_->layer_tree_host()->set_background_color(color);
1309}
1310
Stephen Chenneyd56b5382019-01-29 00:37:021311void RenderWidget::UpdateVisualState() {
Ken Buchananed449bb2018-02-01 21:02:051312 if (!GetWebWidget())
1313 return;
1314
danakj22b4e8b2019-08-01 23:14:391315 DCHECK(!is_frozen_);
1316
Stephen Chenneyd56b5382019-01-29 00:37:021317 // We record metrics only when running in multi-threaded mode, not
1318 // single-thread mode for testing.
1319 bool record_main_frame_metrics =
1320 !!compositor_deps_->GetCompositorImplThreadTaskRunner();
1321
Stephen Chenneyec4312612018-11-21 12:40:161322 // When recording main frame metrics set the lifecycle reason to
1323 // kBeginMainFrame, because this is the calller of UpdateLifecycle
1324 // for the main frame. Otherwise, set the reason to kTests, which is
Stephen Chenneybccdd0302019-08-15 12:21:281325 // the only other reason this method is called.
Stephen Chenneyec4312612018-11-21 12:40:161326 WebWidget::LifecycleUpdateReason lifecycle_reason =
1327 record_main_frame_metrics
1328 ? WebWidget::LifecycleUpdateReason::kBeginMainFrame
1329 : WebWidget::LifecycleUpdateReason::kTest;
1330 GetWebWidget()->UpdateLifecycle(WebWidget::LifecycleUpdate::kAll,
1331 lifecycle_reason);
Blink Reformat1c4d759e2017-04-09 16:34:541332 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(false);
tasakb95dbb50c2017-02-08 18:07:501333
Robert Flack3ef2ffb2018-09-06 20:38:201334 if (first_update_visual_state_after_hidden_) {
Takashi SAKAMOTO870f6262017-08-22 04:08:271335 RecordTimeToFirstActivePaint();
1336 first_update_visual_state_after_hidden_ = false;
1337 }
1338}
tasakb95dbb50c2017-02-08 18:07:501339
Takashi SAKAMOTO870f6262017-08-22 04:08:271340void RenderWidget::RecordTimeToFirstActivePaint() {
tasakb95dbb50c2017-02-08 18:07:501341 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
tasakb95dbb50c2017-02-08 18:07:501342 base::TimeDelta sample = base::TimeTicks::Now() - was_shown_time_;
Takashi SAKAMOTO870f6262017-08-22 04:08:271343 if (render_thread_impl->NeedsToRecordFirstActivePaint(TTFAP_AFTER_PURGED)) {
1344 UMA_HISTOGRAM_TIMES("PurgeAndSuspend.Experimental.TimeToFirstActivePaint",
1345 sample);
1346 }
1347 if (render_thread_impl->NeedsToRecordFirstActivePaint(
1348 TTFAP_5MIN_AFTER_BACKGROUNDED)) {
1349 UMA_HISTOGRAM_TIMES(
1350 "PurgeAndSuspend.Experimental.TimeToFirstActivePaint."
1351 "AfterBackgrounded.5min",
1352 sample);
1353 }
fsamuel78f86e42016-01-20 04:10:231354}
1355
Stephen Chenneyd56b5382019-01-29 00:37:021356void RenderWidget::RecordStartOfFrameMetrics() {
Stephen Chenney23880392019-04-02 18:36:541357 if (GetWebWidget())
1358 GetWebWidget()->RecordStartOfFrameMetrics();
Stephen Chenneyd56b5382019-01-29 00:37:021359}
1360
Stephen Chenney9879a5c2018-09-26 14:21:421361void RenderWidget::RecordEndOfFrameMetrics(base::TimeTicks frame_begin_time) {
Stephen Chenney23880392019-04-02 18:36:541362 if (GetWebWidget())
1363 GetWebWidget()->RecordEndOfFrameMetrics(frame_begin_time);
1364}
Stephen Chenney9879a5c2018-09-26 14:21:421365
Stephen Chenney23880392019-04-02 18:36:541366void RenderWidget::BeginUpdateLayers() {
1367 if (GetWebWidget())
1368 GetWebWidget()->BeginUpdateLayers();
1369}
1370
1371void RenderWidget::EndUpdateLayers() {
1372 if (GetWebWidget())
Stephen Chenneyc3c5987d2019-04-15 20:40:071373 GetWebWidget()->EndUpdateLayers();
Stephen Chenney9879a5c2018-09-26 14:21:421374}
1375
fsamuel78f86e42016-01-20 04:10:231376void RenderWidget::WillBeginCompositorFrame() {
1377 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
1378
Ken Buchananed449bb2018-02-01 21:02:051379 if (!GetWebWidget())
1380 return;
1381
Blink Reformat1c4d759e2017-04-09 16:34:541382 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(true);
alancutter317a8e02017-04-05 10:09:291383
dglazkov06854c5c2016-08-31 00:19:591384 // The UpdateTextInputState can result in further layout and possibly
1385 // enable GPU acceleration so they need to be called before any painting
1386 // is done.
changwan75e3b2072017-01-16 02:55:001387 UpdateTextInputState();
dglazkov06854c5c2016-08-31 00:19:591388 UpdateSelectionBounds();
Vladimir Levinaf8cc0fa2019-07-19 17:54:001389
1390 if (auto* frame_widget = GetFrameWidget()) {
1391 frame_widget->UpdateRenderThrottlingStatus(is_throttled_,
1392 subtree_throttled_);
1393 }
initial.commit09911bf2008-07-26 23:55:291394}
1395
fsamuel72464894f2015-12-15 06:59:311396///////////////////////////////////////////////////////////////////////////////
1397// RenderWidgetInputHandlerDelegate
1398
avid7d6b2e2016-03-04 19:41:171399void RenderWidget::FocusChangeComplete() {
Ehsan Karamad655d7b8a2018-01-12 18:38:381400 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1401 if (!frame_widget)
ekaramad27ca69b12017-04-20 18:34:291402 return;
Ehsan Karamad655d7b8a2018-01-12 18:38:381403
ekaramad27ca69b12017-04-20 18:34:291404 blink::WebLocalFrame* focused =
Ehsan Karamad655d7b8a2018-01-12 18:38:381405 frame_widget->LocalRoot()->View()->FocusedFrame();
1406
ekaramad27ca69b12017-04-20 18:34:291407 if (focused && focused->AutofillClient())
1408 focused->AutofillClient()->DidCompleteFocusChangeInFrame();
avid7d6b2e2016-03-04 19:41:171409}
fsamuel72464894f2015-12-15 06:59:311410
dtapuska1827dd22016-03-11 15:24:591411void RenderWidget::ObserveGestureEventAndResult(
1412 const blink::WebGestureEvent& gesture_event,
1413 const gfx::Vector2dF& unused_delta,
Sandra Sunac5cdd832017-12-11 03:27:131414 const cc::OverscrollBehavior& overscroll_behavior,
dtapuska1827dd22016-03-11 15:24:591415 bool event_processed) {
1416 if (!compositor_deps_->IsElasticOverscrollEnabled())
1417 return;
1418
1419 cc::InputHandlerScrollResult scroll_result;
1420 scroll_result.did_scroll = event_processed;
1421 scroll_result.did_overscroll_root = !unused_delta.IsZero();
1422 scroll_result.unused_scroll_delta = unused_delta;
Sandra Sunac5cdd832017-12-11 03:27:131423 scroll_result.overscroll_behavior = overscroll_behavior;
dtapuska1827dd22016-03-11 15:24:591424
Dave Tapuska04bc5ee92018-04-17 19:03:311425 widget_input_handler_manager_->ObserveGestureEventOnMainThread(gesture_event,
1426 scroll_result);
dtapuska1827dd22016-03-11 15:24:591427}
1428
avid7d6b2e2016-03-04 19:41:171429void RenderWidget::OnDidHandleKeyEvent() {
alexmos56567492016-09-13 00:52:461430 ClearEditCommands();
1431}
1432
1433void RenderWidget::SetEditCommandForNextKeyEvent(const std::string& name,
1434 const std::string& value) {
1435 ClearEditCommands();
1436 edit_commands_.emplace_back(name, value);
1437}
1438
1439void RenderWidget::ClearEditCommands() {
1440 edit_commands_.clear();
avid7d6b2e2016-03-04 19:41:171441}
fsamuel72464894f2015-12-15 06:59:311442
chongza8ba91fc2016-08-16 21:39:171443void RenderWidget::OnDidOverscroll(const ui::DidOverscrollParams& params) {
Dave Tapuska04bc5ee92018-04-17 19:03:311444 if (mojom::WidgetInputHandlerHost* host =
1445 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
1446 host->DidOverscroll(params);
Dave Tapuska139a72f2017-09-06 21:57:031447 }
fsamuel72464894f2015-12-15 06:59:311448}
1449
fsamuele8326c742016-01-12 00:49:391450void RenderWidget::SetInputHandler(RenderWidgetInputHandler* input_handler) {
1451 // Nothing to do here. RenderWidget created the |input_handler| and will take
1452 // ownership of it. We just verify here that we don't already have an input
1453 // handler.
1454 DCHECK(!input_handler_);
1455}
1456
changwan75e3b2072017-01-16 02:55:001457void RenderWidget::ShowVirtualKeyboard() {
danakj125a29e2019-01-24 23:25:291458 // Blink can continue running and change input state between the Close IPC
1459 // and the task that actually closes this class.
1460 if (closing_)
1461 return;
changwan75e3b2072017-01-16 02:55:001462 UpdateTextInputStateInternal(true, false);
1463}
1464
changwan62f57292017-02-17 08:28:251465void RenderWidget::ClearTextInputState() {
1466 text_input_info_ = blink::WebTextInputInfo();
1467 text_input_type_ = ui::TextInputType::TEXT_INPUT_TYPE_NONE;
1468 text_input_mode_ = ui::TextInputMode::TEXT_INPUT_MODE_DEFAULT;
1469 can_compose_inline_ = false;
1470 text_input_flags_ = 0;
AJITH KUMAR V041c0b02017-08-08 10:39:201471 next_previous_flags_ = kInvalidNextPreviousFlagsValue;
changwan62f57292017-02-17 08:28:251472}
1473
changwan75e3b2072017-01-16 02:55:001474void RenderWidget::UpdateTextInputState() {
danakj125a29e2019-01-24 23:25:291475 // Blink can continue running and change input state between the Close IPC
1476 // and the task that actually closes this class.
1477 if (closing_)
1478 return;
changwan75e3b2072017-01-16 02:55:001479 UpdateTextInputStateInternal(false, false);
1480}
1481
1482void RenderWidget::UpdateTextInputStateInternal(bool show_virtual_keyboard,
1483 bool reply_to_request) {
fsamuel72464894f2015-12-15 06:59:311484 TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState");
changwan75e3b2072017-01-16 02:55:001485
fsamuel72464894f2015-12-15 06:59:311486 if (ime_event_guard_) {
changwan75e3b2072017-01-16 02:55:001487 DCHECK(!reply_to_request);
1488 // show_virtual_keyboard should still be effective even if it was set inside
1489 // the IME
fsamuel72464894f2015-12-15 06:59:311490 // event guard.
changwan75e3b2072017-01-16 02:55:001491 if (show_virtual_keyboard)
1492 ime_event_guard_->set_show_virtual_keyboard(true);
fsamuel72464894f2015-12-15 06:59:311493 return;
1494 }
1495
dglazkov97b6c2b2016-10-25 17:35:551496 ui::TextInputType new_type = GetTextInputType();
1497 if (IsDateTimeInput(new_type))
1498 return; // Not considered as a text input field in WebKit/Chromium.
fsamuel72464894f2015-12-15 06:59:311499
dglazkov97b6c2b2016-10-25 17:35:551500 blink::WebTextInputInfo new_info;
ekaramad5aff1942017-01-06 01:26:351501 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:541502 new_info = controller->TextInputInfo();
dtapuskac4dd5be2016-10-25 15:11:101503 const ui::TextInputMode new_mode =
Blink Reformat1c4d759e2017-04-09 16:34:541504 ConvertWebTextInputMode(new_info.input_mode);
fsamuel72464894f2015-12-15 06:59:311505
1506 bool new_can_compose_inline = CanComposeInline();
1507
Jan Wilken Dörrie3d4843c2019-08-02 14:30:281508 // Check whether the keyboard should always be hidden for the currently
1509 // focused element.
1510 auto* focused_frame = GetFocusedWebLocalFrameInWidget();
1511 bool always_hide_ime =
1512 focused_frame && focused_frame->ShouldSuppressKeyboardForFocusedElement();
1513
fsamuel72464894f2015-12-15 06:59:311514 // Only sends text input params if they are changed or if the ime should be
1515 // shown.
changwan75e3b2072017-01-16 02:55:001516 if (show_virtual_keyboard || reply_to_request ||
changwan38c3eb612016-12-09 01:45:561517 text_input_type_ != new_type || text_input_mode_ != new_mode ||
1518 text_input_info_ != new_info ||
Jan Wilken Dörrie3d4843c2019-08-02 14:30:281519 can_compose_inline_ != new_can_compose_inline ||
1520 always_hide_ime_ != always_hide_ime) {
ekaramad9053e57b2016-04-26 20:00:381521 TextInputState params;
dglazkov97b6c2b2016-10-25 17:35:551522 params.type = new_type;
fsamuel72464894f2015-12-15 06:59:311523 params.mode = new_mode;
Dave Tapuskaf0698ee2019-05-21 21:12:331524 params.action = new_info.action;
fsamuel72464894f2015-12-15 06:59:311525 params.flags = new_info.flags;
AJITH KUMAR V9e7b5572017-11-14 00:54:211526#if defined(OS_ANDROID)
AJITH KUMAR V041c0b02017-08-08 10:39:201527 if (next_previous_flags_ == kInvalidNextPreviousFlagsValue) {
1528 // Due to a focus change, values will be reset by the frame.
1529 // That case we only need fresh NEXT/PREVIOUS information.
Albert J. Wong3c93c182018-09-27 17:29:431530 // Also we won't send WidgetHostMsg_TextInputStateChanged if next/previous
AJITH KUMAR V041c0b02017-08-08 10:39:201531 // focusable status is changed.
1532 if (auto* controller = GetInputMethodController()) {
1533 next_previous_flags_ =
1534 controller->ComputeWebTextInputNextPreviousFlags();
1535 } else {
1536 // For safety in case GetInputMethodController() is null, because -1 is
1537 // invalid value to send to browser process.
1538 next_previous_flags_ = 0;
1539 }
1540 }
AJITH KUMAR V9e7b5572017-11-14 00:54:211541#else
1542 next_previous_flags_ = 0;
1543#endif
AJITH KUMAR V041c0b02017-08-08 10:39:201544 params.flags |= next_previous_flags_;
Yuichiro Hanada1b19cf852019-01-18 16:12:261545 params.value = new_info.value.Utf16();
Blink Reformat1c4d759e2017-04-09 16:34:541546 params.selection_start = new_info.selection_start;
1547 params.selection_end = new_info.selection_end;
1548 params.composition_start = new_info.composition_start;
1549 params.composition_end = new_info.composition_end;
fsamuel72464894f2015-12-15 06:59:311550 params.can_compose_inline = new_can_compose_inline;
changwan75e3b2072017-01-16 02:55:001551 // TODO(changwan): change instances of show_ime_if_needed to
1552 // show_virtual_keyboard.
1553 params.show_ime_if_needed = show_virtual_keyboard;
Jan Wilken Dörrie3d4843c2019-08-02 14:30:281554 params.always_hide_ime = always_hide_ime;
changwan75e3b2072017-01-16 02:55:001555 params.reply_to_request = reply_to_request;
Albert J. Wong3c93c182018-09-27 17:29:431556 Send(new WidgetHostMsg_TextInputStateChanged(routing_id(), params));
fsamuel72464894f2015-12-15 06:59:311557
1558 text_input_info_ = new_info;
dglazkov97b6c2b2016-10-25 17:35:551559 text_input_type_ = new_type;
fsamuel72464894f2015-12-15 06:59:311560 text_input_mode_ = new_mode;
1561 can_compose_inline_ = new_can_compose_inline;
Jan Wilken Dörrie3d4843c2019-08-02 14:30:281562 always_hide_ime_ = always_hide_ime;
fsamuel72464894f2015-12-15 06:59:311563 text_input_flags_ = new_info.flags;
Eric Karl706ea6712018-12-21 22:41:381564
1565#if defined(OS_ANDROID)
1566 // If we send a new TextInputStateChanged message, we must also deliver a
1567 // new RenderFrameMetadata, as the IME will need this info to be updated.
1568 // TODO(ericrk): Consider folding the above IPC into RenderFrameMetadata.
1569 // https://crbug.com/912309
kylechara352d2d12019-08-15 19:11:411570 layer_tree_view_->RequestForceSendMetadata();
Eric Karl706ea6712018-12-21 22:41:381571#endif
fsamuel72464894f2015-12-15 06:59:311572 }
1573}
1574
1575bool RenderWidget::WillHandleGestureEvent(const blink::WebGestureEvent& event) {
paulmeyer6ef5a792016-11-08 20:33:581576 possible_drag_event_info_.event_source =
1577 ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH;
1578 possible_drag_event_info_.event_location =
Ella Ge1116059d2018-03-21 02:06:131579 gfx::ToFlooredPoint(event.PositionInScreen());
avid7d6b2e2016-03-04 19:41:171580
fsamuel72464894f2015-12-15 06:59:311581 return false;
1582}
1583
1584bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
ericwilligers88e69742016-10-17 19:29:551585 for (auto& observer : render_frames_)
1586 observer.RenderWidgetWillHandleMouseEvent();
lfge0c2792ec2016-05-11 18:52:081587
paulmeyer6ef5a792016-11-08 20:33:581588 possible_drag_event_info_.event_source =
1589 ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
1590 possible_drag_event_info_.event_location =
Blink Reformat1c4d759e2017-04-09 16:34:541591 gfx::Point(event.PositionInScreen().x, event.PositionInScreen().y);
paulmeyer6ef5a792016-11-08 20:33:581592
Albert J. Wong7bbf22d2018-12-20 00:27:271593 if (delegate())
1594 return delegate()->RenderWidgetWillHandleMouseEventForWidget(event);
avid7d6b2e2016-03-04 19:41:171595
fsamuel72464894f2015-12-15 06:59:311596 return false;
[email protected]fd847792013-10-24 17:12:351597}
1598
initial.commit09911bf2008-07-26 23:55:291599///////////////////////////////////////////////////////////////////////////////
mfomitchev2600fd7c2016-02-17 20:53:391600// RenderWidgetScreenMetricsDelegate
1601
bokanc63441c2016-04-27 15:49:121602void RenderWidget::ResizeWebWidget() {
danakja2c9d0a92018-07-25 20:01:181603 gfx::Size size = GetSizeForWebWidget();
Albert J. Wong7bbf22d2018-12-20 00:27:271604 if (delegate()) {
1605 delegate()->ResizeWebWidgetForWidget(size, top_controls_height_,
1606 bottom_controls_height_,
1607 browser_controls_shrink_blink_size_);
danakja2c9d0a92018-07-25 20:01:181608 return;
1609 }
Erik Chen15476cef2019-08-27 17:28:061610 // TODO:(https://crbug.com/995981): If there is no WebWidget, then the
1611 // RenderWidget should also be destroyed, and this DCHECK should not be
1612 // necessary.
1613 DCHECK(GetWebWidget());
danakja2c9d0a92018-07-25 20:01:181614 GetWebWidget()->Resize(size);
bokanc63441c2016-04-27 15:49:121615}
1616
1617gfx::Size RenderWidget::GetSizeForWebWidget() const {
danakj4b347212018-07-04 17:55:171618 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:031619 return gfx::ScaleToCeiledSize(size_,
1620 GetOriginalScreenInfo().device_scale_factor);
1621 }
bokanc63441c2016-04-27 15:49:121622
1623 return size_;
1624}
1625
W. James MacLean7df854c2019-08-28 16:17:531626gfx::Rect RenderWidget::CompositorViewportRect() const {
1627 return layer_tree_view_->layer_tree_host()->device_viewport_rect();
danakj0d963bd2019-02-20 18:00:461628}
1629
akaba3483d8f2018-07-10 21:43:091630void RenderWidget::UpdateZoom(double zoom_level) {
akabac6bd1212018-06-25 20:10:481631 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1632 if (!frame_widget)
1633 return;
1634 RenderFrameImpl* render_frame =
1635 RenderFrameImpl::FromWebFrame(frame_widget->LocalRoot());
1636
akaba3483d8f2018-07-10 21:43:091637 // Return early if zoom level is unchanged.
1638 if (render_frame->GetZoomLevel() == zoom_level) {
akabac6bd1212018-06-25 20:10:481639 return;
1640 }
1641
akaba3483d8f2018-07-10 21:43:091642 render_frame->SetZoomLevel(zoom_level);
akabac6bd1212018-06-25 20:10:481643
1644 for (auto& observer : render_frame_proxies_)
akaba3483d8f2018-07-10 21:43:091645 observer.OnZoomLevelChanged(zoom_level);
akabac6bd1212018-06-25 20:10:481646
1647 for (auto& plugin : browser_plugins_)
akaba3483d8f2018-07-10 21:43:091648 plugin.OnZoomLevelChanged(zoom_level);
akabac6bd1212018-06-25 20:10:481649}
1650
Albert J. Wong0a918192019-08-28 01:05:281651void RenderWidget::SynchronizeVisualProperties(
1652 const VisualProperties& visual_properties) {
Fady Samuele62be402018-03-29 03:19:531653 gfx::Size new_compositor_viewport_pixel_size =
Albert J. Wong0a918192019-08-28 01:05:281654 visual_properties.auto_resize_enabled
1655 ? gfx::ScaleToCeiledSize(
1656 size_, visual_properties.screen_info.device_scale_factor)
1657 : visual_properties.compositor_viewport_pixel_size;
1658 UpdateSurfaceAndScreenInfo(
1659 visual_properties.local_surface_id_allocation.value_or(
1660 viz::LocalSurfaceIdAllocation()),
W. James MacLean7df854c2019-08-28 16:17:531661 gfx::Rect(new_compositor_viewport_pixel_size),
1662 visual_properties.screen_info);
Albert J. Wong0a918192019-08-28 01:05:281663 UpdateCaptureSequenceNumber(visual_properties.capture_sequence_number);
Erik Chenad7f4a1e2019-08-05 20:38:051664 layer_tree_view_->layer_tree_host()->SetBrowserControlsHeight(
Albert J. Wong0a918192019-08-28 01:05:281665 visual_properties.top_controls_height,
1666 visual_properties.bottom_controls_height,
1667 visual_properties.browser_controls_shrink_blink_size);
mfomitchev2600fd7c2016-02-17 20:53:391668
Albert J. Wong0a918192019-08-28 01:05:281669 UpdateZoom(visual_properties.zoom_level);
akabac6bd1212018-06-25 20:10:481670
Albert J. Wong0a918192019-08-28 01:05:281671 if (!visual_properties.auto_resize_enabled) {
1672 visible_viewport_size_ = visual_properties.visible_viewport_size;
1673 display_mode_ = visual_properties.display_mode;
1674 size_ = visual_properties.new_size;
mfomitchev2600fd7c2016-02-17 20:53:391675
danakj21604ce2018-12-19 16:01:221676 ResizeWebWidget();
mfomitchev2600fd7c2016-02-17 20:53:391677
danakjb4cec102019-01-30 19:22:131678 gfx::Size visual_viewport_size = visible_viewport_size_;
danakj21604ce2018-12-19 16:01:221679 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
danakjb4cec102019-01-30 19:22:131680 visual_viewport_size = gfx::ScaleToCeiledSize(
1681 visual_viewport_size, GetOriginalScreenInfo().device_scale_factor);
danakj21604ce2018-12-19 16:01:221682 }
W. James MacLean7c8581072019-06-18 18:07:531683 // When this function is invoked for a main frame widget, it is only if
1684 // (i) we are initializing the widget, or (ii) the widget supports a local
1685 // mainframe. For widgets supporting a remote main frame, the visual
1686 // viewport is updated through the RenderView.
1687 if (delegate())
1688 delegate()->ResizeVisualViewportForWidget(visual_viewport_size);
bokan71cb5b12016-04-27 03:45:221689
danakjf9284772019-01-23 18:29:141690 // NOTE: We may have entered fullscreen mode without changing our size.
Albert J. Wong0a918192019-08-28 01:05:281691 SetIsFullscreen(visual_properties.is_fullscreen_granted);
mfomitchev2600fd7c2016-02-17 20:53:391692 }
mfomitchev2600fd7c2016-02-17 20:53:391693}
1694
1695void RenderWidget::SetScreenMetricsEmulationParameters(
1696 bool enabled,
1697 const blink::WebDeviceEmulationParams& params) {
Albert J. Wong7bbf22d2018-12-20 00:27:271698 // This is only supported in RenderView, which has an delegate().
1699 DCHECK(delegate());
1700 delegate()->SetScreenMetricsEmulationParametersForWidget(enabled, params);
mfomitchev2600fd7c2016-02-17 20:53:391701}
1702
Albert J. Wong3c93c182018-09-27 17:29:431703void RenderWidget::SetScreenRects(const gfx::Rect& widget_screen_rect,
mfomitchev2600fd7c2016-02-17 20:53:391704 const gfx::Rect& window_screen_rect) {
Albert J. Wong3c93c182018-09-27 17:29:431705 widget_screen_rect_ = widget_screen_rect;
mfomitchev2600fd7c2016-02-17 20:53:391706 window_screen_rect_ = window_screen_rect;
1707}
1708
1709///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461710// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291711
Chris Harrelsond7ab99b2018-01-24 17:51:361712void RenderWidget::IntrinsicSizingInfoChanged(
1713 const blink::WebIntrinsicSizingInfo& sizing_info) {
Albert J. Wong3c93c182018-09-27 17:29:431714 Send(new WidgetHostMsg_IntrinsicSizingInfoChanged(routing_id_, sizing_info));
Chris Harrelsond7ab99b2018-01-24 17:51:361715}
1716
Blink Reformat1c4d759e2017-04-09 16:34:541717void RenderWidget::DidMeaningfulLayout(blink::WebMeaningfulLayout layout_type) {
1718 if (layout_type == blink::WebMeaningfulLayout::kVisuallyNonEmpty) {
Albert J. Wongfb64e142018-10-16 01:10:451719 QueueMessage(new WidgetHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_));
dglazkovf0e1d6d2015-10-10 02:13:481720 }
dglazkov79c426102015-08-31 21:22:431721
ericwilligers88e69742016-10-17 19:29:551722 for (auto& observer : render_frames_)
1723 observer.DidMeaningfulLayout(layout_type);
dglazkov79c426102015-08-31 21:22:431724}
1725
[email protected]586871b2014-07-22 17:05:111726// static
dchengcedca5612016-04-09 01:40:151727std::unique_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
[email protected]586871b2014-07-22 17:05:111728 IPC::Message* msg,
[email protected]586871b2014-07-22 17:05:111729 FrameSwapMessageQueue* frame_swap_message_queue,
1730 scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
[email protected]586871b2014-07-22 17:05:111731 int source_frame_number) {
[email protected]586871b2014-07-22 17:05:111732 bool first_message_for_frame = false;
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491733 frame_swap_message_queue->QueueMessageForFrame(
1734 source_frame_number, base::WrapUnique(msg), &first_message_for_frame);
danakj2d2889a2019-04-05 21:22:081735 if (!first_message_for_frame)
1736 return nullptr;
1737 return std::make_unique<QueueMessageSwapPromise>(
1738 sync_message_filter, frame_swap_message_queue, source_frame_number);
[email protected]586871b2014-07-22 17:05:111739}
1740
danakj53802692018-07-25 21:46:441741void RenderWidget::SetHandlingInputEvent(bool handling_input_event) {
1742 input_handler_->set_handling_input_event(handling_input_event);
1743}
1744
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491745void RenderWidget::QueueMessage(IPC::Message* msg) {
danakj125a29e2019-01-24 23:25:291746 if (closing_)
1747 return;
1748
[email protected]586871b2014-07-22 17:05:111749 // RenderThreadImpl::current() is NULL in some tests.
danakj125a29e2019-01-24 23:25:291750 if (!RenderThreadImpl::current()) {
[email protected]586871b2014-07-22 17:05:111751 Send(msg);
1752 return;
1753 }
1754
dchengcedca5612016-04-09 01:40:151755 std::unique_ptr<cc::SwapPromise> swap_promise =
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491756 QueueMessageImpl(msg, frame_swap_message_queue_.get(),
[email protected]586871b2014-07-22 17:05:111757 RenderThreadImpl::current()->sync_message_filter(),
danakja6c10012018-07-06 14:25:361758 layer_tree_view_->GetSourceFrameNumber());
danakj2d2889a2019-04-05 21:22:081759 if (swap_promise) {
1760 layer_tree_view_->layer_tree_host()->QueueSwapPromise(
1761 std::move(swap_promise));
1762 }
[email protected]586871b2014-07-22 17:05:111763}
1764
Blink Reformat1c4d759e2017-04-09 16:34:541765void RenderWidget::DidChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301766 // TODO(darin): Eliminate this temporary.
Mike Wassermanf95c2d9d2019-04-17 00:44:211767 WebCursor cursor((CursorInfo(cursor_info)));
initial.commit09911bf2008-07-26 23:55:291768 // Only send a SetCursor message if we need to make a change.
Navid Zolghadr293bb862018-12-12 18:15:411769 if (input_handler_->DidChangeCursor(cursor))
Albert J. Wong3c93c182018-09-27 17:29:431770 Send(new WidgetHostMsg_SetCursor(routing_id_, cursor));
initial.commit09911bf2008-07-26 23:55:291771}
1772
aelias5971e47d2017-06-16 02:39:381773void RenderWidget::AutoscrollStart(const blink::WebFloatPoint& point) {
Albert J. Wong3c93c182018-09-27 17:29:431774 Send(new WidgetHostMsg_AutoscrollStart(routing_id_, point));
aelias5971e47d2017-06-16 02:39:381775}
1776
1777void RenderWidget::AutoscrollFling(const blink::WebFloatSize& velocity) {
Albert J. Wong3c93c182018-09-27 17:29:431778 Send(new WidgetHostMsg_AutoscrollFling(routing_id_, velocity));
aelias5971e47d2017-06-16 02:39:381779}
1780
1781void RenderWidget::AutoscrollEnd() {
Albert J. Wong3c93c182018-09-27 17:29:431782 Send(new WidgetHostMsg_AutoscrollEnd(routing_id_));
aelias5971e47d2017-06-16 02:39:381783}
1784
initial.commit09911bf2008-07-26 23:55:291785// We are supposed to get a single call to Show for a newly created RenderWidget
1786// that was created via RenderWidget::CreateWebView. So, we wait until this
1787// point to dispatch the ShowWidget message.
1788//
1789// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281790// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291791//
Blink Reformat1c4d759e2017-04-09 16:34:541792void RenderWidget::Show(WebNavigationPolicy policy) {
danakj65f423b72018-10-10 17:21:201793 if (!show_callback_) {
Albert J. Wong7bbf22d2018-12-20 00:27:271794 if (delegate()) {
danakja2c9d0a92018-07-25 20:01:181795 // When SupportsMultipleWindows is disabled, popups are reusing
danakj65f423b72018-10-10 17:21:201796 // the view's RenderWidget. In some scenarios, this makes blink to call
1797 // Show() twice. But otherwise, if it is enabled, we should not visit
1798 // Show() more than once.
Albert J. Wong7bbf22d2018-12-20 00:27:271799 DCHECK(!delegate()->SupportsMultipleWindowsForWidget());
danakj65f423b72018-10-10 17:21:201800 return;
danakja2c9d0a92018-07-25 20:01:181801 } else {
danakj65f423b72018-10-10 17:21:201802 NOTREACHED() << "received extraneous Show call";
danakja2c9d0a92018-07-25 20:01:181803 }
danakja2c9d0a92018-07-25 20:01:181804 }
1805
initial.commit09911bf2008-07-26 23:55:291806 DCHECK(routing_id_ != MSG_ROUTING_NONE);
nickf7b38222016-11-22 21:59:351807
1808 // The opener is responsible for actually showing this widget.
danakjdf1ceb72018-07-18 20:02:251809 std::move(show_callback_).Run(this, policy, initial_rect_);
nickf7b38222016-11-22 21:59:351810
bokanc007c3a2015-02-03 07:15:561811 // NOTE: initial_rect_ may still have its default values at this point, but
[email protected]8de12d942010-11-17 20:42:441812 // that's okay. It'll be ignored if as_popup is false, or the browser
1813 // process will impose a default position otherwise.
bokanc007c3a2015-02-03 07:15:561814 SetPendingWindowRect(initial_rect_);
initial.commit09911bf2008-07-26 23:55:291815}
1816
danakj17216f4d2018-10-16 22:57:321817LayerTreeView* RenderWidget::InitializeLayerTreeView() {
1818 TRACE_EVENT0("blink", "RenderWidget::InitializeLayerTreeView");
danakj17216f4d2018-10-16 22:57:321819
1820 layer_tree_view_ = std::make_unique<LayerTreeView>(
1821 this, compositor_deps_->GetCompositorMainThreadTaskRunner(),
1822 compositor_deps_->GetCompositorImplThreadTaskRunner(),
1823 compositor_deps_->GetTaskGraphRunner(),
1824 compositor_deps_->GetWebMainThreadScheduler());
1825 layer_tree_view_->Initialize(
danakj6dcbc5962018-11-16 16:45:421826 GenerateLayerTreeSettings(compositor_deps_, for_child_local_root_frame_,
danakj17216f4d2018-10-16 22:57:321827 screen_info_.rect.size(),
1828 screen_info_.device_scale_factor),
1829 compositor_deps_->CreateUkmRecorderFactory());
1830
Fady Samuel1c1ad3692018-11-06 23:28:401831 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
W. James MacLean7df854c2019-08-28 16:17:531832 CompositorViewportRect(), screen_info_);
danakj953af052019-02-06 19:13:181833 // If the widget is hidden, delay starting the compositor until the user shows
1834 // it. Also if the RenderWidget is frozen, we delay starting the compositor
1835 // until we expect to use the widget, which will be signaled through
1836 // WarmupCompositor().
1837 if (!is_frozen_ && !is_hidden_)
1838 StartStopCompositor();
danakj17216f4d2018-10-16 22:57:321839
danakj17216f4d2018-10-16 22:57:321840 DCHECK_NE(MSG_ROUTING_NONE, routing_id_);
danakj17216f4d2018-10-16 22:57:321841
1842 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1843 if (render_thread) {
1844 input_event_queue_ = base::MakeRefCounted<MainThreadEventQueue>(
1845 this, render_thread->GetWebMainThreadScheduler()->InputTaskRunner(),
danakj953af052019-02-06 19:13:181846 render_thread->GetWebMainThreadScheduler(),
1847 /*allow_raf_aligned_input=*/!compositor_never_visible_);
danakj17216f4d2018-10-16 22:57:321848 }
1849
1850 return layer_tree_view_.get();
1851}
1852
danakj953af052019-02-06 19:13:181853void RenderWidget::StartStopCompositor() {
1854 if (compositor_never_visible_)
1855 return;
danakjde8b7482018-11-15 23:45:021856
danakj22b4e8b2019-08-01 23:14:391857 // TODO(danakj): We should start the compositor before becoming shown for
1858 // *all* provisional frames not just provisional main frames (as they become
1859 // thawed). However we need to also prevent BeginMainFrame from occurring, in
1860 // both cases, until the frame is attached at least. And in the case of main
1861 // frames, until blink requests them through StopDeferringMainFrameUpdate().
danakj953af052019-02-06 19:13:181862 if (is_frozen_) {
1863 layer_tree_view_->SetVisible(false);
1864 // Drop all gpu resources, this makes SetVisible(true) more expensive/slower
1865 // but we don't expect to use this RenderWidget again until some possible
1866 // future navigation. This brings us a bit closer to emulating deleting the
1867 // RenderWidget instead of just stopping the compositor.
1868 layer_tree_view_->ReleaseLayerTreeFrameSink();
1869 } else if (is_hidden_) {
1870 layer_tree_view_->SetVisible(false);
1871 } else {
1872 layer_tree_view_->SetVisible(true);
1873 }
danakjde8b7482018-11-15 23:45:021874}
1875
danakj6dcbc5962018-11-16 16:45:421876void RenderWidget::SetIsFrozen(bool is_frozen) {
1877 DCHECK_NE(is_frozen, is_frozen_);
1878 is_frozen_ = is_frozen;
danakj953af052019-02-06 19:13:181879 // If hidden, then frozen changing doesn't change anything with the
1880 // compositor since when hidden the compositor is always stopped.
1881 if (!is_hidden_)
1882 StartStopCompositor();
danakjde8b7482018-11-15 23:45:021883}
1884
danakjf87460792018-12-04 20:14:221885void RenderWidget::WarmupCompositor() {
1886 DCHECK(is_frozen_);
danakj953af052019-02-06 19:13:181887 if (compositor_never_visible_)
danakjf87460792018-12-04 20:14:221888 return;
1889
1890 // Keeping things simple. This would cancel any outstanding warmup if we
1891 // happened to have one (this should be basically impossible). This avoids any
1892 // extra book keeping about the outstanding reqeust.
1893 warmup_weak_ptr_factory_.InvalidateWeakPtrs();
1894 // And if we already did a warmup then we're done.
1895 if (warmup_frame_sink_)
1896 return;
1897
1898 // Mark us pending the warmup frame sink *before* calling
1899 // DoRequestNewLayerTreeFrameSink() as it may run the reply callback
1900 // synchronously. So we don't want to change any state after the call
1901 // to DoRequestNewLayerTreeFrameSink() here.
1902 warmup_frame_sink_request_pending_ = true;
1903
1904 auto cb = base::BindOnce(&RenderWidget::OnReplyForWarmupCompositor,
1905 warmup_weak_ptr_factory_.GetWeakPtr());
1906 DoRequestNewLayerTreeFrameSink(std::move(cb));
1907}
1908
1909void RenderWidget::OnReplyForWarmupCompositor(
1910 std::unique_ptr<cc::LayerTreeFrameSink> sink) {
1911 warmup_frame_sink_request_pending_ = false;
1912
1913 if (after_warmup_callback_)
1914 std::move(after_warmup_callback_).Run(std::move(sink));
1915 else
1916 warmup_frame_sink_ = std::move(sink);
1917}
1918
1919void RenderWidget::AbortWarmupCompositor() {
1920 warmup_frame_sink_request_pending_ = false;
1921 // Drop any pending warmup.
1922 warmup_weak_ptr_factory_.InvalidateWeakPtrs();
1923 // And drop any completed one.
1924 warmup_frame_sink_.reset();
1925
1926 // If we had saved a callback to run after warmup, just do so now indicating
1927 // failure.
1928 if (after_warmup_callback_)
1929 std::move(after_warmup_callback_).Run(nullptr);
1930}
1931
danakj9e93f322019-08-02 22:56:581932// static
1933void RenderWidget::DoDeferredClose(int widget_routing_id) {
1934 // DoDeferredClose() was a posted task, which means the RenderWidget may have
1935 // become frozen in the meantime. Frozen RenderWidgets do not send messages,
1936 // so break the dependency on RenderWidget here, by making this method static
1937 // and going to RenderThread directly to send.
1938 RenderThread::Get()->Send(new WidgetHostMsg_Close(widget_routing_id));
[email protected]2533ce12009-05-09 00:02:241939}
1940
danakj45e4a4f2019-03-12 22:50:421941void RenderWidget::ClosePopupWidgetSoon() {
1942 // Only should be called for popup widgets.
1943 DCHECK(!for_child_local_root_frame_);
1944 DCHECK(!delegate_);
1945
1946 CloseWidgetSoon();
1947}
1948
Blink Reformat1c4d759e2017-04-09 16:34:541949void RenderWidget::CloseWidgetSoon() {
Avi Drissman07d22452019-03-25 17:56:391950 DCHECK(RenderThread::IsMainThread());
danakj292b63e2018-11-19 20:47:061951 // Prevent compositor from setting up new IPC channels, since we know a
1952 // WidgetMsg_Close is coming. We do this immediately, not in DoDeferredClose,
1953 // as the caller (eg WebPagePopupImpl) may start tearing down things after
1954 // calling this method, including detaching the frame from this RenderWidget.
1955 // Then trying to make a LayerTreeFrameSink would crash.
1956 // https://crbug.com/906340
1957 host_will_close_this_ = true;
1958
initial.commit09911bf2008-07-26 23:55:291959 // If a page calls window.close() twice, we'll end up here twice, but that's
1960 // OK. It is safe to send multiple Close messages.
danakj292b63e2018-11-19 20:47:061961 //
[email protected]2533ce12009-05-09 00:02:241962 // Ask the RenderWidgetHost to initiate close. We could be called from deep
danakj295c43f182019-03-13 16:37:171963 // in Javascript. If we ask the RenderWidgetHost to close now, the window
1964 // could be closed before the JS finishes executing, thanks to nested message
1965 // loops running and handling the resuliting Close IPC. So instead, post a
[email protected]2533ce12009-05-09 00:02:241966 // message back to the message loop, which won't run until the JS is
danakj295c43f182019-03-13 16:37:171967 // complete, and then the Close request can be sent.
Hajime Hoshi315a61f2018-08-14 17:27:281968 GetCleanupTaskRunner()->PostTask(
danakj9e93f322019-08-02 22:56:581969 FROM_HERE, base::BindOnce(&RenderWidget::DoDeferredClose, routing_id_));
initial.commit09911bf2008-07-26 23:55:291970}
1971
Erik Chen3433ee02019-08-05 20:14:261972void RenderWidget::Close(std::unique_ptr<RenderWidget> widget) {
danakja6c10012018-07-06 14:25:361973 layer_tree_view_.reset();
Albert J. Wongd593de532018-09-06 05:42:151974 // Note the ACK is a control message going to the RenderProcessHost.
Albert J. Wong3c93c182018-09-27 17:29:431975 RenderThread::Get()->Send(new WidgetHostMsg_Close_ACK(routing_id()));
danakj6ec39d302019-03-15 22:43:221976 closed_ = true;
Erik Chen3433ee02019-08-05 20:14:261977
1978 // At the end of this method, |widget| which points to this is deleted.
1979 DCHECK_EQ(widget.get(), this);
Ken Buchananed449bb2018-02-01 21:02:051980}
1981
1982void RenderWidget::CloseWebWidget() {
danakj35314ab2018-10-19 16:37:341983 // If the browser has not sent OnDisableDeviceEmulation, we have an emulator
1984 // hanging out still. Destroying it must happen *after* the IPC route is
1985 // removed so that another IPC does not arrive and re-create the emulator
1986 // during closing.
1987 //
1988 // This destruction is normally part of an IPC and expects objects to be alive
1989 // that would be alive while the IPC route is active such as the
1990 // |layer_tree_view_|. So we ensure that it is the first thing to be
1991 // destroyed here before deleting things from the RenderWidget or the
Albert J. Wong7bbf22d2018-12-20 00:27:271992 // delegate().
danakj35314ab2018-10-19 16:37:341993 //
1994 // TODO(danakj): The emulator could reset to non-emulated values in an
1995 // explicit method call (instead of in the destructor) that occurs when
1996 // emulation is disabled, but does not need to occur during RenderWidget
1997 // closing. Then we would not have to destroy this so carefully.
1998 screen_metrics_emulator_.reset();
1999
Erik Chen562ca42b2019-08-22 19:46:062000 // TODO(https://crbug.com/995981): This logic is very confusing and should be
2001 // fixed. When the RenderWidget is associated with a RenderView,
2002 // webwidget_internal_ points to an instance of WebView. This is owned by the
2003 // RenderView, which also owns the RenderWidget and is calling into this
2004 // method. We do nothing here and let RenderView destroy the WebView.
2005 //
2006 // For all other RenderWidgets, webwidget_internal_ points at a 'real'
2007 // instance of a WebWidget which is owned by the RenderWidget. In this case,
2008 // we must close the webwidget.
2009 if (!delegate())
2010 webwidget_internal_->Close();
danakj5c5269b2018-11-06 00:39:112011 webwidget_internal_ = nullptr;
danakj2d2889a2019-04-05 21:22:082012
2013 close_weak_ptr_factory_.InvalidateWeakPtrs();
initial.commit09911bf2008-07-26 23:55:292014}
2015
Mitsuru Oshima3c07b332018-02-06 04:56:502016void RenderWidget::UpdateWebViewWithDeviceScaleFactor() {
2017 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2018 blink::WebFrame* current_frame =
2019 frame_widget ? frame_widget->LocalRoot() : nullptr;
2020 blink::WebView* webview = current_frame ? current_frame->View() : nullptr;
2021 if (webview) {
danakj4b347212018-07-04 17:55:172022 if (compositor_deps_->IsUseZoomForDSFEnabled())
Fady Samuela863f152018-03-09 16:10:032023 webview->SetZoomFactorForDeviceScaleFactor(
2024 GetWebScreenInfo().device_scale_factor);
Mitsuru Oshima3c07b332018-02-06 04:56:502025 else
Fady Samuela863f152018-03-09 16:10:032026 webview->SetDeviceScaleFactor(GetWebScreenInfo().device_scale_factor);
Mitsuru Oshima3c07b332018-02-06 04:56:502027
2028 webview->GetSettings()->SetPreferCompositingToLCDTextEnabled(
Christopher Camerone9a30c12018-03-07 08:23:382029 PreferCompositingToLCDText(compositor_deps_,
Fady Samuela863f152018-03-09 16:10:032030 GetWebScreenInfo().device_scale_factor));
Mitsuru Oshima3c07b332018-02-06 04:56:502031 }
2032}
2033
Ehsan Karamad655d7b8a2018-01-12 18:38:382034blink::WebFrameWidget* RenderWidget::GetFrameWidget() const {
danakj89ae4532018-12-12 22:52:552035 // TODO(danakj): Remove this check and don't call this method for non-frames.
2036 if (!for_frame())
2037 return nullptr;
2038 // TODO(danakj): Is this needed? IPCs stop after closing, but code used to
2039 // check for a null WebWidget.
2040 if (closing_)
Ehsan Karamad655d7b8a2018-01-12 18:38:382041 return nullptr;
2042
Erik Chena2819852019-08-28 01:02:282043 return static_cast<blink::WebFrameWidget*>(webwidget_internal_);
Ehsan Karamad655d7b8a2018-01-12 18:38:382044}
2045
bokan841fdc72016-10-06 00:16:352046void RenderWidget::ScreenRectToEmulatedIfNeeded(WebRect* window_rect) const {
2047 DCHECK(window_rect);
2048 float scale = popup_origin_scale_for_emulation_;
2049 if (!scale)
2050 return;
2051 window_rect->x =
2052 popup_view_origin_for_emulation_.x() +
2053 (window_rect->x - popup_screen_origin_for_emulation_.x()) / scale;
2054 window_rect->y =
2055 popup_view_origin_for_emulation_.y() +
2056 (window_rect->y - popup_screen_origin_for_emulation_.y()) / scale;
2057}
2058
2059void RenderWidget::EmulatedToScreenRectIfNeeded(WebRect* window_rect) const {
2060 DCHECK(window_rect);
2061 float scale = popup_origin_scale_for_emulation_;
2062 if (!scale)
2063 return;
2064 window_rect->x =
2065 popup_screen_origin_for_emulation_.x() +
2066 (window_rect->x - popup_view_origin_for_emulation_.x()) * scale;
2067 window_rect->y =
2068 popup_screen_origin_for_emulation_.y() +
2069 (window_rect->y - popup_view_origin_for_emulation_.y()) * scale;
2070}
2071
Blink Reformat1c4d759e2017-04-09 16:34:542072WebRect RenderWidget::WindowRect() {
bokan841fdc72016-10-06 00:16:352073 WebRect rect;
bokan6b08cd22016-10-05 00:55:212074 if (pending_window_rect_count_) {
2075 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
2076 // the RootWindowRect is probably going to return wrong results since the
2077 // browser may not have processed the Move yet. There isn't really anything
2078 // good to do in this case, and it shouldn't happen - since this size is
2079 // only really needed for windowToScreen, which is only used for Popups.
bokan841fdc72016-10-06 00:16:352080 rect = pending_window_rect_;
2081 } else {
2082 rect = window_screen_rect_;
bokan6b08cd22016-10-05 00:55:212083 }
[email protected]2533ce12009-05-09 00:02:242084
bokan841fdc72016-10-06 00:16:352085 ScreenRectToEmulatedIfNeeded(&rect);
2086 return rect;
bokan6b08cd22016-10-05 00:55:212087}
2088
Blink Reformat1c4d759e2017-04-09 16:34:542089WebRect RenderWidget::ViewRect() {
Albert J. Wong3c93c182018-09-27 17:29:432090 WebRect rect = widget_screen_rect_;
bokan841fdc72016-10-06 00:16:352091 ScreenRectToEmulatedIfNeeded(&rect);
2092 return rect;
initial.commit09911bf2008-07-26 23:55:292093}
2094
Blink Reformat1c4d759e2017-04-09 16:34:542095void RenderWidget::SetToolTipText(const blink::WebString& text,
[email protected]8a9d6ca32011-06-06 20:11:302096 WebTextDirection hint) {
Albert J. Wong3c93c182018-09-27 17:29:432097 Send(new WidgetHostMsg_SetTooltipText(routing_id_, text.Utf16(), hint));
[email protected]8a9d6ca32011-06-06 20:11:302098}
2099
Blink Reformat1c4d759e2017-04-09 16:34:542100void RenderWidget::SetWindowRect(const WebRect& rect_in_screen) {
danakj81d601e62018-10-09 22:15:052101 // This path is for the renderer to change the on-screen position/size of
2102 // the widget by changing its window rect. This is not possible for
2103 // RenderWidgets whose position/size are controlled by layout from another
danakj6dcbc5962018-11-16 16:45:422104 // frame tree (ie. child local root frames), as the window rect can only be
2105 // set by the browser.
2106 if (for_child_local_root_frame_)
danakj81d601e62018-10-09 22:15:052107 return;
2108
oshima33ec97cd2015-12-14 19:40:242109 WebRect window_rect = rect_in_screen;
bokan841fdc72016-10-06 00:16:352110 EmulatedToScreenRectIfNeeded(&window_rect);
[email protected]b2e4c70132013-10-03 02:07:512111
danakj7602f4f2019-01-31 18:03:232112 if (synchronous_resize_mode_for_testing_) {
Kent Tamura21d1de62018-12-10 04:45:202113 // This is a web-test-only path. At one point, it was planned to be
danakj65f423b72018-10-10 17:21:202114 // removed. See https://crbug.com/309760.
bokanc007c3a2015-02-03 07:15:562115 SetWindowRectSynchronously(window_rect);
danakj65f423b72018-10-10 17:21:202116 return;
2117 }
2118
2119 if (show_callback_) {
2120 // The widget is not shown yet. Delay the |window_rect| being sent to the
2121 // browser until Show() is called so it can be sent with that IPC, once the
2122 // browser is ready for the info.
2123 initial_rect_ = window_rect;
2124 } else {
2125 Send(new WidgetHostMsg_RequestSetBounds(routing_id_, window_rect));
2126 SetPendingWindowRect(window_rect);
initial.commit09911bf2008-07-26 23:55:292127 }
2128}
2129
[email protected]2533ce12009-05-09 00:02:242130void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
2131 pending_window_rect_ = rect;
2132 pending_window_rect_count_++;
[email protected]2533ce12009-05-09 00:02:242133
bokan6b08cd22016-10-05 00:55:212134 // Popups don't get size updates back from the browser so just store the set
2135 // values.
danakj89ae4532018-12-12 22:52:552136 if (!for_frame()) {
Blink Reformat1c4d759e2017-04-09 16:34:542137 window_screen_rect_ = rect;
Albert J. Wong3c93c182018-09-27 17:29:432138 widget_screen_rect_ = rect;
[email protected]2533ce12009-05-09 00:02:242139 }
[email protected]d4547452008-08-28 18:36:372140}
2141
wjmacleanee244e02017-05-26 21:06:072142void RenderWidget::OnShowContextMenu(ui::MenuSourceType source_type,
2143 const gfx::Point& location) {
wjmacleanee244e02017-05-26 21:06:072144 has_host_context_menu_location_ = true;
2145 host_context_menu_location_ = location;
2146 if (GetWebWidget()) {
2147 GetWebWidget()->ShowContextMenu(
2148 static_cast<blink::WebMenuSourceType>(source_type));
2149 }
2150 has_host_context_menu_location_ = false;
2151}
2152
[email protected]fa7b1dc2010-06-23 17:53:042153void RenderWidget::OnImeSetComposition(
[email protected]fcf75d42013-12-03 20:11:262154 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:112155 const std::vector<WebImeTextSpan>& ime_text_spans,
chongz7eb752802016-01-27 21:28:072156 const gfx::Range& replacement_range,
Ryan Landay9e42fd742017-08-12 01:59:112157 int selection_start,
2158 int selection_end) {
ekaramad5aff1942017-01-06 01:26:352159 if (!ShouldHandleImeEvents())
2160 return;
2161
brettw4b461082016-11-19 18:55:162162#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492163 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
Ryan Landay9e42fd742017-08-12 01:59:112164 plugin->render_frame()->OnImeSetComposition(text, ime_text_spans,
EhsanK22d482e2017-08-10 17:29:492165 selection_start, selection_end);
ekaramad2a46d632016-07-19 13:33:092166 return;
2167 }
2168#endif
[email protected]66fca5bc2013-05-23 06:58:292169 ImeEventGuard guard(this);
ekaramad2daaf672016-11-10 20:29:012170 blink::WebInputMethodController* controller = GetInputMethodController();
ekaramad2daaf672016-11-10 20:29:012171 if (!controller ||
Blink Reformat1c4d759e2017-04-09 16:34:542172 !controller->SetComposition(
Ryan Landay9e42fd742017-08-12 01:59:112173 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:562174 replacement_range.IsValid()
2175 ? WebRange(replacement_range.start(), replacement_range.length())
2176 : WebRange(),
2177 selection_start, selection_end)) {
[email protected]fa7b1dc2010-06-23 17:53:042178 // If we failed to set the composition text, then we need to let the browser
2179 // process to cancel the input method's ongoing composition session, to make
2180 // sure we are in a consistent state.
Dave Tapuska04bc5ee92018-04-17 19:03:312181 if (mojom::WidgetInputHandlerHost* host =
2182 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
2183 host->ImeCancelComposition();
Dave Tapuska139a72f2017-09-06 21:57:032184 }
[email protected]7f00efa2010-04-15 05:01:262185 }
nonafa291792016-08-10 02:36:182186 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]fa7b1dc2010-06-23 17:53:042187}
2188
rlanday7efe2302017-01-11 00:14:282189void RenderWidget::OnImeCommitText(
2190 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:112191 const std::vector<WebImeTextSpan>& ime_text_spans,
rlanday7efe2302017-01-11 00:14:282192 const gfx::Range& replacement_range,
2193 int relative_cursor_pos) {
ekaramad5aff1942017-01-06 01:26:352194 if (!ShouldHandleImeEvents())
2195 return;
2196
brettw4b461082016-11-19 18:55:162197#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492198 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
2199 plugin->render_frame()->OnImeCommitText(text, replacement_range,
2200 relative_cursor_pos);
ekaramad2a46d632016-07-19 13:33:092201 return;
2202 }
2203#endif
[email protected]66fca5bc2013-05-23 06:58:292204 ImeEventGuard guard(this);
fsamuele8326c742016-01-12 00:49:392205 input_handler_->set_handling_input_event(true);
ekaramadb6483a052017-02-10 02:23:262206 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:542207 controller->CommitText(
Ryan Landay9e42fd742017-08-12 01:59:112208 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:562209 replacement_range.IsValid()
2210 ? WebRange(replacement_range.start(), replacement_range.length())
2211 : WebRange(),
2212 relative_cursor_pos);
ekaramadb6483a052017-02-10 02:23:262213 }
aelias87b8f7c2016-09-14 03:19:292214 input_handler_->set_handling_input_event(false);
2215 UpdateCompositionInfo(false /* not an immediate request */);
2216}
2217
2218void RenderWidget::OnImeFinishComposingText(bool keep_selection) {
ekaramad5aff1942017-01-06 01:26:352219 if (!ShouldHandleImeEvents())
2220 return;
2221
brettw4b461082016-11-19 18:55:162222#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492223 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
2224 plugin->render_frame()->OnImeFinishComposingText(keep_selection);
aelias87b8f7c2016-09-14 03:19:292225 return;
2226 }
2227#endif
2228
changwan38c3eb612016-12-09 01:45:562229 if (!GetWebWidget())
aelias87b8f7c2016-09-14 03:19:292230 return;
2231 ImeEventGuard guard(this);
2232 input_handler_->set_handling_input_event(true);
ekaramad2daaf672016-11-10 20:29:012233 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:542234 controller->FinishComposingText(
2235 keep_selection ? WebInputMethodController::kKeepSelection
2236 : WebInputMethodController::kDoNotKeepSelection);
ekaramad2daaf672016-11-10 20:29:012237 }
fsamuele8326c742016-01-12 00:49:392238 input_handler_->set_handling_input_event(false);
nonafa291792016-08-10 02:36:182239 UpdateCompositionInfo(false /* not an immediate request */);
initial.commit09911bf2008-07-26 23:55:292240}
2241
Christopher Camerone9a30c12018-03-07 08:23:382242void RenderWidget::UpdateSurfaceAndScreenInfo(
Fady Samuel1c1ad3692018-11-06 23:28:402243 const viz::LocalSurfaceIdAllocation& new_local_surface_id_allocation,
W. James MacLean7df854c2019-08-28 16:17:532244 const gfx::Rect& compositor_viewport_pixel_rect,
Christopher Camerone9a30c12018-03-07 08:23:382245 const ScreenInfo& new_screen_info) {
Christopher Camerone9a30c12018-03-07 08:23:382246 bool orientation_changed =
2247 screen_info_.orientation_angle != new_screen_info.orientation_angle ||
2248 screen_info_.orientation_type != new_screen_info.orientation_type;
2249 bool web_device_scale_factor_changed =
2250 screen_info_.device_scale_factor != new_screen_info.device_scale_factor;
Fady Samuela863f152018-03-09 16:10:032251 ScreenInfo previous_original_screen_info = GetOriginalScreenInfo();
Christopher Cameronbe7ecea2018-02-27 00:47:192252
Fady Samuel1c1ad3692018-11-06 23:28:402253 local_surface_id_allocation_from_parent_ = new_local_surface_id_allocation;
Christopher Camerone9a30c12018-03-07 08:23:382254 screen_info_ = new_screen_info;
Christopher Cameronbe7ecea2018-02-27 00:47:192255
danakj125a29e2019-01-24 23:25:292256 // Note carefully that the DSF specified in |new_screen_info| is not the
2257 // DSF used by the compositor during device emulation!
W. James MacLean7df854c2019-08-28 16:17:532258 layer_tree_view_->SetViewportRectAndScale(
2259 compositor_viewport_pixel_rect,
danakj125a29e2019-01-24 23:25:292260 GetOriginalScreenInfo().device_scale_factor,
2261 local_surface_id_allocation_from_parent_);
danakj9c4e7b812019-02-19 22:04:272262 // The ViewportVisibleRect derives from the LayerTreeView's viewport size,
2263 // which is set above.
2264 layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect());
danakj04d128a2019-01-25 02:10:202265 layer_tree_view_->SetRasterColorSpace(
2266 screen_info_.color_space.GetRasterColorSpace());
Christopher Cameronbe7ecea2018-02-27 00:47:192267
Christopher Camerone9a30c12018-03-07 08:23:382268 if (orientation_changed)
2269 OnOrientationChange();
Christopher Cameronbe7ecea2018-02-27 00:47:192270
Fady Samuela863f152018-03-09 16:10:032271 if (previous_original_screen_info != GetOriginalScreenInfo()) {
Christopher Camerone9a30c12018-03-07 08:23:382272 for (auto& observer : render_frame_proxies_)
Fady Samuela863f152018-03-09 16:10:032273 observer.OnScreenInfoChanged(GetOriginalScreenInfo());
Christopher Camerone9a30c12018-03-07 08:23:382274
2275 // Notify all embedded BrowserPlugins of the updated ScreenInfo.
2276 for (auto& observer : browser_plugins_)
Fady Samuela863f152018-03-09 16:10:032277 observer.ScreenInfoChanged(GetOriginalScreenInfo());
Christopher Camerone9a30c12018-03-07 08:23:382278 }
2279
2280 if (web_device_scale_factor_changed)
Christopher Cameronbe7ecea2018-02-27 00:47:192281 UpdateWebViewWithDeviceScaleFactor();
oshimad5279032015-12-16 18:22:332282}
2283
danakja2c9d0a92018-07-25 20:01:182284void RenderWidget::SetWindowRectSynchronously(
2285 const gfx::Rect& new_window_rect) {
2286 VisualProperties visual_properties;
2287 visual_properties.screen_info = screen_info_;
2288 visual_properties.new_size = new_window_rect.size();
2289 visual_properties.compositor_viewport_pixel_size = gfx::ScaleToCeiledSize(
2290 new_window_rect.size(), GetWebScreenInfo().device_scale_factor);
2291 visual_properties.visible_viewport_size = new_window_rect.size();
2292 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
2293 visual_properties.display_mode = display_mode_;
Fady Samuel84d8a1f72018-11-08 00:26:172294 visual_properties.local_surface_id_allocation =
2295 local_surface_id_allocation_from_parent_;
danakja2c9d0a92018-07-25 20:01:182296 // We are resizing the window from the renderer, so allocate a new
2297 // viz::LocalSurfaceId to avoid surface invariants violations in tests.
danakj125a29e2019-01-24 23:25:292298 layer_tree_view_->RequestNewLocalSurfaceId();
danakja2c9d0a92018-07-25 20:01:182299 SynchronizeVisualProperties(visual_properties);
2300
Albert J. Wong3c93c182018-09-27 17:29:432301 widget_screen_rect_ = new_window_rect;
danakja2c9d0a92018-07-25 20:01:182302 window_screen_rect_ = new_window_rect;
danakj65f423b72018-10-10 17:21:202303 if (show_callback_) {
2304 // Tests may call here directly to control the window rect. If
2305 // Show() did not happen yet, the rect is stored to be passed to the
2306 // browser when the RenderWidget requests Show().
danakja2c9d0a92018-07-25 20:01:182307 initial_rect_ = new_window_rect;
danakj65f423b72018-10-10 17:21:202308 }
danakja2c9d0a92018-07-25 20:01:182309}
2310
Vladimir Levin98d76dad2018-04-21 00:21:292311void RenderWidget::UpdateCaptureSequenceNumber(
2312 uint32_t capture_sequence_number) {
2313 if (capture_sequence_number == last_capture_sequence_number_)
2314 return;
2315 last_capture_sequence_number_ = capture_sequence_number;
2316
2317 // Notify observers of the new capture sequence number.
2318 for (auto& observer : render_frame_proxies_)
2319 observer.UpdateCaptureSequenceNumber(capture_sequence_number);
2320 for (auto& observer : browser_plugins_)
2321 observer.UpdateCaptureSequenceNumber(capture_sequence_number);
2322}
2323
[email protected]4873c7d2009-07-16 06:36:282324void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
EhsanK955ba582017-11-30 21:14:402325 if (auto* frame = GetFocusedWebLocalFrameInWidget())
2326 frame->SetTextDirection(direction);
[email protected]07f953332009-03-25 04:31:112327}
2328
Albert J. Wong3c93c182018-09-27 17:29:432329void RenderWidget::OnUpdateScreenRects(const gfx::Rect& widget_screen_rect,
[email protected]80ad8622012-11-07 16:33:032330 const gfx::Rect& window_screen_rect) {
[email protected]b2e4c70132013-10-03 02:07:512331 if (screen_metrics_emulator_) {
Albert J. Wong3c93c182018-09-27 17:29:432332 screen_metrics_emulator_->OnUpdateScreenRects(widget_screen_rect,
mfomitchev2600fd7c2016-02-17 20:53:392333 window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:512334 } else {
Albert J. Wong3c93c182018-09-27 17:29:432335 SetScreenRects(widget_screen_rect, window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:512336 }
Albert J. Wong3c93c182018-09-27 17:29:432337 Send(new WidgetHostMsg_UpdateScreenRects_ACK(routing_id()));
[email protected]80ad8622012-11-07 16:33:032338}
2339
kenrbea731792017-01-13 15:10:482340void RenderWidget::OnSetViewportIntersection(
Ken Buchananb2c9e262018-03-10 16:53:312341 const gfx::Rect& viewport_intersection,
Stefan Zager54e25832018-08-14 22:15:312342 const gfx::Rect& compositor_visible_rect,
Stefan Zager0926c9c2019-03-12 02:46:092343 blink::FrameOcclusionState occlusion_state) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252344 if (auto* frame_widget = GetFrameWidget()) {
Ken Buchananb2c9e262018-03-10 16:53:312345 compositor_visible_rect_ = compositor_visible_rect;
Stefan Zager54e25832018-08-14 22:15:312346 frame_widget->SetRemoteViewportIntersection(viewport_intersection,
Stefan Zager0926c9c2019-03-12 02:46:092347 occlusion_state);
danakja6c10012018-07-06 14:25:362348 layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect());
kenrbea731792017-01-13 15:10:482349 }
2350}
2351
kenrb04323782017-06-23 01:23:322352void RenderWidget::OnSetIsInert(bool inert) {
danakj89ae4532018-12-12 22:52:552353 if (auto* frame_widget = GetFrameWidget())
Ehsan Karamadf3ca2a82018-01-20 01:05:252354 frame_widget->SetIsInert(inert);
kenrb04323782017-06-23 01:23:322355}
2356
sunxd540a9962018-05-24 22:51:062357void RenderWidget::OnSetInheritedEffectiveTouchAction(
2358 cc::TouchAction touch_action) {
danakj89ae4532018-12-12 22:52:552359 if (auto* frame_widget = GetFrameWidget())
sunxd540a9962018-05-24 22:51:062360 frame_widget->SetInheritedEffectiveTouchAction(touch_action);
sunxd540a9962018-05-24 22:51:062361}
2362
Ken Buchanan8a319fb2017-11-15 18:37:122363void RenderWidget::OnUpdateRenderThrottlingStatus(bool is_throttled,
2364 bool subtree_throttled) {
Vladimir Levinaf8cc0fa2019-07-19 17:54:002365 is_throttled_ = is_throttled;
2366 subtree_throttled_ = subtree_throttled;
2367
danakj89ae4532018-12-12 22:52:552368 if (auto* frame_widget = GetFrameWidget())
Ehsan Karamadf3ca2a82018-01-20 01:05:252369 frame_widget->UpdateRenderThrottlingStatus(is_throttled, subtree_throttled);
Ken Buchanan8a319fb2017-11-15 18:37:122370}
2371
paulmeyer90f6c31d2016-11-12 00:17:592372void RenderWidget::OnDragTargetDragEnter(
2373 const std::vector<DropData::Metadata>& drop_meta_data,
Ella Ge80a52dce2017-11-15 18:01:522374 const gfx::PointF& client_point,
2375 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592376 WebDragOperationsMask ops,
2377 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252378 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2379 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592380 return;
2381
Ehsan Karamadf3ca2a82018-01-20 01:05:252382 WebDragOperation operation = frame_widget->DragTargetDragEnter(
2383 DropMetaDataToWebDragData(drop_meta_data), client_point, screen_point,
2384 ops, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592385
2386 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
2387}
2388
Ella Ge80a52dce2017-11-15 18:01:522389void RenderWidget::OnDragTargetDragOver(const gfx::PointF& client_point,
2390 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592391 WebDragOperationsMask ops,
2392 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252393 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2394 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592395 return;
2396
Ehsan Karamadf3ca2a82018-01-20 01:05:252397 WebDragOperation operation = frame_widget->DragTargetDragOver(
2398 ConvertWindowPointToViewport(client_point), screen_point, ops,
2399 key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592400
2401 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
2402}
2403
Ella Ge80a52dce2017-11-15 18:01:522404void RenderWidget::OnDragTargetDragLeave(const gfx::PointF& client_point,
2405 const gfx::PointF& screen_point) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252406 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2407 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592408 return;
Ehsan Karamadf3ca2a82018-01-20 01:05:252409
2410 frame_widget
Blink Reformat1c4d759e2017-04-09 16:34:542411 ->DragTargetDragLeave(ConvertWindowPointToViewport(client_point),
kenrb07c272802017-02-07 23:48:172412 screen_point);
paulmeyer90f6c31d2016-11-12 00:17:592413}
2414
2415void RenderWidget::OnDragTargetDrop(const DropData& drop_data,
Ella Ge80a52dce2017-11-15 18:01:522416 const gfx::PointF& client_point,
2417 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592418 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252419 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2420 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592421 return;
2422
Ehsan Karamadf3ca2a82018-01-20 01:05:252423 frame_widget->DragTargetDrop(DropDataToWebDragData(drop_data),
2424 ConvertWindowPointToViewport(client_point),
2425 screen_point, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592426}
2427
Ella Ge80a52dce2017-11-15 18:01:522428void RenderWidget::OnDragSourceEnded(const gfx::PointF& client_point,
2429 const gfx::PointF& screen_point,
paulmeyer8fc8ea92016-11-15 05:12:212430 WebDragOperation op) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252431 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2432 if (!frame_widget)
paulmeyer8fc8ea92016-11-15 05:12:212433 return;
2434
Ehsan Karamadf3ca2a82018-01-20 01:05:252435 frame_widget->DragSourceEndedAt(ConvertWindowPointToViewport(client_point),
2436 screen_point, op);
paulmeyer8fc8ea92016-11-15 05:12:212437}
2438
2439void RenderWidget::OnDragSourceSystemDragEnded() {
danakj503545c2019-01-11 19:03:092440 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2441 if (!frame_widget)
paulmeyer8fc8ea92016-11-15 05:12:212442 return;
2443
danakj503545c2019-01-11 19:03:092444 frame_widget->DragSourceSystemDragEnded();
paulmeyer8fc8ea92016-11-15 05:12:212445}
2446
Blink Reformat1c4d759e2017-04-09 16:34:542447void RenderWidget::ShowVirtualKeyboardOnElementFocus() {
okaa398f50b2017-03-21 06:30:262448#if defined(OS_CHROMEOS)
2449 // On ChromeOS, virtual keyboard is triggered only when users leave the
2450 // mouse button or the finger and a text input element is focused at that
2451 // time. Focus event itself shouldn't trigger virtual keyboard.
2452 UpdateTextInputState();
2453#else
changwan75e3b2072017-01-16 02:55:002454 ShowVirtualKeyboard();
okaa398f50b2017-03-21 06:30:262455#endif
boliu7b2be2f2016-11-04 04:58:312456
2457// TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
2458// virtual keyboard.
2459#if !defined(OS_ANDROID)
2460 FocusChangeComplete();
2461#endif
[email protected]0d1ebed12013-08-05 22:01:132462}
2463
fsamuel72464894f2015-12-15 06:59:312464ui::TextInputType RenderWidget::GetTextInputType() {
brettw4b461082016-11-19 18:55:162465#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492466 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2467 return plugin->text_input_type();
ekaramad2a46d632016-07-19 13:33:092468#endif
ekaramad5aff1942017-01-06 01:26:352469 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:542470 return ConvertWebTextInputType(controller->TextInputType());
fsamuel72464894f2015-12-15 06:59:312471 return ui::TEXT_INPUT_TYPE_NONE;
2472}
2473
nonafa291792016-08-10 02:36:182474void RenderWidget::UpdateCompositionInfo(bool immediate_request) {
2475 if (!monitor_composition_info_ && !immediate_request)
2476 return; // Do not calculate composition info if not requested.
nonadac0c7a2016-08-01 02:30:592477
nonafa291792016-08-10 02:36:182478 TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo");
2479 gfx::Range range;
2480 std::vector<gfx::Rect> character_bounds;
2481
2482 if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE) {
2483 // Composition information is only available on editable node.
2484 range = gfx::Range::InvalidRange();
2485 } else {
2486 GetCompositionRange(&range);
2487 GetCompositionCharacterBounds(&character_bounds);
2488 }
2489
2490 if (!immediate_request &&
2491 !ShouldUpdateCompositionInfo(range, character_bounds)) {
fsamuel72464894f2015-12-15 06:59:312492 return;
nonafa291792016-08-10 02:36:182493 }
fsamuel72464894f2015-12-15 06:59:312494 composition_character_bounds_ = character_bounds;
2495 composition_range_ = range;
Dave Tapuska04bc5ee92018-04-17 19:03:312496 if (mojom::WidgetInputHandlerHost* host =
2497 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
2498 host->ImeCompositionRangeChanged(composition_range_,
2499 composition_character_bounds_);
Dave Tapuska139a72f2017-09-06 21:57:032500 }
fsamuel72464894f2015-12-15 06:59:312501}
2502
Blink Reformat1c4d759e2017-04-09 16:34:542503void RenderWidget::ConvertViewportToWindow(blink::WebRect* rect) {
danakj4b347212018-07-04 17:55:172504 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:032505 float reverse = 1 / GetOriginalScreenInfo().device_scale_factor;
oshimad5279032015-12-16 18:22:332506 // TODO(oshima): We may need to allow pixel precision here as the the
oshimaf866dab2015-12-05 00:41:542507 // anchor element can be placed at half pixel.
lfg15b235a32016-08-25 17:45:462508 gfx::Rect window_rect =
2509 gfx::ScaleToEnclosedRect(gfx::Rect(*rect), reverse);
2510 rect->x = window_rect.x();
2511 rect->y = window_rect.y();
2512 rect->width = window_rect.width();
2513 rect->height = window_rect.height();
oshimaf866dab2015-12-05 00:41:542514 }
2515}
2516
Nicolás Peña Moreno1b3f3f912019-07-16 17:04:132517void RenderWidget::ConvertViewportToWindow(blink::WebFloatRect* rect) {
2518 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
2519 rect->x /= GetOriginalScreenInfo().device_scale_factor;
2520 rect->y /= GetOriginalScreenInfo().device_scale_factor;
2521 rect->width /= GetOriginalScreenInfo().device_scale_factor;
2522 rect->height /= GetOriginalScreenInfo().device_scale_factor;
2523 }
2524}
2525
Blink Reformat1c4d759e2017-04-09 16:34:542526void RenderWidget::ConvertWindowToViewport(blink::WebFloatRect* rect) {
danakj4b347212018-07-04 17:55:172527 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:032528 rect->x *= GetOriginalScreenInfo().device_scale_factor;
2529 rect->y *= GetOriginalScreenInfo().device_scale_factor;
2530 rect->width *= GetOriginalScreenInfo().device_scale_factor;
2531 rect->height *= GetOriginalScreenInfo().device_scale_factor;
oshimaa6985b62016-01-27 08:58:302532 }
2533}
2534
changwan8c342742016-02-26 00:53:392535void RenderWidget::OnRequestTextInputStateUpdate() {
Dave Tapuska9db80842017-07-24 17:24:262536#if defined(OS_ANDROID)
danakj125a29e2019-01-24 23:25:292537 // This task may run between the Close IPC and the task that actually closes
2538 // this class.
2539 if (closing_)
2540 return;
changwan8c342742016-02-26 00:53:392541 DCHECK(!ime_event_guard_);
2542 UpdateSelectionBounds();
changwan75e3b2072017-01-16 02:55:002543 UpdateTextInputStateInternal(false, true /* reply_to_request */);
[email protected]105dffb42013-02-20 03:46:212544#endif
Dave Tapuska9db80842017-07-24 17:24:262545}
[email protected]105dffb42013-02-20 03:46:212546
ekaramadc9b70a72017-03-23 16:14:232547void RenderWidget::OnRequestCompositionUpdates(bool immediate_request,
2548 bool monitor_updates) {
2549 monitor_composition_info_ = monitor_updates;
nonafa291792016-08-10 02:36:182550 if (!immediate_request)
2551 return;
2552 UpdateCompositionInfo(true /* immediate request */);
2553}
2554
[email protected]fcdc5642014-05-09 14:32:242555void RenderWidget::OnOrientationChange() {
Ehsan Karamad655d7b8a2018-01-12 18:38:382556 if (auto* frame_widget = GetFrameWidget()) {
Alex Moshchuk0b409c42017-09-13 02:09:002557 // LocalRoot() might return null for provisional main frames. In this case,
2558 // the frame hasn't committed a navigation and is not swapped into the tree
2559 // yet, so it doesn't make sense to send orientation change events to it.
2560 //
2561 // TODO(https://crbug.com/578349): This check should be cleaned up
2562 // once provisional frames are gone.
Ehsan Karamad655d7b8a2018-01-12 18:38:382563 if (frame_widget->LocalRoot())
2564 frame_widget->LocalRoot()->SendOrientationChangeEvent();
lfg8d649cc2017-04-28 18:04:302565 }
[email protected]fcdc5642014-05-09 14:32:242566}
2567
[email protected]bee16aab2009-08-26 15:55:032568void RenderWidget::SetHidden(bool hidden) {
danakj14e00a8322019-02-07 17:12:062569 // A frozen main frame widget does not become shown or hidden, since it has
2570 // no frame associated with it. It must be thawed before changing visibility.
2571 DCHECK(!is_frozen_);
2572
[email protected]bee16aab2009-08-26 15:55:032573 if (is_hidden_ == hidden)
2574 return;
2575
jdduke8fac9d102014-12-20 02:40:132576 // The status has changed. Tell the RenderThread about it and ensure
2577 // throttled acks are released in case frame production ceases.
[email protected]bee16aab2009-08-26 15:55:032578 is_hidden_ = hidden;
jdduke8fac9d102014-12-20 02:40:132579
Scott Violete3b1a3cb2019-05-02 16:51:522580 if (is_hidden_)
Aditya Keerthic0d45b42019-02-25 18:53:002581 first_update_visual_state_after_hidden_ = true;
alexclarke7fa93942015-10-21 15:37:112582
2583 if (render_widget_scheduling_state_)
2584 render_widget_scheduling_state_->SetHidden(hidden);
danakj1b35e9d2018-11-07 19:09:282585
David Bokanf92eaf22019-03-01 01:54:512586 // If the renderer was hidden, resolve any pending synthetic gestures so they
2587 // aren't blocked waiting for a compositor frame to be generated.
2588 if (is_hidden_)
2589 widget_input_handler_manager_->InvokeInputProcessedCallback();
2590
danakj14e00a8322019-02-07 17:12:062591 StartStopCompositor();
[email protected]bee16aab2009-08-26 15:55:032592}
2593
danakjf9284772019-01-23 18:29:142594void RenderWidget::SetIsFullscreen(bool fullscreen) {
Erik Chen15476cef2019-08-27 17:28:062595 // TODO:(https://crbug.com/995981): If there is no WebWidget, then the
2596 // RenderWidget should also be destroyed, and this conditional should not be
2597 // necessary.
2598 // We intentionally avoid setting internal state so that the next time visual
2599 // properties are synchronized, state will be correctly propagated to the
2600 // WebWidget.
2601 if (!GetWebWidget())
2602 return;
2603
danakjf9284772019-01-23 18:29:142604 if (fullscreen == is_fullscreen_granted_)
[email protected]2b624c562011-10-27 22:58:262605 return;
danakjf9284772019-01-23 18:29:142606 is_fullscreen_granted_ = fullscreen;
mikhail.pozdnyakovf2c902a2015-04-14 08:09:122607 if (is_fullscreen_granted_) {
Blink Reformat1c4d759e2017-04-09 16:34:542608 GetWebWidget()->DidEnterFullscreen();
[email protected]2b624c562011-10-27 22:58:262609 } else {
Blink Reformat1c4d759e2017-04-09 16:34:542610 GetWebWidget()->DidExitFullscreen();
[email protected]2b624c562011-10-27 22:58:262611 }
[email protected]2b624c562011-10-27 22:58:262612}
2613
changwanf2a707b2015-10-30 08:22:162614void RenderWidget::OnImeEventGuardStart(ImeEventGuard* guard) {
2615 if (!ime_event_guard_)
2616 ime_event_guard_ = guard;
[email protected]66fca5bc2013-05-23 06:58:292617}
2618
changwanf2a707b2015-10-30 08:22:162619void RenderWidget::OnImeEventGuardFinish(ImeEventGuard* guard) {
Jeremy Roman0b261f42018-08-28 15:36:012620 if (ime_event_guard_ != guard)
changwanf2a707b2015-10-30 08:22:162621 return;
changwanf2a707b2015-10-30 08:22:162622 ime_event_guard_ = nullptr;
2623
[email protected]66fca5bc2013-05-23 06:58:292624 // While handling an ime event, text input state and selection bounds updates
2625 // are ignored. These must explicitly be updated once finished handling the
2626 // ime event.
2627 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:472628#if defined(OS_ANDROID)
changwan75e3b2072017-01-16 02:55:002629 if (guard->show_virtual_keyboard())
2630 ShowVirtualKeyboard();
2631 else
2632 UpdateTextInputState();
[email protected]cb9e2632013-06-18 11:26:472633#endif
[email protected]66fca5bc2013-05-23 06:58:292634}
2635
[email protected]7c8873e2013-02-05 08:03:012636void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
brettw4b461082016-11-19 18:55:162637#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492638 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
ekaramad2a46d632016-07-19 13:33:092639 // TODO(kinaba) http://crbug.com/101101
2640 // Current Pepper IME API does not handle selection bounds. So we simply
2641 // use the caret position as an empty range for now. It will be updated
2642 // after Pepper API equips features related to surrounding text retrieval.
EhsanK22d482e2017-08-10 17:29:492643 blink::WebRect caret(plugin->GetCaretBounds());
Blink Reformat1c4d759e2017-04-09 16:34:542644 ConvertViewportToWindow(&caret);
ekaramad2a46d632016-07-19 13:33:092645 *focus = caret;
2646 *anchor = caret;
2647 return;
2648 }
2649#endif
[email protected]7c8873e2013-02-05 08:03:012650 WebRect focus_webrect;
2651 WebRect anchor_webrect;
Blink Reformat1c4d759e2017-04-09 16:34:542652 GetWebWidget()->SelectionBounds(focus_webrect, anchor_webrect);
2653 ConvertViewportToWindow(&focus_webrect);
2654 ConvertViewportToWindow(&anchor_webrect);
oshima33ec97cd2015-12-14 19:40:242655 *focus = focus_webrect;
2656 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:322657}
2658
[email protected]e99ef6f2011-10-16 01:13:002659void RenderWidget::UpdateSelectionBounds() {
jdduke1aebad8e2015-07-22 23:25:082660 TRACE_EVENT0("renderer", "RenderWidget::UpdateSelectionBounds");
lfg8ff33912016-09-13 20:59:212661 if (!GetWebWidget())
[email protected]e99ef6f2011-10-16 01:13:002662 return;
changwanf2a707b2015-10-30 08:22:162663 if (ime_event_guard_)
[email protected]66fca5bc2013-05-23 06:58:292664 return;
[email protected]e99ef6f2011-10-16 01:13:002665
mohsenb0eeba72015-08-09 06:20:082666#if defined(USE_AURA)
2667 // TODO(mohsen): For now, always send explicit selection IPC notifications for
2668 // Aura beucause composited selection updates are not working for webview tags
2669 // which regresses IME inside webview. Remove this when composited selection
2670 // updates are fixed for webviews. See, http://crbug.com/510568.
2671 bool send_ipc = true;
2672#else
jddukeacf809e2014-09-23 20:38:382673 // With composited selection updates, the selection bounds will be reported
2674 // directly by the compositor, in which case explicit IPC selection
2675 // notifications should be suppressed.
mohsenb0eeba72015-08-09 06:20:082676 bool send_ipc =
Blink Reformat1c4d759e2017-04-09 16:34:542677 !blink::WebRuntimeFeatures::IsCompositedSelectionUpdateEnabled();
mohsenb0eeba72015-08-09 06:20:082678#endif
2679 if (send_ipc) {
Albert J. Wong3c93c182018-09-27 17:29:432680 WidgetHostMsg_SelectionBounds_Params params;
EhsanK955ba582017-11-30 21:14:402681 params.is_anchor_first = false;
jddukeacf809e2014-09-23 20:38:382682 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
2683 if (selection_anchor_rect_ != params.anchor_rect ||
2684 selection_focus_rect_ != params.focus_rect) {
2685 selection_anchor_rect_ = params.anchor_rect;
2686 selection_focus_rect_ = params.focus_rect;
EhsanK955ba582017-11-30 21:14:402687 if (auto* focused_frame = GetFocusedWebLocalFrameInWidget()) {
2688 focused_frame->SelectionTextDirection(params.focus_dir,
2689 params.anchor_dir);
2690 params.is_anchor_first = focused_frame->IsSelectionAnchorFirst();
2691 }
Albert J. Wong3c93c182018-09-27 17:29:432692 Send(new WidgetHostMsg_SelectionBoundsChanged(routing_id_, params));
jddukeacf809e2014-09-23 20:38:382693 }
[email protected]58b48a0d2012-06-13 07:01:352694 }
jddukeacf809e2014-09-23 20:38:382695
nonafa291792016-08-10 02:36:182696 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]e99ef6f2011-10-16 01:13:002697}
2698
lfgb00fcad2016-07-14 14:16:332699void RenderWidget::DidAutoResize(const gfx::Size& new_size) {
danakj125a29e2019-01-24 23:25:292700 // Blink can continue running and do a layout/resize between the Close IPC
2701 // and the task that actually closes this class.
2702 if (closing_)
2703 return;
2704
lfgb00fcad2016-07-14 14:16:332705 WebRect new_size_in_window(0, 0, new_size.width(), new_size.height());
Blink Reformat1c4d759e2017-04-09 16:34:542706 ConvertViewportToWindow(&new_size_in_window);
lfgb00fcad2016-07-14 14:16:332707 if (size_.width() != new_size_in_window.width ||
2708 size_.height() != new_size_in_window.height) {
2709 size_ = gfx::Size(new_size_in_window.width, new_size_in_window.height);
2710
danakj7602f4f2019-01-31 18:03:232711 if (synchronous_resize_mode_for_testing_) {
Blink Reformat1c4d759e2017-04-09 16:34:542712 gfx::Rect new_pos(WindowRect().x, WindowRect().y, size_.width(),
2713 size_.height());
Albert J. Wong3c93c182018-09-27 17:29:432714 widget_screen_rect_ = new_pos;
lfgb00fcad2016-07-14 14:16:332715 window_screen_rect_ = new_pos;
2716 }
2717
Christopher Camerone9a30c12018-03-07 08:23:382718 // TODO(ccameron): Note that this destroys any information differentiating
danakj9c4e7b812019-02-19 22:04:272719 // |size_| from the compositor's viewport size. Also note that the
Christopher Cameronaad15a0d2018-03-09 03:47:332720 // calculation of |new_compositor_viewport_pixel_size| does not appear to
2721 // take into account device emulation.
danakj125a29e2019-01-24 23:25:292722 layer_tree_view_->RequestNewLocalSurfaceId();
Christopher Cameronaad15a0d2018-03-09 03:47:332723 gfx::Size new_compositor_viewport_pixel_size =
Fady Samuela863f152018-03-09 16:10:032724 gfx::ScaleToCeiledSize(size_, GetWebScreenInfo().device_scale_factor);
Fady Samuel1c1ad3692018-11-06 23:28:402725 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
W. James MacLean7df854c2019-08-28 16:17:532726 gfx::Rect(new_compositor_viewport_pixel_size),
Fady Samuel1c1ad3692018-11-06 23:28:402727 screen_info_);
lfgb00fcad2016-07-14 14:16:332728 }
2729}
2730
[email protected]58b48a0d2012-06-13 07:01:352731void RenderWidget::GetCompositionCharacterBounds(
2732 std::vector<gfx::Rect>* bounds) {
2733 DCHECK(bounds);
2734 bounds->clear();
ekaramad2a46d632016-07-19 13:33:092735
brettw4b461082016-11-19 18:55:162736#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492737 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092738 return;
2739#endif
2740
Ehsan Karamad4975af6d2018-02-09 16:58:162741 blink::WebInputMethodController* controller = GetInputMethodController();
2742 if (!controller)
ekaramad2a46d632016-07-19 13:33:092743 return;
2744 blink::WebVector<blink::WebRect> bounds_from_blink;
Ehsan Karamad4975af6d2018-02-09 16:58:162745 if (!controller->GetCompositionCharacterBounds(bounds_from_blink))
ekaramad2a46d632016-07-19 13:33:092746 return;
2747
2748 for (size_t i = 0; i < bounds_from_blink.size(); ++i) {
Blink Reformat1c4d759e2017-04-09 16:34:542749 ConvertViewportToWindow(&bounds_from_blink[i]);
ekaramad2a46d632016-07-19 13:33:092750 bounds->push_back(bounds_from_blink[i]);
2751 }
[email protected]58b48a0d2012-06-13 07:01:352752}
2753
[email protected]db4fc1e2013-09-06 20:01:512754void RenderWidget::GetCompositionRange(gfx::Range* range) {
brettw4b461082016-11-19 18:55:162755#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492756 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092757 return;
2758#endif
EhsanKcdee7b72017-11-08 21:30:092759 blink::WebInputMethodController* controller = GetInputMethodController();
2760 WebRange web_range = controller ? controller->CompositionRange() : WebRange();
Blink Reformat1c4d759e2017-04-09 16:34:542761 if (web_range.IsNull()) {
nona2363a3d2016-11-09 03:26:212762 *range = gfx::Range::InvalidRange();
2763 return;
[email protected]88dbe32f2013-06-20 23:31:362764 }
Blink Reformat1c4d759e2017-04-09 16:34:542765 range->set_start(web_range.StartOffset());
2766 range->set_end(web_range.EndOffset());
[email protected]88dbe32f2013-06-20 23:31:362767}
2768
[email protected]501ea13d2013-07-09 17:03:292769bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:512770 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:292771 const std::vector<gfx::Rect>& bounds) {
changwan2418e1b2016-12-12 12:43:082772 if (!range.IsValid())
2773 return false;
[email protected]501ea13d2013-07-09 17:03:292774 if (composition_range_ != range)
2775 return true;
2776 if (bounds.size() != composition_character_bounds_.size())
2777 return true;
2778 for (size_t i = 0; i < bounds.size(); ++i) {
2779 if (bounds[i] != composition_character_bounds_[i])
2780 return true;
2781 }
2782 return false;
2783}
[email protected]501ea13d2013-07-09 17:03:292784
[email protected]ad26ef42011-06-17 07:59:452785bool RenderWidget::CanComposeInline() {
brettw4b461082016-11-19 18:55:162786#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492787 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2788 return plugin->IsPluginAcceptingCompositionEvents();
ekaramad2a46d632016-07-19 13:33:092789#endif
[email protected]ad26ef42011-06-17 07:59:452790 return true;
[email protected]56ea1a62011-05-30 07:05:572791}
2792
Blink Reformat1c4d759e2017-04-09 16:34:542793void RenderWidget::DidHandleGestureEvent(const WebGestureEvent& event,
2794 bool event_cancelled) {
danakja2c9d0a92018-07-25 20:01:182795 if (event_cancelled) {
Albert J. Wong7bbf22d2018-12-20 00:27:272796 // The delegate() doesn't need to hear about cancelled events.
[email protected]c68c3e4e2013-01-24 00:36:562797 return;
danakja2c9d0a92018-07-25 20:01:182798 }
2799
2800#if defined(OS_ANDROID) || defined(USE_AURA)
Blink Reformat1c4d759e2017-04-09 16:34:542801 if (event.GetType() == WebInputEvent::kGestureTap) {
changwan75e3b2072017-01-16 02:55:002802 ShowVirtualKeyboard();
Blink Reformat1c4d759e2017-04-09 16:34:542803 } else if (event.GetType() == WebInputEvent::kGestureLongPress) {
lfg8ff33912016-09-13 20:59:212804 DCHECK(GetWebWidget());
ekaramad5aff1942017-01-06 01:26:352805 blink::WebInputMethodController* controller = GetInputMethodController();
Blink Reformat1c4d759e2017-04-09 16:34:542806 if (!controller || controller->TextInputInfo().value.IsEmpty())
changwan75e3b2072017-01-16 02:55:002807 UpdateTextInputState();
[email protected]07c70d22014-08-21 08:33:462808 else
changwan75e3b2072017-01-16 02:55:002809 ShowVirtualKeyboard();
[email protected]c68c3e4e2013-01-24 00:36:562810 }
ekaramada110f642016-12-21 19:47:282811// TODO(ananta): Piggyback off existing IPCs to communicate this information,
2812// crbug/420130.
2813#if defined(OS_WIN)
danakja2c9d0a92018-07-25 20:01:182814 if (event.GetType() == blink::WebGestureEvent::kGestureTap) {
2815 // TODO(estade): hit test the event against focused node to make sure
2816 // the tap actually hit the focused node.
2817 blink::WebInputMethodController* controller = GetInputMethodController();
2818 blink::WebTextInputType text_input_type =
2819 controller ? controller->TextInputType() : blink::kWebTextInputTypeNone;
ekaramada110f642016-12-21 19:47:282820
Albert J. Wong3c93c182018-09-27 17:29:432821 Send(new WidgetHostMsg_FocusedNodeTouched(
danakja2c9d0a92018-07-25 20:01:182822 routing_id_, text_input_type != blink::kWebTextInputTypeNone));
2823 }
ekaramada110f642016-12-21 19:47:282824#endif
[email protected]c68c3e4e2013-01-24 00:36:562825#endif
[email protected]c68c3e4e2013-01-24 00:36:562826}
2827
Blink Reformat1c4d759e2017-04-09 16:34:542828void RenderWidget::DidOverscroll(
danakj1b05cf22019-04-12 23:47:052829 const blink::WebFloatSize& overscroll_delta,
2830 const blink::WebFloatSize& accumulated_overscroll,
sataya.m582c9ce2015-06-09 08:03:422831 const blink::WebFloatPoint& position,
danakj1b05cf22019-04-12 23:47:052832 const blink::WebFloatSize& velocity) {
bokan731ec382016-04-07 03:16:482833#if defined(OS_MACOSX)
2834 // On OSX the user can disable the elastic overscroll effect. If that's the
2835 // case, don't forward the overscroll notification.
2836 DCHECK(compositor_deps());
2837 if (!compositor_deps()->IsElasticOverscrollEnabled())
2838 return;
2839#endif
danakj1b05cf22019-04-12 23:47:052840 input_handler_->DidOverscrollFromBlink(
2841 overscroll_delta, accumulated_overscroll, position, velocity,
2842 layer_tree_view_->layer_tree_host()->overscroll_behavior());
2843}
2844
Daniel Libby688fcb52019-05-25 01:08:472845void RenderWidget::InjectGestureScrollEvent(
2846 blink::WebGestureDevice device,
2847 const blink::WebFloatSize& delta,
2848 ui::input_types::ScrollGranularity granularity,
2849 cc::ElementId scrollable_area_element_id,
2850 blink::WebInputEvent::Type injected_type) {
2851 input_handler_->InjectGestureScrollEvent(
2852 device, delta, granularity, scrollable_area_element_id, injected_type);
2853}
2854
danakj1b05cf22019-04-12 23:47:052855void RenderWidget::SetOverscrollBehavior(
2856 const cc::OverscrollBehavior& behavior) {
2857 layer_tree_view_->layer_tree_host()->SetOverscrollBehavior(behavior);
sataya.m582c9ce2015-06-09 08:03:422858}
2859
danakj4b347212018-07-04 17:55:172860// static
2861cc::LayerTreeSettings RenderWidget::GenerateLayerTreeSettings(
2862 CompositorDependencies* compositor_deps,
2863 bool is_for_subframe,
2864 const gfx::Size& initial_screen_size,
2865 float initial_device_scale_factor) {
2866 const bool is_threaded =
2867 !!compositor_deps->GetCompositorImplThreadTaskRunner();
2868
2869 const base::CommandLine& cmd = *base::CommandLine::ForCurrentProcess();
2870 cc::LayerTreeSettings settings;
2871
Rahul Arakerie510b8c2019-04-01 21:17:542872 settings.compositor_threaded_scrollbar_scrolling =
2873 base::FeatureList::IsEnabled(
2874 features::kCompositorThreadedScrollbarScrolling);
2875
danakj4b347212018-07-04 17:55:172876 settings.resource_settings.use_r16_texture =
2877 base::FeatureList::IsEnabled(media::kUseR16Texture);
2878
2879 settings.commit_to_active_tree = !is_threaded;
2880 settings.is_layer_tree_for_subframe = is_for_subframe;
2881
danakj4b347212018-07-04 17:55:172882 settings.main_frame_before_activation_enabled =
2883 cmd.HasSwitch(cc::switches::kEnableMainFrameBeforeActivation);
2884
2885 // Checkerimaging is not supported for synchronous single-threaded mode, which
2886 // is what the renderer uses if its not threaded.
2887 settings.enable_checker_imaging =
2888 !cmd.HasSwitch(cc::switches::kDisableCheckerImaging) && is_threaded;
2889
2890#if defined(OS_ANDROID)
2891 // We can use a more aggressive limit on Android since decodes tend to take
2892 // longer on these devices.
2893 settings.min_image_bytes_to_checker = 512 * 1024; // 512kB
2894
2895 // Re-rasterization of checker-imaged content with software raster can be too
2896 // costly on Android.
2897 settings.only_checker_images_with_gpu_raster = true;
2898#endif
2899
2900 auto switch_value_as_int = [](const base::CommandLine& command_line,
2901 const std::string& switch_string, int min_value,
2902 int max_value, int* result) {
2903 std::string string_value = command_line.GetSwitchValueASCII(switch_string);
2904 int int_value;
2905 if (base::StringToInt(string_value, &int_value) && int_value >= min_value &&
2906 int_value <= max_value) {
2907 *result = int_value;
2908 return true;
2909 } else {
danakjda15621e2019-04-05 20:34:432910 DLOG(WARNING) << "Failed to parse switch " << switch_string << ": "
2911 << string_value;
danakj4b347212018-07-04 17:55:172912 return false;
2913 }
2914 };
2915
2916 int default_tile_size = 256;
2917#if defined(OS_ANDROID)
2918 const gfx::Size screen_size =
2919 gfx::ScaleToFlooredSize(initial_screen_size, initial_device_scale_factor);
2920 int display_width = screen_size.width();
2921 int display_height = screen_size.height();
2922 int numTiles = (display_width * display_height) / (256 * 256);
2923 if (numTiles > 16)
2924 default_tile_size = 384;
2925 if (numTiles >= 40)
2926 default_tile_size = 512;
2927
2928 // Adjust for some resolutions that barely straddle an extra
2929 // tile when in portrait mode. This helps worst case scroll/raster
2930 // by not needing a full extra tile for each row.
2931 constexpr int tolerance = 10; // To avoid rounding errors.
2932 int portrait_width = std::min(display_width, display_height);
2933 if (default_tile_size == 256 && std::abs(portrait_width - 768) < tolerance)
2934 default_tile_size += 32;
2935 if (default_tile_size == 384 && std::abs(portrait_width - 1200) < tolerance)
2936 default_tile_size += 32;
2937#elif defined(OS_CHROMEOS) || defined(OS_MACOSX)
2938 // Use 512 for high DPI (dsf=2.0f) devices.
2939 if (initial_device_scale_factor >= 2.0f)
2940 default_tile_size = 512;
2941#endif
2942
2943 // TODO(danakj): This should not be a setting O_O; it should change when the
2944 // device scale factor on LayerTreeHost changes.
2945 settings.default_tile_size = gfx::Size(default_tile_size, default_tile_size);
2946 if (cmd.HasSwitch(switches::kDefaultTileWidth)) {
2947 int tile_width = 0;
2948 switch_value_as_int(cmd, switches::kDefaultTileWidth, 1,
2949 std::numeric_limits<int>::max(), &tile_width);
2950 settings.default_tile_size.set_width(tile_width);
2951 }
2952 if (cmd.HasSwitch(switches::kDefaultTileHeight)) {
2953 int tile_height = 0;
2954 switch_value_as_int(cmd, switches::kDefaultTileHeight, 1,
2955 std::numeric_limits<int>::max(), &tile_height);
2956 settings.default_tile_size.set_height(tile_height);
2957 }
2958
2959 int max_untiled_layer_width = settings.max_untiled_layer_size.width();
2960 if (cmd.HasSwitch(switches::kMaxUntiledLayerWidth)) {
2961 switch_value_as_int(cmd, switches::kMaxUntiledLayerWidth, 1,
2962 std::numeric_limits<int>::max(),
2963 &max_untiled_layer_width);
2964 }
2965 int max_untiled_layer_height = settings.max_untiled_layer_size.height();
2966 if (cmd.HasSwitch(switches::kMaxUntiledLayerHeight)) {
2967 switch_value_as_int(cmd, switches::kMaxUntiledLayerHeight, 1,
2968 std::numeric_limits<int>::max(),
2969 &max_untiled_layer_height);
2970 }
2971
2972 settings.max_untiled_layer_size =
2973 gfx::Size(max_untiled_layer_width, max_untiled_layer_height);
2974
2975 settings.gpu_rasterization_msaa_sample_count =
2976 compositor_deps->GetGpuRasterizationMSAASampleCount();
2977 settings.gpu_rasterization_forced =
2978 compositor_deps->IsGpuRasterizationForced();
2979
2980 settings.can_use_lcd_text = compositor_deps->IsLcdTextEnabled();
2981 settings.use_zero_copy = compositor_deps->IsZeroCopyEnabled();
2982 settings.use_partial_raster = compositor_deps->IsPartialRasterEnabled();
2983 settings.enable_elastic_overscroll =
2984 compositor_deps->IsElasticOverscrollEnabled();
2985 settings.resource_settings.use_gpu_memory_buffer_resources =
2986 compositor_deps->IsGpuMemoryBufferCompositorResourcesEnabled();
2987 settings.use_painted_device_scale_factor =
2988 compositor_deps->IsUseZoomForDSFEnabled();
2989
2990 // Build LayerTreeSettings from command line args.
2991 if (cmd.HasSwitch(cc::switches::kBrowserControlsShowThreshold)) {
2992 std::string top_threshold_str =
2993 cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsShowThreshold);
2994 double show_threshold;
2995 if (base::StringToDouble(top_threshold_str, &show_threshold) &&
2996 show_threshold >= 0.f && show_threshold <= 1.f)
2997 settings.top_controls_show_threshold = show_threshold;
2998 }
2999
3000 if (cmd.HasSwitch(cc::switches::kBrowserControlsHideThreshold)) {
3001 std::string top_threshold_str =
3002 cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsHideThreshold);
3003 double hide_threshold;
3004 if (base::StringToDouble(top_threshold_str, &hide_threshold) &&
3005 hide_threshold >= 0.f && hide_threshold <= 1.f)
3006 settings.top_controls_hide_threshold = hide_threshold;
3007 }
3008
Philip Rogers848424a2019-08-14 18:19:593009 // Blink sends cc a layer list and property trees.
3010 settings.use_layer_lists = true;
danakj4b347212018-07-04 17:55:173011
David Bokan163b6a72018-10-25 22:03:493012 // Blink currently doesn't support setting fractional scroll offsets so CC
3013 // must send integer values. We plan to eventually make Blink use fractional
3014 // offsets internally: https://crbug.com/414283.
3015 settings.commit_fractional_scroll_deltas =
3016 blink::WebRuntimeFeatures::IsFractionalScrollOffsetsEnabled();
3017
danakj4b347212018-07-04 17:55:173018 // The means the renderer compositor has 2 possible modes:
3019 // - Threaded compositing with a scheduler.
Kent Tamura21d1de62018-12-10 04:45:203020 // - Single threaded compositing without a scheduler (for web tests only).
3021 // Using the scheduler in web tests introduces additional composite steps
danakj4b347212018-07-04 17:55:173022 // that create flakiness.
3023 settings.single_thread_proxy_scheduler = false;
3024
3025 // These flags should be mirrored by UI versions in ui/compositor/.
3026 if (cmd.HasSwitch(cc::switches::kShowCompositedLayerBorders))
3027 settings.initial_debug_state.show_debug_borders.set();
3028 settings.initial_debug_state.show_layer_animation_bounds_rects =
3029 cmd.HasSwitch(cc::switches::kShowLayerAnimationBounds);
3030 settings.initial_debug_state.show_paint_rects =
3031 cmd.HasSwitch(switches::kShowPaintRects);
rnasri2e621942019-05-14 21:24:253032 settings.initial_debug_state.show_layout_shift_regions =
3033 cmd.HasSwitch(switches::kShowLayoutShiftRegions);
danakj4b347212018-07-04 17:55:173034 settings.initial_debug_state.show_property_changed_rects =
3035 cmd.HasSwitch(cc::switches::kShowPropertyChangedRects);
3036 settings.initial_debug_state.show_surface_damage_rects =
3037 cmd.HasSwitch(cc::switches::kShowSurfaceDamageRects);
3038 settings.initial_debug_state.show_screen_space_rects =
3039 cmd.HasSwitch(cc::switches::kShowScreenSpaceRects);
3040
3041 settings.initial_debug_state.SetRecordRenderingStats(
3042 cmd.HasSwitch(cc::switches::kEnableGpuBenchmarking));
kylechara352d2d12019-08-15 19:11:413043 settings.enable_surface_synchronization = true;
danakj4b347212018-07-04 17:55:173044 settings.build_hit_test_data = features::IsVizHitTestingSurfaceLayerEnabled();
3045
3046 if (cmd.HasSwitch(cc::switches::kSlowDownRasterScaleFactor)) {
3047 const int kMinSlowDownScaleFactor = 0;
3048 const int kMaxSlowDownScaleFactor = INT_MAX;
3049 switch_value_as_int(
3050 cmd, cc::switches::kSlowDownRasterScaleFactor, kMinSlowDownScaleFactor,
3051 kMaxSlowDownScaleFactor,
3052 &settings.initial_debug_state.slow_down_raster_scale_factor);
3053 }
3054
3055 // This is default overlay scrollbar settings for Android and DevTools mobile
3056 // emulator. Aura Overlay Scrollbar will override below.
3057 settings.scrollbar_animator = cc::LayerTreeSettings::ANDROID_OVERLAY;
3058 settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
3059 settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(300);
3060 settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(300);
3061
Daniel Libby43972d82019-02-28 21:35:363062 if (cmd.HasSwitch(cc::switches::kCCScrollAnimationDurationForTesting)) {
3063 const int kMinScrollAnimationDuration = 0;
3064 const int kMaxScrollAnimationDuration = INT_MAX;
3065 int duration;
3066 if (switch_value_as_int(cmd,
3067 cc::switches::kCCScrollAnimationDurationForTesting,
3068 kMinScrollAnimationDuration,
3069 kMaxScrollAnimationDuration, &duration)) {
3070 settings.scroll_animation_duration_for_testing =
3071 base::TimeDelta::FromSeconds(duration);
3072 }
3073 }
3074
danakj4b347212018-07-04 17:55:173075#if defined(OS_ANDROID)
3076 bool using_synchronous_compositor =
3077 compositor_deps->UsingSynchronousCompositing();
Ian Vollick7a847a82019-06-14 19:58:593078 bool using_low_memory_policy =
3079 base::SysInfo::IsLowEndDevice() && !IsSmallScreen(screen_size);
danakj4b347212018-07-04 17:55:173080
3081 settings.use_stream_video_draw_quad = true;
3082 settings.using_synchronous_renderer_compositor = using_synchronous_compositor;
3083 if (using_synchronous_compositor) {
3084 // Android WebView uses system scrollbars, so make ours invisible.
3085 // http://crbug.com/677348: This can't be done using hide_scrollbars
3086 // setting because supporting -webkit custom scrollbars is still desired
3087 // on sublayers.
3088 settings.scrollbar_animator = cc::LayerTreeSettings::NO_ANIMATOR;
3089 settings.solid_color_scrollbar_color = SK_ColorTRANSPARENT;
3090
3091 settings.enable_early_damage_check =
3092 cmd.HasSwitch(cc::switches::kCheckDamageEarly);
3093 }
3094 // Android WebView handles root layer flings itself.
3095 settings.ignore_root_layer_flings = using_synchronous_compositor;
3096 // Memory policy on Android WebView does not depend on whether device is
3097 // low end, so always use default policy.
3098 if (using_low_memory_policy && !using_synchronous_compositor) {
3099 // On low-end we want to be very carefull about killing other
3100 // apps. So initially we use 50% more memory to avoid flickering
3101 // or raster-on-demand.
3102 settings.max_memory_for_prepaint_percentage = 67;
3103 } else {
3104 // On other devices we have increased memory excessively to avoid
3105 // raster-on-demand already, so now we reserve 50% _only_ to avoid
3106 // raster-on-demand, and use 50% of the memory otherwise.
3107 settings.max_memory_for_prepaint_percentage = 50;
3108 }
3109
3110 // TODO(danakj): Only do this on low end devices.
3111 settings.create_low_res_tiling = true;
3112
3113#else // defined(OS_ANDROID)
3114 bool using_synchronous_compositor = false; // Only for Android WebView.
3115 // On desktop, we never use the low memory policy unless we are simulating
3116 // low-end mode via a switch.
3117 bool using_low_memory_policy =
3118 cmd.HasSwitch(switches::kEnableLowEndDeviceMode);
3119
3120 if (ui::IsOverlayScrollbarEnabled()) {
3121 settings.scrollbar_animator = cc::LayerTreeSettings::AURA_OVERLAY;
3122 settings.scrollbar_fade_delay = ui::kOverlayScrollbarFadeDelay;
3123 settings.scrollbar_fade_duration = ui::kOverlayScrollbarFadeDuration;
3124 settings.scrollbar_thinning_duration =
3125 ui::kOverlayScrollbarThinningDuration;
3126 settings.scrollbar_flash_after_any_scroll_update =
3127 ui::OverlayScrollbarFlashAfterAnyScrollUpdate();
3128 settings.scrollbar_flash_when_mouse_enter =
3129 ui::OverlayScrollbarFlashWhenMouseEnter();
3130 }
3131
3132 // On desktop, if there's over 4GB of memory on the machine, increase the
3133 // working set size to 256MB for both gpu and software.
3134 const int kImageDecodeMemoryThresholdMB = 4 * 1024;
3135 if (base::SysInfo::AmountOfPhysicalMemoryMB() >=
3136 kImageDecodeMemoryThresholdMB) {
3137 settings.decoded_image_working_set_budget_bytes = 256 * 1024 * 1024;
3138 } else {
3139 // This is the default, but recorded here as well.
3140 settings.decoded_image_working_set_budget_bytes = 128 * 1024 * 1024;
3141 }
3142#endif // defined(OS_ANDROID)
3143
3144 if (using_low_memory_policy) {
3145 // RGBA_4444 textures are only enabled:
3146 // - If the user hasn't explicitly disabled them
3147 // - If system ram is <= 512MB (1GB devices are sometimes low-end).
3148 // - If we are not running in a WebView, where 4444 isn't supported.
3149 if (!cmd.HasSwitch(switches::kDisableRGBA4444Textures) &&
3150 base::SysInfo::AmountOfPhysicalMemoryMB() <= 512 &&
3151 !using_synchronous_compositor) {
3152 settings.use_rgba_4444 = viz::RGBA_4444;
3153
3154 // If we are going to unpremultiply and dither these tiles, we need to
3155 // allocate an additional RGBA_8888 intermediate for each tile
3156 // rasterization when rastering to RGBA_4444 to allow for dithering.
3157 // Setting a reasonable sized max tile size allows this intermediate to
3158 // be consistently reused.
3159 if (base::FeatureList::IsEnabled(
3160 kUnpremultiplyAndDitherLowBitDepthTiles)) {
3161 settings.max_gpu_raster_tile_size = gfx::Size(512, 256);
3162 settings.unpremultiply_and_dither_low_bit_depth_tiles = true;
3163 }
3164 }
3165 }
3166
3167 if (cmd.HasSwitch(switches::kEnableLowResTiling))
3168 settings.create_low_res_tiling = true;
3169 if (cmd.HasSwitch(switches::kDisableLowResTiling))
3170 settings.create_low_res_tiling = false;
3171
3172 if (cmd.HasSwitch(switches::kEnableRGBA4444Textures) &&
3173 !cmd.HasSwitch(switches::kDisableRGBA4444Textures)) {
3174 settings.use_rgba_4444 = true;
3175 }
3176
3177 settings.max_staging_buffer_usage_in_bytes = 32 * 1024 * 1024; // 32MB
3178 // Use 1/4th of staging buffers on low-end devices.
3179 if (base::SysInfo::IsLowEndDevice())
3180 settings.max_staging_buffer_usage_in_bytes /= 4;
3181
3182 cc::ManagedMemoryPolicy defaults = settings.memory_policy;
3183 settings.memory_policy = GetGpuMemoryPolicy(defaults, initial_screen_size,
3184 initial_device_scale_factor);
3185
3186 settings.disallow_non_exact_resource_reuse =
3187 cmd.HasSwitch(switches::kDisallowNonExactResourceReuse);
3188#if defined(OS_ANDROID)
3189 // TODO(crbug.com/746931): This feature appears to be causing visual
3190 // corruption on certain android devices. Will investigate and re-enable.
3191 settings.disallow_non_exact_resource_reuse = true;
3192#endif
3193
3194 if (cmd.HasSwitch(switches::kRunAllCompositorStagesBeforeDraw)) {
3195 settings.wait_for_all_pipeline_stages_before_draw = true;
3196 settings.enable_latency_recovery = false;
3197 }
Eric Karl1e6ffca2019-02-23 22:08:503198#if defined(OS_ANDROID)
kylechara352d2d12019-08-15 19:11:413199 // TODO(crbug.com/933846): LatencyRecovery is causing jank on Android. Disable
3200 // in viz mode for now, with plan to disable more widely once viz launches.
3201 settings.enable_latency_recovery = false;
Eric Karl1e6ffca2019-02-23 22:08:503202#endif
danakj4b347212018-07-04 17:55:173203
3204 settings.enable_image_animation_resync =
3205 !cmd.HasSwitch(switches::kDisableImageAnimationResync);
3206
Karolina Soltys4d60b402018-10-01 19:28:203207 settings.send_compositor_frame_ack = false;
3208
danakj4b347212018-07-04 17:55:173209 return settings;
3210}
3211
3212// static
3213cc::ManagedMemoryPolicy RenderWidget::GetGpuMemoryPolicy(
3214 const cc::ManagedMemoryPolicy& default_policy,
3215 const gfx::Size& initial_screen_size,
3216 float initial_device_scale_factor) {
3217 cc::ManagedMemoryPolicy actual = default_policy;
3218 actual.bytes_limit_when_visible = 0;
3219
3220 // If the value was overridden on the command line, use the specified value.
3221 static bool client_hard_limit_bytes_overridden =
3222 base::CommandLine::ForCurrentProcess()->HasSwitch(
3223 switches::kForceGpuMemAvailableMb);
3224 if (client_hard_limit_bytes_overridden) {
3225 if (base::StringToSizeT(
3226 base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
3227 switches::kForceGpuMemAvailableMb),
3228 &actual.bytes_limit_when_visible))
3229 actual.bytes_limit_when_visible *= 1024 * 1024;
3230 return actual;
3231 }
3232
3233#if defined(OS_ANDROID)
3234 // We can't query available GPU memory from the system on Android.
3235 // Physical memory is also mis-reported sometimes (eg. Nexus 10 reports
3236 // 1262MB when it actually has 2GB, while Razr M has 1GB but only reports
3237 // 128MB java heap size). First we estimate physical memory using both.
3238 size_t dalvik_mb = base::SysInfo::DalvikHeapSizeMB();
3239 size_t physical_mb = base::SysInfo::AmountOfPhysicalMemoryMB();
3240 size_t physical_memory_mb = 0;
3241 if (base::SysInfo::IsLowEndDevice()) {
3242 // TODO(crbug.com/742534): The code below appears to no longer work.
3243 // |dalvik_mb| no longer follows the expected heuristic pattern, causing us
3244 // to over-estimate memory on low-end devices. This entire section probably
3245 // needs to be re-written, but for now we can address the low-end Android
3246 // issues by ignoring |dalvik_mb|.
3247 physical_memory_mb = physical_mb;
3248 } else if (dalvik_mb >= 256) {
3249 physical_memory_mb = dalvik_mb * 4;
3250 } else {
3251 physical_memory_mb = std::max(dalvik_mb * 4, (physical_mb * 4) / 3);
3252 }
3253
3254 // Now we take a default of 1/8th of memory on high-memory devices,
3255 // and gradually scale that back for low-memory devices (to be nicer
3256 // to other apps so they don't get killed). Examples:
3257 // Nexus 4/10(2GB) 256MB (normally 128MB)
3258 // Droid Razr M(1GB) 114MB (normally 57MB)
3259 // Galaxy Nexus(1GB) 100MB (normally 50MB)
3260 // Xoom(1GB) 100MB (normally 50MB)
3261 // Nexus S(low-end) 8MB (normally 8MB)
3262 // Note that the compositor now uses only some of this memory for
3263 // pre-painting and uses the rest only for 'emergencies'.
3264 if (actual.bytes_limit_when_visible == 0) {
3265 // NOTE: Non-low-end devices use only 50% of these limits,
3266 // except during 'emergencies' where 100% can be used.
3267 if (physical_memory_mb >= 1536)
3268 actual.bytes_limit_when_visible = physical_memory_mb / 8; // >192MB
3269 else if (physical_memory_mb >= 1152)
3270 actual.bytes_limit_when_visible = physical_memory_mb / 8; // >144MB
3271 else if (physical_memory_mb >= 768)
3272 actual.bytes_limit_when_visible = physical_memory_mb / 10; // >76MB
3273 else if (physical_memory_mb >= 513)
3274 actual.bytes_limit_when_visible = physical_memory_mb / 12; // <64MB
3275 else
3276 // Devices with this little RAM have very little headroom so we hardcode
3277 // the limit rather than relying on the heuristics above. (They also use
3278 // 4444 textures so we can use a lower limit.)
3279 actual.bytes_limit_when_visible = 8;
3280
3281 actual.bytes_limit_when_visible =
3282 actual.bytes_limit_when_visible * 1024 * 1024;
3283 // Clamp the observed value to a specific range on Android.
3284 actual.bytes_limit_when_visible = std::max(
3285 actual.bytes_limit_when_visible, static_cast<size_t>(8 * 1024 * 1024));
3286 actual.bytes_limit_when_visible =
3287 std::min(actual.bytes_limit_when_visible,
3288 static_cast<size_t>(256 * 1024 * 1024));
3289 }
3290 actual.priority_cutoff_when_visible =
3291 gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING;
3292#else
3293 // Ignore what the system said and give all clients the same maximum
3294 // allocation on desktop platforms.
3295 actual.bytes_limit_when_visible = 512 * 1024 * 1024;
3296 actual.priority_cutoff_when_visible =
3297 gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
3298
3299 // For large monitors (4k), double the tile memory to avoid frequent out of
3300 // memory problems. 4k could mean a screen width of anywhere from 3840 to 4096
3301 // (see https://en.wikipedia.org/wiki/4K_resolution). We use 3500 as a proxy
3302 // for "large enough".
3303 static const int kLargeDisplayThreshold = 3500;
3304 int display_width =
3305 std::round(initial_screen_size.width() * initial_device_scale_factor);
3306 if (display_width >= kLargeDisplayThreshold)
3307 actual.bytes_limit_when_visible *= 2;
3308#endif
3309 return actual;
3310}
3311
danakj2e87fd82019-07-05 16:42:293312void RenderWidget::SetHasPointerRawUpdateEventHandlers(bool has_handlers) {
Navid Zolghadr8fdb6114e2018-08-29 19:00:543313 if (input_event_queue_)
Navid Zolghadr4ed3ae42019-05-03 17:02:123314 input_event_queue_->HasPointerRawUpdateEventHandlers(has_handlers);
Navid Zolghadr8fdb6114e2018-08-29 19:00:543315}
3316
danakj2e87fd82019-07-05 16:42:293317void RenderWidget::SetHasTouchEventHandlers(bool has_handlers) {
W. James MacLean662d5382018-03-29 18:33:083318 if (has_touch_handlers_ && *has_touch_handlers_ == has_handlers)
3319 return;
3320
3321 has_touch_handlers_ = has_handlers;
alexclarke7fa93942015-10-21 15:37:113322 if (render_widget_scheduling_state_)
3323 render_widget_scheduling_state_->SetHasTouchHandler(has_handlers);
Albert J. Wongeb28e7e2018-10-12 00:57:433324 Send(new WidgetHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
[email protected]ce6689f2013-03-29 12:52:553325}
3326
danakj4645c022019-07-23 18:15:263327void RenderWidget::SetHaveScrollEventHandlers(bool have_handlers) {
3328 layer_tree_view_->layer_tree_host()->SetHaveScrollEventHandlers(
3329 have_handlers);
3330}
3331
Dave Tapuskadfe486c12017-06-09 16:53:133332void RenderWidget::SetNeedsLowLatencyInput(bool needs_low_latency) {
3333 if (input_event_queue_)
3334 input_event_queue_->SetNeedsLowLatency(needs_low_latency);
3335}
3336
Pavel Feldman6708eefa2019-01-17 03:14:323337void RenderWidget::SetNeedsUnbufferedInputForDebugger(bool unbuffered) {
3338 if (input_event_queue_)
3339 input_event_queue_->SetNeedsUnbufferedInputForDebugger(unbuffered);
3340}
3341
W. James MacLeand973a55b2018-11-29 21:39:133342void RenderWidget::AnimateDoubleTapZoomInMainFrame(
3343 const blink::WebPoint& point,
3344 const blink::WebRect& rect_to_zoom) {
3345 // Only oopif subframes should be sending this message.
Albert J. Wong7bbf22d2018-12-20 00:27:273346 DCHECK(!delegate());
W. James MacLeand973a55b2018-11-29 21:39:133347 Send(new WidgetHostMsg_AnimateDoubleTapZoomInMainFrame(routing_id(), point,
3348 rect_to_zoom));
3349}
3350
W. James MacLean5372eb72018-12-19 12:56:363351void RenderWidget::ZoomToFindInPageRectInMainFrame(
3352 const blink::WebRect& rect_to_zoom) {
3353 // Only oopif subframes should be sending this message.
Albert J. Wong7bbf22d2018-12-20 00:27:273354 DCHECK(!delegate_);
W. James MacLean5372eb72018-12-19 12:56:363355 Send(new WidgetHostMsg_ZoomToFindInPageRectInMainFrame(routing_id(),
3356 rect_to_zoom));
3357}
3358
danakj4886cad2019-02-26 22:15:563359void RenderWidget::RegisterViewportLayers(const cc::ViewportLayers& layers) {
3360 layer_tree_view_->layer_tree_host()->RegisterViewportLayers(layers);
3361}
3362
3363void RenderWidget::RegisterSelection(const cc::LayerSelection& selection) {
3364 layer_tree_view_->layer_tree_host()->RegisterSelection(selection);
3365}
3366
chaopeng161241b72019-03-21 18:25:173367void RenderWidget::FallbackCursorModeLockCursor(bool left,
3368 bool right,
3369 bool up,
3370 bool down) {
3371 widget_input_handler_manager_->FallbackCursorModeLockCursor(left, right, up,
3372 down);
3373}
3374
3375void RenderWidget::FallbackCursorModeSetCursorVisibility(bool visible) {
3376 widget_input_handler_manager_->FallbackCursorModeSetCursorVisibility(visible);
3377}
3378
danakj35c203a2019-04-16 17:12:393379void RenderWidget::SetAllowGpuRasterization(bool allow_gpu_raster) {
3380 layer_tree_view_->layer_tree_host()->SetHasGpuRasterizationTrigger(
3381 allow_gpu_raster);
3382}
3383
W. James MacLean233a64ff2019-05-18 16:18:493384void RenderWidget::SetPageScaleStateAndLimits(float page_scale_factor,
3385 bool is_pinch_gesture_active,
3386 float minimum,
3387 float maximum) {
danakj77821e252019-03-27 19:58:043388 layer_tree_view_->layer_tree_host()->SetPageScaleFactorAndLimits(
3389 page_scale_factor, minimum, maximum);
W. James MacLean233a64ff2019-05-18 16:18:493390
3391 // Only continue if this is a mainframe, or something's actually changed.
3392 if (!delegate() ||
3393 (page_scale_factor == page_scale_factor_from_mainframe_ &&
3394 is_pinch_gesture_active == is_pinch_gesture_active_from_mainframe_)) {
3395 return;
3396 }
3397
3398 // The page scale is controlled by the WebView for the local main frame of
3399 // the Page. So this is called from blink by for the RenderWidget of that
3400 // local main frame. We forward the value on to each child RenderWidget (each
3401 // of which will be via proxy child frame). These will each in turn forward
3402 // the message to their child RenderWidgets (through their proxy child
3403 // frames).
3404 DCHECK(!is_frozen_);
3405
3406 for (auto& observer : render_frame_proxies_) {
3407 observer.OnPageScaleFactorChanged(page_scale_factor,
3408 is_pinch_gesture_active);
3409 }
3410 // Store the value to give to any new RenderFrameProxy that is registered.
3411 page_scale_factor_from_mainframe_ = page_scale_factor;
3412 is_pinch_gesture_active_from_mainframe_ = is_pinch_gesture_active;
danakj77821e252019-03-27 19:58:043413}
3414
3415void RenderWidget::StartPageScaleAnimation(const gfx::Vector2d& target_offset,
3416 bool use_anchor,
3417 float new_page_scale,
Sergio Villar Senin2127d7b2019-07-31 17:29:583418 base::TimeDelta duration) {
danakj77821e252019-03-27 19:58:043419 layer_tree_view_->layer_tree_host()->StartPageScaleAnimation(
3420 target_offset, use_anchor, new_page_scale, duration);
3421}
3422
danakjd92cf59a42019-07-23 15:22:513423void RenderWidget::ForceRecalculateRasterScales() {
3424 layer_tree_view_->layer_tree_host()->SetNeedsRecalculateRasterScales();
3425}
3426
danakjda15621e2019-04-05 20:34:433427void RenderWidget::RequestDecode(const cc::PaintImage& image,
3428 base::OnceCallback<void(bool)> callback) {
3429 layer_tree_view_->layer_tree_host()->QueueImageDecode(image,
3430 std::move(callback));
3431}
3432
danakj2d2889a2019-04-05 21:22:083433// Enables measuring and reporting both presentation times and swap times in
3434// swap promises.
3435class ReportTimeSwapPromise : public cc::SwapPromise {
3436 using ReportTimeCallback = blink::WebWidgetClient::ReportTimeCallback;
3437
3438 public:
Mohsen Izadid6715832019-06-05 00:32:513439 ReportTimeSwapPromise(ReportTimeCallback swap_time_callback,
3440 ReportTimeCallback presentation_time_callback,
danakj2d2889a2019-04-05 21:22:083441 scoped_refptr<base::SingleThreadTaskRunner> task_runner,
3442 base::WeakPtr<RenderWidget> render_widget)
Mohsen Izadid6715832019-06-05 00:32:513443 : swap_time_callback_(std::move(swap_time_callback)),
3444 presentation_time_callback_(std::move(presentation_time_callback)),
danakj2d2889a2019-04-05 21:22:083445 task_runner_(std::move(task_runner)),
3446 render_widget_(std::move(render_widget)) {}
3447 ~ReportTimeSwapPromise() override = default;
3448
3449 void DidActivate() override {}
3450
3451 void WillSwap(viz::CompositorFrameMetadata* metadata) override {
3452 DCHECK_GT(metadata->frame_token, 0u);
3453 // The interval between the current swap and its presentation time is
3454 // reported in UMA (see corresponding code in DidSwap() below).
3455 frame_token_ = metadata->frame_token;
3456 }
3457 void DidSwap() override {
3458 DCHECK_GT(frame_token_, 0u);
3459 task_runner_->PostTask(
Mohsen Izadid6715832019-06-05 00:32:513460 FROM_HERE, base::BindOnce(&RunCallbackAfterSwap, base::TimeTicks::Now(),
3461 std::move(swap_time_callback_),
3462 std::move(presentation_time_callback_),
3463 std::move(render_widget_), frame_token_));
danakj2d2889a2019-04-05 21:22:083464 }
3465
Bo Liudef993a2019-04-24 20:08:493466 cc::SwapPromise::DidNotSwapAction DidNotSwap(
3467 DidNotSwapReason reason) override {
danakj2d2889a2019-04-05 21:22:083468 blink::WebWidgetClient::SwapResult result;
3469 switch (reason) {
3470 case cc::SwapPromise::DidNotSwapReason::SWAP_FAILS:
3471 result = blink::WebWidgetClient::SwapResult::kDidNotSwapSwapFails;
3472 break;
3473 case cc::SwapPromise::DidNotSwapReason::COMMIT_FAILS:
3474 result = blink::WebWidgetClient::SwapResult::kDidNotSwapCommitFails;
3475 break;
3476 case cc::SwapPromise::DidNotSwapReason::COMMIT_NO_UPDATE:
3477 result = blink::WebWidgetClient::SwapResult::kDidNotSwapCommitNoUpdate;
3478 break;
3479 case cc::SwapPromise::DidNotSwapReason::ACTIVATION_FAILS:
3480 result = blink::WebWidgetClient::SwapResult::kDidNotSwapActivationFails;
3481 break;
3482 }
3483 // During a failed swap, return the current time regardless of whether we're
3484 // using presentation or swap timestamps.
3485 task_runner_->PostTask(
3486 FROM_HERE,
Mohsen Izadid6715832019-06-05 00:32:513487 base::BindOnce(
3488 [](blink::WebWidgetClient::SwapResult result,
3489 base::TimeTicks swap_time, ReportTimeCallback swap_time_callback,
3490 ReportTimeCallback presentation_time_callback) {
3491 ReportTime(std::move(swap_time_callback), result, swap_time);
3492 ReportTime(std::move(presentation_time_callback), result,
3493 swap_time);
3494 },
3495 result, base::TimeTicks::Now(), std::move(swap_time_callback_),
3496 std::move(presentation_time_callback_)));
Bo Liudef993a2019-04-24 20:08:493497 return DidNotSwapAction::BREAK_PROMISE;
danakj2d2889a2019-04-05 21:22:083498 }
3499
3500 int64_t TraceId() const override { return 0; }
3501
3502 private:
Mohsen Izadid6715832019-06-05 00:32:513503 static void RunCallbackAfterSwap(
3504 base::TimeTicks swap_time,
3505 ReportTimeCallback swap_time_callback,
3506 ReportTimeCallback presentation_time_callback,
3507 base::WeakPtr<RenderWidget> render_widget,
3508 int frame_token) {
3509 if (render_widget) {
3510 render_widget->layer_tree_view()->AddPresentationCallback(
3511 frame_token,
3512 base::BindOnce(&RunCallbackAfterPresentation,
3513 std::move(presentation_time_callback), swap_time));
3514 ReportTime(std::move(swap_time_callback),
3515 blink::WebWidgetClient::SwapResult::kDidSwap, swap_time);
3516 } else {
3517 ReportTime(std::move(swap_time_callback),
3518 blink::WebWidgetClient::SwapResult::kDidSwap, swap_time);
3519 ReportTime(std::move(presentation_time_callback),
3520 blink::WebWidgetClient::SwapResult::kDidSwap, swap_time);
3521 }
3522 }
3523
3524 static void RunCallbackAfterPresentation(
3525 ReportTimeCallback presentation_time_callback,
danakj2d2889a2019-04-05 21:22:083526 base::TimeTicks swap_time,
3527 base::TimeTicks presentation_time) {
3528 DCHECK(!swap_time.is_null());
3529 bool presentation_time_is_valid =
3530 !presentation_time.is_null() && (presentation_time > swap_time);
3531 UMA_HISTOGRAM_BOOLEAN("PageLoad.Internal.Renderer.PresentationTime.Valid",
3532 presentation_time_is_valid);
3533 if (presentation_time_is_valid) {
3534 // This measures from 1ms to 10seconds.
3535 UMA_HISTOGRAM_TIMES(
3536 "PageLoad.Internal.Renderer.PresentationTime.DeltaFromSwapTime",
3537 presentation_time - swap_time);
3538 }
Mohsen Izadid6715832019-06-05 00:32:513539 ReportTime(std::move(presentation_time_callback),
3540 blink::WebWidgetClient::SwapResult::kDidSwap,
3541 presentation_time_is_valid ? presentation_time : swap_time);
danakj2d2889a2019-04-05 21:22:083542 }
3543
Mohsen Izadid6715832019-06-05 00:32:513544 static void ReportTime(ReportTimeCallback callback,
3545 blink::WebWidgetClient::SwapResult result,
3546 base::TimeTicks time) {
3547 if (callback)
3548 std::move(callback).Run(result, time);
3549 }
3550
3551 ReportTimeCallback swap_time_callback_;
3552 ReportTimeCallback presentation_time_callback_;
danakj2d2889a2019-04-05 21:22:083553 scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
3554 base::WeakPtr<RenderWidget> render_widget_;
3555 uint32_t frame_token_ = 0;
3556
3557 DISALLOW_COPY_AND_ASSIGN(ReportTimeSwapPromise);
3558};
3559
3560void RenderWidget::NotifySwapTime(ReportTimeCallback callback) {
Mohsen Izadid6715832019-06-05 00:32:513561 NotifySwapAndPresentationTime(base::NullCallback(), std::move(callback));
3562}
3563
danakj2e87fd82019-07-05 16:42:293564void RenderWidget::SetEventListenerProperties(
3565 cc::EventListenerClass event_class,
3566 cc::EventListenerProperties properties) {
3567 layer_tree_view_->layer_tree_host()->SetEventListenerProperties(event_class,
3568 properties);
3569}
3570
3571cc::EventListenerProperties RenderWidget::EventListenerProperties(
3572 cc::EventListenerClass event_class) const {
3573 return layer_tree_view_->layer_tree_host()->event_listener_properties(
3574 event_class);
3575}
3576
danakj2001a282019-07-18 19:12:323577std::unique_ptr<cc::ScopedDeferMainFrameUpdate>
3578RenderWidget::DeferMainFrameUpdate() {
3579 return layer_tree_view_->layer_tree_host()->DeferMainFrameUpdate();
3580}
3581
3582void RenderWidget::StartDeferringCommits(base::TimeDelta timeout) {
3583 layer_tree_view_->layer_tree_host()->StartDeferringCommits(timeout);
3584}
3585
3586void RenderWidget::StopDeferringCommits(cc::PaintHoldingCommitTrigger trigger) {
3587 layer_tree_view_->layer_tree_host()->StopDeferringCommits(trigger);
3588}
3589
danakjef7f7fa02019-07-26 22:50:063590void RenderWidget::RequestBeginMainFrameNotExpected(bool request) {
3591 layer_tree_view_->layer_tree_host()->RequestBeginMainFrameNotExpected(
3592 request);
3593}
3594
3595int RenderWidget::GetLayerTreeId() const {
3596 return layer_tree_view_->layer_tree_host()->GetId();
3597}
3598
Erik Chenad7f4a1e2019-08-05 20:38:053599void RenderWidget::SetBrowserControlsShownRatio(float ratio) {
3600 layer_tree_view_->layer_tree_host()->SetBrowserControlsShownRatio(ratio);
3601}
3602
3603void RenderWidget::SetBrowserControlsHeight(float top_height,
3604 float bottom_height,
3605 bool shrink_viewport) {
3606 layer_tree_view_->layer_tree_host()->SetBrowserControlsHeight(
3607 top_height, bottom_height, shrink_viewport);
3608}
3609
Erik Chen4f2f6f0d2019-08-14 23:17:233610viz::FrameSinkId RenderWidget::GetFrameSinkId() {
3611 return viz::FrameSinkId(RenderThread::Get()->GetClientId(), routing_id());
3612}
3613
Mohsen Izadid6715832019-06-05 00:32:513614void RenderWidget::NotifySwapAndPresentationTime(
3615 ReportTimeCallback swap_time_callback,
3616 ReportTimeCallback presentation_time_callback) {
danakj2d2889a2019-04-05 21:22:083617 cc::LayerTreeHost* layer_tree_host = layer_tree_view_->layer_tree_host();
3618 // When the WebWidget is closed we cancel any pending SwapPromise that would
3619 // call back into blink, so we use |close_weak_ptr_factory_|.
3620 layer_tree_host->QueueSwapPromise(std::make_unique<ReportTimeSwapPromise>(
Mohsen Izadid6715832019-06-05 00:32:513621 std::move(swap_time_callback), std::move(presentation_time_callback),
danakj2d2889a2019-04-05 21:22:083622 layer_tree_host->GetTaskRunnerProvider()->MainThreadTaskRunner(),
3623 close_weak_ptr_factory_.GetWeakPtr()));
3624}
3625
Dave Tapuskabafc2ba32017-11-28 01:54:373626void RenderWidget::RequestUnbufferedInputEvents() {
3627 if (input_event_queue_)
3628 input_event_queue_->RequestUnbufferedInputEvents();
3629}
3630
xidachenfa0199e72017-05-11 11:34:263631void RenderWidget::SetTouchAction(cc::TouchAction touch_action) {
Dave Tapuskab28a1082017-08-30 15:37:263632 if (!input_handler_->ProcessTouchAction(touch_action))
[email protected]5d0bbdfa92013-12-10 00:35:513633 return;
3634
Dave Tapuska04bc5ee92018-04-17 19:03:313635 widget_input_handler_manager_->ProcessTouchAction(touch_action);
[email protected]5d0bbdfa92013-12-10 00:35:513636}
3637
[email protected]e3244ed2014-06-20 20:04:273638void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
3639 render_frame_proxies_.AddObserver(proxy);
danakj0246bba02019-01-23 23:12:273640 // Page scale factor is propagated down the RenderWidget tree (across
3641 // frame trees). A new RenderFrameProxy means there is a new child
3642 // RenderWidget in another frame tree. In order for it to hear about
3643 // the page scale factor we pass along the last seen value here.
W. James MacLean2cd99b62019-04-08 13:54:433644 proxy->OnPageScaleFactorChanged(page_scale_factor_from_mainframe_,
3645 is_pinch_gesture_active_from_mainframe_);
[email protected]bffc8302014-01-23 20:52:163646}
3647
[email protected]e3244ed2014-06-20 20:04:273648void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
3649 render_frame_proxies_.RemoveObserver(proxy);
[email protected]bffc8302014-01-23 20:52:163650}
3651
[email protected]de3c5d82014-05-28 22:12:593652void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
3653 render_frames_.AddObserver(frame);
3654}
3655
3656void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) {
3657 render_frames_.RemoveObserver(frame);
3658}
3659
Saman Samid189e5dfd2017-12-20 22:55:313660void RenderWidget::RegisterBrowserPlugin(BrowserPlugin* browser_plugin) {
3661 browser_plugins_.AddObserver(browser_plugin);
Saman Sami50d1e0c2018-03-13 20:03:493662 browser_plugin->ScreenInfoChanged(GetOriginalScreenInfo());
Saman Samid189e5dfd2017-12-20 22:55:313663}
3664
3665void RenderWidget::UnregisterBrowserPlugin(BrowserPlugin* browser_plugin) {
3666 browser_plugins_.RemoveObserver(browser_plugin);
3667}
3668
Albert J. Wong3c93c182018-09-27 17:29:433669void RenderWidget::OnWaitNextFrameForTests(
3670 int main_frame_thread_observer_routing_id) {
danakj53802692018-07-25 21:46:443671 // Sends an ACK to the browser process during the next compositor frame.
Albert J. Wong3c93c182018-09-27 17:29:433672 QueueMessage(new WidgetHostMsg_WaitForNextFrameForTests_ACK(
3673 main_frame_thread_observer_routing_id));
lfg43e08e62016-02-03 18:51:373674}
3675
Fady Samuela863f152018-03-09 16:10:033676const ScreenInfo& RenderWidget::GetWebScreenInfo() const {
3677 return screen_info_;
Christopher Camerone9a30c12018-03-07 08:23:383678}
3679
Fady Samuela863f152018-03-09 16:10:033680const ScreenInfo& RenderWidget::GetOriginalScreenInfo() const {
Christopher Camerone9a30c12018-03-07 08:23:383681 return screen_metrics_emulator_
3682 ? screen_metrics_emulator_->original_screen_info()
Fady Samuela863f152018-03-09 16:10:033683 : screen_info_;
oshima50872a72016-03-04 13:26:183684}
3685
Ella Ge80a52dce2017-11-15 18:01:523686gfx::PointF RenderWidget::ConvertWindowPointToViewport(
3687 const gfx::PointF& point) {
paulmeyer90f6c31d2016-11-12 00:17:593688 blink::WebFloatRect point_in_viewport(point.x(), point.y(), 0, 0);
Blink Reformat1c4d759e2017-04-09 16:34:543689 ConvertWindowToViewport(&point_in_viewport);
Ella Ge80a52dce2017-11-15 18:01:523690 return gfx::PointF(point_in_viewport.x, point_in_viewport.y);
3691}
3692
3693gfx::Point RenderWidget::ConvertWindowPointToViewport(const gfx::Point& point) {
3694 return gfx::ToRoundedPoint(ConvertWindowPointToViewport(gfx::PointF(point)));
paulmeyer90f6c31d2016-11-12 00:17:593695}
3696
Mustaq Ahmed32a0b152019-08-06 16:01:263697bool RenderWidget::RequestPointerLock(WebLocalFrame* requester_frame) {
3698 return mouse_lock_dispatcher_->LockMouse(webwidget_mouse_lock_target_.get(),
3699 requester_frame);
lfgbee1e0a2016-06-08 21:24:213700}
3701
Blink Reformat1c4d759e2017-04-09 16:34:543702void RenderWidget::RequestPointerUnlock() {
lfgbee1e0a2016-06-08 21:24:213703 mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
3704}
3705
Blink Reformat1c4d759e2017-04-09 16:34:543706bool RenderWidget::IsPointerLocked() {
lfgbee1e0a2016-06-08 21:24:213707 return mouse_lock_dispatcher_->IsMouseLockedTo(
3708 webwidget_mouse_lock_target_.get());
3709}
3710
Richard Li49fe04d2018-10-21 09:07:193711void RenderWidget::StartDragging(network::mojom::ReferrerPolicy policy,
paulmeyer6ef5a792016-11-08 20:33:583712 const WebDragData& data,
3713 WebDragOperationsMask mask,
danakj0c75ad82018-07-10 19:50:123714 const SkBitmap& drag_image,
danakjef1735a2018-11-13 19:34:443715 const gfx::Point& web_image_offset) {
3716 blink::WebRect offset_in_window(web_image_offset.x(), web_image_offset.y(), 0,
3717 0);
Blink Reformat1c4d759e2017-04-09 16:34:543718 ConvertViewportToWindow(&offset_in_window);
paulmeyer6ef5a792016-11-08 20:33:583719 DropData drop_data(DropDataBuilder::Build(data));
3720 drop_data.referrer_policy = policy;
danakj0c75ad82018-07-10 19:50:123721 gfx::Vector2d image_offset(offset_in_window.x, offset_in_window.y);
3722 Send(new DragHostMsg_StartDragging(routing_id(), drop_data, mask, drag_image,
3723 image_offset, possible_drag_event_info_));
paulmeyer6ef5a792016-11-08 20:33:583724}
3725
Saman Samif7731342018-01-24 22:18:443726void RenderWidget::DidNavigate() {
danakj125a29e2019-01-24 23:25:293727 // Blink may be navigating still between the Close IPC and the task that
3728 // actually closes this class, and for a main frame that would come through
3729 // this method. But since we are closing we can skip it.
3730 if (closing_)
Kinuko Yasudabef2b642019-01-24 04:53:333731 return;
danakj125a29e2019-01-24 23:25:293732
Stephen Chenneyf661f062019-08-02 20:12:423733 // The input handler wants to know about navigation so that it can
Stephen Chenneybccdd0302019-08-15 12:21:283734 // suppress input until the newly navigated page has a committed frame.
3735 // It also resets the state for UMA reporting of input arrival with respect
3736 // to document lifecycle.
Stephen Chenneyf661f062019-08-02 20:12:423737 DCHECK(widget_input_handler_manager_);
3738 widget_input_handler_manager_->DidNavigate();
3739
danakja6c10012018-07-06 14:25:363740 layer_tree_view_->ClearCachesOnNextCommit();
kenrb5d78b842017-03-06 21:06:013741}
3742
lfg8ff33912016-09-13 20:59:213743blink::WebWidget* RenderWidget::GetWebWidget() const {
lfg8ff33912016-09-13 20:59:213744 return webwidget_internal_;
3745}
3746
ekaramad2daaf672016-11-10 20:29:013747blink::WebInputMethodController* RenderWidget::GetInputMethodController()
3748 const {
Ehsan Karamad655d7b8a2018-01-12 18:38:383749 if (auto* frame_widget = GetFrameWidget())
3750 return frame_widget->GetActiveWebInputMethodController();
3751
3752 return nullptr;
ekaramad2daaf672016-11-10 20:29:013753}
3754
Dave Tapuska139a72f2017-09-06 21:57:033755void RenderWidget::SetupWidgetInputHandler(
Dave Tapuskae782bea2019-07-09 16:21:513756 mojo::PendingReceiver<mojom::WidgetInputHandler> receiver,
3757 mojo::PendingRemote<mojom::WidgetInputHandlerHost> host) {
3758 widget_input_handler_manager_->AddInterface(std::move(receiver),
Dave Tapuskab66c28f2017-11-15 17:18:473759 std::move(host));
Dave Tapuska525eb15e2017-08-17 21:05:503760}
3761
Dave Tapuska485aca92017-08-08 00:47:583762void RenderWidget::SetWidgetBinding(mojom::WidgetRequest request) {
3763 // Close the old binding if there was one.
3764 // A RenderWidgetHost should not need more than one channel.
3765 widget_binding_.Close();
3766 widget_binding_.Bind(std::move(request));
3767}
3768
Ken Buchanan94c0beb62018-06-22 19:56:243769void RenderWidget::SetMouseCapture(bool capture) {
3770 if (mojom::WidgetInputHandlerHost* host =
3771 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
3772 host->SetMouseCapture(capture);
3773 }
3774}
3775
danakj53802692018-07-25 21:46:443776void RenderWidget::UseSynchronousResizeModeForTesting(bool enable) {
danakj7602f4f2019-01-31 18:03:233777 synchronous_resize_mode_for_testing_ = enable;
danakja2c9d0a92018-07-25 20:01:183778}
3779
3780void RenderWidget::SetDeviceScaleFactorForTesting(float factor) {
danakjb4cec102019-01-30 19:22:133781 DCHECK_GT(factor, 0.f);
danakja2c9d0a92018-07-25 20:01:183782
danakja2c9d0a92018-07-25 20:01:183783 // We are changing the device scale factor from the renderer, so allocate a
3784 // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
danakj125a29e2019-01-24 23:25:293785 layer_tree_view_->RequestNewLocalSurfaceId();
danakjb4cec102019-01-30 19:22:133786
3787 ScreenInfo info = screen_info_;
3788 info.device_scale_factor = factor;
3789 gfx::Size viewport_pixel_size = gfx::ScaleToCeiledSize(size_, factor);
3790 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
W. James MacLean7df854c2019-08-28 16:17:533791 gfx::Rect(viewport_pixel_size), info);
danakjb4cec102019-01-30 19:22:133792
3793 ResizeWebWidget(); // This picks up the new device scale factor in |info|.
3794
3795 gfx::Size visible_viewport_size = visible_viewport_size_;
3796 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
3797 visible_viewport_size =
3798 gfx::ScaleToCeiledSize(visible_viewport_size, factor);
3799 }
W. James MacLean7c8581072019-06-18 18:07:533800
3801 DCHECK(delegate()) << "Resizing the viewport for a cross-process subframe "
3802 "must be done via the RenderView.";
3803 delegate()->ResizeVisualViewportForWidget(visible_viewport_size);
danakjb4cec102019-01-30 19:22:133804
3805 // Make sure the DSF override stays for future VisualProperties updates, and
3806 // that includes overriding the VisualProperties'
3807 // compositor_viewport_pixel_size with size * this for-testing DSF.
3808 device_scale_factor_for_testing_ = factor;
danakja2c9d0a92018-07-25 20:01:183809}
3810
3811void RenderWidget::SetDeviceColorSpaceForTesting(
3812 const gfx::ColorSpace& color_space) {
danakjb4cec102019-01-30 19:22:133813 // We are changing the device color space from the renderer, so allocate a
3814 // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
3815 layer_tree_view_->RequestNewLocalSurfaceId();
3816
danakj04d128a2019-01-25 02:10:203817 ScreenInfo info = screen_info_;
3818 info.color_space = color_space;
3819 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
W. James MacLean7df854c2019-08-28 16:17:533820 CompositorViewportRect(), info);
danakja2c9d0a92018-07-25 20:01:183821}
3822
3823void RenderWidget::SetWindowRectSynchronouslyForTesting(
3824 const gfx::Rect& new_window_rect) {
3825 SetWindowRectSynchronously(new_window_rect);
3826}
3827
3828void RenderWidget::EnableAutoResizeForTesting(const gfx::Size& min_size,
3829 const gfx::Size& max_size) {
3830 VisualProperties visual_properties;
3831 visual_properties.auto_resize_enabled = true;
3832 visual_properties.min_size_for_auto_resize = min_size;
3833 visual_properties.max_size_for_auto_resize = max_size;
Fady Samuel84d8a1f72018-11-08 00:26:173834 visual_properties.local_surface_id_allocation =
3835 base::Optional<viz::LocalSurfaceIdAllocation>(
3836 viz::LocalSurfaceIdAllocation(
3837 viz::LocalSurfaceId(1, 1, base::UnguessableToken::Create()),
3838 base::TimeTicks::Now()));
danakja2c9d0a92018-07-25 20:01:183839 OnSynchronizeVisualProperties(visual_properties);
3840}
3841
3842void RenderWidget::DisableAutoResizeForTesting(const gfx::Size& new_size) {
3843 if (!auto_resize_mode_)
3844 return;
3845
3846 VisualProperties visual_properties;
3847 visual_properties.auto_resize_enabled = false;
3848 visual_properties.screen_info = screen_info_;
3849 visual_properties.new_size = new_size;
W. James MacLean7df854c2019-08-28 16:17:533850 visual_properties.compositor_viewport_pixel_size =
3851 CompositorViewportRect().size();
danakja2c9d0a92018-07-25 20:01:183852 visual_properties.browser_controls_shrink_blink_size =
3853 browser_controls_shrink_blink_size_;
3854 visual_properties.top_controls_height = top_controls_height_;
3855 visual_properties.visible_viewport_size = visible_viewport_size_;
3856 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
3857 visual_properties.display_mode = display_mode_;
3858 OnSynchronizeVisualProperties(visual_properties);
3859}
3860
EhsanK955ba582017-11-30 21:14:403861blink::WebLocalFrame* RenderWidget::GetFocusedWebLocalFrameInWidget() const {
Ehsan Karamad655d7b8a2018-01-12 18:38:383862 if (auto* frame_widget = GetFrameWidget())
3863 return frame_widget->FocusedWebLocalFrameInWidget();
3864 return nullptr;
EhsanK955ba582017-11-30 21:14:403865}
3866
EhsanK22d482e2017-08-10 17:29:493867#if BUILDFLAG(ENABLE_PLUGINS)
3868PepperPluginInstanceImpl* RenderWidget::GetFocusedPepperPluginInsideWidget() {
Ehsan Karamad655d7b8a2018-01-12 18:38:383869 blink::WebFrameWidget* frame_widget = GetFrameWidget();
3870 if (!frame_widget)
EhsanK22d482e2017-08-10 17:29:493871 return nullptr;
3872
3873 // Focused pepper instance might not always be in the focused frame. For
3874 // instance if a pepper instance and its embedder frame are focused an then
3875 // another frame takes focus using javascript, the embedder frame will no
3876 // longer be focused while the pepper instance is (the embedder frame's
3877 // |focused_pepper_plugin_| is not nullptr). Especially, if the pepper plugin
3878 // is fullscreen, clicking into the pepper will not refocus the embedder
3879 // frame. This is why we have to traverse the whole frame tree to find the
3880 // focused plugin.
Ehsan Karamad655d7b8a2018-01-12 18:38:383881 blink::WebFrame* current_frame = frame_widget->LocalRoot();
EhsanK22d482e2017-08-10 17:29:493882 while (current_frame) {
3883 RenderFrameImpl* render_frame =
3884 current_frame->IsWebLocalFrame()
3885 ? RenderFrameImpl::FromWebFrame(current_frame)
3886 : nullptr;
3887 if (render_frame && render_frame->focused_pepper_plugin())
3888 return render_frame->focused_pepper_plugin();
3889 current_frame = current_frame->TraverseNext();
3890 }
3891 return nullptr;
3892}
3893#endif
3894
Ken Buchananb2c9e262018-03-10 16:53:313895gfx::Rect RenderWidget::ViewportVisibleRect() {
danakj9c4e7b812019-02-19 22:04:273896 if (for_child_local_root_frame_)
3897 return compositor_visible_rect_;
W. James MacLean7df854c2019-08-28 16:17:533898 return CompositorViewportRect();
Ken Buchananb2c9e262018-03-10 16:53:313899}
3900
Hajime Hoshi315a61f2018-08-14 17:27:283901// static
3902scoped_refptr<base::SingleThreadTaskRunner>
3903RenderWidget::GetCleanupTaskRunner() {
3904 return RenderThreadImpl::current_blink_platform_impl()
3905 ->main_thread_scheduler()
3906 ->CleanupTaskRunner();
3907}
3908
Saman Sami50d1e0c2018-03-13 20:03:493909base::WeakPtr<RenderWidget> RenderWidget::AsWeakPtr() {
3910 return weak_ptr_factory_.GetWeakPtr();
3911}
3912
Erik Chen7ee377b2019-08-22 23:38:343913void RenderWidget::SetWebWidgetInternal(blink::WebWidget* web_widget) {
Erik Chena2819852019-08-28 01:02:283914 // TODO(https://crbug.com/995981): This method should not need to exist, since
3915 // we should be creating and destroying a RenderWidget along with the
3916 // WebWidget.
3917 if (web_widget)
3918 web_widget->SetAnimationHost(layer_tree_view_->animation_host());
Erik Chen7ee377b2019-08-22 23:38:343919 webwidget_internal_ = web_widget;
3920}
3921
[email protected]e9ff79c2012-10-19 21:31:263922} // namespace content