blob: b7efdc434d38a2c8d49d6d3117f446cf3f279a76 [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"
ekaramad9053e57b2016-04-26 20:00:3846#include "content/common/text_input_state.h"
Albert J. Wong3c93c182018-09-27 17:29:4347#include "content/common/widget_messages.h"
mlamouriafca06dd2017-01-27 23:35:1848#include "content/public/common/content_client.h"
changwan7ded3752016-03-09 23:25:1249#include "content/public/common/content_features.h"
[email protected]c08950d22011-10-13 22:20:2950#include "content/public/common/content_switches.h"
[email protected]a09d53ce2014-01-31 00:46:4251#include "content/public/common/context_menu_params.h"
paulmeyer90f6c31d2016-11-12 00:17:5952#include "content/public/common/drop_data.h"
Khushal3e96e662017-10-30 23:16:5053#include "content/public/common/service_names.mojom.h"
Jaebaek Seo655110e2017-12-19 23:27:3954#include "content/public/common/use_zoom_for_dsf_policy.h"
mlamouriafca06dd2017-01-27 23:35:1855#include "content/public/renderer/content_renderer_client.h"
Saman Samid189e5dfd2017-12-20 22:55:3156#include "content/renderer/browser_plugin/browser_plugin.h"
Sadrul Habib Chowdhury31c98712018-12-11 04:15:1357#include "content/renderer/compositor/layer_tree_view.h"
[email protected]953bd0062013-08-01 00:58:4058#include "content/renderer/cursor_utils.h"
mfomitchev2600fd7c2016-02-17 20:53:3959#include "content/renderer/devtools/render_widget_screen_metrics_emulator.h"
paulmeyer6ef5a792016-11-08 20:33:5860#include "content/renderer/drop_data_builder.h"
[email protected]b2e4c70132013-10-03 02:07:5161#include "content/renderer/external_popup_menu.h"
Sadrul Habib Chowdhury31c98712018-12-11 04:15:1362#include "content/renderer/frame_swap_message_queue.h"
[email protected]66fca5bc2013-05-23 06:58:2963#include "content/renderer/ime_event_guard.h"
dtapuska9ec1a912017-04-21 15:18:3164#include "content/renderer/input/main_thread_event_queue.h"
Dave Tapuska9db80842017-07-24 17:24:2665#include "content/renderer/input/widget_input_handler_manager.h"
[email protected]adab2332013-07-25 18:04:3266#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
Sadrul Habib Chowdhury31c98712018-12-11 04:15:1367#include "content/renderer/queue_message_swap_promise.h"
[email protected]bffc8302014-01-23 20:52:1668#include "content/renderer/render_frame_impl.h"
danakj4b347212018-07-04 17:55:1769#include "content/renderer/render_frame_metadata_observer_impl.h"
[email protected]e3244ed2014-06-20 20:04:2770#include "content/renderer/render_frame_proxy.h"
[email protected]8704f89b2011-04-15 00:30:0571#include "content/renderer/render_process.h"
[email protected]f1a29a02011-10-06 23:08:4472#include "content/renderer/render_thread_impl.h"
dcheng3ce04b62015-10-26 23:30:5573#include "content/renderer/render_view_impl.h"
tfarina556a7232014-10-05 01:02:0974#include "content/renderer/renderer_blink_platform_impl.h"
danakj4b347212018-07-04 17:55:1775#include "gpu/command_buffer/service/gpu_switches.h"
ekaramad330ba4232016-09-23 17:57:4776#include "ipc/ipc_message_start.h"
[email protected]484955942010-08-19 16:13:1877#include "ipc/ipc_sync_message.h"
Antoine Laboure55c9ef82017-11-10 18:51:2378#include "ipc/ipc_sync_message_filter.h"
danakj4b347212018-07-04 17:55:1779#include "media/base/media_switches.h"
Scott Violet02e38b92018-03-27 23:42:1480#include "ppapi/buildflags/buildflags.h"
[email protected]661eb9d2009-02-03 02:11:4881#include "skia/ext/platform_canvas.h"
Blink Reformata30d4232018-04-07 15:31:0682#include "third_party/blink/public/platform/file_path_conversion.h"
Hajime Hoshi315a61f2018-08-14 17:27:2883#include "third_party/blink/public/platform/platform.h"
Blink Reformata30d4232018-04-07 15:31:0684#include "third_party/blink/public/platform/scheduler/web_render_widget_scheduling_state.h"
Yuta Kitamuradeb91bb2018-05-29 05:53:2085#include "third_party/blink/public/platform/scheduler/web_thread_scheduler.h"
Blink Reformata30d4232018-04-07 15:31:0686#include "third_party/blink/public/platform/web_cursor_info.h"
87#include "third_party/blink/public/platform/web_drag_data.h"
88#include "third_party/blink/public/platform/web_drag_operation.h"
89#include "third_party/blink/public/platform/web_mouse_event.h"
90#include "third_party/blink/public/platform/web_point.h"
91#include "third_party/blink/public/platform/web_rect.h"
92#include "third_party/blink/public/platform/web_runtime_features.h"
93#include "third_party/blink/public/platform/web_size.h"
94#include "third_party/blink/public/platform/web_string.h"
95#include "third_party/blink/public/web/web_autofill_client.h"
96#include "third_party/blink/public/web/web_device_emulation_params.h"
97#include "third_party/blink/public/web/web_frame_widget.h"
98#include "third_party/blink/public/web/web_input_method_controller.h"
99#include "third_party/blink/public/web/web_local_frame.h"
100#include "third_party/blink/public/web/web_node.h"
101#include "third_party/blink/public/web/web_page_popup.h"
102#include "third_party/blink/public/web/web_popup_menu_info.h"
103#include "third_party/blink/public/web/web_range.h"
104#include "third_party/blink/public/web/web_settings.h"
105#include "third_party/blink/public/web/web_view.h"
106#include "third_party/blink/public/web/web_widget.h"
[email protected]d353541f2012-05-03 22:45:41107#include "third_party/skia/include/core/SkShader.h"
Maksim Sisova33072d22019-01-24 15:44:25108#include "ui/base/clipboard/clipboard_constants.h"
Scott Violet8ff9c302018-02-22 22:28:35109#include "ui/base/ui_base_features.h"
danakj4b347212018-07-04 17:55:17110#include "ui/base/ui_base_switches.h"
dtapuska97286c882017-02-24 23:14:43111#include "ui/events/base_event_utils.h"
tfarina655f81d2014-12-23 02:38:50112#include "ui/gfx/geometry/point_conversions.h"
tfarina3b0452d2014-12-31 15:20:09113#include "ui/gfx/geometry/rect_conversions.h"
tfarinaebe974f02015-01-03 04:25:32114#include "ui/gfx/geometry/size_conversions.h"
[email protected]1835b9e2012-02-28 13:12:48115#include "ui/gfx/skia_util.h"
danakj4b347212018-07-04 17:55:17116#include "ui/gfx/switches.h"
[email protected]c9e2cbbb2012-05-12 21:17:27117#include "ui/gl/gl_switches.h"
danakj4b347212018-07-04 17:55:17118#include "ui/native_theme/native_theme_features.h"
119#include "ui/native_theme/overlay_scrollbar_constants_aura.h"
[email protected]d353541f2012-05-03 22:45:41120#include "ui/surface/transport_dib.h"
[email protected]661eb9d2009-02-03 02:11:48121
[email protected]eeb93112013-05-01 19:41:10122#if defined(OS_ANDROID)
[email protected]cefe9b152014-03-27 18:16:15123#include <android/keycodes.h>
wjmaclean1d970622017-01-21 22:28:24124#include "base/time/time.h"
[email protected]eeb93112013-05-01 19:41:10125#endif
126
[email protected]661eb9d2009-02-03 02:11:48127#if defined(OS_POSIX)
[email protected]d5282e72009-05-13 13:16:52128#include "third_party/skia/include/core/SkMallocPixelRef.h"
[email protected]d353541f2012-05-03 22:45:41129#include "third_party/skia/include/core/SkPixelRef.h"
[email protected]661eb9d2009-02-03 02:11:48130#endif // defined(OS_POSIX)
[email protected]8085dbc82008-09-26 22:53:44131
sadrul943e3b32016-08-04 18:22:59132#if defined(USE_AURA)
sadrul602ce1362017-01-26 06:41:10133#include "content/renderer/mus/renderer_window_tree_client.h"
penghuang28a5fa22015-12-02 17:58:19134#endif
135
ekaramad330ba4232016-09-23 17:57:47136#if defined(OS_MACOSX)
137#include "content/renderer/text_input_client_observer.h"
138#endif
139
Ryan Landay9e42fd742017-08-12 01:59:11140using blink::WebImeTextSpan;
[email protected]180ef242013-11-07 06:50:46141using blink::WebCursorInfo;
[email protected]19193682014-04-03 15:01:43142using blink::WebDeviceEmulationParams;
paulmeyer90f6c31d2016-11-12 00:17:59143using blink::WebDragOperation;
paulmeyer6ef5a792016-11-08 20:33:58144using blink::WebDragOperationsMask;
145using blink::WebDragData;
paulmeyer90f6c31d2016-11-12 00:17:59146using blink::WebFrameWidget;
[email protected]180ef242013-11-07 06:50:46147using blink::WebGestureEvent;
148using blink::WebInputEvent;
dtapuska5d2e9c32015-12-03 16:39:49149using blink::WebInputEventResult;
ekaramad2daaf672016-11-10 20:29:01150using blink::WebInputMethodController;
paulmeyer6ef5a792016-11-08 20:33:58151using blink::WebLocalFrame;
[email protected]180ef242013-11-07 06:50:46152using blink::WebMouseEvent;
153using blink::WebMouseWheelEvent;
154using blink::WebNavigationPolicy;
donnda070f3c2015-01-16 19:54:11155using blink::WebNode;
[email protected]180ef242013-11-07 06:50:46156using blink::WebPagePopup;
dglazkove353a372016-09-01 01:33:48157using blink::WebRange;
[email protected]180ef242013-11-07 06:50:46158using blink::WebRect;
[email protected]180ef242013-11-07 06:50:46159using blink::WebSize;
paulmeyer90f6c31d2016-11-12 00:17:59160using blink::WebString;
[email protected]180ef242013-11-07 06:50:46161using blink::WebTextDirection;
162using blink::WebTouchEvent;
[email protected]f8ed4722013-12-03 03:27:25163using blink::WebTouchPoint;
[email protected]180ef242013-11-07 06:50:46164using blink::WebVector;
165using blink::WebWidget;
[email protected]e9ff79c2012-10-19 21:31:26166
paulmeyer90f6c31d2016-11-12 00:17:59167namespace content {
168
[email protected]6a4d7f62013-01-07 21:32:13169namespace {
[email protected]b256eca2013-07-11 10:57:40170
Albert J. Wong2727e8a82019-02-15 16:56:11171RenderWidget::CreateRenderWidgetFunction g_create_render_widget_for_frame =
172 nullptr;
173
Albert J. Wongcb004632018-07-10 22:58:25174using RoutingIDWidgetMap = std::map<int32_t, RenderWidget*>;
175base::LazyInstance<RoutingIDWidgetMap>::Leaky g_routing_id_widget_map =
176 LAZY_INSTANCE_INITIALIZER;
177
danakj4b347212018-07-04 17:55:17178const base::Feature kUnpremultiplyAndDitherLowBitDepthTiles = {
179 "UnpremultiplyAndDitherLowBitDepthTiles", base::FEATURE_ENABLED_BY_DEFAULT};
180
[email protected]b256eca2013-07-11 10:57:40181typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
182
AJITH KUMAR V041c0b02017-08-08 10:39:20183static const int kInvalidNextPreviousFlagsValue = -1;
yiyix6b90ef52018-10-09 19:55:30184static const char* kOOPIF = "OOPIF";
185static const char* kRenderer = "Renderer";
AJITH KUMAR V041c0b02017-08-08 10:39:20186
lfgbee1e0a2016-06-08 21:24:21187class WebWidgetLockTarget : public content::MouseLockDispatcher::LockTarget {
188 public:
189 explicit WebWidgetLockTarget(blink::WebWidget* webwidget)
190 : webwidget_(webwidget) {}
191
192 void OnLockMouseACK(bool succeeded) override {
193 if (succeeded)
Blink Reformat1c4d759e2017-04-09 16:34:54194 webwidget_->DidAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21195 else
Blink Reformat1c4d759e2017-04-09 16:34:54196 webwidget_->DidNotAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21197 }
198
Blink Reformat1c4d759e2017-04-09 16:34:54199 void OnMouseLockLost() override { webwidget_->DidLosePointerLock(); }
lfgbee1e0a2016-06-08 21:24:21200
201 bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event) override {
202 // The WebWidget handles mouse lock in Blink's handleInputEvent().
203 return false;
204 }
205
206 private:
207 blink::WebWidget* webwidget_;
208};
209
Stephen Chenneyd56b5382019-01-29 00:37:02210class ScopedUkmRafAlignedInputTimer {
211 public:
212 explicit ScopedUkmRafAlignedInputTimer(blink::WebWidget* webwidget)
213 : webwidget_(webwidget) {
214 webwidget_->BeginRafAlignedInput();
215 }
216
217 ~ScopedUkmRafAlignedInputTimer() { webwidget_->EndRafAlignedInput(); }
218
219 private:
220 blink::WebWidget* webwidget_;
221
222 DISALLOW_COPY_AND_ASSIGN(ScopedUkmRafAlignedInputTimer);
223};
224
dglazkov97b6c2b2016-10-25 17:35:55225bool IsDateTimeInput(ui::TextInputType type) {
226 return type == ui::TEXT_INPUT_TYPE_DATE ||
227 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
228 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
229 type == ui::TEXT_INPUT_TYPE_MONTH ||
230 type == ui::TEXT_INPUT_TYPE_TIME || type == ui::TEXT_INPUT_TYPE_WEEK;
231}
232
paulmeyer90f6c31d2016-11-12 00:17:59233WebDragData DropMetaDataToWebDragData(
234 const std::vector<DropData::Metadata>& drop_meta_data) {
235 std::vector<WebDragData::Item> item_list;
236 for (const auto& meta_data_item : drop_meta_data) {
237 if (meta_data_item.kind == DropData::Kind::STRING) {
238 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54239 item.storage_type = WebDragData::Item::kStorageTypeString;
240 item.string_type = WebString::FromUTF16(meta_data_item.mime_type);
paulmeyer90f6c31d2016-11-12 00:17:59241 // Have to pass a dummy URL here instead of an empty URL because the
242 // DropData received by browser_plugins goes through a round trip:
243 // DropData::MetaData --> WebDragData-->DropData. In the end, DropData
244 // will contain an empty URL (which means no URL is dragged) if the URL in
245 // WebDragData is empty.
Maksim Sisova33072d22019-01-24 15:44:25246 if (base::EqualsASCII(meta_data_item.mime_type, ui::kMimeTypeURIList)) {
Blink Reformat1c4d759e2017-04-09 16:34:54247 item.string_data = WebString::FromUTF8("about:dragdrop-placeholder");
paulmeyer90f6c31d2016-11-12 00:17:59248 }
249 item_list.push_back(item);
250 continue;
251 }
252
253 // TODO(hush): crbug.com/584789. Blink needs to support creating a file with
254 // just the mimetype. This is needed to drag files to WebView on Android
255 // platform.
256 if ((meta_data_item.kind == DropData::Kind::FILENAME) &&
257 !meta_data_item.filename.empty()) {
258 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54259 item.storage_type = WebDragData::Item::kStorageTypeFilename;
260 item.filename_data = blink::FilePathToWebString(meta_data_item.filename);
paulmeyer90f6c31d2016-11-12 00:17:59261 item_list.push_back(item);
262 continue;
263 }
264
265 if (meta_data_item.kind == DropData::Kind::FILESYSTEMFILE) {
266 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54267 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
268 item.file_system_url = meta_data_item.file_system_url;
paulmeyer90f6c31d2016-11-12 00:17:59269 item_list.push_back(item);
270 continue;
271 }
272 }
273
274 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54275 result.Initialize();
276 result.SetItems(item_list);
paulmeyer90f6c31d2016-11-12 00:17:59277 return result;
278}
279
280WebDragData DropDataToWebDragData(const DropData& drop_data) {
281 std::vector<WebDragData::Item> item_list;
282
283 // These fields are currently unused when dragging into WebKit.
284 DCHECK(drop_data.download_metadata.empty());
285 DCHECK(drop_data.file_contents.empty());
dcheng3dd85612017-02-08 10:46:23286 DCHECK(drop_data.file_contents_content_disposition.empty());
paulmeyer90f6c31d2016-11-12 00:17:59287
288 if (!drop_data.text.is_null()) {
289 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54290 item.storage_type = WebDragData::Item::kStorageTypeString;
Maksim Sisova33072d22019-01-24 15:44:25291 item.string_type = WebString::FromUTF8(ui::kMimeTypeText);
Blink Reformat1c4d759e2017-04-09 16:34:54292 item.string_data = WebString::FromUTF16(drop_data.text.string());
paulmeyer90f6c31d2016-11-12 00:17:59293 item_list.push_back(item);
294 }
295
296 if (!drop_data.url.is_empty()) {
297 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54298 item.storage_type = WebDragData::Item::kStorageTypeString;
Maksim Sisova33072d22019-01-24 15:44:25299 item.string_type = WebString::FromUTF8(ui::kMimeTypeURIList);
Blink Reformat1c4d759e2017-04-09 16:34:54300 item.string_data = WebString::FromUTF8(drop_data.url.spec());
301 item.title = WebString::FromUTF16(drop_data.url_title);
paulmeyer90f6c31d2016-11-12 00:17:59302 item_list.push_back(item);
303 }
304
305 if (!drop_data.html.is_null()) {
306 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54307 item.storage_type = WebDragData::Item::kStorageTypeString;
Maksim Sisova33072d22019-01-24 15:44:25308 item.string_type = WebString::FromUTF8(ui::kMimeTypeHTML);
Blink Reformat1c4d759e2017-04-09 16:34:54309 item.string_data = WebString::FromUTF16(drop_data.html.string());
310 item.base_url = drop_data.html_base_url;
paulmeyer90f6c31d2016-11-12 00:17:59311 item_list.push_back(item);
312 }
313
jdoerrie5a73d0fa2018-10-02 23:54:05314 for (auto it = drop_data.filenames.begin(); it != drop_data.filenames.end();
paulmeyer90f6c31d2016-11-12 00:17:59315 ++it) {
316 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54317 item.storage_type = WebDragData::Item::kStorageTypeFilename;
318 item.filename_data = blink::FilePathToWebString(it->path);
319 item.display_name_data =
kinukoa4293022017-01-27 06:43:25320 blink::FilePathToWebString(base::FilePath(it->display_name));
paulmeyer90f6c31d2016-11-12 00:17:59321 item_list.push_back(item);
322 }
323
jdoerrie5a73d0fa2018-10-02 23:54:05324 for (auto it = drop_data.file_system_files.begin();
325 it != drop_data.file_system_files.end(); ++it) {
paulmeyer90f6c31d2016-11-12 00:17:59326 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54327 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
328 item.file_system_url = it->url;
329 item.file_system_file_size = it->size;
330 item.file_system_id = blink::WebString::FromASCII(it->filesystem_id);
paulmeyer90f6c31d2016-11-12 00:17:59331 item_list.push_back(item);
332 }
333
Stuart Langley48300392017-11-02 03:54:44334 for (const auto& it : drop_data.custom_data) {
paulmeyer90f6c31d2016-11-12 00:17:59335 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54336 item.storage_type = WebDragData::Item::kStorageTypeString;
Stuart Langley48300392017-11-02 03:54:44337 item.string_type = WebString::FromUTF16(it.first);
338 item.string_data = WebString::FromUTF16(it.second);
paulmeyer90f6c31d2016-11-12 00:17:59339 item_list.push_back(item);
340 }
341
342 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54343 result.Initialize();
344 result.SetItems(item_list);
345 result.SetFilesystemId(WebString::FromUTF16(drop_data.filesystem_id));
paulmeyer90f6c31d2016-11-12 00:17:59346 return result;
347}
348
dtapuskac4dd5be2016-10-25 15:11:10349ui::TextInputType ConvertWebTextInputType(blink::WebTextInputType type) {
350 // Check the type is in the range representable by ui::TextInputType.
351 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX))
352 << "blink::WebTextInputType and ui::TextInputType not synchronized";
353 return static_cast<ui::TextInputType>(type);
354}
355
356ui::TextInputMode ConvertWebTextInputMode(blink::WebTextInputMode mode) {
357 // Check the mode is in the range representable by ui::TextInputMode.
358 DCHECK_LE(mode, static_cast<int>(ui::TEXT_INPUT_MODE_MAX))
359 << "blink::WebTextInputMode and ui::TextInputMode not synchronized";
360 return static_cast<ui::TextInputMode>(mode);
361}
362
Mitsuru Oshima3c07b332018-02-06 04:56:50363// Returns true if the device scale is high enough that losing subpixel
364// antialiasing won't have a noticeable effect on text quality.
365static bool DeviceScaleEnsuresTextQuality(float device_scale_factor) {
366#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
367 // On Android, we never have subpixel antialiasing. On Chrome OS we prefer to
368 // composite all scrollers so that we get animated overlay scrollbars.
369 return true;
370#else
371 // 1.5 is a common touchscreen tablet device scale factor. For such
372 // devices main thread antialiasing is a heavy burden.
373 return device_scale_factor >= 1.5f;
374#endif
375}
376
377static bool PreferCompositingToLCDText(CompositorDependencies* compositor_deps,
378 float device_scale_factor) {
379 const base::CommandLine& command_line =
380 *base::CommandLine::ForCurrentProcess();
381 if (command_line.HasSwitch(switches::kDisablePreferCompositingToLCDText))
382 return false;
383 if (command_line.HasSwitch(switches::kEnablePreferCompositingToLCDText))
384 return true;
385 if (!compositor_deps->IsLcdTextEnabled())
386 return true;
387 return DeviceScaleEnsuresTextQuality(device_scale_factor);
388}
389
[email protected]b256eca2013-07-11 10:57:40390} // namespace
391
[email protected]b2e4c70132013-10-03 02:07:51392// RenderWidget ---------------------------------------------------------------
393
Albert J. Wong2727e8a82019-02-15 16:56:11394// static
395void RenderWidget::InstallCreateForFrameHook(
396 CreateRenderWidgetFunction create_widget) {
397 g_create_render_widget_for_frame = create_widget;
398}
399
400scoped_refptr<RenderWidget> RenderWidget::CreateForFrame(
401 int32_t widget_routing_id,
402 CompositorDependencies* compositor_deps,
403 const ScreenInfo& screen_info,
404 blink::WebDisplayMode display_mode,
405 bool is_frozen,
406 bool hidden,
407 bool never_visible,
408 mojom::WidgetRequest widget_request) {
409 if (g_create_render_widget_for_frame) {
410 return g_create_render_widget_for_frame(
411 widget_routing_id, compositor_deps, screen_info, display_mode,
412 is_frozen, hidden, never_visible, std::move(widget_request));
413 }
414
415 return base::WrapRefCounted(new RenderWidget(
416 widget_routing_id, compositor_deps, screen_info, display_mode, is_frozen,
417 hidden, never_visible, std::move(widget_request)));
418}
419
420scoped_refptr<RenderWidget> RenderWidget::CreateForPopup(
421 int32_t widget_routing_id,
422 CompositorDependencies* compositor_deps,
423 const ScreenInfo& screen_info,
424 blink::WebDisplayMode display_mode,
425 bool is_frozen,
426 bool hidden,
427 bool never_visible,
428 mojom::WidgetRequest widget_request) {
429 return base::WrapRefCounted(new RenderWidget(
430 widget_routing_id, compositor_deps, screen_info, display_mode, is_frozen,
431 hidden, never_visible, std::move(widget_request)));
432}
433
danakj829cdd142018-09-14 21:13:27434RenderWidget::RenderWidget(int32_t widget_routing_id,
435 CompositorDependencies* compositor_deps,
danakj829cdd142018-09-14 21:13:27436 const ScreenInfo& screen_info,
437 blink::WebDisplayMode display_mode,
danakj6dcbc5962018-11-16 16:45:42438 bool is_frozen,
danakj829cdd142018-09-14 21:13:27439 bool hidden,
440 bool never_visible,
441 mojom::WidgetRequest widget_request)
nick8331f8ad2016-11-15 20:42:45442 : routing_id_(widget_routing_id),
dcheng35d31c112015-07-22 00:17:36443 compositor_deps_(compositor_deps),
lfg8ff33912016-09-13 20:59:21444 webwidget_internal_(nullptr),
[email protected]847a2582013-03-09 02:29:51445 auto_resize_mode_(false),
[email protected]1ac10dca2013-08-20 20:47:04446 is_hidden_(hidden),
danakj953af052019-02-06 19:13:18447 // When there's no RenderThreadImpl we can't start the compositor without
448 // crashing, so just behave like a never-visible widget.
449 compositor_never_visible_(never_visible || !RenderThreadImpl::current()),
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12450 is_fullscreen_granted_(false),
danakj73dd3032018-07-28 17:49:53451 display_mode_(display_mode),
changwanf2a707b2015-10-30 08:22:16452 ime_event_guard_(nullptr),
danakj6dcbc5962018-11-16 16:45:42453 is_frozen_(is_frozen),
dglazkov97b6c2b2016-10-25 17:35:55454 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
[email protected]b256eca2013-07-11 10:57:40455 text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
shuchen82ce8c52014-10-23 01:55:20456 text_input_flags_(0),
AJITH KUMAR V041c0b02017-08-08 10:39:20457 next_previous_flags_(kInvalidNextPreviousFlagsValue),
[email protected]86ba5fcb2013-09-04 00:36:53458 can_compose_inline_(true),
nonafa291792016-08-10 02:36:18459 composition_range_(gfx::Range::InvalidRange()),
[email protected]867125a02009-12-10 06:01:48460 pending_window_rect_count_(0),
Scott Violetae08f332018-07-27 17:37:23461 screen_info_(screen_info),
nonafa291792016-08-10 02:36:18462 monitor_composition_info_(false),
[email protected]b2e4c70132013-10-03 02:07:51463 popup_origin_scale_for_emulation_(0.f),
samans26510e442017-06-01 22:29:12464 frame_swap_message_queue_(new FrameSwapMessageQueue(routing_id_)),
lfge0c2792ec2016-05-11 18:52:08465 has_host_context_menu_location_(false),
ekaramad2a46d632016-07-19 13:33:09466 has_focus_(false),
danakj6dcbc5962018-11-16 16:45:42467 for_child_local_root_frame_(false),
ekaramad330ba4232016-09-23 17:57:47468#if defined(OS_MACOSX)
469 text_input_client_observer_(new TextInputClientObserver(this)),
470#endif
Takashi SAKAMOTO870f6262017-08-22 04:08:27471 first_update_visual_state_after_hidden_(false),
tasakb95dbb50c2017-02-08 18:07:50472 was_shown_time_(base::TimeTicks::Now()),
kenrb5d78b842017-03-06 21:06:01473 current_content_source_id_(0),
Dave Tapuska1bdf1832017-07-07 18:07:19474 widget_binding_(this, std::move(widget_request)),
danakjf87460792018-12-04 20:14:22475 warmup_weak_ptr_factory_(this),
wjmaclean1d970622017-01-21 22:28:24476 weak_ptr_factory_(this) {
nick8331f8ad2016-11-15 20:42:45477 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
[email protected]380244092011-10-07 17:26:27478 DCHECK(RenderThread::Get());
alexclarke7fa93942015-10-21 15:37:11479
480 // In tests there may not be a RenderThreadImpl.
481 if (RenderThreadImpl::current()) {
482 render_widget_scheduling_state_ = RenderThreadImpl::current()
Yuta Kitamura3331f5c2018-04-05 11:12:25483 ->GetWebMainThreadScheduler()
dcheng07945f632015-12-26 07:59:32484 ->NewRenderWidgetSchedulingState();
alexclarke7fa93942015-10-21 15:37:11485 render_widget_scheduling_state_->SetHidden(is_hidden_);
486 }
sadrul602ce1362017-01-26 06:41:10487#if defined(USE_AURA)
fsamuel098eade2017-03-21 18:06:14488 RendererWindowTreeClient::CreateIfNecessary(routing_id_);
Scott Violete46b3352018-09-22 00:37:07489 if (features::IsMultiProcessMash())
Scott Violet1098538e2017-10-05 19:23:33490 RendererWindowTreeClient::Get(routing_id_)->SetVisible(!is_hidden_);
sadrul602ce1362017-01-26 06:41:10491#endif
Albert J. Wongcb004632018-07-10 22:58:25492
493 if (routing_id_ != MSG_ROUTING_NONE)
494 g_routing_id_widget_map.Get().emplace(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29495}
496
497RenderWidget::~RenderWidget() {
lfg8ff33912016-09-13 20:59:21498 DCHECK(!webwidget_internal_) << "Leaking our WebWidget!";
Albert J. Wong7bbf22d2018-12-20 00:27:27499
Albert J. Wongcb004632018-07-10 22:58:25500 // TODO(ajwong): Add in check that routing_id_ has been removed from
501 // g_routing_id_widget_map once the shutdown semantics for RenderWidget
502 // and RenderViewImpl are rationalized. Currently, too many unit and
503 // browser tests delete a RenderWidget without correclty going through
504 // the shutdown. https://crbug.com/545684
[email protected]bffc8302014-01-23 20:52:16505
sadrul8185d972017-01-31 18:30:11506#if defined(USE_AURA)
fsamuel098eade2017-03-21 18:06:14507 // It is possible for a RenderWidget to be destroyed before it was embedded
508 // in a mus window. The RendererWindowTreeClient will leak in such cases. So
509 // explicitly delete it here.
510 RendererWindowTreeClient::Destroy(routing_id_);
sadrul8185d972017-01-31 18:30:11511#endif
initial.commit09911bf2008-07-26 23:55:29512}
513
[email protected]484955942010-08-19 16:13:18514// static
Albert J. Wongcb004632018-07-10 22:58:25515RenderWidget* RenderWidget::FromRoutingID(int32_t routing_id) {
516 RoutingIDWidgetMap* widgets = g_routing_id_widget_map.Pointer();
jdoerrie5a73d0fa2018-10-02 23:54:05517 auto it = widgets->find(routing_id);
Albert J. Wongcb004632018-07-10 22:58:25518 return it == widgets->end() ? NULL : it->second;
519}
520
danakj25ec6e2b2018-09-26 17:01:31521void RenderWidget::InitForPopup(ShowCallback show_callback,
522 blink::WebPagePopup* web_page_popup) {
523 // Init() increments the reference count on |this|, making it
524 // self-referencing.
525 Init(std::move(show_callback), web_page_popup);
initial.commit09911bf2008-07-26 23:55:29526}
527
danakj6a816592018-09-25 18:30:56528void RenderWidget::InitForChildLocalRoot(
529 blink::WebFrameWidget* web_frame_widget) {
danakj6dcbc5962018-11-16 16:45:42530 for_child_local_root_frame_ = true;
danakj6a816592018-09-25 18:30:56531 // Init() increments the reference count on |this|, making it
532 // self-referencing.
533 Init(base::NullCallback(), web_frame_widget);
dchengda9b4bb2015-07-20 20:58:08534}
535
dchengda9b4bb2015-07-20 20:58:08536void RenderWidget::CloseForFrame() {
danakj8f0bd6c2019-03-14 15:35:24537 DCHECK(for_child_local_root_frame_);
538 closing_for_child_local_root_frame_ = true;
dchengd96a27a2015-07-24 20:17:32539 OnClose();
kenrba7199832015-01-22 23:44:59540}
541
Scott Violetae08f332018-07-27 17:37:23542void RenderWidget::Init(ShowCallback show_callback, WebWidget* web_widget) {
lfg8ff33912016-09-13 20:59:21543 DCHECK(!webwidget_internal_);
nick4df698d82016-11-11 20:39:23544 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29545
danakj17216f4d2018-10-16 22:57:32546 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
547
Jeremy Roman04f27c372017-10-27 15:20:55548 input_handler_ = std::make_unique<RenderWidgetInputHandler>(this, this);
nick8331f8ad2016-11-15 20:42:45549
danakj17216f4d2018-10-16 22:57:32550 LayerTreeView* layer_tree_view = InitializeLayerTreeView();
danakje3bd12622019-02-13 21:54:16551 web_widget->SetLayerTreeView(layer_tree_view,
552 layer_tree_view->animation_host());
Dave Tapuska9db80842017-07-24 17:24:26553
danakj31699d5b2018-09-18 15:39:17554 blink::scheduler::WebThreadScheduler* main_thread_scheduler = nullptr;
555 if (render_thread_impl)
556 main_thread_scheduler = render_thread_impl->GetWebMainThreadScheduler();
Alexander Timin41e917d2018-07-02 16:25:35557 blink::scheduler::WebThreadScheduler* compositor_thread_scheduler =
558 blink::scheduler::WebThreadScheduler::CompositorThreadScheduler();
danakj31699d5b2018-09-18 15:39:17559 scoped_refptr<base::SingleThreadTaskRunner> compositor_input_task_runner;
danakj89ae4532018-12-12 22:52:55560 // Use the compositor thread task runner unless this is a popup or other such
561 // non-frame widgets. The |compositor_thread_scheduler| can be null in tests
562 // without a compositor thread.
563 if (for_frame() && compositor_thread_scheduler) {
564 compositor_input_task_runner =
565 compositor_thread_scheduler->InputTaskRunner();
danakj31699d5b2018-09-18 15:39:17566 }
Alexander Timin41e917d2018-07-02 16:25:35567
David Bokan3fc68482019-03-13 04:48:49568 // We only use an external input handler for frame RenderWidgets because only
569 // frames use the compositor for input handling. Other kinds of RenderWidgets
570 // (e.g. popups, plugins) must forward their input directly through
571 // RenderWidgetInputHandler into Blink.
572 bool uses_input_handler = for_frame();
Dave Tapuska04bc5ee92018-04-17 19:03:31573 widget_input_handler_manager_ = WidgetInputHandlerManager::Create(
danakj31699d5b2018-09-18 15:39:17574 weak_ptr_factory_.GetWeakPtr(), std::move(compositor_input_task_runner),
David Bokan3fc68482019-03-13 04:48:49575 main_thread_scheduler, uses_input_handler);
Dave Tapuska9db80842017-07-24 17:24:26576
danakjdf1ceb72018-07-18 20:02:25577 show_callback_ = std::move(show_callback);
initial.commit09911bf2008-07-26 23:55:29578
lfg8ff33912016-09-13 20:59:21579 webwidget_internal_ = web_widget;
580 webwidget_mouse_lock_target_.reset(
581 new WebWidgetLockTarget(webwidget_internal_));
lfgbee1e0a2016-06-08 21:24:21582 mouse_lock_dispatcher_.reset(new RenderWidgetMouseLockDispatcher(this));
initial.commit09911bf2008-07-26 23:55:29583
nick4df698d82016-11-11 20:39:23584 RenderThread::Get()->AddRoute(routing_id_, this);
585 // Take a reference on behalf of the RenderThread. This will be balanced
Albert J. Wong3c93c182018-09-27 17:29:43586 // when we receive WidgetMsg_Close.
nick4df698d82016-11-11 20:39:23587 AddRef();
danakj6ec39d302019-03-15 22:43:22588
589 initialized_ = true;
initial.commit09911bf2008-07-26 23:55:29590}
591
danakj53802692018-07-25 21:46:44592void RenderWidget::ApplyEmulatedScreenMetricsForPopupWidget(
593 RenderWidget* origin_widget) {
594 RenderWidgetScreenMetricsEmulator* emulator =
595 origin_widget->screen_metrics_emulator_.get();
596 if (!emulator)
597 return;
[email protected]b2e4c70132013-10-03 02:07:51598 popup_origin_scale_for_emulation_ = emulator->scale();
[email protected]19193682014-04-03 15:01:43599 popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
Pavel Feldmancc099f72017-07-20 23:09:00600 popup_screen_origin_for_emulation_ =
Lei Zhang9b359d32017-11-28 00:57:02601 emulator->original_screen_rect().origin();
Fady Samuel1c1ad3692018-11-06 23:28:40602 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
danakj0d963bd2019-02-20 18:00:46603 CompositorViewportSize(),
Fady Samuel1c1ad3692018-11-06 23:28:40604 emulator->original_screen_info());
[email protected]b2e4c70132013-10-03 02:07:51605}
606
[email protected]2d6836f42014-07-02 17:25:31607gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) {
608 if (screen_metrics_emulator_)
609 return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor);
610 return anchor;
611}
612
thakis18e426412017-03-15 12:06:37613#if BUILDFLAG(USE_EXTERNAL_POPUP_MENU)
[email protected]b2e4c70132013-10-03 02:07:51614void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
Albert J. Wong7bbf22d2018-12-20 00:27:27615 ExternalPopupMenu* popup) {
616 if (screen_metrics_emulator_)
617 popup->SetOriginScaleForEmulation(screen_metrics_emulator_->scale());
[email protected]b2e4c70132013-10-03 02:07:51618}
[email protected]53907862014-03-25 15:42:40619#endif
[email protected]b2e4c70132013-10-03 02:07:51620
621void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
622 if (screen_metrics_emulator_)
623 screen_metrics_emulator_->OnShowContextMenu(params);
624}
625
[email protected]a95986a82010-12-24 06:19:28626bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
ekaramad330ba4232016-09-23 17:57:47627#if defined(OS_MACOSX)
628 if (IPC_MESSAGE_CLASS(message) == TextInputClientMsgStart)
629 return text_input_client_observer_->OnMessageReceived(message);
630#endif
lfgbee1e0a2016-06-08 21:24:21631 if (mouse_lock_dispatcher_ &&
632 mouse_lock_dispatcher_->OnMessageReceived(message))
633 return true;
634
[email protected]a95986a82010-12-24 06:19:28635 bool handled = true;
636 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
Albert J. Wong3c93c182018-09-27 17:29:43637 IPC_MESSAGE_HANDLER(WidgetMsg_ShowContextMenu, OnShowContextMenu)
638 IPC_MESSAGE_HANDLER(WidgetMsg_Close, OnClose)
639 IPC_MESSAGE_HANDLER(WidgetMsg_SynchronizeVisualProperties,
Fady Samuel799e72192018-04-25 21:16:57640 OnSynchronizeVisualProperties)
Albert J. Wong3c93c182018-09-27 17:29:43641 IPC_MESSAGE_HANDLER(WidgetMsg_EnableDeviceEmulation,
dgozman9260b0a12015-03-16 13:45:20642 OnEnableDeviceEmulation)
Albert J. Wong3c93c182018-09-27 17:29:43643 IPC_MESSAGE_HANDLER(WidgetMsg_DisableDeviceEmulation,
dgozman9260b0a12015-03-16 13:45:20644 OnDisableDeviceEmulation)
Albert J. Wong3c93c182018-09-27 17:29:43645 IPC_MESSAGE_HANDLER(WidgetMsg_WasHidden, OnWasHidden)
646 IPC_MESSAGE_HANDLER(WidgetMsg_WasShown, OnWasShown)
647 IPC_MESSAGE_HANDLER(WidgetMsg_SetActive, OnSetActive)
Albert J. Wong3c93c182018-09-27 17:29:43648 IPC_MESSAGE_HANDLER(WidgetMsg_SetTextDirection, OnSetTextDirection)
649 IPC_MESSAGE_HANDLER(WidgetMsg_SetBounds_ACK, OnRequestSetBoundsAck)
650 IPC_MESSAGE_HANDLER(WidgetMsg_UpdateScreenRects, OnUpdateScreenRects)
651 IPC_MESSAGE_HANDLER(WidgetMsg_ForceRedraw, OnForceRedraw)
652 IPC_MESSAGE_HANDLER(WidgetMsg_SetViewportIntersection,
kenrbea731792017-01-13 15:10:48653 OnSetViewportIntersection)
Albert J. Wong3c93c182018-09-27 17:29:43654 IPC_MESSAGE_HANDLER(WidgetMsg_SetIsInert, OnSetIsInert)
655 IPC_MESSAGE_HANDLER(WidgetMsg_SetInheritedEffectiveTouchAction,
sunxd540a9962018-05-24 22:51:06656 OnSetInheritedEffectiveTouchAction)
Albert J. Wong3c93c182018-09-27 17:29:43657 IPC_MESSAGE_HANDLER(WidgetMsg_UpdateRenderThrottlingStatus,
Ken Buchanan8a319fb2017-11-15 18:37:12658 OnUpdateRenderThrottlingStatus)
Albert J. Wong3c93c182018-09-27 17:29:43659 IPC_MESSAGE_HANDLER(WidgetMsg_WaitForNextFrameForTests,
lfg43e08e62016-02-03 18:51:37660 OnWaitNextFrameForTests)
paulmeyer90f6c31d2016-11-12 00:17:59661 IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter)
662 IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver, OnDragTargetDragOver)
663 IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave, OnDragTargetDragLeave)
664 IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop)
paulmeyer8fc8ea92016-11-15 05:12:21665 IPC_MESSAGE_HANDLER(DragMsg_SourceEnded, OnDragSourceEnded)
666 IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded,
667 OnDragSourceSystemDragEnded)
[email protected]a95986a82010-12-24 06:19:28668 IPC_MESSAGE_UNHANDLED(handled = false)
669 IPC_END_MESSAGE_MAP()
670 return handled;
671}
initial.commit09911bf2008-07-26 23:55:29672
673bool RenderWidget::Send(IPC::Message* message) {
Nasko Oskovf97e8b02017-07-25 02:45:42674 // Don't send any messages after the browser has told us to close, and filter
danakj6dcbc5962018-11-16 16:45:42675 // most outgoing messages when frozen.
676 if (closing_) {
677 delete message;
678 return false;
679 }
680 if (is_frozen_ && !SwappedOutMessages::CanSendWhileSwappedOut(message)) {
initial.commit09911bf2008-07-26 23:55:29681 delete message;
682 return false;
683 }
684
685 // If given a messsage without a routing ID, then assign our routing ID.
686 if (message->routing_id() == MSG_ROUTING_NONE)
687 message->set_routing_id(routing_id_);
688
[email protected]380244092011-10-07 17:26:27689 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44690}
691
dtapuska014ed082016-11-11 21:58:48692void RenderWidget::SendOrCrash(IPC::Message* message) {
693 bool result = Send(message);
694 CHECK(closing_ || result) << "Failed to send message";
695}
696
ekaramad5aff1942017-01-06 01:26:35697bool RenderWidget::ShouldHandleImeEvents() const {
Albert J. Wong7bbf22d2018-12-20 00:27:27698 if (delegate())
danakj89ae4532018-12-12 22:52:55699 return has_focus_;
700 if (for_child_local_root_frame_) {
701 // TODO(ekaramad): We track page focus in all RenderViews on the page but
702 // the RenderWidgets corresponding to child local roots do not get the
703 // update. For now, this method returns true when the RenderWidget is for a
704 // child local frame, i.e., IME events will be processed regardless of page
705 // focus. We should revisit this after page focus for OOPIFs has been fully
706 // resolved (https://crbug.com/689777).
707 return true;
708 }
709 // Not a frame widget.
710 return false;
ekaramad5aff1942017-01-06 01:26:35711}
712
initial.commit09911bf2008-07-26 23:55:29713void RenderWidget::OnClose() {
dchengd96a27a2015-07-24 20:17:32714 DCHECK(content::RenderThread::Get());
danakj8f0bd6c2019-03-14 15:35:24715 // TODO(crbug.com/939262): If this fails we're handling a WidgetMsg_Close IPC
716 // in a RenderWidget that is a child local root. This will leave the
717 // RenderWidget in a closed state while the blink-side is not closed until the
718 // frame is detached, leading to crashes later if it tries to use the
719 // RenderWidget.
720 if (for_child_local_root_frame_)
721 CHECK(closing_for_child_local_root_frame_);
dchengd96a27a2015-07-24 20:17:32722 if (closing_)
723 return;
danakj292b63e2018-11-19 20:47:06724 for (auto& observer : render_frames_)
725 observer.WidgetWillClose();
dchengd96a27a2015-07-24 20:17:32726 closing_ = true;
727
728 // Browser correspondence is no longer needed at this point.
729 if (routing_id_ != MSG_ROUTING_NONE) {
730 RenderThread::Get()->RemoveRoute(routing_id_);
Albert J. Wongcb004632018-07-10 22:58:25731 g_routing_id_widget_map.Get().erase(routing_id_);
dchengd96a27a2015-07-24 20:17:32732 }
733
danakj327a4fe2019-01-26 00:00:35734 // Stop handling main thread input events immediately so we don't have them
735 // running while things are partly shut down.
736 if (input_event_queue_)
737 input_event_queue_->ClearClient();
738
danakj6dcbc5962018-11-16 16:45:42739 if (for_child_local_root_frame_) {
dchengd96a27a2015-07-24 20:17:32740 // Widgets for frames may be created and closed at any time while the frame
Ken Buchananed449bb2018-02-01 21:02:05741 // is alive. However, WebWidget must be closed synchronously because frame
742 // widgets and frames hold pointers to each other. The deferred call to
743 // Close() will complete cleanup and release |this|, but CloseWebWidget()
744 // prevents Close() from attempting to access members of an
745 // already-deleted frame.
746 CloseWebWidget();
dchengd96a27a2015-07-24 20:17:32747 }
Ken Buchananed449bb2018-02-01 21:02:05748 // If there is a Send call on the stack, then it could be dangerous to close
749 // now. Post a task that only gets invoked when there are no nested message
750 // loops.
Albert J. Wong2727e8a82019-02-15 16:56:11751 //
752 // The asynchronous Close() takes an owning reference to |this| keeping the
753 // object alive beyond the Release() below. It is the last reference to this
754 // object.
755 //
756 // TODO(https://crbug.com/545684): The actual lifetime for RenderWidget
757 // seems to be single-owner. It is either owned by "IPC" events (popup,
758 // mainframe, and fullscreen), or a RenderFrame. If Close() self-deleting,
759 // all the ref-counting mess could be removed.
Hajime Hoshi315a61f2018-08-14 17:27:28760 GetCleanupTaskRunner()->PostNonNestableTask(
761 FROM_HERE, base::BindOnce(&RenderWidget::Close, this));
dchengd96a27a2015-07-24 20:17:32762
763 // Balances the AddRef taken when we called AddRoute.
764 Release();
initial.commit09911bf2008-07-26 23:55:29765}
766
Fady Samuel799e72192018-04-25 21:16:57767void RenderWidget::OnSynchronizeVisualProperties(
danakja2c9d0a92018-07-25 20:01:18768 const VisualProperties& original_params) {
769 TRACE_EVENT0("renderer", "RenderWidget::OnSynchronizeVisualProperties");
EhsanKbd2cea992017-11-23 18:49:08770
danakja2c9d0a92018-07-25 20:01:18771 VisualProperties params = original_params;
danakj01474dd2019-01-28 10:46:04772 // Web tests can override the device scale factor in the renderer.
773 if (device_scale_factor_for_testing_) {
danakjb4cec102019-01-30 19:22:13774 params.screen_info.device_scale_factor = device_scale_factor_for_testing_;
danakj01474dd2019-01-28 10:46:04775 params.compositor_viewport_pixel_size = gfx::ScaleToCeiledSize(
776 params.new_size, params.screen_info.device_scale_factor);
777 }
danakj04d128a2019-01-25 02:10:20778
779 // Inform the rendering thread of the color space indicating the presence of
780 // HDR capabilities. The HDR bit happens to be globally true/false for all
781 // browser windows (on Windows OS) and thus would be the same for all
782 // RenderWidgets, so clobbering each other works out since only the HDR bit is
783 // used. See https://crbug.com/803451 and
784 // https://chromium-review.googlesource.com/c/chromium/src/+/852912/15#message-68bbd3e25c3b421a79cd028b2533629527d21fee
785 //
786 // The RenderThreadImpl can be null in tests.
787 {
788 RenderThreadImpl* render_thread = RenderThreadImpl::current();
789 if (render_thread)
790 render_thread->SetRenderingColorSpace(params.screen_info.color_space);
791 }
792
Albert J. Wong7bbf22d2018-12-20 00:27:27793 if (delegate()) {
danakj84bbf552019-01-21 21:33:31794 if (size_ != params.new_size) {
795 // Only hide popups when the size changes. Eg https://crbug.com/761908.
796 delegate()->CancelPagePopupForWidget();
797 }
danakja2c9d0a92018-07-25 20:01:18798
799 if (display_mode_ != params.display_mode) {
800 display_mode_ = params.display_mode;
Albert J. Wong7bbf22d2018-12-20 00:27:27801 delegate()->ApplyNewDisplayModeForWidget(params.display_mode);
danakja2c9d0a92018-07-25 20:01:18802 }
803
804 bool auto_resize_mode_changed =
805 auto_resize_mode_ != params.auto_resize_enabled;
806 auto_resize_mode_ = params.auto_resize_enabled;
807 min_size_for_auto_resize_ = params.min_size_for_auto_resize;
808 max_size_for_auto_resize_ = params.max_size_for_auto_resize;
809
810 if (auto_resize_mode_) {
811 gfx::Size min_auto_size = min_size_for_auto_resize_;
812 gfx::Size max_auto_size = max_size_for_auto_resize_;
813 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
814 min_auto_size = gfx::ScaleToCeiledSize(
815 min_auto_size, params.screen_info.device_scale_factor);
816 max_auto_size = gfx::ScaleToCeiledSize(
817 max_auto_size, params.screen_info.device_scale_factor);
818 }
Albert J. Wong7bbf22d2018-12-20 00:27:27819 delegate()->ApplyAutoResizeLimitsForWidget(min_auto_size, max_auto_size);
danakja2c9d0a92018-07-25 20:01:18820 } else if (auto_resize_mode_changed) {
Albert J. Wong7bbf22d2018-12-20 00:27:27821 delegate()->DisableAutoResizeForWidget();
danakja2c9d0a92018-07-25 20:01:18822 if (params.new_size.IsEmpty())
823 return;
824 }
825
826 browser_controls_shrink_blink_size_ =
827 params.browser_controls_shrink_blink_size;
828 top_controls_height_ = params.top_controls_height;
829 bottom_controls_height_ = params.bottom_controls_height;
[email protected]b2e4c70132013-10-03 02:07:51830 }
831
danakj7602f4f2019-01-31 18:03:23832 bool ignore_resize_ipc = false;
833 if (synchronous_resize_mode_for_testing_) {
834 // We can ignore browser-initialized resizing during synchronous
835 // (renderer-controlled) mode, unless it is switching us to/from
836 // fullsreen mode or changing the device scale factor.
837 // TODO(danakj): Does the browser actually change DSF inside a web test??
838 // TODO(danakj): Isn't the display mode check redundant with the fullscreen
839 // one?
840 if (params.is_fullscreen_granted == is_fullscreen_granted_ &&
841 params.display_mode == display_mode_ &&
842 params.screen_info.device_scale_factor ==
843 screen_info_.device_scale_factor)
844 ignore_resize_ipc = true;
845 }
846
847 // When controlling the size in the renderer, we should ignore sizes given by
848 // the browser IPC here.
849 // TODO(danakj): There are many things also being ignored that aren't the
850 // widget's size params. It works because tests that use this mode don't
851 // change those parameters, I guess. But it's more complicated then because it
852 // looks like they are related to sync resize mode. Let's move them out of
853 // this block.
854 // TODO(danakj): It would be nice if we can still use the emulator to emulate
855 // things other than the size if we are in sync resize mode - if the emulator
856 // is even used in sync resize tests. It probably isn't though, so either way
857 // it'd be good to get the emulator out of this block (maybe by overwriting
858 // some of |params| in sync resize mode instead of just skipping the emulator.
859 if (!ignore_resize_ipc) {
danakja2c9d0a92018-07-25 20:01:18860 if (screen_metrics_emulator_) {
danakj7602f4f2019-01-31 18:03:23861 // This will call our SynchronizeVisualProperties() method with a
862 // different set of VisualProperties, holding emulated values. Though not
863 // all VisualProperties are modified by the metrics emulator, so it's a
864 // bit unclear to do this with the full structure. Anything it does not
865 // modify can be consumed directly here instead of in
866 // SynchronizeVisualProperties().
danakja2c9d0a92018-07-25 20:01:18867 screen_metrics_emulator_->OnSynchronizeVisualProperties(params);
868 } else {
danakj0246bba02019-01-23 23:12:27869 if (!delegate()) {
870 // The main frame controls the page scale factor, from blink. For other
871 // frame widgets, the page scale is received from its parent as part of
872 // the visual properties here. While blink doesn't need to know this
873 // page scale factor outside the main frame, the compositor does in
874 // order to produce its output at the correct scale.
875 layer_tree_view_->SetExternalPageScaleFactor(params.page_scale_factor);
876 // Store the value to give to any new RenderFrameProxy that is
877 // registered.
878 page_scale_factor_from_mainframe_ = params.page_scale_factor;
879 // Push the page scale factor down to any child RenderWidgets via our
880 // child proxy frames.
881 // TODO(danakj): This ends up setting the page scale factor in the
882 // RenderWidgetHost of the child RenderWidget, so that it can bounce
883 // the value down to its RenderWidget. Since this is essentially a
884 // global value per-page, we could instead store it once in the browser
885 // (such as in RenderViewHost) and distribute it to each frame-hosted
886 // RenderWidget from there.
887 for (auto& child_proxy : render_frame_proxies_)
888 child_proxy.OnPageScaleFactorChanged(params.page_scale_factor);
889 }
890
danakja2c9d0a92018-07-25 20:01:18891 gfx::Size old_visible_viewport_size = visible_viewport_size_;
892 SynchronizeVisualProperties(params);
893 if (old_visible_viewport_size != visible_viewport_size_) {
894 for (auto& render_frame : render_frames_)
Nicolas Ouellet-Payeur93e16152019-03-11 14:27:33895 render_frame.DidChangeVisibleViewport();
danakja2c9d0a92018-07-25 20:01:18896 }
897 }
Fady Samuel799e72192018-04-25 21:16:57898 }
899
Albert J. Wong7bbf22d2018-12-20 00:27:27900 if (delegate() && params.scroll_focused_node_into_view)
901 delegate()->ScrollFocusedNodeIntoViewForWidget();
initial.commit09911bf2008-07-26 23:55:29902}
903
dgozman9260b0a12015-03-16 13:45:20904void RenderWidget::OnEnableDeviceEmulation(
Lei Zhang9b359d32017-11-28 00:57:02905 const blink::WebDeviceEmulationParams& params) {
mfomitchev2600fd7c2016-02-17 20:53:39906 if (!screen_metrics_emulator_) {
Fady Samuel4255c182018-05-24 20:42:36907 VisualProperties visual_properties;
908 visual_properties.screen_info = screen_info_;
909 visual_properties.new_size = size_;
danakj0d963bd2019-02-20 18:00:46910 visual_properties.compositor_viewport_pixel_size = CompositorViewportSize();
Fady Samuel84d8a1f72018-11-08 00:26:17911 visual_properties.local_surface_id_allocation =
912 local_surface_id_allocation_from_parent_;
Fady Samuel4255c182018-05-24 20:42:36913 visual_properties.visible_viewport_size = visible_viewport_size_;
914 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
915 visual_properties.display_mode = display_mode_;
mfomitchev2600fd7c2016-02-17 20:53:39916 screen_metrics_emulator_.reset(new RenderWidgetScreenMetricsEmulator(
Albert J. Wong3c93c182018-09-27 17:29:43917 this, params, visual_properties, widget_screen_rect_,
Fady Samuel4255c182018-05-24 20:42:36918 window_screen_rect_));
oshima50872a72016-03-04 13:26:18919 screen_metrics_emulator_->Apply();
mfomitchev2600fd7c2016-02-17 20:53:39920 } else {
dgozman9260b0a12015-03-16 13:45:20921 screen_metrics_emulator_->ChangeEmulationParams(params);
mfomitchev2600fd7c2016-02-17 20:53:39922 }
dgozman9260b0a12015-03-16 13:45:20923}
924
925void RenderWidget::OnDisableDeviceEmulation() {
926 screen_metrics_emulator_.reset();
927}
928
initial.commit09911bf2008-07-26 23:55:29929void RenderWidget::OnWasHidden() {
danakj14e00a8322019-02-07 17:12:06930 // A frozen main frame widget will never be hidden since that would require it
931 // to be shown first. It must be thawed before changing visibility.
932 DCHECK(!is_frozen_);
933
[email protected]9c3085f2011-06-09 02:10:31934 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
danakj14e00a8322019-02-07 17:12:06935
[email protected]bee16aab2009-08-26 15:55:03936 SetHidden(true);
danakj14e00a8322019-02-07 17:12:06937
ericwilligers88e69742016-10-17 19:29:55938 for (auto& observer : render_frames_)
939 observer.WasHidden();
initial.commit09911bf2008-07-26 23:55:29940}
941
Saman Samie61e5c032018-11-05 22:11:44942void RenderWidget::OnWasShown(base::TimeTicks show_request_timestamp,
Edwin Joea4a4c312019-03-14 19:47:32943 bool was_evicted,
944 base::TimeTicks tab_switch_start_time) {
danakj14e00a8322019-02-07 17:12:06945 // A frozen main frame widget does not become shown, since it has no frame
946 // associated with it. It must be thawed before changing visibility.
947 DCHECK(!is_frozen_);
948
Edwin Joea4069f42019-02-20 15:06:24949 TRACE_EVENT_WITH_FLOW0("renderer", "RenderWidget::OnWasShown", routing_id(),
950 TRACE_EVENT_FLAG_FLOW_IN);
danakj678f0252018-11-09 21:46:34951
tasakb95dbb50c2017-02-08 18:07:50952 was_shown_time_ = base::TimeTicks::Now();
danakj14e00a8322019-02-07 17:12:06953
[email protected]bee16aab2009-08-26 15:55:03954 SetHidden(false);
danakj125a29e2019-01-24 23:25:29955 if (!show_request_timestamp.is_null()) {
danakja6c10012018-07-06 14:25:36956 layer_tree_view_->layer_tree_host()->RequestPresentationTimeForNextFrame(
Edwin Joea4a4c312019-03-14 19:47:32957 tab_switch_time_recorder_.BeginTimeRecording(
958 tab_switch_start_time, false /* has_saved_frames */,
959 show_request_timestamp));
[email protected]3399dd822014-08-09 11:14:24960 }
danakj14e00a8322019-02-07 17:12:06961
962 for (auto& observer : render_frames_)
963 observer.WasShown();
964 if (was_evicted) {
965 for (auto& observer : render_frame_proxies_)
966 observer.WasEvicted();
967 }
initial.commit09911bf2008-07-26 23:55:29968}
969
Avi Drissman014dec72018-06-07 02:34:01970void RenderWidget::OnRequestSetBoundsAck() {
[email protected]53d3f302009-12-21 04:42:05971 DCHECK(pending_window_rect_count_);
972 pending_window_rect_count_--;
973}
974
Albert J. Wongcb004632018-07-10 22:58:25975void RenderWidget::OnForceRedraw(int snapshot_id) {
David Bokanf92eaf22019-03-01 01:54:51976 RequestPresentation(base::BindOnce(&RenderWidget::DidPresentForceDrawFrame,
977 weak_ptr_factory_.GetWeakPtr(),
978 snapshot_id));
979}
980
981void RenderWidget::RequestPresentation(PresentationTimeCallback callback) {
danakj125a29e2019-01-24 23:25:29982 layer_tree_view_->layer_tree_host()->RequestPresentationTimeForNextFrame(
David Bokanf92eaf22019-03-01 01:54:51983 std::move(callback));
danakj125a29e2019-01-24 23:25:29984 layer_tree_view_->SetNeedsForcedRedraw();
David Bokanf92eaf22019-03-01 01:54:51985
986 // Need this since single thread mode doesn't have a scheduler so the above
987 // call won't cause us to generate a new frame.
988 ScheduleAnimation();
Albert J. Wongcb004632018-07-10 22:58:25989}
990
991void RenderWidget::DidPresentForceDrawFrame(
992 int snapshot_id,
993 const gfx::PresentationFeedback& feedback) {
Albert J. Wong3c93c182018-09-27 17:29:43994 Send(new WidgetHostMsg_ForceRedrawComplete(routing_id(), snapshot_id));
Albert J. Wongcb004632018-07-10 22:58:25995}
996
Xianzhu Wangf02017ac2018-10-17 01:47:33997viz::FrameSinkId RenderWidget::GetFrameSinkIdAtPoint(const gfx::PointF& point,
Ken Buchanan44d7e2f2018-08-23 14:18:05998 gfx::PointF* local_point) {
999 return input_handler_->GetFrameSinkIdAtPoint(point, local_point);
Navid Zolghadr0d86e5f2017-10-23 18:09:221000}
1001
danakj327a4fe2019-01-26 00:00:351002bool RenderWidget::HandleInputEvent(
dtapuska9ec1a912017-04-21 15:18:311003 const blink::WebCoalescedInputEvent& input_event,
1004 const ui::LatencyInfo& latency_info,
Dave Tapuskaea83d3bd2017-06-13 16:14:551005 HandledEventCallback callback) {
danakj327a4fe2019-01-26 00:00:351006 if (is_frozen_)
1007 return false;
Dave Tapuskaea83d3bd2017-06-13 16:14:551008 input_handler_->HandleInputEvent(input_event, latency_info,
1009 std::move(callback));
danakj327a4fe2019-01-26 00:00:351010 return true;
dtapuska9ec1a912017-04-21 15:18:311011}
1012
danakj125a29e2019-01-24 23:25:291013void RenderWidget::SetNeedsMainFrame() {
danakj0719e0652019-03-14 21:19:111014 ScheduleAnimation();
danakj125a29e2019-01-24 23:25:291015}
1016
dtapuska9d46ef7d2017-05-26 19:06:061017scoped_refptr<MainThreadEventQueue> RenderWidget::GetInputEventQueue() {
1018 return input_event_queue_;
1019}
1020
fsamuel78f86e42016-01-20 04:10:231021void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
lfg8ff33912016-09-13 20:59:211022 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:541023 GetWebWidget()->SetCursorVisibilityState(is_visible);
fsamuel78f86e42016-01-20 04:10:231024}
1025
1026void RenderWidget::OnMouseCaptureLost() {
lfg8ff33912016-09-13 20:59:211027 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:541028 GetWebWidget()->MouseCaptureLost();
fsamuel78f86e42016-01-20 04:10:231029}
1030
alexmos56567492016-09-13 00:52:461031void RenderWidget::OnSetEditCommandsForNextKeyEvent(
1032 const EditCommands& edit_commands) {
1033 edit_commands_ = edit_commands;
1034}
1035
Albert J. Wongcb004632018-07-10 22:58:251036void RenderWidget::OnSetActive(bool active) {
Albert J. Wong7bbf22d2018-12-20 00:27:271037 if (delegate())
1038 delegate()->SetActiveForWidget(active);
Albert J. Wongcb004632018-07-10 22:58:251039}
1040
fsamuel78f86e42016-01-20 04:10:231041void RenderWidget::OnSetFocus(bool enable) {
Albert J. Wong7bbf22d2018-12-20 00:27:271042 if (delegate())
1043 delegate()->DidReceiveSetFocusEventForWidget();
danakja2c9d0a92018-07-25 20:01:181044 SetFocus(enable);
1045}
1046
1047void RenderWidget::SetFocus(bool enable) {
lfge0c2792ec2016-05-11 18:52:081048 has_focus_ = enable;
1049
lfg8ff33912016-09-13 20:59:211050 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:541051 GetWebWidget()->SetFocus(enable);
lfge0c2792ec2016-05-11 18:52:081052
ericwilligers88e69742016-10-17 19:29:551053 for (auto& observer : render_frames_)
1054 observer.RenderWidgetSetFocus(enable);
danakja2c9d0a92018-07-25 20:01:181055
Albert J. Wong7bbf22d2018-12-20 00:27:271056 if (delegate())
1057 delegate()->DidChangeFocusForWidget();
fsamuel78f86e42016-01-20 04:10:231058}
1059
fsamuel78f86e42016-01-20 04:10:231060///////////////////////////////////////////////////////////////////////////////
danakja6c10012018-07-06 14:25:361061// LayerTreeViewDelegate
fsamuel78f86e42016-01-20 04:10:231062
David Bokanc8e38d02018-10-08 21:56:011063void RenderWidget::ApplyViewportChanges(
1064 const cc::ApplyViewportChangesArgs& args) {
Ken Buchananed449bb2018-02-01 21:02:051065 if (!GetWebWidget())
1066 return;
David Bokanc8e38d02018-10-08 21:56:011067 GetWebWidget()->ApplyViewportChanges(args);
fsamuel78f86e42016-01-20 04:10:231068}
1069
sahel1b47fda72017-03-28 17:03:071070void RenderWidget::RecordWheelAndTouchScrollingCount(
1071 bool has_scrolled_by_wheel,
1072 bool has_scrolled_by_touch) {
Ken Buchananed449bb2018-02-01 21:02:051073 if (!GetWebWidget())
1074 return;
Blink Reformat1c4d759e2017-04-09 16:34:541075 GetWebWidget()->RecordWheelAndTouchScrollingCount(has_scrolled_by_wheel,
sahel1b47fda72017-03-28 17:03:071076 has_scrolled_by_touch);
1077}
1078
Sahel Sharify676580c2019-01-10 21:49:491079void RenderWidget::SendOverscrollEventFromImplSide(
1080 const gfx::Vector2dF& overscroll_delta,
1081 cc::ElementId scroll_latched_element_id) {
1082 if (!GetWebWidget())
1083 return;
1084 GetWebWidget()->SendOverscrollEventFromImplSide(overscroll_delta,
1085 scroll_latched_element_id);
1086}
1087void RenderWidget::SendScrollEndEventFromImplSide(
1088 cc::ElementId scroll_latched_element_id) {
1089 if (!GetWebWidget())
1090 return;
1091 GetWebWidget()->SendScrollEndEventFromImplSide(scroll_latched_element_id);
1092}
1093
Daniel Cheng224569ee2018-04-25 05:45:061094void RenderWidget::BeginMainFrame(base::TimeTicks frame_time) {
Ken Buchananed449bb2018-02-01 21:02:051095 if (!GetWebWidget())
1096 return;
dtapuska3d5624d32016-08-30 04:34:001097
Stephen Chenneyd56b5382019-01-29 00:37:021098 // We record metrics only when running in multi-threaded mode, not
1099 // single-thread mode for testing.
1100 bool record_main_frame_metrics =
1101 !!compositor_deps_->GetCompositorImplThreadTaskRunner();
1102 if (input_event_queue_) {
1103 base::Optional<ScopedUkmRafAlignedInputTimer> ukm_timer;
1104 if (record_main_frame_metrics)
1105 ukm_timer.emplace(GetWebWidget());
1106 input_event_queue_->DispatchRafAlignedInput(frame_time);
1107 }
1108
1109 GetWebWidget()->BeginFrame(frame_time, record_main_frame_metrics);
fsamuel78f86e42016-01-20 04:10:231110}
1111
Stefan Zager148248c2019-02-20 23:24:081112void RenderWidget::DidBeginMainFrame() {
1113 if (!GetWebWidget())
1114 return;
1115 GetWebWidget()->DidBeginFrame();
1116}
1117
danakjc7afae52017-06-20 21:12:411118void RenderWidget::RequestNewLayerTreeFrameSink(
danakja6c10012018-07-06 14:25:361119 LayerTreeFrameSinkCallback callback) {
[email protected]7912e822014-04-16 02:37:031120 // For widgets that are never visible, we don't start the compositor, so we
danakjc7afae52017-06-20 21:12:411121 // never get a request for a cc::LayerTreeFrameSink.
sievers71c62dd52015-10-07 01:44:391122 DCHECK(!compositor_never_visible_);
danakjf87460792018-12-04 20:14:221123 // Frozen RenderWidgets should not be doing any compositing.
Scott Violetb04f16c2018-11-27 00:48:461124 DCHECK(!is_frozen_);
danakj678f0252018-11-09 21:46:341125
1126 if (is_closing()) {
1127 // In this case, we drop the request which means the compositor waits
1128 // forever, which is fine since we're going to destroy it.
1129 return;
1130 }
jonrossa2ff4f82018-02-16 17:27:461131
danakjf87460792018-12-04 20:14:221132 // If we have a warmup in progress, wait for that and store the callback
1133 // to be run when the warmup completes.
1134 if (warmup_frame_sink_request_pending_) {
1135 after_warmup_callback_ = std::move(callback);
1136 return;
1137 }
1138 // If a warmup previously completed, use the result.
1139 if (warmup_frame_sink_) {
1140 std::move(callback).Run(std::move(warmup_frame_sink_));
1141 return;
1142 }
1143
1144 DoRequestNewLayerTreeFrameSink(std::move(callback));
1145}
1146
1147void RenderWidget::DoRequestNewLayerTreeFrameSink(
1148 LayerTreeFrameSinkCallback callback) {
jonrossa2ff4f82018-02-16 17:27:461149 // TODO(jonross): have this generated by the LayerTreeFrameSink itself, which
1150 // would then handle binding.
1151 mojom::RenderFrameMetadataObserverPtr ptr;
1152 mojom::RenderFrameMetadataObserverRequest request = mojo::MakeRequest(&ptr);
1153 mojom::RenderFrameMetadataObserverClientPtrInfo client_info;
1154 mojom::RenderFrameMetadataObserverClientRequest client_request =
1155 mojo::MakeRequest(&client_info);
danakj4b347212018-07-04 17:55:171156 auto render_frame_metadata_observer =
1157 std::make_unique<RenderFrameMetadataObserverImpl>(std::move(request),
1158 std::move(client_info));
danakja6c10012018-07-06 14:25:361159 layer_tree_view_->SetRenderFrameObserver(
danakj4b347212018-07-04 17:55:171160 std::move(render_frame_metadata_observer));
danakjf51754372018-12-13 23:20:011161 GURL url = GetWebWidget()->GetURLForDebugTrace();
danakjefabf312018-10-05 19:03:071162 // The |url| is not always available, fallback to a fixed string.
1163 if (url.is_empty())
1164 url = GURL("chrome://gpu/RenderWidget::RequestNewLayerTreeFrameSink");
danakj6dcbc5962018-11-16 16:45:421165 // TODO(danakj): This may not be accurate, depending on the intent. A child
1166 // local root could be in the same process as the view, so if the client is
1167 // meant to designate the process type, it seems kRenderer would be the
1168 // correct choice. If client is meant to designate the widget type, then
1169 // kOOPIF would denote that it is not for the main frame. However, kRenderer
1170 // would also be used for other widgets such as popups.
1171 const char* client_name = for_child_local_root_frame_ ? kOOPIF : kRenderer;
Scott Violetb04f16c2018-11-27 00:48:461172 RenderThreadImpl::current()->RequestNewLayerTreeFrameSink(
1173 routing_id_, frame_swap_message_queue_, std::move(url),
1174 std::move(callback), std::move(client_request), std::move(ptr),
1175 client_name);
[email protected]ba91a792013-02-06 09:48:281176}
1177
fsamuel78f86e42016-01-20 04:10:231178void RenderWidget::DidCommitAndDrawCompositorFrame() {
1179 // NOTE: Tests may break if this event is renamed or moved. See
1180 // tab_capture_performancetest.cc.
1181 TRACE_EVENT0("gpu", "RenderWidget::DidCommitAndDrawCompositorFrame");
lfge0c2792ec2016-05-11 18:52:081182
ericwilligers88e69742016-10-17 19:29:551183 for (auto& observer : render_frames_)
1184 observer.DidCommitAndDrawCompositorFrame();
lfge0c2792ec2016-05-11 18:52:081185
fsamuel78f86e42016-01-20 04:10:231186 // Notify subclasses that we initiated the paint operation.
1187 DidInitiatePaint();
Yiming Zhou0f8836c22018-09-13 22:22:111188
Albert J. Wongfb64e142018-10-16 01:10:451189 Send(new WidgetHostMsg_DidCommitAndDrawCompositorFrame(routing_id_));
fsamuel78f86e42016-01-20 04:10:231190}
1191
Saman Sami766e0b02018-01-31 17:19:201192void RenderWidget::DidCommitCompositorFrame() {
Albert J. Wong7bbf22d2018-12-20 00:27:271193 if (delegate())
1194 delegate()->DidCommitCompositorFrameForWidget();
Saman Sami766e0b02018-01-31 17:19:201195}
fsamuel78f86e42016-01-20 04:10:231196
danakja2c9d0a92018-07-25 20:01:181197void RenderWidget::DidCompletePageScaleAnimation() {
Albert J. Wong7bbf22d2018-12-20 00:27:271198 if (delegate())
1199 delegate()->DidCompletePageScaleAnimationForWidget();
danakja2c9d0a92018-07-25 20:01:181200}
fsamuel78f86e42016-01-20 04:10:231201
danakjcd417502019-03-13 16:13:211202void RenderWidget::SetLayerTreeMutator(
1203 std::unique_ptr<cc::LayerTreeMutator> mutator) {
1204 layer_tree_view_->layer_tree_host()->SetLayerTreeMutator(std::move(mutator));
1205}
1206
danakj26b99912019-02-08 18:58:191207void RenderWidget::SetRootLayer(scoped_refptr<cc::Layer> layer) {
1208 layer_tree_view_->layer_tree_host()->SetRootLayer(std::move(layer));
1209}
1210
danakj53f46b82018-12-11 20:55:551211void RenderWidget::ScheduleAnimation() {
danakj6ec39d302019-03-15 22:43:221212 CHECK(initialized_);
1213 CHECK(!closed_);
danakj94e73eb2019-03-08 19:26:321214 // TODO(crbug.com/939262): This shouldn't be null. That would mean we're
1215 // somehow using RenderWidget after it has closed.
danakj8f0bd6c2019-03-14 15:35:241216 if (!layer_tree_view_) {
1217 // Determine if this object is for a child or main frame (it should be one
1218 // of them!)
danakj6ec39d302019-03-15 22:43:221219 CHECK(!for_child_local_root_frame_);
1220 CHECK(!delegate_);
1221 CHECK(for_child_local_root_frame_ || delegate_);
danakj8f0bd6c2019-03-14 15:35:241222 }
danakj53f46b82018-12-11 20:55:551223 // This call is not needed in single thread mode for tests without a
danakj0719e0652019-03-14 21:19:111224 // scheduler, but they override this method in order to schedule a synchronous
1225 // composite task themselves.
danakj53f46b82018-12-11 20:55:551226 layer_tree_view_->SetNeedsBeginFrame();
initial.commit09911bf2008-07-26 23:55:291227}
1228
danakjefcb8432019-01-16 18:47:141229void RenderWidget::SetShowFPSCounter(bool show) {
1230 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1231 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1232 debug_state.show_fps_counter = show;
1233 host->SetDebugState(debug_state);
1234}
1235
danakje691e852019-01-16 22:49:041236void RenderWidget::SetShowPaintRects(bool show) {
1237 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1238 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1239 debug_state.show_paint_rects = show;
1240 host->SetDebugState(debug_state);
1241}
1242
1243void RenderWidget::SetShowDebugBorders(bool show) {
1244 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1245 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1246 if (show)
1247 debug_state.show_debug_borders.set();
1248 else
1249 debug_state.show_debug_borders.reset();
1250 host->SetDebugState(debug_state);
1251}
1252
1253void RenderWidget::SetShowScrollBottleneckRects(bool show) {
1254 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1255 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1256 debug_state.show_touch_event_handler_rects = show;
1257 debug_state.show_wheel_event_handler_rects = show;
1258 debug_state.show_non_fast_scrollable_rects = show;
1259 host->SetDebugState(debug_state);
1260}
1261
1262void RenderWidget::SetShowHitTestBorders(bool show) {
1263 cc::LayerTreeHost* host = layer_tree_view_->layer_tree_host();
1264 cc::LayerTreeDebugState debug_state = host->GetDebugState();
1265 debug_state.show_hit_test_borders = show;
1266 host->SetDebugState(debug_state);
1267}
1268
danakj40d07932019-02-28 18:07:101269void RenderWidget::SetBackgroundColor(SkColor color) {
1270 layer_tree_view_->layer_tree_host()->set_background_color(color);
1271}
1272
Stephen Chenneyd56b5382019-01-29 00:37:021273void RenderWidget::UpdateVisualState() {
Ken Buchananed449bb2018-02-01 21:02:051274 if (!GetWebWidget())
1275 return;
1276
Stephen Chenneyd56b5382019-01-29 00:37:021277 // We record metrics only when running in multi-threaded mode, not
1278 // single-thread mode for testing.
1279 bool record_main_frame_metrics =
1280 !!compositor_deps_->GetCompositorImplThreadTaskRunner();
1281
Stephen Chenneyec4312612018-11-21 12:40:161282 // When recording main frame metrics set the lifecycle reason to
1283 // kBeginMainFrame, because this is the calller of UpdateLifecycle
1284 // for the main frame. Otherwise, set the reason to kTests, which is
1285 // the oinly other reason this method is called.
1286 WebWidget::LifecycleUpdateReason lifecycle_reason =
1287 record_main_frame_metrics
1288 ? WebWidget::LifecycleUpdateReason::kBeginMainFrame
1289 : WebWidget::LifecycleUpdateReason::kTest;
1290 GetWebWidget()->UpdateLifecycle(WebWidget::LifecycleUpdate::kAll,
1291 lifecycle_reason);
Blink Reformat1c4d759e2017-04-09 16:34:541292 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(false);
tasakb95dbb50c2017-02-08 18:07:501293
Robert Flack3ef2ffb2018-09-06 20:38:201294 if (first_update_visual_state_after_hidden_) {
Takashi SAKAMOTO870f6262017-08-22 04:08:271295 RecordTimeToFirstActivePaint();
1296 first_update_visual_state_after_hidden_ = false;
1297 }
1298}
tasakb95dbb50c2017-02-08 18:07:501299
Takashi SAKAMOTO870f6262017-08-22 04:08:271300void RenderWidget::RecordTimeToFirstActivePaint() {
tasakb95dbb50c2017-02-08 18:07:501301 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
tasakb95dbb50c2017-02-08 18:07:501302 base::TimeDelta sample = base::TimeTicks::Now() - was_shown_time_;
Takashi SAKAMOTO870f6262017-08-22 04:08:271303 if (render_thread_impl->NeedsToRecordFirstActivePaint(TTFAP_AFTER_PURGED)) {
1304 UMA_HISTOGRAM_TIMES("PurgeAndSuspend.Experimental.TimeToFirstActivePaint",
1305 sample);
1306 }
1307 if (render_thread_impl->NeedsToRecordFirstActivePaint(
1308 TTFAP_5MIN_AFTER_BACKGROUNDED)) {
1309 UMA_HISTOGRAM_TIMES(
1310 "PurgeAndSuspend.Experimental.TimeToFirstActivePaint."
1311 "AfterBackgrounded.5min",
1312 sample);
1313 }
fsamuel78f86e42016-01-20 04:10:231314}
1315
Stephen Chenneyd56b5382019-01-29 00:37:021316void RenderWidget::RecordStartOfFrameMetrics() {
1317 if (!GetWebWidget())
1318 return;
1319
1320 GetWebWidget()->RecordStartOfFrameMetrics();
1321}
1322
Stephen Chenney9879a5c2018-09-26 14:21:421323void RenderWidget::RecordEndOfFrameMetrics(base::TimeTicks frame_begin_time) {
1324 if (!GetWebWidget())
1325 return;
1326
1327 GetWebWidget()->RecordEndOfFrameMetrics(frame_begin_time);
1328}
1329
fsamuel78f86e42016-01-20 04:10:231330void RenderWidget::WillBeginCompositorFrame() {
1331 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
1332
Ken Buchananed449bb2018-02-01 21:02:051333 if (!GetWebWidget())
1334 return;
1335
Blink Reformat1c4d759e2017-04-09 16:34:541336 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(true);
alancutter317a8e02017-04-05 10:09:291337
dglazkov06854c5c2016-08-31 00:19:591338 // The UpdateTextInputState can result in further layout and possibly
1339 // enable GPU acceleration so they need to be called before any painting
1340 // is done.
changwan75e3b2072017-01-16 02:55:001341 UpdateTextInputState();
dglazkov06854c5c2016-08-31 00:19:591342 UpdateSelectionBounds();
1343
ericwilligers88e69742016-10-17 19:29:551344 for (auto& observer : render_frame_proxies_)
1345 observer.WillBeginCompositorFrame();
initial.commit09911bf2008-07-26 23:55:291346}
1347
Kent Tamura21d1de62018-12-10 04:45:201348std::unique_ptr<cc::SwapPromise> RenderWidget::RequestCopyOfOutputForWebTest(
Fady Samueldfecb7d2017-07-26 11:41:041349 std::unique_ptr<viz::CopyOutputRequest> request) {
Kent Tamura21d1de62018-12-10 04:45:201350 return RenderThreadImpl::current()->RequestCopyOfOutputForWebTest(
jbroman6ccbc7d472016-07-27 04:45:411351 routing_id_, std::move(request));
1352}
1353
fsamuel72464894f2015-12-15 06:59:311354///////////////////////////////////////////////////////////////////////////////
1355// RenderWidgetInputHandlerDelegate
1356
avid7d6b2e2016-03-04 19:41:171357void RenderWidget::FocusChangeComplete() {
Ehsan Karamad655d7b8a2018-01-12 18:38:381358 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1359 if (!frame_widget)
ekaramad27ca69b12017-04-20 18:34:291360 return;
Ehsan Karamad655d7b8a2018-01-12 18:38:381361
ekaramad27ca69b12017-04-20 18:34:291362 blink::WebLocalFrame* focused =
Ehsan Karamad655d7b8a2018-01-12 18:38:381363 frame_widget->LocalRoot()->View()->FocusedFrame();
1364
ekaramad27ca69b12017-04-20 18:34:291365 if (focused && focused->AutofillClient())
1366 focused->AutofillClient()->DidCompleteFocusChangeInFrame();
avid7d6b2e2016-03-04 19:41:171367}
fsamuel72464894f2015-12-15 06:59:311368
dtapuska1827dd22016-03-11 15:24:591369void RenderWidget::ObserveGestureEventAndResult(
1370 const blink::WebGestureEvent& gesture_event,
1371 const gfx::Vector2dF& unused_delta,
Sandra Sunac5cdd832017-12-11 03:27:131372 const cc::OverscrollBehavior& overscroll_behavior,
dtapuska1827dd22016-03-11 15:24:591373 bool event_processed) {
1374 if (!compositor_deps_->IsElasticOverscrollEnabled())
1375 return;
1376
1377 cc::InputHandlerScrollResult scroll_result;
1378 scroll_result.did_scroll = event_processed;
1379 scroll_result.did_overscroll_root = !unused_delta.IsZero();
1380 scroll_result.unused_scroll_delta = unused_delta;
Sandra Sunac5cdd832017-12-11 03:27:131381 scroll_result.overscroll_behavior = overscroll_behavior;
dtapuska1827dd22016-03-11 15:24:591382
Dave Tapuska04bc5ee92018-04-17 19:03:311383 widget_input_handler_manager_->ObserveGestureEventOnMainThread(gesture_event,
1384 scroll_result);
dtapuska1827dd22016-03-11 15:24:591385}
1386
avid7d6b2e2016-03-04 19:41:171387void RenderWidget::OnDidHandleKeyEvent() {
alexmos56567492016-09-13 00:52:461388 ClearEditCommands();
1389}
1390
1391void RenderWidget::SetEditCommandForNextKeyEvent(const std::string& name,
1392 const std::string& value) {
1393 ClearEditCommands();
1394 edit_commands_.emplace_back(name, value);
1395}
1396
1397void RenderWidget::ClearEditCommands() {
1398 edit_commands_.clear();
avid7d6b2e2016-03-04 19:41:171399}
fsamuel72464894f2015-12-15 06:59:311400
chongza8ba91fc2016-08-16 21:39:171401void RenderWidget::OnDidOverscroll(const ui::DidOverscrollParams& params) {
Dave Tapuska04bc5ee92018-04-17 19:03:311402 if (mojom::WidgetInputHandlerHost* host =
1403 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
1404 host->DidOverscroll(params);
Dave Tapuska139a72f2017-09-06 21:57:031405 }
fsamuel72464894f2015-12-15 06:59:311406}
1407
fsamuele8326c742016-01-12 00:49:391408void RenderWidget::SetInputHandler(RenderWidgetInputHandler* input_handler) {
1409 // Nothing to do here. RenderWidget created the |input_handler| and will take
1410 // ownership of it. We just verify here that we don't already have an input
1411 // handler.
1412 DCHECK(!input_handler_);
1413}
1414
changwan75e3b2072017-01-16 02:55:001415void RenderWidget::ShowVirtualKeyboard() {
danakj125a29e2019-01-24 23:25:291416 // Blink can continue running and change input state between the Close IPC
1417 // and the task that actually closes this class.
1418 if (closing_)
1419 return;
changwan75e3b2072017-01-16 02:55:001420 UpdateTextInputStateInternal(true, false);
1421}
1422
changwan62f57292017-02-17 08:28:251423void RenderWidget::ClearTextInputState() {
1424 text_input_info_ = blink::WebTextInputInfo();
1425 text_input_type_ = ui::TextInputType::TEXT_INPUT_TYPE_NONE;
1426 text_input_mode_ = ui::TextInputMode::TEXT_INPUT_MODE_DEFAULT;
1427 can_compose_inline_ = false;
1428 text_input_flags_ = 0;
AJITH KUMAR V041c0b02017-08-08 10:39:201429 next_previous_flags_ = kInvalidNextPreviousFlagsValue;
changwan62f57292017-02-17 08:28:251430}
1431
changwan75e3b2072017-01-16 02:55:001432void RenderWidget::UpdateTextInputState() {
danakj125a29e2019-01-24 23:25:291433 // Blink can continue running and change input state between the Close IPC
1434 // and the task that actually closes this class.
1435 if (closing_)
1436 return;
changwan75e3b2072017-01-16 02:55:001437 UpdateTextInputStateInternal(false, false);
1438}
1439
1440void RenderWidget::UpdateTextInputStateInternal(bool show_virtual_keyboard,
1441 bool reply_to_request) {
fsamuel72464894f2015-12-15 06:59:311442 TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState");
changwan75e3b2072017-01-16 02:55:001443
fsamuel72464894f2015-12-15 06:59:311444 if (ime_event_guard_) {
changwan75e3b2072017-01-16 02:55:001445 DCHECK(!reply_to_request);
1446 // show_virtual_keyboard should still be effective even if it was set inside
1447 // the IME
fsamuel72464894f2015-12-15 06:59:311448 // event guard.
changwan75e3b2072017-01-16 02:55:001449 if (show_virtual_keyboard)
1450 ime_event_guard_->set_show_virtual_keyboard(true);
fsamuel72464894f2015-12-15 06:59:311451 return;
1452 }
1453
dglazkov97b6c2b2016-10-25 17:35:551454 ui::TextInputType new_type = GetTextInputType();
1455 if (IsDateTimeInput(new_type))
1456 return; // Not considered as a text input field in WebKit/Chromium.
fsamuel72464894f2015-12-15 06:59:311457
dglazkov97b6c2b2016-10-25 17:35:551458 blink::WebTextInputInfo new_info;
ekaramad5aff1942017-01-06 01:26:351459 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:541460 new_info = controller->TextInputInfo();
dtapuskac4dd5be2016-10-25 15:11:101461 const ui::TextInputMode new_mode =
Blink Reformat1c4d759e2017-04-09 16:34:541462 ConvertWebTextInputMode(new_info.input_mode);
fsamuel72464894f2015-12-15 06:59:311463
1464 bool new_can_compose_inline = CanComposeInline();
1465
1466 // Only sends text input params if they are changed or if the ime should be
1467 // shown.
changwan75e3b2072017-01-16 02:55:001468 if (show_virtual_keyboard || reply_to_request ||
changwan38c3eb612016-12-09 01:45:561469 text_input_type_ != new_type || text_input_mode_ != new_mode ||
1470 text_input_info_ != new_info ||
1471 can_compose_inline_ != new_can_compose_inline) {
ekaramad9053e57b2016-04-26 20:00:381472 TextInputState params;
dglazkov97b6c2b2016-10-25 17:35:551473 params.type = new_type;
fsamuel72464894f2015-12-15 06:59:311474 params.mode = new_mode;
1475 params.flags = new_info.flags;
AJITH KUMAR V9e7b5572017-11-14 00:54:211476#if defined(OS_ANDROID)
AJITH KUMAR V041c0b02017-08-08 10:39:201477 if (next_previous_flags_ == kInvalidNextPreviousFlagsValue) {
1478 // Due to a focus change, values will be reset by the frame.
1479 // That case we only need fresh NEXT/PREVIOUS information.
Albert J. Wong3c93c182018-09-27 17:29:431480 // Also we won't send WidgetHostMsg_TextInputStateChanged if next/previous
AJITH KUMAR V041c0b02017-08-08 10:39:201481 // focusable status is changed.
1482 if (auto* controller = GetInputMethodController()) {
1483 next_previous_flags_ =
1484 controller->ComputeWebTextInputNextPreviousFlags();
1485 } else {
1486 // For safety in case GetInputMethodController() is null, because -1 is
1487 // invalid value to send to browser process.
1488 next_previous_flags_ = 0;
1489 }
1490 }
AJITH KUMAR V9e7b5572017-11-14 00:54:211491#else
1492 next_previous_flags_ = 0;
1493#endif
AJITH KUMAR V041c0b02017-08-08 10:39:201494 params.flags |= next_previous_flags_;
Yuichiro Hanada1b19cf852019-01-18 16:12:261495 params.value = new_info.value.Utf16();
Blink Reformat1c4d759e2017-04-09 16:34:541496 params.selection_start = new_info.selection_start;
1497 params.selection_end = new_info.selection_end;
1498 params.composition_start = new_info.composition_start;
1499 params.composition_end = new_info.composition_end;
fsamuel72464894f2015-12-15 06:59:311500 params.can_compose_inline = new_can_compose_inline;
changwan75e3b2072017-01-16 02:55:001501 // TODO(changwan): change instances of show_ime_if_needed to
1502 // show_virtual_keyboard.
1503 params.show_ime_if_needed = show_virtual_keyboard;
1504 params.reply_to_request = reply_to_request;
Albert J. Wong3c93c182018-09-27 17:29:431505 Send(new WidgetHostMsg_TextInputStateChanged(routing_id(), params));
fsamuel72464894f2015-12-15 06:59:311506
1507 text_input_info_ = new_info;
dglazkov97b6c2b2016-10-25 17:35:551508 text_input_type_ = new_type;
fsamuel72464894f2015-12-15 06:59:311509 text_input_mode_ = new_mode;
1510 can_compose_inline_ = new_can_compose_inline;
1511 text_input_flags_ = new_info.flags;
Eric Karl706ea6712018-12-21 22:41:381512
1513#if defined(OS_ANDROID)
1514 // If we send a new TextInputStateChanged message, we must also deliver a
1515 // new RenderFrameMetadata, as the IME will need this info to be updated.
1516 // TODO(ericrk): Consider folding the above IPC into RenderFrameMetadata.
1517 // https://crbug.com/912309
danakj125a29e2019-01-24 23:25:291518 if (IsSurfaceSynchronizationEnabled()) {
Eric Karl706ea6712018-12-21 22:41:381519 layer_tree_view_->RequestForceSendMetadata();
1520 }
1521#endif
fsamuel72464894f2015-12-15 06:59:311522 }
1523}
1524
1525bool RenderWidget::WillHandleGestureEvent(const blink::WebGestureEvent& event) {
paulmeyer6ef5a792016-11-08 20:33:581526 possible_drag_event_info_.event_source =
1527 ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH;
1528 possible_drag_event_info_.event_location =
Ella Ge1116059d2018-03-21 02:06:131529 gfx::ToFlooredPoint(event.PositionInScreen());
avid7d6b2e2016-03-04 19:41:171530
fsamuel72464894f2015-12-15 06:59:311531 return false;
1532}
1533
1534bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
ericwilligers88e69742016-10-17 19:29:551535 for (auto& observer : render_frames_)
1536 observer.RenderWidgetWillHandleMouseEvent();
lfge0c2792ec2016-05-11 18:52:081537
paulmeyer6ef5a792016-11-08 20:33:581538 possible_drag_event_info_.event_source =
1539 ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
1540 possible_drag_event_info_.event_location =
Blink Reformat1c4d759e2017-04-09 16:34:541541 gfx::Point(event.PositionInScreen().x, event.PositionInScreen().y);
paulmeyer6ef5a792016-11-08 20:33:581542
Albert J. Wong7bbf22d2018-12-20 00:27:271543 if (delegate())
1544 return delegate()->RenderWidgetWillHandleMouseEventForWidget(event);
avid7d6b2e2016-03-04 19:41:171545
fsamuel72464894f2015-12-15 06:59:311546 return false;
[email protected]fd847792013-10-24 17:12:351547}
1548
initial.commit09911bf2008-07-26 23:55:291549///////////////////////////////////////////////////////////////////////////////
mfomitchev2600fd7c2016-02-17 20:53:391550// RenderWidgetScreenMetricsDelegate
1551
bokanc63441c2016-04-27 15:49:121552void RenderWidget::ResizeWebWidget() {
danakja2c9d0a92018-07-25 20:01:181553 gfx::Size size = GetSizeForWebWidget();
Albert J. Wong7bbf22d2018-12-20 00:27:271554 if (delegate()) {
1555 delegate()->ResizeWebWidgetForWidget(size, top_controls_height_,
1556 bottom_controls_height_,
1557 browser_controls_shrink_blink_size_);
danakja2c9d0a92018-07-25 20:01:181558 return;
1559 }
1560 GetWebWidget()->Resize(size);
bokanc63441c2016-04-27 15:49:121561}
1562
1563gfx::Size RenderWidget::GetSizeForWebWidget() const {
danakj4b347212018-07-04 17:55:171564 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:031565 return gfx::ScaleToCeiledSize(size_,
1566 GetOriginalScreenInfo().device_scale_factor);
1567 }
bokanc63441c2016-04-27 15:49:121568
1569 return size_;
1570}
1571
danakj0d963bd2019-02-20 18:00:461572gfx::Size RenderWidget::CompositorViewportSize() const {
1573 return layer_tree_view_->layer_tree_host()->device_viewport_size();
1574}
1575
akaba3483d8f2018-07-10 21:43:091576void RenderWidget::UpdateZoom(double zoom_level) {
akabac6bd1212018-06-25 20:10:481577 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1578 if (!frame_widget)
1579 return;
1580 RenderFrameImpl* render_frame =
1581 RenderFrameImpl::FromWebFrame(frame_widget->LocalRoot());
1582
akaba3483d8f2018-07-10 21:43:091583 // Return early if zoom level is unchanged.
1584 if (render_frame->GetZoomLevel() == zoom_level) {
akabac6bd1212018-06-25 20:10:481585 return;
1586 }
1587
akaba3483d8f2018-07-10 21:43:091588 render_frame->SetZoomLevel(zoom_level);
akabac6bd1212018-06-25 20:10:481589
1590 for (auto& observer : render_frame_proxies_)
akaba3483d8f2018-07-10 21:43:091591 observer.OnZoomLevelChanged(zoom_level);
akabac6bd1212018-06-25 20:10:481592
1593 for (auto& plugin : browser_plugins_)
akaba3483d8f2018-07-10 21:43:091594 plugin.OnZoomLevelChanged(zoom_level);
akabac6bd1212018-06-25 20:10:481595}
1596
Fady Samuel799e72192018-04-25 21:16:571597void RenderWidget::SynchronizeVisualProperties(const VisualProperties& params) {
Miguel Casas5e1018052018-01-09 19:17:361598
Fady Samuele62be402018-03-29 03:19:531599 gfx::Size new_compositor_viewport_pixel_size =
1600 params.auto_resize_enabled
1601 ? gfx::ScaleToCeiledSize(size_,
1602 params.screen_info.device_scale_factor)
1603 : params.compositor_viewport_pixel_size;
Fady Samuel84d8a1f72018-11-08 00:26:171604 UpdateSurfaceAndScreenInfo(params.local_surface_id_allocation.value_or(
1605 viz::LocalSurfaceIdAllocation()),
1606 new_compositor_viewport_pixel_size,
1607 params.screen_info);
Vladimir Levin98d76dad2018-04-21 00:21:291608 UpdateCaptureSequenceNumber(params.capture_sequence_number);
danakj125a29e2019-01-24 23:25:291609 layer_tree_view_->SetBrowserControlsHeight(
1610 params.top_controls_height, params.bottom_controls_height,
1611 params.browser_controls_shrink_blink_size);
mfomitchev2600fd7c2016-02-17 20:53:391612
akaba3483d8f2018-07-10 21:43:091613 UpdateZoom(params.zoom_level);
akabac6bd1212018-06-25 20:10:481614
danakj21604ce2018-12-19 16:01:221615 if (!params.auto_resize_enabled) {
1616 visible_viewport_size_ = params.visible_viewport_size;
danakj21604ce2018-12-19 16:01:221617 display_mode_ = params.display_mode;
danakj21604ce2018-12-19 16:01:221618 size_ = params.new_size;
mfomitchev2600fd7c2016-02-17 20:53:391619
danakj21604ce2018-12-19 16:01:221620 ResizeWebWidget();
mfomitchev2600fd7c2016-02-17 20:53:391621
danakjb4cec102019-01-30 19:22:131622 gfx::Size visual_viewport_size = visible_viewport_size_;
danakj21604ce2018-12-19 16:01:221623 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
danakjb4cec102019-01-30 19:22:131624 visual_viewport_size = gfx::ScaleToCeiledSize(
1625 visual_viewport_size, GetOriginalScreenInfo().device_scale_factor);
danakj21604ce2018-12-19 16:01:221626 }
1627 GetWebWidget()->ResizeVisualViewport(visual_viewport_size);
bokan71cb5b12016-04-27 03:45:221628
danakjf9284772019-01-23 18:29:141629 // NOTE: We may have entered fullscreen mode without changing our size.
1630 SetIsFullscreen(params.is_fullscreen_granted);
mfomitchev2600fd7c2016-02-17 20:53:391631 }
mfomitchev2600fd7c2016-02-17 20:53:391632}
1633
1634void RenderWidget::SetScreenMetricsEmulationParameters(
1635 bool enabled,
1636 const blink::WebDeviceEmulationParams& params) {
Albert J. Wong7bbf22d2018-12-20 00:27:271637 // This is only supported in RenderView, which has an delegate().
1638 DCHECK(delegate());
1639 delegate()->SetScreenMetricsEmulationParametersForWidget(enabled, params);
mfomitchev2600fd7c2016-02-17 20:53:391640}
1641
Albert J. Wong3c93c182018-09-27 17:29:431642void RenderWidget::SetScreenRects(const gfx::Rect& widget_screen_rect,
mfomitchev2600fd7c2016-02-17 20:53:391643 const gfx::Rect& window_screen_rect) {
Albert J. Wong3c93c182018-09-27 17:29:431644 widget_screen_rect_ = widget_screen_rect;
mfomitchev2600fd7c2016-02-17 20:53:391645 window_screen_rect_ = window_screen_rect;
1646}
1647
1648///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461649// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291650
Chris Harrelsond7ab99b2018-01-24 17:51:361651void RenderWidget::IntrinsicSizingInfoChanged(
1652 const blink::WebIntrinsicSizingInfo& sizing_info) {
Albert J. Wong3c93c182018-09-27 17:29:431653 Send(new WidgetHostMsg_IntrinsicSizingInfoChanged(routing_id_, sizing_info));
Chris Harrelsond7ab99b2018-01-24 17:51:361654}
1655
Blink Reformat1c4d759e2017-04-09 16:34:541656void RenderWidget::DidMeaningfulLayout(blink::WebMeaningfulLayout layout_type) {
1657 if (layout_type == blink::WebMeaningfulLayout::kVisuallyNonEmpty) {
Albert J. Wongfb64e142018-10-16 01:10:451658 QueueMessage(new WidgetHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_));
dglazkovf0e1d6d2015-10-10 02:13:481659 }
dglazkov79c426102015-08-31 21:22:431660
ericwilligers88e69742016-10-17 19:29:551661 for (auto& observer : render_frames_)
1662 observer.DidMeaningfulLayout(layout_type);
dglazkov79c426102015-08-31 21:22:431663}
1664
[email protected]586871b2014-07-22 17:05:111665// static
dchengcedca5612016-04-09 01:40:151666std::unique_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
[email protected]586871b2014-07-22 17:05:111667 IPC::Message* msg,
[email protected]586871b2014-07-22 17:05:111668 FrameSwapMessageQueue* frame_swap_message_queue,
1669 scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
[email protected]586871b2014-07-22 17:05:111670 int source_frame_number) {
[email protected]586871b2014-07-22 17:05:111671 bool first_message_for_frame = false;
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491672 frame_swap_message_queue->QueueMessageForFrame(
1673 source_frame_number, base::WrapUnique(msg), &first_message_for_frame);
[email protected]586871b2014-07-22 17:05:111674 if (first_message_for_frame) {
dchengcedca5612016-04-09 01:40:151675 std::unique_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
[email protected]586871b2014-07-22 17:05:111676 sync_message_filter, frame_swap_message_queue, source_frame_number));
dcheng4b6b5ff2014-10-16 00:42:061677 return promise;
[email protected]586871b2014-07-22 17:05:111678 }
dcheng4b6b5ff2014-10-16 00:42:061679 return nullptr;
[email protected]586871b2014-07-22 17:05:111680}
1681
danakj53802692018-07-25 21:46:441682void RenderWidget::SetHandlingInputEvent(bool handling_input_event) {
1683 input_handler_->set_handling_input_event(handling_input_event);
1684}
1685
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491686void RenderWidget::QueueMessage(IPC::Message* msg) {
danakj125a29e2019-01-24 23:25:291687 if (closing_)
1688 return;
1689
[email protected]586871b2014-07-22 17:05:111690 // RenderThreadImpl::current() is NULL in some tests.
danakj125a29e2019-01-24 23:25:291691 if (!RenderThreadImpl::current()) {
[email protected]586871b2014-07-22 17:05:111692 Send(msg);
1693 return;
1694 }
1695
dchengcedca5612016-04-09 01:40:151696 std::unique_ptr<cc::SwapPromise> swap_promise =
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491697 QueueMessageImpl(msg, frame_swap_message_queue_.get(),
[email protected]586871b2014-07-22 17:05:111698 RenderThreadImpl::current()->sync_message_filter(),
danakja6c10012018-07-06 14:25:361699 layer_tree_view_->GetSourceFrameNumber());
[email protected]586871b2014-07-22 17:05:111700
Ken Buchanance710eb2017-08-30 23:46:521701 if (swap_promise)
danakja6c10012018-07-06 14:25:361702 layer_tree_view_->QueueSwapPromise(std::move(swap_promise));
[email protected]586871b2014-07-22 17:05:111703}
1704
Blink Reformat1c4d759e2017-04-09 16:34:541705void RenderWidget::DidChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301706 // TODO(darin): Eliminate this temporary.
[email protected]9ec87712013-05-24 23:23:521707 WebCursor cursor;
tfarina75a0abf2015-10-06 15:07:181708 InitializeCursorFromWebCursorInfo(&cursor, cursor_info);
initial.commit09911bf2008-07-26 23:55:291709 // Only send a SetCursor message if we need to make a change.
Navid Zolghadr293bb862018-12-12 18:15:411710 if (input_handler_->DidChangeCursor(cursor))
Albert J. Wong3c93c182018-09-27 17:29:431711 Send(new WidgetHostMsg_SetCursor(routing_id_, cursor));
initial.commit09911bf2008-07-26 23:55:291712}
1713
aelias5971e47d2017-06-16 02:39:381714void RenderWidget::AutoscrollStart(const blink::WebFloatPoint& point) {
Albert J. Wong3c93c182018-09-27 17:29:431715 Send(new WidgetHostMsg_AutoscrollStart(routing_id_, point));
aelias5971e47d2017-06-16 02:39:381716}
1717
1718void RenderWidget::AutoscrollFling(const blink::WebFloatSize& velocity) {
Albert J. Wong3c93c182018-09-27 17:29:431719 Send(new WidgetHostMsg_AutoscrollFling(routing_id_, velocity));
aelias5971e47d2017-06-16 02:39:381720}
1721
1722void RenderWidget::AutoscrollEnd() {
Albert J. Wong3c93c182018-09-27 17:29:431723 Send(new WidgetHostMsg_AutoscrollEnd(routing_id_));
aelias5971e47d2017-06-16 02:39:381724}
1725
initial.commit09911bf2008-07-26 23:55:291726// We are supposed to get a single call to Show for a newly created RenderWidget
1727// that was created via RenderWidget::CreateWebView. So, we wait until this
1728// point to dispatch the ShowWidget message.
1729//
1730// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281731// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291732//
Blink Reformat1c4d759e2017-04-09 16:34:541733void RenderWidget::Show(WebNavigationPolicy policy) {
danakj65f423b72018-10-10 17:21:201734 if (!show_callback_) {
Albert J. Wong7bbf22d2018-12-20 00:27:271735 if (delegate()) {
danakja2c9d0a92018-07-25 20:01:181736 // When SupportsMultipleWindows is disabled, popups are reusing
danakj65f423b72018-10-10 17:21:201737 // the view's RenderWidget. In some scenarios, this makes blink to call
1738 // Show() twice. But otherwise, if it is enabled, we should not visit
1739 // Show() more than once.
Albert J. Wong7bbf22d2018-12-20 00:27:271740 DCHECK(!delegate()->SupportsMultipleWindowsForWidget());
danakj65f423b72018-10-10 17:21:201741 return;
danakja2c9d0a92018-07-25 20:01:181742 } else {
danakj65f423b72018-10-10 17:21:201743 NOTREACHED() << "received extraneous Show call";
danakja2c9d0a92018-07-25 20:01:181744 }
danakja2c9d0a92018-07-25 20:01:181745 }
1746
initial.commit09911bf2008-07-26 23:55:291747 DCHECK(routing_id_ != MSG_ROUTING_NONE);
nickf7b38222016-11-22 21:59:351748
1749 // The opener is responsible for actually showing this widget.
danakjdf1ceb72018-07-18 20:02:251750 std::move(show_callback_).Run(this, policy, initial_rect_);
nickf7b38222016-11-22 21:59:351751
bokanc007c3a2015-02-03 07:15:561752 // NOTE: initial_rect_ may still have its default values at this point, but
[email protected]8de12d942010-11-17 20:42:441753 // that's okay. It'll be ignored if as_popup is false, or the browser
1754 // process will impose a default position otherwise.
bokanc007c3a2015-02-03 07:15:561755 SetPendingWindowRect(initial_rect_);
initial.commit09911bf2008-07-26 23:55:291756}
1757
danakj17216f4d2018-10-16 22:57:321758LayerTreeView* RenderWidget::InitializeLayerTreeView() {
1759 TRACE_EVENT0("blink", "RenderWidget::InitializeLayerTreeView");
danakj17216f4d2018-10-16 22:57:321760
1761 layer_tree_view_ = std::make_unique<LayerTreeView>(
1762 this, compositor_deps_->GetCompositorMainThreadTaskRunner(),
1763 compositor_deps_->GetCompositorImplThreadTaskRunner(),
1764 compositor_deps_->GetTaskGraphRunner(),
1765 compositor_deps_->GetWebMainThreadScheduler());
1766 layer_tree_view_->Initialize(
danakj6dcbc5962018-11-16 16:45:421767 GenerateLayerTreeSettings(compositor_deps_, for_child_local_root_frame_,
danakj17216f4d2018-10-16 22:57:321768 screen_info_.rect.size(),
1769 screen_info_.device_scale_factor),
1770 compositor_deps_->CreateUkmRecorderFactory());
1771
Fady Samuel1c1ad3692018-11-06 23:28:401772 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
danakj0d963bd2019-02-20 18:00:461773 CompositorViewportSize(), screen_info_);
danakj17216f4d2018-10-16 22:57:321774 layer_tree_view_->SetContentSourceId(current_content_source_id_);
danakj953af052019-02-06 19:13:181775 // If the widget is hidden, delay starting the compositor until the user shows
1776 // it. Also if the RenderWidget is frozen, we delay starting the compositor
1777 // until we expect to use the widget, which will be signaled through
1778 // WarmupCompositor().
1779 if (!is_frozen_ && !is_hidden_)
1780 StartStopCompositor();
danakj17216f4d2018-10-16 22:57:321781
danakj17216f4d2018-10-16 22:57:321782 DCHECK_NE(MSG_ROUTING_NONE, routing_id_);
1783 layer_tree_view_->SetFrameSinkId(
1784 viz::FrameSinkId(RenderThread::Get()->GetClientId(), routing_id_));
1785
1786 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1787 if (render_thread) {
1788 input_event_queue_ = base::MakeRefCounted<MainThreadEventQueue>(
1789 this, render_thread->GetWebMainThreadScheduler()->InputTaskRunner(),
danakj953af052019-02-06 19:13:181790 render_thread->GetWebMainThreadScheduler(),
1791 /*allow_raf_aligned_input=*/!compositor_never_visible_);
danakj17216f4d2018-10-16 22:57:321792 }
1793
1794 return layer_tree_view_.get();
1795}
1796
danakj953af052019-02-06 19:13:181797void RenderWidget::StartStopCompositor() {
1798 if (compositor_never_visible_)
1799 return;
danakjde8b7482018-11-15 23:45:021800
danakj953af052019-02-06 19:13:181801 if (is_frozen_) {
1802 layer_tree_view_->SetVisible(false);
1803 // Drop all gpu resources, this makes SetVisible(true) more expensive/slower
1804 // but we don't expect to use this RenderWidget again until some possible
1805 // future navigation. This brings us a bit closer to emulating deleting the
1806 // RenderWidget instead of just stopping the compositor.
1807 layer_tree_view_->ReleaseLayerTreeFrameSink();
1808 } else if (is_hidden_) {
1809 layer_tree_view_->SetVisible(false);
1810 } else {
1811 layer_tree_view_->SetVisible(true);
1812 }
danakjde8b7482018-11-15 23:45:021813}
1814
danakj6dcbc5962018-11-16 16:45:421815void RenderWidget::SetIsFrozen(bool is_frozen) {
1816 DCHECK_NE(is_frozen, is_frozen_);
1817 is_frozen_ = is_frozen;
danakj953af052019-02-06 19:13:181818 // If hidden, then frozen changing doesn't change anything with the
1819 // compositor since when hidden the compositor is always stopped.
1820 if (!is_hidden_)
1821 StartStopCompositor();
danakjde8b7482018-11-15 23:45:021822}
1823
danakjf87460792018-12-04 20:14:221824void RenderWidget::WarmupCompositor() {
1825 DCHECK(is_frozen_);
danakj953af052019-02-06 19:13:181826 if (compositor_never_visible_)
danakjf87460792018-12-04 20:14:221827 return;
1828
1829 // Keeping things simple. This would cancel any outstanding warmup if we
1830 // happened to have one (this should be basically impossible). This avoids any
1831 // extra book keeping about the outstanding reqeust.
1832 warmup_weak_ptr_factory_.InvalidateWeakPtrs();
1833 // And if we already did a warmup then we're done.
1834 if (warmup_frame_sink_)
1835 return;
1836
1837 // Mark us pending the warmup frame sink *before* calling
1838 // DoRequestNewLayerTreeFrameSink() as it may run the reply callback
1839 // synchronously. So we don't want to change any state after the call
1840 // to DoRequestNewLayerTreeFrameSink() here.
1841 warmup_frame_sink_request_pending_ = true;
1842
1843 auto cb = base::BindOnce(&RenderWidget::OnReplyForWarmupCompositor,
1844 warmup_weak_ptr_factory_.GetWeakPtr());
1845 DoRequestNewLayerTreeFrameSink(std::move(cb));
1846}
1847
1848void RenderWidget::OnReplyForWarmupCompositor(
1849 std::unique_ptr<cc::LayerTreeFrameSink> sink) {
1850 warmup_frame_sink_request_pending_ = false;
1851
1852 if (after_warmup_callback_)
1853 std::move(after_warmup_callback_).Run(std::move(sink));
1854 else
1855 warmup_frame_sink_ = std::move(sink);
1856}
1857
1858void RenderWidget::AbortWarmupCompositor() {
1859 warmup_frame_sink_request_pending_ = false;
1860 // Drop any pending warmup.
1861 warmup_weak_ptr_factory_.InvalidateWeakPtrs();
1862 // And drop any completed one.
1863 warmup_frame_sink_.reset();
1864
1865 // If we had saved a callback to run after warmup, just do so now indicating
1866 // failure.
1867 if (after_warmup_callback_)
1868 std::move(after_warmup_callback_).Run(nullptr);
1869}
1870
[email protected]2533ce12009-05-09 00:02:241871void RenderWidget::DoDeferredClose() {
Albert J. Wong3c93c182018-09-27 17:29:431872 Send(new WidgetHostMsg_Close(routing_id_));
[email protected]2533ce12009-05-09 00:02:241873}
1874
danakj45e4a4f2019-03-12 22:50:421875void RenderWidget::ClosePopupWidgetSoon() {
1876 // Only should be called for popup widgets.
1877 DCHECK(!for_child_local_root_frame_);
1878 DCHECK(!delegate_);
1879
1880 CloseWidgetSoon();
1881}
1882
Blink Reformat1c4d759e2017-04-09 16:34:541883void RenderWidget::CloseWidgetSoon() {
skyostiled8969c2015-07-20 16:57:081884 DCHECK(content::RenderThread::Get());
danakj292b63e2018-11-19 20:47:061885 // Prevent compositor from setting up new IPC channels, since we know a
1886 // WidgetMsg_Close is coming. We do this immediately, not in DoDeferredClose,
1887 // as the caller (eg WebPagePopupImpl) may start tearing down things after
1888 // calling this method, including detaching the frame from this RenderWidget.
1889 // Then trying to make a LayerTreeFrameSink would crash.
1890 // https://crbug.com/906340
1891 host_will_close_this_ = true;
1892
initial.commit09911bf2008-07-26 23:55:291893 // If a page calls window.close() twice, we'll end up here twice, but that's
1894 // OK. It is safe to send multiple Close messages.
danakj292b63e2018-11-19 20:47:061895 //
[email protected]2533ce12009-05-09 00:02:241896 // Ask the RenderWidgetHost to initiate close. We could be called from deep
danakj295c43f182019-03-13 16:37:171897 // in Javascript. If we ask the RenderWidgetHost to close now, the window
1898 // could be closed before the JS finishes executing, thanks to nested message
1899 // loops running and handling the resuliting Close IPC. So instead, post a
[email protected]2533ce12009-05-09 00:02:241900 // message back to the message loop, which won't run until the JS is
danakj295c43f182019-03-13 16:37:171901 // complete, and then the Close request can be sent.
Hajime Hoshi315a61f2018-08-14 17:27:281902 GetCleanupTaskRunner()->PostTask(
1903 FROM_HERE, base::BindOnce(&RenderWidget::DoDeferredClose, this));
initial.commit09911bf2008-07-26 23:55:291904}
1905
1906void RenderWidget::Close() {
danakj6dcbc5962018-11-16 16:45:421907 // This was done immediately in the |for_child_local_root_frame_| case in the
1908 // OnClose() IPC handler.
1909 if (!for_child_local_root_frame_)
danakj5c5269b2018-11-06 00:39:111910 CloseWebWidget();
1911
danakja6c10012018-07-06 14:25:361912 layer_tree_view_.reset();
Albert J. Wong7bbf22d2018-12-20 00:27:271913 if (delegate())
1914 delegate()->DidCloseWidget();
Albert J. Wongd593de532018-09-06 05:42:151915 // Note the ACK is a control message going to the RenderProcessHost.
Albert J. Wong3c93c182018-09-27 17:29:431916 RenderThread::Get()->Send(new WidgetHostMsg_Close_ACK(routing_id()));
danakj6ec39d302019-03-15 22:43:221917 closed_ = true;
Ken Buchananed449bb2018-02-01 21:02:051918}
1919
1920void RenderWidget::CloseWebWidget() {
danakj35314ab2018-10-19 16:37:341921 // If the browser has not sent OnDisableDeviceEmulation, we have an emulator
1922 // hanging out still. Destroying it must happen *after* the IPC route is
1923 // removed so that another IPC does not arrive and re-create the emulator
1924 // during closing.
1925 //
1926 // This destruction is normally part of an IPC and expects objects to be alive
1927 // that would be alive while the IPC route is active such as the
1928 // |layer_tree_view_|. So we ensure that it is the first thing to be
1929 // destroyed here before deleting things from the RenderWidget or the
Albert J. Wong7bbf22d2018-12-20 00:27:271930 // delegate().
danakj35314ab2018-10-19 16:37:341931 //
1932 // TODO(danakj): The emulator could reset to non-emulated values in an
1933 // explicit method call (instead of in the destructor) that occurs when
1934 // emulation is disabled, but does not need to occur during RenderWidget
1935 // closing. Then we would not have to destroy this so carefully.
1936 screen_metrics_emulator_.reset();
1937
Albert J. Wong7bbf22d2018-12-20 00:27:271938 // When delegate() is present, the RenderWidget is for a main frame,
danakj974b8ae2019-02-05 00:26:261939 // and the GetWebWidget() will be a WebFrameWidget, which is not the same as
1940 // |webwidget_internal_|. The WebFrameWidget will be closed when the main
1941 // frame is detached, so we do not close it here. But it does not close the
1942 // |webwidget_internal_| since this class takes responsibility for that here
1943 // in all cases.
danakj5c5269b2018-11-06 00:39:111944 webwidget_internal_->Close();
1945 webwidget_internal_ = nullptr;
initial.commit09911bf2008-07-26 23:55:291946}
1947
Mitsuru Oshima3c07b332018-02-06 04:56:501948void RenderWidget::UpdateWebViewWithDeviceScaleFactor() {
1949 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1950 blink::WebFrame* current_frame =
1951 frame_widget ? frame_widget->LocalRoot() : nullptr;
1952 blink::WebView* webview = current_frame ? current_frame->View() : nullptr;
1953 if (webview) {
danakj4b347212018-07-04 17:55:171954 if (compositor_deps_->IsUseZoomForDSFEnabled())
Fady Samuela863f152018-03-09 16:10:031955 webview->SetZoomFactorForDeviceScaleFactor(
1956 GetWebScreenInfo().device_scale_factor);
Mitsuru Oshima3c07b332018-02-06 04:56:501957 else
Fady Samuela863f152018-03-09 16:10:031958 webview->SetDeviceScaleFactor(GetWebScreenInfo().device_scale_factor);
Mitsuru Oshima3c07b332018-02-06 04:56:501959
1960 webview->GetSettings()->SetPreferCompositingToLCDTextEnabled(
Christopher Camerone9a30c12018-03-07 08:23:381961 PreferCompositingToLCDText(compositor_deps_,
Fady Samuela863f152018-03-09 16:10:031962 GetWebScreenInfo().device_scale_factor));
Mitsuru Oshima3c07b332018-02-06 04:56:501963 }
1964}
1965
Ehsan Karamad655d7b8a2018-01-12 18:38:381966blink::WebFrameWidget* RenderWidget::GetFrameWidget() const {
danakj89ae4532018-12-12 22:52:551967 // TODO(danakj): Remove this check and don't call this method for non-frames.
1968 if (!for_frame())
1969 return nullptr;
1970 // TODO(danakj): Is this needed? IPCs stop after closing, but code used to
1971 // check for a null WebWidget.
1972 if (closing_)
Ehsan Karamad655d7b8a2018-01-12 18:38:381973 return nullptr;
1974
danakj89ae4532018-12-12 22:52:551975 blink::WebWidget* widget;
Albert J. Wong7bbf22d2018-12-20 00:27:271976 if (delegate()) {
danakj89ae4532018-12-12 22:52:551977 // Main frame WebFrameWidgets are held by the delegate, the internal widget
1978 // points directly to the WebView.
1979 // TODO(ekaramad): We should drop IPCs when |is_frozen_| instead of
1980 // handling them and finding a null here. However there is also the case
1981 // of the frame being detached without the widget being frozen to be
1982 // resolved (https://crbug.com/906340). So for now this can return null.
Albert J. Wong7bbf22d2018-12-20 00:27:271983 widget = delegate()->GetWebWidgetForWidget();
danakj89ae4532018-12-12 22:52:551984 } else {
1985 // Subframes always have a WebFrameWidget themselves.
1986 widget = webwidget_internal_;
Ehsan Karamad655d7b8a2018-01-12 18:38:381987 }
danakj89ae4532018-12-12 22:52:551988 return static_cast<blink::WebFrameWidget*>(widget);
Ehsan Karamad655d7b8a2018-01-12 18:38:381989}
1990
bokan841fdc72016-10-06 00:16:351991void RenderWidget::ScreenRectToEmulatedIfNeeded(WebRect* window_rect) const {
1992 DCHECK(window_rect);
1993 float scale = popup_origin_scale_for_emulation_;
1994 if (!scale)
1995 return;
1996 window_rect->x =
1997 popup_view_origin_for_emulation_.x() +
1998 (window_rect->x - popup_screen_origin_for_emulation_.x()) / scale;
1999 window_rect->y =
2000 popup_view_origin_for_emulation_.y() +
2001 (window_rect->y - popup_screen_origin_for_emulation_.y()) / scale;
2002}
2003
2004void RenderWidget::EmulatedToScreenRectIfNeeded(WebRect* window_rect) const {
2005 DCHECK(window_rect);
2006 float scale = popup_origin_scale_for_emulation_;
2007 if (!scale)
2008 return;
2009 window_rect->x =
2010 popup_screen_origin_for_emulation_.x() +
2011 (window_rect->x - popup_view_origin_for_emulation_.x()) * scale;
2012 window_rect->y =
2013 popup_screen_origin_for_emulation_.y() +
2014 (window_rect->y - popup_view_origin_for_emulation_.y()) * scale;
2015}
2016
Blink Reformat1c4d759e2017-04-09 16:34:542017WebRect RenderWidget::WindowRect() {
bokan841fdc72016-10-06 00:16:352018 WebRect rect;
bokan6b08cd22016-10-05 00:55:212019 if (pending_window_rect_count_) {
2020 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
2021 // the RootWindowRect is probably going to return wrong results since the
2022 // browser may not have processed the Move yet. There isn't really anything
2023 // good to do in this case, and it shouldn't happen - since this size is
2024 // only really needed for windowToScreen, which is only used for Popups.
bokan841fdc72016-10-06 00:16:352025 rect = pending_window_rect_;
2026 } else {
2027 rect = window_screen_rect_;
bokan6b08cd22016-10-05 00:55:212028 }
[email protected]2533ce12009-05-09 00:02:242029
bokan841fdc72016-10-06 00:16:352030 ScreenRectToEmulatedIfNeeded(&rect);
2031 return rect;
bokan6b08cd22016-10-05 00:55:212032}
2033
Blink Reformat1c4d759e2017-04-09 16:34:542034WebRect RenderWidget::ViewRect() {
Albert J. Wong3c93c182018-09-27 17:29:432035 WebRect rect = widget_screen_rect_;
bokan841fdc72016-10-06 00:16:352036 ScreenRectToEmulatedIfNeeded(&rect);
2037 return rect;
initial.commit09911bf2008-07-26 23:55:292038}
2039
Blink Reformat1c4d759e2017-04-09 16:34:542040void RenderWidget::SetToolTipText(const blink::WebString& text,
[email protected]8a9d6ca32011-06-06 20:11:302041 WebTextDirection hint) {
Albert J. Wong3c93c182018-09-27 17:29:432042 Send(new WidgetHostMsg_SetTooltipText(routing_id_, text.Utf16(), hint));
[email protected]8a9d6ca32011-06-06 20:11:302043}
2044
Blink Reformat1c4d759e2017-04-09 16:34:542045void RenderWidget::SetWindowRect(const WebRect& rect_in_screen) {
danakj81d601e62018-10-09 22:15:052046 // This path is for the renderer to change the on-screen position/size of
2047 // the widget by changing its window rect. This is not possible for
2048 // RenderWidgets whose position/size are controlled by layout from another
danakj6dcbc5962018-11-16 16:45:422049 // frame tree (ie. child local root frames), as the window rect can only be
2050 // set by the browser.
2051 if (for_child_local_root_frame_)
danakj81d601e62018-10-09 22:15:052052 return;
2053
oshima33ec97cd2015-12-14 19:40:242054 WebRect window_rect = rect_in_screen;
bokan841fdc72016-10-06 00:16:352055 EmulatedToScreenRectIfNeeded(&window_rect);
[email protected]b2e4c70132013-10-03 02:07:512056
danakj7602f4f2019-01-31 18:03:232057 if (synchronous_resize_mode_for_testing_) {
Kent Tamura21d1de62018-12-10 04:45:202058 // This is a web-test-only path. At one point, it was planned to be
danakj65f423b72018-10-10 17:21:202059 // removed. See https://crbug.com/309760.
bokanc007c3a2015-02-03 07:15:562060 SetWindowRectSynchronously(window_rect);
danakj65f423b72018-10-10 17:21:202061 return;
2062 }
2063
2064 if (show_callback_) {
2065 // The widget is not shown yet. Delay the |window_rect| being sent to the
2066 // browser until Show() is called so it can be sent with that IPC, once the
2067 // browser is ready for the info.
2068 initial_rect_ = window_rect;
2069 } else {
2070 Send(new WidgetHostMsg_RequestSetBounds(routing_id_, window_rect));
2071 SetPendingWindowRect(window_rect);
initial.commit09911bf2008-07-26 23:55:292072 }
2073}
2074
[email protected]2533ce12009-05-09 00:02:242075void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
2076 pending_window_rect_ = rect;
2077 pending_window_rect_count_++;
[email protected]2533ce12009-05-09 00:02:242078
bokan6b08cd22016-10-05 00:55:212079 // Popups don't get size updates back from the browser so just store the set
2080 // values.
danakj89ae4532018-12-12 22:52:552081 if (!for_frame()) {
Blink Reformat1c4d759e2017-04-09 16:34:542082 window_screen_rect_ = rect;
Albert J. Wong3c93c182018-09-27 17:29:432083 widget_screen_rect_ = rect;
[email protected]2533ce12009-05-09 00:02:242084 }
[email protected]d4547452008-08-28 18:36:372085}
2086
wjmacleanee244e02017-05-26 21:06:072087void RenderWidget::OnShowContextMenu(ui::MenuSourceType source_type,
2088 const gfx::Point& location) {
wjmacleanee244e02017-05-26 21:06:072089 has_host_context_menu_location_ = true;
2090 host_context_menu_location_ = location;
2091 if (GetWebWidget()) {
2092 GetWebWidget()->ShowContextMenu(
2093 static_cast<blink::WebMenuSourceType>(source_type));
2094 }
2095 has_host_context_menu_location_ = false;
2096}
2097
[email protected]fa7b1dc2010-06-23 17:53:042098void RenderWidget::OnImeSetComposition(
[email protected]fcf75d42013-12-03 20:11:262099 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:112100 const std::vector<WebImeTextSpan>& ime_text_spans,
chongz7eb752802016-01-27 21:28:072101 const gfx::Range& replacement_range,
Ryan Landay9e42fd742017-08-12 01:59:112102 int selection_start,
2103 int selection_end) {
ekaramad5aff1942017-01-06 01:26:352104 if (!ShouldHandleImeEvents())
2105 return;
2106
brettw4b461082016-11-19 18:55:162107#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492108 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
Ryan Landay9e42fd742017-08-12 01:59:112109 plugin->render_frame()->OnImeSetComposition(text, ime_text_spans,
EhsanK22d482e2017-08-10 17:29:492110 selection_start, selection_end);
ekaramad2a46d632016-07-19 13:33:092111 return;
2112 }
2113#endif
[email protected]66fca5bc2013-05-23 06:58:292114 ImeEventGuard guard(this);
ekaramad2daaf672016-11-10 20:29:012115 blink::WebInputMethodController* controller = GetInputMethodController();
ekaramad2daaf672016-11-10 20:29:012116 if (!controller ||
Blink Reformat1c4d759e2017-04-09 16:34:542117 !controller->SetComposition(
Ryan Landay9e42fd742017-08-12 01:59:112118 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:562119 replacement_range.IsValid()
2120 ? WebRange(replacement_range.start(), replacement_range.length())
2121 : WebRange(),
2122 selection_start, selection_end)) {
[email protected]fa7b1dc2010-06-23 17:53:042123 // If we failed to set the composition text, then we need to let the browser
2124 // process to cancel the input method's ongoing composition session, to make
2125 // sure we are in a consistent state.
Dave Tapuska04bc5ee92018-04-17 19:03:312126 if (mojom::WidgetInputHandlerHost* host =
2127 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
2128 host->ImeCancelComposition();
Dave Tapuska139a72f2017-09-06 21:57:032129 }
[email protected]7f00efa2010-04-15 05:01:262130 }
nonafa291792016-08-10 02:36:182131 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]fa7b1dc2010-06-23 17:53:042132}
2133
rlanday7efe2302017-01-11 00:14:282134void RenderWidget::OnImeCommitText(
2135 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:112136 const std::vector<WebImeTextSpan>& ime_text_spans,
rlanday7efe2302017-01-11 00:14:282137 const gfx::Range& replacement_range,
2138 int relative_cursor_pos) {
ekaramad5aff1942017-01-06 01:26:352139 if (!ShouldHandleImeEvents())
2140 return;
2141
brettw4b461082016-11-19 18:55:162142#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492143 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
2144 plugin->render_frame()->OnImeCommitText(text, replacement_range,
2145 relative_cursor_pos);
ekaramad2a46d632016-07-19 13:33:092146 return;
2147 }
2148#endif
[email protected]66fca5bc2013-05-23 06:58:292149 ImeEventGuard guard(this);
fsamuele8326c742016-01-12 00:49:392150 input_handler_->set_handling_input_event(true);
ekaramadb6483a052017-02-10 02:23:262151 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:542152 controller->CommitText(
Ryan Landay9e42fd742017-08-12 01:59:112153 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:562154 replacement_range.IsValid()
2155 ? WebRange(replacement_range.start(), replacement_range.length())
2156 : WebRange(),
2157 relative_cursor_pos);
ekaramadb6483a052017-02-10 02:23:262158 }
aelias87b8f7c2016-09-14 03:19:292159 input_handler_->set_handling_input_event(false);
2160 UpdateCompositionInfo(false /* not an immediate request */);
2161}
2162
2163void RenderWidget::OnImeFinishComposingText(bool keep_selection) {
ekaramad5aff1942017-01-06 01:26:352164 if (!ShouldHandleImeEvents())
2165 return;
2166
brettw4b461082016-11-19 18:55:162167#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492168 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
2169 plugin->render_frame()->OnImeFinishComposingText(keep_selection);
aelias87b8f7c2016-09-14 03:19:292170 return;
2171 }
2172#endif
2173
changwan38c3eb612016-12-09 01:45:562174 if (!GetWebWidget())
aelias87b8f7c2016-09-14 03:19:292175 return;
2176 ImeEventGuard guard(this);
2177 input_handler_->set_handling_input_event(true);
ekaramad2daaf672016-11-10 20:29:012178 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:542179 controller->FinishComposingText(
2180 keep_selection ? WebInputMethodController::kKeepSelection
2181 : WebInputMethodController::kDoNotKeepSelection);
ekaramad2daaf672016-11-10 20:29:012182 }
fsamuele8326c742016-01-12 00:49:392183 input_handler_->set_handling_input_event(false);
nonafa291792016-08-10 02:36:182184 UpdateCompositionInfo(false /* not an immediate request */);
initial.commit09911bf2008-07-26 23:55:292185}
2186
Christopher Camerone9a30c12018-03-07 08:23:382187void RenderWidget::UpdateSurfaceAndScreenInfo(
Fady Samuel1c1ad3692018-11-06 23:28:402188 const viz::LocalSurfaceIdAllocation& new_local_surface_id_allocation,
danakj9c4e7b812019-02-19 22:04:272189 const gfx::Size& compositor_viewport_pixel_size,
Christopher Camerone9a30c12018-03-07 08:23:382190 const ScreenInfo& new_screen_info) {
Christopher Camerone9a30c12018-03-07 08:23:382191 bool orientation_changed =
2192 screen_info_.orientation_angle != new_screen_info.orientation_angle ||
2193 screen_info_.orientation_type != new_screen_info.orientation_type;
2194 bool web_device_scale_factor_changed =
2195 screen_info_.device_scale_factor != new_screen_info.device_scale_factor;
Fady Samuela863f152018-03-09 16:10:032196 ScreenInfo previous_original_screen_info = GetOriginalScreenInfo();
Christopher Cameronbe7ecea2018-02-27 00:47:192197
Fady Samuel1c1ad3692018-11-06 23:28:402198 local_surface_id_allocation_from_parent_ = new_local_surface_id_allocation;
Christopher Camerone9a30c12018-03-07 08:23:382199 screen_info_ = new_screen_info;
Christopher Cameronbe7ecea2018-02-27 00:47:192200
danakj125a29e2019-01-24 23:25:292201 // Note carefully that the DSF specified in |new_screen_info| is not the
2202 // DSF used by the compositor during device emulation!
2203 layer_tree_view_->SetViewportSizeAndScale(
danakj9c4e7b812019-02-19 22:04:272204 compositor_viewport_pixel_size,
danakj125a29e2019-01-24 23:25:292205 GetOriginalScreenInfo().device_scale_factor,
2206 local_surface_id_allocation_from_parent_);
danakj9c4e7b812019-02-19 22:04:272207 // The ViewportVisibleRect derives from the LayerTreeView's viewport size,
2208 // which is set above.
2209 layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect());
danakj04d128a2019-01-25 02:10:202210 layer_tree_view_->SetRasterColorSpace(
2211 screen_info_.color_space.GetRasterColorSpace());
Christopher Cameronbe7ecea2018-02-27 00:47:192212
Christopher Camerone9a30c12018-03-07 08:23:382213 if (orientation_changed)
2214 OnOrientationChange();
Christopher Cameronbe7ecea2018-02-27 00:47:192215
Fady Samuela863f152018-03-09 16:10:032216 if (previous_original_screen_info != GetOriginalScreenInfo()) {
Christopher Camerone9a30c12018-03-07 08:23:382217 for (auto& observer : render_frame_proxies_)
Fady Samuela863f152018-03-09 16:10:032218 observer.OnScreenInfoChanged(GetOriginalScreenInfo());
Christopher Camerone9a30c12018-03-07 08:23:382219
2220 // Notify all embedded BrowserPlugins of the updated ScreenInfo.
2221 for (auto& observer : browser_plugins_)
Fady Samuela863f152018-03-09 16:10:032222 observer.ScreenInfoChanged(GetOriginalScreenInfo());
Christopher Camerone9a30c12018-03-07 08:23:382223 }
2224
2225 if (web_device_scale_factor_changed)
Christopher Cameronbe7ecea2018-02-27 00:47:192226 UpdateWebViewWithDeviceScaleFactor();
oshimad5279032015-12-16 18:22:332227}
2228
danakja2c9d0a92018-07-25 20:01:182229void RenderWidget::SetWindowRectSynchronously(
2230 const gfx::Rect& new_window_rect) {
2231 VisualProperties visual_properties;
2232 visual_properties.screen_info = screen_info_;
2233 visual_properties.new_size = new_window_rect.size();
2234 visual_properties.compositor_viewport_pixel_size = gfx::ScaleToCeiledSize(
2235 new_window_rect.size(), GetWebScreenInfo().device_scale_factor);
2236 visual_properties.visible_viewport_size = new_window_rect.size();
2237 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
2238 visual_properties.display_mode = display_mode_;
Fady Samuel84d8a1f72018-11-08 00:26:172239 visual_properties.local_surface_id_allocation =
2240 local_surface_id_allocation_from_parent_;
danakja2c9d0a92018-07-25 20:01:182241 // We are resizing the window from the renderer, so allocate a new
2242 // viz::LocalSurfaceId to avoid surface invariants violations in tests.
danakj125a29e2019-01-24 23:25:292243 layer_tree_view_->RequestNewLocalSurfaceId();
danakja2c9d0a92018-07-25 20:01:182244 SynchronizeVisualProperties(visual_properties);
2245
Albert J. Wong3c93c182018-09-27 17:29:432246 widget_screen_rect_ = new_window_rect;
danakja2c9d0a92018-07-25 20:01:182247 window_screen_rect_ = new_window_rect;
danakj65f423b72018-10-10 17:21:202248 if (show_callback_) {
2249 // Tests may call here directly to control the window rect. If
2250 // Show() did not happen yet, the rect is stored to be passed to the
2251 // browser when the RenderWidget requests Show().
danakja2c9d0a92018-07-25 20:01:182252 initial_rect_ = new_window_rect;
danakj65f423b72018-10-10 17:21:202253 }
danakja2c9d0a92018-07-25 20:01:182254}
2255
Vladimir Levin98d76dad2018-04-21 00:21:292256void RenderWidget::UpdateCaptureSequenceNumber(
2257 uint32_t capture_sequence_number) {
2258 if (capture_sequence_number == last_capture_sequence_number_)
2259 return;
2260 last_capture_sequence_number_ = capture_sequence_number;
2261
2262 // Notify observers of the new capture sequence number.
2263 for (auto& observer : render_frame_proxies_)
2264 observer.UpdateCaptureSequenceNumber(capture_sequence_number);
2265 for (auto& observer : browser_plugins_)
2266 observer.UpdateCaptureSequenceNumber(capture_sequence_number);
2267}
2268
[email protected]4873c7d2009-07-16 06:36:282269void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
EhsanK955ba582017-11-30 21:14:402270 if (auto* frame = GetFocusedWebLocalFrameInWidget())
2271 frame->SetTextDirection(direction);
[email protected]07f953332009-03-25 04:31:112272}
2273
Albert J. Wong3c93c182018-09-27 17:29:432274void RenderWidget::OnUpdateScreenRects(const gfx::Rect& widget_screen_rect,
[email protected]80ad8622012-11-07 16:33:032275 const gfx::Rect& window_screen_rect) {
[email protected]b2e4c70132013-10-03 02:07:512276 if (screen_metrics_emulator_) {
Albert J. Wong3c93c182018-09-27 17:29:432277 screen_metrics_emulator_->OnUpdateScreenRects(widget_screen_rect,
mfomitchev2600fd7c2016-02-17 20:53:392278 window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:512279 } else {
Albert J. Wong3c93c182018-09-27 17:29:432280 SetScreenRects(widget_screen_rect, window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:512281 }
Albert J. Wong3c93c182018-09-27 17:29:432282 Send(new WidgetHostMsg_UpdateScreenRects_ACK(routing_id()));
[email protected]80ad8622012-11-07 16:33:032283}
2284
kenrbea731792017-01-13 15:10:482285void RenderWidget::OnSetViewportIntersection(
Ken Buchananb2c9e262018-03-10 16:53:312286 const gfx::Rect& viewport_intersection,
Stefan Zager54e25832018-08-14 22:15:312287 const gfx::Rect& compositor_visible_rect,
Stefan Zager0926c9c2019-03-12 02:46:092288 blink::FrameOcclusionState occlusion_state) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252289 if (auto* frame_widget = GetFrameWidget()) {
Ken Buchananb2c9e262018-03-10 16:53:312290 compositor_visible_rect_ = compositor_visible_rect;
Stefan Zager54e25832018-08-14 22:15:312291 frame_widget->SetRemoteViewportIntersection(viewport_intersection,
Stefan Zager0926c9c2019-03-12 02:46:092292 occlusion_state);
danakja6c10012018-07-06 14:25:362293 layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect());
kenrbea731792017-01-13 15:10:482294 }
2295}
2296
kenrb04323782017-06-23 01:23:322297void RenderWidget::OnSetIsInert(bool inert) {
danakj89ae4532018-12-12 22:52:552298 if (auto* frame_widget = GetFrameWidget())
Ehsan Karamadf3ca2a82018-01-20 01:05:252299 frame_widget->SetIsInert(inert);
kenrb04323782017-06-23 01:23:322300}
2301
sunxd540a9962018-05-24 22:51:062302void RenderWidget::OnSetInheritedEffectiveTouchAction(
2303 cc::TouchAction touch_action) {
danakj89ae4532018-12-12 22:52:552304 if (auto* frame_widget = GetFrameWidget())
sunxd540a9962018-05-24 22:51:062305 frame_widget->SetInheritedEffectiveTouchAction(touch_action);
sunxd540a9962018-05-24 22:51:062306}
2307
Ken Buchanan8a319fb2017-11-15 18:37:122308void RenderWidget::OnUpdateRenderThrottlingStatus(bool is_throttled,
2309 bool subtree_throttled) {
danakj89ae4532018-12-12 22:52:552310 if (auto* frame_widget = GetFrameWidget())
Ehsan Karamadf3ca2a82018-01-20 01:05:252311 frame_widget->UpdateRenderThrottlingStatus(is_throttled, subtree_throttled);
Ken Buchanan8a319fb2017-11-15 18:37:122312}
2313
paulmeyer90f6c31d2016-11-12 00:17:592314void RenderWidget::OnDragTargetDragEnter(
2315 const std::vector<DropData::Metadata>& drop_meta_data,
Ella Ge80a52dce2017-11-15 18:01:522316 const gfx::PointF& client_point,
2317 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592318 WebDragOperationsMask ops,
2319 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252320 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2321 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592322 return;
2323
Ehsan Karamadf3ca2a82018-01-20 01:05:252324 WebDragOperation operation = frame_widget->DragTargetDragEnter(
2325 DropMetaDataToWebDragData(drop_meta_data), client_point, screen_point,
2326 ops, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592327
2328 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
2329}
2330
Ella Ge80a52dce2017-11-15 18:01:522331void RenderWidget::OnDragTargetDragOver(const gfx::PointF& client_point,
2332 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592333 WebDragOperationsMask ops,
2334 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252335 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2336 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592337 return;
2338
Ehsan Karamadf3ca2a82018-01-20 01:05:252339 WebDragOperation operation = frame_widget->DragTargetDragOver(
2340 ConvertWindowPointToViewport(client_point), screen_point, ops,
2341 key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592342
2343 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
2344}
2345
Ella Ge80a52dce2017-11-15 18:01:522346void RenderWidget::OnDragTargetDragLeave(const gfx::PointF& client_point,
2347 const gfx::PointF& screen_point) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252348 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2349 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592350 return;
Ehsan Karamadf3ca2a82018-01-20 01:05:252351
2352 frame_widget
Blink Reformat1c4d759e2017-04-09 16:34:542353 ->DragTargetDragLeave(ConvertWindowPointToViewport(client_point),
kenrb07c272802017-02-07 23:48:172354 screen_point);
paulmeyer90f6c31d2016-11-12 00:17:592355}
2356
2357void RenderWidget::OnDragTargetDrop(const DropData& drop_data,
Ella Ge80a52dce2017-11-15 18:01:522358 const gfx::PointF& client_point,
2359 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592360 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252361 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2362 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592363 return;
2364
Ehsan Karamadf3ca2a82018-01-20 01:05:252365 frame_widget->DragTargetDrop(DropDataToWebDragData(drop_data),
2366 ConvertWindowPointToViewport(client_point),
2367 screen_point, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592368}
2369
Ella Ge80a52dce2017-11-15 18:01:522370void RenderWidget::OnDragSourceEnded(const gfx::PointF& client_point,
2371 const gfx::PointF& screen_point,
paulmeyer8fc8ea92016-11-15 05:12:212372 WebDragOperation op) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252373 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2374 if (!frame_widget)
paulmeyer8fc8ea92016-11-15 05:12:212375 return;
2376
Ehsan Karamadf3ca2a82018-01-20 01:05:252377 frame_widget->DragSourceEndedAt(ConvertWindowPointToViewport(client_point),
2378 screen_point, op);
paulmeyer8fc8ea92016-11-15 05:12:212379}
2380
2381void RenderWidget::OnDragSourceSystemDragEnded() {
danakj503545c2019-01-11 19:03:092382 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2383 if (!frame_widget)
paulmeyer8fc8ea92016-11-15 05:12:212384 return;
2385
danakj503545c2019-01-11 19:03:092386 frame_widget->DragSourceSystemDragEnded();
paulmeyer8fc8ea92016-11-15 05:12:212387}
2388
Blink Reformat1c4d759e2017-04-09 16:34:542389void RenderWidget::ShowVirtualKeyboardOnElementFocus() {
okaa398f50b2017-03-21 06:30:262390#if defined(OS_CHROMEOS)
2391 // On ChromeOS, virtual keyboard is triggered only when users leave the
2392 // mouse button or the finger and a text input element is focused at that
2393 // time. Focus event itself shouldn't trigger virtual keyboard.
2394 UpdateTextInputState();
2395#else
changwan75e3b2072017-01-16 02:55:002396 ShowVirtualKeyboard();
okaa398f50b2017-03-21 06:30:262397#endif
boliu7b2be2f2016-11-04 04:58:312398
2399// TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
2400// virtual keyboard.
2401#if !defined(OS_ANDROID)
2402 FocusChangeComplete();
2403#endif
[email protected]0d1ebed12013-08-05 22:01:132404}
2405
fsamuel72464894f2015-12-15 06:59:312406ui::TextInputType RenderWidget::GetTextInputType() {
brettw4b461082016-11-19 18:55:162407#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492408 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2409 return plugin->text_input_type();
ekaramad2a46d632016-07-19 13:33:092410#endif
ekaramad5aff1942017-01-06 01:26:352411 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:542412 return ConvertWebTextInputType(controller->TextInputType());
fsamuel72464894f2015-12-15 06:59:312413 return ui::TEXT_INPUT_TYPE_NONE;
2414}
2415
nonafa291792016-08-10 02:36:182416void RenderWidget::UpdateCompositionInfo(bool immediate_request) {
2417 if (!monitor_composition_info_ && !immediate_request)
2418 return; // Do not calculate composition info if not requested.
nonadac0c7a2016-08-01 02:30:592419
nonafa291792016-08-10 02:36:182420 TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo");
2421 gfx::Range range;
2422 std::vector<gfx::Rect> character_bounds;
2423
2424 if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE) {
2425 // Composition information is only available on editable node.
2426 range = gfx::Range::InvalidRange();
2427 } else {
2428 GetCompositionRange(&range);
2429 GetCompositionCharacterBounds(&character_bounds);
2430 }
2431
2432 if (!immediate_request &&
2433 !ShouldUpdateCompositionInfo(range, character_bounds)) {
fsamuel72464894f2015-12-15 06:59:312434 return;
nonafa291792016-08-10 02:36:182435 }
fsamuel72464894f2015-12-15 06:59:312436 composition_character_bounds_ = character_bounds;
2437 composition_range_ = range;
Dave Tapuska04bc5ee92018-04-17 19:03:312438 if (mojom::WidgetInputHandlerHost* host =
2439 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
2440 host->ImeCompositionRangeChanged(composition_range_,
2441 composition_character_bounds_);
Dave Tapuska139a72f2017-09-06 21:57:032442 }
fsamuel72464894f2015-12-15 06:59:312443}
2444
Blink Reformat1c4d759e2017-04-09 16:34:542445void RenderWidget::ConvertViewportToWindow(blink::WebRect* rect) {
danakj4b347212018-07-04 17:55:172446 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:032447 float reverse = 1 / GetOriginalScreenInfo().device_scale_factor;
oshimad5279032015-12-16 18:22:332448 // TODO(oshima): We may need to allow pixel precision here as the the
oshimaf866dab2015-12-05 00:41:542449 // anchor element can be placed at half pixel.
lfg15b235a32016-08-25 17:45:462450 gfx::Rect window_rect =
2451 gfx::ScaleToEnclosedRect(gfx::Rect(*rect), reverse);
2452 rect->x = window_rect.x();
2453 rect->y = window_rect.y();
2454 rect->width = window_rect.width();
2455 rect->height = window_rect.height();
oshimaf866dab2015-12-05 00:41:542456 }
2457}
2458
Blink Reformat1c4d759e2017-04-09 16:34:542459void RenderWidget::ConvertWindowToViewport(blink::WebFloatRect* rect) {
danakj4b347212018-07-04 17:55:172460 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:032461 rect->x *= GetOriginalScreenInfo().device_scale_factor;
2462 rect->y *= GetOriginalScreenInfo().device_scale_factor;
2463 rect->width *= GetOriginalScreenInfo().device_scale_factor;
2464 rect->height *= GetOriginalScreenInfo().device_scale_factor;
oshimaa6985b62016-01-27 08:58:302465 }
2466}
2467
changwan8c342742016-02-26 00:53:392468void RenderWidget::OnRequestTextInputStateUpdate() {
Dave Tapuska9db80842017-07-24 17:24:262469#if defined(OS_ANDROID)
danakj125a29e2019-01-24 23:25:292470 // This task may run between the Close IPC and the task that actually closes
2471 // this class.
2472 if (closing_)
2473 return;
changwan8c342742016-02-26 00:53:392474 DCHECK(!ime_event_guard_);
2475 UpdateSelectionBounds();
changwan75e3b2072017-01-16 02:55:002476 UpdateTextInputStateInternal(false, true /* reply_to_request */);
[email protected]105dffb42013-02-20 03:46:212477#endif
Dave Tapuska9db80842017-07-24 17:24:262478}
[email protected]105dffb42013-02-20 03:46:212479
ekaramadc9b70a72017-03-23 16:14:232480void RenderWidget::OnRequestCompositionUpdates(bool immediate_request,
2481 bool monitor_updates) {
2482 monitor_composition_info_ = monitor_updates;
nonafa291792016-08-10 02:36:182483 if (!immediate_request)
2484 return;
2485 UpdateCompositionInfo(true /* immediate request */);
2486}
2487
[email protected]fcdc5642014-05-09 14:32:242488void RenderWidget::OnOrientationChange() {
Ehsan Karamad655d7b8a2018-01-12 18:38:382489 if (auto* frame_widget = GetFrameWidget()) {
Alex Moshchuk0b409c42017-09-13 02:09:002490 // LocalRoot() might return null for provisional main frames. In this case,
2491 // the frame hasn't committed a navigation and is not swapped into the tree
2492 // yet, so it doesn't make sense to send orientation change events to it.
2493 //
2494 // TODO(https://crbug.com/578349): This check should be cleaned up
2495 // once provisional frames are gone.
Ehsan Karamad655d7b8a2018-01-12 18:38:382496 if (frame_widget->LocalRoot())
2497 frame_widget->LocalRoot()->SendOrientationChangeEvent();
lfg8d649cc2017-04-28 18:04:302498 }
[email protected]fcdc5642014-05-09 14:32:242499}
2500
[email protected]bee16aab2009-08-26 15:55:032501void RenderWidget::SetHidden(bool hidden) {
danakj14e00a8322019-02-07 17:12:062502 // A frozen main frame widget does not become shown or hidden, since it has
2503 // no frame associated with it. It must be thawed before changing visibility.
2504 DCHECK(!is_frozen_);
2505
[email protected]bee16aab2009-08-26 15:55:032506 if (is_hidden_ == hidden)
2507 return;
2508
jdduke8fac9d102014-12-20 02:40:132509 // The status has changed. Tell the RenderThread about it and ensure
2510 // throttled acks are released in case frame production ceases.
[email protected]bee16aab2009-08-26 15:55:032511 is_hidden_ = hidden;
jdduke8fac9d102014-12-20 02:40:132512
Scott Violet1098538e2017-10-05 19:23:332513#if defined(USE_AURA)
Scott Violete46b3352018-09-22 00:37:072514 if (features::IsMultiProcessMash())
Scott Violet1098538e2017-10-05 19:23:332515 RendererWindowTreeClient::Get(routing_id_)->SetVisible(!hidden);
2516#endif
2517
Aditya Keerthic0d45b42019-02-25 18:53:002518 if (is_hidden_) {
2519 first_update_visual_state_after_hidden_ = true;
Lei Zhang9b359d32017-11-28 00:57:022520 }
alexclarke7fa93942015-10-21 15:37:112521
2522 if (render_widget_scheduling_state_)
2523 render_widget_scheduling_state_->SetHidden(hidden);
danakj1b35e9d2018-11-07 19:09:282524
David Bokanf92eaf22019-03-01 01:54:512525 // If the renderer was hidden, resolve any pending synthetic gestures so they
2526 // aren't blocked waiting for a compositor frame to be generated.
2527 if (is_hidden_)
2528 widget_input_handler_manager_->InvokeInputProcessedCallback();
2529
danakj14e00a8322019-02-07 17:12:062530 StartStopCompositor();
[email protected]bee16aab2009-08-26 15:55:032531}
2532
danakjf9284772019-01-23 18:29:142533void RenderWidget::SetIsFullscreen(bool fullscreen) {
2534 if (fullscreen == is_fullscreen_granted_)
[email protected]2b624c562011-10-27 22:58:262535 return;
danakjf9284772019-01-23 18:29:142536 is_fullscreen_granted_ = fullscreen;
mikhail.pozdnyakovf2c902a2015-04-14 08:09:122537 if (is_fullscreen_granted_) {
Blink Reformat1c4d759e2017-04-09 16:34:542538 GetWebWidget()->DidEnterFullscreen();
[email protected]2b624c562011-10-27 22:58:262539 } else {
Blink Reformat1c4d759e2017-04-09 16:34:542540 GetWebWidget()->DidExitFullscreen();
[email protected]2b624c562011-10-27 22:58:262541 }
[email protected]2b624c562011-10-27 22:58:262542}
2543
changwanf2a707b2015-10-30 08:22:162544void RenderWidget::OnImeEventGuardStart(ImeEventGuard* guard) {
2545 if (!ime_event_guard_)
2546 ime_event_guard_ = guard;
[email protected]66fca5bc2013-05-23 06:58:292547}
2548
changwanf2a707b2015-10-30 08:22:162549void RenderWidget::OnImeEventGuardFinish(ImeEventGuard* guard) {
Jeremy Roman0b261f42018-08-28 15:36:012550 if (ime_event_guard_ != guard)
changwanf2a707b2015-10-30 08:22:162551 return;
changwanf2a707b2015-10-30 08:22:162552 ime_event_guard_ = nullptr;
2553
[email protected]66fca5bc2013-05-23 06:58:292554 // While handling an ime event, text input state and selection bounds updates
2555 // are ignored. These must explicitly be updated once finished handling the
2556 // ime event.
2557 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:472558#if defined(OS_ANDROID)
changwan75e3b2072017-01-16 02:55:002559 if (guard->show_virtual_keyboard())
2560 ShowVirtualKeyboard();
2561 else
2562 UpdateTextInputState();
[email protected]cb9e2632013-06-18 11:26:472563#endif
[email protected]66fca5bc2013-05-23 06:58:292564}
2565
[email protected]7c8873e2013-02-05 08:03:012566void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
brettw4b461082016-11-19 18:55:162567#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492568 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
ekaramad2a46d632016-07-19 13:33:092569 // TODO(kinaba) http://crbug.com/101101
2570 // Current Pepper IME API does not handle selection bounds. So we simply
2571 // use the caret position as an empty range for now. It will be updated
2572 // after Pepper API equips features related to surrounding text retrieval.
EhsanK22d482e2017-08-10 17:29:492573 blink::WebRect caret(plugin->GetCaretBounds());
Blink Reformat1c4d759e2017-04-09 16:34:542574 ConvertViewportToWindow(&caret);
ekaramad2a46d632016-07-19 13:33:092575 *focus = caret;
2576 *anchor = caret;
2577 return;
2578 }
2579#endif
[email protected]7c8873e2013-02-05 08:03:012580 WebRect focus_webrect;
2581 WebRect anchor_webrect;
Blink Reformat1c4d759e2017-04-09 16:34:542582 GetWebWidget()->SelectionBounds(focus_webrect, anchor_webrect);
2583 ConvertViewportToWindow(&focus_webrect);
2584 ConvertViewportToWindow(&anchor_webrect);
oshima33ec97cd2015-12-14 19:40:242585 *focus = focus_webrect;
2586 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:322587}
2588
[email protected]e99ef6f2011-10-16 01:13:002589void RenderWidget::UpdateSelectionBounds() {
jdduke1aebad8e2015-07-22 23:25:082590 TRACE_EVENT0("renderer", "RenderWidget::UpdateSelectionBounds");
lfg8ff33912016-09-13 20:59:212591 if (!GetWebWidget())
[email protected]e99ef6f2011-10-16 01:13:002592 return;
changwanf2a707b2015-10-30 08:22:162593 if (ime_event_guard_)
[email protected]66fca5bc2013-05-23 06:58:292594 return;
[email protected]e99ef6f2011-10-16 01:13:002595
mohsenb0eeba72015-08-09 06:20:082596#if defined(USE_AURA)
2597 // TODO(mohsen): For now, always send explicit selection IPC notifications for
2598 // Aura beucause composited selection updates are not working for webview tags
2599 // which regresses IME inside webview. Remove this when composited selection
2600 // updates are fixed for webviews. See, http://crbug.com/510568.
2601 bool send_ipc = true;
2602#else
jddukeacf809e2014-09-23 20:38:382603 // With composited selection updates, the selection bounds will be reported
2604 // directly by the compositor, in which case explicit IPC selection
2605 // notifications should be suppressed.
mohsenb0eeba72015-08-09 06:20:082606 bool send_ipc =
Blink Reformat1c4d759e2017-04-09 16:34:542607 !blink::WebRuntimeFeatures::IsCompositedSelectionUpdateEnabled();
mohsenb0eeba72015-08-09 06:20:082608#endif
2609 if (send_ipc) {
Albert J. Wong3c93c182018-09-27 17:29:432610 WidgetHostMsg_SelectionBounds_Params params;
EhsanK955ba582017-11-30 21:14:402611 params.is_anchor_first = false;
jddukeacf809e2014-09-23 20:38:382612 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
2613 if (selection_anchor_rect_ != params.anchor_rect ||
2614 selection_focus_rect_ != params.focus_rect) {
2615 selection_anchor_rect_ = params.anchor_rect;
2616 selection_focus_rect_ = params.focus_rect;
EhsanK955ba582017-11-30 21:14:402617 if (auto* focused_frame = GetFocusedWebLocalFrameInWidget()) {
2618 focused_frame->SelectionTextDirection(params.focus_dir,
2619 params.anchor_dir);
2620 params.is_anchor_first = focused_frame->IsSelectionAnchorFirst();
2621 }
Albert J. Wong3c93c182018-09-27 17:29:432622 Send(new WidgetHostMsg_SelectionBoundsChanged(routing_id_, params));
jddukeacf809e2014-09-23 20:38:382623 }
[email protected]58b48a0d2012-06-13 07:01:352624 }
jddukeacf809e2014-09-23 20:38:382625
nonafa291792016-08-10 02:36:182626 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]e99ef6f2011-10-16 01:13:002627}
2628
lfgb00fcad2016-07-14 14:16:332629void RenderWidget::DidAutoResize(const gfx::Size& new_size) {
danakj125a29e2019-01-24 23:25:292630 // Blink can continue running and do a layout/resize between the Close IPC
2631 // and the task that actually closes this class.
2632 if (closing_)
2633 return;
2634
lfgb00fcad2016-07-14 14:16:332635 WebRect new_size_in_window(0, 0, new_size.width(), new_size.height());
Blink Reformat1c4d759e2017-04-09 16:34:542636 ConvertViewportToWindow(&new_size_in_window);
lfgb00fcad2016-07-14 14:16:332637 if (size_.width() != new_size_in_window.width ||
2638 size_.height() != new_size_in_window.height) {
2639 size_ = gfx::Size(new_size_in_window.width, new_size_in_window.height);
2640
danakj7602f4f2019-01-31 18:03:232641 if (synchronous_resize_mode_for_testing_) {
Blink Reformat1c4d759e2017-04-09 16:34:542642 gfx::Rect new_pos(WindowRect().x, WindowRect().y, size_.width(),
2643 size_.height());
Albert J. Wong3c93c182018-09-27 17:29:432644 widget_screen_rect_ = new_pos;
lfgb00fcad2016-07-14 14:16:332645 window_screen_rect_ = new_pos;
2646 }
2647
Christopher Camerone9a30c12018-03-07 08:23:382648 // TODO(ccameron): Note that this destroys any information differentiating
danakj9c4e7b812019-02-19 22:04:272649 // |size_| from the compositor's viewport size. Also note that the
Christopher Cameronaad15a0d2018-03-09 03:47:332650 // calculation of |new_compositor_viewport_pixel_size| does not appear to
2651 // take into account device emulation.
danakj125a29e2019-01-24 23:25:292652 layer_tree_view_->RequestNewLocalSurfaceId();
Christopher Cameronaad15a0d2018-03-09 03:47:332653 gfx::Size new_compositor_viewport_pixel_size =
Fady Samuela863f152018-03-09 16:10:032654 gfx::ScaleToCeiledSize(size_, GetWebScreenInfo().device_scale_factor);
Fady Samuel1c1ad3692018-11-06 23:28:402655 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
2656 new_compositor_viewport_pixel_size,
2657 screen_info_);
lfgb00fcad2016-07-14 14:16:332658 }
2659}
2660
[email protected]58b48a0d2012-06-13 07:01:352661void RenderWidget::GetCompositionCharacterBounds(
2662 std::vector<gfx::Rect>* bounds) {
2663 DCHECK(bounds);
2664 bounds->clear();
ekaramad2a46d632016-07-19 13:33:092665
brettw4b461082016-11-19 18:55:162666#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492667 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092668 return;
2669#endif
2670
Ehsan Karamad4975af6d2018-02-09 16:58:162671 blink::WebInputMethodController* controller = GetInputMethodController();
2672 if (!controller)
ekaramad2a46d632016-07-19 13:33:092673 return;
2674 blink::WebVector<blink::WebRect> bounds_from_blink;
Ehsan Karamad4975af6d2018-02-09 16:58:162675 if (!controller->GetCompositionCharacterBounds(bounds_from_blink))
ekaramad2a46d632016-07-19 13:33:092676 return;
2677
2678 for (size_t i = 0; i < bounds_from_blink.size(); ++i) {
Blink Reformat1c4d759e2017-04-09 16:34:542679 ConvertViewportToWindow(&bounds_from_blink[i]);
ekaramad2a46d632016-07-19 13:33:092680 bounds->push_back(bounds_from_blink[i]);
2681 }
[email protected]58b48a0d2012-06-13 07:01:352682}
2683
[email protected]db4fc1e2013-09-06 20:01:512684void RenderWidget::GetCompositionRange(gfx::Range* range) {
brettw4b461082016-11-19 18:55:162685#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492686 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092687 return;
2688#endif
EhsanKcdee7b72017-11-08 21:30:092689 blink::WebInputMethodController* controller = GetInputMethodController();
2690 WebRange web_range = controller ? controller->CompositionRange() : WebRange();
Blink Reformat1c4d759e2017-04-09 16:34:542691 if (web_range.IsNull()) {
nona2363a3d2016-11-09 03:26:212692 *range = gfx::Range::InvalidRange();
2693 return;
[email protected]88dbe32f2013-06-20 23:31:362694 }
Blink Reformat1c4d759e2017-04-09 16:34:542695 range->set_start(web_range.StartOffset());
2696 range->set_end(web_range.EndOffset());
[email protected]88dbe32f2013-06-20 23:31:362697}
2698
[email protected]501ea13d2013-07-09 17:03:292699bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:512700 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:292701 const std::vector<gfx::Rect>& bounds) {
changwan2418e1b2016-12-12 12:43:082702 if (!range.IsValid())
2703 return false;
[email protected]501ea13d2013-07-09 17:03:292704 if (composition_range_ != range)
2705 return true;
2706 if (bounds.size() != composition_character_bounds_.size())
2707 return true;
2708 for (size_t i = 0; i < bounds.size(); ++i) {
2709 if (bounds[i] != composition_character_bounds_[i])
2710 return true;
2711 }
2712 return false;
2713}
[email protected]501ea13d2013-07-09 17:03:292714
[email protected]ad26ef42011-06-17 07:59:452715bool RenderWidget::CanComposeInline() {
brettw4b461082016-11-19 18:55:162716#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492717 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2718 return plugin->IsPluginAcceptingCompositionEvents();
ekaramad2a46d632016-07-19 13:33:092719#endif
[email protected]ad26ef42011-06-17 07:59:452720 return true;
[email protected]56ea1a62011-05-30 07:05:572721}
2722
Blink Reformat1c4d759e2017-04-09 16:34:542723void RenderWidget::DidHandleGestureEvent(const WebGestureEvent& event,
2724 bool event_cancelled) {
danakja2c9d0a92018-07-25 20:01:182725 if (event_cancelled) {
Albert J. Wong7bbf22d2018-12-20 00:27:272726 // The delegate() doesn't need to hear about cancelled events.
[email protected]c68c3e4e2013-01-24 00:36:562727 return;
danakja2c9d0a92018-07-25 20:01:182728 }
2729
2730#if defined(OS_ANDROID) || defined(USE_AURA)
Blink Reformat1c4d759e2017-04-09 16:34:542731 if (event.GetType() == WebInputEvent::kGestureTap) {
changwan75e3b2072017-01-16 02:55:002732 ShowVirtualKeyboard();
Blink Reformat1c4d759e2017-04-09 16:34:542733 } else if (event.GetType() == WebInputEvent::kGestureLongPress) {
lfg8ff33912016-09-13 20:59:212734 DCHECK(GetWebWidget());
ekaramad5aff1942017-01-06 01:26:352735 blink::WebInputMethodController* controller = GetInputMethodController();
Blink Reformat1c4d759e2017-04-09 16:34:542736 if (!controller || controller->TextInputInfo().value.IsEmpty())
changwan75e3b2072017-01-16 02:55:002737 UpdateTextInputState();
[email protected]07c70d22014-08-21 08:33:462738 else
changwan75e3b2072017-01-16 02:55:002739 ShowVirtualKeyboard();
[email protected]c68c3e4e2013-01-24 00:36:562740 }
ekaramada110f642016-12-21 19:47:282741// TODO(ananta): Piggyback off existing IPCs to communicate this information,
2742// crbug/420130.
2743#if defined(OS_WIN)
danakja2c9d0a92018-07-25 20:01:182744 if (event.GetType() == blink::WebGestureEvent::kGestureTap) {
2745 // TODO(estade): hit test the event against focused node to make sure
2746 // the tap actually hit the focused node.
2747 blink::WebInputMethodController* controller = GetInputMethodController();
2748 blink::WebTextInputType text_input_type =
2749 controller ? controller->TextInputType() : blink::kWebTextInputTypeNone;
ekaramada110f642016-12-21 19:47:282750
Albert J. Wong3c93c182018-09-27 17:29:432751 Send(new WidgetHostMsg_FocusedNodeTouched(
danakja2c9d0a92018-07-25 20:01:182752 routing_id_, text_input_type != blink::kWebTextInputTypeNone));
2753 }
ekaramada110f642016-12-21 19:47:282754#endif
[email protected]c68c3e4e2013-01-24 00:36:562755#endif
danakja2c9d0a92018-07-25 20:01:182756
Albert J. Wong7bbf22d2018-12-20 00:27:272757 // The delegate() gets to respond to handling gestures last.
2758 if (delegate())
2759 delegate()->DidHandleGestureEventForWidget(event);
[email protected]c68c3e4e2013-01-24 00:36:562760}
2761
Blink Reformat1c4d759e2017-04-09 16:34:542762void RenderWidget::DidOverscroll(
bokane53a10f2016-04-13 23:48:312763 const blink::WebFloatSize& overscrollDelta,
2764 const blink::WebFloatSize& accumulatedOverscroll,
sataya.m582c9ce2015-06-09 08:03:422765 const blink::WebFloatPoint& position,
sunyunjiabbea8a92017-08-31 11:18:542766 const blink::WebFloatSize& velocity,
danakje819b622018-05-01 20:27:142767 const cc::OverscrollBehavior& behavior) {
bokan731ec382016-04-07 03:16:482768#if defined(OS_MACOSX)
2769 // On OSX the user can disable the elastic overscroll effect. If that's the
2770 // case, don't forward the overscroll notification.
2771 DCHECK(compositor_deps());
2772 if (!compositor_deps()->IsElasticOverscrollEnabled())
2773 return;
2774#endif
bokane53a10f2016-04-13 23:48:312775 input_handler_->DidOverscrollFromBlink(overscrollDelta, accumulatedOverscroll,
sunyunjiabbea8a92017-08-31 11:18:542776 position, velocity, behavior);
sataya.m582c9ce2015-06-09 08:03:422777}
2778
danakj4b347212018-07-04 17:55:172779// static
2780cc::LayerTreeSettings RenderWidget::GenerateLayerTreeSettings(
2781 CompositorDependencies* compositor_deps,
2782 bool is_for_subframe,
2783 const gfx::Size& initial_screen_size,
2784 float initial_device_scale_factor) {
2785 const bool is_threaded =
2786 !!compositor_deps->GetCompositorImplThreadTaskRunner();
2787
2788 const base::CommandLine& cmd = *base::CommandLine::ForCurrentProcess();
2789 cc::LayerTreeSettings settings;
2790
2791 settings.resource_settings.use_r16_texture =
2792 base::FeatureList::IsEnabled(media::kUseR16Texture);
2793
2794 settings.commit_to_active_tree = !is_threaded;
2795 settings.is_layer_tree_for_subframe = is_for_subframe;
2796
2797 // For web contents, layer transforms should scale up the contents of layers
2798 // to keep content always crisp when possible.
2799 settings.layer_transforms_should_scale_layer_contents = true;
2800
2801 settings.main_frame_before_activation_enabled =
2802 cmd.HasSwitch(cc::switches::kEnableMainFrameBeforeActivation);
2803
2804 // Checkerimaging is not supported for synchronous single-threaded mode, which
2805 // is what the renderer uses if its not threaded.
2806 settings.enable_checker_imaging =
2807 !cmd.HasSwitch(cc::switches::kDisableCheckerImaging) && is_threaded;
2808
2809#if defined(OS_ANDROID)
2810 // We can use a more aggressive limit on Android since decodes tend to take
2811 // longer on these devices.
2812 settings.min_image_bytes_to_checker = 512 * 1024; // 512kB
2813
2814 // Re-rasterization of checker-imaged content with software raster can be too
2815 // costly on Android.
2816 settings.only_checker_images_with_gpu_raster = true;
2817#endif
2818
2819 auto switch_value_as_int = [](const base::CommandLine& command_line,
2820 const std::string& switch_string, int min_value,
2821 int max_value, int* result) {
2822 std::string string_value = command_line.GetSwitchValueASCII(switch_string);
2823 int int_value;
2824 if (base::StringToInt(string_value, &int_value) && int_value >= min_value &&
2825 int_value <= max_value) {
2826 *result = int_value;
2827 return true;
2828 } else {
2829 LOG(WARNING) << "Failed to parse switch " << switch_string << ": "
2830 << string_value;
2831 return false;
2832 }
2833 };
2834
2835 int default_tile_size = 256;
2836#if defined(OS_ANDROID)
2837 const gfx::Size screen_size =
2838 gfx::ScaleToFlooredSize(initial_screen_size, initial_device_scale_factor);
2839 int display_width = screen_size.width();
2840 int display_height = screen_size.height();
2841 int numTiles = (display_width * display_height) / (256 * 256);
2842 if (numTiles > 16)
2843 default_tile_size = 384;
2844 if (numTiles >= 40)
2845 default_tile_size = 512;
2846
2847 // Adjust for some resolutions that barely straddle an extra
2848 // tile when in portrait mode. This helps worst case scroll/raster
2849 // by not needing a full extra tile for each row.
2850 constexpr int tolerance = 10; // To avoid rounding errors.
2851 int portrait_width = std::min(display_width, display_height);
2852 if (default_tile_size == 256 && std::abs(portrait_width - 768) < tolerance)
2853 default_tile_size += 32;
2854 if (default_tile_size == 384 && std::abs(portrait_width - 1200) < tolerance)
2855 default_tile_size += 32;
2856#elif defined(OS_CHROMEOS) || defined(OS_MACOSX)
2857 // Use 512 for high DPI (dsf=2.0f) devices.
2858 if (initial_device_scale_factor >= 2.0f)
2859 default_tile_size = 512;
2860#endif
2861
2862 // TODO(danakj): This should not be a setting O_O; it should change when the
2863 // device scale factor on LayerTreeHost changes.
2864 settings.default_tile_size = gfx::Size(default_tile_size, default_tile_size);
2865 if (cmd.HasSwitch(switches::kDefaultTileWidth)) {
2866 int tile_width = 0;
2867 switch_value_as_int(cmd, switches::kDefaultTileWidth, 1,
2868 std::numeric_limits<int>::max(), &tile_width);
2869 settings.default_tile_size.set_width(tile_width);
2870 }
2871 if (cmd.HasSwitch(switches::kDefaultTileHeight)) {
2872 int tile_height = 0;
2873 switch_value_as_int(cmd, switches::kDefaultTileHeight, 1,
2874 std::numeric_limits<int>::max(), &tile_height);
2875 settings.default_tile_size.set_height(tile_height);
2876 }
2877
2878 int max_untiled_layer_width = settings.max_untiled_layer_size.width();
2879 if (cmd.HasSwitch(switches::kMaxUntiledLayerWidth)) {
2880 switch_value_as_int(cmd, switches::kMaxUntiledLayerWidth, 1,
2881 std::numeric_limits<int>::max(),
2882 &max_untiled_layer_width);
2883 }
2884 int max_untiled_layer_height = settings.max_untiled_layer_size.height();
2885 if (cmd.HasSwitch(switches::kMaxUntiledLayerHeight)) {
2886 switch_value_as_int(cmd, switches::kMaxUntiledLayerHeight, 1,
2887 std::numeric_limits<int>::max(),
2888 &max_untiled_layer_height);
2889 }
2890
2891 settings.max_untiled_layer_size =
2892 gfx::Size(max_untiled_layer_width, max_untiled_layer_height);
2893
2894 settings.gpu_rasterization_msaa_sample_count =
2895 compositor_deps->GetGpuRasterizationMSAASampleCount();
2896 settings.gpu_rasterization_forced =
2897 compositor_deps->IsGpuRasterizationForced();
2898
2899 settings.can_use_lcd_text = compositor_deps->IsLcdTextEnabled();
2900 settings.use_zero_copy = compositor_deps->IsZeroCopyEnabled();
2901 settings.use_partial_raster = compositor_deps->IsPartialRasterEnabled();
2902 settings.enable_elastic_overscroll =
2903 compositor_deps->IsElasticOverscrollEnabled();
2904 settings.resource_settings.use_gpu_memory_buffer_resources =
2905 compositor_deps->IsGpuMemoryBufferCompositorResourcesEnabled();
2906 settings.use_painted_device_scale_factor =
2907 compositor_deps->IsUseZoomForDSFEnabled();
2908
2909 // Build LayerTreeSettings from command line args.
2910 if (cmd.HasSwitch(cc::switches::kBrowserControlsShowThreshold)) {
2911 std::string top_threshold_str =
2912 cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsShowThreshold);
2913 double show_threshold;
2914 if (base::StringToDouble(top_threshold_str, &show_threshold) &&
2915 show_threshold >= 0.f && show_threshold <= 1.f)
2916 settings.top_controls_show_threshold = show_threshold;
2917 }
2918
2919 if (cmd.HasSwitch(cc::switches::kBrowserControlsHideThreshold)) {
2920 std::string top_threshold_str =
2921 cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsHideThreshold);
2922 double hide_threshold;
2923 if (base::StringToDouble(top_threshold_str, &hide_threshold) &&
2924 hide_threshold >= 0.f && hide_threshold <= 1.f)
2925 settings.top_controls_hide_threshold = hide_threshold;
2926 }
2927
Philip Rogersc55ab6a2018-12-05 17:29:192928 // Blink sends cc a layer list and property trees when either
2929 // BlinkGenPropertyTrees or CompositeAfterPaint are enabled.
Philip Rogersfc2f1162018-10-17 18:28:312930 settings.use_layer_lists =
2931 blink::WebRuntimeFeatures::IsBlinkGenPropertyTreesEnabled() ||
Philip Rogersc55ab6a2018-12-05 17:29:192932 blink::WebRuntimeFeatures::IsCompositeAfterPaintEnabled();
danakj4b347212018-07-04 17:55:172933
David Bokan163b6a72018-10-25 22:03:492934 // Blink currently doesn't support setting fractional scroll offsets so CC
2935 // must send integer values. We plan to eventually make Blink use fractional
2936 // offsets internally: https://crbug.com/414283.
2937 settings.commit_fractional_scroll_deltas =
2938 blink::WebRuntimeFeatures::IsFractionalScrollOffsetsEnabled();
2939
danakj4b347212018-07-04 17:55:172940 // The means the renderer compositor has 2 possible modes:
2941 // - Threaded compositing with a scheduler.
Kent Tamura21d1de62018-12-10 04:45:202942 // - Single threaded compositing without a scheduler (for web tests only).
2943 // Using the scheduler in web tests introduces additional composite steps
danakj4b347212018-07-04 17:55:172944 // that create flakiness.
2945 settings.single_thread_proxy_scheduler = false;
2946
2947 // These flags should be mirrored by UI versions in ui/compositor/.
2948 if (cmd.HasSwitch(cc::switches::kShowCompositedLayerBorders))
2949 settings.initial_debug_state.show_debug_borders.set();
2950 settings.initial_debug_state.show_layer_animation_bounds_rects =
2951 cmd.HasSwitch(cc::switches::kShowLayerAnimationBounds);
2952 settings.initial_debug_state.show_paint_rects =
2953 cmd.HasSwitch(switches::kShowPaintRects);
2954 settings.initial_debug_state.show_property_changed_rects =
2955 cmd.HasSwitch(cc::switches::kShowPropertyChangedRects);
2956 settings.initial_debug_state.show_surface_damage_rects =
2957 cmd.HasSwitch(cc::switches::kShowSurfaceDamageRects);
2958 settings.initial_debug_state.show_screen_space_rects =
2959 cmd.HasSwitch(cc::switches::kShowScreenSpaceRects);
2960
2961 settings.initial_debug_state.SetRecordRenderingStats(
2962 cmd.HasSwitch(cc::switches::kEnableGpuBenchmarking));
2963 settings.enable_surface_synchronization =
2964 features::IsSurfaceSynchronizationEnabled();
2965 settings.build_hit_test_data = features::IsVizHitTestingSurfaceLayerEnabled();
2966
2967 if (cmd.HasSwitch(cc::switches::kSlowDownRasterScaleFactor)) {
2968 const int kMinSlowDownScaleFactor = 0;
2969 const int kMaxSlowDownScaleFactor = INT_MAX;
2970 switch_value_as_int(
2971 cmd, cc::switches::kSlowDownRasterScaleFactor, kMinSlowDownScaleFactor,
2972 kMaxSlowDownScaleFactor,
2973 &settings.initial_debug_state.slow_down_raster_scale_factor);
2974 }
2975
2976 // This is default overlay scrollbar settings for Android and DevTools mobile
2977 // emulator. Aura Overlay Scrollbar will override below.
2978 settings.scrollbar_animator = cc::LayerTreeSettings::ANDROID_OVERLAY;
2979 settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
2980 settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(300);
2981 settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(300);
2982
Daniel Libby43972d82019-02-28 21:35:362983 if (cmd.HasSwitch(cc::switches::kCCScrollAnimationDurationForTesting)) {
2984 const int kMinScrollAnimationDuration = 0;
2985 const int kMaxScrollAnimationDuration = INT_MAX;
2986 int duration;
2987 if (switch_value_as_int(cmd,
2988 cc::switches::kCCScrollAnimationDurationForTesting,
2989 kMinScrollAnimationDuration,
2990 kMaxScrollAnimationDuration, &duration)) {
2991 settings.scroll_animation_duration_for_testing =
2992 base::TimeDelta::FromSeconds(duration);
2993 }
2994 }
2995
danakj4b347212018-07-04 17:55:172996#if defined(OS_ANDROID)
2997 bool using_synchronous_compositor =
2998 compositor_deps->UsingSynchronousCompositing();
2999 bool using_low_memory_policy = base::SysInfo::IsLowEndDevice();
3000
3001 settings.use_stream_video_draw_quad = true;
3002 settings.using_synchronous_renderer_compositor = using_synchronous_compositor;
3003 if (using_synchronous_compositor) {
3004 // Android WebView uses system scrollbars, so make ours invisible.
3005 // http://crbug.com/677348: This can't be done using hide_scrollbars
3006 // setting because supporting -webkit custom scrollbars is still desired
3007 // on sublayers.
3008 settings.scrollbar_animator = cc::LayerTreeSettings::NO_ANIMATOR;
3009 settings.solid_color_scrollbar_color = SK_ColorTRANSPARENT;
3010
3011 settings.enable_early_damage_check =
3012 cmd.HasSwitch(cc::switches::kCheckDamageEarly);
3013 }
3014 // Android WebView handles root layer flings itself.
3015 settings.ignore_root_layer_flings = using_synchronous_compositor;
3016 // Memory policy on Android WebView does not depend on whether device is
3017 // low end, so always use default policy.
3018 if (using_low_memory_policy && !using_synchronous_compositor) {
3019 // On low-end we want to be very carefull about killing other
3020 // apps. So initially we use 50% more memory to avoid flickering
3021 // or raster-on-demand.
3022 settings.max_memory_for_prepaint_percentage = 67;
3023 } else {
3024 // On other devices we have increased memory excessively to avoid
3025 // raster-on-demand already, so now we reserve 50% _only_ to avoid
3026 // raster-on-demand, and use 50% of the memory otherwise.
3027 settings.max_memory_for_prepaint_percentage = 50;
3028 }
3029
3030 // TODO(danakj): Only do this on low end devices.
3031 settings.create_low_res_tiling = true;
3032
3033#else // defined(OS_ANDROID)
3034 bool using_synchronous_compositor = false; // Only for Android WebView.
3035 // On desktop, we never use the low memory policy unless we are simulating
3036 // low-end mode via a switch.
3037 bool using_low_memory_policy =
3038 cmd.HasSwitch(switches::kEnableLowEndDeviceMode);
3039
3040 if (ui::IsOverlayScrollbarEnabled()) {
3041 settings.scrollbar_animator = cc::LayerTreeSettings::AURA_OVERLAY;
3042 settings.scrollbar_fade_delay = ui::kOverlayScrollbarFadeDelay;
3043 settings.scrollbar_fade_duration = ui::kOverlayScrollbarFadeDuration;
3044 settings.scrollbar_thinning_duration =
3045 ui::kOverlayScrollbarThinningDuration;
3046 settings.scrollbar_flash_after_any_scroll_update =
3047 ui::OverlayScrollbarFlashAfterAnyScrollUpdate();
3048 settings.scrollbar_flash_when_mouse_enter =
3049 ui::OverlayScrollbarFlashWhenMouseEnter();
3050 }
3051
3052 // On desktop, if there's over 4GB of memory on the machine, increase the
3053 // working set size to 256MB for both gpu and software.
3054 const int kImageDecodeMemoryThresholdMB = 4 * 1024;
3055 if (base::SysInfo::AmountOfPhysicalMemoryMB() >=
3056 kImageDecodeMemoryThresholdMB) {
3057 settings.decoded_image_working_set_budget_bytes = 256 * 1024 * 1024;
3058 } else {
3059 // This is the default, but recorded here as well.
3060 settings.decoded_image_working_set_budget_bytes = 128 * 1024 * 1024;
3061 }
3062#endif // defined(OS_ANDROID)
3063
3064 if (using_low_memory_policy) {
3065 // RGBA_4444 textures are only enabled:
3066 // - If the user hasn't explicitly disabled them
3067 // - If system ram is <= 512MB (1GB devices are sometimes low-end).
3068 // - If we are not running in a WebView, where 4444 isn't supported.
3069 if (!cmd.HasSwitch(switches::kDisableRGBA4444Textures) &&
3070 base::SysInfo::AmountOfPhysicalMemoryMB() <= 512 &&
3071 !using_synchronous_compositor) {
3072 settings.use_rgba_4444 = viz::RGBA_4444;
3073
3074 // If we are going to unpremultiply and dither these tiles, we need to
3075 // allocate an additional RGBA_8888 intermediate for each tile
3076 // rasterization when rastering to RGBA_4444 to allow for dithering.
3077 // Setting a reasonable sized max tile size allows this intermediate to
3078 // be consistently reused.
3079 if (base::FeatureList::IsEnabled(
3080 kUnpremultiplyAndDitherLowBitDepthTiles)) {
3081 settings.max_gpu_raster_tile_size = gfx::Size(512, 256);
3082 settings.unpremultiply_and_dither_low_bit_depth_tiles = true;
3083 }
3084 }
3085 }
3086
3087 if (cmd.HasSwitch(switches::kEnableLowResTiling))
3088 settings.create_low_res_tiling = true;
3089 if (cmd.HasSwitch(switches::kDisableLowResTiling))
3090 settings.create_low_res_tiling = false;
3091
3092 if (cmd.HasSwitch(switches::kEnableRGBA4444Textures) &&
3093 !cmd.HasSwitch(switches::kDisableRGBA4444Textures)) {
3094 settings.use_rgba_4444 = true;
3095 }
3096
3097 settings.max_staging_buffer_usage_in_bytes = 32 * 1024 * 1024; // 32MB
3098 // Use 1/4th of staging buffers on low-end devices.
3099 if (base::SysInfo::IsLowEndDevice())
3100 settings.max_staging_buffer_usage_in_bytes /= 4;
3101
3102 cc::ManagedMemoryPolicy defaults = settings.memory_policy;
3103 settings.memory_policy = GetGpuMemoryPolicy(defaults, initial_screen_size,
3104 initial_device_scale_factor);
3105
3106 settings.disallow_non_exact_resource_reuse =
3107 cmd.HasSwitch(switches::kDisallowNonExactResourceReuse);
3108#if defined(OS_ANDROID)
3109 // TODO(crbug.com/746931): This feature appears to be causing visual
3110 // corruption on certain android devices. Will investigate and re-enable.
3111 settings.disallow_non_exact_resource_reuse = true;
3112#endif
3113
3114 if (cmd.HasSwitch(switches::kRunAllCompositorStagesBeforeDraw)) {
3115 settings.wait_for_all_pipeline_stages_before_draw = true;
3116 settings.enable_latency_recovery = false;
3117 }
Eric Karl1e6ffca2019-02-23 22:08:503118#if defined(OS_ANDROID)
3119 if (features::IsSurfaceSynchronizationEnabled()) {
3120 // TODO(crbug.com/933846): LatencyRecovery is causing jank on Android.
3121 // Disable in viz mode for now, with plant o disable more widely once
3122 // viz launches.
3123 settings.enable_latency_recovery = false;
3124 }
3125#endif
danakj4b347212018-07-04 17:55:173126
3127 settings.enable_image_animation_resync =
3128 !cmd.HasSwitch(switches::kDisableImageAnimationResync);
3129
Karolina Soltys4d60b402018-10-01 19:28:203130 settings.send_compositor_frame_ack = false;
3131
danakj4b347212018-07-04 17:55:173132 return settings;
3133}
3134
3135// static
3136cc::ManagedMemoryPolicy RenderWidget::GetGpuMemoryPolicy(
3137 const cc::ManagedMemoryPolicy& default_policy,
3138 const gfx::Size& initial_screen_size,
3139 float initial_device_scale_factor) {
3140 cc::ManagedMemoryPolicy actual = default_policy;
3141 actual.bytes_limit_when_visible = 0;
3142
3143 // If the value was overridden on the command line, use the specified value.
3144 static bool client_hard_limit_bytes_overridden =
3145 base::CommandLine::ForCurrentProcess()->HasSwitch(
3146 switches::kForceGpuMemAvailableMb);
3147 if (client_hard_limit_bytes_overridden) {
3148 if (base::StringToSizeT(
3149 base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
3150 switches::kForceGpuMemAvailableMb),
3151 &actual.bytes_limit_when_visible))
3152 actual.bytes_limit_when_visible *= 1024 * 1024;
3153 return actual;
3154 }
3155
3156#if defined(OS_ANDROID)
3157 // We can't query available GPU memory from the system on Android.
3158 // Physical memory is also mis-reported sometimes (eg. Nexus 10 reports
3159 // 1262MB when it actually has 2GB, while Razr M has 1GB but only reports
3160 // 128MB java heap size). First we estimate physical memory using both.
3161 size_t dalvik_mb = base::SysInfo::DalvikHeapSizeMB();
3162 size_t physical_mb = base::SysInfo::AmountOfPhysicalMemoryMB();
3163 size_t physical_memory_mb = 0;
3164 if (base::SysInfo::IsLowEndDevice()) {
3165 // TODO(crbug.com/742534): The code below appears to no longer work.
3166 // |dalvik_mb| no longer follows the expected heuristic pattern, causing us
3167 // to over-estimate memory on low-end devices. This entire section probably
3168 // needs to be re-written, but for now we can address the low-end Android
3169 // issues by ignoring |dalvik_mb|.
3170 physical_memory_mb = physical_mb;
3171 } else if (dalvik_mb >= 256) {
3172 physical_memory_mb = dalvik_mb * 4;
3173 } else {
3174 physical_memory_mb = std::max(dalvik_mb * 4, (physical_mb * 4) / 3);
3175 }
3176
3177 // Now we take a default of 1/8th of memory on high-memory devices,
3178 // and gradually scale that back for low-memory devices (to be nicer
3179 // to other apps so they don't get killed). Examples:
3180 // Nexus 4/10(2GB) 256MB (normally 128MB)
3181 // Droid Razr M(1GB) 114MB (normally 57MB)
3182 // Galaxy Nexus(1GB) 100MB (normally 50MB)
3183 // Xoom(1GB) 100MB (normally 50MB)
3184 // Nexus S(low-end) 8MB (normally 8MB)
3185 // Note that the compositor now uses only some of this memory for
3186 // pre-painting and uses the rest only for 'emergencies'.
3187 if (actual.bytes_limit_when_visible == 0) {
3188 // NOTE: Non-low-end devices use only 50% of these limits,
3189 // except during 'emergencies' where 100% can be used.
3190 if (physical_memory_mb >= 1536)
3191 actual.bytes_limit_when_visible = physical_memory_mb / 8; // >192MB
3192 else if (physical_memory_mb >= 1152)
3193 actual.bytes_limit_when_visible = physical_memory_mb / 8; // >144MB
3194 else if (physical_memory_mb >= 768)
3195 actual.bytes_limit_when_visible = physical_memory_mb / 10; // >76MB
3196 else if (physical_memory_mb >= 513)
3197 actual.bytes_limit_when_visible = physical_memory_mb / 12; // <64MB
3198 else
3199 // Devices with this little RAM have very little headroom so we hardcode
3200 // the limit rather than relying on the heuristics above. (They also use
3201 // 4444 textures so we can use a lower limit.)
3202 actual.bytes_limit_when_visible = 8;
3203
3204 actual.bytes_limit_when_visible =
3205 actual.bytes_limit_when_visible * 1024 * 1024;
3206 // Clamp the observed value to a specific range on Android.
3207 actual.bytes_limit_when_visible = std::max(
3208 actual.bytes_limit_when_visible, static_cast<size_t>(8 * 1024 * 1024));
3209 actual.bytes_limit_when_visible =
3210 std::min(actual.bytes_limit_when_visible,
3211 static_cast<size_t>(256 * 1024 * 1024));
3212 }
3213 actual.priority_cutoff_when_visible =
3214 gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING;
3215#else
3216 // Ignore what the system said and give all clients the same maximum
3217 // allocation on desktop platforms.
3218 actual.bytes_limit_when_visible = 512 * 1024 * 1024;
3219 actual.priority_cutoff_when_visible =
3220 gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
3221
3222 // For large monitors (4k), double the tile memory to avoid frequent out of
3223 // memory problems. 4k could mean a screen width of anywhere from 3840 to 4096
3224 // (see https://en.wikipedia.org/wiki/4K_resolution). We use 3500 as a proxy
3225 // for "large enough".
3226 static const int kLargeDisplayThreshold = 3500;
3227 int display_width =
3228 std::round(initial_screen_size.width() * initial_device_scale_factor);
3229 if (display_width >= kLargeDisplayThreshold)
3230 actual.bytes_limit_when_visible *= 2;
3231#endif
3232 return actual;
3233}
3234
Navid Zolghadr8fdb6114e2018-08-29 19:00:543235void RenderWidget::HasPointerRawMoveEventHandlers(bool has_handlers) {
3236 if (input_event_queue_)
3237 input_event_queue_->HasPointerRawMoveEventHandlers(has_handlers);
3238}
3239
Blink Reformat1c4d759e2017-04-09 16:34:543240void RenderWidget::HasTouchEventHandlers(bool has_handlers) {
W. James MacLean662d5382018-03-29 18:33:083241 if (has_touch_handlers_ && *has_touch_handlers_ == has_handlers)
3242 return;
3243
3244 has_touch_handlers_ = has_handlers;
alexclarke7fa93942015-10-21 15:37:113245 if (render_widget_scheduling_state_)
3246 render_widget_scheduling_state_->SetHasTouchHandler(has_handlers);
Albert J. Wongeb28e7e2018-10-12 00:57:433247 Send(new WidgetHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
[email protected]ce6689f2013-03-29 12:52:553248}
3249
Dave Tapuskadfe486c12017-06-09 16:53:133250void RenderWidget::SetNeedsLowLatencyInput(bool needs_low_latency) {
3251 if (input_event_queue_)
3252 input_event_queue_->SetNeedsLowLatency(needs_low_latency);
3253}
3254
Pavel Feldman6708eefa2019-01-17 03:14:323255void RenderWidget::SetNeedsUnbufferedInputForDebugger(bool unbuffered) {
3256 if (input_event_queue_)
3257 input_event_queue_->SetNeedsUnbufferedInputForDebugger(unbuffered);
3258}
3259
W. James MacLeand973a55b2018-11-29 21:39:133260void RenderWidget::AnimateDoubleTapZoomInMainFrame(
3261 const blink::WebPoint& point,
3262 const blink::WebRect& rect_to_zoom) {
3263 // Only oopif subframes should be sending this message.
Albert J. Wong7bbf22d2018-12-20 00:27:273264 DCHECK(!delegate());
W. James MacLeand973a55b2018-11-29 21:39:133265 Send(new WidgetHostMsg_AnimateDoubleTapZoomInMainFrame(routing_id(), point,
3266 rect_to_zoom));
3267}
3268
W. James MacLean5372eb72018-12-19 12:56:363269void RenderWidget::ZoomToFindInPageRectInMainFrame(
3270 const blink::WebRect& rect_to_zoom) {
3271 // Only oopif subframes should be sending this message.
Albert J. Wong7bbf22d2018-12-20 00:27:273272 DCHECK(!delegate_);
W. James MacLean5372eb72018-12-19 12:56:363273 Send(new WidgetHostMsg_ZoomToFindInPageRectInMainFrame(routing_id(),
3274 rect_to_zoom));
3275}
3276
danakj4886cad2019-02-26 22:15:563277void RenderWidget::RegisterViewportLayers(const cc::ViewportLayers& layers) {
3278 layer_tree_view_->layer_tree_host()->RegisterViewportLayers(layers);
3279}
3280
3281void RenderWidget::RegisterSelection(const cc::LayerSelection& selection) {
3282 layer_tree_view_->layer_tree_host()->RegisterSelection(selection);
3283}
3284
Dave Tapuskabafc2ba32017-11-28 01:54:373285void RenderWidget::RequestUnbufferedInputEvents() {
3286 if (input_event_queue_)
3287 input_event_queue_->RequestUnbufferedInputEvents();
3288}
3289
xidachenfa0199e72017-05-11 11:34:263290void RenderWidget::SetTouchAction(cc::TouchAction touch_action) {
Dave Tapuskab28a1082017-08-30 15:37:263291 if (!input_handler_->ProcessTouchAction(touch_action))
[email protected]5d0bbdfa92013-12-10 00:35:513292 return;
3293
Dave Tapuska04bc5ee92018-04-17 19:03:313294 widget_input_handler_manager_->ProcessTouchAction(touch_action);
[email protected]5d0bbdfa92013-12-10 00:35:513295}
3296
[email protected]e3244ed2014-06-20 20:04:273297void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
3298 render_frame_proxies_.AddObserver(proxy);
danakj0246bba02019-01-23 23:12:273299 // Page scale factor is propagated down the RenderWidget tree (across
3300 // frame trees). A new RenderFrameProxy means there is a new child
3301 // RenderWidget in another frame tree. In order for it to hear about
3302 // the page scale factor we pass along the last seen value here.
W. James MacLean2a90bff2018-11-05 20:52:473303 proxy->OnPageScaleFactorChanged(page_scale_factor_from_mainframe_);
[email protected]bffc8302014-01-23 20:52:163304}
3305
[email protected]e3244ed2014-06-20 20:04:273306void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
3307 render_frame_proxies_.RemoveObserver(proxy);
[email protected]bffc8302014-01-23 20:52:163308}
3309
[email protected]de3c5d82014-05-28 22:12:593310void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
3311 render_frames_.AddObserver(frame);
3312}
3313
3314void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) {
3315 render_frames_.RemoveObserver(frame);
3316}
3317
Saman Samid189e5dfd2017-12-20 22:55:313318void RenderWidget::RegisterBrowserPlugin(BrowserPlugin* browser_plugin) {
3319 browser_plugins_.AddObserver(browser_plugin);
Saman Sami50d1e0c2018-03-13 20:03:493320 browser_plugin->ScreenInfoChanged(GetOriginalScreenInfo());
Saman Samid189e5dfd2017-12-20 22:55:313321}
3322
3323void RenderWidget::UnregisterBrowserPlugin(BrowserPlugin* browser_plugin) {
3324 browser_plugins_.RemoveObserver(browser_plugin);
3325}
3326
Albert J. Wong3c93c182018-09-27 17:29:433327void RenderWidget::OnWaitNextFrameForTests(
3328 int main_frame_thread_observer_routing_id) {
danakj53802692018-07-25 21:46:443329 // Sends an ACK to the browser process during the next compositor frame.
Albert J. Wong3c93c182018-09-27 17:29:433330 QueueMessage(new WidgetHostMsg_WaitForNextFrameForTests_ACK(
3331 main_frame_thread_observer_routing_id));
lfg43e08e62016-02-03 18:51:373332}
3333
Fady Samuela863f152018-03-09 16:10:033334const ScreenInfo& RenderWidget::GetWebScreenInfo() const {
3335 return screen_info_;
Christopher Camerone9a30c12018-03-07 08:23:383336}
3337
Fady Samuela863f152018-03-09 16:10:033338const ScreenInfo& RenderWidget::GetOriginalScreenInfo() const {
Christopher Camerone9a30c12018-03-07 08:23:383339 return screen_metrics_emulator_
3340 ? screen_metrics_emulator_->original_screen_info()
Fady Samuela863f152018-03-09 16:10:033341 : screen_info_;
oshima50872a72016-03-04 13:26:183342}
3343
Ella Ge80a52dce2017-11-15 18:01:523344gfx::PointF RenderWidget::ConvertWindowPointToViewport(
3345 const gfx::PointF& point) {
paulmeyer90f6c31d2016-11-12 00:17:593346 blink::WebFloatRect point_in_viewport(point.x(), point.y(), 0, 0);
Blink Reformat1c4d759e2017-04-09 16:34:543347 ConvertWindowToViewport(&point_in_viewport);
Ella Ge80a52dce2017-11-15 18:01:523348 return gfx::PointF(point_in_viewport.x, point_in_viewport.y);
3349}
3350
3351gfx::Point RenderWidget::ConvertWindowPointToViewport(const gfx::Point& point) {
3352 return gfx::ToRoundedPoint(ConvertWindowPointToViewport(gfx::PointF(point)));
paulmeyer90f6c31d2016-11-12 00:17:593353}
3354
Blink Reformat1c4d759e2017-04-09 16:34:543355bool RenderWidget::RequestPointerLock() {
lfgbee1e0a2016-06-08 21:24:213356 return mouse_lock_dispatcher_->LockMouse(webwidget_mouse_lock_target_.get());
3357}
3358
Blink Reformat1c4d759e2017-04-09 16:34:543359void RenderWidget::RequestPointerUnlock() {
lfgbee1e0a2016-06-08 21:24:213360 mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
3361}
3362
Blink Reformat1c4d759e2017-04-09 16:34:543363bool RenderWidget::IsPointerLocked() {
lfgbee1e0a2016-06-08 21:24:213364 return mouse_lock_dispatcher_->IsMouseLockedTo(
3365 webwidget_mouse_lock_target_.get());
3366}
3367
Richard Li49fe04d2018-10-21 09:07:193368void RenderWidget::StartDragging(network::mojom::ReferrerPolicy policy,
paulmeyer6ef5a792016-11-08 20:33:583369 const WebDragData& data,
3370 WebDragOperationsMask mask,
danakj0c75ad82018-07-10 19:50:123371 const SkBitmap& drag_image,
danakjef1735a2018-11-13 19:34:443372 const gfx::Point& web_image_offset) {
3373 blink::WebRect offset_in_window(web_image_offset.x(), web_image_offset.y(), 0,
3374 0);
Blink Reformat1c4d759e2017-04-09 16:34:543375 ConvertViewportToWindow(&offset_in_window);
paulmeyer6ef5a792016-11-08 20:33:583376 DropData drop_data(DropDataBuilder::Build(data));
3377 drop_data.referrer_policy = policy;
danakj0c75ad82018-07-10 19:50:123378 gfx::Vector2d image_offset(offset_in_window.x, offset_in_window.y);
3379 Send(new DragHostMsg_StartDragging(routing_id(), drop_data, mask, drag_image,
3380 image_offset, possible_drag_event_info_));
paulmeyer6ef5a792016-11-08 20:33:583381}
3382
kenrb5d78b842017-03-06 21:06:013383uint32_t RenderWidget::GetContentSourceId() {
3384 return current_content_source_id_;
3385}
3386
Saman Samif7731342018-01-24 22:18:443387void RenderWidget::DidNavigate() {
danakj125a29e2019-01-24 23:25:293388 // Blink may be navigating still between the Close IPC and the task that
3389 // actually closes this class, and for a main frame that would come through
3390 // this method. But since we are closing we can skip it.
3391 if (closing_)
Kinuko Yasudabef2b642019-01-24 04:53:333392 return;
danakj125a29e2019-01-24 23:25:293393
3394 ++current_content_source_id_;
danakja6c10012018-07-06 14:25:363395 layer_tree_view_->SetContentSourceId(current_content_source_id_);
3396 layer_tree_view_->ClearCachesOnNextCommit();
kenrb5d78b842017-03-06 21:06:013397}
3398
lfg8ff33912016-09-13 20:59:213399blink::WebWidget* RenderWidget::GetWebWidget() const {
Albert J. Wong7bbf22d2018-12-20 00:27:273400 if (delegate()) {
3401 blink::WebWidget* delegate_widget = delegate()->GetWebWidgetForWidget();
danakja2c9d0a92018-07-25 20:01:183402 if (delegate_widget)
3403 return delegate_widget;
3404 }
lfg8ff33912016-09-13 20:59:213405 return webwidget_internal_;
3406}
3407
ekaramad2daaf672016-11-10 20:29:013408blink::WebInputMethodController* RenderWidget::GetInputMethodController()
3409 const {
Ehsan Karamad655d7b8a2018-01-12 18:38:383410 if (auto* frame_widget = GetFrameWidget())
3411 return frame_widget->GetActiveWebInputMethodController();
3412
3413 return nullptr;
ekaramad2daaf672016-11-10 20:29:013414}
3415
Dave Tapuska139a72f2017-09-06 21:57:033416void RenderWidget::SetupWidgetInputHandler(
3417 mojom::WidgetInputHandlerRequest request,
3418 mojom::WidgetInputHandlerHostPtr host) {
Dave Tapuskab66c28f2017-11-15 17:18:473419 widget_input_handler_manager_->AddInterface(std::move(request),
3420 std::move(host));
Dave Tapuska525eb15e2017-08-17 21:05:503421}
3422
Dave Tapuska485aca92017-08-08 00:47:583423void RenderWidget::SetWidgetBinding(mojom::WidgetRequest request) {
3424 // Close the old binding if there was one.
3425 // A RenderWidgetHost should not need more than one channel.
3426 widget_binding_.Close();
3427 widget_binding_.Bind(std::move(request));
3428}
3429
Ken Buchanan94c0beb62018-06-22 19:56:243430void RenderWidget::SetMouseCapture(bool capture) {
3431 if (mojom::WidgetInputHandlerHost* host =
3432 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
3433 host->SetMouseCapture(capture);
3434 }
3435}
3436
Fady Samuelca9ecb72018-05-05 05:59:273437bool RenderWidget::IsSurfaceSynchronizationEnabled() const {
danakja6c10012018-07-06 14:25:363438 return layer_tree_view_ &&
3439 layer_tree_view_->IsSurfaceSynchronizationEnabled();
Fady Samuelca9ecb72018-05-05 05:59:273440}
3441
W. James MacLean2a90bff2018-11-05 20:52:473442void RenderWidget::PageScaleFactorChanged(float page_scale_factor) {
danakj0246bba02019-01-23 23:12:273443 // The page scale is controlled by the WebView for the local main frame of
3444 // the Page. So this is called from blink by for the RenderWidget of that
3445 // local main frame. We forward the value on to each child RenderWidget (each
3446 // of which will be via proxy child frame). These will each in turn forward
3447 // the message to their child RenderWidgets (through their proxy child
3448 // frames).
3449 // TODO(crbug.com/924336): This value is continuously propagated during a
3450 // pinch-zoom, causing the child RenderWidgets to re-raster, while the main
3451 // frame is able to throttle re-raster to powers of 2. We could find some way
3452 // to throttle child RenderWidgets also, perhaps by informing them when the
3453 // pinch-zoom gesture is started and stopped.
3454 DCHECK(!is_frozen_);
3455 DCHECK(delegate());
W. James MacLean2a90bff2018-11-05 20:52:473456
W. James MacLean2a90bff2018-11-05 20:52:473457 for (auto& observer : render_frame_proxies_)
3458 observer.OnPageScaleFactorChanged(page_scale_factor);
danakj0246bba02019-01-23 23:12:273459 // Store the value to give to any new RenderFrameProxy that is registered.
3460 page_scale_factor_from_mainframe_ = page_scale_factor;
W. James MacLean2a90bff2018-11-05 20:52:473461}
3462
danakj53802692018-07-25 21:46:443463void RenderWidget::UseSynchronousResizeModeForTesting(bool enable) {
danakj7602f4f2019-01-31 18:03:233464 synchronous_resize_mode_for_testing_ = enable;
danakja2c9d0a92018-07-25 20:01:183465}
3466
3467void RenderWidget::SetDeviceScaleFactorForTesting(float factor) {
danakjb4cec102019-01-30 19:22:133468 DCHECK_GT(factor, 0.f);
danakja2c9d0a92018-07-25 20:01:183469
danakja2c9d0a92018-07-25 20:01:183470 // We are changing the device scale factor from the renderer, so allocate a
3471 // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
danakj125a29e2019-01-24 23:25:293472 layer_tree_view_->RequestNewLocalSurfaceId();
danakjb4cec102019-01-30 19:22:133473
3474 ScreenInfo info = screen_info_;
3475 info.device_scale_factor = factor;
3476 gfx::Size viewport_pixel_size = gfx::ScaleToCeiledSize(size_, factor);
3477 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
3478 viewport_pixel_size, info);
3479
3480 ResizeWebWidget(); // This picks up the new device scale factor in |info|.
3481
3482 gfx::Size visible_viewport_size = visible_viewport_size_;
3483 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
3484 visible_viewport_size =
3485 gfx::ScaleToCeiledSize(visible_viewport_size, factor);
3486 }
3487 GetWebWidget()->ResizeVisualViewport(visible_viewport_size);
3488
3489 // Make sure the DSF override stays for future VisualProperties updates, and
3490 // that includes overriding the VisualProperties'
3491 // compositor_viewport_pixel_size with size * this for-testing DSF.
3492 device_scale_factor_for_testing_ = factor;
danakja2c9d0a92018-07-25 20:01:183493}
3494
3495void RenderWidget::SetDeviceColorSpaceForTesting(
3496 const gfx::ColorSpace& color_space) {
danakjb4cec102019-01-30 19:22:133497 // We are changing the device color space from the renderer, so allocate a
3498 // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
3499 layer_tree_view_->RequestNewLocalSurfaceId();
3500
danakj04d128a2019-01-25 02:10:203501 ScreenInfo info = screen_info_;
3502 info.color_space = color_space;
3503 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
danakj0d963bd2019-02-20 18:00:463504 CompositorViewportSize(), info);
danakja2c9d0a92018-07-25 20:01:183505}
3506
3507void RenderWidget::SetWindowRectSynchronouslyForTesting(
3508 const gfx::Rect& new_window_rect) {
3509 SetWindowRectSynchronously(new_window_rect);
3510}
3511
3512void RenderWidget::EnableAutoResizeForTesting(const gfx::Size& min_size,
3513 const gfx::Size& max_size) {
3514 VisualProperties visual_properties;
3515 visual_properties.auto_resize_enabled = true;
3516 visual_properties.min_size_for_auto_resize = min_size;
3517 visual_properties.max_size_for_auto_resize = max_size;
Fady Samuel84d8a1f72018-11-08 00:26:173518 visual_properties.local_surface_id_allocation =
3519 base::Optional<viz::LocalSurfaceIdAllocation>(
3520 viz::LocalSurfaceIdAllocation(
3521 viz::LocalSurfaceId(1, 1, base::UnguessableToken::Create()),
3522 base::TimeTicks::Now()));
danakja2c9d0a92018-07-25 20:01:183523 OnSynchronizeVisualProperties(visual_properties);
3524}
3525
3526void RenderWidget::DisableAutoResizeForTesting(const gfx::Size& new_size) {
3527 if (!auto_resize_mode_)
3528 return;
3529
3530 VisualProperties visual_properties;
3531 visual_properties.auto_resize_enabled = false;
3532 visual_properties.screen_info = screen_info_;
3533 visual_properties.new_size = new_size;
danakj0d963bd2019-02-20 18:00:463534 visual_properties.compositor_viewport_pixel_size = CompositorViewportSize();
danakja2c9d0a92018-07-25 20:01:183535 visual_properties.browser_controls_shrink_blink_size =
3536 browser_controls_shrink_blink_size_;
3537 visual_properties.top_controls_height = top_controls_height_;
3538 visual_properties.visible_viewport_size = visible_viewport_size_;
3539 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
3540 visual_properties.display_mode = display_mode_;
danakja2c9d0a92018-07-25 20:01:183541 OnSynchronizeVisualProperties(visual_properties);
3542}
3543
EhsanK955ba582017-11-30 21:14:403544blink::WebLocalFrame* RenderWidget::GetFocusedWebLocalFrameInWidget() const {
Ehsan Karamad655d7b8a2018-01-12 18:38:383545 if (auto* frame_widget = GetFrameWidget())
3546 return frame_widget->FocusedWebLocalFrameInWidget();
3547 return nullptr;
EhsanK955ba582017-11-30 21:14:403548}
3549
EhsanK22d482e2017-08-10 17:29:493550#if BUILDFLAG(ENABLE_PLUGINS)
3551PepperPluginInstanceImpl* RenderWidget::GetFocusedPepperPluginInsideWidget() {
Ehsan Karamad655d7b8a2018-01-12 18:38:383552 blink::WebFrameWidget* frame_widget = GetFrameWidget();
3553 if (!frame_widget)
EhsanK22d482e2017-08-10 17:29:493554 return nullptr;
3555
3556 // Focused pepper instance might not always be in the focused frame. For
3557 // instance if a pepper instance and its embedder frame are focused an then
3558 // another frame takes focus using javascript, the embedder frame will no
3559 // longer be focused while the pepper instance is (the embedder frame's
3560 // |focused_pepper_plugin_| is not nullptr). Especially, if the pepper plugin
3561 // is fullscreen, clicking into the pepper will not refocus the embedder
3562 // frame. This is why we have to traverse the whole frame tree to find the
3563 // focused plugin.
Ehsan Karamad655d7b8a2018-01-12 18:38:383564 blink::WebFrame* current_frame = frame_widget->LocalRoot();
EhsanK22d482e2017-08-10 17:29:493565 while (current_frame) {
3566 RenderFrameImpl* render_frame =
3567 current_frame->IsWebLocalFrame()
3568 ? RenderFrameImpl::FromWebFrame(current_frame)
3569 : nullptr;
3570 if (render_frame && render_frame->focused_pepper_plugin())
3571 return render_frame->focused_pepper_plugin();
3572 current_frame = current_frame->TraverseNext();
3573 }
3574 return nullptr;
3575}
3576#endif
3577
Ken Buchananb2c9e262018-03-10 16:53:313578gfx::Rect RenderWidget::ViewportVisibleRect() {
danakj9c4e7b812019-02-19 22:04:273579 if (for_child_local_root_frame_)
3580 return compositor_visible_rect_;
danakj0d963bd2019-02-20 18:00:463581 return gfx::Rect(CompositorViewportSize());
Ken Buchananb2c9e262018-03-10 16:53:313582}
3583
Hajime Hoshi315a61f2018-08-14 17:27:283584// static
3585scoped_refptr<base::SingleThreadTaskRunner>
3586RenderWidget::GetCleanupTaskRunner() {
3587 return RenderThreadImpl::current_blink_platform_impl()
3588 ->main_thread_scheduler()
3589 ->CleanupTaskRunner();
3590}
3591
Saman Sami50d1e0c2018-03-13 20:03:493592base::WeakPtr<RenderWidget> RenderWidget::AsWeakPtr() {
3593 return weak_ptr_factory_.GetWeakPtr();
3594}
3595
[email protected]e9ff79c2012-10-19 21:31:263596} // namespace content