blob: 6b10975221a3c7884224e00b809b1181c8eaec20 [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"
25#include "base/trace_event/trace_event_synthetic_delay.h"
[email protected]661eb9d2009-02-03 02:11:4826#include "build/build_config.h"
loyso6e6efc42017-01-21 02:23:0327#include "cc/animation/animation_host.h"
danakj1120f4c2016-09-15 02:05:3228#include "cc/output/compositor_frame_sink.h"
jbroman6ccbc7d472016-07-27 04:45:4129#include "cc/output/copy_output_request.h"
fsamuel78f86e42016-01-20 04:10:2330#include "cc/scheduler/begin_frame_source.h"
loyso6e6efc42017-01-21 02:23:0331#include "cc/trees/layer_tree_host.h"
oshima750cb4342015-10-31 00:59:0132#include "content/common/content_switches_internal.h"
paulmeyer6ef5a792016-11-08 20:33:5833#include "content/common/drag_event_source_info.h"
34#include "content/common/drag_messages.h"
[email protected]9017d7852013-11-21 17:47:3535#include "content/common/input/synthetic_gesture_packet.h"
[email protected]c084330e02013-04-27 01:08:1536#include "content/common/input_messages.h"
jcivelliae1560a2016-11-01 22:40:2337#include "content/common/render_message_filter.mojom.h"
[email protected]992db4c2011-05-12 15:37:1538#include "content/common/swapped_out_messages.h"
ekaramad9053e57b2016-04-26 20:00:3839#include "content/common/text_input_state.h"
[email protected]778574e2011-03-21 22:03:5040#include "content/common/view_messages.h"
mlamouriafca06dd2017-01-27 23:35:1841#include "content/public/common/content_client.h"
changwan7ded3752016-03-09 23:25:1242#include "content/public/common/content_features.h"
[email protected]c08950d22011-10-13 22:20:2943#include "content/public/common/content_switches.h"
[email protected]a09d53ce2014-01-31 00:46:4244#include "content/public/common/context_menu_params.h"
paulmeyer90f6c31d2016-11-12 00:17:5945#include "content/public/common/drop_data.h"
mlamouriafca06dd2017-01-27 23:35:1846#include "content/public/renderer/content_renderer_client.h"
[email protected]953bd0062013-08-01 00:58:4047#include "content/renderer/cursor_utils.h"
mfomitchev2600fd7c2016-02-17 20:53:3948#include "content/renderer/devtools/render_widget_screen_metrics_emulator.h"
paulmeyer6ef5a792016-11-08 20:33:5849#include "content/renderer/drop_data_builder.h"
[email protected]b2e4c70132013-10-03 02:07:5150#include "content/renderer/external_popup_menu.h"
[email protected]586871b2014-07-22 17:05:1151#include "content/renderer/gpu/frame_swap_message_queue.h"
[email protected]586871b2014-07-22 17:05:1152#include "content/renderer/gpu/queue_message_swap_promise.h"
[email protected]ba91a792013-02-06 09:48:2853#include "content/renderer/gpu/render_widget_compositor.h"
[email protected]66fca5bc2013-05-23 06:58:2954#include "content/renderer/ime_event_guard.h"
[email protected]7a72d452013-12-13 10:01:1355#include "content/renderer/input/input_handler_manager.h"
[email protected]adab2332013-07-25 18:04:3256#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
[email protected]bffc8302014-01-23 20:52:1657#include "content/renderer/render_frame_impl.h"
[email protected]e3244ed2014-06-20 20:04:2758#include "content/renderer/render_frame_proxy.h"
[email protected]8704f89b2011-04-15 00:30:0559#include "content/renderer/render_process.h"
[email protected]f1a29a02011-10-06 23:08:4460#include "content/renderer/render_thread_impl.h"
dcheng3ce04b62015-10-26 23:30:5561#include "content/renderer/render_view_impl.h"
avi40b5be7a2016-03-03 21:13:4462#include "content/renderer/render_widget_owner_delegate.h"
tfarina556a7232014-10-05 01:02:0963#include "content/renderer/renderer_blink_platform_impl.h"
[email protected]5b45ad42013-10-25 00:42:0464#include "content/renderer/resizing_mode_selector.h"
ekaramad330ba4232016-09-23 17:57:4765#include "ipc/ipc_message_start.h"
[email protected]484955942010-08-19 16:13:1866#include "ipc/ipc_sync_message.h"
brettw4b461082016-11-19 18:55:1667#include "ppapi/features/features.h"
[email protected]661eb9d2009-02-03 02:11:4868#include "skia/ext/platform_canvas.h"
kinukoa4293022017-01-27 06:43:2569#include "third_party/WebKit/public/platform/FilePathConversion.h"
[email protected]ec173b522013-11-14 11:01:1870#include "third_party/WebKit/public/platform/WebCursorInfo.h"
paulmeyer90f6c31d2016-11-12 00:17:5971#include "third_party/WebKit/public/platform/WebDragData.h"
72#include "third_party/WebKit/public/platform/WebDragOperation.h"
dtapuskaa794bd0812017-01-06 15:22:5573#include "third_party/WebKit/public/platform/WebMouseEvent.h"
donnda070f3c2015-01-16 19:54:1174#include "third_party/WebKit/public/platform/WebPoint.h"
[email protected]aaf68892013-07-18 00:11:3075#include "third_party/WebKit/public/platform/WebRect.h"
76#include "third_party/WebKit/public/platform/WebSize.h"
77#include "third_party/WebKit/public/platform/WebString.h"
skyostil529caa292016-08-10 17:44:5178#include "third_party/WebKit/public/platform/scheduler/renderer/render_widget_scheduling_state.h"
79#include "third_party/WebKit/public/platform/scheduler/renderer/renderer_scheduler.h"
[email protected]19193682014-04-03 15:01:4380#include "third_party/WebKit/public/web/WebDeviceEmulationParams.h"
kenrba7199832015-01-22 23:44:5981#include "third_party/WebKit/public/web/WebFrameWidget.h"
ekaramad2daaf672016-11-10 20:29:0182#include "third_party/WebKit/public/web/WebInputMethodController.h"
kenrba7199832015-01-22 23:44:5983#include "third_party/WebKit/public/web/WebLocalFrame.h"
donnda070f3c2015-01-16 19:54:1184#include "third_party/WebKit/public/web/WebNode.h"
[email protected]2255a9332013-06-17 05:12:3185#include "third_party/WebKit/public/web/WebPagePopup.h"
[email protected]2255a9332013-06-17 05:12:3186#include "third_party/WebKit/public/web/WebPopupMenuInfo.h"
87#include "third_party/WebKit/public/web/WebRange.h"
jddukeacf809e2014-09-23 20:38:3888#include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
kenrba7199832015-01-22 23:44:5989#include "third_party/WebKit/public/web/WebView.h"
lfge0c2792ec2016-05-11 18:52:0890#include "third_party/WebKit/public/web/WebWidget.h"
[email protected]d353541f2012-05-03 22:45:4191#include "third_party/skia/include/core/SkShader.h"
paulmeyer90f6c31d2016-11-12 00:17:5992#include "ui/base/clipboard/clipboard.h"
[email protected]faec7b12012-06-19 14:42:1393#include "ui/base/ui_base_switches.h"
dtapuska97286c882017-02-24 23:14:4394#include "ui/events/base_event_utils.h"
tfarina655f81d2014-12-23 02:38:5095#include "ui/gfx/geometry/point_conversions.h"
tfarina3b0452d2014-12-31 15:20:0996#include "ui/gfx/geometry/rect_conversions.h"
tfarinaebe974f02015-01-03 04:25:3297#include "ui/gfx/geometry/size_conversions.h"
[email protected]1835b9e2012-02-28 13:12:4898#include "ui/gfx/skia_util.h"
[email protected]c9e2cbbb2012-05-12 21:17:2799#include "ui/gl/gl_switches.h"
[email protected]d353541f2012-05-03 22:45:41100#include "ui/surface/transport_dib.h"
[email protected]661eb9d2009-02-03 02:11:48101
[email protected]eeb93112013-05-01 19:41:10102#if defined(OS_ANDROID)
[email protected]cefe9b152014-03-27 18:16:15103#include <android/keycodes.h>
wjmaclean1d970622017-01-21 22:28:24104#include "base/time/time.h"
[email protected]eeb93112013-05-01 19:41:10105#endif
106
[email protected]661eb9d2009-02-03 02:11:48107#if defined(OS_POSIX)
[email protected]d5282e72009-05-13 13:16:52108#include "third_party/skia/include/core/SkMallocPixelRef.h"
[email protected]d353541f2012-05-03 22:45:41109#include "third_party/skia/include/core/SkPixelRef.h"
[email protected]661eb9d2009-02-03 02:11:48110#endif // defined(OS_POSIX)
[email protected]8085dbc82008-09-26 22:53:44111
sadrul943e3b32016-08-04 18:22:59112#if defined(USE_AURA)
sadrul602ce1362017-01-26 06:41:10113#include "content/renderer/mus/renderer_window_tree_client.h"
penghuang28a5fa22015-12-02 17:58:19114#endif
115
ekaramad330ba4232016-09-23 17:57:47116#if defined(OS_MACOSX)
117#include "content/renderer/text_input_client_observer.h"
118#endif
119
[email protected]180ef242013-11-07 06:50:46120using blink::WebCompositionUnderline;
121using blink::WebCursorInfo;
[email protected]19193682014-04-03 15:01:43122using blink::WebDeviceEmulationParams;
paulmeyer90f6c31d2016-11-12 00:17:59123using blink::WebDragOperation;
paulmeyer6ef5a792016-11-08 20:33:58124using blink::WebDragOperationsMask;
125using blink::WebDragData;
paulmeyer90f6c31d2016-11-12 00:17:59126using blink::WebFrameWidget;
[email protected]180ef242013-11-07 06:50:46127using blink::WebGestureEvent;
paulmeyer6ef5a792016-11-08 20:33:58128using blink::WebImage;
[email protected]180ef242013-11-07 06:50:46129using blink::WebInputEvent;
dtapuska5d2e9c32015-12-03 16:39:49130using blink::WebInputEventResult;
ekaramad2daaf672016-11-10 20:29:01131using blink::WebInputMethodController;
paulmeyer6ef5a792016-11-08 20:33:58132using blink::WebLocalFrame;
[email protected]180ef242013-11-07 06:50:46133using blink::WebMouseEvent;
134using blink::WebMouseWheelEvent;
135using blink::WebNavigationPolicy;
donnda070f3c2015-01-16 19:54:11136using blink::WebNode;
[email protected]180ef242013-11-07 06:50:46137using blink::WebPagePopup;
donnda070f3c2015-01-16 19:54:11138using blink::WebPoint;
[email protected]180ef242013-11-07 06:50:46139using blink::WebPopupType;
dglazkove353a372016-09-01 01:33:48140using blink::WebRange;
[email protected]180ef242013-11-07 06:50:46141using blink::WebRect;
[email protected]180ef242013-11-07 06:50:46142using blink::WebSize;
paulmeyer90f6c31d2016-11-12 00:17:59143using blink::WebString;
[email protected]180ef242013-11-07 06:50:46144using blink::WebTextDirection;
145using blink::WebTouchEvent;
[email protected]f8ed4722013-12-03 03:27:25146using blink::WebTouchPoint;
[email protected]180ef242013-11-07 06:50:46147using blink::WebVector;
148using blink::WebWidget;
[email protected]e9ff79c2012-10-19 21:31:26149
paulmeyer90f6c31d2016-11-12 00:17:59150namespace content {
151
[email protected]6a4d7f62013-01-07 21:32:13152namespace {
[email protected]b256eca2013-07-11 10:57:40153
154typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
155
lfgbee1e0a2016-06-08 21:24:21156class WebWidgetLockTarget : public content::MouseLockDispatcher::LockTarget {
157 public:
158 explicit WebWidgetLockTarget(blink::WebWidget* webwidget)
159 : webwidget_(webwidget) {}
160
161 void OnLockMouseACK(bool succeeded) override {
162 if (succeeded)
163 webwidget_->didAcquirePointerLock();
164 else
165 webwidget_->didNotAcquirePointerLock();
166 }
167
168 void OnMouseLockLost() override { webwidget_->didLosePointerLock(); }
169
170 bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event) override {
171 // The WebWidget handles mouse lock in Blink's handleInputEvent().
172 return false;
173 }
174
175 private:
176 blink::WebWidget* webwidget_;
177};
178
dglazkov97b6c2b2016-10-25 17:35:55179bool IsDateTimeInput(ui::TextInputType type) {
180 return type == ui::TEXT_INPUT_TYPE_DATE ||
181 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
182 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
183 type == ui::TEXT_INPUT_TYPE_MONTH ||
184 type == ui::TEXT_INPUT_TYPE_TIME || type == ui::TEXT_INPUT_TYPE_WEEK;
185}
186
paulmeyer90f6c31d2016-11-12 00:17:59187WebDragData DropMetaDataToWebDragData(
188 const std::vector<DropData::Metadata>& drop_meta_data) {
189 std::vector<WebDragData::Item> item_list;
190 for (const auto& meta_data_item : drop_meta_data) {
191 if (meta_data_item.kind == DropData::Kind::STRING) {
192 WebDragData::Item item;
193 item.storageType = WebDragData::Item::StorageTypeString;
kinukoa4293022017-01-27 06:43:25194 item.stringType = WebString::fromUTF16(meta_data_item.mime_type);
paulmeyer90f6c31d2016-11-12 00:17:59195 // Have to pass a dummy URL here instead of an empty URL because the
196 // DropData received by browser_plugins goes through a round trip:
197 // DropData::MetaData --> WebDragData-->DropData. In the end, DropData
198 // will contain an empty URL (which means no URL is dragged) if the URL in
199 // WebDragData is empty.
200 if (base::EqualsASCII(meta_data_item.mime_type,
201 ui::Clipboard::kMimeTypeURIList)) {
202 item.stringData = WebString::fromUTF8("about:dragdrop-placeholder");
203 }
204 item_list.push_back(item);
205 continue;
206 }
207
208 // TODO(hush): crbug.com/584789. Blink needs to support creating a file with
209 // just the mimetype. This is needed to drag files to WebView on Android
210 // platform.
211 if ((meta_data_item.kind == DropData::Kind::FILENAME) &&
212 !meta_data_item.filename.empty()) {
213 WebDragData::Item item;
214 item.storageType = WebDragData::Item::StorageTypeFilename;
kinukoa4293022017-01-27 06:43:25215 item.filenameData = blink::FilePathToWebString(meta_data_item.filename);
paulmeyer90f6c31d2016-11-12 00:17:59216 item_list.push_back(item);
217 continue;
218 }
219
220 if (meta_data_item.kind == DropData::Kind::FILESYSTEMFILE) {
221 WebDragData::Item item;
222 item.storageType = WebDragData::Item::StorageTypeFileSystemFile;
223 item.fileSystemURL = meta_data_item.file_system_url;
224 item_list.push_back(item);
225 continue;
226 }
227 }
228
229 WebDragData result;
230 result.initialize();
231 result.setItems(item_list);
232 return result;
233}
234
235WebDragData DropDataToWebDragData(const DropData& drop_data) {
236 std::vector<WebDragData::Item> item_list;
237
238 // These fields are currently unused when dragging into WebKit.
239 DCHECK(drop_data.download_metadata.empty());
240 DCHECK(drop_data.file_contents.empty());
dcheng3dd85612017-02-08 10:46:23241 DCHECK(drop_data.file_contents_content_disposition.empty());
paulmeyer90f6c31d2016-11-12 00:17:59242
243 if (!drop_data.text.is_null()) {
244 WebDragData::Item item;
245 item.storageType = WebDragData::Item::StorageTypeString;
246 item.stringType = WebString::fromUTF8(ui::Clipboard::kMimeTypeText);
kinukoa4293022017-01-27 06:43:25247 item.stringData = WebString::fromUTF16(drop_data.text.string());
paulmeyer90f6c31d2016-11-12 00:17:59248 item_list.push_back(item);
249 }
250
251 if (!drop_data.url.is_empty()) {
252 WebDragData::Item item;
253 item.storageType = WebDragData::Item::StorageTypeString;
254 item.stringType = WebString::fromUTF8(ui::Clipboard::kMimeTypeURIList);
255 item.stringData = WebString::fromUTF8(drop_data.url.spec());
kinukoa4293022017-01-27 06:43:25256 item.title = WebString::fromUTF16(drop_data.url_title);
paulmeyer90f6c31d2016-11-12 00:17:59257 item_list.push_back(item);
258 }
259
260 if (!drop_data.html.is_null()) {
261 WebDragData::Item item;
262 item.storageType = WebDragData::Item::StorageTypeString;
263 item.stringType = WebString::fromUTF8(ui::Clipboard::kMimeTypeHTML);
kinukoa4293022017-01-27 06:43:25264 item.stringData = WebString::fromUTF16(drop_data.html.string());
paulmeyer90f6c31d2016-11-12 00:17:59265 item.baseURL = drop_data.html_base_url;
266 item_list.push_back(item);
267 }
268
269 for (std::vector<ui::FileInfo>::const_iterator it =
270 drop_data.filenames.begin();
271 it != drop_data.filenames.end();
272 ++it) {
273 WebDragData::Item item;
274 item.storageType = WebDragData::Item::StorageTypeFilename;
kinukoa4293022017-01-27 06:43:25275 item.filenameData = blink::FilePathToWebString(it->path);
276 item.displayNameData =
277 blink::FilePathToWebString(base::FilePath(it->display_name));
paulmeyer90f6c31d2016-11-12 00:17:59278 item_list.push_back(item);
279 }
280
281 for (std::vector<DropData::FileSystemFileInfo>::const_iterator it =
282 drop_data.file_system_files.begin();
283 it != drop_data.file_system_files.end();
284 ++it) {
285 WebDragData::Item item;
286 item.storageType = WebDragData::Item::StorageTypeFileSystemFile;
287 item.fileSystemURL = it->url;
288 item.fileSystemFileSize = it->size;
hironoda08349d2016-12-14 07:36:16289 item.fileSystemId = blink::WebString::fromASCII(it->filesystem_id);
paulmeyer90f6c31d2016-11-12 00:17:59290 item_list.push_back(item);
291 }
292
293 for (std::map<base::string16, base::string16>::const_iterator it =
294 drop_data.custom_data.begin();
295 it != drop_data.custom_data.end();
296 ++it) {
297 WebDragData::Item item;
298 item.storageType = WebDragData::Item::StorageTypeString;
kinukoa4293022017-01-27 06:43:25299 item.stringType = WebString::fromUTF16(it->first);
300 item.stringData = WebString::fromUTF16(it->second);
paulmeyer90f6c31d2016-11-12 00:17:59301 item_list.push_back(item);
302 }
303
304 WebDragData result;
305 result.initialize();
306 result.setItems(item_list);
kinukoa4293022017-01-27 06:43:25307 result.setFilesystemId(WebString::fromUTF16(drop_data.filesystem_id));
paulmeyer90f6c31d2016-11-12 00:17:59308 return result;
309}
310
lfg1568d112016-08-30 16:06:29311content::RenderWidget::CreateRenderWidgetFunction g_create_render_widget =
312 nullptr;
313
314content::RenderWidget::RenderWidgetInitializedCallback
315 g_render_widget_initialized = nullptr;
316
dtapuskac4dd5be2016-10-25 15:11:10317ui::TextInputType ConvertWebTextInputType(blink::WebTextInputType type) {
318 // Check the type is in the range representable by ui::TextInputType.
319 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX))
320 << "blink::WebTextInputType and ui::TextInputType not synchronized";
321 return static_cast<ui::TextInputType>(type);
322}
323
324ui::TextInputMode ConvertWebTextInputMode(blink::WebTextInputMode mode) {
325 // Check the mode is in the range representable by ui::TextInputMode.
326 DCHECK_LE(mode, static_cast<int>(ui::TEXT_INPUT_MODE_MAX))
327 << "blink::WebTextInputMode and ui::TextInputMode not synchronized";
328 return static_cast<ui::TextInputMode>(mode);
329}
330
[email protected]b256eca2013-07-11 10:57:40331} // namespace
332
[email protected]b2e4c70132013-10-03 02:07:51333// RenderWidget ---------------------------------------------------------------
334
nick8331f8ad2016-11-15 20:42:45335RenderWidget::RenderWidget(int32_t widget_routing_id,
336 CompositorDependencies* compositor_deps,
dcheng35d31c112015-07-22 00:17:36337 blink::WebPopupType popup_type,
ccameron2f451532016-09-07 21:49:27338 const ScreenInfo& screen_info,
[email protected]1ac10dca2013-08-20 20:47:04339 bool swapped_out,
[email protected]7912e822014-04-16 02:37:03340 bool hidden,
341 bool never_visible)
nick8331f8ad2016-11-15 20:42:45342 : routing_id_(widget_routing_id),
dcheng35d31c112015-07-22 00:17:36343 compositor_deps_(compositor_deps),
lfg8ff33912016-09-13 20:59:21344 webwidget_internal_(nullptr),
avi40b5be7a2016-03-03 21:13:44345 owner_delegate_(nullptr),
initial.commit09911bf2008-07-26 23:55:29346 next_paint_flags_(0),
[email protected]847a2582013-03-09 02:29:51347 auto_resize_mode_(false),
[email protected]ea3ee0a2012-05-15 03:43:09348 need_update_rect_for_auto_resize_(false),
initial.commit09911bf2008-07-26 23:55:29349 did_show_(false),
[email protected]1ac10dca2013-08-20 20:47:04350 is_hidden_(hidden),
sievers71c62dd52015-10-07 01:44:39351 compositor_never_visible_(never_visible),
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12352 is_fullscreen_granted_(false),
mikhail.pozdnyakovc0e251b2015-04-15 06:51:12353 display_mode_(blink::WebDisplayModeUndefined),
changwanf2a707b2015-10-30 08:22:16354 ime_event_guard_(nullptr),
[email protected]661eb9d2009-02-03 02:11:48355 closing_(false),
[email protected]aeeedad2014-08-22 18:16:22356 host_closing_(false),
[email protected]14392a52012-05-02 20:28:44357 is_swapped_out_(swapped_out),
simonhong628f9812015-04-27 23:13:20358 for_oopif_(false),
dglazkov97b6c2b2016-10-25 17:35:55359 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
[email protected]b256eca2013-07-11 10:57:40360 text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
shuchen82ce8c52014-10-23 01:55:20361 text_input_flags_(0),
[email protected]86ba5fcb2013-09-04 00:36:53362 can_compose_inline_(true),
nonafa291792016-08-10 02:36:18363 composition_range_(gfx::Range::InvalidRange()),
[email protected]3e2b375b2010-04-07 17:03:12364 popup_type_(popup_type),
[email protected]867125a02009-12-10 06:01:48365 pending_window_rect_count_(0),
[email protected]842f10652012-06-06 01:54:04366 screen_info_(screen_info),
ccameron2f451532016-09-07 21:49:27367 device_scale_factor_(screen_info_.device_scale_factor),
nonafa291792016-08-10 02:36:18368 monitor_composition_info_(false),
[email protected]b2e4c70132013-10-03 02:07:51369 popup_origin_scale_for_emulation_(0.f),
[email protected]586871b2014-07-22 17:05:11370 frame_swap_message_queue_(new FrameSwapMessageQueue()),
[email protected]a09d53ce2014-01-31 00:46:42371 resizing_mode_selector_(new ResizingModeSelector()),
lfge0c2792ec2016-05-11 18:52:08372 has_host_context_menu_location_(false),
wjmaclean1d970622017-01-21 22:28:24373 has_added_input_handler_(false),
ekaramad2a46d632016-07-19 13:33:09374 has_focus_(false),
ekaramad330ba4232016-09-23 17:57:47375#if defined(OS_MACOSX)
376 text_input_client_observer_(new TextInputClientObserver(this)),
377#endif
wjmaclean1d970622017-01-21 22:28:24378 focused_pepper_plugin_(nullptr),
tasakb95dbb50c2017-02-08 18:07:50379 time_to_first_active_paint_recorded_(true),
380 was_shown_time_(base::TimeTicks::Now()),
kenrb5d78b842017-03-06 21:06:01381 current_content_source_id_(0),
wjmaclean1d970622017-01-21 22:28:24382 weak_ptr_factory_(this) {
nick8331f8ad2016-11-15 20:42:45383 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
[email protected]8b3f0eb2012-05-03 19:15:05384 if (!swapped_out)
385 RenderProcess::current()->AddRefProcess();
[email protected]380244092011-10-07 17:26:27386 DCHECK(RenderThread::Get());
alexclarke7fa93942015-10-21 15:37:11387
388 // In tests there may not be a RenderThreadImpl.
389 if (RenderThreadImpl::current()) {
390 render_widget_scheduling_state_ = RenderThreadImpl::current()
391 ->GetRendererScheduler()
dcheng07945f632015-12-26 07:59:32392 ->NewRenderWidgetSchedulingState();
alexclarke7fa93942015-10-21 15:37:11393 render_widget_scheduling_state_->SetHidden(is_hidden_);
394 }
sadrul602ce1362017-01-26 06:41:10395#if defined(USE_AURA)
sadrul8185d972017-01-31 18:30:11396 if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
397 switches::kNoUseMusInRenderer)) {
sadrulbe523b7c2017-02-06 19:35:24398 RendererWindowTreeClient::CreateIfNecessary(routing_id_);
sadrul602ce1362017-01-26 06:41:10399 }
400#endif
initial.commit09911bf2008-07-26 23:55:29401}
402
403RenderWidget::~RenderWidget() {
lfg8ff33912016-09-13 20:59:21404 DCHECK(!webwidget_internal_) << "Leaking our WebWidget!";
[email protected]bffc8302014-01-23 20:52:16405
[email protected]992db4c2011-05-12 15:37:15406 // If we are swapped out, we have released already.
[email protected]d2e2f9ee2013-08-21 11:02:02407 if (!is_swapped_out_ && RenderProcess::current())
[email protected]992db4c2011-05-12 15:37:15408 RenderProcess::current()->ReleaseProcess();
sadrul8185d972017-01-31 18:30:11409#if defined(USE_AURA)
410 if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
411 switches::kNoUseMusInRenderer)) {
412 // It is possible for a RenderWidget to be destroyed before it was embedded
413 // in a mus window. The RendererWindowTreeClient will leak in such cases. So
414 // explicitly delete it here.
415 RendererWindowTreeClient::Destroy(routing_id_);
416 }
417#endif
initial.commit09911bf2008-07-26 23:55:29418}
419
[email protected]484955942010-08-19 16:13:18420// static
lfg1568d112016-08-30 16:06:29421void RenderWidget::InstallCreateHook(
422 CreateRenderWidgetFunction create_render_widget,
423 RenderWidgetInitializedCallback render_widget_initialized) {
424 CHECK(!g_create_render_widget && !g_render_widget_initialized);
425 g_create_render_widget = create_render_widget;
426 g_render_widget_initialized = render_widget_initialized;
427}
428
429// static
nickf7b38222016-11-22 21:59:35430RenderWidget* RenderWidget::CreateForPopup(
431 RenderViewImpl* opener,
432 CompositorDependencies* compositor_deps,
433 blink::WebPopupType popup_type,
434 const ScreenInfo& screen_info) {
nick4df698d82016-11-11 20:39:23435 // Do a synchronous IPC to obtain a routing ID.
436 int32_t routing_id = MSG_ROUTING_NONE;
437 if (!RenderThreadImpl::current_render_message_filter()->CreateNewWidget(
nickf7b38222016-11-22 21:59:35438 opener->GetRoutingID(), popup_type, &routing_id)) {
nick4df698d82016-11-11 20:39:23439 return nullptr;
440 }
441
nick8331f8ad2016-11-15 20:42:45442 scoped_refptr<RenderWidget> widget(
443 new RenderWidget(routing_id, compositor_deps, popup_type, screen_info,
444 false, false, false));
nickf7b38222016-11-22 21:59:35445 ShowCallback opener_callback =
wjmaclean1d970622017-01-21 22:28:24446 base::Bind(&RenderViewImpl::ShowCreatedPopupWidget, opener->GetWeakPtr());
nickf7b38222016-11-22 21:59:35447 widget->Init(opener_callback, RenderWidget::CreateWebWidget(widget.get()));
nick4df698d82016-11-11 20:39:23448 DCHECK(!widget->HasOneRef()); // RenderWidget::Init() adds a reference.
449 return widget.get();
initial.commit09911bf2008-07-26 23:55:29450}
451
[email protected]484955942010-08-19 16:13:18452// static
kenrba7199832015-01-22 23:44:59453RenderWidget* RenderWidget::CreateForFrame(
nick4df698d82016-11-11 20:39:23454 int widget_routing_id,
kenrba7199832015-01-22 23:44:59455 bool hidden,
ccameron2f451532016-09-07 21:49:27456 const ScreenInfo& screen_info,
kenrba7199832015-01-22 23:44:59457 CompositorDependencies* compositor_deps,
458 blink::WebLocalFrame* frame) {
nick4df698d82016-11-11 20:39:23459 CHECK_NE(widget_routing_id, MSG_ROUTING_NONE);
dcheng3ce04b62015-10-26 23:30:55460 // TODO(avi): Before RenderViewImpl has-a RenderWidget, the browser passes the
461 // same routing ID for both the view routing ID and the main frame widget
462 // routing ID. https://crbug.com/545684
nick4df698d82016-11-11 20:39:23463 RenderViewImpl* view = RenderViewImpl::FromRoutingID(widget_routing_id);
dcheng3ce04b62015-10-26 23:30:55464 if (view) {
avi8a45c1092016-03-01 16:12:34465 view->AttachWebFrameWidget(
466 RenderWidget::CreateWebFrameWidget(view->GetWidget(), frame));
467 return view->GetWidget();
dcheng3ce04b62015-10-26 23:30:55468 }
dcheng35d31c112015-07-22 00:17:36469 scoped_refptr<RenderWidget> widget(
lfg1568d112016-08-30 16:06:29470 g_create_render_widget
nick8331f8ad2016-11-15 20:42:45471 ? g_create_render_widget(widget_routing_id, compositor_deps,
472 blink::WebPopupTypeNone, screen_info, false,
473 hidden, false)
474 : new RenderWidget(widget_routing_id, compositor_deps,
475 blink::WebPopupTypeNone, screen_info, false,
476 hidden, false));
simonhong628f9812015-04-27 23:13:20477 widget->for_oopif_ = true;
nick4df698d82016-11-11 20:39:23478 // Init increments the reference count on |widget|, keeping it alive after
kenrba7199832015-01-22 23:44:59479 // this function returns.
nickf7b38222016-11-22 21:59:35480 widget->Init(RenderWidget::ShowCallback(),
nick4df698d82016-11-11 20:39:23481 RenderWidget::CreateWebFrameWidget(widget.get(), frame));
482
483 if (g_render_widget_initialized)
484 g_render_widget_initialized(widget.get());
485 return widget.get();
kenrba7199832015-01-22 23:44:59486}
487
488// static
lfgcaab5142016-02-26 19:06:52489blink::WebFrameWidget* RenderWidget::CreateWebFrameWidget(
dchengda9b4bb2015-07-20 20:58:08490 RenderWidget* render_widget,
491 blink::WebLocalFrame* frame) {
dcheng3ce04b62015-10-26 23:30:55492 if (!frame->parent()) {
493 // TODO(dcheng): The main frame widget currently has a special case.
494 // Eliminate this once WebView is no longer a WebWidget.
495 return blink::WebFrameWidget::create(render_widget, frame->view(), frame);
496 }
dchengda9b4bb2015-07-20 20:58:08497 return blink::WebFrameWidget::create(render_widget, frame);
498}
499
500// static
kenrba7199832015-01-22 23:44:59501blink::WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) {
[email protected]484955942010-08-19 16:13:18502 switch (render_widget->popup_type_) {
[email protected]180ef242013-11-07 06:50:46503 case blink::WebPopupTypeNone: // Nothing to create.
[email protected]484955942010-08-19 16:13:18504 break;
[email protected]180ef242013-11-07 06:50:46505 case blink::WebPopupTypePage:
[email protected]a7547fb2012-03-08 04:43:44506 return WebPagePopup::create(render_widget);
[email protected]484955942010-08-19 16:13:18507 default:
508 NOTREACHED();
509 }
510 return NULL;
511}
512
dchengda9b4bb2015-07-20 20:58:08513void RenderWidget::CloseForFrame() {
dchengd96a27a2015-07-24 20:17:32514 OnClose();
kenrba7199832015-01-22 23:44:59515}
516
alexmos78c9c0d2016-10-14 18:57:03517void RenderWidget::SetSwappedOut(bool is_swapped_out) {
518 // We should only toggle between states.
519 DCHECK(is_swapped_out_ != is_swapped_out);
520 is_swapped_out_ = is_swapped_out;
521
522 // If we are swapping out, we will call ReleaseProcess, allowing the process
523 // to exit if all of its RenderViews are swapped out. We wait until the
524 // WasSwappedOut call to do this, to allow the unload handler to finish.
525 // If we are swapping in, we call AddRefProcess to prevent the process from
526 // exiting.
527 if (!is_swapped_out_)
528 RenderProcess::current()->AddRefProcess();
529}
530
nickf7b38222016-11-22 21:59:35531void RenderWidget::Init(const ShowCallback& show_callback,
532 WebWidget* web_widget) {
lfg8ff33912016-09-13 20:59:21533 DCHECK(!webwidget_internal_);
nick4df698d82016-11-11 20:39:23534 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29535
sadrul9fe48922017-01-23 18:59:49536 input_handler_ = base::MakeUnique<RenderWidgetInputHandler>(this, this);
nick8331f8ad2016-11-15 20:42:45537
nickf7b38222016-11-22 21:59:35538 show_callback_ = show_callback;
initial.commit09911bf2008-07-26 23:55:29539
lfg8ff33912016-09-13 20:59:21540 webwidget_internal_ = web_widget;
541 webwidget_mouse_lock_target_.reset(
542 new WebWidgetLockTarget(webwidget_internal_));
lfgbee1e0a2016-06-08 21:24:21543 mouse_lock_dispatcher_.reset(new RenderWidgetMouseLockDispatcher(this));
initial.commit09911bf2008-07-26 23:55:29544
nick4df698d82016-11-11 20:39:23545 RenderThread::Get()->AddRoute(routing_id_, this);
546 // Take a reference on behalf of the RenderThread. This will be balanced
547 // when we receive ViewMsg_Close.
548 AddRef();
549 if (RenderThreadImpl::current()) {
550 RenderThreadImpl::current()->WidgetCreated();
551 if (is_hidden_)
552 RenderThreadImpl::current()->WidgetHidden();
initial.commit09911bf2008-07-26 23:55:29553 }
554}
555
[email protected]949b6592014-08-20 13:17:52556void RenderWidget::WasSwappedOut() {
557 // If we have been swapped out and no one else is using this process,
558 // it's safe to exit now.
559 CHECK(is_swapped_out_);
560 RenderProcess::current()->ReleaseProcess();
561}
562
[email protected]b2e4c70132013-10-03 02:07:51563void RenderWidget::SetPopupOriginAdjustmentsForEmulation(
mfomitchev2600fd7c2016-02-17 20:53:39564 RenderWidgetScreenMetricsEmulator* emulator) {
[email protected]b2e4c70132013-10-03 02:07:51565 popup_origin_scale_for_emulation_ = emulator->scale();
[email protected]19193682014-04-03 15:01:43566 popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
[email protected]9a2d7ee32013-12-05 12:15:49567 popup_screen_origin_for_emulation_ = gfx::Point(
568 emulator->original_screen_rect().origin().x() + emulator->offset().x(),
569 emulator->original_screen_rect().origin().y() + emulator->offset().y());
[email protected]5f75aa42014-04-01 23:00:56570 screen_info_ = emulator->original_screen_info();
ccameron2f451532016-09-07 21:49:27571 device_scale_factor_ = screen_info_.device_scale_factor;
[email protected]b2e4c70132013-10-03 02:07:51572}
573
[email protected]2d6836f42014-07-02 17:25:31574gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) {
575 if (screen_metrics_emulator_)
576 return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor);
577 return anchor;
578}
579
thakis18e426412017-03-15 12:06:37580#if BUILDFLAG(USE_EXTERNAL_POPUP_MENU)
[email protected]b2e4c70132013-10-03 02:07:51581void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
mfomitchev2600fd7c2016-02-17 20:53:39582 ExternalPopupMenu* popup,
583 RenderWidgetScreenMetricsEmulator* emulator) {
[email protected]9a2d7ee32013-12-05 12:15:49584 popup->SetOriginScaleAndOffsetForEmulation(
585 emulator->scale(), emulator->offset());
[email protected]b2e4c70132013-10-03 02:07:51586}
[email protected]53907862014-03-25 15:42:40587#endif
[email protected]b2e4c70132013-10-03 02:07:51588
589void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
590 if (screen_metrics_emulator_)
591 screen_metrics_emulator_->OnShowContextMenu(params);
592}
593
[email protected]a95986a82010-12-24 06:19:28594bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
ekaramad330ba4232016-09-23 17:57:47595#if defined(OS_MACOSX)
596 if (IPC_MESSAGE_CLASS(message) == TextInputClientMsgStart)
597 return text_input_client_observer_->OnMessageReceived(message);
598#endif
lfgbee1e0a2016-06-08 21:24:21599 if (mouse_lock_dispatcher_ &&
600 mouse_lock_dispatcher_->OnMessageReceived(message))
601 return true;
602
[email protected]a95986a82010-12-24 06:19:28603 bool handled = true;
604 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
[email protected]c084330e02013-04-27 01:08:15605 IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
[email protected]34202de2013-05-06 23:36:22606 IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
607 OnCursorVisibilityChange)
[email protected]a2214eb2014-06-23 18:31:22608 IPC_MESSAGE_HANDLER(InputMsg_ImeSetComposition, OnImeSetComposition)
aelias87b8f7c2016-09-14 03:19:29609 IPC_MESSAGE_HANDLER(InputMsg_ImeCommitText, OnImeCommitText)
610 IPC_MESSAGE_HANDLER(InputMsg_ImeFinishComposingText,
611 OnImeFinishComposingText)
[email protected]c084330e02013-04-27 01:08:15612 IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
alexmos56567492016-09-13 00:52:46613 IPC_MESSAGE_HANDLER(InputMsg_SetEditCommandsForNextKeyEvent,
614 OnSetEditCommandsForNextKeyEvent)
[email protected]c084330e02013-04-27 01:08:15615 IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
[email protected]9017d7852013-11-21 17:47:35616 IPC_MESSAGE_HANDLER(InputMsg_SyntheticGestureCompleted,
617 OnSyntheticGestureCompleted)
[email protected]a95986a82010-12-24 06:19:28618 IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
[email protected]a95986a82010-12-24 06:19:28619 IPC_MESSAGE_HANDLER(ViewMsg_Resize, OnResize)
dgozman9260b0a12015-03-16 13:45:20620 IPC_MESSAGE_HANDLER(ViewMsg_EnableDeviceEmulation,
621 OnEnableDeviceEmulation)
622 IPC_MESSAGE_HANDLER(ViewMsg_DisableDeviceEmulation,
623 OnDisableDeviceEmulation)
[email protected]a95986a82010-12-24 06:19:28624 IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
[email protected]9e2e4632012-07-27 16:38:41625 IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
[email protected]3d9ec5052013-01-02 22:05:25626 IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
[email protected]a95986a82010-12-24 06:19:28627 IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
628 IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
[email protected]80ad8622012-11-07 16:33:03629 IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
kenrbea731792017-01-13 15:10:48630 IPC_MESSAGE_HANDLER(ViewMsg_SetViewportIntersection,
631 OnSetViewportIntersection)
lfg43e08e62016-02-03 18:51:37632 IPC_MESSAGE_HANDLER(ViewMsg_WaitForNextFrameForTests,
633 OnWaitNextFrameForTests)
nonafa291792016-08-10 02:36:18634 IPC_MESSAGE_HANDLER(InputMsg_RequestCompositionUpdate,
635 OnRequestCompositionUpdate)
paulmeyer90f6c31d2016-11-12 00:17:59636 IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter)
637 IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver, OnDragTargetDragOver)
638 IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave, OnDragTargetDragLeave)
639 IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop)
paulmeyer8fc8ea92016-11-15 05:12:21640 IPC_MESSAGE_HANDLER(DragMsg_SourceEnded, OnDragSourceEnded)
641 IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded,
642 OnDragSourceSystemDragEnded)
[email protected]105dffb42013-02-20 03:46:21643#if defined(OS_ANDROID)
changwan8c342742016-02-26 00:53:39644 IPC_MESSAGE_HANDLER(InputMsg_RequestTextInputStateUpdate,
645 OnRequestTextInputStateUpdate)
[email protected]105dffb42013-02-20 03:46:21646#endif
[email protected]a95986a82010-12-24 06:19:28647 IPC_MESSAGE_UNHANDLED(handled = false)
648 IPC_END_MESSAGE_MAP()
649 return handled;
650}
initial.commit09911bf2008-07-26 23:55:29651
652bool RenderWidget::Send(IPC::Message* message) {
[email protected]992db4c2011-05-12 15:37:15653 // Don't send any messages after the browser has told us to close, and filter
654 // most outgoing messages while swapped out.
655 if ((is_swapped_out_ &&
[email protected]e9ff79c2012-10-19 21:31:26656 !SwappedOutMessages::CanSendWhileSwappedOut(message)) ||
[email protected]c6c921e92012-05-10 23:31:11657 closing_) {
initial.commit09911bf2008-07-26 23:55:29658 delete message;
659 return false;
660 }
661
662 // If given a messsage without a routing ID, then assign our routing ID.
663 if (message->routing_id() == MSG_ROUTING_NONE)
664 message->set_routing_id(routing_id_);
665
[email protected]380244092011-10-07 17:26:27666 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44667}
668
dtapuska014ed082016-11-11 21:58:48669void RenderWidget::SendOrCrash(IPC::Message* message) {
670 bool result = Send(message);
671 CHECK(closing_ || result) << "Failed to send message";
672}
673
ekaramad5aff1942017-01-06 01:26:35674bool RenderWidget::ShouldHandleImeEvents() const {
ekaramadb6483a052017-02-10 02:23:26675 // TODO(ekaramad): We track page focus in all RenderViews on the page but the
676 // RenderWidgets corresponding to OOPIFs do not get the update. For now, this
677 // method returns true when the RenderWidget is for an OOPIF, i.e., IME events
678 // will be processed regardless of page focus. We should revisit this after
679 // page focus for OOPIFs has been fully resolved (https://crbug.com/689777).
680 return GetWebWidget() && GetWebWidget()->isWebFrameWidget() &&
681 (has_focus_ || for_oopif_);
ekaramad5aff1942017-01-06 01:26:35682}
683
bokanc007c3a2015-02-03 07:15:56684void RenderWidget::SetWindowRectSynchronously(
685 const gfx::Rect& new_window_rect) {
mfomitchev2600fd7c2016-02-17 20:53:39686 ResizeParams params;
687 params.screen_info = screen_info_;
688 params.new_size = new_window_rect.size();
689 params.physical_backing_size =
690 gfx::ScaleToCeiledSize(new_window_rect.size(), device_scale_factor_);
mfomitchev2600fd7c2016-02-17 20:53:39691 params.visible_viewport_size = new_window_rect.size();
mfomitchev2600fd7c2016-02-17 20:53:39692 params.is_fullscreen_granted = is_fullscreen_granted_;
693 params.display_mode = display_mode_;
694 params.needs_resize_ack = false;
695 Resize(params);
696
bokanc007c3a2015-02-03 07:15:56697 view_screen_rect_ = new_window_rect;
698 window_screen_rect_ = new_window_rect;
[email protected]92650162013-10-30 03:31:02699 if (!did_show_)
bokanc007c3a2015-02-03 07:15:56700 initial_rect_ = new_window_rect;
[email protected]92650162013-10-30 03:31:02701}
702
initial.commit09911bf2008-07-26 23:55:29703void RenderWidget::OnClose() {
dchengd96a27a2015-07-24 20:17:32704 DCHECK(content::RenderThread::Get());
705 if (closing_)
706 return;
707 NotifyOnClose();
708 closing_ = true;
709
710 // Browser correspondence is no longer needed at this point.
711 if (routing_id_ != MSG_ROUTING_NONE) {
712 RenderThread::Get()->RemoveRoute(routing_id_);
713 SetHidden(false);
714 if (RenderThreadImpl::current())
715 RenderThreadImpl::current()->WidgetDestroyed();
716 }
717
718 if (for_oopif_) {
719 // Widgets for frames may be created and closed at any time while the frame
720 // is alive. However, the closing process must happen synchronously. Frame
721 // widget and frames hold pointers to each other. If Close() is deferred to
722 // the message loop like in the non-frame widget case, WebWidget::close()
723 // can end up accessing members of an already-deleted frame.
724 Close();
725 } else {
726 // If there is a Send call on the stack, then it could be dangerous to close
727 // now. Post a task that only gets invoked when there are no nested message
728 // loops.
729 base::ThreadTaskRunnerHandle::Get()->PostNonNestableTask(
730 FROM_HERE, base::Bind(&RenderWidget::Close, this));
731 }
732
733 // Balances the AddRef taken when we called AddRoute.
734 Release();
initial.commit09911bf2008-07-26 23:55:29735}
736
fsamuel664e8b62016-01-20 19:54:01737void RenderWidget::OnResize(const ResizeParams& params) {
[email protected]5b45ad42013-10-25 00:42:04738 if (resizing_mode_selector_->ShouldAbortOnResize(this, params))
[email protected]03e88672013-10-22 21:31:32739 return;
740
[email protected]b2e4c70132013-10-03 02:07:51741 if (screen_metrics_emulator_) {
mfomitchev2600fd7c2016-02-17 20:53:39742 screen_metrics_emulator_->OnResize(params);
[email protected]b2e4c70132013-10-03 02:07:51743 return;
744 }
745
mfomitchev2600fd7c2016-02-17 20:53:39746 Resize(params);
initial.commit09911bf2008-07-26 23:55:29747}
748
dgozman9260b0a12015-03-16 13:45:20749void RenderWidget::OnEnableDeviceEmulation(
750 const blink::WebDeviceEmulationParams& params) {
mfomitchev2600fd7c2016-02-17 20:53:39751 if (!screen_metrics_emulator_) {
752 ResizeParams resize_params;
753 resize_params.screen_info = screen_info_;
754 resize_params.new_size = size_;
755 resize_params.physical_backing_size = physical_backing_size_;
756 resize_params.visible_viewport_size = visible_viewport_size_;
mfomitchev2600fd7c2016-02-17 20:53:39757 resize_params.is_fullscreen_granted = is_fullscreen_granted_;
758 resize_params.display_mode = display_mode_;
759 screen_metrics_emulator_.reset(new RenderWidgetScreenMetricsEmulator(
760 this, params, resize_params, view_screen_rect_, window_screen_rect_));
oshima50872a72016-03-04 13:26:18761 screen_metrics_emulator_->Apply();
mfomitchev2600fd7c2016-02-17 20:53:39762 } else {
dgozman9260b0a12015-03-16 13:45:20763 screen_metrics_emulator_->ChangeEmulationParams(params);
mfomitchev2600fd7c2016-02-17 20:53:39764 }
dgozman9260b0a12015-03-16 13:45:20765}
766
767void RenderWidget::OnDisableDeviceEmulation() {
768 screen_metrics_emulator_.reset();
769}
770
initial.commit09911bf2008-07-26 23:55:29771void RenderWidget::OnWasHidden() {
[email protected]9c3085f2011-06-09 02:10:31772 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
initial.commit09911bf2008-07-26 23:55:29773 // Go into a mode where we stop generating paint and scrolling events.
[email protected]bee16aab2009-08-26 15:55:03774 SetHidden(true);
ericwilligers88e69742016-10-17 19:29:55775 for (auto& observer : render_frames_)
776 observer.WasHidden();
initial.commit09911bf2008-07-26 23:55:29777}
778
[email protected]3399dd822014-08-09 11:14:24779void RenderWidget::OnWasShown(bool needs_repainting,
780 const ui::LatencyInfo& latency_info) {
[email protected]9e2e4632012-07-27 16:38:41781 TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
initial.commit09911bf2008-07-26 23:55:29782 // During shutdown we can just ignore this message.
lfg8ff33912016-09-13 20:59:21783 if (!GetWebWidget())
initial.commit09911bf2008-07-26 23:55:29784 return;
785
tasakb95dbb50c2017-02-08 18:07:50786 was_shown_time_ = base::TimeTicks::Now();
initial.commit09911bf2008-07-26 23:55:29787 // See OnWasHidden
[email protected]bee16aab2009-08-26 15:55:03788 SetHidden(false);
ericwilligers88e69742016-10-17 19:29:55789 for (auto& observer : render_frames_)
790 observer.WasShown();
initial.commit09911bf2008-07-26 23:55:29791
[email protected]8a23afb32014-04-30 22:40:23792 if (!needs_repainting)
initial.commit09911bf2008-07-26 23:55:29793 return;
initial.commit09911bf2008-07-26 23:55:29794
795 // Generate a full repaint.
[email protected]3399dd822014-08-09 11:14:24796 if (compositor_) {
797 ui::LatencyInfo swap_latency_info(latency_info);
dchengcedca5612016-04-09 01:40:15798 std::unique_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor(
[email protected]3399dd822014-08-09 11:14:24799 compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info));
[email protected]aca33f4f2014-05-17 17:08:05800 compositor_->SetNeedsForcedRedraw();
[email protected]3399dd822014-08-09 11:14:24801 }
jdduke491a3f0c2015-06-15 23:30:26802 ScheduleComposite();
initial.commit09911bf2008-07-26 23:55:29803}
804
[email protected]53d3f302009-12-21 04:42:05805void RenderWidget::OnRequestMoveAck() {
806 DCHECK(pending_window_rect_count_);
807 pending_window_rect_count_--;
808}
809
[email protected]ed7defa2013-03-12 21:29:59810GURL RenderWidget::GetURLForGraphicsContext3D() {
811 return GURL();
[email protected]65225772011-05-12 21:10:24812}
813
nzolghadr5d8596502017-01-23 22:59:35814void RenderWidget::OnHandleInputEvent(
815 const blink::WebInputEvent* input_event,
816 const std::vector<const blink::WebInputEvent*>& coalesced_events,
817 const ui::LatencyInfo& latency_info,
818 InputEventDispatchType dispatch_type) {
fsamuel78f86e42016-01-20 04:10:23819 if (!input_event)
820 return;
nzolghadr5d8596502017-01-23 22:59:35821
822 input_handler_->HandleInputEvent(
823 blink::WebCoalescedInputEvent(*input_event, coalesced_events),
824 latency_info, dispatch_type);
fsamuel78f86e42016-01-20 04:10:23825}
826
827void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
lfg8ff33912016-09-13 20:59:21828 if (GetWebWidget())
829 GetWebWidget()->setCursorVisibilityState(is_visible);
fsamuel78f86e42016-01-20 04:10:23830}
831
832void RenderWidget::OnMouseCaptureLost() {
lfg8ff33912016-09-13 20:59:21833 if (GetWebWidget())
834 GetWebWidget()->mouseCaptureLost();
fsamuel78f86e42016-01-20 04:10:23835}
836
alexmos56567492016-09-13 00:52:46837void RenderWidget::OnSetEditCommandsForNextKeyEvent(
838 const EditCommands& edit_commands) {
839 edit_commands_ = edit_commands;
840}
841
fsamuel78f86e42016-01-20 04:10:23842void RenderWidget::OnSetFocus(bool enable) {
lfge0c2792ec2016-05-11 18:52:08843 has_focus_ = enable;
844
lfg8ff33912016-09-13 20:59:21845 if (GetWebWidget())
846 GetWebWidget()->setFocus(enable);
lfge0c2792ec2016-05-11 18:52:08847
ericwilligers88e69742016-10-17 19:29:55848 for (auto& observer : render_frames_)
849 observer.RenderWidgetSetFocus(enable);
fsamuel78f86e42016-01-20 04:10:23850}
851
dtapuska3d5624d32016-08-30 04:34:00852void RenderWidget::SetNeedsMainFrame() {
853 RenderWidgetCompositor* rwc = compositor();
854 if (!rwc)
855 return;
856 rwc->setNeedsBeginFrame();
857}
858
fsamuel78f86e42016-01-20 04:10:23859///////////////////////////////////////////////////////////////////////////////
860// RenderWidgetCompositorDelegate
861
862void RenderWidget::ApplyViewportDeltas(
863 const gfx::Vector2dF& inner_delta,
864 const gfx::Vector2dF& outer_delta,
865 const gfx::Vector2dF& elastic_overscroll_delta,
866 float page_scale,
867 float top_controls_delta) {
lfg8ff33912016-09-13 20:59:21868 GetWebWidget()->applyViewportDeltas(inner_delta, outer_delta,
869 elastic_overscroll_delta, page_scale,
870 top_controls_delta);
fsamuel78f86e42016-01-20 04:10:23871}
872
873void RenderWidget::BeginMainFrame(double frame_time_sec) {
dtapuska3d5624d32016-08-30 04:34:00874 RenderThreadImpl* render_thread = RenderThreadImpl::current();
875 // render_thread may be NULL in tests.
876 InputHandlerManager* input_handler_manager =
877 render_thread ? render_thread->input_handler_manager() : NULL;
878 if (input_handler_manager)
dtapuska97286c882017-02-24 23:14:43879 input_handler_manager->ProcessRafAlignedInputOnMainThread(
880 routing_id_, ui::EventTimeStampFromSeconds(frame_time_sec));
dtapuska3d5624d32016-08-30 04:34:00881
lfg8ff33912016-09-13 20:59:21882 GetWebWidget()->beginFrame(frame_time_sec);
fsamuel78f86e42016-01-20 04:10:23883}
884
danakj1120f4c2016-09-15 02:05:32885std::unique_ptr<cc::CompositorFrameSink>
samansd5db2502017-01-13 23:18:27886RenderWidget::CreateCompositorFrameSink(const cc::FrameSinkId& frame_sink_id,
887 bool fallback) {
lfg8ff33912016-09-13 20:59:21888 DCHECK(GetWebWidget());
[email protected]7912e822014-04-16 02:37:03889 // For widgets that are never visible, we don't start the compositor, so we
danakj1120f4c2016-09-15 02:05:32890 // never get a request for a cc::CompositorFrameSink.
sievers71c62dd52015-10-07 01:44:39891 DCHECK(!compositor_never_visible_);
danakj1120f4c2016-09-15 02:05:32892 return RenderThreadImpl::current()->CreateCompositorFrameSink(
samansd5db2502017-01-13 23:18:27893 frame_sink_id, fallback, routing_id_, frame_swap_message_queue_,
danakj83066a32016-06-21 02:34:49894 GetURLForGraphicsContext3D());
[email protected]ba91a792013-02-06 09:48:28895}
896
fsamuel78f86e42016-01-20 04:10:23897void RenderWidget::DidCommitAndDrawCompositorFrame() {
898 // NOTE: Tests may break if this event is renamed or moved. See
899 // tab_capture_performancetest.cc.
900 TRACE_EVENT0("gpu", "RenderWidget::DidCommitAndDrawCompositorFrame");
lfge0c2792ec2016-05-11 18:52:08901
ericwilligers88e69742016-10-17 19:29:55902 for (auto& observer : render_frames_)
903 observer.DidCommitAndDrawCompositorFrame();
lfge0c2792ec2016-05-11 18:52:08904
fsamuel78f86e42016-01-20 04:10:23905 // Notify subclasses that we initiated the paint operation.
906 DidInitiatePaint();
907}
908
909void RenderWidget::DidCommitCompositorFrame() {
ericwilligers88e69742016-10-17 19:29:55910 for (auto& observer : render_frames_)
911 observer.DidCommitCompositorFrame();
912 for (auto& observer : render_frame_proxies_)
913 observer.DidCommitCompositorFrame();
fsamuel78f86e42016-01-20 04:10:23914}
915
916void RenderWidget::DidCompletePageScaleAnimation() {}
917
danakj6c872fc02016-10-22 04:29:49918void RenderWidget::DidReceiveCompositorFrameAck() {
919 TRACE_EVENT0("renderer", "RenderWidget::DidReceiveCompositorFrameAck");
fsamuel78f86e42016-01-20 04:10:23920
pimanbfb2ceb2016-03-18 21:32:58921 if (!next_paint_flags_ && !need_update_rect_for_auto_resize_) {
fsamuel78f86e42016-01-20 04:10:23922 return;
923 }
924
925 ViewHostMsg_UpdateRect_Params params;
926 params.view_size = size_;
fsamuel78f86e42016-01-20 04:10:23927 params.flags = next_paint_flags_;
928
929 Send(new ViewHostMsg_UpdateRect(routing_id_, params));
930 next_paint_flags_ = 0;
931 need_update_rect_for_auto_resize_ = false;
932}
933
fsamuel78f86e42016-01-20 04:10:23934bool RenderWidget::IsClosing() const {
935 return host_closing_;
936}
937
danakj53eccbc2016-03-02 22:51:07938void RenderWidget::RequestScheduleAnimation() {
fsamuel78f86e42016-01-20 04:10:23939 scheduleAnimation();
initial.commit09911bf2008-07-26 23:55:29940}
941
fsamuel78f86e42016-01-20 04:10:23942void RenderWidget::UpdateVisualState() {
lfg8ff33912016-09-13 20:59:21943 GetWebWidget()->updateAllLifecyclePhases();
tasakb95dbb50c2017-02-08 18:07:50944
945 if (time_to_first_active_paint_recorded_)
946 return;
947
948 RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
949 if (!render_thread_impl->NeedsToRecordFirstActivePaint())
950 return;
951
952 time_to_first_active_paint_recorded_ = true;
953 base::TimeDelta sample = base::TimeTicks::Now() - was_shown_time_;
954 UMA_HISTOGRAM_TIMES("PurgeAndSuspend.Experimental.TimeToFirstActivePaint",
955 sample);
fsamuel78f86e42016-01-20 04:10:23956}
957
958void RenderWidget::WillBeginCompositorFrame() {
959 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
960
dglazkov06854c5c2016-08-31 00:19:59961 // The UpdateTextInputState can result in further layout and possibly
962 // enable GPU acceleration so they need to be called before any painting
963 // is done.
changwan75e3b2072017-01-16 02:55:00964 UpdateTextInputState();
dglazkov06854c5c2016-08-31 00:19:59965 UpdateSelectionBounds();
966
ericwilligers88e69742016-10-17 19:29:55967 for (auto& observer : render_frame_proxies_)
968 observer.WillBeginCompositorFrame();
initial.commit09911bf2008-07-26 23:55:29969}
970
jbroman6ccbc7d472016-07-27 04:45:41971std::unique_ptr<cc::SwapPromise> RenderWidget::RequestCopyOfOutputForLayoutTest(
972 std::unique_ptr<cc::CopyOutputRequest> request) {
973 return RenderThreadImpl::current()->RequestCopyOfOutputForLayoutTest(
974 routing_id_, std::move(request));
975}
976
fsamuel72464894f2015-12-15 06:59:31977///////////////////////////////////////////////////////////////////////////////
978// RenderWidgetInputHandlerDelegate
979
avid7d6b2e2016-03-04 19:41:17980void RenderWidget::FocusChangeComplete() {
981 if (owner_delegate_)
982 owner_delegate_->RenderWidgetFocusChangeComplete();
983}
fsamuel72464894f2015-12-15 06:59:31984
985bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
avid7d6b2e2016-03-04 19:41:17986 if (owner_delegate_)
987 return owner_delegate_->DoesRenderWidgetHaveTouchEventHandlersAt(point);
988
fsamuel72464894f2015-12-15 06:59:31989 return true;
990}
991
dtapuska1827dd22016-03-11 15:24:59992void RenderWidget::ObserveGestureEventAndResult(
993 const blink::WebGestureEvent& gesture_event,
994 const gfx::Vector2dF& unused_delta,
995 bool event_processed) {
996 if (!compositor_deps_->IsElasticOverscrollEnabled())
997 return;
998
999 cc::InputHandlerScrollResult scroll_result;
1000 scroll_result.did_scroll = event_processed;
1001 scroll_result.did_overscroll_root = !unused_delta.IsZero();
1002 scroll_result.unused_scroll_delta = unused_delta;
1003
1004 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1005 InputHandlerManager* input_handler_manager =
1006 render_thread ? render_thread->input_handler_manager() : NULL;
1007 if (input_handler_manager) {
1008 input_handler_manager->ObserveGestureEventAndResultOnMainThread(
1009 routing_id_, gesture_event, scroll_result);
1010 }
1011}
1012
avid7d6b2e2016-03-04 19:41:171013void RenderWidget::OnDidHandleKeyEvent() {
alexmos56567492016-09-13 00:52:461014 ClearEditCommands();
1015}
1016
1017void RenderWidget::SetEditCommandForNextKeyEvent(const std::string& name,
1018 const std::string& value) {
1019 ClearEditCommands();
1020 edit_commands_.emplace_back(name, value);
1021}
1022
1023void RenderWidget::ClearEditCommands() {
1024 edit_commands_.clear();
avid7d6b2e2016-03-04 19:41:171025}
fsamuel72464894f2015-12-15 06:59:311026
chongza8ba91fc2016-08-16 21:39:171027void RenderWidget::OnDidOverscroll(const ui::DidOverscrollParams& params) {
fsamuel72464894f2015-12-15 06:59:311028 Send(new InputHostMsg_DidOverscroll(routing_id_, params));
1029}
1030
dchengcedca5612016-04-09 01:40:151031void RenderWidget::OnInputEventAck(
1032 std::unique_ptr<InputEventAck> input_event_ack) {
dtapuska014ed082016-11-11 21:58:481033 SendOrCrash(
1034 new InputHostMsg_HandleInputEvent_ACK(routing_id_, *input_event_ack));
fsamuel72464894f2015-12-15 06:59:311035}
1036
dtapuska46616922016-03-17 22:52:011037void RenderWidget::NotifyInputEventHandled(
dtapuskab08721e62016-06-29 03:35:071038 blink::WebInputEvent::Type handled_type,
skyostilcff62882017-01-28 13:18:041039 blink::WebInputEventResult result,
dtapuskab08721e62016-06-29 03:35:071040 InputEventAckState ack_result) {
dtapuska0bd451a2016-02-18 17:08:101041 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1042 InputHandlerManager* input_handler_manager =
1043 render_thread ? render_thread->input_handler_manager() : NULL;
1044 if (input_handler_manager) {
dtapuskab08721e62016-06-29 03:35:071045 input_handler_manager->NotifyInputEventHandledOnMainThread(
skyostilcff62882017-01-28 13:18:041046 routing_id_, handled_type, result, ack_result);
dtapuska0bd451a2016-02-18 17:08:101047 }
1048}
1049
fsamuele8326c742016-01-12 00:49:391050void RenderWidget::SetInputHandler(RenderWidgetInputHandler* input_handler) {
1051 // Nothing to do here. RenderWidget created the |input_handler| and will take
1052 // ownership of it. We just verify here that we don't already have an input
1053 // handler.
1054 DCHECK(!input_handler_);
1055}
1056
changwan75e3b2072017-01-16 02:55:001057void RenderWidget::ShowVirtualKeyboard() {
1058 UpdateTextInputStateInternal(true, false);
1059}
1060
changwan62f57292017-02-17 08:28:251061void RenderWidget::ClearTextInputState() {
1062 text_input_info_ = blink::WebTextInputInfo();
1063 text_input_type_ = ui::TextInputType::TEXT_INPUT_TYPE_NONE;
1064 text_input_mode_ = ui::TextInputMode::TEXT_INPUT_MODE_DEFAULT;
1065 can_compose_inline_ = false;
1066 text_input_flags_ = 0;
1067}
1068
changwan75e3b2072017-01-16 02:55:001069void RenderWidget::UpdateTextInputState() {
1070 UpdateTextInputStateInternal(false, false);
1071}
1072
1073void RenderWidget::UpdateTextInputStateInternal(bool show_virtual_keyboard,
1074 bool reply_to_request) {
fsamuel72464894f2015-12-15 06:59:311075 TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState");
changwan75e3b2072017-01-16 02:55:001076
fsamuel72464894f2015-12-15 06:59:311077 if (ime_event_guard_) {
changwan75e3b2072017-01-16 02:55:001078 DCHECK(!reply_to_request);
1079 // show_virtual_keyboard should still be effective even if it was set inside
1080 // the IME
fsamuel72464894f2015-12-15 06:59:311081 // event guard.
changwan75e3b2072017-01-16 02:55:001082 if (show_virtual_keyboard)
1083 ime_event_guard_->set_show_virtual_keyboard(true);
fsamuel72464894f2015-12-15 06:59:311084 return;
1085 }
1086
dglazkov97b6c2b2016-10-25 17:35:551087 ui::TextInputType new_type = GetTextInputType();
1088 if (IsDateTimeInput(new_type))
1089 return; // Not considered as a text input field in WebKit/Chromium.
fsamuel72464894f2015-12-15 06:59:311090
dglazkov97b6c2b2016-10-25 17:35:551091 blink::WebTextInputInfo new_info;
ekaramad5aff1942017-01-06 01:26:351092 if (auto* controller = GetInputMethodController())
1093 new_info = controller->textInputInfo();
dtapuskac4dd5be2016-10-25 15:11:101094 const ui::TextInputMode new_mode =
1095 ConvertWebTextInputMode(new_info.inputMode);
fsamuel72464894f2015-12-15 06:59:311096
1097 bool new_can_compose_inline = CanComposeInline();
1098
1099 // Only sends text input params if they are changed or if the ime should be
1100 // shown.
changwan75e3b2072017-01-16 02:55:001101 if (show_virtual_keyboard || reply_to_request ||
changwan38c3eb612016-12-09 01:45:561102 text_input_type_ != new_type || text_input_mode_ != new_mode ||
1103 text_input_info_ != new_info ||
1104 can_compose_inline_ != new_can_compose_inline) {
ekaramad9053e57b2016-04-26 20:00:381105 TextInputState params;
dglazkov97b6c2b2016-10-25 17:35:551106 params.type = new_type;
fsamuel72464894f2015-12-15 06:59:311107 params.mode = new_mode;
1108 params.flags = new_info.flags;
1109 params.value = new_info.value.utf8();
1110 params.selection_start = new_info.selectionStart;
1111 params.selection_end = new_info.selectionEnd;
1112 params.composition_start = new_info.compositionStart;
1113 params.composition_end = new_info.compositionEnd;
1114 params.can_compose_inline = new_can_compose_inline;
changwan75e3b2072017-01-16 02:55:001115 // TODO(changwan): change instances of show_ime_if_needed to
1116 // show_virtual_keyboard.
1117 params.show_ime_if_needed = show_virtual_keyboard;
1118 params.reply_to_request = reply_to_request;
fsamuel72464894f2015-12-15 06:59:311119 Send(new ViewHostMsg_TextInputStateChanged(routing_id(), params));
1120
1121 text_input_info_ = new_info;
dglazkov97b6c2b2016-10-25 17:35:551122 text_input_type_ = new_type;
fsamuel72464894f2015-12-15 06:59:311123 text_input_mode_ = new_mode;
1124 can_compose_inline_ = new_can_compose_inline;
1125 text_input_flags_ = new_info.flags;
1126 }
1127}
1128
1129bool RenderWidget::WillHandleGestureEvent(const blink::WebGestureEvent& event) {
paulmeyer6ef5a792016-11-08 20:33:581130 possible_drag_event_info_.event_source =
1131 ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH;
1132 possible_drag_event_info_.event_location =
1133 gfx::Point(event.globalX, event.globalY);
avid7d6b2e2016-03-04 19:41:171134
fsamuel72464894f2015-12-15 06:59:311135 return false;
1136}
1137
1138bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
ericwilligers88e69742016-10-17 19:29:551139 for (auto& observer : render_frames_)
1140 observer.RenderWidgetWillHandleMouseEvent();
lfge0c2792ec2016-05-11 18:52:081141
paulmeyer6ef5a792016-11-08 20:33:581142 possible_drag_event_info_.event_source =
1143 ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
1144 possible_drag_event_info_.event_location =
1145 gfx::Point(event.globalX, event.globalY);
1146
avid7d6b2e2016-03-04 19:41:171147 if (owner_delegate_)
1148 return owner_delegate_->RenderWidgetWillHandleMouseEvent(event);
1149
fsamuel72464894f2015-12-15 06:59:311150 return false;
[email protected]fd847792013-10-24 17:12:351151}
1152
initial.commit09911bf2008-07-26 23:55:291153///////////////////////////////////////////////////////////////////////////////
mfomitchev2600fd7c2016-02-17 20:53:391154// RenderWidgetScreenMetricsDelegate
1155
1156void RenderWidget::Redraw() {
1157 set_next_paint_is_resize_ack();
1158 if (compositor_)
1159 compositor_->SetNeedsRedrawRect(gfx::Rect(size_));
1160}
1161
bokanc63441c2016-04-27 15:49:121162void RenderWidget::ResizeWebWidget() {
lfg8ff33912016-09-13 20:59:211163 GetWebWidget()->resize(GetSizeForWebWidget());
bokanc63441c2016-04-27 15:49:121164}
1165
1166gfx::Size RenderWidget::GetSizeForWebWidget() const {
1167 if (IsUseZoomForDSFEnabled())
1168 return gfx::ScaleToCeiledSize(size_, GetOriginalDeviceScaleFactor());
1169
1170 return size_;
1171}
1172
mfomitchev2600fd7c2016-02-17 20:53:391173void RenderWidget::Resize(const ResizeParams& params) {
engedy6cb63c92016-02-23 14:14:581174 bool orientation_changed =
ccameron2f451532016-09-07 21:49:271175 screen_info_.orientation_angle != params.screen_info.orientation_angle ||
1176 screen_info_.orientation_type != params.screen_info.orientation_type;
engedy6cb63c92016-02-23 14:14:581177
mfomitchev2600fd7c2016-02-17 20:53:391178 screen_info_ = params.screen_info;
wjmaclean8a795f32016-08-11 23:49:581179
ccameron2f451532016-09-07 21:49:271180 if (device_scale_factor_ != screen_info_.device_scale_factor) {
1181 device_scale_factor_ = screen_info_.device_scale_factor;
wjmaclean8a795f32016-08-11 23:49:581182 OnDeviceScaleFactorChanged();
1183 ScheduleComposite();
1184 }
mfomitchev2600fd7c2016-02-17 20:53:391185
1186 if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
1187 // A resize ack shouldn't be requested if we have not ACK'd the previous
1188 // one.
1189 DCHECK(!params.needs_resize_ack || !next_paint_is_resize_ack());
1190 }
1191
1192 // Ignore this during shutdown.
lfg8ff33912016-09-13 20:59:211193 if (!GetWebWidget())
mfomitchev2600fd7c2016-02-17 20:53:391194 return;
1195
ianwene5fc5782016-08-18 04:05:151196 if (compositor_) {
mfomitchev2600fd7c2016-02-17 20:53:391197 compositor_->setViewportSize(params.physical_backing_size);
ianwene5fc5782016-08-18 04:05:151198 compositor_->setBottomControlsHeight(params.bottom_controls_height);
ccameron24c87c32017-03-14 21:50:421199 compositor_->SetRasterColorSpace(
1200 screen_info_.icc_profile.GetParametricColorSpace());
ianwene5fc5782016-08-18 04:05:151201 }
mfomitchev2600fd7c2016-02-17 20:53:391202
mfomitchev2600fd7c2016-02-17 20:53:391203 visible_viewport_size_ = params.visible_viewport_size;
mfomitchev2600fd7c2016-02-17 20:53:391204
1205 // NOTE: We may have entered fullscreen mode without changing our size.
1206 bool fullscreen_change =
1207 is_fullscreen_granted_ != params.is_fullscreen_granted;
1208 is_fullscreen_granted_ = params.is_fullscreen_granted;
1209 display_mode_ = params.display_mode;
1210
bokanc63441c2016-04-27 15:49:121211 size_ = params.new_size;
1212 physical_backing_size_ = params.physical_backing_size;
mfomitchev2600fd7c2016-02-17 20:53:391213
bokanc63441c2016-04-27 15:49:121214 ResizeWebWidget();
bokan71cb5b12016-04-27 03:45:221215
mfomitchev2600fd7c2016-02-17 20:53:391216 WebSize visual_viewport_size;
1217
1218 if (IsUseZoomForDSFEnabled()) {
oshima50872a72016-03-04 13:26:181219 visual_viewport_size = gfx::ScaleToCeiledSize(
1220 params.visible_viewport_size,
1221 GetOriginalDeviceScaleFactor());
mfomitchev2600fd7c2016-02-17 20:53:391222 } else {
1223 visual_viewport_size = visible_viewport_size_;
1224 }
1225
lfg8ff33912016-09-13 20:59:211226 GetWebWidget()->resizeVisualViewport(visual_viewport_size);
mfomitchev2600fd7c2016-02-17 20:53:391227
bokanc63441c2016-04-27 15:49:121228 // When resizing, we want to wait to paint before ACK'ing the resize. This
1229 // ensures that we only resize as fast as we can paint. We only need to
1230 // send an ACK if we are resized to a non-empty rect.
mfomitchev2600fd7c2016-02-17 20:53:391231 if (params.new_size.IsEmpty() || params.physical_backing_size.IsEmpty()) {
1232 // In this case there is no paint/composite and therefore no
1233 // ViewHostMsg_UpdateRect to send the resize ack with. We'd need to send the
1234 // ack through a fake ViewHostMsg_UpdateRect or a different message.
1235 DCHECK(!params.needs_resize_ack);
1236 }
1237
1238 // Send the Resize_ACK flag once we paint again if requested.
1239 if (params.needs_resize_ack)
1240 set_next_paint_is_resize_ack();
1241
1242 if (fullscreen_change)
1243 DidToggleFullscreen();
1244
engedy6cb63c92016-02-23 14:14:581245 if (orientation_changed)
1246 OnOrientationChange();
1247
mfomitchev2600fd7c2016-02-17 20:53:391248 // If a resize ack is requested and it isn't set-up, then no more resizes will
1249 // come in and in general things will go wrong.
1250 DCHECK(!params.needs_resize_ack || next_paint_is_resize_ack());
1251}
1252
1253void RenderWidget::SetScreenMetricsEmulationParameters(
1254 bool enabled,
1255 const blink::WebDeviceEmulationParams& params) {
1256 // This is only supported in RenderView.
1257 NOTREACHED();
1258}
1259
1260void RenderWidget::SetScreenRects(const gfx::Rect& view_screen_rect,
1261 const gfx::Rect& window_screen_rect) {
1262 view_screen_rect_ = view_screen_rect;
1263 window_screen_rect_ = window_screen_rect;
1264}
1265
1266///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461267// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291268
[email protected]3a1c8a8032013-03-18 22:35:321269void RenderWidget::AutoResizeCompositor() {
danakjddaec912015-09-25 19:38:401270 physical_backing_size_ = gfx::ScaleToCeiledSize(size_, device_scale_factor_);
[email protected]97e1bf72013-03-06 14:06:051271 if (compositor_)
oshima750cb4342015-10-31 00:59:011272 compositor_->setViewportSize(physical_backing_size_);
[email protected]97e1bf72013-03-06 14:06:051273}
1274
loyso50b51c22017-01-10 07:18:371275blink::WebLayerTreeView* RenderWidget::initializeLayerTreeView() {
[email protected]aeeedad2014-08-22 18:16:221276 DCHECK(!host_closing_);
1277
loyso6e6efc42017-01-21 02:23:031278 compositor_ = RenderWidgetCompositor::Create(this, compositor_deps_);
1279 auto animation_host = cc::AnimationHost::CreateMainInstance();
1280
1281 auto layer_tree_host = RenderWidgetCompositor::CreateLayerTreeHost(
1282 compositor_.get(), compositor_.get(), animation_host.get(),
1283 compositor_deps_, device_scale_factor_, screen_info_);
1284 compositor_->Initialize(std::move(layer_tree_host),
1285 std::move(animation_host));
1286
wjmaclean1d970622017-01-21 22:28:241287 compositor_->SetIsForOopif(for_oopif_);
oshima750cb4342015-10-31 00:59:011288 compositor_->setViewportSize(physical_backing_size_);
oshimad5279032015-12-16 18:22:331289 OnDeviceScaleFactorChanged();
ccameron2c6d2702017-03-08 19:42:421290 compositor_->SetRasterColorSpace(screen_info_.icc_profile.GetColorSpace());
kenrb5d78b842017-03-06 21:06:011291 compositor_->SetContentSourceId(current_content_source_id_);
sievers71c62dd52015-10-07 01:44:391292 // For background pages and certain tests, we don't want to trigger
danakj1120f4c2016-09-15 02:05:321293 // CompositorFrameSink creation.
sievers71c62dd52015-10-07 01:44:391294 if (compositor_never_visible_ || !RenderThreadImpl::current())
1295 compositor_->SetNeverVisible();
1296
pimanc4af3072015-10-02 03:45:591297 StartCompositor();
staraz067f58242016-11-07 21:06:411298 DCHECK_NE(MSG_ROUTING_NONE, routing_id_);
1299 compositor_->SetFrameSinkId(
1300 cc::FrameSinkId(RenderThread::Get()->GetClientId(), routing_id_));
loyso50b51c22017-01-10 07:18:371301
wjmaclean1d970622017-01-21 22:28:241302 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1303 // render_thread may be NULL in tests.
1304 InputHandlerManager* input_handler_manager =
1305 render_thread ? render_thread->input_handler_manager() : NULL;
1306 if (input_handler_manager) {
1307 input_handler_manager->AddInputHandler(
1308 routing_id_, compositor()->GetInputHandler(),
1309 weak_ptr_factory_.GetWeakPtr(),
1310 compositor_deps_->IsScrollAnimatorEnabled());
1311 has_added_input_handler_ = true;
1312 }
1313
loyso50b51c22017-01-10 07:18:371314 return compositor_.get();
[email protected]e195e582013-03-08 01:32:591315}
1316
ennef3c58142014-12-09 21:44:381317void RenderWidget::WillCloseLayerTreeView() {
1318 if (host_closing_)
1319 return;
1320
1321 // Prevent new compositors or output surfaces from being created.
1322 host_closing_ = true;
1323
[email protected]aeeedad2014-08-22 18:16:221324 // Always send this notification to prevent new layer tree views from
1325 // being created, even if one hasn't been created yet.
lfg8ff33912016-09-13 20:59:211326 if (blink::WebWidget* widget = GetWebWidget())
1327 widget->willCloseLayerTreeView();
[email protected]aeeedad2014-08-22 18:16:221328}
1329
dglazkovf0e1d6d2015-10-10 02:13:481330void RenderWidget::didMeaningfulLayout(blink::WebMeaningfulLayout layout_type) {
1331 if (layout_type == blink::WebMeaningfulLayout::VisuallyNonEmpty) {
1332 QueueMessage(new ViewHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_),
1333 MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE);
1334 }
dglazkov79c426102015-08-31 21:22:431335
ericwilligers88e69742016-10-17 19:29:551336 for (auto& observer : render_frames_)
1337 observer.DidMeaningfulLayout(layout_type);
dglazkov79c426102015-08-31 21:22:431338}
1339
jdduke491a3f0c2015-06-15 23:30:261340void RenderWidget::ScheduleComposite() {
1341 if (compositor_ &&
1342 compositor_deps_->GetCompositorImplThreadTaskRunner().get()) {
skyostil32650d22016-09-26 16:58:231343 compositor_->setNeedsCompositorUpdate();
jdduke491a3f0c2015-06-15 23:30:261344 }
1345}
1346
1347void RenderWidget::ScheduleCompositeWithForcedRedraw() {
1348 if (compositor_) {
1349 // Regardless of whether threaded compositing is enabled, always
1350 // use this mechanism to force the compositor to redraw. However,
1351 // the invalidation code path below is still needed for the
1352 // non-threaded case.
1353 compositor_->SetNeedsForcedRedraw();
1354 }
1355 ScheduleComposite();
[email protected]6fceb912013-02-15 06:24:151356}
1357
[email protected]586871b2014-07-22 17:05:111358// static
dchengcedca5612016-04-09 01:40:151359std::unique_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
[email protected]586871b2014-07-22 17:05:111360 IPC::Message* msg,
1361 MessageDeliveryPolicy policy,
1362 FrameSwapMessageQueue* frame_swap_message_queue,
1363 scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
[email protected]586871b2014-07-22 17:05:111364 int source_frame_number) {
[email protected]586871b2014-07-22 17:05:111365 bool first_message_for_frame = false;
dchengcedca5612016-04-09 01:40:151366 frame_swap_message_queue->QueueMessageForFrame(policy, source_frame_number,
1367 base::WrapUnique(msg),
[email protected]586871b2014-07-22 17:05:111368 &first_message_for_frame);
1369 if (first_message_for_frame) {
dchengcedca5612016-04-09 01:40:151370 std::unique_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
[email protected]586871b2014-07-22 17:05:111371 sync_message_filter, frame_swap_message_queue, source_frame_number));
dcheng4b6b5ff2014-10-16 00:42:061372 return promise;
[email protected]586871b2014-07-22 17:05:111373 }
dcheng4b6b5ff2014-10-16 00:42:061374 return nullptr;
[email protected]586871b2014-07-22 17:05:111375}
1376
1377void RenderWidget::QueueMessage(IPC::Message* msg,
1378 MessageDeliveryPolicy policy) {
1379 // RenderThreadImpl::current() is NULL in some tests.
1380 if (!compositor_ || !RenderThreadImpl::current()) {
1381 Send(msg);
1382 return;
1383 }
1384
dchengcedca5612016-04-09 01:40:151385 std::unique_ptr<cc::SwapPromise> swap_promise =
1386 QueueMessageImpl(msg, policy, frame_swap_message_queue_.get(),
[email protected]586871b2014-07-22 17:05:111387 RenderThreadImpl::current()->sync_message_filter(),
[email protected]586871b2014-07-22 17:05:111388 compositor_->GetSourceFrameNumber());
1389
1390 if (swap_promise) {
dcheng07945f632015-12-26 07:59:321391 compositor_->QueueSwapPromise(std::move(swap_promise));
igsollaeab34cc2015-02-20 11:33:351392 // Request a commit. This might either A) request a commit ahead of time
1393 // or B) request a commit which is not needed because there are not
1394 // pending updates. If B) then the commit will be skipped and the swap
1395 // promises will be broken (see EarlyOut_NoUpdates). To achieve that we
1396 // call SetNeedsUpdateLayers instead of SetNeedsCommit so that
1397 // can_cancel_commit is not unset.
1398 compositor_->SetNeedsUpdateLayers();
[email protected]586871b2014-07-22 17:05:111399 }
1400}
1401
[email protected]4873c7d2009-07-16 06:36:281402void RenderWidget::didChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301403 // TODO(darin): Eliminate this temporary.
[email protected]9ec87712013-05-24 23:23:521404 WebCursor cursor;
tfarina75a0abf2015-10-06 15:07:181405 InitializeCursorFromWebCursorInfo(&cursor, cursor_info);
initial.commit09911bf2008-07-26 23:55:291406 // Only send a SetCursor message if we need to make a change.
1407 if (!current_cursor_.IsEqual(cursor)) {
1408 current_cursor_ = cursor;
1409 Send(new ViewHostMsg_SetCursor(routing_id_, cursor));
1410 }
1411}
1412
1413// We are supposed to get a single call to Show for a newly created RenderWidget
1414// that was created via RenderWidget::CreateWebView. So, we wait until this
1415// point to dispatch the ShowWidget message.
1416//
1417// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281418// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291419//
nickf7b38222016-11-22 21:59:351420void RenderWidget::show(WebNavigationPolicy policy) {
initial.commit09911bf2008-07-26 23:55:291421 DCHECK(!did_show_) << "received extraneous Show call";
1422 DCHECK(routing_id_ != MSG_ROUTING_NONE);
nickf7b38222016-11-22 21:59:351423 DCHECK(!show_callback_.is_null());
initial.commit09911bf2008-07-26 23:55:291424
[email protected]8de12d942010-11-17 20:42:441425 if (did_show_)
1426 return;
1427
1428 did_show_ = true;
nickf7b38222016-11-22 21:59:351429
1430 // The opener is responsible for actually showing this widget.
1431 show_callback_.Run(this, policy, initial_rect_);
nick5ae4d2d2017-01-06 01:18:351432 show_callback_.Reset();
nickf7b38222016-11-22 21:59:351433
bokanc007c3a2015-02-03 07:15:561434 // NOTE: initial_rect_ may still have its default values at this point, but
[email protected]8de12d942010-11-17 20:42:441435 // that's okay. It'll be ignored if as_popup is false, or the browser
1436 // process will impose a default position otherwise.
bokanc007c3a2015-02-03 07:15:561437 SetPendingWindowRect(initial_rect_);
initial.commit09911bf2008-07-26 23:55:291438}
1439
[email protected]2533ce12009-05-09 00:02:241440void RenderWidget::DoDeferredClose() {
ennef3c58142014-12-09 21:44:381441 WillCloseLayerTreeView();
[email protected]2533ce12009-05-09 00:02:241442 Send(new ViewHostMsg_Close(routing_id_));
1443}
1444
dgozmancf9039cd2015-04-06 12:01:311445void RenderWidget::NotifyOnClose() {
ericwilligers88e69742016-10-17 19:29:551446 for (auto& observer : render_frames_)
1447 observer.WidgetWillClose();
dgozmancf9039cd2015-04-06 12:01:311448}
1449
[email protected]4873c7d2009-07-16 06:36:281450void RenderWidget::closeWidgetSoon() {
skyostiled8969c2015-07-20 16:57:081451 DCHECK(content::RenderThread::Get());
[email protected]e1c3a552012-05-04 20:51:321452 if (is_swapped_out_) {
1453 // This widget is currently swapped out, and the active widget is in a
1454 // different process. Have the browser route the close request to the
1455 // active widget instead, so that the correct unload handlers are run.
1456 Send(new ViewHostMsg_RouteCloseEvent(routing_id_));
1457 return;
1458 }
1459
initial.commit09911bf2008-07-26 23:55:291460 // If a page calls window.close() twice, we'll end up here twice, but that's
1461 // OK. It is safe to send multiple Close messages.
1462
[email protected]2533ce12009-05-09 00:02:241463 // Ask the RenderWidgetHost to initiate close. We could be called from deep
1464 // in Javascript. If we ask the RendwerWidgetHost to close now, the window
1465 // could be closed before the JS finishes executing. So instead, post a
1466 // message back to the message loop, which won't run until the JS is
1467 // complete, and then the Close message can be sent.
skyostiled8969c2015-07-20 16:57:081468 base::ThreadTaskRunnerHandle::Get()->PostTask(
[email protected]32876ae2011-11-15 22:25:211469 FROM_HERE, base::Bind(&RenderWidget::DoDeferredClose, this));
initial.commit09911bf2008-07-26 23:55:291470}
1471
[email protected]9017d7852013-11-21 17:47:351472void RenderWidget::QueueSyntheticGesture(
dchengcedca5612016-04-09 01:40:151473 std::unique_ptr<SyntheticGestureParams> gesture_params,
[email protected]9017d7852013-11-21 17:47:351474 const SyntheticGestureCompletionCallback& callback) {
1475 DCHECK(!callback.is_null());
1476
1477 pending_synthetic_gesture_callbacks_.push(callback);
1478
1479 SyntheticGesturePacket gesture_packet;
dcheng07945f632015-12-26 07:59:321480 gesture_packet.set_gesture_params(std::move(gesture_params));
[email protected]9017d7852013-11-21 17:47:351481
1482 Send(new InputHostMsg_QueueSyntheticGesture(routing_id_, gesture_packet));
1483}
1484
initial.commit09911bf2008-07-26 23:55:291485void RenderWidget::Close() {
[email protected]404630b2014-07-03 19:33:031486 screen_metrics_emulator_.reset();
ennef3c58142014-12-09 21:44:381487 WillCloseLayerTreeView();
1488 compositor_.reset();
lfg8ff33912016-09-13 20:59:211489 if (webwidget_internal_) {
1490 webwidget_internal_->close();
1491 webwidget_internal_ = nullptr;
initial.commit09911bf2008-07-26 23:55:291492 }
1493}
1494
bokan841fdc72016-10-06 00:16:351495void RenderWidget::ScreenRectToEmulatedIfNeeded(WebRect* window_rect) const {
1496 DCHECK(window_rect);
1497 float scale = popup_origin_scale_for_emulation_;
1498 if (!scale)
1499 return;
1500 window_rect->x =
1501 popup_view_origin_for_emulation_.x() +
1502 (window_rect->x - popup_screen_origin_for_emulation_.x()) / scale;
1503 window_rect->y =
1504 popup_view_origin_for_emulation_.y() +
1505 (window_rect->y - popup_screen_origin_for_emulation_.y()) / scale;
1506}
1507
1508void RenderWidget::EmulatedToScreenRectIfNeeded(WebRect* window_rect) const {
1509 DCHECK(window_rect);
1510 float scale = popup_origin_scale_for_emulation_;
1511 if (!scale)
1512 return;
1513 window_rect->x =
1514 popup_screen_origin_for_emulation_.x() +
1515 (window_rect->x - popup_view_origin_for_emulation_.x()) * scale;
1516 window_rect->y =
1517 popup_screen_origin_for_emulation_.y() +
1518 (window_rect->y - popup_view_origin_for_emulation_.y()) * scale;
1519}
1520
[email protected]4873c7d2009-07-16 06:36:281521WebRect RenderWidget::windowRect() {
bokan841fdc72016-10-06 00:16:351522 WebRect rect;
bokan6b08cd22016-10-05 00:55:211523 if (pending_window_rect_count_) {
1524 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
1525 // the RootWindowRect is probably going to return wrong results since the
1526 // browser may not have processed the Move yet. There isn't really anything
1527 // good to do in this case, and it shouldn't happen - since this size is
1528 // only really needed for windowToScreen, which is only used for Popups.
bokan841fdc72016-10-06 00:16:351529 rect = pending_window_rect_;
1530 } else {
1531 rect = window_screen_rect_;
bokan6b08cd22016-10-05 00:55:211532 }
[email protected]2533ce12009-05-09 00:02:241533
bokan841fdc72016-10-06 00:16:351534 ScreenRectToEmulatedIfNeeded(&rect);
1535 return rect;
bokan6b08cd22016-10-05 00:55:211536}
1537
1538WebRect RenderWidget::viewRect() {
bokan841fdc72016-10-06 00:16:351539 WebRect rect = view_screen_rect_;
1540 ScreenRectToEmulatedIfNeeded(&rect);
1541 return rect;
initial.commit09911bf2008-07-26 23:55:291542}
1543
[email protected]180ef242013-11-07 06:50:461544void RenderWidget::setToolTipText(const blink::WebString& text,
[email protected]8a9d6ca32011-06-06 20:11:301545 WebTextDirection hint) {
kinukoa4293022017-01-27 06:43:251546 Send(new ViewHostMsg_SetTooltipText(routing_id_, text.utf16(), hint));
[email protected]8a9d6ca32011-06-06 20:11:301547}
1548
oshima33ec97cd2015-12-14 19:40:241549void RenderWidget::setWindowRect(const WebRect& rect_in_screen) {
1550 WebRect window_rect = rect_in_screen;
bokan841fdc72016-10-06 00:16:351551 EmulatedToScreenRectIfNeeded(&window_rect);
[email protected]b2e4c70132013-10-03 02:07:511552
[email protected]5b45ad42013-10-25 00:42:041553 if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]ec951b9d2013-10-20 06:21:201554 if (did_show_) {
bokanc007c3a2015-02-03 07:15:561555 Send(new ViewHostMsg_RequestMove(routing_id_, window_rect));
1556 SetPendingWindowRect(window_rect);
[email protected]8be1c582013-03-06 00:55:031557 } else {
bokanc007c3a2015-02-03 07:15:561558 initial_rect_ = window_rect;
[email protected]8be1c582013-03-06 00:55:031559 }
initial.commit09911bf2008-07-26 23:55:291560 } else {
bokanc007c3a2015-02-03 07:15:561561 SetWindowRectSynchronously(window_rect);
initial.commit09911bf2008-07-26 23:55:291562 }
1563}
1564
[email protected]2533ce12009-05-09 00:02:241565void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
1566 pending_window_rect_ = rect;
1567 pending_window_rect_count_++;
[email protected]2533ce12009-05-09 00:02:241568
bokan6b08cd22016-10-05 00:55:211569 // Popups don't get size updates back from the browser so just store the set
1570 // values.
1571 if (popup_type_ != blink::WebPopupTypeNone) {
1572 window_screen_rect_ = rect;
1573 view_screen_rect_ = rect;
[email protected]2533ce12009-05-09 00:02:241574 }
[email protected]d4547452008-08-28 18:36:371575}
1576
[email protected]fa7b1dc2010-06-23 17:53:041577void RenderWidget::OnImeSetComposition(
[email protected]fcf75d42013-12-03 20:11:261578 const base::string16& text,
[email protected]fa7b1dc2010-06-23 17:53:041579 const std::vector<WebCompositionUnderline>& underlines,
chongz7eb752802016-01-27 21:28:071580 const gfx::Range& replacement_range,
[email protected]fa7b1dc2010-06-23 17:53:041581 int selection_start, int selection_end) {
ekaramad5aff1942017-01-06 01:26:351582 if (!ShouldHandleImeEvents())
1583 return;
1584
brettw4b461082016-11-19 18:55:161585#if BUILDFLAG(ENABLE_PLUGINS)
ekaramad2a46d632016-07-19 13:33:091586 if (focused_pepper_plugin_) {
1587 focused_pepper_plugin_->render_frame()->OnImeSetComposition(
1588 text, underlines, selection_start, selection_end);
1589 return;
1590 }
1591#endif
[email protected]66fca5bc2013-05-23 06:58:291592 ImeEventGuard guard(this);
ekaramad2daaf672016-11-10 20:29:011593 blink::WebInputMethodController* controller = GetInputMethodController();
ekaramad2daaf672016-11-10 20:29:011594 if (!controller ||
1595 !controller->setComposition(
kinukoa4293022017-01-27 06:43:251596 WebString::fromUTF16(text),
ekaramadce32ef9f2017-02-09 17:33:561597 WebVector<WebCompositionUnderline>(underlines),
1598 replacement_range.IsValid()
1599 ? WebRange(replacement_range.start(), replacement_range.length())
1600 : WebRange(),
1601 selection_start, selection_end)) {
[email protected]fa7b1dc2010-06-23 17:53:041602 // If we failed to set the composition text, then we need to let the browser
1603 // process to cancel the input method's ongoing composition session, to make
1604 // sure we are in a consistent state.
[email protected]a2214eb2014-06-23 18:31:221605 Send(new InputHostMsg_ImeCancelComposition(routing_id()));
[email protected]7f00efa2010-04-15 05:01:261606 }
nonafa291792016-08-10 02:36:181607 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]fa7b1dc2010-06-23 17:53:041608}
1609
rlanday7efe2302017-01-11 00:14:281610void RenderWidget::OnImeCommitText(
1611 const base::string16& text,
1612 const std::vector<WebCompositionUnderline>& underlines,
1613 const gfx::Range& replacement_range,
1614 int relative_cursor_pos) {
ekaramad5aff1942017-01-06 01:26:351615 if (!ShouldHandleImeEvents())
1616 return;
1617
brettw4b461082016-11-19 18:55:161618#if BUILDFLAG(ENABLE_PLUGINS)
ekaramad2a46d632016-07-19 13:33:091619 if (focused_pepper_plugin_) {
aelias87b8f7c2016-09-14 03:19:291620 focused_pepper_plugin_->render_frame()->OnImeCommitText(
1621 text, replacement_range, relative_cursor_pos);
ekaramad2a46d632016-07-19 13:33:091622 return;
1623 }
1624#endif
[email protected]66fca5bc2013-05-23 06:58:291625 ImeEventGuard guard(this);
fsamuele8326c742016-01-12 00:49:391626 input_handler_->set_handling_input_event(true);
ekaramadb6483a052017-02-10 02:23:261627 if (auto* controller = GetInputMethodController()) {
ekaramadce32ef9f2017-02-09 17:33:561628 controller->commitText(
1629 WebString::fromUTF16(text),
1630 WebVector<WebCompositionUnderline>(underlines),
1631 replacement_range.IsValid()
1632 ? WebRange(replacement_range.start(), replacement_range.length())
1633 : WebRange(),
1634 relative_cursor_pos);
ekaramadb6483a052017-02-10 02:23:261635 }
aelias87b8f7c2016-09-14 03:19:291636 input_handler_->set_handling_input_event(false);
1637 UpdateCompositionInfo(false /* not an immediate request */);
1638}
1639
1640void RenderWidget::OnImeFinishComposingText(bool keep_selection) {
ekaramad5aff1942017-01-06 01:26:351641 if (!ShouldHandleImeEvents())
1642 return;
1643
brettw4b461082016-11-19 18:55:161644#if BUILDFLAG(ENABLE_PLUGINS)
aelias87b8f7c2016-09-14 03:19:291645 if (focused_pepper_plugin_) {
1646 focused_pepper_plugin_->render_frame()->OnImeFinishComposingText(
1647 keep_selection);
1648 return;
1649 }
1650#endif
1651
changwan38c3eb612016-12-09 01:45:561652 if (!GetWebWidget())
aelias87b8f7c2016-09-14 03:19:291653 return;
1654 ImeEventGuard guard(this);
1655 input_handler_->set_handling_input_event(true);
ekaramad2daaf672016-11-10 20:29:011656 if (auto* controller = GetInputMethodController()) {
1657 controller->finishComposingText(
1658 keep_selection ? WebInputMethodController::KeepSelection
1659 : WebInputMethodController::DoNotKeepSelection);
1660 }
fsamuele8326c742016-01-12 00:49:391661 input_handler_->set_handling_input_event(false);
nonafa291792016-08-10 02:36:181662 UpdateCompositionInfo(false /* not an immediate request */);
initial.commit09911bf2008-07-26 23:55:291663}
1664
oshimad5279032015-12-16 18:22:331665void RenderWidget::OnDeviceScaleFactorChanged() {
1666 if (!compositor_)
1667 return;
oshimad5279032015-12-16 18:22:331668 if (IsUseZoomForDSFEnabled())
oshima50872a72016-03-04 13:26:181669 compositor_->SetPaintedDeviceScaleFactor(GetOriginalDeviceScaleFactor());
oshimad5279032015-12-16 18:22:331670 else
1671 compositor_->setDeviceScaleFactor(device_scale_factor_);
1672}
1673
[email protected]0bc1f572013-04-17 01:46:311674void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
[email protected]ec7dc112008-08-06 05:30:121675 // During shutdown we can just ignore this message.
lfg8ff33912016-09-13 20:59:211676 if (!GetWebWidget())
[email protected]ec7dc112008-08-06 05:30:121677 return;
1678
[email protected]0bc1f572013-04-17 01:46:311679 // Even if the browser provides an empty damage rect, it's still expecting to
1680 // receive a repaint ack so just damage the entire widget bounds.
1681 if (size_to_paint.IsEmpty()) {
1682 size_to_paint = size_;
1683 }
1684
[email protected]ec7dc112008-08-06 05:30:121685 set_next_paint_is_repaint_ack();
[email protected]aca33f4f2014-05-17 17:08:051686 if (compositor_)
[email protected]0bc1f572013-04-17 01:46:311687 compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint));
[email protected]ec7dc112008-08-06 05:30:121688}
1689
[email protected]79fa22e2013-08-23 15:18:121690void RenderWidget::OnSyntheticGestureCompleted() {
[email protected]9017d7852013-11-21 17:47:351691 DCHECK(!pending_synthetic_gesture_callbacks_.empty());
1692
1693 pending_synthetic_gesture_callbacks_.front().Run();
1694 pending_synthetic_gesture_callbacks_.pop();
[email protected]0e241b4b2012-08-18 09:06:271695}
1696
[email protected]4873c7d2009-07-16 06:36:281697void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
lfg8ff33912016-09-13 20:59:211698 if (!GetWebWidget())
[email protected]07f953332009-03-25 04:31:111699 return;
lfg8ff33912016-09-13 20:59:211700 GetWebWidget()->setTextDirection(direction);
[email protected]07f953332009-03-25 04:31:111701}
1702
[email protected]80ad8622012-11-07 16:33:031703void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
1704 const gfx::Rect& window_screen_rect) {
[email protected]b2e4c70132013-10-03 02:07:511705 if (screen_metrics_emulator_) {
mfomitchev2600fd7c2016-02-17 20:53:391706 screen_metrics_emulator_->OnUpdateScreenRects(view_screen_rect,
1707 window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:511708 } else {
mfomitchev2600fd7c2016-02-17 20:53:391709 SetScreenRects(view_screen_rect, window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:511710 }
[email protected]80ad8622012-11-07 16:33:031711 Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
1712}
1713
lfgdb5c4ed2016-03-04 23:09:071714void RenderWidget::OnUpdateWindowScreenRect(
1715 const gfx::Rect& window_screen_rect) {
bokan6b08cd22016-10-05 00:55:211716 if (screen_metrics_emulator_)
lfgdb5c4ed2016-03-04 23:09:071717 screen_metrics_emulator_->OnUpdateWindowScreenRect(window_screen_rect);
bokan6b08cd22016-10-05 00:55:211718 else
lfgdb5c4ed2016-03-04 23:09:071719 window_screen_rect_ = window_screen_rect;
lfgdb5c4ed2016-03-04 23:09:071720}
1721
kenrbea731792017-01-13 15:10:481722void RenderWidget::OnSetViewportIntersection(
1723 const gfx::Rect& viewport_intersection) {
1724 if (GetWebWidget() && GetWebWidget()->isWebFrameWidget()) {
1725 DCHECK(popup_type_ == WebPopupType::WebPopupTypeNone);
1726 static_cast<WebFrameWidget*>(GetWebWidget())
1727 ->setRemoteViewportIntersection(viewport_intersection);
1728 }
1729}
1730
paulmeyer90f6c31d2016-11-12 00:17:591731void RenderWidget::OnDragTargetDragEnter(
1732 const std::vector<DropData::Metadata>& drop_meta_data,
1733 const gfx::Point& client_point,
1734 const gfx::Point& screen_point,
1735 WebDragOperationsMask ops,
1736 int key_modifiers) {
1737 if (!GetWebWidget())
1738 return;
1739
1740 DCHECK(GetWebWidget()->isWebFrameWidget());
1741 WebDragOperation operation = static_cast<WebFrameWidget*>(GetWebWidget())->
1742 dragTargetDragEnter(DropMetaDataToWebDragData(drop_meta_data),
1743 client_point, screen_point, ops, key_modifiers);
1744
1745 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
1746}
1747
1748void RenderWidget::OnDragTargetDragOver(const gfx::Point& client_point,
1749 const gfx::Point& screen_point,
1750 WebDragOperationsMask ops,
1751 int key_modifiers) {
1752 if (!GetWebWidget())
1753 return;
1754
1755 DCHECK(GetWebWidget()->isWebFrameWidget());
1756 WebDragOperation operation =
1757 static_cast<WebFrameWidget*>(GetWebWidget())->dragTargetDragOver(
1758 ConvertWindowPointToViewport(client_point),
1759 screen_point, ops, key_modifiers);
1760
1761 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
1762}
1763
kenrb07c272802017-02-07 23:48:171764void RenderWidget::OnDragTargetDragLeave(const gfx::Point& client_point,
1765 const gfx::Point& screen_point) {
paulmeyer90f6c31d2016-11-12 00:17:591766 if (!GetWebWidget())
1767 return;
1768 DCHECK(GetWebWidget()->isWebFrameWidget());
kenrb07c272802017-02-07 23:48:171769 static_cast<WebFrameWidget*>(GetWebWidget())
1770 ->dragTargetDragLeave(ConvertWindowPointToViewport(client_point),
1771 screen_point);
paulmeyer90f6c31d2016-11-12 00:17:591772}
1773
1774void RenderWidget::OnDragTargetDrop(const DropData& drop_data,
1775 const gfx::Point& client_point,
1776 const gfx::Point& screen_point,
1777 int key_modifiers) {
1778 if (!GetWebWidget())
1779 return;
1780
1781 DCHECK(GetWebWidget()->isWebFrameWidget());
1782 static_cast<WebFrameWidget*>(GetWebWidget())->dragTargetDrop(
1783 DropDataToWebDragData(drop_data),
1784 ConvertWindowPointToViewport(client_point),
1785 screen_point, key_modifiers);
1786}
1787
paulmeyer8fc8ea92016-11-15 05:12:211788void RenderWidget::OnDragSourceEnded(const gfx::Point& client_point,
1789 const gfx::Point& screen_point,
1790 WebDragOperation op) {
1791 if (!GetWebWidget())
1792 return;
1793
1794 static_cast<WebFrameWidget*>(GetWebWidget())->dragSourceEndedAt(
1795 ConvertWindowPointToViewport(client_point), screen_point, op);
1796}
1797
1798void RenderWidget::OnDragSourceSystemDragEnded() {
1799 if (!GetWebWidget())
1800 return;
1801
1802 static_cast<WebFrameWidget*>(GetWebWidget())->dragSourceSystemDragEnded();
1803}
1804
lukasza86f05da2017-01-24 21:23:261805void RenderWidget::showVirtualKeyboardOnElementFocus() {
changwan75e3b2072017-01-16 02:55:001806 ShowVirtualKeyboard();
boliu7b2be2f2016-11-04 04:58:311807
1808// TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
1809// virtual keyboard.
1810#if !defined(OS_ANDROID)
1811 FocusChangeComplete();
1812#endif
[email protected]0d1ebed12013-08-05 22:01:131813}
1814
fsamuel72464894f2015-12-15 06:59:311815ui::TextInputType RenderWidget::GetTextInputType() {
brettw4b461082016-11-19 18:55:161816#if BUILDFLAG(ENABLE_PLUGINS)
ekaramad2a46d632016-07-19 13:33:091817 if (focused_pepper_plugin_)
1818 return focused_pepper_plugin_->text_input_type();
1819#endif
ekaramad5aff1942017-01-06 01:26:351820 if (auto* controller = GetInputMethodController())
1821 return ConvertWebTextInputType(controller->textInputType());
fsamuel72464894f2015-12-15 06:59:311822 return ui::TEXT_INPUT_TYPE_NONE;
1823}
1824
nonafa291792016-08-10 02:36:181825void RenderWidget::UpdateCompositionInfo(bool immediate_request) {
1826 if (!monitor_composition_info_ && !immediate_request)
1827 return; // Do not calculate composition info if not requested.
nonadac0c7a2016-08-01 02:30:591828
nonafa291792016-08-10 02:36:181829 TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo");
1830 gfx::Range range;
1831 std::vector<gfx::Rect> character_bounds;
1832
1833 if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE) {
1834 // Composition information is only available on editable node.
1835 range = gfx::Range::InvalidRange();
1836 } else {
1837 GetCompositionRange(&range);
1838 GetCompositionCharacterBounds(&character_bounds);
1839 }
1840
1841 if (!immediate_request &&
1842 !ShouldUpdateCompositionInfo(range, character_bounds)) {
fsamuel72464894f2015-12-15 06:59:311843 return;
nonafa291792016-08-10 02:36:181844 }
fsamuel72464894f2015-12-15 06:59:311845 composition_character_bounds_ = character_bounds;
1846 composition_range_ = range;
1847 Send(new InputHostMsg_ImeCompositionRangeChanged(
1848 routing_id(), composition_range_, composition_character_bounds_));
fsamuel72464894f2015-12-15 06:59:311849}
1850
oshimaf866dab2015-12-05 00:41:541851void RenderWidget::convertViewportToWindow(blink::WebRect* rect) {
1852 if (IsUseZoomForDSFEnabled()) {
lfg15b235a32016-08-25 17:45:461853 float reverse = 1 / GetOriginalDeviceScaleFactor();
oshimad5279032015-12-16 18:22:331854 // TODO(oshima): We may need to allow pixel precision here as the the
oshimaf866dab2015-12-05 00:41:541855 // anchor element can be placed at half pixel.
lfg15b235a32016-08-25 17:45:461856 gfx::Rect window_rect =
1857 gfx::ScaleToEnclosedRect(gfx::Rect(*rect), reverse);
1858 rect->x = window_rect.x();
1859 rect->y = window_rect.y();
1860 rect->width = window_rect.width();
1861 rect->height = window_rect.height();
oshimaf866dab2015-12-05 00:41:541862 }
1863}
1864
oshimaa6985b62016-01-27 08:58:301865void RenderWidget::convertWindowToViewport(blink::WebFloatRect* rect) {
1866 if (IsUseZoomForDSFEnabled()) {
oshima50872a72016-03-04 13:26:181867 rect->x *= GetOriginalDeviceScaleFactor();
1868 rect->y *= GetOriginalDeviceScaleFactor();
1869 rect->width *= GetOriginalDeviceScaleFactor();
1870 rect->height *= GetOriginalDeviceScaleFactor();
oshimaa6985b62016-01-27 08:58:301871 }
1872}
1873
[email protected]adb362312014-06-28 06:04:241874#if defined(OS_ANDROID)
changwan8c342742016-02-26 00:53:391875void RenderWidget::OnRequestTextInputStateUpdate() {
1876 DCHECK(!ime_event_guard_);
1877 UpdateSelectionBounds();
changwan75e3b2072017-01-16 02:55:001878 UpdateTextInputStateInternal(false, true /* reply_to_request */);
changwan8c342742016-02-26 00:53:391879}
[email protected]105dffb42013-02-20 03:46:211880#endif
1881
nonafa291792016-08-10 02:36:181882void RenderWidget::OnRequestCompositionUpdate(bool immediate_request,
1883 bool monitor_request) {
1884 monitor_composition_info_ = monitor_request;
1885 if (!immediate_request)
1886 return;
1887 UpdateCompositionInfo(true /* immediate request */);
1888}
1889
wjmaclean8a795f32016-08-11 23:49:581890void RenderWidget::OnSetDeviceScaleFactor(float device_scale_factor) {
[email protected]468ac582012-11-20 00:53:191891 if (device_scale_factor_ == device_scale_factor)
1892 return;
1893
1894 device_scale_factor_ = device_scale_factor;
oshimad5279032015-12-16 18:22:331895
1896 OnDeviceScaleFactorChanged();
jdduke491a3f0c2015-06-15 23:30:261897 ScheduleComposite();
wjmaclean8a795f32016-08-11 23:49:581898
1899 physical_backing_size_ = gfx::ScaleToCeiledSize(size_, device_scale_factor_);
[email protected]468ac582012-11-20 00:53:191900}
1901
[email protected]fcdc5642014-05-09 14:32:241902void RenderWidget::OnOrientationChange() {
1903}
1904
[email protected]bee16aab2009-08-26 15:55:031905void RenderWidget::SetHidden(bool hidden) {
1906 if (is_hidden_ == hidden)
1907 return;
1908
jdduke8fac9d102014-12-20 02:40:131909 // The status has changed. Tell the RenderThread about it and ensure
1910 // throttled acks are released in case frame production ceases.
[email protected]bee16aab2009-08-26 15:55:031911 is_hidden_ = hidden;
jdduke8fac9d102014-12-20 02:40:131912
tasakb95dbb50c2017-02-08 18:07:501913 if (is_hidden_) {
[email protected]b2db9272014-01-10 17:42:001914 RenderThreadImpl::current()->WidgetHidden();
tasakb95dbb50c2017-02-08 18:07:501915 time_to_first_active_paint_recorded_ = false;
1916 } else
[email protected]b2db9272014-01-10 17:42:001917 RenderThreadImpl::current()->WidgetRestored();
alexclarke7fa93942015-10-21 15:37:111918
1919 if (render_widget_scheduling_state_)
1920 render_widget_scheduling_state_->SetHidden(hidden);
[email protected]bee16aab2009-08-26 15:55:031921}
1922
[email protected]2b624c562011-10-27 22:58:261923void RenderWidget::DidToggleFullscreen() {
lfg8ff33912016-09-13 20:59:211924 if (!GetWebWidget())
[email protected]2b624c562011-10-27 22:58:261925 return;
1926
mikhail.pozdnyakovf2c902a2015-04-14 08:09:121927 if (is_fullscreen_granted_) {
lfg8ff33912016-09-13 20:59:211928 GetWebWidget()->didEnterFullscreen();
[email protected]2b624c562011-10-27 22:58:261929 } else {
lfg8ff33912016-09-13 20:59:211930 GetWebWidget()->didExitFullscreen();
[email protected]2b624c562011-10-27 22:58:261931 }
[email protected]2b624c562011-10-27 22:58:261932}
1933
[email protected]674741932009-02-04 23:44:461934bool RenderWidget::next_paint_is_resize_ack() const {
[email protected]53d3f302009-12-21 04:42:051935 return ViewHostMsg_UpdateRect_Flags::is_resize_ack(next_paint_flags_);
[email protected]674741932009-02-04 23:44:461936}
1937
[email protected]674741932009-02-04 23:44:461938void RenderWidget::set_next_paint_is_resize_ack() {
[email protected]53d3f302009-12-21 04:42:051939 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
[email protected]674741932009-02-04 23:44:461940}
1941
[email protected]674741932009-02-04 23:44:461942void RenderWidget::set_next_paint_is_repaint_ack() {
[email protected]53d3f302009-12-21 04:42:051943 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK;
[email protected]674741932009-02-04 23:44:461944}
1945
changwanf2a707b2015-10-30 08:22:161946void RenderWidget::OnImeEventGuardStart(ImeEventGuard* guard) {
1947 if (!ime_event_guard_)
1948 ime_event_guard_ = guard;
[email protected]66fca5bc2013-05-23 06:58:291949}
1950
changwanf2a707b2015-10-30 08:22:161951void RenderWidget::OnImeEventGuardFinish(ImeEventGuard* guard) {
1952 if (ime_event_guard_ != guard) {
changwan75e3b2072017-01-16 02:55:001953 DCHECK(!ime_event_guard_->reply_to_request());
changwanf2a707b2015-10-30 08:22:161954 return;
1955 }
1956 ime_event_guard_ = nullptr;
1957
[email protected]66fca5bc2013-05-23 06:58:291958 // While handling an ime event, text input state and selection bounds updates
1959 // are ignored. These must explicitly be updated once finished handling the
1960 // ime event.
1961 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:471962#if defined(OS_ANDROID)
changwan75e3b2072017-01-16 02:55:001963 if (guard->show_virtual_keyboard())
1964 ShowVirtualKeyboard();
1965 else
1966 UpdateTextInputState();
[email protected]cb9e2632013-06-18 11:26:471967#endif
[email protected]66fca5bc2013-05-23 06:58:291968}
1969
[email protected]7c8873e2013-02-05 08:03:011970void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
brettw4b461082016-11-19 18:55:161971#if BUILDFLAG(ENABLE_PLUGINS)
ekaramad2a46d632016-07-19 13:33:091972 if (focused_pepper_plugin_) {
1973 // TODO(kinaba) http://crbug.com/101101
1974 // Current Pepper IME API does not handle selection bounds. So we simply
1975 // use the caret position as an empty range for now. It will be updated
1976 // after Pepper API equips features related to surrounding text retrieval.
1977 blink::WebRect caret(focused_pepper_plugin_->GetCaretBounds());
1978 convertViewportToWindow(&caret);
1979 *focus = caret;
1980 *anchor = caret;
1981 return;
1982 }
1983#endif
[email protected]7c8873e2013-02-05 08:03:011984 WebRect focus_webrect;
1985 WebRect anchor_webrect;
lfg8ff33912016-09-13 20:59:211986 GetWebWidget()->selectionBounds(focus_webrect, anchor_webrect);
oshima33ec97cd2015-12-14 19:40:241987 convertViewportToWindow(&focus_webrect);
1988 convertViewportToWindow(&anchor_webrect);
1989 *focus = focus_webrect;
1990 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:321991}
1992
[email protected]e99ef6f2011-10-16 01:13:001993void RenderWidget::UpdateSelectionBounds() {
jdduke1aebad8e2015-07-22 23:25:081994 TRACE_EVENT0("renderer", "RenderWidget::UpdateSelectionBounds");
lfg8ff33912016-09-13 20:59:211995 if (!GetWebWidget())
[email protected]e99ef6f2011-10-16 01:13:001996 return;
changwanf2a707b2015-10-30 08:22:161997 if (ime_event_guard_)
[email protected]66fca5bc2013-05-23 06:58:291998 return;
[email protected]e99ef6f2011-10-16 01:13:001999
mohsenb0eeba72015-08-09 06:20:082000#if defined(USE_AURA)
2001 // TODO(mohsen): For now, always send explicit selection IPC notifications for
2002 // Aura beucause composited selection updates are not working for webview tags
2003 // which regresses IME inside webview. Remove this when composited selection
2004 // updates are fixed for webviews. See, http://crbug.com/510568.
2005 bool send_ipc = true;
2006#else
jddukeacf809e2014-09-23 20:38:382007 // With composited selection updates, the selection bounds will be reported
2008 // directly by the compositor, in which case explicit IPC selection
2009 // notifications should be suppressed.
mohsenb0eeba72015-08-09 06:20:082010 bool send_ipc =
2011 !blink::WebRuntimeFeatures::isCompositedSelectionUpdateEnabled();
2012#endif
2013 if (send_ipc) {
jddukeacf809e2014-09-23 20:38:382014 ViewHostMsg_SelectionBounds_Params params;
2015 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
2016 if (selection_anchor_rect_ != params.anchor_rect ||
2017 selection_focus_rect_ != params.focus_rect) {
2018 selection_anchor_rect_ = params.anchor_rect;
2019 selection_focus_rect_ = params.focus_rect;
lfg8ff33912016-09-13 20:59:212020 GetWebWidget()->selectionTextDirection(params.focus_dir,
2021 params.anchor_dir);
2022 params.is_anchor_first = GetWebWidget()->isSelectionAnchorFirst();
jddukeacf809e2014-09-23 20:38:382023 Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
2024 }
[email protected]58b48a0d2012-06-13 07:01:352025 }
jddukeacf809e2014-09-23 20:38:382026
nonafa291792016-08-10 02:36:182027 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]e99ef6f2011-10-16 01:13:002028}
2029
lfgb00fcad2016-07-14 14:16:332030void RenderWidget::DidAutoResize(const gfx::Size& new_size) {
2031 WebRect new_size_in_window(0, 0, new_size.width(), new_size.height());
2032 convertViewportToWindow(&new_size_in_window);
2033 if (size_.width() != new_size_in_window.width ||
2034 size_.height() != new_size_in_window.height) {
2035 size_ = gfx::Size(new_size_in_window.width, new_size_in_window.height);
2036
2037 if (resizing_mode_selector_->is_synchronous_mode()) {
bokan6b08cd22016-10-05 00:55:212038 gfx::Rect new_pos(windowRect().x, windowRect().y,
lfg0140a452016-07-19 19:15:052039 size_.width(), size_.height());
lfgb00fcad2016-07-14 14:16:332040 view_screen_rect_ = new_pos;
2041 window_screen_rect_ = new_pos;
2042 }
2043
2044 AutoResizeCompositor();
2045
2046 if (!resizing_mode_selector_->is_synchronous_mode())
2047 need_update_rect_for_auto_resize_ = true;
2048 }
2049}
2050
[email protected]58b48a0d2012-06-13 07:01:352051void RenderWidget::GetCompositionCharacterBounds(
2052 std::vector<gfx::Rect>* bounds) {
2053 DCHECK(bounds);
2054 bounds->clear();
ekaramad2a46d632016-07-19 13:33:092055
brettw4b461082016-11-19 18:55:162056#if BUILDFLAG(ENABLE_PLUGINS)
ekaramad2a46d632016-07-19 13:33:092057 if (focused_pepper_plugin_)
2058 return;
2059#endif
2060
lfg8ff33912016-09-13 20:59:212061 if (!GetWebWidget())
ekaramad2a46d632016-07-19 13:33:092062 return;
2063 blink::WebVector<blink::WebRect> bounds_from_blink;
lfg8ff33912016-09-13 20:59:212064 if (!GetWebWidget()->getCompositionCharacterBounds(bounds_from_blink))
ekaramad2a46d632016-07-19 13:33:092065 return;
2066
2067 for (size_t i = 0; i < bounds_from_blink.size(); ++i) {
2068 convertViewportToWindow(&bounds_from_blink[i]);
2069 bounds->push_back(bounds_from_blink[i]);
2070 }
[email protected]58b48a0d2012-06-13 07:01:352071}
2072
[email protected]db4fc1e2013-09-06 20:01:512073void RenderWidget::GetCompositionRange(gfx::Range* range) {
brettw4b461082016-11-19 18:55:162074#if BUILDFLAG(ENABLE_PLUGINS)
ekaramad2a46d632016-07-19 13:33:092075 if (focused_pepper_plugin_)
2076 return;
2077#endif
lfg8ff33912016-09-13 20:59:212078 WebRange web_range = GetWebWidget()->compositionRange();
nona2363a3d2016-11-09 03:26:212079 if (web_range.isNull()) {
2080 *range = gfx::Range::InvalidRange();
2081 return;
[email protected]88dbe32f2013-06-20 23:31:362082 }
nona2363a3d2016-11-09 03:26:212083 range->set_start(web_range.startOffset());
2084 range->set_end(web_range.endOffset());
[email protected]88dbe32f2013-06-20 23:31:362085}
2086
[email protected]501ea13d2013-07-09 17:03:292087bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:512088 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:292089 const std::vector<gfx::Rect>& bounds) {
changwan2418e1b2016-12-12 12:43:082090 if (!range.IsValid())
2091 return false;
[email protected]501ea13d2013-07-09 17:03:292092 if (composition_range_ != range)
2093 return true;
2094 if (bounds.size() != composition_character_bounds_.size())
2095 return true;
2096 for (size_t i = 0; i < bounds.size(); ++i) {
2097 if (bounds[i] != composition_character_bounds_[i])
2098 return true;
2099 }
2100 return false;
2101}
[email protected]501ea13d2013-07-09 17:03:292102
[email protected]ad26ef42011-06-17 07:59:452103bool RenderWidget::CanComposeInline() {
brettw4b461082016-11-19 18:55:162104#if BUILDFLAG(ENABLE_PLUGINS)
ekaramad2a46d632016-07-19 13:33:092105 if (focused_pepper_plugin_)
2106 return focused_pepper_plugin_->IsPluginAcceptingCompositionEvents();
2107#endif
[email protected]ad26ef42011-06-17 07:59:452108 return true;
[email protected]56ea1a62011-05-30 07:05:572109}
2110
ccameron2f451532016-09-07 21:49:272111blink::WebScreenInfo RenderWidget::screenInfo() {
2112 blink::WebScreenInfo web_screen_info;
2113 web_screen_info.deviceScaleFactor = screen_info_.device_scale_factor;
mlamouriafca06dd2017-01-27 23:35:182114 web_screen_info.iccProfile = screen_info_.icc_profile;
ccameron2f451532016-09-07 21:49:272115 web_screen_info.depth = screen_info_.depth;
2116 web_screen_info.depthPerComponent = screen_info_.depth_per_component;
2117 web_screen_info.isMonochrome = screen_info_.is_monochrome;
2118 web_screen_info.rect = blink::WebRect(screen_info_.rect);
2119 web_screen_info.availableRect = blink::WebRect(screen_info_.available_rect);
2120 switch (screen_info_.orientation_type) {
2121 case SCREEN_ORIENTATION_VALUES_PORTRAIT_PRIMARY:
2122 web_screen_info.orientationType =
2123 blink::WebScreenOrientationPortraitPrimary;
2124 break;
2125 case SCREEN_ORIENTATION_VALUES_PORTRAIT_SECONDARY:
2126 web_screen_info.orientationType =
2127 blink::WebScreenOrientationPortraitSecondary;
2128 break;
2129 case SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY:
2130 web_screen_info.orientationType =
2131 blink::WebScreenOrientationLandscapePrimary;
2132 break;
2133 case SCREEN_ORIENTATION_VALUES_LANDSCAPE_SECONDARY:
2134 web_screen_info.orientationType =
2135 blink::WebScreenOrientationLandscapeSecondary;
2136 break;
2137 default:
2138 web_screen_info.orientationType =
2139 blink::WebScreenOrientationUndefined;
2140 break;
2141 }
2142 web_screen_info.orientationAngle = screen_info_.orientation_angle;
2143 return web_screen_info;
[email protected]4873c7d2009-07-16 06:36:282144}
2145
donnda070f3c2015-01-16 19:54:112146#if defined(OS_ANDROID)
2147void RenderWidget::showUnhandledTapUIIfNeeded(
2148 const WebPoint& tapped_position,
2149 const WebNode& tapped_node,
2150 bool page_changed) {
fsamuele8326c742016-01-12 00:49:392151 DCHECK(input_handler_->handling_input_event());
donnda070f3c2015-01-16 19:54:112152 bool should_trigger = !page_changed && tapped_node.isTextNode() &&
donnd57e54f52015-02-26 19:03:372153 !tapped_node.isContentEditable() &&
2154 !tapped_node.isInsideFocusableElementOrARIAWidget();
donnda070f3c2015-01-16 19:54:112155 if (should_trigger) {
2156 Send(new ViewHostMsg_ShowUnhandledTapUIIfNeeded(routing_id_,
2157 tapped_position.x, tapped_position.y));
2158 }
2159}
2160#endif
2161
[email protected]c68c3e4e2013-01-24 00:36:562162void RenderWidget::didHandleGestureEvent(
2163 const WebGestureEvent& event,
2164 bool event_cancelled) {
[email protected]183e28d2014-01-20 18:18:022165#if defined(OS_ANDROID) || defined(USE_AURA)
[email protected]c68c3e4e2013-01-24 00:36:562166 if (event_cancelled)
2167 return;
dtapuska8c4dae12017-01-13 00:23:062168 if (event.type() == WebInputEvent::GestureTap) {
changwan75e3b2072017-01-16 02:55:002169 ShowVirtualKeyboard();
dtapuska8c4dae12017-01-13 00:23:062170 } else if (event.type() == WebInputEvent::GestureLongPress) {
lfg8ff33912016-09-13 20:59:212171 DCHECK(GetWebWidget());
ekaramad5aff1942017-01-06 01:26:352172 blink::WebInputMethodController* controller = GetInputMethodController();
2173 if (!controller || controller->textInputInfo().value.isEmpty())
changwan75e3b2072017-01-16 02:55:002174 UpdateTextInputState();
[email protected]07c70d22014-08-21 08:33:462175 else
changwan75e3b2072017-01-16 02:55:002176 ShowVirtualKeyboard();
[email protected]c68c3e4e2013-01-24 00:36:562177 }
ekaramada110f642016-12-21 19:47:282178// TODO(ananta): Piggyback off existing IPCs to communicate this information,
2179// crbug/420130.
2180#if defined(OS_WIN)
dtapuska8c4dae12017-01-13 00:23:062181 if (event.type() != blink::WebGestureEvent::GestureTap)
ekaramada110f642016-12-21 19:47:282182 return;
2183
2184 // TODO(estade): hit test the event against focused node to make sure
2185 // the tap actually hit the focused node.
ekaramad5aff1942017-01-06 01:26:352186 blink::WebInputMethodController* controller = GetInputMethodController();
2187 blink::WebTextInputType text_input_type =
2188 controller ? controller->textInputType() : blink::WebTextInputTypeNone;
ekaramada110f642016-12-21 19:47:282189
2190 Send(new ViewHostMsg_FocusedNodeTouched(
2191 routing_id_, text_input_type != blink::WebTextInputTypeNone));
2192#endif
[email protected]c68c3e4e2013-01-24 00:36:562193#endif
2194}
2195
sataya.m582c9ce2015-06-09 08:03:422196void RenderWidget::didOverscroll(
bokane53a10f2016-04-13 23:48:312197 const blink::WebFloatSize& overscrollDelta,
2198 const blink::WebFloatSize& accumulatedOverscroll,
sataya.m582c9ce2015-06-09 08:03:422199 const blink::WebFloatPoint& position,
2200 const blink::WebFloatSize& velocity) {
bokan731ec382016-04-07 03:16:482201#if defined(OS_MACOSX)
2202 // On OSX the user can disable the elastic overscroll effect. If that's the
2203 // case, don't forward the overscroll notification.
2204 DCHECK(compositor_deps());
2205 if (!compositor_deps()->IsElasticOverscrollEnabled())
2206 return;
2207#endif
bokane53a10f2016-04-13 23:48:312208 input_handler_->DidOverscrollFromBlink(overscrollDelta, accumulatedOverscroll,
fsamuele8326c742016-01-12 00:49:392209 position, velocity);
sataya.m582c9ce2015-06-09 08:03:422210}
2211
[email protected]7912e822014-04-16 02:37:032212void RenderWidget::StartCompositor() {
sievers71c62dd52015-10-07 01:44:392213 if (!is_hidden())
2214 compositor_->setVisible(true);
[email protected]7912e822014-04-16 02:37:032215}
2216
[email protected]24ed0432013-04-24 07:50:312217RenderWidgetCompositor* RenderWidget::compositor() const {
2218 return compositor_.get();
2219}
2220
fsamuel72464894f2015-12-15 06:59:312221void RenderWidget::SetHandlingInputEventForTesting(bool handling_input_event) {
fsamuele8326c742016-01-12 00:49:392222 input_handler_->set_handling_input_event(handling_input_event);
[email protected]67bfb83f2011-09-22 03:36:372223}
[email protected]c3d45532011-10-07 19:20:402224
[email protected]ce6689f2013-03-29 12:52:552225void RenderWidget::hasTouchEventHandlers(bool has_handlers) {
alexclarke7fa93942015-10-21 15:37:112226 if (render_widget_scheduling_state_)
2227 render_widget_scheduling_state_->SetHasTouchHandler(has_handlers);
[email protected]ce6689f2013-03-29 12:52:552228 Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
2229}
2230
[email protected]5d0bbdfa92013-12-10 00:35:512231void RenderWidget::setTouchAction(
2232 blink::WebTouchAction web_touch_action) {
[email protected]5d0bbdfa92013-12-10 00:35:512233 // Ignore setTouchAction calls that result from synthetic touch events (eg.
2234 // when blink is emulating touch with mouse).
fsamuele8326c742016-01-12 00:49:392235 if (input_handler_->handling_event_type() != WebInputEvent::TouchStart)
[email protected]5d0bbdfa92013-12-10 00:35:512236 return;
2237
[email protected]a18f67a2013-12-20 19:44:362238 content::TouchAction content_touch_action =
2239 static_cast<content::TouchAction>(web_touch_action);
[email protected]5d0bbdfa92013-12-10 00:35:512240 Send(new InputHostMsg_SetTouchAction(routing_id_, content_touch_action));
2241}
2242
[email protected]e3244ed2014-06-20 20:04:272243void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
2244 render_frame_proxies_.AddObserver(proxy);
[email protected]bffc8302014-01-23 20:52:162245}
2246
[email protected]e3244ed2014-06-20 20:04:272247void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
2248 render_frame_proxies_.RemoveObserver(proxy);
[email protected]bffc8302014-01-23 20:52:162249}
2250
[email protected]de3c5d82014-05-28 22:12:592251void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
2252 render_frames_.AddObserver(frame);
2253}
2254
2255void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) {
2256 render_frames_.RemoveObserver(frame);
2257}
2258
lfg43e08e62016-02-03 18:51:372259void RenderWidget::OnWaitNextFrameForTests(int routing_id) {
2260 QueueMessage(new ViewHostMsg_WaitForNextFrameForTests_ACK(routing_id),
2261 MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE);
2262}
2263
oshima50872a72016-03-04 13:26:182264float RenderWidget::GetOriginalDeviceScaleFactor() const {
2265 return
2266 screen_metrics_emulator_ ?
ccameron2f451532016-09-07 21:49:272267 screen_metrics_emulator_->original_screen_info().device_scale_factor :
oshima50872a72016-03-04 13:26:182268 device_scale_factor_;
2269}
2270
paulmeyer90f6c31d2016-11-12 00:17:592271gfx::Point RenderWidget::ConvertWindowPointToViewport(
2272 const gfx::Point& point) {
2273 blink::WebFloatRect point_in_viewport(point.x(), point.y(), 0, 0);
2274 convertWindowToViewport(&point_in_viewport);
2275 return gfx::Point(point_in_viewport.x, point_in_viewport.y);
2276}
2277
lfgbee1e0a2016-06-08 21:24:212278bool RenderWidget::requestPointerLock() {
2279 return mouse_lock_dispatcher_->LockMouse(webwidget_mouse_lock_target_.get());
2280}
2281
2282void RenderWidget::requestPointerUnlock() {
2283 mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
2284}
2285
2286bool RenderWidget::isPointerLocked() {
2287 return mouse_lock_dispatcher_->IsMouseLockedTo(
2288 webwidget_mouse_lock_target_.get());
2289}
2290
paulmeyer6ef5a792016-11-08 20:33:582291void RenderWidget::startDragging(blink::WebReferrerPolicy policy,
2292 const WebDragData& data,
2293 WebDragOperationsMask mask,
2294 const WebImage& image,
2295 const WebPoint& webImageOffset) {
2296 blink::WebRect offset_in_window(webImageOffset.x, webImageOffset.y, 0, 0);
2297 convertViewportToWindow(&offset_in_window);
2298 DropData drop_data(DropDataBuilder::Build(data));
2299 drop_data.referrer_policy = policy;
2300 gfx::Vector2d imageOffset(offset_in_window.x, offset_in_window.y);
paulmeyer90f6c31d2016-11-12 00:17:592301 Send(new DragHostMsg_StartDragging(routing_id(), drop_data, mask,
paulmeyer6ef5a792016-11-08 20:33:582302 image.getSkBitmap(), imageOffset,
2303 possible_drag_event_info_));
2304}
2305
kenrb5d78b842017-03-06 21:06:012306uint32_t RenderWidget::GetContentSourceId() {
2307 return current_content_source_id_;
2308}
2309
2310void RenderWidget::IncrementContentSourceId() {
2311 if (compositor_)
2312 compositor_->SetContentSourceId(++current_content_source_id_);
2313}
2314
lfg8ff33912016-09-13 20:59:212315blink::WebWidget* RenderWidget::GetWebWidget() const {
2316 return webwidget_internal_;
2317}
2318
ekaramad2daaf672016-11-10 20:29:012319blink::WebInputMethodController* RenderWidget::GetInputMethodController()
2320 const {
ekaramad5a9f52a2016-12-07 01:35:182321 if (!GetWebWidget()->isWebFrameWidget()) {
2322 // TODO(ekaramad): We should not get here in response to IME IPC or updates
2323 // when the RenderWidget is swapped out. We should top sending IPCs from the
2324 // browser side (https://crbug.com/669219).
2325 // If there is no WebFrameWidget, then there will be no
2326 // InputMethodControllers for a WebLocalFrame.
2327 return nullptr;
2328 }
ekaramad2daaf672016-11-10 20:29:012329 return static_cast<blink::WebFrameWidget*>(GetWebWidget())
2330 ->getActiveWebInputMethodController();
2331}
2332
[email protected]e9ff79c2012-10-19 21:31:262333} // namespace content