blob: 729ada2ff5054c2f1aa0eaa59b7d0841ff2d79fe [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"
[email protected]4fb66842009-12-04 21:41:0015#include "base/command_line.h"
changwan7ded3752016-03-09 23:25:1216#include "base/feature_list.h"
initial.commit09911bf2008-07-26 23:55:2917#include "base/logging.h"
avi1023d012015-12-25 02:39:1418#include "base/macros.h"
dchengcedca5612016-04-09 01:40:1519#include "base/memory/ptr_util.h"
[email protected]b256eca2013-07-11 10:57:4020#include "base/memory/singleton.h"
asvitkine8d51e9d2016-09-02 23:55:4321#include "base/metrics/histogram_macros.h"
[email protected]aa4117f2011-12-09 22:19:2122#include "base/stl_util.h"
danakj4b347212018-07-04 17:55:1723#include "base/strings/string_number_conversions.h"
[email protected]74ebfb12013-06-07 20:48:0024#include "base/strings/utf_string_conversions.h"
Sebastien Marchand75a7cdf2018-11-13 23:47:0325#include "base/system/sys_info.h"
fdoraya19b7702016-12-23 14:19:3126#include "base/threading/thread_task_runner_handle.h"
primiano9e38d552015-01-28 04:18:0127#include "base/trace_event/trace_event.h"
[email protected]661eb9d2009-02-03 02:11:4828#include "build/build_config.h"
loyso6e6efc42017-01-21 02:23:0329#include "cc/animation/animation_host.h"
danakj4b347212018-07-04 17:55:1730#include "cc/base/switches.h"
xidachenfa0199e72017-05-11 11:34:2631#include "cc/input/touch_action.h"
danakjba65a0912017-09-21 16:38:4232#include "cc/trees/layer_tree_frame_sink.h"
loyso6e6efc42017-01-21 02:23:0333#include "cc/trees/layer_tree_host.h"
danakj4c987652018-07-05 15:49:4134#include "cc/trees/ukm_manager.h"
danakj4b347212018-07-04 17:55:1735#include "components/viz/common/features.h"
Fady Samuelc645ffe2017-07-24 17:28:2036#include "components/viz/common/frame_sinks/begin_frame_source.h"
danakjf20f4502017-09-26 17:13:3137#include "components/viz/common/frame_sinks/copy_output_request.h"
danakj4b347212018-07-04 17:55:1738#include "components/viz/common/switches.h"
39#include "content/common/content_switches_internal.h"
paulmeyer6ef5a792016-11-08 20:33:5840#include "content/common/drag_event_source_info.h"
41#include "content/common/drag_messages.h"
jonrossa2ff4f82018-02-16 17:27:4642#include "content/common/render_frame_metadata.mojom.h"
jcivelliae1560a2016-11-01 22:40:2343#include "content/common/render_message_filter.mojom.h"
Nasko Oskovf97e8b02017-07-25 02:45:4244#include "content/common/swapped_out_messages.h"
Sadrul Habib Chowdhury8bc43cc2018-06-06 01:48:0345#include "content/common/tab_switching_time_callback.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"
avi40b5be7a2016-03-03 21:13:4474#include "content/renderer/render_widget_owner_delegate.h"
tfarina556a7232014-10-05 01:02:0975#include "content/renderer/renderer_blink_platform_impl.h"
[email protected]5b45ad42013-10-25 00:42:0476#include "content/renderer/resizing_mode_selector.h"
danakj4b347212018-07-04 17:55:1777#include "gpu/command_buffer/service/gpu_switches.h"
ekaramad330ba4232016-09-23 17:57:4778#include "ipc/ipc_message_start.h"
[email protected]484955942010-08-19 16:13:1879#include "ipc/ipc_sync_message.h"
Antoine Laboure55c9ef82017-11-10 18:51:2380#include "ipc/ipc_sync_message_filter.h"
danakj4b347212018-07-04 17:55:1781#include "media/base/media_switches.h"
Scott Violet02e38b92018-03-27 23:42:1482#include "ppapi/buildflags/buildflags.h"
[email protected]661eb9d2009-02-03 02:11:4883#include "skia/ext/platform_canvas.h"
Blink Reformata30d4232018-04-07 15:31:0684#include "third_party/blink/public/platform/file_path_conversion.h"
Hajime Hoshi315a61f2018-08-14 17:27:2885#include "third_party/blink/public/platform/platform.h"
Blink Reformata30d4232018-04-07 15:31:0686#include "third_party/blink/public/platform/scheduler/web_render_widget_scheduling_state.h"
Yuta Kitamuradeb91bb2018-05-29 05:53:2087#include "third_party/blink/public/platform/scheduler/web_thread_scheduler.h"
Blink Reformata30d4232018-04-07 15:31:0688#include "third_party/blink/public/platform/web_cursor_info.h"
89#include "third_party/blink/public/platform/web_drag_data.h"
90#include "third_party/blink/public/platform/web_drag_operation.h"
91#include "third_party/blink/public/platform/web_mouse_event.h"
92#include "third_party/blink/public/platform/web_point.h"
93#include "third_party/blink/public/platform/web_rect.h"
94#include "third_party/blink/public/platform/web_runtime_features.h"
95#include "third_party/blink/public/platform/web_size.h"
96#include "third_party/blink/public/platform/web_string.h"
97#include "third_party/blink/public/web/web_autofill_client.h"
98#include "third_party/blink/public/web/web_device_emulation_params.h"
99#include "third_party/blink/public/web/web_frame_widget.h"
100#include "third_party/blink/public/web/web_input_method_controller.h"
101#include "third_party/blink/public/web/web_local_frame.h"
102#include "third_party/blink/public/web/web_node.h"
103#include "third_party/blink/public/web/web_page_popup.h"
104#include "third_party/blink/public/web/web_popup_menu_info.h"
105#include "third_party/blink/public/web/web_range.h"
106#include "third_party/blink/public/web/web_settings.h"
107#include "third_party/blink/public/web/web_view.h"
108#include "third_party/blink/public/web/web_widget.h"
[email protected]d353541f2012-05-03 22:45:41109#include "third_party/skia/include/core/SkShader.h"
paulmeyer90f6c31d2016-11-12 00:17:59110#include "ui/base/clipboard/clipboard.h"
Scott Violet8ff9c302018-02-22 22:28:35111#include "ui/base/ui_base_features.h"
danakj4b347212018-07-04 17:55:17112#include "ui/base/ui_base_switches.h"
dtapuska97286c882017-02-24 23:14:43113#include "ui/events/base_event_utils.h"
tfarina655f81d2014-12-23 02:38:50114#include "ui/gfx/geometry/point_conversions.h"
tfarina3b0452d2014-12-31 15:20:09115#include "ui/gfx/geometry/rect_conversions.h"
tfarinaebe974f02015-01-03 04:25:32116#include "ui/gfx/geometry/size_conversions.h"
[email protected]1835b9e2012-02-28 13:12:48117#include "ui/gfx/skia_util.h"
danakj4b347212018-07-04 17:55:17118#include "ui/gfx/switches.h"
[email protected]c9e2cbbb2012-05-12 21:17:27119#include "ui/gl/gl_switches.h"
danakj4b347212018-07-04 17:55:17120#include "ui/native_theme/native_theme_features.h"
121#include "ui/native_theme/overlay_scrollbar_constants_aura.h"
[email protected]d353541f2012-05-03 22:45:41122#include "ui/surface/transport_dib.h"
[email protected]661eb9d2009-02-03 02:11:48123
[email protected]eeb93112013-05-01 19:41:10124#if defined(OS_ANDROID)
[email protected]cefe9b152014-03-27 18:16:15125#include <android/keycodes.h>
wjmaclean1d970622017-01-21 22:28:24126#include "base/time/time.h"
[email protected]eeb93112013-05-01 19:41:10127#endif
128
[email protected]661eb9d2009-02-03 02:11:48129#if defined(OS_POSIX)
[email protected]d5282e72009-05-13 13:16:52130#include "third_party/skia/include/core/SkMallocPixelRef.h"
[email protected]d353541f2012-05-03 22:45:41131#include "third_party/skia/include/core/SkPixelRef.h"
[email protected]661eb9d2009-02-03 02:11:48132#endif // defined(OS_POSIX)
[email protected]8085dbc82008-09-26 22:53:44133
sadrul943e3b32016-08-04 18:22:59134#if defined(USE_AURA)
sadrul602ce1362017-01-26 06:41:10135#include "content/renderer/mus/renderer_window_tree_client.h"
penghuang28a5fa22015-12-02 17:58:19136#endif
137
ekaramad330ba4232016-09-23 17:57:47138#if defined(OS_MACOSX)
139#include "content/renderer/text_input_client_observer.h"
140#endif
141
Ryan Landay9e42fd742017-08-12 01:59:11142using blink::WebImeTextSpan;
[email protected]180ef242013-11-07 06:50:46143using blink::WebCursorInfo;
[email protected]19193682014-04-03 15:01:43144using blink::WebDeviceEmulationParams;
paulmeyer90f6c31d2016-11-12 00:17:59145using blink::WebDragOperation;
paulmeyer6ef5a792016-11-08 20:33:58146using blink::WebDragOperationsMask;
147using blink::WebDragData;
paulmeyer90f6c31d2016-11-12 00:17:59148using blink::WebFrameWidget;
[email protected]180ef242013-11-07 06:50:46149using blink::WebGestureEvent;
150using blink::WebInputEvent;
dtapuska5d2e9c32015-12-03 16:39:49151using blink::WebInputEventResult;
ekaramad2daaf672016-11-10 20:29:01152using blink::WebInputMethodController;
paulmeyer6ef5a792016-11-08 20:33:58153using blink::WebLocalFrame;
[email protected]180ef242013-11-07 06:50:46154using blink::WebMouseEvent;
155using blink::WebMouseWheelEvent;
156using blink::WebNavigationPolicy;
donnda070f3c2015-01-16 19:54:11157using blink::WebNode;
[email protected]180ef242013-11-07 06:50:46158using blink::WebPagePopup;
dglazkove353a372016-09-01 01:33:48159using blink::WebRange;
[email protected]180ef242013-11-07 06:50:46160using blink::WebRect;
[email protected]180ef242013-11-07 06:50:46161using blink::WebSize;
paulmeyer90f6c31d2016-11-12 00:17:59162using blink::WebString;
[email protected]180ef242013-11-07 06:50:46163using blink::WebTextDirection;
164using blink::WebTouchEvent;
[email protected]f8ed4722013-12-03 03:27:25165using blink::WebTouchPoint;
[email protected]180ef242013-11-07 06:50:46166using blink::WebVector;
167using blink::WebWidget;
[email protected]e9ff79c2012-10-19 21:31:26168
paulmeyer90f6c31d2016-11-12 00:17:59169namespace content {
170
[email protected]6a4d7f62013-01-07 21:32:13171namespace {
[email protected]b256eca2013-07-11 10:57:40172
Albert J. Wongcb004632018-07-10 22:58:25173using RoutingIDWidgetMap = std::map<int32_t, RenderWidget*>;
174base::LazyInstance<RoutingIDWidgetMap>::Leaky g_routing_id_widget_map =
175 LAZY_INSTANCE_INITIALIZER;
176
danakj4b347212018-07-04 17:55:17177const base::Feature kUnpremultiplyAndDitherLowBitDepthTiles = {
178 "UnpremultiplyAndDitherLowBitDepthTiles", base::FEATURE_ENABLED_BY_DEFAULT};
179
[email protected]b256eca2013-07-11 10:57:40180typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
181
AJITH KUMAR V041c0b02017-08-08 10:39:20182static const int kInvalidNextPreviousFlagsValue = -1;
yiyix6b90ef52018-10-09 19:55:30183static const char* kOOPIF = "OOPIF";
184static const char* kRenderer = "Renderer";
AJITH KUMAR V041c0b02017-08-08 10:39:20185
lfgbee1e0a2016-06-08 21:24:21186class WebWidgetLockTarget : public content::MouseLockDispatcher::LockTarget {
187 public:
188 explicit WebWidgetLockTarget(blink::WebWidget* webwidget)
189 : webwidget_(webwidget) {}
190
191 void OnLockMouseACK(bool succeeded) override {
192 if (succeeded)
Blink Reformat1c4d759e2017-04-09 16:34:54193 webwidget_->DidAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21194 else
Blink Reformat1c4d759e2017-04-09 16:34:54195 webwidget_->DidNotAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21196 }
197
Blink Reformat1c4d759e2017-04-09 16:34:54198 void OnMouseLockLost() override { webwidget_->DidLosePointerLock(); }
lfgbee1e0a2016-06-08 21:24:21199
200 bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event) override {
201 // The WebWidget handles mouse lock in Blink's handleInputEvent().
202 return false;
203 }
204
205 private:
206 blink::WebWidget* webwidget_;
207};
208
dglazkov97b6c2b2016-10-25 17:35:55209bool IsDateTimeInput(ui::TextInputType type) {
210 return type == ui::TEXT_INPUT_TYPE_DATE ||
211 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
212 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
213 type == ui::TEXT_INPUT_TYPE_MONTH ||
214 type == ui::TEXT_INPUT_TYPE_TIME || type == ui::TEXT_INPUT_TYPE_WEEK;
215}
216
paulmeyer90f6c31d2016-11-12 00:17:59217WebDragData DropMetaDataToWebDragData(
218 const std::vector<DropData::Metadata>& drop_meta_data) {
219 std::vector<WebDragData::Item> item_list;
220 for (const auto& meta_data_item : drop_meta_data) {
221 if (meta_data_item.kind == DropData::Kind::STRING) {
222 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54223 item.storage_type = WebDragData::Item::kStorageTypeString;
224 item.string_type = WebString::FromUTF16(meta_data_item.mime_type);
paulmeyer90f6c31d2016-11-12 00:17:59225 // Have to pass a dummy URL here instead of an empty URL because the
226 // DropData received by browser_plugins goes through a round trip:
227 // DropData::MetaData --> WebDragData-->DropData. In the end, DropData
228 // will contain an empty URL (which means no URL is dragged) if the URL in
229 // WebDragData is empty.
230 if (base::EqualsASCII(meta_data_item.mime_type,
231 ui::Clipboard::kMimeTypeURIList)) {
Blink Reformat1c4d759e2017-04-09 16:34:54232 item.string_data = WebString::FromUTF8("about:dragdrop-placeholder");
paulmeyer90f6c31d2016-11-12 00:17:59233 }
234 item_list.push_back(item);
235 continue;
236 }
237
238 // TODO(hush): crbug.com/584789. Blink needs to support creating a file with
239 // just the mimetype. This is needed to drag files to WebView on Android
240 // platform.
241 if ((meta_data_item.kind == DropData::Kind::FILENAME) &&
242 !meta_data_item.filename.empty()) {
243 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54244 item.storage_type = WebDragData::Item::kStorageTypeFilename;
245 item.filename_data = blink::FilePathToWebString(meta_data_item.filename);
paulmeyer90f6c31d2016-11-12 00:17:59246 item_list.push_back(item);
247 continue;
248 }
249
250 if (meta_data_item.kind == DropData::Kind::FILESYSTEMFILE) {
251 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54252 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
253 item.file_system_url = meta_data_item.file_system_url;
paulmeyer90f6c31d2016-11-12 00:17:59254 item_list.push_back(item);
255 continue;
256 }
257 }
258
259 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54260 result.Initialize();
261 result.SetItems(item_list);
paulmeyer90f6c31d2016-11-12 00:17:59262 return result;
263}
264
265WebDragData DropDataToWebDragData(const DropData& drop_data) {
266 std::vector<WebDragData::Item> item_list;
267
268 // These fields are currently unused when dragging into WebKit.
269 DCHECK(drop_data.download_metadata.empty());
270 DCHECK(drop_data.file_contents.empty());
dcheng3dd85612017-02-08 10:46:23271 DCHECK(drop_data.file_contents_content_disposition.empty());
paulmeyer90f6c31d2016-11-12 00:17:59272
273 if (!drop_data.text.is_null()) {
274 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54275 item.storage_type = WebDragData::Item::kStorageTypeString;
276 item.string_type = WebString::FromUTF8(ui::Clipboard::kMimeTypeText);
277 item.string_data = WebString::FromUTF16(drop_data.text.string());
paulmeyer90f6c31d2016-11-12 00:17:59278 item_list.push_back(item);
279 }
280
281 if (!drop_data.url.is_empty()) {
282 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54283 item.storage_type = WebDragData::Item::kStorageTypeString;
284 item.string_type = WebString::FromUTF8(ui::Clipboard::kMimeTypeURIList);
285 item.string_data = WebString::FromUTF8(drop_data.url.spec());
286 item.title = WebString::FromUTF16(drop_data.url_title);
paulmeyer90f6c31d2016-11-12 00:17:59287 item_list.push_back(item);
288 }
289
290 if (!drop_data.html.is_null()) {
291 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54292 item.storage_type = WebDragData::Item::kStorageTypeString;
293 item.string_type = WebString::FromUTF8(ui::Clipboard::kMimeTypeHTML);
294 item.string_data = WebString::FromUTF16(drop_data.html.string());
295 item.base_url = drop_data.html_base_url;
paulmeyer90f6c31d2016-11-12 00:17:59296 item_list.push_back(item);
297 }
298
jdoerrie5a73d0fa2018-10-02 23:54:05299 for (auto it = drop_data.filenames.begin(); it != drop_data.filenames.end();
paulmeyer90f6c31d2016-11-12 00:17:59300 ++it) {
301 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54302 item.storage_type = WebDragData::Item::kStorageTypeFilename;
303 item.filename_data = blink::FilePathToWebString(it->path);
304 item.display_name_data =
kinukoa4293022017-01-27 06:43:25305 blink::FilePathToWebString(base::FilePath(it->display_name));
paulmeyer90f6c31d2016-11-12 00:17:59306 item_list.push_back(item);
307 }
308
jdoerrie5a73d0fa2018-10-02 23:54:05309 for (auto it = drop_data.file_system_files.begin();
310 it != drop_data.file_system_files.end(); ++it) {
paulmeyer90f6c31d2016-11-12 00:17:59311 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54312 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
313 item.file_system_url = it->url;
314 item.file_system_file_size = it->size;
315 item.file_system_id = blink::WebString::FromASCII(it->filesystem_id);
paulmeyer90f6c31d2016-11-12 00:17:59316 item_list.push_back(item);
317 }
318
Stuart Langley48300392017-11-02 03:54:44319 for (const auto& it : drop_data.custom_data) {
paulmeyer90f6c31d2016-11-12 00:17:59320 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54321 item.storage_type = WebDragData::Item::kStorageTypeString;
Stuart Langley48300392017-11-02 03:54:44322 item.string_type = WebString::FromUTF16(it.first);
323 item.string_data = WebString::FromUTF16(it.second);
paulmeyer90f6c31d2016-11-12 00:17:59324 item_list.push_back(item);
325 }
326
327 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54328 result.Initialize();
329 result.SetItems(item_list);
330 result.SetFilesystemId(WebString::FromUTF16(drop_data.filesystem_id));
paulmeyer90f6c31d2016-11-12 00:17:59331 return result;
332}
333
dtapuskac4dd5be2016-10-25 15:11:10334ui::TextInputType ConvertWebTextInputType(blink::WebTextInputType type) {
335 // Check the type is in the range representable by ui::TextInputType.
336 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX))
337 << "blink::WebTextInputType and ui::TextInputType not synchronized";
338 return static_cast<ui::TextInputType>(type);
339}
340
341ui::TextInputMode ConvertWebTextInputMode(blink::WebTextInputMode mode) {
342 // Check the mode is in the range representable by ui::TextInputMode.
343 DCHECK_LE(mode, static_cast<int>(ui::TEXT_INPUT_MODE_MAX))
344 << "blink::WebTextInputMode and ui::TextInputMode not synchronized";
345 return static_cast<ui::TextInputMode>(mode);
346}
347
Mitsuru Oshima3c07b332018-02-06 04:56:50348// Returns true if the device scale is high enough that losing subpixel
349// antialiasing won't have a noticeable effect on text quality.
350static bool DeviceScaleEnsuresTextQuality(float device_scale_factor) {
351#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
352 // On Android, we never have subpixel antialiasing. On Chrome OS we prefer to
353 // composite all scrollers so that we get animated overlay scrollbars.
354 return true;
355#else
356 // 1.5 is a common touchscreen tablet device scale factor. For such
357 // devices main thread antialiasing is a heavy burden.
358 return device_scale_factor >= 1.5f;
359#endif
360}
361
362static bool PreferCompositingToLCDText(CompositorDependencies* compositor_deps,
363 float device_scale_factor) {
364 const base::CommandLine& command_line =
365 *base::CommandLine::ForCurrentProcess();
366 if (command_line.HasSwitch(switches::kDisablePreferCompositingToLCDText))
367 return false;
368 if (command_line.HasSwitch(switches::kEnablePreferCompositingToLCDText))
369 return true;
370 if (!compositor_deps->IsLcdTextEnabled())
371 return true;
372 return DeviceScaleEnsuresTextQuality(device_scale_factor);
373}
374
[email protected]b256eca2013-07-11 10:57:40375} // namespace
376
[email protected]b2e4c70132013-10-03 02:07:51377// RenderWidget ---------------------------------------------------------------
378
danakj829cdd142018-09-14 21:13:27379RenderWidget::RenderWidget(int32_t widget_routing_id,
380 CompositorDependencies* compositor_deps,
danakj6a816592018-09-25 18:30:56381 WidgetType widget_type,
danakj829cdd142018-09-14 21:13:27382 const ScreenInfo& screen_info,
383 blink::WebDisplayMode display_mode,
danakj6dcbc5962018-11-16 16:45:42384 bool is_frozen,
danakj829cdd142018-09-14 21:13:27385 bool hidden,
386 bool never_visible,
387 mojom::WidgetRequest widget_request)
nick8331f8ad2016-11-15 20:42:45388 : routing_id_(widget_routing_id),
dcheng35d31c112015-07-22 00:17:36389 compositor_deps_(compositor_deps),
lfg8ff33912016-09-13 20:59:21390 webwidget_internal_(nullptr),
avi40b5be7a2016-03-03 21:13:44391 owner_delegate_(nullptr),
[email protected]847a2582013-03-09 02:29:51392 auto_resize_mode_(false),
[email protected]1ac10dca2013-08-20 20:47:04393 is_hidden_(hidden),
sievers71c62dd52015-10-07 01:44:39394 compositor_never_visible_(never_visible),
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12395 is_fullscreen_granted_(false),
danakj73dd3032018-07-28 17:49:53396 display_mode_(display_mode),
changwanf2a707b2015-10-30 08:22:16397 ime_event_guard_(nullptr),
[email protected]661eb9d2009-02-03 02:11:48398 closing_(false),
danakj5c5269b2018-11-06 00:39:11399 host_will_close_this_(false),
danakj6dcbc5962018-11-16 16:45:42400 is_frozen_(is_frozen),
dglazkov97b6c2b2016-10-25 17:35:55401 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
[email protected]b256eca2013-07-11 10:57:40402 text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
shuchen82ce8c52014-10-23 01:55:20403 text_input_flags_(0),
AJITH KUMAR V041c0b02017-08-08 10:39:20404 next_previous_flags_(kInvalidNextPreviousFlagsValue),
[email protected]86ba5fcb2013-09-04 00:36:53405 can_compose_inline_(true),
nonafa291792016-08-10 02:36:18406 composition_range_(gfx::Range::InvalidRange()),
danakj6a816592018-09-25 18:30:56407 widget_type_(widget_type),
[email protected]867125a02009-12-10 06:01:48408 pending_window_rect_count_(0),
Scott Violetae08f332018-07-27 17:37:23409 screen_info_(screen_info),
nonafa291792016-08-10 02:36:18410 monitor_composition_info_(false),
[email protected]b2e4c70132013-10-03 02:07:51411 popup_origin_scale_for_emulation_(0.f),
samans26510e442017-06-01 22:29:12412 frame_swap_message_queue_(new FrameSwapMessageQueue(routing_id_)),
[email protected]a09d53ce2014-01-31 00:46:42413 resizing_mode_selector_(new ResizingModeSelector()),
lfge0c2792ec2016-05-11 18:52:08414 has_host_context_menu_location_(false),
ekaramad2a46d632016-07-19 13:33:09415 has_focus_(false),
danakj6dcbc5962018-11-16 16:45:42416 for_child_local_root_frame_(false),
ekaramad330ba4232016-09-23 17:57:47417#if defined(OS_MACOSX)
418 text_input_client_observer_(new TextInputClientObserver(this)),
419#endif
Takashi SAKAMOTO870f6262017-08-22 04:08:27420 first_update_visual_state_after_hidden_(false),
tasakb95dbb50c2017-02-08 18:07:50421 was_shown_time_(base::TimeTicks::Now()),
kenrb5d78b842017-03-06 21:06:01422 current_content_source_id_(0),
Dave Tapuska1bdf1832017-07-07 18:07:19423 widget_binding_(this, std::move(widget_request)),
danakjf87460792018-12-04 20:14:22424 warmup_weak_ptr_factory_(this),
wjmaclean1d970622017-01-21 22:28:24425 weak_ptr_factory_(this) {
nick8331f8ad2016-11-15 20:42:45426 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
[email protected]380244092011-10-07 17:26:27427 DCHECK(RenderThread::Get());
alexclarke7fa93942015-10-21 15:37:11428
429 // In tests there may not be a RenderThreadImpl.
430 if (RenderThreadImpl::current()) {
431 render_widget_scheduling_state_ = RenderThreadImpl::current()
Yuta Kitamura3331f5c2018-04-05 11:12:25432 ->GetWebMainThreadScheduler()
dcheng07945f632015-12-26 07:59:32433 ->NewRenderWidgetSchedulingState();
alexclarke7fa93942015-10-21 15:37:11434 render_widget_scheduling_state_->SetHidden(is_hidden_);
435 }
sadrul602ce1362017-01-26 06:41:10436#if defined(USE_AURA)
fsamuel098eade2017-03-21 18:06:14437 RendererWindowTreeClient::CreateIfNecessary(routing_id_);
Scott Violete46b3352018-09-22 00:37:07438 if (features::IsMultiProcessMash())
Scott Violet1098538e2017-10-05 19:23:33439 RendererWindowTreeClient::Get(routing_id_)->SetVisible(!is_hidden_);
sadrul602ce1362017-01-26 06:41:10440#endif
Albert J. Wongcb004632018-07-10 22:58:25441
442 if (routing_id_ != MSG_ROUTING_NONE)
443 g_routing_id_widget_map.Get().emplace(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29444}
445
446RenderWidget::~RenderWidget() {
lfg8ff33912016-09-13 20:59:21447 DCHECK(!webwidget_internal_) << "Leaking our WebWidget!";
Albert J. Wongcb004632018-07-10 22:58:25448 // TODO(ajwong): Add in check that routing_id_ has been removed from
449 // g_routing_id_widget_map once the shutdown semantics for RenderWidget
450 // and RenderViewImpl are rationalized. Currently, too many unit and
451 // browser tests delete a RenderWidget without correclty going through
452 // the shutdown. https://crbug.com/545684
[email protected]bffc8302014-01-23 20:52:16453
dtapuska9ec1a912017-04-21 15:18:31454 if (input_event_queue_)
455 input_event_queue_->ClearClient();
456
sadrul8185d972017-01-31 18:30:11457#if defined(USE_AURA)
fsamuel098eade2017-03-21 18:06:14458 // It is possible for a RenderWidget to be destroyed before it was embedded
459 // in a mus window. The RendererWindowTreeClient will leak in such cases. So
460 // explicitly delete it here.
461 RendererWindowTreeClient::Destroy(routing_id_);
sadrul8185d972017-01-31 18:30:11462#endif
initial.commit09911bf2008-07-26 23:55:29463}
464
[email protected]484955942010-08-19 16:13:18465// static
Albert J. Wongcb004632018-07-10 22:58:25466RenderWidget* RenderWidget::FromRoutingID(int32_t routing_id) {
467 RoutingIDWidgetMap* widgets = g_routing_id_widget_map.Pointer();
jdoerrie5a73d0fa2018-10-02 23:54:05468 auto it = widgets->find(routing_id);
Albert J. Wongcb004632018-07-10 22:58:25469 return it == widgets->end() ? NULL : it->second;
470}
471
danakj25ec6e2b2018-09-26 17:01:31472void RenderWidget::InitForPopup(ShowCallback show_callback,
473 blink::WebPagePopup* web_page_popup) {
474 // Init() increments the reference count on |this|, making it
475 // self-referencing.
476 Init(std::move(show_callback), web_page_popup);
initial.commit09911bf2008-07-26 23:55:29477}
478
danakj6a816592018-09-25 18:30:56479void RenderWidget::InitForChildLocalRoot(
480 blink::WebFrameWidget* web_frame_widget) {
danakj6dcbc5962018-11-16 16:45:42481 for_child_local_root_frame_ = true;
danakj6a816592018-09-25 18:30:56482 // Init() increments the reference count on |this|, making it
483 // self-referencing.
484 Init(base::NullCallback(), web_frame_widget);
dchengda9b4bb2015-07-20 20:58:08485}
486
dchengda9b4bb2015-07-20 20:58:08487void RenderWidget::CloseForFrame() {
dchengd96a27a2015-07-24 20:17:32488 OnClose();
kenrba7199832015-01-22 23:44:59489}
490
Scott Violetae08f332018-07-27 17:37:23491void RenderWidget::Init(ShowCallback show_callback, WebWidget* web_widget) {
lfg8ff33912016-09-13 20:59:21492 DCHECK(!webwidget_internal_);
nick4df698d82016-11-11 20:39:23493 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29494
danakj17216f4d2018-10-16 22:57:32495 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
496
Jeremy Roman04f27c372017-10-27 15:20:55497 input_handler_ = std::make_unique<RenderWidgetInputHandler>(this, this);
nick8331f8ad2016-11-15 20:42:45498
danakj17216f4d2018-10-16 22:57:32499 LayerTreeView* layer_tree_view = InitializeLayerTreeView();
500 web_widget->SetLayerTreeView(layer_tree_view);
Dave Tapuska9db80842017-07-24 17:24:26501
danakj31699d5b2018-09-18 15:39:17502 blink::scheduler::WebThreadScheduler* main_thread_scheduler = nullptr;
503 if (render_thread_impl)
504 main_thread_scheduler = render_thread_impl->GetWebMainThreadScheduler();
Alexander Timin41e917d2018-07-02 16:25:35505 blink::scheduler::WebThreadScheduler* compositor_thread_scheduler =
506 blink::scheduler::WebThreadScheduler::CompositorThreadScheduler();
danakj31699d5b2018-09-18 15:39:17507 scoped_refptr<base::SingleThreadTaskRunner> compositor_input_task_runner;
508 // The |compositor_thread_scheduler| can be null in tests without a compositor
509 // thread.
510 if (compositor_thread_scheduler) {
511 // When the RenderWidget is for a frame (ie for a local root) then it uses
danakjbd335392018-10-10 20:17:04512 // the compositor thread task runner. When it is for a popup or other such
513 // widgets, it does not.
514 // TODO(danakj): The |web_widget| given here should become a WebFrameWidget
515 // in the case the RenderWidget is for a RenderViewImpl, but currently the
516 // WebFrameWidget gets attached after RenderWidget init. So we have to check
517 // IsWebView() as well.
518 if (web_widget->IsWebFrameWidget() || web_widget->IsWebView()) {
danakj31699d5b2018-09-18 15:39:17519 compositor_input_task_runner =
520 compositor_thread_scheduler->InputTaskRunner();
521 }
522 }
Alexander Timin41e917d2018-07-02 16:25:35523
Dave Tapuska04bc5ee92018-04-17 19:03:31524 widget_input_handler_manager_ = WidgetInputHandlerManager::Create(
danakj31699d5b2018-09-18 15:39:17525 weak_ptr_factory_.GetWeakPtr(), std::move(compositor_input_task_runner),
526 main_thread_scheduler);
Dave Tapuska9db80842017-07-24 17:24:26527
danakjdf1ceb72018-07-18 20:02:25528 show_callback_ = std::move(show_callback);
initial.commit09911bf2008-07-26 23:55:29529
lfg8ff33912016-09-13 20:59:21530 webwidget_internal_ = web_widget;
531 webwidget_mouse_lock_target_.reset(
532 new WebWidgetLockTarget(webwidget_internal_));
lfgbee1e0a2016-06-08 21:24:21533 mouse_lock_dispatcher_.reset(new RenderWidgetMouseLockDispatcher(this));
initial.commit09911bf2008-07-26 23:55:29534
nick4df698d82016-11-11 20:39:23535 RenderThread::Get()->AddRoute(routing_id_, this);
536 // Take a reference on behalf of the RenderThread. This will be balanced
Albert J. Wong3c93c182018-09-27 17:29:43537 // when we receive WidgetMsg_Close.
nick4df698d82016-11-11 20:39:23538 AddRef();
539 if (RenderThreadImpl::current()) {
540 RenderThreadImpl::current()->WidgetCreated();
541 if (is_hidden_)
542 RenderThreadImpl::current()->WidgetHidden();
initial.commit09911bf2008-07-26 23:55:29543 }
544}
545
danakj53802692018-07-25 21:46:44546void RenderWidget::ApplyEmulatedScreenMetricsForPopupWidget(
547 RenderWidget* origin_widget) {
548 RenderWidgetScreenMetricsEmulator* emulator =
549 origin_widget->screen_metrics_emulator_.get();
550 if (!emulator)
551 return;
[email protected]b2e4c70132013-10-03 02:07:51552 popup_origin_scale_for_emulation_ = emulator->scale();
[email protected]19193682014-04-03 15:01:43553 popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
Pavel Feldmancc099f72017-07-20 23:09:00554 popup_screen_origin_for_emulation_ =
Lei Zhang9b359d32017-11-28 00:57:02555 emulator->original_screen_rect().origin();
Fady Samuel1c1ad3692018-11-06 23:28:40556 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
557 compositor_viewport_pixel_size_,
558 emulator->original_screen_info());
[email protected]b2e4c70132013-10-03 02:07:51559}
560
[email protected]2d6836f42014-07-02 17:25:31561gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) {
562 if (screen_metrics_emulator_)
563 return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor);
564 return anchor;
565}
566
thakis18e426412017-03-15 12:06:37567#if BUILDFLAG(USE_EXTERNAL_POPUP_MENU)
[email protected]b2e4c70132013-10-03 02:07:51568void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
mfomitchev2600fd7c2016-02-17 20:53:39569 ExternalPopupMenu* popup,
570 RenderWidgetScreenMetricsEmulator* emulator) {
Pavel Feldmancc099f72017-07-20 23:09:00571 popup->SetOriginScaleForEmulation(emulator->scale());
[email protected]b2e4c70132013-10-03 02:07:51572}
[email protected]53907862014-03-25 15:42:40573#endif
[email protected]b2e4c70132013-10-03 02:07:51574
575void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
576 if (screen_metrics_emulator_)
577 screen_metrics_emulator_->OnShowContextMenu(params);
578}
579
[email protected]a95986a82010-12-24 06:19:28580bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
ekaramad330ba4232016-09-23 17:57:47581#if defined(OS_MACOSX)
582 if (IPC_MESSAGE_CLASS(message) == TextInputClientMsgStart)
583 return text_input_client_observer_->OnMessageReceived(message);
584#endif
lfgbee1e0a2016-06-08 21:24:21585 if (mouse_lock_dispatcher_ &&
586 mouse_lock_dispatcher_->OnMessageReceived(message))
587 return true;
588
[email protected]a95986a82010-12-24 06:19:28589 bool handled = true;
590 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
Albert J. Wong3c93c182018-09-27 17:29:43591 IPC_MESSAGE_HANDLER(WidgetMsg_ShowContextMenu, OnShowContextMenu)
592 IPC_MESSAGE_HANDLER(WidgetMsg_Close, OnClose)
593 IPC_MESSAGE_HANDLER(WidgetMsg_SynchronizeVisualProperties,
Fady Samuel799e72192018-04-25 21:16:57594 OnSynchronizeVisualProperties)
Albert J. Wong3c93c182018-09-27 17:29:43595 IPC_MESSAGE_HANDLER(WidgetMsg_EnableDeviceEmulation,
dgozman9260b0a12015-03-16 13:45:20596 OnEnableDeviceEmulation)
Albert J. Wong3c93c182018-09-27 17:29:43597 IPC_MESSAGE_HANDLER(WidgetMsg_DisableDeviceEmulation,
dgozman9260b0a12015-03-16 13:45:20598 OnDisableDeviceEmulation)
Albert J. Wong3c93c182018-09-27 17:29:43599 IPC_MESSAGE_HANDLER(WidgetMsg_WasHidden, OnWasHidden)
600 IPC_MESSAGE_HANDLER(WidgetMsg_WasShown, OnWasShown)
601 IPC_MESSAGE_HANDLER(WidgetMsg_SetActive, OnSetActive)
602 IPC_MESSAGE_HANDLER(WidgetMsg_SetBackgroundOpaque, OnSetBackgroundOpaque)
603 IPC_MESSAGE_HANDLER(WidgetMsg_SetTextDirection, OnSetTextDirection)
604 IPC_MESSAGE_HANDLER(WidgetMsg_SetBounds_ACK, OnRequestSetBoundsAck)
605 IPC_MESSAGE_HANDLER(WidgetMsg_UpdateScreenRects, OnUpdateScreenRects)
606 IPC_MESSAGE_HANDLER(WidgetMsg_ForceRedraw, OnForceRedraw)
607 IPC_MESSAGE_HANDLER(WidgetMsg_SetViewportIntersection,
kenrbea731792017-01-13 15:10:48608 OnSetViewportIntersection)
Albert J. Wong3c93c182018-09-27 17:29:43609 IPC_MESSAGE_HANDLER(WidgetMsg_SetIsInert, OnSetIsInert)
610 IPC_MESSAGE_HANDLER(WidgetMsg_SetInheritedEffectiveTouchAction,
sunxd540a9962018-05-24 22:51:06611 OnSetInheritedEffectiveTouchAction)
Albert J. Wong3c93c182018-09-27 17:29:43612 IPC_MESSAGE_HANDLER(WidgetMsg_UpdateRenderThrottlingStatus,
Ken Buchanan8a319fb2017-11-15 18:37:12613 OnUpdateRenderThrottlingStatus)
Albert J. Wong3c93c182018-09-27 17:29:43614 IPC_MESSAGE_HANDLER(WidgetMsg_WaitForNextFrameForTests,
lfg43e08e62016-02-03 18:51:37615 OnWaitNextFrameForTests)
paulmeyer90f6c31d2016-11-12 00:17:59616 IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter)
617 IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver, OnDragTargetDragOver)
618 IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave, OnDragTargetDragLeave)
619 IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop)
paulmeyer8fc8ea92016-11-15 05:12:21620 IPC_MESSAGE_HANDLER(DragMsg_SourceEnded, OnDragSourceEnded)
621 IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded,
622 OnDragSourceSystemDragEnded)
[email protected]a95986a82010-12-24 06:19:28623 IPC_MESSAGE_UNHANDLED(handled = false)
624 IPC_END_MESSAGE_MAP()
625 return handled;
626}
initial.commit09911bf2008-07-26 23:55:29627
628bool RenderWidget::Send(IPC::Message* message) {
Nasko Oskovf97e8b02017-07-25 02:45:42629 // Don't send any messages after the browser has told us to close, and filter
danakj6dcbc5962018-11-16 16:45:42630 // most outgoing messages when frozen.
631 if (closing_) {
632 delete message;
633 return false;
634 }
635 if (is_frozen_ && !SwappedOutMessages::CanSendWhileSwappedOut(message)) {
initial.commit09911bf2008-07-26 23:55:29636 delete message;
637 return false;
638 }
639
640 // If given a messsage without a routing ID, then assign our routing ID.
641 if (message->routing_id() == MSG_ROUTING_NONE)
642 message->set_routing_id(routing_id_);
643
[email protected]380244092011-10-07 17:26:27644 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44645}
646
dtapuska014ed082016-11-11 21:58:48647void RenderWidget::SendOrCrash(IPC::Message* message) {
648 bool result = Send(message);
649 CHECK(closing_ || result) << "Failed to send message";
650}
651
ekaramad5aff1942017-01-06 01:26:35652bool RenderWidget::ShouldHandleImeEvents() const {
ekaramadb6483a052017-02-10 02:23:26653 // TODO(ekaramad): We track page focus in all RenderViews on the page but the
654 // RenderWidgets corresponding to OOPIFs do not get the update. For now, this
655 // method returns true when the RenderWidget is for an OOPIF, i.e., IME events
656 // will be processed regardless of page focus. We should revisit this after
657 // page focus for OOPIFs has been fully resolved (https://crbug.com/689777).
Blink Reformat1c4d759e2017-04-09 16:34:54658 return GetWebWidget() && GetWebWidget()->IsWebFrameWidget() &&
danakj6dcbc5962018-11-16 16:45:42659 (has_focus_ || for_child_local_root_frame_);
ekaramad5aff1942017-01-06 01:26:35660}
661
initial.commit09911bf2008-07-26 23:55:29662void RenderWidget::OnClose() {
dchengd96a27a2015-07-24 20:17:32663 DCHECK(content::RenderThread::Get());
664 if (closing_)
665 return;
danakj292b63e2018-11-19 20:47:06666 for (auto& observer : render_frames_)
667 observer.WidgetWillClose();
dchengd96a27a2015-07-24 20:17:32668 closing_ = true;
669
670 // Browser correspondence is no longer needed at this point.
671 if (routing_id_ != MSG_ROUTING_NONE) {
672 RenderThread::Get()->RemoveRoute(routing_id_);
Albert J. Wongcb004632018-07-10 22:58:25673 g_routing_id_widget_map.Get().erase(routing_id_);
danakj678f0252018-11-09 21:46:34674 if (RenderThreadImpl::current()) {
675 // RenderWidgets may be hidden when they are closed. If we were previously
676 // hidden, we are being counted as such in RenderThreadImpl. Thus we
677 // remove that count here by calling WidgetRestored() even though we're
678 // clearly not becoming visible here.
679 if (is_hidden_)
680 RenderThreadImpl::current()->WidgetRestored();
dchengd96a27a2015-07-24 20:17:32681 RenderThreadImpl::current()->WidgetDestroyed();
danakj678f0252018-11-09 21:46:34682 }
dchengd96a27a2015-07-24 20:17:32683 }
684
danakj6dcbc5962018-11-16 16:45:42685 if (for_child_local_root_frame_) {
dchengd96a27a2015-07-24 20:17:32686 // Widgets for frames may be created and closed at any time while the frame
Ken Buchananed449bb2018-02-01 21:02:05687 // is alive. However, WebWidget must be closed synchronously because frame
688 // widgets and frames hold pointers to each other. The deferred call to
689 // Close() will complete cleanup and release |this|, but CloseWebWidget()
690 // prevents Close() from attempting to access members of an
691 // already-deleted frame.
692 CloseWebWidget();
dchengd96a27a2015-07-24 20:17:32693 }
Ken Buchananed449bb2018-02-01 21:02:05694 // If there is a Send call on the stack, then it could be dangerous to close
695 // now. Post a task that only gets invoked when there are no nested message
696 // loops.
Hajime Hoshi315a61f2018-08-14 17:27:28697 GetCleanupTaskRunner()->PostNonNestableTask(
698 FROM_HERE, base::BindOnce(&RenderWidget::Close, this));
dchengd96a27a2015-07-24 20:17:32699
700 // Balances the AddRef taken when we called AddRoute.
701 Release();
initial.commit09911bf2008-07-26 23:55:29702}
703
Fady Samuel799e72192018-04-25 21:16:57704void RenderWidget::OnSynchronizeVisualProperties(
danakja2c9d0a92018-07-25 20:01:18705 const VisualProperties& original_params) {
706 TRACE_EVENT0("renderer", "RenderWidget::OnSynchronizeVisualProperties");
EhsanKbd2cea992017-11-23 18:49:08707
danakja2c9d0a92018-07-25 20:01:18708 VisualProperties params = original_params;
709 if (owner_delegate_) {
710 owner_delegate_->ApplyNewSizeForWidget(size_, params.new_size);
711
712 if (display_mode_ != params.display_mode) {
713 display_mode_ = params.display_mode;
714 owner_delegate_->ApplyNewDisplayModeForWidget(params.display_mode);
715 }
716
717 bool auto_resize_mode_changed =
718 auto_resize_mode_ != params.auto_resize_enabled;
719 auto_resize_mode_ = params.auto_resize_enabled;
720 min_size_for_auto_resize_ = params.min_size_for_auto_resize;
721 max_size_for_auto_resize_ = params.max_size_for_auto_resize;
722
723 if (auto_resize_mode_) {
724 gfx::Size min_auto_size = min_size_for_auto_resize_;
725 gfx::Size max_auto_size = max_size_for_auto_resize_;
726 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
727 min_auto_size = gfx::ScaleToCeiledSize(
728 min_auto_size, params.screen_info.device_scale_factor);
729 max_auto_size = gfx::ScaleToCeiledSize(
730 max_auto_size, params.screen_info.device_scale_factor);
731 }
732 owner_delegate_->ApplyAutoResizeLimitsForWidget(min_auto_size,
733 max_auto_size);
734 } else if (auto_resize_mode_changed) {
735 owner_delegate_->DisableAutoResizeForWidget();
736 if (params.new_size.IsEmpty())
737 return;
738 }
739
740 browser_controls_shrink_blink_size_ =
741 params.browser_controls_shrink_blink_size;
742 top_controls_height_ = params.top_controls_height;
743 bottom_controls_height_ = params.bottom_controls_height;
744
745 // TODO(fsamuel): Modifies the |params| that are used for
746 // SynchronizeVisualProperties(), but does not used this modified
747 // device_scale_factor for the auto-resize values, which is probably a bug.
748 if (device_scale_factor_for_testing_) {
749 params.screen_info.device_scale_factor =
750 *device_scale_factor_for_testing_;
751 params.compositor_viewport_pixel_size = gfx::ScaleToCeiledSize(
752 params.new_size, params.screen_info.device_scale_factor);
753 }
[email protected]b2e4c70132013-10-03 02:07:51754 }
755
danakja2c9d0a92018-07-25 20:01:18756 if (!resizing_mode_selector_->ShouldAbortOnResize(this, params)) {
757 if (screen_metrics_emulator_) {
758 screen_metrics_emulator_->OnSynchronizeVisualProperties(params);
759 } else {
760 gfx::Size old_visible_viewport_size = visible_viewport_size_;
761 SynchronizeVisualProperties(params);
762 if (old_visible_viewport_size != visible_viewport_size_) {
763 for (auto& render_frame : render_frames_)
764 render_frame.DidChangeVisibleViewport();
765 }
766 }
Fady Samuel799e72192018-04-25 21:16:57767 }
768
danakja2c9d0a92018-07-25 20:01:18769 if (owner_delegate_ && params.scroll_focused_node_into_view)
770 owner_delegate_->ScrollFocusedNodeIntoViewForWidget();
initial.commit09911bf2008-07-26 23:55:29771}
772
dgozman9260b0a12015-03-16 13:45:20773void RenderWidget::OnEnableDeviceEmulation(
Lei Zhang9b359d32017-11-28 00:57:02774 const blink::WebDeviceEmulationParams& params) {
mfomitchev2600fd7c2016-02-17 20:53:39775 if (!screen_metrics_emulator_) {
Fady Samuel4255c182018-05-24 20:42:36776 VisualProperties visual_properties;
777 visual_properties.screen_info = screen_info_;
778 visual_properties.new_size = size_;
779 visual_properties.compositor_viewport_pixel_size =
Christopher Cameronaad15a0d2018-03-09 03:47:33780 compositor_viewport_pixel_size_;
Fady Samuel84d8a1f72018-11-08 00:26:17781 visual_properties.local_surface_id_allocation =
782 local_surface_id_allocation_from_parent_;
Fady Samuel4255c182018-05-24 20:42:36783 visual_properties.visible_viewport_size = visible_viewport_size_;
784 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
785 visual_properties.display_mode = display_mode_;
W. James MacLean2a90bff2018-11-05 20:52:47786 visual_properties.page_scale_factor = page_scale_factor_from_mainframe_;
mfomitchev2600fd7c2016-02-17 20:53:39787 screen_metrics_emulator_.reset(new RenderWidgetScreenMetricsEmulator(
Albert J. Wong3c93c182018-09-27 17:29:43788 this, params, visual_properties, widget_screen_rect_,
Fady Samuel4255c182018-05-24 20:42:36789 window_screen_rect_));
oshima50872a72016-03-04 13:26:18790 screen_metrics_emulator_->Apply();
mfomitchev2600fd7c2016-02-17 20:53:39791 } else {
dgozman9260b0a12015-03-16 13:45:20792 screen_metrics_emulator_->ChangeEmulationParams(params);
mfomitchev2600fd7c2016-02-17 20:53:39793 }
dgozman9260b0a12015-03-16 13:45:20794}
795
796void RenderWidget::OnDisableDeviceEmulation() {
797 screen_metrics_emulator_.reset();
798}
799
initial.commit09911bf2008-07-26 23:55:29800void RenderWidget::OnWasHidden() {
[email protected]9c3085f2011-06-09 02:10:31801 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
initial.commit09911bf2008-07-26 23:55:29802 // Go into a mode where we stop generating paint and scrolling events.
[email protected]bee16aab2009-08-26 15:55:03803 SetHidden(true);
ericwilligers88e69742016-10-17 19:29:55804 for (auto& observer : render_frames_)
805 observer.WasHidden();
initial.commit09911bf2008-07-26 23:55:29806}
807
Saman Samie61e5c032018-11-05 22:11:44808void RenderWidget::OnWasShown(base::TimeTicks show_request_timestamp,
809 bool was_evicted) {
[email protected]9e2e4632012-07-27 16:38:41810 TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
danakj57f139f2018-11-19 19:23:46811 // TODO(danakj): Nothing should happen ideally if the RenderWidget is frozen!
812 // It's not visible! However.. the RenderView needs to see it as visible in
813 // order to make the Page visible /o\ so this is hard. We need to detangle
814 // page visibility from the main widget. https://crbug.com/419087
danakj678f0252018-11-09 21:46:34815
tasakb95dbb50c2017-02-08 18:07:50816 was_shown_time_ = base::TimeTicks::Now();
initial.commit09911bf2008-07-26 23:55:29817 // See OnWasHidden
[email protected]bee16aab2009-08-26 15:55:03818 SetHidden(false);
ericwilligers88e69742016-10-17 19:29:55819 for (auto& observer : render_frames_)
820 observer.WasShown();
initial.commit09911bf2008-07-26 23:55:29821
Saman Samie61e5c032018-11-05 22:11:44822 if (was_evicted) {
823 for (auto& observer : render_frame_proxies_) {
824 observer.WasEvicted();
825 }
826 }
827
danakja6c10012018-07-06 14:25:36828 if (layer_tree_view_ && !show_request_timestamp.is_null()) {
829 layer_tree_view_->layer_tree_host()->RequestPresentationTimeForNextFrame(
Sadrul Habib Chowdhury8bc43cc2018-06-06 01:48:03830 CreateTabSwitchingTimeRecorder(show_request_timestamp));
[email protected]3399dd822014-08-09 11:14:24831 }
initial.commit09911bf2008-07-26 23:55:29832}
833
Avi Drissman014dec72018-06-07 02:34:01834void RenderWidget::OnRequestSetBoundsAck() {
[email protected]53d3f302009-12-21 04:42:05835 DCHECK(pending_window_rect_count_);
836 pending_window_rect_count_--;
837}
838
Albert J. Wongcb004632018-07-10 22:58:25839void RenderWidget::OnForceRedraw(int snapshot_id) {
840 if (LayerTreeView* ltv = layer_tree_view()) {
841 ltv->layer_tree_host()->RequestPresentationTimeForNextFrame(
842 base::BindOnce(&RenderWidget::DidPresentForceDrawFrame,
843 weak_ptr_factory_.GetWeakPtr(), snapshot_id));
844 ltv->SetNeedsForcedRedraw();
845 }
846}
847
848void RenderWidget::DidPresentForceDrawFrame(
849 int snapshot_id,
850 const gfx::PresentationFeedback& feedback) {
Albert J. Wong3c93c182018-09-27 17:29:43851 Send(new WidgetHostMsg_ForceRedrawComplete(routing_id(), snapshot_id));
Albert J. Wongcb004632018-07-10 22:58:25852}
853
Xianzhu Wangf02017ac2018-10-17 01:47:33854viz::FrameSinkId RenderWidget::GetFrameSinkIdAtPoint(const gfx::PointF& point,
Ken Buchanan44d7e2f2018-08-23 14:18:05855 gfx::PointF* local_point) {
856 return input_handler_->GetFrameSinkIdAtPoint(point, local_point);
Navid Zolghadr0d86e5f2017-10-23 18:09:22857}
858
Dave Tapuskaea83d3bd2017-06-13 16:14:55859void RenderWidget::HandleInputEvent(
dtapuska9ec1a912017-04-21 15:18:31860 const blink::WebCoalescedInputEvent& input_event,
861 const ui::LatencyInfo& latency_info,
Dave Tapuskaea83d3bd2017-06-13 16:14:55862 HandledEventCallback callback) {
danakj6dcbc5962018-11-16 16:45:42863 if (owner_delegate_ && is_frozen_) {
danakja2c9d0a92018-07-25 20:01:18864 std::move(callback).Run(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, latency_info,
865 nullptr, base::nullopt);
866 return;
867 }
Dave Tapuskaea83d3bd2017-06-13 16:14:55868 input_handler_->HandleInputEvent(input_event, latency_info,
869 std::move(callback));
dtapuska9ec1a912017-04-21 15:18:31870}
871
dtapuska9d46ef7d2017-05-26 19:06:06872scoped_refptr<MainThreadEventQueue> RenderWidget::GetInputEventQueue() {
873 return input_event_queue_;
874}
875
fsamuel78f86e42016-01-20 04:10:23876void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
lfg8ff33912016-09-13 20:59:21877 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:54878 GetWebWidget()->SetCursorVisibilityState(is_visible);
fsamuel78f86e42016-01-20 04:10:23879}
880
881void RenderWidget::OnMouseCaptureLost() {
lfg8ff33912016-09-13 20:59:21882 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:54883 GetWebWidget()->MouseCaptureLost();
fsamuel78f86e42016-01-20 04:10:23884}
885
alexmos56567492016-09-13 00:52:46886void RenderWidget::OnSetEditCommandsForNextKeyEvent(
887 const EditCommands& edit_commands) {
888 edit_commands_ = edit_commands;
889}
890
Albert J. Wongcb004632018-07-10 22:58:25891void RenderWidget::OnSetActive(bool active) {
892 if (owner_delegate_)
danakja2c9d0a92018-07-25 20:01:18893 owner_delegate_->SetActiveForWidget(active);
Albert J. Wongcb004632018-07-10 22:58:25894}
895
896void RenderWidget::OnSetBackgroundOpaque(bool opaque) {
danakj0ba0e7b2018-09-25 19:37:13897 // Background opaque-ness modification is only supported for the main frame.
898 // The |owner_delegate_| is used as proxy for this RenderWidget being attached
899 // to the main frame.
900 if (!owner_delegate_)
901 return;
902
903 blink::WebWidget* web_widget = GetWebWidget();
904 // This is true since we only do this for RenderWidgets attached to the main
905 // frame.
906 DCHECK(web_widget->IsWebFrameWidget());
907 auto* web_frame_widget = static_cast<blink::WebFrameWidget*>(web_widget);
908 if (opaque) {
909 web_frame_widget->ClearBaseBackgroundColorOverride();
910 web_frame_widget->ClearBackgroundColorOverride();
911 } else {
912 web_frame_widget->SetBaseBackgroundColorOverride(SK_ColorTRANSPARENT);
913 web_frame_widget->SetBackgroundColorOverride(SK_ColorTRANSPARENT);
914 }
Albert J. Wongcb004632018-07-10 22:58:25915}
916
fsamuel78f86e42016-01-20 04:10:23917void RenderWidget::OnSetFocus(bool enable) {
danakja2c9d0a92018-07-25 20:01:18918 if (owner_delegate_)
919 owner_delegate_->DidReceiveSetFocusEventForWidget();
920 SetFocus(enable);
921}
922
923void RenderWidget::SetFocus(bool enable) {
lfge0c2792ec2016-05-11 18:52:08924 has_focus_ = enable;
925
lfg8ff33912016-09-13 20:59:21926 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:54927 GetWebWidget()->SetFocus(enable);
lfge0c2792ec2016-05-11 18:52:08928
ericwilligers88e69742016-10-17 19:29:55929 for (auto& observer : render_frames_)
930 observer.RenderWidgetSetFocus(enable);
danakja2c9d0a92018-07-25 20:01:18931
932 if (owner_delegate_)
933 owner_delegate_->DidChangeFocusForWidget();
fsamuel78f86e42016-01-20 04:10:23934}
935
dtapuska3d5624d32016-08-30 04:34:00936void RenderWidget::SetNeedsMainFrame() {
danakj53f46b82018-12-11 20:55:55937 // The WebWidgetClient is not |this| if tests override it for the WebView and
938 // WebViewClient.
939 blink::WebWidgetClient* client =
940 owner_delegate_ ? owner_delegate_->GetWebWidgetClientForWidget() : this;
941 client->ScheduleAnimation();
dtapuska3d5624d32016-08-30 04:34:00942}
943
fsamuel78f86e42016-01-20 04:10:23944///////////////////////////////////////////////////////////////////////////////
danakja6c10012018-07-06 14:25:36945// LayerTreeViewDelegate
fsamuel78f86e42016-01-20 04:10:23946
David Bokanc8e38d02018-10-08 21:56:01947void RenderWidget::ApplyViewportChanges(
948 const cc::ApplyViewportChangesArgs& args) {
Ken Buchananed449bb2018-02-01 21:02:05949 if (!GetWebWidget())
950 return;
David Bokanc8e38d02018-10-08 21:56:01951 GetWebWidget()->ApplyViewportChanges(args);
fsamuel78f86e42016-01-20 04:10:23952}
953
sahel1b47fda72017-03-28 17:03:07954void RenderWidget::RecordWheelAndTouchScrollingCount(
955 bool has_scrolled_by_wheel,
956 bool has_scrolled_by_touch) {
Ken Buchananed449bb2018-02-01 21:02:05957 if (!GetWebWidget())
958 return;
Blink Reformat1c4d759e2017-04-09 16:34:54959 GetWebWidget()->RecordWheelAndTouchScrollingCount(has_scrolled_by_wheel,
sahel1b47fda72017-03-28 17:03:07960 has_scrolled_by_touch);
961}
962
Daniel Cheng224569ee2018-04-25 05:45:06963void RenderWidget::BeginMainFrame(base::TimeTicks frame_time) {
Ken Buchananed449bb2018-02-01 21:02:05964 if (!GetWebWidget())
965 return;
Daniel Cheng224569ee2018-04-25 05:45:06966 if (input_event_queue_)
967 input_event_queue_->DispatchRafAlignedInput(frame_time);
dtapuska3d5624d32016-08-30 04:34:00968
Daniel Cheng224569ee2018-04-25 05:45:06969 GetWebWidget()->BeginFrame(frame_time);
fsamuel78f86e42016-01-20 04:10:23970}
971
danakjc7afae52017-06-20 21:12:41972void RenderWidget::RequestNewLayerTreeFrameSink(
danakja6c10012018-07-06 14:25:36973 LayerTreeFrameSinkCallback callback) {
[email protected]7912e822014-04-16 02:37:03974 // For widgets that are never visible, we don't start the compositor, so we
danakjc7afae52017-06-20 21:12:41975 // never get a request for a cc::LayerTreeFrameSink.
sievers71c62dd52015-10-07 01:44:39976 DCHECK(!compositor_never_visible_);
danakjf87460792018-12-04 20:14:22977 // Frozen RenderWidgets should not be doing any compositing.
Scott Violetb04f16c2018-11-27 00:48:46978 DCHECK(!is_frozen_);
danakj678f0252018-11-09 21:46:34979
980 if (is_closing()) {
981 // In this case, we drop the request which means the compositor waits
982 // forever, which is fine since we're going to destroy it.
983 return;
984 }
jonrossa2ff4f82018-02-16 17:27:46985
danakjf87460792018-12-04 20:14:22986 // If we have a warmup in progress, wait for that and store the callback
987 // to be run when the warmup completes.
988 if (warmup_frame_sink_request_pending_) {
989 after_warmup_callback_ = std::move(callback);
990 return;
991 }
992 // If a warmup previously completed, use the result.
993 if (warmup_frame_sink_) {
994 std::move(callback).Run(std::move(warmup_frame_sink_));
995 return;
996 }
997
998 DoRequestNewLayerTreeFrameSink(std::move(callback));
999}
1000
1001void RenderWidget::DoRequestNewLayerTreeFrameSink(
1002 LayerTreeFrameSinkCallback callback) {
jonrossa2ff4f82018-02-16 17:27:461003 // TODO(jonross): have this generated by the LayerTreeFrameSink itself, which
1004 // would then handle binding.
1005 mojom::RenderFrameMetadataObserverPtr ptr;
1006 mojom::RenderFrameMetadataObserverRequest request = mojo::MakeRequest(&ptr);
1007 mojom::RenderFrameMetadataObserverClientPtrInfo client_info;
1008 mojom::RenderFrameMetadataObserverClientRequest client_request =
1009 mojo::MakeRequest(&client_info);
danakj4b347212018-07-04 17:55:171010 auto render_frame_metadata_observer =
1011 std::make_unique<RenderFrameMetadataObserverImpl>(std::move(request),
1012 std::move(client_info));
danakja6c10012018-07-06 14:25:361013 layer_tree_view_->SetRenderFrameObserver(
danakj4b347212018-07-04 17:55:171014 std::move(render_frame_metadata_observer));
danakjbe7cebf02018-12-05 00:20:391015 GURL url;
1016 // TODO(crbug.com/896836): Sometimes there's no valid widget, for main frame
1017 // widgets.
1018 if (!owner_delegate_ || GetFrameWidget())
1019 url = GetWebWidget()->GetURLForDebugTrace();
danakjefabf312018-10-05 19:03:071020 // The |url| is not always available, fallback to a fixed string.
1021 if (url.is_empty())
1022 url = GURL("chrome://gpu/RenderWidget::RequestNewLayerTreeFrameSink");
danakj6dcbc5962018-11-16 16:45:421023 // TODO(danakj): This may not be accurate, depending on the intent. A child
1024 // local root could be in the same process as the view, so if the client is
1025 // meant to designate the process type, it seems kRenderer would be the
1026 // correct choice. If client is meant to designate the widget type, then
1027 // kOOPIF would denote that it is not for the main frame. However, kRenderer
1028 // would also be used for other widgets such as popups.
1029 const char* client_name = for_child_local_root_frame_ ? kOOPIF : kRenderer;
Scott Violetb04f16c2018-11-27 00:48:461030 RenderThreadImpl::current()->RequestNewLayerTreeFrameSink(
1031 routing_id_, frame_swap_message_queue_, std::move(url),
1032 std::move(callback), std::move(client_request), std::move(ptr),
1033 client_name);
[email protected]ba91a792013-02-06 09:48:281034}
1035
fsamuel78f86e42016-01-20 04:10:231036void RenderWidget::DidCommitAndDrawCompositorFrame() {
1037 // NOTE: Tests may break if this event is renamed or moved. See
1038 // tab_capture_performancetest.cc.
1039 TRACE_EVENT0("gpu", "RenderWidget::DidCommitAndDrawCompositorFrame");
lfge0c2792ec2016-05-11 18:52:081040
ericwilligers88e69742016-10-17 19:29:551041 for (auto& observer : render_frames_)
1042 observer.DidCommitAndDrawCompositorFrame();
lfge0c2792ec2016-05-11 18:52:081043
fsamuel78f86e42016-01-20 04:10:231044 // Notify subclasses that we initiated the paint operation.
1045 DidInitiatePaint();
Yiming Zhou0f8836c22018-09-13 22:22:111046
Albert J. Wongfb64e142018-10-16 01:10:451047 Send(new WidgetHostMsg_DidCommitAndDrawCompositorFrame(routing_id_));
fsamuel78f86e42016-01-20 04:10:231048}
1049
Saman Sami766e0b02018-01-31 17:19:201050void RenderWidget::DidCommitCompositorFrame() {
danakja2c9d0a92018-07-25 20:01:181051 if (owner_delegate_)
1052 owner_delegate_->DidCommitCompositorFrameForWidget();
Saman Sami766e0b02018-01-31 17:19:201053}
fsamuel78f86e42016-01-20 04:10:231054
danakja2c9d0a92018-07-25 20:01:181055void RenderWidget::DidCompletePageScaleAnimation() {
1056 if (owner_delegate_)
1057 owner_delegate_->DidCompletePageScaleAnimationForWidget();
1058}
fsamuel78f86e42016-01-20 04:10:231059
danakj53f46b82018-12-11 20:55:551060void RenderWidget::ScheduleAnimation() {
1061 // This call is not needed in single thread mode for tests without a
1062 // scheduler, but they need to override the WebWidgetClient and replace this
1063 // method in order to schedule a synchronous composite task themselves.
1064 layer_tree_view_->SetNeedsBeginFrame();
initial.commit09911bf2008-07-26 23:55:291065}
1066
Stephen Chenneyec4312612018-11-21 12:40:161067void RenderWidget::UpdateVisualState(bool record_main_frame_metrics) {
Ken Buchananed449bb2018-02-01 21:02:051068 if (!GetWebWidget())
1069 return;
1070
Stephen Chenneyec4312612018-11-21 12:40:161071 // When recording main frame metrics set the lifecycle reason to
1072 // kBeginMainFrame, because this is the calller of UpdateLifecycle
1073 // for the main frame. Otherwise, set the reason to kTests, which is
1074 // the oinly other reason this method is called.
1075 WebWidget::LifecycleUpdateReason lifecycle_reason =
1076 record_main_frame_metrics
1077 ? WebWidget::LifecycleUpdateReason::kBeginMainFrame
1078 : WebWidget::LifecycleUpdateReason::kTest;
1079 GetWebWidget()->UpdateLifecycle(WebWidget::LifecycleUpdate::kAll,
1080 lifecycle_reason);
Blink Reformat1c4d759e2017-04-09 16:34:541081 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(false);
tasakb95dbb50c2017-02-08 18:07:501082
Robert Flack3ef2ffb2018-09-06 20:38:201083 if (first_update_visual_state_after_hidden_) {
Takashi SAKAMOTO870f6262017-08-22 04:08:271084 RecordTimeToFirstActivePaint();
1085 first_update_visual_state_after_hidden_ = false;
1086 }
1087}
tasakb95dbb50c2017-02-08 18:07:501088
Takashi SAKAMOTO870f6262017-08-22 04:08:271089void RenderWidget::RecordTimeToFirstActivePaint() {
tasakb95dbb50c2017-02-08 18:07:501090 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
tasakb95dbb50c2017-02-08 18:07:501091 base::TimeDelta sample = base::TimeTicks::Now() - was_shown_time_;
Takashi SAKAMOTO870f6262017-08-22 04:08:271092 if (render_thread_impl->NeedsToRecordFirstActivePaint(TTFAP_AFTER_PURGED)) {
1093 UMA_HISTOGRAM_TIMES("PurgeAndSuspend.Experimental.TimeToFirstActivePaint",
1094 sample);
1095 }
1096 if (render_thread_impl->NeedsToRecordFirstActivePaint(
1097 TTFAP_5MIN_AFTER_BACKGROUNDED)) {
1098 UMA_HISTOGRAM_TIMES(
1099 "PurgeAndSuspend.Experimental.TimeToFirstActivePaint."
1100 "AfterBackgrounded.5min",
1101 sample);
1102 }
fsamuel78f86e42016-01-20 04:10:231103}
1104
Stephen Chenney9879a5c2018-09-26 14:21:421105void RenderWidget::RecordEndOfFrameMetrics(base::TimeTicks frame_begin_time) {
1106 if (!GetWebWidget())
1107 return;
1108
1109 GetWebWidget()->RecordEndOfFrameMetrics(frame_begin_time);
1110}
1111
fsamuel78f86e42016-01-20 04:10:231112void RenderWidget::WillBeginCompositorFrame() {
1113 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
1114
Ken Buchananed449bb2018-02-01 21:02:051115 if (!GetWebWidget())
1116 return;
1117
Blink Reformat1c4d759e2017-04-09 16:34:541118 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(true);
alancutter317a8e02017-04-05 10:09:291119
dglazkov06854c5c2016-08-31 00:19:591120 // The UpdateTextInputState can result in further layout and possibly
1121 // enable GPU acceleration so they need to be called before any painting
1122 // is done.
changwan75e3b2072017-01-16 02:55:001123 UpdateTextInputState();
dglazkov06854c5c2016-08-31 00:19:591124 UpdateSelectionBounds();
1125
ericwilligers88e69742016-10-17 19:29:551126 for (auto& observer : render_frame_proxies_)
1127 observer.WillBeginCompositorFrame();
initial.commit09911bf2008-07-26 23:55:291128}
1129
Kent Tamura21d1de62018-12-10 04:45:201130std::unique_ptr<cc::SwapPromise> RenderWidget::RequestCopyOfOutputForWebTest(
Fady Samueldfecb7d2017-07-26 11:41:041131 std::unique_ptr<viz::CopyOutputRequest> request) {
Kent Tamura21d1de62018-12-10 04:45:201132 return RenderThreadImpl::current()->RequestCopyOfOutputForWebTest(
jbroman6ccbc7d472016-07-27 04:45:411133 routing_id_, std::move(request));
1134}
1135
fsamuel72464894f2015-12-15 06:59:311136///////////////////////////////////////////////////////////////////////////////
1137// RenderWidgetInputHandlerDelegate
1138
avid7d6b2e2016-03-04 19:41:171139void RenderWidget::FocusChangeComplete() {
Ehsan Karamad655d7b8a2018-01-12 18:38:381140 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1141 if (!frame_widget)
ekaramad27ca69b12017-04-20 18:34:291142 return;
Ehsan Karamad655d7b8a2018-01-12 18:38:381143
ekaramad27ca69b12017-04-20 18:34:291144 blink::WebLocalFrame* focused =
Ehsan Karamad655d7b8a2018-01-12 18:38:381145 frame_widget->LocalRoot()->View()->FocusedFrame();
1146
ekaramad27ca69b12017-04-20 18:34:291147 if (focused && focused->AutofillClient())
1148 focused->AutofillClient()->DidCompleteFocusChangeInFrame();
avid7d6b2e2016-03-04 19:41:171149}
fsamuel72464894f2015-12-15 06:59:311150
dtapuska1827dd22016-03-11 15:24:591151void RenderWidget::ObserveGestureEventAndResult(
1152 const blink::WebGestureEvent& gesture_event,
1153 const gfx::Vector2dF& unused_delta,
Sandra Sunac5cdd832017-12-11 03:27:131154 const cc::OverscrollBehavior& overscroll_behavior,
dtapuska1827dd22016-03-11 15:24:591155 bool event_processed) {
1156 if (!compositor_deps_->IsElasticOverscrollEnabled())
1157 return;
1158
1159 cc::InputHandlerScrollResult scroll_result;
1160 scroll_result.did_scroll = event_processed;
1161 scroll_result.did_overscroll_root = !unused_delta.IsZero();
1162 scroll_result.unused_scroll_delta = unused_delta;
Sandra Sunac5cdd832017-12-11 03:27:131163 scroll_result.overscroll_behavior = overscroll_behavior;
dtapuska1827dd22016-03-11 15:24:591164
Dave Tapuska04bc5ee92018-04-17 19:03:311165 widget_input_handler_manager_->ObserveGestureEventOnMainThread(gesture_event,
1166 scroll_result);
dtapuska1827dd22016-03-11 15:24:591167}
1168
avid7d6b2e2016-03-04 19:41:171169void RenderWidget::OnDidHandleKeyEvent() {
alexmos56567492016-09-13 00:52:461170 ClearEditCommands();
1171}
1172
1173void RenderWidget::SetEditCommandForNextKeyEvent(const std::string& name,
1174 const std::string& value) {
1175 ClearEditCommands();
1176 edit_commands_.emplace_back(name, value);
1177}
1178
1179void RenderWidget::ClearEditCommands() {
1180 edit_commands_.clear();
avid7d6b2e2016-03-04 19:41:171181}
fsamuel72464894f2015-12-15 06:59:311182
chongza8ba91fc2016-08-16 21:39:171183void RenderWidget::OnDidOverscroll(const ui::DidOverscrollParams& params) {
Dave Tapuska04bc5ee92018-04-17 19:03:311184 if (mojom::WidgetInputHandlerHost* host =
1185 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
1186 host->DidOverscroll(params);
Dave Tapuska139a72f2017-09-06 21:57:031187 }
fsamuel72464894f2015-12-15 06:59:311188}
1189
fsamuele8326c742016-01-12 00:49:391190void RenderWidget::SetInputHandler(RenderWidgetInputHandler* input_handler) {
1191 // Nothing to do here. RenderWidget created the |input_handler| and will take
1192 // ownership of it. We just verify here that we don't already have an input
1193 // handler.
1194 DCHECK(!input_handler_);
1195}
1196
changwan75e3b2072017-01-16 02:55:001197void RenderWidget::ShowVirtualKeyboard() {
1198 UpdateTextInputStateInternal(true, false);
1199}
1200
changwan62f57292017-02-17 08:28:251201void RenderWidget::ClearTextInputState() {
1202 text_input_info_ = blink::WebTextInputInfo();
1203 text_input_type_ = ui::TextInputType::TEXT_INPUT_TYPE_NONE;
1204 text_input_mode_ = ui::TextInputMode::TEXT_INPUT_MODE_DEFAULT;
1205 can_compose_inline_ = false;
1206 text_input_flags_ = 0;
AJITH KUMAR V041c0b02017-08-08 10:39:201207 next_previous_flags_ = kInvalidNextPreviousFlagsValue;
changwan62f57292017-02-17 08:28:251208}
1209
changwan75e3b2072017-01-16 02:55:001210void RenderWidget::UpdateTextInputState() {
1211 UpdateTextInputStateInternal(false, false);
1212}
1213
1214void RenderWidget::UpdateTextInputStateInternal(bool show_virtual_keyboard,
1215 bool reply_to_request) {
fsamuel72464894f2015-12-15 06:59:311216 TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState");
changwan75e3b2072017-01-16 02:55:001217
fsamuel72464894f2015-12-15 06:59:311218 if (ime_event_guard_) {
changwan75e3b2072017-01-16 02:55:001219 DCHECK(!reply_to_request);
1220 // show_virtual_keyboard should still be effective even if it was set inside
1221 // the IME
fsamuel72464894f2015-12-15 06:59:311222 // event guard.
changwan75e3b2072017-01-16 02:55:001223 if (show_virtual_keyboard)
1224 ime_event_guard_->set_show_virtual_keyboard(true);
fsamuel72464894f2015-12-15 06:59:311225 return;
1226 }
1227
dglazkov97b6c2b2016-10-25 17:35:551228 ui::TextInputType new_type = GetTextInputType();
1229 if (IsDateTimeInput(new_type))
1230 return; // Not considered as a text input field in WebKit/Chromium.
fsamuel72464894f2015-12-15 06:59:311231
dglazkov97b6c2b2016-10-25 17:35:551232 blink::WebTextInputInfo new_info;
ekaramad5aff1942017-01-06 01:26:351233 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:541234 new_info = controller->TextInputInfo();
dtapuskac4dd5be2016-10-25 15:11:101235 const ui::TextInputMode new_mode =
Blink Reformat1c4d759e2017-04-09 16:34:541236 ConvertWebTextInputMode(new_info.input_mode);
fsamuel72464894f2015-12-15 06:59:311237
1238 bool new_can_compose_inline = CanComposeInline();
1239
1240 // Only sends text input params if they are changed or if the ime should be
1241 // shown.
changwan75e3b2072017-01-16 02:55:001242 if (show_virtual_keyboard || reply_to_request ||
changwan38c3eb612016-12-09 01:45:561243 text_input_type_ != new_type || text_input_mode_ != new_mode ||
1244 text_input_info_ != new_info ||
1245 can_compose_inline_ != new_can_compose_inline) {
ekaramad9053e57b2016-04-26 20:00:381246 TextInputState params;
dglazkov97b6c2b2016-10-25 17:35:551247 params.type = new_type;
fsamuel72464894f2015-12-15 06:59:311248 params.mode = new_mode;
1249 params.flags = new_info.flags;
AJITH KUMAR V9e7b5572017-11-14 00:54:211250#if defined(OS_ANDROID)
AJITH KUMAR V041c0b02017-08-08 10:39:201251 if (next_previous_flags_ == kInvalidNextPreviousFlagsValue) {
1252 // Due to a focus change, values will be reset by the frame.
1253 // That case we only need fresh NEXT/PREVIOUS information.
Albert J. Wong3c93c182018-09-27 17:29:431254 // Also we won't send WidgetHostMsg_TextInputStateChanged if next/previous
AJITH KUMAR V041c0b02017-08-08 10:39:201255 // focusable status is changed.
1256 if (auto* controller = GetInputMethodController()) {
1257 next_previous_flags_ =
1258 controller->ComputeWebTextInputNextPreviousFlags();
1259 } else {
1260 // For safety in case GetInputMethodController() is null, because -1 is
1261 // invalid value to send to browser process.
1262 next_previous_flags_ = 0;
1263 }
1264 }
AJITH KUMAR V9e7b5572017-11-14 00:54:211265#else
1266 next_previous_flags_ = 0;
1267#endif
AJITH KUMAR V041c0b02017-08-08 10:39:201268 params.flags |= next_previous_flags_;
Blink Reformat1c4d759e2017-04-09 16:34:541269 params.value = new_info.value.Utf8();
1270 params.selection_start = new_info.selection_start;
1271 params.selection_end = new_info.selection_end;
1272 params.composition_start = new_info.composition_start;
1273 params.composition_end = new_info.composition_end;
fsamuel72464894f2015-12-15 06:59:311274 params.can_compose_inline = new_can_compose_inline;
changwan75e3b2072017-01-16 02:55:001275 // TODO(changwan): change instances of show_ime_if_needed to
1276 // show_virtual_keyboard.
1277 params.show_ime_if_needed = show_virtual_keyboard;
1278 params.reply_to_request = reply_to_request;
Albert J. Wong3c93c182018-09-27 17:29:431279 Send(new WidgetHostMsg_TextInputStateChanged(routing_id(), params));
fsamuel72464894f2015-12-15 06:59:311280
1281 text_input_info_ = new_info;
dglazkov97b6c2b2016-10-25 17:35:551282 text_input_type_ = new_type;
fsamuel72464894f2015-12-15 06:59:311283 text_input_mode_ = new_mode;
1284 can_compose_inline_ = new_can_compose_inline;
1285 text_input_flags_ = new_info.flags;
Eric Karlfe193e32018-12-07 17:15:441286
1287#if defined(OS_ANDROID)
1288 // If we send a new TextInputStateChanged message, we must also deliver a
1289 // new RenderFrameMetadata, as the IME will need this info to be updated.
1290 // TODO(ericrk): Introduce a |text_input_state_revision_| var to synchronize
1291 // the RFM with the TextInputStateChanged message. https://crbug.com/912309
1292 if (layer_tree_view_ && IsSurfaceSynchronizationEnabled()) {
1293 layer_tree_view_->RequestNewLocalSurfaceId();
1294 }
1295#endif
fsamuel72464894f2015-12-15 06:59:311296 }
1297}
1298
1299bool RenderWidget::WillHandleGestureEvent(const blink::WebGestureEvent& event) {
paulmeyer6ef5a792016-11-08 20:33:581300 possible_drag_event_info_.event_source =
1301 ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH;
1302 possible_drag_event_info_.event_location =
Ella Ge1116059d2018-03-21 02:06:131303 gfx::ToFlooredPoint(event.PositionInScreen());
avid7d6b2e2016-03-04 19:41:171304
fsamuel72464894f2015-12-15 06:59:311305 return false;
1306}
1307
1308bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
ericwilligers88e69742016-10-17 19:29:551309 for (auto& observer : render_frames_)
1310 observer.RenderWidgetWillHandleMouseEvent();
lfge0c2792ec2016-05-11 18:52:081311
paulmeyer6ef5a792016-11-08 20:33:581312 possible_drag_event_info_.event_source =
1313 ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
1314 possible_drag_event_info_.event_location =
Blink Reformat1c4d759e2017-04-09 16:34:541315 gfx::Point(event.PositionInScreen().x, event.PositionInScreen().y);
paulmeyer6ef5a792016-11-08 20:33:581316
avid7d6b2e2016-03-04 19:41:171317 if (owner_delegate_)
danakja2c9d0a92018-07-25 20:01:181318 return owner_delegate_->RenderWidgetWillHandleMouseEventForWidget(event);
avid7d6b2e2016-03-04 19:41:171319
fsamuel72464894f2015-12-15 06:59:311320 return false;
[email protected]fd847792013-10-24 17:12:351321}
1322
initial.commit09911bf2008-07-26 23:55:291323///////////////////////////////////////////////////////////////////////////////
mfomitchev2600fd7c2016-02-17 20:53:391324// RenderWidgetScreenMetricsDelegate
1325
1326void RenderWidget::Redraw() {
danakja6c10012018-07-06 14:25:361327 if (layer_tree_view_)
1328 layer_tree_view_->SetNeedsRedrawRect(gfx::Rect(size_));
mfomitchev2600fd7c2016-02-17 20:53:391329}
1330
bokanc63441c2016-04-27 15:49:121331void RenderWidget::ResizeWebWidget() {
danakja2c9d0a92018-07-25 20:01:181332 gfx::Size size = GetSizeForWebWidget();
1333 if (owner_delegate_) {
1334 owner_delegate_->ResizeWebWidgetForWidget(
1335 size, top_controls_height_, bottom_controls_height_,
1336 browser_controls_shrink_blink_size_);
1337 return;
1338 }
1339 GetWebWidget()->Resize(size);
bokanc63441c2016-04-27 15:49:121340}
1341
1342gfx::Size RenderWidget::GetSizeForWebWidget() const {
danakj4b347212018-07-04 17:55:171343 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:031344 return gfx::ScaleToCeiledSize(size_,
1345 GetOriginalScreenInfo().device_scale_factor);
1346 }
bokanc63441c2016-04-27 15:49:121347
1348 return size_;
1349}
1350
akaba3483d8f2018-07-10 21:43:091351void RenderWidget::UpdateZoom(double zoom_level) {
akabac6bd1212018-06-25 20:10:481352 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1353 if (!frame_widget)
1354 return;
1355 RenderFrameImpl* render_frame =
1356 RenderFrameImpl::FromWebFrame(frame_widget->LocalRoot());
1357
akaba3483d8f2018-07-10 21:43:091358 // Return early if zoom level is unchanged.
1359 if (render_frame->GetZoomLevel() == zoom_level) {
akabac6bd1212018-06-25 20:10:481360 return;
1361 }
1362
akaba3483d8f2018-07-10 21:43:091363 render_frame->SetZoomLevel(zoom_level);
akabac6bd1212018-06-25 20:10:481364
1365 for (auto& observer : render_frame_proxies_)
akaba3483d8f2018-07-10 21:43:091366 observer.OnZoomLevelChanged(zoom_level);
akabac6bd1212018-06-25 20:10:481367
1368 for (auto& plugin : browser_plugins_)
akaba3483d8f2018-07-10 21:43:091369 plugin.OnZoomLevelChanged(zoom_level);
akabac6bd1212018-06-25 20:10:481370}
1371
Fady Samuel799e72192018-04-25 21:16:571372void RenderWidget::SynchronizeVisualProperties(const VisualProperties& params) {
Christopher Cameronbe7ecea2018-02-27 00:47:191373 // Inform the rendering thread of the color space indicate the presence of HDR
1374 // capabilities.
Miguel Casas5e1018052018-01-09 19:17:361375 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1376 if (render_thread)
Christopher Camerone9a30c12018-03-07 08:23:381377 render_thread->SetRenderingColorSpace(params.screen_info.color_space);
Miguel Casas5e1018052018-01-09 19:17:361378
mfomitchev2600fd7c2016-02-17 20:53:391379 // Ignore this during shutdown.
lfg8ff33912016-09-13 20:59:211380 if (!GetWebWidget())
mfomitchev2600fd7c2016-02-17 20:53:391381 return;
1382
W. James MacLean2a90bff2018-11-05 20:52:471383 // Only propagate the external PSF to non-main-frames.
1384 if (!owner_delegate_)
1385 layer_tree_view_->SetExternalPageScaleFactor(params.page_scale_factor);
1386
Fady Samuele62be402018-03-29 03:19:531387 gfx::Size new_compositor_viewport_pixel_size =
1388 params.auto_resize_enabled
1389 ? gfx::ScaleToCeiledSize(size_,
1390 params.screen_info.device_scale_factor)
1391 : params.compositor_viewport_pixel_size;
Fady Samuel84d8a1f72018-11-08 00:26:171392 UpdateSurfaceAndScreenInfo(params.local_surface_id_allocation.value_or(
1393 viz::LocalSurfaceIdAllocation()),
1394 new_compositor_viewport_pixel_size,
1395 params.screen_info);
Vladimir Levin98d76dad2018-04-21 00:21:291396 UpdateCaptureSequenceNumber(params.capture_sequence_number);
danakja6c10012018-07-06 14:25:361397 if (layer_tree_view_) {
1398 layer_tree_view_->SetBrowserControlsHeight(
Sadrul Habib Chowdhury04d5dd4d2017-08-10 01:59:271399 params.top_controls_height, params.bottom_controls_height,
1400 params.browser_controls_shrink_blink_size);
danakja6c10012018-07-06 14:25:361401 layer_tree_view_->SetRasterColorSpace(
Sadrul Habib Chowdhury04d5dd4d2017-08-10 01:59:271402 screen_info_.color_space.GetRasterColorSpace());
ianwene5fc5782016-08-18 04:05:151403 }
mfomitchev2600fd7c2016-02-17 20:53:391404
akaba3483d8f2018-07-10 21:43:091405 UpdateZoom(params.zoom_level);
akabac6bd1212018-06-25 20:10:481406
Fady Samuele62be402018-03-29 03:19:531407 if (params.auto_resize_enabled)
1408 return;
1409
mfomitchev2600fd7c2016-02-17 20:53:391410 visible_viewport_size_ = params.visible_viewport_size;
mfomitchev2600fd7c2016-02-17 20:53:391411
1412 // NOTE: We may have entered fullscreen mode without changing our size.
1413 bool fullscreen_change =
1414 is_fullscreen_granted_ != params.is_fullscreen_granted;
1415 is_fullscreen_granted_ = params.is_fullscreen_granted;
1416 display_mode_ = params.display_mode;
1417
bokanc63441c2016-04-27 15:49:121418 size_ = params.new_size;
mfomitchev2600fd7c2016-02-17 20:53:391419
bokanc63441c2016-04-27 15:49:121420 ResizeWebWidget();
bokan71cb5b12016-04-27 03:45:221421
mfomitchev2600fd7c2016-02-17 20:53:391422 WebSize visual_viewport_size;
danakj4b347212018-07-04 17:55:171423 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:031424 visual_viewport_size =
1425 gfx::ScaleToCeiledSize(params.visible_viewport_size,
1426 GetOriginalScreenInfo().device_scale_factor);
mfomitchev2600fd7c2016-02-17 20:53:391427 } else {
1428 visual_viewport_size = visible_viewport_size_;
1429 }
Blink Reformat1c4d759e2017-04-09 16:34:541430 GetWebWidget()->ResizeVisualViewport(visual_viewport_size);
mfomitchev2600fd7c2016-02-17 20:53:391431
mfomitchev2600fd7c2016-02-17 20:53:391432 if (fullscreen_change)
1433 DidToggleFullscreen();
W. James MacLean2a90bff2018-11-05 20:52:471434
1435 if (!owner_delegate_) {
1436 // Make sure that page scale factor changes propagating down from the main
1437 // frame are relayed to nested OOPIFs/non-main-frames.
1438 page_scale_factor_from_mainframe_ = params.page_scale_factor;
1439 for (auto& observer : render_frame_proxies_)
1440 observer.OnPageScaleFactorChanged(params.page_scale_factor);
1441 }
mfomitchev2600fd7c2016-02-17 20:53:391442}
1443
1444void RenderWidget::SetScreenMetricsEmulationParameters(
1445 bool enabled,
1446 const blink::WebDeviceEmulationParams& params) {
danakja2c9d0a92018-07-25 20:01:181447 // This is only supported in RenderView, which has an |owner_delegate_|.
1448 DCHECK(owner_delegate_);
1449 owner_delegate_->SetScreenMetricsEmulationParametersForWidget(enabled,
1450 params);
mfomitchev2600fd7c2016-02-17 20:53:391451}
1452
Albert J. Wong3c93c182018-09-27 17:29:431453void RenderWidget::SetScreenRects(const gfx::Rect& widget_screen_rect,
mfomitchev2600fd7c2016-02-17 20:53:391454 const gfx::Rect& window_screen_rect) {
Albert J. Wong3c93c182018-09-27 17:29:431455 widget_screen_rect_ = widget_screen_rect;
mfomitchev2600fd7c2016-02-17 20:53:391456 window_screen_rect_ = window_screen_rect;
1457}
1458
1459///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461460// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291461
Chris Harrelsond7ab99b2018-01-24 17:51:361462void RenderWidget::IntrinsicSizingInfoChanged(
1463 const blink::WebIntrinsicSizingInfo& sizing_info) {
Albert J. Wong3c93c182018-09-27 17:29:431464 Send(new WidgetHostMsg_IntrinsicSizingInfoChanged(routing_id_, sizing_info));
Chris Harrelsond7ab99b2018-01-24 17:51:361465}
1466
Blink Reformat1c4d759e2017-04-09 16:34:541467void RenderWidget::DidMeaningfulLayout(blink::WebMeaningfulLayout layout_type) {
1468 if (layout_type == blink::WebMeaningfulLayout::kVisuallyNonEmpty) {
Albert J. Wongfb64e142018-10-16 01:10:451469 QueueMessage(new WidgetHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_));
dglazkovf0e1d6d2015-10-10 02:13:481470 }
dglazkov79c426102015-08-31 21:22:431471
ericwilligers88e69742016-10-17 19:29:551472 for (auto& observer : render_frames_)
1473 observer.DidMeaningfulLayout(layout_type);
dglazkov79c426102015-08-31 21:22:431474}
1475
[email protected]586871b2014-07-22 17:05:111476// static
dchengcedca5612016-04-09 01:40:151477std::unique_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
[email protected]586871b2014-07-22 17:05:111478 IPC::Message* msg,
[email protected]586871b2014-07-22 17:05:111479 FrameSwapMessageQueue* frame_swap_message_queue,
1480 scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
[email protected]586871b2014-07-22 17:05:111481 int source_frame_number) {
[email protected]586871b2014-07-22 17:05:111482 bool first_message_for_frame = false;
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491483 frame_swap_message_queue->QueueMessageForFrame(
1484 source_frame_number, base::WrapUnique(msg), &first_message_for_frame);
[email protected]586871b2014-07-22 17:05:111485 if (first_message_for_frame) {
dchengcedca5612016-04-09 01:40:151486 std::unique_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
[email protected]586871b2014-07-22 17:05:111487 sync_message_filter, frame_swap_message_queue, source_frame_number));
dcheng4b6b5ff2014-10-16 00:42:061488 return promise;
[email protected]586871b2014-07-22 17:05:111489 }
dcheng4b6b5ff2014-10-16 00:42:061490 return nullptr;
[email protected]586871b2014-07-22 17:05:111491}
1492
danakj53802692018-07-25 21:46:441493void RenderWidget::SetHandlingInputEvent(bool handling_input_event) {
1494 input_handler_->set_handling_input_event(handling_input_event);
1495}
1496
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491497void RenderWidget::QueueMessage(IPC::Message* msg) {
[email protected]586871b2014-07-22 17:05:111498 // RenderThreadImpl::current() is NULL in some tests.
danakja6c10012018-07-06 14:25:361499 if (!layer_tree_view_ || !RenderThreadImpl::current()) {
[email protected]586871b2014-07-22 17:05:111500 Send(msg);
1501 return;
1502 }
1503
dchengcedca5612016-04-09 01:40:151504 std::unique_ptr<cc::SwapPromise> swap_promise =
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491505 QueueMessageImpl(msg, frame_swap_message_queue_.get(),
[email protected]586871b2014-07-22 17:05:111506 RenderThreadImpl::current()->sync_message_filter(),
danakja6c10012018-07-06 14:25:361507 layer_tree_view_->GetSourceFrameNumber());
[email protected]586871b2014-07-22 17:05:111508
Ken Buchanance710eb2017-08-30 23:46:521509 if (swap_promise)
danakja6c10012018-07-06 14:25:361510 layer_tree_view_->QueueSwapPromise(std::move(swap_promise));
[email protected]586871b2014-07-22 17:05:111511}
1512
Blink Reformat1c4d759e2017-04-09 16:34:541513void RenderWidget::DidChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301514 // TODO(darin): Eliminate this temporary.
[email protected]9ec87712013-05-24 23:23:521515 WebCursor cursor;
tfarina75a0abf2015-10-06 15:07:181516 InitializeCursorFromWebCursorInfo(&cursor, cursor_info);
initial.commit09911bf2008-07-26 23:55:291517 // Only send a SetCursor message if we need to make a change.
Navid Zolghadr293bb862018-12-12 18:15:411518 if (input_handler_->DidChangeCursor(cursor))
Albert J. Wong3c93c182018-09-27 17:29:431519 Send(new WidgetHostMsg_SetCursor(routing_id_, cursor));
initial.commit09911bf2008-07-26 23:55:291520}
1521
aelias5971e47d2017-06-16 02:39:381522void RenderWidget::AutoscrollStart(const blink::WebFloatPoint& point) {
Albert J. Wong3c93c182018-09-27 17:29:431523 Send(new WidgetHostMsg_AutoscrollStart(routing_id_, point));
aelias5971e47d2017-06-16 02:39:381524}
1525
1526void RenderWidget::AutoscrollFling(const blink::WebFloatSize& velocity) {
Albert J. Wong3c93c182018-09-27 17:29:431527 Send(new WidgetHostMsg_AutoscrollFling(routing_id_, velocity));
aelias5971e47d2017-06-16 02:39:381528}
1529
1530void RenderWidget::AutoscrollEnd() {
Albert J. Wong3c93c182018-09-27 17:29:431531 Send(new WidgetHostMsg_AutoscrollEnd(routing_id_));
aelias5971e47d2017-06-16 02:39:381532}
1533
initial.commit09911bf2008-07-26 23:55:291534// We are supposed to get a single call to Show for a newly created RenderWidget
1535// that was created via RenderWidget::CreateWebView. So, we wait until this
1536// point to dispatch the ShowWidget message.
1537//
1538// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281539// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291540//
Blink Reformat1c4d759e2017-04-09 16:34:541541void RenderWidget::Show(WebNavigationPolicy policy) {
danakj65f423b72018-10-10 17:21:201542 if (!show_callback_) {
danakja2c9d0a92018-07-25 20:01:181543 if (owner_delegate_) {
1544 // When SupportsMultipleWindows is disabled, popups are reusing
danakj65f423b72018-10-10 17:21:201545 // the view's RenderWidget. In some scenarios, this makes blink to call
1546 // Show() twice. But otherwise, if it is enabled, we should not visit
1547 // Show() more than once.
danakja2c9d0a92018-07-25 20:01:181548 DCHECK(!owner_delegate_->SupportsMultipleWindowsForWidget());
danakj65f423b72018-10-10 17:21:201549 return;
danakja2c9d0a92018-07-25 20:01:181550 } else {
danakj65f423b72018-10-10 17:21:201551 NOTREACHED() << "received extraneous Show call";
danakja2c9d0a92018-07-25 20:01:181552 }
danakja2c9d0a92018-07-25 20:01:181553 }
1554
initial.commit09911bf2008-07-26 23:55:291555 DCHECK(routing_id_ != MSG_ROUTING_NONE);
nickf7b38222016-11-22 21:59:351556
1557 // The opener is responsible for actually showing this widget.
danakjdf1ceb72018-07-18 20:02:251558 std::move(show_callback_).Run(this, policy, initial_rect_);
nickf7b38222016-11-22 21:59:351559
bokanc007c3a2015-02-03 07:15:561560 // NOTE: initial_rect_ may still have its default values at this point, but
[email protected]8de12d942010-11-17 20:42:441561 // that's okay. It'll be ignored if as_popup is false, or the browser
1562 // process will impose a default position otherwise.
bokanc007c3a2015-02-03 07:15:561563 SetPendingWindowRect(initial_rect_);
initial.commit09911bf2008-07-26 23:55:291564}
1565
danakj17216f4d2018-10-16 22:57:321566LayerTreeView* RenderWidget::InitializeLayerTreeView() {
1567 TRACE_EVENT0("blink", "RenderWidget::InitializeLayerTreeView");
danakj17216f4d2018-10-16 22:57:321568
1569 layer_tree_view_ = std::make_unique<LayerTreeView>(
1570 this, compositor_deps_->GetCompositorMainThreadTaskRunner(),
1571 compositor_deps_->GetCompositorImplThreadTaskRunner(),
1572 compositor_deps_->GetTaskGraphRunner(),
1573 compositor_deps_->GetWebMainThreadScheduler());
1574 layer_tree_view_->Initialize(
danakj6dcbc5962018-11-16 16:45:421575 GenerateLayerTreeSettings(compositor_deps_, for_child_local_root_frame_,
danakj17216f4d2018-10-16 22:57:321576 screen_info_.rect.size(),
1577 screen_info_.device_scale_factor),
1578 compositor_deps_->CreateUkmRecorderFactory());
1579
Fady Samuel1c1ad3692018-11-06 23:28:401580 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
danakj17216f4d2018-10-16 22:57:321581 compositor_viewport_pixel_size_, screen_info_);
1582 layer_tree_view_->SetRasterColorSpace(
1583 screen_info_.color_space.GetRasterColorSpace());
1584 layer_tree_view_->SetContentSourceId(current_content_source_id_);
1585 // For background pages and certain tests, we don't want to trigger
1586 // LayerTreeFrameSink creation.
1587 bool should_generate_frame_sink =
1588 !compositor_never_visible_ && RenderThreadImpl::current();
danakje9be3162018-11-05 21:32:001589 if (!should_generate_frame_sink) {
1590 // Prevents SetVisible() from blink from doing anything.
danakj17216f4d2018-10-16 22:57:321591 layer_tree_view_->SetNeverVisible();
danakj6dcbc5962018-11-16 16:45:421592 } else if (!is_frozen_) {
danakje9be3162018-11-05 21:32:001593 // Begins the compositor's scheduler to start producing frames.
1594 // Don't do this if the RenderWidget is attached to a RenderViewImpl for a
danakjbc6ba9d22018-11-17 04:03:411595 // proxy main frame, as this RenderWidget is frozen then, and won't be
danakje9be3162018-11-05 21:32:001596 // used for compositing until a WebFrameWidget is attached.
1597 StartCompositor();
1598 }
danakj17216f4d2018-10-16 22:57:321599
danakj17216f4d2018-10-16 22:57:321600 DCHECK_NE(MSG_ROUTING_NONE, routing_id_);
1601 layer_tree_view_->SetFrameSinkId(
1602 viz::FrameSinkId(RenderThread::Get()->GetClientId(), routing_id_));
1603
1604 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1605 if (render_thread) {
1606 input_event_queue_ = base::MakeRefCounted<MainThreadEventQueue>(
1607 this, render_thread->GetWebMainThreadScheduler()->InputTaskRunner(),
1608 render_thread->GetWebMainThreadScheduler(), should_generate_frame_sink);
1609 }
1610
1611 return layer_tree_view_.get();
1612}
1613
danakjde8b7482018-11-15 23:45:021614void RenderWidget::StartCompositor() {
1615 if (!is_hidden_)
1616 layer_tree_view_->SetVisible(true);
1617}
1618
1619void RenderWidget::StopCompositor() {
1620 layer_tree_view_->SetVisible(false);
1621 // Drop all gpu resources, this makes SetVisible(true) more expensive/slower
1622 // but we don't expect to use this RenderWidget again until some possible
1623 // future navigation. This brings us a bit closer to emulating deleting the
1624 // RenderWidget instead of just stopping the compositor.
1625 layer_tree_view_->ReleaseLayerTreeFrameSink();
1626}
1627
danakj6dcbc5962018-11-16 16:45:421628void RenderWidget::SetIsFrozen(bool is_frozen) {
1629 DCHECK_NE(is_frozen, is_frozen_);
1630 is_frozen_ = is_frozen;
1631 if (is_frozen)
danakjde8b7482018-11-15 23:45:021632 StopCompositor();
1633 else
1634 StartCompositor();
1635}
1636
danakjf87460792018-12-04 20:14:221637void RenderWidget::WarmupCompositor() {
1638 DCHECK(is_frozen_);
1639
1640 // Tests have no RenderThreadImpl /o\.
1641 if (!RenderThreadImpl::current())
1642 return;
1643
1644 // Keeping things simple. This would cancel any outstanding warmup if we
1645 // happened to have one (this should be basically impossible). This avoids any
1646 // extra book keeping about the outstanding reqeust.
1647 warmup_weak_ptr_factory_.InvalidateWeakPtrs();
1648 // And if we already did a warmup then we're done.
1649 if (warmup_frame_sink_)
1650 return;
1651
1652 // Mark us pending the warmup frame sink *before* calling
1653 // DoRequestNewLayerTreeFrameSink() as it may run the reply callback
1654 // synchronously. So we don't want to change any state after the call
1655 // to DoRequestNewLayerTreeFrameSink() here.
1656 warmup_frame_sink_request_pending_ = true;
1657
1658 auto cb = base::BindOnce(&RenderWidget::OnReplyForWarmupCompositor,
1659 warmup_weak_ptr_factory_.GetWeakPtr());
1660 DoRequestNewLayerTreeFrameSink(std::move(cb));
1661}
1662
1663void RenderWidget::OnReplyForWarmupCompositor(
1664 std::unique_ptr<cc::LayerTreeFrameSink> sink) {
1665 warmup_frame_sink_request_pending_ = false;
1666
1667 if (after_warmup_callback_)
1668 std::move(after_warmup_callback_).Run(std::move(sink));
1669 else
1670 warmup_frame_sink_ = std::move(sink);
1671}
1672
1673void RenderWidget::AbortWarmupCompositor() {
1674 warmup_frame_sink_request_pending_ = false;
1675 // Drop any pending warmup.
1676 warmup_weak_ptr_factory_.InvalidateWeakPtrs();
1677 // And drop any completed one.
1678 warmup_frame_sink_.reset();
1679
1680 // If we had saved a callback to run after warmup, just do so now indicating
1681 // failure.
1682 if (after_warmup_callback_)
1683 std::move(after_warmup_callback_).Run(nullptr);
1684}
1685
[email protected]2533ce12009-05-09 00:02:241686void RenderWidget::DoDeferredClose() {
Albert J. Wong3c93c182018-09-27 17:29:431687 Send(new WidgetHostMsg_Close(routing_id_));
[email protected]2533ce12009-05-09 00:02:241688}
1689
Blink Reformat1c4d759e2017-04-09 16:34:541690void RenderWidget::CloseWidgetSoon() {
skyostiled8969c2015-07-20 16:57:081691 DCHECK(content::RenderThread::Get());
danakj6dcbc5962018-11-16 16:45:421692 if (is_frozen_) {
1693 // This widget is currently not active. The active main frame widget is in a
[email protected]e1c3a552012-05-04 20:51:321694 // different process. Have the browser route the close request to the
1695 // active widget instead, so that the correct unload handlers are run.
Albert J. Wongfb64e142018-10-16 01:10:451696 Send(new WidgetHostMsg_RouteCloseEvent(routing_id_));
[email protected]e1c3a552012-05-04 20:51:321697 return;
1698 }
1699
danakj292b63e2018-11-19 20:47:061700 // Prevent compositor from setting up new IPC channels, since we know a
1701 // WidgetMsg_Close is coming. We do this immediately, not in DoDeferredClose,
1702 // as the caller (eg WebPagePopupImpl) may start tearing down things after
1703 // calling this method, including detaching the frame from this RenderWidget.
1704 // Then trying to make a LayerTreeFrameSink would crash.
1705 // https://crbug.com/906340
1706 host_will_close_this_ = true;
1707
initial.commit09911bf2008-07-26 23:55:291708 // If a page calls window.close() twice, we'll end up here twice, but that's
1709 // OK. It is safe to send multiple Close messages.
danakj292b63e2018-11-19 20:47:061710 //
[email protected]2533ce12009-05-09 00:02:241711 // Ask the RenderWidgetHost to initiate close. We could be called from deep
1712 // in Javascript. If we ask the RendwerWidgetHost to close now, the window
1713 // could be closed before the JS finishes executing. So instead, post a
1714 // message back to the message loop, which won't run until the JS is
1715 // complete, and then the Close message can be sent.
Hajime Hoshi315a61f2018-08-14 17:27:281716 GetCleanupTaskRunner()->PostTask(
1717 FROM_HERE, base::BindOnce(&RenderWidget::DoDeferredClose, this));
initial.commit09911bf2008-07-26 23:55:291718}
1719
1720void RenderWidget::Close() {
danakj6dcbc5962018-11-16 16:45:421721 // This was done immediately in the |for_child_local_root_frame_| case in the
1722 // OnClose() IPC handler.
1723 if (!for_child_local_root_frame_)
danakj5c5269b2018-11-06 00:39:111724 CloseWebWidget();
1725
danakja6c10012018-07-06 14:25:361726 layer_tree_view_.reset();
danakja2c9d0a92018-07-25 20:01:181727 if (owner_delegate_)
1728 owner_delegate_->DidCloseWidget();
Albert J. Wongd593de532018-09-06 05:42:151729 // Note the ACK is a control message going to the RenderProcessHost.
Albert J. Wong3c93c182018-09-27 17:29:431730 RenderThread::Get()->Send(new WidgetHostMsg_Close_ACK(routing_id()));
Ken Buchananed449bb2018-02-01 21:02:051731}
1732
1733void RenderWidget::CloseWebWidget() {
danakj35314ab2018-10-19 16:37:341734 // If the browser has not sent OnDisableDeviceEmulation, we have an emulator
1735 // hanging out still. Destroying it must happen *after* the IPC route is
1736 // removed so that another IPC does not arrive and re-create the emulator
1737 // during closing.
1738 //
1739 // This destruction is normally part of an IPC and expects objects to be alive
1740 // that would be alive while the IPC route is active such as the
1741 // |layer_tree_view_|. So we ensure that it is the first thing to be
1742 // destroyed here before deleting things from the RenderWidget or the
1743 // |owner_delegate_|.
1744 //
1745 // TODO(danakj): The emulator could reset to non-emulated values in an
1746 // explicit method call (instead of in the destructor) that occurs when
1747 // emulation is disabled, but does not need to occur during RenderWidget
1748 // closing. Then we would not have to destroy this so carefully.
1749 screen_metrics_emulator_.reset();
1750
danakj5c5269b2018-11-06 00:39:111751 // Informs the WebWidget that compositor is being destroyed, so it can remove
1752 // references to it first.
1753 //
1754 // When |owner_delegate_| is present, the RenderWidget is for a main frame,
1755 // and the GetWebWidget() is not the same as |webwidget_internal_|. However
1756 // that widget is responsible for doing WillCloseLayerTreeView() on the
1757 // |webwidget_internal_|, not us. Otherwise, they are the same and this is
1758 // notifying |webwidget_internal_|.
1759 GetWebWidget()->WillCloseLayerTreeView();
1760
1761 // While the wrapping WebWidget from an |owner_delegate_| is responsible for
1762 // doing WillCloseLayerTreeView() on the |webwidget_internal_|, this class is
1763 // responsible for calling Close() on it. Notably, then, the wrapping
1764 // WebWidget does not.
1765 webwidget_internal_->Close();
1766 webwidget_internal_ = nullptr;
initial.commit09911bf2008-07-26 23:55:291767}
1768
Mitsuru Oshima3c07b332018-02-06 04:56:501769void RenderWidget::UpdateWebViewWithDeviceScaleFactor() {
1770 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1771 blink::WebFrame* current_frame =
1772 frame_widget ? frame_widget->LocalRoot() : nullptr;
1773 blink::WebView* webview = current_frame ? current_frame->View() : nullptr;
1774 if (webview) {
danakj4b347212018-07-04 17:55:171775 if (compositor_deps_->IsUseZoomForDSFEnabled())
Fady Samuela863f152018-03-09 16:10:031776 webview->SetZoomFactorForDeviceScaleFactor(
1777 GetWebScreenInfo().device_scale_factor);
Mitsuru Oshima3c07b332018-02-06 04:56:501778 else
Fady Samuela863f152018-03-09 16:10:031779 webview->SetDeviceScaleFactor(GetWebScreenInfo().device_scale_factor);
Mitsuru Oshima3c07b332018-02-06 04:56:501780
1781 webview->GetSettings()->SetPreferCompositingToLCDTextEnabled(
Christopher Camerone9a30c12018-03-07 08:23:381782 PreferCompositingToLCDText(compositor_deps_,
Fady Samuela863f152018-03-09 16:10:031783 GetWebScreenInfo().device_scale_factor));
Mitsuru Oshima3c07b332018-02-06 04:56:501784 }
1785}
1786
Ehsan Karamad655d7b8a2018-01-12 18:38:381787blink::WebFrameWidget* RenderWidget::GetFrameWidget() const {
1788 blink::WebWidget* web_widget = GetWebWidget();
1789 if (!web_widget)
1790 return nullptr;
1791
1792 if (!web_widget->IsWebFrameWidget()) {
1793 // TODO(ekaramad): This should not happen. If we have a WebWidget and we
1794 // need a WebFrameWidget then we should be getting a WebFrameWidget. But
1795 // unfortunately this does not seem to be the case in some scenarios --
1796 // specifically when a RenderViewImpl swaps out during navigation the
1797 // WebViewImpl loses its WebViewFrameWidget but sometimes we receive IPCs
1798 // which are destined for WebFrameWidget (https://crbug.com/669219).
1799 return nullptr;
1800 }
1801
1802 return static_cast<blink::WebFrameWidget*>(web_widget);
1803}
1804
bokan841fdc72016-10-06 00:16:351805void RenderWidget::ScreenRectToEmulatedIfNeeded(WebRect* window_rect) const {
1806 DCHECK(window_rect);
1807 float scale = popup_origin_scale_for_emulation_;
1808 if (!scale)
1809 return;
1810 window_rect->x =
1811 popup_view_origin_for_emulation_.x() +
1812 (window_rect->x - popup_screen_origin_for_emulation_.x()) / scale;
1813 window_rect->y =
1814 popup_view_origin_for_emulation_.y() +
1815 (window_rect->y - popup_screen_origin_for_emulation_.y()) / scale;
1816}
1817
1818void RenderWidget::EmulatedToScreenRectIfNeeded(WebRect* window_rect) const {
1819 DCHECK(window_rect);
1820 float scale = popup_origin_scale_for_emulation_;
1821 if (!scale)
1822 return;
1823 window_rect->x =
1824 popup_screen_origin_for_emulation_.x() +
1825 (window_rect->x - popup_view_origin_for_emulation_.x()) * scale;
1826 window_rect->y =
1827 popup_screen_origin_for_emulation_.y() +
1828 (window_rect->y - popup_view_origin_for_emulation_.y()) * scale;
1829}
1830
Blink Reformat1c4d759e2017-04-09 16:34:541831WebRect RenderWidget::WindowRect() {
bokan841fdc72016-10-06 00:16:351832 WebRect rect;
bokan6b08cd22016-10-05 00:55:211833 if (pending_window_rect_count_) {
1834 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
1835 // the RootWindowRect is probably going to return wrong results since the
1836 // browser may not have processed the Move yet. There isn't really anything
1837 // good to do in this case, and it shouldn't happen - since this size is
1838 // only really needed for windowToScreen, which is only used for Popups.
bokan841fdc72016-10-06 00:16:351839 rect = pending_window_rect_;
1840 } else {
1841 rect = window_screen_rect_;
bokan6b08cd22016-10-05 00:55:211842 }
[email protected]2533ce12009-05-09 00:02:241843
bokan841fdc72016-10-06 00:16:351844 ScreenRectToEmulatedIfNeeded(&rect);
1845 return rect;
bokan6b08cd22016-10-05 00:55:211846}
1847
Blink Reformat1c4d759e2017-04-09 16:34:541848WebRect RenderWidget::ViewRect() {
Albert J. Wong3c93c182018-09-27 17:29:431849 WebRect rect = widget_screen_rect_;
bokan841fdc72016-10-06 00:16:351850 ScreenRectToEmulatedIfNeeded(&rect);
1851 return rect;
initial.commit09911bf2008-07-26 23:55:291852}
1853
Blink Reformat1c4d759e2017-04-09 16:34:541854void RenderWidget::SetToolTipText(const blink::WebString& text,
[email protected]8a9d6ca32011-06-06 20:11:301855 WebTextDirection hint) {
Albert J. Wong3c93c182018-09-27 17:29:431856 Send(new WidgetHostMsg_SetTooltipText(routing_id_, text.Utf16(), hint));
[email protected]8a9d6ca32011-06-06 20:11:301857}
1858
Blink Reformat1c4d759e2017-04-09 16:34:541859void RenderWidget::SetWindowRect(const WebRect& rect_in_screen) {
danakj81d601e62018-10-09 22:15:051860 // This path is for the renderer to change the on-screen position/size of
1861 // the widget by changing its window rect. This is not possible for
1862 // RenderWidgets whose position/size are controlled by layout from another
danakj6dcbc5962018-11-16 16:45:421863 // frame tree (ie. child local root frames), as the window rect can only be
1864 // set by the browser.
1865 if (for_child_local_root_frame_)
danakj81d601e62018-10-09 22:15:051866 return;
1867
oshima33ec97cd2015-12-14 19:40:241868 WebRect window_rect = rect_in_screen;
bokan841fdc72016-10-06 00:16:351869 EmulatedToScreenRectIfNeeded(&window_rect);
[email protected]b2e4c70132013-10-03 02:07:511870
danakj65f423b72018-10-10 17:21:201871 if (resizing_mode_selector_->is_synchronous_mode()) {
Kent Tamura21d1de62018-12-10 04:45:201872 // This is a web-test-only path. At one point, it was planned to be
danakj65f423b72018-10-10 17:21:201873 // removed. See https://crbug.com/309760.
bokanc007c3a2015-02-03 07:15:561874 SetWindowRectSynchronously(window_rect);
danakj65f423b72018-10-10 17:21:201875 return;
1876 }
1877
1878 if (show_callback_) {
1879 // The widget is not shown yet. Delay the |window_rect| being sent to the
1880 // browser until Show() is called so it can be sent with that IPC, once the
1881 // browser is ready for the info.
1882 initial_rect_ = window_rect;
1883 } else {
1884 Send(new WidgetHostMsg_RequestSetBounds(routing_id_, window_rect));
1885 SetPendingWindowRect(window_rect);
initial.commit09911bf2008-07-26 23:55:291886 }
1887}
1888
[email protected]2533ce12009-05-09 00:02:241889void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
1890 pending_window_rect_ = rect;
1891 pending_window_rect_count_++;
[email protected]2533ce12009-05-09 00:02:241892
bokan6b08cd22016-10-05 00:55:211893 // Popups don't get size updates back from the browser so just store the set
1894 // values.
danakj6a816592018-09-25 18:30:561895 if (widget_type_ != WidgetType::kFrame) {
Blink Reformat1c4d759e2017-04-09 16:34:541896 window_screen_rect_ = rect;
Albert J. Wong3c93c182018-09-27 17:29:431897 widget_screen_rect_ = rect;
[email protected]2533ce12009-05-09 00:02:241898 }
[email protected]d4547452008-08-28 18:36:371899}
1900
wjmacleanee244e02017-05-26 21:06:071901void RenderWidget::OnShowContextMenu(ui::MenuSourceType source_type,
1902 const gfx::Point& location) {
wjmacleanee244e02017-05-26 21:06:071903 has_host_context_menu_location_ = true;
1904 host_context_menu_location_ = location;
1905 if (GetWebWidget()) {
1906 GetWebWidget()->ShowContextMenu(
1907 static_cast<blink::WebMenuSourceType>(source_type));
1908 }
1909 has_host_context_menu_location_ = false;
1910}
1911
[email protected]fa7b1dc2010-06-23 17:53:041912void RenderWidget::OnImeSetComposition(
[email protected]fcf75d42013-12-03 20:11:261913 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:111914 const std::vector<WebImeTextSpan>& ime_text_spans,
chongz7eb752802016-01-27 21:28:071915 const gfx::Range& replacement_range,
Ryan Landay9e42fd742017-08-12 01:59:111916 int selection_start,
1917 int selection_end) {
ekaramad5aff1942017-01-06 01:26:351918 if (!ShouldHandleImeEvents())
1919 return;
1920
brettw4b461082016-11-19 18:55:161921#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:491922 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
Ryan Landay9e42fd742017-08-12 01:59:111923 plugin->render_frame()->OnImeSetComposition(text, ime_text_spans,
EhsanK22d482e2017-08-10 17:29:491924 selection_start, selection_end);
ekaramad2a46d632016-07-19 13:33:091925 return;
1926 }
1927#endif
[email protected]66fca5bc2013-05-23 06:58:291928 ImeEventGuard guard(this);
ekaramad2daaf672016-11-10 20:29:011929 blink::WebInputMethodController* controller = GetInputMethodController();
ekaramad2daaf672016-11-10 20:29:011930 if (!controller ||
Blink Reformat1c4d759e2017-04-09 16:34:541931 !controller->SetComposition(
Ryan Landay9e42fd742017-08-12 01:59:111932 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:561933 replacement_range.IsValid()
1934 ? WebRange(replacement_range.start(), replacement_range.length())
1935 : WebRange(),
1936 selection_start, selection_end)) {
[email protected]fa7b1dc2010-06-23 17:53:041937 // If we failed to set the composition text, then we need to let the browser
1938 // process to cancel the input method's ongoing composition session, to make
1939 // sure we are in a consistent state.
Dave Tapuska04bc5ee92018-04-17 19:03:311940 if (mojom::WidgetInputHandlerHost* host =
1941 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
1942 host->ImeCancelComposition();
Dave Tapuska139a72f2017-09-06 21:57:031943 }
[email protected]7f00efa2010-04-15 05:01:261944 }
nonafa291792016-08-10 02:36:181945 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]fa7b1dc2010-06-23 17:53:041946}
1947
rlanday7efe2302017-01-11 00:14:281948void RenderWidget::OnImeCommitText(
1949 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:111950 const std::vector<WebImeTextSpan>& ime_text_spans,
rlanday7efe2302017-01-11 00:14:281951 const gfx::Range& replacement_range,
1952 int relative_cursor_pos) {
ekaramad5aff1942017-01-06 01:26:351953 if (!ShouldHandleImeEvents())
1954 return;
1955
brettw4b461082016-11-19 18:55:161956#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:491957 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
1958 plugin->render_frame()->OnImeCommitText(text, replacement_range,
1959 relative_cursor_pos);
ekaramad2a46d632016-07-19 13:33:091960 return;
1961 }
1962#endif
[email protected]66fca5bc2013-05-23 06:58:291963 ImeEventGuard guard(this);
fsamuele8326c742016-01-12 00:49:391964 input_handler_->set_handling_input_event(true);
ekaramadb6483a052017-02-10 02:23:261965 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:541966 controller->CommitText(
Ryan Landay9e42fd742017-08-12 01:59:111967 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:561968 replacement_range.IsValid()
1969 ? WebRange(replacement_range.start(), replacement_range.length())
1970 : WebRange(),
1971 relative_cursor_pos);
ekaramadb6483a052017-02-10 02:23:261972 }
aelias87b8f7c2016-09-14 03:19:291973 input_handler_->set_handling_input_event(false);
1974 UpdateCompositionInfo(false /* not an immediate request */);
1975}
1976
1977void RenderWidget::OnImeFinishComposingText(bool keep_selection) {
ekaramad5aff1942017-01-06 01:26:351978 if (!ShouldHandleImeEvents())
1979 return;
1980
brettw4b461082016-11-19 18:55:161981#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:491982 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
1983 plugin->render_frame()->OnImeFinishComposingText(keep_selection);
aelias87b8f7c2016-09-14 03:19:291984 return;
1985 }
1986#endif
1987
changwan38c3eb612016-12-09 01:45:561988 if (!GetWebWidget())
aelias87b8f7c2016-09-14 03:19:291989 return;
1990 ImeEventGuard guard(this);
1991 input_handler_->set_handling_input_event(true);
ekaramad2daaf672016-11-10 20:29:011992 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:541993 controller->FinishComposingText(
1994 keep_selection ? WebInputMethodController::kKeepSelection
1995 : WebInputMethodController::kDoNotKeepSelection);
ekaramad2daaf672016-11-10 20:29:011996 }
fsamuele8326c742016-01-12 00:49:391997 input_handler_->set_handling_input_event(false);
nonafa291792016-08-10 02:36:181998 UpdateCompositionInfo(false /* not an immediate request */);
initial.commit09911bf2008-07-26 23:55:291999}
2000
Christopher Camerone9a30c12018-03-07 08:23:382001void RenderWidget::UpdateSurfaceAndScreenInfo(
Fady Samuel1c1ad3692018-11-06 23:28:402002 const viz::LocalSurfaceIdAllocation& new_local_surface_id_allocation,
Christopher Cameronaad15a0d2018-03-09 03:47:332003 const gfx::Size& new_compositor_viewport_pixel_size,
Christopher Camerone9a30c12018-03-07 08:23:382004 const ScreenInfo& new_screen_info) {
Christopher Camerone9a30c12018-03-07 08:23:382005 bool orientation_changed =
2006 screen_info_.orientation_angle != new_screen_info.orientation_angle ||
2007 screen_info_.orientation_type != new_screen_info.orientation_type;
2008 bool web_device_scale_factor_changed =
2009 screen_info_.device_scale_factor != new_screen_info.device_scale_factor;
Fady Samuela863f152018-03-09 16:10:032010 ScreenInfo previous_original_screen_info = GetOriginalScreenInfo();
Christopher Cameronbe7ecea2018-02-27 00:47:192011
Fady Samuel1c1ad3692018-11-06 23:28:402012 local_surface_id_allocation_from_parent_ = new_local_surface_id_allocation;
Christopher Cameronaad15a0d2018-03-09 03:47:332013 compositor_viewport_pixel_size_ = new_compositor_viewport_pixel_size;
Christopher Camerone9a30c12018-03-07 08:23:382014 screen_info_ = new_screen_info;
Christopher Cameronbe7ecea2018-02-27 00:47:192015
danakja6c10012018-07-06 14:25:362016 if (layer_tree_view_) {
2017 layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect());
Christopher Camerone9a30c12018-03-07 08:23:382018 // Note carefully that the DSF specified in |new_screen_info| is not the
2019 // DSF used by the compositor during device emulation!
danakja6c10012018-07-06 14:25:362020 layer_tree_view_->SetViewportSizeAndScale(
Fady Samuela863f152018-03-09 16:10:032021 compositor_viewport_pixel_size_,
Fady Samuel4255c182018-05-24 20:42:362022 GetOriginalScreenInfo().device_scale_factor,
Fady Samuel1c1ad3692018-11-06 23:28:402023 local_surface_id_allocation_from_parent_);
Christopher Camerone9a30c12018-03-07 08:23:382024 }
Christopher Cameronbe7ecea2018-02-27 00:47:192025
Christopher Camerone9a30c12018-03-07 08:23:382026 if (orientation_changed)
2027 OnOrientationChange();
Christopher Cameronbe7ecea2018-02-27 00:47:192028
Fady Samuela863f152018-03-09 16:10:032029 if (previous_original_screen_info != GetOriginalScreenInfo()) {
Christopher Camerone9a30c12018-03-07 08:23:382030 for (auto& observer : render_frame_proxies_)
Fady Samuela863f152018-03-09 16:10:032031 observer.OnScreenInfoChanged(GetOriginalScreenInfo());
Christopher Camerone9a30c12018-03-07 08:23:382032
2033 // Notify all embedded BrowserPlugins of the updated ScreenInfo.
2034 for (auto& observer : browser_plugins_)
Fady Samuela863f152018-03-09 16:10:032035 observer.ScreenInfoChanged(GetOriginalScreenInfo());
Christopher Camerone9a30c12018-03-07 08:23:382036 }
2037
2038 if (web_device_scale_factor_changed)
Christopher Cameronbe7ecea2018-02-27 00:47:192039 UpdateWebViewWithDeviceScaleFactor();
oshimad5279032015-12-16 18:22:332040}
2041
danakja2c9d0a92018-07-25 20:01:182042void RenderWidget::SetWindowRectSynchronously(
2043 const gfx::Rect& new_window_rect) {
2044 VisualProperties visual_properties;
2045 visual_properties.screen_info = screen_info_;
2046 visual_properties.new_size = new_window_rect.size();
2047 visual_properties.compositor_viewport_pixel_size = gfx::ScaleToCeiledSize(
2048 new_window_rect.size(), GetWebScreenInfo().device_scale_factor);
2049 visual_properties.visible_viewport_size = new_window_rect.size();
2050 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
2051 visual_properties.display_mode = display_mode_;
Fady Samuel84d8a1f72018-11-08 00:26:172052 visual_properties.local_surface_id_allocation =
2053 local_surface_id_allocation_from_parent_;
W. James MacLean2a90bff2018-11-05 20:52:472054 visual_properties.page_scale_factor = page_scale_factor_from_mainframe_;
danakja2c9d0a92018-07-25 20:01:182055 // We are resizing the window from the renderer, so allocate a new
2056 // viz::LocalSurfaceId to avoid surface invariants violations in tests.
2057 if (layer_tree_view_)
2058 layer_tree_view_->RequestNewLocalSurfaceId();
2059 SynchronizeVisualProperties(visual_properties);
2060
Albert J. Wong3c93c182018-09-27 17:29:432061 widget_screen_rect_ = new_window_rect;
danakja2c9d0a92018-07-25 20:01:182062 window_screen_rect_ = new_window_rect;
danakj65f423b72018-10-10 17:21:202063 if (show_callback_) {
2064 // Tests may call here directly to control the window rect. If
2065 // Show() did not happen yet, the rect is stored to be passed to the
2066 // browser when the RenderWidget requests Show().
danakja2c9d0a92018-07-25 20:01:182067 initial_rect_ = new_window_rect;
danakj65f423b72018-10-10 17:21:202068 }
danakja2c9d0a92018-07-25 20:01:182069}
2070
Vladimir Levin98d76dad2018-04-21 00:21:292071void RenderWidget::UpdateCaptureSequenceNumber(
2072 uint32_t capture_sequence_number) {
2073 if (capture_sequence_number == last_capture_sequence_number_)
2074 return;
2075 last_capture_sequence_number_ = capture_sequence_number;
2076
2077 // Notify observers of the new capture sequence number.
2078 for (auto& observer : render_frame_proxies_)
2079 observer.UpdateCaptureSequenceNumber(capture_sequence_number);
2080 for (auto& observer : browser_plugins_)
2081 observer.UpdateCaptureSequenceNumber(capture_sequence_number);
2082}
2083
[email protected]4873c7d2009-07-16 06:36:282084void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
EhsanK955ba582017-11-30 21:14:402085 if (auto* frame = GetFocusedWebLocalFrameInWidget())
2086 frame->SetTextDirection(direction);
[email protected]07f953332009-03-25 04:31:112087}
2088
Albert J. Wong3c93c182018-09-27 17:29:432089void RenderWidget::OnUpdateScreenRects(const gfx::Rect& widget_screen_rect,
[email protected]80ad8622012-11-07 16:33:032090 const gfx::Rect& window_screen_rect) {
[email protected]b2e4c70132013-10-03 02:07:512091 if (screen_metrics_emulator_) {
Albert J. Wong3c93c182018-09-27 17:29:432092 screen_metrics_emulator_->OnUpdateScreenRects(widget_screen_rect,
mfomitchev2600fd7c2016-02-17 20:53:392093 window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:512094 } else {
Albert J. Wong3c93c182018-09-27 17:29:432095 SetScreenRects(widget_screen_rect, window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:512096 }
Albert J. Wong3c93c182018-09-27 17:29:432097 Send(new WidgetHostMsg_UpdateScreenRects_ACK(routing_id()));
[email protected]80ad8622012-11-07 16:33:032098}
2099
kenrbea731792017-01-13 15:10:482100void RenderWidget::OnSetViewportIntersection(
Ken Buchananb2c9e262018-03-10 16:53:312101 const gfx::Rect& viewport_intersection,
Stefan Zager54e25832018-08-14 22:15:312102 const gfx::Rect& compositor_visible_rect,
2103 bool occluded_or_obscured) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252104 if (auto* frame_widget = GetFrameWidget()) {
danakj6a816592018-09-25 18:30:562105 DCHECK_EQ(widget_type_, WidgetType::kFrame);
Ken Buchananb2c9e262018-03-10 16:53:312106 compositor_visible_rect_ = compositor_visible_rect;
Stefan Zager54e25832018-08-14 22:15:312107 frame_widget->SetRemoteViewportIntersection(viewport_intersection,
2108 occluded_or_obscured);
danakja6c10012018-07-06 14:25:362109 layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect());
kenrbea731792017-01-13 15:10:482110 }
2111}
2112
kenrb04323782017-06-23 01:23:322113void RenderWidget::OnSetIsInert(bool inert) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252114 if (auto* frame_widget = GetFrameWidget()) {
danakj6a816592018-09-25 18:30:562115 DCHECK_EQ(widget_type_, WidgetType::kFrame);
Ehsan Karamadf3ca2a82018-01-20 01:05:252116 frame_widget->SetIsInert(inert);
kenrb04323782017-06-23 01:23:322117 }
2118}
2119
sunxd540a9962018-05-24 22:51:062120void RenderWidget::OnSetInheritedEffectiveTouchAction(
2121 cc::TouchAction touch_action) {
2122 if (auto* frame_widget = GetFrameWidget()) {
danakj6a816592018-09-25 18:30:562123 DCHECK_EQ(widget_type_, WidgetType::kFrame);
sunxd540a9962018-05-24 22:51:062124 frame_widget->SetInheritedEffectiveTouchAction(touch_action);
2125 }
2126}
2127
Ken Buchanan8a319fb2017-11-15 18:37:122128void RenderWidget::OnUpdateRenderThrottlingStatus(bool is_throttled,
2129 bool subtree_throttled) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252130 if (auto* frame_widget = GetFrameWidget()) {
danakj6a816592018-09-25 18:30:562131 DCHECK_EQ(widget_type_, WidgetType::kFrame);
Ehsan Karamadf3ca2a82018-01-20 01:05:252132 frame_widget->UpdateRenderThrottlingStatus(is_throttled, subtree_throttled);
Ken Buchanan8a319fb2017-11-15 18:37:122133 }
2134}
2135
paulmeyer90f6c31d2016-11-12 00:17:592136void RenderWidget::OnDragTargetDragEnter(
2137 const std::vector<DropData::Metadata>& drop_meta_data,
Ella Ge80a52dce2017-11-15 18:01:522138 const gfx::PointF& client_point,
2139 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592140 WebDragOperationsMask ops,
2141 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252142 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2143 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592144 return;
2145
Ehsan Karamadf3ca2a82018-01-20 01:05:252146 WebDragOperation operation = frame_widget->DragTargetDragEnter(
2147 DropMetaDataToWebDragData(drop_meta_data), client_point, screen_point,
2148 ops, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592149
2150 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
2151}
2152
Ella Ge80a52dce2017-11-15 18:01:522153void RenderWidget::OnDragTargetDragOver(const gfx::PointF& client_point,
2154 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592155 WebDragOperationsMask ops,
2156 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252157 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2158 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592159 return;
2160
Ehsan Karamadf3ca2a82018-01-20 01:05:252161 WebDragOperation operation = frame_widget->DragTargetDragOver(
2162 ConvertWindowPointToViewport(client_point), screen_point, ops,
2163 key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592164
2165 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
2166}
2167
Ella Ge80a52dce2017-11-15 18:01:522168void RenderWidget::OnDragTargetDragLeave(const gfx::PointF& client_point,
2169 const gfx::PointF& screen_point) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252170 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2171 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592172 return;
Ehsan Karamadf3ca2a82018-01-20 01:05:252173
2174 frame_widget
Blink Reformat1c4d759e2017-04-09 16:34:542175 ->DragTargetDragLeave(ConvertWindowPointToViewport(client_point),
kenrb07c272802017-02-07 23:48:172176 screen_point);
paulmeyer90f6c31d2016-11-12 00:17:592177}
2178
2179void RenderWidget::OnDragTargetDrop(const DropData& drop_data,
Ella Ge80a52dce2017-11-15 18:01:522180 const gfx::PointF& client_point,
2181 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592182 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252183 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2184 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592185 return;
2186
Ehsan Karamadf3ca2a82018-01-20 01:05:252187 frame_widget->DragTargetDrop(DropDataToWebDragData(drop_data),
2188 ConvertWindowPointToViewport(client_point),
2189 screen_point, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592190}
2191
Ella Ge80a52dce2017-11-15 18:01:522192void RenderWidget::OnDragSourceEnded(const gfx::PointF& client_point,
2193 const gfx::PointF& screen_point,
paulmeyer8fc8ea92016-11-15 05:12:212194 WebDragOperation op) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252195 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2196 if (!frame_widget)
paulmeyer8fc8ea92016-11-15 05:12:212197 return;
2198
Ehsan Karamadf3ca2a82018-01-20 01:05:252199 frame_widget->DragSourceEndedAt(ConvertWindowPointToViewport(client_point),
2200 screen_point, op);
paulmeyer8fc8ea92016-11-15 05:12:212201}
2202
2203void RenderWidget::OnDragSourceSystemDragEnded() {
2204 if (!GetWebWidget())
2205 return;
2206
Blink Reformat1c4d759e2017-04-09 16:34:542207 static_cast<WebFrameWidget*>(GetWebWidget())->DragSourceSystemDragEnded();
paulmeyer8fc8ea92016-11-15 05:12:212208}
2209
Blink Reformat1c4d759e2017-04-09 16:34:542210void RenderWidget::ShowVirtualKeyboardOnElementFocus() {
okaa398f50b2017-03-21 06:30:262211#if defined(OS_CHROMEOS)
2212 // On ChromeOS, virtual keyboard is triggered only when users leave the
2213 // mouse button or the finger and a text input element is focused at that
2214 // time. Focus event itself shouldn't trigger virtual keyboard.
2215 UpdateTextInputState();
2216#else
changwan75e3b2072017-01-16 02:55:002217 ShowVirtualKeyboard();
okaa398f50b2017-03-21 06:30:262218#endif
boliu7b2be2f2016-11-04 04:58:312219
2220// TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
2221// virtual keyboard.
2222#if !defined(OS_ANDROID)
2223 FocusChangeComplete();
2224#endif
[email protected]0d1ebed12013-08-05 22:01:132225}
2226
fsamuel72464894f2015-12-15 06:59:312227ui::TextInputType RenderWidget::GetTextInputType() {
brettw4b461082016-11-19 18:55:162228#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492229 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2230 return plugin->text_input_type();
ekaramad2a46d632016-07-19 13:33:092231#endif
ekaramad5aff1942017-01-06 01:26:352232 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:542233 return ConvertWebTextInputType(controller->TextInputType());
fsamuel72464894f2015-12-15 06:59:312234 return ui::TEXT_INPUT_TYPE_NONE;
2235}
2236
nonafa291792016-08-10 02:36:182237void RenderWidget::UpdateCompositionInfo(bool immediate_request) {
2238 if (!monitor_composition_info_ && !immediate_request)
2239 return; // Do not calculate composition info if not requested.
nonadac0c7a2016-08-01 02:30:592240
nonafa291792016-08-10 02:36:182241 TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo");
2242 gfx::Range range;
2243 std::vector<gfx::Rect> character_bounds;
2244
2245 if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE) {
2246 // Composition information is only available on editable node.
2247 range = gfx::Range::InvalidRange();
2248 } else {
2249 GetCompositionRange(&range);
2250 GetCompositionCharacterBounds(&character_bounds);
2251 }
2252
2253 if (!immediate_request &&
2254 !ShouldUpdateCompositionInfo(range, character_bounds)) {
fsamuel72464894f2015-12-15 06:59:312255 return;
nonafa291792016-08-10 02:36:182256 }
fsamuel72464894f2015-12-15 06:59:312257 composition_character_bounds_ = character_bounds;
2258 composition_range_ = range;
Dave Tapuska04bc5ee92018-04-17 19:03:312259 if (mojom::WidgetInputHandlerHost* host =
2260 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
2261 host->ImeCompositionRangeChanged(composition_range_,
2262 composition_character_bounds_);
Dave Tapuska139a72f2017-09-06 21:57:032263 }
fsamuel72464894f2015-12-15 06:59:312264}
2265
Blink Reformat1c4d759e2017-04-09 16:34:542266void RenderWidget::ConvertViewportToWindow(blink::WebRect* rect) {
danakj4b347212018-07-04 17:55:172267 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:032268 float reverse = 1 / GetOriginalScreenInfo().device_scale_factor;
oshimad5279032015-12-16 18:22:332269 // TODO(oshima): We may need to allow pixel precision here as the the
oshimaf866dab2015-12-05 00:41:542270 // anchor element can be placed at half pixel.
lfg15b235a32016-08-25 17:45:462271 gfx::Rect window_rect =
2272 gfx::ScaleToEnclosedRect(gfx::Rect(*rect), reverse);
2273 rect->x = window_rect.x();
2274 rect->y = window_rect.y();
2275 rect->width = window_rect.width();
2276 rect->height = window_rect.height();
oshimaf866dab2015-12-05 00:41:542277 }
2278}
2279
Blink Reformat1c4d759e2017-04-09 16:34:542280void RenderWidget::ConvertWindowToViewport(blink::WebFloatRect* rect) {
danakj4b347212018-07-04 17:55:172281 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:032282 rect->x *= GetOriginalScreenInfo().device_scale_factor;
2283 rect->y *= GetOriginalScreenInfo().device_scale_factor;
2284 rect->width *= GetOriginalScreenInfo().device_scale_factor;
2285 rect->height *= GetOriginalScreenInfo().device_scale_factor;
oshimaa6985b62016-01-27 08:58:302286 }
2287}
2288
changwan8c342742016-02-26 00:53:392289void RenderWidget::OnRequestTextInputStateUpdate() {
Dave Tapuska9db80842017-07-24 17:24:262290#if defined(OS_ANDROID)
changwan8c342742016-02-26 00:53:392291 DCHECK(!ime_event_guard_);
2292 UpdateSelectionBounds();
changwan75e3b2072017-01-16 02:55:002293 UpdateTextInputStateInternal(false, true /* reply_to_request */);
[email protected]105dffb42013-02-20 03:46:212294#endif
Dave Tapuska9db80842017-07-24 17:24:262295}
[email protected]105dffb42013-02-20 03:46:212296
ekaramadc9b70a72017-03-23 16:14:232297void RenderWidget::OnRequestCompositionUpdates(bool immediate_request,
2298 bool monitor_updates) {
2299 monitor_composition_info_ = monitor_updates;
nonafa291792016-08-10 02:36:182300 if (!immediate_request)
2301 return;
2302 UpdateCompositionInfo(true /* immediate request */);
2303}
2304
[email protected]fcdc5642014-05-09 14:32:242305void RenderWidget::OnOrientationChange() {
Ehsan Karamad655d7b8a2018-01-12 18:38:382306 if (auto* frame_widget = GetFrameWidget()) {
Alex Moshchuk0b409c42017-09-13 02:09:002307 // LocalRoot() might return null for provisional main frames. In this case,
2308 // the frame hasn't committed a navigation and is not swapped into the tree
2309 // yet, so it doesn't make sense to send orientation change events to it.
2310 //
2311 // TODO(https://crbug.com/578349): This check should be cleaned up
2312 // once provisional frames are gone.
Ehsan Karamad655d7b8a2018-01-12 18:38:382313 if (frame_widget->LocalRoot())
2314 frame_widget->LocalRoot()->SendOrientationChangeEvent();
lfg8d649cc2017-04-28 18:04:302315 }
[email protected]fcdc5642014-05-09 14:32:242316}
2317
[email protected]bee16aab2009-08-26 15:55:032318void RenderWidget::SetHidden(bool hidden) {
2319 if (is_hidden_ == hidden)
2320 return;
2321
jdduke8fac9d102014-12-20 02:40:132322 // The status has changed. Tell the RenderThread about it and ensure
2323 // throttled acks are released in case frame production ceases.
[email protected]bee16aab2009-08-26 15:55:032324 is_hidden_ = hidden;
jdduke8fac9d102014-12-20 02:40:132325
Scott Violet1098538e2017-10-05 19:23:332326#if defined(USE_AURA)
Scott Violete46b3352018-09-22 00:37:072327 if (features::IsMultiProcessMash())
Scott Violet1098538e2017-10-05 19:23:332328 RendererWindowTreeClient::Get(routing_id_)->SetVisible(!hidden);
2329#endif
2330
Saman Sami58ed4392018-01-31 20:54:192331 // RenderThreadImpl::current() could be null in tests.
2332 if (RenderThreadImpl::current()) {
2333 if (is_hidden_) {
2334 RenderThreadImpl::current()->WidgetHidden();
2335 first_update_visual_state_after_hidden_ = true;
2336 } else {
2337 RenderThreadImpl::current()->WidgetRestored();
2338 }
Lei Zhang9b359d32017-11-28 00:57:022339 }
alexclarke7fa93942015-10-21 15:37:112340
2341 if (render_widget_scheduling_state_)
2342 render_widget_scheduling_state_->SetHidden(hidden);
danakj1b35e9d2018-11-07 19:09:282343
danakj57f139f2018-11-19 19:23:462344 // When the RenderWidget is frozen, visibility of the compositor is overridden
2345 // to always be hidden to prevent it from using resources that are not needed.
2346 // Unfortunately the main RenderWidget for a RenderView must be marked visible
2347 // even if the RenderView has a proxy main frame (and the RenderWidget is
2348 // frozen), in order for the RenderView to use the visibility signal from the
2349 // RenderWidget. This is bad. But we don't need to show the compositor to
2350 // satisfy that requirement.
2351 if (!is_frozen_)
2352 layer_tree_view_->SetVisible(!is_hidden_);
[email protected]bee16aab2009-08-26 15:55:032353}
2354
[email protected]2b624c562011-10-27 22:58:262355void RenderWidget::DidToggleFullscreen() {
lfg8ff33912016-09-13 20:59:212356 if (!GetWebWidget())
[email protected]2b624c562011-10-27 22:58:262357 return;
2358
mikhail.pozdnyakovf2c902a2015-04-14 08:09:122359 if (is_fullscreen_granted_) {
Blink Reformat1c4d759e2017-04-09 16:34:542360 GetWebWidget()->DidEnterFullscreen();
[email protected]2b624c562011-10-27 22:58:262361 } else {
Blink Reformat1c4d759e2017-04-09 16:34:542362 GetWebWidget()->DidExitFullscreen();
[email protected]2b624c562011-10-27 22:58:262363 }
[email protected]2b624c562011-10-27 22:58:262364}
2365
changwanf2a707b2015-10-30 08:22:162366void RenderWidget::OnImeEventGuardStart(ImeEventGuard* guard) {
2367 if (!ime_event_guard_)
2368 ime_event_guard_ = guard;
[email protected]66fca5bc2013-05-23 06:58:292369}
2370
changwanf2a707b2015-10-30 08:22:162371void RenderWidget::OnImeEventGuardFinish(ImeEventGuard* guard) {
Jeremy Roman0b261f42018-08-28 15:36:012372 if (ime_event_guard_ != guard)
changwanf2a707b2015-10-30 08:22:162373 return;
changwanf2a707b2015-10-30 08:22:162374 ime_event_guard_ = nullptr;
2375
[email protected]66fca5bc2013-05-23 06:58:292376 // While handling an ime event, text input state and selection bounds updates
2377 // are ignored. These must explicitly be updated once finished handling the
2378 // ime event.
2379 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:472380#if defined(OS_ANDROID)
changwan75e3b2072017-01-16 02:55:002381 if (guard->show_virtual_keyboard())
2382 ShowVirtualKeyboard();
2383 else
2384 UpdateTextInputState();
[email protected]cb9e2632013-06-18 11:26:472385#endif
[email protected]66fca5bc2013-05-23 06:58:292386}
2387
[email protected]7c8873e2013-02-05 08:03:012388void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
brettw4b461082016-11-19 18:55:162389#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492390 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
ekaramad2a46d632016-07-19 13:33:092391 // TODO(kinaba) http://crbug.com/101101
2392 // Current Pepper IME API does not handle selection bounds. So we simply
2393 // use the caret position as an empty range for now. It will be updated
2394 // after Pepper API equips features related to surrounding text retrieval.
EhsanK22d482e2017-08-10 17:29:492395 blink::WebRect caret(plugin->GetCaretBounds());
Blink Reformat1c4d759e2017-04-09 16:34:542396 ConvertViewportToWindow(&caret);
ekaramad2a46d632016-07-19 13:33:092397 *focus = caret;
2398 *anchor = caret;
2399 return;
2400 }
2401#endif
[email protected]7c8873e2013-02-05 08:03:012402 WebRect focus_webrect;
2403 WebRect anchor_webrect;
Blink Reformat1c4d759e2017-04-09 16:34:542404 GetWebWidget()->SelectionBounds(focus_webrect, anchor_webrect);
2405 ConvertViewportToWindow(&focus_webrect);
2406 ConvertViewportToWindow(&anchor_webrect);
oshima33ec97cd2015-12-14 19:40:242407 *focus = focus_webrect;
2408 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:322409}
2410
[email protected]e99ef6f2011-10-16 01:13:002411void RenderWidget::UpdateSelectionBounds() {
jdduke1aebad8e2015-07-22 23:25:082412 TRACE_EVENT0("renderer", "RenderWidget::UpdateSelectionBounds");
lfg8ff33912016-09-13 20:59:212413 if (!GetWebWidget())
[email protected]e99ef6f2011-10-16 01:13:002414 return;
changwanf2a707b2015-10-30 08:22:162415 if (ime_event_guard_)
[email protected]66fca5bc2013-05-23 06:58:292416 return;
[email protected]e99ef6f2011-10-16 01:13:002417
mohsenb0eeba72015-08-09 06:20:082418#if defined(USE_AURA)
2419 // TODO(mohsen): For now, always send explicit selection IPC notifications for
2420 // Aura beucause composited selection updates are not working for webview tags
2421 // which regresses IME inside webview. Remove this when composited selection
2422 // updates are fixed for webviews. See, http://crbug.com/510568.
2423 bool send_ipc = true;
2424#else
jddukeacf809e2014-09-23 20:38:382425 // With composited selection updates, the selection bounds will be reported
2426 // directly by the compositor, in which case explicit IPC selection
2427 // notifications should be suppressed.
mohsenb0eeba72015-08-09 06:20:082428 bool send_ipc =
Blink Reformat1c4d759e2017-04-09 16:34:542429 !blink::WebRuntimeFeatures::IsCompositedSelectionUpdateEnabled();
mohsenb0eeba72015-08-09 06:20:082430#endif
2431 if (send_ipc) {
Albert J. Wong3c93c182018-09-27 17:29:432432 WidgetHostMsg_SelectionBounds_Params params;
EhsanK955ba582017-11-30 21:14:402433 params.is_anchor_first = false;
jddukeacf809e2014-09-23 20:38:382434 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
2435 if (selection_anchor_rect_ != params.anchor_rect ||
2436 selection_focus_rect_ != params.focus_rect) {
2437 selection_anchor_rect_ = params.anchor_rect;
2438 selection_focus_rect_ = params.focus_rect;
EhsanK955ba582017-11-30 21:14:402439 if (auto* focused_frame = GetFocusedWebLocalFrameInWidget()) {
2440 focused_frame->SelectionTextDirection(params.focus_dir,
2441 params.anchor_dir);
2442 params.is_anchor_first = focused_frame->IsSelectionAnchorFirst();
2443 }
Albert J. Wong3c93c182018-09-27 17:29:432444 Send(new WidgetHostMsg_SelectionBoundsChanged(routing_id_, params));
jddukeacf809e2014-09-23 20:38:382445 }
[email protected]58b48a0d2012-06-13 07:01:352446 }
jddukeacf809e2014-09-23 20:38:382447
nonafa291792016-08-10 02:36:182448 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]e99ef6f2011-10-16 01:13:002449}
2450
lfgb00fcad2016-07-14 14:16:332451void RenderWidget::DidAutoResize(const gfx::Size& new_size) {
2452 WebRect new_size_in_window(0, 0, new_size.width(), new_size.height());
Blink Reformat1c4d759e2017-04-09 16:34:542453 ConvertViewportToWindow(&new_size_in_window);
lfgb00fcad2016-07-14 14:16:332454 if (size_.width() != new_size_in_window.width ||
2455 size_.height() != new_size_in_window.height) {
2456 size_ = gfx::Size(new_size_in_window.width, new_size_in_window.height);
2457
2458 if (resizing_mode_selector_->is_synchronous_mode()) {
Blink Reformat1c4d759e2017-04-09 16:34:542459 gfx::Rect new_pos(WindowRect().x, WindowRect().y, size_.width(),
2460 size_.height());
Albert J. Wong3c93c182018-09-27 17:29:432461 widget_screen_rect_ = new_pos;
lfgb00fcad2016-07-14 14:16:332462 window_screen_rect_ = new_pos;
2463 }
2464
Christopher Camerone9a30c12018-03-07 08:23:382465 // TODO(ccameron): Note that this destroys any information differentiating
Christopher Cameronaad15a0d2018-03-09 03:47:332466 // |size_| from |compositor_viewport_pixel_size_|. Also note that the
2467 // calculation of |new_compositor_viewport_pixel_size| does not appear to
2468 // take into account device emulation.
danakja6c10012018-07-06 14:25:362469 if (layer_tree_view_)
2470 layer_tree_view_->RequestNewLocalSurfaceId();
Christopher Cameronaad15a0d2018-03-09 03:47:332471 gfx::Size new_compositor_viewport_pixel_size =
Fady Samuela863f152018-03-09 16:10:032472 gfx::ScaleToCeiledSize(size_, GetWebScreenInfo().device_scale_factor);
Fady Samuel1c1ad3692018-11-06 23:28:402473 UpdateSurfaceAndScreenInfo(local_surface_id_allocation_from_parent_,
2474 new_compositor_viewport_pixel_size,
2475 screen_info_);
lfgb00fcad2016-07-14 14:16:332476 }
2477}
2478
[email protected]58b48a0d2012-06-13 07:01:352479void RenderWidget::GetCompositionCharacterBounds(
2480 std::vector<gfx::Rect>* bounds) {
2481 DCHECK(bounds);
2482 bounds->clear();
ekaramad2a46d632016-07-19 13:33:092483
brettw4b461082016-11-19 18:55:162484#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492485 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092486 return;
2487#endif
2488
Ehsan Karamad4975af6d2018-02-09 16:58:162489 blink::WebInputMethodController* controller = GetInputMethodController();
2490 if (!controller)
ekaramad2a46d632016-07-19 13:33:092491 return;
2492 blink::WebVector<blink::WebRect> bounds_from_blink;
Ehsan Karamad4975af6d2018-02-09 16:58:162493 if (!controller->GetCompositionCharacterBounds(bounds_from_blink))
ekaramad2a46d632016-07-19 13:33:092494 return;
2495
2496 for (size_t i = 0; i < bounds_from_blink.size(); ++i) {
Blink Reformat1c4d759e2017-04-09 16:34:542497 ConvertViewportToWindow(&bounds_from_blink[i]);
ekaramad2a46d632016-07-19 13:33:092498 bounds->push_back(bounds_from_blink[i]);
2499 }
[email protected]58b48a0d2012-06-13 07:01:352500}
2501
[email protected]db4fc1e2013-09-06 20:01:512502void RenderWidget::GetCompositionRange(gfx::Range* range) {
brettw4b461082016-11-19 18:55:162503#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492504 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092505 return;
2506#endif
EhsanKcdee7b72017-11-08 21:30:092507 blink::WebInputMethodController* controller = GetInputMethodController();
2508 WebRange web_range = controller ? controller->CompositionRange() : WebRange();
Blink Reformat1c4d759e2017-04-09 16:34:542509 if (web_range.IsNull()) {
nona2363a3d2016-11-09 03:26:212510 *range = gfx::Range::InvalidRange();
2511 return;
[email protected]88dbe32f2013-06-20 23:31:362512 }
Blink Reformat1c4d759e2017-04-09 16:34:542513 range->set_start(web_range.StartOffset());
2514 range->set_end(web_range.EndOffset());
[email protected]88dbe32f2013-06-20 23:31:362515}
2516
[email protected]501ea13d2013-07-09 17:03:292517bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:512518 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:292519 const std::vector<gfx::Rect>& bounds) {
changwan2418e1b2016-12-12 12:43:082520 if (!range.IsValid())
2521 return false;
[email protected]501ea13d2013-07-09 17:03:292522 if (composition_range_ != range)
2523 return true;
2524 if (bounds.size() != composition_character_bounds_.size())
2525 return true;
2526 for (size_t i = 0; i < bounds.size(); ++i) {
2527 if (bounds[i] != composition_character_bounds_[i])
2528 return true;
2529 }
2530 return false;
2531}
[email protected]501ea13d2013-07-09 17:03:292532
[email protected]ad26ef42011-06-17 07:59:452533bool RenderWidget::CanComposeInline() {
brettw4b461082016-11-19 18:55:162534#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492535 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2536 return plugin->IsPluginAcceptingCompositionEvents();
ekaramad2a46d632016-07-19 13:33:092537#endif
[email protected]ad26ef42011-06-17 07:59:452538 return true;
[email protected]56ea1a62011-05-30 07:05:572539}
2540
Blink Reformat1c4d759e2017-04-09 16:34:542541void RenderWidget::DidHandleGestureEvent(const WebGestureEvent& event,
2542 bool event_cancelled) {
danakja2c9d0a92018-07-25 20:01:182543 if (event_cancelled) {
2544 // The |owner_delegate_| doesn't need to hear about cancelled events.
[email protected]c68c3e4e2013-01-24 00:36:562545 return;
danakja2c9d0a92018-07-25 20:01:182546 }
2547
2548#if defined(OS_ANDROID) || defined(USE_AURA)
Blink Reformat1c4d759e2017-04-09 16:34:542549 if (event.GetType() == WebInputEvent::kGestureTap) {
changwan75e3b2072017-01-16 02:55:002550 ShowVirtualKeyboard();
Blink Reformat1c4d759e2017-04-09 16:34:542551 } else if (event.GetType() == WebInputEvent::kGestureLongPress) {
lfg8ff33912016-09-13 20:59:212552 DCHECK(GetWebWidget());
ekaramad5aff1942017-01-06 01:26:352553 blink::WebInputMethodController* controller = GetInputMethodController();
Blink Reformat1c4d759e2017-04-09 16:34:542554 if (!controller || controller->TextInputInfo().value.IsEmpty())
changwan75e3b2072017-01-16 02:55:002555 UpdateTextInputState();
[email protected]07c70d22014-08-21 08:33:462556 else
changwan75e3b2072017-01-16 02:55:002557 ShowVirtualKeyboard();
[email protected]c68c3e4e2013-01-24 00:36:562558 }
ekaramada110f642016-12-21 19:47:282559// TODO(ananta): Piggyback off existing IPCs to communicate this information,
2560// crbug/420130.
2561#if defined(OS_WIN)
danakja2c9d0a92018-07-25 20:01:182562 if (event.GetType() == blink::WebGestureEvent::kGestureTap) {
2563 // TODO(estade): hit test the event against focused node to make sure
2564 // the tap actually hit the focused node.
2565 blink::WebInputMethodController* controller = GetInputMethodController();
2566 blink::WebTextInputType text_input_type =
2567 controller ? controller->TextInputType() : blink::kWebTextInputTypeNone;
ekaramada110f642016-12-21 19:47:282568
Albert J. Wong3c93c182018-09-27 17:29:432569 Send(new WidgetHostMsg_FocusedNodeTouched(
danakja2c9d0a92018-07-25 20:01:182570 routing_id_, text_input_type != blink::kWebTextInputTypeNone));
2571 }
ekaramada110f642016-12-21 19:47:282572#endif
[email protected]c68c3e4e2013-01-24 00:36:562573#endif
danakja2c9d0a92018-07-25 20:01:182574
2575 // The |owner_delegate_| gets to respond to handling gestures last.
2576 if (owner_delegate_)
2577 owner_delegate_->DidHandleGestureEventForWidget(event);
[email protected]c68c3e4e2013-01-24 00:36:562578}
2579
Blink Reformat1c4d759e2017-04-09 16:34:542580void RenderWidget::DidOverscroll(
bokane53a10f2016-04-13 23:48:312581 const blink::WebFloatSize& overscrollDelta,
2582 const blink::WebFloatSize& accumulatedOverscroll,
sataya.m582c9ce2015-06-09 08:03:422583 const blink::WebFloatPoint& position,
sunyunjiabbea8a92017-08-31 11:18:542584 const blink::WebFloatSize& velocity,
danakje819b622018-05-01 20:27:142585 const cc::OverscrollBehavior& behavior) {
bokan731ec382016-04-07 03:16:482586#if defined(OS_MACOSX)
2587 // On OSX the user can disable the elastic overscroll effect. If that's the
2588 // case, don't forward the overscroll notification.
2589 DCHECK(compositor_deps());
2590 if (!compositor_deps()->IsElasticOverscrollEnabled())
2591 return;
2592#endif
bokane53a10f2016-04-13 23:48:312593 input_handler_->DidOverscrollFromBlink(overscrollDelta, accumulatedOverscroll,
sunyunjiabbea8a92017-08-31 11:18:542594 position, velocity, behavior);
sataya.m582c9ce2015-06-09 08:03:422595}
2596
danakj4b347212018-07-04 17:55:172597// static
2598cc::LayerTreeSettings RenderWidget::GenerateLayerTreeSettings(
2599 CompositorDependencies* compositor_deps,
2600 bool is_for_subframe,
2601 const gfx::Size& initial_screen_size,
2602 float initial_device_scale_factor) {
2603 const bool is_threaded =
2604 !!compositor_deps->GetCompositorImplThreadTaskRunner();
2605
2606 const base::CommandLine& cmd = *base::CommandLine::ForCurrentProcess();
2607 cc::LayerTreeSettings settings;
2608
2609 settings.resource_settings.use_r16_texture =
2610 base::FeatureList::IsEnabled(media::kUseR16Texture);
2611
2612 settings.commit_to_active_tree = !is_threaded;
2613 settings.is_layer_tree_for_subframe = is_for_subframe;
2614
2615 // For web contents, layer transforms should scale up the contents of layers
2616 // to keep content always crisp when possible.
2617 settings.layer_transforms_should_scale_layer_contents = true;
2618
2619 settings.main_frame_before_activation_enabled =
2620 cmd.HasSwitch(cc::switches::kEnableMainFrameBeforeActivation);
2621
2622 // Checkerimaging is not supported for synchronous single-threaded mode, which
2623 // is what the renderer uses if its not threaded.
2624 settings.enable_checker_imaging =
2625 !cmd.HasSwitch(cc::switches::kDisableCheckerImaging) && is_threaded;
2626
2627#if defined(OS_ANDROID)
2628 // We can use a more aggressive limit on Android since decodes tend to take
2629 // longer on these devices.
2630 settings.min_image_bytes_to_checker = 512 * 1024; // 512kB
2631
2632 // Re-rasterization of checker-imaged content with software raster can be too
2633 // costly on Android.
2634 settings.only_checker_images_with_gpu_raster = true;
2635#endif
2636
2637 auto switch_value_as_int = [](const base::CommandLine& command_line,
2638 const std::string& switch_string, int min_value,
2639 int max_value, int* result) {
2640 std::string string_value = command_line.GetSwitchValueASCII(switch_string);
2641 int int_value;
2642 if (base::StringToInt(string_value, &int_value) && int_value >= min_value &&
2643 int_value <= max_value) {
2644 *result = int_value;
2645 return true;
2646 } else {
2647 LOG(WARNING) << "Failed to parse switch " << switch_string << ": "
2648 << string_value;
2649 return false;
2650 }
2651 };
2652
2653 int default_tile_size = 256;
2654#if defined(OS_ANDROID)
2655 const gfx::Size screen_size =
2656 gfx::ScaleToFlooredSize(initial_screen_size, initial_device_scale_factor);
2657 int display_width = screen_size.width();
2658 int display_height = screen_size.height();
2659 int numTiles = (display_width * display_height) / (256 * 256);
2660 if (numTiles > 16)
2661 default_tile_size = 384;
2662 if (numTiles >= 40)
2663 default_tile_size = 512;
2664
2665 // Adjust for some resolutions that barely straddle an extra
2666 // tile when in portrait mode. This helps worst case scroll/raster
2667 // by not needing a full extra tile for each row.
2668 constexpr int tolerance = 10; // To avoid rounding errors.
2669 int portrait_width = std::min(display_width, display_height);
2670 if (default_tile_size == 256 && std::abs(portrait_width - 768) < tolerance)
2671 default_tile_size += 32;
2672 if (default_tile_size == 384 && std::abs(portrait_width - 1200) < tolerance)
2673 default_tile_size += 32;
2674#elif defined(OS_CHROMEOS) || defined(OS_MACOSX)
2675 // Use 512 for high DPI (dsf=2.0f) devices.
2676 if (initial_device_scale_factor >= 2.0f)
2677 default_tile_size = 512;
2678#endif
2679
2680 // TODO(danakj): This should not be a setting O_O; it should change when the
2681 // device scale factor on LayerTreeHost changes.
2682 settings.default_tile_size = gfx::Size(default_tile_size, default_tile_size);
2683 if (cmd.HasSwitch(switches::kDefaultTileWidth)) {
2684 int tile_width = 0;
2685 switch_value_as_int(cmd, switches::kDefaultTileWidth, 1,
2686 std::numeric_limits<int>::max(), &tile_width);
2687 settings.default_tile_size.set_width(tile_width);
2688 }
2689 if (cmd.HasSwitch(switches::kDefaultTileHeight)) {
2690 int tile_height = 0;
2691 switch_value_as_int(cmd, switches::kDefaultTileHeight, 1,
2692 std::numeric_limits<int>::max(), &tile_height);
2693 settings.default_tile_size.set_height(tile_height);
2694 }
2695
2696 int max_untiled_layer_width = settings.max_untiled_layer_size.width();
2697 if (cmd.HasSwitch(switches::kMaxUntiledLayerWidth)) {
2698 switch_value_as_int(cmd, switches::kMaxUntiledLayerWidth, 1,
2699 std::numeric_limits<int>::max(),
2700 &max_untiled_layer_width);
2701 }
2702 int max_untiled_layer_height = settings.max_untiled_layer_size.height();
2703 if (cmd.HasSwitch(switches::kMaxUntiledLayerHeight)) {
2704 switch_value_as_int(cmd, switches::kMaxUntiledLayerHeight, 1,
2705 std::numeric_limits<int>::max(),
2706 &max_untiled_layer_height);
2707 }
2708
2709 settings.max_untiled_layer_size =
2710 gfx::Size(max_untiled_layer_width, max_untiled_layer_height);
2711
2712 settings.gpu_rasterization_msaa_sample_count =
2713 compositor_deps->GetGpuRasterizationMSAASampleCount();
2714 settings.gpu_rasterization_forced =
2715 compositor_deps->IsGpuRasterizationForced();
2716
2717 settings.can_use_lcd_text = compositor_deps->IsLcdTextEnabled();
2718 settings.use_zero_copy = compositor_deps->IsZeroCopyEnabled();
2719 settings.use_partial_raster = compositor_deps->IsPartialRasterEnabled();
2720 settings.enable_elastic_overscroll =
2721 compositor_deps->IsElasticOverscrollEnabled();
2722 settings.resource_settings.use_gpu_memory_buffer_resources =
2723 compositor_deps->IsGpuMemoryBufferCompositorResourcesEnabled();
2724 settings.use_painted_device_scale_factor =
2725 compositor_deps->IsUseZoomForDSFEnabled();
2726
2727 // Build LayerTreeSettings from command line args.
2728 if (cmd.HasSwitch(cc::switches::kBrowserControlsShowThreshold)) {
2729 std::string top_threshold_str =
2730 cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsShowThreshold);
2731 double show_threshold;
2732 if (base::StringToDouble(top_threshold_str, &show_threshold) &&
2733 show_threshold >= 0.f && show_threshold <= 1.f)
2734 settings.top_controls_show_threshold = show_threshold;
2735 }
2736
2737 if (cmd.HasSwitch(cc::switches::kBrowserControlsHideThreshold)) {
2738 std::string top_threshold_str =
2739 cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsHideThreshold);
2740 double hide_threshold;
2741 if (base::StringToDouble(top_threshold_str, &hide_threshold) &&
2742 hide_threshold >= 0.f && hide_threshold <= 1.f)
2743 settings.top_controls_hide_threshold = hide_threshold;
2744 }
2745
Philip Rogersc55ab6a2018-12-05 17:29:192746 // Blink sends cc a layer list and property trees when either
2747 // BlinkGenPropertyTrees or CompositeAfterPaint are enabled.
Philip Rogersfc2f1162018-10-17 18:28:312748 settings.use_layer_lists =
2749 blink::WebRuntimeFeatures::IsBlinkGenPropertyTreesEnabled() ||
Philip Rogersc55ab6a2018-12-05 17:29:192750 blink::WebRuntimeFeatures::IsCompositeAfterPaintEnabled();
danakj4b347212018-07-04 17:55:172751
David Bokan163b6a72018-10-25 22:03:492752 // Blink currently doesn't support setting fractional scroll offsets so CC
2753 // must send integer values. We plan to eventually make Blink use fractional
2754 // offsets internally: https://crbug.com/414283.
2755 settings.commit_fractional_scroll_deltas =
2756 blink::WebRuntimeFeatures::IsFractionalScrollOffsetsEnabled();
2757
danakj4b347212018-07-04 17:55:172758 // The means the renderer compositor has 2 possible modes:
2759 // - Threaded compositing with a scheduler.
Kent Tamura21d1de62018-12-10 04:45:202760 // - Single threaded compositing without a scheduler (for web tests only).
2761 // Using the scheduler in web tests introduces additional composite steps
danakj4b347212018-07-04 17:55:172762 // that create flakiness.
2763 settings.single_thread_proxy_scheduler = false;
2764
2765 // These flags should be mirrored by UI versions in ui/compositor/.
2766 if (cmd.HasSwitch(cc::switches::kShowCompositedLayerBorders))
2767 settings.initial_debug_state.show_debug_borders.set();
2768 settings.initial_debug_state.show_layer_animation_bounds_rects =
2769 cmd.HasSwitch(cc::switches::kShowLayerAnimationBounds);
2770 settings.initial_debug_state.show_paint_rects =
2771 cmd.HasSwitch(switches::kShowPaintRects);
2772 settings.initial_debug_state.show_property_changed_rects =
2773 cmd.HasSwitch(cc::switches::kShowPropertyChangedRects);
2774 settings.initial_debug_state.show_surface_damage_rects =
2775 cmd.HasSwitch(cc::switches::kShowSurfaceDamageRects);
2776 settings.initial_debug_state.show_screen_space_rects =
2777 cmd.HasSwitch(cc::switches::kShowScreenSpaceRects);
2778
2779 settings.initial_debug_state.SetRecordRenderingStats(
2780 cmd.HasSwitch(cc::switches::kEnableGpuBenchmarking));
2781 settings.enable_surface_synchronization =
2782 features::IsSurfaceSynchronizationEnabled();
2783 settings.build_hit_test_data = features::IsVizHitTestingSurfaceLayerEnabled();
2784
2785 if (cmd.HasSwitch(cc::switches::kSlowDownRasterScaleFactor)) {
2786 const int kMinSlowDownScaleFactor = 0;
2787 const int kMaxSlowDownScaleFactor = INT_MAX;
2788 switch_value_as_int(
2789 cmd, cc::switches::kSlowDownRasterScaleFactor, kMinSlowDownScaleFactor,
2790 kMaxSlowDownScaleFactor,
2791 &settings.initial_debug_state.slow_down_raster_scale_factor);
2792 }
2793
2794 // This is default overlay scrollbar settings for Android and DevTools mobile
2795 // emulator. Aura Overlay Scrollbar will override below.
2796 settings.scrollbar_animator = cc::LayerTreeSettings::ANDROID_OVERLAY;
2797 settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
2798 settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(300);
2799 settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(300);
2800
2801#if defined(OS_ANDROID)
2802 bool using_synchronous_compositor =
2803 compositor_deps->UsingSynchronousCompositing();
2804 bool using_low_memory_policy = base::SysInfo::IsLowEndDevice();
2805
2806 settings.use_stream_video_draw_quad = true;
2807 settings.using_synchronous_renderer_compositor = using_synchronous_compositor;
2808 if (using_synchronous_compositor) {
2809 // Android WebView uses system scrollbars, so make ours invisible.
2810 // http://crbug.com/677348: This can't be done using hide_scrollbars
2811 // setting because supporting -webkit custom scrollbars is still desired
2812 // on sublayers.
2813 settings.scrollbar_animator = cc::LayerTreeSettings::NO_ANIMATOR;
2814 settings.solid_color_scrollbar_color = SK_ColorTRANSPARENT;
2815
2816 settings.enable_early_damage_check =
2817 cmd.HasSwitch(cc::switches::kCheckDamageEarly);
2818 }
2819 // Android WebView handles root layer flings itself.
2820 settings.ignore_root_layer_flings = using_synchronous_compositor;
2821 // Memory policy on Android WebView does not depend on whether device is
2822 // low end, so always use default policy.
2823 if (using_low_memory_policy && !using_synchronous_compositor) {
2824 // On low-end we want to be very carefull about killing other
2825 // apps. So initially we use 50% more memory to avoid flickering
2826 // or raster-on-demand.
2827 settings.max_memory_for_prepaint_percentage = 67;
2828 } else {
2829 // On other devices we have increased memory excessively to avoid
2830 // raster-on-demand already, so now we reserve 50% _only_ to avoid
2831 // raster-on-demand, and use 50% of the memory otherwise.
2832 settings.max_memory_for_prepaint_percentage = 50;
2833 }
2834
2835 // TODO(danakj): Only do this on low end devices.
2836 settings.create_low_res_tiling = true;
2837
2838#else // defined(OS_ANDROID)
2839 bool using_synchronous_compositor = false; // Only for Android WebView.
2840 // On desktop, we never use the low memory policy unless we are simulating
2841 // low-end mode via a switch.
2842 bool using_low_memory_policy =
2843 cmd.HasSwitch(switches::kEnableLowEndDeviceMode);
2844
2845 if (ui::IsOverlayScrollbarEnabled()) {
2846 settings.scrollbar_animator = cc::LayerTreeSettings::AURA_OVERLAY;
2847 settings.scrollbar_fade_delay = ui::kOverlayScrollbarFadeDelay;
2848 settings.scrollbar_fade_duration = ui::kOverlayScrollbarFadeDuration;
2849 settings.scrollbar_thinning_duration =
2850 ui::kOverlayScrollbarThinningDuration;
2851 settings.scrollbar_flash_after_any_scroll_update =
2852 ui::OverlayScrollbarFlashAfterAnyScrollUpdate();
2853 settings.scrollbar_flash_when_mouse_enter =
2854 ui::OverlayScrollbarFlashWhenMouseEnter();
2855 }
2856
2857 // On desktop, if there's over 4GB of memory on the machine, increase the
2858 // working set size to 256MB for both gpu and software.
2859 const int kImageDecodeMemoryThresholdMB = 4 * 1024;
2860 if (base::SysInfo::AmountOfPhysicalMemoryMB() >=
2861 kImageDecodeMemoryThresholdMB) {
2862 settings.decoded_image_working_set_budget_bytes = 256 * 1024 * 1024;
2863 } else {
2864 // This is the default, but recorded here as well.
2865 settings.decoded_image_working_set_budget_bytes = 128 * 1024 * 1024;
2866 }
2867#endif // defined(OS_ANDROID)
2868
2869 if (using_low_memory_policy) {
2870 // RGBA_4444 textures are only enabled:
2871 // - If the user hasn't explicitly disabled them
2872 // - If system ram is <= 512MB (1GB devices are sometimes low-end).
2873 // - If we are not running in a WebView, where 4444 isn't supported.
2874 if (!cmd.HasSwitch(switches::kDisableRGBA4444Textures) &&
2875 base::SysInfo::AmountOfPhysicalMemoryMB() <= 512 &&
2876 !using_synchronous_compositor) {
2877 settings.use_rgba_4444 = viz::RGBA_4444;
2878
2879 // If we are going to unpremultiply and dither these tiles, we need to
2880 // allocate an additional RGBA_8888 intermediate for each tile
2881 // rasterization when rastering to RGBA_4444 to allow for dithering.
2882 // Setting a reasonable sized max tile size allows this intermediate to
2883 // be consistently reused.
2884 if (base::FeatureList::IsEnabled(
2885 kUnpremultiplyAndDitherLowBitDepthTiles)) {
2886 settings.max_gpu_raster_tile_size = gfx::Size(512, 256);
2887 settings.unpremultiply_and_dither_low_bit_depth_tiles = true;
2888 }
2889 }
2890 }
2891
2892 if (cmd.HasSwitch(switches::kEnableLowResTiling))
2893 settings.create_low_res_tiling = true;
2894 if (cmd.HasSwitch(switches::kDisableLowResTiling))
2895 settings.create_low_res_tiling = false;
2896
2897 if (cmd.HasSwitch(switches::kEnableRGBA4444Textures) &&
2898 !cmd.HasSwitch(switches::kDisableRGBA4444Textures)) {
2899 settings.use_rgba_4444 = true;
2900 }
2901
2902 settings.max_staging_buffer_usage_in_bytes = 32 * 1024 * 1024; // 32MB
2903 // Use 1/4th of staging buffers on low-end devices.
2904 if (base::SysInfo::IsLowEndDevice())
2905 settings.max_staging_buffer_usage_in_bytes /= 4;
2906
2907 cc::ManagedMemoryPolicy defaults = settings.memory_policy;
2908 settings.memory_policy = GetGpuMemoryPolicy(defaults, initial_screen_size,
2909 initial_device_scale_factor);
2910
2911 settings.disallow_non_exact_resource_reuse =
2912 cmd.HasSwitch(switches::kDisallowNonExactResourceReuse);
2913#if defined(OS_ANDROID)
2914 // TODO(crbug.com/746931): This feature appears to be causing visual
2915 // corruption on certain android devices. Will investigate and re-enable.
2916 settings.disallow_non_exact_resource_reuse = true;
2917#endif
2918
2919 if (cmd.HasSwitch(switches::kRunAllCompositorStagesBeforeDraw)) {
2920 settings.wait_for_all_pipeline_stages_before_draw = true;
2921 settings.enable_latency_recovery = false;
2922 }
2923
2924 settings.enable_image_animation_resync =
2925 !cmd.HasSwitch(switches::kDisableImageAnimationResync);
2926
2927 settings.always_request_presentation_time =
2928 cmd.HasSwitch(cc::switches::kAlwaysRequestPresentationTime);
Karolina Soltys4d60b402018-10-01 19:28:202929
2930 settings.send_compositor_frame_ack = false;
2931
danakj4b347212018-07-04 17:55:172932 return settings;
2933}
2934
2935// static
2936cc::ManagedMemoryPolicy RenderWidget::GetGpuMemoryPolicy(
2937 const cc::ManagedMemoryPolicy& default_policy,
2938 const gfx::Size& initial_screen_size,
2939 float initial_device_scale_factor) {
2940 cc::ManagedMemoryPolicy actual = default_policy;
2941 actual.bytes_limit_when_visible = 0;
2942
2943 // If the value was overridden on the command line, use the specified value.
2944 static bool client_hard_limit_bytes_overridden =
2945 base::CommandLine::ForCurrentProcess()->HasSwitch(
2946 switches::kForceGpuMemAvailableMb);
2947 if (client_hard_limit_bytes_overridden) {
2948 if (base::StringToSizeT(
2949 base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
2950 switches::kForceGpuMemAvailableMb),
2951 &actual.bytes_limit_when_visible))
2952 actual.bytes_limit_when_visible *= 1024 * 1024;
2953 return actual;
2954 }
2955
2956#if defined(OS_ANDROID)
2957 // We can't query available GPU memory from the system on Android.
2958 // Physical memory is also mis-reported sometimes (eg. Nexus 10 reports
2959 // 1262MB when it actually has 2GB, while Razr M has 1GB but only reports
2960 // 128MB java heap size). First we estimate physical memory using both.
2961 size_t dalvik_mb = base::SysInfo::DalvikHeapSizeMB();
2962 size_t physical_mb = base::SysInfo::AmountOfPhysicalMemoryMB();
2963 size_t physical_memory_mb = 0;
2964 if (base::SysInfo::IsLowEndDevice()) {
2965 // TODO(crbug.com/742534): The code below appears to no longer work.
2966 // |dalvik_mb| no longer follows the expected heuristic pattern, causing us
2967 // to over-estimate memory on low-end devices. This entire section probably
2968 // needs to be re-written, but for now we can address the low-end Android
2969 // issues by ignoring |dalvik_mb|.
2970 physical_memory_mb = physical_mb;
2971 } else if (dalvik_mb >= 256) {
2972 physical_memory_mb = dalvik_mb * 4;
2973 } else {
2974 physical_memory_mb = std::max(dalvik_mb * 4, (physical_mb * 4) / 3);
2975 }
2976
2977 // Now we take a default of 1/8th of memory on high-memory devices,
2978 // and gradually scale that back for low-memory devices (to be nicer
2979 // to other apps so they don't get killed). Examples:
2980 // Nexus 4/10(2GB) 256MB (normally 128MB)
2981 // Droid Razr M(1GB) 114MB (normally 57MB)
2982 // Galaxy Nexus(1GB) 100MB (normally 50MB)
2983 // Xoom(1GB) 100MB (normally 50MB)
2984 // Nexus S(low-end) 8MB (normally 8MB)
2985 // Note that the compositor now uses only some of this memory for
2986 // pre-painting and uses the rest only for 'emergencies'.
2987 if (actual.bytes_limit_when_visible == 0) {
2988 // NOTE: Non-low-end devices use only 50% of these limits,
2989 // except during 'emergencies' where 100% can be used.
2990 if (physical_memory_mb >= 1536)
2991 actual.bytes_limit_when_visible = physical_memory_mb / 8; // >192MB
2992 else if (physical_memory_mb >= 1152)
2993 actual.bytes_limit_when_visible = physical_memory_mb / 8; // >144MB
2994 else if (physical_memory_mb >= 768)
2995 actual.bytes_limit_when_visible = physical_memory_mb / 10; // >76MB
2996 else if (physical_memory_mb >= 513)
2997 actual.bytes_limit_when_visible = physical_memory_mb / 12; // <64MB
2998 else
2999 // Devices with this little RAM have very little headroom so we hardcode
3000 // the limit rather than relying on the heuristics above. (They also use
3001 // 4444 textures so we can use a lower limit.)
3002 actual.bytes_limit_when_visible = 8;
3003
3004 actual.bytes_limit_when_visible =
3005 actual.bytes_limit_when_visible * 1024 * 1024;
3006 // Clamp the observed value to a specific range on Android.
3007 actual.bytes_limit_when_visible = std::max(
3008 actual.bytes_limit_when_visible, static_cast<size_t>(8 * 1024 * 1024));
3009 actual.bytes_limit_when_visible =
3010 std::min(actual.bytes_limit_when_visible,
3011 static_cast<size_t>(256 * 1024 * 1024));
3012 }
3013 actual.priority_cutoff_when_visible =
3014 gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING;
3015#else
3016 // Ignore what the system said and give all clients the same maximum
3017 // allocation on desktop platforms.
3018 actual.bytes_limit_when_visible = 512 * 1024 * 1024;
3019 actual.priority_cutoff_when_visible =
3020 gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
3021
3022 // For large monitors (4k), double the tile memory to avoid frequent out of
3023 // memory problems. 4k could mean a screen width of anywhere from 3840 to 4096
3024 // (see https://en.wikipedia.org/wiki/4K_resolution). We use 3500 as a proxy
3025 // for "large enough".
3026 static const int kLargeDisplayThreshold = 3500;
3027 int display_width =
3028 std::round(initial_screen_size.width() * initial_device_scale_factor);
3029 if (display_width >= kLargeDisplayThreshold)
3030 actual.bytes_limit_when_visible *= 2;
3031#endif
3032 return actual;
3033}
3034
Navid Zolghadr8fdb6114e2018-08-29 19:00:543035void RenderWidget::HasPointerRawMoveEventHandlers(bool has_handlers) {
3036 if (input_event_queue_)
3037 input_event_queue_->HasPointerRawMoveEventHandlers(has_handlers);
3038}
3039
Blink Reformat1c4d759e2017-04-09 16:34:543040void RenderWidget::HasTouchEventHandlers(bool has_handlers) {
W. James MacLean662d5382018-03-29 18:33:083041 if (has_touch_handlers_ && *has_touch_handlers_ == has_handlers)
3042 return;
3043
3044 has_touch_handlers_ = has_handlers;
alexclarke7fa93942015-10-21 15:37:113045 if (render_widget_scheduling_state_)
3046 render_widget_scheduling_state_->SetHasTouchHandler(has_handlers);
Albert J. Wongeb28e7e2018-10-12 00:57:433047 Send(new WidgetHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
[email protected]ce6689f2013-03-29 12:52:553048}
3049
Dave Tapuskadfe486c12017-06-09 16:53:133050void RenderWidget::SetNeedsLowLatencyInput(bool needs_low_latency) {
3051 if (input_event_queue_)
3052 input_event_queue_->SetNeedsLowLatency(needs_low_latency);
3053}
3054
W. James MacLeand973a55b2018-11-29 21:39:133055void RenderWidget::AnimateDoubleTapZoomInMainFrame(
3056 const blink::WebPoint& point,
3057 const blink::WebRect& rect_to_zoom) {
3058 // Only oopif subframes should be sending this message.
3059 DCHECK(!owner_delegate_);
3060 Send(new WidgetHostMsg_AnimateDoubleTapZoomInMainFrame(routing_id(), point,
3061 rect_to_zoom));
3062}
3063
Dave Tapuskabafc2ba32017-11-28 01:54:373064void RenderWidget::RequestUnbufferedInputEvents() {
3065 if (input_event_queue_)
3066 input_event_queue_->RequestUnbufferedInputEvents();
3067}
3068
xidachenfa0199e72017-05-11 11:34:263069void RenderWidget::SetTouchAction(cc::TouchAction touch_action) {
Dave Tapuskab28a1082017-08-30 15:37:263070 if (!input_handler_->ProcessTouchAction(touch_action))
[email protected]5d0bbdfa92013-12-10 00:35:513071 return;
3072
Dave Tapuska04bc5ee92018-04-17 19:03:313073 widget_input_handler_manager_->ProcessTouchAction(touch_action);
[email protected]5d0bbdfa92013-12-10 00:35:513074}
3075
[email protected]e3244ed2014-06-20 20:04:273076void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
3077 render_frame_proxies_.AddObserver(proxy);
W. James MacLean2a90bff2018-11-05 20:52:473078 // During initial page load, the main frame may have received page
3079 // scale factor information before the sub-frame proxies were registered, so
3080 // make sure we pass the page scale factor along here.
3081 proxy->OnPageScaleFactorChanged(page_scale_factor_from_mainframe_);
[email protected]bffc8302014-01-23 20:52:163082}
3083
[email protected]e3244ed2014-06-20 20:04:273084void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
3085 render_frame_proxies_.RemoveObserver(proxy);
[email protected]bffc8302014-01-23 20:52:163086}
3087
[email protected]de3c5d82014-05-28 22:12:593088void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
3089 render_frames_.AddObserver(frame);
3090}
3091
3092void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) {
3093 render_frames_.RemoveObserver(frame);
3094}
3095
Saman Samid189e5dfd2017-12-20 22:55:313096void RenderWidget::RegisterBrowserPlugin(BrowserPlugin* browser_plugin) {
3097 browser_plugins_.AddObserver(browser_plugin);
Saman Sami50d1e0c2018-03-13 20:03:493098 browser_plugin->ScreenInfoChanged(GetOriginalScreenInfo());
Saman Samid189e5dfd2017-12-20 22:55:313099}
3100
3101void RenderWidget::UnregisterBrowserPlugin(BrowserPlugin* browser_plugin) {
3102 browser_plugins_.RemoveObserver(browser_plugin);
3103}
3104
Albert J. Wong3c93c182018-09-27 17:29:433105void RenderWidget::OnWaitNextFrameForTests(
3106 int main_frame_thread_observer_routing_id) {
danakj53802692018-07-25 21:46:443107 // Sends an ACK to the browser process during the next compositor frame.
Albert J. Wong3c93c182018-09-27 17:29:433108 QueueMessage(new WidgetHostMsg_WaitForNextFrameForTests_ACK(
3109 main_frame_thread_observer_routing_id));
lfg43e08e62016-02-03 18:51:373110}
3111
Fady Samuela863f152018-03-09 16:10:033112const ScreenInfo& RenderWidget::GetWebScreenInfo() const {
3113 return screen_info_;
Christopher Camerone9a30c12018-03-07 08:23:383114}
3115
Fady Samuela863f152018-03-09 16:10:033116const ScreenInfo& RenderWidget::GetOriginalScreenInfo() const {
Christopher Camerone9a30c12018-03-07 08:23:383117 return screen_metrics_emulator_
3118 ? screen_metrics_emulator_->original_screen_info()
Fady Samuela863f152018-03-09 16:10:033119 : screen_info_;
oshima50872a72016-03-04 13:26:183120}
3121
Ella Ge80a52dce2017-11-15 18:01:523122gfx::PointF RenderWidget::ConvertWindowPointToViewport(
3123 const gfx::PointF& point) {
paulmeyer90f6c31d2016-11-12 00:17:593124 blink::WebFloatRect point_in_viewport(point.x(), point.y(), 0, 0);
Blink Reformat1c4d759e2017-04-09 16:34:543125 ConvertWindowToViewport(&point_in_viewport);
Ella Ge80a52dce2017-11-15 18:01:523126 return gfx::PointF(point_in_viewport.x, point_in_viewport.y);
3127}
3128
3129gfx::Point RenderWidget::ConvertWindowPointToViewport(const gfx::Point& point) {
3130 return gfx::ToRoundedPoint(ConvertWindowPointToViewport(gfx::PointF(point)));
paulmeyer90f6c31d2016-11-12 00:17:593131}
3132
Blink Reformat1c4d759e2017-04-09 16:34:543133bool RenderWidget::RequestPointerLock() {
lfgbee1e0a2016-06-08 21:24:213134 return mouse_lock_dispatcher_->LockMouse(webwidget_mouse_lock_target_.get());
3135}
3136
Blink Reformat1c4d759e2017-04-09 16:34:543137void RenderWidget::RequestPointerUnlock() {
lfgbee1e0a2016-06-08 21:24:213138 mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
3139}
3140
Blink Reformat1c4d759e2017-04-09 16:34:543141bool RenderWidget::IsPointerLocked() {
lfgbee1e0a2016-06-08 21:24:213142 return mouse_lock_dispatcher_->IsMouseLockedTo(
3143 webwidget_mouse_lock_target_.get());
3144}
3145
Richard Li49fe04d2018-10-21 09:07:193146void RenderWidget::StartDragging(network::mojom::ReferrerPolicy policy,
paulmeyer6ef5a792016-11-08 20:33:583147 const WebDragData& data,
3148 WebDragOperationsMask mask,
danakj0c75ad82018-07-10 19:50:123149 const SkBitmap& drag_image,
danakjef1735a2018-11-13 19:34:443150 const gfx::Point& web_image_offset) {
3151 blink::WebRect offset_in_window(web_image_offset.x(), web_image_offset.y(), 0,
3152 0);
Blink Reformat1c4d759e2017-04-09 16:34:543153 ConvertViewportToWindow(&offset_in_window);
paulmeyer6ef5a792016-11-08 20:33:583154 DropData drop_data(DropDataBuilder::Build(data));
3155 drop_data.referrer_policy = policy;
danakj0c75ad82018-07-10 19:50:123156 gfx::Vector2d image_offset(offset_in_window.x, offset_in_window.y);
3157 Send(new DragHostMsg_StartDragging(routing_id(), drop_data, mask, drag_image,
3158 image_offset, possible_drag_event_info_));
paulmeyer6ef5a792016-11-08 20:33:583159}
3160
kenrb5d78b842017-03-06 21:06:013161uint32_t RenderWidget::GetContentSourceId() {
3162 return current_content_source_id_;
3163}
3164
Saman Samif7731342018-01-24 22:18:443165void RenderWidget::DidNavigate() {
Saman Sami26a1fcd2018-04-10 17:12:213166 ++current_content_source_id_;
danakja6c10012018-07-06 14:25:363167 if (!layer_tree_view_)
Saman Samif7731342018-01-24 22:18:443168 return;
danakja6c10012018-07-06 14:25:363169 layer_tree_view_->SetContentSourceId(current_content_source_id_);
3170 layer_tree_view_->ClearCachesOnNextCommit();
kenrb5d78b842017-03-06 21:06:013171}
3172
lfg8ff33912016-09-13 20:59:213173blink::WebWidget* RenderWidget::GetWebWidget() const {
danakja2c9d0a92018-07-25 20:01:183174 if (owner_delegate_) {
3175 blink::WebWidget* delegate_widget =
3176 owner_delegate_->GetWebWidgetForWidget();
3177 if (delegate_widget)
3178 return delegate_widget;
3179 }
lfg8ff33912016-09-13 20:59:213180 return webwidget_internal_;
3181}
3182
ekaramad2daaf672016-11-10 20:29:013183blink::WebInputMethodController* RenderWidget::GetInputMethodController()
3184 const {
Ehsan Karamad655d7b8a2018-01-12 18:38:383185 if (auto* frame_widget = GetFrameWidget())
3186 return frame_widget->GetActiveWebInputMethodController();
3187
3188 return nullptr;
ekaramad2daaf672016-11-10 20:29:013189}
3190
Dave Tapuska139a72f2017-09-06 21:57:033191void RenderWidget::SetupWidgetInputHandler(
3192 mojom::WidgetInputHandlerRequest request,
3193 mojom::WidgetInputHandlerHostPtr host) {
Dave Tapuskab66c28f2017-11-15 17:18:473194 widget_input_handler_manager_->AddInterface(std::move(request),
3195 std::move(host));
Dave Tapuska525eb15e2017-08-17 21:05:503196}
3197
Dave Tapuska485aca92017-08-08 00:47:583198void RenderWidget::SetWidgetBinding(mojom::WidgetRequest request) {
3199 // Close the old binding if there was one.
3200 // A RenderWidgetHost should not need more than one channel.
3201 widget_binding_.Close();
3202 widget_binding_.Bind(std::move(request));
3203}
3204
Ken Buchanan94c0beb62018-06-22 19:56:243205void RenderWidget::SetMouseCapture(bool capture) {
3206 if (mojom::WidgetInputHandlerHost* host =
3207 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
3208 host->SetMouseCapture(capture);
3209 }
3210}
3211
danakj53802692018-07-25 21:46:443212void RenderWidget::SetWindowScreenRect(const gfx::Rect& window_screen_rect) {
3213 if (screen_metrics_emulator_)
3214 screen_metrics_emulator_->OnUpdateWindowScreenRect(window_screen_rect);
3215 else
3216 window_screen_rect_ = window_screen_rect;
3217}
3218
Fady Samuelca9ecb72018-05-05 05:59:273219bool RenderWidget::IsSurfaceSynchronizationEnabled() const {
danakja6c10012018-07-06 14:25:363220 return layer_tree_view_ &&
3221 layer_tree_view_->IsSurfaceSynchronizationEnabled();
Fady Samuelca9ecb72018-05-05 05:59:273222}
3223
W. James MacLean2a90bff2018-11-05 20:52:473224void RenderWidget::PageScaleFactorChanged(float page_scale_factor) {
3225 // Only the main frame pulls page scale information from the layer tree host.
3226 // Pages scale is shared with non-mainframe widgets via the IPC for
3227 // OnSynchronizeVisualProperties.
3228 if (!owner_delegate_)
3229 return;
3230
3231 page_scale_factor_from_mainframe_ = page_scale_factor;
3232 for (auto& observer : render_frame_proxies_)
3233 observer.OnPageScaleFactorChanged(page_scale_factor);
3234}
3235
danakj53802692018-07-25 21:46:443236void RenderWidget::UseSynchronousResizeModeForTesting(bool enable) {
3237 resizing_mode_selector_->set_is_synchronous_mode(enable);
danakja2c9d0a92018-07-25 20:01:183238}
3239
3240void RenderWidget::SetDeviceScaleFactorForTesting(float factor) {
3241 device_scale_factor_for_testing_ = factor;
3242
3243 VisualProperties visual_properties;
3244 visual_properties.screen_info = screen_info_;
3245 visual_properties.screen_info.device_scale_factor = factor;
3246 visual_properties.new_size = size();
3247 visual_properties.visible_viewport_size = visible_viewport_size_;
3248 visual_properties.compositor_viewport_pixel_size =
3249 gfx::ScaleToCeiledSize(size(), factor);
3250 visual_properties.browser_controls_shrink_blink_size = false;
3251 visual_properties.top_controls_height = 0.f;
3252 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
3253 visual_properties.display_mode = display_mode_;
Fady Samuel84d8a1f72018-11-08 00:26:173254 visual_properties.local_surface_id_allocation =
3255 local_surface_id_allocation_from_parent_;
W. James MacLean2a90bff2018-11-05 20:52:473256 visual_properties.page_scale_factor = page_scale_factor_from_mainframe_;
danakja2c9d0a92018-07-25 20:01:183257 // We are changing the device scale factor from the renderer, so allocate a
3258 // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
3259 if (layer_tree_view_)
3260 layer_tree_view_->RequestNewLocalSurfaceId();
3261
3262 OnSynchronizeVisualProperties(visual_properties);
3263}
3264
3265void RenderWidget::SetDeviceColorSpaceForTesting(
3266 const gfx::ColorSpace& color_space) {
3267 VisualProperties visual_properties;
3268 visual_properties.screen_info = screen_info_;
3269 visual_properties.screen_info.color_space = color_space;
3270 visual_properties.new_size = size();
3271 visual_properties.visible_viewport_size = visible_viewport_size_;
3272 visual_properties.compositor_viewport_pixel_size =
3273 compositor_viewport_pixel_size_;
3274 visual_properties.browser_controls_shrink_blink_size = false;
3275 visual_properties.top_controls_height = 0.f;
3276 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
3277 visual_properties.display_mode = display_mode_;
Fady Samuel84d8a1f72018-11-08 00:26:173278 visual_properties.local_surface_id_allocation =
3279 local_surface_id_allocation_from_parent_;
W. James MacLean2a90bff2018-11-05 20:52:473280 visual_properties.page_scale_factor = page_scale_factor_from_mainframe_;
danakja2c9d0a92018-07-25 20:01:183281 // We are changing the device color space from the renderer, so allocate a
3282 // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
3283 if (layer_tree_view_)
3284 layer_tree_view_->RequestNewLocalSurfaceId();
3285 OnSynchronizeVisualProperties(visual_properties);
3286}
3287
3288void RenderWidget::SetWindowRectSynchronouslyForTesting(
3289 const gfx::Rect& new_window_rect) {
3290 SetWindowRectSynchronously(new_window_rect);
3291}
3292
3293void RenderWidget::EnableAutoResizeForTesting(const gfx::Size& min_size,
3294 const gfx::Size& max_size) {
3295 VisualProperties visual_properties;
3296 visual_properties.auto_resize_enabled = true;
3297 visual_properties.min_size_for_auto_resize = min_size;
3298 visual_properties.max_size_for_auto_resize = max_size;
Fady Samuel84d8a1f72018-11-08 00:26:173299 visual_properties.local_surface_id_allocation =
3300 base::Optional<viz::LocalSurfaceIdAllocation>(
3301 viz::LocalSurfaceIdAllocation(
3302 viz::LocalSurfaceId(1, 1, base::UnguessableToken::Create()),
3303 base::TimeTicks::Now()));
W. James MacLean2a90bff2018-11-05 20:52:473304 visual_properties.page_scale_factor = page_scale_factor_from_mainframe_;
danakja2c9d0a92018-07-25 20:01:183305 OnSynchronizeVisualProperties(visual_properties);
3306}
3307
3308void RenderWidget::DisableAutoResizeForTesting(const gfx::Size& new_size) {
3309 if (!auto_resize_mode_)
3310 return;
3311
3312 VisualProperties visual_properties;
3313 visual_properties.auto_resize_enabled = false;
3314 visual_properties.screen_info = screen_info_;
3315 visual_properties.new_size = new_size;
3316 visual_properties.compositor_viewport_pixel_size =
3317 compositor_viewport_pixel_size_;
3318 visual_properties.browser_controls_shrink_blink_size =
3319 browser_controls_shrink_blink_size_;
3320 visual_properties.top_controls_height = top_controls_height_;
3321 visual_properties.visible_viewport_size = visible_viewport_size_;
3322 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
3323 visual_properties.display_mode = display_mode_;
W. James MacLean2a90bff2018-11-05 20:52:473324 visual_properties.page_scale_factor = page_scale_factor_from_mainframe_;
danakja2c9d0a92018-07-25 20:01:183325 OnSynchronizeVisualProperties(visual_properties);
3326}
3327
EhsanK955ba582017-11-30 21:14:403328blink::WebLocalFrame* RenderWidget::GetFocusedWebLocalFrameInWidget() const {
Ehsan Karamad655d7b8a2018-01-12 18:38:383329 if (auto* frame_widget = GetFrameWidget())
3330 return frame_widget->FocusedWebLocalFrameInWidget();
3331 return nullptr;
EhsanK955ba582017-11-30 21:14:403332}
3333
EhsanK22d482e2017-08-10 17:29:493334#if BUILDFLAG(ENABLE_PLUGINS)
3335PepperPluginInstanceImpl* RenderWidget::GetFocusedPepperPluginInsideWidget() {
Ehsan Karamad655d7b8a2018-01-12 18:38:383336 blink::WebFrameWidget* frame_widget = GetFrameWidget();
3337 if (!frame_widget)
EhsanK22d482e2017-08-10 17:29:493338 return nullptr;
3339
3340 // Focused pepper instance might not always be in the focused frame. For
3341 // instance if a pepper instance and its embedder frame are focused an then
3342 // another frame takes focus using javascript, the embedder frame will no
3343 // longer be focused while the pepper instance is (the embedder frame's
3344 // |focused_pepper_plugin_| is not nullptr). Especially, if the pepper plugin
3345 // is fullscreen, clicking into the pepper will not refocus the embedder
3346 // frame. This is why we have to traverse the whole frame tree to find the
3347 // focused plugin.
Ehsan Karamad655d7b8a2018-01-12 18:38:383348 blink::WebFrame* current_frame = frame_widget->LocalRoot();
EhsanK22d482e2017-08-10 17:29:493349 while (current_frame) {
3350 RenderFrameImpl* render_frame =
3351 current_frame->IsWebLocalFrame()
3352 ? RenderFrameImpl::FromWebFrame(current_frame)
3353 : nullptr;
3354 if (render_frame && render_frame->focused_pepper_plugin())
3355 return render_frame->focused_pepper_plugin();
3356 current_frame = current_frame->TraverseNext();
3357 }
3358 return nullptr;
3359}
3360#endif
3361
Ken Buchananb2c9e262018-03-10 16:53:313362gfx::Rect RenderWidget::ViewportVisibleRect() {
danakj6dcbc5962018-11-16 16:45:423363 return for_child_local_root_frame_
3364 ? compositor_visible_rect_
3365 : gfx::Rect(compositor_viewport_pixel_size_);
Ken Buchananb2c9e262018-03-10 16:53:313366}
3367
Hajime Hoshi315a61f2018-08-14 17:27:283368// static
3369scoped_refptr<base::SingleThreadTaskRunner>
3370RenderWidget::GetCleanupTaskRunner() {
3371 return RenderThreadImpl::current_blink_platform_impl()
3372 ->main_thread_scheduler()
3373 ->CleanupTaskRunner();
3374}
3375
Saman Sami50d1e0c2018-03-13 20:03:493376base::WeakPtr<RenderWidget> RenderWidget::AsWeakPtr() {
3377 return weak_ptr_factory_.GetWeakPtr();
3378}
3379
[email protected]e9ff79c2012-10-19 21:31:263380} // namespace content