blob: 2d10e5b134db0c822f823f364b6a0192b8a95db7 [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"
[email protected]35b4f0c2014-06-26 16:55:2725#include "base/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"
[email protected]778574e2011-03-21 22:03:5047#include "content/common/view_messages.h"
Albert J. Wong3c93c182018-09-27 17:29:4348#include "content/common/widget_messages.h"
mlamouriafca06dd2017-01-27 23:35:1849#include "content/public/common/content_client.h"
changwan7ded3752016-03-09 23:25:1250#include "content/public/common/content_features.h"
[email protected]c08950d22011-10-13 22:20:2951#include "content/public/common/content_switches.h"
[email protected]a09d53ce2014-01-31 00:46:4252#include "content/public/common/context_menu_params.h"
paulmeyer90f6c31d2016-11-12 00:17:5953#include "content/public/common/drop_data.h"
Khushal3e96e662017-10-30 23:16:5054#include "content/public/common/service_names.mojom.h"
Jaebaek Seo655110e2017-12-19 23:27:3955#include "content/public/common/use_zoom_for_dsf_policy.h"
mlamouriafca06dd2017-01-27 23:35:1856#include "content/public/renderer/content_renderer_client.h"
Saman Samid189e5dfd2017-12-20 22:55:3157#include "content/renderer/browser_plugin/browser_plugin.h"
[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"
[email protected]586871b2014-07-22 17:05:1162#include "content/renderer/gpu/frame_swap_message_queue.h"
danakja6c10012018-07-06 14:25:3663#include "content/renderer/gpu/layer_tree_view.h"
[email protected]586871b2014-07-22 17:05:1164#include "content/renderer/gpu/queue_message_swap_promise.h"
[email protected]66fca5bc2013-05-23 06:58:2965#include "content/renderer/ime_event_guard.h"
dtapuska9ec1a912017-04-21 15:18:3166#include "content/renderer/input/main_thread_event_queue.h"
Dave Tapuska9db80842017-07-24 17:24:2667#include "content/renderer/input/widget_input_handler_manager.h"
[email protected]adab2332013-07-25 18:04:3268#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
[email protected]bffc8302014-01-23 20:52:1669#include "content/renderer/render_frame_impl.h"
danakj4b347212018-07-04 17:55:1770#include "content/renderer/render_frame_metadata_observer_impl.h"
[email protected]e3244ed2014-06-20 20:04:2771#include "content/renderer/render_frame_proxy.h"
[email protected]8704f89b2011-04-15 00:30:0572#include "content/renderer/render_process.h"
[email protected]f1a29a02011-10-06 23:08:4473#include "content/renderer/render_thread_impl.h"
dcheng3ce04b62015-10-26 23:30:5574#include "content/renderer/render_view_impl.h"
avi40b5be7a2016-03-03 21:13:4475#include "content/renderer/render_widget_owner_delegate.h"
tfarina556a7232014-10-05 01:02:0976#include "content/renderer/renderer_blink_platform_impl.h"
[email protected]5b45ad42013-10-25 00:42:0477#include "content/renderer/resizing_mode_selector.h"
danakj4b347212018-07-04 17:55:1778#include "gpu/command_buffer/service/gpu_switches.h"
ekaramad330ba4232016-09-23 17:57:4779#include "ipc/ipc_message_start.h"
[email protected]484955942010-08-19 16:13:1880#include "ipc/ipc_sync_message.h"
Antoine Laboure55c9ef82017-11-10 18:51:2381#include "ipc/ipc_sync_message_filter.h"
danakj4b347212018-07-04 17:55:1782#include "media/base/media_switches.h"
Scott Violet02e38b92018-03-27 23:42:1483#include "ppapi/buildflags/buildflags.h"
[email protected]661eb9d2009-02-03 02:11:4884#include "skia/ext/platform_canvas.h"
Blink Reformata30d4232018-04-07 15:31:0685#include "third_party/blink/public/platform/file_path_conversion.h"
Hajime Hoshi315a61f2018-08-14 17:27:2886#include "third_party/blink/public/platform/platform.h"
Blink Reformata30d4232018-04-07 15:31:0687#include "third_party/blink/public/platform/scheduler/web_render_widget_scheduling_state.h"
Yuta Kitamuradeb91bb2018-05-29 05:53:2088#include "third_party/blink/public/platform/scheduler/web_thread_scheduler.h"
Blink Reformata30d4232018-04-07 15:31:0689#include "third_party/blink/public/platform/web_cursor_info.h"
90#include "third_party/blink/public/platform/web_drag_data.h"
91#include "third_party/blink/public/platform/web_drag_operation.h"
92#include "third_party/blink/public/platform/web_mouse_event.h"
93#include "third_party/blink/public/platform/web_point.h"
94#include "third_party/blink/public/platform/web_rect.h"
95#include "third_party/blink/public/platform/web_runtime_features.h"
96#include "third_party/blink/public/platform/web_size.h"
97#include "third_party/blink/public/platform/web_string.h"
Hajime Hoshi315a61f2018-08-14 17:27:2898#include "third_party/blink/public/platform/web_thread.h"
Blink Reformata30d4232018-04-07 15:31:0699#include "third_party/blink/public/web/web_autofill_client.h"
100#include "third_party/blink/public/web/web_device_emulation_params.h"
101#include "third_party/blink/public/web/web_frame_widget.h"
102#include "third_party/blink/public/web/web_input_method_controller.h"
103#include "third_party/blink/public/web/web_local_frame.h"
104#include "third_party/blink/public/web/web_node.h"
105#include "third_party/blink/public/web/web_page_popup.h"
106#include "third_party/blink/public/web/web_popup_menu_info.h"
107#include "third_party/blink/public/web/web_range.h"
108#include "third_party/blink/public/web/web_settings.h"
109#include "third_party/blink/public/web/web_view.h"
110#include "third_party/blink/public/web/web_widget.h"
[email protected]d353541f2012-05-03 22:45:41111#include "third_party/skia/include/core/SkShader.h"
paulmeyer90f6c31d2016-11-12 00:17:59112#include "ui/base/clipboard/clipboard.h"
Scott Violet8ff9c302018-02-22 22:28:35113#include "ui/base/ui_base_features.h"
danakj4b347212018-07-04 17:55:17114#include "ui/base/ui_base_switches.h"
dtapuska97286c882017-02-24 23:14:43115#include "ui/events/base_event_utils.h"
tfarina655f81d2014-12-23 02:38:50116#include "ui/gfx/geometry/point_conversions.h"
tfarina3b0452d2014-12-31 15:20:09117#include "ui/gfx/geometry/rect_conversions.h"
tfarinaebe974f02015-01-03 04:25:32118#include "ui/gfx/geometry/size_conversions.h"
[email protected]1835b9e2012-02-28 13:12:48119#include "ui/gfx/skia_util.h"
danakj4b347212018-07-04 17:55:17120#include "ui/gfx/switches.h"
[email protected]c9e2cbbb2012-05-12 21:17:27121#include "ui/gl/gl_switches.h"
danakj4b347212018-07-04 17:55:17122#include "ui/native_theme/native_theme_features.h"
123#include "ui/native_theme/overlay_scrollbar_constants_aura.h"
[email protected]d353541f2012-05-03 22:45:41124#include "ui/surface/transport_dib.h"
[email protected]661eb9d2009-02-03 02:11:48125
[email protected]eeb93112013-05-01 19:41:10126#if defined(OS_ANDROID)
[email protected]cefe9b152014-03-27 18:16:15127#include <android/keycodes.h>
wjmaclean1d970622017-01-21 22:28:24128#include "base/time/time.h"
[email protected]eeb93112013-05-01 19:41:10129#endif
130
[email protected]661eb9d2009-02-03 02:11:48131#if defined(OS_POSIX)
[email protected]d5282e72009-05-13 13:16:52132#include "third_party/skia/include/core/SkMallocPixelRef.h"
[email protected]d353541f2012-05-03 22:45:41133#include "third_party/skia/include/core/SkPixelRef.h"
[email protected]661eb9d2009-02-03 02:11:48134#endif // defined(OS_POSIX)
[email protected]8085dbc82008-09-26 22:53:44135
sadrul943e3b32016-08-04 18:22:59136#if defined(USE_AURA)
sadrul602ce1362017-01-26 06:41:10137#include "content/renderer/mus/renderer_window_tree_client.h"
penghuang28a5fa22015-12-02 17:58:19138#endif
139
ekaramad330ba4232016-09-23 17:57:47140#if defined(OS_MACOSX)
141#include "content/renderer/text_input_client_observer.h"
142#endif
143
Ryan Landay9e42fd742017-08-12 01:59:11144using blink::WebImeTextSpan;
[email protected]180ef242013-11-07 06:50:46145using blink::WebCursorInfo;
[email protected]19193682014-04-03 15:01:43146using blink::WebDeviceEmulationParams;
paulmeyer90f6c31d2016-11-12 00:17:59147using blink::WebDragOperation;
paulmeyer6ef5a792016-11-08 20:33:58148using blink::WebDragOperationsMask;
149using blink::WebDragData;
paulmeyer90f6c31d2016-11-12 00:17:59150using blink::WebFrameWidget;
[email protected]180ef242013-11-07 06:50:46151using blink::WebGestureEvent;
152using blink::WebInputEvent;
dtapuska5d2e9c32015-12-03 16:39:49153using blink::WebInputEventResult;
ekaramad2daaf672016-11-10 20:29:01154using blink::WebInputMethodController;
paulmeyer6ef5a792016-11-08 20:33:58155using blink::WebLocalFrame;
[email protected]180ef242013-11-07 06:50:46156using blink::WebMouseEvent;
157using blink::WebMouseWheelEvent;
158using blink::WebNavigationPolicy;
donnda070f3c2015-01-16 19:54:11159using blink::WebNode;
[email protected]180ef242013-11-07 06:50:46160using blink::WebPagePopup;
donnda070f3c2015-01-16 19:54:11161using blink::WebPoint;
dglazkove353a372016-09-01 01:33:48162using blink::WebRange;
[email protected]180ef242013-11-07 06:50:46163using blink::WebRect;
[email protected]180ef242013-11-07 06:50:46164using blink::WebSize;
paulmeyer90f6c31d2016-11-12 00:17:59165using blink::WebString;
[email protected]180ef242013-11-07 06:50:46166using blink::WebTextDirection;
167using blink::WebTouchEvent;
[email protected]f8ed4722013-12-03 03:27:25168using blink::WebTouchPoint;
[email protected]180ef242013-11-07 06:50:46169using blink::WebVector;
170using blink::WebWidget;
[email protected]e9ff79c2012-10-19 21:31:26171
paulmeyer90f6c31d2016-11-12 00:17:59172namespace content {
173
[email protected]6a4d7f62013-01-07 21:32:13174namespace {
[email protected]b256eca2013-07-11 10:57:40175
Albert J. Wongcb004632018-07-10 22:58:25176using RoutingIDWidgetMap = std::map<int32_t, RenderWidget*>;
177base::LazyInstance<RoutingIDWidgetMap>::Leaky g_routing_id_widget_map =
178 LAZY_INSTANCE_INITIALIZER;
179
danakj4b347212018-07-04 17:55:17180const base::Feature kUnpremultiplyAndDitherLowBitDepthTiles = {
181 "UnpremultiplyAndDitherLowBitDepthTiles", base::FEATURE_ENABLED_BY_DEFAULT};
182
[email protected]b256eca2013-07-11 10:57:40183typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
184
AJITH KUMAR V041c0b02017-08-08 10:39:20185static const int kInvalidNextPreviousFlagsValue = -1;
186
lfgbee1e0a2016-06-08 21:24:21187class WebWidgetLockTarget : public content::MouseLockDispatcher::LockTarget {
188 public:
189 explicit WebWidgetLockTarget(blink::WebWidget* webwidget)
190 : webwidget_(webwidget) {}
191
192 void OnLockMouseACK(bool succeeded) override {
193 if (succeeded)
Blink Reformat1c4d759e2017-04-09 16:34:54194 webwidget_->DidAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21195 else
Blink Reformat1c4d759e2017-04-09 16:34:54196 webwidget_->DidNotAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21197 }
198
Blink Reformat1c4d759e2017-04-09 16:34:54199 void OnMouseLockLost() override { webwidget_->DidLosePointerLock(); }
lfgbee1e0a2016-06-08 21:24:21200
201 bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event) override {
202 // The WebWidget handles mouse lock in Blink's handleInputEvent().
203 return false;
204 }
205
206 private:
207 blink::WebWidget* webwidget_;
208};
209
dglazkov97b6c2b2016-10-25 17:35:55210bool IsDateTimeInput(ui::TextInputType type) {
211 return type == ui::TEXT_INPUT_TYPE_DATE ||
212 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
213 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
214 type == ui::TEXT_INPUT_TYPE_MONTH ||
215 type == ui::TEXT_INPUT_TYPE_TIME || type == ui::TEXT_INPUT_TYPE_WEEK;
216}
217
paulmeyer90f6c31d2016-11-12 00:17:59218WebDragData DropMetaDataToWebDragData(
219 const std::vector<DropData::Metadata>& drop_meta_data) {
220 std::vector<WebDragData::Item> item_list;
221 for (const auto& meta_data_item : drop_meta_data) {
222 if (meta_data_item.kind == DropData::Kind::STRING) {
223 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54224 item.storage_type = WebDragData::Item::kStorageTypeString;
225 item.string_type = WebString::FromUTF16(meta_data_item.mime_type);
paulmeyer90f6c31d2016-11-12 00:17:59226 // Have to pass a dummy URL here instead of an empty URL because the
227 // DropData received by browser_plugins goes through a round trip:
228 // DropData::MetaData --> WebDragData-->DropData. In the end, DropData
229 // will contain an empty URL (which means no URL is dragged) if the URL in
230 // WebDragData is empty.
231 if (base::EqualsASCII(meta_data_item.mime_type,
232 ui::Clipboard::kMimeTypeURIList)) {
Blink Reformat1c4d759e2017-04-09 16:34:54233 item.string_data = WebString::FromUTF8("about:dragdrop-placeholder");
paulmeyer90f6c31d2016-11-12 00:17:59234 }
235 item_list.push_back(item);
236 continue;
237 }
238
239 // TODO(hush): crbug.com/584789. Blink needs to support creating a file with
240 // just the mimetype. This is needed to drag files to WebView on Android
241 // platform.
242 if ((meta_data_item.kind == DropData::Kind::FILENAME) &&
243 !meta_data_item.filename.empty()) {
244 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54245 item.storage_type = WebDragData::Item::kStorageTypeFilename;
246 item.filename_data = blink::FilePathToWebString(meta_data_item.filename);
paulmeyer90f6c31d2016-11-12 00:17:59247 item_list.push_back(item);
248 continue;
249 }
250
251 if (meta_data_item.kind == DropData::Kind::FILESYSTEMFILE) {
252 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54253 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
254 item.file_system_url = meta_data_item.file_system_url;
paulmeyer90f6c31d2016-11-12 00:17:59255 item_list.push_back(item);
256 continue;
257 }
258 }
259
260 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54261 result.Initialize();
262 result.SetItems(item_list);
paulmeyer90f6c31d2016-11-12 00:17:59263 return result;
264}
265
266WebDragData DropDataToWebDragData(const DropData& drop_data) {
267 std::vector<WebDragData::Item> item_list;
268
269 // These fields are currently unused when dragging into WebKit.
270 DCHECK(drop_data.download_metadata.empty());
271 DCHECK(drop_data.file_contents.empty());
dcheng3dd85612017-02-08 10:46:23272 DCHECK(drop_data.file_contents_content_disposition.empty());
paulmeyer90f6c31d2016-11-12 00:17:59273
274 if (!drop_data.text.is_null()) {
275 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54276 item.storage_type = WebDragData::Item::kStorageTypeString;
277 item.string_type = WebString::FromUTF8(ui::Clipboard::kMimeTypeText);
278 item.string_data = WebString::FromUTF16(drop_data.text.string());
paulmeyer90f6c31d2016-11-12 00:17:59279 item_list.push_back(item);
280 }
281
282 if (!drop_data.url.is_empty()) {
283 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54284 item.storage_type = WebDragData::Item::kStorageTypeString;
285 item.string_type = WebString::FromUTF8(ui::Clipboard::kMimeTypeURIList);
286 item.string_data = WebString::FromUTF8(drop_data.url.spec());
287 item.title = WebString::FromUTF16(drop_data.url_title);
paulmeyer90f6c31d2016-11-12 00:17:59288 item_list.push_back(item);
289 }
290
291 if (!drop_data.html.is_null()) {
292 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54293 item.storage_type = WebDragData::Item::kStorageTypeString;
294 item.string_type = WebString::FromUTF8(ui::Clipboard::kMimeTypeHTML);
295 item.string_data = WebString::FromUTF16(drop_data.html.string());
296 item.base_url = drop_data.html_base_url;
paulmeyer90f6c31d2016-11-12 00:17:59297 item_list.push_back(item);
298 }
299
jdoerrie5a73d0fa2018-10-02 23:54:05300 for (auto it = drop_data.filenames.begin(); it != drop_data.filenames.end();
paulmeyer90f6c31d2016-11-12 00:17:59301 ++it) {
302 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54303 item.storage_type = WebDragData::Item::kStorageTypeFilename;
304 item.filename_data = blink::FilePathToWebString(it->path);
305 item.display_name_data =
kinukoa4293022017-01-27 06:43:25306 blink::FilePathToWebString(base::FilePath(it->display_name));
paulmeyer90f6c31d2016-11-12 00:17:59307 item_list.push_back(item);
308 }
309
jdoerrie5a73d0fa2018-10-02 23:54:05310 for (auto it = drop_data.file_system_files.begin();
311 it != drop_data.file_system_files.end(); ++it) {
paulmeyer90f6c31d2016-11-12 00:17:59312 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54313 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
314 item.file_system_url = it->url;
315 item.file_system_file_size = it->size;
316 item.file_system_id = blink::WebString::FromASCII(it->filesystem_id);
paulmeyer90f6c31d2016-11-12 00:17:59317 item_list.push_back(item);
318 }
319
Stuart Langley48300392017-11-02 03:54:44320 for (const auto& it : drop_data.custom_data) {
paulmeyer90f6c31d2016-11-12 00:17:59321 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54322 item.storage_type = WebDragData::Item::kStorageTypeString;
Stuart Langley48300392017-11-02 03:54:44323 item.string_type = WebString::FromUTF16(it.first);
324 item.string_data = WebString::FromUTF16(it.second);
paulmeyer90f6c31d2016-11-12 00:17:59325 item_list.push_back(item);
326 }
327
328 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54329 result.Initialize();
330 result.SetItems(item_list);
331 result.SetFilesystemId(WebString::FromUTF16(drop_data.filesystem_id));
paulmeyer90f6c31d2016-11-12 00:17:59332 return result;
333}
334
dtapuskac4dd5be2016-10-25 15:11:10335ui::TextInputType ConvertWebTextInputType(blink::WebTextInputType type) {
336 // Check the type is in the range representable by ui::TextInputType.
337 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX))
338 << "blink::WebTextInputType and ui::TextInputType not synchronized";
339 return static_cast<ui::TextInputType>(type);
340}
341
342ui::TextInputMode ConvertWebTextInputMode(blink::WebTextInputMode mode) {
343 // Check the mode is in the range representable by ui::TextInputMode.
344 DCHECK_LE(mode, static_cast<int>(ui::TEXT_INPUT_MODE_MAX))
345 << "blink::WebTextInputMode and ui::TextInputMode not synchronized";
346 return static_cast<ui::TextInputMode>(mode);
347}
348
Mitsuru Oshima3c07b332018-02-06 04:56:50349// Returns true if the device scale is high enough that losing subpixel
350// antialiasing won't have a noticeable effect on text quality.
351static bool DeviceScaleEnsuresTextQuality(float device_scale_factor) {
352#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
353 // On Android, we never have subpixel antialiasing. On Chrome OS we prefer to
354 // composite all scrollers so that we get animated overlay scrollbars.
355 return true;
356#else
357 // 1.5 is a common touchscreen tablet device scale factor. For such
358 // devices main thread antialiasing is a heavy burden.
359 return device_scale_factor >= 1.5f;
360#endif
361}
362
363static bool PreferCompositingToLCDText(CompositorDependencies* compositor_deps,
364 float device_scale_factor) {
365 const base::CommandLine& command_line =
366 *base::CommandLine::ForCurrentProcess();
367 if (command_line.HasSwitch(switches::kDisablePreferCompositingToLCDText))
368 return false;
369 if (command_line.HasSwitch(switches::kEnablePreferCompositingToLCDText))
370 return true;
371 if (!compositor_deps->IsLcdTextEnabled())
372 return true;
373 return DeviceScaleEnsuresTextQuality(device_scale_factor);
374}
375
[email protected]b256eca2013-07-11 10:57:40376} // namespace
377
[email protected]b2e4c70132013-10-03 02:07:51378// RenderWidget ---------------------------------------------------------------
379
danakj829cdd142018-09-14 21:13:27380RenderWidget::RenderWidget(int32_t widget_routing_id,
381 CompositorDependencies* compositor_deps,
danakj6a816592018-09-25 18:30:56382 WidgetType widget_type,
danakj829cdd142018-09-14 21:13:27383 const ScreenInfo& screen_info,
384 blink::WebDisplayMode display_mode,
385 bool swapped_out,
386 bool hidden,
387 bool never_visible,
388 mojom::WidgetRequest widget_request)
nick8331f8ad2016-11-15 20:42:45389 : routing_id_(widget_routing_id),
dcheng35d31c112015-07-22 00:17:36390 compositor_deps_(compositor_deps),
lfg8ff33912016-09-13 20:59:21391 webwidget_internal_(nullptr),
avi40b5be7a2016-03-03 21:13:44392 owner_delegate_(nullptr),
[email protected]847a2582013-03-09 02:29:51393 auto_resize_mode_(false),
initial.commit09911bf2008-07-26 23:55:29394 did_show_(false),
[email protected]1ac10dca2013-08-20 20:47:04395 is_hidden_(hidden),
sievers71c62dd52015-10-07 01:44:39396 compositor_never_visible_(never_visible),
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12397 is_fullscreen_granted_(false),
danakj73dd3032018-07-28 17:49:53398 display_mode_(display_mode),
changwanf2a707b2015-10-30 08:22:16399 ime_event_guard_(nullptr),
[email protected]661eb9d2009-02-03 02:11:48400 closing_(false),
[email protected]aeeedad2014-08-22 18:16:22401 host_closing_(false),
[email protected]14392a52012-05-02 20:28:44402 is_swapped_out_(swapped_out),
dglazkov97b6c2b2016-10-25 17:35:55403 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
[email protected]b256eca2013-07-11 10:57:40404 text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
shuchen82ce8c52014-10-23 01:55:20405 text_input_flags_(0),
AJITH KUMAR V041c0b02017-08-08 10:39:20406 next_previous_flags_(kInvalidNextPreviousFlagsValue),
[email protected]86ba5fcb2013-09-04 00:36:53407 can_compose_inline_(true),
nonafa291792016-08-10 02:36:18408 composition_range_(gfx::Range::InvalidRange()),
danakj6a816592018-09-25 18:30:56409 widget_type_(widget_type),
[email protected]867125a02009-12-10 06:01:48410 pending_window_rect_count_(0),
Scott Violetae08f332018-07-27 17:37:23411 screen_info_(screen_info),
nonafa291792016-08-10 02:36:18412 monitor_composition_info_(false),
[email protected]b2e4c70132013-10-03 02:07:51413 popup_origin_scale_for_emulation_(0.f),
samans26510e442017-06-01 22:29:12414 frame_swap_message_queue_(new FrameSwapMessageQueue(routing_id_)),
[email protected]a09d53ce2014-01-31 00:46:42415 resizing_mode_selector_(new ResizingModeSelector()),
lfge0c2792ec2016-05-11 18:52:08416 has_host_context_menu_location_(false),
ekaramad2a46d632016-07-19 13:33:09417 has_focus_(false),
Nicolas Pena75a35d662018-04-05 20:13:44418 for_oopif_(false),
ekaramad330ba4232016-09-23 17:57:47419#if defined(OS_MACOSX)
420 text_input_client_observer_(new TextInputClientObserver(this)),
421#endif
Takashi SAKAMOTO870f6262017-08-22 04:08:27422 first_update_visual_state_after_hidden_(false),
tasakb95dbb50c2017-02-08 18:07:50423 was_shown_time_(base::TimeTicks::Now()),
kenrb5d78b842017-03-06 21:06:01424 current_content_source_id_(0),
Dave Tapuska1bdf1832017-07-07 18:07:19425 widget_binding_(this, std::move(widget_request)),
wjmaclean1d970622017-01-21 22:28:24426 weak_ptr_factory_(this) {
nick8331f8ad2016-11-15 20:42:45427 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
[email protected]380244092011-10-07 17:26:27428 DCHECK(RenderThread::Get());
alexclarke7fa93942015-10-21 15:37:11429
430 // In tests there may not be a RenderThreadImpl.
431 if (RenderThreadImpl::current()) {
432 render_widget_scheduling_state_ = RenderThreadImpl::current()
Yuta Kitamura3331f5c2018-04-05 11:12:25433 ->GetWebMainThreadScheduler()
dcheng07945f632015-12-26 07:59:32434 ->NewRenderWidgetSchedulingState();
alexclarke7fa93942015-10-21 15:37:11435 render_widget_scheduling_state_->SetHidden(is_hidden_);
436 }
sadrul602ce1362017-01-26 06:41:10437#if defined(USE_AURA)
fsamuel098eade2017-03-21 18:06:14438 RendererWindowTreeClient::CreateIfNecessary(routing_id_);
Scott Violete46b3352018-09-22 00:37:07439 if (features::IsMultiProcessMash())
Scott Violet1098538e2017-10-05 19:23:33440 RendererWindowTreeClient::Get(routing_id_)->SetVisible(!is_hidden_);
sadrul602ce1362017-01-26 06:41:10441#endif
Albert J. Wongcb004632018-07-10 22:58:25442
443 if (routing_id_ != MSG_ROUTING_NONE)
444 g_routing_id_widget_map.Get().emplace(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29445}
446
447RenderWidget::~RenderWidget() {
lfg8ff33912016-09-13 20:59:21448 DCHECK(!webwidget_internal_) << "Leaking our WebWidget!";
Albert J. Wongcb004632018-07-10 22:58:25449 // TODO(ajwong): Add in check that routing_id_ has been removed from
450 // g_routing_id_widget_map once the shutdown semantics for RenderWidget
451 // and RenderViewImpl are rationalized. Currently, too many unit and
452 // browser tests delete a RenderWidget without correclty going through
453 // the shutdown. https://crbug.com/545684
[email protected]bffc8302014-01-23 20:52:16454
dtapuska9ec1a912017-04-21 15:18:31455 if (input_event_queue_)
456 input_event_queue_->ClearClient();
457
sadrul8185d972017-01-31 18:30:11458#if defined(USE_AURA)
fsamuel098eade2017-03-21 18:06:14459 // It is possible for a RenderWidget to be destroyed before it was embedded
460 // in a mus window. The RendererWindowTreeClient will leak in such cases. So
461 // explicitly delete it here.
462 RendererWindowTreeClient::Destroy(routing_id_);
sadrul8185d972017-01-31 18:30:11463#endif
initial.commit09911bf2008-07-26 23:55:29464}
465
[email protected]484955942010-08-19 16:13:18466// static
Albert J. Wongcb004632018-07-10 22:58:25467RenderWidget* RenderWidget::FromRoutingID(int32_t routing_id) {
468 RoutingIDWidgetMap* widgets = g_routing_id_widget_map.Pointer();
jdoerrie5a73d0fa2018-10-02 23:54:05469 auto it = widgets->find(routing_id);
Albert J. Wongcb004632018-07-10 22:58:25470 return it == widgets->end() ? NULL : it->second;
471}
472
danakj25ec6e2b2018-09-26 17:01:31473void RenderWidget::InitForPopup(ShowCallback show_callback,
474 blink::WebPagePopup* web_page_popup) {
475 // Init() increments the reference count on |this|, making it
476 // self-referencing.
477 Init(std::move(show_callback), web_page_popup);
initial.commit09911bf2008-07-26 23:55:29478}
479
danakj6a816592018-09-25 18:30:56480void RenderWidget::InitForChildLocalRoot(
481 blink::WebFrameWidget* web_frame_widget) {
482 for_oopif_ = true;
483 // Init() increments the reference count on |this|, making it
484 // self-referencing.
485 Init(base::NullCallback(), web_frame_widget);
dchengda9b4bb2015-07-20 20:58:08486}
487
dchengda9b4bb2015-07-20 20:58:08488void RenderWidget::CloseForFrame() {
danakja2c9d0a92018-07-25 20:01:18489 if (owner_delegate_) {
490 owner_delegate_->OverrideCloseForWidget();
491 return;
492 }
dchengd96a27a2015-07-24 20:17:32493 OnClose();
kenrba7199832015-01-22 23:44:59494}
495
alexmos78c9c0d2016-10-14 18:57:03496void RenderWidget::SetSwappedOut(bool is_swapped_out) {
497 // We should only toggle between states.
498 DCHECK(is_swapped_out_ != is_swapped_out);
499 is_swapped_out_ = is_swapped_out;
alexmos78c9c0d2016-10-14 18:57:03500}
501
Scott Violetae08f332018-07-27 17:37:23502void RenderWidget::Init(ShowCallback show_callback, WebWidget* web_widget) {
lfg8ff33912016-09-13 20:59:21503 DCHECK(!webwidget_internal_);
nick4df698d82016-11-11 20:39:23504 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29505
Jeremy Roman04f27c372017-10-27 15:20:55506 input_handler_ = std::make_unique<RenderWidgetInputHandler>(this, this);
nick8331f8ad2016-11-15 20:42:45507
Dave Tapuska04bc5ee92018-04-17 19:03:31508 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
Dave Tapuska9db80842017-07-24 17:24:26509
danakj31699d5b2018-09-18 15:39:17510 blink::scheduler::WebThreadScheduler* main_thread_scheduler = nullptr;
511 if (render_thread_impl)
512 main_thread_scheduler = render_thread_impl->GetWebMainThreadScheduler();
Alexander Timin41e917d2018-07-02 16:25:35513 blink::scheduler::WebThreadScheduler* compositor_thread_scheduler =
514 blink::scheduler::WebThreadScheduler::CompositorThreadScheduler();
danakj31699d5b2018-09-18 15:39:17515 scoped_refptr<base::SingleThreadTaskRunner> compositor_input_task_runner;
516 // The |compositor_thread_scheduler| can be null in tests without a compositor
517 // thread.
518 if (compositor_thread_scheduler) {
519 // When the RenderWidget is for a frame (ie for a local root) then it uses
520 // the compositor thread task runner. When it is for a popup, it does not.
521 // When |owner_delegate_| is true, the RenderWidget is attached to the main
522 // Frame (which makes it a local root). Otherwise, if it is |for_oopif_|
523 // then it is a local root (a local Frame) sitting below a remote Frame.
524 if (owner_delegate_ || for_oopif_) {
525 compositor_input_task_runner =
526 compositor_thread_scheduler->InputTaskRunner();
527 }
528 }
Alexander Timin41e917d2018-07-02 16:25:35529
Dave Tapuska04bc5ee92018-04-17 19:03:31530 widget_input_handler_manager_ = WidgetInputHandlerManager::Create(
danakj31699d5b2018-09-18 15:39:17531 weak_ptr_factory_.GetWeakPtr(), std::move(compositor_input_task_runner),
532 main_thread_scheduler);
Dave Tapuska9db80842017-07-24 17:24:26533
danakjdf1ceb72018-07-18 20:02:25534 show_callback_ = std::move(show_callback);
initial.commit09911bf2008-07-26 23:55:29535
lfg8ff33912016-09-13 20:59:21536 webwidget_internal_ = web_widget;
537 webwidget_mouse_lock_target_.reset(
538 new WebWidgetLockTarget(webwidget_internal_));
lfgbee1e0a2016-06-08 21:24:21539 mouse_lock_dispatcher_.reset(new RenderWidgetMouseLockDispatcher(this));
initial.commit09911bf2008-07-26 23:55:29540
nick4df698d82016-11-11 20:39:23541 RenderThread::Get()->AddRoute(routing_id_, this);
542 // Take a reference on behalf of the RenderThread. This will be balanced
Albert J. Wong3c93c182018-09-27 17:29:43543 // when we receive WidgetMsg_Close.
nick4df698d82016-11-11 20:39:23544 AddRef();
545 if (RenderThreadImpl::current()) {
546 RenderThreadImpl::current()->WidgetCreated();
547 if (is_hidden_)
548 RenderThreadImpl::current()->WidgetHidden();
initial.commit09911bf2008-07-26 23:55:29549 }
550}
551
danakj53802692018-07-25 21:46:44552void RenderWidget::ApplyEmulatedScreenMetricsForPopupWidget(
553 RenderWidget* origin_widget) {
554 RenderWidgetScreenMetricsEmulator* emulator =
555 origin_widget->screen_metrics_emulator_.get();
556 if (!emulator)
557 return;
[email protected]b2e4c70132013-10-03 02:07:51558 popup_origin_scale_for_emulation_ = emulator->scale();
[email protected]19193682014-04-03 15:01:43559 popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
Pavel Feldmancc099f72017-07-20 23:09:00560 popup_screen_origin_for_emulation_ =
Lei Zhang9b359d32017-11-28 00:57:02561 emulator->original_screen_rect().origin();
Fady Samuel4255c182018-05-24 20:42:36562 UpdateSurfaceAndScreenInfo(local_surface_id_from_parent_,
563 compositor_viewport_pixel_size_,
Christopher Camerone9a30c12018-03-07 08:23:38564 emulator->original_screen_info());
[email protected]b2e4c70132013-10-03 02:07:51565}
566
[email protected]2d6836f42014-07-02 17:25:31567gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) {
568 if (screen_metrics_emulator_)
569 return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor);
570 return anchor;
571}
572
thakis18e426412017-03-15 12:06:37573#if BUILDFLAG(USE_EXTERNAL_POPUP_MENU)
[email protected]b2e4c70132013-10-03 02:07:51574void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
mfomitchev2600fd7c2016-02-17 20:53:39575 ExternalPopupMenu* popup,
576 RenderWidgetScreenMetricsEmulator* emulator) {
Pavel Feldmancc099f72017-07-20 23:09:00577 popup->SetOriginScaleForEmulation(emulator->scale());
[email protected]b2e4c70132013-10-03 02:07:51578}
[email protected]53907862014-03-25 15:42:40579#endif
[email protected]b2e4c70132013-10-03 02:07:51580
581void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
582 if (screen_metrics_emulator_)
583 screen_metrics_emulator_->OnShowContextMenu(params);
584}
585
[email protected]a95986a82010-12-24 06:19:28586bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
ekaramad330ba4232016-09-23 17:57:47587#if defined(OS_MACOSX)
588 if (IPC_MESSAGE_CLASS(message) == TextInputClientMsgStart)
589 return text_input_client_observer_->OnMessageReceived(message);
590#endif
lfgbee1e0a2016-06-08 21:24:21591 if (mouse_lock_dispatcher_ &&
592 mouse_lock_dispatcher_->OnMessageReceived(message))
593 return true;
594
[email protected]a95986a82010-12-24 06:19:28595 bool handled = true;
596 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
Albert J. Wong3c93c182018-09-27 17:29:43597 IPC_MESSAGE_HANDLER(WidgetMsg_ShowContextMenu, OnShowContextMenu)
598 IPC_MESSAGE_HANDLER(WidgetMsg_Close, OnClose)
599 IPC_MESSAGE_HANDLER(WidgetMsg_SynchronizeVisualProperties,
Fady Samuel799e72192018-04-25 21:16:57600 OnSynchronizeVisualProperties)
Albert J. Wong3c93c182018-09-27 17:29:43601 IPC_MESSAGE_HANDLER(WidgetMsg_EnableDeviceEmulation,
dgozman9260b0a12015-03-16 13:45:20602 OnEnableDeviceEmulation)
Albert J. Wong3c93c182018-09-27 17:29:43603 IPC_MESSAGE_HANDLER(WidgetMsg_DisableDeviceEmulation,
dgozman9260b0a12015-03-16 13:45:20604 OnDisableDeviceEmulation)
Albert J. Wong3c93c182018-09-27 17:29:43605 IPC_MESSAGE_HANDLER(WidgetMsg_WasHidden, OnWasHidden)
606 IPC_MESSAGE_HANDLER(WidgetMsg_WasShown, OnWasShown)
607 IPC_MESSAGE_HANDLER(WidgetMsg_SetActive, OnSetActive)
608 IPC_MESSAGE_HANDLER(WidgetMsg_SetBackgroundOpaque, OnSetBackgroundOpaque)
609 IPC_MESSAGE_HANDLER(WidgetMsg_SetTextDirection, OnSetTextDirection)
610 IPC_MESSAGE_HANDLER(WidgetMsg_SetBounds_ACK, OnRequestSetBoundsAck)
611 IPC_MESSAGE_HANDLER(WidgetMsg_UpdateScreenRects, OnUpdateScreenRects)
612 IPC_MESSAGE_HANDLER(WidgetMsg_ForceRedraw, OnForceRedraw)
613 IPC_MESSAGE_HANDLER(WidgetMsg_SetViewportIntersection,
kenrbea731792017-01-13 15:10:48614 OnSetViewportIntersection)
Albert J. Wong3c93c182018-09-27 17:29:43615 IPC_MESSAGE_HANDLER(WidgetMsg_SetIsInert, OnSetIsInert)
616 IPC_MESSAGE_HANDLER(WidgetMsg_SetInheritedEffectiveTouchAction,
sunxd540a9962018-05-24 22:51:06617 OnSetInheritedEffectiveTouchAction)
Albert J. Wong3c93c182018-09-27 17:29:43618 IPC_MESSAGE_HANDLER(WidgetMsg_UpdateRenderThrottlingStatus,
Ken Buchanan8a319fb2017-11-15 18:37:12619 OnUpdateRenderThrottlingStatus)
Albert J. Wong3c93c182018-09-27 17:29:43620 IPC_MESSAGE_HANDLER(WidgetMsg_WaitForNextFrameForTests,
lfg43e08e62016-02-03 18:51:37621 OnWaitNextFrameForTests)
paulmeyer90f6c31d2016-11-12 00:17:59622 IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter)
623 IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver, OnDragTargetDragOver)
624 IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave, OnDragTargetDragLeave)
625 IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop)
paulmeyer8fc8ea92016-11-15 05:12:21626 IPC_MESSAGE_HANDLER(DragMsg_SourceEnded, OnDragSourceEnded)
627 IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded,
628 OnDragSourceSystemDragEnded)
[email protected]a95986a82010-12-24 06:19:28629 IPC_MESSAGE_UNHANDLED(handled = false)
630 IPC_END_MESSAGE_MAP()
631 return handled;
632}
initial.commit09911bf2008-07-26 23:55:29633
634bool RenderWidget::Send(IPC::Message* message) {
Nasko Oskovf97e8b02017-07-25 02:45:42635 // Don't send any messages after the browser has told us to close, and filter
636 // most outgoing messages while swapped out.
637 if ((is_swapped_out_ &&
638 !SwappedOutMessages::CanSendWhileSwappedOut(message)) ||
639 closing_) {
initial.commit09911bf2008-07-26 23:55:29640 delete message;
641 return false;
642 }
643
644 // If given a messsage without a routing ID, then assign our routing ID.
645 if (message->routing_id() == MSG_ROUTING_NONE)
646 message->set_routing_id(routing_id_);
647
[email protected]380244092011-10-07 17:26:27648 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44649}
650
dtapuska014ed082016-11-11 21:58:48651void RenderWidget::SendOrCrash(IPC::Message* message) {
652 bool result = Send(message);
653 CHECK(closing_ || result) << "Failed to send message";
654}
655
ekaramad5aff1942017-01-06 01:26:35656bool RenderWidget::ShouldHandleImeEvents() const {
ekaramadb6483a052017-02-10 02:23:26657 // TODO(ekaramad): We track page focus in all RenderViews on the page but the
658 // RenderWidgets corresponding to OOPIFs do not get the update. For now, this
659 // method returns true when the RenderWidget is for an OOPIF, i.e., IME events
660 // will be processed regardless of page focus. We should revisit this after
661 // page focus for OOPIFs has been fully resolved (https://crbug.com/689777).
Blink Reformat1c4d759e2017-04-09 16:34:54662 return GetWebWidget() && GetWebWidget()->IsWebFrameWidget() &&
ekaramadb6483a052017-02-10 02:23:26663 (has_focus_ || for_oopif_);
ekaramad5aff1942017-01-06 01:26:35664}
665
initial.commit09911bf2008-07-26 23:55:29666void RenderWidget::OnClose() {
dchengd96a27a2015-07-24 20:17:32667 DCHECK(content::RenderThread::Get());
668 if (closing_)
669 return;
670 NotifyOnClose();
671 closing_ = true;
672
673 // Browser correspondence is no longer needed at this point.
674 if (routing_id_ != MSG_ROUTING_NONE) {
675 RenderThread::Get()->RemoveRoute(routing_id_);
Albert J. Wongcb004632018-07-10 22:58:25676 g_routing_id_widget_map.Get().erase(routing_id_);
dchengd96a27a2015-07-24 20:17:32677 SetHidden(false);
678 if (RenderThreadImpl::current())
679 RenderThreadImpl::current()->WidgetDestroyed();
680 }
681
682 if (for_oopif_) {
683 // Widgets for frames may be created and closed at any time while the frame
Ken Buchananed449bb2018-02-01 21:02:05684 // is alive. However, WebWidget must be closed synchronously because frame
685 // widgets and frames hold pointers to each other. The deferred call to
686 // Close() will complete cleanup and release |this|, but CloseWebWidget()
687 // prevents Close() from attempting to access members of an
688 // already-deleted frame.
689 CloseWebWidget();
dchengd96a27a2015-07-24 20:17:32690 }
Ken Buchananed449bb2018-02-01 21:02:05691 // If there is a Send call on the stack, then it could be dangerous to close
692 // now. Post a task that only gets invoked when there are no nested message
693 // loops.
Hajime Hoshi315a61f2018-08-14 17:27:28694 GetCleanupTaskRunner()->PostNonNestableTask(
695 FROM_HERE, base::BindOnce(&RenderWidget::Close, this));
dchengd96a27a2015-07-24 20:17:32696
697 // Balances the AddRef taken when we called AddRoute.
698 Release();
initial.commit09911bf2008-07-26 23:55:29699}
700
Fady Samuel799e72192018-04-25 21:16:57701void RenderWidget::OnSynchronizeVisualProperties(
danakja2c9d0a92018-07-25 20:01:18702 const VisualProperties& original_params) {
703 TRACE_EVENT0("renderer", "RenderWidget::OnSynchronizeVisualProperties");
EhsanKbd2cea992017-11-23 18:49:08704
danakja2c9d0a92018-07-25 20:01:18705 VisualProperties params = original_params;
706 if (owner_delegate_) {
707 owner_delegate_->ApplyNewSizeForWidget(size_, params.new_size);
708
709 if (display_mode_ != params.display_mode) {
710 display_mode_ = params.display_mode;
711 owner_delegate_->ApplyNewDisplayModeForWidget(params.display_mode);
712 }
713
714 bool auto_resize_mode_changed =
715 auto_resize_mode_ != params.auto_resize_enabled;
716 auto_resize_mode_ = params.auto_resize_enabled;
717 min_size_for_auto_resize_ = params.min_size_for_auto_resize;
718 max_size_for_auto_resize_ = params.max_size_for_auto_resize;
719
720 if (auto_resize_mode_) {
721 gfx::Size min_auto_size = min_size_for_auto_resize_;
722 gfx::Size max_auto_size = max_size_for_auto_resize_;
723 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
724 min_auto_size = gfx::ScaleToCeiledSize(
725 min_auto_size, params.screen_info.device_scale_factor);
726 max_auto_size = gfx::ScaleToCeiledSize(
727 max_auto_size, params.screen_info.device_scale_factor);
728 }
729 owner_delegate_->ApplyAutoResizeLimitsForWidget(min_auto_size,
730 max_auto_size);
731 } else if (auto_resize_mode_changed) {
732 owner_delegate_->DisableAutoResizeForWidget();
733 if (params.new_size.IsEmpty())
734 return;
735 }
736
737 browser_controls_shrink_blink_size_ =
738 params.browser_controls_shrink_blink_size;
739 top_controls_height_ = params.top_controls_height;
740 bottom_controls_height_ = params.bottom_controls_height;
741
742 // TODO(fsamuel): Modifies the |params| that are used for
743 // SynchronizeVisualProperties(), but does not used this modified
744 // device_scale_factor for the auto-resize values, which is probably a bug.
745 if (device_scale_factor_for_testing_) {
746 params.screen_info.device_scale_factor =
747 *device_scale_factor_for_testing_;
748 params.compositor_viewport_pixel_size = gfx::ScaleToCeiledSize(
749 params.new_size, params.screen_info.device_scale_factor);
750 }
[email protected]b2e4c70132013-10-03 02:07:51751 }
752
danakja2c9d0a92018-07-25 20:01:18753 if (!resizing_mode_selector_->ShouldAbortOnResize(this, params)) {
754 if (screen_metrics_emulator_) {
755 screen_metrics_emulator_->OnSynchronizeVisualProperties(params);
756 } else {
757 gfx::Size old_visible_viewport_size = visible_viewport_size_;
758 SynchronizeVisualProperties(params);
759 if (old_visible_viewport_size != visible_viewport_size_) {
760 for (auto& render_frame : render_frames_)
761 render_frame.DidChangeVisibleViewport();
762 }
763 }
Fady Samuel799e72192018-04-25 21:16:57764 }
765
danakja2c9d0a92018-07-25 20:01:18766 if (owner_delegate_ && params.scroll_focused_node_into_view)
767 owner_delegate_->ScrollFocusedNodeIntoViewForWidget();
initial.commit09911bf2008-07-26 23:55:29768}
769
dgozman9260b0a12015-03-16 13:45:20770void RenderWidget::OnEnableDeviceEmulation(
Lei Zhang9b359d32017-11-28 00:57:02771 const blink::WebDeviceEmulationParams& params) {
mfomitchev2600fd7c2016-02-17 20:53:39772 if (!screen_metrics_emulator_) {
Fady Samuel4255c182018-05-24 20:42:36773 VisualProperties visual_properties;
774 visual_properties.screen_info = screen_info_;
775 visual_properties.new_size = size_;
776 visual_properties.compositor_viewport_pixel_size =
Christopher Cameronaad15a0d2018-03-09 03:47:33777 compositor_viewport_pixel_size_;
Fady Samuel4255c182018-05-24 20:42:36778 visual_properties.local_surface_id = local_surface_id_from_parent_;
779 visual_properties.visible_viewport_size = visible_viewport_size_;
780 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
781 visual_properties.display_mode = display_mode_;
mfomitchev2600fd7c2016-02-17 20:53:39782 screen_metrics_emulator_.reset(new RenderWidgetScreenMetricsEmulator(
Albert J. Wong3c93c182018-09-27 17:29:43783 this, params, visual_properties, widget_screen_rect_,
Fady Samuel4255c182018-05-24 20:42:36784 window_screen_rect_));
oshima50872a72016-03-04 13:26:18785 screen_metrics_emulator_->Apply();
mfomitchev2600fd7c2016-02-17 20:53:39786 } else {
dgozman9260b0a12015-03-16 13:45:20787 screen_metrics_emulator_->ChangeEmulationParams(params);
mfomitchev2600fd7c2016-02-17 20:53:39788 }
dgozman9260b0a12015-03-16 13:45:20789}
790
791void RenderWidget::OnDisableDeviceEmulation() {
792 screen_metrics_emulator_.reset();
793}
794
initial.commit09911bf2008-07-26 23:55:29795void RenderWidget::OnWasHidden() {
[email protected]9c3085f2011-06-09 02:10:31796 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
initial.commit09911bf2008-07-26 23:55:29797 // Go into a mode where we stop generating paint and scrolling events.
[email protected]bee16aab2009-08-26 15:55:03798 SetHidden(true);
ericwilligers88e69742016-10-17 19:29:55799 for (auto& observer : render_frames_)
800 observer.WasHidden();
initial.commit09911bf2008-07-26 23:55:29801}
802
danakj1574cf42018-09-26 21:43:14803void RenderWidget::OnWasShown(base::TimeTicks show_request_timestamp) {
[email protected]9e2e4632012-07-27 16:38:41804 TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
initial.commit09911bf2008-07-26 23:55:29805 // During shutdown we can just ignore this message.
lfg8ff33912016-09-13 20:59:21806 if (!GetWebWidget())
initial.commit09911bf2008-07-26 23:55:29807 return;
808
tasakb95dbb50c2017-02-08 18:07:50809 was_shown_time_ = base::TimeTicks::Now();
initial.commit09911bf2008-07-26 23:55:29810 // See OnWasHidden
[email protected]bee16aab2009-08-26 15:55:03811 SetHidden(false);
ericwilligers88e69742016-10-17 19:29:55812 for (auto& observer : render_frames_)
813 observer.WasShown();
initial.commit09911bf2008-07-26 23:55:29814
danakja6c10012018-07-06 14:25:36815 if (layer_tree_view_ && !show_request_timestamp.is_null()) {
816 layer_tree_view_->layer_tree_host()->RequestPresentationTimeForNextFrame(
Sadrul Habib Chowdhury8bc43cc2018-06-06 01:48:03817 CreateTabSwitchingTimeRecorder(show_request_timestamp));
[email protected]3399dd822014-08-09 11:14:24818 }
initial.commit09911bf2008-07-26 23:55:29819}
820
Avi Drissman014dec72018-06-07 02:34:01821void RenderWidget::OnRequestSetBoundsAck() {
[email protected]53d3f302009-12-21 04:42:05822 DCHECK(pending_window_rect_count_);
823 pending_window_rect_count_--;
824}
825
Albert J. Wongcb004632018-07-10 22:58:25826void RenderWidget::OnForceRedraw(int snapshot_id) {
827 if (LayerTreeView* ltv = layer_tree_view()) {
828 ltv->layer_tree_host()->RequestPresentationTimeForNextFrame(
829 base::BindOnce(&RenderWidget::DidPresentForceDrawFrame,
830 weak_ptr_factory_.GetWeakPtr(), snapshot_id));
831 ltv->SetNeedsForcedRedraw();
832 }
833}
834
835void RenderWidget::DidPresentForceDrawFrame(
836 int snapshot_id,
837 const gfx::PresentationFeedback& feedback) {
Albert J. Wong3c93c182018-09-27 17:29:43838 Send(new WidgetHostMsg_ForceRedrawComplete(routing_id(), snapshot_id));
Albert J. Wongcb004632018-07-10 22:58:25839}
840
Ken Buchanan44d7e2f2018-08-23 14:18:05841viz::FrameSinkId RenderWidget::GetFrameSinkIdAtPoint(const gfx::Point& point,
842 gfx::PointF* local_point) {
843 return input_handler_->GetFrameSinkIdAtPoint(point, local_point);
Navid Zolghadr0d86e5f2017-10-23 18:09:22844}
845
Dave Tapuskaea83d3bd2017-06-13 16:14:55846void RenderWidget::HandleInputEvent(
dtapuska9ec1a912017-04-21 15:18:31847 const blink::WebCoalescedInputEvent& input_event,
848 const ui::LatencyInfo& latency_info,
Dave Tapuskaea83d3bd2017-06-13 16:14:55849 HandledEventCallback callback) {
danakja2c9d0a92018-07-25 20:01:18850 if (owner_delegate_ && is_swapped_out_) {
851 std::move(callback).Run(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, latency_info,
852 nullptr, base::nullopt);
853 return;
854 }
Dave Tapuskaea83d3bd2017-06-13 16:14:55855 input_handler_->HandleInputEvent(input_event, latency_info,
856 std::move(callback));
dtapuska9ec1a912017-04-21 15:18:31857}
858
dtapuska9d46ef7d2017-05-26 19:06:06859scoped_refptr<MainThreadEventQueue> RenderWidget::GetInputEventQueue() {
860 return input_event_queue_;
861}
862
fsamuel78f86e42016-01-20 04:10:23863void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
lfg8ff33912016-09-13 20:59:21864 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:54865 GetWebWidget()->SetCursorVisibilityState(is_visible);
fsamuel78f86e42016-01-20 04:10:23866}
867
868void RenderWidget::OnMouseCaptureLost() {
lfg8ff33912016-09-13 20:59:21869 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:54870 GetWebWidget()->MouseCaptureLost();
fsamuel78f86e42016-01-20 04:10:23871}
872
alexmos56567492016-09-13 00:52:46873void RenderWidget::OnSetEditCommandsForNextKeyEvent(
874 const EditCommands& edit_commands) {
875 edit_commands_ = edit_commands;
876}
877
Albert J. Wongcb004632018-07-10 22:58:25878void RenderWidget::OnSetActive(bool active) {
879 if (owner_delegate_)
danakja2c9d0a92018-07-25 20:01:18880 owner_delegate_->SetActiveForWidget(active);
Albert J. Wongcb004632018-07-10 22:58:25881}
882
883void RenderWidget::OnSetBackgroundOpaque(bool opaque) {
danakj0ba0e7b2018-09-25 19:37:13884 // Background opaque-ness modification is only supported for the main frame.
885 // The |owner_delegate_| is used as proxy for this RenderWidget being attached
886 // to the main frame.
887 if (!owner_delegate_)
888 return;
889
890 blink::WebWidget* web_widget = GetWebWidget();
891 // This is true since we only do this for RenderWidgets attached to the main
892 // frame.
893 DCHECK(web_widget->IsWebFrameWidget());
894 auto* web_frame_widget = static_cast<blink::WebFrameWidget*>(web_widget);
895 if (opaque) {
896 web_frame_widget->ClearBaseBackgroundColorOverride();
897 web_frame_widget->ClearBackgroundColorOverride();
898 } else {
899 web_frame_widget->SetBaseBackgroundColorOverride(SK_ColorTRANSPARENT);
900 web_frame_widget->SetBackgroundColorOverride(SK_ColorTRANSPARENT);
901 }
Albert J. Wongcb004632018-07-10 22:58:25902}
903
fsamuel78f86e42016-01-20 04:10:23904void RenderWidget::OnSetFocus(bool enable) {
danakja2c9d0a92018-07-25 20:01:18905 if (owner_delegate_)
906 owner_delegate_->DidReceiveSetFocusEventForWidget();
907 SetFocus(enable);
908}
909
910void RenderWidget::SetFocus(bool enable) {
lfge0c2792ec2016-05-11 18:52:08911 has_focus_ = enable;
912
lfg8ff33912016-09-13 20:59:21913 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:54914 GetWebWidget()->SetFocus(enable);
lfge0c2792ec2016-05-11 18:52:08915
ericwilligers88e69742016-10-17 19:29:55916 for (auto& observer : render_frames_)
917 observer.RenderWidgetSetFocus(enable);
danakja2c9d0a92018-07-25 20:01:18918
919 if (owner_delegate_)
920 owner_delegate_->DidChangeFocusForWidget();
fsamuel78f86e42016-01-20 04:10:23921}
922
dtapuska3d5624d32016-08-30 04:34:00923void RenderWidget::SetNeedsMainFrame() {
danakja6c10012018-07-06 14:25:36924 LayerTreeView* ltv = layer_tree_view();
925 if (!ltv)
dtapuska3d5624d32016-08-30 04:34:00926 return;
danakja6c10012018-07-06 14:25:36927 ltv->SetNeedsBeginFrame();
dtapuska3d5624d32016-08-30 04:34:00928}
929
fsamuel78f86e42016-01-20 04:10:23930///////////////////////////////////////////////////////////////////////////////
danakja6c10012018-07-06 14:25:36931// LayerTreeViewDelegate
fsamuel78f86e42016-01-20 04:10:23932
933void RenderWidget::ApplyViewportDeltas(
934 const gfx::Vector2dF& inner_delta,
935 const gfx::Vector2dF& outer_delta,
936 const gfx::Vector2dF& elastic_overscroll_delta,
937 float page_scale,
938 float top_controls_delta) {
Ken Buchananed449bb2018-02-01 21:02:05939 if (!GetWebWidget())
940 return;
Blink Reformat1c4d759e2017-04-09 16:34:54941 GetWebWidget()->ApplyViewportDeltas(inner_delta, outer_delta,
lfg8ff33912016-09-13 20:59:21942 elastic_overscroll_delta, page_scale,
943 top_controls_delta);
fsamuel78f86e42016-01-20 04:10:23944}
945
sahel1b47fda72017-03-28 17:03:07946void RenderWidget::RecordWheelAndTouchScrollingCount(
947 bool has_scrolled_by_wheel,
948 bool has_scrolled_by_touch) {
Ken Buchananed449bb2018-02-01 21:02:05949 if (!GetWebWidget())
950 return;
Blink Reformat1c4d759e2017-04-09 16:34:54951 GetWebWidget()->RecordWheelAndTouchScrollingCount(has_scrolled_by_wheel,
sahel1b47fda72017-03-28 17:03:07952 has_scrolled_by_touch);
953}
954
Daniel Cheng224569ee2018-04-25 05:45:06955void RenderWidget::BeginMainFrame(base::TimeTicks frame_time) {
Ken Buchananed449bb2018-02-01 21:02:05956 if (!GetWebWidget())
957 return;
Daniel Cheng224569ee2018-04-25 05:45:06958 if (input_event_queue_)
959 input_event_queue_->DispatchRafAlignedInput(frame_time);
dtapuska3d5624d32016-08-30 04:34:00960
Daniel Cheng224569ee2018-04-25 05:45:06961 GetWebWidget()->BeginFrame(frame_time);
fsamuel78f86e42016-01-20 04:10:23962}
963
danakjc7afae52017-06-20 21:12:41964void RenderWidget::RequestNewLayerTreeFrameSink(
danakja6c10012018-07-06 14:25:36965 LayerTreeFrameSinkCallback callback) {
lfg8ff33912016-09-13 20:59:21966 DCHECK(GetWebWidget());
[email protected]7912e822014-04-16 02:37:03967 // For widgets that are never visible, we don't start the compositor, so we
danakjc7afae52017-06-20 21:12:41968 // never get a request for a cc::LayerTreeFrameSink.
sievers71c62dd52015-10-07 01:44:39969 DCHECK(!compositor_never_visible_);
jonrossa2ff4f82018-02-16 17:27:46970
971 // TODO(jonross): have this generated by the LayerTreeFrameSink itself, which
972 // would then handle binding.
973 mojom::RenderFrameMetadataObserverPtr ptr;
974 mojom::RenderFrameMetadataObserverRequest request = mojo::MakeRequest(&ptr);
975 mojom::RenderFrameMetadataObserverClientPtrInfo client_info;
976 mojom::RenderFrameMetadataObserverClientRequest client_request =
977 mojo::MakeRequest(&client_info);
danakj4b347212018-07-04 17:55:17978 auto render_frame_metadata_observer =
979 std::make_unique<RenderFrameMetadataObserverImpl>(std::move(request),
980 std::move(client_info));
danakja6c10012018-07-06 14:25:36981 layer_tree_view_->SetRenderFrameObserver(
danakj4b347212018-07-04 17:55:17982 std::move(render_frame_metadata_observer));
danakjc7afae52017-06-20 21:12:41983 RenderThreadImpl::current()->RequestNewLayerTreeFrameSink(
danakjab9ef4d2017-10-31 23:38:33984 routing_id_, frame_swap_message_queue_, GetURLForGraphicsContext3D(),
danakja6c10012018-07-06 14:25:36985 std::move(callback), std::move(client_request), std::move(ptr));
[email protected]ba91a792013-02-06 09:48:28986}
987
fsamuel78f86e42016-01-20 04:10:23988void RenderWidget::DidCommitAndDrawCompositorFrame() {
989 // NOTE: Tests may break if this event is renamed or moved. See
990 // tab_capture_performancetest.cc.
991 TRACE_EVENT0("gpu", "RenderWidget::DidCommitAndDrawCompositorFrame");
lfge0c2792ec2016-05-11 18:52:08992
ericwilligers88e69742016-10-17 19:29:55993 for (auto& observer : render_frames_)
994 observer.DidCommitAndDrawCompositorFrame();
lfge0c2792ec2016-05-11 18:52:08995
fsamuel78f86e42016-01-20 04:10:23996 // Notify subclasses that we initiated the paint operation.
997 DidInitiatePaint();
Yiming Zhou0f8836c22018-09-13 22:22:11998
999 Send(new ViewHostMsg_DidCommitAndDrawCompositorFrame(routing_id_));
fsamuel78f86e42016-01-20 04:10:231000}
1001
Saman Sami766e0b02018-01-31 17:19:201002void RenderWidget::DidCommitCompositorFrame() {
danakja2c9d0a92018-07-25 20:01:181003 if (owner_delegate_)
1004 owner_delegate_->DidCommitCompositorFrameForWidget();
Saman Sami766e0b02018-01-31 17:19:201005}
fsamuel78f86e42016-01-20 04:10:231006
danakja2c9d0a92018-07-25 20:01:181007void RenderWidget::DidCompletePageScaleAnimation() {
1008 if (owner_delegate_)
1009 owner_delegate_->DidCompletePageScaleAnimationForWidget();
1010}
fsamuel78f86e42016-01-20 04:10:231011
fsamuel78f86e42016-01-20 04:10:231012bool RenderWidget::IsClosing() const {
Albert J. Wongcb004632018-07-10 22:58:251013 // TODO(ajwong): There is oddly 2 closing states. This API is used by
1014 // LayerTreeView only as part of the LayerTreeViewDelegate interface and
1015 // is the guard against creating new compositor frames unnecessarily.
1016 // Historically, when RenderViewImpl and RenderWidget shared the same
1017 // routing id, it was possible for |closing_| to be true, |host_closing_| to
1018 // false, and for the code in
1019 // RenderThreadImpl::RequestNewLayerTreeFrameSink() to still look up a valid
1020 // RenderViewImpl from the routing id. This is actually a benign shutdown
1021 // race in Android that can be triggered in the SynchronouslyComposite path
1022 // via AwContentsGarbageCollectionTest#testCreateAndGcManyTimes.
1023 //
1024 // Once RenderViewImpl and RenderWidget are split, attempt to combine two
1025 // states so the shutdown logic is cleaner.
1026 //
1027 // http://crbug.com/545684
1028 return host_closing_ || closing_;
fsamuel78f86e42016-01-20 04:10:231029}
1030
danakj53eccbc2016-03-02 22:51:071031void RenderWidget::RequestScheduleAnimation() {
danakja2c9d0a92018-07-25 20:01:181032 if (owner_delegate_) {
1033 owner_delegate_->RequestScheduleAnimationForWidget();
1034 return;
1035 }
Blink Reformat1c4d759e2017-04-09 16:34:541036 ScheduleAnimation();
initial.commit09911bf2008-07-26 23:55:291037}
1038
Robert Flack3ef2ffb2018-09-06 20:38:201039void RenderWidget::UpdateVisualState() {
Ken Buchananed449bb2018-02-01 21:02:051040 if (!GetWebWidget())
1041 return;
1042
Robert Flack3ef2ffb2018-09-06 20:38:201043 GetWebWidget()->UpdateLifecycle(WebWidget::LifecycleUpdate::kAll);
Blink Reformat1c4d759e2017-04-09 16:34:541044 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(false);
tasakb95dbb50c2017-02-08 18:07:501045
Robert Flack3ef2ffb2018-09-06 20:38:201046 if (first_update_visual_state_after_hidden_) {
Takashi SAKAMOTO870f6262017-08-22 04:08:271047 RecordTimeToFirstActivePaint();
1048 first_update_visual_state_after_hidden_ = false;
1049 }
1050}
tasakb95dbb50c2017-02-08 18:07:501051
Takashi SAKAMOTO870f6262017-08-22 04:08:271052void RenderWidget::RecordTimeToFirstActivePaint() {
tasakb95dbb50c2017-02-08 18:07:501053 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
tasakb95dbb50c2017-02-08 18:07:501054 base::TimeDelta sample = base::TimeTicks::Now() - was_shown_time_;
Takashi SAKAMOTO870f6262017-08-22 04:08:271055 if (render_thread_impl->NeedsToRecordFirstActivePaint(TTFAP_AFTER_PURGED)) {
1056 UMA_HISTOGRAM_TIMES("PurgeAndSuspend.Experimental.TimeToFirstActivePaint",
1057 sample);
1058 }
1059 if (render_thread_impl->NeedsToRecordFirstActivePaint(
1060 TTFAP_5MIN_AFTER_BACKGROUNDED)) {
1061 UMA_HISTOGRAM_TIMES(
1062 "PurgeAndSuspend.Experimental.TimeToFirstActivePaint."
1063 "AfterBackgrounded.5min",
1064 sample);
1065 }
fsamuel78f86e42016-01-20 04:10:231066}
1067
Stephen Chenney9879a5c2018-09-26 14:21:421068void RenderWidget::RecordEndOfFrameMetrics(base::TimeTicks frame_begin_time) {
1069 if (!GetWebWidget())
1070 return;
1071
1072 GetWebWidget()->RecordEndOfFrameMetrics(frame_begin_time);
1073}
1074
fsamuel78f86e42016-01-20 04:10:231075void RenderWidget::WillBeginCompositorFrame() {
1076 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
1077
Ken Buchananed449bb2018-02-01 21:02:051078 if (!GetWebWidget())
1079 return;
1080
Blink Reformat1c4d759e2017-04-09 16:34:541081 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(true);
alancutter317a8e02017-04-05 10:09:291082
dglazkov06854c5c2016-08-31 00:19:591083 // The UpdateTextInputState can result in further layout and possibly
1084 // enable GPU acceleration so they need to be called before any painting
1085 // is done.
changwan75e3b2072017-01-16 02:55:001086 UpdateTextInputState();
dglazkov06854c5c2016-08-31 00:19:591087 UpdateSelectionBounds();
1088
ericwilligers88e69742016-10-17 19:29:551089 for (auto& observer : render_frame_proxies_)
1090 observer.WillBeginCompositorFrame();
initial.commit09911bf2008-07-26 23:55:291091}
1092
jbroman6ccbc7d472016-07-27 04:45:411093std::unique_ptr<cc::SwapPromise> RenderWidget::RequestCopyOfOutputForLayoutTest(
Fady Samueldfecb7d2017-07-26 11:41:041094 std::unique_ptr<viz::CopyOutputRequest> request) {
jbroman6ccbc7d472016-07-27 04:45:411095 return RenderThreadImpl::current()->RequestCopyOfOutputForLayoutTest(
1096 routing_id_, std::move(request));
1097}
1098
fsamuel72464894f2015-12-15 06:59:311099///////////////////////////////////////////////////////////////////////////////
1100// RenderWidgetInputHandlerDelegate
1101
avid7d6b2e2016-03-04 19:41:171102void RenderWidget::FocusChangeComplete() {
Ehsan Karamad655d7b8a2018-01-12 18:38:381103 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1104 if (!frame_widget)
ekaramad27ca69b12017-04-20 18:34:291105 return;
Ehsan Karamad655d7b8a2018-01-12 18:38:381106
ekaramad27ca69b12017-04-20 18:34:291107 blink::WebLocalFrame* focused =
Ehsan Karamad655d7b8a2018-01-12 18:38:381108 frame_widget->LocalRoot()->View()->FocusedFrame();
1109
ekaramad27ca69b12017-04-20 18:34:291110 if (focused && focused->AutofillClient())
1111 focused->AutofillClient()->DidCompleteFocusChangeInFrame();
avid7d6b2e2016-03-04 19:41:171112}
fsamuel72464894f2015-12-15 06:59:311113
dtapuska1827dd22016-03-11 15:24:591114void RenderWidget::ObserveGestureEventAndResult(
1115 const blink::WebGestureEvent& gesture_event,
1116 const gfx::Vector2dF& unused_delta,
Sandra Sunac5cdd832017-12-11 03:27:131117 const cc::OverscrollBehavior& overscroll_behavior,
dtapuska1827dd22016-03-11 15:24:591118 bool event_processed) {
1119 if (!compositor_deps_->IsElasticOverscrollEnabled())
1120 return;
1121
1122 cc::InputHandlerScrollResult scroll_result;
1123 scroll_result.did_scroll = event_processed;
1124 scroll_result.did_overscroll_root = !unused_delta.IsZero();
1125 scroll_result.unused_scroll_delta = unused_delta;
Sandra Sunac5cdd832017-12-11 03:27:131126 scroll_result.overscroll_behavior = overscroll_behavior;
dtapuska1827dd22016-03-11 15:24:591127
Dave Tapuska04bc5ee92018-04-17 19:03:311128 widget_input_handler_manager_->ObserveGestureEventOnMainThread(gesture_event,
1129 scroll_result);
dtapuska1827dd22016-03-11 15:24:591130}
1131
avid7d6b2e2016-03-04 19:41:171132void RenderWidget::OnDidHandleKeyEvent() {
alexmos56567492016-09-13 00:52:461133 ClearEditCommands();
1134}
1135
1136void RenderWidget::SetEditCommandForNextKeyEvent(const std::string& name,
1137 const std::string& value) {
1138 ClearEditCommands();
1139 edit_commands_.emplace_back(name, value);
1140}
1141
1142void RenderWidget::ClearEditCommands() {
1143 edit_commands_.clear();
avid7d6b2e2016-03-04 19:41:171144}
fsamuel72464894f2015-12-15 06:59:311145
chongza8ba91fc2016-08-16 21:39:171146void RenderWidget::OnDidOverscroll(const ui::DidOverscrollParams& params) {
Dave Tapuska04bc5ee92018-04-17 19:03:311147 if (mojom::WidgetInputHandlerHost* host =
1148 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
1149 host->DidOverscroll(params);
Dave Tapuska139a72f2017-09-06 21:57:031150 }
fsamuel72464894f2015-12-15 06:59:311151}
1152
fsamuele8326c742016-01-12 00:49:391153void RenderWidget::SetInputHandler(RenderWidgetInputHandler* input_handler) {
1154 // Nothing to do here. RenderWidget created the |input_handler| and will take
1155 // ownership of it. We just verify here that we don't already have an input
1156 // handler.
1157 DCHECK(!input_handler_);
1158}
1159
changwan75e3b2072017-01-16 02:55:001160void RenderWidget::ShowVirtualKeyboard() {
1161 UpdateTextInputStateInternal(true, false);
1162}
1163
changwan62f57292017-02-17 08:28:251164void RenderWidget::ClearTextInputState() {
1165 text_input_info_ = blink::WebTextInputInfo();
1166 text_input_type_ = ui::TextInputType::TEXT_INPUT_TYPE_NONE;
1167 text_input_mode_ = ui::TextInputMode::TEXT_INPUT_MODE_DEFAULT;
1168 can_compose_inline_ = false;
1169 text_input_flags_ = 0;
AJITH KUMAR V041c0b02017-08-08 10:39:201170 next_previous_flags_ = kInvalidNextPreviousFlagsValue;
changwan62f57292017-02-17 08:28:251171}
1172
changwan75e3b2072017-01-16 02:55:001173void RenderWidget::UpdateTextInputState() {
1174 UpdateTextInputStateInternal(false, false);
1175}
1176
1177void RenderWidget::UpdateTextInputStateInternal(bool show_virtual_keyboard,
1178 bool reply_to_request) {
fsamuel72464894f2015-12-15 06:59:311179 TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState");
changwan75e3b2072017-01-16 02:55:001180
fsamuel72464894f2015-12-15 06:59:311181 if (ime_event_guard_) {
changwan75e3b2072017-01-16 02:55:001182 DCHECK(!reply_to_request);
1183 // show_virtual_keyboard should still be effective even if it was set inside
1184 // the IME
fsamuel72464894f2015-12-15 06:59:311185 // event guard.
changwan75e3b2072017-01-16 02:55:001186 if (show_virtual_keyboard)
1187 ime_event_guard_->set_show_virtual_keyboard(true);
fsamuel72464894f2015-12-15 06:59:311188 return;
1189 }
1190
dglazkov97b6c2b2016-10-25 17:35:551191 ui::TextInputType new_type = GetTextInputType();
1192 if (IsDateTimeInput(new_type))
1193 return; // Not considered as a text input field in WebKit/Chromium.
fsamuel72464894f2015-12-15 06:59:311194
dglazkov97b6c2b2016-10-25 17:35:551195 blink::WebTextInputInfo new_info;
ekaramad5aff1942017-01-06 01:26:351196 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:541197 new_info = controller->TextInputInfo();
dtapuskac4dd5be2016-10-25 15:11:101198 const ui::TextInputMode new_mode =
Blink Reformat1c4d759e2017-04-09 16:34:541199 ConvertWebTextInputMode(new_info.input_mode);
fsamuel72464894f2015-12-15 06:59:311200
1201 bool new_can_compose_inline = CanComposeInline();
1202
1203 // Only sends text input params if they are changed or if the ime should be
1204 // shown.
changwan75e3b2072017-01-16 02:55:001205 if (show_virtual_keyboard || reply_to_request ||
changwan38c3eb612016-12-09 01:45:561206 text_input_type_ != new_type || text_input_mode_ != new_mode ||
1207 text_input_info_ != new_info ||
1208 can_compose_inline_ != new_can_compose_inline) {
ekaramad9053e57b2016-04-26 20:00:381209 TextInputState params;
dglazkov97b6c2b2016-10-25 17:35:551210 params.type = new_type;
fsamuel72464894f2015-12-15 06:59:311211 params.mode = new_mode;
1212 params.flags = new_info.flags;
AJITH KUMAR V9e7b5572017-11-14 00:54:211213#if defined(OS_ANDROID)
AJITH KUMAR V041c0b02017-08-08 10:39:201214 if (next_previous_flags_ == kInvalidNextPreviousFlagsValue) {
1215 // Due to a focus change, values will be reset by the frame.
1216 // That case we only need fresh NEXT/PREVIOUS information.
Albert J. Wong3c93c182018-09-27 17:29:431217 // Also we won't send WidgetHostMsg_TextInputStateChanged if next/previous
AJITH KUMAR V041c0b02017-08-08 10:39:201218 // focusable status is changed.
1219 if (auto* controller = GetInputMethodController()) {
1220 next_previous_flags_ =
1221 controller->ComputeWebTextInputNextPreviousFlags();
1222 } else {
1223 // For safety in case GetInputMethodController() is null, because -1 is
1224 // invalid value to send to browser process.
1225 next_previous_flags_ = 0;
1226 }
1227 }
AJITH KUMAR V9e7b5572017-11-14 00:54:211228#else
1229 next_previous_flags_ = 0;
1230#endif
AJITH KUMAR V041c0b02017-08-08 10:39:201231 params.flags |= next_previous_flags_;
Blink Reformat1c4d759e2017-04-09 16:34:541232 params.value = new_info.value.Utf8();
1233 params.selection_start = new_info.selection_start;
1234 params.selection_end = new_info.selection_end;
1235 params.composition_start = new_info.composition_start;
1236 params.composition_end = new_info.composition_end;
fsamuel72464894f2015-12-15 06:59:311237 params.can_compose_inline = new_can_compose_inline;
changwan75e3b2072017-01-16 02:55:001238 // TODO(changwan): change instances of show_ime_if_needed to
1239 // show_virtual_keyboard.
1240 params.show_ime_if_needed = show_virtual_keyboard;
1241 params.reply_to_request = reply_to_request;
Albert J. Wong3c93c182018-09-27 17:29:431242 Send(new WidgetHostMsg_TextInputStateChanged(routing_id(), params));
fsamuel72464894f2015-12-15 06:59:311243
1244 text_input_info_ = new_info;
dglazkov97b6c2b2016-10-25 17:35:551245 text_input_type_ = new_type;
fsamuel72464894f2015-12-15 06:59:311246 text_input_mode_ = new_mode;
1247 can_compose_inline_ = new_can_compose_inline;
1248 text_input_flags_ = new_info.flags;
1249 }
1250}
1251
1252bool RenderWidget::WillHandleGestureEvent(const blink::WebGestureEvent& event) {
paulmeyer6ef5a792016-11-08 20:33:581253 possible_drag_event_info_.event_source =
1254 ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH;
1255 possible_drag_event_info_.event_location =
Ella Ge1116059d2018-03-21 02:06:131256 gfx::ToFlooredPoint(event.PositionInScreen());
avid7d6b2e2016-03-04 19:41:171257
fsamuel72464894f2015-12-15 06:59:311258 return false;
1259}
1260
1261bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
ericwilligers88e69742016-10-17 19:29:551262 for (auto& observer : render_frames_)
1263 observer.RenderWidgetWillHandleMouseEvent();
lfge0c2792ec2016-05-11 18:52:081264
paulmeyer6ef5a792016-11-08 20:33:581265 possible_drag_event_info_.event_source =
1266 ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
1267 possible_drag_event_info_.event_location =
Blink Reformat1c4d759e2017-04-09 16:34:541268 gfx::Point(event.PositionInScreen().x, event.PositionInScreen().y);
paulmeyer6ef5a792016-11-08 20:33:581269
avid7d6b2e2016-03-04 19:41:171270 if (owner_delegate_)
danakja2c9d0a92018-07-25 20:01:181271 return owner_delegate_->RenderWidgetWillHandleMouseEventForWidget(event);
avid7d6b2e2016-03-04 19:41:171272
fsamuel72464894f2015-12-15 06:59:311273 return false;
[email protected]fd847792013-10-24 17:12:351274}
1275
initial.commit09911bf2008-07-26 23:55:291276///////////////////////////////////////////////////////////////////////////////
mfomitchev2600fd7c2016-02-17 20:53:391277// RenderWidgetScreenMetricsDelegate
1278
1279void RenderWidget::Redraw() {
danakja6c10012018-07-06 14:25:361280 if (layer_tree_view_)
1281 layer_tree_view_->SetNeedsRedrawRect(gfx::Rect(size_));
mfomitchev2600fd7c2016-02-17 20:53:391282}
1283
bokanc63441c2016-04-27 15:49:121284void RenderWidget::ResizeWebWidget() {
danakja2c9d0a92018-07-25 20:01:181285 gfx::Size size = GetSizeForWebWidget();
1286 if (owner_delegate_) {
1287 owner_delegate_->ResizeWebWidgetForWidget(
1288 size, top_controls_height_, bottom_controls_height_,
1289 browser_controls_shrink_blink_size_);
1290 return;
1291 }
1292 GetWebWidget()->Resize(size);
bokanc63441c2016-04-27 15:49:121293}
1294
1295gfx::Size RenderWidget::GetSizeForWebWidget() const {
danakj4b347212018-07-04 17:55:171296 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:031297 return gfx::ScaleToCeiledSize(size_,
1298 GetOriginalScreenInfo().device_scale_factor);
1299 }
bokanc63441c2016-04-27 15:49:121300
1301 return size_;
1302}
1303
akaba3483d8f2018-07-10 21:43:091304void RenderWidget::UpdateZoom(double zoom_level) {
akabac6bd1212018-06-25 20:10:481305 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1306 if (!frame_widget)
1307 return;
1308 RenderFrameImpl* render_frame =
1309 RenderFrameImpl::FromWebFrame(frame_widget->LocalRoot());
1310
akaba3483d8f2018-07-10 21:43:091311 // Return early if zoom level is unchanged.
1312 if (render_frame->GetZoomLevel() == zoom_level) {
akabac6bd1212018-06-25 20:10:481313 return;
1314 }
1315
akaba3483d8f2018-07-10 21:43:091316 render_frame->SetZoomLevel(zoom_level);
akabac6bd1212018-06-25 20:10:481317
1318 for (auto& observer : render_frame_proxies_)
akaba3483d8f2018-07-10 21:43:091319 observer.OnZoomLevelChanged(zoom_level);
akabac6bd1212018-06-25 20:10:481320
1321 for (auto& plugin : browser_plugins_)
akaba3483d8f2018-07-10 21:43:091322 plugin.OnZoomLevelChanged(zoom_level);
akabac6bd1212018-06-25 20:10:481323}
1324
Fady Samuel799e72192018-04-25 21:16:571325void RenderWidget::SynchronizeVisualProperties(const VisualProperties& params) {
Christopher Cameronbe7ecea2018-02-27 00:47:191326 // Inform the rendering thread of the color space indicate the presence of HDR
1327 // capabilities.
Miguel Casas5e1018052018-01-09 19:17:361328 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1329 if (render_thread)
Christopher Camerone9a30c12018-03-07 08:23:381330 render_thread->SetRenderingColorSpace(params.screen_info.color_space);
Miguel Casas5e1018052018-01-09 19:17:361331
mfomitchev2600fd7c2016-02-17 20:53:391332 // Ignore this during shutdown.
lfg8ff33912016-09-13 20:59:211333 if (!GetWebWidget())
mfomitchev2600fd7c2016-02-17 20:53:391334 return;
1335
Fady Samuele62be402018-03-29 03:19:531336 gfx::Size new_compositor_viewport_pixel_size =
1337 params.auto_resize_enabled
1338 ? gfx::ScaleToCeiledSize(size_,
1339 params.screen_info.device_scale_factor)
1340 : params.compositor_viewport_pixel_size;
Fady Samuel4392abb2018-05-10 21:01:211341 UpdateSurfaceAndScreenInfo(
1342 params.local_surface_id.value_or(viz::LocalSurfaceId()),
1343 new_compositor_viewport_pixel_size, params.screen_info);
Vladimir Levin98d76dad2018-04-21 00:21:291344 UpdateCaptureSequenceNumber(params.capture_sequence_number);
danakja6c10012018-07-06 14:25:361345 if (layer_tree_view_) {
1346 layer_tree_view_->SetBrowserControlsHeight(
Sadrul Habib Chowdhury04d5dd4d2017-08-10 01:59:271347 params.top_controls_height, params.bottom_controls_height,
1348 params.browser_controls_shrink_blink_size);
danakja6c10012018-07-06 14:25:361349 layer_tree_view_->SetRasterColorSpace(
Sadrul Habib Chowdhury04d5dd4d2017-08-10 01:59:271350 screen_info_.color_space.GetRasterColorSpace());
ianwene5fc5782016-08-18 04:05:151351 }
mfomitchev2600fd7c2016-02-17 20:53:391352
akaba3483d8f2018-07-10 21:43:091353 UpdateZoom(params.zoom_level);
akabac6bd1212018-06-25 20:10:481354
Fady Samuele62be402018-03-29 03:19:531355 if (params.auto_resize_enabled)
1356 return;
1357
mfomitchev2600fd7c2016-02-17 20:53:391358 visible_viewport_size_ = params.visible_viewport_size;
mfomitchev2600fd7c2016-02-17 20:53:391359
1360 // NOTE: We may have entered fullscreen mode without changing our size.
1361 bool fullscreen_change =
1362 is_fullscreen_granted_ != params.is_fullscreen_granted;
1363 is_fullscreen_granted_ = params.is_fullscreen_granted;
1364 display_mode_ = params.display_mode;
1365
bokanc63441c2016-04-27 15:49:121366 size_ = params.new_size;
mfomitchev2600fd7c2016-02-17 20:53:391367
bokanc63441c2016-04-27 15:49:121368 ResizeWebWidget();
bokan71cb5b12016-04-27 03:45:221369
mfomitchev2600fd7c2016-02-17 20:53:391370 WebSize visual_viewport_size;
danakj4b347212018-07-04 17:55:171371 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:031372 visual_viewport_size =
1373 gfx::ScaleToCeiledSize(params.visible_viewport_size,
1374 GetOriginalScreenInfo().device_scale_factor);
mfomitchev2600fd7c2016-02-17 20:53:391375 } else {
1376 visual_viewport_size = visible_viewport_size_;
1377 }
Blink Reformat1c4d759e2017-04-09 16:34:541378 GetWebWidget()->ResizeVisualViewport(visual_viewport_size);
mfomitchev2600fd7c2016-02-17 20:53:391379
mfomitchev2600fd7c2016-02-17 20:53:391380 if (fullscreen_change)
1381 DidToggleFullscreen();
mfomitchev2600fd7c2016-02-17 20:53:391382}
1383
1384void RenderWidget::SetScreenMetricsEmulationParameters(
1385 bool enabled,
1386 const blink::WebDeviceEmulationParams& params) {
danakja2c9d0a92018-07-25 20:01:181387 // This is only supported in RenderView, which has an |owner_delegate_|.
1388 DCHECK(owner_delegate_);
1389 owner_delegate_->SetScreenMetricsEmulationParametersForWidget(enabled,
1390 params);
mfomitchev2600fd7c2016-02-17 20:53:391391}
1392
Albert J. Wong3c93c182018-09-27 17:29:431393void RenderWidget::SetScreenRects(const gfx::Rect& widget_screen_rect,
mfomitchev2600fd7c2016-02-17 20:53:391394 const gfx::Rect& window_screen_rect) {
Albert J. Wong3c93c182018-09-27 17:29:431395 widget_screen_rect_ = widget_screen_rect;
mfomitchev2600fd7c2016-02-17 20:53:391396 window_screen_rect_ = window_screen_rect;
1397}
1398
1399///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461400// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291401
Blink Reformat1c4d759e2017-04-09 16:34:541402blink::WebLayerTreeView* RenderWidget::InitializeLayerTreeView() {
[email protected]aeeedad2014-08-22 18:16:221403 DCHECK(!host_closing_);
1404
danakja6c10012018-07-06 14:25:361405 layer_tree_view_ = std::make_unique<LayerTreeView>(
danakj4c987652018-07-05 15:49:411406 this, compositor_deps_->GetCompositorMainThreadTaskRunner(),
1407 compositor_deps_->GetCompositorImplThreadTaskRunner(),
1408 compositor_deps_->GetTaskGraphRunner(),
1409 compositor_deps_->GetWebMainThreadScheduler());
danakja6c10012018-07-06 14:25:361410 layer_tree_view_->Initialize(
danakj4c987652018-07-05 15:49:411411 GenerateLayerTreeSettings(compositor_deps_, for_oopif_,
1412 screen_info_.rect.size(),
1413 screen_info_.device_scale_factor),
1414 compositor_deps_->CreateUkmRecorderFactory());
loyso6e6efc42017-01-21 02:23:031415
Fady Samuel4255c182018-05-24 20:42:361416 UpdateSurfaceAndScreenInfo(local_surface_id_from_parent_,
1417 compositor_viewport_pixel_size_, screen_info_);
danakja6c10012018-07-06 14:25:361418 layer_tree_view_->SetRasterColorSpace(
Christopher Camerona1ea2b72017-08-02 01:59:091419 screen_info_.color_space.GetRasterColorSpace());
danakja6c10012018-07-06 14:25:361420 layer_tree_view_->SetContentSourceId(current_content_source_id_);
sievers71c62dd52015-10-07 01:44:391421 // For background pages and certain tests, we don't want to trigger
danakjc7afae52017-06-20 21:12:411422 // LayerTreeFrameSink creation.
dtapuskab08611f2017-04-24 16:10:221423 bool should_generate_frame_sink =
1424 !compositor_never_visible_ && RenderThreadImpl::current();
1425 if (!should_generate_frame_sink)
danakja6c10012018-07-06 14:25:361426 layer_tree_view_->SetNeverVisible();
sievers71c62dd52015-10-07 01:44:391427
pimanc4af3072015-10-02 03:45:591428 StartCompositor();
staraz067f58242016-11-07 21:06:411429 DCHECK_NE(MSG_ROUTING_NONE, routing_id_);
danakja6c10012018-07-06 14:25:361430 layer_tree_view_->SetFrameSinkId(
Fady Samueld5c26182017-07-12 02:43:331431 viz::FrameSinkId(RenderThread::Get()->GetClientId(), routing_id_));
loyso50b51c22017-01-10 07:18:371432
wjmaclean1d970622017-01-21 22:28:241433 RenderThreadImpl* render_thread = RenderThreadImpl::current();
Dave Tapuska9db80842017-07-24 17:24:261434 if (render_thread) {
dtapuska9ec1a912017-04-21 15:18:311435 input_event_queue_ = new MainThreadEventQueue(
Yuta Kitamura3331f5c2018-04-05 11:12:251436 this, render_thread->GetWebMainThreadScheduler()->InputTaskRunner(),
1437 render_thread->GetWebMainThreadScheduler(), should_generate_frame_sink);
wjmaclean1d970622017-01-21 22:28:241438 }
1439
Khushal3e96e662017-10-30 23:16:501440 UpdateURLForCompositorUkm();
1441
danakja6c10012018-07-06 14:25:361442 return layer_tree_view_.get();
[email protected]e195e582013-03-08 01:32:591443}
1444
Chris Harrelsond7ab99b2018-01-24 17:51:361445void RenderWidget::IntrinsicSizingInfoChanged(
1446 const blink::WebIntrinsicSizingInfo& sizing_info) {
Albert J. Wong3c93c182018-09-27 17:29:431447 Send(new WidgetHostMsg_IntrinsicSizingInfoChanged(routing_id_, sizing_info));
Chris Harrelsond7ab99b2018-01-24 17:51:361448}
1449
ennef3c58142014-12-09 21:44:381450void RenderWidget::WillCloseLayerTreeView() {
1451 if (host_closing_)
1452 return;
1453
1454 // Prevent new compositors or output surfaces from being created.
1455 host_closing_ = true;
1456
[email protected]aeeedad2014-08-22 18:16:221457 // Always send this notification to prevent new layer tree views from
1458 // being created, even if one hasn't been created yet.
lfg8ff33912016-09-13 20:59:211459 if (blink::WebWidget* widget = GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:541460 widget->WillCloseLayerTreeView();
[email protected]aeeedad2014-08-22 18:16:221461}
1462
Blink Reformat1c4d759e2017-04-09 16:34:541463void RenderWidget::DidMeaningfulLayout(blink::WebMeaningfulLayout layout_type) {
1464 if (layout_type == blink::WebMeaningfulLayout::kVisuallyNonEmpty) {
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491465 QueueMessage(new ViewHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_));
dglazkovf0e1d6d2015-10-10 02:13:481466 }
dglazkov79c426102015-08-31 21:22:431467
ericwilligers88e69742016-10-17 19:29:551468 for (auto& observer : render_frames_)
1469 observer.DidMeaningfulLayout(layout_type);
dglazkov79c426102015-08-31 21:22:431470}
1471
[email protected]586871b2014-07-22 17:05:111472// static
dchengcedca5612016-04-09 01:40:151473std::unique_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
[email protected]586871b2014-07-22 17:05:111474 IPC::Message* msg,
[email protected]586871b2014-07-22 17:05:111475 FrameSwapMessageQueue* frame_swap_message_queue,
1476 scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
[email protected]586871b2014-07-22 17:05:111477 int source_frame_number) {
[email protected]586871b2014-07-22 17:05:111478 bool first_message_for_frame = false;
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491479 frame_swap_message_queue->QueueMessageForFrame(
1480 source_frame_number, base::WrapUnique(msg), &first_message_for_frame);
[email protected]586871b2014-07-22 17:05:111481 if (first_message_for_frame) {
dchengcedca5612016-04-09 01:40:151482 std::unique_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
[email protected]586871b2014-07-22 17:05:111483 sync_message_filter, frame_swap_message_queue, source_frame_number));
dcheng4b6b5ff2014-10-16 00:42:061484 return promise;
[email protected]586871b2014-07-22 17:05:111485 }
dcheng4b6b5ff2014-10-16 00:42:061486 return nullptr;
[email protected]586871b2014-07-22 17:05:111487}
1488
danakj53802692018-07-25 21:46:441489void RenderWidget::SetHandlingInputEvent(bool handling_input_event) {
1490 input_handler_->set_handling_input_event(handling_input_event);
1491}
1492
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491493void RenderWidget::QueueMessage(IPC::Message* msg) {
[email protected]586871b2014-07-22 17:05:111494 // RenderThreadImpl::current() is NULL in some tests.
danakja6c10012018-07-06 14:25:361495 if (!layer_tree_view_ || !RenderThreadImpl::current()) {
[email protected]586871b2014-07-22 17:05:111496 Send(msg);
1497 return;
1498 }
1499
dchengcedca5612016-04-09 01:40:151500 std::unique_ptr<cc::SwapPromise> swap_promise =
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491501 QueueMessageImpl(msg, frame_swap_message_queue_.get(),
[email protected]586871b2014-07-22 17:05:111502 RenderThreadImpl::current()->sync_message_filter(),
danakja6c10012018-07-06 14:25:361503 layer_tree_view_->GetSourceFrameNumber());
[email protected]586871b2014-07-22 17:05:111504
Ken Buchanance710eb2017-08-30 23:46:521505 if (swap_promise)
danakja6c10012018-07-06 14:25:361506 layer_tree_view_->QueueSwapPromise(std::move(swap_promise));
[email protected]586871b2014-07-22 17:05:111507}
1508
Blink Reformat1c4d759e2017-04-09 16:34:541509void RenderWidget::DidChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301510 // TODO(darin): Eliminate this temporary.
[email protected]9ec87712013-05-24 23:23:521511 WebCursor cursor;
tfarina75a0abf2015-10-06 15:07:181512 InitializeCursorFromWebCursorInfo(&cursor, cursor_info);
initial.commit09911bf2008-07-26 23:55:291513 // Only send a SetCursor message if we need to make a change.
1514 if (!current_cursor_.IsEqual(cursor)) {
1515 current_cursor_ = cursor;
Albert J. Wong3c93c182018-09-27 17:29:431516 Send(new WidgetHostMsg_SetCursor(routing_id_, cursor));
initial.commit09911bf2008-07-26 23:55:291517 }
1518}
1519
aelias5971e47d2017-06-16 02:39:381520void RenderWidget::AutoscrollStart(const blink::WebFloatPoint& point) {
Albert J. Wong3c93c182018-09-27 17:29:431521 Send(new WidgetHostMsg_AutoscrollStart(routing_id_, point));
aelias5971e47d2017-06-16 02:39:381522}
1523
1524void RenderWidget::AutoscrollFling(const blink::WebFloatSize& velocity) {
Albert J. Wong3c93c182018-09-27 17:29:431525 Send(new WidgetHostMsg_AutoscrollFling(routing_id_, velocity));
aelias5971e47d2017-06-16 02:39:381526}
1527
1528void RenderWidget::AutoscrollEnd() {
Albert J. Wong3c93c182018-09-27 17:29:431529 Send(new WidgetHostMsg_AutoscrollEnd(routing_id_));
aelias5971e47d2017-06-16 02:39:381530}
1531
initial.commit09911bf2008-07-26 23:55:291532// We are supposed to get a single call to Show for a newly created RenderWidget
1533// that was created via RenderWidget::CreateWebView. So, we wait until this
1534// point to dispatch the ShowWidget message.
1535//
1536// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281537// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291538//
Blink Reformat1c4d759e2017-04-09 16:34:541539void RenderWidget::Show(WebNavigationPolicy policy) {
danakja2c9d0a92018-07-25 20:01:181540 if (did_show_) {
1541 if (owner_delegate_) {
1542 // When SupportsMultipleWindows is disabled, popups are reusing
1543 // the same view. In some scenarios, this makes blink to call Show()
1544 // twice. But otherwise, if it is enabled, we should not visit Show() more
1545 // than once.
1546 DCHECK(!owner_delegate_->SupportsMultipleWindowsForWidget());
1547 } else {
1548 DCHECK(!did_show_) << "received extraneous Show call";
1549 }
1550 return;
1551 }
1552
initial.commit09911bf2008-07-26 23:55:291553 DCHECK(routing_id_ != MSG_ROUTING_NONE);
danakjdf1ceb72018-07-18 20:02:251554 DCHECK(show_callback_);
initial.commit09911bf2008-07-26 23:55:291555
[email protected]8de12d942010-11-17 20:42:441556 did_show_ = true;
nickf7b38222016-11-22 21:59:351557
1558 // The opener is responsible for actually showing this widget.
danakjdf1ceb72018-07-18 20:02:251559 std::move(show_callback_).Run(this, policy, initial_rect_);
nickf7b38222016-11-22 21:59:351560
bokanc007c3a2015-02-03 07:15:561561 // NOTE: initial_rect_ may still have its default values at this point, but
[email protected]8de12d942010-11-17 20:42:441562 // that's okay. It'll be ignored if as_popup is false, or the browser
1563 // process will impose a default position otherwise.
bokanc007c3a2015-02-03 07:15:561564 SetPendingWindowRect(initial_rect_);
initial.commit09911bf2008-07-26 23:55:291565}
1566
[email protected]2533ce12009-05-09 00:02:241567void RenderWidget::DoDeferredClose() {
ennef3c58142014-12-09 21:44:381568 WillCloseLayerTreeView();
Albert J. Wong3c93c182018-09-27 17:29:431569 Send(new WidgetHostMsg_Close(routing_id_));
[email protected]2533ce12009-05-09 00:02:241570}
1571
dgozmancf9039cd2015-04-06 12:01:311572void RenderWidget::NotifyOnClose() {
ericwilligers88e69742016-10-17 19:29:551573 for (auto& observer : render_frames_)
1574 observer.WidgetWillClose();
dgozmancf9039cd2015-04-06 12:01:311575}
1576
Blink Reformat1c4d759e2017-04-09 16:34:541577void RenderWidget::CloseWidgetSoon() {
skyostiled8969c2015-07-20 16:57:081578 DCHECK(content::RenderThread::Get());
[email protected]e1c3a552012-05-04 20:51:321579 if (is_swapped_out_) {
1580 // This widget is currently swapped out, and the active widget is in a
1581 // different process. Have the browser route the close request to the
1582 // active widget instead, so that the correct unload handlers are run.
1583 Send(new ViewHostMsg_RouteCloseEvent(routing_id_));
1584 return;
1585 }
1586
initial.commit09911bf2008-07-26 23:55:291587 // If a page calls window.close() twice, we'll end up here twice, but that's
1588 // OK. It is safe to send multiple Close messages.
1589
[email protected]2533ce12009-05-09 00:02:241590 // Ask the RenderWidgetHost to initiate close. We could be called from deep
1591 // in Javascript. If we ask the RendwerWidgetHost to close now, the window
1592 // could be closed before the JS finishes executing. So instead, post a
1593 // message back to the message loop, which won't run until the JS is
1594 // complete, and then the Close message can be sent.
Hajime Hoshi315a61f2018-08-14 17:27:281595 GetCleanupTaskRunner()->PostTask(
1596 FROM_HERE, base::BindOnce(&RenderWidget::DoDeferredClose, this));
initial.commit09911bf2008-07-26 23:55:291597}
1598
1599void RenderWidget::Close() {
[email protected]404630b2014-07-03 19:33:031600 screen_metrics_emulator_.reset();
Ken Buchananed449bb2018-02-01 21:02:051601 CloseWebWidget();
danakja6c10012018-07-06 14:25:361602 layer_tree_view_.reset();
danakja2c9d0a92018-07-25 20:01:181603 if (owner_delegate_)
1604 owner_delegate_->DidCloseWidget();
Albert J. Wongd593de532018-09-06 05:42:151605 // Note the ACK is a control message going to the RenderProcessHost.
Albert J. Wong3c93c182018-09-27 17:29:431606 RenderThread::Get()->Send(new WidgetHostMsg_Close_ACK(routing_id()));
Ken Buchananed449bb2018-02-01 21:02:051607}
1608
1609void RenderWidget::CloseWebWidget() {
1610 WillCloseLayerTreeView();
lfg8ff33912016-09-13 20:59:211611 if (webwidget_internal_) {
Blink Reformat1c4d759e2017-04-09 16:34:541612 webwidget_internal_->Close();
lfg8ff33912016-09-13 20:59:211613 webwidget_internal_ = nullptr;
initial.commit09911bf2008-07-26 23:55:291614 }
1615}
1616
Mitsuru Oshima3c07b332018-02-06 04:56:501617void RenderWidget::UpdateWebViewWithDeviceScaleFactor() {
1618 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1619 blink::WebFrame* current_frame =
1620 frame_widget ? frame_widget->LocalRoot() : nullptr;
1621 blink::WebView* webview = current_frame ? current_frame->View() : nullptr;
1622 if (webview) {
danakj4b347212018-07-04 17:55:171623 if (compositor_deps_->IsUseZoomForDSFEnabled())
Fady Samuela863f152018-03-09 16:10:031624 webview->SetZoomFactorForDeviceScaleFactor(
1625 GetWebScreenInfo().device_scale_factor);
Mitsuru Oshima3c07b332018-02-06 04:56:501626 else
Fady Samuela863f152018-03-09 16:10:031627 webview->SetDeviceScaleFactor(GetWebScreenInfo().device_scale_factor);
Mitsuru Oshima3c07b332018-02-06 04:56:501628
1629 webview->GetSettings()->SetPreferCompositingToLCDTextEnabled(
Christopher Camerone9a30c12018-03-07 08:23:381630 PreferCompositingToLCDText(compositor_deps_,
Fady Samuela863f152018-03-09 16:10:031631 GetWebScreenInfo().device_scale_factor));
Mitsuru Oshima3c07b332018-02-06 04:56:501632 }
1633}
1634
Ehsan Karamad655d7b8a2018-01-12 18:38:381635blink::WebFrameWidget* RenderWidget::GetFrameWidget() const {
1636 blink::WebWidget* web_widget = GetWebWidget();
1637 if (!web_widget)
1638 return nullptr;
1639
1640 if (!web_widget->IsWebFrameWidget()) {
1641 // TODO(ekaramad): This should not happen. If we have a WebWidget and we
1642 // need a WebFrameWidget then we should be getting a WebFrameWidget. But
1643 // unfortunately this does not seem to be the case in some scenarios --
1644 // specifically when a RenderViewImpl swaps out during navigation the
1645 // WebViewImpl loses its WebViewFrameWidget but sometimes we receive IPCs
1646 // which are destined for WebFrameWidget (https://crbug.com/669219).
1647 return nullptr;
1648 }
1649
1650 return static_cast<blink::WebFrameWidget*>(web_widget);
1651}
1652
bokan841fdc72016-10-06 00:16:351653void RenderWidget::ScreenRectToEmulatedIfNeeded(WebRect* window_rect) const {
1654 DCHECK(window_rect);
1655 float scale = popup_origin_scale_for_emulation_;
1656 if (!scale)
1657 return;
1658 window_rect->x =
1659 popup_view_origin_for_emulation_.x() +
1660 (window_rect->x - popup_screen_origin_for_emulation_.x()) / scale;
1661 window_rect->y =
1662 popup_view_origin_for_emulation_.y() +
1663 (window_rect->y - popup_screen_origin_for_emulation_.y()) / scale;
1664}
1665
1666void RenderWidget::EmulatedToScreenRectIfNeeded(WebRect* window_rect) const {
1667 DCHECK(window_rect);
1668 float scale = popup_origin_scale_for_emulation_;
1669 if (!scale)
1670 return;
1671 window_rect->x =
1672 popup_screen_origin_for_emulation_.x() +
1673 (window_rect->x - popup_view_origin_for_emulation_.x()) * scale;
1674 window_rect->y =
1675 popup_screen_origin_for_emulation_.y() +
1676 (window_rect->y - popup_view_origin_for_emulation_.y()) * scale;
1677}
1678
Blink Reformat1c4d759e2017-04-09 16:34:541679WebRect RenderWidget::WindowRect() {
bokan841fdc72016-10-06 00:16:351680 WebRect rect;
bokan6b08cd22016-10-05 00:55:211681 if (pending_window_rect_count_) {
1682 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
1683 // the RootWindowRect is probably going to return wrong results since the
1684 // browser may not have processed the Move yet. There isn't really anything
1685 // good to do in this case, and it shouldn't happen - since this size is
1686 // only really needed for windowToScreen, which is only used for Popups.
bokan841fdc72016-10-06 00:16:351687 rect = pending_window_rect_;
1688 } else {
1689 rect = window_screen_rect_;
bokan6b08cd22016-10-05 00:55:211690 }
[email protected]2533ce12009-05-09 00:02:241691
bokan841fdc72016-10-06 00:16:351692 ScreenRectToEmulatedIfNeeded(&rect);
1693 return rect;
bokan6b08cd22016-10-05 00:55:211694}
1695
Blink Reformat1c4d759e2017-04-09 16:34:541696WebRect RenderWidget::ViewRect() {
Albert J. Wong3c93c182018-09-27 17:29:431697 WebRect rect = widget_screen_rect_;
bokan841fdc72016-10-06 00:16:351698 ScreenRectToEmulatedIfNeeded(&rect);
1699 return rect;
initial.commit09911bf2008-07-26 23:55:291700}
1701
Blink Reformat1c4d759e2017-04-09 16:34:541702void RenderWidget::SetToolTipText(const blink::WebString& text,
[email protected]8a9d6ca32011-06-06 20:11:301703 WebTextDirection hint) {
Albert J. Wong3c93c182018-09-27 17:29:431704 Send(new WidgetHostMsg_SetTooltipText(routing_id_, text.Utf16(), hint));
[email protected]8a9d6ca32011-06-06 20:11:301705}
1706
Blink Reformat1c4d759e2017-04-09 16:34:541707void RenderWidget::SetWindowRect(const WebRect& rect_in_screen) {
oshima33ec97cd2015-12-14 19:40:241708 WebRect window_rect = rect_in_screen;
bokan841fdc72016-10-06 00:16:351709 EmulatedToScreenRectIfNeeded(&window_rect);
[email protected]b2e4c70132013-10-03 02:07:511710
[email protected]5b45ad42013-10-25 00:42:041711 if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]ec951b9d2013-10-20 06:21:201712 if (did_show_) {
Albert J. Wong3c93c182018-09-27 17:29:431713 Send(new WidgetHostMsg_RequestSetBounds(routing_id_, window_rect));
bokanc007c3a2015-02-03 07:15:561714 SetPendingWindowRect(window_rect);
[email protected]8be1c582013-03-06 00:55:031715 } else {
bokanc007c3a2015-02-03 07:15:561716 initial_rect_ = window_rect;
[email protected]8be1c582013-03-06 00:55:031717 }
initial.commit09911bf2008-07-26 23:55:291718 } else {
bokanc007c3a2015-02-03 07:15:561719 SetWindowRectSynchronously(window_rect);
initial.commit09911bf2008-07-26 23:55:291720 }
1721}
1722
[email protected]2533ce12009-05-09 00:02:241723void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
1724 pending_window_rect_ = rect;
1725 pending_window_rect_count_++;
[email protected]2533ce12009-05-09 00:02:241726
bokan6b08cd22016-10-05 00:55:211727 // Popups don't get size updates back from the browser so just store the set
1728 // values.
danakj6a816592018-09-25 18:30:561729 if (widget_type_ != WidgetType::kFrame) {
Blink Reformat1c4d759e2017-04-09 16:34:541730 window_screen_rect_ = rect;
Albert J. Wong3c93c182018-09-27 17:29:431731 widget_screen_rect_ = rect;
[email protected]2533ce12009-05-09 00:02:241732 }
[email protected]d4547452008-08-28 18:36:371733}
1734
wjmacleanee244e02017-05-26 21:06:071735void RenderWidget::OnShowContextMenu(ui::MenuSourceType source_type,
1736 const gfx::Point& location) {
wjmacleanee244e02017-05-26 21:06:071737 has_host_context_menu_location_ = true;
1738 host_context_menu_location_ = location;
1739 if (GetWebWidget()) {
1740 GetWebWidget()->ShowContextMenu(
1741 static_cast<blink::WebMenuSourceType>(source_type));
1742 }
1743 has_host_context_menu_location_ = false;
1744}
1745
[email protected]fa7b1dc2010-06-23 17:53:041746void RenderWidget::OnImeSetComposition(
[email protected]fcf75d42013-12-03 20:11:261747 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:111748 const std::vector<WebImeTextSpan>& ime_text_spans,
chongz7eb752802016-01-27 21:28:071749 const gfx::Range& replacement_range,
Ryan Landay9e42fd742017-08-12 01:59:111750 int selection_start,
1751 int selection_end) {
ekaramad5aff1942017-01-06 01:26:351752 if (!ShouldHandleImeEvents())
1753 return;
1754
brettw4b461082016-11-19 18:55:161755#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:491756 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
Ryan Landay9e42fd742017-08-12 01:59:111757 plugin->render_frame()->OnImeSetComposition(text, ime_text_spans,
EhsanK22d482e2017-08-10 17:29:491758 selection_start, selection_end);
ekaramad2a46d632016-07-19 13:33:091759 return;
1760 }
1761#endif
[email protected]66fca5bc2013-05-23 06:58:291762 ImeEventGuard guard(this);
ekaramad2daaf672016-11-10 20:29:011763 blink::WebInputMethodController* controller = GetInputMethodController();
ekaramad2daaf672016-11-10 20:29:011764 if (!controller ||
Blink Reformat1c4d759e2017-04-09 16:34:541765 !controller->SetComposition(
Ryan Landay9e42fd742017-08-12 01:59:111766 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:561767 replacement_range.IsValid()
1768 ? WebRange(replacement_range.start(), replacement_range.length())
1769 : WebRange(),
1770 selection_start, selection_end)) {
[email protected]fa7b1dc2010-06-23 17:53:041771 // If we failed to set the composition text, then we need to let the browser
1772 // process to cancel the input method's ongoing composition session, to make
1773 // sure we are in a consistent state.
Dave Tapuska04bc5ee92018-04-17 19:03:311774 if (mojom::WidgetInputHandlerHost* host =
1775 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
1776 host->ImeCancelComposition();
Dave Tapuska139a72f2017-09-06 21:57:031777 }
[email protected]7f00efa2010-04-15 05:01:261778 }
nonafa291792016-08-10 02:36:181779 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]fa7b1dc2010-06-23 17:53:041780}
1781
rlanday7efe2302017-01-11 00:14:281782void RenderWidget::OnImeCommitText(
1783 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:111784 const std::vector<WebImeTextSpan>& ime_text_spans,
rlanday7efe2302017-01-11 00:14:281785 const gfx::Range& replacement_range,
1786 int relative_cursor_pos) {
ekaramad5aff1942017-01-06 01:26:351787 if (!ShouldHandleImeEvents())
1788 return;
1789
brettw4b461082016-11-19 18:55:161790#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:491791 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
1792 plugin->render_frame()->OnImeCommitText(text, replacement_range,
1793 relative_cursor_pos);
ekaramad2a46d632016-07-19 13:33:091794 return;
1795 }
1796#endif
[email protected]66fca5bc2013-05-23 06:58:291797 ImeEventGuard guard(this);
fsamuele8326c742016-01-12 00:49:391798 input_handler_->set_handling_input_event(true);
ekaramadb6483a052017-02-10 02:23:261799 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:541800 controller->CommitText(
Ryan Landay9e42fd742017-08-12 01:59:111801 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:561802 replacement_range.IsValid()
1803 ? WebRange(replacement_range.start(), replacement_range.length())
1804 : WebRange(),
1805 relative_cursor_pos);
ekaramadb6483a052017-02-10 02:23:261806 }
aelias87b8f7c2016-09-14 03:19:291807 input_handler_->set_handling_input_event(false);
1808 UpdateCompositionInfo(false /* not an immediate request */);
1809}
1810
1811void RenderWidget::OnImeFinishComposingText(bool keep_selection) {
ekaramad5aff1942017-01-06 01:26:351812 if (!ShouldHandleImeEvents())
1813 return;
1814
brettw4b461082016-11-19 18:55:161815#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:491816 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
1817 plugin->render_frame()->OnImeFinishComposingText(keep_selection);
aelias87b8f7c2016-09-14 03:19:291818 return;
1819 }
1820#endif
1821
changwan38c3eb612016-12-09 01:45:561822 if (!GetWebWidget())
aelias87b8f7c2016-09-14 03:19:291823 return;
1824 ImeEventGuard guard(this);
1825 input_handler_->set_handling_input_event(true);
ekaramad2daaf672016-11-10 20:29:011826 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:541827 controller->FinishComposingText(
1828 keep_selection ? WebInputMethodController::kKeepSelection
1829 : WebInputMethodController::kDoNotKeepSelection);
ekaramad2daaf672016-11-10 20:29:011830 }
fsamuele8326c742016-01-12 00:49:391831 input_handler_->set_handling_input_event(false);
nonafa291792016-08-10 02:36:181832 UpdateCompositionInfo(false /* not an immediate request */);
initial.commit09911bf2008-07-26 23:55:291833}
1834
Christopher Camerone9a30c12018-03-07 08:23:381835void RenderWidget::UpdateSurfaceAndScreenInfo(
Fady Samuel4392abb2018-05-10 21:01:211836 const viz::LocalSurfaceId& new_local_surface_id,
Christopher Cameronaad15a0d2018-03-09 03:47:331837 const gfx::Size& new_compositor_viewport_pixel_size,
Christopher Camerone9a30c12018-03-07 08:23:381838 const ScreenInfo& new_screen_info) {
Christopher Camerone9a30c12018-03-07 08:23:381839 bool orientation_changed =
1840 screen_info_.orientation_angle != new_screen_info.orientation_angle ||
1841 screen_info_.orientation_type != new_screen_info.orientation_type;
1842 bool web_device_scale_factor_changed =
1843 screen_info_.device_scale_factor != new_screen_info.device_scale_factor;
Fady Samuela863f152018-03-09 16:10:031844 ScreenInfo previous_original_screen_info = GetOriginalScreenInfo();
Christopher Cameronbe7ecea2018-02-27 00:47:191845
Fady Samuel4255c182018-05-24 20:42:361846 local_surface_id_from_parent_ = new_local_surface_id;
Christopher Cameronaad15a0d2018-03-09 03:47:331847 compositor_viewport_pixel_size_ = new_compositor_viewport_pixel_size;
Christopher Camerone9a30c12018-03-07 08:23:381848 screen_info_ = new_screen_info;
Christopher Cameronbe7ecea2018-02-27 00:47:191849
danakja6c10012018-07-06 14:25:361850 if (layer_tree_view_) {
1851 layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect());
Christopher Camerone9a30c12018-03-07 08:23:381852 // Note carefully that the DSF specified in |new_screen_info| is not the
1853 // DSF used by the compositor during device emulation!
danakja6c10012018-07-06 14:25:361854 layer_tree_view_->SetViewportSizeAndScale(
Fady Samuela863f152018-03-09 16:10:031855 compositor_viewport_pixel_size_,
Fady Samuel4255c182018-05-24 20:42:361856 GetOriginalScreenInfo().device_scale_factor,
1857 local_surface_id_from_parent_);
Christopher Camerone9a30c12018-03-07 08:23:381858 }
Christopher Cameronbe7ecea2018-02-27 00:47:191859
Christopher Camerone9a30c12018-03-07 08:23:381860 if (orientation_changed)
1861 OnOrientationChange();
Christopher Cameronbe7ecea2018-02-27 00:47:191862
Fady Samuela863f152018-03-09 16:10:031863 if (previous_original_screen_info != GetOriginalScreenInfo()) {
Christopher Camerone9a30c12018-03-07 08:23:381864 for (auto& observer : render_frame_proxies_)
Fady Samuela863f152018-03-09 16:10:031865 observer.OnScreenInfoChanged(GetOriginalScreenInfo());
Christopher Camerone9a30c12018-03-07 08:23:381866
1867 // Notify all embedded BrowserPlugins of the updated ScreenInfo.
1868 for (auto& observer : browser_plugins_)
Fady Samuela863f152018-03-09 16:10:031869 observer.ScreenInfoChanged(GetOriginalScreenInfo());
Christopher Camerone9a30c12018-03-07 08:23:381870 }
1871
1872 if (web_device_scale_factor_changed)
Christopher Cameronbe7ecea2018-02-27 00:47:191873 UpdateWebViewWithDeviceScaleFactor();
oshimad5279032015-12-16 18:22:331874}
1875
danakja2c9d0a92018-07-25 20:01:181876void RenderWidget::SetWindowRectSynchronously(
1877 const gfx::Rect& new_window_rect) {
1878 VisualProperties visual_properties;
1879 visual_properties.screen_info = screen_info_;
1880 visual_properties.new_size = new_window_rect.size();
1881 visual_properties.compositor_viewport_pixel_size = gfx::ScaleToCeiledSize(
1882 new_window_rect.size(), GetWebScreenInfo().device_scale_factor);
1883 visual_properties.visible_viewport_size = new_window_rect.size();
1884 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
1885 visual_properties.display_mode = display_mode_;
1886 visual_properties.local_surface_id = local_surface_id_from_parent_;
1887 // We are resizing the window from the renderer, so allocate a new
1888 // viz::LocalSurfaceId to avoid surface invariants violations in tests.
1889 if (layer_tree_view_)
1890 layer_tree_view_->RequestNewLocalSurfaceId();
1891 SynchronizeVisualProperties(visual_properties);
1892
Albert J. Wong3c93c182018-09-27 17:29:431893 widget_screen_rect_ = new_window_rect;
danakja2c9d0a92018-07-25 20:01:181894 window_screen_rect_ = new_window_rect;
1895 if (!did_show_)
1896 initial_rect_ = new_window_rect;
1897}
1898
Vladimir Levin98d76dad2018-04-21 00:21:291899void RenderWidget::UpdateCaptureSequenceNumber(
1900 uint32_t capture_sequence_number) {
1901 if (capture_sequence_number == last_capture_sequence_number_)
1902 return;
1903 last_capture_sequence_number_ = capture_sequence_number;
1904
1905 // Notify observers of the new capture sequence number.
1906 for (auto& observer : render_frame_proxies_)
1907 observer.UpdateCaptureSequenceNumber(capture_sequence_number);
1908 for (auto& observer : browser_plugins_)
1909 observer.UpdateCaptureSequenceNumber(capture_sequence_number);
1910}
1911
[email protected]4873c7d2009-07-16 06:36:281912void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
EhsanK955ba582017-11-30 21:14:401913 if (auto* frame = GetFocusedWebLocalFrameInWidget())
1914 frame->SetTextDirection(direction);
[email protected]07f953332009-03-25 04:31:111915}
1916
Albert J. Wong3c93c182018-09-27 17:29:431917void RenderWidget::OnUpdateScreenRects(const gfx::Rect& widget_screen_rect,
[email protected]80ad8622012-11-07 16:33:031918 const gfx::Rect& window_screen_rect) {
[email protected]b2e4c70132013-10-03 02:07:511919 if (screen_metrics_emulator_) {
Albert J. Wong3c93c182018-09-27 17:29:431920 screen_metrics_emulator_->OnUpdateScreenRects(widget_screen_rect,
mfomitchev2600fd7c2016-02-17 20:53:391921 window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:511922 } else {
Albert J. Wong3c93c182018-09-27 17:29:431923 SetScreenRects(widget_screen_rect, window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:511924 }
Albert J. Wong3c93c182018-09-27 17:29:431925 Send(new WidgetHostMsg_UpdateScreenRects_ACK(routing_id()));
[email protected]80ad8622012-11-07 16:33:031926}
1927
kenrbea731792017-01-13 15:10:481928void RenderWidget::OnSetViewportIntersection(
Ken Buchananb2c9e262018-03-10 16:53:311929 const gfx::Rect& viewport_intersection,
Stefan Zager54e25832018-08-14 22:15:311930 const gfx::Rect& compositor_visible_rect,
1931 bool occluded_or_obscured) {
Ehsan Karamadf3ca2a82018-01-20 01:05:251932 if (auto* frame_widget = GetFrameWidget()) {
danakj6a816592018-09-25 18:30:561933 DCHECK_EQ(widget_type_, WidgetType::kFrame);
Ken Buchananb2c9e262018-03-10 16:53:311934 compositor_visible_rect_ = compositor_visible_rect;
Stefan Zager54e25832018-08-14 22:15:311935 frame_widget->SetRemoteViewportIntersection(viewport_intersection,
1936 occluded_or_obscured);
danakja6c10012018-07-06 14:25:361937 layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect());
kenrbea731792017-01-13 15:10:481938 }
1939}
1940
kenrb04323782017-06-23 01:23:321941void RenderWidget::OnSetIsInert(bool inert) {
Ehsan Karamadf3ca2a82018-01-20 01:05:251942 if (auto* frame_widget = GetFrameWidget()) {
danakj6a816592018-09-25 18:30:561943 DCHECK_EQ(widget_type_, WidgetType::kFrame);
Ehsan Karamadf3ca2a82018-01-20 01:05:251944 frame_widget->SetIsInert(inert);
kenrb04323782017-06-23 01:23:321945 }
1946}
1947
sunxd540a9962018-05-24 22:51:061948void RenderWidget::OnSetInheritedEffectiveTouchAction(
1949 cc::TouchAction touch_action) {
1950 if (auto* frame_widget = GetFrameWidget()) {
danakj6a816592018-09-25 18:30:561951 DCHECK_EQ(widget_type_, WidgetType::kFrame);
sunxd540a9962018-05-24 22:51:061952 frame_widget->SetInheritedEffectiveTouchAction(touch_action);
1953 }
1954}
1955
Ken Buchanan8a319fb2017-11-15 18:37:121956void RenderWidget::OnUpdateRenderThrottlingStatus(bool is_throttled,
1957 bool subtree_throttled) {
Ehsan Karamadf3ca2a82018-01-20 01:05:251958 if (auto* frame_widget = GetFrameWidget()) {
danakj6a816592018-09-25 18:30:561959 DCHECK_EQ(widget_type_, WidgetType::kFrame);
Ehsan Karamadf3ca2a82018-01-20 01:05:251960 frame_widget->UpdateRenderThrottlingStatus(is_throttled, subtree_throttled);
Ken Buchanan8a319fb2017-11-15 18:37:121961 }
1962}
1963
paulmeyer90f6c31d2016-11-12 00:17:591964void RenderWidget::OnDragTargetDragEnter(
1965 const std::vector<DropData::Metadata>& drop_meta_data,
Ella Ge80a52dce2017-11-15 18:01:521966 const gfx::PointF& client_point,
1967 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:591968 WebDragOperationsMask ops,
1969 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:251970 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1971 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:591972 return;
1973
Ehsan Karamadf3ca2a82018-01-20 01:05:251974 WebDragOperation operation = frame_widget->DragTargetDragEnter(
1975 DropMetaDataToWebDragData(drop_meta_data), client_point, screen_point,
1976 ops, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:591977
1978 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
1979}
1980
Ella Ge80a52dce2017-11-15 18:01:521981void RenderWidget::OnDragTargetDragOver(const gfx::PointF& client_point,
1982 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:591983 WebDragOperationsMask ops,
1984 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:251985 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1986 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:591987 return;
1988
Ehsan Karamadf3ca2a82018-01-20 01:05:251989 WebDragOperation operation = frame_widget->DragTargetDragOver(
1990 ConvertWindowPointToViewport(client_point), screen_point, ops,
1991 key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:591992
1993 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
1994}
1995
Ella Ge80a52dce2017-11-15 18:01:521996void RenderWidget::OnDragTargetDragLeave(const gfx::PointF& client_point,
1997 const gfx::PointF& screen_point) {
Ehsan Karamadf3ca2a82018-01-20 01:05:251998 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1999 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592000 return;
Ehsan Karamadf3ca2a82018-01-20 01:05:252001
2002 frame_widget
Blink Reformat1c4d759e2017-04-09 16:34:542003 ->DragTargetDragLeave(ConvertWindowPointToViewport(client_point),
kenrb07c272802017-02-07 23:48:172004 screen_point);
paulmeyer90f6c31d2016-11-12 00:17:592005}
2006
2007void RenderWidget::OnDragTargetDrop(const DropData& drop_data,
Ella Ge80a52dce2017-11-15 18:01:522008 const gfx::PointF& client_point,
2009 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592010 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252011 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2012 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592013 return;
2014
Ehsan Karamadf3ca2a82018-01-20 01:05:252015 frame_widget->DragTargetDrop(DropDataToWebDragData(drop_data),
2016 ConvertWindowPointToViewport(client_point),
2017 screen_point, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592018}
2019
Ella Ge80a52dce2017-11-15 18:01:522020void RenderWidget::OnDragSourceEnded(const gfx::PointF& client_point,
2021 const gfx::PointF& screen_point,
paulmeyer8fc8ea92016-11-15 05:12:212022 WebDragOperation op) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252023 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2024 if (!frame_widget)
paulmeyer8fc8ea92016-11-15 05:12:212025 return;
2026
Ehsan Karamadf3ca2a82018-01-20 01:05:252027 frame_widget->DragSourceEndedAt(ConvertWindowPointToViewport(client_point),
2028 screen_point, op);
paulmeyer8fc8ea92016-11-15 05:12:212029}
2030
2031void RenderWidget::OnDragSourceSystemDragEnded() {
2032 if (!GetWebWidget())
2033 return;
2034
Blink Reformat1c4d759e2017-04-09 16:34:542035 static_cast<WebFrameWidget*>(GetWebWidget())->DragSourceSystemDragEnded();
paulmeyer8fc8ea92016-11-15 05:12:212036}
2037
Blink Reformat1c4d759e2017-04-09 16:34:542038void RenderWidget::ShowVirtualKeyboardOnElementFocus() {
okaa398f50b2017-03-21 06:30:262039#if defined(OS_CHROMEOS)
2040 // On ChromeOS, virtual keyboard is triggered only when users leave the
2041 // mouse button or the finger and a text input element is focused at that
2042 // time. Focus event itself shouldn't trigger virtual keyboard.
2043 UpdateTextInputState();
2044#else
changwan75e3b2072017-01-16 02:55:002045 ShowVirtualKeyboard();
okaa398f50b2017-03-21 06:30:262046#endif
boliu7b2be2f2016-11-04 04:58:312047
2048// TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
2049// virtual keyboard.
2050#if !defined(OS_ANDROID)
2051 FocusChangeComplete();
2052#endif
[email protected]0d1ebed12013-08-05 22:01:132053}
2054
fsamuel72464894f2015-12-15 06:59:312055ui::TextInputType RenderWidget::GetTextInputType() {
brettw4b461082016-11-19 18:55:162056#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492057 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2058 return plugin->text_input_type();
ekaramad2a46d632016-07-19 13:33:092059#endif
ekaramad5aff1942017-01-06 01:26:352060 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:542061 return ConvertWebTextInputType(controller->TextInputType());
fsamuel72464894f2015-12-15 06:59:312062 return ui::TEXT_INPUT_TYPE_NONE;
2063}
2064
nonafa291792016-08-10 02:36:182065void RenderWidget::UpdateCompositionInfo(bool immediate_request) {
2066 if (!monitor_composition_info_ && !immediate_request)
2067 return; // Do not calculate composition info if not requested.
nonadac0c7a2016-08-01 02:30:592068
nonafa291792016-08-10 02:36:182069 TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo");
2070 gfx::Range range;
2071 std::vector<gfx::Rect> character_bounds;
2072
2073 if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE) {
2074 // Composition information is only available on editable node.
2075 range = gfx::Range::InvalidRange();
2076 } else {
2077 GetCompositionRange(&range);
2078 GetCompositionCharacterBounds(&character_bounds);
2079 }
2080
2081 if (!immediate_request &&
2082 !ShouldUpdateCompositionInfo(range, character_bounds)) {
fsamuel72464894f2015-12-15 06:59:312083 return;
nonafa291792016-08-10 02:36:182084 }
fsamuel72464894f2015-12-15 06:59:312085 composition_character_bounds_ = character_bounds;
2086 composition_range_ = range;
Dave Tapuska04bc5ee92018-04-17 19:03:312087 if (mojom::WidgetInputHandlerHost* host =
2088 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
2089 host->ImeCompositionRangeChanged(composition_range_,
2090 composition_character_bounds_);
Dave Tapuska139a72f2017-09-06 21:57:032091 }
fsamuel72464894f2015-12-15 06:59:312092}
2093
Blink Reformat1c4d759e2017-04-09 16:34:542094void RenderWidget::ConvertViewportToWindow(blink::WebRect* rect) {
danakj4b347212018-07-04 17:55:172095 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:032096 float reverse = 1 / GetOriginalScreenInfo().device_scale_factor;
oshimad5279032015-12-16 18:22:332097 // TODO(oshima): We may need to allow pixel precision here as the the
oshimaf866dab2015-12-05 00:41:542098 // anchor element can be placed at half pixel.
lfg15b235a32016-08-25 17:45:462099 gfx::Rect window_rect =
2100 gfx::ScaleToEnclosedRect(gfx::Rect(*rect), reverse);
2101 rect->x = window_rect.x();
2102 rect->y = window_rect.y();
2103 rect->width = window_rect.width();
2104 rect->height = window_rect.height();
oshimaf866dab2015-12-05 00:41:542105 }
2106}
2107
Blink Reformat1c4d759e2017-04-09 16:34:542108void RenderWidget::ConvertWindowToViewport(blink::WebFloatRect* rect) {
danakj4b347212018-07-04 17:55:172109 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:032110 rect->x *= GetOriginalScreenInfo().device_scale_factor;
2111 rect->y *= GetOriginalScreenInfo().device_scale_factor;
2112 rect->width *= GetOriginalScreenInfo().device_scale_factor;
2113 rect->height *= GetOriginalScreenInfo().device_scale_factor;
oshimaa6985b62016-01-27 08:58:302114 }
2115}
2116
changwan8c342742016-02-26 00:53:392117void RenderWidget::OnRequestTextInputStateUpdate() {
Dave Tapuska9db80842017-07-24 17:24:262118#if defined(OS_ANDROID)
changwan8c342742016-02-26 00:53:392119 DCHECK(!ime_event_guard_);
2120 UpdateSelectionBounds();
changwan75e3b2072017-01-16 02:55:002121 UpdateTextInputStateInternal(false, true /* reply_to_request */);
[email protected]105dffb42013-02-20 03:46:212122#endif
Dave Tapuska9db80842017-07-24 17:24:262123}
[email protected]105dffb42013-02-20 03:46:212124
ekaramadc9b70a72017-03-23 16:14:232125void RenderWidget::OnRequestCompositionUpdates(bool immediate_request,
2126 bool monitor_updates) {
2127 monitor_composition_info_ = monitor_updates;
nonafa291792016-08-10 02:36:182128 if (!immediate_request)
2129 return;
2130 UpdateCompositionInfo(true /* immediate request */);
2131}
2132
[email protected]fcdc5642014-05-09 14:32:242133void RenderWidget::OnOrientationChange() {
Ehsan Karamad655d7b8a2018-01-12 18:38:382134 if (auto* frame_widget = GetFrameWidget()) {
Alex Moshchuk0b409c42017-09-13 02:09:002135 // LocalRoot() might return null for provisional main frames. In this case,
2136 // the frame hasn't committed a navigation and is not swapped into the tree
2137 // yet, so it doesn't make sense to send orientation change events to it.
2138 //
2139 // TODO(https://crbug.com/578349): This check should be cleaned up
2140 // once provisional frames are gone.
Ehsan Karamad655d7b8a2018-01-12 18:38:382141 if (frame_widget->LocalRoot())
2142 frame_widget->LocalRoot()->SendOrientationChangeEvent();
lfg8d649cc2017-04-28 18:04:302143 }
[email protected]fcdc5642014-05-09 14:32:242144}
2145
danakja2c9d0a92018-07-25 20:01:182146GURL RenderWidget::GetURLForGraphicsContext3D() {
2147 if (owner_delegate_)
2148 return owner_delegate_->GetURLForGraphicsContext3DForWidget();
2149 return GURL();
2150}
2151
[email protected]bee16aab2009-08-26 15:55:032152void RenderWidget::SetHidden(bool hidden) {
2153 if (is_hidden_ == hidden)
2154 return;
2155
jdduke8fac9d102014-12-20 02:40:132156 // The status has changed. Tell the RenderThread about it and ensure
2157 // throttled acks are released in case frame production ceases.
[email protected]bee16aab2009-08-26 15:55:032158 is_hidden_ = hidden;
jdduke8fac9d102014-12-20 02:40:132159
Scott Violet1098538e2017-10-05 19:23:332160#if defined(USE_AURA)
Scott Violete46b3352018-09-22 00:37:072161 if (features::IsMultiProcessMash())
Scott Violet1098538e2017-10-05 19:23:332162 RendererWindowTreeClient::Get(routing_id_)->SetVisible(!hidden);
2163#endif
2164
Saman Sami58ed4392018-01-31 20:54:192165 // RenderThreadImpl::current() could be null in tests.
2166 if (RenderThreadImpl::current()) {
2167 if (is_hidden_) {
2168 RenderThreadImpl::current()->WidgetHidden();
2169 first_update_visual_state_after_hidden_ = true;
2170 } else {
2171 RenderThreadImpl::current()->WidgetRestored();
2172 }
Lei Zhang9b359d32017-11-28 00:57:022173 }
alexclarke7fa93942015-10-21 15:37:112174
2175 if (render_widget_scheduling_state_)
2176 render_widget_scheduling_state_->SetHidden(hidden);
[email protected]bee16aab2009-08-26 15:55:032177}
2178
[email protected]2b624c562011-10-27 22:58:262179void RenderWidget::DidToggleFullscreen() {
lfg8ff33912016-09-13 20:59:212180 if (!GetWebWidget())
[email protected]2b624c562011-10-27 22:58:262181 return;
2182
mikhail.pozdnyakovf2c902a2015-04-14 08:09:122183 if (is_fullscreen_granted_) {
Blink Reformat1c4d759e2017-04-09 16:34:542184 GetWebWidget()->DidEnterFullscreen();
[email protected]2b624c562011-10-27 22:58:262185 } else {
Blink Reformat1c4d759e2017-04-09 16:34:542186 GetWebWidget()->DidExitFullscreen();
[email protected]2b624c562011-10-27 22:58:262187 }
[email protected]2b624c562011-10-27 22:58:262188}
2189
changwanf2a707b2015-10-30 08:22:162190void RenderWidget::OnImeEventGuardStart(ImeEventGuard* guard) {
2191 if (!ime_event_guard_)
2192 ime_event_guard_ = guard;
[email protected]66fca5bc2013-05-23 06:58:292193}
2194
changwanf2a707b2015-10-30 08:22:162195void RenderWidget::OnImeEventGuardFinish(ImeEventGuard* guard) {
Jeremy Roman0b261f42018-08-28 15:36:012196 if (ime_event_guard_ != guard)
changwanf2a707b2015-10-30 08:22:162197 return;
changwanf2a707b2015-10-30 08:22:162198 ime_event_guard_ = nullptr;
2199
[email protected]66fca5bc2013-05-23 06:58:292200 // While handling an ime event, text input state and selection bounds updates
2201 // are ignored. These must explicitly be updated once finished handling the
2202 // ime event.
2203 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:472204#if defined(OS_ANDROID)
changwan75e3b2072017-01-16 02:55:002205 if (guard->show_virtual_keyboard())
2206 ShowVirtualKeyboard();
2207 else
2208 UpdateTextInputState();
[email protected]cb9e2632013-06-18 11:26:472209#endif
[email protected]66fca5bc2013-05-23 06:58:292210}
2211
[email protected]7c8873e2013-02-05 08:03:012212void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
brettw4b461082016-11-19 18:55:162213#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492214 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
ekaramad2a46d632016-07-19 13:33:092215 // TODO(kinaba) http://crbug.com/101101
2216 // Current Pepper IME API does not handle selection bounds. So we simply
2217 // use the caret position as an empty range for now. It will be updated
2218 // after Pepper API equips features related to surrounding text retrieval.
EhsanK22d482e2017-08-10 17:29:492219 blink::WebRect caret(plugin->GetCaretBounds());
Blink Reformat1c4d759e2017-04-09 16:34:542220 ConvertViewportToWindow(&caret);
ekaramad2a46d632016-07-19 13:33:092221 *focus = caret;
2222 *anchor = caret;
2223 return;
2224 }
2225#endif
[email protected]7c8873e2013-02-05 08:03:012226 WebRect focus_webrect;
2227 WebRect anchor_webrect;
Blink Reformat1c4d759e2017-04-09 16:34:542228 GetWebWidget()->SelectionBounds(focus_webrect, anchor_webrect);
2229 ConvertViewportToWindow(&focus_webrect);
2230 ConvertViewportToWindow(&anchor_webrect);
oshima33ec97cd2015-12-14 19:40:242231 *focus = focus_webrect;
2232 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:322233}
2234
[email protected]e99ef6f2011-10-16 01:13:002235void RenderWidget::UpdateSelectionBounds() {
jdduke1aebad8e2015-07-22 23:25:082236 TRACE_EVENT0("renderer", "RenderWidget::UpdateSelectionBounds");
lfg8ff33912016-09-13 20:59:212237 if (!GetWebWidget())
[email protected]e99ef6f2011-10-16 01:13:002238 return;
changwanf2a707b2015-10-30 08:22:162239 if (ime_event_guard_)
[email protected]66fca5bc2013-05-23 06:58:292240 return;
[email protected]e99ef6f2011-10-16 01:13:002241
mohsenb0eeba72015-08-09 06:20:082242#if defined(USE_AURA)
2243 // TODO(mohsen): For now, always send explicit selection IPC notifications for
2244 // Aura beucause composited selection updates are not working for webview tags
2245 // which regresses IME inside webview. Remove this when composited selection
2246 // updates are fixed for webviews. See, http://crbug.com/510568.
2247 bool send_ipc = true;
2248#else
jddukeacf809e2014-09-23 20:38:382249 // With composited selection updates, the selection bounds will be reported
2250 // directly by the compositor, in which case explicit IPC selection
2251 // notifications should be suppressed.
mohsenb0eeba72015-08-09 06:20:082252 bool send_ipc =
Blink Reformat1c4d759e2017-04-09 16:34:542253 !blink::WebRuntimeFeatures::IsCompositedSelectionUpdateEnabled();
mohsenb0eeba72015-08-09 06:20:082254#endif
2255 if (send_ipc) {
Albert J. Wong3c93c182018-09-27 17:29:432256 WidgetHostMsg_SelectionBounds_Params params;
EhsanK955ba582017-11-30 21:14:402257 params.is_anchor_first = false;
jddukeacf809e2014-09-23 20:38:382258 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
2259 if (selection_anchor_rect_ != params.anchor_rect ||
2260 selection_focus_rect_ != params.focus_rect) {
2261 selection_anchor_rect_ = params.anchor_rect;
2262 selection_focus_rect_ = params.focus_rect;
EhsanK955ba582017-11-30 21:14:402263 if (auto* focused_frame = GetFocusedWebLocalFrameInWidget()) {
2264 focused_frame->SelectionTextDirection(params.focus_dir,
2265 params.anchor_dir);
2266 params.is_anchor_first = focused_frame->IsSelectionAnchorFirst();
2267 }
Albert J. Wong3c93c182018-09-27 17:29:432268 Send(new WidgetHostMsg_SelectionBoundsChanged(routing_id_, params));
jddukeacf809e2014-09-23 20:38:382269 }
[email protected]58b48a0d2012-06-13 07:01:352270 }
jddukeacf809e2014-09-23 20:38:382271
nonafa291792016-08-10 02:36:182272 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]e99ef6f2011-10-16 01:13:002273}
2274
lfgb00fcad2016-07-14 14:16:332275void RenderWidget::DidAutoResize(const gfx::Size& new_size) {
2276 WebRect new_size_in_window(0, 0, new_size.width(), new_size.height());
Blink Reformat1c4d759e2017-04-09 16:34:542277 ConvertViewportToWindow(&new_size_in_window);
lfgb00fcad2016-07-14 14:16:332278 if (size_.width() != new_size_in_window.width ||
2279 size_.height() != new_size_in_window.height) {
2280 size_ = gfx::Size(new_size_in_window.width, new_size_in_window.height);
2281
2282 if (resizing_mode_selector_->is_synchronous_mode()) {
Blink Reformat1c4d759e2017-04-09 16:34:542283 gfx::Rect new_pos(WindowRect().x, WindowRect().y, size_.width(),
2284 size_.height());
Albert J. Wong3c93c182018-09-27 17:29:432285 widget_screen_rect_ = new_pos;
lfgb00fcad2016-07-14 14:16:332286 window_screen_rect_ = new_pos;
2287 }
2288
Christopher Camerone9a30c12018-03-07 08:23:382289 // TODO(ccameron): Note that this destroys any information differentiating
Christopher Cameronaad15a0d2018-03-09 03:47:332290 // |size_| from |compositor_viewport_pixel_size_|. Also note that the
2291 // calculation of |new_compositor_viewport_pixel_size| does not appear to
2292 // take into account device emulation.
danakja6c10012018-07-06 14:25:362293 if (layer_tree_view_)
2294 layer_tree_view_->RequestNewLocalSurfaceId();
Christopher Cameronaad15a0d2018-03-09 03:47:332295 gfx::Size new_compositor_viewport_pixel_size =
Fady Samuela863f152018-03-09 16:10:032296 gfx::ScaleToCeiledSize(size_, GetWebScreenInfo().device_scale_factor);
Fady Samuel4255c182018-05-24 20:42:362297 UpdateSurfaceAndScreenInfo(local_surface_id_from_parent_,
2298 new_compositor_viewport_pixel_size,
2299 screen_info_);
lfgb00fcad2016-07-14 14:16:332300 }
2301}
2302
[email protected]58b48a0d2012-06-13 07:01:352303void RenderWidget::GetCompositionCharacterBounds(
2304 std::vector<gfx::Rect>* bounds) {
2305 DCHECK(bounds);
2306 bounds->clear();
ekaramad2a46d632016-07-19 13:33:092307
brettw4b461082016-11-19 18:55:162308#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492309 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092310 return;
2311#endif
2312
Ehsan Karamad4975af6d2018-02-09 16:58:162313 blink::WebInputMethodController* controller = GetInputMethodController();
2314 if (!controller)
ekaramad2a46d632016-07-19 13:33:092315 return;
2316 blink::WebVector<blink::WebRect> bounds_from_blink;
Ehsan Karamad4975af6d2018-02-09 16:58:162317 if (!controller->GetCompositionCharacterBounds(bounds_from_blink))
ekaramad2a46d632016-07-19 13:33:092318 return;
2319
2320 for (size_t i = 0; i < bounds_from_blink.size(); ++i) {
Blink Reformat1c4d759e2017-04-09 16:34:542321 ConvertViewportToWindow(&bounds_from_blink[i]);
ekaramad2a46d632016-07-19 13:33:092322 bounds->push_back(bounds_from_blink[i]);
2323 }
[email protected]58b48a0d2012-06-13 07:01:352324}
2325
[email protected]db4fc1e2013-09-06 20:01:512326void RenderWidget::GetCompositionRange(gfx::Range* range) {
brettw4b461082016-11-19 18:55:162327#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492328 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092329 return;
2330#endif
EhsanKcdee7b72017-11-08 21:30:092331 blink::WebInputMethodController* controller = GetInputMethodController();
2332 WebRange web_range = controller ? controller->CompositionRange() : WebRange();
Blink Reformat1c4d759e2017-04-09 16:34:542333 if (web_range.IsNull()) {
nona2363a3d2016-11-09 03:26:212334 *range = gfx::Range::InvalidRange();
2335 return;
[email protected]88dbe32f2013-06-20 23:31:362336 }
Blink Reformat1c4d759e2017-04-09 16:34:542337 range->set_start(web_range.StartOffset());
2338 range->set_end(web_range.EndOffset());
[email protected]88dbe32f2013-06-20 23:31:362339}
2340
[email protected]501ea13d2013-07-09 17:03:292341bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:512342 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:292343 const std::vector<gfx::Rect>& bounds) {
changwan2418e1b2016-12-12 12:43:082344 if (!range.IsValid())
2345 return false;
[email protected]501ea13d2013-07-09 17:03:292346 if (composition_range_ != range)
2347 return true;
2348 if (bounds.size() != composition_character_bounds_.size())
2349 return true;
2350 for (size_t i = 0; i < bounds.size(); ++i) {
2351 if (bounds[i] != composition_character_bounds_[i])
2352 return true;
2353 }
2354 return false;
2355}
[email protected]501ea13d2013-07-09 17:03:292356
[email protected]ad26ef42011-06-17 07:59:452357bool RenderWidget::CanComposeInline() {
brettw4b461082016-11-19 18:55:162358#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492359 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2360 return plugin->IsPluginAcceptingCompositionEvents();
ekaramad2a46d632016-07-19 13:33:092361#endif
[email protected]ad26ef42011-06-17 07:59:452362 return true;
[email protected]56ea1a62011-05-30 07:05:572363}
2364
Blink Reformat1c4d759e2017-04-09 16:34:542365blink::WebScreenInfo RenderWidget::GetScreenInfo() {
ccameron2f451532016-09-07 21:49:272366 blink::WebScreenInfo web_screen_info;
Blink Reformat1c4d759e2017-04-09 16:34:542367 web_screen_info.device_scale_factor = screen_info_.device_scale_factor;
ccameronab0aab82017-06-24 17:21:542368 web_screen_info.color_space = screen_info_.color_space;
ccameron2f451532016-09-07 21:49:272369 web_screen_info.depth = screen_info_.depth;
Blink Reformat1c4d759e2017-04-09 16:34:542370 web_screen_info.depth_per_component = screen_info_.depth_per_component;
2371 web_screen_info.is_monochrome = screen_info_.is_monochrome;
ccameron2f451532016-09-07 21:49:272372 web_screen_info.rect = blink::WebRect(screen_info_.rect);
Blink Reformat1c4d759e2017-04-09 16:34:542373 web_screen_info.available_rect = blink::WebRect(screen_info_.available_rect);
ccameron2f451532016-09-07 21:49:272374 switch (screen_info_.orientation_type) {
2375 case SCREEN_ORIENTATION_VALUES_PORTRAIT_PRIMARY:
Blink Reformat1c4d759e2017-04-09 16:34:542376 web_screen_info.orientation_type =
2377 blink::kWebScreenOrientationPortraitPrimary;
ccameron2f451532016-09-07 21:49:272378 break;
2379 case SCREEN_ORIENTATION_VALUES_PORTRAIT_SECONDARY:
Blink Reformat1c4d759e2017-04-09 16:34:542380 web_screen_info.orientation_type =
2381 blink::kWebScreenOrientationPortraitSecondary;
ccameron2f451532016-09-07 21:49:272382 break;
2383 case SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY:
Blink Reformat1c4d759e2017-04-09 16:34:542384 web_screen_info.orientation_type =
2385 blink::kWebScreenOrientationLandscapePrimary;
ccameron2f451532016-09-07 21:49:272386 break;
2387 case SCREEN_ORIENTATION_VALUES_LANDSCAPE_SECONDARY:
Blink Reformat1c4d759e2017-04-09 16:34:542388 web_screen_info.orientation_type =
2389 blink::kWebScreenOrientationLandscapeSecondary;
ccameron2f451532016-09-07 21:49:272390 break;
2391 default:
Blink Reformat1c4d759e2017-04-09 16:34:542392 web_screen_info.orientation_type = blink::kWebScreenOrientationUndefined;
ccameron2f451532016-09-07 21:49:272393 break;
2394 }
Blink Reformat1c4d759e2017-04-09 16:34:542395 web_screen_info.orientation_angle = screen_info_.orientation_angle;
Fady Samuel85a1bf72017-10-27 14:30:202396
ccameron2f451532016-09-07 21:49:272397 return web_screen_info;
[email protected]4873c7d2009-07-16 06:36:282398}
2399
Blink Reformat1c4d759e2017-04-09 16:34:542400void RenderWidget::DidHandleGestureEvent(const WebGestureEvent& event,
2401 bool event_cancelled) {
danakja2c9d0a92018-07-25 20:01:182402 if (event_cancelled) {
2403 // The |owner_delegate_| doesn't need to hear about cancelled events.
[email protected]c68c3e4e2013-01-24 00:36:562404 return;
danakja2c9d0a92018-07-25 20:01:182405 }
2406
2407#if defined(OS_ANDROID) || defined(USE_AURA)
Blink Reformat1c4d759e2017-04-09 16:34:542408 if (event.GetType() == WebInputEvent::kGestureTap) {
changwan75e3b2072017-01-16 02:55:002409 ShowVirtualKeyboard();
Blink Reformat1c4d759e2017-04-09 16:34:542410 } else if (event.GetType() == WebInputEvent::kGestureLongPress) {
lfg8ff33912016-09-13 20:59:212411 DCHECK(GetWebWidget());
ekaramad5aff1942017-01-06 01:26:352412 blink::WebInputMethodController* controller = GetInputMethodController();
Blink Reformat1c4d759e2017-04-09 16:34:542413 if (!controller || controller->TextInputInfo().value.IsEmpty())
changwan75e3b2072017-01-16 02:55:002414 UpdateTextInputState();
[email protected]07c70d22014-08-21 08:33:462415 else
changwan75e3b2072017-01-16 02:55:002416 ShowVirtualKeyboard();
[email protected]c68c3e4e2013-01-24 00:36:562417 }
ekaramada110f642016-12-21 19:47:282418// TODO(ananta): Piggyback off existing IPCs to communicate this information,
2419// crbug/420130.
2420#if defined(OS_WIN)
danakja2c9d0a92018-07-25 20:01:182421 if (event.GetType() == blink::WebGestureEvent::kGestureTap) {
2422 // TODO(estade): hit test the event against focused node to make sure
2423 // the tap actually hit the focused node.
2424 blink::WebInputMethodController* controller = GetInputMethodController();
2425 blink::WebTextInputType text_input_type =
2426 controller ? controller->TextInputType() : blink::kWebTextInputTypeNone;
ekaramada110f642016-12-21 19:47:282427
Albert J. Wong3c93c182018-09-27 17:29:432428 Send(new WidgetHostMsg_FocusedNodeTouched(
danakja2c9d0a92018-07-25 20:01:182429 routing_id_, text_input_type != blink::kWebTextInputTypeNone));
2430 }
ekaramada110f642016-12-21 19:47:282431#endif
[email protected]c68c3e4e2013-01-24 00:36:562432#endif
danakja2c9d0a92018-07-25 20:01:182433
2434 // The |owner_delegate_| gets to respond to handling gestures last.
2435 if (owner_delegate_)
2436 owner_delegate_->DidHandleGestureEventForWidget(event);
[email protected]c68c3e4e2013-01-24 00:36:562437}
2438
Blink Reformat1c4d759e2017-04-09 16:34:542439void RenderWidget::DidOverscroll(
bokane53a10f2016-04-13 23:48:312440 const blink::WebFloatSize& overscrollDelta,
2441 const blink::WebFloatSize& accumulatedOverscroll,
sataya.m582c9ce2015-06-09 08:03:422442 const blink::WebFloatPoint& position,
sunyunjiabbea8a92017-08-31 11:18:542443 const blink::WebFloatSize& velocity,
danakje819b622018-05-01 20:27:142444 const cc::OverscrollBehavior& behavior) {
bokan731ec382016-04-07 03:16:482445#if defined(OS_MACOSX)
2446 // On OSX the user can disable the elastic overscroll effect. If that's the
2447 // case, don't forward the overscroll notification.
2448 DCHECK(compositor_deps());
2449 if (!compositor_deps()->IsElasticOverscrollEnabled())
2450 return;
2451#endif
bokane53a10f2016-04-13 23:48:312452 input_handler_->DidOverscrollFromBlink(overscrollDelta, accumulatedOverscroll,
sunyunjiabbea8a92017-08-31 11:18:542453 position, velocity, behavior);
sataya.m582c9ce2015-06-09 08:03:422454}
2455
danakj4b347212018-07-04 17:55:172456// static
2457cc::LayerTreeSettings RenderWidget::GenerateLayerTreeSettings(
2458 CompositorDependencies* compositor_deps,
2459 bool is_for_subframe,
2460 const gfx::Size& initial_screen_size,
2461 float initial_device_scale_factor) {
2462 const bool is_threaded =
2463 !!compositor_deps->GetCompositorImplThreadTaskRunner();
2464
2465 const base::CommandLine& cmd = *base::CommandLine::ForCurrentProcess();
2466 cc::LayerTreeSettings settings;
2467
2468 settings.resource_settings.use_r16_texture =
2469 base::FeatureList::IsEnabled(media::kUseR16Texture);
2470
2471 settings.commit_to_active_tree = !is_threaded;
2472 settings.is_layer_tree_for_subframe = is_for_subframe;
2473
2474 // For web contents, layer transforms should scale up the contents of layers
2475 // to keep content always crisp when possible.
2476 settings.layer_transforms_should_scale_layer_contents = true;
2477
2478 settings.main_frame_before_activation_enabled =
2479 cmd.HasSwitch(cc::switches::kEnableMainFrameBeforeActivation);
2480
2481 // Checkerimaging is not supported for synchronous single-threaded mode, which
2482 // is what the renderer uses if its not threaded.
2483 settings.enable_checker_imaging =
2484 !cmd.HasSwitch(cc::switches::kDisableCheckerImaging) && is_threaded;
2485
2486#if defined(OS_ANDROID)
2487 // We can use a more aggressive limit on Android since decodes tend to take
2488 // longer on these devices.
2489 settings.min_image_bytes_to_checker = 512 * 1024; // 512kB
2490
2491 // Re-rasterization of checker-imaged content with software raster can be too
2492 // costly on Android.
2493 settings.only_checker_images_with_gpu_raster = true;
2494#endif
2495
2496 auto switch_value_as_int = [](const base::CommandLine& command_line,
2497 const std::string& switch_string, int min_value,
2498 int max_value, int* result) {
2499 std::string string_value = command_line.GetSwitchValueASCII(switch_string);
2500 int int_value;
2501 if (base::StringToInt(string_value, &int_value) && int_value >= min_value &&
2502 int_value <= max_value) {
2503 *result = int_value;
2504 return true;
2505 } else {
2506 LOG(WARNING) << "Failed to parse switch " << switch_string << ": "
2507 << string_value;
2508 return false;
2509 }
2510 };
2511
2512 int default_tile_size = 256;
2513#if defined(OS_ANDROID)
2514 const gfx::Size screen_size =
2515 gfx::ScaleToFlooredSize(initial_screen_size, initial_device_scale_factor);
2516 int display_width = screen_size.width();
2517 int display_height = screen_size.height();
2518 int numTiles = (display_width * display_height) / (256 * 256);
2519 if (numTiles > 16)
2520 default_tile_size = 384;
2521 if (numTiles >= 40)
2522 default_tile_size = 512;
2523
2524 // Adjust for some resolutions that barely straddle an extra
2525 // tile when in portrait mode. This helps worst case scroll/raster
2526 // by not needing a full extra tile for each row.
2527 constexpr int tolerance = 10; // To avoid rounding errors.
2528 int portrait_width = std::min(display_width, display_height);
2529 if (default_tile_size == 256 && std::abs(portrait_width - 768) < tolerance)
2530 default_tile_size += 32;
2531 if (default_tile_size == 384 && std::abs(portrait_width - 1200) < tolerance)
2532 default_tile_size += 32;
2533#elif defined(OS_CHROMEOS) || defined(OS_MACOSX)
2534 // Use 512 for high DPI (dsf=2.0f) devices.
2535 if (initial_device_scale_factor >= 2.0f)
2536 default_tile_size = 512;
2537#endif
2538
2539 // TODO(danakj): This should not be a setting O_O; it should change when the
2540 // device scale factor on LayerTreeHost changes.
2541 settings.default_tile_size = gfx::Size(default_tile_size, default_tile_size);
2542 if (cmd.HasSwitch(switches::kDefaultTileWidth)) {
2543 int tile_width = 0;
2544 switch_value_as_int(cmd, switches::kDefaultTileWidth, 1,
2545 std::numeric_limits<int>::max(), &tile_width);
2546 settings.default_tile_size.set_width(tile_width);
2547 }
2548 if (cmd.HasSwitch(switches::kDefaultTileHeight)) {
2549 int tile_height = 0;
2550 switch_value_as_int(cmd, switches::kDefaultTileHeight, 1,
2551 std::numeric_limits<int>::max(), &tile_height);
2552 settings.default_tile_size.set_height(tile_height);
2553 }
2554
2555 int max_untiled_layer_width = settings.max_untiled_layer_size.width();
2556 if (cmd.HasSwitch(switches::kMaxUntiledLayerWidth)) {
2557 switch_value_as_int(cmd, switches::kMaxUntiledLayerWidth, 1,
2558 std::numeric_limits<int>::max(),
2559 &max_untiled_layer_width);
2560 }
2561 int max_untiled_layer_height = settings.max_untiled_layer_size.height();
2562 if (cmd.HasSwitch(switches::kMaxUntiledLayerHeight)) {
2563 switch_value_as_int(cmd, switches::kMaxUntiledLayerHeight, 1,
2564 std::numeric_limits<int>::max(),
2565 &max_untiled_layer_height);
2566 }
2567
2568 settings.max_untiled_layer_size =
2569 gfx::Size(max_untiled_layer_width, max_untiled_layer_height);
2570
2571 settings.gpu_rasterization_msaa_sample_count =
2572 compositor_deps->GetGpuRasterizationMSAASampleCount();
2573 settings.gpu_rasterization_forced =
2574 compositor_deps->IsGpuRasterizationForced();
2575
2576 settings.can_use_lcd_text = compositor_deps->IsLcdTextEnabled();
2577 settings.use_zero_copy = compositor_deps->IsZeroCopyEnabled();
2578 settings.use_partial_raster = compositor_deps->IsPartialRasterEnabled();
2579 settings.enable_elastic_overscroll =
2580 compositor_deps->IsElasticOverscrollEnabled();
2581 settings.resource_settings.use_gpu_memory_buffer_resources =
2582 compositor_deps->IsGpuMemoryBufferCompositorResourcesEnabled();
2583 settings.use_painted_device_scale_factor =
2584 compositor_deps->IsUseZoomForDSFEnabled();
2585
2586 // Build LayerTreeSettings from command line args.
2587 if (cmd.HasSwitch(cc::switches::kBrowserControlsShowThreshold)) {
2588 std::string top_threshold_str =
2589 cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsShowThreshold);
2590 double show_threshold;
2591 if (base::StringToDouble(top_threshold_str, &show_threshold) &&
2592 show_threshold >= 0.f && show_threshold <= 1.f)
2593 settings.top_controls_show_threshold = show_threshold;
2594 }
2595
2596 if (cmd.HasSwitch(cc::switches::kBrowserControlsHideThreshold)) {
2597 std::string top_threshold_str =
2598 cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsHideThreshold);
2599 double hide_threshold;
2600 if (base::StringToDouble(top_threshold_str, &hide_threshold) &&
2601 hide_threshold >= 0.f && hide_threshold <= 1.f)
2602 settings.top_controls_hide_threshold = hide_threshold;
2603 }
2604
2605 settings.use_layer_lists = cmd.HasSwitch(cc::switches::kEnableLayerLists);
2606
2607 // The means the renderer compositor has 2 possible modes:
2608 // - Threaded compositing with a scheduler.
2609 // - Single threaded compositing without a scheduler (for layout tests only).
2610 // Using the scheduler in layout tests introduces additional composite steps
2611 // that create flakiness.
2612 settings.single_thread_proxy_scheduler = false;
2613
2614 // These flags should be mirrored by UI versions in ui/compositor/.
2615 if (cmd.HasSwitch(cc::switches::kShowCompositedLayerBorders))
2616 settings.initial_debug_state.show_debug_borders.set();
2617 settings.initial_debug_state.show_layer_animation_bounds_rects =
2618 cmd.HasSwitch(cc::switches::kShowLayerAnimationBounds);
2619 settings.initial_debug_state.show_paint_rects =
2620 cmd.HasSwitch(switches::kShowPaintRects);
2621 settings.initial_debug_state.show_property_changed_rects =
2622 cmd.HasSwitch(cc::switches::kShowPropertyChangedRects);
2623 settings.initial_debug_state.show_surface_damage_rects =
2624 cmd.HasSwitch(cc::switches::kShowSurfaceDamageRects);
2625 settings.initial_debug_state.show_screen_space_rects =
2626 cmd.HasSwitch(cc::switches::kShowScreenSpaceRects);
2627
2628 settings.initial_debug_state.SetRecordRenderingStats(
2629 cmd.HasSwitch(cc::switches::kEnableGpuBenchmarking));
2630 settings.enable_surface_synchronization =
2631 features::IsSurfaceSynchronizationEnabled();
2632 settings.build_hit_test_data = features::IsVizHitTestingSurfaceLayerEnabled();
2633
2634 if (cmd.HasSwitch(cc::switches::kSlowDownRasterScaleFactor)) {
2635 const int kMinSlowDownScaleFactor = 0;
2636 const int kMaxSlowDownScaleFactor = INT_MAX;
2637 switch_value_as_int(
2638 cmd, cc::switches::kSlowDownRasterScaleFactor, kMinSlowDownScaleFactor,
2639 kMaxSlowDownScaleFactor,
2640 &settings.initial_debug_state.slow_down_raster_scale_factor);
2641 }
2642
2643 // This is default overlay scrollbar settings for Android and DevTools mobile
2644 // emulator. Aura Overlay Scrollbar will override below.
2645 settings.scrollbar_animator = cc::LayerTreeSettings::ANDROID_OVERLAY;
2646 settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
2647 settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(300);
2648 settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(300);
2649
2650#if defined(OS_ANDROID)
2651 bool using_synchronous_compositor =
2652 compositor_deps->UsingSynchronousCompositing();
2653 bool using_low_memory_policy = base::SysInfo::IsLowEndDevice();
2654
2655 settings.use_stream_video_draw_quad = true;
2656 settings.using_synchronous_renderer_compositor = using_synchronous_compositor;
2657 if (using_synchronous_compositor) {
2658 // Android WebView uses system scrollbars, so make ours invisible.
2659 // http://crbug.com/677348: This can't be done using hide_scrollbars
2660 // setting because supporting -webkit custom scrollbars is still desired
2661 // on sublayers.
2662 settings.scrollbar_animator = cc::LayerTreeSettings::NO_ANIMATOR;
2663 settings.solid_color_scrollbar_color = SK_ColorTRANSPARENT;
2664
2665 settings.enable_early_damage_check =
2666 cmd.HasSwitch(cc::switches::kCheckDamageEarly);
2667 }
2668 // Android WebView handles root layer flings itself.
2669 settings.ignore_root_layer_flings = using_synchronous_compositor;
2670 // Memory policy on Android WebView does not depend on whether device is
2671 // low end, so always use default policy.
2672 if (using_low_memory_policy && !using_synchronous_compositor) {
2673 // On low-end we want to be very carefull about killing other
2674 // apps. So initially we use 50% more memory to avoid flickering
2675 // or raster-on-demand.
2676 settings.max_memory_for_prepaint_percentage = 67;
2677 } else {
2678 // On other devices we have increased memory excessively to avoid
2679 // raster-on-demand already, so now we reserve 50% _only_ to avoid
2680 // raster-on-demand, and use 50% of the memory otherwise.
2681 settings.max_memory_for_prepaint_percentage = 50;
2682 }
2683
2684 // TODO(danakj): Only do this on low end devices.
2685 settings.create_low_res_tiling = true;
2686
2687#else // defined(OS_ANDROID)
2688 bool using_synchronous_compositor = false; // Only for Android WebView.
2689 // On desktop, we never use the low memory policy unless we are simulating
2690 // low-end mode via a switch.
2691 bool using_low_memory_policy =
2692 cmd.HasSwitch(switches::kEnableLowEndDeviceMode);
2693
2694 if (ui::IsOverlayScrollbarEnabled()) {
2695 settings.scrollbar_animator = cc::LayerTreeSettings::AURA_OVERLAY;
2696 settings.scrollbar_fade_delay = ui::kOverlayScrollbarFadeDelay;
2697 settings.scrollbar_fade_duration = ui::kOverlayScrollbarFadeDuration;
2698 settings.scrollbar_thinning_duration =
2699 ui::kOverlayScrollbarThinningDuration;
2700 settings.scrollbar_flash_after_any_scroll_update =
2701 ui::OverlayScrollbarFlashAfterAnyScrollUpdate();
2702 settings.scrollbar_flash_when_mouse_enter =
2703 ui::OverlayScrollbarFlashWhenMouseEnter();
2704 }
2705
2706 // On desktop, if there's over 4GB of memory on the machine, increase the
2707 // working set size to 256MB for both gpu and software.
2708 const int kImageDecodeMemoryThresholdMB = 4 * 1024;
2709 if (base::SysInfo::AmountOfPhysicalMemoryMB() >=
2710 kImageDecodeMemoryThresholdMB) {
2711 settings.decoded_image_working_set_budget_bytes = 256 * 1024 * 1024;
2712 } else {
2713 // This is the default, but recorded here as well.
2714 settings.decoded_image_working_set_budget_bytes = 128 * 1024 * 1024;
2715 }
2716#endif // defined(OS_ANDROID)
2717
2718 if (using_low_memory_policy) {
2719 // RGBA_4444 textures are only enabled:
2720 // - If the user hasn't explicitly disabled them
2721 // - If system ram is <= 512MB (1GB devices are sometimes low-end).
2722 // - If we are not running in a WebView, where 4444 isn't supported.
2723 if (!cmd.HasSwitch(switches::kDisableRGBA4444Textures) &&
2724 base::SysInfo::AmountOfPhysicalMemoryMB() <= 512 &&
2725 !using_synchronous_compositor) {
2726 settings.use_rgba_4444 = viz::RGBA_4444;
2727
2728 // If we are going to unpremultiply and dither these tiles, we need to
2729 // allocate an additional RGBA_8888 intermediate for each tile
2730 // rasterization when rastering to RGBA_4444 to allow for dithering.
2731 // Setting a reasonable sized max tile size allows this intermediate to
2732 // be consistently reused.
2733 if (base::FeatureList::IsEnabled(
2734 kUnpremultiplyAndDitherLowBitDepthTiles)) {
2735 settings.max_gpu_raster_tile_size = gfx::Size(512, 256);
2736 settings.unpremultiply_and_dither_low_bit_depth_tiles = true;
2737 }
2738 }
2739 }
2740
2741 if (cmd.HasSwitch(switches::kEnableLowResTiling))
2742 settings.create_low_res_tiling = true;
2743 if (cmd.HasSwitch(switches::kDisableLowResTiling))
2744 settings.create_low_res_tiling = false;
2745
2746 if (cmd.HasSwitch(switches::kEnableRGBA4444Textures) &&
2747 !cmd.HasSwitch(switches::kDisableRGBA4444Textures)) {
2748 settings.use_rgba_4444 = true;
2749 }
2750
2751 settings.max_staging_buffer_usage_in_bytes = 32 * 1024 * 1024; // 32MB
2752 // Use 1/4th of staging buffers on low-end devices.
2753 if (base::SysInfo::IsLowEndDevice())
2754 settings.max_staging_buffer_usage_in_bytes /= 4;
2755
2756 cc::ManagedMemoryPolicy defaults = settings.memory_policy;
2757 settings.memory_policy = GetGpuMemoryPolicy(defaults, initial_screen_size,
2758 initial_device_scale_factor);
2759
2760 settings.disallow_non_exact_resource_reuse =
2761 cmd.HasSwitch(switches::kDisallowNonExactResourceReuse);
2762#if defined(OS_ANDROID)
2763 // TODO(crbug.com/746931): This feature appears to be causing visual
2764 // corruption on certain android devices. Will investigate and re-enable.
2765 settings.disallow_non_exact_resource_reuse = true;
2766#endif
2767
2768 if (cmd.HasSwitch(switches::kRunAllCompositorStagesBeforeDraw)) {
2769 settings.wait_for_all_pipeline_stages_before_draw = true;
2770 settings.enable_latency_recovery = false;
2771 }
2772
2773 settings.enable_image_animation_resync =
2774 !cmd.HasSwitch(switches::kDisableImageAnimationResync);
2775
2776 settings.always_request_presentation_time =
2777 cmd.HasSwitch(cc::switches::kAlwaysRequestPresentationTime);
Karolina Soltys4d60b402018-10-01 19:28:202778
2779 settings.send_compositor_frame_ack = false;
2780
danakj4b347212018-07-04 17:55:172781 return settings;
2782}
2783
2784// static
2785cc::ManagedMemoryPolicy RenderWidget::GetGpuMemoryPolicy(
2786 const cc::ManagedMemoryPolicy& default_policy,
2787 const gfx::Size& initial_screen_size,
2788 float initial_device_scale_factor) {
2789 cc::ManagedMemoryPolicy actual = default_policy;
2790 actual.bytes_limit_when_visible = 0;
2791
2792 // If the value was overridden on the command line, use the specified value.
2793 static bool client_hard_limit_bytes_overridden =
2794 base::CommandLine::ForCurrentProcess()->HasSwitch(
2795 switches::kForceGpuMemAvailableMb);
2796 if (client_hard_limit_bytes_overridden) {
2797 if (base::StringToSizeT(
2798 base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
2799 switches::kForceGpuMemAvailableMb),
2800 &actual.bytes_limit_when_visible))
2801 actual.bytes_limit_when_visible *= 1024 * 1024;
2802 return actual;
2803 }
2804
2805#if defined(OS_ANDROID)
2806 // We can't query available GPU memory from the system on Android.
2807 // Physical memory is also mis-reported sometimes (eg. Nexus 10 reports
2808 // 1262MB when it actually has 2GB, while Razr M has 1GB but only reports
2809 // 128MB java heap size). First we estimate physical memory using both.
2810 size_t dalvik_mb = base::SysInfo::DalvikHeapSizeMB();
2811 size_t physical_mb = base::SysInfo::AmountOfPhysicalMemoryMB();
2812 size_t physical_memory_mb = 0;
2813 if (base::SysInfo::IsLowEndDevice()) {
2814 // TODO(crbug.com/742534): The code below appears to no longer work.
2815 // |dalvik_mb| no longer follows the expected heuristic pattern, causing us
2816 // to over-estimate memory on low-end devices. This entire section probably
2817 // needs to be re-written, but for now we can address the low-end Android
2818 // issues by ignoring |dalvik_mb|.
2819 physical_memory_mb = physical_mb;
2820 } else if (dalvik_mb >= 256) {
2821 physical_memory_mb = dalvik_mb * 4;
2822 } else {
2823 physical_memory_mb = std::max(dalvik_mb * 4, (physical_mb * 4) / 3);
2824 }
2825
2826 // Now we take a default of 1/8th of memory on high-memory devices,
2827 // and gradually scale that back for low-memory devices (to be nicer
2828 // to other apps so they don't get killed). Examples:
2829 // Nexus 4/10(2GB) 256MB (normally 128MB)
2830 // Droid Razr M(1GB) 114MB (normally 57MB)
2831 // Galaxy Nexus(1GB) 100MB (normally 50MB)
2832 // Xoom(1GB) 100MB (normally 50MB)
2833 // Nexus S(low-end) 8MB (normally 8MB)
2834 // Note that the compositor now uses only some of this memory for
2835 // pre-painting and uses the rest only for 'emergencies'.
2836 if (actual.bytes_limit_when_visible == 0) {
2837 // NOTE: Non-low-end devices use only 50% of these limits,
2838 // except during 'emergencies' where 100% can be used.
2839 if (physical_memory_mb >= 1536)
2840 actual.bytes_limit_when_visible = physical_memory_mb / 8; // >192MB
2841 else if (physical_memory_mb >= 1152)
2842 actual.bytes_limit_when_visible = physical_memory_mb / 8; // >144MB
2843 else if (physical_memory_mb >= 768)
2844 actual.bytes_limit_when_visible = physical_memory_mb / 10; // >76MB
2845 else if (physical_memory_mb >= 513)
2846 actual.bytes_limit_when_visible = physical_memory_mb / 12; // <64MB
2847 else
2848 // Devices with this little RAM have very little headroom so we hardcode
2849 // the limit rather than relying on the heuristics above. (They also use
2850 // 4444 textures so we can use a lower limit.)
2851 actual.bytes_limit_when_visible = 8;
2852
2853 actual.bytes_limit_when_visible =
2854 actual.bytes_limit_when_visible * 1024 * 1024;
2855 // Clamp the observed value to a specific range on Android.
2856 actual.bytes_limit_when_visible = std::max(
2857 actual.bytes_limit_when_visible, static_cast<size_t>(8 * 1024 * 1024));
2858 actual.bytes_limit_when_visible =
2859 std::min(actual.bytes_limit_when_visible,
2860 static_cast<size_t>(256 * 1024 * 1024));
2861 }
2862 actual.priority_cutoff_when_visible =
2863 gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING;
2864#else
2865 // Ignore what the system said and give all clients the same maximum
2866 // allocation on desktop platforms.
2867 actual.bytes_limit_when_visible = 512 * 1024 * 1024;
2868 actual.priority_cutoff_when_visible =
2869 gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
2870
2871 // For large monitors (4k), double the tile memory to avoid frequent out of
2872 // memory problems. 4k could mean a screen width of anywhere from 3840 to 4096
2873 // (see https://en.wikipedia.org/wiki/4K_resolution). We use 3500 as a proxy
2874 // for "large enough".
2875 static const int kLargeDisplayThreshold = 3500;
2876 int display_width =
2877 std::round(initial_screen_size.width() * initial_device_scale_factor);
2878 if (display_width >= kLargeDisplayThreshold)
2879 actual.bytes_limit_when_visible *= 2;
2880#endif
2881 return actual;
2882}
2883
[email protected]7912e822014-04-16 02:37:032884void RenderWidget::StartCompositor() {
sievers71c62dd52015-10-07 01:44:392885 if (!is_hidden())
danakja6c10012018-07-06 14:25:362886 layer_tree_view_->SetVisible(true);
[email protected]24ed0432013-04-24 07:50:312887}
2888
Navid Zolghadr8fdb6114e2018-08-29 19:00:542889void RenderWidget::HasPointerRawMoveEventHandlers(bool has_handlers) {
2890 if (input_event_queue_)
2891 input_event_queue_->HasPointerRawMoveEventHandlers(has_handlers);
2892}
2893
Blink Reformat1c4d759e2017-04-09 16:34:542894void RenderWidget::HasTouchEventHandlers(bool has_handlers) {
W. James MacLean662d5382018-03-29 18:33:082895 if (has_touch_handlers_ && *has_touch_handlers_ == has_handlers)
2896 return;
2897
2898 has_touch_handlers_ = has_handlers;
alexclarke7fa93942015-10-21 15:37:112899 if (render_widget_scheduling_state_)
2900 render_widget_scheduling_state_->SetHasTouchHandler(has_handlers);
[email protected]ce6689f2013-03-29 12:52:552901 Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
2902}
2903
Dave Tapuskadfe486c12017-06-09 16:53:132904void RenderWidget::SetNeedsLowLatencyInput(bool needs_low_latency) {
2905 if (input_event_queue_)
2906 input_event_queue_->SetNeedsLowLatency(needs_low_latency);
2907}
2908
Dave Tapuskabafc2ba32017-11-28 01:54:372909void RenderWidget::RequestUnbufferedInputEvents() {
2910 if (input_event_queue_)
2911 input_event_queue_->RequestUnbufferedInputEvents();
2912}
2913
xidachenfa0199e72017-05-11 11:34:262914void RenderWidget::SetTouchAction(cc::TouchAction touch_action) {
Dave Tapuskab28a1082017-08-30 15:37:262915 if (!input_handler_->ProcessTouchAction(touch_action))
[email protected]5d0bbdfa92013-12-10 00:35:512916 return;
2917
Dave Tapuska04bc5ee92018-04-17 19:03:312918 widget_input_handler_manager_->ProcessTouchAction(touch_action);
[email protected]5d0bbdfa92013-12-10 00:35:512919}
2920
[email protected]e3244ed2014-06-20 20:04:272921void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
2922 render_frame_proxies_.AddObserver(proxy);
[email protected]bffc8302014-01-23 20:52:162923}
2924
[email protected]e3244ed2014-06-20 20:04:272925void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
2926 render_frame_proxies_.RemoveObserver(proxy);
[email protected]bffc8302014-01-23 20:52:162927}
2928
[email protected]de3c5d82014-05-28 22:12:592929void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
2930 render_frames_.AddObserver(frame);
2931}
2932
2933void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) {
2934 render_frames_.RemoveObserver(frame);
2935}
2936
Saman Samid189e5dfd2017-12-20 22:55:312937void RenderWidget::RegisterBrowserPlugin(BrowserPlugin* browser_plugin) {
2938 browser_plugins_.AddObserver(browser_plugin);
Saman Sami50d1e0c2018-03-13 20:03:492939 browser_plugin->ScreenInfoChanged(GetOriginalScreenInfo());
Saman Samid189e5dfd2017-12-20 22:55:312940}
2941
2942void RenderWidget::UnregisterBrowserPlugin(BrowserPlugin* browser_plugin) {
2943 browser_plugins_.RemoveObserver(browser_plugin);
2944}
2945
Albert J. Wong3c93c182018-09-27 17:29:432946void RenderWidget::OnWaitNextFrameForTests(
2947 int main_frame_thread_observer_routing_id) {
danakj53802692018-07-25 21:46:442948 // Sends an ACK to the browser process during the next compositor frame.
Albert J. Wong3c93c182018-09-27 17:29:432949 QueueMessage(new WidgetHostMsg_WaitForNextFrameForTests_ACK(
2950 main_frame_thread_observer_routing_id));
lfg43e08e62016-02-03 18:51:372951}
2952
Fady Samuela863f152018-03-09 16:10:032953const ScreenInfo& RenderWidget::GetWebScreenInfo() const {
2954 return screen_info_;
Christopher Camerone9a30c12018-03-07 08:23:382955}
2956
Fady Samuela863f152018-03-09 16:10:032957const ScreenInfo& RenderWidget::GetOriginalScreenInfo() const {
Christopher Camerone9a30c12018-03-07 08:23:382958 return screen_metrics_emulator_
2959 ? screen_metrics_emulator_->original_screen_info()
Fady Samuela863f152018-03-09 16:10:032960 : screen_info_;
oshima50872a72016-03-04 13:26:182961}
2962
Ella Ge80a52dce2017-11-15 18:01:522963gfx::PointF RenderWidget::ConvertWindowPointToViewport(
2964 const gfx::PointF& point) {
paulmeyer90f6c31d2016-11-12 00:17:592965 blink::WebFloatRect point_in_viewport(point.x(), point.y(), 0, 0);
Blink Reformat1c4d759e2017-04-09 16:34:542966 ConvertWindowToViewport(&point_in_viewport);
Ella Ge80a52dce2017-11-15 18:01:522967 return gfx::PointF(point_in_viewport.x, point_in_viewport.y);
2968}
2969
2970gfx::Point RenderWidget::ConvertWindowPointToViewport(const gfx::Point& point) {
2971 return gfx::ToRoundedPoint(ConvertWindowPointToViewport(gfx::PointF(point)));
paulmeyer90f6c31d2016-11-12 00:17:592972}
2973
Blink Reformat1c4d759e2017-04-09 16:34:542974bool RenderWidget::RequestPointerLock() {
lfgbee1e0a2016-06-08 21:24:212975 return mouse_lock_dispatcher_->LockMouse(webwidget_mouse_lock_target_.get());
2976}
2977
Blink Reformat1c4d759e2017-04-09 16:34:542978void RenderWidget::RequestPointerUnlock() {
lfgbee1e0a2016-06-08 21:24:212979 mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
2980}
2981
Blink Reformat1c4d759e2017-04-09 16:34:542982bool RenderWidget::IsPointerLocked() {
lfgbee1e0a2016-06-08 21:24:212983 return mouse_lock_dispatcher_->IsMouseLockedTo(
2984 webwidget_mouse_lock_target_.get());
2985}
2986
Blink Reformat1c4d759e2017-04-09 16:34:542987void RenderWidget::StartDragging(blink::WebReferrerPolicy policy,
paulmeyer6ef5a792016-11-08 20:33:582988 const WebDragData& data,
2989 WebDragOperationsMask mask,
danakj0c75ad82018-07-10 19:50:122990 const SkBitmap& drag_image,
2991 const WebPoint& web_image_offset) {
2992 blink::WebRect offset_in_window(web_image_offset.x, web_image_offset.y, 0, 0);
Blink Reformat1c4d759e2017-04-09 16:34:542993 ConvertViewportToWindow(&offset_in_window);
paulmeyer6ef5a792016-11-08 20:33:582994 DropData drop_data(DropDataBuilder::Build(data));
2995 drop_data.referrer_policy = policy;
danakj0c75ad82018-07-10 19:50:122996 gfx::Vector2d image_offset(offset_in_window.x, offset_in_window.y);
2997 Send(new DragHostMsg_StartDragging(routing_id(), drop_data, mask, drag_image,
2998 image_offset, possible_drag_event_info_));
paulmeyer6ef5a792016-11-08 20:33:582999}
3000
kenrb5d78b842017-03-06 21:06:013001uint32_t RenderWidget::GetContentSourceId() {
3002 return current_content_source_id_;
3003}
3004
Saman Samif7731342018-01-24 22:18:443005void RenderWidget::DidNavigate() {
Saman Sami26a1fcd2018-04-10 17:12:213006 ++current_content_source_id_;
danakja6c10012018-07-06 14:25:363007 if (!layer_tree_view_)
Saman Samif7731342018-01-24 22:18:443008 return;
danakja6c10012018-07-06 14:25:363009 layer_tree_view_->SetContentSourceId(current_content_source_id_);
3010 layer_tree_view_->ClearCachesOnNextCommit();
kenrb5d78b842017-03-06 21:06:013011}
3012
lfg8ff33912016-09-13 20:59:213013blink::WebWidget* RenderWidget::GetWebWidget() const {
danakja2c9d0a92018-07-25 20:01:183014 if (owner_delegate_) {
3015 blink::WebWidget* delegate_widget =
3016 owner_delegate_->GetWebWidgetForWidget();
3017 if (delegate_widget)
3018 return delegate_widget;
3019 }
lfg8ff33912016-09-13 20:59:213020 return webwidget_internal_;
3021}
3022
ekaramad2daaf672016-11-10 20:29:013023blink::WebInputMethodController* RenderWidget::GetInputMethodController()
3024 const {
Ehsan Karamad655d7b8a2018-01-12 18:38:383025 if (auto* frame_widget = GetFrameWidget())
3026 return frame_widget->GetActiveWebInputMethodController();
3027
3028 return nullptr;
ekaramad2daaf672016-11-10 20:29:013029}
3030
Dave Tapuska139a72f2017-09-06 21:57:033031void RenderWidget::SetupWidgetInputHandler(
3032 mojom::WidgetInputHandlerRequest request,
3033 mojom::WidgetInputHandlerHostPtr host) {
Dave Tapuskab66c28f2017-11-15 17:18:473034 widget_input_handler_manager_->AddInterface(std::move(request),
3035 std::move(host));
Dave Tapuska525eb15e2017-08-17 21:05:503036}
3037
Dave Tapuska485aca92017-08-08 00:47:583038void RenderWidget::SetWidgetBinding(mojom::WidgetRequest request) {
3039 // Close the old binding if there was one.
3040 // A RenderWidgetHost should not need more than one channel.
3041 widget_binding_.Close();
3042 widget_binding_.Bind(std::move(request));
3043}
3044
Ken Buchanan94c0beb62018-06-22 19:56:243045void RenderWidget::SetMouseCapture(bool capture) {
3046 if (mojom::WidgetInputHandlerHost* host =
3047 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
3048 host->SetMouseCapture(capture);
3049 }
3050}
3051
danakj53802692018-07-25 21:46:443052void RenderWidget::SetWindowScreenRect(const gfx::Rect& window_screen_rect) {
3053 if (screen_metrics_emulator_)
3054 screen_metrics_emulator_->OnUpdateWindowScreenRect(window_screen_rect);
3055 else
3056 window_screen_rect_ = window_screen_rect;
3057}
3058
Fady Samuelca9ecb72018-05-05 05:59:273059bool RenderWidget::IsSurfaceSynchronizationEnabled() const {
danakja6c10012018-07-06 14:25:363060 return layer_tree_view_ &&
3061 layer_tree_view_->IsSurfaceSynchronizationEnabled();
Fady Samuelca9ecb72018-05-05 05:59:273062}
3063
danakj53802692018-07-25 21:46:443064void RenderWidget::UseSynchronousResizeModeForTesting(bool enable) {
3065 resizing_mode_selector_->set_is_synchronous_mode(enable);
danakja2c9d0a92018-07-25 20:01:183066}
3067
3068void RenderWidget::SetDeviceScaleFactorForTesting(float factor) {
3069 device_scale_factor_for_testing_ = factor;
3070
3071 VisualProperties visual_properties;
3072 visual_properties.screen_info = screen_info_;
3073 visual_properties.screen_info.device_scale_factor = factor;
3074 visual_properties.new_size = size();
3075 visual_properties.visible_viewport_size = visible_viewport_size_;
3076 visual_properties.compositor_viewport_pixel_size =
3077 gfx::ScaleToCeiledSize(size(), factor);
3078 visual_properties.browser_controls_shrink_blink_size = false;
3079 visual_properties.top_controls_height = 0.f;
3080 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
3081 visual_properties.display_mode = display_mode_;
3082 visual_properties.local_surface_id = local_surface_id_from_parent_;
3083 // We are changing the device scale factor from the renderer, so allocate a
3084 // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
3085 if (layer_tree_view_)
3086 layer_tree_view_->RequestNewLocalSurfaceId();
3087
3088 OnSynchronizeVisualProperties(visual_properties);
3089}
3090
3091void RenderWidget::SetDeviceColorSpaceForTesting(
3092 const gfx::ColorSpace& color_space) {
3093 VisualProperties visual_properties;
3094 visual_properties.screen_info = screen_info_;
3095 visual_properties.screen_info.color_space = color_space;
3096 visual_properties.new_size = size();
3097 visual_properties.visible_viewport_size = visible_viewport_size_;
3098 visual_properties.compositor_viewport_pixel_size =
3099 compositor_viewport_pixel_size_;
3100 visual_properties.browser_controls_shrink_blink_size = false;
3101 visual_properties.top_controls_height = 0.f;
3102 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
3103 visual_properties.display_mode = display_mode_;
3104 visual_properties.local_surface_id = local_surface_id_from_parent_;
3105 // We are changing the device color space from the renderer, so allocate a
3106 // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
3107 if (layer_tree_view_)
3108 layer_tree_view_->RequestNewLocalSurfaceId();
3109 OnSynchronizeVisualProperties(visual_properties);
3110}
3111
3112void RenderWidget::SetWindowRectSynchronouslyForTesting(
3113 const gfx::Rect& new_window_rect) {
3114 SetWindowRectSynchronously(new_window_rect);
3115}
3116
3117void RenderWidget::EnableAutoResizeForTesting(const gfx::Size& min_size,
3118 const gfx::Size& max_size) {
3119 VisualProperties visual_properties;
3120 visual_properties.auto_resize_enabled = true;
3121 visual_properties.min_size_for_auto_resize = min_size;
3122 visual_properties.max_size_for_auto_resize = max_size;
3123 visual_properties.local_surface_id = base::Optional<viz::LocalSurfaceId>(
3124 viz::LocalSurfaceId(1, 1, base::UnguessableToken::Create()));
3125 OnSynchronizeVisualProperties(visual_properties);
3126}
3127
3128void RenderWidget::DisableAutoResizeForTesting(const gfx::Size& new_size) {
3129 if (!auto_resize_mode_)
3130 return;
3131
3132 VisualProperties visual_properties;
3133 visual_properties.auto_resize_enabled = false;
3134 visual_properties.screen_info = screen_info_;
3135 visual_properties.new_size = new_size;
3136 visual_properties.compositor_viewport_pixel_size =
3137 compositor_viewport_pixel_size_;
3138 visual_properties.browser_controls_shrink_blink_size =
3139 browser_controls_shrink_blink_size_;
3140 visual_properties.top_controls_height = top_controls_height_;
3141 visual_properties.visible_viewport_size = visible_viewport_size_;
3142 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
3143 visual_properties.display_mode = display_mode_;
3144 OnSynchronizeVisualProperties(visual_properties);
3145}
3146
Khushal3e96e662017-10-30 23:16:503147void RenderWidget::UpdateURLForCompositorUkm() {
danakja6c10012018-07-06 14:25:363148 DCHECK(layer_tree_view_);
Ehsan Karamad655d7b8a2018-01-12 18:38:383149 blink::WebFrameWidget* frame_widget = GetFrameWidget();
3150 if (!frame_widget)
Khushal3e96e662017-10-30 23:16:503151 return;
3152
Ehsan Karamad655d7b8a2018-01-12 18:38:383153 auto* render_frame = RenderFrameImpl::FromWebFrame(frame_widget->LocalRoot());
Khushal3e96e662017-10-30 23:16:503154 if (!render_frame->IsMainFrame())
3155 return;
3156
danakja6c10012018-07-06 14:25:363157 layer_tree_view_->SetURLForUkm(
3158 render_frame->GetWebFrame()->GetDocument().Url());
Khushal3e96e662017-10-30 23:16:503159}
3160
EhsanK955ba582017-11-30 21:14:403161blink::WebLocalFrame* RenderWidget::GetFocusedWebLocalFrameInWidget() const {
Ehsan Karamad655d7b8a2018-01-12 18:38:383162 if (auto* frame_widget = GetFrameWidget())
3163 return frame_widget->FocusedWebLocalFrameInWidget();
3164 return nullptr;
EhsanK955ba582017-11-30 21:14:403165}
3166
EhsanK22d482e2017-08-10 17:29:493167#if BUILDFLAG(ENABLE_PLUGINS)
3168PepperPluginInstanceImpl* RenderWidget::GetFocusedPepperPluginInsideWidget() {
Ehsan Karamad655d7b8a2018-01-12 18:38:383169 blink::WebFrameWidget* frame_widget = GetFrameWidget();
3170 if (!frame_widget)
EhsanK22d482e2017-08-10 17:29:493171 return nullptr;
3172
3173 // Focused pepper instance might not always be in the focused frame. For
3174 // instance if a pepper instance and its embedder frame are focused an then
3175 // another frame takes focus using javascript, the embedder frame will no
3176 // longer be focused while the pepper instance is (the embedder frame's
3177 // |focused_pepper_plugin_| is not nullptr). Especially, if the pepper plugin
3178 // is fullscreen, clicking into the pepper will not refocus the embedder
3179 // frame. This is why we have to traverse the whole frame tree to find the
3180 // focused plugin.
Ehsan Karamad655d7b8a2018-01-12 18:38:383181 blink::WebFrame* current_frame = frame_widget->LocalRoot();
EhsanK22d482e2017-08-10 17:29:493182 while (current_frame) {
3183 RenderFrameImpl* render_frame =
3184 current_frame->IsWebLocalFrame()
3185 ? RenderFrameImpl::FromWebFrame(current_frame)
3186 : nullptr;
3187 if (render_frame && render_frame->focused_pepper_plugin())
3188 return render_frame->focused_pepper_plugin();
3189 current_frame = current_frame->TraverseNext();
3190 }
3191 return nullptr;
3192}
3193#endif
3194
Ken Buchananb2c9e262018-03-10 16:53:313195gfx::Rect RenderWidget::ViewportVisibleRect() {
3196 return for_oopif_ ? compositor_visible_rect_
3197 : gfx::Rect(compositor_viewport_pixel_size_);
3198}
3199
Hajime Hoshi315a61f2018-08-14 17:27:283200// static
3201scoped_refptr<base::SingleThreadTaskRunner>
3202RenderWidget::GetCleanupTaskRunner() {
3203 return RenderThreadImpl::current_blink_platform_impl()
3204 ->main_thread_scheduler()
3205 ->CleanupTaskRunner();
3206}
3207
Saman Sami50d1e0c2018-03-13 20:03:493208base::WeakPtr<RenderWidget> RenderWidget::AsWeakPtr() {
3209 return weak_ptr_factory_.GetWeakPtr();
3210}
3211
[email protected]e9ff79c2012-10-19 21:31:263212} // namespace content