blob: 3013a52a505183c804f39fa867ce5d1527da8397 [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>
dchengcedca5612016-04-09 01:40:159#include <memory>
dcheng07945f632015-12-26 07:59:3210#include <utility>
11
[email protected]c27dd4f2014-05-22 18:05:1912#include "base/auto_reset.h"
danakj4b347212018-07-04 17:55:1713#include "base/base_switches.h"
[email protected]32876ae2011-11-15 22:25:2114#include "base/bind.h"
Sebastien Marchand17fa2782019-01-25 19:28:1015#include "base/bind_helpers.h"
[email protected]4fb66842009-12-04 21:41:0016#include "base/command_line.h"
changwan7ded3752016-03-09 23:25:1217#include "base/feature_list.h"
initial.commit09911bf2008-07-26 23:55:2918#include "base/logging.h"
avi1023d012015-12-25 02:39:1419#include "base/macros.h"
dchengcedca5612016-04-09 01:40:1520#include "base/memory/ptr_util.h"
[email protected]b256eca2013-07-11 10:57:4021#include "base/memory/singleton.h"
asvitkine8d51e9d2016-09-02 23:55:4322#include "base/metrics/histogram_macros.h"
[email protected]aa4117f2011-12-09 22:19:2123#include "base/stl_util.h"
danakj4b347212018-07-04 17:55:1724#include "base/strings/string_number_conversions.h"
[email protected]74ebfb12013-06-07 20:48:0025#include "base/strings/utf_string_conversions.h"
Sebastien Marchand75a7cdf2018-11-13 23:47:0326#include "base/system/sys_info.h"
fdoraya19b7702016-12-23 14:19:3127#include "base/threading/thread_task_runner_handle.h"
primiano9e38d552015-01-28 04:18:0128#include "base/trace_event/trace_event.h"
[email protected]661eb9d2009-02-03 02:11:4829#include "build/build_config.h"
loyso6e6efc42017-01-21 02:23:0330#include "cc/animation/animation_host.h"
danakj4b347212018-07-04 17:55:1731#include "cc/base/switches.h"
xidachenfa0199e72017-05-11 11:34:2632#include "cc/input/touch_action.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"
Sadrul Habib Chowdhury8bc43cc2018-06-06 01:48:0346#include "content/common/tab_switching_time_callback.h"
ekaramad9053e57b2016-04-26 20:00:3847#include "content/common/text_input_state.h"
Albert J. Wong3c93c182018-09-27 17:29:4348#include "content/common/widget_messages.h"
mlamouriafca06dd2017-01-27 23:35:1849#include "content/public/common/content_client.h"
changwan7ded3752016-03-09 23:25:1250#include "content/public/common/content_features.h"
[email protected]c08950d22011-10-13 22:20:2951#include "content/public/common/content_switches.h"
[email protected]a09d53ce2014-01-31 00:46:4252#include "content/public/common/context_menu_params.h"
paulmeyer90f6c31d2016-11-12 00:17:5953#include "content/public/common/drop_data.h"
Khushal3e96e662017-10-30 23:16:5054#include "content/public/common/service_names.mojom.h"
Jaebaek Seo655110e2017-12-19 23:27:3955#include "content/public/common/use_zoom_for_dsf_policy.h"
mlamouriafca06dd2017-01-27 23:35:1856#include "content/public/renderer/content_renderer_client.h"
Saman Samid189e5dfd2017-12-20 22:55:3157#include "content/renderer/browser_plugin/browser_plugin.h"
Sadrul Habib Chowdhury31c98712018-12-11 04:15:1358#include "content/renderer/compositor/layer_tree_view.h"
[email protected]953bd0062013-08-01 00:58:4059#include "content/renderer/cursor_utils.h"
mfomitchev2600fd7c2016-02-17 20:53:3960#include "content/renderer/devtools/render_widget_screen_metrics_emulator.h"
paulmeyer6ef5a792016-11-08 20:33:5861#include "content/renderer/drop_data_builder.h"
[email protected]b2e4c70132013-10-03 02:07:5162#include "content/renderer/external_popup_menu.h"
Sadrul Habib Chowdhury31c98712018-12-11 04:15:1363#include "content/renderer/frame_swap_message_queue.h"
[email protected]66fca5bc2013-05-23 06:58:2964#include "content/renderer/ime_event_guard.h"
dtapuska9ec1a912017-04-21 15:18:3165#include "content/renderer/input/main_thread_event_queue.h"
Dave Tapuska9db80842017-07-24 17:24:2666#include "content/renderer/input/widget_input_handler_manager.h"
[email protected]adab2332013-07-25 18:04:3267#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
Sadrul Habib Chowdhury31c98712018-12-11 04:15:1368#include "content/renderer/queue_message_swap_promise.h"
[email protected]bffc8302014-01-23 20:52:1669#include "content/renderer/render_frame_impl.h"
danakj4b347212018-07-04 17:55:1770#include "content/renderer/render_frame_metadata_observer_impl.h"
[email protected]e3244ed2014-06-20 20:04:2771#include "content/renderer/render_frame_proxy.h"
[email protected]8704f89b2011-04-15 00:30:0572#include "content/renderer/render_process.h"
[email protected]f1a29a02011-10-06 23:08:4473#include "content/renderer/render_thread_impl.h"
dcheng3ce04b62015-10-26 23:30:5574#include "content/renderer/render_view_impl.h"
tfarina556a7232014-10-05 01:02:0975#include "content/renderer/renderer_blink_platform_impl.h"
[email protected]5b45ad42013-10-25 00:42:0476#include "content/renderer/resizing_mode_selector.h"
danakj4b347212018-07-04 17:55:1777#include "gpu/command_buffer/service/gpu_switches.h"
ekaramad330ba4232016-09-23 17:57:4778#include "ipc/ipc_message_start.h"
[email protected]484955942010-08-19 16:13:1879#include "ipc/ipc_sync_message.h"
Antoine Laboure55c9ef82017-11-10 18:51:2380#include "ipc/ipc_sync_message_filter.h"
danakj4b347212018-07-04 17:55:1781#include "media/base/media_switches.h"
Scott Violet02e38b92018-03-27 23:42:1482#include "ppapi/buildflags/buildflags.h"
[email protected]661eb9d2009-02-03 02:11:4883#include "skia/ext/platform_canvas.h"
Blink Reformata30d4232018-04-07 15:31:0684#include "third_party/blink/public/platform/file_path_conversion.h"
Hajime Hoshi315a61f2018-08-14 17:27:2885#include "third_party/blink/public/platform/platform.h"
Blink Reformata30d4232018-04-07 15:31:0686#include "third_party/blink/public/platform/scheduler/web_render_widget_scheduling_state.h"
Yuta Kitamuradeb91bb2018-05-29 05:53:2087#include "third_party/blink/public/platform/scheduler/web_thread_scheduler.h"
Blink Reformata30d4232018-04-07 15:31:0688#include "third_party/blink/public/platform/web_cursor_info.h"
89#include "third_party/blink/public/platform/web_drag_data.h"
90#include "third_party/blink/public/platform/web_drag_operation.h"
91#include "third_party/blink/public/platform/web_mouse_event.h"
92#include "third_party/blink/public/platform/web_point.h"
93#include "third_party/blink/public/platform/web_rect.h"
94#include "third_party/blink/public/platform/web_runtime_features.h"
95#include "third_party/blink/public/platform/web_size.h"
96#include "third_party/blink/public/platform/web_string.h"
97#include "third_party/blink/public/web/web_autofill_client.h"
98#include "third_party/blink/public/web/web_device_emulation_params.h"
99#include "third_party/blink/public/web/web_frame_widget.h"
100#include "third_party/blink/public/web/web_input_method_controller.h"
101#include "third_party/blink/public/web/web_local_frame.h"
102#include "third_party/blink/public/web/web_node.h"
103#include "third_party/blink/public/web/web_page_popup.h"
104#include "third_party/blink/public/web/web_popup_menu_info.h"
105#include "third_party/blink/public/web/web_range.h"
106#include "third_party/blink/public/web/web_settings.h"
107#include "third_party/blink/public/web/web_view.h"
108#include "third_party/blink/public/web/web_widget.h"
[email protected]d353541f2012-05-03 22:45:41109#include "third_party/skia/include/core/SkShader.h"
Maksim Sisova33072d22019-01-24 15:44:25110#include "ui/base/clipboard/clipboard_constants.h"
Scott Violet8ff9c302018-02-22 22:28:35111#include "ui/base/ui_base_features.h"
danakj4b347212018-07-04 17:55:17112#include "ui/base/ui_base_switches.h"
dtapuska97286c882017-02-24 23:14:43113#include "ui/events/base_event_utils.h"
tfarina655f81d2014-12-23 02:38:50114#include "ui/gfx/geometry/point_conversions.h"
tfarina3b0452d2014-12-31 15:20:09115#include "ui/gfx/geometry/rect_conversions.h"
tfarinaebe974f02015-01-03 04:25:32116#include "ui/gfx/geometry/size_conversions.h"
[email protected]1835b9e2012-02-28 13:12:48117#include "ui/gfx/skia_util.h"
danakj4b347212018-07-04 17:55:17118#include "ui/gfx/switches.h"
[email protected]c9e2cbbb2012-05-12 21:17:27119#include "ui/gl/gl_switches.h"
danakj4b347212018-07-04 17:55:17120#include "ui/native_theme/native_theme_features.h"
121#include "ui/native_theme/overlay_scrollbar_constants_aura.h"
[email protected]d353541f2012-05-03 22:45:41122#include "ui/surface/transport_dib.h"
[email protected]661eb9d2009-02-03 02:11:48123
[email protected]eeb93112013-05-01 19:41:10124#if defined(OS_ANDROID)
[email protected]cefe9b152014-03-27 18:16:15125#include <android/keycodes.h>
wjmaclean1d970622017-01-21 22:28:24126#include "base/time/time.h"
[email protected]eeb93112013-05-01 19:41:10127#endif
128
[email protected]661eb9d2009-02-03 02:11:48129#if defined(OS_POSIX)
[email protected]d5282e72009-05-13 13:16:52130#include "third_party/skia/include/core/SkMallocPixelRef.h"
[email protected]d353541f2012-05-03 22:45:41131#include "third_party/skia/include/core/SkPixelRef.h"
[email protected]661eb9d2009-02-03 02:11:48132#endif // defined(OS_POSIX)
[email protected]8085dbc82008-09-26 22:53:44133
sadrul943e3b32016-08-04 18:22:59134#if defined(USE_AURA)
sadrul602ce1362017-01-26 06:41:10135#include "content/renderer/mus/renderer_window_tree_client.h"
penghuang28a5fa22015-12-02 17:58:19136#endif
137
ekaramad330ba4232016-09-23 17:57:47138#if defined(OS_MACOSX)
139#include "content/renderer/text_input_client_observer.h"
140#endif
141
Ryan Landay9e42fd742017-08-12 01:59:11142using blink::WebImeTextSpan;
[email protected]180ef242013-11-07 06:50:46143using blink::WebCursorInfo;
[email protected]19193682014-04-03 15:01:43144using blink::WebDeviceEmulationParams;
paulmeyer90f6c31d2016-11-12 00:17:59145using blink::WebDragOperation;
paulmeyer6ef5a792016-11-08 20:33:58146using blink::WebDragOperationsMask;
147using blink::WebDragData;
paulmeyer90f6c31d2016-11-12 00:17:59148using blink::WebFrameWidget;
[email protected]180ef242013-11-07 06:50:46149using blink::WebGestureEvent;
150using blink::WebInputEvent;
dtapuska5d2e9c32015-12-03 16:39:49151using blink::WebInputEventResult;
ekaramad2daaf672016-11-10 20:29:01152using blink::WebInputMethodController;
paulmeyer6ef5a792016-11-08 20:33:58153using blink::WebLocalFrame;
[email protected]180ef242013-11-07 06:50:46154using blink::WebMouseEvent;
155using blink::WebMouseWheelEvent;
156using blink::WebNavigationPolicy;
donnda070f3c2015-01-16 19:54:11157using blink::WebNode;
[email protected]180ef242013-11-07 06:50:46158using blink::WebPagePopup;
dglazkove353a372016-09-01 01:33:48159using blink::WebRange;
[email protected]180ef242013-11-07 06:50:46160using blink::WebRect;
[email protected]180ef242013-11-07 06:50:46161using blink::WebSize;
paulmeyer90f6c31d2016-11-12 00:17:59162using blink::WebString;
[email protected]180ef242013-11-07 06:50:46163using blink::WebTextDirection;
164using blink::WebTouchEvent;
[email protected]f8ed4722013-12-03 03:27:25165using blink::WebTouchPoint;
[email protected]180ef242013-11-07 06:50:46166using blink::WebVector;
167using blink::WebWidget;
[email protected]e9ff79c2012-10-19 21:31:26168
paulmeyer90f6c31d2016-11-12 00:17:59169namespace content {
170
[email protected]6a4d7f62013-01-07 21:32:13171namespace {
[email protected]b256eca2013-07-11 10:57:40172
Albert J. Wongcb004632018-07-10 22:58:25173using RoutingIDWidgetMap = std::map<int32_t, RenderWidget*>;
174base::LazyInstance<RoutingIDWidgetMap>::Leaky g_routing_id_widget_map =
175 LAZY_INSTANCE_INITIALIZER;
176
danakj4b347212018-07-04 17:55:17177const base::Feature kUnpremultiplyAndDitherLowBitDepthTiles = {
178 "UnpremultiplyAndDitherLowBitDepthTiles", base::FEATURE_ENABLED_BY_DEFAULT};
179
[email protected]b256eca2013-07-11 10:57:40180typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
181
AJITH KUMAR V041c0b02017-08-08 10:39:20182static const int kInvalidNextPreviousFlagsValue = -1;
yiyix6b90ef52018-10-09 19:55:30183static const char* kOOPIF = "OOPIF";
184static const char* kRenderer = "Renderer";
AJITH KUMAR V041c0b02017-08-08 10:39:20185
lfgbee1e0a2016-06-08 21:24:21186class WebWidgetLockTarget : public content::MouseLockDispatcher::LockTarget {
187 public:
188 explicit WebWidgetLockTarget(blink::WebWidget* webwidget)
189 : webwidget_(webwidget) {}
190
191 void OnLockMouseACK(bool succeeded) override {
192 if (succeeded)
Blink Reformat1c4d759e2017-04-09 16:34:54193 webwidget_->DidAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21194 else
Blink Reformat1c4d759e2017-04-09 16:34:54195 webwidget_->DidNotAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21196 }
197
Blink Reformat1c4d759e2017-04-09 16:34:54198 void OnMouseLockLost() override { webwidget_->DidLosePointerLock(); }
lfgbee1e0a2016-06-08 21:24:21199
200 bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event) override {
201 // The WebWidget handles mouse lock in Blink's handleInputEvent().
202 return false;
203 }
204
205 private:
206 blink::WebWidget* webwidget_;
207};
208
Stephen Chenneyd56b5382019-01-29 00:37:02209class ScopedUkmRafAlignedInputTimer {
210 public:
211 explicit ScopedUkmRafAlignedInputTimer(blink::WebWidget* webwidget)
212 : webwidget_(webwidget) {
213 webwidget_->BeginRafAlignedInput();
214 }
215
216 ~ScopedUkmRafAlignedInputTimer() { webwidget_->EndRafAlignedInput(); }
217
218 private:
219 blink::WebWidget* webwidget_;
220
221 DISALLOW_COPY_AND_ASSIGN(ScopedUkmRafAlignedInputTimer);
222};
223
dglazkov97b6c2b2016-10-25 17:35:55224bool IsDateTimeInput(ui::TextInputType type) {
225 return type == ui::TEXT_INPUT_TYPE_DATE ||
226 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
227 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
228 type == ui::TEXT_INPUT_TYPE_MONTH ||
229 type == ui::TEXT_INPUT_TYPE_TIME || type == ui::TEXT_INPUT_TYPE_WEEK;
230}
231
paulmeyer90f6c31d2016-11-12 00:17:59232WebDragData DropMetaDataToWebDragData(
233 const std::vector<DropData::Metadata>& drop_meta_data) {
234 std::vector<WebDragData::Item> item_list;
235 for (const auto& meta_data_item : drop_meta_data) {
236 if (meta_data_item.kind == DropData::Kind::STRING) {
237 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54238 item.storage_type = WebDragData::Item::kStorageTypeString;
239 item.string_type = WebString::FromUTF16(meta_data_item.mime_type);
paulmeyer90f6c31d2016-11-12 00:17:59240 // Have to pass a dummy URL here instead of an empty URL because the
241 // DropData received by browser_plugins goes through a round trip:
242 // DropData::MetaData --> WebDragData-->DropData. In the end, DropData
243 // will contain an empty URL (which means no URL is dragged) if the URL in
244 // WebDragData is empty.
Maksim Sisova33072d22019-01-24 15:44:25245 if (base::EqualsASCII(meta_data_item.mime_type, ui::kMimeTypeURIList)) {
Blink Reformat1c4d759e2017-04-09 16:34:54246 item.string_data = WebString::FromUTF8("about:dragdrop-placeholder");
paulmeyer90f6c31d2016-11-12 00:17:59247 }
248 item_list.push_back(item);
249 continue;
250 }
251
252 // TODO(hush): crbug.com/584789. Blink needs to support creating a file with
253 // just the mimetype. This is needed to drag files to WebView on Android
254 // platform.
255 if ((meta_data_item.kind == DropData::Kind::FILENAME) &&
256 !meta_data_item.filename.empty()) {
257 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54258 item.storage_type = WebDragData::Item::kStorageTypeFilename;
259 item.filename_data = blink::FilePathToWebString(meta_data_item.filename);
paulmeyer90f6c31d2016-11-12 00:17:59260 item_list.push_back(item);
261 continue;
262 }
263
264 if (meta_data_item.kind == DropData::Kind::FILESYSTEMFILE) {
265 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54266 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
267 item.file_system_url = meta_data_item.file_system_url;
paulmeyer90f6c31d2016-11-12 00:17:59268 item_list.push_back(item);
269 continue;
270 }
271 }
272
273 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54274 result.Initialize();
275 result.SetItems(item_list);
paulmeyer90f6c31d2016-11-12 00:17:59276 return result;
277}
278
279WebDragData DropDataToWebDragData(const DropData& drop_data) {
280 std::vector<WebDragData::Item> item_list;
281
282 // These fields are currently unused when dragging into WebKit.
283 DCHECK(drop_data.download_metadata.empty());
284 DCHECK(drop_data.file_contents.empty());
dcheng3dd85612017-02-08 10:46:23285 DCHECK(drop_data.file_contents_content_disposition.empty());
paulmeyer90f6c31d2016-11-12 00:17:59286
287 if (!drop_data.text.is_null()) {
288 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54289 item.storage_type = WebDragData::Item::kStorageTypeString;
Maksim Sisova33072d22019-01-24 15:44:25290 item.string_type = WebString::FromUTF8(ui::kMimeTypeText);
Blink Reformat1c4d759e2017-04-09 16:34:54291 item.string_data = WebString::FromUTF16(drop_data.text.string());
paulmeyer90f6c31d2016-11-12 00:17:59292 item_list.push_back(item);
293 }
294
295 if (!drop_data.url.is_empty()) {
296 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54297 item.storage_type = WebDragData::Item::kStorageTypeString;
Maksim Sisova33072d22019-01-24 15:44:25298 item.string_type = WebString::FromUTF8(ui::kMimeTypeURIList);
Blink Reformat1c4d759e2017-04-09 16:34:54299 item.string_data = WebString::FromUTF8(drop_data.url.spec());
300 item.title = WebString::FromUTF16(drop_data.url_title);
paulmeyer90f6c31d2016-11-12 00:17:59301 item_list.push_back(item);
302 }
303
304 if (!drop_data.html.is_null()) {
305 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54306 item.storage_type = WebDragData::Item::kStorageTypeString;
Maksim Sisova33072d22019-01-24 15:44:25307 item.string_type = WebString::FromUTF8(ui::kMimeTypeHTML);
Blink Reformat1c4d759e2017-04-09 16:34:54308 item.string_data = WebString::FromUTF16(drop_data.html.string());
309 item.base_url = drop_data.html_base_url;
paulmeyer90f6c31d2016-11-12 00:17:59310 item_list.push_back(item);
311 }
312
jdoerrie5a73d0fa2018-10-02 23:54:05313 for (auto it = drop_data.filenames.begin(); it != drop_data.filenames.end();
paulmeyer90f6c31d2016-11-12 00:17:59314 ++it) {
315 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54316 item.storage_type = WebDragData::Item::kStorageTypeFilename;
317 item.filename_data = blink::FilePathToWebString(it->path);
318 item.display_name_data =
kinukoa4293022017-01-27 06:43:25319 blink::FilePathToWebString(base::FilePath(it->display_name));
paulmeyer90f6c31d2016-11-12 00:17:59320 item_list.push_back(item);
321 }
322
jdoerrie5a73d0fa2018-10-02 23:54:05323 for (auto it = drop_data.file_system_files.begin();
324 it != drop_data.file_system_files.end(); ++it) {
paulmeyer90f6c31d2016-11-12 00:17:59325 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54326 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
327 item.file_system_url = it->url;
328 item.file_system_file_size = it->size;
329 item.file_system_id = blink::WebString::FromASCII(it->filesystem_id);
paulmeyer90f6c31d2016-11-12 00:17:59330 item_list.push_back(item);
331 }
332
Stuart Langley48300392017-11-02 03:54:44333 for (const auto& it : drop_data.custom_data) {
paulmeyer90f6c31d2016-11-12 00:17:59334 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54335 item.storage_type = WebDragData::Item::kStorageTypeString;
Stuart Langley48300392017-11-02 03:54:44336 item.string_type = WebString::FromUTF16(it.first);
337 item.string_data = WebString::FromUTF16(it.second);
paulmeyer90f6c31d2016-11-12 00:17:59338 item_list.push_back(item);
339 }
340
341 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54342 result.Initialize();
343 result.SetItems(item_list);
344 result.SetFilesystemId(WebString::FromUTF16(drop_data.filesystem_id));
paulmeyer90f6c31d2016-11-12 00:17:59345 return result;
346}
347
dtapuskac4dd5be2016-10-25 15:11:10348ui::TextInputType ConvertWebTextInputType(blink::WebTextInputType type) {
349 // Check the type is in the range representable by ui::TextInputType.
350 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX))
351 << "blink::WebTextInputType and ui::TextInputType not synchronized";
352 return static_cast<ui::TextInputType>(type);
353}
354
355ui::TextInputMode ConvertWebTextInputMode(blink::WebTextInputMode mode) {
356 // Check the mode is in the range representable by ui::TextInputMode.
357 DCHECK_LE(mode, static_cast<int>(ui::TEXT_INPUT_MODE_MAX))
358 << "blink::WebTextInputMode and ui::TextInputMode not synchronized";
359 return static_cast<ui::TextInputMode>(mode);
360}
361
Mitsuru Oshima3c07b332018-02-06 04:56:50362// Returns true if the device scale is high enough that losing subpixel
363// antialiasing won't have a noticeable effect on text quality.
364static bool DeviceScaleEnsuresTextQuality(float device_scale_factor) {
365#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
366 // On Android, we never have subpixel antialiasing. On Chrome OS we prefer to
367 // composite all scrollers so that we get animated overlay scrollbars.
368 return true;
369#else
370 // 1.5 is a common touchscreen tablet device scale factor. For such
371 // devices main thread antialiasing is a heavy burden.
372 return device_scale_factor >= 1.5f;
373#endif
374}
375
376static bool PreferCompositingToLCDText(CompositorDependencies* compositor_deps,
377 float device_scale_factor) {
378 const base::CommandLine& command_line =
379 *base::CommandLine::ForCurrentProcess();
380 if (command_line.HasSwitch(switches::kDisablePreferCompositingToLCDText))
381 return false;
382 if (command_line.HasSwitch(switches::kEnablePreferCompositingToLCDText))
383 return true;
384 if (!compositor_deps->IsLcdTextEnabled())
385 return true;
386 return DeviceScaleEnsuresTextQuality(device_scale_factor);
387}
388
[email protected]b256eca2013-07-11 10:57:40389} // namespace
390
[email protected]b2e4c70132013-10-03 02:07:51391// RenderWidget ---------------------------------------------------------------
392
danakj829cdd142018-09-14 21:13:27393RenderWidget::RenderWidget(int32_t widget_routing_id,
394 CompositorDependencies* compositor_deps,
danakj829cdd142018-09-14 21:13:27395 const ScreenInfo& screen_info,
396 blink::WebDisplayMode display_mode,
danakj6dcbc5962018-11-16 16:45:42397 bool is_frozen,
danakj829cdd142018-09-14 21:13:27398 bool hidden,
399 bool never_visible,
400 mojom::WidgetRequest widget_request)
nick8331f8ad2016-11-15 20:42:45401 : routing_id_(widget_routing_id),
dcheng35d31c112015-07-22 00:17:36402 compositor_deps_(compositor_deps),
lfg8ff33912016-09-13 20:59:21403 webwidget_internal_(nullptr),
[email protected]847a2582013-03-09 02:29:51404 auto_resize_mode_(false),
[email protected]1ac10dca2013-08-20 20:47:04405 is_hidden_(hidden),
sievers71c62dd52015-10-07 01:44:39406 compositor_never_visible_(never_visible),
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12407 is_fullscreen_granted_(false),
danakj73dd3032018-07-28 17:49:53408 display_mode_(display_mode),
changwanf2a707b2015-10-30 08:22:16409 ime_event_guard_(nullptr),
[email protected]661eb9d2009-02-03 02:11:48410 closing_(false),
danakj5c5269b2018-11-06 00:39:11411 host_will_close_this_(false),
danakj6dcbc5962018-11-16 16:45:42412 is_frozen_(is_frozen),
dglazkov97b6c2b2016-10-25 17:35:55413 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
[email protected]b256eca2013-07-11 10:57:40414 text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
shuchen82ce8c52014-10-23 01:55:20415 text_input_flags_(0),
AJITH KUMAR V041c0b02017-08-08 10:39:20416 next_previous_flags_(kInvalidNextPreviousFlagsValue),
[email protected]86ba5fcb2013-09-04 00:36:53417 can_compose_inline_(true),
nonafa291792016-08-10 02:36:18418 composition_range_(gfx::Range::InvalidRange()),
[email protected]867125a02009-12-10 06:01:48419 pending_window_rect_count_(0),
Scott Violetae08f332018-07-27 17:37:23420 screen_info_(screen_info),
nonafa291792016-08-10 02:36:18421 monitor_composition_info_(false),
[email protected]b2e4c70132013-10-03 02:07:51422 popup_origin_scale_for_emulation_(0.f),
samans26510e442017-06-01 22:29:12423 frame_swap_message_queue_(new FrameSwapMessageQueue(routing_id_)),
[email protected]a09d53ce2014-01-31 00:46:42424 resizing_mode_selector_(new ResizingModeSelector()),
lfge0c2792ec2016-05-11 18:52:08425 has_host_context_menu_location_(false),
ekaramad2a46d632016-07-19 13:33:09426 has_focus_(false),
danakj6dcbc5962018-11-16 16:45:42427 for_child_local_root_frame_(false),
ekaramad330ba4232016-09-23 17:57:47428#if defined(OS_MACOSX)
429 text_input_client_observer_(new TextInputClientObserver(this)),
430#endif
Takashi SAKAMOTO870f6262017-08-22 04:08:27431 first_update_visual_state_after_hidden_(false),
tasakb95dbb50c2017-02-08 18:07:50432 was_shown_time_(base::TimeTicks::Now()),
kenrb5d78b842017-03-06 21:06:01433 current_content_source_id_(0),
Dave Tapuska1bdf1832017-07-07 18:07:19434 widget_binding_(this, std::move(widget_request)),
danakjf87460792018-12-04 20:14:22435 warmup_weak_ptr_factory_(this),
wjmaclean1d970622017-01-21 22:28:24436 weak_ptr_factory_(this) {
nick8331f8ad2016-11-15 20:42:45437 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
[email protected]380244092011-10-07 17:26:27438 DCHECK(RenderThread::Get());
alexclarke7fa93942015-10-21 15:37:11439
440 // In tests there may not be a RenderThreadImpl.
441 if (RenderThreadImpl::current()) {
442 render_widget_scheduling_state_ = RenderThreadImpl::current()
Yuta Kitamura3331f5c2018-04-05 11:12:25443 ->GetWebMainThreadScheduler()
dcheng07945f632015-12-26 07:59:32444 ->NewRenderWidgetSchedulingState();
alexclarke7fa93942015-10-21 15:37:11445 render_widget_scheduling_state_->SetHidden(is_hidden_);
446 }
sadrul602ce1362017-01-26 06:41:10447#if defined(USE_AURA)
fsamuel098eade2017-03-21 18:06:14448 RendererWindowTreeClient::CreateIfNecessary(routing_id_);
Scott Violete46b3352018-09-22 00:37:07449 if (features::IsMultiProcessMash())
Scott Violet1098538e2017-10-05 19:23:33450 RendererWindowTreeClient::Get(routing_id_)->SetVisible(!is_hidden_);
sadrul602ce1362017-01-26 06:41:10451#endif
Albert J. Wongcb004632018-07-10 22:58:25452
453 if (routing_id_ != MSG_ROUTING_NONE)
454 g_routing_id_widget_map.Get().emplace(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29455}
456
457RenderWidget::~RenderWidget() {
lfg8ff33912016-09-13 20:59:21458 DCHECK(!webwidget_internal_) << "Leaking our WebWidget!";
Albert J. Wong7bbf22d2018-12-20 00:27:27459
Albert J. Wongcb004632018-07-10 22:58:25460 // TODO(ajwong): Add in check that routing_id_ has been removed from
461 // g_routing_id_widget_map once the shutdown semantics for RenderWidget
462 // and RenderViewImpl are rationalized. Currently, too many unit and
463 // browser tests delete a RenderWidget without correclty going through
464 // the shutdown. https://crbug.com/545684
[email protected]bffc8302014-01-23 20:52:16465
sadrul8185d972017-01-31 18:30:11466#if defined(USE_AURA)
fsamuel098eade2017-03-21 18:06:14467 // It is possible for a RenderWidget to be destroyed before it was embedded
468 // in a mus window. The RendererWindowTreeClient will leak in such cases. So
469 // explicitly delete it here.
470 RendererWindowTreeClient::Destroy(routing_id_);
sadrul8185d972017-01-31 18:30:11471#endif
initial.commit09911bf2008-07-26 23:55:29472}
473
[email protected]484955942010-08-19 16:13:18474// static
Albert J. Wongcb004632018-07-10 22:58:25475RenderWidget* RenderWidget::FromRoutingID(int32_t routing_id) {
476 RoutingIDWidgetMap* widgets = g_routing_id_widget_map.Pointer();
jdoerrie5a73d0fa2018-10-02 23:54:05477 auto it = widgets->find(routing_id);
Albert J. Wongcb004632018-07-10 22:58:25478 return it == widgets->end() ? NULL : it->second;
479}
480
danakj25ec6e2b2018-09-26 17:01:31481void RenderWidget::InitForPopup(ShowCallback show_callback,
482 blink::WebPagePopup* web_page_popup) {
483 // Init() increments the reference count on |this|, making it
484 // self-referencing.
485 Init(std::move(show_callback), web_page_popup);
initial.commit09911bf2008-07-26 23:55:29486}
487
danakj6a816592018-09-25 18:30:56488void RenderWidget::InitForChildLocalRoot(
489 blink::WebFrameWidget* web_frame_widget) {
danakj6dcbc5962018-11-16 16:45:42490 for_child_local_root_frame_ = true;
danakj6a816592018-09-25 18:30:56491 // Init() increments the reference count on |this|, making it
492 // self-referencing.
493 Init(base::NullCallback(), web_frame_widget);
dchengda9b4bb2015-07-20 20:58:08494}
495
dchengda9b4bb2015-07-20 20:58:08496void RenderWidget::CloseForFrame() {
dchengd96a27a2015-07-24 20:17:32497 OnClose();
kenrba7199832015-01-22 23:44:59498}
499
Scott Violetae08f332018-07-27 17:37:23500void RenderWidget::Init(ShowCallback show_callback, WebWidget* web_widget) {
lfg8ff33912016-09-13 20:59:21501 DCHECK(!webwidget_internal_);
nick4df698d82016-11-11 20:39:23502 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29503
danakj17216f4d2018-10-16 22:57:32504 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
505
Jeremy Roman04f27c372017-10-27 15:20:55506 input_handler_ = std::make_unique<RenderWidgetInputHandler>(this, this);
nick8331f8ad2016-11-15 20:42:45507
danakj17216f4d2018-10-16 22:57:32508 LayerTreeView* layer_tree_view = InitializeLayerTreeView();
509 web_widget->SetLayerTreeView(layer_tree_view);
Dave Tapuska9db80842017-07-24 17:24:26510
danakj31699d5b2018-09-18 15:39:17511 blink::scheduler::WebThreadScheduler* main_thread_scheduler = nullptr;
512 if (render_thread_impl)
513 main_thread_scheduler = render_thread_impl->GetWebMainThreadScheduler();
Alexander Timin41e917d2018-07-02 16:25:35514 blink::scheduler::WebThreadScheduler* compositor_thread_scheduler =
515 blink::scheduler::WebThreadScheduler::CompositorThreadScheduler();
danakj31699d5b2018-09-18 15:39:17516 scoped_refptr<base::SingleThreadTaskRunner> compositor_input_task_runner;
danakj89ae4532018-12-12 22:52:55517 // Use the compositor thread task runner unless this is a popup or other such
518 // non-frame widgets. The |compositor_thread_scheduler| can be null in tests
519 // without a compositor thread.
520 if (for_frame() && compositor_thread_scheduler) {
521 compositor_input_task_runner =
522 compositor_thread_scheduler->InputTaskRunner();
danakj31699d5b2018-09-18 15:39:17523 }
Alexander Timin41e917d2018-07-02 16:25:35524
Dave Tapuska04bc5ee92018-04-17 19:03:31525 widget_input_handler_manager_ = WidgetInputHandlerManager::Create(
danakj31699d5b2018-09-18 15:39:17526 weak_ptr_factory_.GetWeakPtr(), std::move(compositor_input_task_runner),
527 main_thread_scheduler);
Dave Tapuska9db80842017-07-24 17:24:26528
danakjdf1ceb72018-07-18 20:02:25529 show_callback_ = std::move(show_callback);
initial.commit09911bf2008-07-26 23:55:29530
lfg8ff33912016-09-13 20:59:21531 webwidget_internal_ = web_widget;
532 webwidget_mouse_lock_target_.reset(
533 new WebWidgetLockTarget(webwidget_internal_));
lfgbee1e0a2016-06-08 21:24:21534 mouse_lock_dispatcher_.reset(new RenderWidgetMouseLockDispatcher(this));
initial.commit09911bf2008-07-26 23:55:29535
nick4df698d82016-11-11 20:39:23536 RenderThread::Get()->AddRoute(routing_id_, this);
537 // Take a reference on behalf of the RenderThread. This will be balanced
Albert J. Wong3c93c182018-09-27 17:29:43538 // when we receive WidgetMsg_Close.
nick4df698d82016-11-11 20:39:23539 AddRef();
540 if (RenderThreadImpl::current()) {
541 RenderThreadImpl::current()->WidgetCreated();
542 if (is_hidden_)
543 RenderThreadImpl::current()->WidgetHidden();
initial.commit09911bf2008-07-26 23:55:29544 }
545}
546
danakj53802692018-07-25 21:46:44547void RenderWidget::ApplyEmulatedScreenMetricsForPopupWidget(
548 RenderWidget* origin_widget) {
549 RenderWidgetScreenMetricsEmulator* emulator =
550 origin_widget->screen_metrics_emulator_.get();
551 if (!emulator)
552 return;
[email protected]b2e4c70132013-10-03 02:07:51553 popup_origin_scale_for_emulation_ = emulator->scale();
[email protected]19193682014-04-03 15:01:43554 popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
Pavel Feldmancc099f72017-07-20 23:09:00555 popup_screen_origin_for_emulation_ =
Lei Zhang9b359d32017-11-28 00:57:02556 emulator->original_screen_rect().origin();
Fady Samuel1c1ad3692018-11-06 23:28:40557 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
558 compositor_viewport_pixel_size_,
559 emulator->original_screen_info());
[email protected]b2e4c70132013-10-03 02:07:51560}
561
[email protected]2d6836f42014-07-02 17:25:31562gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) {
563 if (screen_metrics_emulator_)
564 return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor);
565 return anchor;
566}
567
thakis18e426412017-03-15 12:06:37568#if BUILDFLAG(USE_EXTERNAL_POPUP_MENU)
[email protected]b2e4c70132013-10-03 02:07:51569void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
Albert J. Wong7bbf22d2018-12-20 00:27:27570 ExternalPopupMenu* popup) {
571 if (screen_metrics_emulator_)
572 popup->SetOriginScaleForEmulation(screen_metrics_emulator_->scale());
[email protected]b2e4c70132013-10-03 02:07:51573}
[email protected]53907862014-03-25 15:42:40574#endif
[email protected]b2e4c70132013-10-03 02:07:51575
576void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
577 if (screen_metrics_emulator_)
578 screen_metrics_emulator_->OnShowContextMenu(params);
579}
580
[email protected]a95986a82010-12-24 06:19:28581bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
ekaramad330ba4232016-09-23 17:57:47582#if defined(OS_MACOSX)
583 if (IPC_MESSAGE_CLASS(message) == TextInputClientMsgStart)
584 return text_input_client_observer_->OnMessageReceived(message);
585#endif
lfgbee1e0a2016-06-08 21:24:21586 if (mouse_lock_dispatcher_ &&
587 mouse_lock_dispatcher_->OnMessageReceived(message))
588 return true;
589
[email protected]a95986a82010-12-24 06:19:28590 bool handled = true;
591 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
Albert J. Wong3c93c182018-09-27 17:29:43592 IPC_MESSAGE_HANDLER(WidgetMsg_ShowContextMenu, OnShowContextMenu)
593 IPC_MESSAGE_HANDLER(WidgetMsg_Close, OnClose)
594 IPC_MESSAGE_HANDLER(WidgetMsg_SynchronizeVisualProperties,
Fady Samuel799e72192018-04-25 21:16:57595 OnSynchronizeVisualProperties)
Albert J. Wong3c93c182018-09-27 17:29:43596 IPC_MESSAGE_HANDLER(WidgetMsg_EnableDeviceEmulation,
dgozman9260b0a12015-03-16 13:45:20597 OnEnableDeviceEmulation)
Albert J. Wong3c93c182018-09-27 17:29:43598 IPC_MESSAGE_HANDLER(WidgetMsg_DisableDeviceEmulation,
dgozman9260b0a12015-03-16 13:45:20599 OnDisableDeviceEmulation)
Albert J. Wong3c93c182018-09-27 17:29:43600 IPC_MESSAGE_HANDLER(WidgetMsg_WasHidden, OnWasHidden)
601 IPC_MESSAGE_HANDLER(WidgetMsg_WasShown, OnWasShown)
602 IPC_MESSAGE_HANDLER(WidgetMsg_SetActive, OnSetActive)
Albert J. Wong3c93c182018-09-27 17:29:43603 IPC_MESSAGE_HANDLER(WidgetMsg_SetTextDirection, OnSetTextDirection)
604 IPC_MESSAGE_HANDLER(WidgetMsg_SetBounds_ACK, OnRequestSetBoundsAck)
605 IPC_MESSAGE_HANDLER(WidgetMsg_UpdateScreenRects, OnUpdateScreenRects)
606 IPC_MESSAGE_HANDLER(WidgetMsg_ForceRedraw, OnForceRedraw)
607 IPC_MESSAGE_HANDLER(WidgetMsg_SetViewportIntersection,
kenrbea731792017-01-13 15:10:48608 OnSetViewportIntersection)
Albert J. Wong3c93c182018-09-27 17:29:43609 IPC_MESSAGE_HANDLER(WidgetMsg_SetIsInert, OnSetIsInert)
610 IPC_MESSAGE_HANDLER(WidgetMsg_SetInheritedEffectiveTouchAction,
sunxd540a9962018-05-24 22:51:06611 OnSetInheritedEffectiveTouchAction)
Albert J. Wong3c93c182018-09-27 17:29:43612 IPC_MESSAGE_HANDLER(WidgetMsg_UpdateRenderThrottlingStatus,
Ken Buchanan8a319fb2017-11-15 18:37:12613 OnUpdateRenderThrottlingStatus)
Albert J. Wong3c93c182018-09-27 17:29:43614 IPC_MESSAGE_HANDLER(WidgetMsg_WaitForNextFrameForTests,
lfg43e08e62016-02-03 18:51:37615 OnWaitNextFrameForTests)
paulmeyer90f6c31d2016-11-12 00:17:59616 IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter)
617 IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver, OnDragTargetDragOver)
618 IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave, OnDragTargetDragLeave)
619 IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop)
paulmeyer8fc8ea92016-11-15 05:12:21620 IPC_MESSAGE_HANDLER(DragMsg_SourceEnded, OnDragSourceEnded)
621 IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded,
622 OnDragSourceSystemDragEnded)
[email protected]a95986a82010-12-24 06:19:28623 IPC_MESSAGE_UNHANDLED(handled = false)
624 IPC_END_MESSAGE_MAP()
625 return handled;
626}
initial.commit09911bf2008-07-26 23:55:29627
628bool RenderWidget::Send(IPC::Message* message) {
Nasko Oskovf97e8b02017-07-25 02:45:42629 // Don't send any messages after the browser has told us to close, and filter
danakj6dcbc5962018-11-16 16:45:42630 // most outgoing messages when frozen.
631 if (closing_) {
632 delete message;
633 return false;
634 }
635 if (is_frozen_ && !SwappedOutMessages::CanSendWhileSwappedOut(message)) {
initial.commit09911bf2008-07-26 23:55:29636 delete message;
637 return false;
638 }
639
640 // If given a messsage without a routing ID, then assign our routing ID.
641 if (message->routing_id() == MSG_ROUTING_NONE)
642 message->set_routing_id(routing_id_);
643
[email protected]380244092011-10-07 17:26:27644 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44645}
646
dtapuska014ed082016-11-11 21:58:48647void RenderWidget::SendOrCrash(IPC::Message* message) {
648 bool result = Send(message);
649 CHECK(closing_ || result) << "Failed to send message";
650}
651
ekaramad5aff1942017-01-06 01:26:35652bool RenderWidget::ShouldHandleImeEvents() const {
Albert J. Wong7bbf22d2018-12-20 00:27:27653 if (delegate())
danakj89ae4532018-12-12 22:52:55654 return has_focus_;
655 if (for_child_local_root_frame_) {
656 // TODO(ekaramad): We track page focus in all RenderViews on the page but
657 // the RenderWidgets corresponding to child local roots do not get the
658 // update. For now, this method returns true when the RenderWidget is for a
659 // child local frame, i.e., IME events will be processed regardless of page
660 // focus. We should revisit this after page focus for OOPIFs has been fully
661 // resolved (https://crbug.com/689777).
662 return true;
663 }
664 // Not a frame widget.
665 return false;
ekaramad5aff1942017-01-06 01:26:35666}
667
initial.commit09911bf2008-07-26 23:55:29668void RenderWidget::OnClose() {
dchengd96a27a2015-07-24 20:17:32669 DCHECK(content::RenderThread::Get());
670 if (closing_)
671 return;
danakj292b63e2018-11-19 20:47:06672 for (auto& observer : render_frames_)
673 observer.WidgetWillClose();
dchengd96a27a2015-07-24 20:17:32674 closing_ = true;
675
676 // Browser correspondence is no longer needed at this point.
677 if (routing_id_ != MSG_ROUTING_NONE) {
678 RenderThread::Get()->RemoveRoute(routing_id_);
Albert J. Wongcb004632018-07-10 22:58:25679 g_routing_id_widget_map.Get().erase(routing_id_);
danakj678f0252018-11-09 21:46:34680 if (RenderThreadImpl::current()) {
681 // RenderWidgets may be hidden when they are closed. If we were previously
682 // hidden, we are being counted as such in RenderThreadImpl. Thus we
683 // remove that count here by calling WidgetRestored() even though we're
684 // clearly not becoming visible here.
685 if (is_hidden_)
686 RenderThreadImpl::current()->WidgetRestored();
dchengd96a27a2015-07-24 20:17:32687 RenderThreadImpl::current()->WidgetDestroyed();
danakj678f0252018-11-09 21:46:34688 }
dchengd96a27a2015-07-24 20:17:32689 }
690
danakj327a4fe2019-01-26 00:00:35691 // Stop handling main thread input events immediately so we don't have them
692 // running while things are partly shut down.
693 if (input_event_queue_)
694 input_event_queue_->ClearClient();
695
danakj6dcbc5962018-11-16 16:45:42696 if (for_child_local_root_frame_) {
dchengd96a27a2015-07-24 20:17:32697 // Widgets for frames may be created and closed at any time while the frame
Ken Buchananed449bb2018-02-01 21:02:05698 // is alive. However, WebWidget must be closed synchronously because frame
699 // widgets and frames hold pointers to each other. The deferred call to
700 // Close() will complete cleanup and release |this|, but CloseWebWidget()
701 // prevents Close() from attempting to access members of an
702 // already-deleted frame.
703 CloseWebWidget();
dchengd96a27a2015-07-24 20:17:32704 }
Ken Buchananed449bb2018-02-01 21:02:05705 // If there is a Send call on the stack, then it could be dangerous to close
706 // now. Post a task that only gets invoked when there are no nested message
707 // loops.
Hajime Hoshi315a61f2018-08-14 17:27:28708 GetCleanupTaskRunner()->PostNonNestableTask(
709 FROM_HERE, base::BindOnce(&RenderWidget::Close, this));
dchengd96a27a2015-07-24 20:17:32710
711 // Balances the AddRef taken when we called AddRoute.
712 Release();
initial.commit09911bf2008-07-26 23:55:29713}
714
Fady Samuel799e72192018-04-25 21:16:57715void RenderWidget::OnSynchronizeVisualProperties(
danakja2c9d0a92018-07-25 20:01:18716 const VisualProperties& original_params) {
717 TRACE_EVENT0("renderer", "RenderWidget::OnSynchronizeVisualProperties");
EhsanKbd2cea992017-11-23 18:49:08718
danakja2c9d0a92018-07-25 20:01:18719 VisualProperties params = original_params;
danakj01474dd2019-01-28 10:46:04720 // Web tests can override the device scale factor in the renderer.
721 if (device_scale_factor_for_testing_) {
danakjb4cec102019-01-30 19:22:13722 params.screen_info.device_scale_factor = device_scale_factor_for_testing_;
danakj01474dd2019-01-28 10:46:04723 params.compositor_viewport_pixel_size = gfx::ScaleToCeiledSize(
724 params.new_size, params.screen_info.device_scale_factor);
725 }
danakj04d128a2019-01-25 02:10:20726
727 // Inform the rendering thread of the color space indicating the presence of
728 // HDR capabilities. The HDR bit happens to be globally true/false for all
729 // browser windows (on Windows OS) and thus would be the same for all
730 // RenderWidgets, so clobbering each other works out since only the HDR bit is
731 // used. See https://crbug.com/803451 and
732 // https://chromium-review.googlesource.com/c/chromium/src/+/852912/15#message-68bbd3e25c3b421a79cd028b2533629527d21fee
733 //
734 // The RenderThreadImpl can be null in tests.
735 {
736 RenderThreadImpl* render_thread = RenderThreadImpl::current();
737 if (render_thread)
738 render_thread->SetRenderingColorSpace(params.screen_info.color_space);
739 }
740
Albert J. Wong7bbf22d2018-12-20 00:27:27741 if (delegate()) {
danakj84bbf552019-01-21 21:33:31742 if (size_ != params.new_size) {
743 // Only hide popups when the size changes. Eg https://crbug.com/761908.
744 delegate()->CancelPagePopupForWidget();
745 }
danakja2c9d0a92018-07-25 20:01:18746
747 if (display_mode_ != params.display_mode) {
748 display_mode_ = params.display_mode;
Albert J. Wong7bbf22d2018-12-20 00:27:27749 delegate()->ApplyNewDisplayModeForWidget(params.display_mode);
danakja2c9d0a92018-07-25 20:01:18750 }
751
752 bool auto_resize_mode_changed =
753 auto_resize_mode_ != params.auto_resize_enabled;
754 auto_resize_mode_ = params.auto_resize_enabled;
755 min_size_for_auto_resize_ = params.min_size_for_auto_resize;
756 max_size_for_auto_resize_ = params.max_size_for_auto_resize;
757
758 if (auto_resize_mode_) {
759 gfx::Size min_auto_size = min_size_for_auto_resize_;
760 gfx::Size max_auto_size = max_size_for_auto_resize_;
761 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
762 min_auto_size = gfx::ScaleToCeiledSize(
763 min_auto_size, params.screen_info.device_scale_factor);
764 max_auto_size = gfx::ScaleToCeiledSize(
765 max_auto_size, params.screen_info.device_scale_factor);
766 }
Albert J. Wong7bbf22d2018-12-20 00:27:27767 delegate()->ApplyAutoResizeLimitsForWidget(min_auto_size, max_auto_size);
danakja2c9d0a92018-07-25 20:01:18768 } else if (auto_resize_mode_changed) {
Albert J. Wong7bbf22d2018-12-20 00:27:27769 delegate()->DisableAutoResizeForWidget();
danakja2c9d0a92018-07-25 20:01:18770 if (params.new_size.IsEmpty())
771 return;
772 }
773
774 browser_controls_shrink_blink_size_ =
775 params.browser_controls_shrink_blink_size;
776 top_controls_height_ = params.top_controls_height;
777 bottom_controls_height_ = params.bottom_controls_height;
[email protected]b2e4c70132013-10-03 02:07:51778 }
779
danakja2c9d0a92018-07-25 20:01:18780 if (!resizing_mode_selector_->ShouldAbortOnResize(this, params)) {
781 if (screen_metrics_emulator_) {
782 screen_metrics_emulator_->OnSynchronizeVisualProperties(params);
783 } else {
danakj0246bba02019-01-23 23:12:27784 if (!delegate()) {
785 // The main frame controls the page scale factor, from blink. For other
786 // frame widgets, the page scale is received from its parent as part of
787 // the visual properties here. While blink doesn't need to know this
788 // page scale factor outside the main frame, the compositor does in
789 // order to produce its output at the correct scale.
790 layer_tree_view_->SetExternalPageScaleFactor(params.page_scale_factor);
791 // Store the value to give to any new RenderFrameProxy that is
792 // registered.
793 page_scale_factor_from_mainframe_ = params.page_scale_factor;
794 // Push the page scale factor down to any child RenderWidgets via our
795 // child proxy frames.
796 // TODO(danakj): This ends up setting the page scale factor in the
797 // RenderWidgetHost of the child RenderWidget, so that it can bounce
798 // the value down to its RenderWidget. Since this is essentially a
799 // global value per-page, we could instead store it once in the browser
800 // (such as in RenderViewHost) and distribute it to each frame-hosted
801 // RenderWidget from there.
802 for (auto& child_proxy : render_frame_proxies_)
803 child_proxy.OnPageScaleFactorChanged(params.page_scale_factor);
804 }
805
danakja2c9d0a92018-07-25 20:01:18806 gfx::Size old_visible_viewport_size = visible_viewport_size_;
807 SynchronizeVisualProperties(params);
808 if (old_visible_viewport_size != visible_viewport_size_) {
809 for (auto& render_frame : render_frames_)
810 render_frame.DidChangeVisibleViewport();
811 }
812 }
Fady Samuel799e72192018-04-25 21:16:57813 }
814
Albert J. Wong7bbf22d2018-12-20 00:27:27815 if (delegate() && params.scroll_focused_node_into_view)
816 delegate()->ScrollFocusedNodeIntoViewForWidget();
initial.commit09911bf2008-07-26 23:55:29817}
818
dgozman9260b0a12015-03-16 13:45:20819void RenderWidget::OnEnableDeviceEmulation(
Lei Zhang9b359d32017-11-28 00:57:02820 const blink::WebDeviceEmulationParams& params) {
mfomitchev2600fd7c2016-02-17 20:53:39821 if (!screen_metrics_emulator_) {
Fady Samuel4255c182018-05-24 20:42:36822 VisualProperties visual_properties;
823 visual_properties.screen_info = screen_info_;
824 visual_properties.new_size = size_;
825 visual_properties.compositor_viewport_pixel_size =
Christopher Cameronaad15a0d2018-03-09 03:47:33826 compositor_viewport_pixel_size_;
Fady Samuel84d8a1f72018-11-08 00:26:17827 visual_properties.local_surface_id_allocation =
828 local_surface_id_allocation_from_parent_;
Fady Samuel4255c182018-05-24 20:42:36829 visual_properties.visible_viewport_size = visible_viewport_size_;
830 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
831 visual_properties.display_mode = display_mode_;
mfomitchev2600fd7c2016-02-17 20:53:39832 screen_metrics_emulator_.reset(new RenderWidgetScreenMetricsEmulator(
Albert J. Wong3c93c182018-09-27 17:29:43833 this, params, visual_properties, widget_screen_rect_,
Fady Samuel4255c182018-05-24 20:42:36834 window_screen_rect_));
oshima50872a72016-03-04 13:26:18835 screen_metrics_emulator_->Apply();
mfomitchev2600fd7c2016-02-17 20:53:39836 } else {
dgozman9260b0a12015-03-16 13:45:20837 screen_metrics_emulator_->ChangeEmulationParams(params);
mfomitchev2600fd7c2016-02-17 20:53:39838 }
dgozman9260b0a12015-03-16 13:45:20839}
840
841void RenderWidget::OnDisableDeviceEmulation() {
842 screen_metrics_emulator_.reset();
843}
844
initial.commit09911bf2008-07-26 23:55:29845void RenderWidget::OnWasHidden() {
[email protected]9c3085f2011-06-09 02:10:31846 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
initial.commit09911bf2008-07-26 23:55:29847 // Go into a mode where we stop generating paint and scrolling events.
[email protected]bee16aab2009-08-26 15:55:03848 SetHidden(true);
ericwilligers88e69742016-10-17 19:29:55849 for (auto& observer : render_frames_)
850 observer.WasHidden();
initial.commit09911bf2008-07-26 23:55:29851}
852
Saman Samie61e5c032018-11-05 22:11:44853void RenderWidget::OnWasShown(base::TimeTicks show_request_timestamp,
854 bool was_evicted) {
[email protected]9e2e4632012-07-27 16:38:41855 TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
danakj57f139f2018-11-19 19:23:46856 // TODO(danakj): Nothing should happen ideally if the RenderWidget is frozen!
857 // It's not visible! However.. the RenderView needs to see it as visible in
858 // order to make the Page visible /o\ so this is hard. We need to detangle
859 // page visibility from the main widget. https://crbug.com/419087
danakj678f0252018-11-09 21:46:34860
tasakb95dbb50c2017-02-08 18:07:50861 was_shown_time_ = base::TimeTicks::Now();
initial.commit09911bf2008-07-26 23:55:29862 // See OnWasHidden
[email protected]bee16aab2009-08-26 15:55:03863 SetHidden(false);
ericwilligers88e69742016-10-17 19:29:55864 for (auto& observer : render_frames_)
865 observer.WasShown();
initial.commit09911bf2008-07-26 23:55:29866
Saman Samie61e5c032018-11-05 22:11:44867 if (was_evicted) {
868 for (auto& observer : render_frame_proxies_) {
869 observer.WasEvicted();
870 }
871 }
872
danakj125a29e2019-01-24 23:25:29873 if (!show_request_timestamp.is_null()) {
danakja6c10012018-07-06 14:25:36874 layer_tree_view_->layer_tree_host()->RequestPresentationTimeForNextFrame(
Sadrul Habib Chowdhury8bc43cc2018-06-06 01:48:03875 CreateTabSwitchingTimeRecorder(show_request_timestamp));
[email protected]3399dd822014-08-09 11:14:24876 }
initial.commit09911bf2008-07-26 23:55:29877}
878
Avi Drissman014dec72018-06-07 02:34:01879void RenderWidget::OnRequestSetBoundsAck() {
[email protected]53d3f302009-12-21 04:42:05880 DCHECK(pending_window_rect_count_);
881 pending_window_rect_count_--;
882}
883
Albert J. Wongcb004632018-07-10 22:58:25884void RenderWidget::OnForceRedraw(int snapshot_id) {
danakj125a29e2019-01-24 23:25:29885 layer_tree_view_->layer_tree_host()->RequestPresentationTimeForNextFrame(
886 base::BindOnce(&RenderWidget::DidPresentForceDrawFrame,
887 weak_ptr_factory_.GetWeakPtr(), snapshot_id));
888 layer_tree_view_->SetNeedsForcedRedraw();
Albert J. Wongcb004632018-07-10 22:58:25889}
890
891void RenderWidget::DidPresentForceDrawFrame(
892 int snapshot_id,
893 const gfx::PresentationFeedback& feedback) {
Albert J. Wong3c93c182018-09-27 17:29:43894 Send(new WidgetHostMsg_ForceRedrawComplete(routing_id(), snapshot_id));
Albert J. Wongcb004632018-07-10 22:58:25895}
896
Xianzhu Wangf02017ac2018-10-17 01:47:33897viz::FrameSinkId RenderWidget::GetFrameSinkIdAtPoint(const gfx::PointF& point,
Ken Buchanan44d7e2f2018-08-23 14:18:05898 gfx::PointF* local_point) {
899 return input_handler_->GetFrameSinkIdAtPoint(point, local_point);
Navid Zolghadr0d86e5f2017-10-23 18:09:22900}
901
danakj327a4fe2019-01-26 00:00:35902bool RenderWidget::HandleInputEvent(
dtapuska9ec1a912017-04-21 15:18:31903 const blink::WebCoalescedInputEvent& input_event,
904 const ui::LatencyInfo& latency_info,
Dave Tapuskaea83d3bd2017-06-13 16:14:55905 HandledEventCallback callback) {
danakj327a4fe2019-01-26 00:00:35906 if (is_frozen_)
907 return false;
Dave Tapuskaea83d3bd2017-06-13 16:14:55908 input_handler_->HandleInputEvent(input_event, latency_info,
909 std::move(callback));
danakj327a4fe2019-01-26 00:00:35910 return true;
dtapuska9ec1a912017-04-21 15:18:31911}
912
danakj125a29e2019-01-24 23:25:29913void RenderWidget::SetNeedsMainFrame() {
danakj125a29e2019-01-24 23:25:29914 // The WebWidgetClient is not |this| if tests override it for the WebView and
915 // WebViewClient.
916 blink::WebWidgetClient* client =
917 delegate() ? delegate()->GetWebWidgetClientForWidget() : this;
918 client->ScheduleAnimation();
919}
920
dtapuska9d46ef7d2017-05-26 19:06:06921scoped_refptr<MainThreadEventQueue> RenderWidget::GetInputEventQueue() {
922 return input_event_queue_;
923}
924
fsamuel78f86e42016-01-20 04:10:23925void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
lfg8ff33912016-09-13 20:59:21926 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:54927 GetWebWidget()->SetCursorVisibilityState(is_visible);
fsamuel78f86e42016-01-20 04:10:23928}
929
930void RenderWidget::OnMouseCaptureLost() {
lfg8ff33912016-09-13 20:59:21931 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:54932 GetWebWidget()->MouseCaptureLost();
fsamuel78f86e42016-01-20 04:10:23933}
934
alexmos56567492016-09-13 00:52:46935void RenderWidget::OnSetEditCommandsForNextKeyEvent(
936 const EditCommands& edit_commands) {
937 edit_commands_ = edit_commands;
938}
939
Albert J. Wongcb004632018-07-10 22:58:25940void RenderWidget::OnSetActive(bool active) {
Albert J. Wong7bbf22d2018-12-20 00:27:27941 if (delegate())
942 delegate()->SetActiveForWidget(active);
Albert J. Wongcb004632018-07-10 22:58:25943}
944
fsamuel78f86e42016-01-20 04:10:23945void RenderWidget::OnSetFocus(bool enable) {
Albert J. Wong7bbf22d2018-12-20 00:27:27946 if (delegate())
947 delegate()->DidReceiveSetFocusEventForWidget();
danakja2c9d0a92018-07-25 20:01:18948 SetFocus(enable);
949}
950
951void RenderWidget::SetFocus(bool enable) {
lfge0c2792ec2016-05-11 18:52:08952 has_focus_ = enable;
953
lfg8ff33912016-09-13 20:59:21954 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:54955 GetWebWidget()->SetFocus(enable);
lfge0c2792ec2016-05-11 18:52:08956
ericwilligers88e69742016-10-17 19:29:55957 for (auto& observer : render_frames_)
958 observer.RenderWidgetSetFocus(enable);
danakja2c9d0a92018-07-25 20:01:18959
Albert J. Wong7bbf22d2018-12-20 00:27:27960 if (delegate())
961 delegate()->DidChangeFocusForWidget();
fsamuel78f86e42016-01-20 04:10:23962}
963
fsamuel78f86e42016-01-20 04:10:23964///////////////////////////////////////////////////////////////////////////////
danakja6c10012018-07-06 14:25:36965// LayerTreeViewDelegate
fsamuel78f86e42016-01-20 04:10:23966
David Bokanc8e38d02018-10-08 21:56:01967void RenderWidget::ApplyViewportChanges(
968 const cc::ApplyViewportChangesArgs& args) {
Ken Buchananed449bb2018-02-01 21:02:05969 if (!GetWebWidget())
970 return;
David Bokanc8e38d02018-10-08 21:56:01971 GetWebWidget()->ApplyViewportChanges(args);
fsamuel78f86e42016-01-20 04:10:23972}
973
sahel1b47fda72017-03-28 17:03:07974void RenderWidget::RecordWheelAndTouchScrollingCount(
975 bool has_scrolled_by_wheel,
976 bool has_scrolled_by_touch) {
Ken Buchananed449bb2018-02-01 21:02:05977 if (!GetWebWidget())
978 return;
Blink Reformat1c4d759e2017-04-09 16:34:54979 GetWebWidget()->RecordWheelAndTouchScrollingCount(has_scrolled_by_wheel,
sahel1b47fda72017-03-28 17:03:07980 has_scrolled_by_touch);
981}
982
Sahel Sharify676580c2019-01-10 21:49:49983void RenderWidget::SendOverscrollEventFromImplSide(
984 const gfx::Vector2dF& overscroll_delta,
985 cc::ElementId scroll_latched_element_id) {
986 if (!GetWebWidget())
987 return;
988 GetWebWidget()->SendOverscrollEventFromImplSide(overscroll_delta,
989 scroll_latched_element_id);
990}
991void RenderWidget::SendScrollEndEventFromImplSide(
992 cc::ElementId scroll_latched_element_id) {
993 if (!GetWebWidget())
994 return;
995 GetWebWidget()->SendScrollEndEventFromImplSide(scroll_latched_element_id);
996}
997
Daniel Cheng224569ee2018-04-25 05:45:06998void RenderWidget::BeginMainFrame(base::TimeTicks frame_time) {
Ken Buchananed449bb2018-02-01 21:02:05999 if (!GetWebWidget())
1000 return;
dtapuska3d5624d32016-08-30 04:34:001001
Stephen Chenneyd56b5382019-01-29 00:37:021002 // We record metrics only when running in multi-threaded mode, not
1003 // single-thread mode for testing.
1004 bool record_main_frame_metrics =
1005 !!compositor_deps_->GetCompositorImplThreadTaskRunner();
1006 if (input_event_queue_) {
1007 base::Optional<ScopedUkmRafAlignedInputTimer> ukm_timer;
1008 if (record_main_frame_metrics)
1009 ukm_timer.emplace(GetWebWidget());
1010 input_event_queue_->DispatchRafAlignedInput(frame_time);
1011 }
1012
1013 GetWebWidget()->BeginFrame(frame_time, record_main_frame_metrics);
fsamuel78f86e42016-01-20 04:10:231014}
1015
danakjc7afae52017-06-20 21:12:411016void RenderWidget::RequestNewLayerTreeFrameSink(
danakja6c10012018-07-06 14:25:361017 LayerTreeFrameSinkCallback callback) {
[email protected]7912e822014-04-16 02:37:031018 // For widgets that are never visible, we don't start the compositor, so we
danakjc7afae52017-06-20 21:12:411019 // never get a request for a cc::LayerTreeFrameSink.
sievers71c62dd52015-10-07 01:44:391020 DCHECK(!compositor_never_visible_);
danakjf87460792018-12-04 20:14:221021 // Frozen RenderWidgets should not be doing any compositing.
Scott Violetb04f16c2018-11-27 00:48:461022 DCHECK(!is_frozen_);
danakj678f0252018-11-09 21:46:341023
1024 if (is_closing()) {
1025 // In this case, we drop the request which means the compositor waits
1026 // forever, which is fine since we're going to destroy it.
1027 return;
1028 }
jonrossa2ff4f82018-02-16 17:27:461029
danakjf87460792018-12-04 20:14:221030 // If we have a warmup in progress, wait for that and store the callback
1031 // to be run when the warmup completes.
1032 if (warmup_frame_sink_request_pending_) {
1033 after_warmup_callback_ = std::move(callback);
1034 return;
1035 }
1036 // If a warmup previously completed, use the result.
1037 if (warmup_frame_sink_) {
1038 std::move(callback).Run(std::move(warmup_frame_sink_));
1039 return;
1040 }
1041
1042 DoRequestNewLayerTreeFrameSink(std::move(callback));
1043}
1044
1045void RenderWidget::DoRequestNewLayerTreeFrameSink(
1046 LayerTreeFrameSinkCallback callback) {
jonrossa2ff4f82018-02-16 17:27:461047 // TODO(jonross): have this generated by the LayerTreeFrameSink itself, which
1048 // would then handle binding.
1049 mojom::RenderFrameMetadataObserverPtr ptr;
1050 mojom::RenderFrameMetadataObserverRequest request = mojo::MakeRequest(&ptr);
1051 mojom::RenderFrameMetadataObserverClientPtrInfo client_info;
1052 mojom::RenderFrameMetadataObserverClientRequest client_request =
1053 mojo::MakeRequest(&client_info);
danakj4b347212018-07-04 17:55:171054 auto render_frame_metadata_observer =
1055 std::make_unique<RenderFrameMetadataObserverImpl>(std::move(request),
1056 std::move(client_info));
danakja6c10012018-07-06 14:25:361057 layer_tree_view_->SetRenderFrameObserver(
danakj4b347212018-07-04 17:55:171058 std::move(render_frame_metadata_observer));
danakjf51754372018-12-13 23:20:011059 GURL url = GetWebWidget()->GetURLForDebugTrace();
danakjefabf312018-10-05 19:03:071060 // The |url| is not always available, fallback to a fixed string.
1061 if (url.is_empty())
1062 url = GURL("chrome://gpu/RenderWidget::RequestNewLayerTreeFrameSink");
danakj6dcbc5962018-11-16 16:45:421063 // TODO(danakj): This may not be accurate, depending on the intent. A child
1064 // local root could be in the same process as the view, so if the client is
1065 // meant to designate the process type, it seems kRenderer would be the
1066 // correct choice. If client is meant to designate the widget type, then
1067 // kOOPIF would denote that it is not for the main frame. However, kRenderer
1068 // would also be used for other widgets such as popups.
1069 const char* client_name = for_child_local_root_frame_ ? kOOPIF : kRenderer;
Scott Violetb04f16c2018-11-27 00:48:461070 RenderThreadImpl::current()->RequestNewLayerTreeFrameSink(
1071 routing_id_, frame_swap_message_queue_, std::move(url),
1072 std::move(callback), std::move(client_request), std::move(ptr),
1073 client_name);
[email protected]ba91a792013-02-06 09:48:281074}
1075
fsamuel78f86e42016-01-20 04:10:231076void RenderWidget::DidCommitAndDrawCompositorFrame() {
1077 // NOTE: Tests may break if this event is renamed or moved. See
1078 // tab_capture_performancetest.cc.
1079 TRACE_EVENT0("gpu", "RenderWidget::DidCommitAndDrawCompositorFrame");
lfge0c2792ec2016-05-11 18:52:081080
ericwilligers88e69742016-10-17 19:29:551081 for (auto& observer : render_frames_)
1082 observer.DidCommitAndDrawCompositorFrame();
lfge0c2792ec2016-05-11 18:52:081083
fsamuel78f86e42016-01-20 04:10:231084 // Notify subclasses that we initiated the paint operation.
1085 DidInitiatePaint();
Yiming Zhou0f8836c22018-09-13 22:22:111086
Albert J. Wongfb64e142018-10-16 01:10:451087 Send(new WidgetHostMsg_DidCommitAndDrawCompositorFrame(routing_id_));
fsamuel78f86e42016-01-20 04:10:231088}
1089
Saman Sami766e0b02018-01-31 17:19:201090void RenderWidget::DidCommitCompositorFrame() {
Albert J. Wong7bbf22d2018-12-20 00:27:271091 if (delegate())
1092 delegate()->DidCommitCompositorFrameForWidget();
Saman Sami766e0b02018-01-31 17:19:201093}
fsamuel78f86e42016-01-20 04:10:231094
danakja2c9d0a92018-07-25 20:01:181095void RenderWidget::DidCompletePageScaleAnimation() {
Albert J. Wong7bbf22d2018-12-20 00:27:271096 if (delegate())
1097 delegate()->DidCompletePageScaleAnimationForWidget();
danakja2c9d0a92018-07-25 20:01:181098}
fsamuel78f86e42016-01-20 04:10:231099
danakj53f46b82018-12-11 20:55:551100void RenderWidget::ScheduleAnimation() {
1101 // This call is not needed in single thread mode for tests without a
1102 // scheduler, but they need to override the WebWidgetClient and replace this
1103 // method in order to schedule a synchronous composite task themselves.
1104 layer_tree_view_->SetNeedsBeginFrame();
initial.commit09911bf2008-07-26 23:55:291105}
1106
danakjefcb8432019-01-16 18:47:141107void RenderWidget::SetShowFPSCounter(bool show) {
1108 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1109 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1110 debug_state.show_fps_counter = show;
1111 host->SetDebugState(debug_state);
1112}
1113
danakje691e852019-01-16 22:49:041114void RenderWidget::SetShowPaintRects(bool show) {
1115 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1116 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1117 debug_state.show_paint_rects = show;
1118 host->SetDebugState(debug_state);
1119}
1120
1121void RenderWidget::SetShowDebugBorders(bool show) {
1122 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1123 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1124 if (show)
1125 debug_state.show_debug_borders.set();
1126 else
1127 debug_state.show_debug_borders.reset();
1128 host->SetDebugState(debug_state);
1129}
1130
1131void RenderWidget::SetShowScrollBottleneckRects(bool show) {
1132 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1133 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1134 debug_state.show_touch_event_handler_rects = show;
1135 debug_state.show_wheel_event_handler_rects = show;
1136 debug_state.show_non_fast_scrollable_rects = show;
1137 host->SetDebugState(debug_state);
1138}
1139
1140void RenderWidget::SetShowHitTestBorders(bool show) {
1141 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1142 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1143 debug_state.show_hit_test_borders = show;
1144 host->SetDebugState(debug_state);
1145}
1146
Stephen Chenneyd56b5382019-01-29 00:37:021147void RenderWidget::UpdateVisualState() {
Ken Buchananed449bb2018-02-01 21:02:051148 if (!GetWebWidget())
1149 return;
1150
Stephen Chenneyd56b5382019-01-29 00:37:021151 // We record metrics only when running in multi-threaded mode, not
1152 // single-thread mode for testing.
1153 bool record_main_frame_metrics =
1154 !!compositor_deps_->GetCompositorImplThreadTaskRunner();
1155
Stephen Chenneyec4312612018-11-21 12:40:161156 // When recording main frame metrics set the lifecycle reason to
1157 // kBeginMainFrame, because this is the calller of UpdateLifecycle
1158 // for the main frame. Otherwise, set the reason to kTests, which is
1159 // the oinly other reason this method is called.
1160 WebWidget::LifecycleUpdateReason lifecycle_reason =
1161 record_main_frame_metrics
1162 ? WebWidget::LifecycleUpdateReason::kBeginMainFrame
1163 : WebWidget::LifecycleUpdateReason::kTest;
1164 GetWebWidget()->UpdateLifecycle(WebWidget::LifecycleUpdate::kAll,
1165 lifecycle_reason);
Blink Reformat1c4d759e2017-04-09 16:34:541166 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(false);
tasakb95dbb50c2017-02-08 18:07:501167
Robert Flack3ef2ffb2018-09-06 20:38:201168 if (first_update_visual_state_after_hidden_) {
Takashi SAKAMOTO870f6262017-08-22 04:08:271169 RecordTimeToFirstActivePaint();
1170 first_update_visual_state_after_hidden_ = false;
1171 }
1172}
tasakb95dbb50c2017-02-08 18:07:501173
Takashi SAKAMOTO870f6262017-08-22 04:08:271174void RenderWidget::RecordTimeToFirstActivePaint() {
tasakb95dbb50c2017-02-08 18:07:501175 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
tasakb95dbb50c2017-02-08 18:07:501176 base::TimeDelta sample = base::TimeTicks::Now() - was_shown_time_;
Takashi SAKAMOTO870f6262017-08-22 04:08:271177 if (render_thread_impl->NeedsToRecordFirstActivePaint(TTFAP_AFTER_PURGED)) {
1178 UMA_HISTOGRAM_TIMES("PurgeAndSuspend.Experimental.TimeToFirstActivePaint",
1179 sample);
1180 }
1181 if (render_thread_impl->NeedsToRecordFirstActivePaint(
1182 TTFAP_5MIN_AFTER_BACKGROUNDED)) {
1183 UMA_HISTOGRAM_TIMES(
1184 "PurgeAndSuspend.Experimental.TimeToFirstActivePaint."
1185 "AfterBackgrounded.5min",
1186 sample);
1187 }
fsamuel78f86e42016-01-20 04:10:231188}
1189
Stephen Chenneyd56b5382019-01-29 00:37:021190void RenderWidget::RecordStartOfFrameMetrics() {
1191 if (!GetWebWidget())
1192 return;
1193
1194 GetWebWidget()->RecordStartOfFrameMetrics();
1195}
1196
Stephen Chenney9879a5c2018-09-26 14:21:421197void RenderWidget::RecordEndOfFrameMetrics(base::TimeTicks frame_begin_time) {
1198 if (!GetWebWidget())
1199 return;
1200
1201 GetWebWidget()->RecordEndOfFrameMetrics(frame_begin_time);
1202}
1203
fsamuel78f86e42016-01-20 04:10:231204void RenderWidget::WillBeginCompositorFrame() {
1205 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
1206
Ken Buchananed449bb2018-02-01 21:02:051207 if (!GetWebWidget())
1208 return;
1209
Blink Reformat1c4d759e2017-04-09 16:34:541210 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(true);
alancutter317a8e02017-04-05 10:09:291211
dglazkov06854c5c2016-08-31 00:19:591212 // The UpdateTextInputState can result in further layout and possibly
1213 // enable GPU acceleration so they need to be called before any painting
1214 // is done.
changwan75e3b2072017-01-16 02:55:001215 UpdateTextInputState();
dglazkov06854c5c2016-08-31 00:19:591216 UpdateSelectionBounds();
1217
ericwilligers88e69742016-10-17 19:29:551218 for (auto& observer : render_frame_proxies_)
1219 observer.WillBeginCompositorFrame();
initial.commit09911bf2008-07-26 23:55:291220}
1221
Kent Tamura21d1de62018-12-10 04:45:201222std::unique_ptr<cc::SwapPromise> RenderWidget::RequestCopyOfOutputForWebTest(
Fady Samueldfecb7d2017-07-26 11:41:041223 std::unique_ptr<viz::CopyOutputRequest> request) {
Kent Tamura21d1de62018-12-10 04:45:201224 return RenderThreadImpl::current()->RequestCopyOfOutputForWebTest(
jbroman6ccbc7d472016-07-27 04:45:411225 routing_id_, std::move(request));
1226}
1227
fsamuel72464894f2015-12-15 06:59:311228///////////////////////////////////////////////////////////////////////////////
1229// RenderWidgetInputHandlerDelegate
1230
avid7d6b2e2016-03-04 19:41:171231void RenderWidget::FocusChangeComplete() {
Ehsan Karamad655d7b8a2018-01-12 18:38:381232 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1233 if (!frame_widget)
ekaramad27ca69b12017-04-20 18:34:291234 return;
Ehsan Karamad655d7b8a2018-01-12 18:38:381235
ekaramad27ca69b12017-04-20 18:34:291236 blink::WebLocalFrame* focused =
Ehsan Karamad655d7b8a2018-01-12 18:38:381237 frame_widget->LocalRoot()->View()->FocusedFrame();
1238
ekaramad27ca69b12017-04-20 18:34:291239 if (focused && focused->AutofillClient())
1240 focused->AutofillClient()->DidCompleteFocusChangeInFrame();
avid7d6b2e2016-03-04 19:41:171241}
fsamuel72464894f2015-12-15 06:59:311242
dtapuska1827dd22016-03-11 15:24:591243void RenderWidget::ObserveGestureEventAndResult(
1244 const blink::WebGestureEvent& gesture_event,
1245 const gfx::Vector2dF& unused_delta,
Sandra Sunac5cdd832017-12-11 03:27:131246 const cc::OverscrollBehavior& overscroll_behavior,
dtapuska1827dd22016-03-11 15:24:591247 bool event_processed) {
1248 if (!compositor_deps_->IsElasticOverscrollEnabled())
1249 return;
1250
1251 cc::InputHandlerScrollResult scroll_result;
1252 scroll_result.did_scroll = event_processed;
1253 scroll_result.did_overscroll_root = !unused_delta.IsZero();
1254 scroll_result.unused_scroll_delta = unused_delta;
Sandra Sunac5cdd832017-12-11 03:27:131255 scroll_result.overscroll_behavior = overscroll_behavior;
dtapuska1827dd22016-03-11 15:24:591256
Dave Tapuska04bc5ee92018-04-17 19:03:311257 widget_input_handler_manager_->ObserveGestureEventOnMainThread(gesture_event,
1258 scroll_result);
dtapuska1827dd22016-03-11 15:24:591259}
1260
avid7d6b2e2016-03-04 19:41:171261void RenderWidget::OnDidHandleKeyEvent() {
alexmos56567492016-09-13 00:52:461262 ClearEditCommands();
1263}
1264
1265void RenderWidget::SetEditCommandForNextKeyEvent(const std::string& name,
1266 const std::string& value) {
1267 ClearEditCommands();
1268 edit_commands_.emplace_back(name, value);
1269}
1270
1271void RenderWidget::ClearEditCommands() {
1272 edit_commands_.clear();
avid7d6b2e2016-03-04 19:41:171273}
fsamuel72464894f2015-12-15 06:59:311274
chongza8ba91fc2016-08-16 21:39:171275void RenderWidget::OnDidOverscroll(const ui::DidOverscrollParams& params) {
Dave Tapuska04bc5ee92018-04-17 19:03:311276 if (mojom::WidgetInputHandlerHost* host =
1277 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
1278 host->DidOverscroll(params);
Dave Tapuska139a72f2017-09-06 21:57:031279 }
fsamuel72464894f2015-12-15 06:59:311280}
1281
fsamuele8326c742016-01-12 00:49:391282void RenderWidget::SetInputHandler(RenderWidgetInputHandler* input_handler) {
1283 // Nothing to do here. RenderWidget created the |input_handler| and will take
1284 // ownership of it. We just verify here that we don't already have an input
1285 // handler.
1286 DCHECK(!input_handler_);
1287}
1288
changwan75e3b2072017-01-16 02:55:001289void RenderWidget::ShowVirtualKeyboard() {
danakj125a29e2019-01-24 23:25:291290 // Blink can continue running and change input state between the Close IPC
1291 // and the task that actually closes this class.
1292 if (closing_)
1293 return;
changwan75e3b2072017-01-16 02:55:001294 UpdateTextInputStateInternal(true, false);
1295}
1296
changwan62f57292017-02-17 08:28:251297void RenderWidget::ClearTextInputState() {
1298 text_input_info_ = blink::WebTextInputInfo();
1299 text_input_type_ = ui::TextInputType::TEXT_INPUT_TYPE_NONE;
1300 text_input_mode_ = ui::TextInputMode::TEXT_INPUT_MODE_DEFAULT;
1301 can_compose_inline_ = false;
1302 text_input_flags_ = 0;
AJITH KUMAR V041c0b02017-08-08 10:39:201303 next_previous_flags_ = kInvalidNextPreviousFlagsValue;
changwan62f57292017-02-17 08:28:251304}
1305
changwan75e3b2072017-01-16 02:55:001306void RenderWidget::UpdateTextInputState() {
danakj125a29e2019-01-24 23:25:291307 // Blink can continue running and change input state between the Close IPC
1308 // and the task that actually closes this class.
1309 if (closing_)
1310 return;
changwan75e3b2072017-01-16 02:55:001311 UpdateTextInputStateInternal(false, false);
1312}
1313
1314void RenderWidget::UpdateTextInputStateInternal(bool show_virtual_keyboard,
1315 bool reply_to_request) {
fsamuel72464894f2015-12-15 06:59:311316 TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState");
changwan75e3b2072017-01-16 02:55:001317
fsamuel72464894f2015-12-15 06:59:311318 if (ime_event_guard_) {
changwan75e3b2072017-01-16 02:55:001319 DCHECK(!reply_to_request);
1320 // show_virtual_keyboard should still be effective even if it was set inside
1321 // the IME
fsamuel72464894f2015-12-15 06:59:311322 // event guard.
changwan75e3b2072017-01-16 02:55:001323 if (show_virtual_keyboard)
1324 ime_event_guard_->set_show_virtual_keyboard(true);
fsamuel72464894f2015-12-15 06:59:311325 return;
1326 }
1327
dglazkov97b6c2b2016-10-25 17:35:551328 ui::TextInputType new_type = GetTextInputType();
1329 if (IsDateTimeInput(new_type))
1330 return; // Not considered as a text input field in WebKit/Chromium.
fsamuel72464894f2015-12-15 06:59:311331
dglazkov97b6c2b2016-10-25 17:35:551332 blink::WebTextInputInfo new_info;
ekaramad5aff1942017-01-06 01:26:351333 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:541334 new_info = controller->TextInputInfo();
dtapuskac4dd5be2016-10-25 15:11:101335 const ui::TextInputMode new_mode =
Blink Reformat1c4d759e2017-04-09 16:34:541336 ConvertWebTextInputMode(new_info.input_mode);
fsamuel72464894f2015-12-15 06:59:311337
1338 bool new_can_compose_inline = CanComposeInline();
1339
1340 // Only sends text input params if they are changed or if the ime should be
1341 // shown.
changwan75e3b2072017-01-16 02:55:001342 if (show_virtual_keyboard || reply_to_request ||
changwan38c3eb612016-12-09 01:45:561343 text_input_type_ != new_type || text_input_mode_ != new_mode ||
1344 text_input_info_ != new_info ||
1345 can_compose_inline_ != new_can_compose_inline) {
ekaramad9053e57b2016-04-26 20:00:381346 TextInputState params;
dglazkov97b6c2b2016-10-25 17:35:551347 params.type = new_type;
fsamuel72464894f2015-12-15 06:59:311348 params.mode = new_mode;
1349 params.flags = new_info.flags;
AJITH KUMAR V9e7b5572017-11-14 00:54:211350#if defined(OS_ANDROID)
AJITH KUMAR V041c0b02017-08-08 10:39:201351 if (next_previous_flags_ == kInvalidNextPreviousFlagsValue) {
1352 // Due to a focus change, values will be reset by the frame.
1353 // That case we only need fresh NEXT/PREVIOUS information.
Albert J. Wong3c93c182018-09-27 17:29:431354 // Also we won't send WidgetHostMsg_TextInputStateChanged if next/previous
AJITH KUMAR V041c0b02017-08-08 10:39:201355 // focusable status is changed.
1356 if (auto* controller = GetInputMethodController()) {
1357 next_previous_flags_ =
1358 controller->ComputeWebTextInputNextPreviousFlags();
1359 } else {
1360 // For safety in case GetInputMethodController() is null, because -1 is
1361 // invalid value to send to browser process.
1362 next_previous_flags_ = 0;
1363 }
1364 }
AJITH KUMAR V9e7b5572017-11-14 00:54:211365#else
1366 next_previous_flags_ = 0;
1367#endif
AJITH KUMAR V041c0b02017-08-08 10:39:201368 params.flags |= next_previous_flags_;
Yuichiro Hanada1b19cf852019-01-18 16:12:261369 params.value = new_info.value.Utf16();
Blink Reformat1c4d759e2017-04-09 16:34:541370 params.selection_start = new_info.selection_start;
1371 params.selection_end = new_info.selection_end;
1372 params.composition_start = new_info.composition_start;
1373 params.composition_end = new_info.composition_end;
fsamuel72464894f2015-12-15 06:59:311374 params.can_compose_inline = new_can_compose_inline;
changwan75e3b2072017-01-16 02:55:001375 // TODO(changwan): change instances of show_ime_if_needed to
1376 // show_virtual_keyboard.
1377 params.show_ime_if_needed = show_virtual_keyboard;
1378 params.reply_to_request = reply_to_request;
Albert J. Wong3c93c182018-09-27 17:29:431379 Send(new WidgetHostMsg_TextInputStateChanged(routing_id(), params));
fsamuel72464894f2015-12-15 06:59:311380
1381 text_input_info_ = new_info;
dglazkov97b6c2b2016-10-25 17:35:551382 text_input_type_ = new_type;
fsamuel72464894f2015-12-15 06:59:311383 text_input_mode_ = new_mode;
1384 can_compose_inline_ = new_can_compose_inline;
1385 text_input_flags_ = new_info.flags;
Eric Karl706ea6712018-12-21 22:41:381386
1387#if defined(OS_ANDROID)
1388 // If we send a new TextInputStateChanged message, we must also deliver a
1389 // new RenderFrameMetadata, as the IME will need this info to be updated.
1390 // TODO(ericrk): Consider folding the above IPC into RenderFrameMetadata.
1391 // https://crbug.com/912309
danakj125a29e2019-01-24 23:25:291392 if (IsSurfaceSynchronizationEnabled()) {
Eric Karl706ea6712018-12-21 22:41:381393 layer_tree_view_->RequestForceSendMetadata();
1394 }
1395#endif
fsamuel72464894f2015-12-15 06:59:311396 }
1397}
1398
1399bool RenderWidget::WillHandleGestureEvent(const blink::WebGestureEvent& event) {
paulmeyer6ef5a792016-11-08 20:33:581400 possible_drag_event_info_.event_source =
1401 ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH;
1402 possible_drag_event_info_.event_location =
Ella Ge1116059d2018-03-21 02:06:131403 gfx::ToFlooredPoint(event.PositionInScreen());
avid7d6b2e2016-03-04 19:41:171404
fsamuel72464894f2015-12-15 06:59:311405 return false;
1406}
1407
1408bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
ericwilligers88e69742016-10-17 19:29:551409 for (auto& observer : render_frames_)
1410 observer.RenderWidgetWillHandleMouseEvent();
lfge0c2792ec2016-05-11 18:52:081411
paulmeyer6ef5a792016-11-08 20:33:581412 possible_drag_event_info_.event_source =
1413 ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
1414 possible_drag_event_info_.event_location =
Blink Reformat1c4d759e2017-04-09 16:34:541415 gfx::Point(event.PositionInScreen().x, event.PositionInScreen().y);
paulmeyer6ef5a792016-11-08 20:33:581416
Albert J. Wong7bbf22d2018-12-20 00:27:271417 if (delegate())
1418 return delegate()->RenderWidgetWillHandleMouseEventForWidget(event);
avid7d6b2e2016-03-04 19:41:171419
fsamuel72464894f2015-12-15 06:59:311420 return false;
[email protected]fd847792013-10-24 17:12:351421}
1422
initial.commit09911bf2008-07-26 23:55:291423///////////////////////////////////////////////////////////////////////////////
mfomitchev2600fd7c2016-02-17 20:53:391424// RenderWidgetScreenMetricsDelegate
1425
bokanc63441c2016-04-27 15:49:121426void RenderWidget::ResizeWebWidget() {
danakja2c9d0a92018-07-25 20:01:181427 gfx::Size size = GetSizeForWebWidget();
Albert J. Wong7bbf22d2018-12-20 00:27:271428 if (delegate()) {
1429 delegate()->ResizeWebWidgetForWidget(size, top_controls_height_,
1430 bottom_controls_height_,
1431 browser_controls_shrink_blink_size_);
danakja2c9d0a92018-07-25 20:01:181432 return;
1433 }
1434 GetWebWidget()->Resize(size);
bokanc63441c2016-04-27 15:49:121435}
1436
1437gfx::Size RenderWidget::GetSizeForWebWidget() const {
danakj4b347212018-07-04 17:55:171438 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:031439 return gfx::ScaleToCeiledSize(size_,
1440 GetOriginalScreenInfo().device_scale_factor);
1441 }
bokanc63441c2016-04-27 15:49:121442
1443 return size_;
1444}
1445
akaba3483d8f2018-07-10 21:43:091446void RenderWidget::UpdateZoom(double zoom_level) {
akabac6bd1212018-06-25 20:10:481447 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1448 if (!frame_widget)
1449 return;
1450 RenderFrameImpl* render_frame =
1451 RenderFrameImpl::FromWebFrame(frame_widget->LocalRoot());
1452
akaba3483d8f2018-07-10 21:43:091453 // Return early if zoom level is unchanged.
1454 if (render_frame->GetZoomLevel() == zoom_level) {
akabac6bd1212018-06-25 20:10:481455 return;
1456 }
1457
akaba3483d8f2018-07-10 21:43:091458 render_frame->SetZoomLevel(zoom_level);
akabac6bd1212018-06-25 20:10:481459
1460 for (auto& observer : render_frame_proxies_)
akaba3483d8f2018-07-10 21:43:091461 observer.OnZoomLevelChanged(zoom_level);
akabac6bd1212018-06-25 20:10:481462
1463 for (auto& plugin : browser_plugins_)
akaba3483d8f2018-07-10 21:43:091464 plugin.OnZoomLevelChanged(zoom_level);
akabac6bd1212018-06-25 20:10:481465}
1466
Fady Samuel799e72192018-04-25 21:16:571467void RenderWidget::SynchronizeVisualProperties(const VisualProperties& params) {
Miguel Casas5e1018052018-01-09 19:17:361468
Fady Samuele62be402018-03-29 03:19:531469 gfx::Size new_compositor_viewport_pixel_size =
1470 params.auto_resize_enabled
1471 ? gfx::ScaleToCeiledSize(size_,
1472 params.screen_info.device_scale_factor)
1473 : params.compositor_viewport_pixel_size;
Fady Samuel84d8a1f72018-11-08 00:26:171474 UpdateSurfaceAndScreenInfo(params.local_surface_id_allocation.value_or(
1475 viz::LocalSurfaceIdAllocation()),
1476 new_compositor_viewport_pixel_size,
1477 params.screen_info);
Vladimir Levin98d76dad2018-04-21 00:21:291478 UpdateCaptureSequenceNumber(params.capture_sequence_number);
danakj125a29e2019-01-24 23:25:291479 layer_tree_view_->SetBrowserControlsHeight(
1480 params.top_controls_height, params.bottom_controls_height,
1481 params.browser_controls_shrink_blink_size);
mfomitchev2600fd7c2016-02-17 20:53:391482
akaba3483d8f2018-07-10 21:43:091483 UpdateZoom(params.zoom_level);
akabac6bd1212018-06-25 20:10:481484
danakj21604ce2018-12-19 16:01:221485 if (!params.auto_resize_enabled) {
1486 visible_viewport_size_ = params.visible_viewport_size;
danakj21604ce2018-12-19 16:01:221487 display_mode_ = params.display_mode;
danakj21604ce2018-12-19 16:01:221488 size_ = params.new_size;
mfomitchev2600fd7c2016-02-17 20:53:391489
danakj21604ce2018-12-19 16:01:221490 ResizeWebWidget();
mfomitchev2600fd7c2016-02-17 20:53:391491
danakjb4cec102019-01-30 19:22:131492 gfx::Size visual_viewport_size = visible_viewport_size_;
danakj21604ce2018-12-19 16:01:221493 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
danakjb4cec102019-01-30 19:22:131494 visual_viewport_size = gfx::ScaleToCeiledSize(
1495 visual_viewport_size, GetOriginalScreenInfo().device_scale_factor);
danakj21604ce2018-12-19 16:01:221496 }
1497 GetWebWidget()->ResizeVisualViewport(visual_viewport_size);
bokan71cb5b12016-04-27 03:45:221498
danakjf9284772019-01-23 18:29:141499 // NOTE: We may have entered fullscreen mode without changing our size.
1500 SetIsFullscreen(params.is_fullscreen_granted);
mfomitchev2600fd7c2016-02-17 20:53:391501 }
mfomitchev2600fd7c2016-02-17 20:53:391502}
1503
1504void RenderWidget::SetScreenMetricsEmulationParameters(
1505 bool enabled,
1506 const blink::WebDeviceEmulationParams& params) {
Albert J. Wong7bbf22d2018-12-20 00:27:271507 // This is only supported in RenderView, which has an delegate().
1508 DCHECK(delegate());
1509 delegate()->SetScreenMetricsEmulationParametersForWidget(enabled, params);
mfomitchev2600fd7c2016-02-17 20:53:391510}
1511
Albert J. Wong3c93c182018-09-27 17:29:431512void RenderWidget::SetScreenRects(const gfx::Rect& widget_screen_rect,
mfomitchev2600fd7c2016-02-17 20:53:391513 const gfx::Rect& window_screen_rect) {
Albert J. Wong3c93c182018-09-27 17:29:431514 widget_screen_rect_ = widget_screen_rect;
mfomitchev2600fd7c2016-02-17 20:53:391515 window_screen_rect_ = window_screen_rect;
1516}
1517
1518///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461519// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291520
Chris Harrelsond7ab99b2018-01-24 17:51:361521void RenderWidget::IntrinsicSizingInfoChanged(
1522 const blink::WebIntrinsicSizingInfo& sizing_info) {
Albert J. Wong3c93c182018-09-27 17:29:431523 Send(new WidgetHostMsg_IntrinsicSizingInfoChanged(routing_id_, sizing_info));
Chris Harrelsond7ab99b2018-01-24 17:51:361524}
1525
Blink Reformat1c4d759e2017-04-09 16:34:541526void RenderWidget::DidMeaningfulLayout(blink::WebMeaningfulLayout layout_type) {
1527 if (layout_type == blink::WebMeaningfulLayout::kVisuallyNonEmpty) {
Albert J. Wongfb64e142018-10-16 01:10:451528 QueueMessage(new WidgetHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_));
dglazkovf0e1d6d2015-10-10 02:13:481529 }
dglazkov79c426102015-08-31 21:22:431530
ericwilligers88e69742016-10-17 19:29:551531 for (auto& observer : render_frames_)
1532 observer.DidMeaningfulLayout(layout_type);
dglazkov79c426102015-08-31 21:22:431533}
1534
[email protected]586871b2014-07-22 17:05:111535// static
dchengcedca5612016-04-09 01:40:151536std::unique_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
[email protected]586871b2014-07-22 17:05:111537 IPC::Message* msg,
[email protected]586871b2014-07-22 17:05:111538 FrameSwapMessageQueue* frame_swap_message_queue,
1539 scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
[email protected]586871b2014-07-22 17:05:111540 int source_frame_number) {
[email protected]586871b2014-07-22 17:05:111541 bool first_message_for_frame = false;
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491542 frame_swap_message_queue->QueueMessageForFrame(
1543 source_frame_number, base::WrapUnique(msg), &first_message_for_frame);
[email protected]586871b2014-07-22 17:05:111544 if (first_message_for_frame) {
dchengcedca5612016-04-09 01:40:151545 std::unique_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
[email protected]586871b2014-07-22 17:05:111546 sync_message_filter, frame_swap_message_queue, source_frame_number));
dcheng4b6b5ff2014-10-16 00:42:061547 return promise;
[email protected]586871b2014-07-22 17:05:111548 }
dcheng4b6b5ff2014-10-16 00:42:061549 return nullptr;
[email protected]586871b2014-07-22 17:05:111550}
1551
danakj53802692018-07-25 21:46:441552void RenderWidget::SetHandlingInputEvent(bool handling_input_event) {
1553 input_handler_->set_handling_input_event(handling_input_event);
1554}
1555
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491556void RenderWidget::QueueMessage(IPC::Message* msg) {
danakj125a29e2019-01-24 23:25:291557 if (closing_)
1558 return;
1559
[email protected]586871b2014-07-22 17:05:111560 // RenderThreadImpl::current() is NULL in some tests.
danakj125a29e2019-01-24 23:25:291561 if (!RenderThreadImpl::current()) {
[email protected]586871b2014-07-22 17:05:111562 Send(msg);
1563 return;
1564 }
1565
dchengcedca5612016-04-09 01:40:151566 std::unique_ptr<cc::SwapPromise> swap_promise =
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491567 QueueMessageImpl(msg, frame_swap_message_queue_.get(),
[email protected]586871b2014-07-22 17:05:111568 RenderThreadImpl::current()->sync_message_filter(),
danakja6c10012018-07-06 14:25:361569 layer_tree_view_->GetSourceFrameNumber());
[email protected]586871b2014-07-22 17:05:111570
Ken Buchanance710eb2017-08-30 23:46:521571 if (swap_promise)
danakja6c10012018-07-06 14:25:361572 layer_tree_view_->QueueSwapPromise(std::move(swap_promise));
[email protected]586871b2014-07-22 17:05:111573}
1574
Blink Reformat1c4d759e2017-04-09 16:34:541575void RenderWidget::DidChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301576 // TODO(darin): Eliminate this temporary.
[email protected]9ec87712013-05-24 23:23:521577 WebCursor cursor;
tfarina75a0abf2015-10-06 15:07:181578 InitializeCursorFromWebCursorInfo(&cursor, cursor_info);
initial.commit09911bf2008-07-26 23:55:291579 // Only send a SetCursor message if we need to make a change.
Navid Zolghadr293bb862018-12-12 18:15:411580 if (input_handler_->DidChangeCursor(cursor))
Albert J. Wong3c93c182018-09-27 17:29:431581 Send(new WidgetHostMsg_SetCursor(routing_id_, cursor));
initial.commit09911bf2008-07-26 23:55:291582}
1583
aelias5971e47d2017-06-16 02:39:381584void RenderWidget::AutoscrollStart(const blink::WebFloatPoint& point) {
Albert J. Wong3c93c182018-09-27 17:29:431585 Send(new WidgetHostMsg_AutoscrollStart(routing_id_, point));
aelias5971e47d2017-06-16 02:39:381586}
1587
1588void RenderWidget::AutoscrollFling(const blink::WebFloatSize& velocity) {
Albert J. Wong3c93c182018-09-27 17:29:431589 Send(new WidgetHostMsg_AutoscrollFling(routing_id_, velocity));
aelias5971e47d2017-06-16 02:39:381590}
1591
1592void RenderWidget::AutoscrollEnd() {
Albert J. Wong3c93c182018-09-27 17:29:431593 Send(new WidgetHostMsg_AutoscrollEnd(routing_id_));
aelias5971e47d2017-06-16 02:39:381594}
1595
initial.commit09911bf2008-07-26 23:55:291596// We are supposed to get a single call to Show for a newly created RenderWidget
1597// that was created via RenderWidget::CreateWebView. So, we wait until this
1598// point to dispatch the ShowWidget message.
1599//
1600// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281601// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291602//
Blink Reformat1c4d759e2017-04-09 16:34:541603void RenderWidget::Show(WebNavigationPolicy policy) {
danakj65f423b72018-10-10 17:21:201604 if (!show_callback_) {
Albert J. Wong7bbf22d2018-12-20 00:27:271605 if (delegate()) {
danakja2c9d0a92018-07-25 20:01:181606 // When SupportsMultipleWindows is disabled, popups are reusing
danakj65f423b72018-10-10 17:21:201607 // the view's RenderWidget. In some scenarios, this makes blink to call
1608 // Show() twice. But otherwise, if it is enabled, we should not visit
1609 // Show() more than once.
Albert J. Wong7bbf22d2018-12-20 00:27:271610 DCHECK(!delegate()->SupportsMultipleWindowsForWidget());
danakj65f423b72018-10-10 17:21:201611 return;
danakja2c9d0a92018-07-25 20:01:181612 } else {
danakj65f423b72018-10-10 17:21:201613 NOTREACHED() << "received extraneous Show call";
danakja2c9d0a92018-07-25 20:01:181614 }
danakja2c9d0a92018-07-25 20:01:181615 }
1616
initial.commit09911bf2008-07-26 23:55:291617 DCHECK(routing_id_ != MSG_ROUTING_NONE);
nickf7b38222016-11-22 21:59:351618
1619 // The opener is responsible for actually showing this widget.
danakjdf1ceb72018-07-18 20:02:251620 std::move(show_callback_).Run(this, policy, initial_rect_);
nickf7b38222016-11-22 21:59:351621
bokanc007c3a2015-02-03 07:15:561622 // NOTE: initial_rect_ may still have its default values at this point, but
[email protected]8de12d942010-11-17 20:42:441623 // that's okay. It'll be ignored if as_popup is false, or the browser
1624 // process will impose a default position otherwise.
bokanc007c3a2015-02-03 07:15:561625 SetPendingWindowRect(initial_rect_);
initial.commit09911bf2008-07-26 23:55:291626}
1627
danakj17216f4d2018-10-16 22:57:321628LayerTreeView* RenderWidget::InitializeLayerTreeView() {
1629 TRACE_EVENT0("blink", "RenderWidget::InitializeLayerTreeView");
danakj17216f4d2018-10-16 22:57:321630
1631 layer_tree_view_ = std::make_unique<LayerTreeView>(
1632 this, compositor_deps_->GetCompositorMainThreadTaskRunner(),
1633 compositor_deps_->GetCompositorImplThreadTaskRunner(),
1634 compositor_deps_->GetTaskGraphRunner(),
1635 compositor_deps_->GetWebMainThreadScheduler());
1636 layer_tree_view_->Initialize(
danakj6dcbc5962018-11-16 16:45:421637 GenerateLayerTreeSettings(compositor_deps_, for_child_local_root_frame_,
danakj17216f4d2018-10-16 22:57:321638 screen_info_.rect.size(),
1639 screen_info_.device_scale_factor),
1640 compositor_deps_->CreateUkmRecorderFactory());
1641
Fady Samuel1c1ad3692018-11-06 23:28:401642 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
danakj17216f4d2018-10-16 22:57:321643 compositor_viewport_pixel_size_, screen_info_);
danakj17216f4d2018-10-16 22:57:321644 layer_tree_view_->SetContentSourceId(current_content_source_id_);
1645 // For background pages and certain tests, we don't want to trigger
1646 // LayerTreeFrameSink creation.
1647 bool should_generate_frame_sink =
1648 !compositor_never_visible_ && RenderThreadImpl::current();
danakje9be3162018-11-05 21:32:001649 if (!should_generate_frame_sink) {
1650 // Prevents SetVisible() from blink from doing anything.
danakj17216f4d2018-10-16 22:57:321651 layer_tree_view_->SetNeverVisible();
danakj6dcbc5962018-11-16 16:45:421652 } else if (!is_frozen_) {
danakje9be3162018-11-05 21:32:001653 // Begins the compositor's scheduler to start producing frames.
1654 // Don't do this if the RenderWidget is attached to a RenderViewImpl for a
danakjbc6ba9d22018-11-17 04:03:411655 // proxy main frame, as this RenderWidget is frozen then, and won't be
danakje9be3162018-11-05 21:32:001656 // used for compositing until a WebFrameWidget is attached.
1657 StartCompositor();
1658 }
danakj17216f4d2018-10-16 22:57:321659
danakj17216f4d2018-10-16 22:57:321660 DCHECK_NE(MSG_ROUTING_NONE, routing_id_);
1661 layer_tree_view_->SetFrameSinkId(
1662 viz::FrameSinkId(RenderThread::Get()->GetClientId(), routing_id_));
1663
1664 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1665 if (render_thread) {
1666 input_event_queue_ = base::MakeRefCounted<MainThreadEventQueue>(
1667 this, render_thread->GetWebMainThreadScheduler()->InputTaskRunner(),
1668 render_thread->GetWebMainThreadScheduler(), should_generate_frame_sink);
1669 }
1670
1671 return layer_tree_view_.get();
1672}
1673
danakjde8b7482018-11-15 23:45:021674void RenderWidget::StartCompositor() {
1675 if (!is_hidden_)
1676 layer_tree_view_->SetVisible(true);
1677}
1678
1679void RenderWidget::StopCompositor() {
1680 layer_tree_view_->SetVisible(false);
1681 // Drop all gpu resources, this makes SetVisible(true) more expensive/slower
1682 // but we don't expect to use this RenderWidget again until some possible
1683 // future navigation. This brings us a bit closer to emulating deleting the
1684 // RenderWidget instead of just stopping the compositor.
1685 layer_tree_view_->ReleaseLayerTreeFrameSink();
1686}
1687
danakj6dcbc5962018-11-16 16:45:421688void RenderWidget::SetIsFrozen(bool is_frozen) {
1689 DCHECK_NE(is_frozen, is_frozen_);
1690 is_frozen_ = is_frozen;
1691 if (is_frozen)
danakjde8b7482018-11-15 23:45:021692 StopCompositor();
1693 else
1694 StartCompositor();
1695}
1696
danakjf87460792018-12-04 20:14:221697void RenderWidget::WarmupCompositor() {
1698 DCHECK(is_frozen_);
1699
1700 // Tests have no RenderThreadImpl /o\.
1701 if (!RenderThreadImpl::current())
1702 return;
1703
1704 // Keeping things simple. This would cancel any outstanding warmup if we
1705 // happened to have one (this should be basically impossible). This avoids any
1706 // extra book keeping about the outstanding reqeust.
1707 warmup_weak_ptr_factory_.InvalidateWeakPtrs();
1708 // And if we already did a warmup then we're done.
1709 if (warmup_frame_sink_)
1710 return;
1711
1712 // Mark us pending the warmup frame sink *before* calling
1713 // DoRequestNewLayerTreeFrameSink() as it may run the reply callback
1714 // synchronously. So we don't want to change any state after the call
1715 // to DoRequestNewLayerTreeFrameSink() here.
1716 warmup_frame_sink_request_pending_ = true;
1717
1718 auto cb = base::BindOnce(&RenderWidget::OnReplyForWarmupCompositor,
1719 warmup_weak_ptr_factory_.GetWeakPtr());
1720 DoRequestNewLayerTreeFrameSink(std::move(cb));
1721}
1722
1723void RenderWidget::OnReplyForWarmupCompositor(
1724 std::unique_ptr<cc::LayerTreeFrameSink> sink) {
1725 warmup_frame_sink_request_pending_ = false;
1726
1727 if (after_warmup_callback_)
1728 std::move(after_warmup_callback_).Run(std::move(sink));
1729 else
1730 warmup_frame_sink_ = std::move(sink);
1731}
1732
1733void RenderWidget::AbortWarmupCompositor() {
1734 warmup_frame_sink_request_pending_ = false;
1735 // Drop any pending warmup.
1736 warmup_weak_ptr_factory_.InvalidateWeakPtrs();
1737 // And drop any completed one.
1738 warmup_frame_sink_.reset();
1739
1740 // If we had saved a callback to run after warmup, just do so now indicating
1741 // failure.
1742 if (after_warmup_callback_)
1743 std::move(after_warmup_callback_).Run(nullptr);
1744}
1745
[email protected]2533ce12009-05-09 00:02:241746void RenderWidget::DoDeferredClose() {
Albert J. Wong3c93c182018-09-27 17:29:431747 Send(new WidgetHostMsg_Close(routing_id_));
[email protected]2533ce12009-05-09 00:02:241748}
1749
Blink Reformat1c4d759e2017-04-09 16:34:541750void RenderWidget::CloseWidgetSoon() {
skyostiled8969c2015-07-20 16:57:081751 DCHECK(content::RenderThread::Get());
danakj6dcbc5962018-11-16 16:45:421752 if (is_frozen_) {
1753 // This widget is currently not active. The active main frame widget is in a
[email protected]e1c3a552012-05-04 20:51:321754 // different process. Have the browser route the close request to the
1755 // active widget instead, so that the correct unload handlers are run.
Albert J. Wongfb64e142018-10-16 01:10:451756 Send(new WidgetHostMsg_RouteCloseEvent(routing_id_));
[email protected]e1c3a552012-05-04 20:51:321757 return;
1758 }
1759
danakj292b63e2018-11-19 20:47:061760 // Prevent compositor from setting up new IPC channels, since we know a
1761 // WidgetMsg_Close is coming. We do this immediately, not in DoDeferredClose,
1762 // as the caller (eg WebPagePopupImpl) may start tearing down things after
1763 // calling this method, including detaching the frame from this RenderWidget.
1764 // Then trying to make a LayerTreeFrameSink would crash.
1765 // https://crbug.com/906340
1766 host_will_close_this_ = true;
1767
initial.commit09911bf2008-07-26 23:55:291768 // If a page calls window.close() twice, we'll end up here twice, but that's
1769 // OK. It is safe to send multiple Close messages.
danakj292b63e2018-11-19 20:47:061770 //
[email protected]2533ce12009-05-09 00:02:241771 // Ask the RenderWidgetHost to initiate close. We could be called from deep
1772 // in Javascript. If we ask the RendwerWidgetHost to close now, the window
1773 // could be closed before the JS finishes executing. So instead, post a
1774 // message back to the message loop, which won't run until the JS is
1775 // complete, and then the Close message can be sent.
Hajime Hoshi315a61f2018-08-14 17:27:281776 GetCleanupTaskRunner()->PostTask(
1777 FROM_HERE, base::BindOnce(&RenderWidget::DoDeferredClose, this));
initial.commit09911bf2008-07-26 23:55:291778}
1779
1780void RenderWidget::Close() {
danakj6dcbc5962018-11-16 16:45:421781 // This was done immediately in the |for_child_local_root_frame_| case in the
1782 // OnClose() IPC handler.
1783 if (!for_child_local_root_frame_)
danakj5c5269b2018-11-06 00:39:111784 CloseWebWidget();
1785
danakja6c10012018-07-06 14:25:361786 layer_tree_view_.reset();
Albert J. Wong7bbf22d2018-12-20 00:27:271787 if (delegate())
1788 delegate()->DidCloseWidget();
Albert J. Wongd593de532018-09-06 05:42:151789 // Note the ACK is a control message going to the RenderProcessHost.
Albert J. Wong3c93c182018-09-27 17:29:431790 RenderThread::Get()->Send(new WidgetHostMsg_Close_ACK(routing_id()));
Ken Buchananed449bb2018-02-01 21:02:051791}
1792
1793void RenderWidget::CloseWebWidget() {
danakj35314ab2018-10-19 16:37:341794 // If the browser has not sent OnDisableDeviceEmulation, we have an emulator
1795 // hanging out still. Destroying it must happen *after* the IPC route is
1796 // removed so that another IPC does not arrive and re-create the emulator
1797 // during closing.
1798 //
1799 // This destruction is normally part of an IPC and expects objects to be alive
1800 // that would be alive while the IPC route is active such as the
1801 // |layer_tree_view_|. So we ensure that it is the first thing to be
1802 // destroyed here before deleting things from the RenderWidget or the
Albert J. Wong7bbf22d2018-12-20 00:27:271803 // delegate().
danakj35314ab2018-10-19 16:37:341804 //
1805 // TODO(danakj): The emulator could reset to non-emulated values in an
1806 // explicit method call (instead of in the destructor) that occurs when
1807 // emulation is disabled, but does not need to occur during RenderWidget
1808 // closing. Then we would not have to destroy this so carefully.
1809 screen_metrics_emulator_.reset();
1810
danakj5c5269b2018-11-06 00:39:111811 // Informs the WebWidget that compositor is being destroyed, so it can remove
1812 // references to it first.
1813 //
Albert J. Wong7bbf22d2018-12-20 00:27:271814 // When delegate() is present, the RenderWidget is for a main frame,
danakj5c5269b2018-11-06 00:39:111815 // and the GetWebWidget() is not the same as |webwidget_internal_|. However
1816 // that widget is responsible for doing WillCloseLayerTreeView() on the
1817 // |webwidget_internal_|, not us. Otherwise, they are the same and this is
1818 // notifying |webwidget_internal_|.
1819 GetWebWidget()->WillCloseLayerTreeView();
1820
Albert J. Wong7bbf22d2018-12-20 00:27:271821 // While the wrapping WebWidget from an delegate() is responsible for
danakj5c5269b2018-11-06 00:39:111822 // doing WillCloseLayerTreeView() on the |webwidget_internal_|, this class is
1823 // responsible for calling Close() on it. Notably, then, the wrapping
1824 // WebWidget does not.
1825 webwidget_internal_->Close();
1826 webwidget_internal_ = nullptr;
initial.commit09911bf2008-07-26 23:55:291827}
1828
Mitsuru Oshima3c07b332018-02-06 04:56:501829void RenderWidget::UpdateWebViewWithDeviceScaleFactor() {
1830 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1831 blink::WebFrame* current_frame =
1832 frame_widget ? frame_widget->LocalRoot() : nullptr;
1833 blink::WebView* webview = current_frame ? current_frame->View() : nullptr;
1834 if (webview) {
danakj4b347212018-07-04 17:55:171835 if (compositor_deps_->IsUseZoomForDSFEnabled())
Fady Samuela863f152018-03-09 16:10:031836 webview->SetZoomFactorForDeviceScaleFactor(
1837 GetWebScreenInfo().device_scale_factor);
Mitsuru Oshima3c07b332018-02-06 04:56:501838 else
Fady Samuela863f152018-03-09 16:10:031839 webview->SetDeviceScaleFactor(GetWebScreenInfo().device_scale_factor);
Mitsuru Oshima3c07b332018-02-06 04:56:501840
1841 webview->GetSettings()->SetPreferCompositingToLCDTextEnabled(
Christopher Camerone9a30c12018-03-07 08:23:381842 PreferCompositingToLCDText(compositor_deps_,
Fady Samuela863f152018-03-09 16:10:031843 GetWebScreenInfo().device_scale_factor));
Mitsuru Oshima3c07b332018-02-06 04:56:501844 }
1845}
1846
Ehsan Karamad655d7b8a2018-01-12 18:38:381847blink::WebFrameWidget* RenderWidget::GetFrameWidget() const {
danakj89ae4532018-12-12 22:52:551848 // TODO(danakj): Remove this check and don't call this method for non-frames.
1849 if (!for_frame())
1850 return nullptr;
1851 // TODO(danakj): Is this needed? IPCs stop after closing, but code used to
1852 // check for a null WebWidget.
1853 if (closing_)
Ehsan Karamad655d7b8a2018-01-12 18:38:381854 return nullptr;
1855
danakj89ae4532018-12-12 22:52:551856 blink::WebWidget* widget;
Albert J. Wong7bbf22d2018-12-20 00:27:271857 if (delegate()) {
danakj89ae4532018-12-12 22:52:551858 // Main frame WebFrameWidgets are held by the delegate, the internal widget
1859 // points directly to the WebView.
1860 // TODO(ekaramad): We should drop IPCs when |is_frozen_| instead of
1861 // handling them and finding a null here. However there is also the case
1862 // of the frame being detached without the widget being frozen to be
1863 // resolved (https://crbug.com/906340). So for now this can return null.
Albert J. Wong7bbf22d2018-12-20 00:27:271864 widget = delegate()->GetWebWidgetForWidget();
danakj89ae4532018-12-12 22:52:551865 } else {
1866 // Subframes always have a WebFrameWidget themselves.
1867 widget = webwidget_internal_;
Ehsan Karamad655d7b8a2018-01-12 18:38:381868 }
danakj89ae4532018-12-12 22:52:551869 return static_cast<blink::WebFrameWidget*>(widget);
Ehsan Karamad655d7b8a2018-01-12 18:38:381870}
1871
bokan841fdc72016-10-06 00:16:351872void RenderWidget::ScreenRectToEmulatedIfNeeded(WebRect* window_rect) const {
1873 DCHECK(window_rect);
1874 float scale = popup_origin_scale_for_emulation_;
1875 if (!scale)
1876 return;
1877 window_rect->x =
1878 popup_view_origin_for_emulation_.x() +
1879 (window_rect->x - popup_screen_origin_for_emulation_.x()) / scale;
1880 window_rect->y =
1881 popup_view_origin_for_emulation_.y() +
1882 (window_rect->y - popup_screen_origin_for_emulation_.y()) / scale;
1883}
1884
1885void RenderWidget::EmulatedToScreenRectIfNeeded(WebRect* window_rect) const {
1886 DCHECK(window_rect);
1887 float scale = popup_origin_scale_for_emulation_;
1888 if (!scale)
1889 return;
1890 window_rect->x =
1891 popup_screen_origin_for_emulation_.x() +
1892 (window_rect->x - popup_view_origin_for_emulation_.x()) * scale;
1893 window_rect->y =
1894 popup_screen_origin_for_emulation_.y() +
1895 (window_rect->y - popup_view_origin_for_emulation_.y()) * scale;
1896}
1897
Blink Reformat1c4d759e2017-04-09 16:34:541898WebRect RenderWidget::WindowRect() {
bokan841fdc72016-10-06 00:16:351899 WebRect rect;
bokan6b08cd22016-10-05 00:55:211900 if (pending_window_rect_count_) {
1901 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
1902 // the RootWindowRect is probably going to return wrong results since the
1903 // browser may not have processed the Move yet. There isn't really anything
1904 // good to do in this case, and it shouldn't happen - since this size is
1905 // only really needed for windowToScreen, which is only used for Popups.
bokan841fdc72016-10-06 00:16:351906 rect = pending_window_rect_;
1907 } else {
1908 rect = window_screen_rect_;
bokan6b08cd22016-10-05 00:55:211909 }
[email protected]2533ce12009-05-09 00:02:241910
bokan841fdc72016-10-06 00:16:351911 ScreenRectToEmulatedIfNeeded(&rect);
1912 return rect;
bokan6b08cd22016-10-05 00:55:211913}
1914
Blink Reformat1c4d759e2017-04-09 16:34:541915WebRect RenderWidget::ViewRect() {
Albert J. Wong3c93c182018-09-27 17:29:431916 WebRect rect = widget_screen_rect_;
bokan841fdc72016-10-06 00:16:351917 ScreenRectToEmulatedIfNeeded(&rect);
1918 return rect;
initial.commit09911bf2008-07-26 23:55:291919}
1920
Blink Reformat1c4d759e2017-04-09 16:34:541921void RenderWidget::SetToolTipText(const blink::WebString& text,
[email protected]8a9d6ca32011-06-06 20:11:301922 WebTextDirection hint) {
Albert J. Wong3c93c182018-09-27 17:29:431923 Send(new WidgetHostMsg_SetTooltipText(routing_id_, text.Utf16(), hint));
[email protected]8a9d6ca32011-06-06 20:11:301924}
1925
Blink Reformat1c4d759e2017-04-09 16:34:541926void RenderWidget::SetWindowRect(const WebRect& rect_in_screen) {
danakj81d601e62018-10-09 22:15:051927 // This path is for the renderer to change the on-screen position/size of
1928 // the widget by changing its window rect. This is not possible for
1929 // RenderWidgets whose position/size are controlled by layout from another
danakj6dcbc5962018-11-16 16:45:421930 // frame tree (ie. child local root frames), as the window rect can only be
1931 // set by the browser.
1932 if (for_child_local_root_frame_)
danakj81d601e62018-10-09 22:15:051933 return;
1934
oshima33ec97cd2015-12-14 19:40:241935 WebRect window_rect = rect_in_screen;
bokan841fdc72016-10-06 00:16:351936 EmulatedToScreenRectIfNeeded(&window_rect);
[email protected]b2e4c70132013-10-03 02:07:511937
danakj65f423b72018-10-10 17:21:201938 if (resizing_mode_selector_->is_synchronous_mode()) {
Kent Tamura21d1de62018-12-10 04:45:201939 // This is a web-test-only path. At one point, it was planned to be
danakj65f423b72018-10-10 17:21:201940 // removed. See https://crbug.com/309760.
bokanc007c3a2015-02-03 07:15:561941 SetWindowRectSynchronously(window_rect);
danakj65f423b72018-10-10 17:21:201942 return;
1943 }
1944
1945 if (show_callback_) {
1946 // The widget is not shown yet. Delay the |window_rect| being sent to the
1947 // browser until Show() is called so it can be sent with that IPC, once the
1948 // browser is ready for the info.
1949 initial_rect_ = window_rect;
1950 } else {
1951 Send(new WidgetHostMsg_RequestSetBounds(routing_id_, window_rect));
1952 SetPendingWindowRect(window_rect);
initial.commit09911bf2008-07-26 23:55:291953 }
1954}
1955
[email protected]2533ce12009-05-09 00:02:241956void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
1957 pending_window_rect_ = rect;
1958 pending_window_rect_count_++;
[email protected]2533ce12009-05-09 00:02:241959
bokan6b08cd22016-10-05 00:55:211960 // Popups don't get size updates back from the browser so just store the set
1961 // values.
danakj89ae4532018-12-12 22:52:551962 if (!for_frame()) {
Blink Reformat1c4d759e2017-04-09 16:34:541963 window_screen_rect_ = rect;
Albert J. Wong3c93c182018-09-27 17:29:431964 widget_screen_rect_ = rect;
[email protected]2533ce12009-05-09 00:02:241965 }
[email protected]d4547452008-08-28 18:36:371966}
1967
wjmacleanee244e02017-05-26 21:06:071968void RenderWidget::OnShowContextMenu(ui::MenuSourceType source_type,
1969 const gfx::Point& location) {
wjmacleanee244e02017-05-26 21:06:071970 has_host_context_menu_location_ = true;
1971 host_context_menu_location_ = location;
1972 if (GetWebWidget()) {
1973 GetWebWidget()->ShowContextMenu(
1974 static_cast<blink::WebMenuSourceType>(source_type));
1975 }
1976 has_host_context_menu_location_ = false;
1977}
1978
[email protected]fa7b1dc2010-06-23 17:53:041979void RenderWidget::OnImeSetComposition(
[email protected]fcf75d42013-12-03 20:11:261980 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:111981 const std::vector<WebImeTextSpan>& ime_text_spans,
chongz7eb752802016-01-27 21:28:071982 const gfx::Range& replacement_range,
Ryan Landay9e42fd742017-08-12 01:59:111983 int selection_start,
1984 int selection_end) {
ekaramad5aff1942017-01-06 01:26:351985 if (!ShouldHandleImeEvents())
1986 return;
1987
brettw4b461082016-11-19 18:55:161988#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:491989 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
Ryan Landay9e42fd742017-08-12 01:59:111990 plugin->render_frame()->OnImeSetComposition(text, ime_text_spans,
EhsanK22d482e2017-08-10 17:29:491991 selection_start, selection_end);
ekaramad2a46d632016-07-19 13:33:091992 return;
1993 }
1994#endif
[email protected]66fca5bc2013-05-23 06:58:291995 ImeEventGuard guard(this);
ekaramad2daaf672016-11-10 20:29:011996 blink::WebInputMethodController* controller = GetInputMethodController();
ekaramad2daaf672016-11-10 20:29:011997 if (!controller ||
Blink Reformat1c4d759e2017-04-09 16:34:541998 !controller->SetComposition(
Ryan Landay9e42fd742017-08-12 01:59:111999 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:562000 replacement_range.IsValid()
2001 ? WebRange(replacement_range.start(), replacement_range.length())
2002 : WebRange(),
2003 selection_start, selection_end)) {
[email protected]fa7b1dc2010-06-23 17:53:042004 // If we failed to set the composition text, then we need to let the browser
2005 // process to cancel the input method's ongoing composition session, to make
2006 // sure we are in a consistent state.
Dave Tapuska04bc5ee92018-04-17 19:03:312007 if (mojom::WidgetInputHandlerHost* host =
2008 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
2009 host->ImeCancelComposition();
Dave Tapuska139a72f2017-09-06 21:57:032010 }
[email protected]7f00efa2010-04-15 05:01:262011 }
nonafa291792016-08-10 02:36:182012 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]fa7b1dc2010-06-23 17:53:042013}
2014
rlanday7efe2302017-01-11 00:14:282015void RenderWidget::OnImeCommitText(
2016 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:112017 const std::vector<WebImeTextSpan>& ime_text_spans,
rlanday7efe2302017-01-11 00:14:282018 const gfx::Range& replacement_range,
2019 int relative_cursor_pos) {
ekaramad5aff1942017-01-06 01:26:352020 if (!ShouldHandleImeEvents())
2021 return;
2022
brettw4b461082016-11-19 18:55:162023#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492024 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
2025 plugin->render_frame()->OnImeCommitText(text, replacement_range,
2026 relative_cursor_pos);
ekaramad2a46d632016-07-19 13:33:092027 return;
2028 }
2029#endif
[email protected]66fca5bc2013-05-23 06:58:292030 ImeEventGuard guard(this);
fsamuele8326c742016-01-12 00:49:392031 input_handler_->set_handling_input_event(true);
ekaramadb6483a052017-02-10 02:23:262032 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:542033 controller->CommitText(
Ryan Landay9e42fd742017-08-12 01:59:112034 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:562035 replacement_range.IsValid()
2036 ? WebRange(replacement_range.start(), replacement_range.length())
2037 : WebRange(),
2038 relative_cursor_pos);
ekaramadb6483a052017-02-10 02:23:262039 }
aelias87b8f7c2016-09-14 03:19:292040 input_handler_->set_handling_input_event(false);
2041 UpdateCompositionInfo(false /* not an immediate request */);
2042}
2043
2044void RenderWidget::OnImeFinishComposingText(bool keep_selection) {
ekaramad5aff1942017-01-06 01:26:352045 if (!ShouldHandleImeEvents())
2046 return;
2047
brettw4b461082016-11-19 18:55:162048#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492049 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
2050 plugin->render_frame()->OnImeFinishComposingText(keep_selection);
aelias87b8f7c2016-09-14 03:19:292051 return;
2052 }
2053#endif
2054
changwan38c3eb612016-12-09 01:45:562055 if (!GetWebWidget())
aelias87b8f7c2016-09-14 03:19:292056 return;
2057 ImeEventGuard guard(this);
2058 input_handler_->set_handling_input_event(true);
ekaramad2daaf672016-11-10 20:29:012059 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:542060 controller->FinishComposingText(
2061 keep_selection ? WebInputMethodController::kKeepSelection
2062 : WebInputMethodController::kDoNotKeepSelection);
ekaramad2daaf672016-11-10 20:29:012063 }
fsamuele8326c742016-01-12 00:49:392064 input_handler_->set_handling_input_event(false);
nonafa291792016-08-10 02:36:182065 UpdateCompositionInfo(false /* not an immediate request */);
initial.commit09911bf2008-07-26 23:55:292066}
2067
Christopher Camerone9a30c12018-03-07 08:23:382068void RenderWidget::UpdateSurfaceAndScreenInfo(
Fady Samuel1c1ad3692018-11-06 23:28:402069 const viz::LocalSurfaceIdAllocation& new_local_surface_id_allocation,
Christopher Cameronaad15a0d2018-03-09 03:47:332070 const gfx::Size& new_compositor_viewport_pixel_size,
Christopher Camerone9a30c12018-03-07 08:23:382071 const ScreenInfo& new_screen_info) {
Christopher Camerone9a30c12018-03-07 08:23:382072 bool orientation_changed =
2073 screen_info_.orientation_angle != new_screen_info.orientation_angle ||
2074 screen_info_.orientation_type != new_screen_info.orientation_type;
2075 bool web_device_scale_factor_changed =
2076 screen_info_.device_scale_factor != new_screen_info.device_scale_factor;
Fady Samuela863f152018-03-09 16:10:032077 ScreenInfo previous_original_screen_info = GetOriginalScreenInfo();
Christopher Cameronbe7ecea2018-02-27 00:47:192078
Fady Samuel1c1ad3692018-11-06 23:28:402079 local_surface_id_allocation_from_parent_ = new_local_surface_id_allocation;
Christopher Cameronaad15a0d2018-03-09 03:47:332080 compositor_viewport_pixel_size_ = new_compositor_viewport_pixel_size;
Christopher Camerone9a30c12018-03-07 08:23:382081 screen_info_ = new_screen_info;
Christopher Cameronbe7ecea2018-02-27 00:47:192082
danakj125a29e2019-01-24 23:25:292083 layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect());
2084 // Note carefully that the DSF specified in |new_screen_info| is not the
2085 // DSF used by the compositor during device emulation!
2086 layer_tree_view_->SetViewportSizeAndScale(
2087 compositor_viewport_pixel_size_,
2088 GetOriginalScreenInfo().device_scale_factor,
2089 local_surface_id_allocation_from_parent_);
danakj04d128a2019-01-25 02:10:202090 layer_tree_view_->SetRasterColorSpace(
2091 screen_info_.color_space.GetRasterColorSpace());
Christopher Cameronbe7ecea2018-02-27 00:47:192092
Christopher Camerone9a30c12018-03-07 08:23:382093 if (orientation_changed)
2094 OnOrientationChange();
Christopher Cameronbe7ecea2018-02-27 00:47:192095
Fady Samuela863f152018-03-09 16:10:032096 if (previous_original_screen_info != GetOriginalScreenInfo()) {
Christopher Camerone9a30c12018-03-07 08:23:382097 for (auto& observer : render_frame_proxies_)
Fady Samuela863f152018-03-09 16:10:032098 observer.OnScreenInfoChanged(GetOriginalScreenInfo());
Christopher Camerone9a30c12018-03-07 08:23:382099
2100 // Notify all embedded BrowserPlugins of the updated ScreenInfo.
2101 for (auto& observer : browser_plugins_)
Fady Samuela863f152018-03-09 16:10:032102 observer.ScreenInfoChanged(GetOriginalScreenInfo());
Christopher Camerone9a30c12018-03-07 08:23:382103 }
2104
2105 if (web_device_scale_factor_changed)
Christopher Cameronbe7ecea2018-02-27 00:47:192106 UpdateWebViewWithDeviceScaleFactor();
oshimad5279032015-12-16 18:22:332107}
2108
danakja2c9d0a92018-07-25 20:01:182109void RenderWidget::SetWindowRectSynchronously(
2110 const gfx::Rect& new_window_rect) {
2111 VisualProperties visual_properties;
2112 visual_properties.screen_info = screen_info_;
2113 visual_properties.new_size = new_window_rect.size();
2114 visual_properties.compositor_viewport_pixel_size = gfx::ScaleToCeiledSize(
2115 new_window_rect.size(), GetWebScreenInfo().device_scale_factor);
2116 visual_properties.visible_viewport_size = new_window_rect.size();
2117 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
2118 visual_properties.display_mode = display_mode_;
Fady Samuel84d8a1f72018-11-08 00:26:172119 visual_properties.local_surface_id_allocation =
2120 local_surface_id_allocation_from_parent_;
danakja2c9d0a92018-07-25 20:01:182121 // We are resizing the window from the renderer, so allocate a new
2122 // viz::LocalSurfaceId to avoid surface invariants violations in tests.
danakj125a29e2019-01-24 23:25:292123 layer_tree_view_->RequestNewLocalSurfaceId();
danakja2c9d0a92018-07-25 20:01:182124 SynchronizeVisualProperties(visual_properties);
2125
Albert J. Wong3c93c182018-09-27 17:29:432126 widget_screen_rect_ = new_window_rect;
danakja2c9d0a92018-07-25 20:01:182127 window_screen_rect_ = new_window_rect;
danakj65f423b72018-10-10 17:21:202128 if (show_callback_) {
2129 // Tests may call here directly to control the window rect. If
2130 // Show() did not happen yet, the rect is stored to be passed to the
2131 // browser when the RenderWidget requests Show().
danakja2c9d0a92018-07-25 20:01:182132 initial_rect_ = new_window_rect;
danakj65f423b72018-10-10 17:21:202133 }
danakja2c9d0a92018-07-25 20:01:182134}
2135
Vladimir Levin98d76dad2018-04-21 00:21:292136void RenderWidget::UpdateCaptureSequenceNumber(
2137 uint32_t capture_sequence_number) {
2138 if (capture_sequence_number == last_capture_sequence_number_)
2139 return;
2140 last_capture_sequence_number_ = capture_sequence_number;
2141
2142 // Notify observers of the new capture sequence number.
2143 for (auto& observer : render_frame_proxies_)
2144 observer.UpdateCaptureSequenceNumber(capture_sequence_number);
2145 for (auto& observer : browser_plugins_)
2146 observer.UpdateCaptureSequenceNumber(capture_sequence_number);
2147}
2148
[email protected]4873c7d2009-07-16 06:36:282149void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
EhsanK955ba582017-11-30 21:14:402150 if (auto* frame = GetFocusedWebLocalFrameInWidget())
2151 frame->SetTextDirection(direction);
[email protected]07f953332009-03-25 04:31:112152}
2153
Albert J. Wong3c93c182018-09-27 17:29:432154void RenderWidget::OnUpdateScreenRects(const gfx::Rect& widget_screen_rect,
[email protected]80ad8622012-11-07 16:33:032155 const gfx::Rect& window_screen_rect) {
[email protected]b2e4c70132013-10-03 02:07:512156 if (screen_metrics_emulator_) {
Albert J. Wong3c93c182018-09-27 17:29:432157 screen_metrics_emulator_->OnUpdateScreenRects(widget_screen_rect,
mfomitchev2600fd7c2016-02-17 20:53:392158 window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:512159 } else {
Albert J. Wong3c93c182018-09-27 17:29:432160 SetScreenRects(widget_screen_rect, window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:512161 }
Albert J. Wong3c93c182018-09-27 17:29:432162 Send(new WidgetHostMsg_UpdateScreenRects_ACK(routing_id()));
[email protected]80ad8622012-11-07 16:33:032163}
2164
kenrbea731792017-01-13 15:10:482165void RenderWidget::OnSetViewportIntersection(
Ken Buchananb2c9e262018-03-10 16:53:312166 const gfx::Rect& viewport_intersection,
Stefan Zager54e25832018-08-14 22:15:312167 const gfx::Rect& compositor_visible_rect,
2168 bool occluded_or_obscured) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252169 if (auto* frame_widget = GetFrameWidget()) {
Ken Buchananb2c9e262018-03-10 16:53:312170 compositor_visible_rect_ = compositor_visible_rect;
Stefan Zager54e25832018-08-14 22:15:312171 frame_widget->SetRemoteViewportIntersection(viewport_intersection,
2172 occluded_or_obscured);
danakja6c10012018-07-06 14:25:362173 layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect());
kenrbea731792017-01-13 15:10:482174 }
2175}
2176
kenrb04323782017-06-23 01:23:322177void RenderWidget::OnSetIsInert(bool inert) {
danakj89ae4532018-12-12 22:52:552178 if (auto* frame_widget = GetFrameWidget())
Ehsan Karamadf3ca2a82018-01-20 01:05:252179 frame_widget->SetIsInert(inert);
kenrb04323782017-06-23 01:23:322180}
2181
sunxd540a9962018-05-24 22:51:062182void RenderWidget::OnSetInheritedEffectiveTouchAction(
2183 cc::TouchAction touch_action) {
danakj89ae4532018-12-12 22:52:552184 if (auto* frame_widget = GetFrameWidget())
sunxd540a9962018-05-24 22:51:062185 frame_widget->SetInheritedEffectiveTouchAction(touch_action);
sunxd540a9962018-05-24 22:51:062186}
2187
Ken Buchanan8a319fb2017-11-15 18:37:122188void RenderWidget::OnUpdateRenderThrottlingStatus(bool is_throttled,
2189 bool subtree_throttled) {
danakj89ae4532018-12-12 22:52:552190 if (auto* frame_widget = GetFrameWidget())
Ehsan Karamadf3ca2a82018-01-20 01:05:252191 frame_widget->UpdateRenderThrottlingStatus(is_throttled, subtree_throttled);
Ken Buchanan8a319fb2017-11-15 18:37:122192}
2193
paulmeyer90f6c31d2016-11-12 00:17:592194void RenderWidget::OnDragTargetDragEnter(
2195 const std::vector<DropData::Metadata>& drop_meta_data,
Ella Ge80a52dce2017-11-15 18:01:522196 const gfx::PointF& client_point,
2197 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592198 WebDragOperationsMask ops,
2199 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252200 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2201 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592202 return;
2203
Ehsan Karamadf3ca2a82018-01-20 01:05:252204 WebDragOperation operation = frame_widget->DragTargetDragEnter(
2205 DropMetaDataToWebDragData(drop_meta_data), client_point, screen_point,
2206 ops, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592207
2208 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
2209}
2210
Ella Ge80a52dce2017-11-15 18:01:522211void RenderWidget::OnDragTargetDragOver(const gfx::PointF& client_point,
2212 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592213 WebDragOperationsMask ops,
2214 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252215 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2216 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592217 return;
2218
Ehsan Karamadf3ca2a82018-01-20 01:05:252219 WebDragOperation operation = frame_widget->DragTargetDragOver(
2220 ConvertWindowPointToViewport(client_point), screen_point, ops,
2221 key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592222
2223 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
2224}
2225
Ella Ge80a52dce2017-11-15 18:01:522226void RenderWidget::OnDragTargetDragLeave(const gfx::PointF& client_point,
2227 const gfx::PointF& screen_point) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252228 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2229 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592230 return;
Ehsan Karamadf3ca2a82018-01-20 01:05:252231
2232 frame_widget
Blink Reformat1c4d759e2017-04-09 16:34:542233 ->DragTargetDragLeave(ConvertWindowPointToViewport(client_point),
kenrb07c272802017-02-07 23:48:172234 screen_point);
paulmeyer90f6c31d2016-11-12 00:17:592235}
2236
2237void RenderWidget::OnDragTargetDrop(const DropData& drop_data,
Ella Ge80a52dce2017-11-15 18:01:522238 const gfx::PointF& client_point,
2239 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592240 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252241 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2242 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592243 return;
2244
Ehsan Karamadf3ca2a82018-01-20 01:05:252245 frame_widget->DragTargetDrop(DropDataToWebDragData(drop_data),
2246 ConvertWindowPointToViewport(client_point),
2247 screen_point, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592248}
2249
Ella Ge80a52dce2017-11-15 18:01:522250void RenderWidget::OnDragSourceEnded(const gfx::PointF& client_point,
2251 const gfx::PointF& screen_point,
paulmeyer8fc8ea92016-11-15 05:12:212252 WebDragOperation op) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252253 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2254 if (!frame_widget)
paulmeyer8fc8ea92016-11-15 05:12:212255 return;
2256
Ehsan Karamadf3ca2a82018-01-20 01:05:252257 frame_widget->DragSourceEndedAt(ConvertWindowPointToViewport(client_point),
2258 screen_point, op);
paulmeyer8fc8ea92016-11-15 05:12:212259}
2260
2261void RenderWidget::OnDragSourceSystemDragEnded() {
danakj503545c2019-01-11 19:03:092262 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2263 if (!frame_widget)
paulmeyer8fc8ea92016-11-15 05:12:212264 return;
2265
danakj503545c2019-01-11 19:03:092266 frame_widget->DragSourceSystemDragEnded();
paulmeyer8fc8ea92016-11-15 05:12:212267}
2268
Blink Reformat1c4d759e2017-04-09 16:34:542269void RenderWidget::ShowVirtualKeyboardOnElementFocus() {
okaa398f50b2017-03-21 06:30:262270#if defined(OS_CHROMEOS)
2271 // On ChromeOS, virtual keyboard is triggered only when users leave the
2272 // mouse button or the finger and a text input element is focused at that
2273 // time. Focus event itself shouldn't trigger virtual keyboard.
2274 UpdateTextInputState();
2275#else
changwan75e3b2072017-01-16 02:55:002276 ShowVirtualKeyboard();
okaa398f50b2017-03-21 06:30:262277#endif
boliu7b2be2f2016-11-04 04:58:312278
2279// TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
2280// virtual keyboard.
2281#if !defined(OS_ANDROID)
2282 FocusChangeComplete();
2283#endif
[email protected]0d1ebed12013-08-05 22:01:132284}
2285
fsamuel72464894f2015-12-15 06:59:312286ui::TextInputType RenderWidget::GetTextInputType() {
brettw4b461082016-11-19 18:55:162287#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492288 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2289 return plugin->text_input_type();
ekaramad2a46d632016-07-19 13:33:092290#endif
ekaramad5aff1942017-01-06 01:26:352291 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:542292 return ConvertWebTextInputType(controller->TextInputType());
fsamuel72464894f2015-12-15 06:59:312293 return ui::TEXT_INPUT_TYPE_NONE;
2294}
2295
nonafa291792016-08-10 02:36:182296void RenderWidget::UpdateCompositionInfo(bool immediate_request) {
2297 if (!monitor_composition_info_ && !immediate_request)
2298 return; // Do not calculate composition info if not requested.
nonadac0c7a2016-08-01 02:30:592299
nonafa291792016-08-10 02:36:182300 TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo");
2301 gfx::Range range;
2302 std::vector<gfx::Rect> character_bounds;
2303
2304 if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE) {
2305 // Composition information is only available on editable node.
2306 range = gfx::Range::InvalidRange();
2307 } else {
2308 GetCompositionRange(&range);
2309 GetCompositionCharacterBounds(&character_bounds);
2310 }
2311
2312 if (!immediate_request &&
2313 !ShouldUpdateCompositionInfo(range, character_bounds)) {
fsamuel72464894f2015-12-15 06:59:312314 return;
nonafa291792016-08-10 02:36:182315 }
fsamuel72464894f2015-12-15 06:59:312316 composition_character_bounds_ = character_bounds;
2317 composition_range_ = range;
Dave Tapuska04bc5ee92018-04-17 19:03:312318 if (mojom::WidgetInputHandlerHost* host =
2319 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
2320 host->ImeCompositionRangeChanged(composition_range_,
2321 composition_character_bounds_);
Dave Tapuska139a72f2017-09-06 21:57:032322 }
fsamuel72464894f2015-12-15 06:59:312323}
2324
Blink Reformat1c4d759e2017-04-09 16:34:542325void RenderWidget::ConvertViewportToWindow(blink::WebRect* rect) {
danakj4b347212018-07-04 17:55:172326 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:032327 float reverse = 1 / GetOriginalScreenInfo().device_scale_factor;
oshimad5279032015-12-16 18:22:332328 // TODO(oshima): We may need to allow pixel precision here as the the
oshimaf866dab2015-12-05 00:41:542329 // anchor element can be placed at half pixel.
lfg15b235a32016-08-25 17:45:462330 gfx::Rect window_rect =
2331 gfx::ScaleToEnclosedRect(gfx::Rect(*rect), reverse);
2332 rect->x = window_rect.x();
2333 rect->y = window_rect.y();
2334 rect->width = window_rect.width();
2335 rect->height = window_rect.height();
oshimaf866dab2015-12-05 00:41:542336 }
2337}
2338
Blink Reformat1c4d759e2017-04-09 16:34:542339void RenderWidget::ConvertWindowToViewport(blink::WebFloatRect* rect) {
danakj4b347212018-07-04 17:55:172340 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:032341 rect->x *= GetOriginalScreenInfo().device_scale_factor;
2342 rect->y *= GetOriginalScreenInfo().device_scale_factor;
2343 rect->width *= GetOriginalScreenInfo().device_scale_factor;
2344 rect->height *= GetOriginalScreenInfo().device_scale_factor;
oshimaa6985b62016-01-27 08:58:302345 }
2346}
2347
changwan8c342742016-02-26 00:53:392348void RenderWidget::OnRequestTextInputStateUpdate() {
Dave Tapuska9db80842017-07-24 17:24:262349#if defined(OS_ANDROID)
danakj125a29e2019-01-24 23:25:292350 // This task may run between the Close IPC and the task that actually closes
2351 // this class.
2352 if (closing_)
2353 return;
changwan8c342742016-02-26 00:53:392354 DCHECK(!ime_event_guard_);
2355 UpdateSelectionBounds();
changwan75e3b2072017-01-16 02:55:002356 UpdateTextInputStateInternal(false, true /* reply_to_request */);
[email protected]105dffb42013-02-20 03:46:212357#endif
Dave Tapuska9db80842017-07-24 17:24:262358}
[email protected]105dffb42013-02-20 03:46:212359
ekaramadc9b70a72017-03-23 16:14:232360void RenderWidget::OnRequestCompositionUpdates(bool immediate_request,
2361 bool monitor_updates) {
2362 monitor_composition_info_ = monitor_updates;
nonafa291792016-08-10 02:36:182363 if (!immediate_request)
2364 return;
2365 UpdateCompositionInfo(true /* immediate request */);
2366}
2367
[email protected]fcdc5642014-05-09 14:32:242368void RenderWidget::OnOrientationChange() {
Ehsan Karamad655d7b8a2018-01-12 18:38:382369 if (auto* frame_widget = GetFrameWidget()) {
Alex Moshchuk0b409c42017-09-13 02:09:002370 // LocalRoot() might return null for provisional main frames. In this case,
2371 // the frame hasn't committed a navigation and is not swapped into the tree
2372 // yet, so it doesn't make sense to send orientation change events to it.
2373 //
2374 // TODO(https://crbug.com/578349): This check should be cleaned up
2375 // once provisional frames are gone.
Ehsan Karamad655d7b8a2018-01-12 18:38:382376 if (frame_widget->LocalRoot())
2377 frame_widget->LocalRoot()->SendOrientationChangeEvent();
lfg8d649cc2017-04-28 18:04:302378 }
[email protected]fcdc5642014-05-09 14:32:242379}
2380
[email protected]bee16aab2009-08-26 15:55:032381void RenderWidget::SetHidden(bool hidden) {
2382 if (is_hidden_ == hidden)
2383 return;
2384
jdduke8fac9d102014-12-20 02:40:132385 // The status has changed. Tell the RenderThread about it and ensure
2386 // throttled acks are released in case frame production ceases.
[email protected]bee16aab2009-08-26 15:55:032387 is_hidden_ = hidden;
jdduke8fac9d102014-12-20 02:40:132388
Scott Violet1098538e2017-10-05 19:23:332389#if defined(USE_AURA)
Scott Violete46b3352018-09-22 00:37:072390 if (features::IsMultiProcessMash())
Scott Violet1098538e2017-10-05 19:23:332391 RendererWindowTreeClient::Get(routing_id_)->SetVisible(!hidden);
2392#endif
2393
Saman Sami58ed4392018-01-31 20:54:192394 // RenderThreadImpl::current() could be null in tests.
2395 if (RenderThreadImpl::current()) {
2396 if (is_hidden_) {
2397 RenderThreadImpl::current()->WidgetHidden();
2398 first_update_visual_state_after_hidden_ = true;
2399 } else {
2400 RenderThreadImpl::current()->WidgetRestored();
2401 }
Lei Zhang9b359d32017-11-28 00:57:022402 }
alexclarke7fa93942015-10-21 15:37:112403
2404 if (render_widget_scheduling_state_)
2405 render_widget_scheduling_state_->SetHidden(hidden);
danakj1b35e9d2018-11-07 19:09:282406
danakj57f139f2018-11-19 19:23:462407 // When the RenderWidget is frozen, visibility of the compositor is overridden
2408 // to always be hidden to prevent it from using resources that are not needed.
2409 // Unfortunately the main RenderWidget for a RenderView must be marked visible
2410 // even if the RenderView has a proxy main frame (and the RenderWidget is
2411 // frozen), in order for the RenderView to use the visibility signal from the
2412 // RenderWidget. This is bad. But we don't need to show the compositor to
2413 // satisfy that requirement.
2414 if (!is_frozen_)
2415 layer_tree_view_->SetVisible(!is_hidden_);
[email protected]bee16aab2009-08-26 15:55:032416}
2417
danakjf9284772019-01-23 18:29:142418void RenderWidget::SetIsFullscreen(bool fullscreen) {
2419 if (fullscreen == is_fullscreen_granted_)
[email protected]2b624c562011-10-27 22:58:262420 return;
danakjf9284772019-01-23 18:29:142421 is_fullscreen_granted_ = fullscreen;
mikhail.pozdnyakovf2c902a2015-04-14 08:09:122422 if (is_fullscreen_granted_) {
Blink Reformat1c4d759e2017-04-09 16:34:542423 GetWebWidget()->DidEnterFullscreen();
[email protected]2b624c562011-10-27 22:58:262424 } else {
Blink Reformat1c4d759e2017-04-09 16:34:542425 GetWebWidget()->DidExitFullscreen();
[email protected]2b624c562011-10-27 22:58:262426 }
[email protected]2b624c562011-10-27 22:58:262427}
2428
changwanf2a707b2015-10-30 08:22:162429void RenderWidget::OnImeEventGuardStart(ImeEventGuard* guard) {
2430 if (!ime_event_guard_)
2431 ime_event_guard_ = guard;
[email protected]66fca5bc2013-05-23 06:58:292432}
2433
changwanf2a707b2015-10-30 08:22:162434void RenderWidget::OnImeEventGuardFinish(ImeEventGuard* guard) {
Jeremy Roman0b261f42018-08-28 15:36:012435 if (ime_event_guard_ != guard)
changwanf2a707b2015-10-30 08:22:162436 return;
changwanf2a707b2015-10-30 08:22:162437 ime_event_guard_ = nullptr;
2438
[email protected]66fca5bc2013-05-23 06:58:292439 // While handling an ime event, text input state and selection bounds updates
2440 // are ignored. These must explicitly be updated once finished handling the
2441 // ime event.
2442 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:472443#if defined(OS_ANDROID)
changwan75e3b2072017-01-16 02:55:002444 if (guard->show_virtual_keyboard())
2445 ShowVirtualKeyboard();
2446 else
2447 UpdateTextInputState();
[email protected]cb9e2632013-06-18 11:26:472448#endif
[email protected]66fca5bc2013-05-23 06:58:292449}
2450
[email protected]7c8873e2013-02-05 08:03:012451void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
brettw4b461082016-11-19 18:55:162452#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492453 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
ekaramad2a46d632016-07-19 13:33:092454 // TODO(kinaba) http://crbug.com/101101
2455 // Current Pepper IME API does not handle selection bounds. So we simply
2456 // use the caret position as an empty range for now. It will be updated
2457 // after Pepper API equips features related to surrounding text retrieval.
EhsanK22d482e2017-08-10 17:29:492458 blink::WebRect caret(plugin->GetCaretBounds());
Blink Reformat1c4d759e2017-04-09 16:34:542459 ConvertViewportToWindow(&caret);
ekaramad2a46d632016-07-19 13:33:092460 *focus = caret;
2461 *anchor = caret;
2462 return;
2463 }
2464#endif
[email protected]7c8873e2013-02-05 08:03:012465 WebRect focus_webrect;
2466 WebRect anchor_webrect;
Blink Reformat1c4d759e2017-04-09 16:34:542467 GetWebWidget()->SelectionBounds(focus_webrect, anchor_webrect);
2468 ConvertViewportToWindow(&focus_webrect);
2469 ConvertViewportToWindow(&anchor_webrect);
oshima33ec97cd2015-12-14 19:40:242470 *focus = focus_webrect;
2471 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:322472}
2473
[email protected]e99ef6f2011-10-16 01:13:002474void RenderWidget::UpdateSelectionBounds() {
jdduke1aebad8e2015-07-22 23:25:082475 TRACE_EVENT0("renderer", "RenderWidget::UpdateSelectionBounds");
lfg8ff33912016-09-13 20:59:212476 if (!GetWebWidget())
[email protected]e99ef6f2011-10-16 01:13:002477 return;
changwanf2a707b2015-10-30 08:22:162478 if (ime_event_guard_)
[email protected]66fca5bc2013-05-23 06:58:292479 return;
[email protected]e99ef6f2011-10-16 01:13:002480
mohsenb0eeba72015-08-09 06:20:082481#if defined(USE_AURA)
2482 // TODO(mohsen): For now, always send explicit selection IPC notifications for
2483 // Aura beucause composited selection updates are not working for webview tags
2484 // which regresses IME inside webview. Remove this when composited selection
2485 // updates are fixed for webviews. See, http://crbug.com/510568.
2486 bool send_ipc = true;
2487#else
jddukeacf809e2014-09-23 20:38:382488 // With composited selection updates, the selection bounds will be reported
2489 // directly by the compositor, in which case explicit IPC selection
2490 // notifications should be suppressed.
mohsenb0eeba72015-08-09 06:20:082491 bool send_ipc =
Blink Reformat1c4d759e2017-04-09 16:34:542492 !blink::WebRuntimeFeatures::IsCompositedSelectionUpdateEnabled();
mohsenb0eeba72015-08-09 06:20:082493#endif
2494 if (send_ipc) {
Albert J. Wong3c93c182018-09-27 17:29:432495 WidgetHostMsg_SelectionBounds_Params params;
EhsanK955ba582017-11-30 21:14:402496 params.is_anchor_first = false;
jddukeacf809e2014-09-23 20:38:382497 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
2498 if (selection_anchor_rect_ != params.anchor_rect ||
2499 selection_focus_rect_ != params.focus_rect) {
2500 selection_anchor_rect_ = params.anchor_rect;
2501 selection_focus_rect_ = params.focus_rect;
EhsanK955ba582017-11-30 21:14:402502 if (auto* focused_frame = GetFocusedWebLocalFrameInWidget()) {
2503 focused_frame->SelectionTextDirection(params.focus_dir,
2504 params.anchor_dir);
2505 params.is_anchor_first = focused_frame->IsSelectionAnchorFirst();
2506 }
Albert J. Wong3c93c182018-09-27 17:29:432507 Send(new WidgetHostMsg_SelectionBoundsChanged(routing_id_, params));
jddukeacf809e2014-09-23 20:38:382508 }
[email protected]58b48a0d2012-06-13 07:01:352509 }
jddukeacf809e2014-09-23 20:38:382510
nonafa291792016-08-10 02:36:182511 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]e99ef6f2011-10-16 01:13:002512}
2513
lfgb00fcad2016-07-14 14:16:332514void RenderWidget::DidAutoResize(const gfx::Size& new_size) {
danakj125a29e2019-01-24 23:25:292515 // Blink can continue running and do a layout/resize between the Close IPC
2516 // and the task that actually closes this class.
2517 if (closing_)
2518 return;
2519
lfgb00fcad2016-07-14 14:16:332520 WebRect new_size_in_window(0, 0, new_size.width(), new_size.height());
Blink Reformat1c4d759e2017-04-09 16:34:542521 ConvertViewportToWindow(&new_size_in_window);
lfgb00fcad2016-07-14 14:16:332522 if (size_.width() != new_size_in_window.width ||
2523 size_.height() != new_size_in_window.height) {
2524 size_ = gfx::Size(new_size_in_window.width, new_size_in_window.height);
2525
2526 if (resizing_mode_selector_->is_synchronous_mode()) {
Blink Reformat1c4d759e2017-04-09 16:34:542527 gfx::Rect new_pos(WindowRect().x, WindowRect().y, size_.width(),
2528 size_.height());
Albert J. Wong3c93c182018-09-27 17:29:432529 widget_screen_rect_ = new_pos;
lfgb00fcad2016-07-14 14:16:332530 window_screen_rect_ = new_pos;
2531 }
2532
Christopher Camerone9a30c12018-03-07 08:23:382533 // TODO(ccameron): Note that this destroys any information differentiating
Christopher Cameronaad15a0d2018-03-09 03:47:332534 // |size_| from |compositor_viewport_pixel_size_|. Also note that the
2535 // calculation of |new_compositor_viewport_pixel_size| does not appear to
2536 // take into account device emulation.
danakj125a29e2019-01-24 23:25:292537 layer_tree_view_->RequestNewLocalSurfaceId();
Christopher Cameronaad15a0d2018-03-09 03:47:332538 gfx::Size new_compositor_viewport_pixel_size =
Fady Samuela863f152018-03-09 16:10:032539 gfx::ScaleToCeiledSize(size_, GetWebScreenInfo().device_scale_factor);
Fady Samuel1c1ad3692018-11-06 23:28:402540 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
2541 new_compositor_viewport_pixel_size,
2542 screen_info_);
lfgb00fcad2016-07-14 14:16:332543 }
2544}
2545
[email protected]58b48a0d2012-06-13 07:01:352546void RenderWidget::GetCompositionCharacterBounds(
2547 std::vector<gfx::Rect>* bounds) {
2548 DCHECK(bounds);
2549 bounds->clear();
ekaramad2a46d632016-07-19 13:33:092550
brettw4b461082016-11-19 18:55:162551#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492552 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092553 return;
2554#endif
2555
Ehsan Karamad4975af6d2018-02-09 16:58:162556 blink::WebInputMethodController* controller = GetInputMethodController();
2557 if (!controller)
ekaramad2a46d632016-07-19 13:33:092558 return;
2559 blink::WebVector<blink::WebRect> bounds_from_blink;
Ehsan Karamad4975af6d2018-02-09 16:58:162560 if (!controller->GetCompositionCharacterBounds(bounds_from_blink))
ekaramad2a46d632016-07-19 13:33:092561 return;
2562
2563 for (size_t i = 0; i < bounds_from_blink.size(); ++i) {
Blink Reformat1c4d759e2017-04-09 16:34:542564 ConvertViewportToWindow(&bounds_from_blink[i]);
ekaramad2a46d632016-07-19 13:33:092565 bounds->push_back(bounds_from_blink[i]);
2566 }
[email protected]58b48a0d2012-06-13 07:01:352567}
2568
[email protected]db4fc1e2013-09-06 20:01:512569void RenderWidget::GetCompositionRange(gfx::Range* range) {
brettw4b461082016-11-19 18:55:162570#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492571 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092572 return;
2573#endif
EhsanKcdee7b72017-11-08 21:30:092574 blink::WebInputMethodController* controller = GetInputMethodController();
2575 WebRange web_range = controller ? controller->CompositionRange() : WebRange();
Blink Reformat1c4d759e2017-04-09 16:34:542576 if (web_range.IsNull()) {
nona2363a3d2016-11-09 03:26:212577 *range = gfx::Range::InvalidRange();
2578 return;
[email protected]88dbe32f2013-06-20 23:31:362579 }
Blink Reformat1c4d759e2017-04-09 16:34:542580 range->set_start(web_range.StartOffset());
2581 range->set_end(web_range.EndOffset());
[email protected]88dbe32f2013-06-20 23:31:362582}
2583
[email protected]501ea13d2013-07-09 17:03:292584bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:512585 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:292586 const std::vector<gfx::Rect>& bounds) {
changwan2418e1b2016-12-12 12:43:082587 if (!range.IsValid())
2588 return false;
[email protected]501ea13d2013-07-09 17:03:292589 if (composition_range_ != range)
2590 return true;
2591 if (bounds.size() != composition_character_bounds_.size())
2592 return true;
2593 for (size_t i = 0; i < bounds.size(); ++i) {
2594 if (bounds[i] != composition_character_bounds_[i])
2595 return true;
2596 }
2597 return false;
2598}
[email protected]501ea13d2013-07-09 17:03:292599
[email protected]ad26ef42011-06-17 07:59:452600bool RenderWidget::CanComposeInline() {
brettw4b461082016-11-19 18:55:162601#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492602 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2603 return plugin->IsPluginAcceptingCompositionEvents();
ekaramad2a46d632016-07-19 13:33:092604#endif
[email protected]ad26ef42011-06-17 07:59:452605 return true;
[email protected]56ea1a62011-05-30 07:05:572606}
2607
Blink Reformat1c4d759e2017-04-09 16:34:542608void RenderWidget::DidHandleGestureEvent(const WebGestureEvent& event,
2609 bool event_cancelled) {
danakja2c9d0a92018-07-25 20:01:182610 if (event_cancelled) {
Albert J. Wong7bbf22d2018-12-20 00:27:272611 // The delegate() doesn't need to hear about cancelled events.
[email protected]c68c3e4e2013-01-24 00:36:562612 return;
danakja2c9d0a92018-07-25 20:01:182613 }
2614
2615#if defined(OS_ANDROID) || defined(USE_AURA)
Blink Reformat1c4d759e2017-04-09 16:34:542616 if (event.GetType() == WebInputEvent::kGestureTap) {
changwan75e3b2072017-01-16 02:55:002617 ShowVirtualKeyboard();
Blink Reformat1c4d759e2017-04-09 16:34:542618 } else if (event.GetType() == WebInputEvent::kGestureLongPress) {
lfg8ff33912016-09-13 20:59:212619 DCHECK(GetWebWidget());
ekaramad5aff1942017-01-06 01:26:352620 blink::WebInputMethodController* controller = GetInputMethodController();
Blink Reformat1c4d759e2017-04-09 16:34:542621 if (!controller || controller->TextInputInfo().value.IsEmpty())
changwan75e3b2072017-01-16 02:55:002622 UpdateTextInputState();
[email protected]07c70d22014-08-21 08:33:462623 else
changwan75e3b2072017-01-16 02:55:002624 ShowVirtualKeyboard();
[email protected]c68c3e4e2013-01-24 00:36:562625 }
ekaramada110f642016-12-21 19:47:282626// TODO(ananta): Piggyback off existing IPCs to communicate this information,
2627// crbug/420130.
2628#if defined(OS_WIN)
danakja2c9d0a92018-07-25 20:01:182629 if (event.GetType() == blink::WebGestureEvent::kGestureTap) {
2630 // TODO(estade): hit test the event against focused node to make sure
2631 // the tap actually hit the focused node.
2632 blink::WebInputMethodController* controller = GetInputMethodController();
2633 blink::WebTextInputType text_input_type =
2634 controller ? controller->TextInputType() : blink::kWebTextInputTypeNone;
ekaramada110f642016-12-21 19:47:282635
Albert J. Wong3c93c182018-09-27 17:29:432636 Send(new WidgetHostMsg_FocusedNodeTouched(
danakja2c9d0a92018-07-25 20:01:182637 routing_id_, text_input_type != blink::kWebTextInputTypeNone));
2638 }
ekaramada110f642016-12-21 19:47:282639#endif
[email protected]c68c3e4e2013-01-24 00:36:562640#endif
danakja2c9d0a92018-07-25 20:01:182641
Albert J. Wong7bbf22d2018-12-20 00:27:272642 // The delegate() gets to respond to handling gestures last.
2643 if (delegate())
2644 delegate()->DidHandleGestureEventForWidget(event);
[email protected]c68c3e4e2013-01-24 00:36:562645}
2646
Blink Reformat1c4d759e2017-04-09 16:34:542647void RenderWidget::DidOverscroll(
bokane53a10f2016-04-13 23:48:312648 const blink::WebFloatSize& overscrollDelta,
2649 const blink::WebFloatSize& accumulatedOverscroll,
sataya.m582c9ce2015-06-09 08:03:422650 const blink::WebFloatPoint& position,
sunyunjiabbea8a92017-08-31 11:18:542651 const blink::WebFloatSize& velocity,
danakje819b622018-05-01 20:27:142652 const cc::OverscrollBehavior& behavior) {
bokan731ec382016-04-07 03:16:482653#if defined(OS_MACOSX)
2654 // On OSX the user can disable the elastic overscroll effect. If that's the
2655 // case, don't forward the overscroll notification.
2656 DCHECK(compositor_deps());
2657 if (!compositor_deps()->IsElasticOverscrollEnabled())
2658 return;
2659#endif
bokane53a10f2016-04-13 23:48:312660 input_handler_->DidOverscrollFromBlink(overscrollDelta, accumulatedOverscroll,
sunyunjiabbea8a92017-08-31 11:18:542661 position, velocity, behavior);
sataya.m582c9ce2015-06-09 08:03:422662}
2663
danakj4b347212018-07-04 17:55:172664// static
2665cc::LayerTreeSettings RenderWidget::GenerateLayerTreeSettings(
2666 CompositorDependencies* compositor_deps,
2667 bool is_for_subframe,
2668 const gfx::Size& initial_screen_size,
2669 float initial_device_scale_factor) {
2670 const bool is_threaded =
2671 !!compositor_deps->GetCompositorImplThreadTaskRunner();
2672
2673 const base::CommandLine& cmd = *base::CommandLine::ForCurrentProcess();
2674 cc::LayerTreeSettings settings;
2675
2676 settings.resource_settings.use_r16_texture =
2677 base::FeatureList::IsEnabled(media::kUseR16Texture);
2678
2679 settings.commit_to_active_tree = !is_threaded;
2680 settings.is_layer_tree_for_subframe = is_for_subframe;
2681
2682 // For web contents, layer transforms should scale up the contents of layers
2683 // to keep content always crisp when possible.
2684 settings.layer_transforms_should_scale_layer_contents = true;
2685
2686 settings.main_frame_before_activation_enabled =
2687 cmd.HasSwitch(cc::switches::kEnableMainFrameBeforeActivation);
2688
2689 // Checkerimaging is not supported for synchronous single-threaded mode, which
2690 // is what the renderer uses if its not threaded.
2691 settings.enable_checker_imaging =
2692 !cmd.HasSwitch(cc::switches::kDisableCheckerImaging) && is_threaded;
2693
2694#if defined(OS_ANDROID)
2695 // We can use a more aggressive limit on Android since decodes tend to take
2696 // longer on these devices.
2697 settings.min_image_bytes_to_checker = 512 * 1024; // 512kB
2698
2699 // Re-rasterization of checker-imaged content with software raster can be too
2700 // costly on Android.
2701 settings.only_checker_images_with_gpu_raster = true;
2702#endif
2703
2704 auto switch_value_as_int = [](const base::CommandLine& command_line,
2705 const std::string& switch_string, int min_value,
2706 int max_value, int* result) {
2707 std::string string_value = command_line.GetSwitchValueASCII(switch_string);
2708 int int_value;
2709 if (base::StringToInt(string_value, &int_value) && int_value >= min_value &&
2710 int_value <= max_value) {
2711 *result = int_value;
2712 return true;
2713 } else {
2714 LOG(WARNING) << "Failed to parse switch " << switch_string << ": "
2715 << string_value;
2716 return false;
2717 }
2718 };
2719
2720 int default_tile_size = 256;
2721#if defined(OS_ANDROID)
2722 const gfx::Size screen_size =
2723 gfx::ScaleToFlooredSize(initial_screen_size, initial_device_scale_factor);
2724 int display_width = screen_size.width();
2725 int display_height = screen_size.height();
2726 int numTiles = (display_width * display_height) / (256 * 256);
2727 if (numTiles > 16)
2728 default_tile_size = 384;
2729 if (numTiles >= 40)
2730 default_tile_size = 512;
2731
2732 // Adjust for some resolutions that barely straddle an extra
2733 // tile when in portrait mode. This helps worst case scroll/raster
2734 // by not needing a full extra tile for each row.
2735 constexpr int tolerance = 10; // To avoid rounding errors.
2736 int portrait_width = std::min(display_width, display_height);
2737 if (default_tile_size == 256 && std::abs(portrait_width - 768) < tolerance)
2738 default_tile_size += 32;
2739 if (default_tile_size == 384 && std::abs(portrait_width - 1200) < tolerance)
2740 default_tile_size += 32;
2741#elif defined(OS_CHROMEOS) || defined(OS_MACOSX)
2742 // Use 512 for high DPI (dsf=2.0f) devices.
2743 if (initial_device_scale_factor >= 2.0f)
2744 default_tile_size = 512;
2745#endif
2746
2747 // TODO(danakj): This should not be a setting O_O; it should change when the
2748 // device scale factor on LayerTreeHost changes.
2749 settings.default_tile_size = gfx::Size(default_tile_size, default_tile_size);
2750 if (cmd.HasSwitch(switches::kDefaultTileWidth)) {
2751 int tile_width = 0;
2752 switch_value_as_int(cmd, switches::kDefaultTileWidth, 1,
2753 std::numeric_limits<int>::max(), &tile_width);
2754 settings.default_tile_size.set_width(tile_width);
2755 }
2756 if (cmd.HasSwitch(switches::kDefaultTileHeight)) {
2757 int tile_height = 0;
2758 switch_value_as_int(cmd, switches::kDefaultTileHeight, 1,
2759 std::numeric_limits<int>::max(), &tile_height);
2760 settings.default_tile_size.set_height(tile_height);
2761 }
2762
2763 int max_untiled_layer_width = settings.max_untiled_layer_size.width();
2764 if (cmd.HasSwitch(switches::kMaxUntiledLayerWidth)) {
2765 switch_value_as_int(cmd, switches::kMaxUntiledLayerWidth, 1,
2766 std::numeric_limits<int>::max(),
2767 &max_untiled_layer_width);
2768 }
2769 int max_untiled_layer_height = settings.max_untiled_layer_size.height();
2770 if (cmd.HasSwitch(switches::kMaxUntiledLayerHeight)) {
2771 switch_value_as_int(cmd, switches::kMaxUntiledLayerHeight, 1,
2772 std::numeric_limits<int>::max(),
2773 &max_untiled_layer_height);
2774 }
2775
2776 settings.max_untiled_layer_size =
2777 gfx::Size(max_untiled_layer_width, max_untiled_layer_height);
2778
2779 settings.gpu_rasterization_msaa_sample_count =
2780 compositor_deps->GetGpuRasterizationMSAASampleCount();
2781 settings.gpu_rasterization_forced =
2782 compositor_deps->IsGpuRasterizationForced();
2783
2784 settings.can_use_lcd_text = compositor_deps->IsLcdTextEnabled();
2785 settings.use_zero_copy = compositor_deps->IsZeroCopyEnabled();
2786 settings.use_partial_raster = compositor_deps->IsPartialRasterEnabled();
2787 settings.enable_elastic_overscroll =
2788 compositor_deps->IsElasticOverscrollEnabled();
2789 settings.resource_settings.use_gpu_memory_buffer_resources =
2790 compositor_deps->IsGpuMemoryBufferCompositorResourcesEnabled();
2791 settings.use_painted_device_scale_factor =
2792 compositor_deps->IsUseZoomForDSFEnabled();
2793
2794 // Build LayerTreeSettings from command line args.
2795 if (cmd.HasSwitch(cc::switches::kBrowserControlsShowThreshold)) {
2796 std::string top_threshold_str =
2797 cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsShowThreshold);
2798 double show_threshold;
2799 if (base::StringToDouble(top_threshold_str, &show_threshold) &&
2800 show_threshold >= 0.f && show_threshold <= 1.f)
2801 settings.top_controls_show_threshold = show_threshold;
2802 }
2803
2804 if (cmd.HasSwitch(cc::switches::kBrowserControlsHideThreshold)) {
2805 std::string top_threshold_str =
2806 cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsHideThreshold);
2807 double hide_threshold;
2808 if (base::StringToDouble(top_threshold_str, &hide_threshold) &&
2809 hide_threshold >= 0.f && hide_threshold <= 1.f)
2810 settings.top_controls_hide_threshold = hide_threshold;
2811 }
2812
Philip Rogersc55ab6a2018-12-05 17:29:192813 // Blink sends cc a layer list and property trees when either
2814 // BlinkGenPropertyTrees or CompositeAfterPaint are enabled.
Philip Rogersfc2f1162018-10-17 18:28:312815 settings.use_layer_lists =
2816 blink::WebRuntimeFeatures::IsBlinkGenPropertyTreesEnabled() ||
Philip Rogersc55ab6a2018-12-05 17:29:192817 blink::WebRuntimeFeatures::IsCompositeAfterPaintEnabled();
danakj4b347212018-07-04 17:55:172818
David Bokan163b6a72018-10-25 22:03:492819 // Blink currently doesn't support setting fractional scroll offsets so CC
2820 // must send integer values. We plan to eventually make Blink use fractional
2821 // offsets internally: https://crbug.com/414283.
2822 settings.commit_fractional_scroll_deltas =
2823 blink::WebRuntimeFeatures::IsFractionalScrollOffsetsEnabled();
2824
danakj4b347212018-07-04 17:55:172825 // The means the renderer compositor has 2 possible modes:
2826 // - Threaded compositing with a scheduler.
Kent Tamura21d1de62018-12-10 04:45:202827 // - Single threaded compositing without a scheduler (for web tests only).
2828 // Using the scheduler in web tests introduces additional composite steps
danakj4b347212018-07-04 17:55:172829 // that create flakiness.
2830 settings.single_thread_proxy_scheduler = false;
2831
2832 // These flags should be mirrored by UI versions in ui/compositor/.
2833 if (cmd.HasSwitch(cc::switches::kShowCompositedLayerBorders))
2834 settings.initial_debug_state.show_debug_borders.set();
2835 settings.initial_debug_state.show_layer_animation_bounds_rects =
2836 cmd.HasSwitch(cc::switches::kShowLayerAnimationBounds);
2837 settings.initial_debug_state.show_paint_rects =
2838 cmd.HasSwitch(switches::kShowPaintRects);
2839 settings.initial_debug_state.show_property_changed_rects =
2840 cmd.HasSwitch(cc::switches::kShowPropertyChangedRects);
2841 settings.initial_debug_state.show_surface_damage_rects =
2842 cmd.HasSwitch(cc::switches::kShowSurfaceDamageRects);
2843 settings.initial_debug_state.show_screen_space_rects =
2844 cmd.HasSwitch(cc::switches::kShowScreenSpaceRects);
2845
2846 settings.initial_debug_state.SetRecordRenderingStats(
2847 cmd.HasSwitch(cc::switches::kEnableGpuBenchmarking));
2848 settings.enable_surface_synchronization =
2849 features::IsSurfaceSynchronizationEnabled();
2850 settings.build_hit_test_data = features::IsVizHitTestingSurfaceLayerEnabled();
2851
2852 if (cmd.HasSwitch(cc::switches::kSlowDownRasterScaleFactor)) {
2853 const int kMinSlowDownScaleFactor = 0;
2854 const int kMaxSlowDownScaleFactor = INT_MAX;
2855 switch_value_as_int(
2856 cmd, cc::switches::kSlowDownRasterScaleFactor, kMinSlowDownScaleFactor,
2857 kMaxSlowDownScaleFactor,
2858 &settings.initial_debug_state.slow_down_raster_scale_factor);
2859 }
2860
2861 // This is default overlay scrollbar settings for Android and DevTools mobile
2862 // emulator. Aura Overlay Scrollbar will override below.
2863 settings.scrollbar_animator = cc::LayerTreeSettings::ANDROID_OVERLAY;
2864 settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
2865 settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(300);
2866 settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(300);
2867
2868#if defined(OS_ANDROID)
2869 bool using_synchronous_compositor =
2870 compositor_deps->UsingSynchronousCompositing();
2871 bool using_low_memory_policy = base::SysInfo::IsLowEndDevice();
2872
2873 settings.use_stream_video_draw_quad = true;
2874 settings.using_synchronous_renderer_compositor = using_synchronous_compositor;
2875 if (using_synchronous_compositor) {
2876 // Android WebView uses system scrollbars, so make ours invisible.
2877 // http://crbug.com/677348: This can't be done using hide_scrollbars
2878 // setting because supporting -webkit custom scrollbars is still desired
2879 // on sublayers.
2880 settings.scrollbar_animator = cc::LayerTreeSettings::NO_ANIMATOR;
2881 settings.solid_color_scrollbar_color = SK_ColorTRANSPARENT;
2882
2883 settings.enable_early_damage_check =
2884 cmd.HasSwitch(cc::switches::kCheckDamageEarly);
2885 }
2886 // Android WebView handles root layer flings itself.
2887 settings.ignore_root_layer_flings = using_synchronous_compositor;
2888 // Memory policy on Android WebView does not depend on whether device is
2889 // low end, so always use default policy.
2890 if (using_low_memory_policy && !using_synchronous_compositor) {
2891 // On low-end we want to be very carefull about killing other
2892 // apps. So initially we use 50% more memory to avoid flickering
2893 // or raster-on-demand.
2894 settings.max_memory_for_prepaint_percentage = 67;
2895 } else {
2896 // On other devices we have increased memory excessively to avoid
2897 // raster-on-demand already, so now we reserve 50% _only_ to avoid
2898 // raster-on-demand, and use 50% of the memory otherwise.
2899 settings.max_memory_for_prepaint_percentage = 50;
2900 }
2901
2902 // TODO(danakj): Only do this on low end devices.
2903 settings.create_low_res_tiling = true;
2904
2905#else // defined(OS_ANDROID)
2906 bool using_synchronous_compositor = false; // Only for Android WebView.
2907 // On desktop, we never use the low memory policy unless we are simulating
2908 // low-end mode via a switch.
2909 bool using_low_memory_policy =
2910 cmd.HasSwitch(switches::kEnableLowEndDeviceMode);
2911
2912 if (ui::IsOverlayScrollbarEnabled()) {
2913 settings.scrollbar_animator = cc::LayerTreeSettings::AURA_OVERLAY;
2914 settings.scrollbar_fade_delay = ui::kOverlayScrollbarFadeDelay;
2915 settings.scrollbar_fade_duration = ui::kOverlayScrollbarFadeDuration;
2916 settings.scrollbar_thinning_duration =
2917 ui::kOverlayScrollbarThinningDuration;
2918 settings.scrollbar_flash_after_any_scroll_update =
2919 ui::OverlayScrollbarFlashAfterAnyScrollUpdate();
2920 settings.scrollbar_flash_when_mouse_enter =
2921 ui::OverlayScrollbarFlashWhenMouseEnter();
2922 }
2923
2924 // On desktop, if there's over 4GB of memory on the machine, increase the
2925 // working set size to 256MB for both gpu and software.
2926 const int kImageDecodeMemoryThresholdMB = 4 * 1024;
2927 if (base::SysInfo::AmountOfPhysicalMemoryMB() >=
2928 kImageDecodeMemoryThresholdMB) {
2929 settings.decoded_image_working_set_budget_bytes = 256 * 1024 * 1024;
2930 } else {
2931 // This is the default, but recorded here as well.
2932 settings.decoded_image_working_set_budget_bytes = 128 * 1024 * 1024;
2933 }
2934#endif // defined(OS_ANDROID)
2935
2936 if (using_low_memory_policy) {
2937 // RGBA_4444 textures are only enabled:
2938 // - If the user hasn't explicitly disabled them
2939 // - If system ram is <= 512MB (1GB devices are sometimes low-end).
2940 // - If we are not running in a WebView, where 4444 isn't supported.
2941 if (!cmd.HasSwitch(switches::kDisableRGBA4444Textures) &&
2942 base::SysInfo::AmountOfPhysicalMemoryMB() <= 512 &&
2943 !using_synchronous_compositor) {
2944 settings.use_rgba_4444 = viz::RGBA_4444;
2945
2946 // If we are going to unpremultiply and dither these tiles, we need to
2947 // allocate an additional RGBA_8888 intermediate for each tile
2948 // rasterization when rastering to RGBA_4444 to allow for dithering.
2949 // Setting a reasonable sized max tile size allows this intermediate to
2950 // be consistently reused.
2951 if (base::FeatureList::IsEnabled(
2952 kUnpremultiplyAndDitherLowBitDepthTiles)) {
2953 settings.max_gpu_raster_tile_size = gfx::Size(512, 256);
2954 settings.unpremultiply_and_dither_low_bit_depth_tiles = true;
2955 }
2956 }
2957 }
2958
2959 if (cmd.HasSwitch(switches::kEnableLowResTiling))
2960 settings.create_low_res_tiling = true;
2961 if (cmd.HasSwitch(switches::kDisableLowResTiling))
2962 settings.create_low_res_tiling = false;
2963
2964 if (cmd.HasSwitch(switches::kEnableRGBA4444Textures) &&
2965 !cmd.HasSwitch(switches::kDisableRGBA4444Textures)) {
2966 settings.use_rgba_4444 = true;
2967 }
2968
2969 settings.max_staging_buffer_usage_in_bytes = 32 * 1024 * 1024; // 32MB
2970 // Use 1/4th of staging buffers on low-end devices.
2971 if (base::SysInfo::IsLowEndDevice())
2972 settings.max_staging_buffer_usage_in_bytes /= 4;
2973
2974 cc::ManagedMemoryPolicy defaults = settings.memory_policy;
2975 settings.memory_policy = GetGpuMemoryPolicy(defaults, initial_screen_size,
2976 initial_device_scale_factor);
2977
2978 settings.disallow_non_exact_resource_reuse =
2979 cmd.HasSwitch(switches::kDisallowNonExactResourceReuse);
2980#if defined(OS_ANDROID)
2981 // TODO(crbug.com/746931): This feature appears to be causing visual
2982 // corruption on certain android devices. Will investigate and re-enable.
2983 settings.disallow_non_exact_resource_reuse = true;
2984#endif
2985
2986 if (cmd.HasSwitch(switches::kRunAllCompositorStagesBeforeDraw)) {
2987 settings.wait_for_all_pipeline_stages_before_draw = true;
2988 settings.enable_latency_recovery = false;
2989 }
2990
2991 settings.enable_image_animation_resync =
2992 !cmd.HasSwitch(switches::kDisableImageAnimationResync);
2993
Karolina Soltys4d60b402018-10-01 19:28:202994 settings.send_compositor_frame_ack = false;
2995
danakj4b347212018-07-04 17:55:172996 return settings;
2997}
2998
2999// static
3000cc::ManagedMemoryPolicy RenderWidget::GetGpuMemoryPolicy(
3001 const cc::ManagedMemoryPolicy& default_policy,
3002 const gfx::Size& initial_screen_size,
3003 float initial_device_scale_factor) {
3004 cc::ManagedMemoryPolicy actual = default_policy;
3005 actual.bytes_limit_when_visible = 0;
3006
3007 // If the value was overridden on the command line, use the specified value.
3008 static bool client_hard_limit_bytes_overridden =
3009 base::CommandLine::ForCurrentProcess()->HasSwitch(
3010 switches::kForceGpuMemAvailableMb);
3011 if (client_hard_limit_bytes_overridden) {
3012 if (base::StringToSizeT(
3013 base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
3014 switches::kForceGpuMemAvailableMb),
3015 &actual.bytes_limit_when_visible))
3016 actual.bytes_limit_when_visible *= 1024 * 1024;
3017 return actual;
3018 }
3019
3020#if defined(OS_ANDROID)
3021 // We can't query available GPU memory from the system on Android.
3022 // Physical memory is also mis-reported sometimes (eg. Nexus 10 reports
3023 // 1262MB when it actually has 2GB, while Razr M has 1GB but only reports
3024 // 128MB java heap size). First we estimate physical memory using both.
3025 size_t dalvik_mb = base::SysInfo::DalvikHeapSizeMB();
3026 size_t physical_mb = base::SysInfo::AmountOfPhysicalMemoryMB();
3027 size_t physical_memory_mb = 0;
3028 if (base::SysInfo::IsLowEndDevice()) {
3029 // TODO(crbug.com/742534): The code below appears to no longer work.
3030 // |dalvik_mb| no longer follows the expected heuristic pattern, causing us
3031 // to over-estimate memory on low-end devices. This entire section probably
3032 // needs to be re-written, but for now we can address the low-end Android
3033 // issues by ignoring |dalvik_mb|.
3034 physical_memory_mb = physical_mb;
3035 } else if (dalvik_mb >= 256) {
3036 physical_memory_mb = dalvik_mb * 4;
3037 } else {
3038 physical_memory_mb = std::max(dalvik_mb * 4, (physical_mb * 4) / 3);
3039 }
3040
3041 // Now we take a default of 1/8th of memory on high-memory devices,
3042 // and gradually scale that back for low-memory devices (to be nicer
3043 // to other apps so they don't get killed). Examples:
3044 // Nexus 4/10(2GB) 256MB (normally 128MB)
3045 // Droid Razr M(1GB) 114MB (normally 57MB)
3046 // Galaxy Nexus(1GB) 100MB (normally 50MB)
3047 // Xoom(1GB) 100MB (normally 50MB)
3048 // Nexus S(low-end) 8MB (normally 8MB)
3049 // Note that the compositor now uses only some of this memory for
3050 // pre-painting and uses the rest only for 'emergencies'.
3051 if (actual.bytes_limit_when_visible == 0) {
3052 // NOTE: Non-low-end devices use only 50% of these limits,
3053 // except during 'emergencies' where 100% can be used.
3054 if (physical_memory_mb >= 1536)
3055 actual.bytes_limit_when_visible = physical_memory_mb / 8; // >192MB
3056 else if (physical_memory_mb >= 1152)
3057 actual.bytes_limit_when_visible = physical_memory_mb / 8; // >144MB
3058 else if (physical_memory_mb >= 768)
3059 actual.bytes_limit_when_visible = physical_memory_mb / 10; // >76MB
3060 else if (physical_memory_mb >= 513)
3061 actual.bytes_limit_when_visible = physical_memory_mb / 12; // <64MB
3062 else
3063 // Devices with this little RAM have very little headroom so we hardcode
3064 // the limit rather than relying on the heuristics above. (They also use
3065 // 4444 textures so we can use a lower limit.)
3066 actual.bytes_limit_when_visible = 8;
3067
3068 actual.bytes_limit_when_visible =
3069 actual.bytes_limit_when_visible * 1024 * 1024;
3070 // Clamp the observed value to a specific range on Android.
3071 actual.bytes_limit_when_visible = std::max(
3072 actual.bytes_limit_when_visible, static_cast<size_t>(8 * 1024 * 1024));
3073 actual.bytes_limit_when_visible =
3074 std::min(actual.bytes_limit_when_visible,
3075 static_cast<size_t>(256 * 1024 * 1024));
3076 }
3077 actual.priority_cutoff_when_visible =
3078 gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING;
3079#else
3080 // Ignore what the system said and give all clients the same maximum
3081 // allocation on desktop platforms.
3082 actual.bytes_limit_when_visible = 512 * 1024 * 1024;
3083 actual.priority_cutoff_when_visible =
3084 gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
3085
3086 // For large monitors (4k), double the tile memory to avoid frequent out of
3087 // memory problems. 4k could mean a screen width of anywhere from 3840 to 4096
3088 // (see https://en.wikipedia.org/wiki/4K_resolution). We use 3500 as a proxy
3089 // for "large enough".
3090 static const int kLargeDisplayThreshold = 3500;
3091 int display_width =
3092 std::round(initial_screen_size.width() * initial_device_scale_factor);
3093 if (display_width >= kLargeDisplayThreshold)
3094 actual.bytes_limit_when_visible *= 2;
3095#endif
3096 return actual;
3097}
3098
Navid Zolghadr8fdb6114e2018-08-29 19:00:543099void RenderWidget::HasPointerRawMoveEventHandlers(bool has_handlers) {
3100 if (input_event_queue_)
3101 input_event_queue_->HasPointerRawMoveEventHandlers(has_handlers);
3102}
3103
Blink Reformat1c4d759e2017-04-09 16:34:543104void RenderWidget::HasTouchEventHandlers(bool has_handlers) {
W. James MacLean662d5382018-03-29 18:33:083105 if (has_touch_handlers_ && *has_touch_handlers_ == has_handlers)
3106 return;
3107
3108 has_touch_handlers_ = has_handlers;
alexclarke7fa93942015-10-21 15:37:113109 if (render_widget_scheduling_state_)
3110 render_widget_scheduling_state_->SetHasTouchHandler(has_handlers);
Albert J. Wongeb28e7e2018-10-12 00:57:433111 Send(new WidgetHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
[email protected]ce6689f2013-03-29 12:52:553112}
3113
Dave Tapuskadfe486c12017-06-09 16:53:133114void RenderWidget::SetNeedsLowLatencyInput(bool needs_low_latency) {
3115 if (input_event_queue_)
3116 input_event_queue_->SetNeedsLowLatency(needs_low_latency);
3117}
3118
Pavel Feldman6708eefa2019-01-17 03:14:323119void RenderWidget::SetNeedsUnbufferedInputForDebugger(bool unbuffered) {
3120 if (input_event_queue_)
3121 input_event_queue_->SetNeedsUnbufferedInputForDebugger(unbuffered);
3122}
3123
W. James MacLeand973a55b2018-11-29 21:39:133124void RenderWidget::AnimateDoubleTapZoomInMainFrame(
3125 const blink::WebPoint& point,
3126 const blink::WebRect& rect_to_zoom) {
3127 // Only oopif subframes should be sending this message.
Albert J. Wong7bbf22d2018-12-20 00:27:273128 DCHECK(!delegate());
W. James MacLeand973a55b2018-11-29 21:39:133129 Send(new WidgetHostMsg_AnimateDoubleTapZoomInMainFrame(routing_id(), point,
3130 rect_to_zoom));
3131}
3132
W. James MacLean5372eb72018-12-19 12:56:363133void RenderWidget::ZoomToFindInPageRectInMainFrame(
3134 const blink::WebRect& rect_to_zoom) {
3135 // Only oopif subframes should be sending this message.
Albert J. Wong7bbf22d2018-12-20 00:27:273136 DCHECK(!delegate_);
W. James MacLean5372eb72018-12-19 12:56:363137 Send(new WidgetHostMsg_ZoomToFindInPageRectInMainFrame(routing_id(),
3138 rect_to_zoom));
3139}
3140
Dave Tapuskabafc2ba32017-11-28 01:54:373141void RenderWidget::RequestUnbufferedInputEvents() {
3142 if (input_event_queue_)
3143 input_event_queue_->RequestUnbufferedInputEvents();
3144}
3145
xidachenfa0199e72017-05-11 11:34:263146void RenderWidget::SetTouchAction(cc::TouchAction touch_action) {
Dave Tapuskab28a1082017-08-30 15:37:263147 if (!input_handler_->ProcessTouchAction(touch_action))
[email protected]5d0bbdfa92013-12-10 00:35:513148 return;
3149
Dave Tapuska04bc5ee92018-04-17 19:03:313150 widget_input_handler_manager_->ProcessTouchAction(touch_action);
[email protected]5d0bbdfa92013-12-10 00:35:513151}
3152
[email protected]e3244ed2014-06-20 20:04:273153void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
3154 render_frame_proxies_.AddObserver(proxy);
danakj0246bba02019-01-23 23:12:273155 // Page scale factor is propagated down the RenderWidget tree (across
3156 // frame trees). A new RenderFrameProxy means there is a new child
3157 // RenderWidget in another frame tree. In order for it to hear about
3158 // the page scale factor we pass along the last seen value here.
W. James MacLean2a90bff2018-11-05 20:52:473159 proxy->OnPageScaleFactorChanged(page_scale_factor_from_mainframe_);
[email protected]bffc8302014-01-23 20:52:163160}
3161
[email protected]e3244ed2014-06-20 20:04:273162void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
3163 render_frame_proxies_.RemoveObserver(proxy);
[email protected]bffc8302014-01-23 20:52:163164}
3165
[email protected]de3c5d82014-05-28 22:12:593166void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
3167 render_frames_.AddObserver(frame);
3168}
3169
3170void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) {
3171 render_frames_.RemoveObserver(frame);
3172}
3173
Saman Samid189e5dfd2017-12-20 22:55:313174void RenderWidget::RegisterBrowserPlugin(BrowserPlugin* browser_plugin) {
3175 browser_plugins_.AddObserver(browser_plugin);
Saman Sami50d1e0c2018-03-13 20:03:493176 browser_plugin->ScreenInfoChanged(GetOriginalScreenInfo());
Saman Samid189e5dfd2017-12-20 22:55:313177}
3178
3179void RenderWidget::UnregisterBrowserPlugin(BrowserPlugin* browser_plugin) {
3180 browser_plugins_.RemoveObserver(browser_plugin);
3181}
3182
Albert J. Wong3c93c182018-09-27 17:29:433183void RenderWidget::OnWaitNextFrameForTests(
3184 int main_frame_thread_observer_routing_id) {
danakj53802692018-07-25 21:46:443185 // Sends an ACK to the browser process during the next compositor frame.
Albert J. Wong3c93c182018-09-27 17:29:433186 QueueMessage(new WidgetHostMsg_WaitForNextFrameForTests_ACK(
3187 main_frame_thread_observer_routing_id));
lfg43e08e62016-02-03 18:51:373188}
3189
Fady Samuela863f152018-03-09 16:10:033190const ScreenInfo& RenderWidget::GetWebScreenInfo() const {
3191 return screen_info_;
Christopher Camerone9a30c12018-03-07 08:23:383192}
3193
Fady Samuela863f152018-03-09 16:10:033194const ScreenInfo& RenderWidget::GetOriginalScreenInfo() const {
Christopher Camerone9a30c12018-03-07 08:23:383195 return screen_metrics_emulator_
3196 ? screen_metrics_emulator_->original_screen_info()
Fady Samuela863f152018-03-09 16:10:033197 : screen_info_;
oshima50872a72016-03-04 13:26:183198}
3199
Ella Ge80a52dce2017-11-15 18:01:523200gfx::PointF RenderWidget::ConvertWindowPointToViewport(
3201 const gfx::PointF& point) {
paulmeyer90f6c31d2016-11-12 00:17:593202 blink::WebFloatRect point_in_viewport(point.x(), point.y(), 0, 0);
Blink Reformat1c4d759e2017-04-09 16:34:543203 ConvertWindowToViewport(&point_in_viewport);
Ella Ge80a52dce2017-11-15 18:01:523204 return gfx::PointF(point_in_viewport.x, point_in_viewport.y);
3205}
3206
3207gfx::Point RenderWidget::ConvertWindowPointToViewport(const gfx::Point& point) {
3208 return gfx::ToRoundedPoint(ConvertWindowPointToViewport(gfx::PointF(point)));
paulmeyer90f6c31d2016-11-12 00:17:593209}
3210
Blink Reformat1c4d759e2017-04-09 16:34:543211bool RenderWidget::RequestPointerLock() {
lfgbee1e0a2016-06-08 21:24:213212 return mouse_lock_dispatcher_->LockMouse(webwidget_mouse_lock_target_.get());
3213}
3214
Blink Reformat1c4d759e2017-04-09 16:34:543215void RenderWidget::RequestPointerUnlock() {
lfgbee1e0a2016-06-08 21:24:213216 mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
3217}
3218
Blink Reformat1c4d759e2017-04-09 16:34:543219bool RenderWidget::IsPointerLocked() {
lfgbee1e0a2016-06-08 21:24:213220 return mouse_lock_dispatcher_->IsMouseLockedTo(
3221 webwidget_mouse_lock_target_.get());
3222}
3223
Richard Li49fe04d2018-10-21 09:07:193224void RenderWidget::StartDragging(network::mojom::ReferrerPolicy policy,
paulmeyer6ef5a792016-11-08 20:33:583225 const WebDragData& data,
3226 WebDragOperationsMask mask,
danakj0c75ad82018-07-10 19:50:123227 const SkBitmap& drag_image,
danakjef1735a2018-11-13 19:34:443228 const gfx::Point& web_image_offset) {
3229 blink::WebRect offset_in_window(web_image_offset.x(), web_image_offset.y(), 0,
3230 0);
Blink Reformat1c4d759e2017-04-09 16:34:543231 ConvertViewportToWindow(&offset_in_window);
paulmeyer6ef5a792016-11-08 20:33:583232 DropData drop_data(DropDataBuilder::Build(data));
3233 drop_data.referrer_policy = policy;
danakj0c75ad82018-07-10 19:50:123234 gfx::Vector2d image_offset(offset_in_window.x, offset_in_window.y);
3235 Send(new DragHostMsg_StartDragging(routing_id(), drop_data, mask, drag_image,
3236 image_offset, possible_drag_event_info_));
paulmeyer6ef5a792016-11-08 20:33:583237}
3238
kenrb5d78b842017-03-06 21:06:013239uint32_t RenderWidget::GetContentSourceId() {
3240 return current_content_source_id_;
3241}
3242
Saman Samif7731342018-01-24 22:18:443243void RenderWidget::DidNavigate() {
danakj125a29e2019-01-24 23:25:293244 // Blink may be navigating still between the Close IPC and the task that
3245 // actually closes this class, and for a main frame that would come through
3246 // this method. But since we are closing we can skip it.
3247 if (closing_)
Kinuko Yasudabef2b642019-01-24 04:53:333248 return;
danakj125a29e2019-01-24 23:25:293249
3250 ++current_content_source_id_;
danakja6c10012018-07-06 14:25:363251 layer_tree_view_->SetContentSourceId(current_content_source_id_);
3252 layer_tree_view_->ClearCachesOnNextCommit();
kenrb5d78b842017-03-06 21:06:013253}
3254
lfg8ff33912016-09-13 20:59:213255blink::WebWidget* RenderWidget::GetWebWidget() const {
Albert J. Wong7bbf22d2018-12-20 00:27:273256 if (delegate()) {
3257 blink::WebWidget* delegate_widget = delegate()->GetWebWidgetForWidget();
danakja2c9d0a92018-07-25 20:01:183258 if (delegate_widget)
3259 return delegate_widget;
3260 }
lfg8ff33912016-09-13 20:59:213261 return webwidget_internal_;
3262}
3263
ekaramad2daaf672016-11-10 20:29:013264blink::WebInputMethodController* RenderWidget::GetInputMethodController()
3265 const {
Ehsan Karamad655d7b8a2018-01-12 18:38:383266 if (auto* frame_widget = GetFrameWidget())
3267 return frame_widget->GetActiveWebInputMethodController();
3268
3269 return nullptr;
ekaramad2daaf672016-11-10 20:29:013270}
3271
Dave Tapuska139a72f2017-09-06 21:57:033272void RenderWidget::SetupWidgetInputHandler(
3273 mojom::WidgetInputHandlerRequest request,
3274 mojom::WidgetInputHandlerHostPtr host) {
Dave Tapuskab66c28f2017-11-15 17:18:473275 widget_input_handler_manager_->AddInterface(std::move(request),
3276 std::move(host));
Dave Tapuska525eb15e2017-08-17 21:05:503277}
3278
Dave Tapuska485aca92017-08-08 00:47:583279void RenderWidget::SetWidgetBinding(mojom::WidgetRequest request) {
3280 // Close the old binding if there was one.
3281 // A RenderWidgetHost should not need more than one channel.
3282 widget_binding_.Close();
3283 widget_binding_.Bind(std::move(request));
3284}
3285
Ken Buchanan94c0beb62018-06-22 19:56:243286void RenderWidget::SetMouseCapture(bool capture) {
3287 if (mojom::WidgetInputHandlerHost* host =
3288 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
3289 host->SetMouseCapture(capture);
3290 }
3291}
3292
danakj53802692018-07-25 21:46:443293void RenderWidget::SetWindowScreenRect(const gfx::Rect& window_screen_rect) {
3294 if (screen_metrics_emulator_)
3295 screen_metrics_emulator_->OnUpdateWindowScreenRect(window_screen_rect);
3296 else
3297 window_screen_rect_ = window_screen_rect;
3298}
3299
Fady Samuelca9ecb72018-05-05 05:59:273300bool RenderWidget::IsSurfaceSynchronizationEnabled() const {
danakja6c10012018-07-06 14:25:363301 return layer_tree_view_ &&
3302 layer_tree_view_->IsSurfaceSynchronizationEnabled();
Fady Samuelca9ecb72018-05-05 05:59:273303}
3304
W. James MacLean2a90bff2018-11-05 20:52:473305void RenderWidget::PageScaleFactorChanged(float page_scale_factor) {
danakj0246bba02019-01-23 23:12:273306 // The page scale is controlled by the WebView for the local main frame of
3307 // the Page. So this is called from blink by for the RenderWidget of that
3308 // local main frame. We forward the value on to each child RenderWidget (each
3309 // of which will be via proxy child frame). These will each in turn forward
3310 // the message to their child RenderWidgets (through their proxy child
3311 // frames).
3312 // TODO(crbug.com/924336): This value is continuously propagated during a
3313 // pinch-zoom, causing the child RenderWidgets to re-raster, while the main
3314 // frame is able to throttle re-raster to powers of 2. We could find some way
3315 // to throttle child RenderWidgets also, perhaps by informing them when the
3316 // pinch-zoom gesture is started and stopped.
3317 DCHECK(!is_frozen_);
3318 DCHECK(delegate());
W. James MacLean2a90bff2018-11-05 20:52:473319
W. James MacLean2a90bff2018-11-05 20:52:473320 for (auto& observer : render_frame_proxies_)
3321 observer.OnPageScaleFactorChanged(page_scale_factor);
danakj0246bba02019-01-23 23:12:273322 // Store the value to give to any new RenderFrameProxy that is registered.
3323 page_scale_factor_from_mainframe_ = page_scale_factor;
W. James MacLean2a90bff2018-11-05 20:52:473324}
3325
danakj53802692018-07-25 21:46:443326void RenderWidget::UseSynchronousResizeModeForTesting(bool enable) {
3327 resizing_mode_selector_->set_is_synchronous_mode(enable);
danakja2c9d0a92018-07-25 20:01:183328}
3329
3330void RenderWidget::SetDeviceScaleFactorForTesting(float factor) {
danakjb4cec102019-01-30 19:22:133331 DCHECK_GT(factor, 0.f);
danakja2c9d0a92018-07-25 20:01:183332
danakja2c9d0a92018-07-25 20:01:183333 // We are changing the device scale factor from the renderer, so allocate a
3334 // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
danakj125a29e2019-01-24 23:25:293335 layer_tree_view_->RequestNewLocalSurfaceId();
danakjb4cec102019-01-30 19:22:133336
3337 ScreenInfo info = screen_info_;
3338 info.device_scale_factor = factor;
3339 gfx::Size viewport_pixel_size = gfx::ScaleToCeiledSize(size_, factor);
3340 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
3341 viewport_pixel_size, info);
3342
3343 ResizeWebWidget(); // This picks up the new device scale factor in |info|.
3344
3345 gfx::Size visible_viewport_size = visible_viewport_size_;
3346 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
3347 visible_viewport_size =
3348 gfx::ScaleToCeiledSize(visible_viewport_size, factor);
3349 }
3350 GetWebWidget()->ResizeVisualViewport(visible_viewport_size);
3351
3352 // Make sure the DSF override stays for future VisualProperties updates, and
3353 // that includes overriding the VisualProperties'
3354 // compositor_viewport_pixel_size with size * this for-testing DSF.
3355 device_scale_factor_for_testing_ = factor;
danakja2c9d0a92018-07-25 20:01:183356}
3357
3358void RenderWidget::SetDeviceColorSpaceForTesting(
3359 const gfx::ColorSpace& color_space) {
danakjb4cec102019-01-30 19:22:133360 // We are changing the device color space from the renderer, so allocate a
3361 // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
3362 layer_tree_view_->RequestNewLocalSurfaceId();
3363
danakj04d128a2019-01-25 02:10:203364 ScreenInfo info = screen_info_;
3365 info.color_space = color_space;
3366 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
3367 compositor_viewport_pixel_size_, info);
danakja2c9d0a92018-07-25 20:01:183368}
3369
3370void RenderWidget::SetWindowRectSynchronouslyForTesting(
3371 const gfx::Rect& new_window_rect) {
3372 SetWindowRectSynchronously(new_window_rect);
3373}
3374
3375void RenderWidget::EnableAutoResizeForTesting(const gfx::Size& min_size,
3376 const gfx::Size& max_size) {
3377 VisualProperties visual_properties;
3378 visual_properties.auto_resize_enabled = true;
3379 visual_properties.min_size_for_auto_resize = min_size;
3380 visual_properties.max_size_for_auto_resize = max_size;
Fady Samuel84d8a1f72018-11-08 00:26:173381 visual_properties.local_surface_id_allocation =
3382 base::Optional<viz::LocalSurfaceIdAllocation>(
3383 viz::LocalSurfaceIdAllocation(
3384 viz::LocalSurfaceId(1, 1, base::UnguessableToken::Create()),
3385 base::TimeTicks::Now()));
danakja2c9d0a92018-07-25 20:01:183386 OnSynchronizeVisualProperties(visual_properties);
3387}
3388
3389void RenderWidget::DisableAutoResizeForTesting(const gfx::Size& new_size) {
3390 if (!auto_resize_mode_)
3391 return;
3392
3393 VisualProperties visual_properties;
3394 visual_properties.auto_resize_enabled = false;
3395 visual_properties.screen_info = screen_info_;
3396 visual_properties.new_size = new_size;
3397 visual_properties.compositor_viewport_pixel_size =
3398 compositor_viewport_pixel_size_;
3399 visual_properties.browser_controls_shrink_blink_size =
3400 browser_controls_shrink_blink_size_;
3401 visual_properties.top_controls_height = top_controls_height_;
3402 visual_properties.visible_viewport_size = visible_viewport_size_;
3403 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
3404 visual_properties.display_mode = display_mode_;
danakja2c9d0a92018-07-25 20:01:183405 OnSynchronizeVisualProperties(visual_properties);
3406}
3407
EhsanK955ba582017-11-30 21:14:403408blink::WebLocalFrame* RenderWidget::GetFocusedWebLocalFrameInWidget() const {
Ehsan Karamad655d7b8a2018-01-12 18:38:383409 if (auto* frame_widget = GetFrameWidget())
3410 return frame_widget->FocusedWebLocalFrameInWidget();
3411 return nullptr;
EhsanK955ba582017-11-30 21:14:403412}
3413
EhsanK22d482e2017-08-10 17:29:493414#if BUILDFLAG(ENABLE_PLUGINS)
3415PepperPluginInstanceImpl* RenderWidget::GetFocusedPepperPluginInsideWidget() {
Ehsan Karamad655d7b8a2018-01-12 18:38:383416 blink::WebFrameWidget* frame_widget = GetFrameWidget();
3417 if (!frame_widget)
EhsanK22d482e2017-08-10 17:29:493418 return nullptr;
3419
3420 // Focused pepper instance might not always be in the focused frame. For
3421 // instance if a pepper instance and its embedder frame are focused an then
3422 // another frame takes focus using javascript, the embedder frame will no
3423 // longer be focused while the pepper instance is (the embedder frame's
3424 // |focused_pepper_plugin_| is not nullptr). Especially, if the pepper plugin
3425 // is fullscreen, clicking into the pepper will not refocus the embedder
3426 // frame. This is why we have to traverse the whole frame tree to find the
3427 // focused plugin.
Ehsan Karamad655d7b8a2018-01-12 18:38:383428 blink::WebFrame* current_frame = frame_widget->LocalRoot();
EhsanK22d482e2017-08-10 17:29:493429 while (current_frame) {
3430 RenderFrameImpl* render_frame =
3431 current_frame->IsWebLocalFrame()
3432 ? RenderFrameImpl::FromWebFrame(current_frame)
3433 : nullptr;
3434 if (render_frame && render_frame->focused_pepper_plugin())
3435 return render_frame->focused_pepper_plugin();
3436 current_frame = current_frame->TraverseNext();
3437 }
3438 return nullptr;
3439}
3440#endif
3441
Ken Buchananb2c9e262018-03-10 16:53:313442gfx::Rect RenderWidget::ViewportVisibleRect() {
danakj6dcbc5962018-11-16 16:45:423443 return for_child_local_root_frame_
3444 ? compositor_visible_rect_
3445 : gfx::Rect(compositor_viewport_pixel_size_);
Ken Buchananb2c9e262018-03-10 16:53:313446}
3447
Hajime Hoshi315a61f2018-08-14 17:27:283448// static
3449scoped_refptr<base::SingleThreadTaskRunner>
3450RenderWidget::GetCleanupTaskRunner() {
3451 return RenderThreadImpl::current_blink_platform_impl()
3452 ->main_thread_scheduler()
3453 ->CleanupTaskRunner();
3454}
3455
Saman Sami50d1e0c2018-03-13 20:03:493456base::WeakPtr<RenderWidget> RenderWidget::AsWeakPtr() {
3457 return weak_ptr_factory_.GetWeakPtr();
3458}
3459
[email protected]e9ff79c2012-10-19 21:31:263460} // namespace content