blob: bb618b150d405cd05e5d067ad717293338d96ac3 [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"
mlamouriafca06dd2017-01-27 23:35:1848#include "content/public/common/content_client.h"
changwan7ded3752016-03-09 23:25:1249#include "content/public/common/content_features.h"
[email protected]c08950d22011-10-13 22:20:2950#include "content/public/common/content_switches.h"
[email protected]a09d53ce2014-01-31 00:46:4251#include "content/public/common/context_menu_params.h"
paulmeyer90f6c31d2016-11-12 00:17:5952#include "content/public/common/drop_data.h"
Khushal3e96e662017-10-30 23:16:5053#include "content/public/common/service_names.mojom.h"
Jaebaek Seo655110e2017-12-19 23:27:3954#include "content/public/common/use_zoom_for_dsf_policy.h"
mlamouriafca06dd2017-01-27 23:35:1855#include "content/public/renderer/content_renderer_client.h"
Saman Samid189e5dfd2017-12-20 22:55:3156#include "content/renderer/browser_plugin/browser_plugin.h"
[email protected]953bd0062013-08-01 00:58:4057#include "content/renderer/cursor_utils.h"
mfomitchev2600fd7c2016-02-17 20:53:3958#include "content/renderer/devtools/render_widget_screen_metrics_emulator.h"
paulmeyer6ef5a792016-11-08 20:33:5859#include "content/renderer/drop_data_builder.h"
[email protected]b2e4c70132013-10-03 02:07:5160#include "content/renderer/external_popup_menu.h"
[email protected]586871b2014-07-22 17:05:1161#include "content/renderer/gpu/frame_swap_message_queue.h"
danakja6c10012018-07-06 14:25:3662#include "content/renderer/gpu/layer_tree_view.h"
[email protected]586871b2014-07-22 17:05:1163#include "content/renderer/gpu/queue_message_swap_promise.h"
danakja2c9d0a92018-07-25 20:01:1864#include "content/renderer/idle_user_detector.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"
Blink Reformata30d4232018-04-07 15:31:0686#include "third_party/blink/public/platform/scheduler/web_render_widget_scheduling_state.h"
Yuta Kitamuradeb91bb2018-05-29 05:53:2087#include "third_party/blink/public/platform/scheduler/web_thread_scheduler.h"
Blink Reformata30d4232018-04-07 15:31:0688#include "third_party/blink/public/platform/web_cursor_info.h"
89#include "third_party/blink/public/platform/web_drag_data.h"
90#include "third_party/blink/public/platform/web_drag_operation.h"
91#include "third_party/blink/public/platform/web_mouse_event.h"
92#include "third_party/blink/public/platform/web_point.h"
93#include "third_party/blink/public/platform/web_rect.h"
94#include "third_party/blink/public/platform/web_runtime_features.h"
95#include "third_party/blink/public/platform/web_size.h"
96#include "third_party/blink/public/platform/web_string.h"
97#include "third_party/blink/public/web/web_autofill_client.h"
98#include "third_party/blink/public/web/web_device_emulation_params.h"
99#include "third_party/blink/public/web/web_frame_widget.h"
100#include "third_party/blink/public/web/web_input_method_controller.h"
101#include "third_party/blink/public/web/web_local_frame.h"
102#include "third_party/blink/public/web/web_node.h"
103#include "third_party/blink/public/web/web_page_popup.h"
104#include "third_party/blink/public/web/web_popup_menu_info.h"
105#include "third_party/blink/public/web/web_range.h"
106#include "third_party/blink/public/web/web_settings.h"
107#include "third_party/blink/public/web/web_view.h"
108#include "third_party/blink/public/web/web_widget.h"
[email protected]d353541f2012-05-03 22:45:41109#include "third_party/skia/include/core/SkShader.h"
paulmeyer90f6c31d2016-11-12 00:17:59110#include "ui/base/clipboard/clipboard.h"
Scott Violet8ff9c302018-02-22 22:28:35111#include "ui/base/ui_base_features.h"
danakj4b347212018-07-04 17:55:17112#include "ui/base/ui_base_switches.h"
dtapuska97286c882017-02-24 23:14:43113#include "ui/events/base_event_utils.h"
tfarina655f81d2014-12-23 02:38:50114#include "ui/gfx/geometry/point_conversions.h"
tfarina3b0452d2014-12-31 15:20:09115#include "ui/gfx/geometry/rect_conversions.h"
tfarinaebe974f02015-01-03 04:25:32116#include "ui/gfx/geometry/size_conversions.h"
[email protected]1835b9e2012-02-28 13:12:48117#include "ui/gfx/skia_util.h"
danakj4b347212018-07-04 17:55:17118#include "ui/gfx/switches.h"
[email protected]c9e2cbbb2012-05-12 21:17:27119#include "ui/gl/gl_switches.h"
danakj4b347212018-07-04 17:55:17120#include "ui/native_theme/native_theme_features.h"
121#include "ui/native_theme/overlay_scrollbar_constants_aura.h"
[email protected]d353541f2012-05-03 22:45:41122#include "ui/surface/transport_dib.h"
[email protected]661eb9d2009-02-03 02:11:48123
[email protected]eeb93112013-05-01 19:41:10124#if defined(OS_ANDROID)
[email protected]cefe9b152014-03-27 18:16:15125#include <android/keycodes.h>
wjmaclean1d970622017-01-21 22:28:24126#include "base/time/time.h"
[email protected]eeb93112013-05-01 19:41:10127#endif
128
[email protected]661eb9d2009-02-03 02:11:48129#if defined(OS_POSIX)
[email protected]d5282e72009-05-13 13:16:52130#include "third_party/skia/include/core/SkMallocPixelRef.h"
[email protected]d353541f2012-05-03 22:45:41131#include "third_party/skia/include/core/SkPixelRef.h"
[email protected]661eb9d2009-02-03 02:11:48132#endif // defined(OS_POSIX)
[email protected]8085dbc82008-09-26 22:53:44133
sadrul943e3b32016-08-04 18:22:59134#if defined(USE_AURA)
sadrul602ce1362017-01-26 06:41:10135#include "content/renderer/mus/renderer_window_tree_client.h"
penghuang28a5fa22015-12-02 17:58:19136#endif
137
ekaramad330ba4232016-09-23 17:57:47138#if defined(OS_MACOSX)
139#include "content/renderer/text_input_client_observer.h"
140#endif
141
Ryan Landay9e42fd742017-08-12 01:59:11142using blink::WebImeTextSpan;
[email protected]180ef242013-11-07 06:50:46143using blink::WebCursorInfo;
[email protected]19193682014-04-03 15:01:43144using blink::WebDeviceEmulationParams;
paulmeyer90f6c31d2016-11-12 00:17:59145using blink::WebDragOperation;
paulmeyer6ef5a792016-11-08 20:33:58146using blink::WebDragOperationsMask;
147using blink::WebDragData;
paulmeyer90f6c31d2016-11-12 00:17:59148using blink::WebFrameWidget;
[email protected]180ef242013-11-07 06:50:46149using blink::WebGestureEvent;
150using blink::WebInputEvent;
dtapuska5d2e9c32015-12-03 16:39:49151using blink::WebInputEventResult;
ekaramad2daaf672016-11-10 20:29:01152using blink::WebInputMethodController;
paulmeyer6ef5a792016-11-08 20:33:58153using blink::WebLocalFrame;
[email protected]180ef242013-11-07 06:50:46154using blink::WebMouseEvent;
155using blink::WebMouseWheelEvent;
156using blink::WebNavigationPolicy;
donnda070f3c2015-01-16 19:54:11157using blink::WebNode;
[email protected]180ef242013-11-07 06:50:46158using blink::WebPagePopup;
donnda070f3c2015-01-16 19:54:11159using blink::WebPoint;
[email protected]180ef242013-11-07 06:50:46160using blink::WebPopupType;
dglazkove353a372016-09-01 01:33:48161using blink::WebRange;
[email protected]180ef242013-11-07 06:50:46162using blink::WebRect;
[email protected]180ef242013-11-07 06:50:46163using blink::WebSize;
paulmeyer90f6c31d2016-11-12 00:17:59164using blink::WebString;
[email protected]180ef242013-11-07 06:50:46165using blink::WebTextDirection;
166using blink::WebTouchEvent;
[email protected]f8ed4722013-12-03 03:27:25167using blink::WebTouchPoint;
[email protected]180ef242013-11-07 06:50:46168using blink::WebVector;
169using blink::WebWidget;
[email protected]e9ff79c2012-10-19 21:31:26170
paulmeyer90f6c31d2016-11-12 00:17:59171namespace content {
172
[email protected]6a4d7f62013-01-07 21:32:13173namespace {
[email protected]b256eca2013-07-11 10:57:40174
Albert J. Wongcb004632018-07-10 22:58:25175using RoutingIDWidgetMap = std::map<int32_t, RenderWidget*>;
176base::LazyInstance<RoutingIDWidgetMap>::Leaky g_routing_id_widget_map =
177 LAZY_INSTANCE_INITIALIZER;
178
danakj4b347212018-07-04 17:55:17179const base::Feature kUnpremultiplyAndDitherLowBitDepthTiles = {
180 "UnpremultiplyAndDitherLowBitDepthTiles", base::FEATURE_ENABLED_BY_DEFAULT};
181
[email protected]b256eca2013-07-11 10:57:40182typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
183
AJITH KUMAR V041c0b02017-08-08 10:39:20184static const int kInvalidNextPreviousFlagsValue = -1;
185
lfgbee1e0a2016-06-08 21:24:21186class WebWidgetLockTarget : public content::MouseLockDispatcher::LockTarget {
187 public:
188 explicit WebWidgetLockTarget(blink::WebWidget* webwidget)
189 : webwidget_(webwidget) {}
190
191 void OnLockMouseACK(bool succeeded) override {
192 if (succeeded)
Blink Reformat1c4d759e2017-04-09 16:34:54193 webwidget_->DidAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21194 else
Blink Reformat1c4d759e2017-04-09 16:34:54195 webwidget_->DidNotAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21196 }
197
Blink Reformat1c4d759e2017-04-09 16:34:54198 void OnMouseLockLost() override { webwidget_->DidLosePointerLock(); }
lfgbee1e0a2016-06-08 21:24:21199
200 bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event) override {
201 // The WebWidget handles mouse lock in Blink's handleInputEvent().
202 return false;
203 }
204
205 private:
206 blink::WebWidget* webwidget_;
207};
208
dglazkov97b6c2b2016-10-25 17:35:55209bool IsDateTimeInput(ui::TextInputType type) {
210 return type == ui::TEXT_INPUT_TYPE_DATE ||
211 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
212 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
213 type == ui::TEXT_INPUT_TYPE_MONTH ||
214 type == ui::TEXT_INPUT_TYPE_TIME || type == ui::TEXT_INPUT_TYPE_WEEK;
215}
216
paulmeyer90f6c31d2016-11-12 00:17:59217WebDragData DropMetaDataToWebDragData(
218 const std::vector<DropData::Metadata>& drop_meta_data) {
219 std::vector<WebDragData::Item> item_list;
220 for (const auto& meta_data_item : drop_meta_data) {
221 if (meta_data_item.kind == DropData::Kind::STRING) {
222 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54223 item.storage_type = WebDragData::Item::kStorageTypeString;
224 item.string_type = WebString::FromUTF16(meta_data_item.mime_type);
paulmeyer90f6c31d2016-11-12 00:17:59225 // Have to pass a dummy URL here instead of an empty URL because the
226 // DropData received by browser_plugins goes through a round trip:
227 // DropData::MetaData --> WebDragData-->DropData. In the end, DropData
228 // will contain an empty URL (which means no URL is dragged) if the URL in
229 // WebDragData is empty.
230 if (base::EqualsASCII(meta_data_item.mime_type,
231 ui::Clipboard::kMimeTypeURIList)) {
Blink Reformat1c4d759e2017-04-09 16:34:54232 item.string_data = WebString::FromUTF8("about:dragdrop-placeholder");
paulmeyer90f6c31d2016-11-12 00:17:59233 }
234 item_list.push_back(item);
235 continue;
236 }
237
238 // TODO(hush): crbug.com/584789. Blink needs to support creating a file with
239 // just the mimetype. This is needed to drag files to WebView on Android
240 // platform.
241 if ((meta_data_item.kind == DropData::Kind::FILENAME) &&
242 !meta_data_item.filename.empty()) {
243 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54244 item.storage_type = WebDragData::Item::kStorageTypeFilename;
245 item.filename_data = blink::FilePathToWebString(meta_data_item.filename);
paulmeyer90f6c31d2016-11-12 00:17:59246 item_list.push_back(item);
247 continue;
248 }
249
250 if (meta_data_item.kind == DropData::Kind::FILESYSTEMFILE) {
251 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54252 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
253 item.file_system_url = meta_data_item.file_system_url;
paulmeyer90f6c31d2016-11-12 00:17:59254 item_list.push_back(item);
255 continue;
256 }
257 }
258
259 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54260 result.Initialize();
261 result.SetItems(item_list);
paulmeyer90f6c31d2016-11-12 00:17:59262 return result;
263}
264
265WebDragData DropDataToWebDragData(const DropData& drop_data) {
266 std::vector<WebDragData::Item> item_list;
267
268 // These fields are currently unused when dragging into WebKit.
269 DCHECK(drop_data.download_metadata.empty());
270 DCHECK(drop_data.file_contents.empty());
dcheng3dd85612017-02-08 10:46:23271 DCHECK(drop_data.file_contents_content_disposition.empty());
paulmeyer90f6c31d2016-11-12 00:17:59272
273 if (!drop_data.text.is_null()) {
274 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54275 item.storage_type = WebDragData::Item::kStorageTypeString;
276 item.string_type = WebString::FromUTF8(ui::Clipboard::kMimeTypeText);
277 item.string_data = WebString::FromUTF16(drop_data.text.string());
paulmeyer90f6c31d2016-11-12 00:17:59278 item_list.push_back(item);
279 }
280
281 if (!drop_data.url.is_empty()) {
282 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54283 item.storage_type = WebDragData::Item::kStorageTypeString;
284 item.string_type = WebString::FromUTF8(ui::Clipboard::kMimeTypeURIList);
285 item.string_data = WebString::FromUTF8(drop_data.url.spec());
286 item.title = WebString::FromUTF16(drop_data.url_title);
paulmeyer90f6c31d2016-11-12 00:17:59287 item_list.push_back(item);
288 }
289
290 if (!drop_data.html.is_null()) {
291 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54292 item.storage_type = WebDragData::Item::kStorageTypeString;
293 item.string_type = WebString::FromUTF8(ui::Clipboard::kMimeTypeHTML);
294 item.string_data = WebString::FromUTF16(drop_data.html.string());
295 item.base_url = drop_data.html_base_url;
paulmeyer90f6c31d2016-11-12 00:17:59296 item_list.push_back(item);
297 }
298
299 for (std::vector<ui::FileInfo>::const_iterator it =
300 drop_data.filenames.begin();
301 it != drop_data.filenames.end();
302 ++it) {
303 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54304 item.storage_type = WebDragData::Item::kStorageTypeFilename;
305 item.filename_data = blink::FilePathToWebString(it->path);
306 item.display_name_data =
kinukoa4293022017-01-27 06:43:25307 blink::FilePathToWebString(base::FilePath(it->display_name));
paulmeyer90f6c31d2016-11-12 00:17:59308 item_list.push_back(item);
309 }
310
311 for (std::vector<DropData::FileSystemFileInfo>::const_iterator it =
312 drop_data.file_system_files.begin();
313 it != drop_data.file_system_files.end();
314 ++it) {
315 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54316 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
317 item.file_system_url = it->url;
318 item.file_system_file_size = it->size;
319 item.file_system_id = blink::WebString::FromASCII(it->filesystem_id);
paulmeyer90f6c31d2016-11-12 00:17:59320 item_list.push_back(item);
321 }
322
Stuart Langley48300392017-11-02 03:54:44323 for (const auto& it : drop_data.custom_data) {
paulmeyer90f6c31d2016-11-12 00:17:59324 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54325 item.storage_type = WebDragData::Item::kStorageTypeString;
Stuart Langley48300392017-11-02 03:54:44326 item.string_type = WebString::FromUTF16(it.first);
327 item.string_data = WebString::FromUTF16(it.second);
paulmeyer90f6c31d2016-11-12 00:17:59328 item_list.push_back(item);
329 }
330
331 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54332 result.Initialize();
333 result.SetItems(item_list);
334 result.SetFilesystemId(WebString::FromUTF16(drop_data.filesystem_id));
paulmeyer90f6c31d2016-11-12 00:17:59335 return result;
336}
337
lfg1568d112016-08-30 16:06:29338content::RenderWidget::CreateRenderWidgetFunction g_create_render_widget =
339 nullptr;
340
341content::RenderWidget::RenderWidgetInitializedCallback
342 g_render_widget_initialized = nullptr;
343
dtapuskac4dd5be2016-10-25 15:11:10344ui::TextInputType ConvertWebTextInputType(blink::WebTextInputType type) {
345 // Check the type is in the range representable by ui::TextInputType.
346 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX))
347 << "blink::WebTextInputType and ui::TextInputType not synchronized";
348 return static_cast<ui::TextInputType>(type);
349}
350
351ui::TextInputMode ConvertWebTextInputMode(blink::WebTextInputMode mode) {
352 // Check the mode is in the range representable by ui::TextInputMode.
353 DCHECK_LE(mode, static_cast<int>(ui::TEXT_INPUT_MODE_MAX))
354 << "blink::WebTextInputMode and ui::TextInputMode not synchronized";
355 return static_cast<ui::TextInputMode>(mode);
356}
357
Mitsuru Oshima3c07b332018-02-06 04:56:50358// Returns true if the device scale is high enough that losing subpixel
359// antialiasing won't have a noticeable effect on text quality.
360static bool DeviceScaleEnsuresTextQuality(float device_scale_factor) {
361#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
362 // On Android, we never have subpixel antialiasing. On Chrome OS we prefer to
363 // composite all scrollers so that we get animated overlay scrollbars.
364 return true;
365#else
366 // 1.5 is a common touchscreen tablet device scale factor. For such
367 // devices main thread antialiasing is a heavy burden.
368 return device_scale_factor >= 1.5f;
369#endif
370}
371
372static bool PreferCompositingToLCDText(CompositorDependencies* compositor_deps,
373 float device_scale_factor) {
374 const base::CommandLine& command_line =
375 *base::CommandLine::ForCurrentProcess();
376 if (command_line.HasSwitch(switches::kDisablePreferCompositingToLCDText))
377 return false;
378 if (command_line.HasSwitch(switches::kEnablePreferCompositingToLCDText))
379 return true;
380 if (!compositor_deps->IsLcdTextEnabled())
381 return true;
382 return DeviceScaleEnsuresTextQuality(device_scale_factor);
383}
384
[email protected]b256eca2013-07-11 10:57:40385} // namespace
386
[email protected]b2e4c70132013-10-03 02:07:51387// RenderWidget ---------------------------------------------------------------
388
Hajime Hoshiabb3c8f2017-12-04 18:41:39389RenderWidget::RenderWidget(
390 int32_t widget_routing_id,
391 CompositorDependencies* compositor_deps,
392 blink::WebPopupType popup_type,
Scott Violetae08f332018-07-27 17:37:23393 const ScreenInfo& screen_info,
danakj73dd3032018-07-28 17:49:53394 blink::WebDisplayMode display_mode,
Hajime Hoshiabb3c8f2017-12-04 18:41:39395 bool swapped_out,
396 bool hidden,
397 bool never_visible,
398 scoped_refptr<base::SingleThreadTaskRunner> task_runner,
399 mojom::WidgetRequest widget_request)
nick8331f8ad2016-11-15 20:42:45400 : routing_id_(widget_routing_id),
dcheng35d31c112015-07-22 00:17:36401 compositor_deps_(compositor_deps),
lfg8ff33912016-09-13 20:59:21402 webwidget_internal_(nullptr),
avi40b5be7a2016-03-03 21:13:44403 owner_delegate_(nullptr),
[email protected]847a2582013-03-09 02:29:51404 auto_resize_mode_(false),
initial.commit09911bf2008-07-26 23:55:29405 did_show_(false),
[email protected]1ac10dca2013-08-20 20:47:04406 is_hidden_(hidden),
sievers71c62dd52015-10-07 01:44:39407 compositor_never_visible_(never_visible),
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12408 is_fullscreen_granted_(false),
danakj73dd3032018-07-28 17:49:53409 display_mode_(display_mode),
changwanf2a707b2015-10-30 08:22:16410 ime_event_guard_(nullptr),
[email protected]661eb9d2009-02-03 02:11:48411 closing_(false),
[email protected]aeeedad2014-08-22 18:16:22412 host_closing_(false),
[email protected]14392a52012-05-02 20:28:44413 is_swapped_out_(swapped_out),
dglazkov97b6c2b2016-10-25 17:35:55414 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
[email protected]b256eca2013-07-11 10:57:40415 text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
shuchen82ce8c52014-10-23 01:55:20416 text_input_flags_(0),
AJITH KUMAR V041c0b02017-08-08 10:39:20417 next_previous_flags_(kInvalidNextPreviousFlagsValue),
[email protected]86ba5fcb2013-09-04 00:36:53418 can_compose_inline_(true),
nonafa291792016-08-10 02:36:18419 composition_range_(gfx::Range::InvalidRange()),
[email protected]3e2b375b2010-04-07 17:03:12420 popup_type_(popup_type),
[email protected]867125a02009-12-10 06:01:48421 pending_window_rect_count_(0),
Scott Violetae08f332018-07-27 17:37:23422 screen_info_(screen_info),
nonafa291792016-08-10 02:36:18423 monitor_composition_info_(false),
[email protected]b2e4c70132013-10-03 02:07:51424 popup_origin_scale_for_emulation_(0.f),
samans26510e442017-06-01 22:29:12425 frame_swap_message_queue_(new FrameSwapMessageQueue(routing_id_)),
[email protected]a09d53ce2014-01-31 00:46:42426 resizing_mode_selector_(new ResizingModeSelector()),
lfge0c2792ec2016-05-11 18:52:08427 has_host_context_menu_location_(false),
ekaramad2a46d632016-07-19 13:33:09428 has_focus_(false),
Nicolas Pena75a35d662018-04-05 20:13:44429 for_oopif_(false),
ekaramad330ba4232016-09-23 17:57:47430#if defined(OS_MACOSX)
431 text_input_client_observer_(new TextInputClientObserver(this)),
432#endif
Takashi SAKAMOTO870f6262017-08-22 04:08:27433 first_update_visual_state_after_hidden_(false),
tasakb95dbb50c2017-02-08 18:07:50434 was_shown_time_(base::TimeTicks::Now()),
kenrb5d78b842017-03-06 21:06:01435 current_content_source_id_(0),
Dave Tapuska1bdf1832017-07-07 18:07:19436 widget_binding_(this, std::move(widget_request)),
Hajime Hoshiabb3c8f2017-12-04 18:41:39437 task_runner_(task_runner),
wjmaclean1d970622017-01-21 22:28:24438 weak_ptr_factory_(this) {
nick8331f8ad2016-11-15 20:42:45439 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
[email protected]8b3f0eb2012-05-03 19:15:05440 if (!swapped_out)
441 RenderProcess::current()->AddRefProcess();
[email protected]380244092011-10-07 17:26:27442 DCHECK(RenderThread::Get());
alexclarke7fa93942015-10-21 15:37:11443
444 // In tests there may not be a RenderThreadImpl.
445 if (RenderThreadImpl::current()) {
446 render_widget_scheduling_state_ = RenderThreadImpl::current()
Yuta Kitamura3331f5c2018-04-05 11:12:25447 ->GetWebMainThreadScheduler()
dcheng07945f632015-12-26 07:59:32448 ->NewRenderWidgetSchedulingState();
alexclarke7fa93942015-10-21 15:37:11449 render_widget_scheduling_state_->SetHidden(is_hidden_);
450 }
sadrul602ce1362017-01-26 06:41:10451#if defined(USE_AURA)
fsamuel098eade2017-03-21 18:06:14452 RendererWindowTreeClient::CreateIfNecessary(routing_id_);
Scott Violet6fca1312018-06-15 16:27:26453 if (!features::IsAshInBrowserProcess())
Scott Violet1098538e2017-10-05 19:23:33454 RendererWindowTreeClient::Get(routing_id_)->SetVisible(!is_hidden_);
sadrul602ce1362017-01-26 06:41:10455#endif
Albert J. Wongcb004632018-07-10 22:58:25456
457 if (routing_id_ != MSG_ROUTING_NONE)
458 g_routing_id_widget_map.Get().emplace(routing_id_, this);
initial.commit09911bf2008-07-26 23:55:29459}
460
461RenderWidget::~RenderWidget() {
lfg8ff33912016-09-13 20:59:21462 DCHECK(!webwidget_internal_) << "Leaking our WebWidget!";
Albert J. Wongcb004632018-07-10 22:58:25463 // TODO(ajwong): Add in check that routing_id_ has been removed from
464 // g_routing_id_widget_map once the shutdown semantics for RenderWidget
465 // and RenderViewImpl are rationalized. Currently, too many unit and
466 // browser tests delete a RenderWidget without correclty going through
467 // the shutdown. https://crbug.com/545684
[email protected]bffc8302014-01-23 20:52:16468
dtapuska9ec1a912017-04-21 15:18:31469 if (input_event_queue_)
470 input_event_queue_->ClearClient();
471
[email protected]992db4c2011-05-12 15:37:15472 // If we are swapped out, we have released already.
[email protected]d2e2f9ee2013-08-21 11:02:02473 if (!is_swapped_out_ && RenderProcess::current())
[email protected]992db4c2011-05-12 15:37:15474 RenderProcess::current()->ReleaseProcess();
sadrul8185d972017-01-31 18:30:11475#if defined(USE_AURA)
fsamuel098eade2017-03-21 18:06:14476 // It is possible for a RenderWidget to be destroyed before it was embedded
477 // in a mus window. The RendererWindowTreeClient will leak in such cases. So
478 // explicitly delete it here.
479 RendererWindowTreeClient::Destroy(routing_id_);
sadrul8185d972017-01-31 18:30:11480#endif
initial.commit09911bf2008-07-26 23:55:29481}
482
[email protected]484955942010-08-19 16:13:18483// static
lfg1568d112016-08-30 16:06:29484void RenderWidget::InstallCreateHook(
485 CreateRenderWidgetFunction create_render_widget,
486 RenderWidgetInitializedCallback render_widget_initialized) {
487 CHECK(!g_create_render_widget && !g_render_widget_initialized);
488 g_create_render_widget = create_render_widget;
489 g_render_widget_initialized = render_widget_initialized;
490}
491
492// static
Albert J. Wongcb004632018-07-10 22:58:25493RenderWidget* RenderWidget::FromRoutingID(int32_t routing_id) {
494 RoutingIDWidgetMap* widgets = g_routing_id_widget_map.Pointer();
495 RoutingIDWidgetMap::iterator it = widgets->find(routing_id);
496 return it == widgets->end() ? NULL : it->second;
497}
498
499// static
nickf7b38222016-11-22 21:59:35500RenderWidget* RenderWidget::CreateForPopup(
501 RenderViewImpl* opener,
502 CompositorDependencies* compositor_deps,
503 blink::WebPopupType popup_type,
Hajime Hoshiabb3c8f2017-12-04 18:41:39504 const ScreenInfo& screen_info,
505 scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
Dave Tapuska1bdf1832017-07-07 18:07:19506 mojom::WidgetPtr widget_channel;
507 mojom::WidgetRequest widget_channel_request =
508 mojo::MakeRequest(&widget_channel);
509
nick4df698d82016-11-11 20:39:23510 // Do a synchronous IPC to obtain a routing ID.
511 int32_t routing_id = MSG_ROUTING_NONE;
512 if (!RenderThreadImpl::current_render_message_filter()->CreateNewWidget(
Dave Tapuska1bdf1832017-07-07 18:07:19513 opener->GetRoutingID(), popup_type, std::move(widget_channel),
514 &routing_id)) {
nick4df698d82016-11-11 20:39:23515 return nullptr;
516 }
517
danakj73dd3032018-07-28 17:49:53518 scoped_refptr<RenderWidget> widget(
519 new RenderWidget(routing_id, compositor_deps, popup_type, screen_info,
520 blink::kWebDisplayModeUndefined, false, false, false,
521 task_runner, std::move(widget_channel_request)));
danakjdf1ceb72018-07-18 20:02:25522 ShowCallback opener_callback = base::BindOnce(
523 &RenderViewImpl::ShowCreatedPopupWidget, opener->GetWeakPtr());
Scott Violetae08f332018-07-27 17:37:23524 widget->Init(std::move(opener_callback),
525 RenderWidget::CreateWebWidget(widget.get()));
nick4df698d82016-11-11 20:39:23526 DCHECK(!widget->HasOneRef()); // RenderWidget::Init() adds a reference.
527 return widget.get();
initial.commit09911bf2008-07-26 23:55:29528}
529
[email protected]484955942010-08-19 16:13:18530// static
kenrba7199832015-01-22 23:44:59531RenderWidget* RenderWidget::CreateForFrame(
nick4df698d82016-11-11 20:39:23532 int widget_routing_id,
kenrba7199832015-01-22 23:44:59533 bool hidden,
ccameron2f451532016-09-07 21:49:27534 const ScreenInfo& screen_info,
kenrba7199832015-01-22 23:44:59535 CompositorDependencies* compositor_deps,
536 blink::WebLocalFrame* frame) {
nick4df698d82016-11-11 20:39:23537 CHECK_NE(widget_routing_id, MSG_ROUTING_NONE);
Albert J. Wongcb004632018-07-10 22:58:25538 RenderFrameImpl* render_frame = RenderFrameImpl::FromWebFrame(frame);
539 // For the mainframe, the RenderWidget is attached to the RenderView.
540 // TODO(ajwong): Remove this when the widget is always attached to a frame.
541 // https://crbug.com/545684
542 if (!frame->Parent()) {
543 RenderViewImpl* view =
544 static_cast<RenderViewImpl*>(render_frame->GetRenderView());
danakj9a8a9cf2018-07-17 23:52:12545 // Use the WidgetClient() from the RenderViewImpl, rather than getting its
546 // RenderWidget directly. Layout tests may inject a different
547 // WebWidgetClient on the RenderViewImpl that intercepts calls before they
548 // get to the RenderWidget.
avi8a45c1092016-03-01 16:12:34549 view->AttachWebFrameWidget(
danakj9a8a9cf2018-07-17 23:52:12550 RenderWidget::CreateWebFrameWidget(view->WidgetClient(), frame));
Lucas Furukawa Gadani6ccadf72018-02-13 10:29:10551 view->GetWidget()->UpdateWebViewWithDeviceScaleFactor();
avi8a45c1092016-03-01 16:12:34552 return view->GetWidget();
dcheng3ce04b62015-10-26 23:30:55553 }
Hajime Hoshiabb3c8f2017-12-04 18:41:39554 scoped_refptr<base::SingleThreadTaskRunner> task_runner =
Hajime Hoshi0cda8752018-05-11 08:25:54555 frame->GetTaskRunner(blink::TaskType::kInternalDefault);
dcheng35d31c112015-07-22 00:17:36556 scoped_refptr<RenderWidget> widget(
lfg1568d112016-08-30 16:06:29557 g_create_render_widget
nick8331f8ad2016-11-15 20:42:45558 ? g_create_render_widget(widget_routing_id, compositor_deps,
danakj73dd3032018-07-28 17:49:53559 blink::kWebPopupTypeNone, screen_info,
560 blink::kWebDisplayModeUndefined, false,
Scott Violetae08f332018-07-27 17:37:23561 hidden, false)
nick8331f8ad2016-11-15 20:42:45562 : new RenderWidget(widget_routing_id, compositor_deps,
danakj73dd3032018-07-28 17:49:53563 blink::kWebPopupTypeNone, screen_info,
564 blink::kWebDisplayModeUndefined, false, hidden,
565 false, task_runner));
simonhong628f9812015-04-27 23:13:20566 widget->for_oopif_ = true;
nick4df698d82016-11-11 20:39:23567 // Init increments the reference count on |widget|, keeping it alive after
kenrba7199832015-01-22 23:44:59568 // this function returns.
Scott Violetae08f332018-07-27 17:37:23569 widget->Init(base::NullCallback(),
nick4df698d82016-11-11 20:39:23570 RenderWidget::CreateWebFrameWidget(widget.get(), frame));
Lucas Furukawa Gadani6ccadf72018-02-13 10:29:10571 widget->UpdateWebViewWithDeviceScaleFactor();
nick4df698d82016-11-11 20:39:23572
573 if (g_render_widget_initialized)
574 g_render_widget_initialized(widget.get());
575 return widget.get();
kenrba7199832015-01-22 23:44:59576}
577
578// static
lfgcaab5142016-02-26 19:06:52579blink::WebFrameWidget* RenderWidget::CreateWebFrameWidget(
danakj9a8a9cf2018-07-17 23:52:12580 blink::WebWidgetClient* widget_client,
dchengda9b4bb2015-07-20 20:58:08581 blink::WebLocalFrame* frame) {
danakj9a8a9cf2018-07-17 23:52:12582 return blink::WebFrameWidget::Create(widget_client, frame);
dchengda9b4bb2015-07-20 20:58:08583}
584
585// static
kenrba7199832015-01-22 23:44:59586blink::WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) {
[email protected]484955942010-08-19 16:13:18587 switch (render_widget->popup_type_) {
Blink Reformat1c4d759e2017-04-09 16:34:54588 case blink::kWebPopupTypeNone: // Nothing to create.
[email protected]484955942010-08-19 16:13:18589 break;
Blink Reformat1c4d759e2017-04-09 16:34:54590 case blink::kWebPopupTypePage:
591 return WebPagePopup::Create(render_widget);
[email protected]484955942010-08-19 16:13:18592 default:
593 NOTREACHED();
594 }
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28595 return nullptr;
[email protected]484955942010-08-19 16:13:18596}
597
dchengda9b4bb2015-07-20 20:58:08598void RenderWidget::CloseForFrame() {
danakja2c9d0a92018-07-25 20:01:18599 if (owner_delegate_) {
600 owner_delegate_->OverrideCloseForWidget();
601 return;
602 }
dchengd96a27a2015-07-24 20:17:32603 OnClose();
kenrba7199832015-01-22 23:44:59604}
605
alexmos78c9c0d2016-10-14 18:57:03606void RenderWidget::SetSwappedOut(bool is_swapped_out) {
607 // We should only toggle between states.
608 DCHECK(is_swapped_out_ != is_swapped_out);
609 is_swapped_out_ = is_swapped_out;
610
611 // If we are swapping out, we will call ReleaseProcess, allowing the process
612 // to exit if all of its RenderViews are swapped out. We wait until the
613 // WasSwappedOut call to do this, to allow the unload handler to finish.
614 // If we are swapping in, we call AddRefProcess to prevent the process from
615 // exiting.
616 if (!is_swapped_out_)
617 RenderProcess::current()->AddRefProcess();
618}
619
Scott Violetae08f332018-07-27 17:37:23620void RenderWidget::Init(ShowCallback show_callback, WebWidget* web_widget) {
lfg8ff33912016-09-13 20:59:21621 DCHECK(!webwidget_internal_);
nick4df698d82016-11-11 20:39:23622 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29623
Jeremy Roman04f27c372017-10-27 15:20:55624 input_handler_ = std::make_unique<RenderWidgetInputHandler>(this, this);
nick8331f8ad2016-11-15 20:42:45625
Dave Tapuska04bc5ee92018-04-17 19:03:31626 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
Dave Tapuska9db80842017-07-24 17:24:26627
Alexander Timin41e917d2018-07-02 16:25:35628 blink::scheduler::WebThreadScheduler* compositor_thread_scheduler =
629 blink::scheduler::WebThreadScheduler::CompositorThreadScheduler();
630
Dave Tapuska04bc5ee92018-04-17 19:03:31631 widget_input_handler_manager_ = WidgetInputHandlerManager::Create(
632 weak_ptr_factory_.GetWeakPtr(),
danakja6c10012018-07-06 14:25:36633 compositor_thread_scheduler && layer_tree_view_
Alexander Timin41e917d2018-07-02 16:25:35634 ? compositor_thread_scheduler->InputTaskRunner()
Dave Tapuska04bc5ee92018-04-17 19:03:31635 : nullptr,
636 render_thread_impl ? render_thread_impl->GetWebMainThreadScheduler()
637 : nullptr);
Dave Tapuska9db80842017-07-24 17:24:26638
danakjdf1ceb72018-07-18 20:02:25639 show_callback_ = std::move(show_callback);
initial.commit09911bf2008-07-26 23:55:29640
lfg8ff33912016-09-13 20:59:21641 webwidget_internal_ = web_widget;
642 webwidget_mouse_lock_target_.reset(
643 new WebWidgetLockTarget(webwidget_internal_));
lfgbee1e0a2016-06-08 21:24:21644 mouse_lock_dispatcher_.reset(new RenderWidgetMouseLockDispatcher(this));
initial.commit09911bf2008-07-26 23:55:29645
nick4df698d82016-11-11 20:39:23646 RenderThread::Get()->AddRoute(routing_id_, this);
647 // Take a reference on behalf of the RenderThread. This will be balanced
648 // when we receive ViewMsg_Close.
649 AddRef();
650 if (RenderThreadImpl::current()) {
651 RenderThreadImpl::current()->WidgetCreated();
652 if (is_hidden_)
653 RenderThreadImpl::current()->WidgetHidden();
initial.commit09911bf2008-07-26 23:55:29654 }
655}
656
danakja2c9d0a92018-07-25 20:01:18657void RenderWidget::SetUpIdleUserDetector() {
658 idle_user_detector_ = std::make_unique<IdleUserDetector>();
659}
660
[email protected]949b6592014-08-20 13:17:52661void RenderWidget::WasSwappedOut() {
662 // If we have been swapped out and no one else is using this process,
663 // it's safe to exit now.
664 CHECK(is_swapped_out_);
665 RenderProcess::current()->ReleaseProcess();
666}
667
danakj53802692018-07-25 21:46:44668void RenderWidget::ApplyEmulatedScreenMetricsForPopupWidget(
669 RenderWidget* origin_widget) {
670 RenderWidgetScreenMetricsEmulator* emulator =
671 origin_widget->screen_metrics_emulator_.get();
672 if (!emulator)
673 return;
[email protected]b2e4c70132013-10-03 02:07:51674 popup_origin_scale_for_emulation_ = emulator->scale();
[email protected]19193682014-04-03 15:01:43675 popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
Pavel Feldmancc099f72017-07-20 23:09:00676 popup_screen_origin_for_emulation_ =
Lei Zhang9b359d32017-11-28 00:57:02677 emulator->original_screen_rect().origin();
Fady Samuel4255c182018-05-24 20:42:36678 UpdateSurfaceAndScreenInfo(local_surface_id_from_parent_,
679 compositor_viewport_pixel_size_,
Christopher Camerone9a30c12018-03-07 08:23:38680 emulator->original_screen_info());
[email protected]b2e4c70132013-10-03 02:07:51681}
682
[email protected]2d6836f42014-07-02 17:25:31683gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) {
684 if (screen_metrics_emulator_)
685 return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor);
686 return anchor;
687}
688
thakis18e426412017-03-15 12:06:37689#if BUILDFLAG(USE_EXTERNAL_POPUP_MENU)
[email protected]b2e4c70132013-10-03 02:07:51690void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
mfomitchev2600fd7c2016-02-17 20:53:39691 ExternalPopupMenu* popup,
692 RenderWidgetScreenMetricsEmulator* emulator) {
Pavel Feldmancc099f72017-07-20 23:09:00693 popup->SetOriginScaleForEmulation(emulator->scale());
[email protected]b2e4c70132013-10-03 02:07:51694}
[email protected]53907862014-03-25 15:42:40695#endif
[email protected]b2e4c70132013-10-03 02:07:51696
697void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
698 if (screen_metrics_emulator_)
699 screen_metrics_emulator_->OnShowContextMenu(params);
700}
701
[email protected]a95986a82010-12-24 06:19:28702bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
ekaramad330ba4232016-09-23 17:57:47703#if defined(OS_MACOSX)
704 if (IPC_MESSAGE_CLASS(message) == TextInputClientMsgStart)
705 return text_input_client_observer_->OnMessageReceived(message);
706#endif
lfgbee1e0a2016-06-08 21:24:21707 if (mouse_lock_dispatcher_ &&
708 mouse_lock_dispatcher_->OnMessageReceived(message))
709 return true;
710
[email protected]a95986a82010-12-24 06:19:28711 bool handled = true;
712 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
wjmacleanee244e02017-05-26 21:06:07713 IPC_MESSAGE_HANDLER(ViewMsg_ShowContextMenu, OnShowContextMenu)
[email protected]a95986a82010-12-24 06:19:28714 IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
Fady Samuel799e72192018-04-25 21:16:57715 IPC_MESSAGE_HANDLER(ViewMsg_SynchronizeVisualProperties,
716 OnSynchronizeVisualProperties)
dgozman9260b0a12015-03-16 13:45:20717 IPC_MESSAGE_HANDLER(ViewMsg_EnableDeviceEmulation,
718 OnEnableDeviceEmulation)
719 IPC_MESSAGE_HANDLER(ViewMsg_DisableDeviceEmulation,
720 OnDisableDeviceEmulation)
[email protected]a95986a82010-12-24 06:19:28721 IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
[email protected]9e2e4632012-07-27 16:38:41722 IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
Albert J. Wongcb004632018-07-10 22:58:25723 IPC_MESSAGE_HANDLER(ViewMsg_SetActive, OnSetActive)
724 IPC_MESSAGE_HANDLER(ViewMsg_SetBackgroundOpaque, OnSetBackgroundOpaque)
[email protected]a95986a82010-12-24 06:19:28725 IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
Avi Drissman014dec72018-06-07 02:34:01726 IPC_MESSAGE_HANDLER(ViewMsg_SetBounds_ACK, OnRequestSetBoundsAck)
[email protected]80ad8622012-11-07 16:33:03727 IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
Albert J. Wongcb004632018-07-10 22:58:25728 IPC_MESSAGE_HANDLER(ViewMsg_ForceRedraw, OnForceRedraw)
kenrbea731792017-01-13 15:10:48729 IPC_MESSAGE_HANDLER(ViewMsg_SetViewportIntersection,
730 OnSetViewportIntersection)
kenrb04323782017-06-23 01:23:32731 IPC_MESSAGE_HANDLER(ViewMsg_SetIsInert, OnSetIsInert)
sunxd540a9962018-05-24 22:51:06732 IPC_MESSAGE_HANDLER(ViewMsg_SetInheritedEffectiveTouchAction,
733 OnSetInheritedEffectiveTouchAction)
Ken Buchanan8a319fb2017-11-15 18:37:12734 IPC_MESSAGE_HANDLER(ViewMsg_UpdateRenderThrottlingStatus,
735 OnUpdateRenderThrottlingStatus)
lfg43e08e62016-02-03 18:51:37736 IPC_MESSAGE_HANDLER(ViewMsg_WaitForNextFrameForTests,
737 OnWaitNextFrameForTests)
paulmeyer90f6c31d2016-11-12 00:17:59738 IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter)
739 IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver, OnDragTargetDragOver)
740 IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave, OnDragTargetDragLeave)
741 IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop)
paulmeyer8fc8ea92016-11-15 05:12:21742 IPC_MESSAGE_HANDLER(DragMsg_SourceEnded, OnDragSourceEnded)
743 IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded,
744 OnDragSourceSystemDragEnded)
[email protected]a95986a82010-12-24 06:19:28745 IPC_MESSAGE_UNHANDLED(handled = false)
746 IPC_END_MESSAGE_MAP()
747 return handled;
748}
initial.commit09911bf2008-07-26 23:55:29749
750bool RenderWidget::Send(IPC::Message* message) {
Nasko Oskovf97e8b02017-07-25 02:45:42751 // Don't send any messages after the browser has told us to close, and filter
752 // most outgoing messages while swapped out.
753 if ((is_swapped_out_ &&
754 !SwappedOutMessages::CanSendWhileSwappedOut(message)) ||
755 closing_) {
initial.commit09911bf2008-07-26 23:55:29756 delete message;
757 return false;
758 }
759
760 // If given a messsage without a routing ID, then assign our routing ID.
761 if (message->routing_id() == MSG_ROUTING_NONE)
762 message->set_routing_id(routing_id_);
763
[email protected]380244092011-10-07 17:26:27764 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44765}
766
dtapuska014ed082016-11-11 21:58:48767void RenderWidget::SendOrCrash(IPC::Message* message) {
768 bool result = Send(message);
769 CHECK(closing_ || result) << "Failed to send message";
770}
771
ekaramad5aff1942017-01-06 01:26:35772bool RenderWidget::ShouldHandleImeEvents() const {
ekaramadb6483a052017-02-10 02:23:26773 // TODO(ekaramad): We track page focus in all RenderViews on the page but the
774 // RenderWidgets corresponding to OOPIFs do not get the update. For now, this
775 // method returns true when the RenderWidget is for an OOPIF, i.e., IME events
776 // will be processed regardless of page focus. We should revisit this after
777 // page focus for OOPIFs has been fully resolved (https://crbug.com/689777).
Blink Reformat1c4d759e2017-04-09 16:34:54778 return GetWebWidget() && GetWebWidget()->IsWebFrameWidget() &&
ekaramadb6483a052017-02-10 02:23:26779 (has_focus_ || for_oopif_);
ekaramad5aff1942017-01-06 01:26:35780}
781
initial.commit09911bf2008-07-26 23:55:29782void RenderWidget::OnClose() {
dchengd96a27a2015-07-24 20:17:32783 DCHECK(content::RenderThread::Get());
784 if (closing_)
785 return;
786 NotifyOnClose();
787 closing_ = true;
788
789 // Browser correspondence is no longer needed at this point.
790 if (routing_id_ != MSG_ROUTING_NONE) {
791 RenderThread::Get()->RemoveRoute(routing_id_);
Albert J. Wongcb004632018-07-10 22:58:25792 g_routing_id_widget_map.Get().erase(routing_id_);
dchengd96a27a2015-07-24 20:17:32793 SetHidden(false);
794 if (RenderThreadImpl::current())
795 RenderThreadImpl::current()->WidgetDestroyed();
796 }
797
798 if (for_oopif_) {
799 // Widgets for frames may be created and closed at any time while the frame
Ken Buchananed449bb2018-02-01 21:02:05800 // is alive. However, WebWidget must be closed synchronously because frame
801 // widgets and frames hold pointers to each other. The deferred call to
802 // Close() will complete cleanup and release |this|, but CloseWebWidget()
803 // prevents Close() from attempting to access members of an
804 // already-deleted frame.
805 CloseWebWidget();
dchengd96a27a2015-07-24 20:17:32806 }
Ken Buchananed449bb2018-02-01 21:02:05807 // If there is a Send call on the stack, then it could be dangerous to close
808 // now. Post a task that only gets invoked when there are no nested message
809 // loops.
810 task_runner_->PostNonNestableTask(FROM_HERE,
811 base::BindOnce(&RenderWidget::Close, this));
dchengd96a27a2015-07-24 20:17:32812
813 // Balances the AddRef taken when we called AddRoute.
814 Release();
initial.commit09911bf2008-07-26 23:55:29815}
816
Fady Samuel799e72192018-04-25 21:16:57817void RenderWidget::OnSynchronizeVisualProperties(
danakja2c9d0a92018-07-25 20:01:18818 const VisualProperties& original_params) {
819 TRACE_EVENT0("renderer", "RenderWidget::OnSynchronizeVisualProperties");
EhsanKbd2cea992017-11-23 18:49:08820
danakja2c9d0a92018-07-25 20:01:18821 VisualProperties params = original_params;
822 if (owner_delegate_) {
823 owner_delegate_->ApplyNewSizeForWidget(size_, params.new_size);
824
825 if (display_mode_ != params.display_mode) {
826 display_mode_ = params.display_mode;
827 owner_delegate_->ApplyNewDisplayModeForWidget(params.display_mode);
828 }
829
830 bool auto_resize_mode_changed =
831 auto_resize_mode_ != params.auto_resize_enabled;
832 auto_resize_mode_ = params.auto_resize_enabled;
833 min_size_for_auto_resize_ = params.min_size_for_auto_resize;
834 max_size_for_auto_resize_ = params.max_size_for_auto_resize;
835
836 if (auto_resize_mode_) {
837 gfx::Size min_auto_size = min_size_for_auto_resize_;
838 gfx::Size max_auto_size = max_size_for_auto_resize_;
839 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
840 min_auto_size = gfx::ScaleToCeiledSize(
841 min_auto_size, params.screen_info.device_scale_factor);
842 max_auto_size = gfx::ScaleToCeiledSize(
843 max_auto_size, params.screen_info.device_scale_factor);
844 }
845 owner_delegate_->ApplyAutoResizeLimitsForWidget(min_auto_size,
846 max_auto_size);
847 } else if (auto_resize_mode_changed) {
848 owner_delegate_->DisableAutoResizeForWidget();
849 if (params.new_size.IsEmpty())
850 return;
851 }
852
853 browser_controls_shrink_blink_size_ =
854 params.browser_controls_shrink_blink_size;
855 top_controls_height_ = params.top_controls_height;
856 bottom_controls_height_ = params.bottom_controls_height;
857
858 // TODO(fsamuel): Modifies the |params| that are used for
859 // SynchronizeVisualProperties(), but does not used this modified
860 // device_scale_factor for the auto-resize values, which is probably a bug.
861 if (device_scale_factor_for_testing_) {
862 params.screen_info.device_scale_factor =
863 *device_scale_factor_for_testing_;
864 params.compositor_viewport_pixel_size = gfx::ScaleToCeiledSize(
865 params.new_size, params.screen_info.device_scale_factor);
866 }
[email protected]b2e4c70132013-10-03 02:07:51867 }
868
danakja2c9d0a92018-07-25 20:01:18869 if (!resizing_mode_selector_->ShouldAbortOnResize(this, params)) {
870 if (screen_metrics_emulator_) {
871 screen_metrics_emulator_->OnSynchronizeVisualProperties(params);
872 } else {
873 gfx::Size old_visible_viewport_size = visible_viewport_size_;
874 SynchronizeVisualProperties(params);
875 if (old_visible_viewport_size != visible_viewport_size_) {
876 for (auto& render_frame : render_frames_)
877 render_frame.DidChangeVisibleViewport();
878 }
879 }
Fady Samuel799e72192018-04-25 21:16:57880 }
881
danakja2c9d0a92018-07-25 20:01:18882 if (owner_delegate_ && params.scroll_focused_node_into_view)
883 owner_delegate_->ScrollFocusedNodeIntoViewForWidget();
initial.commit09911bf2008-07-26 23:55:29884}
885
dgozman9260b0a12015-03-16 13:45:20886void RenderWidget::OnEnableDeviceEmulation(
Lei Zhang9b359d32017-11-28 00:57:02887 const blink::WebDeviceEmulationParams& params) {
mfomitchev2600fd7c2016-02-17 20:53:39888 if (!screen_metrics_emulator_) {
Fady Samuel4255c182018-05-24 20:42:36889 VisualProperties visual_properties;
890 visual_properties.screen_info = screen_info_;
891 visual_properties.new_size = size_;
892 visual_properties.compositor_viewport_pixel_size =
Christopher Cameronaad15a0d2018-03-09 03:47:33893 compositor_viewport_pixel_size_;
Fady Samuel4255c182018-05-24 20:42:36894 visual_properties.local_surface_id = local_surface_id_from_parent_;
895 visual_properties.visible_viewport_size = visible_viewport_size_;
896 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
897 visual_properties.display_mode = display_mode_;
mfomitchev2600fd7c2016-02-17 20:53:39898 screen_metrics_emulator_.reset(new RenderWidgetScreenMetricsEmulator(
Fady Samuel4255c182018-05-24 20:42:36899 this, params, visual_properties, view_screen_rect_,
900 window_screen_rect_));
oshima50872a72016-03-04 13:26:18901 screen_metrics_emulator_->Apply();
mfomitchev2600fd7c2016-02-17 20:53:39902 } else {
dgozman9260b0a12015-03-16 13:45:20903 screen_metrics_emulator_->ChangeEmulationParams(params);
mfomitchev2600fd7c2016-02-17 20:53:39904 }
dgozman9260b0a12015-03-16 13:45:20905}
906
907void RenderWidget::OnDisableDeviceEmulation() {
908 screen_metrics_emulator_.reset();
909}
910
initial.commit09911bf2008-07-26 23:55:29911void RenderWidget::OnWasHidden() {
[email protected]9c3085f2011-06-09 02:10:31912 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
initial.commit09911bf2008-07-26 23:55:29913 // Go into a mode where we stop generating paint and scrolling events.
[email protected]bee16aab2009-08-26 15:55:03914 SetHidden(true);
ericwilligers88e69742016-10-17 19:29:55915 for (auto& observer : render_frames_)
916 observer.WasHidden();
initial.commit09911bf2008-07-26 23:55:29917}
918
Saman Samid709592b2018-02-03 00:38:10919void RenderWidget::OnWasShown(bool needs_repainting,
Sadrul Habib Chowdhury8bc43cc2018-06-06 01:48:03920 base::TimeTicks show_request_timestamp) {
[email protected]9e2e4632012-07-27 16:38:41921 TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
initial.commit09911bf2008-07-26 23:55:29922 // During shutdown we can just ignore this message.
lfg8ff33912016-09-13 20:59:21923 if (!GetWebWidget())
initial.commit09911bf2008-07-26 23:55:29924 return;
925
tasakb95dbb50c2017-02-08 18:07:50926 was_shown_time_ = base::TimeTicks::Now();
initial.commit09911bf2008-07-26 23:55:29927 // See OnWasHidden
[email protected]bee16aab2009-08-26 15:55:03928 SetHidden(false);
ericwilligers88e69742016-10-17 19:29:55929 for (auto& observer : render_frames_)
930 observer.WasShown();
initial.commit09911bf2008-07-26 23:55:29931
[email protected]8a23afb32014-04-30 22:40:23932 if (!needs_repainting)
initial.commit09911bf2008-07-26 23:55:29933 return;
initial.commit09911bf2008-07-26 23:55:29934
danakja6c10012018-07-06 14:25:36935 if (layer_tree_view_ && !show_request_timestamp.is_null()) {
936 layer_tree_view_->layer_tree_host()->RequestPresentationTimeForNextFrame(
Sadrul Habib Chowdhury8bc43cc2018-06-06 01:48:03937 CreateTabSwitchingTimeRecorder(show_request_timestamp));
[email protected]3399dd822014-08-09 11:14:24938 }
initial.commit09911bf2008-07-26 23:55:29939}
940
Avi Drissman014dec72018-06-07 02:34:01941void RenderWidget::OnRequestSetBoundsAck() {
[email protected]53d3f302009-12-21 04:42:05942 DCHECK(pending_window_rect_count_);
943 pending_window_rect_count_--;
944}
945
Albert J. Wongcb004632018-07-10 22:58:25946void RenderWidget::OnForceRedraw(int snapshot_id) {
947 if (LayerTreeView* ltv = layer_tree_view()) {
948 ltv->layer_tree_host()->RequestPresentationTimeForNextFrame(
949 base::BindOnce(&RenderWidget::DidPresentForceDrawFrame,
950 weak_ptr_factory_.GetWeakPtr(), snapshot_id));
951 ltv->SetNeedsForcedRedraw();
952 }
953}
954
955void RenderWidget::DidPresentForceDrawFrame(
956 int snapshot_id,
957 const gfx::PresentationFeedback& feedback) {
958 Send(new ViewHostMsg_ForceRedrawComplete(routing_id(), snapshot_id));
959}
960
Sadrul Habib Chowdhury6539b732018-01-05 21:53:27961viz::FrameSinkId RenderWidget::GetFrameSinkIdAtPoint(const gfx::Point& point) {
962 return input_handler_->GetFrameSinkIdAtPoint(point);
Navid Zolghadr0d86e5f2017-10-23 18:09:22963}
964
Dave Tapuskaea83d3bd2017-06-13 16:14:55965void RenderWidget::HandleInputEvent(
dtapuska9ec1a912017-04-21 15:18:31966 const blink::WebCoalescedInputEvent& input_event,
967 const ui::LatencyInfo& latency_info,
Dave Tapuskaea83d3bd2017-06-13 16:14:55968 HandledEventCallback callback) {
danakja2c9d0a92018-07-25 20:01:18969 if (owner_delegate_ && is_swapped_out_) {
970 std::move(callback).Run(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, latency_info,
971 nullptr, base::nullopt);
972 return;
973 }
974 if (idle_user_detector_)
975 idle_user_detector_->ActivityDetected();
Dave Tapuskaea83d3bd2017-06-13 16:14:55976 input_handler_->HandleInputEvent(input_event, latency_info,
977 std::move(callback));
dtapuska9ec1a912017-04-21 15:18:31978}
979
dtapuska9d46ef7d2017-05-26 19:06:06980scoped_refptr<MainThreadEventQueue> RenderWidget::GetInputEventQueue() {
981 return input_event_queue_;
982}
983
fsamuel78f86e42016-01-20 04:10:23984void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
lfg8ff33912016-09-13 20:59:21985 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:54986 GetWebWidget()->SetCursorVisibilityState(is_visible);
fsamuel78f86e42016-01-20 04:10:23987}
988
989void RenderWidget::OnMouseCaptureLost() {
lfg8ff33912016-09-13 20:59:21990 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:54991 GetWebWidget()->MouseCaptureLost();
fsamuel78f86e42016-01-20 04:10:23992}
993
alexmos56567492016-09-13 00:52:46994void RenderWidget::OnSetEditCommandsForNextKeyEvent(
995 const EditCommands& edit_commands) {
996 edit_commands_ = edit_commands;
997}
998
Albert J. Wongcb004632018-07-10 22:58:25999void RenderWidget::OnSetActive(bool active) {
1000 if (owner_delegate_)
danakja2c9d0a92018-07-25 20:01:181001 owner_delegate_->SetActiveForWidget(active);
Albert J. Wongcb004632018-07-10 22:58:251002}
1003
1004void RenderWidget::OnSetBackgroundOpaque(bool opaque) {
1005 if (owner_delegate_)
danakja2c9d0a92018-07-25 20:01:181006 owner_delegate_->SetBackgroundOpaqueForWidget(opaque);
Albert J. Wongcb004632018-07-10 22:58:251007}
1008
fsamuel78f86e42016-01-20 04:10:231009void RenderWidget::OnSetFocus(bool enable) {
danakja2c9d0a92018-07-25 20:01:181010 if (owner_delegate_)
1011 owner_delegate_->DidReceiveSetFocusEventForWidget();
1012 SetFocus(enable);
1013}
1014
1015void RenderWidget::SetFocus(bool enable) {
lfge0c2792ec2016-05-11 18:52:081016 has_focus_ = enable;
1017
lfg8ff33912016-09-13 20:59:211018 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:541019 GetWebWidget()->SetFocus(enable);
lfge0c2792ec2016-05-11 18:52:081020
ericwilligers88e69742016-10-17 19:29:551021 for (auto& observer : render_frames_)
1022 observer.RenderWidgetSetFocus(enable);
danakja2c9d0a92018-07-25 20:01:181023
1024 if (owner_delegate_)
1025 owner_delegate_->DidChangeFocusForWidget();
fsamuel78f86e42016-01-20 04:10:231026}
1027
dtapuska3d5624d32016-08-30 04:34:001028void RenderWidget::SetNeedsMainFrame() {
danakja6c10012018-07-06 14:25:361029 LayerTreeView* ltv = layer_tree_view();
1030 if (!ltv)
dtapuska3d5624d32016-08-30 04:34:001031 return;
danakja6c10012018-07-06 14:25:361032 ltv->SetNeedsBeginFrame();
dtapuska3d5624d32016-08-30 04:34:001033}
1034
fsamuel78f86e42016-01-20 04:10:231035///////////////////////////////////////////////////////////////////////////////
danakja6c10012018-07-06 14:25:361036// LayerTreeViewDelegate
fsamuel78f86e42016-01-20 04:10:231037
1038void RenderWidget::ApplyViewportDeltas(
1039 const gfx::Vector2dF& inner_delta,
1040 const gfx::Vector2dF& outer_delta,
1041 const gfx::Vector2dF& elastic_overscroll_delta,
1042 float page_scale,
1043 float top_controls_delta) {
Ken Buchananed449bb2018-02-01 21:02:051044 if (!GetWebWidget())
1045 return;
Blink Reformat1c4d759e2017-04-09 16:34:541046 GetWebWidget()->ApplyViewportDeltas(inner_delta, outer_delta,
lfg8ff33912016-09-13 20:59:211047 elastic_overscroll_delta, page_scale,
1048 top_controls_delta);
fsamuel78f86e42016-01-20 04:10:231049}
1050
sahel1b47fda72017-03-28 17:03:071051void RenderWidget::RecordWheelAndTouchScrollingCount(
1052 bool has_scrolled_by_wheel,
1053 bool has_scrolled_by_touch) {
Ken Buchananed449bb2018-02-01 21:02:051054 if (!GetWebWidget())
1055 return;
Blink Reformat1c4d759e2017-04-09 16:34:541056 GetWebWidget()->RecordWheelAndTouchScrollingCount(has_scrolled_by_wheel,
sahel1b47fda72017-03-28 17:03:071057 has_scrolled_by_touch);
1058}
1059
Daniel Cheng224569ee2018-04-25 05:45:061060void RenderWidget::BeginMainFrame(base::TimeTicks frame_time) {
Ken Buchananed449bb2018-02-01 21:02:051061 if (!GetWebWidget())
1062 return;
Daniel Cheng224569ee2018-04-25 05:45:061063 if (input_event_queue_)
1064 input_event_queue_->DispatchRafAlignedInput(frame_time);
dtapuska3d5624d32016-08-30 04:34:001065
Daniel Cheng224569ee2018-04-25 05:45:061066 GetWebWidget()->BeginFrame(frame_time);
fsamuel78f86e42016-01-20 04:10:231067}
1068
danakjc7afae52017-06-20 21:12:411069void RenderWidget::RequestNewLayerTreeFrameSink(
danakja6c10012018-07-06 14:25:361070 LayerTreeFrameSinkCallback callback) {
lfg8ff33912016-09-13 20:59:211071 DCHECK(GetWebWidget());
[email protected]7912e822014-04-16 02:37:031072 // For widgets that are never visible, we don't start the compositor, so we
danakjc7afae52017-06-20 21:12:411073 // never get a request for a cc::LayerTreeFrameSink.
sievers71c62dd52015-10-07 01:44:391074 DCHECK(!compositor_never_visible_);
jonrossa2ff4f82018-02-16 17:27:461075
1076 // TODO(jonross): have this generated by the LayerTreeFrameSink itself, which
1077 // would then handle binding.
1078 mojom::RenderFrameMetadataObserverPtr ptr;
1079 mojom::RenderFrameMetadataObserverRequest request = mojo::MakeRequest(&ptr);
1080 mojom::RenderFrameMetadataObserverClientPtrInfo client_info;
1081 mojom::RenderFrameMetadataObserverClientRequest client_request =
1082 mojo::MakeRequest(&client_info);
danakj4b347212018-07-04 17:55:171083 auto render_frame_metadata_observer =
1084 std::make_unique<RenderFrameMetadataObserverImpl>(std::move(request),
1085 std::move(client_info));
danakja6c10012018-07-06 14:25:361086 layer_tree_view_->SetRenderFrameObserver(
danakj4b347212018-07-04 17:55:171087 std::move(render_frame_metadata_observer));
danakjc7afae52017-06-20 21:12:411088 RenderThreadImpl::current()->RequestNewLayerTreeFrameSink(
danakjab9ef4d2017-10-31 23:38:331089 routing_id_, frame_swap_message_queue_, GetURLForGraphicsContext3D(),
danakja6c10012018-07-06 14:25:361090 std::move(callback), std::move(client_request), std::move(ptr));
[email protected]ba91a792013-02-06 09:48:281091}
1092
fsamuel78f86e42016-01-20 04:10:231093void RenderWidget::DidCommitAndDrawCompositorFrame() {
1094 // NOTE: Tests may break if this event is renamed or moved. See
1095 // tab_capture_performancetest.cc.
1096 TRACE_EVENT0("gpu", "RenderWidget::DidCommitAndDrawCompositorFrame");
lfge0c2792ec2016-05-11 18:52:081097
ericwilligers88e69742016-10-17 19:29:551098 for (auto& observer : render_frames_)
1099 observer.DidCommitAndDrawCompositorFrame();
lfge0c2792ec2016-05-11 18:52:081100
fsamuel78f86e42016-01-20 04:10:231101 // Notify subclasses that we initiated the paint operation.
1102 DidInitiatePaint();
fsamuel78f86e42016-01-20 04:10:231103}
1104
Saman Sami766e0b02018-01-31 17:19:201105void RenderWidget::DidCommitCompositorFrame() {
danakja2c9d0a92018-07-25 20:01:181106 if (owner_delegate_)
1107 owner_delegate_->DidCommitCompositorFrameForWidget();
Saman Sami766e0b02018-01-31 17:19:201108}
fsamuel78f86e42016-01-20 04:10:231109
danakja2c9d0a92018-07-25 20:01:181110void RenderWidget::DidCompletePageScaleAnimation() {
1111 if (owner_delegate_)
1112 owner_delegate_->DidCompletePageScaleAnimationForWidget();
1113}
fsamuel78f86e42016-01-20 04:10:231114
danakj6c872fc02016-10-22 04:29:491115void RenderWidget::DidReceiveCompositorFrameAck() {
fsamuel78f86e42016-01-20 04:10:231116}
1117
fsamuel78f86e42016-01-20 04:10:231118bool RenderWidget::IsClosing() const {
Albert J. Wongcb004632018-07-10 22:58:251119 // TODO(ajwong): There is oddly 2 closing states. This API is used by
1120 // LayerTreeView only as part of the LayerTreeViewDelegate interface and
1121 // is the guard against creating new compositor frames unnecessarily.
1122 // Historically, when RenderViewImpl and RenderWidget shared the same
1123 // routing id, it was possible for |closing_| to be true, |host_closing_| to
1124 // false, and for the code in
1125 // RenderThreadImpl::RequestNewLayerTreeFrameSink() to still look up a valid
1126 // RenderViewImpl from the routing id. This is actually a benign shutdown
1127 // race in Android that can be triggered in the SynchronouslyComposite path
1128 // via AwContentsGarbageCollectionTest#testCreateAndGcManyTimes.
1129 //
1130 // Once RenderViewImpl and RenderWidget are split, attempt to combine two
1131 // states so the shutdown logic is cleaner.
1132 //
1133 // http://crbug.com/545684
1134 return host_closing_ || closing_;
fsamuel78f86e42016-01-20 04:10:231135}
1136
danakj53eccbc2016-03-02 22:51:071137void RenderWidget::RequestScheduleAnimation() {
danakja2c9d0a92018-07-25 20:01:181138 if (owner_delegate_) {
1139 owner_delegate_->RequestScheduleAnimationForWidget();
1140 return;
1141 }
Blink Reformat1c4d759e2017-04-09 16:34:541142 ScheduleAnimation();
initial.commit09911bf2008-07-26 23:55:291143}
1144
Eric Seckler8af8c0e52018-01-17 23:45:531145void RenderWidget::UpdateVisualState(VisualStateUpdate requested_update) {
Ken Buchananed449bb2018-02-01 21:02:051146 if (!GetWebWidget())
1147 return;
1148
Eric Seckler8af8c0e52018-01-17 23:45:531149 bool pre_paint_only = requested_update == VisualStateUpdate::kPrePaint;
1150 WebWidget::LifecycleUpdate lifecycle_update =
1151 pre_paint_only ? WebWidget::LifecycleUpdate::kPrePaint
1152 : WebWidget::LifecycleUpdate::kAll;
1153
1154 GetWebWidget()->UpdateLifecycle(lifecycle_update);
Blink Reformat1c4d759e2017-04-09 16:34:541155 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(false);
tasakb95dbb50c2017-02-08 18:07:501156
Eric Seckler8af8c0e52018-01-17 23:45:531157 if (first_update_visual_state_after_hidden_ && !pre_paint_only) {
Takashi SAKAMOTO870f6262017-08-22 04:08:271158 RecordTimeToFirstActivePaint();
1159 first_update_visual_state_after_hidden_ = false;
1160 }
1161}
tasakb95dbb50c2017-02-08 18:07:501162
Takashi SAKAMOTO870f6262017-08-22 04:08:271163void RenderWidget::RecordTimeToFirstActivePaint() {
tasakb95dbb50c2017-02-08 18:07:501164 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
tasakb95dbb50c2017-02-08 18:07:501165 base::TimeDelta sample = base::TimeTicks::Now() - was_shown_time_;
Takashi SAKAMOTO870f6262017-08-22 04:08:271166 if (render_thread_impl->NeedsToRecordFirstActivePaint(TTFAP_AFTER_PURGED)) {
1167 UMA_HISTOGRAM_TIMES("PurgeAndSuspend.Experimental.TimeToFirstActivePaint",
1168 sample);
1169 }
1170 if (render_thread_impl->NeedsToRecordFirstActivePaint(
1171 TTFAP_5MIN_AFTER_BACKGROUNDED)) {
1172 UMA_HISTOGRAM_TIMES(
1173 "PurgeAndSuspend.Experimental.TimeToFirstActivePaint."
1174 "AfterBackgrounded.5min",
1175 sample);
1176 }
fsamuel78f86e42016-01-20 04:10:231177}
1178
1179void RenderWidget::WillBeginCompositorFrame() {
1180 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
1181
Ken Buchananed449bb2018-02-01 21:02:051182 if (!GetWebWidget())
1183 return;
1184
Blink Reformat1c4d759e2017-04-09 16:34:541185 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(true);
alancutter317a8e02017-04-05 10:09:291186
dglazkov06854c5c2016-08-31 00:19:591187 // The UpdateTextInputState can result in further layout and possibly
1188 // enable GPU acceleration so they need to be called before any painting
1189 // is done.
changwan75e3b2072017-01-16 02:55:001190 UpdateTextInputState();
dglazkov06854c5c2016-08-31 00:19:591191 UpdateSelectionBounds();
1192
ericwilligers88e69742016-10-17 19:29:551193 for (auto& observer : render_frame_proxies_)
1194 observer.WillBeginCompositorFrame();
initial.commit09911bf2008-07-26 23:55:291195}
1196
jbroman6ccbc7d472016-07-27 04:45:411197std::unique_ptr<cc::SwapPromise> RenderWidget::RequestCopyOfOutputForLayoutTest(
Fady Samueldfecb7d2017-07-26 11:41:041198 std::unique_ptr<viz::CopyOutputRequest> request) {
jbroman6ccbc7d472016-07-27 04:45:411199 return RenderThreadImpl::current()->RequestCopyOfOutputForLayoutTest(
1200 routing_id_, std::move(request));
1201}
1202
fsamuel72464894f2015-12-15 06:59:311203///////////////////////////////////////////////////////////////////////////////
1204// RenderWidgetInputHandlerDelegate
1205
avid7d6b2e2016-03-04 19:41:171206void RenderWidget::FocusChangeComplete() {
Ehsan Karamad655d7b8a2018-01-12 18:38:381207 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1208 if (!frame_widget)
ekaramad27ca69b12017-04-20 18:34:291209 return;
Ehsan Karamad655d7b8a2018-01-12 18:38:381210
ekaramad27ca69b12017-04-20 18:34:291211 blink::WebLocalFrame* focused =
Ehsan Karamad655d7b8a2018-01-12 18:38:381212 frame_widget->LocalRoot()->View()->FocusedFrame();
1213
ekaramad27ca69b12017-04-20 18:34:291214 if (focused && focused->AutofillClient())
1215 focused->AutofillClient()->DidCompleteFocusChangeInFrame();
avid7d6b2e2016-03-04 19:41:171216}
fsamuel72464894f2015-12-15 06:59:311217
dtapuska1827dd22016-03-11 15:24:591218void RenderWidget::ObserveGestureEventAndResult(
1219 const blink::WebGestureEvent& gesture_event,
1220 const gfx::Vector2dF& unused_delta,
Sandra Sunac5cdd832017-12-11 03:27:131221 const cc::OverscrollBehavior& overscroll_behavior,
dtapuska1827dd22016-03-11 15:24:591222 bool event_processed) {
1223 if (!compositor_deps_->IsElasticOverscrollEnabled())
1224 return;
1225
1226 cc::InputHandlerScrollResult scroll_result;
1227 scroll_result.did_scroll = event_processed;
1228 scroll_result.did_overscroll_root = !unused_delta.IsZero();
1229 scroll_result.unused_scroll_delta = unused_delta;
Sandra Sunac5cdd832017-12-11 03:27:131230 scroll_result.overscroll_behavior = overscroll_behavior;
dtapuska1827dd22016-03-11 15:24:591231
Dave Tapuska04bc5ee92018-04-17 19:03:311232 widget_input_handler_manager_->ObserveGestureEventOnMainThread(gesture_event,
1233 scroll_result);
dtapuska1827dd22016-03-11 15:24:591234}
1235
avid7d6b2e2016-03-04 19:41:171236void RenderWidget::OnDidHandleKeyEvent() {
alexmos56567492016-09-13 00:52:461237 ClearEditCommands();
1238}
1239
1240void RenderWidget::SetEditCommandForNextKeyEvent(const std::string& name,
1241 const std::string& value) {
1242 ClearEditCommands();
1243 edit_commands_.emplace_back(name, value);
1244}
1245
1246void RenderWidget::ClearEditCommands() {
1247 edit_commands_.clear();
avid7d6b2e2016-03-04 19:41:171248}
fsamuel72464894f2015-12-15 06:59:311249
chongza8ba91fc2016-08-16 21:39:171250void RenderWidget::OnDidOverscroll(const ui::DidOverscrollParams& params) {
Dave Tapuska04bc5ee92018-04-17 19:03:311251 if (mojom::WidgetInputHandlerHost* host =
1252 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
1253 host->DidOverscroll(params);
Dave Tapuska139a72f2017-09-06 21:57:031254 }
fsamuel72464894f2015-12-15 06:59:311255}
1256
fsamuele8326c742016-01-12 00:49:391257void RenderWidget::SetInputHandler(RenderWidgetInputHandler* input_handler) {
1258 // Nothing to do here. RenderWidget created the |input_handler| and will take
1259 // ownership of it. We just verify here that we don't already have an input
1260 // handler.
1261 DCHECK(!input_handler_);
1262}
1263
changwan75e3b2072017-01-16 02:55:001264void RenderWidget::ShowVirtualKeyboard() {
1265 UpdateTextInputStateInternal(true, false);
1266}
1267
changwan62f57292017-02-17 08:28:251268void RenderWidget::ClearTextInputState() {
1269 text_input_info_ = blink::WebTextInputInfo();
1270 text_input_type_ = ui::TextInputType::TEXT_INPUT_TYPE_NONE;
1271 text_input_mode_ = ui::TextInputMode::TEXT_INPUT_MODE_DEFAULT;
1272 can_compose_inline_ = false;
1273 text_input_flags_ = 0;
AJITH KUMAR V041c0b02017-08-08 10:39:201274 next_previous_flags_ = kInvalidNextPreviousFlagsValue;
changwan62f57292017-02-17 08:28:251275}
1276
changwan75e3b2072017-01-16 02:55:001277void RenderWidget::UpdateTextInputState() {
1278 UpdateTextInputStateInternal(false, false);
1279}
1280
1281void RenderWidget::UpdateTextInputStateInternal(bool show_virtual_keyboard,
1282 bool reply_to_request) {
fsamuel72464894f2015-12-15 06:59:311283 TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState");
changwan75e3b2072017-01-16 02:55:001284
fsamuel72464894f2015-12-15 06:59:311285 if (ime_event_guard_) {
changwan75e3b2072017-01-16 02:55:001286 DCHECK(!reply_to_request);
1287 // show_virtual_keyboard should still be effective even if it was set inside
1288 // the IME
fsamuel72464894f2015-12-15 06:59:311289 // event guard.
changwan75e3b2072017-01-16 02:55:001290 if (show_virtual_keyboard)
1291 ime_event_guard_->set_show_virtual_keyboard(true);
fsamuel72464894f2015-12-15 06:59:311292 return;
1293 }
1294
dglazkov97b6c2b2016-10-25 17:35:551295 ui::TextInputType new_type = GetTextInputType();
1296 if (IsDateTimeInput(new_type))
1297 return; // Not considered as a text input field in WebKit/Chromium.
fsamuel72464894f2015-12-15 06:59:311298
dglazkov97b6c2b2016-10-25 17:35:551299 blink::WebTextInputInfo new_info;
ekaramad5aff1942017-01-06 01:26:351300 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:541301 new_info = controller->TextInputInfo();
dtapuskac4dd5be2016-10-25 15:11:101302 const ui::TextInputMode new_mode =
Blink Reformat1c4d759e2017-04-09 16:34:541303 ConvertWebTextInputMode(new_info.input_mode);
fsamuel72464894f2015-12-15 06:59:311304
1305 bool new_can_compose_inline = CanComposeInline();
1306
1307 // Only sends text input params if they are changed or if the ime should be
1308 // shown.
changwan75e3b2072017-01-16 02:55:001309 if (show_virtual_keyboard || reply_to_request ||
changwan38c3eb612016-12-09 01:45:561310 text_input_type_ != new_type || text_input_mode_ != new_mode ||
1311 text_input_info_ != new_info ||
1312 can_compose_inline_ != new_can_compose_inline) {
ekaramad9053e57b2016-04-26 20:00:381313 TextInputState params;
dglazkov97b6c2b2016-10-25 17:35:551314 params.type = new_type;
fsamuel72464894f2015-12-15 06:59:311315 params.mode = new_mode;
1316 params.flags = new_info.flags;
AJITH KUMAR V9e7b5572017-11-14 00:54:211317#if defined(OS_ANDROID)
AJITH KUMAR V041c0b02017-08-08 10:39:201318 if (next_previous_flags_ == kInvalidNextPreviousFlagsValue) {
1319 // Due to a focus change, values will be reset by the frame.
1320 // That case we only need fresh NEXT/PREVIOUS information.
1321 // Also we won't send ViewHostMsg_TextInputStateChanged if next/previous
1322 // focusable status is changed.
1323 if (auto* controller = GetInputMethodController()) {
1324 next_previous_flags_ =
1325 controller->ComputeWebTextInputNextPreviousFlags();
1326 } else {
1327 // For safety in case GetInputMethodController() is null, because -1 is
1328 // invalid value to send to browser process.
1329 next_previous_flags_ = 0;
1330 }
1331 }
AJITH KUMAR V9e7b5572017-11-14 00:54:211332#else
1333 next_previous_flags_ = 0;
1334#endif
AJITH KUMAR V041c0b02017-08-08 10:39:201335 params.flags |= next_previous_flags_;
Blink Reformat1c4d759e2017-04-09 16:34:541336 params.value = new_info.value.Utf8();
1337 params.selection_start = new_info.selection_start;
1338 params.selection_end = new_info.selection_end;
1339 params.composition_start = new_info.composition_start;
1340 params.composition_end = new_info.composition_end;
fsamuel72464894f2015-12-15 06:59:311341 params.can_compose_inline = new_can_compose_inline;
changwan75e3b2072017-01-16 02:55:001342 // TODO(changwan): change instances of show_ime_if_needed to
1343 // show_virtual_keyboard.
1344 params.show_ime_if_needed = show_virtual_keyboard;
1345 params.reply_to_request = reply_to_request;
fsamuel72464894f2015-12-15 06:59:311346 Send(new ViewHostMsg_TextInputStateChanged(routing_id(), params));
1347
1348 text_input_info_ = new_info;
dglazkov97b6c2b2016-10-25 17:35:551349 text_input_type_ = new_type;
fsamuel72464894f2015-12-15 06:59:311350 text_input_mode_ = new_mode;
1351 can_compose_inline_ = new_can_compose_inline;
1352 text_input_flags_ = new_info.flags;
1353 }
1354}
1355
1356bool RenderWidget::WillHandleGestureEvent(const blink::WebGestureEvent& event) {
paulmeyer6ef5a792016-11-08 20:33:581357 possible_drag_event_info_.event_source =
1358 ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH;
1359 possible_drag_event_info_.event_location =
Ella Ge1116059d2018-03-21 02:06:131360 gfx::ToFlooredPoint(event.PositionInScreen());
avid7d6b2e2016-03-04 19:41:171361
fsamuel72464894f2015-12-15 06:59:311362 return false;
1363}
1364
1365bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
ericwilligers88e69742016-10-17 19:29:551366 for (auto& observer : render_frames_)
1367 observer.RenderWidgetWillHandleMouseEvent();
lfge0c2792ec2016-05-11 18:52:081368
paulmeyer6ef5a792016-11-08 20:33:581369 possible_drag_event_info_.event_source =
1370 ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
1371 possible_drag_event_info_.event_location =
Blink Reformat1c4d759e2017-04-09 16:34:541372 gfx::Point(event.PositionInScreen().x, event.PositionInScreen().y);
paulmeyer6ef5a792016-11-08 20:33:581373
avid7d6b2e2016-03-04 19:41:171374 if (owner_delegate_)
danakja2c9d0a92018-07-25 20:01:181375 return owner_delegate_->RenderWidgetWillHandleMouseEventForWidget(event);
avid7d6b2e2016-03-04 19:41:171376
fsamuel72464894f2015-12-15 06:59:311377 return false;
[email protected]fd847792013-10-24 17:12:351378}
1379
initial.commit09911bf2008-07-26 23:55:291380///////////////////////////////////////////////////////////////////////////////
mfomitchev2600fd7c2016-02-17 20:53:391381// RenderWidgetScreenMetricsDelegate
1382
1383void RenderWidget::Redraw() {
danakja6c10012018-07-06 14:25:361384 if (layer_tree_view_)
1385 layer_tree_view_->SetNeedsRedrawRect(gfx::Rect(size_));
mfomitchev2600fd7c2016-02-17 20:53:391386}
1387
bokanc63441c2016-04-27 15:49:121388void RenderWidget::ResizeWebWidget() {
danakja2c9d0a92018-07-25 20:01:181389 gfx::Size size = GetSizeForWebWidget();
1390 if (owner_delegate_) {
1391 owner_delegate_->ResizeWebWidgetForWidget(
1392 size, top_controls_height_, bottom_controls_height_,
1393 browser_controls_shrink_blink_size_);
1394 return;
1395 }
1396 GetWebWidget()->Resize(size);
bokanc63441c2016-04-27 15:49:121397}
1398
1399gfx::Size RenderWidget::GetSizeForWebWidget() const {
danakj4b347212018-07-04 17:55:171400 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:031401 return gfx::ScaleToCeiledSize(size_,
1402 GetOriginalScreenInfo().device_scale_factor);
1403 }
bokanc63441c2016-04-27 15:49:121404
1405 return size_;
1406}
1407
akaba3483d8f2018-07-10 21:43:091408void RenderWidget::UpdateZoom(double zoom_level) {
akabac6bd1212018-06-25 20:10:481409 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1410 if (!frame_widget)
1411 return;
1412 RenderFrameImpl* render_frame =
1413 RenderFrameImpl::FromWebFrame(frame_widget->LocalRoot());
1414
akaba3483d8f2018-07-10 21:43:091415 // Return early if zoom level is unchanged.
1416 if (render_frame->GetZoomLevel() == zoom_level) {
akabac6bd1212018-06-25 20:10:481417 return;
1418 }
1419
akaba3483d8f2018-07-10 21:43:091420 render_frame->SetZoomLevel(zoom_level);
akabac6bd1212018-06-25 20:10:481421
1422 for (auto& observer : render_frame_proxies_)
akaba3483d8f2018-07-10 21:43:091423 observer.OnZoomLevelChanged(zoom_level);
akabac6bd1212018-06-25 20:10:481424
1425 for (auto& plugin : browser_plugins_)
akaba3483d8f2018-07-10 21:43:091426 plugin.OnZoomLevelChanged(zoom_level);
akabac6bd1212018-06-25 20:10:481427}
1428
Fady Samuel799e72192018-04-25 21:16:571429void RenderWidget::SynchronizeVisualProperties(const VisualProperties& params) {
Christopher Cameronbe7ecea2018-02-27 00:47:191430 // Inform the rendering thread of the color space indicate the presence of HDR
1431 // capabilities.
Miguel Casas5e1018052018-01-09 19:17:361432 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1433 if (render_thread)
Christopher Camerone9a30c12018-03-07 08:23:381434 render_thread->SetRenderingColorSpace(params.screen_info.color_space);
Miguel Casas5e1018052018-01-09 19:17:361435
mfomitchev2600fd7c2016-02-17 20:53:391436 // Ignore this during shutdown.
lfg8ff33912016-09-13 20:59:211437 if (!GetWebWidget())
mfomitchev2600fd7c2016-02-17 20:53:391438 return;
1439
Fady Samuele62be402018-03-29 03:19:531440 gfx::Size new_compositor_viewport_pixel_size =
1441 params.auto_resize_enabled
1442 ? gfx::ScaleToCeiledSize(size_,
1443 params.screen_info.device_scale_factor)
1444 : params.compositor_viewport_pixel_size;
Fady Samuel4392abb2018-05-10 21:01:211445 UpdateSurfaceAndScreenInfo(
1446 params.local_surface_id.value_or(viz::LocalSurfaceId()),
1447 new_compositor_viewport_pixel_size, params.screen_info);
Vladimir Levin98d76dad2018-04-21 00:21:291448 UpdateCaptureSequenceNumber(params.capture_sequence_number);
danakja6c10012018-07-06 14:25:361449 if (layer_tree_view_) {
1450 layer_tree_view_->SetBrowserControlsHeight(
Sadrul Habib Chowdhury04d5dd4d2017-08-10 01:59:271451 params.top_controls_height, params.bottom_controls_height,
1452 params.browser_controls_shrink_blink_size);
danakja6c10012018-07-06 14:25:361453 layer_tree_view_->SetRasterColorSpace(
Sadrul Habib Chowdhury04d5dd4d2017-08-10 01:59:271454 screen_info_.color_space.GetRasterColorSpace());
ianwene5fc5782016-08-18 04:05:151455 }
mfomitchev2600fd7c2016-02-17 20:53:391456
akaba3483d8f2018-07-10 21:43:091457 UpdateZoom(params.zoom_level);
akabac6bd1212018-06-25 20:10:481458
Fady Samuele62be402018-03-29 03:19:531459 if (params.auto_resize_enabled)
1460 return;
1461
mfomitchev2600fd7c2016-02-17 20:53:391462 visible_viewport_size_ = params.visible_viewport_size;
mfomitchev2600fd7c2016-02-17 20:53:391463
1464 // NOTE: We may have entered fullscreen mode without changing our size.
1465 bool fullscreen_change =
1466 is_fullscreen_granted_ != params.is_fullscreen_granted;
1467 is_fullscreen_granted_ = params.is_fullscreen_granted;
1468 display_mode_ = params.display_mode;
1469
bokanc63441c2016-04-27 15:49:121470 size_ = params.new_size;
mfomitchev2600fd7c2016-02-17 20:53:391471
bokanc63441c2016-04-27 15:49:121472 ResizeWebWidget();
bokan71cb5b12016-04-27 03:45:221473
mfomitchev2600fd7c2016-02-17 20:53:391474 WebSize visual_viewport_size;
danakj4b347212018-07-04 17:55:171475 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:031476 visual_viewport_size =
1477 gfx::ScaleToCeiledSize(params.visible_viewport_size,
1478 GetOriginalScreenInfo().device_scale_factor);
mfomitchev2600fd7c2016-02-17 20:53:391479 } else {
1480 visual_viewport_size = visible_viewport_size_;
1481 }
Blink Reformat1c4d759e2017-04-09 16:34:541482 GetWebWidget()->ResizeVisualViewport(visual_viewport_size);
mfomitchev2600fd7c2016-02-17 20:53:391483
mfomitchev2600fd7c2016-02-17 20:53:391484 if (fullscreen_change)
1485 DidToggleFullscreen();
mfomitchev2600fd7c2016-02-17 20:53:391486}
1487
1488void RenderWidget::SetScreenMetricsEmulationParameters(
1489 bool enabled,
1490 const blink::WebDeviceEmulationParams& params) {
danakja2c9d0a92018-07-25 20:01:181491 // This is only supported in RenderView, which has an |owner_delegate_|.
1492 DCHECK(owner_delegate_);
1493 owner_delegate_->SetScreenMetricsEmulationParametersForWidget(enabled,
1494 params);
mfomitchev2600fd7c2016-02-17 20:53:391495}
1496
1497void RenderWidget::SetScreenRects(const gfx::Rect& view_screen_rect,
1498 const gfx::Rect& window_screen_rect) {
1499 view_screen_rect_ = view_screen_rect;
1500 window_screen_rect_ = window_screen_rect;
1501}
1502
1503///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461504// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291505
Blink Reformat1c4d759e2017-04-09 16:34:541506blink::WebLayerTreeView* RenderWidget::InitializeLayerTreeView() {
[email protected]aeeedad2014-08-22 18:16:221507 DCHECK(!host_closing_);
1508
danakja6c10012018-07-06 14:25:361509 layer_tree_view_ = std::make_unique<LayerTreeView>(
danakj4c987652018-07-05 15:49:411510 this, compositor_deps_->GetCompositorMainThreadTaskRunner(),
1511 compositor_deps_->GetCompositorImplThreadTaskRunner(),
1512 compositor_deps_->GetTaskGraphRunner(),
1513 compositor_deps_->GetWebMainThreadScheduler());
danakja6c10012018-07-06 14:25:361514 layer_tree_view_->Initialize(
danakj4c987652018-07-05 15:49:411515 GenerateLayerTreeSettings(compositor_deps_, for_oopif_,
1516 screen_info_.rect.size(),
1517 screen_info_.device_scale_factor),
1518 compositor_deps_->CreateUkmRecorderFactory());
loyso6e6efc42017-01-21 02:23:031519
Fady Samuel4255c182018-05-24 20:42:361520 UpdateSurfaceAndScreenInfo(local_surface_id_from_parent_,
1521 compositor_viewport_pixel_size_, screen_info_);
danakja6c10012018-07-06 14:25:361522 layer_tree_view_->SetRasterColorSpace(
Christopher Camerona1ea2b72017-08-02 01:59:091523 screen_info_.color_space.GetRasterColorSpace());
danakja6c10012018-07-06 14:25:361524 layer_tree_view_->SetContentSourceId(current_content_source_id_);
sievers71c62dd52015-10-07 01:44:391525 // For background pages and certain tests, we don't want to trigger
danakjc7afae52017-06-20 21:12:411526 // LayerTreeFrameSink creation.
dtapuskab08611f2017-04-24 16:10:221527 bool should_generate_frame_sink =
1528 !compositor_never_visible_ && RenderThreadImpl::current();
1529 if (!should_generate_frame_sink)
danakja6c10012018-07-06 14:25:361530 layer_tree_view_->SetNeverVisible();
sievers71c62dd52015-10-07 01:44:391531
pimanc4af3072015-10-02 03:45:591532 StartCompositor();
staraz067f58242016-11-07 21:06:411533 DCHECK_NE(MSG_ROUTING_NONE, routing_id_);
danakja6c10012018-07-06 14:25:361534 layer_tree_view_->SetFrameSinkId(
Fady Samueld5c26182017-07-12 02:43:331535 viz::FrameSinkId(RenderThread::Get()->GetClientId(), routing_id_));
loyso50b51c22017-01-10 07:18:371536
wjmaclean1d970622017-01-21 22:28:241537 RenderThreadImpl* render_thread = RenderThreadImpl::current();
Dave Tapuska9db80842017-07-24 17:24:261538 if (render_thread) {
dtapuska9ec1a912017-04-21 15:18:311539 input_event_queue_ = new MainThreadEventQueue(
Yuta Kitamura3331f5c2018-04-05 11:12:251540 this, render_thread->GetWebMainThreadScheduler()->InputTaskRunner(),
1541 render_thread->GetWebMainThreadScheduler(), should_generate_frame_sink);
wjmaclean1d970622017-01-21 22:28:241542 }
1543
Khushal3e96e662017-10-30 23:16:501544 UpdateURLForCompositorUkm();
1545
danakja6c10012018-07-06 14:25:361546 return layer_tree_view_.get();
[email protected]e195e582013-03-08 01:32:591547}
1548
Chris Harrelsond7ab99b2018-01-24 17:51:361549void RenderWidget::IntrinsicSizingInfoChanged(
1550 const blink::WebIntrinsicSizingInfo& sizing_info) {
1551 Send(new ViewHostMsg_IntrinsicSizingInfoChanged(routing_id_, sizing_info));
1552}
1553
ennef3c58142014-12-09 21:44:381554void RenderWidget::WillCloseLayerTreeView() {
1555 if (host_closing_)
1556 return;
1557
1558 // Prevent new compositors or output surfaces from being created.
1559 host_closing_ = true;
1560
[email protected]aeeedad2014-08-22 18:16:221561 // Always send this notification to prevent new layer tree views from
1562 // being created, even if one hasn't been created yet.
lfg8ff33912016-09-13 20:59:211563 if (blink::WebWidget* widget = GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:541564 widget->WillCloseLayerTreeView();
[email protected]aeeedad2014-08-22 18:16:221565}
1566
Blink Reformat1c4d759e2017-04-09 16:34:541567void RenderWidget::DidMeaningfulLayout(blink::WebMeaningfulLayout layout_type) {
1568 if (layout_type == blink::WebMeaningfulLayout::kVisuallyNonEmpty) {
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491569 QueueMessage(new ViewHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_));
dglazkovf0e1d6d2015-10-10 02:13:481570 }
dglazkov79c426102015-08-31 21:22:431571
ericwilligers88e69742016-10-17 19:29:551572 for (auto& observer : render_frames_)
1573 observer.DidMeaningfulLayout(layout_type);
dglazkov79c426102015-08-31 21:22:431574}
1575
[email protected]586871b2014-07-22 17:05:111576// static
dchengcedca5612016-04-09 01:40:151577std::unique_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
[email protected]586871b2014-07-22 17:05:111578 IPC::Message* msg,
[email protected]586871b2014-07-22 17:05:111579 FrameSwapMessageQueue* frame_swap_message_queue,
1580 scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
[email protected]586871b2014-07-22 17:05:111581 int source_frame_number) {
[email protected]586871b2014-07-22 17:05:111582 bool first_message_for_frame = false;
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491583 frame_swap_message_queue->QueueMessageForFrame(
1584 source_frame_number, base::WrapUnique(msg), &first_message_for_frame);
[email protected]586871b2014-07-22 17:05:111585 if (first_message_for_frame) {
dchengcedca5612016-04-09 01:40:151586 std::unique_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
[email protected]586871b2014-07-22 17:05:111587 sync_message_filter, frame_swap_message_queue, source_frame_number));
dcheng4b6b5ff2014-10-16 00:42:061588 return promise;
[email protected]586871b2014-07-22 17:05:111589 }
dcheng4b6b5ff2014-10-16 00:42:061590 return nullptr;
[email protected]586871b2014-07-22 17:05:111591}
1592
danakj53802692018-07-25 21:46:441593void RenderWidget::SetHandlingInputEvent(bool handling_input_event) {
1594 input_handler_->set_handling_input_event(handling_input_event);
1595}
1596
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491597void RenderWidget::QueueMessage(IPC::Message* msg) {
[email protected]586871b2014-07-22 17:05:111598 // RenderThreadImpl::current() is NULL in some tests.
danakja6c10012018-07-06 14:25:361599 if (!layer_tree_view_ || !RenderThreadImpl::current()) {
[email protected]586871b2014-07-22 17:05:111600 Send(msg);
1601 return;
1602 }
1603
dchengcedca5612016-04-09 01:40:151604 std::unique_ptr<cc::SwapPromise> swap_promise =
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:491605 QueueMessageImpl(msg, frame_swap_message_queue_.get(),
[email protected]586871b2014-07-22 17:05:111606 RenderThreadImpl::current()->sync_message_filter(),
danakja6c10012018-07-06 14:25:361607 layer_tree_view_->GetSourceFrameNumber());
[email protected]586871b2014-07-22 17:05:111608
Ken Buchanance710eb2017-08-30 23:46:521609 if (swap_promise)
danakja6c10012018-07-06 14:25:361610 layer_tree_view_->QueueSwapPromise(std::move(swap_promise));
[email protected]586871b2014-07-22 17:05:111611}
1612
Blink Reformat1c4d759e2017-04-09 16:34:541613void RenderWidget::DidChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301614 // TODO(darin): Eliminate this temporary.
[email protected]9ec87712013-05-24 23:23:521615 WebCursor cursor;
tfarina75a0abf2015-10-06 15:07:181616 InitializeCursorFromWebCursorInfo(&cursor, cursor_info);
initial.commit09911bf2008-07-26 23:55:291617 // Only send a SetCursor message if we need to make a change.
1618 if (!current_cursor_.IsEqual(cursor)) {
1619 current_cursor_ = cursor;
1620 Send(new ViewHostMsg_SetCursor(routing_id_, cursor));
1621 }
1622}
1623
aelias5971e47d2017-06-16 02:39:381624void RenderWidget::AutoscrollStart(const blink::WebFloatPoint& point) {
1625 Send(new ViewHostMsg_AutoscrollStart(routing_id_, point));
1626}
1627
1628void RenderWidget::AutoscrollFling(const blink::WebFloatSize& velocity) {
1629 Send(new ViewHostMsg_AutoscrollFling(routing_id_, velocity));
1630}
1631
1632void RenderWidget::AutoscrollEnd() {
1633 Send(new ViewHostMsg_AutoscrollEnd(routing_id_));
1634}
1635
initial.commit09911bf2008-07-26 23:55:291636// We are supposed to get a single call to Show for a newly created RenderWidget
1637// that was created via RenderWidget::CreateWebView. So, we wait until this
1638// point to dispatch the ShowWidget message.
1639//
1640// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281641// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291642//
Blink Reformat1c4d759e2017-04-09 16:34:541643void RenderWidget::Show(WebNavigationPolicy policy) {
danakja2c9d0a92018-07-25 20:01:181644 if (did_show_) {
1645 if (owner_delegate_) {
1646 // When SupportsMultipleWindows is disabled, popups are reusing
1647 // the same view. In some scenarios, this makes blink to call Show()
1648 // twice. But otherwise, if it is enabled, we should not visit Show() more
1649 // than once.
1650 DCHECK(!owner_delegate_->SupportsMultipleWindowsForWidget());
1651 } else {
1652 DCHECK(!did_show_) << "received extraneous Show call";
1653 }
1654 return;
1655 }
1656
initial.commit09911bf2008-07-26 23:55:291657 DCHECK(routing_id_ != MSG_ROUTING_NONE);
danakjdf1ceb72018-07-18 20:02:251658 DCHECK(show_callback_);
initial.commit09911bf2008-07-26 23:55:291659
[email protected]8de12d942010-11-17 20:42:441660 did_show_ = true;
nickf7b38222016-11-22 21:59:351661
1662 // The opener is responsible for actually showing this widget.
danakjdf1ceb72018-07-18 20:02:251663 std::move(show_callback_).Run(this, policy, initial_rect_);
nickf7b38222016-11-22 21:59:351664
bokanc007c3a2015-02-03 07:15:561665 // NOTE: initial_rect_ may still have its default values at this point, but
[email protected]8de12d942010-11-17 20:42:441666 // that's okay. It'll be ignored if as_popup is false, or the browser
1667 // process will impose a default position otherwise.
bokanc007c3a2015-02-03 07:15:561668 SetPendingWindowRect(initial_rect_);
initial.commit09911bf2008-07-26 23:55:291669}
1670
[email protected]2533ce12009-05-09 00:02:241671void RenderWidget::DoDeferredClose() {
ennef3c58142014-12-09 21:44:381672 WillCloseLayerTreeView();
[email protected]2533ce12009-05-09 00:02:241673 Send(new ViewHostMsg_Close(routing_id_));
1674}
1675
dgozmancf9039cd2015-04-06 12:01:311676void RenderWidget::NotifyOnClose() {
ericwilligers88e69742016-10-17 19:29:551677 for (auto& observer : render_frames_)
1678 observer.WidgetWillClose();
dgozmancf9039cd2015-04-06 12:01:311679}
1680
Blink Reformat1c4d759e2017-04-09 16:34:541681void RenderWidget::CloseWidgetSoon() {
skyostiled8969c2015-07-20 16:57:081682 DCHECK(content::RenderThread::Get());
[email protected]e1c3a552012-05-04 20:51:321683 if (is_swapped_out_) {
1684 // This widget is currently swapped out, and the active widget is in a
1685 // different process. Have the browser route the close request to the
1686 // active widget instead, so that the correct unload handlers are run.
1687 Send(new ViewHostMsg_RouteCloseEvent(routing_id_));
1688 return;
1689 }
1690
initial.commit09911bf2008-07-26 23:55:291691 // If a page calls window.close() twice, we'll end up here twice, but that's
1692 // OK. It is safe to send multiple Close messages.
1693
[email protected]2533ce12009-05-09 00:02:241694 // Ask the RenderWidgetHost to initiate close. We could be called from deep
1695 // in Javascript. If we ask the RendwerWidgetHost to close now, the window
1696 // could be closed before the JS finishes executing. So instead, post a
1697 // message back to the message loop, which won't run until the JS is
1698 // complete, and then the Close message can be sent.
Hajime Hoshiabb3c8f2017-12-04 18:41:391699 task_runner_->PostTask(FROM_HERE,
1700 base::BindOnce(&RenderWidget::DoDeferredClose, this));
initial.commit09911bf2008-07-26 23:55:291701}
1702
1703void RenderWidget::Close() {
[email protected]404630b2014-07-03 19:33:031704 screen_metrics_emulator_.reset();
Ken Buchananed449bb2018-02-01 21:02:051705 CloseWebWidget();
danakja6c10012018-07-06 14:25:361706 layer_tree_view_.reset();
danakja2c9d0a92018-07-25 20:01:181707 if (owner_delegate_)
1708 owner_delegate_->DidCloseWidget();
Ken Buchananed449bb2018-02-01 21:02:051709}
1710
1711void RenderWidget::CloseWebWidget() {
1712 WillCloseLayerTreeView();
lfg8ff33912016-09-13 20:59:211713 if (webwidget_internal_) {
Blink Reformat1c4d759e2017-04-09 16:34:541714 webwidget_internal_->Close();
lfg8ff33912016-09-13 20:59:211715 webwidget_internal_ = nullptr;
initial.commit09911bf2008-07-26 23:55:291716 }
1717}
1718
Mitsuru Oshima3c07b332018-02-06 04:56:501719void RenderWidget::UpdateWebViewWithDeviceScaleFactor() {
1720 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1721 blink::WebFrame* current_frame =
1722 frame_widget ? frame_widget->LocalRoot() : nullptr;
1723 blink::WebView* webview = current_frame ? current_frame->View() : nullptr;
1724 if (webview) {
danakj4b347212018-07-04 17:55:171725 if (compositor_deps_->IsUseZoomForDSFEnabled())
Fady Samuela863f152018-03-09 16:10:031726 webview->SetZoomFactorForDeviceScaleFactor(
1727 GetWebScreenInfo().device_scale_factor);
Mitsuru Oshima3c07b332018-02-06 04:56:501728 else
Fady Samuela863f152018-03-09 16:10:031729 webview->SetDeviceScaleFactor(GetWebScreenInfo().device_scale_factor);
Mitsuru Oshima3c07b332018-02-06 04:56:501730
1731 webview->GetSettings()->SetPreferCompositingToLCDTextEnabled(
Christopher Camerone9a30c12018-03-07 08:23:381732 PreferCompositingToLCDText(compositor_deps_,
Fady Samuela863f152018-03-09 16:10:031733 GetWebScreenInfo().device_scale_factor));
Mitsuru Oshima3c07b332018-02-06 04:56:501734 }
1735}
1736
Ehsan Karamad655d7b8a2018-01-12 18:38:381737blink::WebFrameWidget* RenderWidget::GetFrameWidget() const {
1738 blink::WebWidget* web_widget = GetWebWidget();
1739 if (!web_widget)
1740 return nullptr;
1741
1742 if (!web_widget->IsWebFrameWidget()) {
1743 // TODO(ekaramad): This should not happen. If we have a WebWidget and we
1744 // need a WebFrameWidget then we should be getting a WebFrameWidget. But
1745 // unfortunately this does not seem to be the case in some scenarios --
1746 // specifically when a RenderViewImpl swaps out during navigation the
1747 // WebViewImpl loses its WebViewFrameWidget but sometimes we receive IPCs
1748 // which are destined for WebFrameWidget (https://crbug.com/669219).
1749 return nullptr;
1750 }
1751
1752 return static_cast<blink::WebFrameWidget*>(web_widget);
1753}
1754
bokan841fdc72016-10-06 00:16:351755void RenderWidget::ScreenRectToEmulatedIfNeeded(WebRect* window_rect) const {
1756 DCHECK(window_rect);
1757 float scale = popup_origin_scale_for_emulation_;
1758 if (!scale)
1759 return;
1760 window_rect->x =
1761 popup_view_origin_for_emulation_.x() +
1762 (window_rect->x - popup_screen_origin_for_emulation_.x()) / scale;
1763 window_rect->y =
1764 popup_view_origin_for_emulation_.y() +
1765 (window_rect->y - popup_screen_origin_for_emulation_.y()) / scale;
1766}
1767
1768void RenderWidget::EmulatedToScreenRectIfNeeded(WebRect* window_rect) const {
1769 DCHECK(window_rect);
1770 float scale = popup_origin_scale_for_emulation_;
1771 if (!scale)
1772 return;
1773 window_rect->x =
1774 popup_screen_origin_for_emulation_.x() +
1775 (window_rect->x - popup_view_origin_for_emulation_.x()) * scale;
1776 window_rect->y =
1777 popup_screen_origin_for_emulation_.y() +
1778 (window_rect->y - popup_view_origin_for_emulation_.y()) * scale;
1779}
1780
Blink Reformat1c4d759e2017-04-09 16:34:541781WebRect RenderWidget::WindowRect() {
bokan841fdc72016-10-06 00:16:351782 WebRect rect;
bokan6b08cd22016-10-05 00:55:211783 if (pending_window_rect_count_) {
1784 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
1785 // the RootWindowRect is probably going to return wrong results since the
1786 // browser may not have processed the Move yet. There isn't really anything
1787 // good to do in this case, and it shouldn't happen - since this size is
1788 // only really needed for windowToScreen, which is only used for Popups.
bokan841fdc72016-10-06 00:16:351789 rect = pending_window_rect_;
1790 } else {
1791 rect = window_screen_rect_;
bokan6b08cd22016-10-05 00:55:211792 }
[email protected]2533ce12009-05-09 00:02:241793
bokan841fdc72016-10-06 00:16:351794 ScreenRectToEmulatedIfNeeded(&rect);
1795 return rect;
bokan6b08cd22016-10-05 00:55:211796}
1797
Blink Reformat1c4d759e2017-04-09 16:34:541798WebRect RenderWidget::ViewRect() {
bokan841fdc72016-10-06 00:16:351799 WebRect rect = view_screen_rect_;
1800 ScreenRectToEmulatedIfNeeded(&rect);
1801 return rect;
initial.commit09911bf2008-07-26 23:55:291802}
1803
Blink Reformat1c4d759e2017-04-09 16:34:541804void RenderWidget::SetToolTipText(const blink::WebString& text,
[email protected]8a9d6ca32011-06-06 20:11:301805 WebTextDirection hint) {
Blink Reformat1c4d759e2017-04-09 16:34:541806 Send(new ViewHostMsg_SetTooltipText(routing_id_, text.Utf16(), hint));
[email protected]8a9d6ca32011-06-06 20:11:301807}
1808
Blink Reformat1c4d759e2017-04-09 16:34:541809void RenderWidget::SetWindowRect(const WebRect& rect_in_screen) {
oshima33ec97cd2015-12-14 19:40:241810 WebRect window_rect = rect_in_screen;
bokan841fdc72016-10-06 00:16:351811 EmulatedToScreenRectIfNeeded(&window_rect);
[email protected]b2e4c70132013-10-03 02:07:511812
[email protected]5b45ad42013-10-25 00:42:041813 if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]ec951b9d2013-10-20 06:21:201814 if (did_show_) {
Avi Drissman014dec72018-06-07 02:34:011815 Send(new ViewHostMsg_RequestSetBounds(routing_id_, window_rect));
bokanc007c3a2015-02-03 07:15:561816 SetPendingWindowRect(window_rect);
[email protected]8be1c582013-03-06 00:55:031817 } else {
bokanc007c3a2015-02-03 07:15:561818 initial_rect_ = window_rect;
[email protected]8be1c582013-03-06 00:55:031819 }
initial.commit09911bf2008-07-26 23:55:291820 } else {
bokanc007c3a2015-02-03 07:15:561821 SetWindowRectSynchronously(window_rect);
initial.commit09911bf2008-07-26 23:55:291822 }
1823}
1824
[email protected]2533ce12009-05-09 00:02:241825void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
1826 pending_window_rect_ = rect;
1827 pending_window_rect_count_++;
[email protected]2533ce12009-05-09 00:02:241828
bokan6b08cd22016-10-05 00:55:211829 // Popups don't get size updates back from the browser so just store the set
1830 // values.
Blink Reformat1c4d759e2017-04-09 16:34:541831 if (popup_type_ != blink::kWebPopupTypeNone) {
1832 window_screen_rect_ = rect;
1833 view_screen_rect_ = rect;
[email protected]2533ce12009-05-09 00:02:241834 }
[email protected]d4547452008-08-28 18:36:371835}
1836
wjmacleanee244e02017-05-26 21:06:071837void RenderWidget::OnShowContextMenu(ui::MenuSourceType source_type,
1838 const gfx::Point& location) {
wjmacleanee244e02017-05-26 21:06:071839 has_host_context_menu_location_ = true;
1840 host_context_menu_location_ = location;
1841 if (GetWebWidget()) {
1842 GetWebWidget()->ShowContextMenu(
1843 static_cast<blink::WebMenuSourceType>(source_type));
1844 }
1845 has_host_context_menu_location_ = false;
1846}
1847
[email protected]fa7b1dc2010-06-23 17:53:041848void RenderWidget::OnImeSetComposition(
[email protected]fcf75d42013-12-03 20:11:261849 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:111850 const std::vector<WebImeTextSpan>& ime_text_spans,
chongz7eb752802016-01-27 21:28:071851 const gfx::Range& replacement_range,
Ryan Landay9e42fd742017-08-12 01:59:111852 int selection_start,
1853 int selection_end) {
ekaramad5aff1942017-01-06 01:26:351854 if (!ShouldHandleImeEvents())
1855 return;
1856
brettw4b461082016-11-19 18:55:161857#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:491858 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
Ryan Landay9e42fd742017-08-12 01:59:111859 plugin->render_frame()->OnImeSetComposition(text, ime_text_spans,
EhsanK22d482e2017-08-10 17:29:491860 selection_start, selection_end);
ekaramad2a46d632016-07-19 13:33:091861 return;
1862 }
1863#endif
[email protected]66fca5bc2013-05-23 06:58:291864 ImeEventGuard guard(this);
ekaramad2daaf672016-11-10 20:29:011865 blink::WebInputMethodController* controller = GetInputMethodController();
ekaramad2daaf672016-11-10 20:29:011866 if (!controller ||
Blink Reformat1c4d759e2017-04-09 16:34:541867 !controller->SetComposition(
Ryan Landay9e42fd742017-08-12 01:59:111868 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:561869 replacement_range.IsValid()
1870 ? WebRange(replacement_range.start(), replacement_range.length())
1871 : WebRange(),
1872 selection_start, selection_end)) {
[email protected]fa7b1dc2010-06-23 17:53:041873 // If we failed to set the composition text, then we need to let the browser
1874 // process to cancel the input method's ongoing composition session, to make
1875 // sure we are in a consistent state.
Dave Tapuska04bc5ee92018-04-17 19:03:311876 if (mojom::WidgetInputHandlerHost* host =
1877 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
1878 host->ImeCancelComposition();
Dave Tapuska139a72f2017-09-06 21:57:031879 }
[email protected]7f00efa2010-04-15 05:01:261880 }
nonafa291792016-08-10 02:36:181881 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]fa7b1dc2010-06-23 17:53:041882}
1883
rlanday7efe2302017-01-11 00:14:281884void RenderWidget::OnImeCommitText(
1885 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:111886 const std::vector<WebImeTextSpan>& ime_text_spans,
rlanday7efe2302017-01-11 00:14:281887 const gfx::Range& replacement_range,
1888 int relative_cursor_pos) {
ekaramad5aff1942017-01-06 01:26:351889 if (!ShouldHandleImeEvents())
1890 return;
1891
brettw4b461082016-11-19 18:55:161892#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:491893 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
1894 plugin->render_frame()->OnImeCommitText(text, replacement_range,
1895 relative_cursor_pos);
ekaramad2a46d632016-07-19 13:33:091896 return;
1897 }
1898#endif
[email protected]66fca5bc2013-05-23 06:58:291899 ImeEventGuard guard(this);
fsamuele8326c742016-01-12 00:49:391900 input_handler_->set_handling_input_event(true);
ekaramadb6483a052017-02-10 02:23:261901 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:541902 controller->CommitText(
Ryan Landay9e42fd742017-08-12 01:59:111903 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:561904 replacement_range.IsValid()
1905 ? WebRange(replacement_range.start(), replacement_range.length())
1906 : WebRange(),
1907 relative_cursor_pos);
ekaramadb6483a052017-02-10 02:23:261908 }
aelias87b8f7c2016-09-14 03:19:291909 input_handler_->set_handling_input_event(false);
1910 UpdateCompositionInfo(false /* not an immediate request */);
1911}
1912
1913void RenderWidget::OnImeFinishComposingText(bool keep_selection) {
ekaramad5aff1942017-01-06 01:26:351914 if (!ShouldHandleImeEvents())
1915 return;
1916
brettw4b461082016-11-19 18:55:161917#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:491918 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
1919 plugin->render_frame()->OnImeFinishComposingText(keep_selection);
aelias87b8f7c2016-09-14 03:19:291920 return;
1921 }
1922#endif
1923
changwan38c3eb612016-12-09 01:45:561924 if (!GetWebWidget())
aelias87b8f7c2016-09-14 03:19:291925 return;
1926 ImeEventGuard guard(this);
1927 input_handler_->set_handling_input_event(true);
ekaramad2daaf672016-11-10 20:29:011928 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:541929 controller->FinishComposingText(
1930 keep_selection ? WebInputMethodController::kKeepSelection
1931 : WebInputMethodController::kDoNotKeepSelection);
ekaramad2daaf672016-11-10 20:29:011932 }
fsamuele8326c742016-01-12 00:49:391933 input_handler_->set_handling_input_event(false);
nonafa291792016-08-10 02:36:181934 UpdateCompositionInfo(false /* not an immediate request */);
initial.commit09911bf2008-07-26 23:55:291935}
1936
Christopher Camerone9a30c12018-03-07 08:23:381937void RenderWidget::UpdateSurfaceAndScreenInfo(
Fady Samuel4392abb2018-05-10 21:01:211938 const viz::LocalSurfaceId& new_local_surface_id,
Christopher Cameronaad15a0d2018-03-09 03:47:331939 const gfx::Size& new_compositor_viewport_pixel_size,
Christopher Camerone9a30c12018-03-07 08:23:381940 const ScreenInfo& new_screen_info) {
Christopher Camerone9a30c12018-03-07 08:23:381941 bool orientation_changed =
1942 screen_info_.orientation_angle != new_screen_info.orientation_angle ||
1943 screen_info_.orientation_type != new_screen_info.orientation_type;
1944 bool web_device_scale_factor_changed =
1945 screen_info_.device_scale_factor != new_screen_info.device_scale_factor;
Fady Samuela863f152018-03-09 16:10:031946 ScreenInfo previous_original_screen_info = GetOriginalScreenInfo();
Christopher Cameronbe7ecea2018-02-27 00:47:191947
Fady Samuel4255c182018-05-24 20:42:361948 local_surface_id_from_parent_ = new_local_surface_id;
Christopher Cameronaad15a0d2018-03-09 03:47:331949 compositor_viewport_pixel_size_ = new_compositor_viewport_pixel_size;
Christopher Camerone9a30c12018-03-07 08:23:381950 screen_info_ = new_screen_info;
Christopher Cameronbe7ecea2018-02-27 00:47:191951
danakja6c10012018-07-06 14:25:361952 if (layer_tree_view_) {
1953 layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect());
Christopher Camerone9a30c12018-03-07 08:23:381954 // Note carefully that the DSF specified in |new_screen_info| is not the
1955 // DSF used by the compositor during device emulation!
danakja6c10012018-07-06 14:25:361956 layer_tree_view_->SetViewportSizeAndScale(
Fady Samuela863f152018-03-09 16:10:031957 compositor_viewport_pixel_size_,
Fady Samuel4255c182018-05-24 20:42:361958 GetOriginalScreenInfo().device_scale_factor,
1959 local_surface_id_from_parent_);
Christopher Camerone9a30c12018-03-07 08:23:381960 }
Christopher Cameronbe7ecea2018-02-27 00:47:191961
Christopher Camerone9a30c12018-03-07 08:23:381962 if (orientation_changed)
1963 OnOrientationChange();
Christopher Cameronbe7ecea2018-02-27 00:47:191964
Fady Samuela863f152018-03-09 16:10:031965 if (previous_original_screen_info != GetOriginalScreenInfo()) {
Christopher Camerone9a30c12018-03-07 08:23:381966 for (auto& observer : render_frame_proxies_)
Fady Samuela863f152018-03-09 16:10:031967 observer.OnScreenInfoChanged(GetOriginalScreenInfo());
Christopher Camerone9a30c12018-03-07 08:23:381968
1969 // Notify all embedded BrowserPlugins of the updated ScreenInfo.
1970 for (auto& observer : browser_plugins_)
Fady Samuela863f152018-03-09 16:10:031971 observer.ScreenInfoChanged(GetOriginalScreenInfo());
Christopher Camerone9a30c12018-03-07 08:23:381972 }
1973
1974 if (web_device_scale_factor_changed)
Christopher Cameronbe7ecea2018-02-27 00:47:191975 UpdateWebViewWithDeviceScaleFactor();
oshimad5279032015-12-16 18:22:331976}
1977
danakja2c9d0a92018-07-25 20:01:181978void RenderWidget::SetWindowRectSynchronously(
1979 const gfx::Rect& new_window_rect) {
1980 VisualProperties visual_properties;
1981 visual_properties.screen_info = screen_info_;
1982 visual_properties.new_size = new_window_rect.size();
1983 visual_properties.compositor_viewport_pixel_size = gfx::ScaleToCeiledSize(
1984 new_window_rect.size(), GetWebScreenInfo().device_scale_factor);
1985 visual_properties.visible_viewport_size = new_window_rect.size();
1986 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
1987 visual_properties.display_mode = display_mode_;
1988 visual_properties.local_surface_id = local_surface_id_from_parent_;
1989 // We are resizing the window from the renderer, so allocate a new
1990 // viz::LocalSurfaceId to avoid surface invariants violations in tests.
1991 if (layer_tree_view_)
1992 layer_tree_view_->RequestNewLocalSurfaceId();
1993 SynchronizeVisualProperties(visual_properties);
1994
1995 view_screen_rect_ = new_window_rect;
1996 window_screen_rect_ = new_window_rect;
1997 if (!did_show_)
1998 initial_rect_ = new_window_rect;
1999}
2000
Vladimir Levin98d76dad2018-04-21 00:21:292001void RenderWidget::UpdateCaptureSequenceNumber(
2002 uint32_t capture_sequence_number) {
2003 if (capture_sequence_number == last_capture_sequence_number_)
2004 return;
2005 last_capture_sequence_number_ = capture_sequence_number;
2006
2007 // Notify observers of the new capture sequence number.
2008 for (auto& observer : render_frame_proxies_)
2009 observer.UpdateCaptureSequenceNumber(capture_sequence_number);
2010 for (auto& observer : browser_plugins_)
2011 observer.UpdateCaptureSequenceNumber(capture_sequence_number);
2012}
2013
[email protected]4873c7d2009-07-16 06:36:282014void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
EhsanK955ba582017-11-30 21:14:402015 if (auto* frame = GetFocusedWebLocalFrameInWidget())
2016 frame->SetTextDirection(direction);
[email protected]07f953332009-03-25 04:31:112017}
2018
[email protected]80ad8622012-11-07 16:33:032019void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
2020 const gfx::Rect& window_screen_rect) {
[email protected]b2e4c70132013-10-03 02:07:512021 if (screen_metrics_emulator_) {
mfomitchev2600fd7c2016-02-17 20:53:392022 screen_metrics_emulator_->OnUpdateScreenRects(view_screen_rect,
2023 window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:512024 } else {
mfomitchev2600fd7c2016-02-17 20:53:392025 SetScreenRects(view_screen_rect, window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:512026 }
[email protected]80ad8622012-11-07 16:33:032027 Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
2028}
2029
kenrbea731792017-01-13 15:10:482030void RenderWidget::OnSetViewportIntersection(
Ken Buchananb2c9e262018-03-10 16:53:312031 const gfx::Rect& viewport_intersection,
2032 const gfx::Rect& compositor_visible_rect) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252033 if (auto* frame_widget = GetFrameWidget()) {
Ken Buchanan8a319fb2017-11-15 18:37:122034 DCHECK_EQ(popup_type_, WebPopupType::kWebPopupTypeNone);
Ken Buchananb2c9e262018-03-10 16:53:312035 compositor_visible_rect_ = compositor_visible_rect;
Ehsan Karamadf3ca2a82018-01-20 01:05:252036 frame_widget->SetRemoteViewportIntersection(viewport_intersection);
danakja6c10012018-07-06 14:25:362037 layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect());
kenrbea731792017-01-13 15:10:482038 }
2039}
2040
kenrb04323782017-06-23 01:23:322041void RenderWidget::OnSetIsInert(bool inert) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252042 if (auto* frame_widget = GetFrameWidget()) {
Ken Buchanan8a319fb2017-11-15 18:37:122043 DCHECK_EQ(popup_type_, WebPopupType::kWebPopupTypeNone);
Ehsan Karamadf3ca2a82018-01-20 01:05:252044 frame_widget->SetIsInert(inert);
kenrb04323782017-06-23 01:23:322045 }
2046}
2047
sunxd540a9962018-05-24 22:51:062048void RenderWidget::OnSetInheritedEffectiveTouchAction(
2049 cc::TouchAction touch_action) {
2050 if (auto* frame_widget = GetFrameWidget()) {
2051 DCHECK_EQ(popup_type_, WebPopupType::kWebPopupTypeNone);
2052 frame_widget->SetInheritedEffectiveTouchAction(touch_action);
2053 }
2054}
2055
Ken Buchanan8a319fb2017-11-15 18:37:122056void RenderWidget::OnUpdateRenderThrottlingStatus(bool is_throttled,
2057 bool subtree_throttled) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252058 if (auto* frame_widget = GetFrameWidget()) {
Ken Buchanan8a319fb2017-11-15 18:37:122059 DCHECK_EQ(popup_type_, WebPopupType::kWebPopupTypeNone);
Ehsan Karamadf3ca2a82018-01-20 01:05:252060 frame_widget->UpdateRenderThrottlingStatus(is_throttled, subtree_throttled);
Ken Buchanan8a319fb2017-11-15 18:37:122061 }
2062}
2063
paulmeyer90f6c31d2016-11-12 00:17:592064void RenderWidget::OnDragTargetDragEnter(
2065 const std::vector<DropData::Metadata>& drop_meta_data,
Ella Ge80a52dce2017-11-15 18:01:522066 const gfx::PointF& client_point,
2067 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592068 WebDragOperationsMask ops,
2069 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252070 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2071 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592072 return;
2073
Ehsan Karamadf3ca2a82018-01-20 01:05:252074 WebDragOperation operation = frame_widget->DragTargetDragEnter(
2075 DropMetaDataToWebDragData(drop_meta_data), client_point, screen_point,
2076 ops, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592077
2078 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
2079}
2080
Ella Ge80a52dce2017-11-15 18:01:522081void RenderWidget::OnDragTargetDragOver(const gfx::PointF& client_point,
2082 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592083 WebDragOperationsMask ops,
2084 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252085 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2086 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592087 return;
2088
Ehsan Karamadf3ca2a82018-01-20 01:05:252089 WebDragOperation operation = frame_widget->DragTargetDragOver(
2090 ConvertWindowPointToViewport(client_point), screen_point, ops,
2091 key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592092
2093 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
2094}
2095
Ella Ge80a52dce2017-11-15 18:01:522096void RenderWidget::OnDragTargetDragLeave(const gfx::PointF& client_point,
2097 const gfx::PointF& screen_point) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252098 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2099 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592100 return;
Ehsan Karamadf3ca2a82018-01-20 01:05:252101
2102 frame_widget
2103
Blink Reformat1c4d759e2017-04-09 16:34:542104 ->DragTargetDragLeave(ConvertWindowPointToViewport(client_point),
kenrb07c272802017-02-07 23:48:172105 screen_point);
paulmeyer90f6c31d2016-11-12 00:17:592106}
2107
2108void RenderWidget::OnDragTargetDrop(const DropData& drop_data,
Ella Ge80a52dce2017-11-15 18:01:522109 const gfx::PointF& client_point,
2110 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:592111 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252112 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2113 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:592114 return;
2115
Ehsan Karamadf3ca2a82018-01-20 01:05:252116 frame_widget->DragTargetDrop(DropDataToWebDragData(drop_data),
2117 ConvertWindowPointToViewport(client_point),
2118 screen_point, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:592119}
2120
Ella Ge80a52dce2017-11-15 18:01:522121void RenderWidget::OnDragSourceEnded(const gfx::PointF& client_point,
2122 const gfx::PointF& screen_point,
paulmeyer8fc8ea92016-11-15 05:12:212123 WebDragOperation op) {
Ehsan Karamadf3ca2a82018-01-20 01:05:252124 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2125 if (!frame_widget)
paulmeyer8fc8ea92016-11-15 05:12:212126 return;
2127
Ehsan Karamadf3ca2a82018-01-20 01:05:252128 frame_widget->DragSourceEndedAt(ConvertWindowPointToViewport(client_point),
2129 screen_point, op);
paulmeyer8fc8ea92016-11-15 05:12:212130}
2131
2132void RenderWidget::OnDragSourceSystemDragEnded() {
2133 if (!GetWebWidget())
2134 return;
2135
Blink Reformat1c4d759e2017-04-09 16:34:542136 static_cast<WebFrameWidget*>(GetWebWidget())->DragSourceSystemDragEnded();
paulmeyer8fc8ea92016-11-15 05:12:212137}
2138
Blink Reformat1c4d759e2017-04-09 16:34:542139void RenderWidget::ShowVirtualKeyboardOnElementFocus() {
okaa398f50b2017-03-21 06:30:262140#if defined(OS_CHROMEOS)
2141 // On ChromeOS, virtual keyboard is triggered only when users leave the
2142 // mouse button or the finger and a text input element is focused at that
2143 // time. Focus event itself shouldn't trigger virtual keyboard.
2144 UpdateTextInputState();
2145#else
changwan75e3b2072017-01-16 02:55:002146 ShowVirtualKeyboard();
okaa398f50b2017-03-21 06:30:262147#endif
boliu7b2be2f2016-11-04 04:58:312148
2149// TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
2150// virtual keyboard.
2151#if !defined(OS_ANDROID)
2152 FocusChangeComplete();
2153#endif
[email protected]0d1ebed12013-08-05 22:01:132154}
2155
fsamuel72464894f2015-12-15 06:59:312156ui::TextInputType RenderWidget::GetTextInputType() {
brettw4b461082016-11-19 18:55:162157#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492158 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2159 return plugin->text_input_type();
ekaramad2a46d632016-07-19 13:33:092160#endif
ekaramad5aff1942017-01-06 01:26:352161 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:542162 return ConvertWebTextInputType(controller->TextInputType());
fsamuel72464894f2015-12-15 06:59:312163 return ui::TEXT_INPUT_TYPE_NONE;
2164}
2165
nonafa291792016-08-10 02:36:182166void RenderWidget::UpdateCompositionInfo(bool immediate_request) {
2167 if (!monitor_composition_info_ && !immediate_request)
2168 return; // Do not calculate composition info if not requested.
nonadac0c7a2016-08-01 02:30:592169
nonafa291792016-08-10 02:36:182170 TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo");
2171 gfx::Range range;
2172 std::vector<gfx::Rect> character_bounds;
2173
2174 if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE) {
2175 // Composition information is only available on editable node.
2176 range = gfx::Range::InvalidRange();
2177 } else {
2178 GetCompositionRange(&range);
2179 GetCompositionCharacterBounds(&character_bounds);
2180 }
2181
2182 if (!immediate_request &&
2183 !ShouldUpdateCompositionInfo(range, character_bounds)) {
fsamuel72464894f2015-12-15 06:59:312184 return;
nonafa291792016-08-10 02:36:182185 }
fsamuel72464894f2015-12-15 06:59:312186 composition_character_bounds_ = character_bounds;
2187 composition_range_ = range;
Dave Tapuska04bc5ee92018-04-17 19:03:312188 if (mojom::WidgetInputHandlerHost* host =
2189 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
2190 host->ImeCompositionRangeChanged(composition_range_,
2191 composition_character_bounds_);
Dave Tapuska139a72f2017-09-06 21:57:032192 }
fsamuel72464894f2015-12-15 06:59:312193}
2194
Blink Reformat1c4d759e2017-04-09 16:34:542195void RenderWidget::ConvertViewportToWindow(blink::WebRect* rect) {
danakj4b347212018-07-04 17:55:172196 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:032197 float reverse = 1 / GetOriginalScreenInfo().device_scale_factor;
oshimad5279032015-12-16 18:22:332198 // TODO(oshima): We may need to allow pixel precision here as the the
oshimaf866dab2015-12-05 00:41:542199 // anchor element can be placed at half pixel.
lfg15b235a32016-08-25 17:45:462200 gfx::Rect window_rect =
2201 gfx::ScaleToEnclosedRect(gfx::Rect(*rect), reverse);
2202 rect->x = window_rect.x();
2203 rect->y = window_rect.y();
2204 rect->width = window_rect.width();
2205 rect->height = window_rect.height();
oshimaf866dab2015-12-05 00:41:542206 }
2207}
2208
Blink Reformat1c4d759e2017-04-09 16:34:542209void RenderWidget::ConvertWindowToViewport(blink::WebFloatRect* rect) {
danakj4b347212018-07-04 17:55:172210 if (compositor_deps_->IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:032211 rect->x *= GetOriginalScreenInfo().device_scale_factor;
2212 rect->y *= GetOriginalScreenInfo().device_scale_factor;
2213 rect->width *= GetOriginalScreenInfo().device_scale_factor;
2214 rect->height *= GetOriginalScreenInfo().device_scale_factor;
oshimaa6985b62016-01-27 08:58:302215 }
2216}
2217
changwan8c342742016-02-26 00:53:392218void RenderWidget::OnRequestTextInputStateUpdate() {
Dave Tapuska9db80842017-07-24 17:24:262219#if defined(OS_ANDROID)
changwan8c342742016-02-26 00:53:392220 DCHECK(!ime_event_guard_);
2221 UpdateSelectionBounds();
changwan75e3b2072017-01-16 02:55:002222 UpdateTextInputStateInternal(false, true /* reply_to_request */);
[email protected]105dffb42013-02-20 03:46:212223#endif
Dave Tapuska9db80842017-07-24 17:24:262224}
[email protected]105dffb42013-02-20 03:46:212225
ekaramadc9b70a72017-03-23 16:14:232226void RenderWidget::OnRequestCompositionUpdates(bool immediate_request,
2227 bool monitor_updates) {
2228 monitor_composition_info_ = monitor_updates;
nonafa291792016-08-10 02:36:182229 if (!immediate_request)
2230 return;
2231 UpdateCompositionInfo(true /* immediate request */);
2232}
2233
[email protected]fcdc5642014-05-09 14:32:242234void RenderWidget::OnOrientationChange() {
Ehsan Karamad655d7b8a2018-01-12 18:38:382235 if (auto* frame_widget = GetFrameWidget()) {
Alex Moshchuk0b409c42017-09-13 02:09:002236 // LocalRoot() might return null for provisional main frames. In this case,
2237 // the frame hasn't committed a navigation and is not swapped into the tree
2238 // yet, so it doesn't make sense to send orientation change events to it.
2239 //
2240 // TODO(https://crbug.com/578349): This check should be cleaned up
2241 // once provisional frames are gone.
Ehsan Karamad655d7b8a2018-01-12 18:38:382242 if (frame_widget->LocalRoot())
2243 frame_widget->LocalRoot()->SendOrientationChangeEvent();
lfg8d649cc2017-04-28 18:04:302244 }
[email protected]fcdc5642014-05-09 14:32:242245}
2246
danakja2c9d0a92018-07-25 20:01:182247GURL RenderWidget::GetURLForGraphicsContext3D() {
2248 if (owner_delegate_)
2249 return owner_delegate_->GetURLForGraphicsContext3DForWidget();
2250 return GURL();
2251}
2252
[email protected]bee16aab2009-08-26 15:55:032253void RenderWidget::SetHidden(bool hidden) {
2254 if (is_hidden_ == hidden)
2255 return;
2256
jdduke8fac9d102014-12-20 02:40:132257 // The status has changed. Tell the RenderThread about it and ensure
2258 // throttled acks are released in case frame production ceases.
[email protected]bee16aab2009-08-26 15:55:032259 is_hidden_ = hidden;
jdduke8fac9d102014-12-20 02:40:132260
Scott Violet1098538e2017-10-05 19:23:332261#if defined(USE_AURA)
Scott Violet6fca1312018-06-15 16:27:262262 if (!features::IsAshInBrowserProcess())
Scott Violet1098538e2017-10-05 19:23:332263 RendererWindowTreeClient::Get(routing_id_)->SetVisible(!hidden);
2264#endif
2265
Saman Sami58ed4392018-01-31 20:54:192266 // RenderThreadImpl::current() could be null in tests.
2267 if (RenderThreadImpl::current()) {
2268 if (is_hidden_) {
2269 RenderThreadImpl::current()->WidgetHidden();
2270 first_update_visual_state_after_hidden_ = true;
2271 } else {
2272 RenderThreadImpl::current()->WidgetRestored();
2273 }
Lei Zhang9b359d32017-11-28 00:57:022274 }
alexclarke7fa93942015-10-21 15:37:112275
2276 if (render_widget_scheduling_state_)
2277 render_widget_scheduling_state_->SetHidden(hidden);
[email protected]bee16aab2009-08-26 15:55:032278}
2279
[email protected]2b624c562011-10-27 22:58:262280void RenderWidget::DidToggleFullscreen() {
lfg8ff33912016-09-13 20:59:212281 if (!GetWebWidget())
[email protected]2b624c562011-10-27 22:58:262282 return;
2283
mikhail.pozdnyakovf2c902a2015-04-14 08:09:122284 if (is_fullscreen_granted_) {
Blink Reformat1c4d759e2017-04-09 16:34:542285 GetWebWidget()->DidEnterFullscreen();
[email protected]2b624c562011-10-27 22:58:262286 } else {
Blink Reformat1c4d759e2017-04-09 16:34:542287 GetWebWidget()->DidExitFullscreen();
[email protected]2b624c562011-10-27 22:58:262288 }
[email protected]2b624c562011-10-27 22:58:262289}
2290
changwanf2a707b2015-10-30 08:22:162291void RenderWidget::OnImeEventGuardStart(ImeEventGuard* guard) {
2292 if (!ime_event_guard_)
2293 ime_event_guard_ = guard;
[email protected]66fca5bc2013-05-23 06:58:292294}
2295
changwanf2a707b2015-10-30 08:22:162296void RenderWidget::OnImeEventGuardFinish(ImeEventGuard* guard) {
2297 if (ime_event_guard_ != guard) {
changwan75e3b2072017-01-16 02:55:002298 DCHECK(!ime_event_guard_->reply_to_request());
changwanf2a707b2015-10-30 08:22:162299 return;
2300 }
2301 ime_event_guard_ = nullptr;
2302
[email protected]66fca5bc2013-05-23 06:58:292303 // While handling an ime event, text input state and selection bounds updates
2304 // are ignored. These must explicitly be updated once finished handling the
2305 // ime event.
2306 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:472307#if defined(OS_ANDROID)
changwan75e3b2072017-01-16 02:55:002308 if (guard->show_virtual_keyboard())
2309 ShowVirtualKeyboard();
2310 else
2311 UpdateTextInputState();
[email protected]cb9e2632013-06-18 11:26:472312#endif
[email protected]66fca5bc2013-05-23 06:58:292313}
2314
[email protected]7c8873e2013-02-05 08:03:012315void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
brettw4b461082016-11-19 18:55:162316#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492317 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
ekaramad2a46d632016-07-19 13:33:092318 // TODO(kinaba) http://crbug.com/101101
2319 // Current Pepper IME API does not handle selection bounds. So we simply
2320 // use the caret position as an empty range for now. It will be updated
2321 // after Pepper API equips features related to surrounding text retrieval.
EhsanK22d482e2017-08-10 17:29:492322 blink::WebRect caret(plugin->GetCaretBounds());
Blink Reformat1c4d759e2017-04-09 16:34:542323 ConvertViewportToWindow(&caret);
ekaramad2a46d632016-07-19 13:33:092324 *focus = caret;
2325 *anchor = caret;
2326 return;
2327 }
2328#endif
[email protected]7c8873e2013-02-05 08:03:012329 WebRect focus_webrect;
2330 WebRect anchor_webrect;
Blink Reformat1c4d759e2017-04-09 16:34:542331 GetWebWidget()->SelectionBounds(focus_webrect, anchor_webrect);
2332 ConvertViewportToWindow(&focus_webrect);
2333 ConvertViewportToWindow(&anchor_webrect);
oshima33ec97cd2015-12-14 19:40:242334 *focus = focus_webrect;
2335 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:322336}
2337
[email protected]e99ef6f2011-10-16 01:13:002338void RenderWidget::UpdateSelectionBounds() {
jdduke1aebad8e2015-07-22 23:25:082339 TRACE_EVENT0("renderer", "RenderWidget::UpdateSelectionBounds");
lfg8ff33912016-09-13 20:59:212340 if (!GetWebWidget())
[email protected]e99ef6f2011-10-16 01:13:002341 return;
changwanf2a707b2015-10-30 08:22:162342 if (ime_event_guard_)
[email protected]66fca5bc2013-05-23 06:58:292343 return;
[email protected]e99ef6f2011-10-16 01:13:002344
mohsenb0eeba72015-08-09 06:20:082345#if defined(USE_AURA)
2346 // TODO(mohsen): For now, always send explicit selection IPC notifications for
2347 // Aura beucause composited selection updates are not working for webview tags
2348 // which regresses IME inside webview. Remove this when composited selection
2349 // updates are fixed for webviews. See, http://crbug.com/510568.
2350 bool send_ipc = true;
2351#else
jddukeacf809e2014-09-23 20:38:382352 // With composited selection updates, the selection bounds will be reported
2353 // directly by the compositor, in which case explicit IPC selection
2354 // notifications should be suppressed.
mohsenb0eeba72015-08-09 06:20:082355 bool send_ipc =
Blink Reformat1c4d759e2017-04-09 16:34:542356 !blink::WebRuntimeFeatures::IsCompositedSelectionUpdateEnabled();
mohsenb0eeba72015-08-09 06:20:082357#endif
2358 if (send_ipc) {
jddukeacf809e2014-09-23 20:38:382359 ViewHostMsg_SelectionBounds_Params params;
EhsanK955ba582017-11-30 21:14:402360 params.is_anchor_first = false;
jddukeacf809e2014-09-23 20:38:382361 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
2362 if (selection_anchor_rect_ != params.anchor_rect ||
2363 selection_focus_rect_ != params.focus_rect) {
2364 selection_anchor_rect_ = params.anchor_rect;
2365 selection_focus_rect_ = params.focus_rect;
EhsanK955ba582017-11-30 21:14:402366 if (auto* focused_frame = GetFocusedWebLocalFrameInWidget()) {
2367 focused_frame->SelectionTextDirection(params.focus_dir,
2368 params.anchor_dir);
2369 params.is_anchor_first = focused_frame->IsSelectionAnchorFirst();
2370 }
jddukeacf809e2014-09-23 20:38:382371 Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
2372 }
[email protected]58b48a0d2012-06-13 07:01:352373 }
jddukeacf809e2014-09-23 20:38:382374
nonafa291792016-08-10 02:36:182375 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]e99ef6f2011-10-16 01:13:002376}
2377
lfgb00fcad2016-07-14 14:16:332378void RenderWidget::DidAutoResize(const gfx::Size& new_size) {
2379 WebRect new_size_in_window(0, 0, new_size.width(), new_size.height());
Blink Reformat1c4d759e2017-04-09 16:34:542380 ConvertViewportToWindow(&new_size_in_window);
lfgb00fcad2016-07-14 14:16:332381 if (size_.width() != new_size_in_window.width ||
2382 size_.height() != new_size_in_window.height) {
2383 size_ = gfx::Size(new_size_in_window.width, new_size_in_window.height);
2384
2385 if (resizing_mode_selector_->is_synchronous_mode()) {
Blink Reformat1c4d759e2017-04-09 16:34:542386 gfx::Rect new_pos(WindowRect().x, WindowRect().y, size_.width(),
2387 size_.height());
lfgb00fcad2016-07-14 14:16:332388 view_screen_rect_ = new_pos;
2389 window_screen_rect_ = new_pos;
2390 }
2391
Christopher Camerone9a30c12018-03-07 08:23:382392 // TODO(ccameron): Note that this destroys any information differentiating
Christopher Cameronaad15a0d2018-03-09 03:47:332393 // |size_| from |compositor_viewport_pixel_size_|. Also note that the
2394 // calculation of |new_compositor_viewport_pixel_size| does not appear to
2395 // take into account device emulation.
danakja6c10012018-07-06 14:25:362396 if (layer_tree_view_)
2397 layer_tree_view_->RequestNewLocalSurfaceId();
Christopher Cameronaad15a0d2018-03-09 03:47:332398 gfx::Size new_compositor_viewport_pixel_size =
Fady Samuela863f152018-03-09 16:10:032399 gfx::ScaleToCeiledSize(size_, GetWebScreenInfo().device_scale_factor);
Fady Samuel4255c182018-05-24 20:42:362400 UpdateSurfaceAndScreenInfo(local_surface_id_from_parent_,
2401 new_compositor_viewport_pixel_size,
2402 screen_info_);
lfgb00fcad2016-07-14 14:16:332403 }
2404}
2405
[email protected]58b48a0d2012-06-13 07:01:352406void RenderWidget::GetCompositionCharacterBounds(
2407 std::vector<gfx::Rect>* bounds) {
2408 DCHECK(bounds);
2409 bounds->clear();
ekaramad2a46d632016-07-19 13:33:092410
brettw4b461082016-11-19 18:55:162411#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492412 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092413 return;
2414#endif
2415
Ehsan Karamad4975af6d2018-02-09 16:58:162416 blink::WebInputMethodController* controller = GetInputMethodController();
2417 if (!controller)
ekaramad2a46d632016-07-19 13:33:092418 return;
2419 blink::WebVector<blink::WebRect> bounds_from_blink;
Ehsan Karamad4975af6d2018-02-09 16:58:162420 if (!controller->GetCompositionCharacterBounds(bounds_from_blink))
ekaramad2a46d632016-07-19 13:33:092421 return;
2422
2423 for (size_t i = 0; i < bounds_from_blink.size(); ++i) {
Blink Reformat1c4d759e2017-04-09 16:34:542424 ConvertViewportToWindow(&bounds_from_blink[i]);
ekaramad2a46d632016-07-19 13:33:092425 bounds->push_back(bounds_from_blink[i]);
2426 }
[email protected]58b48a0d2012-06-13 07:01:352427}
2428
[email protected]db4fc1e2013-09-06 20:01:512429void RenderWidget::GetCompositionRange(gfx::Range* range) {
brettw4b461082016-11-19 18:55:162430#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492431 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092432 return;
2433#endif
EhsanKcdee7b72017-11-08 21:30:092434 blink::WebInputMethodController* controller = GetInputMethodController();
2435 WebRange web_range = controller ? controller->CompositionRange() : WebRange();
Blink Reformat1c4d759e2017-04-09 16:34:542436 if (web_range.IsNull()) {
nona2363a3d2016-11-09 03:26:212437 *range = gfx::Range::InvalidRange();
2438 return;
[email protected]88dbe32f2013-06-20 23:31:362439 }
Blink Reformat1c4d759e2017-04-09 16:34:542440 range->set_start(web_range.StartOffset());
2441 range->set_end(web_range.EndOffset());
[email protected]88dbe32f2013-06-20 23:31:362442}
2443
[email protected]501ea13d2013-07-09 17:03:292444bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:512445 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:292446 const std::vector<gfx::Rect>& bounds) {
changwan2418e1b2016-12-12 12:43:082447 if (!range.IsValid())
2448 return false;
[email protected]501ea13d2013-07-09 17:03:292449 if (composition_range_ != range)
2450 return true;
2451 if (bounds.size() != composition_character_bounds_.size())
2452 return true;
2453 for (size_t i = 0; i < bounds.size(); ++i) {
2454 if (bounds[i] != composition_character_bounds_[i])
2455 return true;
2456 }
2457 return false;
2458}
[email protected]501ea13d2013-07-09 17:03:292459
[email protected]ad26ef42011-06-17 07:59:452460bool RenderWidget::CanComposeInline() {
brettw4b461082016-11-19 18:55:162461#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492462 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2463 return plugin->IsPluginAcceptingCompositionEvents();
ekaramad2a46d632016-07-19 13:33:092464#endif
[email protected]ad26ef42011-06-17 07:59:452465 return true;
[email protected]56ea1a62011-05-30 07:05:572466}
2467
Blink Reformat1c4d759e2017-04-09 16:34:542468blink::WebScreenInfo RenderWidget::GetScreenInfo() {
ccameron2f451532016-09-07 21:49:272469 blink::WebScreenInfo web_screen_info;
Blink Reformat1c4d759e2017-04-09 16:34:542470 web_screen_info.device_scale_factor = screen_info_.device_scale_factor;
ccameronab0aab82017-06-24 17:21:542471 web_screen_info.color_space = screen_info_.color_space;
ccameron2f451532016-09-07 21:49:272472 web_screen_info.depth = screen_info_.depth;
Blink Reformat1c4d759e2017-04-09 16:34:542473 web_screen_info.depth_per_component = screen_info_.depth_per_component;
2474 web_screen_info.is_monochrome = screen_info_.is_monochrome;
ccameron2f451532016-09-07 21:49:272475 web_screen_info.rect = blink::WebRect(screen_info_.rect);
Blink Reformat1c4d759e2017-04-09 16:34:542476 web_screen_info.available_rect = blink::WebRect(screen_info_.available_rect);
ccameron2f451532016-09-07 21:49:272477 switch (screen_info_.orientation_type) {
2478 case SCREEN_ORIENTATION_VALUES_PORTRAIT_PRIMARY:
Blink Reformat1c4d759e2017-04-09 16:34:542479 web_screen_info.orientation_type =
2480 blink::kWebScreenOrientationPortraitPrimary;
ccameron2f451532016-09-07 21:49:272481 break;
2482 case SCREEN_ORIENTATION_VALUES_PORTRAIT_SECONDARY:
Blink Reformat1c4d759e2017-04-09 16:34:542483 web_screen_info.orientation_type =
2484 blink::kWebScreenOrientationPortraitSecondary;
ccameron2f451532016-09-07 21:49:272485 break;
2486 case SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY:
Blink Reformat1c4d759e2017-04-09 16:34:542487 web_screen_info.orientation_type =
2488 blink::kWebScreenOrientationLandscapePrimary;
ccameron2f451532016-09-07 21:49:272489 break;
2490 case SCREEN_ORIENTATION_VALUES_LANDSCAPE_SECONDARY:
Blink Reformat1c4d759e2017-04-09 16:34:542491 web_screen_info.orientation_type =
2492 blink::kWebScreenOrientationLandscapeSecondary;
ccameron2f451532016-09-07 21:49:272493 break;
2494 default:
Blink Reformat1c4d759e2017-04-09 16:34:542495 web_screen_info.orientation_type = blink::kWebScreenOrientationUndefined;
ccameron2f451532016-09-07 21:49:272496 break;
2497 }
Blink Reformat1c4d759e2017-04-09 16:34:542498 web_screen_info.orientation_angle = screen_info_.orientation_angle;
Fady Samuel85a1bf72017-10-27 14:30:202499
ccameron2f451532016-09-07 21:49:272500 return web_screen_info;
[email protected]4873c7d2009-07-16 06:36:282501}
2502
Blink Reformat1c4d759e2017-04-09 16:34:542503void RenderWidget::DidHandleGestureEvent(const WebGestureEvent& event,
2504 bool event_cancelled) {
danakja2c9d0a92018-07-25 20:01:182505 if (event_cancelled) {
2506 // The |owner_delegate_| doesn't need to hear about cancelled events.
[email protected]c68c3e4e2013-01-24 00:36:562507 return;
danakja2c9d0a92018-07-25 20:01:182508 }
2509
2510#if defined(OS_ANDROID) || defined(USE_AURA)
Blink Reformat1c4d759e2017-04-09 16:34:542511 if (event.GetType() == WebInputEvent::kGestureTap) {
changwan75e3b2072017-01-16 02:55:002512 ShowVirtualKeyboard();
Blink Reformat1c4d759e2017-04-09 16:34:542513 } else if (event.GetType() == WebInputEvent::kGestureLongPress) {
lfg8ff33912016-09-13 20:59:212514 DCHECK(GetWebWidget());
ekaramad5aff1942017-01-06 01:26:352515 blink::WebInputMethodController* controller = GetInputMethodController();
Blink Reformat1c4d759e2017-04-09 16:34:542516 if (!controller || controller->TextInputInfo().value.IsEmpty())
changwan75e3b2072017-01-16 02:55:002517 UpdateTextInputState();
[email protected]07c70d22014-08-21 08:33:462518 else
changwan75e3b2072017-01-16 02:55:002519 ShowVirtualKeyboard();
[email protected]c68c3e4e2013-01-24 00:36:562520 }
ekaramada110f642016-12-21 19:47:282521// TODO(ananta): Piggyback off existing IPCs to communicate this information,
2522// crbug/420130.
2523#if defined(OS_WIN)
danakja2c9d0a92018-07-25 20:01:182524 if (event.GetType() == blink::WebGestureEvent::kGestureTap) {
2525 // TODO(estade): hit test the event against focused node to make sure
2526 // the tap actually hit the focused node.
2527 blink::WebInputMethodController* controller = GetInputMethodController();
2528 blink::WebTextInputType text_input_type =
2529 controller ? controller->TextInputType() : blink::kWebTextInputTypeNone;
ekaramada110f642016-12-21 19:47:282530
danakja2c9d0a92018-07-25 20:01:182531 Send(new ViewHostMsg_FocusedNodeTouched(
2532 routing_id_, text_input_type != blink::kWebTextInputTypeNone));
2533 }
ekaramada110f642016-12-21 19:47:282534#endif
[email protected]c68c3e4e2013-01-24 00:36:562535#endif
danakja2c9d0a92018-07-25 20:01:182536
2537 // The |owner_delegate_| gets to respond to handling gestures last.
2538 if (owner_delegate_)
2539 owner_delegate_->DidHandleGestureEventForWidget(event);
[email protected]c68c3e4e2013-01-24 00:36:562540}
2541
Blink Reformat1c4d759e2017-04-09 16:34:542542void RenderWidget::DidOverscroll(
bokane53a10f2016-04-13 23:48:312543 const blink::WebFloatSize& overscrollDelta,
2544 const blink::WebFloatSize& accumulatedOverscroll,
sataya.m582c9ce2015-06-09 08:03:422545 const blink::WebFloatPoint& position,
sunyunjiabbea8a92017-08-31 11:18:542546 const blink::WebFloatSize& velocity,
danakje819b622018-05-01 20:27:142547 const cc::OverscrollBehavior& behavior) {
bokan731ec382016-04-07 03:16:482548#if defined(OS_MACOSX)
2549 // On OSX the user can disable the elastic overscroll effect. If that's the
2550 // case, don't forward the overscroll notification.
2551 DCHECK(compositor_deps());
2552 if (!compositor_deps()->IsElasticOverscrollEnabled())
2553 return;
2554#endif
bokane53a10f2016-04-13 23:48:312555 input_handler_->DidOverscrollFromBlink(overscrollDelta, accumulatedOverscroll,
sunyunjiabbea8a92017-08-31 11:18:542556 position, velocity, behavior);
sataya.m582c9ce2015-06-09 08:03:422557}
2558
danakj4b347212018-07-04 17:55:172559// static
2560cc::LayerTreeSettings RenderWidget::GenerateLayerTreeSettings(
2561 CompositorDependencies* compositor_deps,
2562 bool is_for_subframe,
2563 const gfx::Size& initial_screen_size,
2564 float initial_device_scale_factor) {
2565 const bool is_threaded =
2566 !!compositor_deps->GetCompositorImplThreadTaskRunner();
2567
2568 const base::CommandLine& cmd = *base::CommandLine::ForCurrentProcess();
2569 cc::LayerTreeSettings settings;
2570
2571 settings.resource_settings.use_r16_texture =
2572 base::FeatureList::IsEnabled(media::kUseR16Texture);
2573
2574 settings.commit_to_active_tree = !is_threaded;
2575 settings.is_layer_tree_for_subframe = is_for_subframe;
2576
2577 // For web contents, layer transforms should scale up the contents of layers
2578 // to keep content always crisp when possible.
2579 settings.layer_transforms_should_scale_layer_contents = true;
2580
2581 settings.main_frame_before_activation_enabled =
2582 cmd.HasSwitch(cc::switches::kEnableMainFrameBeforeActivation);
2583
2584 // Checkerimaging is not supported for synchronous single-threaded mode, which
2585 // is what the renderer uses if its not threaded.
2586 settings.enable_checker_imaging =
2587 !cmd.HasSwitch(cc::switches::kDisableCheckerImaging) && is_threaded;
2588
2589#if defined(OS_ANDROID)
2590 // We can use a more aggressive limit on Android since decodes tend to take
2591 // longer on these devices.
2592 settings.min_image_bytes_to_checker = 512 * 1024; // 512kB
2593
2594 // Re-rasterization of checker-imaged content with software raster can be too
2595 // costly on Android.
2596 settings.only_checker_images_with_gpu_raster = true;
2597#endif
2598
2599 auto switch_value_as_int = [](const base::CommandLine& command_line,
2600 const std::string& switch_string, int min_value,
2601 int max_value, int* result) {
2602 std::string string_value = command_line.GetSwitchValueASCII(switch_string);
2603 int int_value;
2604 if (base::StringToInt(string_value, &int_value) && int_value >= min_value &&
2605 int_value <= max_value) {
2606 *result = int_value;
2607 return true;
2608 } else {
2609 LOG(WARNING) << "Failed to parse switch " << switch_string << ": "
2610 << string_value;
2611 return false;
2612 }
2613 };
2614
2615 int default_tile_size = 256;
2616#if defined(OS_ANDROID)
2617 const gfx::Size screen_size =
2618 gfx::ScaleToFlooredSize(initial_screen_size, initial_device_scale_factor);
2619 int display_width = screen_size.width();
2620 int display_height = screen_size.height();
2621 int numTiles = (display_width * display_height) / (256 * 256);
2622 if (numTiles > 16)
2623 default_tile_size = 384;
2624 if (numTiles >= 40)
2625 default_tile_size = 512;
2626
2627 // Adjust for some resolutions that barely straddle an extra
2628 // tile when in portrait mode. This helps worst case scroll/raster
2629 // by not needing a full extra tile for each row.
2630 constexpr int tolerance = 10; // To avoid rounding errors.
2631 int portrait_width = std::min(display_width, display_height);
2632 if (default_tile_size == 256 && std::abs(portrait_width - 768) < tolerance)
2633 default_tile_size += 32;
2634 if (default_tile_size == 384 && std::abs(portrait_width - 1200) < tolerance)
2635 default_tile_size += 32;
2636#elif defined(OS_CHROMEOS) || defined(OS_MACOSX)
2637 // Use 512 for high DPI (dsf=2.0f) devices.
2638 if (initial_device_scale_factor >= 2.0f)
2639 default_tile_size = 512;
2640#endif
2641
2642 // TODO(danakj): This should not be a setting O_O; it should change when the
2643 // device scale factor on LayerTreeHost changes.
2644 settings.default_tile_size = gfx::Size(default_tile_size, default_tile_size);
2645 if (cmd.HasSwitch(switches::kDefaultTileWidth)) {
2646 int tile_width = 0;
2647 switch_value_as_int(cmd, switches::kDefaultTileWidth, 1,
2648 std::numeric_limits<int>::max(), &tile_width);
2649 settings.default_tile_size.set_width(tile_width);
2650 }
2651 if (cmd.HasSwitch(switches::kDefaultTileHeight)) {
2652 int tile_height = 0;
2653 switch_value_as_int(cmd, switches::kDefaultTileHeight, 1,
2654 std::numeric_limits<int>::max(), &tile_height);
2655 settings.default_tile_size.set_height(tile_height);
2656 }
2657
2658 int max_untiled_layer_width = settings.max_untiled_layer_size.width();
2659 if (cmd.HasSwitch(switches::kMaxUntiledLayerWidth)) {
2660 switch_value_as_int(cmd, switches::kMaxUntiledLayerWidth, 1,
2661 std::numeric_limits<int>::max(),
2662 &max_untiled_layer_width);
2663 }
2664 int max_untiled_layer_height = settings.max_untiled_layer_size.height();
2665 if (cmd.HasSwitch(switches::kMaxUntiledLayerHeight)) {
2666 switch_value_as_int(cmd, switches::kMaxUntiledLayerHeight, 1,
2667 std::numeric_limits<int>::max(),
2668 &max_untiled_layer_height);
2669 }
2670
2671 settings.max_untiled_layer_size =
2672 gfx::Size(max_untiled_layer_width, max_untiled_layer_height);
2673
2674 settings.gpu_rasterization_msaa_sample_count =
2675 compositor_deps->GetGpuRasterizationMSAASampleCount();
2676 settings.gpu_rasterization_forced =
2677 compositor_deps->IsGpuRasterizationForced();
2678
2679 settings.can_use_lcd_text = compositor_deps->IsLcdTextEnabled();
2680 settings.use_zero_copy = compositor_deps->IsZeroCopyEnabled();
2681 settings.use_partial_raster = compositor_deps->IsPartialRasterEnabled();
2682 settings.enable_elastic_overscroll =
2683 compositor_deps->IsElasticOverscrollEnabled();
2684 settings.resource_settings.use_gpu_memory_buffer_resources =
2685 compositor_deps->IsGpuMemoryBufferCompositorResourcesEnabled();
2686 settings.use_painted_device_scale_factor =
2687 compositor_deps->IsUseZoomForDSFEnabled();
2688
2689 // Build LayerTreeSettings from command line args.
2690 if (cmd.HasSwitch(cc::switches::kBrowserControlsShowThreshold)) {
2691 std::string top_threshold_str =
2692 cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsShowThreshold);
2693 double show_threshold;
2694 if (base::StringToDouble(top_threshold_str, &show_threshold) &&
2695 show_threshold >= 0.f && show_threshold <= 1.f)
2696 settings.top_controls_show_threshold = show_threshold;
2697 }
2698
2699 if (cmd.HasSwitch(cc::switches::kBrowserControlsHideThreshold)) {
2700 std::string top_threshold_str =
2701 cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsHideThreshold);
2702 double hide_threshold;
2703 if (base::StringToDouble(top_threshold_str, &hide_threshold) &&
2704 hide_threshold >= 0.f && hide_threshold <= 1.f)
2705 settings.top_controls_hide_threshold = hide_threshold;
2706 }
2707
2708 settings.use_layer_lists = cmd.HasSwitch(cc::switches::kEnableLayerLists);
2709
2710 // The means the renderer compositor has 2 possible modes:
2711 // - Threaded compositing with a scheduler.
2712 // - Single threaded compositing without a scheduler (for layout tests only).
2713 // Using the scheduler in layout tests introduces additional composite steps
2714 // that create flakiness.
2715 settings.single_thread_proxy_scheduler = false;
2716
2717 // These flags should be mirrored by UI versions in ui/compositor/.
2718 if (cmd.HasSwitch(cc::switches::kShowCompositedLayerBorders))
2719 settings.initial_debug_state.show_debug_borders.set();
2720 settings.initial_debug_state.show_layer_animation_bounds_rects =
2721 cmd.HasSwitch(cc::switches::kShowLayerAnimationBounds);
2722 settings.initial_debug_state.show_paint_rects =
2723 cmd.HasSwitch(switches::kShowPaintRects);
2724 settings.initial_debug_state.show_property_changed_rects =
2725 cmd.HasSwitch(cc::switches::kShowPropertyChangedRects);
2726 settings.initial_debug_state.show_surface_damage_rects =
2727 cmd.HasSwitch(cc::switches::kShowSurfaceDamageRects);
2728 settings.initial_debug_state.show_screen_space_rects =
2729 cmd.HasSwitch(cc::switches::kShowScreenSpaceRects);
2730
2731 settings.initial_debug_state.SetRecordRenderingStats(
2732 cmd.HasSwitch(cc::switches::kEnableGpuBenchmarking));
2733 settings.enable_surface_synchronization =
2734 features::IsSurfaceSynchronizationEnabled();
2735 settings.build_hit_test_data = features::IsVizHitTestingSurfaceLayerEnabled();
2736
2737 if (cmd.HasSwitch(cc::switches::kSlowDownRasterScaleFactor)) {
2738 const int kMinSlowDownScaleFactor = 0;
2739 const int kMaxSlowDownScaleFactor = INT_MAX;
2740 switch_value_as_int(
2741 cmd, cc::switches::kSlowDownRasterScaleFactor, kMinSlowDownScaleFactor,
2742 kMaxSlowDownScaleFactor,
2743 &settings.initial_debug_state.slow_down_raster_scale_factor);
2744 }
2745
2746 // This is default overlay scrollbar settings for Android and DevTools mobile
2747 // emulator. Aura Overlay Scrollbar will override below.
2748 settings.scrollbar_animator = cc::LayerTreeSettings::ANDROID_OVERLAY;
2749 settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
2750 settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(300);
2751 settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(300);
2752
2753#if defined(OS_ANDROID)
2754 bool using_synchronous_compositor =
2755 compositor_deps->UsingSynchronousCompositing();
2756 bool using_low_memory_policy = base::SysInfo::IsLowEndDevice();
2757
2758 settings.use_stream_video_draw_quad = true;
2759 settings.using_synchronous_renderer_compositor = using_synchronous_compositor;
2760 if (using_synchronous_compositor) {
2761 // Android WebView uses system scrollbars, so make ours invisible.
2762 // http://crbug.com/677348: This can't be done using hide_scrollbars
2763 // setting because supporting -webkit custom scrollbars is still desired
2764 // on sublayers.
2765 settings.scrollbar_animator = cc::LayerTreeSettings::NO_ANIMATOR;
2766 settings.solid_color_scrollbar_color = SK_ColorTRANSPARENT;
2767
2768 settings.enable_early_damage_check =
2769 cmd.HasSwitch(cc::switches::kCheckDamageEarly);
2770 }
2771 // Android WebView handles root layer flings itself.
2772 settings.ignore_root_layer_flings = using_synchronous_compositor;
2773 // Memory policy on Android WebView does not depend on whether device is
2774 // low end, so always use default policy.
2775 if (using_low_memory_policy && !using_synchronous_compositor) {
2776 // On low-end we want to be very carefull about killing other
2777 // apps. So initially we use 50% more memory to avoid flickering
2778 // or raster-on-demand.
2779 settings.max_memory_for_prepaint_percentage = 67;
2780 } else {
2781 // On other devices we have increased memory excessively to avoid
2782 // raster-on-demand already, so now we reserve 50% _only_ to avoid
2783 // raster-on-demand, and use 50% of the memory otherwise.
2784 settings.max_memory_for_prepaint_percentage = 50;
2785 }
2786
2787 // TODO(danakj): Only do this on low end devices.
2788 settings.create_low_res_tiling = true;
2789
2790#else // defined(OS_ANDROID)
2791 bool using_synchronous_compositor = false; // Only for Android WebView.
2792 // On desktop, we never use the low memory policy unless we are simulating
2793 // low-end mode via a switch.
2794 bool using_low_memory_policy =
2795 cmd.HasSwitch(switches::kEnableLowEndDeviceMode);
2796
2797 if (ui::IsOverlayScrollbarEnabled()) {
2798 settings.scrollbar_animator = cc::LayerTreeSettings::AURA_OVERLAY;
2799 settings.scrollbar_fade_delay = ui::kOverlayScrollbarFadeDelay;
2800 settings.scrollbar_fade_duration = ui::kOverlayScrollbarFadeDuration;
2801 settings.scrollbar_thinning_duration =
2802 ui::kOverlayScrollbarThinningDuration;
2803 settings.scrollbar_flash_after_any_scroll_update =
2804 ui::OverlayScrollbarFlashAfterAnyScrollUpdate();
2805 settings.scrollbar_flash_when_mouse_enter =
2806 ui::OverlayScrollbarFlashWhenMouseEnter();
2807 }
2808
2809 // On desktop, if there's over 4GB of memory on the machine, increase the
2810 // working set size to 256MB for both gpu and software.
2811 const int kImageDecodeMemoryThresholdMB = 4 * 1024;
2812 if (base::SysInfo::AmountOfPhysicalMemoryMB() >=
2813 kImageDecodeMemoryThresholdMB) {
2814 settings.decoded_image_working_set_budget_bytes = 256 * 1024 * 1024;
2815 } else {
2816 // This is the default, but recorded here as well.
2817 settings.decoded_image_working_set_budget_bytes = 128 * 1024 * 1024;
2818 }
2819#endif // defined(OS_ANDROID)
2820
2821 if (using_low_memory_policy) {
2822 // RGBA_4444 textures are only enabled:
2823 // - If the user hasn't explicitly disabled them
2824 // - If system ram is <= 512MB (1GB devices are sometimes low-end).
2825 // - If we are not running in a WebView, where 4444 isn't supported.
2826 if (!cmd.HasSwitch(switches::kDisableRGBA4444Textures) &&
2827 base::SysInfo::AmountOfPhysicalMemoryMB() <= 512 &&
2828 !using_synchronous_compositor) {
2829 settings.use_rgba_4444 = viz::RGBA_4444;
2830
2831 // If we are going to unpremultiply and dither these tiles, we need to
2832 // allocate an additional RGBA_8888 intermediate for each tile
2833 // rasterization when rastering to RGBA_4444 to allow for dithering.
2834 // Setting a reasonable sized max tile size allows this intermediate to
2835 // be consistently reused.
2836 if (base::FeatureList::IsEnabled(
2837 kUnpremultiplyAndDitherLowBitDepthTiles)) {
2838 settings.max_gpu_raster_tile_size = gfx::Size(512, 256);
2839 settings.unpremultiply_and_dither_low_bit_depth_tiles = true;
2840 }
2841 }
2842 }
2843
2844 if (cmd.HasSwitch(switches::kEnableLowResTiling))
2845 settings.create_low_res_tiling = true;
2846 if (cmd.HasSwitch(switches::kDisableLowResTiling))
2847 settings.create_low_res_tiling = false;
2848
2849 if (cmd.HasSwitch(switches::kEnableRGBA4444Textures) &&
2850 !cmd.HasSwitch(switches::kDisableRGBA4444Textures)) {
2851 settings.use_rgba_4444 = true;
2852 }
2853
2854 settings.max_staging_buffer_usage_in_bytes = 32 * 1024 * 1024; // 32MB
2855 // Use 1/4th of staging buffers on low-end devices.
2856 if (base::SysInfo::IsLowEndDevice())
2857 settings.max_staging_buffer_usage_in_bytes /= 4;
2858
2859 cc::ManagedMemoryPolicy defaults = settings.memory_policy;
2860 settings.memory_policy = GetGpuMemoryPolicy(defaults, initial_screen_size,
2861 initial_device_scale_factor);
2862
2863 settings.disallow_non_exact_resource_reuse =
2864 cmd.HasSwitch(switches::kDisallowNonExactResourceReuse);
2865#if defined(OS_ANDROID)
2866 // TODO(crbug.com/746931): This feature appears to be causing visual
2867 // corruption on certain android devices. Will investigate and re-enable.
2868 settings.disallow_non_exact_resource_reuse = true;
2869#endif
2870
2871 if (cmd.HasSwitch(switches::kRunAllCompositorStagesBeforeDraw)) {
2872 settings.wait_for_all_pipeline_stages_before_draw = true;
2873 settings.enable_latency_recovery = false;
2874 }
2875
2876 settings.enable_image_animation_resync =
2877 !cmd.HasSwitch(switches::kDisableImageAnimationResync);
2878
2879 settings.always_request_presentation_time =
2880 cmd.HasSwitch(cc::switches::kAlwaysRequestPresentationTime);
2881 return settings;
2882}
2883
2884// static
2885cc::ManagedMemoryPolicy RenderWidget::GetGpuMemoryPolicy(
2886 const cc::ManagedMemoryPolicy& default_policy,
2887 const gfx::Size& initial_screen_size,
2888 float initial_device_scale_factor) {
2889 cc::ManagedMemoryPolicy actual = default_policy;
2890 actual.bytes_limit_when_visible = 0;
2891
2892 // If the value was overridden on the command line, use the specified value.
2893 static bool client_hard_limit_bytes_overridden =
2894 base::CommandLine::ForCurrentProcess()->HasSwitch(
2895 switches::kForceGpuMemAvailableMb);
2896 if (client_hard_limit_bytes_overridden) {
2897 if (base::StringToSizeT(
2898 base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
2899 switches::kForceGpuMemAvailableMb),
2900 &actual.bytes_limit_when_visible))
2901 actual.bytes_limit_when_visible *= 1024 * 1024;
2902 return actual;
2903 }
2904
2905#if defined(OS_ANDROID)
2906 // We can't query available GPU memory from the system on Android.
2907 // Physical memory is also mis-reported sometimes (eg. Nexus 10 reports
2908 // 1262MB when it actually has 2GB, while Razr M has 1GB but only reports
2909 // 128MB java heap size). First we estimate physical memory using both.
2910 size_t dalvik_mb = base::SysInfo::DalvikHeapSizeMB();
2911 size_t physical_mb = base::SysInfo::AmountOfPhysicalMemoryMB();
2912 size_t physical_memory_mb = 0;
2913 if (base::SysInfo::IsLowEndDevice()) {
2914 // TODO(crbug.com/742534): The code below appears to no longer work.
2915 // |dalvik_mb| no longer follows the expected heuristic pattern, causing us
2916 // to over-estimate memory on low-end devices. This entire section probably
2917 // needs to be re-written, but for now we can address the low-end Android
2918 // issues by ignoring |dalvik_mb|.
2919 physical_memory_mb = physical_mb;
2920 } else if (dalvik_mb >= 256) {
2921 physical_memory_mb = dalvik_mb * 4;
2922 } else {
2923 physical_memory_mb = std::max(dalvik_mb * 4, (physical_mb * 4) / 3);
2924 }
2925
2926 // Now we take a default of 1/8th of memory on high-memory devices,
2927 // and gradually scale that back for low-memory devices (to be nicer
2928 // to other apps so they don't get killed). Examples:
2929 // Nexus 4/10(2GB) 256MB (normally 128MB)
2930 // Droid Razr M(1GB) 114MB (normally 57MB)
2931 // Galaxy Nexus(1GB) 100MB (normally 50MB)
2932 // Xoom(1GB) 100MB (normally 50MB)
2933 // Nexus S(low-end) 8MB (normally 8MB)
2934 // Note that the compositor now uses only some of this memory for
2935 // pre-painting and uses the rest only for 'emergencies'.
2936 if (actual.bytes_limit_when_visible == 0) {
2937 // NOTE: Non-low-end devices use only 50% of these limits,
2938 // except during 'emergencies' where 100% can be used.
2939 if (physical_memory_mb >= 1536)
2940 actual.bytes_limit_when_visible = physical_memory_mb / 8; // >192MB
2941 else if (physical_memory_mb >= 1152)
2942 actual.bytes_limit_when_visible = physical_memory_mb / 8; // >144MB
2943 else if (physical_memory_mb >= 768)
2944 actual.bytes_limit_when_visible = physical_memory_mb / 10; // >76MB
2945 else if (physical_memory_mb >= 513)
2946 actual.bytes_limit_when_visible = physical_memory_mb / 12; // <64MB
2947 else
2948 // Devices with this little RAM have very little headroom so we hardcode
2949 // the limit rather than relying on the heuristics above. (They also use
2950 // 4444 textures so we can use a lower limit.)
2951 actual.bytes_limit_when_visible = 8;
2952
2953 actual.bytes_limit_when_visible =
2954 actual.bytes_limit_when_visible * 1024 * 1024;
2955 // Clamp the observed value to a specific range on Android.
2956 actual.bytes_limit_when_visible = std::max(
2957 actual.bytes_limit_when_visible, static_cast<size_t>(8 * 1024 * 1024));
2958 actual.bytes_limit_when_visible =
2959 std::min(actual.bytes_limit_when_visible,
2960 static_cast<size_t>(256 * 1024 * 1024));
2961 }
2962 actual.priority_cutoff_when_visible =
2963 gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING;
2964#else
2965 // Ignore what the system said and give all clients the same maximum
2966 // allocation on desktop platforms.
2967 actual.bytes_limit_when_visible = 512 * 1024 * 1024;
2968 actual.priority_cutoff_when_visible =
2969 gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
2970
2971 // For large monitors (4k), double the tile memory to avoid frequent out of
2972 // memory problems. 4k could mean a screen width of anywhere from 3840 to 4096
2973 // (see https://en.wikipedia.org/wiki/4K_resolution). We use 3500 as a proxy
2974 // for "large enough".
2975 static const int kLargeDisplayThreshold = 3500;
2976 int display_width =
2977 std::round(initial_screen_size.width() * initial_device_scale_factor);
2978 if (display_width >= kLargeDisplayThreshold)
2979 actual.bytes_limit_when_visible *= 2;
2980#endif
2981 return actual;
2982}
2983
[email protected]7912e822014-04-16 02:37:032984void RenderWidget::StartCompositor() {
sievers71c62dd52015-10-07 01:44:392985 if (!is_hidden())
danakja6c10012018-07-06 14:25:362986 layer_tree_view_->SetVisible(true);
[email protected]24ed0432013-04-24 07:50:312987}
2988
Blink Reformat1c4d759e2017-04-09 16:34:542989void RenderWidget::HasTouchEventHandlers(bool has_handlers) {
W. James MacLean662d5382018-03-29 18:33:082990 if (has_touch_handlers_ && *has_touch_handlers_ == has_handlers)
2991 return;
2992
2993 has_touch_handlers_ = has_handlers;
alexclarke7fa93942015-10-21 15:37:112994 if (render_widget_scheduling_state_)
2995 render_widget_scheduling_state_->SetHasTouchHandler(has_handlers);
[email protected]ce6689f2013-03-29 12:52:552996 Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
2997}
2998
Dave Tapuskadfe486c12017-06-09 16:53:132999void RenderWidget::SetNeedsLowLatencyInput(bool needs_low_latency) {
3000 if (input_event_queue_)
3001 input_event_queue_->SetNeedsLowLatency(needs_low_latency);
3002}
3003
Dave Tapuskabafc2ba32017-11-28 01:54:373004void RenderWidget::RequestUnbufferedInputEvents() {
3005 if (input_event_queue_)
3006 input_event_queue_->RequestUnbufferedInputEvents();
3007}
3008
xidachenfa0199e72017-05-11 11:34:263009void RenderWidget::SetTouchAction(cc::TouchAction touch_action) {
Dave Tapuskab28a1082017-08-30 15:37:263010 if (!input_handler_->ProcessTouchAction(touch_action))
[email protected]5d0bbdfa92013-12-10 00:35:513011 return;
3012
Dave Tapuska04bc5ee92018-04-17 19:03:313013 widget_input_handler_manager_->ProcessTouchAction(touch_action);
[email protected]5d0bbdfa92013-12-10 00:35:513014}
3015
[email protected]e3244ed2014-06-20 20:04:273016void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
3017 render_frame_proxies_.AddObserver(proxy);
[email protected]bffc8302014-01-23 20:52:163018}
3019
[email protected]e3244ed2014-06-20 20:04:273020void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
3021 render_frame_proxies_.RemoveObserver(proxy);
[email protected]bffc8302014-01-23 20:52:163022}
3023
[email protected]de3c5d82014-05-28 22:12:593024void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
3025 render_frames_.AddObserver(frame);
3026}
3027
3028void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) {
3029 render_frames_.RemoveObserver(frame);
3030}
3031
Saman Samid189e5dfd2017-12-20 22:55:313032void RenderWidget::RegisterBrowserPlugin(BrowserPlugin* browser_plugin) {
3033 browser_plugins_.AddObserver(browser_plugin);
Saman Sami50d1e0c2018-03-13 20:03:493034 browser_plugin->ScreenInfoChanged(GetOriginalScreenInfo());
Saman Samid189e5dfd2017-12-20 22:55:313035}
3036
3037void RenderWidget::UnregisterBrowserPlugin(BrowserPlugin* browser_plugin) {
3038 browser_plugins_.RemoveObserver(browser_plugin);
3039}
3040
lfg43e08e62016-02-03 18:51:373041void RenderWidget::OnWaitNextFrameForTests(int routing_id) {
danakj53802692018-07-25 21:46:443042 // Sends an ACK to the browser process during the next compositor frame.
Sadrul Habib Chowdhury4e0335cf2018-07-31 20:08:493043 QueueMessage(new ViewHostMsg_WaitForNextFrameForTests_ACK(routing_id));
lfg43e08e62016-02-03 18:51:373044}
3045
Fady Samuela863f152018-03-09 16:10:033046const ScreenInfo& RenderWidget::GetWebScreenInfo() const {
3047 return screen_info_;
Christopher Camerone9a30c12018-03-07 08:23:383048}
3049
Fady Samuela863f152018-03-09 16:10:033050const ScreenInfo& RenderWidget::GetOriginalScreenInfo() const {
Christopher Camerone9a30c12018-03-07 08:23:383051 return screen_metrics_emulator_
3052 ? screen_metrics_emulator_->original_screen_info()
Fady Samuela863f152018-03-09 16:10:033053 : screen_info_;
oshima50872a72016-03-04 13:26:183054}
3055
Ella Ge80a52dce2017-11-15 18:01:523056gfx::PointF RenderWidget::ConvertWindowPointToViewport(
3057 const gfx::PointF& point) {
paulmeyer90f6c31d2016-11-12 00:17:593058 blink::WebFloatRect point_in_viewport(point.x(), point.y(), 0, 0);
Blink Reformat1c4d759e2017-04-09 16:34:543059 ConvertWindowToViewport(&point_in_viewport);
Ella Ge80a52dce2017-11-15 18:01:523060 return gfx::PointF(point_in_viewport.x, point_in_viewport.y);
3061}
3062
3063gfx::Point RenderWidget::ConvertWindowPointToViewport(const gfx::Point& point) {
3064 return gfx::ToRoundedPoint(ConvertWindowPointToViewport(gfx::PointF(point)));
paulmeyer90f6c31d2016-11-12 00:17:593065}
3066
Blink Reformat1c4d759e2017-04-09 16:34:543067bool RenderWidget::RequestPointerLock() {
lfgbee1e0a2016-06-08 21:24:213068 return mouse_lock_dispatcher_->LockMouse(webwidget_mouse_lock_target_.get());
3069}
3070
Blink Reformat1c4d759e2017-04-09 16:34:543071void RenderWidget::RequestPointerUnlock() {
lfgbee1e0a2016-06-08 21:24:213072 mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
3073}
3074
Blink Reformat1c4d759e2017-04-09 16:34:543075bool RenderWidget::IsPointerLocked() {
lfgbee1e0a2016-06-08 21:24:213076 return mouse_lock_dispatcher_->IsMouseLockedTo(
3077 webwidget_mouse_lock_target_.get());
3078}
3079
Blink Reformat1c4d759e2017-04-09 16:34:543080void RenderWidget::StartDragging(blink::WebReferrerPolicy policy,
paulmeyer6ef5a792016-11-08 20:33:583081 const WebDragData& data,
3082 WebDragOperationsMask mask,
danakj0c75ad82018-07-10 19:50:123083 const SkBitmap& drag_image,
3084 const WebPoint& web_image_offset) {
3085 blink::WebRect offset_in_window(web_image_offset.x, web_image_offset.y, 0, 0);
Blink Reformat1c4d759e2017-04-09 16:34:543086 ConvertViewportToWindow(&offset_in_window);
paulmeyer6ef5a792016-11-08 20:33:583087 DropData drop_data(DropDataBuilder::Build(data));
3088 drop_data.referrer_policy = policy;
danakj0c75ad82018-07-10 19:50:123089 gfx::Vector2d image_offset(offset_in_window.x, offset_in_window.y);
3090 Send(new DragHostMsg_StartDragging(routing_id(), drop_data, mask, drag_image,
3091 image_offset, possible_drag_event_info_));
paulmeyer6ef5a792016-11-08 20:33:583092}
3093
kenrb5d78b842017-03-06 21:06:013094uint32_t RenderWidget::GetContentSourceId() {
3095 return current_content_source_id_;
3096}
3097
Saman Samif7731342018-01-24 22:18:443098void RenderWidget::DidNavigate() {
Saman Sami26a1fcd2018-04-10 17:12:213099 ++current_content_source_id_;
danakja6c10012018-07-06 14:25:363100 if (!layer_tree_view_)
Saman Samif7731342018-01-24 22:18:443101 return;
danakja6c10012018-07-06 14:25:363102 layer_tree_view_->SetContentSourceId(current_content_source_id_);
3103 layer_tree_view_->ClearCachesOnNextCommit();
kenrb5d78b842017-03-06 21:06:013104}
3105
lfg8ff33912016-09-13 20:59:213106blink::WebWidget* RenderWidget::GetWebWidget() const {
danakja2c9d0a92018-07-25 20:01:183107 if (owner_delegate_) {
3108 blink::WebWidget* delegate_widget =
3109 owner_delegate_->GetWebWidgetForWidget();
3110 if (delegate_widget)
3111 return delegate_widget;
3112 }
lfg8ff33912016-09-13 20:59:213113 return webwidget_internal_;
3114}
3115
ekaramad2daaf672016-11-10 20:29:013116blink::WebInputMethodController* RenderWidget::GetInputMethodController()
3117 const {
Ehsan Karamad655d7b8a2018-01-12 18:38:383118 if (auto* frame_widget = GetFrameWidget())
3119 return frame_widget->GetActiveWebInputMethodController();
3120
3121 return nullptr;
ekaramad2daaf672016-11-10 20:29:013122}
3123
Dave Tapuska139a72f2017-09-06 21:57:033124void RenderWidget::SetupWidgetInputHandler(
3125 mojom::WidgetInputHandlerRequest request,
3126 mojom::WidgetInputHandlerHostPtr host) {
Dave Tapuskab66c28f2017-11-15 17:18:473127 widget_input_handler_manager_->AddInterface(std::move(request),
3128 std::move(host));
Dave Tapuska525eb15e2017-08-17 21:05:503129}
3130
Dave Tapuska485aca92017-08-08 00:47:583131void RenderWidget::SetWidgetBinding(mojom::WidgetRequest request) {
3132 // Close the old binding if there was one.
3133 // A RenderWidgetHost should not need more than one channel.
3134 widget_binding_.Close();
3135 widget_binding_.Bind(std::move(request));
3136}
3137
Ken Buchanan94c0beb62018-06-22 19:56:243138void RenderWidget::SetMouseCapture(bool capture) {
3139 if (mojom::WidgetInputHandlerHost* host =
3140 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
3141 host->SetMouseCapture(capture);
3142 }
3143}
3144
danakj53802692018-07-25 21:46:443145void RenderWidget::SetWindowScreenRect(const gfx::Rect& window_screen_rect) {
3146 if (screen_metrics_emulator_)
3147 screen_metrics_emulator_->OnUpdateWindowScreenRect(window_screen_rect);
3148 else
3149 window_screen_rect_ = window_screen_rect;
3150}
3151
Fady Samuelca9ecb72018-05-05 05:59:273152bool RenderWidget::IsSurfaceSynchronizationEnabled() const {
danakja6c10012018-07-06 14:25:363153 return layer_tree_view_ &&
3154 layer_tree_view_->IsSurfaceSynchronizationEnabled();
Fady Samuelca9ecb72018-05-05 05:59:273155}
3156
danakj53802692018-07-25 21:46:443157void RenderWidget::UseSynchronousResizeModeForTesting(bool enable) {
3158 resizing_mode_selector_->set_is_synchronous_mode(enable);
danakja2c9d0a92018-07-25 20:01:183159}
3160
3161void RenderWidget::SetDeviceScaleFactorForTesting(float factor) {
3162 device_scale_factor_for_testing_ = factor;
3163
3164 VisualProperties visual_properties;
3165 visual_properties.screen_info = screen_info_;
3166 visual_properties.screen_info.device_scale_factor = factor;
3167 visual_properties.new_size = size();
3168 visual_properties.visible_viewport_size = visible_viewport_size_;
3169 visual_properties.compositor_viewport_pixel_size =
3170 gfx::ScaleToCeiledSize(size(), factor);
3171 visual_properties.browser_controls_shrink_blink_size = false;
3172 visual_properties.top_controls_height = 0.f;
3173 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
3174 visual_properties.display_mode = display_mode_;
3175 visual_properties.local_surface_id = local_surface_id_from_parent_;
3176 // We are changing the device scale factor from the renderer, so allocate a
3177 // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
3178 if (layer_tree_view_)
3179 layer_tree_view_->RequestNewLocalSurfaceId();
3180
3181 OnSynchronizeVisualProperties(visual_properties);
3182}
3183
3184void RenderWidget::SetDeviceColorSpaceForTesting(
3185 const gfx::ColorSpace& color_space) {
3186 VisualProperties visual_properties;
3187 visual_properties.screen_info = screen_info_;
3188 visual_properties.screen_info.color_space = color_space;
3189 visual_properties.new_size = size();
3190 visual_properties.visible_viewport_size = visible_viewport_size_;
3191 visual_properties.compositor_viewport_pixel_size =
3192 compositor_viewport_pixel_size_;
3193 visual_properties.browser_controls_shrink_blink_size = false;
3194 visual_properties.top_controls_height = 0.f;
3195 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
3196 visual_properties.display_mode = display_mode_;
3197 visual_properties.local_surface_id = local_surface_id_from_parent_;
3198 // We are changing the device color space from the renderer, so allocate a
3199 // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
3200 if (layer_tree_view_)
3201 layer_tree_view_->RequestNewLocalSurfaceId();
3202 OnSynchronizeVisualProperties(visual_properties);
3203}
3204
3205void RenderWidget::SetWindowRectSynchronouslyForTesting(
3206 const gfx::Rect& new_window_rect) {
3207 SetWindowRectSynchronously(new_window_rect);
3208}
3209
3210void RenderWidget::EnableAutoResizeForTesting(const gfx::Size& min_size,
3211 const gfx::Size& max_size) {
3212 VisualProperties visual_properties;
3213 visual_properties.auto_resize_enabled = true;
3214 visual_properties.min_size_for_auto_resize = min_size;
3215 visual_properties.max_size_for_auto_resize = max_size;
3216 visual_properties.local_surface_id = base::Optional<viz::LocalSurfaceId>(
3217 viz::LocalSurfaceId(1, 1, base::UnguessableToken::Create()));
3218 OnSynchronizeVisualProperties(visual_properties);
3219}
3220
3221void RenderWidget::DisableAutoResizeForTesting(const gfx::Size& new_size) {
3222 if (!auto_resize_mode_)
3223 return;
3224
3225 VisualProperties visual_properties;
3226 visual_properties.auto_resize_enabled = false;
3227 visual_properties.screen_info = screen_info_;
3228 visual_properties.new_size = new_size;
3229 visual_properties.compositor_viewport_pixel_size =
3230 compositor_viewport_pixel_size_;
3231 visual_properties.browser_controls_shrink_blink_size =
3232 browser_controls_shrink_blink_size_;
3233 visual_properties.top_controls_height = top_controls_height_;
3234 visual_properties.visible_viewport_size = visible_viewport_size_;
3235 visual_properties.is_fullscreen_granted = is_fullscreen_granted_;
3236 visual_properties.display_mode = display_mode_;
3237 OnSynchronizeVisualProperties(visual_properties);
3238}
3239
Khushal3e96e662017-10-30 23:16:503240void RenderWidget::UpdateURLForCompositorUkm() {
danakja6c10012018-07-06 14:25:363241 DCHECK(layer_tree_view_);
Ehsan Karamad655d7b8a2018-01-12 18:38:383242 blink::WebFrameWidget* frame_widget = GetFrameWidget();
3243 if (!frame_widget)
Khushal3e96e662017-10-30 23:16:503244 return;
3245
Ehsan Karamad655d7b8a2018-01-12 18:38:383246 auto* render_frame = RenderFrameImpl::FromWebFrame(frame_widget->LocalRoot());
Khushal3e96e662017-10-30 23:16:503247 if (!render_frame->IsMainFrame())
3248 return;
3249
danakja6c10012018-07-06 14:25:363250 layer_tree_view_->SetURLForUkm(
3251 render_frame->GetWebFrame()->GetDocument().Url());
Khushal3e96e662017-10-30 23:16:503252}
3253
EhsanK955ba582017-11-30 21:14:403254blink::WebLocalFrame* RenderWidget::GetFocusedWebLocalFrameInWidget() const {
Ehsan Karamad655d7b8a2018-01-12 18:38:383255 if (auto* frame_widget = GetFrameWidget())
3256 return frame_widget->FocusedWebLocalFrameInWidget();
3257 return nullptr;
EhsanK955ba582017-11-30 21:14:403258}
3259
EhsanK22d482e2017-08-10 17:29:493260#if BUILDFLAG(ENABLE_PLUGINS)
3261PepperPluginInstanceImpl* RenderWidget::GetFocusedPepperPluginInsideWidget() {
Ehsan Karamad655d7b8a2018-01-12 18:38:383262 blink::WebFrameWidget* frame_widget = GetFrameWidget();
3263 if (!frame_widget)
EhsanK22d482e2017-08-10 17:29:493264 return nullptr;
3265
3266 // Focused pepper instance might not always be in the focused frame. For
3267 // instance if a pepper instance and its embedder frame are focused an then
3268 // another frame takes focus using javascript, the embedder frame will no
3269 // longer be focused while the pepper instance is (the embedder frame's
3270 // |focused_pepper_plugin_| is not nullptr). Especially, if the pepper plugin
3271 // is fullscreen, clicking into the pepper will not refocus the embedder
3272 // frame. This is why we have to traverse the whole frame tree to find the
3273 // focused plugin.
Ehsan Karamad655d7b8a2018-01-12 18:38:383274 blink::WebFrame* current_frame = frame_widget->LocalRoot();
EhsanK22d482e2017-08-10 17:29:493275 while (current_frame) {
3276 RenderFrameImpl* render_frame =
3277 current_frame->IsWebLocalFrame()
3278 ? RenderFrameImpl::FromWebFrame(current_frame)
3279 : nullptr;
3280 if (render_frame && render_frame->focused_pepper_plugin())
3281 return render_frame->focused_pepper_plugin();
3282 current_frame = current_frame->TraverseNext();
3283 }
3284 return nullptr;
3285}
3286#endif
3287
Ken Buchananb2c9e262018-03-10 16:53:313288gfx::Rect RenderWidget::ViewportVisibleRect() {
3289 return for_oopif_ ? compositor_visible_rect_
3290 : gfx::Rect(compositor_viewport_pixel_size_);
3291}
3292
Saman Sami50d1e0c2018-03-13 20:03:493293base::WeakPtr<RenderWidget> RenderWidget::AsWeakPtr() {
3294 return weak_ptr_factory_.GetWeakPtr();
3295}
3296
[email protected]e9ff79c2012-10-19 21:31:263297} // namespace content