blob: 6b729837a2cd2a5de0ac1ec820e83e1587d9ecda [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
dchengcedca5612016-04-09 01:40:157#include <memory>
dcheng07945f632015-12-26 07:59:328#include <utility>
9
[email protected]c27dd4f2014-05-22 18:05:1910#include "base/auto_reset.h"
[email protected]32876ae2011-11-15 22:25:2111#include "base/bind.h"
[email protected]4fb66842009-12-04 21:41:0012#include "base/command_line.h"
changwan7ded3752016-03-09 23:25:1213#include "base/feature_list.h"
initial.commit09911bf2008-07-26 23:55:2914#include "base/logging.h"
avi1023d012015-12-25 02:39:1415#include "base/macros.h"
dchengcedca5612016-04-09 01:40:1516#include "base/memory/ptr_util.h"
[email protected]b256eca2013-07-11 10:57:4017#include "base/memory/singleton.h"
[email protected]aaf68892013-07-18 00:11:3018#include "base/message_loop/message_loop.h"
asvitkine8d51e9d2016-09-02 23:55:4319#include "base/metrics/histogram_macros.h"
[email protected]aa4117f2011-12-09 22:19:2120#include "base/stl_util.h"
[email protected]74ebfb12013-06-07 20:48:0021#include "base/strings/utf_string_conversions.h"
[email protected]35b4f0c2014-06-26 16:55:2722#include "base/sys_info.h"
fdoraya19b7702016-12-23 14:19:3123#include "base/threading/thread_task_runner_handle.h"
primiano9e38d552015-01-28 04:18:0124#include "base/trace_event/trace_event.h"
[email protected]661eb9d2009-02-03 02:11:4825#include "build/build_config.h"
loyso6e6efc42017-01-21 02:23:0326#include "cc/animation/animation_host.h"
xidachenfa0199e72017-05-11 11:34:2627#include "cc/input/touch_action.h"
danakjba65a0912017-09-21 16:38:4228#include "cc/trees/layer_tree_frame_sink.h"
loyso6e6efc42017-01-21 02:23:0329#include "cc/trees/layer_tree_host.h"
Fady Samuelc645ffe2017-07-24 17:28:2030#include "components/viz/common/frame_sinks/begin_frame_source.h"
danakjf20f4502017-09-26 17:13:3131#include "components/viz/common/frame_sinks/copy_output_request.h"
paulmeyer6ef5a792016-11-08 20:33:5832#include "content/common/drag_event_source_info.h"
33#include "content/common/drag_messages.h"
jonrossa2ff4f82018-02-16 17:27:4634#include "content/common/render_frame_metadata.mojom.h"
jcivelliae1560a2016-11-01 22:40:2335#include "content/common/render_message_filter.mojom.h"
Nasko Oskovf97e8b02017-07-25 02:45:4236#include "content/common/swapped_out_messages.h"
ekaramad9053e57b2016-04-26 20:00:3837#include "content/common/text_input_state.h"
[email protected]778574e2011-03-21 22:03:5038#include "content/common/view_messages.h"
mlamouriafca06dd2017-01-27 23:35:1839#include "content/public/common/content_client.h"
changwan7ded3752016-03-09 23:25:1240#include "content/public/common/content_features.h"
[email protected]c08950d22011-10-13 22:20:2941#include "content/public/common/content_switches.h"
[email protected]a09d53ce2014-01-31 00:46:4242#include "content/public/common/context_menu_params.h"
paulmeyer90f6c31d2016-11-12 00:17:5943#include "content/public/common/drop_data.h"
Khushal3e96e662017-10-30 23:16:5044#include "content/public/common/service_names.mojom.h"
Jaebaek Seo655110e2017-12-19 23:27:3945#include "content/public/common/use_zoom_for_dsf_policy.h"
mlamouriafca06dd2017-01-27 23:35:1846#include "content/public/renderer/content_renderer_client.h"
Saman Samid189e5dfd2017-12-20 22:55:3147#include "content/renderer/browser_plugin/browser_plugin.h"
[email protected]953bd0062013-08-01 00:58:4048#include "content/renderer/cursor_utils.h"
mfomitchev2600fd7c2016-02-17 20:53:3949#include "content/renderer/devtools/render_widget_screen_metrics_emulator.h"
paulmeyer6ef5a792016-11-08 20:33:5850#include "content/renderer/drop_data_builder.h"
[email protected]b2e4c70132013-10-03 02:07:5151#include "content/renderer/external_popup_menu.h"
[email protected]586871b2014-07-22 17:05:1152#include "content/renderer/gpu/frame_swap_message_queue.h"
[email protected]586871b2014-07-22 17:05:1153#include "content/renderer/gpu/queue_message_swap_promise.h"
[email protected]ba91a792013-02-06 09:48:2854#include "content/renderer/gpu/render_widget_compositor.h"
[email protected]66fca5bc2013-05-23 06:58:2955#include "content/renderer/ime_event_guard.h"
dtapuska9ec1a912017-04-21 15:18:3156#include "content/renderer/input/main_thread_event_queue.h"
Dave Tapuska9db80842017-07-24 17:24:2657#include "content/renderer/input/widget_input_handler_manager.h"
[email protected]adab2332013-07-25 18:04:3258#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
[email protected]bffc8302014-01-23 20:52:1659#include "content/renderer/render_frame_impl.h"
[email protected]e3244ed2014-06-20 20:04:2760#include "content/renderer/render_frame_proxy.h"
[email protected]8704f89b2011-04-15 00:30:0561#include "content/renderer/render_process.h"
[email protected]f1a29a02011-10-06 23:08:4462#include "content/renderer/render_thread_impl.h"
dcheng3ce04b62015-10-26 23:30:5563#include "content/renderer/render_view_impl.h"
avi40b5be7a2016-03-03 21:13:4464#include "content/renderer/render_widget_owner_delegate.h"
tfarina556a7232014-10-05 01:02:0965#include "content/renderer/renderer_blink_platform_impl.h"
[email protected]5b45ad42013-10-25 00:42:0466#include "content/renderer/resizing_mode_selector.h"
ekaramad330ba4232016-09-23 17:57:4767#include "ipc/ipc_message_start.h"
[email protected]484955942010-08-19 16:13:1868#include "ipc/ipc_sync_message.h"
Antoine Laboure55c9ef82017-11-10 18:51:2369#include "ipc/ipc_sync_message_filter.h"
Scott Violet02e38b92018-03-27 23:42:1470#include "ppapi/buildflags/buildflags.h"
[email protected]661eb9d2009-02-03 02:11:4871#include "skia/ext/platform_canvas.h"
Blink Reformata30d4232018-04-07 15:31:0672#include "third_party/blink/public/platform/file_path_conversion.h"
73#include "third_party/blink/public/platform/scheduler/web_main_thread_scheduler.h"
74#include "third_party/blink/public/platform/scheduler/web_render_widget_scheduling_state.h"
75#include "third_party/blink/public/platform/web_cursor_info.h"
76#include "third_party/blink/public/platform/web_drag_data.h"
77#include "third_party/blink/public/platform/web_drag_operation.h"
78#include "third_party/blink/public/platform/web_mouse_event.h"
79#include "third_party/blink/public/platform/web_point.h"
80#include "third_party/blink/public/platform/web_rect.h"
81#include "third_party/blink/public/platform/web_runtime_features.h"
82#include "third_party/blink/public/platform/web_size.h"
83#include "third_party/blink/public/platform/web_string.h"
84#include "third_party/blink/public/web/web_autofill_client.h"
85#include "third_party/blink/public/web/web_device_emulation_params.h"
86#include "third_party/blink/public/web/web_frame_widget.h"
87#include "third_party/blink/public/web/web_input_method_controller.h"
88#include "third_party/blink/public/web/web_local_frame.h"
89#include "third_party/blink/public/web/web_node.h"
90#include "third_party/blink/public/web/web_page_popup.h"
91#include "third_party/blink/public/web/web_popup_menu_info.h"
92#include "third_party/blink/public/web/web_range.h"
93#include "third_party/blink/public/web/web_settings.h"
94#include "third_party/blink/public/web/web_view.h"
95#include "third_party/blink/public/web/web_widget.h"
[email protected]d353541f2012-05-03 22:45:4196#include "third_party/skia/include/core/SkShader.h"
paulmeyer90f6c31d2016-11-12 00:17:5997#include "ui/base/clipboard/clipboard.h"
Scott Violet8ff9c302018-02-22 22:28:3598#include "ui/base/ui_base_features.h"
dtapuska97286c882017-02-24 23:14:4399#include "ui/events/base_event_utils.h"
tfarina655f81d2014-12-23 02:38:50100#include "ui/gfx/geometry/point_conversions.h"
tfarina3b0452d2014-12-31 15:20:09101#include "ui/gfx/geometry/rect_conversions.h"
tfarinaebe974f02015-01-03 04:25:32102#include "ui/gfx/geometry/size_conversions.h"
[email protected]1835b9e2012-02-28 13:12:48103#include "ui/gfx/skia_util.h"
[email protected]c9e2cbbb2012-05-12 21:17:27104#include "ui/gl/gl_switches.h"
[email protected]d353541f2012-05-03 22:45:41105#include "ui/surface/transport_dib.h"
[email protected]661eb9d2009-02-03 02:11:48106
[email protected]eeb93112013-05-01 19:41:10107#if defined(OS_ANDROID)
[email protected]cefe9b152014-03-27 18:16:15108#include <android/keycodes.h>
wjmaclean1d970622017-01-21 22:28:24109#include "base/time/time.h"
[email protected]eeb93112013-05-01 19:41:10110#endif
111
[email protected]661eb9d2009-02-03 02:11:48112#if defined(OS_POSIX)
[email protected]d5282e72009-05-13 13:16:52113#include "third_party/skia/include/core/SkMallocPixelRef.h"
[email protected]d353541f2012-05-03 22:45:41114#include "third_party/skia/include/core/SkPixelRef.h"
[email protected]661eb9d2009-02-03 02:11:48115#endif // defined(OS_POSIX)
[email protected]8085dbc82008-09-26 22:53:44116
sadrul943e3b32016-08-04 18:22:59117#if defined(USE_AURA)
sadrul602ce1362017-01-26 06:41:10118#include "content/renderer/mus/renderer_window_tree_client.h"
penghuang28a5fa22015-12-02 17:58:19119#endif
120
ekaramad330ba4232016-09-23 17:57:47121#if defined(OS_MACOSX)
122#include "content/renderer/text_input_client_observer.h"
123#endif
124
Ryan Landay9e42fd742017-08-12 01:59:11125using blink::WebImeTextSpan;
[email protected]180ef242013-11-07 06:50:46126using blink::WebCursorInfo;
[email protected]19193682014-04-03 15:01:43127using blink::WebDeviceEmulationParams;
paulmeyer90f6c31d2016-11-12 00:17:59128using blink::WebDragOperation;
paulmeyer6ef5a792016-11-08 20:33:58129using blink::WebDragOperationsMask;
130using blink::WebDragData;
paulmeyer90f6c31d2016-11-12 00:17:59131using blink::WebFrameWidget;
[email protected]180ef242013-11-07 06:50:46132using blink::WebGestureEvent;
paulmeyer6ef5a792016-11-08 20:33:58133using blink::WebImage;
[email protected]180ef242013-11-07 06:50:46134using blink::WebInputEvent;
dtapuska5d2e9c32015-12-03 16:39:49135using blink::WebInputEventResult;
ekaramad2daaf672016-11-10 20:29:01136using blink::WebInputMethodController;
paulmeyer6ef5a792016-11-08 20:33:58137using blink::WebLocalFrame;
[email protected]180ef242013-11-07 06:50:46138using blink::WebMouseEvent;
139using blink::WebMouseWheelEvent;
140using blink::WebNavigationPolicy;
donnda070f3c2015-01-16 19:54:11141using blink::WebNode;
[email protected]180ef242013-11-07 06:50:46142using blink::WebPagePopup;
donnda070f3c2015-01-16 19:54:11143using blink::WebPoint;
[email protected]180ef242013-11-07 06:50:46144using blink::WebPopupType;
dglazkove353a372016-09-01 01:33:48145using blink::WebRange;
[email protected]180ef242013-11-07 06:50:46146using blink::WebRect;
[email protected]180ef242013-11-07 06:50:46147using blink::WebSize;
paulmeyer90f6c31d2016-11-12 00:17:59148using blink::WebString;
[email protected]180ef242013-11-07 06:50:46149using blink::WebTextDirection;
150using blink::WebTouchEvent;
[email protected]f8ed4722013-12-03 03:27:25151using blink::WebTouchPoint;
[email protected]180ef242013-11-07 06:50:46152using blink::WebVector;
153using blink::WebWidget;
[email protected]e9ff79c2012-10-19 21:31:26154
paulmeyer90f6c31d2016-11-12 00:17:59155namespace content {
156
[email protected]6a4d7f62013-01-07 21:32:13157namespace {
[email protected]b256eca2013-07-11 10:57:40158
159typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
160
AJITH KUMAR V041c0b02017-08-08 10:39:20161static const int kInvalidNextPreviousFlagsValue = -1;
162
lfgbee1e0a2016-06-08 21:24:21163class WebWidgetLockTarget : public content::MouseLockDispatcher::LockTarget {
164 public:
165 explicit WebWidgetLockTarget(blink::WebWidget* webwidget)
166 : webwidget_(webwidget) {}
167
168 void OnLockMouseACK(bool succeeded) override {
169 if (succeeded)
Blink Reformat1c4d759e2017-04-09 16:34:54170 webwidget_->DidAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21171 else
Blink Reformat1c4d759e2017-04-09 16:34:54172 webwidget_->DidNotAcquirePointerLock();
lfgbee1e0a2016-06-08 21:24:21173 }
174
Blink Reformat1c4d759e2017-04-09 16:34:54175 void OnMouseLockLost() override { webwidget_->DidLosePointerLock(); }
lfgbee1e0a2016-06-08 21:24:21176
177 bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event) override {
178 // The WebWidget handles mouse lock in Blink's handleInputEvent().
179 return false;
180 }
181
182 private:
183 blink::WebWidget* webwidget_;
184};
185
dglazkov97b6c2b2016-10-25 17:35:55186bool IsDateTimeInput(ui::TextInputType type) {
187 return type == ui::TEXT_INPUT_TYPE_DATE ||
188 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
189 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
190 type == ui::TEXT_INPUT_TYPE_MONTH ||
191 type == ui::TEXT_INPUT_TYPE_TIME || type == ui::TEXT_INPUT_TYPE_WEEK;
192}
193
paulmeyer90f6c31d2016-11-12 00:17:59194WebDragData DropMetaDataToWebDragData(
195 const std::vector<DropData::Metadata>& drop_meta_data) {
196 std::vector<WebDragData::Item> item_list;
197 for (const auto& meta_data_item : drop_meta_data) {
198 if (meta_data_item.kind == DropData::Kind::STRING) {
199 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54200 item.storage_type = WebDragData::Item::kStorageTypeString;
201 item.string_type = WebString::FromUTF16(meta_data_item.mime_type);
paulmeyer90f6c31d2016-11-12 00:17:59202 // Have to pass a dummy URL here instead of an empty URL because the
203 // DropData received by browser_plugins goes through a round trip:
204 // DropData::MetaData --> WebDragData-->DropData. In the end, DropData
205 // will contain an empty URL (which means no URL is dragged) if the URL in
206 // WebDragData is empty.
207 if (base::EqualsASCII(meta_data_item.mime_type,
208 ui::Clipboard::kMimeTypeURIList)) {
Blink Reformat1c4d759e2017-04-09 16:34:54209 item.string_data = WebString::FromUTF8("about:dragdrop-placeholder");
paulmeyer90f6c31d2016-11-12 00:17:59210 }
211 item_list.push_back(item);
212 continue;
213 }
214
215 // TODO(hush): crbug.com/584789. Blink needs to support creating a file with
216 // just the mimetype. This is needed to drag files to WebView on Android
217 // platform.
218 if ((meta_data_item.kind == DropData::Kind::FILENAME) &&
219 !meta_data_item.filename.empty()) {
220 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54221 item.storage_type = WebDragData::Item::kStorageTypeFilename;
222 item.filename_data = blink::FilePathToWebString(meta_data_item.filename);
paulmeyer90f6c31d2016-11-12 00:17:59223 item_list.push_back(item);
224 continue;
225 }
226
227 if (meta_data_item.kind == DropData::Kind::FILESYSTEMFILE) {
228 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54229 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
230 item.file_system_url = meta_data_item.file_system_url;
paulmeyer90f6c31d2016-11-12 00:17:59231 item_list.push_back(item);
232 continue;
233 }
234 }
235
236 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54237 result.Initialize();
238 result.SetItems(item_list);
paulmeyer90f6c31d2016-11-12 00:17:59239 return result;
240}
241
242WebDragData DropDataToWebDragData(const DropData& drop_data) {
243 std::vector<WebDragData::Item> item_list;
244
245 // These fields are currently unused when dragging into WebKit.
246 DCHECK(drop_data.download_metadata.empty());
247 DCHECK(drop_data.file_contents.empty());
dcheng3dd85612017-02-08 10:46:23248 DCHECK(drop_data.file_contents_content_disposition.empty());
paulmeyer90f6c31d2016-11-12 00:17:59249
250 if (!drop_data.text.is_null()) {
251 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54252 item.storage_type = WebDragData::Item::kStorageTypeString;
253 item.string_type = WebString::FromUTF8(ui::Clipboard::kMimeTypeText);
254 item.string_data = WebString::FromUTF16(drop_data.text.string());
paulmeyer90f6c31d2016-11-12 00:17:59255 item_list.push_back(item);
256 }
257
258 if (!drop_data.url.is_empty()) {
259 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54260 item.storage_type = WebDragData::Item::kStorageTypeString;
261 item.string_type = WebString::FromUTF8(ui::Clipboard::kMimeTypeURIList);
262 item.string_data = WebString::FromUTF8(drop_data.url.spec());
263 item.title = WebString::FromUTF16(drop_data.url_title);
paulmeyer90f6c31d2016-11-12 00:17:59264 item_list.push_back(item);
265 }
266
267 if (!drop_data.html.is_null()) {
268 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54269 item.storage_type = WebDragData::Item::kStorageTypeString;
270 item.string_type = WebString::FromUTF8(ui::Clipboard::kMimeTypeHTML);
271 item.string_data = WebString::FromUTF16(drop_data.html.string());
272 item.base_url = drop_data.html_base_url;
paulmeyer90f6c31d2016-11-12 00:17:59273 item_list.push_back(item);
274 }
275
276 for (std::vector<ui::FileInfo>::const_iterator it =
277 drop_data.filenames.begin();
278 it != drop_data.filenames.end();
279 ++it) {
280 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54281 item.storage_type = WebDragData::Item::kStorageTypeFilename;
282 item.filename_data = blink::FilePathToWebString(it->path);
283 item.display_name_data =
kinukoa4293022017-01-27 06:43:25284 blink::FilePathToWebString(base::FilePath(it->display_name));
paulmeyer90f6c31d2016-11-12 00:17:59285 item_list.push_back(item);
286 }
287
288 for (std::vector<DropData::FileSystemFileInfo>::const_iterator it =
289 drop_data.file_system_files.begin();
290 it != drop_data.file_system_files.end();
291 ++it) {
292 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54293 item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile;
294 item.file_system_url = it->url;
295 item.file_system_file_size = it->size;
296 item.file_system_id = blink::WebString::FromASCII(it->filesystem_id);
paulmeyer90f6c31d2016-11-12 00:17:59297 item_list.push_back(item);
298 }
299
Stuart Langley48300392017-11-02 03:54:44300 for (const auto& it : drop_data.custom_data) {
paulmeyer90f6c31d2016-11-12 00:17:59301 WebDragData::Item item;
Blink Reformat1c4d759e2017-04-09 16:34:54302 item.storage_type = WebDragData::Item::kStorageTypeString;
Stuart Langley48300392017-11-02 03:54:44303 item.string_type = WebString::FromUTF16(it.first);
304 item.string_data = WebString::FromUTF16(it.second);
paulmeyer90f6c31d2016-11-12 00:17:59305 item_list.push_back(item);
306 }
307
308 WebDragData result;
Blink Reformat1c4d759e2017-04-09 16:34:54309 result.Initialize();
310 result.SetItems(item_list);
311 result.SetFilesystemId(WebString::FromUTF16(drop_data.filesystem_id));
paulmeyer90f6c31d2016-11-12 00:17:59312 return result;
313}
314
lfg1568d112016-08-30 16:06:29315content::RenderWidget::CreateRenderWidgetFunction g_create_render_widget =
316 nullptr;
317
318content::RenderWidget::RenderWidgetInitializedCallback
319 g_render_widget_initialized = nullptr;
320
dtapuskac4dd5be2016-10-25 15:11:10321ui::TextInputType ConvertWebTextInputType(blink::WebTextInputType type) {
322 // Check the type is in the range representable by ui::TextInputType.
323 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX))
324 << "blink::WebTextInputType and ui::TextInputType not synchronized";
325 return static_cast<ui::TextInputType>(type);
326}
327
328ui::TextInputMode ConvertWebTextInputMode(blink::WebTextInputMode mode) {
329 // Check the mode is in the range representable by ui::TextInputMode.
330 DCHECK_LE(mode, static_cast<int>(ui::TEXT_INPUT_MODE_MAX))
331 << "blink::WebTextInputMode and ui::TextInputMode not synchronized";
332 return static_cast<ui::TextInputMode>(mode);
333}
334
Mitsuru Oshima3c07b332018-02-06 04:56:50335// Returns true if the device scale is high enough that losing subpixel
336// antialiasing won't have a noticeable effect on text quality.
337static bool DeviceScaleEnsuresTextQuality(float device_scale_factor) {
338#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
339 // On Android, we never have subpixel antialiasing. On Chrome OS we prefer to
340 // composite all scrollers so that we get animated overlay scrollbars.
341 return true;
342#else
343 // 1.5 is a common touchscreen tablet device scale factor. For such
344 // devices main thread antialiasing is a heavy burden.
345 return device_scale_factor >= 1.5f;
346#endif
347}
348
349static bool PreferCompositingToLCDText(CompositorDependencies* compositor_deps,
350 float device_scale_factor) {
351 const base::CommandLine& command_line =
352 *base::CommandLine::ForCurrentProcess();
353 if (command_line.HasSwitch(switches::kDisablePreferCompositingToLCDText))
354 return false;
355 if (command_line.HasSwitch(switches::kEnablePreferCompositingToLCDText))
356 return true;
357 if (!compositor_deps->IsLcdTextEnabled())
358 return true;
359 return DeviceScaleEnsuresTextQuality(device_scale_factor);
360}
361
[email protected]b256eca2013-07-11 10:57:40362} // namespace
363
[email protected]b2e4c70132013-10-03 02:07:51364// RenderWidget ---------------------------------------------------------------
365
Hajime Hoshiabb3c8f2017-12-04 18:41:39366RenderWidget::RenderWidget(
367 int32_t widget_routing_id,
368 CompositorDependencies* compositor_deps,
369 blink::WebPopupType popup_type,
370 const ScreenInfo& screen_info,
371 bool swapped_out,
372 bool hidden,
373 bool never_visible,
374 scoped_refptr<base::SingleThreadTaskRunner> task_runner,
375 mojom::WidgetRequest widget_request)
nick8331f8ad2016-11-15 20:42:45376 : routing_id_(widget_routing_id),
dcheng35d31c112015-07-22 00:17:36377 compositor_deps_(compositor_deps),
lfg8ff33912016-09-13 20:59:21378 webwidget_internal_(nullptr),
avi40b5be7a2016-03-03 21:13:44379 owner_delegate_(nullptr),
initial.commit09911bf2008-07-26 23:55:29380 next_paint_flags_(0),
[email protected]847a2582013-03-09 02:29:51381 auto_resize_mode_(false),
Fady Samueld10aadd82017-11-03 18:23:57382 need_resize_ack_for_auto_resize_(false),
initial.commit09911bf2008-07-26 23:55:29383 did_show_(false),
[email protected]1ac10dca2013-08-20 20:47:04384 is_hidden_(hidden),
sievers71c62dd52015-10-07 01:44:39385 compositor_never_visible_(never_visible),
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12386 is_fullscreen_granted_(false),
Blink Reformat1c4d759e2017-04-09 16:34:54387 display_mode_(blink::kWebDisplayModeUndefined),
changwanf2a707b2015-10-30 08:22:16388 ime_event_guard_(nullptr),
[email protected]661eb9d2009-02-03 02:11:48389 closing_(false),
[email protected]aeeedad2014-08-22 18:16:22390 host_closing_(false),
[email protected]14392a52012-05-02 20:28:44391 is_swapped_out_(swapped_out),
dglazkov97b6c2b2016-10-25 17:35:55392 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
[email protected]b256eca2013-07-11 10:57:40393 text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
shuchen82ce8c52014-10-23 01:55:20394 text_input_flags_(0),
AJITH KUMAR V041c0b02017-08-08 10:39:20395 next_previous_flags_(kInvalidNextPreviousFlagsValue),
[email protected]86ba5fcb2013-09-04 00:36:53396 can_compose_inline_(true),
nonafa291792016-08-10 02:36:18397 composition_range_(gfx::Range::InvalidRange()),
[email protected]3e2b375b2010-04-07 17:03:12398 popup_type_(popup_type),
[email protected]867125a02009-12-10 06:01:48399 pending_window_rect_count_(0),
[email protected]842f10652012-06-06 01:54:04400 screen_info_(screen_info),
nonafa291792016-08-10 02:36:18401 monitor_composition_info_(false),
[email protected]b2e4c70132013-10-03 02:07:51402 popup_origin_scale_for_emulation_(0.f),
samans26510e442017-06-01 22:29:12403 frame_swap_message_queue_(new FrameSwapMessageQueue(routing_id_)),
[email protected]a09d53ce2014-01-31 00:46:42404 resizing_mode_selector_(new ResizingModeSelector()),
lfge0c2792ec2016-05-11 18:52:08405 has_host_context_menu_location_(false),
ekaramad2a46d632016-07-19 13:33:09406 has_focus_(false),
Nicolas Pena75a35d662018-04-05 20:13:44407 for_oopif_(false),
ekaramad330ba4232016-09-23 17:57:47408#if defined(OS_MACOSX)
409 text_input_client_observer_(new TextInputClientObserver(this)),
410#endif
Takashi SAKAMOTO870f6262017-08-22 04:08:27411 first_update_visual_state_after_hidden_(false),
tasakb95dbb50c2017-02-08 18:07:50412 was_shown_time_(base::TimeTicks::Now()),
kenrb5d78b842017-03-06 21:06:01413 current_content_source_id_(0),
Dave Tapuska1bdf1832017-07-07 18:07:19414 widget_binding_(this, std::move(widget_request)),
Hajime Hoshiabb3c8f2017-12-04 18:41:39415 task_runner_(task_runner),
wjmaclean1d970622017-01-21 22:28:24416 weak_ptr_factory_(this) {
nick8331f8ad2016-11-15 20:42:45417 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
[email protected]8b3f0eb2012-05-03 19:15:05418 if (!swapped_out)
419 RenderProcess::current()->AddRefProcess();
[email protected]380244092011-10-07 17:26:27420 DCHECK(RenderThread::Get());
alexclarke7fa93942015-10-21 15:37:11421
422 // In tests there may not be a RenderThreadImpl.
423 if (RenderThreadImpl::current()) {
424 render_widget_scheduling_state_ = RenderThreadImpl::current()
Yuta Kitamura3331f5c2018-04-05 11:12:25425 ->GetWebMainThreadScheduler()
dcheng07945f632015-12-26 07:59:32426 ->NewRenderWidgetSchedulingState();
alexclarke7fa93942015-10-21 15:37:11427 render_widget_scheduling_state_->SetHidden(is_hidden_);
428 }
sadrul602ce1362017-01-26 06:41:10429#if defined(USE_AURA)
fsamuel098eade2017-03-21 18:06:14430 RendererWindowTreeClient::CreateIfNecessary(routing_id_);
Scott Violet8ff9c302018-02-22 22:28:35431 if (features::IsMusEnabled())
Scott Violet1098538e2017-10-05 19:23:33432 RendererWindowTreeClient::Get(routing_id_)->SetVisible(!is_hidden_);
sadrul602ce1362017-01-26 06:41:10433#endif
initial.commit09911bf2008-07-26 23:55:29434}
435
436RenderWidget::~RenderWidget() {
lfg8ff33912016-09-13 20:59:21437 DCHECK(!webwidget_internal_) << "Leaking our WebWidget!";
[email protected]bffc8302014-01-23 20:52:16438
dtapuska9ec1a912017-04-21 15:18:31439 if (input_event_queue_)
440 input_event_queue_->ClearClient();
441
[email protected]992db4c2011-05-12 15:37:15442 // If we are swapped out, we have released already.
[email protected]d2e2f9ee2013-08-21 11:02:02443 if (!is_swapped_out_ && RenderProcess::current())
[email protected]992db4c2011-05-12 15:37:15444 RenderProcess::current()->ReleaseProcess();
sadrul8185d972017-01-31 18:30:11445#if defined(USE_AURA)
fsamuel098eade2017-03-21 18:06:14446 // It is possible for a RenderWidget to be destroyed before it was embedded
447 // in a mus window. The RendererWindowTreeClient will leak in such cases. So
448 // explicitly delete it here.
449 RendererWindowTreeClient::Destroy(routing_id_);
sadrul8185d972017-01-31 18:30:11450#endif
initial.commit09911bf2008-07-26 23:55:29451}
452
[email protected]484955942010-08-19 16:13:18453// static
lfg1568d112016-08-30 16:06:29454void RenderWidget::InstallCreateHook(
455 CreateRenderWidgetFunction create_render_widget,
456 RenderWidgetInitializedCallback render_widget_initialized) {
457 CHECK(!g_create_render_widget && !g_render_widget_initialized);
458 g_create_render_widget = create_render_widget;
459 g_render_widget_initialized = render_widget_initialized;
460}
461
462// static
nickf7b38222016-11-22 21:59:35463RenderWidget* RenderWidget::CreateForPopup(
464 RenderViewImpl* opener,
465 CompositorDependencies* compositor_deps,
466 blink::WebPopupType popup_type,
Hajime Hoshiabb3c8f2017-12-04 18:41:39467 const ScreenInfo& screen_info,
468 scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
Dave Tapuska1bdf1832017-07-07 18:07:19469 mojom::WidgetPtr widget_channel;
470 mojom::WidgetRequest widget_channel_request =
471 mojo::MakeRequest(&widget_channel);
472
nick4df698d82016-11-11 20:39:23473 // Do a synchronous IPC to obtain a routing ID.
474 int32_t routing_id = MSG_ROUTING_NONE;
475 if (!RenderThreadImpl::current_render_message_filter()->CreateNewWidget(
Dave Tapuska1bdf1832017-07-07 18:07:19476 opener->GetRoutingID(), popup_type, std::move(widget_channel),
477 &routing_id)) {
nick4df698d82016-11-11 20:39:23478 return nullptr;
479 }
480
Hajime Hoshiabb3c8f2017-12-04 18:41:39481 scoped_refptr<RenderWidget> widget(new RenderWidget(
482 routing_id, compositor_deps, popup_type, screen_info, false, false, false,
483 task_runner, std::move(widget_channel_request)));
nickf7b38222016-11-22 21:59:35484 ShowCallback opener_callback =
wjmaclean1d970622017-01-21 22:28:24485 base::Bind(&RenderViewImpl::ShowCreatedPopupWidget, opener->GetWeakPtr());
Tommy Nyquist4b749d02018-03-20 21:46:29486 widget->Init(std::move(opener_callback),
487 RenderWidget::CreateWebWidget(widget.get()));
nick4df698d82016-11-11 20:39:23488 DCHECK(!widget->HasOneRef()); // RenderWidget::Init() adds a reference.
489 return widget.get();
initial.commit09911bf2008-07-26 23:55:29490}
491
[email protected]484955942010-08-19 16:13:18492// static
kenrba7199832015-01-22 23:44:59493RenderWidget* RenderWidget::CreateForFrame(
nick4df698d82016-11-11 20:39:23494 int widget_routing_id,
kenrba7199832015-01-22 23:44:59495 bool hidden,
ccameron2f451532016-09-07 21:49:27496 const ScreenInfo& screen_info,
kenrba7199832015-01-22 23:44:59497 CompositorDependencies* compositor_deps,
498 blink::WebLocalFrame* frame) {
nick4df698d82016-11-11 20:39:23499 CHECK_NE(widget_routing_id, MSG_ROUTING_NONE);
dcheng3ce04b62015-10-26 23:30:55500 // TODO(avi): Before RenderViewImpl has-a RenderWidget, the browser passes the
501 // same routing ID for both the view routing ID and the main frame widget
502 // routing ID. https://crbug.com/545684
nick4df698d82016-11-11 20:39:23503 RenderViewImpl* view = RenderViewImpl::FromRoutingID(widget_routing_id);
dcheng3ce04b62015-10-26 23:30:55504 if (view) {
avi8a45c1092016-03-01 16:12:34505 view->AttachWebFrameWidget(
506 RenderWidget::CreateWebFrameWidget(view->GetWidget(), frame));
Lucas Furukawa Gadani6ccadf72018-02-13 10:29:10507 view->GetWidget()->UpdateWebViewWithDeviceScaleFactor();
avi8a45c1092016-03-01 16:12:34508 return view->GetWidget();
dcheng3ce04b62015-10-26 23:30:55509 }
Hajime Hoshiabb3c8f2017-12-04 18:41:39510 scoped_refptr<base::SingleThreadTaskRunner> task_runner =
511 frame->GetTaskRunner(blink::TaskType::kUnthrottled);
dcheng35d31c112015-07-22 00:17:36512 scoped_refptr<RenderWidget> widget(
lfg1568d112016-08-30 16:06:29513 g_create_render_widget
nick8331f8ad2016-11-15 20:42:45514 ? g_create_render_widget(widget_routing_id, compositor_deps,
Blink Reformat1c4d759e2017-04-09 16:34:54515 blink::kWebPopupTypeNone, screen_info, false,
nick8331f8ad2016-11-15 20:42:45516 hidden, false)
517 : new RenderWidget(widget_routing_id, compositor_deps,
Blink Reformat1c4d759e2017-04-09 16:34:54518 blink::kWebPopupTypeNone, screen_info, false,
Hajime Hoshiabb3c8f2017-12-04 18:41:39519 hidden, false, task_runner));
simonhong628f9812015-04-27 23:13:20520 widget->for_oopif_ = true;
nick4df698d82016-11-11 20:39:23521 // Init increments the reference count on |widget|, keeping it alive after
kenrba7199832015-01-22 23:44:59522 // this function returns.
nickf7b38222016-11-22 21:59:35523 widget->Init(RenderWidget::ShowCallback(),
nick4df698d82016-11-11 20:39:23524 RenderWidget::CreateWebFrameWidget(widget.get(), frame));
Lucas Furukawa Gadani6ccadf72018-02-13 10:29:10525 widget->UpdateWebViewWithDeviceScaleFactor();
nick4df698d82016-11-11 20:39:23526
527 if (g_render_widget_initialized)
528 g_render_widget_initialized(widget.get());
529 return widget.get();
kenrba7199832015-01-22 23:44:59530}
531
532// static
lfgcaab5142016-02-26 19:06:52533blink::WebFrameWidget* RenderWidget::CreateWebFrameWidget(
dchengda9b4bb2015-07-20 20:58:08534 RenderWidget* render_widget,
535 blink::WebLocalFrame* frame) {
Blink Reformat1c4d759e2017-04-09 16:34:54536 return blink::WebFrameWidget::Create(render_widget, frame);
dchengda9b4bb2015-07-20 20:58:08537}
538
539// static
kenrba7199832015-01-22 23:44:59540blink::WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) {
[email protected]484955942010-08-19 16:13:18541 switch (render_widget->popup_type_) {
Blink Reformat1c4d759e2017-04-09 16:34:54542 case blink::kWebPopupTypeNone: // Nothing to create.
[email protected]484955942010-08-19 16:13:18543 break;
Blink Reformat1c4d759e2017-04-09 16:34:54544 case blink::kWebPopupTypePage:
545 return WebPagePopup::Create(render_widget);
[email protected]484955942010-08-19 16:13:18546 default:
547 NOTREACHED();
548 }
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28549 return nullptr;
[email protected]484955942010-08-19 16:13:18550}
551
dchengda9b4bb2015-07-20 20:58:08552void RenderWidget::CloseForFrame() {
dchengd96a27a2015-07-24 20:17:32553 OnClose();
kenrba7199832015-01-22 23:44:59554}
555
alexmos78c9c0d2016-10-14 18:57:03556void RenderWidget::SetSwappedOut(bool is_swapped_out) {
557 // We should only toggle between states.
558 DCHECK(is_swapped_out_ != is_swapped_out);
559 is_swapped_out_ = is_swapped_out;
560
561 // If we are swapping out, we will call ReleaseProcess, allowing the process
562 // to exit if all of its RenderViews are swapped out. We wait until the
563 // WasSwappedOut call to do this, to allow the unload handler to finish.
564 // If we are swapping in, we call AddRefProcess to prevent the process from
565 // exiting.
566 if (!is_swapped_out_)
567 RenderProcess::current()->AddRefProcess();
568}
569
nickf7b38222016-11-22 21:59:35570void RenderWidget::Init(const ShowCallback& show_callback,
571 WebWidget* web_widget) {
lfg8ff33912016-09-13 20:59:21572 DCHECK(!webwidget_internal_);
nick4df698d82016-11-11 20:39:23573 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29574
Jeremy Roman04f27c372017-10-27 15:20:55575 input_handler_ = std::make_unique<RenderWidgetInputHandler>(this, this);
nick8331f8ad2016-11-15 20:42:45576
Dave Tapuska04bc5ee92018-04-17 19:03:31577 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
Dave Tapuska9db80842017-07-24 17:24:26578
Dave Tapuska04bc5ee92018-04-17 19:03:31579 widget_input_handler_manager_ = WidgetInputHandlerManager::Create(
580 weak_ptr_factory_.GetWeakPtr(),
581 render_thread_impl && compositor_
582 ? render_thread_impl->compositor_task_runner()
583 : nullptr,
584 render_thread_impl ? render_thread_impl->GetWebMainThreadScheduler()
585 : nullptr);
Dave Tapuska9db80842017-07-24 17:24:26586
nickf7b38222016-11-22 21:59:35587 show_callback_ = show_callback;
initial.commit09911bf2008-07-26 23:55:29588
lfg8ff33912016-09-13 20:59:21589 webwidget_internal_ = web_widget;
590 webwidget_mouse_lock_target_.reset(
591 new WebWidgetLockTarget(webwidget_internal_));
lfgbee1e0a2016-06-08 21:24:21592 mouse_lock_dispatcher_.reset(new RenderWidgetMouseLockDispatcher(this));
initial.commit09911bf2008-07-26 23:55:29593
nick4df698d82016-11-11 20:39:23594 RenderThread::Get()->AddRoute(routing_id_, this);
595 // Take a reference on behalf of the RenderThread. This will be balanced
596 // when we receive ViewMsg_Close.
597 AddRef();
598 if (RenderThreadImpl::current()) {
599 RenderThreadImpl::current()->WidgetCreated();
600 if (is_hidden_)
601 RenderThreadImpl::current()->WidgetHidden();
initial.commit09911bf2008-07-26 23:55:29602 }
603}
604
[email protected]949b6592014-08-20 13:17:52605void RenderWidget::WasSwappedOut() {
606 // If we have been swapped out and no one else is using this process,
607 // it's safe to exit now.
608 CHECK(is_swapped_out_);
609 RenderProcess::current()->ReleaseProcess();
610}
611
[email protected]b2e4c70132013-10-03 02:07:51612void RenderWidget::SetPopupOriginAdjustmentsForEmulation(
mfomitchev2600fd7c2016-02-17 20:53:39613 RenderWidgetScreenMetricsEmulator* emulator) {
[email protected]b2e4c70132013-10-03 02:07:51614 popup_origin_scale_for_emulation_ = emulator->scale();
[email protected]19193682014-04-03 15:01:43615 popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
Pavel Feldmancc099f72017-07-20 23:09:00616 popup_screen_origin_for_emulation_ =
Lei Zhang9b359d32017-11-28 00:57:02617 emulator->original_screen_rect().origin();
Christopher Cameronaad15a0d2018-03-09 03:47:33618 UpdateSurfaceAndScreenInfo(local_surface_id_, compositor_viewport_pixel_size_,
Christopher Camerone9a30c12018-03-07 08:23:38619 emulator->original_screen_info());
[email protected]b2e4c70132013-10-03 02:07:51620}
621
[email protected]2d6836f42014-07-02 17:25:31622gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) {
623 if (screen_metrics_emulator_)
624 return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor);
625 return anchor;
626}
627
thakis18e426412017-03-15 12:06:37628#if BUILDFLAG(USE_EXTERNAL_POPUP_MENU)
[email protected]b2e4c70132013-10-03 02:07:51629void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
mfomitchev2600fd7c2016-02-17 20:53:39630 ExternalPopupMenu* popup,
631 RenderWidgetScreenMetricsEmulator* emulator) {
Pavel Feldmancc099f72017-07-20 23:09:00632 popup->SetOriginScaleForEmulation(emulator->scale());
[email protected]b2e4c70132013-10-03 02:07:51633}
[email protected]53907862014-03-25 15:42:40634#endif
[email protected]b2e4c70132013-10-03 02:07:51635
[email protected]b2e4c70132013-10-03 02:07:51636void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
637 if (screen_metrics_emulator_)
638 screen_metrics_emulator_->OnShowContextMenu(params);
639}
640
[email protected]a95986a82010-12-24 06:19:28641bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
ekaramad330ba4232016-09-23 17:57:47642#if defined(OS_MACOSX)
643 if (IPC_MESSAGE_CLASS(message) == TextInputClientMsgStart)
644 return text_input_client_observer_->OnMessageReceived(message);
645#endif
lfgbee1e0a2016-06-08 21:24:21646 if (mouse_lock_dispatcher_ &&
647 mouse_lock_dispatcher_->OnMessageReceived(message))
648 return true;
649
[email protected]a95986a82010-12-24 06:19:28650 bool handled = true;
651 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
wjmacleanee244e02017-05-26 21:06:07652 IPC_MESSAGE_HANDLER(ViewMsg_ShowContextMenu, OnShowContextMenu)
[email protected]a95986a82010-12-24 06:19:28653 IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
[email protected]a95986a82010-12-24 06:19:28654 IPC_MESSAGE_HANDLER(ViewMsg_Resize, OnResize)
dgozman9260b0a12015-03-16 13:45:20655 IPC_MESSAGE_HANDLER(ViewMsg_EnableDeviceEmulation,
656 OnEnableDeviceEmulation)
657 IPC_MESSAGE_HANDLER(ViewMsg_DisableDeviceEmulation,
658 OnDisableDeviceEmulation)
[email protected]a95986a82010-12-24 06:19:28659 IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
[email protected]9e2e4632012-07-27 16:38:41660 IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
[email protected]3d9ec5052013-01-02 22:05:25661 IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
[email protected]a95986a82010-12-24 06:19:28662 IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
663 IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
[email protected]80ad8622012-11-07 16:33:03664 IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
kenrbea731792017-01-13 15:10:48665 IPC_MESSAGE_HANDLER(ViewMsg_SetViewportIntersection,
666 OnSetViewportIntersection)
kenrb04323782017-06-23 01:23:32667 IPC_MESSAGE_HANDLER(ViewMsg_SetIsInert, OnSetIsInert)
Ken Buchanan8a319fb2017-11-15 18:37:12668 IPC_MESSAGE_HANDLER(ViewMsg_UpdateRenderThrottlingStatus,
669 OnUpdateRenderThrottlingStatus)
lfg43e08e62016-02-03 18:51:37670 IPC_MESSAGE_HANDLER(ViewMsg_WaitForNextFrameForTests,
671 OnWaitNextFrameForTests)
paulmeyer90f6c31d2016-11-12 00:17:59672 IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter)
673 IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver, OnDragTargetDragOver)
674 IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave, OnDragTargetDragLeave)
675 IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop)
paulmeyer8fc8ea92016-11-15 05:12:21676 IPC_MESSAGE_HANDLER(DragMsg_SourceEnded, OnDragSourceEnded)
677 IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded,
678 OnDragSourceSystemDragEnded)
[email protected]a95986a82010-12-24 06:19:28679 IPC_MESSAGE_UNHANDLED(handled = false)
680 IPC_END_MESSAGE_MAP()
681 return handled;
682}
initial.commit09911bf2008-07-26 23:55:29683
684bool RenderWidget::Send(IPC::Message* message) {
Nasko Oskovf97e8b02017-07-25 02:45:42685 // Don't send any messages after the browser has told us to close, and filter
686 // most outgoing messages while swapped out.
687 if ((is_swapped_out_ &&
688 !SwappedOutMessages::CanSendWhileSwappedOut(message)) ||
689 closing_) {
initial.commit09911bf2008-07-26 23:55:29690 delete message;
691 return false;
692 }
693
694 // If given a messsage without a routing ID, then assign our routing ID.
695 if (message->routing_id() == MSG_ROUTING_NONE)
696 message->set_routing_id(routing_id_);
697
[email protected]380244092011-10-07 17:26:27698 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44699}
700
dtapuska014ed082016-11-11 21:58:48701void RenderWidget::SendOrCrash(IPC::Message* message) {
702 bool result = Send(message);
703 CHECK(closing_ || result) << "Failed to send message";
704}
705
ekaramad5aff1942017-01-06 01:26:35706bool RenderWidget::ShouldHandleImeEvents() const {
ekaramadb6483a052017-02-10 02:23:26707 // TODO(ekaramad): We track page focus in all RenderViews on the page but the
708 // RenderWidgets corresponding to OOPIFs do not get the update. For now, this
709 // method returns true when the RenderWidget is for an OOPIF, i.e., IME events
710 // will be processed regardless of page focus. We should revisit this after
711 // page focus for OOPIFs has been fully resolved (https://crbug.com/689777).
Blink Reformat1c4d759e2017-04-09 16:34:54712 return GetWebWidget() && GetWebWidget()->IsWebFrameWidget() &&
ekaramadb6483a052017-02-10 02:23:26713 (has_focus_ || for_oopif_);
ekaramad5aff1942017-01-06 01:26:35714}
715
bokanc007c3a2015-02-03 07:15:56716void RenderWidget::SetWindowRectSynchronously(
717 const gfx::Rect& new_window_rect) {
mfomitchev2600fd7c2016-02-17 20:53:39718 ResizeParams params;
719 params.screen_info = screen_info_;
720 params.new_size = new_window_rect.size();
Fady Samuela863f152018-03-09 16:10:03721 params.compositor_viewport_pixel_size = gfx::ScaleToCeiledSize(
722 new_window_rect.size(), GetWebScreenInfo().device_scale_factor);
mfomitchev2600fd7c2016-02-17 20:53:39723 params.visible_viewport_size = new_window_rect.size();
mfomitchev2600fd7c2016-02-17 20:53:39724 params.is_fullscreen_granted = is_fullscreen_granted_;
725 params.display_mode = display_mode_;
726 params.needs_resize_ack = false;
727 Resize(params);
728
bokanc007c3a2015-02-03 07:15:56729 view_screen_rect_ = new_window_rect;
730 window_screen_rect_ = new_window_rect;
[email protected]92650162013-10-30 03:31:02731 if (!did_show_)
bokanc007c3a2015-02-03 07:15:56732 initial_rect_ = new_window_rect;
[email protected]92650162013-10-30 03:31:02733}
734
initial.commit09911bf2008-07-26 23:55:29735void RenderWidget::OnClose() {
dchengd96a27a2015-07-24 20:17:32736 DCHECK(content::RenderThread::Get());
737 if (closing_)
738 return;
739 NotifyOnClose();
740 closing_ = true;
741
742 // Browser correspondence is no longer needed at this point.
743 if (routing_id_ != MSG_ROUTING_NONE) {
744 RenderThread::Get()->RemoveRoute(routing_id_);
745 SetHidden(false);
746 if (RenderThreadImpl::current())
747 RenderThreadImpl::current()->WidgetDestroyed();
748 }
749
750 if (for_oopif_) {
751 // Widgets for frames may be created and closed at any time while the frame
Ken Buchananed449bb2018-02-01 21:02:05752 // is alive. However, WebWidget must be closed synchronously because frame
753 // widgets and frames hold pointers to each other. The deferred call to
754 // Close() will complete cleanup and release |this|, but CloseWebWidget()
755 // prevents Close() from attempting to access members of an
756 // already-deleted frame.
757 CloseWebWidget();
dchengd96a27a2015-07-24 20:17:32758 }
Ken Buchananed449bb2018-02-01 21:02:05759 // If there is a Send call on the stack, then it could be dangerous to close
760 // now. Post a task that only gets invoked when there are no nested message
761 // loops.
762 task_runner_->PostNonNestableTask(FROM_HERE,
763 base::BindOnce(&RenderWidget::Close, this));
dchengd96a27a2015-07-24 20:17:32764
765 // Balances the AddRef taken when we called AddRoute.
766 Release();
initial.commit09911bf2008-07-26 23:55:29767}
768
fsamuel664e8b62016-01-20 19:54:01769void RenderWidget::OnResize(const ResizeParams& params) {
EhsanKbd2cea992017-11-23 18:49:08770 gfx::Size old_visible_viewport_size = visible_viewport_size_;
771
[email protected]5b45ad42013-10-25 00:42:04772 if (resizing_mode_selector_->ShouldAbortOnResize(this, params))
[email protected]03e88672013-10-22 21:31:32773 return;
774
[email protected]b2e4c70132013-10-03 02:07:51775 if (screen_metrics_emulator_) {
mfomitchev2600fd7c2016-02-17 20:53:39776 screen_metrics_emulator_->OnResize(params);
[email protected]b2e4c70132013-10-03 02:07:51777 return;
778 }
779
mfomitchev2600fd7c2016-02-17 20:53:39780 Resize(params);
EhsanKbd2cea992017-11-23 18:49:08781
782 if (old_visible_viewport_size != visible_viewport_size_) {
783 for (auto& render_frame : render_frames_)
784 render_frame.DidChangeVisibleViewport();
785 }
initial.commit09911bf2008-07-26 23:55:29786}
787
dgozman9260b0a12015-03-16 13:45:20788void RenderWidget::OnEnableDeviceEmulation(
Lei Zhang9b359d32017-11-28 00:57:02789 const blink::WebDeviceEmulationParams& params) {
mfomitchev2600fd7c2016-02-17 20:53:39790 if (!screen_metrics_emulator_) {
791 ResizeParams resize_params;
792 resize_params.screen_info = screen_info_;
793 resize_params.new_size = size_;
Christopher Cameronaad15a0d2018-03-09 03:47:33794 resize_params.compositor_viewport_pixel_size =
795 compositor_viewport_pixel_size_;
Fady Samuela41e9d42018-03-01 21:31:58796 resize_params.local_surface_id = local_surface_id_;
797 resize_params.content_source_id = current_content_source_id_;
mfomitchev2600fd7c2016-02-17 20:53:39798 resize_params.visible_viewport_size = visible_viewport_size_;
mfomitchev2600fd7c2016-02-17 20:53:39799 resize_params.is_fullscreen_granted = is_fullscreen_granted_;
800 resize_params.display_mode = display_mode_;
801 screen_metrics_emulator_.reset(new RenderWidgetScreenMetricsEmulator(
802 this, params, resize_params, view_screen_rect_, window_screen_rect_));
oshima50872a72016-03-04 13:26:18803 screen_metrics_emulator_->Apply();
mfomitchev2600fd7c2016-02-17 20:53:39804 } else {
dgozman9260b0a12015-03-16 13:45:20805 screen_metrics_emulator_->ChangeEmulationParams(params);
mfomitchev2600fd7c2016-02-17 20:53:39806 }
dgozman9260b0a12015-03-16 13:45:20807}
808
809void RenderWidget::OnDisableDeviceEmulation() {
810 screen_metrics_emulator_.reset();
811}
812
initial.commit09911bf2008-07-26 23:55:29813void RenderWidget::OnWasHidden() {
[email protected]9c3085f2011-06-09 02:10:31814 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
initial.commit09911bf2008-07-26 23:55:29815 // Go into a mode where we stop generating paint and scrolling events.
[email protected]bee16aab2009-08-26 15:55:03816 SetHidden(true);
ericwilligers88e69742016-10-17 19:29:55817 for (auto& observer : render_frames_)
818 observer.WasHidden();
Saman Sami58ed4392018-01-31 20:54:19819
820 // Ack the resize if we have to, so that the next time we're visible we get a
821 // fresh ResizeParams right away; otherwise we'll start painting based on a
822 // stale ResizeParams.
823 DidResizeOrRepaintAck();
initial.commit09911bf2008-07-26 23:55:29824}
825
Saman Samid709592b2018-02-03 00:38:10826void RenderWidget::OnWasShown(bool needs_repainting,
827 const ui::LatencyInfo& latency_info) {
[email protected]9e2e4632012-07-27 16:38:41828 TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
initial.commit09911bf2008-07-26 23:55:29829 // During shutdown we can just ignore this message.
lfg8ff33912016-09-13 20:59:21830 if (!GetWebWidget())
initial.commit09911bf2008-07-26 23:55:29831 return;
832
tasakb95dbb50c2017-02-08 18:07:50833 was_shown_time_ = base::TimeTicks::Now();
initial.commit09911bf2008-07-26 23:55:29834 // See OnWasHidden
[email protected]bee16aab2009-08-26 15:55:03835 SetHidden(false);
ericwilligers88e69742016-10-17 19:29:55836 for (auto& observer : render_frames_)
837 observer.WasShown();
initial.commit09911bf2008-07-26 23:55:29838
[email protected]8a23afb32014-04-30 22:40:23839 if (!needs_repainting)
initial.commit09911bf2008-07-26 23:55:29840 return;
initial.commit09911bf2008-07-26 23:55:29841
[email protected]3399dd822014-08-09 11:14:24842 if (compositor_) {
843 ui::LatencyInfo swap_latency_info(latency_info);
danakj87fbafb2017-04-04 16:54:11844 std::unique_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor =
845 compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info);
846 // Force this SwapPromiseMonitor to trigger and insert a SwapPromise.
Blink Reformat1c4d759e2017-04-09 16:34:54847 compositor_->SetNeedsBeginFrame();
[email protected]3399dd822014-08-09 11:14:24848 }
initial.commit09911bf2008-07-26 23:55:29849}
850
[email protected]53d3f302009-12-21 04:42:05851void RenderWidget::OnRequestMoveAck() {
852 DCHECK(pending_window_rect_count_);
853 pending_window_rect_count_--;
854}
855
[email protected]ed7defa2013-03-12 21:29:59856GURL RenderWidget::GetURLForGraphicsContext3D() {
857 return GURL();
[email protected]65225772011-05-12 21:10:24858}
859
Sadrul Habib Chowdhury6539b732018-01-05 21:53:27860viz::FrameSinkId RenderWidget::GetFrameSinkIdAtPoint(const gfx::Point& point) {
861 return input_handler_->GetFrameSinkIdAtPoint(point);
Navid Zolghadr0d86e5f2017-10-23 18:09:22862}
863
Dave Tapuskaea83d3bd2017-06-13 16:14:55864void RenderWidget::HandleInputEvent(
dtapuska9ec1a912017-04-21 15:18:31865 const blink::WebCoalescedInputEvent& input_event,
866 const ui::LatencyInfo& latency_info,
Dave Tapuskaea83d3bd2017-06-13 16:14:55867 HandledEventCallback callback) {
868 input_handler_->HandleInputEvent(input_event, latency_info,
869 std::move(callback));
dtapuska9ec1a912017-04-21 15:18:31870}
871
dtapuska9d46ef7d2017-05-26 19:06:06872scoped_refptr<MainThreadEventQueue> RenderWidget::GetInputEventQueue() {
873 return input_event_queue_;
874}
875
fsamuel78f86e42016-01-20 04:10:23876void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
lfg8ff33912016-09-13 20:59:21877 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:54878 GetWebWidget()->SetCursorVisibilityState(is_visible);
fsamuel78f86e42016-01-20 04:10:23879}
880
881void RenderWidget::OnMouseCaptureLost() {
lfg8ff33912016-09-13 20:59:21882 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:54883 GetWebWidget()->MouseCaptureLost();
fsamuel78f86e42016-01-20 04:10:23884}
885
alexmos56567492016-09-13 00:52:46886void RenderWidget::OnSetEditCommandsForNextKeyEvent(
887 const EditCommands& edit_commands) {
888 edit_commands_ = edit_commands;
889}
890
fsamuel78f86e42016-01-20 04:10:23891void RenderWidget::OnSetFocus(bool enable) {
lfge0c2792ec2016-05-11 18:52:08892 has_focus_ = enable;
893
lfg8ff33912016-09-13 20:59:21894 if (GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:54895 GetWebWidget()->SetFocus(enable);
lfge0c2792ec2016-05-11 18:52:08896
ericwilligers88e69742016-10-17 19:29:55897 for (auto& observer : render_frames_)
898 observer.RenderWidgetSetFocus(enable);
fsamuel78f86e42016-01-20 04:10:23899}
900
dtapuska3d5624d32016-08-30 04:34:00901void RenderWidget::SetNeedsMainFrame() {
902 RenderWidgetCompositor* rwc = compositor();
903 if (!rwc)
904 return;
Blink Reformat1c4d759e2017-04-09 16:34:54905 rwc->SetNeedsBeginFrame();
dtapuska3d5624d32016-08-30 04:34:00906}
907
fsamuel78f86e42016-01-20 04:10:23908///////////////////////////////////////////////////////////////////////////////
909// RenderWidgetCompositorDelegate
910
911void RenderWidget::ApplyViewportDeltas(
912 const gfx::Vector2dF& inner_delta,
913 const gfx::Vector2dF& outer_delta,
914 const gfx::Vector2dF& elastic_overscroll_delta,
915 float page_scale,
916 float top_controls_delta) {
Ken Buchananed449bb2018-02-01 21:02:05917 if (!GetWebWidget())
918 return;
Blink Reformat1c4d759e2017-04-09 16:34:54919 GetWebWidget()->ApplyViewportDeltas(inner_delta, outer_delta,
lfg8ff33912016-09-13 20:59:21920 elastic_overscroll_delta, page_scale,
921 top_controls_delta);
fsamuel78f86e42016-01-20 04:10:23922}
923
sahel1b47fda72017-03-28 17:03:07924void RenderWidget::RecordWheelAndTouchScrollingCount(
925 bool has_scrolled_by_wheel,
926 bool has_scrolled_by_touch) {
Ken Buchananed449bb2018-02-01 21:02:05927 if (!GetWebWidget())
928 return;
Blink Reformat1c4d759e2017-04-09 16:34:54929 GetWebWidget()->RecordWheelAndTouchScrollingCount(has_scrolled_by_wheel,
sahel1b47fda72017-03-28 17:03:07930 has_scrolled_by_touch);
931}
932
fsamuel78f86e42016-01-20 04:10:23933void RenderWidget::BeginMainFrame(double frame_time_sec) {
Ken Buchananed449bb2018-02-01 21:02:05934 if (!GetWebWidget())
935 return;
dtapuska9ec1a912017-04-21 15:18:31936 if (input_event_queue_) {
937 input_event_queue_->DispatchRafAlignedInput(
938 ui::EventTimeStampFromSeconds(frame_time_sec));
939 }
dtapuska3d5624d32016-08-30 04:34:00940
Blink Reformat1c4d759e2017-04-09 16:34:54941 GetWebWidget()->BeginFrame(frame_time_sec);
fsamuel78f86e42016-01-20 04:10:23942}
943
danakjc7afae52017-06-20 21:12:41944void RenderWidget::RequestNewLayerTreeFrameSink(
danakjc7afae52017-06-20 21:12:41945 const LayerTreeFrameSinkCallback& callback) {
lfg8ff33912016-09-13 20:59:21946 DCHECK(GetWebWidget());
[email protected]7912e822014-04-16 02:37:03947 // For widgets that are never visible, we don't start the compositor, so we
danakjc7afae52017-06-20 21:12:41948 // never get a request for a cc::LayerTreeFrameSink.
sievers71c62dd52015-10-07 01:44:39949 DCHECK(!compositor_never_visible_);
jonrossa2ff4f82018-02-16 17:27:46950
951 // TODO(jonross): have this generated by the LayerTreeFrameSink itself, which
952 // would then handle binding.
953 mojom::RenderFrameMetadataObserverPtr ptr;
954 mojom::RenderFrameMetadataObserverRequest request = mojo::MakeRequest(&ptr);
955 mojom::RenderFrameMetadataObserverClientPtrInfo client_info;
956 mojom::RenderFrameMetadataObserverClientRequest client_request =
957 mojo::MakeRequest(&client_info);
958 compositor_->CreateRenderFrameObserver(std::move(request),
959 std::move(client_info));
danakjc7afae52017-06-20 21:12:41960 RenderThreadImpl::current()->RequestNewLayerTreeFrameSink(
danakjab9ef4d2017-10-31 23:38:33961 routing_id_, frame_swap_message_queue_, GetURLForGraphicsContext3D(),
jonrossa2ff4f82018-02-16 17:27:46962 callback, std::move(client_request), std::move(ptr));
[email protected]ba91a792013-02-06 09:48:28963}
964
fsamuel78f86e42016-01-20 04:10:23965void RenderWidget::DidCommitAndDrawCompositorFrame() {
966 // NOTE: Tests may break if this event is renamed or moved. See
967 // tab_capture_performancetest.cc.
968 TRACE_EVENT0("gpu", "RenderWidget::DidCommitAndDrawCompositorFrame");
lfge0c2792ec2016-05-11 18:52:08969
ericwilligers88e69742016-10-17 19:29:55970 for (auto& observer : render_frames_)
971 observer.DidCommitAndDrawCompositorFrame();
lfge0c2792ec2016-05-11 18:52:08972
fsamuel78f86e42016-01-20 04:10:23973 // Notify subclasses that we initiated the paint operation.
974 DidInitiatePaint();
975}
976
Saman Sami766e0b02018-01-31 17:19:20977void RenderWidget::DidCommitCompositorFrame() {
Saman Samif9b3f6192018-03-29 02:59:29978 DidResizeOrRepaintAck();
Saman Sami766e0b02018-01-31 17:19:20979}
fsamuel78f86e42016-01-20 04:10:23980
981void RenderWidget::DidCompletePageScaleAnimation() {}
982
danakj6c872fc02016-10-22 04:29:49983void RenderWidget::DidReceiveCompositorFrameAck() {
fsamuel78f86e42016-01-20 04:10:23984}
985
fsamuel78f86e42016-01-20 04:10:23986bool RenderWidget::IsClosing() const {
987 return host_closing_;
988}
989
danakj53eccbc2016-03-02 22:51:07990void RenderWidget::RequestScheduleAnimation() {
Blink Reformat1c4d759e2017-04-09 16:34:54991 ScheduleAnimation();
initial.commit09911bf2008-07-26 23:55:29992}
993
Eric Seckler8af8c0e52018-01-17 23:45:53994void RenderWidget::UpdateVisualState(VisualStateUpdate requested_update) {
Ken Buchananed449bb2018-02-01 21:02:05995 if (!GetWebWidget())
996 return;
997
Eric Seckler8af8c0e52018-01-17 23:45:53998 bool pre_paint_only = requested_update == VisualStateUpdate::kPrePaint;
999 WebWidget::LifecycleUpdate lifecycle_update =
1000 pre_paint_only ? WebWidget::LifecycleUpdate::kPrePaint
1001 : WebWidget::LifecycleUpdate::kAll;
1002
1003 GetWebWidget()->UpdateLifecycle(lifecycle_update);
Blink Reformat1c4d759e2017-04-09 16:34:541004 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(false);
tasakb95dbb50c2017-02-08 18:07:501005
Eric Seckler8af8c0e52018-01-17 23:45:531006 if (first_update_visual_state_after_hidden_ && !pre_paint_only) {
Takashi SAKAMOTO870f6262017-08-22 04:08:271007 RecordTimeToFirstActivePaint();
1008 first_update_visual_state_after_hidden_ = false;
1009 }
1010}
tasakb95dbb50c2017-02-08 18:07:501011
Takashi SAKAMOTO870f6262017-08-22 04:08:271012void RenderWidget::RecordTimeToFirstActivePaint() {
tasakb95dbb50c2017-02-08 18:07:501013 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
tasakb95dbb50c2017-02-08 18:07:501014 base::TimeDelta sample = base::TimeTicks::Now() - was_shown_time_;
Takashi SAKAMOTO870f6262017-08-22 04:08:271015 if (render_thread_impl->NeedsToRecordFirstActivePaint(TTFAP_AFTER_PURGED)) {
1016 UMA_HISTOGRAM_TIMES("PurgeAndSuspend.Experimental.TimeToFirstActivePaint",
1017 sample);
1018 }
1019 if (render_thread_impl->NeedsToRecordFirstActivePaint(
1020 TTFAP_5MIN_AFTER_BACKGROUNDED)) {
1021 UMA_HISTOGRAM_TIMES(
1022 "PurgeAndSuspend.Experimental.TimeToFirstActivePaint."
1023 "AfterBackgrounded.5min",
1024 sample);
1025 }
fsamuel78f86e42016-01-20 04:10:231026}
1027
1028void RenderWidget::WillBeginCompositorFrame() {
1029 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
1030
Ken Buchananed449bb2018-02-01 21:02:051031 if (!GetWebWidget())
1032 return;
1033
Blink Reformat1c4d759e2017-04-09 16:34:541034 GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(true);
alancutter317a8e02017-04-05 10:09:291035
dglazkov06854c5c2016-08-31 00:19:591036 // The UpdateTextInputState can result in further layout and possibly
1037 // enable GPU acceleration so they need to be called before any painting
1038 // is done.
changwan75e3b2072017-01-16 02:55:001039 UpdateTextInputState();
dglazkov06854c5c2016-08-31 00:19:591040 UpdateSelectionBounds();
1041
ericwilligers88e69742016-10-17 19:29:551042 for (auto& observer : render_frame_proxies_)
1043 observer.WillBeginCompositorFrame();
initial.commit09911bf2008-07-26 23:55:291044}
1045
jbroman6ccbc7d472016-07-27 04:45:411046std::unique_ptr<cc::SwapPromise> RenderWidget::RequestCopyOfOutputForLayoutTest(
Fady Samueldfecb7d2017-07-26 11:41:041047 std::unique_ptr<viz::CopyOutputRequest> request) {
jbroman6ccbc7d472016-07-27 04:45:411048 return RenderThreadImpl::current()->RequestCopyOfOutputForLayoutTest(
1049 routing_id_, std::move(request));
1050}
1051
fsamuel72464894f2015-12-15 06:59:311052///////////////////////////////////////////////////////////////////////////////
1053// RenderWidgetInputHandlerDelegate
1054
avid7d6b2e2016-03-04 19:41:171055void RenderWidget::FocusChangeComplete() {
Ehsan Karamad655d7b8a2018-01-12 18:38:381056 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1057 if (!frame_widget)
ekaramad27ca69b12017-04-20 18:34:291058 return;
Ehsan Karamad655d7b8a2018-01-12 18:38:381059
ekaramad27ca69b12017-04-20 18:34:291060 blink::WebLocalFrame* focused =
Ehsan Karamad655d7b8a2018-01-12 18:38:381061 frame_widget->LocalRoot()->View()->FocusedFrame();
1062
ekaramad27ca69b12017-04-20 18:34:291063 if (focused && focused->AutofillClient())
1064 focused->AutofillClient()->DidCompleteFocusChangeInFrame();
avid7d6b2e2016-03-04 19:41:171065}
fsamuel72464894f2015-12-15 06:59:311066
dtapuska1827dd22016-03-11 15:24:591067void RenderWidget::ObserveGestureEventAndResult(
1068 const blink::WebGestureEvent& gesture_event,
1069 const gfx::Vector2dF& unused_delta,
Sandra Sunac5cdd832017-12-11 03:27:131070 const cc::OverscrollBehavior& overscroll_behavior,
dtapuska1827dd22016-03-11 15:24:591071 bool event_processed) {
1072 if (!compositor_deps_->IsElasticOverscrollEnabled())
1073 return;
1074
1075 cc::InputHandlerScrollResult scroll_result;
1076 scroll_result.did_scroll = event_processed;
1077 scroll_result.did_overscroll_root = !unused_delta.IsZero();
1078 scroll_result.unused_scroll_delta = unused_delta;
Sandra Sunac5cdd832017-12-11 03:27:131079 scroll_result.overscroll_behavior = overscroll_behavior;
dtapuska1827dd22016-03-11 15:24:591080
Dave Tapuska04bc5ee92018-04-17 19:03:311081 widget_input_handler_manager_->ObserveGestureEventOnMainThread(gesture_event,
1082 scroll_result);
dtapuska1827dd22016-03-11 15:24:591083}
1084
avid7d6b2e2016-03-04 19:41:171085void RenderWidget::OnDidHandleKeyEvent() {
alexmos56567492016-09-13 00:52:461086 ClearEditCommands();
1087}
1088
1089void RenderWidget::SetEditCommandForNextKeyEvent(const std::string& name,
1090 const std::string& value) {
1091 ClearEditCommands();
1092 edit_commands_.emplace_back(name, value);
1093}
1094
1095void RenderWidget::ClearEditCommands() {
1096 edit_commands_.clear();
avid7d6b2e2016-03-04 19:41:171097}
fsamuel72464894f2015-12-15 06:59:311098
chongza8ba91fc2016-08-16 21:39:171099void RenderWidget::OnDidOverscroll(const ui::DidOverscrollParams& params) {
Dave Tapuska04bc5ee92018-04-17 19:03:311100 if (mojom::WidgetInputHandlerHost* host =
1101 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
1102 host->DidOverscroll(params);
Dave Tapuska139a72f2017-09-06 21:57:031103 }
fsamuel72464894f2015-12-15 06:59:311104}
1105
fsamuele8326c742016-01-12 00:49:391106void RenderWidget::SetInputHandler(RenderWidgetInputHandler* input_handler) {
1107 // Nothing to do here. RenderWidget created the |input_handler| and will take
1108 // ownership of it. We just verify here that we don't already have an input
1109 // handler.
1110 DCHECK(!input_handler_);
1111}
1112
changwan75e3b2072017-01-16 02:55:001113void RenderWidget::ShowVirtualKeyboard() {
1114 UpdateTextInputStateInternal(true, false);
1115}
1116
changwan62f57292017-02-17 08:28:251117void RenderWidget::ClearTextInputState() {
1118 text_input_info_ = blink::WebTextInputInfo();
1119 text_input_type_ = ui::TextInputType::TEXT_INPUT_TYPE_NONE;
1120 text_input_mode_ = ui::TextInputMode::TEXT_INPUT_MODE_DEFAULT;
1121 can_compose_inline_ = false;
1122 text_input_flags_ = 0;
AJITH KUMAR V041c0b02017-08-08 10:39:201123 next_previous_flags_ = kInvalidNextPreviousFlagsValue;
changwan62f57292017-02-17 08:28:251124}
1125
changwan75e3b2072017-01-16 02:55:001126void RenderWidget::UpdateTextInputState() {
1127 UpdateTextInputStateInternal(false, false);
1128}
1129
1130void RenderWidget::UpdateTextInputStateInternal(bool show_virtual_keyboard,
1131 bool reply_to_request) {
fsamuel72464894f2015-12-15 06:59:311132 TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState");
changwan75e3b2072017-01-16 02:55:001133
fsamuel72464894f2015-12-15 06:59:311134 if (ime_event_guard_) {
changwan75e3b2072017-01-16 02:55:001135 DCHECK(!reply_to_request);
1136 // show_virtual_keyboard should still be effective even if it was set inside
1137 // the IME
fsamuel72464894f2015-12-15 06:59:311138 // event guard.
changwan75e3b2072017-01-16 02:55:001139 if (show_virtual_keyboard)
1140 ime_event_guard_->set_show_virtual_keyboard(true);
fsamuel72464894f2015-12-15 06:59:311141 return;
1142 }
1143
dglazkov97b6c2b2016-10-25 17:35:551144 ui::TextInputType new_type = GetTextInputType();
1145 if (IsDateTimeInput(new_type))
1146 return; // Not considered as a text input field in WebKit/Chromium.
fsamuel72464894f2015-12-15 06:59:311147
dglazkov97b6c2b2016-10-25 17:35:551148 blink::WebTextInputInfo new_info;
ekaramad5aff1942017-01-06 01:26:351149 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:541150 new_info = controller->TextInputInfo();
dtapuskac4dd5be2016-10-25 15:11:101151 const ui::TextInputMode new_mode =
Blink Reformat1c4d759e2017-04-09 16:34:541152 ConvertWebTextInputMode(new_info.input_mode);
fsamuel72464894f2015-12-15 06:59:311153
1154 bool new_can_compose_inline = CanComposeInline();
1155
1156 // Only sends text input params if they are changed or if the ime should be
1157 // shown.
changwan75e3b2072017-01-16 02:55:001158 if (show_virtual_keyboard || reply_to_request ||
changwan38c3eb612016-12-09 01:45:561159 text_input_type_ != new_type || text_input_mode_ != new_mode ||
1160 text_input_info_ != new_info ||
1161 can_compose_inline_ != new_can_compose_inline) {
ekaramad9053e57b2016-04-26 20:00:381162 TextInputState params;
dglazkov97b6c2b2016-10-25 17:35:551163 params.type = new_type;
fsamuel72464894f2015-12-15 06:59:311164 params.mode = new_mode;
1165 params.flags = new_info.flags;
AJITH KUMAR V9e7b5572017-11-14 00:54:211166#if defined(OS_ANDROID)
AJITH KUMAR V041c0b02017-08-08 10:39:201167 if (next_previous_flags_ == kInvalidNextPreviousFlagsValue) {
1168 // Due to a focus change, values will be reset by the frame.
1169 // That case we only need fresh NEXT/PREVIOUS information.
1170 // Also we won't send ViewHostMsg_TextInputStateChanged if next/previous
1171 // focusable status is changed.
1172 if (auto* controller = GetInputMethodController()) {
1173 next_previous_flags_ =
1174 controller->ComputeWebTextInputNextPreviousFlags();
1175 } else {
1176 // For safety in case GetInputMethodController() is null, because -1 is
1177 // invalid value to send to browser process.
1178 next_previous_flags_ = 0;
1179 }
1180 }
AJITH KUMAR V9e7b5572017-11-14 00:54:211181#else
1182 next_previous_flags_ = 0;
1183#endif
AJITH KUMAR V041c0b02017-08-08 10:39:201184 params.flags |= next_previous_flags_;
Blink Reformat1c4d759e2017-04-09 16:34:541185 params.value = new_info.value.Utf8();
1186 params.selection_start = new_info.selection_start;
1187 params.selection_end = new_info.selection_end;
1188 params.composition_start = new_info.composition_start;
1189 params.composition_end = new_info.composition_end;
fsamuel72464894f2015-12-15 06:59:311190 params.can_compose_inline = new_can_compose_inline;
changwan75e3b2072017-01-16 02:55:001191 // TODO(changwan): change instances of show_ime_if_needed to
1192 // show_virtual_keyboard.
1193 params.show_ime_if_needed = show_virtual_keyboard;
1194 params.reply_to_request = reply_to_request;
fsamuel72464894f2015-12-15 06:59:311195 Send(new ViewHostMsg_TextInputStateChanged(routing_id(), params));
1196
1197 text_input_info_ = new_info;
dglazkov97b6c2b2016-10-25 17:35:551198 text_input_type_ = new_type;
fsamuel72464894f2015-12-15 06:59:311199 text_input_mode_ = new_mode;
1200 can_compose_inline_ = new_can_compose_inline;
1201 text_input_flags_ = new_info.flags;
1202 }
1203}
1204
1205bool RenderWidget::WillHandleGestureEvent(const blink::WebGestureEvent& event) {
paulmeyer6ef5a792016-11-08 20:33:581206 possible_drag_event_info_.event_source =
1207 ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH;
1208 possible_drag_event_info_.event_location =
Ella Ge1116059d2018-03-21 02:06:131209 gfx::ToFlooredPoint(event.PositionInScreen());
avid7d6b2e2016-03-04 19:41:171210
fsamuel72464894f2015-12-15 06:59:311211 return false;
1212}
1213
1214bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
ericwilligers88e69742016-10-17 19:29:551215 for (auto& observer : render_frames_)
1216 observer.RenderWidgetWillHandleMouseEvent();
lfge0c2792ec2016-05-11 18:52:081217
paulmeyer6ef5a792016-11-08 20:33:581218 possible_drag_event_info_.event_source =
1219 ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
1220 possible_drag_event_info_.event_location =
Blink Reformat1c4d759e2017-04-09 16:34:541221 gfx::Point(event.PositionInScreen().x, event.PositionInScreen().y);
paulmeyer6ef5a792016-11-08 20:33:581222
avid7d6b2e2016-03-04 19:41:171223 if (owner_delegate_)
1224 return owner_delegate_->RenderWidgetWillHandleMouseEvent(event);
1225
fsamuel72464894f2015-12-15 06:59:311226 return false;
[email protected]fd847792013-10-24 17:12:351227}
1228
initial.commit09911bf2008-07-26 23:55:291229///////////////////////////////////////////////////////////////////////////////
mfomitchev2600fd7c2016-02-17 20:53:391230// RenderWidgetScreenMetricsDelegate
1231
1232void RenderWidget::Redraw() {
1233 set_next_paint_is_resize_ack();
1234 if (compositor_)
1235 compositor_->SetNeedsRedrawRect(gfx::Rect(size_));
1236}
1237
bokanc63441c2016-04-27 15:49:121238void RenderWidget::ResizeWebWidget() {
Blink Reformat1c4d759e2017-04-09 16:34:541239 GetWebWidget()->Resize(GetSizeForWebWidget());
bokanc63441c2016-04-27 15:49:121240}
1241
1242gfx::Size RenderWidget::GetSizeForWebWidget() const {
Fady Samuela863f152018-03-09 16:10:031243 if (IsUseZoomForDSFEnabled()) {
1244 return gfx::ScaleToCeiledSize(size_,
1245 GetOriginalScreenInfo().device_scale_factor);
1246 }
bokanc63441c2016-04-27 15:49:121247
1248 return size_;
1249}
1250
mfomitchev2600fd7c2016-02-17 20:53:391251void RenderWidget::Resize(const ResizeParams& params) {
Chris Blume760b9462018-04-12 21:45:331252 viz::LocalSurfaceId new_local_surface_id;
1253 // If the content_source_id of ResizeParams doesn't match
1254 // |current_content_source_id_|, then the given LocalSurfaceId was generated
1255 // before the navigation. Continue with the resize but don't use the
1256 // LocalSurfaceId until the right one comes.
1257 if (params.local_surface_id &&
1258 params.content_source_id == current_content_source_id_) {
1259 new_local_surface_id = child_local_surface_id_allocator_.UpdateFromParent(
1260 params.local_surface_id.value());
1261 }
1262
Fady Samuele62be402018-03-29 03:19:531263 if (params.auto_resize_enabled && auto_resize_mode_ &&
1264 (!params.auto_resize_sequence_number ||
1265 auto_resize_sequence_number_ != params.auto_resize_sequence_number)) {
1266 DidResizeOrRepaintAck();
1267 return;
1268 }
1269
Saman Samif7731342018-01-24 22:18:441270 // The content_source_id that the browser sends us should never be larger than
1271 // |current_content_source_id_|.
1272 DCHECK_GE(1u << 30, current_content_source_id_ - params.content_source_id);
1273
Christopher Cameronbe7ecea2018-02-27 00:47:191274 // Inform the rendering thread of the color space indicate the presence of HDR
1275 // capabilities.
Miguel Casas5e1018052018-01-09 19:17:361276 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1277 if (render_thread)
Christopher Camerone9a30c12018-03-07 08:23:381278 render_thread->SetRenderingColorSpace(params.screen_info.color_space);
Miguel Casas5e1018052018-01-09 19:17:361279
mfomitchev2600fd7c2016-02-17 20:53:391280 if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
1281 // A resize ack shouldn't be requested if we have not ACK'd the previous
1282 // one.
Saman Samif7731342018-01-24 22:18:441283 DCHECK(!compositor_ || !params.needs_resize_ack ||
1284 !next_paint_is_resize_ack());
mfomitchev2600fd7c2016-02-17 20:53:391285 }
1286
1287 // Ignore this during shutdown.
lfg8ff33912016-09-13 20:59:211288 if (!GetWebWidget())
mfomitchev2600fd7c2016-02-17 20:53:391289 return;
1290
Fady Samuele62be402018-03-29 03:19:531291 gfx::Size new_compositor_viewport_pixel_size =
1292 params.auto_resize_enabled
1293 ? gfx::ScaleToCeiledSize(size_,
1294 params.screen_info.device_scale_factor)
1295 : params.compositor_viewport_pixel_size;
Christopher Cameronaad15a0d2018-03-09 03:47:331296 UpdateSurfaceAndScreenInfo(new_local_surface_id,
Fady Samuele62be402018-03-29 03:19:531297 new_compositor_viewport_pixel_size,
Christopher Camerone9a30c12018-03-07 08:23:381298 params.screen_info);
ianwene5fc5782016-08-18 04:05:151299 if (compositor_) {
Fady Samuel319e429c2017-10-02 18:31:551300 // If surface synchronization is enabled, then this will use the provided
fsamuelca02c4e2017-05-09 13:34:141301 // |local_surface_id_| to submit the next generated CompositorFrame.
1302 // If the ID is not valid, then the compositor will defer commits until
1303 // it receives a valid surface ID. This is a no-op if surface
1304 // synchronization is disabled.
Fady Samuel2bb02292017-10-17 23:59:151305 DCHECK(!compositor_->IsSurfaceSynchronizationEnabled() ||
Fady Samuela41e9d42018-03-01 21:31:581306 !params.needs_resize_ack || !params.local_surface_id ||
1307 params.local_surface_id->is_valid());
Sadrul Habib Chowdhury04d5dd4d2017-08-10 01:59:271308 compositor_->SetBrowserControlsHeight(
1309 params.top_controls_height, params.bottom_controls_height,
1310 params.browser_controls_shrink_blink_size);
1311 compositor_->SetRasterColorSpace(
1312 screen_info_.color_space.GetRasterColorSpace());
ianwene5fc5782016-08-18 04:05:151313 }
mfomitchev2600fd7c2016-02-17 20:53:391314
Fady Samuele62be402018-03-29 03:19:531315 if (params.auto_resize_enabled)
1316 return;
1317
mfomitchev2600fd7c2016-02-17 20:53:391318 visible_viewport_size_ = params.visible_viewport_size;
mfomitchev2600fd7c2016-02-17 20:53:391319
1320 // NOTE: We may have entered fullscreen mode without changing our size.
1321 bool fullscreen_change =
1322 is_fullscreen_granted_ != params.is_fullscreen_granted;
1323 is_fullscreen_granted_ = params.is_fullscreen_granted;
1324 display_mode_ = params.display_mode;
1325
bokanc63441c2016-04-27 15:49:121326 size_ = params.new_size;
mfomitchev2600fd7c2016-02-17 20:53:391327
bokanc63441c2016-04-27 15:49:121328 ResizeWebWidget();
bokan71cb5b12016-04-27 03:45:221329
mfomitchev2600fd7c2016-02-17 20:53:391330 WebSize visual_viewport_size;
mfomitchev2600fd7c2016-02-17 20:53:391331 if (IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:031332 visual_viewport_size =
1333 gfx::ScaleToCeiledSize(params.visible_viewport_size,
1334 GetOriginalScreenInfo().device_scale_factor);
mfomitchev2600fd7c2016-02-17 20:53:391335 } else {
1336 visual_viewport_size = visible_viewport_size_;
1337 }
Blink Reformat1c4d759e2017-04-09 16:34:541338 GetWebWidget()->ResizeVisualViewport(visual_viewport_size);
mfomitchev2600fd7c2016-02-17 20:53:391339
bokanc63441c2016-04-27 15:49:121340 // When resizing, we want to wait to paint before ACK'ing the resize. This
1341 // ensures that we only resize as fast as we can paint. We only need to
1342 // send an ACK if we are resized to a non-empty rect.
Christopher Cameronaad15a0d2018-03-09 03:47:331343 if (params.new_size.IsEmpty() ||
1344 params.compositor_viewport_pixel_size.IsEmpty()) {
mfomitchev2600fd7c2016-02-17 20:53:391345 // In this case there is no paint/composite and therefore no
Fady Samuelcc3e3b4a2017-10-03 02:09:211346 // ViewHostMsg_ResizeOrRepaint_ACK to send the resize ack with. We'd need to
1347 // send the ack through a fake ViewHostMsg_ResizeOrRepaint_ACK or a
1348 // different message.
mfomitchev2600fd7c2016-02-17 20:53:391349 DCHECK(!params.needs_resize_ack);
1350 }
1351
1352 // Send the Resize_ACK flag once we paint again if requested.
1353 if (params.needs_resize_ack)
1354 set_next_paint_is_resize_ack();
1355
1356 if (fullscreen_change)
1357 DidToggleFullscreen();
1358
1359 // If a resize ack is requested and it isn't set-up, then no more resizes will
1360 // come in and in general things will go wrong.
1361 DCHECK(!params.needs_resize_ack || next_paint_is_resize_ack());
Saman Samif7731342018-01-24 22:18:441362
1363 // If this resize was initiated before navigation and surface synchronization
1364 // is on, it is not expected to be acked.
1365 if (compositor_ && compositor_->IsSurfaceSynchronizationEnabled() &&
1366 params.needs_resize_ack && !local_surface_id_.is_valid()) {
1367 DCHECK_NE(params.content_source_id, current_content_source_id_);
1368 reset_next_paint_is_resize_ack();
1369 }
mfomitchev2600fd7c2016-02-17 20:53:391370}
1371
1372void RenderWidget::SetScreenMetricsEmulationParameters(
1373 bool enabled,
1374 const blink::WebDeviceEmulationParams& params) {
1375 // This is only supported in RenderView.
1376 NOTREACHED();
1377}
1378
1379void RenderWidget::SetScreenRects(const gfx::Rect& view_screen_rect,
1380 const gfx::Rect& window_screen_rect) {
1381 view_screen_rect_ = view_screen_rect;
1382 window_screen_rect_ = window_screen_rect;
1383}
1384
1385///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461386// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291387
Blink Reformat1c4d759e2017-04-09 16:34:541388blink::WebLayerTreeView* RenderWidget::InitializeLayerTreeView() {
[email protected]aeeedad2014-08-22 18:16:221389 DCHECK(!host_closing_);
1390
loyso6e6efc42017-01-21 02:23:031391 compositor_ = RenderWidgetCompositor::Create(this, compositor_deps_);
1392 auto animation_host = cc::AnimationHost::CreateMainInstance();
1393
wjmacleana755e302017-04-20 00:43:161394 // Oopif status must be set before the LayerTreeHost is created.
1395 compositor_->SetIsForOopif(for_oopif_);
loyso6e6efc42017-01-21 02:23:031396 auto layer_tree_host = RenderWidgetCompositor::CreateLayerTreeHost(
1397 compositor_.get(), compositor_.get(), animation_host.get(),
Christopher Camerone9a30c12018-03-07 08:23:381398 compositor_deps_, screen_info_);
loyso6e6efc42017-01-21 02:23:031399 compositor_->Initialize(std::move(layer_tree_host),
1400 std::move(animation_host));
1401
Saman Samif7731342018-01-24 22:18:441402 // We can get into this state if surface synchronization is on and the last
1403 // resize was initiated before navigation, in which case we don't have to ack
1404 // it.
1405 if (compositor_->IsSurfaceSynchronizationEnabled() && !auto_resize_mode_ &&
1406 next_paint_is_resize_ack() && !local_surface_id_.is_valid()) {
1407 reset_next_paint_is_resize_ack();
1408 }
1409
Christopher Cameronaad15a0d2018-03-09 03:47:331410 UpdateSurfaceAndScreenInfo(local_surface_id_, compositor_viewport_pixel_size_,
Christopher Camerone9a30c12018-03-07 08:23:381411 screen_info_);
ccameron01912992017-05-23 07:34:031412 compositor_->SetRasterColorSpace(
Christopher Camerona1ea2b72017-08-02 01:59:091413 screen_info_.color_space.GetRasterColorSpace());
kenrb5d78b842017-03-06 21:06:011414 compositor_->SetContentSourceId(current_content_source_id_);
sievers71c62dd52015-10-07 01:44:391415 // For background pages and certain tests, we don't want to trigger
danakjc7afae52017-06-20 21:12:411416 // LayerTreeFrameSink creation.
dtapuskab08611f2017-04-24 16:10:221417 bool should_generate_frame_sink =
1418 !compositor_never_visible_ && RenderThreadImpl::current();
1419 if (!should_generate_frame_sink)
sievers71c62dd52015-10-07 01:44:391420 compositor_->SetNeverVisible();
1421
pimanc4af3072015-10-02 03:45:591422 StartCompositor();
staraz067f58242016-11-07 21:06:411423 DCHECK_NE(MSG_ROUTING_NONE, routing_id_);
1424 compositor_->SetFrameSinkId(
Fady Samueld5c26182017-07-12 02:43:331425 viz::FrameSinkId(RenderThread::Get()->GetClientId(), routing_id_));
loyso50b51c22017-01-10 07:18:371426
wjmaclean1d970622017-01-21 22:28:241427 RenderThreadImpl* render_thread = RenderThreadImpl::current();
Dave Tapuska9db80842017-07-24 17:24:261428 if (render_thread) {
dtapuska9ec1a912017-04-21 15:18:311429 input_event_queue_ = new MainThreadEventQueue(
Yuta Kitamura3331f5c2018-04-05 11:12:251430 this, render_thread->GetWebMainThreadScheduler()->InputTaskRunner(),
1431 render_thread->GetWebMainThreadScheduler(), should_generate_frame_sink);
wjmaclean1d970622017-01-21 22:28:241432 }
1433
Khushal3e96e662017-10-30 23:16:501434 UpdateURLForCompositorUkm();
1435
loyso50b51c22017-01-10 07:18:371436 return compositor_.get();
[email protected]e195e582013-03-08 01:32:591437}
1438
Chris Harrelsond7ab99b2018-01-24 17:51:361439void RenderWidget::IntrinsicSizingInfoChanged(
1440 const blink::WebIntrinsicSizingInfo& sizing_info) {
1441 Send(new ViewHostMsg_IntrinsicSizingInfoChanged(routing_id_, sizing_info));
1442}
1443
ennef3c58142014-12-09 21:44:381444void RenderWidget::WillCloseLayerTreeView() {
1445 if (host_closing_)
1446 return;
1447
1448 // Prevent new compositors or output surfaces from being created.
1449 host_closing_ = true;
1450
[email protected]aeeedad2014-08-22 18:16:221451 // Always send this notification to prevent new layer tree views from
1452 // being created, even if one hasn't been created yet.
lfg8ff33912016-09-13 20:59:211453 if (blink::WebWidget* widget = GetWebWidget())
Blink Reformat1c4d759e2017-04-09 16:34:541454 widget->WillCloseLayerTreeView();
[email protected]aeeedad2014-08-22 18:16:221455}
1456
Blink Reformat1c4d759e2017-04-09 16:34:541457void RenderWidget::DidMeaningfulLayout(blink::WebMeaningfulLayout layout_type) {
1458 if (layout_type == blink::WebMeaningfulLayout::kVisuallyNonEmpty) {
dglazkovf0e1d6d2015-10-10 02:13:481459 QueueMessage(new ViewHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_),
1460 MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE);
1461 }
dglazkov79c426102015-08-31 21:22:431462
ericwilligers88e69742016-10-17 19:29:551463 for (auto& observer : render_frames_)
1464 observer.DidMeaningfulLayout(layout_type);
dglazkov79c426102015-08-31 21:22:431465}
1466
[email protected]586871b2014-07-22 17:05:111467// static
dchengcedca5612016-04-09 01:40:151468std::unique_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
[email protected]586871b2014-07-22 17:05:111469 IPC::Message* msg,
1470 MessageDeliveryPolicy policy,
1471 FrameSwapMessageQueue* frame_swap_message_queue,
1472 scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
[email protected]586871b2014-07-22 17:05:111473 int source_frame_number) {
[email protected]586871b2014-07-22 17:05:111474 bool first_message_for_frame = false;
dchengcedca5612016-04-09 01:40:151475 frame_swap_message_queue->QueueMessageForFrame(policy, source_frame_number,
1476 base::WrapUnique(msg),
[email protected]586871b2014-07-22 17:05:111477 &first_message_for_frame);
1478 if (first_message_for_frame) {
dchengcedca5612016-04-09 01:40:151479 std::unique_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
[email protected]586871b2014-07-22 17:05:111480 sync_message_filter, frame_swap_message_queue, source_frame_number));
dcheng4b6b5ff2014-10-16 00:42:061481 return promise;
[email protected]586871b2014-07-22 17:05:111482 }
dcheng4b6b5ff2014-10-16 00:42:061483 return nullptr;
[email protected]586871b2014-07-22 17:05:111484}
1485
1486void RenderWidget::QueueMessage(IPC::Message* msg,
1487 MessageDeliveryPolicy policy) {
1488 // RenderThreadImpl::current() is NULL in some tests.
1489 if (!compositor_ || !RenderThreadImpl::current()) {
1490 Send(msg);
1491 return;
1492 }
1493
dchengcedca5612016-04-09 01:40:151494 std::unique_ptr<cc::SwapPromise> swap_promise =
1495 QueueMessageImpl(msg, policy, frame_swap_message_queue_.get(),
[email protected]586871b2014-07-22 17:05:111496 RenderThreadImpl::current()->sync_message_filter(),
[email protected]586871b2014-07-22 17:05:111497 compositor_->GetSourceFrameNumber());
1498
Ken Buchanance710eb2017-08-30 23:46:521499 if (swap_promise)
dcheng07945f632015-12-26 07:59:321500 compositor_->QueueSwapPromise(std::move(swap_promise));
[email protected]586871b2014-07-22 17:05:111501}
1502
Blink Reformat1c4d759e2017-04-09 16:34:541503void RenderWidget::DidChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301504 // TODO(darin): Eliminate this temporary.
[email protected]9ec87712013-05-24 23:23:521505 WebCursor cursor;
tfarina75a0abf2015-10-06 15:07:181506 InitializeCursorFromWebCursorInfo(&cursor, cursor_info);
initial.commit09911bf2008-07-26 23:55:291507 // Only send a SetCursor message if we need to make a change.
1508 if (!current_cursor_.IsEqual(cursor)) {
1509 current_cursor_ = cursor;
1510 Send(new ViewHostMsg_SetCursor(routing_id_, cursor));
1511 }
1512}
1513
aelias5971e47d2017-06-16 02:39:381514void RenderWidget::AutoscrollStart(const blink::WebFloatPoint& point) {
1515 Send(new ViewHostMsg_AutoscrollStart(routing_id_, point));
1516}
1517
1518void RenderWidget::AutoscrollFling(const blink::WebFloatSize& velocity) {
1519 Send(new ViewHostMsg_AutoscrollFling(routing_id_, velocity));
1520}
1521
1522void RenderWidget::AutoscrollEnd() {
1523 Send(new ViewHostMsg_AutoscrollEnd(routing_id_));
1524}
1525
initial.commit09911bf2008-07-26 23:55:291526// We are supposed to get a single call to Show for a newly created RenderWidget
1527// that was created via RenderWidget::CreateWebView. So, we wait until this
1528// point to dispatch the ShowWidget message.
1529//
1530// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281531// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291532//
Blink Reformat1c4d759e2017-04-09 16:34:541533void RenderWidget::Show(WebNavigationPolicy policy) {
initial.commit09911bf2008-07-26 23:55:291534 DCHECK(!did_show_) << "received extraneous Show call";
1535 DCHECK(routing_id_ != MSG_ROUTING_NONE);
nickf7b38222016-11-22 21:59:351536 DCHECK(!show_callback_.is_null());
initial.commit09911bf2008-07-26 23:55:291537
[email protected]8de12d942010-11-17 20:42:441538 if (did_show_)
1539 return;
1540
1541 did_show_ = true;
nickf7b38222016-11-22 21:59:351542
1543 // The opener is responsible for actually showing this widget.
1544 show_callback_.Run(this, policy, initial_rect_);
nick5ae4d2d2017-01-06 01:18:351545 show_callback_.Reset();
nickf7b38222016-11-22 21:59:351546
bokanc007c3a2015-02-03 07:15:561547 // NOTE: initial_rect_ may still have its default values at this point, but
[email protected]8de12d942010-11-17 20:42:441548 // that's okay. It'll be ignored if as_popup is false, or the browser
1549 // process will impose a default position otherwise.
bokanc007c3a2015-02-03 07:15:561550 SetPendingWindowRect(initial_rect_);
initial.commit09911bf2008-07-26 23:55:291551}
1552
[email protected]2533ce12009-05-09 00:02:241553void RenderWidget::DoDeferredClose() {
ennef3c58142014-12-09 21:44:381554 WillCloseLayerTreeView();
[email protected]2533ce12009-05-09 00:02:241555 Send(new ViewHostMsg_Close(routing_id_));
1556}
1557
dgozmancf9039cd2015-04-06 12:01:311558void RenderWidget::NotifyOnClose() {
ericwilligers88e69742016-10-17 19:29:551559 for (auto& observer : render_frames_)
1560 observer.WidgetWillClose();
dgozmancf9039cd2015-04-06 12:01:311561}
1562
Blink Reformat1c4d759e2017-04-09 16:34:541563void RenderWidget::CloseWidgetSoon() {
skyostiled8969c2015-07-20 16:57:081564 DCHECK(content::RenderThread::Get());
[email protected]e1c3a552012-05-04 20:51:321565 if (is_swapped_out_) {
1566 // This widget is currently swapped out, and the active widget is in a
1567 // different process. Have the browser route the close request to the
1568 // active widget instead, so that the correct unload handlers are run.
1569 Send(new ViewHostMsg_RouteCloseEvent(routing_id_));
1570 return;
1571 }
1572
initial.commit09911bf2008-07-26 23:55:291573 // If a page calls window.close() twice, we'll end up here twice, but that's
1574 // OK. It is safe to send multiple Close messages.
1575
[email protected]2533ce12009-05-09 00:02:241576 // Ask the RenderWidgetHost to initiate close. We could be called from deep
1577 // in Javascript. If we ask the RendwerWidgetHost to close now, the window
1578 // could be closed before the JS finishes executing. So instead, post a
1579 // message back to the message loop, which won't run until the JS is
1580 // complete, and then the Close message can be sent.
Hajime Hoshiabb3c8f2017-12-04 18:41:391581 task_runner_->PostTask(FROM_HERE,
1582 base::BindOnce(&RenderWidget::DoDeferredClose, this));
initial.commit09911bf2008-07-26 23:55:291583}
1584
1585void RenderWidget::Close() {
[email protected]404630b2014-07-03 19:33:031586 screen_metrics_emulator_.reset();
Ken Buchananed449bb2018-02-01 21:02:051587 CloseWebWidget();
ennef3c58142014-12-09 21:44:381588 compositor_.reset();
Ken Buchananed449bb2018-02-01 21:02:051589}
1590
1591void RenderWidget::CloseWebWidget() {
1592 WillCloseLayerTreeView();
lfg8ff33912016-09-13 20:59:211593 if (webwidget_internal_) {
Blink Reformat1c4d759e2017-04-09 16:34:541594 webwidget_internal_->Close();
lfg8ff33912016-09-13 20:59:211595 webwidget_internal_ = nullptr;
initial.commit09911bf2008-07-26 23:55:291596 }
1597}
1598
Mitsuru Oshima3c07b332018-02-06 04:56:501599void RenderWidget::UpdateWebViewWithDeviceScaleFactor() {
1600 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1601 blink::WebFrame* current_frame =
1602 frame_widget ? frame_widget->LocalRoot() : nullptr;
1603 blink::WebView* webview = current_frame ? current_frame->View() : nullptr;
1604 if (webview) {
1605 if (IsUseZoomForDSFEnabled())
Fady Samuela863f152018-03-09 16:10:031606 webview->SetZoomFactorForDeviceScaleFactor(
1607 GetWebScreenInfo().device_scale_factor);
Mitsuru Oshima3c07b332018-02-06 04:56:501608 else
Fady Samuela863f152018-03-09 16:10:031609 webview->SetDeviceScaleFactor(GetWebScreenInfo().device_scale_factor);
Mitsuru Oshima3c07b332018-02-06 04:56:501610
1611 webview->GetSettings()->SetPreferCompositingToLCDTextEnabled(
Christopher Camerone9a30c12018-03-07 08:23:381612 PreferCompositingToLCDText(compositor_deps_,
Fady Samuela863f152018-03-09 16:10:031613 GetWebScreenInfo().device_scale_factor));
Mitsuru Oshima3c07b332018-02-06 04:56:501614 }
1615}
1616
Ehsan Karamad655d7b8a2018-01-12 18:38:381617blink::WebFrameWidget* RenderWidget::GetFrameWidget() const {
1618 blink::WebWidget* web_widget = GetWebWidget();
1619 if (!web_widget)
1620 return nullptr;
1621
1622 if (!web_widget->IsWebFrameWidget()) {
1623 // TODO(ekaramad): This should not happen. If we have a WebWidget and we
1624 // need a WebFrameWidget then we should be getting a WebFrameWidget. But
1625 // unfortunately this does not seem to be the case in some scenarios --
1626 // specifically when a RenderViewImpl swaps out during navigation the
1627 // WebViewImpl loses its WebViewFrameWidget but sometimes we receive IPCs
1628 // which are destined for WebFrameWidget (https://crbug.com/669219).
1629 return nullptr;
1630 }
1631
1632 return static_cast<blink::WebFrameWidget*>(web_widget);
1633}
1634
bokan841fdc72016-10-06 00:16:351635void RenderWidget::ScreenRectToEmulatedIfNeeded(WebRect* window_rect) const {
1636 DCHECK(window_rect);
1637 float scale = popup_origin_scale_for_emulation_;
1638 if (!scale)
1639 return;
1640 window_rect->x =
1641 popup_view_origin_for_emulation_.x() +
1642 (window_rect->x - popup_screen_origin_for_emulation_.x()) / scale;
1643 window_rect->y =
1644 popup_view_origin_for_emulation_.y() +
1645 (window_rect->y - popup_screen_origin_for_emulation_.y()) / scale;
1646}
1647
1648void RenderWidget::EmulatedToScreenRectIfNeeded(WebRect* window_rect) const {
1649 DCHECK(window_rect);
1650 float scale = popup_origin_scale_for_emulation_;
1651 if (!scale)
1652 return;
1653 window_rect->x =
1654 popup_screen_origin_for_emulation_.x() +
1655 (window_rect->x - popup_view_origin_for_emulation_.x()) * scale;
1656 window_rect->y =
1657 popup_screen_origin_for_emulation_.y() +
1658 (window_rect->y - popup_view_origin_for_emulation_.y()) * scale;
1659}
1660
Blink Reformat1c4d759e2017-04-09 16:34:541661WebRect RenderWidget::WindowRect() {
bokan841fdc72016-10-06 00:16:351662 WebRect rect;
bokan6b08cd22016-10-05 00:55:211663 if (pending_window_rect_count_) {
1664 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
1665 // the RootWindowRect is probably going to return wrong results since the
1666 // browser may not have processed the Move yet. There isn't really anything
1667 // good to do in this case, and it shouldn't happen - since this size is
1668 // only really needed for windowToScreen, which is only used for Popups.
bokan841fdc72016-10-06 00:16:351669 rect = pending_window_rect_;
1670 } else {
1671 rect = window_screen_rect_;
bokan6b08cd22016-10-05 00:55:211672 }
[email protected]2533ce12009-05-09 00:02:241673
bokan841fdc72016-10-06 00:16:351674 ScreenRectToEmulatedIfNeeded(&rect);
1675 return rect;
bokan6b08cd22016-10-05 00:55:211676}
1677
Blink Reformat1c4d759e2017-04-09 16:34:541678WebRect RenderWidget::ViewRect() {
bokan841fdc72016-10-06 00:16:351679 WebRect rect = view_screen_rect_;
1680 ScreenRectToEmulatedIfNeeded(&rect);
1681 return rect;
initial.commit09911bf2008-07-26 23:55:291682}
1683
Blink Reformat1c4d759e2017-04-09 16:34:541684void RenderWidget::SetToolTipText(const blink::WebString& text,
[email protected]8a9d6ca32011-06-06 20:11:301685 WebTextDirection hint) {
Blink Reformat1c4d759e2017-04-09 16:34:541686 Send(new ViewHostMsg_SetTooltipText(routing_id_, text.Utf16(), hint));
[email protected]8a9d6ca32011-06-06 20:11:301687}
1688
Blink Reformat1c4d759e2017-04-09 16:34:541689void RenderWidget::SetWindowRect(const WebRect& rect_in_screen) {
oshima33ec97cd2015-12-14 19:40:241690 WebRect window_rect = rect_in_screen;
bokan841fdc72016-10-06 00:16:351691 EmulatedToScreenRectIfNeeded(&window_rect);
[email protected]b2e4c70132013-10-03 02:07:511692
[email protected]5b45ad42013-10-25 00:42:041693 if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]ec951b9d2013-10-20 06:21:201694 if (did_show_) {
bokanc007c3a2015-02-03 07:15:561695 Send(new ViewHostMsg_RequestMove(routing_id_, window_rect));
1696 SetPendingWindowRect(window_rect);
[email protected]8be1c582013-03-06 00:55:031697 } else {
bokanc007c3a2015-02-03 07:15:561698 initial_rect_ = window_rect;
[email protected]8be1c582013-03-06 00:55:031699 }
initial.commit09911bf2008-07-26 23:55:291700 } else {
bokanc007c3a2015-02-03 07:15:561701 SetWindowRectSynchronously(window_rect);
initial.commit09911bf2008-07-26 23:55:291702 }
1703}
1704
[email protected]2533ce12009-05-09 00:02:241705void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
1706 pending_window_rect_ = rect;
1707 pending_window_rect_count_++;
[email protected]2533ce12009-05-09 00:02:241708
bokan6b08cd22016-10-05 00:55:211709 // Popups don't get size updates back from the browser so just store the set
1710 // values.
Blink Reformat1c4d759e2017-04-09 16:34:541711 if (popup_type_ != blink::kWebPopupTypeNone) {
1712 window_screen_rect_ = rect;
1713 view_screen_rect_ = rect;
[email protected]2533ce12009-05-09 00:02:241714 }
[email protected]d4547452008-08-28 18:36:371715}
1716
wjmacleanee244e02017-05-26 21:06:071717void RenderWidget::OnShowContextMenu(ui::MenuSourceType source_type,
1718 const gfx::Point& location) {
wjmacleanee244e02017-05-26 21:06:071719 has_host_context_menu_location_ = true;
1720 host_context_menu_location_ = location;
1721 if (GetWebWidget()) {
1722 GetWebWidget()->ShowContextMenu(
1723 static_cast<blink::WebMenuSourceType>(source_type));
1724 }
1725 has_host_context_menu_location_ = false;
1726}
1727
[email protected]fa7b1dc2010-06-23 17:53:041728void RenderWidget::OnImeSetComposition(
[email protected]fcf75d42013-12-03 20:11:261729 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:111730 const std::vector<WebImeTextSpan>& ime_text_spans,
chongz7eb752802016-01-27 21:28:071731 const gfx::Range& replacement_range,
Ryan Landay9e42fd742017-08-12 01:59:111732 int selection_start,
1733 int selection_end) {
ekaramad5aff1942017-01-06 01:26:351734 if (!ShouldHandleImeEvents())
1735 return;
1736
brettw4b461082016-11-19 18:55:161737#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:491738 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
Ryan Landay9e42fd742017-08-12 01:59:111739 plugin->render_frame()->OnImeSetComposition(text, ime_text_spans,
EhsanK22d482e2017-08-10 17:29:491740 selection_start, selection_end);
ekaramad2a46d632016-07-19 13:33:091741 return;
1742 }
1743#endif
[email protected]66fca5bc2013-05-23 06:58:291744 ImeEventGuard guard(this);
ekaramad2daaf672016-11-10 20:29:011745 blink::WebInputMethodController* controller = GetInputMethodController();
ekaramad2daaf672016-11-10 20:29:011746 if (!controller ||
Blink Reformat1c4d759e2017-04-09 16:34:541747 !controller->SetComposition(
Ryan Landay9e42fd742017-08-12 01:59:111748 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:561749 replacement_range.IsValid()
1750 ? WebRange(replacement_range.start(), replacement_range.length())
1751 : WebRange(),
1752 selection_start, selection_end)) {
[email protected]fa7b1dc2010-06-23 17:53:041753 // If we failed to set the composition text, then we need to let the browser
1754 // process to cancel the input method's ongoing composition session, to make
1755 // sure we are in a consistent state.
Dave Tapuska04bc5ee92018-04-17 19:03:311756 if (mojom::WidgetInputHandlerHost* host =
1757 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
1758 host->ImeCancelComposition();
Dave Tapuska139a72f2017-09-06 21:57:031759 }
[email protected]7f00efa2010-04-15 05:01:261760 }
nonafa291792016-08-10 02:36:181761 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]fa7b1dc2010-06-23 17:53:041762}
1763
rlanday7efe2302017-01-11 00:14:281764void RenderWidget::OnImeCommitText(
1765 const base::string16& text,
Ryan Landay9e42fd742017-08-12 01:59:111766 const std::vector<WebImeTextSpan>& ime_text_spans,
rlanday7efe2302017-01-11 00:14:281767 const gfx::Range& replacement_range,
1768 int relative_cursor_pos) {
ekaramad5aff1942017-01-06 01:26:351769 if (!ShouldHandleImeEvents())
1770 return;
1771
brettw4b461082016-11-19 18:55:161772#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:491773 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
1774 plugin->render_frame()->OnImeCommitText(text, replacement_range,
1775 relative_cursor_pos);
ekaramad2a46d632016-07-19 13:33:091776 return;
1777 }
1778#endif
[email protected]66fca5bc2013-05-23 06:58:291779 ImeEventGuard guard(this);
fsamuele8326c742016-01-12 00:49:391780 input_handler_->set_handling_input_event(true);
ekaramadb6483a052017-02-10 02:23:261781 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:541782 controller->CommitText(
Ryan Landay9e42fd742017-08-12 01:59:111783 WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans),
ekaramadce32ef9f2017-02-09 17:33:561784 replacement_range.IsValid()
1785 ? WebRange(replacement_range.start(), replacement_range.length())
1786 : WebRange(),
1787 relative_cursor_pos);
ekaramadb6483a052017-02-10 02:23:261788 }
aelias87b8f7c2016-09-14 03:19:291789 input_handler_->set_handling_input_event(false);
1790 UpdateCompositionInfo(false /* not an immediate request */);
1791}
1792
1793void RenderWidget::OnImeFinishComposingText(bool keep_selection) {
ekaramad5aff1942017-01-06 01:26:351794 if (!ShouldHandleImeEvents())
1795 return;
1796
brettw4b461082016-11-19 18:55:161797#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:491798 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
1799 plugin->render_frame()->OnImeFinishComposingText(keep_selection);
aelias87b8f7c2016-09-14 03:19:291800 return;
1801 }
1802#endif
1803
changwan38c3eb612016-12-09 01:45:561804 if (!GetWebWidget())
aelias87b8f7c2016-09-14 03:19:291805 return;
1806 ImeEventGuard guard(this);
1807 input_handler_->set_handling_input_event(true);
ekaramad2daaf672016-11-10 20:29:011808 if (auto* controller = GetInputMethodController()) {
Blink Reformat1c4d759e2017-04-09 16:34:541809 controller->FinishComposingText(
1810 keep_selection ? WebInputMethodController::kKeepSelection
1811 : WebInputMethodController::kDoNotKeepSelection);
ekaramad2daaf672016-11-10 20:29:011812 }
fsamuele8326c742016-01-12 00:49:391813 input_handler_->set_handling_input_event(false);
nonafa291792016-08-10 02:36:181814 UpdateCompositionInfo(false /* not an immediate request */);
initial.commit09911bf2008-07-26 23:55:291815}
1816
Christopher Camerone9a30c12018-03-07 08:23:381817void RenderWidget::UpdateSurfaceAndScreenInfo(
Christopher Cameronbe7ecea2018-02-27 00:47:191818 viz::LocalSurfaceId new_local_surface_id,
Christopher Cameronaad15a0d2018-03-09 03:47:331819 const gfx::Size& new_compositor_viewport_pixel_size,
Christopher Camerone9a30c12018-03-07 08:23:381820 const ScreenInfo& new_screen_info) {
Christopher Camerone9a30c12018-03-07 08:23:381821 bool orientation_changed =
1822 screen_info_.orientation_angle != new_screen_info.orientation_angle ||
1823 screen_info_.orientation_type != new_screen_info.orientation_type;
1824 bool web_device_scale_factor_changed =
1825 screen_info_.device_scale_factor != new_screen_info.device_scale_factor;
Fady Samuela863f152018-03-09 16:10:031826 ScreenInfo previous_original_screen_info = GetOriginalScreenInfo();
Christopher Cameronbe7ecea2018-02-27 00:47:191827
1828 local_surface_id_ = new_local_surface_id;
Christopher Cameronaad15a0d2018-03-09 03:47:331829 compositor_viewport_pixel_size_ = new_compositor_viewport_pixel_size;
Christopher Camerone9a30c12018-03-07 08:23:381830 screen_info_ = new_screen_info;
Christopher Cameronbe7ecea2018-02-27 00:47:191831
Christopher Camerone9a30c12018-03-07 08:23:381832 if (compositor_) {
Ken Buchananb2c9e262018-03-10 16:53:311833 compositor_->SetViewportVisibleRect(ViewportVisibleRect());
Christopher Camerone9a30c12018-03-07 08:23:381834 // Note carefully that the DSF specified in |new_screen_info| is not the
1835 // DSF used by the compositor during device emulation!
Fady Samuela863f152018-03-09 16:10:031836 compositor_->SetViewportSizeAndScale(
1837 compositor_viewport_pixel_size_,
1838 GetOriginalScreenInfo().device_scale_factor, local_surface_id_);
Christopher Camerone9a30c12018-03-07 08:23:381839 }
Christopher Cameronbe7ecea2018-02-27 00:47:191840
Christopher Camerone9a30c12018-03-07 08:23:381841 if (orientation_changed)
1842 OnOrientationChange();
Christopher Cameronbe7ecea2018-02-27 00:47:191843
Fady Samuela863f152018-03-09 16:10:031844 if (previous_original_screen_info != GetOriginalScreenInfo()) {
Christopher Camerone9a30c12018-03-07 08:23:381845 for (auto& observer : render_frame_proxies_)
Fady Samuela863f152018-03-09 16:10:031846 observer.OnScreenInfoChanged(GetOriginalScreenInfo());
Christopher Camerone9a30c12018-03-07 08:23:381847
1848 // Notify all embedded BrowserPlugins of the updated ScreenInfo.
1849 for (auto& observer : browser_plugins_)
Fady Samuela863f152018-03-09 16:10:031850 observer.ScreenInfoChanged(GetOriginalScreenInfo());
Christopher Camerone9a30c12018-03-07 08:23:381851 }
1852
1853 if (web_device_scale_factor_changed)
Christopher Cameronbe7ecea2018-02-27 00:47:191854 UpdateWebViewWithDeviceScaleFactor();
oshimad5279032015-12-16 18:22:331855}
1856
[email protected]0bc1f572013-04-17 01:46:311857void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
[email protected]ec7dc112008-08-06 05:30:121858 // During shutdown we can just ignore this message.
lfg8ff33912016-09-13 20:59:211859 if (!GetWebWidget())
[email protected]ec7dc112008-08-06 05:30:121860 return;
1861
[email protected]0bc1f572013-04-17 01:46:311862 // Even if the browser provides an empty damage rect, it's still expecting to
1863 // receive a repaint ack so just damage the entire widget bounds.
1864 if (size_to_paint.IsEmpty()) {
1865 size_to_paint = size_;
1866 }
1867
[email protected]ec7dc112008-08-06 05:30:121868 set_next_paint_is_repaint_ack();
[email protected]aca33f4f2014-05-17 17:08:051869 if (compositor_)
[email protected]0bc1f572013-04-17 01:46:311870 compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint));
[email protected]ec7dc112008-08-06 05:30:121871}
1872
[email protected]4873c7d2009-07-16 06:36:281873void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
EhsanK955ba582017-11-30 21:14:401874 if (auto* frame = GetFocusedWebLocalFrameInWidget())
1875 frame->SetTextDirection(direction);
[email protected]07f953332009-03-25 04:31:111876}
1877
[email protected]80ad8622012-11-07 16:33:031878void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
1879 const gfx::Rect& window_screen_rect) {
[email protected]b2e4c70132013-10-03 02:07:511880 if (screen_metrics_emulator_) {
mfomitchev2600fd7c2016-02-17 20:53:391881 screen_metrics_emulator_->OnUpdateScreenRects(view_screen_rect,
1882 window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:511883 } else {
mfomitchev2600fd7c2016-02-17 20:53:391884 SetScreenRects(view_screen_rect, window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:511885 }
[email protected]80ad8622012-11-07 16:33:031886 Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
1887}
1888
lfgdb5c4ed2016-03-04 23:09:071889void RenderWidget::OnUpdateWindowScreenRect(
1890 const gfx::Rect& window_screen_rect) {
bokan6b08cd22016-10-05 00:55:211891 if (screen_metrics_emulator_)
lfgdb5c4ed2016-03-04 23:09:071892 screen_metrics_emulator_->OnUpdateWindowScreenRect(window_screen_rect);
bokan6b08cd22016-10-05 00:55:211893 else
lfgdb5c4ed2016-03-04 23:09:071894 window_screen_rect_ = window_screen_rect;
lfgdb5c4ed2016-03-04 23:09:071895}
1896
kenrbea731792017-01-13 15:10:481897void RenderWidget::OnSetViewportIntersection(
Ken Buchananb2c9e262018-03-10 16:53:311898 const gfx::Rect& viewport_intersection,
1899 const gfx::Rect& compositor_visible_rect) {
Ehsan Karamadf3ca2a82018-01-20 01:05:251900 if (auto* frame_widget = GetFrameWidget()) {
Ken Buchanan8a319fb2017-11-15 18:37:121901 DCHECK_EQ(popup_type_, WebPopupType::kWebPopupTypeNone);
Ken Buchananb2c9e262018-03-10 16:53:311902 viewport_intersection_ = viewport_intersection;
1903 compositor_visible_rect_ = compositor_visible_rect;
Ehsan Karamadf3ca2a82018-01-20 01:05:251904 frame_widget->SetRemoteViewportIntersection(viewport_intersection);
Ken Buchananb2c9e262018-03-10 16:53:311905 compositor_->SetViewportVisibleRect(ViewportVisibleRect());
kenrbea731792017-01-13 15:10:481906 }
1907}
1908
kenrb04323782017-06-23 01:23:321909void RenderWidget::OnSetIsInert(bool inert) {
Ehsan Karamadf3ca2a82018-01-20 01:05:251910 if (auto* frame_widget = GetFrameWidget()) {
Ken Buchanan8a319fb2017-11-15 18:37:121911 DCHECK_EQ(popup_type_, WebPopupType::kWebPopupTypeNone);
Ehsan Karamadf3ca2a82018-01-20 01:05:251912 frame_widget->SetIsInert(inert);
kenrb04323782017-06-23 01:23:321913 }
1914}
1915
Ken Buchanan8a319fb2017-11-15 18:37:121916void RenderWidget::OnUpdateRenderThrottlingStatus(bool is_throttled,
1917 bool subtree_throttled) {
Ehsan Karamadf3ca2a82018-01-20 01:05:251918 if (auto* frame_widget = GetFrameWidget()) {
Ken Buchanan8a319fb2017-11-15 18:37:121919 DCHECK_EQ(popup_type_, WebPopupType::kWebPopupTypeNone);
Ehsan Karamadf3ca2a82018-01-20 01:05:251920 frame_widget->UpdateRenderThrottlingStatus(is_throttled, subtree_throttled);
Ken Buchanan8a319fb2017-11-15 18:37:121921 }
1922}
1923
paulmeyer90f6c31d2016-11-12 00:17:591924void RenderWidget::OnDragTargetDragEnter(
1925 const std::vector<DropData::Metadata>& drop_meta_data,
Ella Ge80a52dce2017-11-15 18:01:521926 const gfx::PointF& client_point,
1927 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:591928 WebDragOperationsMask ops,
1929 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:251930 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1931 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:591932 return;
1933
Ehsan Karamadf3ca2a82018-01-20 01:05:251934 WebDragOperation operation = frame_widget->DragTargetDragEnter(
1935 DropMetaDataToWebDragData(drop_meta_data), client_point, screen_point,
1936 ops, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:591937
1938 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
1939}
1940
Ella Ge80a52dce2017-11-15 18:01:521941void RenderWidget::OnDragTargetDragOver(const gfx::PointF& client_point,
1942 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:591943 WebDragOperationsMask ops,
1944 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:251945 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1946 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:591947 return;
1948
Ehsan Karamadf3ca2a82018-01-20 01:05:251949 WebDragOperation operation = frame_widget->DragTargetDragOver(
1950 ConvertWindowPointToViewport(client_point), screen_point, ops,
1951 key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:591952
1953 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
1954}
1955
Ella Ge80a52dce2017-11-15 18:01:521956void RenderWidget::OnDragTargetDragLeave(const gfx::PointF& client_point,
1957 const gfx::PointF& screen_point) {
Ehsan Karamadf3ca2a82018-01-20 01:05:251958 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1959 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:591960 return;
Ehsan Karamadf3ca2a82018-01-20 01:05:251961
1962 frame_widget
1963
Blink Reformat1c4d759e2017-04-09 16:34:541964 ->DragTargetDragLeave(ConvertWindowPointToViewport(client_point),
kenrb07c272802017-02-07 23:48:171965 screen_point);
paulmeyer90f6c31d2016-11-12 00:17:591966}
1967
1968void RenderWidget::OnDragTargetDrop(const DropData& drop_data,
Ella Ge80a52dce2017-11-15 18:01:521969 const gfx::PointF& client_point,
1970 const gfx::PointF& screen_point,
paulmeyer90f6c31d2016-11-12 00:17:591971 int key_modifiers) {
Ehsan Karamadf3ca2a82018-01-20 01:05:251972 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1973 if (!frame_widget)
paulmeyer90f6c31d2016-11-12 00:17:591974 return;
1975
Ehsan Karamadf3ca2a82018-01-20 01:05:251976 frame_widget->DragTargetDrop(DropDataToWebDragData(drop_data),
1977 ConvertWindowPointToViewport(client_point),
1978 screen_point, key_modifiers);
paulmeyer90f6c31d2016-11-12 00:17:591979}
1980
Ella Ge80a52dce2017-11-15 18:01:521981void RenderWidget::OnDragSourceEnded(const gfx::PointF& client_point,
1982 const gfx::PointF& screen_point,
paulmeyer8fc8ea92016-11-15 05:12:211983 WebDragOperation op) {
Ehsan Karamadf3ca2a82018-01-20 01:05:251984 blink::WebFrameWidget* frame_widget = GetFrameWidget();
1985 if (!frame_widget)
paulmeyer8fc8ea92016-11-15 05:12:211986 return;
1987
Ehsan Karamadf3ca2a82018-01-20 01:05:251988 frame_widget->DragSourceEndedAt(ConvertWindowPointToViewport(client_point),
1989 screen_point, op);
paulmeyer8fc8ea92016-11-15 05:12:211990}
1991
1992void RenderWidget::OnDragSourceSystemDragEnded() {
1993 if (!GetWebWidget())
1994 return;
1995
Blink Reformat1c4d759e2017-04-09 16:34:541996 static_cast<WebFrameWidget*>(GetWebWidget())->DragSourceSystemDragEnded();
paulmeyer8fc8ea92016-11-15 05:12:211997}
1998
Blink Reformat1c4d759e2017-04-09 16:34:541999void RenderWidget::ShowVirtualKeyboardOnElementFocus() {
okaa398f50b2017-03-21 06:30:262000#if defined(OS_CHROMEOS)
2001 // On ChromeOS, virtual keyboard is triggered only when users leave the
2002 // mouse button or the finger and a text input element is focused at that
2003 // time. Focus event itself shouldn't trigger virtual keyboard.
2004 UpdateTextInputState();
2005#else
changwan75e3b2072017-01-16 02:55:002006 ShowVirtualKeyboard();
okaa398f50b2017-03-21 06:30:262007#endif
boliu7b2be2f2016-11-04 04:58:312008
2009// TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
2010// virtual keyboard.
2011#if !defined(OS_ANDROID)
2012 FocusChangeComplete();
2013#endif
[email protected]0d1ebed12013-08-05 22:01:132014}
2015
fsamuel72464894f2015-12-15 06:59:312016ui::TextInputType RenderWidget::GetTextInputType() {
brettw4b461082016-11-19 18:55:162017#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492018 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2019 return plugin->text_input_type();
ekaramad2a46d632016-07-19 13:33:092020#endif
ekaramad5aff1942017-01-06 01:26:352021 if (auto* controller = GetInputMethodController())
Blink Reformat1c4d759e2017-04-09 16:34:542022 return ConvertWebTextInputType(controller->TextInputType());
fsamuel72464894f2015-12-15 06:59:312023 return ui::TEXT_INPUT_TYPE_NONE;
2024}
2025
nonafa291792016-08-10 02:36:182026void RenderWidget::UpdateCompositionInfo(bool immediate_request) {
2027 if (!monitor_composition_info_ && !immediate_request)
2028 return; // Do not calculate composition info if not requested.
nonadac0c7a2016-08-01 02:30:592029
nonafa291792016-08-10 02:36:182030 TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo");
2031 gfx::Range range;
2032 std::vector<gfx::Rect> character_bounds;
2033
2034 if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE) {
2035 // Composition information is only available on editable node.
2036 range = gfx::Range::InvalidRange();
2037 } else {
2038 GetCompositionRange(&range);
2039 GetCompositionCharacterBounds(&character_bounds);
2040 }
2041
2042 if (!immediate_request &&
2043 !ShouldUpdateCompositionInfo(range, character_bounds)) {
fsamuel72464894f2015-12-15 06:59:312044 return;
nonafa291792016-08-10 02:36:182045 }
fsamuel72464894f2015-12-15 06:59:312046 composition_character_bounds_ = character_bounds;
2047 composition_range_ = range;
Dave Tapuska04bc5ee92018-04-17 19:03:312048 if (mojom::WidgetInputHandlerHost* host =
2049 widget_input_handler_manager_->GetWidgetInputHandlerHost()) {
2050 host->ImeCompositionRangeChanged(composition_range_,
2051 composition_character_bounds_);
Dave Tapuska139a72f2017-09-06 21:57:032052 }
fsamuel72464894f2015-12-15 06:59:312053}
2054
Blink Reformat1c4d759e2017-04-09 16:34:542055void RenderWidget::ConvertViewportToWindow(blink::WebRect* rect) {
oshimaf866dab2015-12-05 00:41:542056 if (IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:032057 float reverse = 1 / GetOriginalScreenInfo().device_scale_factor;
oshimad5279032015-12-16 18:22:332058 // TODO(oshima): We may need to allow pixel precision here as the the
oshimaf866dab2015-12-05 00:41:542059 // anchor element can be placed at half pixel.
lfg15b235a32016-08-25 17:45:462060 gfx::Rect window_rect =
2061 gfx::ScaleToEnclosedRect(gfx::Rect(*rect), reverse);
2062 rect->x = window_rect.x();
2063 rect->y = window_rect.y();
2064 rect->width = window_rect.width();
2065 rect->height = window_rect.height();
oshimaf866dab2015-12-05 00:41:542066 }
2067}
2068
Blink Reformat1c4d759e2017-04-09 16:34:542069void RenderWidget::ConvertWindowToViewport(blink::WebFloatRect* rect) {
oshimaa6985b62016-01-27 08:58:302070 if (IsUseZoomForDSFEnabled()) {
Fady Samuela863f152018-03-09 16:10:032071 rect->x *= GetOriginalScreenInfo().device_scale_factor;
2072 rect->y *= GetOriginalScreenInfo().device_scale_factor;
2073 rect->width *= GetOriginalScreenInfo().device_scale_factor;
2074 rect->height *= GetOriginalScreenInfo().device_scale_factor;
oshimaa6985b62016-01-27 08:58:302075 }
2076}
2077
changwan8c342742016-02-26 00:53:392078void RenderWidget::OnRequestTextInputStateUpdate() {
Dave Tapuska9db80842017-07-24 17:24:262079#if defined(OS_ANDROID)
changwan8c342742016-02-26 00:53:392080 DCHECK(!ime_event_guard_);
2081 UpdateSelectionBounds();
changwan75e3b2072017-01-16 02:55:002082 UpdateTextInputStateInternal(false, true /* reply_to_request */);
[email protected]105dffb42013-02-20 03:46:212083#endif
Dave Tapuska9db80842017-07-24 17:24:262084}
[email protected]105dffb42013-02-20 03:46:212085
ekaramadc9b70a72017-03-23 16:14:232086void RenderWidget::OnRequestCompositionUpdates(bool immediate_request,
2087 bool monitor_updates) {
2088 monitor_composition_info_ = monitor_updates;
nonafa291792016-08-10 02:36:182089 if (!immediate_request)
2090 return;
2091 UpdateCompositionInfo(true /* immediate request */);
2092}
2093
[email protected]fcdc5642014-05-09 14:32:242094void RenderWidget::OnOrientationChange() {
Ehsan Karamad655d7b8a2018-01-12 18:38:382095 if (auto* frame_widget = GetFrameWidget()) {
Alex Moshchuk0b409c42017-09-13 02:09:002096 // LocalRoot() might return null for provisional main frames. In this case,
2097 // the frame hasn't committed a navigation and is not swapped into the tree
2098 // yet, so it doesn't make sense to send orientation change events to it.
2099 //
2100 // TODO(https://crbug.com/578349): This check should be cleaned up
2101 // once provisional frames are gone.
Ehsan Karamad655d7b8a2018-01-12 18:38:382102 if (frame_widget->LocalRoot())
2103 frame_widget->LocalRoot()->SendOrientationChangeEvent();
lfg8d649cc2017-04-28 18:04:302104 }
[email protected]fcdc5642014-05-09 14:32:242105}
2106
[email protected]bee16aab2009-08-26 15:55:032107void RenderWidget::SetHidden(bool hidden) {
2108 if (is_hidden_ == hidden)
2109 return;
2110
jdduke8fac9d102014-12-20 02:40:132111 // The status has changed. Tell the RenderThread about it and ensure
2112 // throttled acks are released in case frame production ceases.
[email protected]bee16aab2009-08-26 15:55:032113 is_hidden_ = hidden;
jdduke8fac9d102014-12-20 02:40:132114
Scott Violet1098538e2017-10-05 19:23:332115#if defined(USE_AURA)
Scott Violet8ff9c302018-02-22 22:28:352116 if (features::IsMusEnabled())
Scott Violet1098538e2017-10-05 19:23:332117 RendererWindowTreeClient::Get(routing_id_)->SetVisible(!hidden);
2118#endif
2119
Saman Sami58ed4392018-01-31 20:54:192120 // RenderThreadImpl::current() could be null in tests.
2121 if (RenderThreadImpl::current()) {
2122 if (is_hidden_) {
2123 RenderThreadImpl::current()->WidgetHidden();
2124 first_update_visual_state_after_hidden_ = true;
2125 } else {
2126 RenderThreadImpl::current()->WidgetRestored();
2127 }
Lei Zhang9b359d32017-11-28 00:57:022128 }
alexclarke7fa93942015-10-21 15:37:112129
2130 if (render_widget_scheduling_state_)
2131 render_widget_scheduling_state_->SetHidden(hidden);
[email protected]bee16aab2009-08-26 15:55:032132}
2133
[email protected]2b624c562011-10-27 22:58:262134void RenderWidget::DidToggleFullscreen() {
lfg8ff33912016-09-13 20:59:212135 if (!GetWebWidget())
[email protected]2b624c562011-10-27 22:58:262136 return;
2137
mikhail.pozdnyakovf2c902a2015-04-14 08:09:122138 if (is_fullscreen_granted_) {
Blink Reformat1c4d759e2017-04-09 16:34:542139 GetWebWidget()->DidEnterFullscreen();
[email protected]2b624c562011-10-27 22:58:262140 } else {
Blink Reformat1c4d759e2017-04-09 16:34:542141 GetWebWidget()->DidExitFullscreen();
[email protected]2b624c562011-10-27 22:58:262142 }
[email protected]2b624c562011-10-27 22:58:262143}
2144
[email protected]674741932009-02-04 23:44:462145bool RenderWidget::next_paint_is_resize_ack() const {
Fady Samuelcc3e3b4a2017-10-03 02:09:212146 return ViewHostMsg_ResizeOrRepaint_ACK_Flags::is_resize_ack(
2147 next_paint_flags_);
[email protected]674741932009-02-04 23:44:462148}
2149
[email protected]674741932009-02-04 23:44:462150void RenderWidget::set_next_paint_is_resize_ack() {
Fady Samuelcc3e3b4a2017-10-03 02:09:212151 next_paint_flags_ |= ViewHostMsg_ResizeOrRepaint_ACK_Flags::IS_RESIZE_ACK;
[email protected]674741932009-02-04 23:44:462152}
2153
[email protected]674741932009-02-04 23:44:462154void RenderWidget::set_next_paint_is_repaint_ack() {
Fady Samuelcc3e3b4a2017-10-03 02:09:212155 next_paint_flags_ |= ViewHostMsg_ResizeOrRepaint_ACK_Flags::IS_REPAINT_ACK;
[email protected]674741932009-02-04 23:44:462156}
2157
Saman Samif7731342018-01-24 22:18:442158void RenderWidget::reset_next_paint_is_resize_ack() {
2159 DCHECK(next_paint_is_resize_ack());
2160 next_paint_flags_ ^= ViewHostMsg_ResizeOrRepaint_ACK_Flags::IS_RESIZE_ACK;
2161}
2162
changwanf2a707b2015-10-30 08:22:162163void RenderWidget::OnImeEventGuardStart(ImeEventGuard* guard) {
2164 if (!ime_event_guard_)
2165 ime_event_guard_ = guard;
[email protected]66fca5bc2013-05-23 06:58:292166}
2167
changwanf2a707b2015-10-30 08:22:162168void RenderWidget::OnImeEventGuardFinish(ImeEventGuard* guard) {
2169 if (ime_event_guard_ != guard) {
changwan75e3b2072017-01-16 02:55:002170 DCHECK(!ime_event_guard_->reply_to_request());
changwanf2a707b2015-10-30 08:22:162171 return;
2172 }
2173 ime_event_guard_ = nullptr;
2174
[email protected]66fca5bc2013-05-23 06:58:292175 // While handling an ime event, text input state and selection bounds updates
2176 // are ignored. These must explicitly be updated once finished handling the
2177 // ime event.
2178 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:472179#if defined(OS_ANDROID)
changwan75e3b2072017-01-16 02:55:002180 if (guard->show_virtual_keyboard())
2181 ShowVirtualKeyboard();
2182 else
2183 UpdateTextInputState();
[email protected]cb9e2632013-06-18 11:26:472184#endif
[email protected]66fca5bc2013-05-23 06:58:292185}
2186
[email protected]7c8873e2013-02-05 08:03:012187void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
brettw4b461082016-11-19 18:55:162188#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492189 if (auto* plugin = GetFocusedPepperPluginInsideWidget()) {
ekaramad2a46d632016-07-19 13:33:092190 // TODO(kinaba) http://crbug.com/101101
2191 // Current Pepper IME API does not handle selection bounds. So we simply
2192 // use the caret position as an empty range for now. It will be updated
2193 // after Pepper API equips features related to surrounding text retrieval.
EhsanK22d482e2017-08-10 17:29:492194 blink::WebRect caret(plugin->GetCaretBounds());
Blink Reformat1c4d759e2017-04-09 16:34:542195 ConvertViewportToWindow(&caret);
ekaramad2a46d632016-07-19 13:33:092196 *focus = caret;
2197 *anchor = caret;
2198 return;
2199 }
2200#endif
[email protected]7c8873e2013-02-05 08:03:012201 WebRect focus_webrect;
2202 WebRect anchor_webrect;
Blink Reformat1c4d759e2017-04-09 16:34:542203 GetWebWidget()->SelectionBounds(focus_webrect, anchor_webrect);
2204 ConvertViewportToWindow(&focus_webrect);
2205 ConvertViewportToWindow(&anchor_webrect);
oshima33ec97cd2015-12-14 19:40:242206 *focus = focus_webrect;
2207 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:322208}
2209
[email protected]e99ef6f2011-10-16 01:13:002210void RenderWidget::UpdateSelectionBounds() {
jdduke1aebad8e2015-07-22 23:25:082211 TRACE_EVENT0("renderer", "RenderWidget::UpdateSelectionBounds");
lfg8ff33912016-09-13 20:59:212212 if (!GetWebWidget())
[email protected]e99ef6f2011-10-16 01:13:002213 return;
changwanf2a707b2015-10-30 08:22:162214 if (ime_event_guard_)
[email protected]66fca5bc2013-05-23 06:58:292215 return;
[email protected]e99ef6f2011-10-16 01:13:002216
mohsenb0eeba72015-08-09 06:20:082217#if defined(USE_AURA)
2218 // TODO(mohsen): For now, always send explicit selection IPC notifications for
2219 // Aura beucause composited selection updates are not working for webview tags
2220 // which regresses IME inside webview. Remove this when composited selection
2221 // updates are fixed for webviews. See, http://crbug.com/510568.
2222 bool send_ipc = true;
2223#else
jddukeacf809e2014-09-23 20:38:382224 // With composited selection updates, the selection bounds will be reported
2225 // directly by the compositor, in which case explicit IPC selection
2226 // notifications should be suppressed.
mohsenb0eeba72015-08-09 06:20:082227 bool send_ipc =
Blink Reformat1c4d759e2017-04-09 16:34:542228 !blink::WebRuntimeFeatures::IsCompositedSelectionUpdateEnabled();
mohsenb0eeba72015-08-09 06:20:082229#endif
2230 if (send_ipc) {
jddukeacf809e2014-09-23 20:38:382231 ViewHostMsg_SelectionBounds_Params params;
EhsanK955ba582017-11-30 21:14:402232 params.is_anchor_first = false;
jddukeacf809e2014-09-23 20:38:382233 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
2234 if (selection_anchor_rect_ != params.anchor_rect ||
2235 selection_focus_rect_ != params.focus_rect) {
2236 selection_anchor_rect_ = params.anchor_rect;
2237 selection_focus_rect_ = params.focus_rect;
EhsanK955ba582017-11-30 21:14:402238 if (auto* focused_frame = GetFocusedWebLocalFrameInWidget()) {
2239 focused_frame->SelectionTextDirection(params.focus_dir,
2240 params.anchor_dir);
2241 params.is_anchor_first = focused_frame->IsSelectionAnchorFirst();
2242 }
jddukeacf809e2014-09-23 20:38:382243 Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
2244 }
[email protected]58b48a0d2012-06-13 07:01:352245 }
jddukeacf809e2014-09-23 20:38:382246
nonafa291792016-08-10 02:36:182247 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]e99ef6f2011-10-16 01:13:002248}
2249
lfgb00fcad2016-07-14 14:16:332250void RenderWidget::DidAutoResize(const gfx::Size& new_size) {
2251 WebRect new_size_in_window(0, 0, new_size.width(), new_size.height());
Blink Reformat1c4d759e2017-04-09 16:34:542252 ConvertViewportToWindow(&new_size_in_window);
lfgb00fcad2016-07-14 14:16:332253 if (size_.width() != new_size_in_window.width ||
2254 size_.height() != new_size_in_window.height) {
2255 size_ = gfx::Size(new_size_in_window.width, new_size_in_window.height);
2256
2257 if (resizing_mode_selector_->is_synchronous_mode()) {
Blink Reformat1c4d759e2017-04-09 16:34:542258 gfx::Rect new_pos(WindowRect().x, WindowRect().y, size_.width(),
2259 size_.height());
lfgb00fcad2016-07-14 14:16:332260 view_screen_rect_ = new_pos;
2261 window_screen_rect_ = new_pos;
2262 }
2263
Christopher Camerone9a30c12018-03-07 08:23:382264 // TODO(ccameron): Note that this destroys any information differentiating
Christopher Cameronaad15a0d2018-03-09 03:47:332265 // |size_| from |compositor_viewport_pixel_size_|. Also note that the
2266 // calculation of |new_compositor_viewport_pixel_size| does not appear to
2267 // take into account device emulation.
Fady Samuelda839bb2018-03-26 17:34:482268 ++auto_resize_sequence_number_;
Christopher Cameronaad15a0d2018-03-09 03:47:332269 gfx::Size new_compositor_viewport_pixel_size =
Fady Samuela863f152018-03-09 16:10:032270 gfx::ScaleToCeiledSize(size_, GetWebScreenInfo().device_scale_factor);
Chris Blume760b9462018-04-12 21:45:332271 viz::LocalSurfaceId local_surface_id;
2272 if (!compositor_viewport_pixel_size_.IsEmpty())
2273 local_surface_id = child_local_surface_id_allocator_.GenerateId();
2274 UpdateSurfaceAndScreenInfo(
2275 local_surface_id, new_compositor_viewport_pixel_size, screen_info_);
lfgb00fcad2016-07-14 14:16:332276
Fady Samuel319e429c2017-10-02 18:31:552277 if (!resizing_mode_selector_->is_synchronous_mode()) {
Fady Samueld10aadd82017-11-03 18:23:572278 need_resize_ack_for_auto_resize_ = true;
Fady Samuel319e429c2017-10-02 18:31:552279 // If surface synchronization is off, then ResizeAcks go to the browser in
2280 // response to a DidReceiveCompositorFrame. With surface synchronization
2281 // on, that notification will not arrive here because the compositor is
2282 // deferring commits and thus submission of CompositorFrames.
2283 if (!size_.IsEmpty() && compositor_ &&
Fady Samuel1ee6fb5c2018-02-16 03:27:462284 compositor_->IsSurfaceSynchronizationEnabled() &&
2285 !auto_resize_ack_callback_.callback()) {
2286 auto_resize_ack_callback_.Reset(
2287 base::BindOnce(&RenderWidget::DidResizeOrRepaintAck,
2288 weak_ptr_factory_.GetWeakPtr()));
2289 base::ThreadTaskRunnerHandle::Get()->PostTask(
2290 FROM_HERE, auto_resize_ack_callback_.callback());
Fady Samuel319e429c2017-10-02 18:31:552291 }
2292 }
lfgb00fcad2016-07-14 14:16:332293 }
2294}
2295
[email protected]58b48a0d2012-06-13 07:01:352296void RenderWidget::GetCompositionCharacterBounds(
2297 std::vector<gfx::Rect>* bounds) {
2298 DCHECK(bounds);
2299 bounds->clear();
ekaramad2a46d632016-07-19 13:33:092300
brettw4b461082016-11-19 18:55:162301#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492302 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092303 return;
2304#endif
2305
Ehsan Karamad4975af6d2018-02-09 16:58:162306 blink::WebInputMethodController* controller = GetInputMethodController();
2307 if (!controller)
ekaramad2a46d632016-07-19 13:33:092308 return;
2309 blink::WebVector<blink::WebRect> bounds_from_blink;
Ehsan Karamad4975af6d2018-02-09 16:58:162310 if (!controller->GetCompositionCharacterBounds(bounds_from_blink))
ekaramad2a46d632016-07-19 13:33:092311 return;
2312
2313 for (size_t i = 0; i < bounds_from_blink.size(); ++i) {
Blink Reformat1c4d759e2017-04-09 16:34:542314 ConvertViewportToWindow(&bounds_from_blink[i]);
ekaramad2a46d632016-07-19 13:33:092315 bounds->push_back(bounds_from_blink[i]);
2316 }
[email protected]58b48a0d2012-06-13 07:01:352317}
2318
[email protected]db4fc1e2013-09-06 20:01:512319void RenderWidget::GetCompositionRange(gfx::Range* range) {
brettw4b461082016-11-19 18:55:162320#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492321 if (GetFocusedPepperPluginInsideWidget())
ekaramad2a46d632016-07-19 13:33:092322 return;
2323#endif
EhsanKcdee7b72017-11-08 21:30:092324 blink::WebInputMethodController* controller = GetInputMethodController();
2325 WebRange web_range = controller ? controller->CompositionRange() : WebRange();
Blink Reformat1c4d759e2017-04-09 16:34:542326 if (web_range.IsNull()) {
nona2363a3d2016-11-09 03:26:212327 *range = gfx::Range::InvalidRange();
2328 return;
[email protected]88dbe32f2013-06-20 23:31:362329 }
Blink Reformat1c4d759e2017-04-09 16:34:542330 range->set_start(web_range.StartOffset());
2331 range->set_end(web_range.EndOffset());
[email protected]88dbe32f2013-06-20 23:31:362332}
2333
[email protected]501ea13d2013-07-09 17:03:292334bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:512335 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:292336 const std::vector<gfx::Rect>& bounds) {
changwan2418e1b2016-12-12 12:43:082337 if (!range.IsValid())
2338 return false;
[email protected]501ea13d2013-07-09 17:03:292339 if (composition_range_ != range)
2340 return true;
2341 if (bounds.size() != composition_character_bounds_.size())
2342 return true;
2343 for (size_t i = 0; i < bounds.size(); ++i) {
2344 if (bounds[i] != composition_character_bounds_[i])
2345 return true;
2346 }
2347 return false;
2348}
[email protected]501ea13d2013-07-09 17:03:292349
[email protected]ad26ef42011-06-17 07:59:452350bool RenderWidget::CanComposeInline() {
brettw4b461082016-11-19 18:55:162351#if BUILDFLAG(ENABLE_PLUGINS)
EhsanK22d482e2017-08-10 17:29:492352 if (auto* plugin = GetFocusedPepperPluginInsideWidget())
2353 return plugin->IsPluginAcceptingCompositionEvents();
ekaramad2a46d632016-07-19 13:33:092354#endif
[email protected]ad26ef42011-06-17 07:59:452355 return true;
[email protected]56ea1a62011-05-30 07:05:572356}
2357
Blink Reformat1c4d759e2017-04-09 16:34:542358blink::WebScreenInfo RenderWidget::GetScreenInfo() {
ccameron2f451532016-09-07 21:49:272359 blink::WebScreenInfo web_screen_info;
Blink Reformat1c4d759e2017-04-09 16:34:542360 web_screen_info.device_scale_factor = screen_info_.device_scale_factor;
ccameronab0aab82017-06-24 17:21:542361 web_screen_info.color_space = screen_info_.color_space;
ccameron2f451532016-09-07 21:49:272362 web_screen_info.depth = screen_info_.depth;
Blink Reformat1c4d759e2017-04-09 16:34:542363 web_screen_info.depth_per_component = screen_info_.depth_per_component;
2364 web_screen_info.is_monochrome = screen_info_.is_monochrome;
ccameron2f451532016-09-07 21:49:272365 web_screen_info.rect = blink::WebRect(screen_info_.rect);
Blink Reformat1c4d759e2017-04-09 16:34:542366 web_screen_info.available_rect = blink::WebRect(screen_info_.available_rect);
ccameron2f451532016-09-07 21:49:272367 switch (screen_info_.orientation_type) {
2368 case SCREEN_ORIENTATION_VALUES_PORTRAIT_PRIMARY:
Blink Reformat1c4d759e2017-04-09 16:34:542369 web_screen_info.orientation_type =
2370 blink::kWebScreenOrientationPortraitPrimary;
ccameron2f451532016-09-07 21:49:272371 break;
2372 case SCREEN_ORIENTATION_VALUES_PORTRAIT_SECONDARY:
Blink Reformat1c4d759e2017-04-09 16:34:542373 web_screen_info.orientation_type =
2374 blink::kWebScreenOrientationPortraitSecondary;
ccameron2f451532016-09-07 21:49:272375 break;
2376 case SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY:
Blink Reformat1c4d759e2017-04-09 16:34:542377 web_screen_info.orientation_type =
2378 blink::kWebScreenOrientationLandscapePrimary;
ccameron2f451532016-09-07 21:49:272379 break;
2380 case SCREEN_ORIENTATION_VALUES_LANDSCAPE_SECONDARY:
Blink Reformat1c4d759e2017-04-09 16:34:542381 web_screen_info.orientation_type =
2382 blink::kWebScreenOrientationLandscapeSecondary;
ccameron2f451532016-09-07 21:49:272383 break;
2384 default:
Blink Reformat1c4d759e2017-04-09 16:34:542385 web_screen_info.orientation_type = blink::kWebScreenOrientationUndefined;
ccameron2f451532016-09-07 21:49:272386 break;
2387 }
Blink Reformat1c4d759e2017-04-09 16:34:542388 web_screen_info.orientation_angle = screen_info_.orientation_angle;
Fady Samuel85a1bf72017-10-27 14:30:202389
ccameron2f451532016-09-07 21:49:272390 return web_screen_info;
[email protected]4873c7d2009-07-16 06:36:282391}
2392
Blink Reformat1c4d759e2017-04-09 16:34:542393void RenderWidget::DidHandleGestureEvent(const WebGestureEvent& event,
2394 bool event_cancelled) {
[email protected]183e28d2014-01-20 18:18:022395#if defined(OS_ANDROID) || defined(USE_AURA)
[email protected]c68c3e4e2013-01-24 00:36:562396 if (event_cancelled)
2397 return;
Blink Reformat1c4d759e2017-04-09 16:34:542398 if (event.GetType() == WebInputEvent::kGestureTap) {
changwan75e3b2072017-01-16 02:55:002399 ShowVirtualKeyboard();
Blink Reformat1c4d759e2017-04-09 16:34:542400 } else if (event.GetType() == WebInputEvent::kGestureLongPress) {
lfg8ff33912016-09-13 20:59:212401 DCHECK(GetWebWidget());
ekaramad5aff1942017-01-06 01:26:352402 blink::WebInputMethodController* controller = GetInputMethodController();
Blink Reformat1c4d759e2017-04-09 16:34:542403 if (!controller || controller->TextInputInfo().value.IsEmpty())
changwan75e3b2072017-01-16 02:55:002404 UpdateTextInputState();
[email protected]07c70d22014-08-21 08:33:462405 else
changwan75e3b2072017-01-16 02:55:002406 ShowVirtualKeyboard();
[email protected]c68c3e4e2013-01-24 00:36:562407 }
ekaramada110f642016-12-21 19:47:282408// TODO(ananta): Piggyback off existing IPCs to communicate this information,
2409// crbug/420130.
2410#if defined(OS_WIN)
Blink Reformat1c4d759e2017-04-09 16:34:542411 if (event.GetType() != blink::WebGestureEvent::kGestureTap)
ekaramada110f642016-12-21 19:47:282412 return;
2413
2414 // TODO(estade): hit test the event against focused node to make sure
2415 // the tap actually hit the focused node.
ekaramad5aff1942017-01-06 01:26:352416 blink::WebInputMethodController* controller = GetInputMethodController();
2417 blink::WebTextInputType text_input_type =
Blink Reformat1c4d759e2017-04-09 16:34:542418 controller ? controller->TextInputType() : blink::kWebTextInputTypeNone;
ekaramada110f642016-12-21 19:47:282419
2420 Send(new ViewHostMsg_FocusedNodeTouched(
Blink Reformat1c4d759e2017-04-09 16:34:542421 routing_id_, text_input_type != blink::kWebTextInputTypeNone));
ekaramada110f642016-12-21 19:47:282422#endif
[email protected]c68c3e4e2013-01-24 00:36:562423#endif
2424}
2425
Blink Reformat1c4d759e2017-04-09 16:34:542426void RenderWidget::DidOverscroll(
bokane53a10f2016-04-13 23:48:312427 const blink::WebFloatSize& overscrollDelta,
2428 const blink::WebFloatSize& accumulatedOverscroll,
sataya.m582c9ce2015-06-09 08:03:422429 const blink::WebFloatPoint& position,
sunyunjiabbea8a92017-08-31 11:18:542430 const blink::WebFloatSize& velocity,
Sandra Sun2288e8532017-11-30 22:50:162431 const blink::WebOverscrollBehavior& behavior) {
bokan731ec382016-04-07 03:16:482432#if defined(OS_MACOSX)
2433 // On OSX the user can disable the elastic overscroll effect. If that's the
2434 // case, don't forward the overscroll notification.
2435 DCHECK(compositor_deps());
2436 if (!compositor_deps()->IsElasticOverscrollEnabled())
2437 return;
2438#endif
bokane53a10f2016-04-13 23:48:312439 input_handler_->DidOverscrollFromBlink(overscrollDelta, accumulatedOverscroll,
sunyunjiabbea8a92017-08-31 11:18:542440 position, velocity, behavior);
sataya.m582c9ce2015-06-09 08:03:422441}
2442
[email protected]7912e822014-04-16 02:37:032443void RenderWidget::StartCompositor() {
sievers71c62dd52015-10-07 01:44:392444 if (!is_hidden())
Blink Reformat1c4d759e2017-04-09 16:34:542445 compositor_->SetVisible(true);
[email protected]7912e822014-04-16 02:37:032446}
2447
[email protected]24ed0432013-04-24 07:50:312448RenderWidgetCompositor* RenderWidget::compositor() const {
2449 return compositor_.get();
2450}
2451
fsamuel72464894f2015-12-15 06:59:312452void RenderWidget::SetHandlingInputEventForTesting(bool handling_input_event) {
fsamuele8326c742016-01-12 00:49:392453 input_handler_->set_handling_input_event(handling_input_event);
[email protected]67bfb83f2011-09-22 03:36:372454}
[email protected]c3d45532011-10-07 19:20:402455
Blink Reformat1c4d759e2017-04-09 16:34:542456void RenderWidget::HasTouchEventHandlers(bool has_handlers) {
W. James MacLean662d5382018-03-29 18:33:082457 if (has_touch_handlers_ && *has_touch_handlers_ == has_handlers)
2458 return;
2459
2460 has_touch_handlers_ = has_handlers;
alexclarke7fa93942015-10-21 15:37:112461 if (render_widget_scheduling_state_)
2462 render_widget_scheduling_state_->SetHasTouchHandler(has_handlers);
[email protected]ce6689f2013-03-29 12:52:552463 Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
2464}
2465
Dave Tapuskadfe486c12017-06-09 16:53:132466void RenderWidget::SetNeedsLowLatencyInput(bool needs_low_latency) {
2467 if (input_event_queue_)
2468 input_event_queue_->SetNeedsLowLatency(needs_low_latency);
2469}
2470
Dave Tapuskabafc2ba32017-11-28 01:54:372471void RenderWidget::RequestUnbufferedInputEvents() {
2472 if (input_event_queue_)
2473 input_event_queue_->RequestUnbufferedInputEvents();
2474}
2475
xidachenfa0199e72017-05-11 11:34:262476void RenderWidget::SetTouchAction(cc::TouchAction touch_action) {
Dave Tapuskab28a1082017-08-30 15:37:262477 if (!input_handler_->ProcessTouchAction(touch_action))
[email protected]5d0bbdfa92013-12-10 00:35:512478 return;
2479
Dave Tapuska04bc5ee92018-04-17 19:03:312480 widget_input_handler_manager_->ProcessTouchAction(touch_action);
[email protected]5d0bbdfa92013-12-10 00:35:512481}
2482
[email protected]e3244ed2014-06-20 20:04:272483void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
2484 render_frame_proxies_.AddObserver(proxy);
[email protected]bffc8302014-01-23 20:52:162485}
2486
[email protected]e3244ed2014-06-20 20:04:272487void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
2488 render_frame_proxies_.RemoveObserver(proxy);
[email protected]bffc8302014-01-23 20:52:162489}
2490
[email protected]de3c5d82014-05-28 22:12:592491void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
2492 render_frames_.AddObserver(frame);
2493}
2494
2495void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) {
2496 render_frames_.RemoveObserver(frame);
2497}
2498
Saman Samid189e5dfd2017-12-20 22:55:312499void RenderWidget::RegisterBrowserPlugin(BrowserPlugin* browser_plugin) {
2500 browser_plugins_.AddObserver(browser_plugin);
Saman Sami50d1e0c2018-03-13 20:03:492501 browser_plugin->ScreenInfoChanged(GetOriginalScreenInfo());
Saman Samid189e5dfd2017-12-20 22:55:312502}
2503
2504void RenderWidget::UnregisterBrowserPlugin(BrowserPlugin* browser_plugin) {
2505 browser_plugins_.RemoveObserver(browser_plugin);
2506}
2507
lfg43e08e62016-02-03 18:51:372508void RenderWidget::OnWaitNextFrameForTests(int routing_id) {
2509 QueueMessage(new ViewHostMsg_WaitForNextFrameForTests_ACK(routing_id),
2510 MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE);
2511}
2512
Fady Samuela863f152018-03-09 16:10:032513const ScreenInfo& RenderWidget::GetWebScreenInfo() const {
2514 return screen_info_;
Christopher Camerone9a30c12018-03-07 08:23:382515}
2516
Fady Samuela863f152018-03-09 16:10:032517const ScreenInfo& RenderWidget::GetOriginalScreenInfo() const {
Christopher Camerone9a30c12018-03-07 08:23:382518 return screen_metrics_emulator_
2519 ? screen_metrics_emulator_->original_screen_info()
Fady Samuela863f152018-03-09 16:10:032520 : screen_info_;
oshima50872a72016-03-04 13:26:182521}
2522
Ella Ge80a52dce2017-11-15 18:01:522523gfx::PointF RenderWidget::ConvertWindowPointToViewport(
2524 const gfx::PointF& point) {
paulmeyer90f6c31d2016-11-12 00:17:592525 blink::WebFloatRect point_in_viewport(point.x(), point.y(), 0, 0);
Blink Reformat1c4d759e2017-04-09 16:34:542526 ConvertWindowToViewport(&point_in_viewport);
Ella Ge80a52dce2017-11-15 18:01:522527 return gfx::PointF(point_in_viewport.x, point_in_viewport.y);
2528}
2529
2530gfx::Point RenderWidget::ConvertWindowPointToViewport(const gfx::Point& point) {
2531 return gfx::ToRoundedPoint(ConvertWindowPointToViewport(gfx::PointF(point)));
paulmeyer90f6c31d2016-11-12 00:17:592532}
2533
Blink Reformat1c4d759e2017-04-09 16:34:542534bool RenderWidget::RequestPointerLock() {
lfgbee1e0a2016-06-08 21:24:212535 return mouse_lock_dispatcher_->LockMouse(webwidget_mouse_lock_target_.get());
2536}
2537
Blink Reformat1c4d759e2017-04-09 16:34:542538void RenderWidget::RequestPointerUnlock() {
lfgbee1e0a2016-06-08 21:24:212539 mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
2540}
2541
Blink Reformat1c4d759e2017-04-09 16:34:542542bool RenderWidget::IsPointerLocked() {
lfgbee1e0a2016-06-08 21:24:212543 return mouse_lock_dispatcher_->IsMouseLockedTo(
2544 webwidget_mouse_lock_target_.get());
2545}
2546
Blink Reformat1c4d759e2017-04-09 16:34:542547void RenderWidget::StartDragging(blink::WebReferrerPolicy policy,
paulmeyer6ef5a792016-11-08 20:33:582548 const WebDragData& data,
2549 WebDragOperationsMask mask,
2550 const WebImage& image,
2551 const WebPoint& webImageOffset) {
2552 blink::WebRect offset_in_window(webImageOffset.x, webImageOffset.y, 0, 0);
Blink Reformat1c4d759e2017-04-09 16:34:542553 ConvertViewportToWindow(&offset_in_window);
paulmeyer6ef5a792016-11-08 20:33:582554 DropData drop_data(DropDataBuilder::Build(data));
2555 drop_data.referrer_policy = policy;
2556 gfx::Vector2d imageOffset(offset_in_window.x, offset_in_window.y);
paulmeyer90f6c31d2016-11-12 00:17:592557 Send(new DragHostMsg_StartDragging(routing_id(), drop_data, mask,
Blink Reformat1c4d759e2017-04-09 16:34:542558 image.GetSkBitmap(), imageOffset,
paulmeyer6ef5a792016-11-08 20:33:582559 possible_drag_event_info_));
2560}
2561
kenrb5d78b842017-03-06 21:06:012562uint32_t RenderWidget::GetContentSourceId() {
2563 return current_content_source_id_;
2564}
2565
Saman Samif7731342018-01-24 22:18:442566void RenderWidget::DidNavigate() {
Saman Sami26a1fcd2018-04-10 17:12:212567 ++current_content_source_id_;
Saman Samif7731342018-01-24 22:18:442568 if (!compositor_)
2569 return;
Saman Sami26a1fcd2018-04-10 17:12:212570 compositor_->SetContentSourceId(current_content_source_id_);
Christopher Cameronbe7ecea2018-02-27 00:47:192571
Christopher Cameronaad15a0d2018-03-09 03:47:332572 UpdateSurfaceAndScreenInfo(viz::LocalSurfaceId(),
2573 compositor_viewport_pixel_size_, screen_info_);
Christopher Cameronbe7ecea2018-02-27 00:47:192574
Saman Samif7731342018-01-24 22:18:442575 // If surface synchronization is on, navigation implicitly acks any resize
2576 // that has happened so far so we can get the next ResizeParams containing the
2577 // LocalSurfaceId that should be used after navigation.
2578 if (compositor_->IsSurfaceSynchronizationEnabled() && !auto_resize_mode_ &&
2579 next_paint_is_resize_ack()) {
2580 reset_next_paint_is_resize_ack();
2581 }
kenrb5d78b842017-03-06 21:06:012582}
2583
lfg8ff33912016-09-13 20:59:212584blink::WebWidget* RenderWidget::GetWebWidget() const {
2585 return webwidget_internal_;
2586}
2587
ekaramad2daaf672016-11-10 20:29:012588blink::WebInputMethodController* RenderWidget::GetInputMethodController()
2589 const {
Ehsan Karamad655d7b8a2018-01-12 18:38:382590 if (auto* frame_widget = GetFrameWidget())
2591 return frame_widget->GetActiveWebInputMethodController();
2592
2593 return nullptr;
ekaramad2daaf672016-11-10 20:29:012594}
2595
Dave Tapuska139a72f2017-09-06 21:57:032596void RenderWidget::SetupWidgetInputHandler(
2597 mojom::WidgetInputHandlerRequest request,
2598 mojom::WidgetInputHandlerHostPtr host) {
Dave Tapuskab66c28f2017-11-15 17:18:472599 widget_input_handler_manager_->AddInterface(std::move(request),
2600 std::move(host));
Dave Tapuska525eb15e2017-08-17 21:05:502601}
2602
Dave Tapuska485aca92017-08-08 00:47:582603void RenderWidget::SetWidgetBinding(mojom::WidgetRequest request) {
2604 // Close the old binding if there was one.
2605 // A RenderWidgetHost should not need more than one channel.
2606 widget_binding_.Close();
2607 widget_binding_.Bind(std::move(request));
2608}
2609
Fady Samuelcc3e3b4a2017-10-03 02:09:212610void RenderWidget::DidResizeOrRepaintAck() {
Fady Samueld10aadd82017-11-03 18:23:572611 if (!next_paint_flags_ && !need_resize_ack_for_auto_resize_)
Fady Samuel319e429c2017-10-02 18:31:552612 return;
2613
Fady Samuelcc3e3b4a2017-10-03 02:09:212614 ViewHostMsg_ResizeOrRepaint_ACK_Params params;
Fady Samuel319e429c2017-10-02 18:31:552615 params.view_size = size_;
2616 params.flags = next_paint_flags_;
Fady Samuelda839bb2018-03-26 17:34:482617 params.sequence_number = auto_resize_sequence_number_;
Chris Blume760b9462018-04-12 21:45:332618 if (child_local_surface_id_allocator_.GetCurrentLocalSurfaceId().is_valid()) {
2619 params.child_allocated_local_surface_id =
2620 child_local_surface_id_allocator_.GetCurrentLocalSurfaceId();
2621 DCHECK(params.child_allocated_local_surface_id.value().is_valid());
2622 }
Fady Samuel319e429c2017-10-02 18:31:552623
Fady Samuelcc3e3b4a2017-10-03 02:09:212624 Send(new ViewHostMsg_ResizeOrRepaint_ACK(routing_id_, params));
Fady Samuel319e429c2017-10-02 18:31:552625 next_paint_flags_ = 0;
Fady Samueld10aadd82017-11-03 18:23:572626 need_resize_ack_for_auto_resize_ = false;
Fady Samuel319e429c2017-10-02 18:31:552627}
2628
Khushal3e96e662017-10-30 23:16:502629void RenderWidget::UpdateURLForCompositorUkm() {
2630 DCHECK(compositor_);
Ehsan Karamad655d7b8a2018-01-12 18:38:382631 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2632 if (!frame_widget)
Khushal3e96e662017-10-30 23:16:502633 return;
2634
Ehsan Karamad655d7b8a2018-01-12 18:38:382635 auto* render_frame = RenderFrameImpl::FromWebFrame(frame_widget->LocalRoot());
Khushal3e96e662017-10-30 23:16:502636 if (!render_frame->IsMainFrame())
2637 return;
2638
2639 compositor_->SetURLForUkm(render_frame->GetWebFrame()->GetDocument().Url());
2640}
2641
EhsanK955ba582017-11-30 21:14:402642blink::WebLocalFrame* RenderWidget::GetFocusedWebLocalFrameInWidget() const {
Ehsan Karamad655d7b8a2018-01-12 18:38:382643 if (auto* frame_widget = GetFrameWidget())
2644 return frame_widget->FocusedWebLocalFrameInWidget();
2645 return nullptr;
EhsanK955ba582017-11-30 21:14:402646}
2647
EhsanK22d482e2017-08-10 17:29:492648#if BUILDFLAG(ENABLE_PLUGINS)
2649PepperPluginInstanceImpl* RenderWidget::GetFocusedPepperPluginInsideWidget() {
Ehsan Karamad655d7b8a2018-01-12 18:38:382650 blink::WebFrameWidget* frame_widget = GetFrameWidget();
2651 if (!frame_widget)
EhsanK22d482e2017-08-10 17:29:492652 return nullptr;
2653
2654 // Focused pepper instance might not always be in the focused frame. For
2655 // instance if a pepper instance and its embedder frame are focused an then
2656 // another frame takes focus using javascript, the embedder frame will no
2657 // longer be focused while the pepper instance is (the embedder frame's
2658 // |focused_pepper_plugin_| is not nullptr). Especially, if the pepper plugin
2659 // is fullscreen, clicking into the pepper will not refocus the embedder
2660 // frame. This is why we have to traverse the whole frame tree to find the
2661 // focused plugin.
Ehsan Karamad655d7b8a2018-01-12 18:38:382662 blink::WebFrame* current_frame = frame_widget->LocalRoot();
EhsanK22d482e2017-08-10 17:29:492663 while (current_frame) {
2664 RenderFrameImpl* render_frame =
2665 current_frame->IsWebLocalFrame()
2666 ? RenderFrameImpl::FromWebFrame(current_frame)
2667 : nullptr;
2668 if (render_frame && render_frame->focused_pepper_plugin())
2669 return render_frame->focused_pepper_plugin();
2670 current_frame = current_frame->TraverseNext();
2671 }
2672 return nullptr;
2673}
2674#endif
2675
Ken Buchananb2c9e262018-03-10 16:53:312676gfx::Rect RenderWidget::ViewportVisibleRect() {
2677 return for_oopif_ ? compositor_visible_rect_
2678 : gfx::Rect(compositor_viewport_pixel_size_);
2679}
2680
Saman Sami50d1e0c2018-03-13 20:03:492681base::WeakPtr<RenderWidget> RenderWidget::AsWeakPtr() {
2682 return weak_ptr_factory_.GetWeakPtr();
2683}
2684
[email protected]e9ff79c2012-10-19 21:31:262685} // namespace content