blob: 2ef8c177aa9a01b84dcdcf39471dd8b5b068f49e [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"
tfarina655f81d2014-12-23 02:38:5094#include "ui/gfx/geometry/point_conversions.h"
tfarina3b0452d2014-12-31 15:20:0995#include "ui/gfx/geometry/rect_conversions.h"
tfarinaebe974f02015-01-03 04:25:3296#include "ui/gfx/geometry/size_conversions.h"
[email protected]1835b9e2012-02-28 13:12:4897#include "ui/gfx/skia_util.h"
[email protected]c9e2cbbb2012-05-12 21:17:2798#include "ui/gl/gl_switches.h"
[email protected]d353541f2012-05-03 22:45:4199#include "ui/surface/transport_dib.h"
[email protected]661eb9d2009-02-03 02:11:48100
[email protected]eeb93112013-05-01 19:41:10101#if defined(OS_ANDROID)
[email protected]cefe9b152014-03-27 18:16:15102#include <android/keycodes.h>
wjmaclean1d970622017-01-21 22:28:24103#include "base/time/time.h"
[email protected]eeb93112013-05-01 19:41:10104#endif
105
[email protected]661eb9d2009-02-03 02:11:48106#if defined(OS_POSIX)
[email protected]d5282e72009-05-13 13:16:52107#include "third_party/skia/include/core/SkMallocPixelRef.h"
[email protected]d353541f2012-05-03 22:45:41108#include "third_party/skia/include/core/SkPixelRef.h"
[email protected]661eb9d2009-02-03 02:11:48109#endif // defined(OS_POSIX)
[email protected]8085dbc82008-09-26 22:53:44110
sadrul943e3b32016-08-04 18:22:59111#if defined(USE_AURA)
sadrul602ce1362017-01-26 06:41:10112#include "content/renderer/mus/renderer_window_tree_client.h"
penghuang28a5fa22015-12-02 17:58:19113#endif
114
ekaramad330ba4232016-09-23 17:57:47115#if defined(OS_MACOSX)
116#include "content/renderer/text_input_client_observer.h"
117#endif
118
[email protected]180ef242013-11-07 06:50:46119using blink::WebCompositionUnderline;
120using blink::WebCursorInfo;
[email protected]19193682014-04-03 15:01:43121using blink::WebDeviceEmulationParams;
paulmeyer90f6c31d2016-11-12 00:17:59122using blink::WebDragOperation;
paulmeyer6ef5a792016-11-08 20:33:58123using blink::WebDragOperationsMask;
124using blink::WebDragData;
paulmeyer90f6c31d2016-11-12 00:17:59125using blink::WebFrameWidget;
[email protected]180ef242013-11-07 06:50:46126using blink::WebGestureEvent;
paulmeyer6ef5a792016-11-08 20:33:58127using blink::WebImage;
[email protected]180ef242013-11-07 06:50:46128using blink::WebInputEvent;
dtapuska5d2e9c32015-12-03 16:39:49129using blink::WebInputEventResult;
ekaramad2daaf672016-11-10 20:29:01130using blink::WebInputMethodController;
paulmeyer6ef5a792016-11-08 20:33:58131using blink::WebLocalFrame;
[email protected]180ef242013-11-07 06:50:46132using blink::WebMouseEvent;
133using blink::WebMouseWheelEvent;
134using blink::WebNavigationPolicy;
donnda070f3c2015-01-16 19:54:11135using blink::WebNode;
[email protected]180ef242013-11-07 06:50:46136using blink::WebPagePopup;
donnda070f3c2015-01-16 19:54:11137using blink::WebPoint;
[email protected]180ef242013-11-07 06:50:46138using blink::WebPopupType;
dglazkove353a372016-09-01 01:33:48139using blink::WebRange;
[email protected]180ef242013-11-07 06:50:46140using blink::WebRect;
[email protected]180ef242013-11-07 06:50:46141using blink::WebSize;
paulmeyer90f6c31d2016-11-12 00:17:59142using blink::WebString;
[email protected]180ef242013-11-07 06:50:46143using blink::WebTextDirection;
144using blink::WebTouchEvent;
[email protected]f8ed4722013-12-03 03:27:25145using blink::WebTouchPoint;
[email protected]180ef242013-11-07 06:50:46146using blink::WebVector;
147using blink::WebWidget;
[email protected]e9ff79c2012-10-19 21:31:26148
paulmeyer90f6c31d2016-11-12 00:17:59149namespace content {
150
[email protected]6a4d7f62013-01-07 21:32:13151namespace {
[email protected]b256eca2013-07-11 10:57:40152
153typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
154
lfgbee1e0a2016-06-08 21:24:21155class WebWidgetLockTarget : public content::MouseLockDispatcher::LockTarget {
156 public:
157 explicit WebWidgetLockTarget(blink::WebWidget* webwidget)
158 : webwidget_(webwidget) {}
159
160 void OnLockMouseACK(bool succeeded) override {
161 if (succeeded)
162 webwidget_->didAcquirePointerLock();
163 else
164 webwidget_->didNotAcquirePointerLock();
165 }
166
167 void OnMouseLockLost() override { webwidget_->didLosePointerLock(); }
168
169 bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event) override {
170 // The WebWidget handles mouse lock in Blink's handleInputEvent().
171 return false;
172 }
173
174 private:
175 blink::WebWidget* webwidget_;
176};
177
dglazkov97b6c2b2016-10-25 17:35:55178bool IsDateTimeInput(ui::TextInputType type) {
179 return type == ui::TEXT_INPUT_TYPE_DATE ||
180 type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
181 type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
182 type == ui::TEXT_INPUT_TYPE_MONTH ||
183 type == ui::TEXT_INPUT_TYPE_TIME || type == ui::TEXT_INPUT_TYPE_WEEK;
184}
185
paulmeyer90f6c31d2016-11-12 00:17:59186WebDragData DropMetaDataToWebDragData(
187 const std::vector<DropData::Metadata>& drop_meta_data) {
188 std::vector<WebDragData::Item> item_list;
189 for (const auto& meta_data_item : drop_meta_data) {
190 if (meta_data_item.kind == DropData::Kind::STRING) {
191 WebDragData::Item item;
192 item.storageType = WebDragData::Item::StorageTypeString;
kinukoa4293022017-01-27 06:43:25193 item.stringType = WebString::fromUTF16(meta_data_item.mime_type);
paulmeyer90f6c31d2016-11-12 00:17:59194 // Have to pass a dummy URL here instead of an empty URL because the
195 // DropData received by browser_plugins goes through a round trip:
196 // DropData::MetaData --> WebDragData-->DropData. In the end, DropData
197 // will contain an empty URL (which means no URL is dragged) if the URL in
198 // WebDragData is empty.
199 if (base::EqualsASCII(meta_data_item.mime_type,
200 ui::Clipboard::kMimeTypeURIList)) {
201 item.stringData = WebString::fromUTF8("about:dragdrop-placeholder");
202 }
203 item_list.push_back(item);
204 continue;
205 }
206
207 // TODO(hush): crbug.com/584789. Blink needs to support creating a file with
208 // just the mimetype. This is needed to drag files to WebView on Android
209 // platform.
210 if ((meta_data_item.kind == DropData::Kind::FILENAME) &&
211 !meta_data_item.filename.empty()) {
212 WebDragData::Item item;
213 item.storageType = WebDragData::Item::StorageTypeFilename;
kinukoa4293022017-01-27 06:43:25214 item.filenameData = blink::FilePathToWebString(meta_data_item.filename);
paulmeyer90f6c31d2016-11-12 00:17:59215 item_list.push_back(item);
216 continue;
217 }
218
219 if (meta_data_item.kind == DropData::Kind::FILESYSTEMFILE) {
220 WebDragData::Item item;
221 item.storageType = WebDragData::Item::StorageTypeFileSystemFile;
222 item.fileSystemURL = meta_data_item.file_system_url;
223 item_list.push_back(item);
224 continue;
225 }
226 }
227
228 WebDragData result;
229 result.initialize();
230 result.setItems(item_list);
231 return result;
232}
233
234WebDragData DropDataToWebDragData(const DropData& drop_data) {
235 std::vector<WebDragData::Item> item_list;
236
237 // These fields are currently unused when dragging into WebKit.
238 DCHECK(drop_data.download_metadata.empty());
239 DCHECK(drop_data.file_contents.empty());
240 DCHECK(drop_data.file_description_filename.empty());
241
242 if (!drop_data.text.is_null()) {
243 WebDragData::Item item;
244 item.storageType = WebDragData::Item::StorageTypeString;
245 item.stringType = WebString::fromUTF8(ui::Clipboard::kMimeTypeText);
kinukoa4293022017-01-27 06:43:25246 item.stringData = WebString::fromUTF16(drop_data.text.string());
paulmeyer90f6c31d2016-11-12 00:17:59247 item_list.push_back(item);
248 }
249
250 if (!drop_data.url.is_empty()) {
251 WebDragData::Item item;
252 item.storageType = WebDragData::Item::StorageTypeString;
253 item.stringType = WebString::fromUTF8(ui::Clipboard::kMimeTypeURIList);
254 item.stringData = WebString::fromUTF8(drop_data.url.spec());
kinukoa4293022017-01-27 06:43:25255 item.title = WebString::fromUTF16(drop_data.url_title);
paulmeyer90f6c31d2016-11-12 00:17:59256 item_list.push_back(item);
257 }
258
259 if (!drop_data.html.is_null()) {
260 WebDragData::Item item;
261 item.storageType = WebDragData::Item::StorageTypeString;
262 item.stringType = WebString::fromUTF8(ui::Clipboard::kMimeTypeHTML);
kinukoa4293022017-01-27 06:43:25263 item.stringData = WebString::fromUTF16(drop_data.html.string());
paulmeyer90f6c31d2016-11-12 00:17:59264 item.baseURL = drop_data.html_base_url;
265 item_list.push_back(item);
266 }
267
268 for (std::vector<ui::FileInfo>::const_iterator it =
269 drop_data.filenames.begin();
270 it != drop_data.filenames.end();
271 ++it) {
272 WebDragData::Item item;
273 item.storageType = WebDragData::Item::StorageTypeFilename;
kinukoa4293022017-01-27 06:43:25274 item.filenameData = blink::FilePathToWebString(it->path);
275 item.displayNameData =
276 blink::FilePathToWebString(base::FilePath(it->display_name));
paulmeyer90f6c31d2016-11-12 00:17:59277 item_list.push_back(item);
278 }
279
280 for (std::vector<DropData::FileSystemFileInfo>::const_iterator it =
281 drop_data.file_system_files.begin();
282 it != drop_data.file_system_files.end();
283 ++it) {
284 WebDragData::Item item;
285 item.storageType = WebDragData::Item::StorageTypeFileSystemFile;
286 item.fileSystemURL = it->url;
287 item.fileSystemFileSize = it->size;
hironoda08349d2016-12-14 07:36:16288 item.fileSystemId = blink::WebString::fromASCII(it->filesystem_id);
paulmeyer90f6c31d2016-11-12 00:17:59289 item_list.push_back(item);
290 }
291
292 for (std::map<base::string16, base::string16>::const_iterator it =
293 drop_data.custom_data.begin();
294 it != drop_data.custom_data.end();
295 ++it) {
296 WebDragData::Item item;
297 item.storageType = WebDragData::Item::StorageTypeString;
kinukoa4293022017-01-27 06:43:25298 item.stringType = WebString::fromUTF16(it->first);
299 item.stringData = WebString::fromUTF16(it->second);
paulmeyer90f6c31d2016-11-12 00:17:59300 item_list.push_back(item);
301 }
302
303 WebDragData result;
304 result.initialize();
305 result.setItems(item_list);
kinukoa4293022017-01-27 06:43:25306 result.setFilesystemId(WebString::fromUTF16(drop_data.filesystem_id));
paulmeyer90f6c31d2016-11-12 00:17:59307 return result;
308}
309
lfg1568d112016-08-30 16:06:29310content::RenderWidget::CreateRenderWidgetFunction g_create_render_widget =
311 nullptr;
312
313content::RenderWidget::RenderWidgetInitializedCallback
314 g_render_widget_initialized = nullptr;
315
dtapuskac4dd5be2016-10-25 15:11:10316ui::TextInputType ConvertWebTextInputType(blink::WebTextInputType type) {
317 // Check the type is in the range representable by ui::TextInputType.
318 DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX))
319 << "blink::WebTextInputType and ui::TextInputType not synchronized";
320 return static_cast<ui::TextInputType>(type);
321}
322
323ui::TextInputMode ConvertWebTextInputMode(blink::WebTextInputMode mode) {
324 // Check the mode is in the range representable by ui::TextInputMode.
325 DCHECK_LE(mode, static_cast<int>(ui::TEXT_INPUT_MODE_MAX))
326 << "blink::WebTextInputMode and ui::TextInputMode not synchronized";
327 return static_cast<ui::TextInputMode>(mode);
328}
329
[email protected]b256eca2013-07-11 10:57:40330} // namespace
331
[email protected]b2e4c70132013-10-03 02:07:51332// RenderWidget ---------------------------------------------------------------
333
nick8331f8ad2016-11-15 20:42:45334RenderWidget::RenderWidget(int32_t widget_routing_id,
335 CompositorDependencies* compositor_deps,
dcheng35d31c112015-07-22 00:17:36336 blink::WebPopupType popup_type,
ccameron2f451532016-09-07 21:49:27337 const ScreenInfo& screen_info,
[email protected]1ac10dca2013-08-20 20:47:04338 bool swapped_out,
[email protected]7912e822014-04-16 02:37:03339 bool hidden,
340 bool never_visible)
nick8331f8ad2016-11-15 20:42:45341 : routing_id_(widget_routing_id),
dcheng35d31c112015-07-22 00:17:36342 compositor_deps_(compositor_deps),
lfg8ff33912016-09-13 20:59:21343 webwidget_internal_(nullptr),
avi40b5be7a2016-03-03 21:13:44344 owner_delegate_(nullptr),
initial.commit09911bf2008-07-26 23:55:29345 next_paint_flags_(0),
[email protected]847a2582013-03-09 02:29:51346 auto_resize_mode_(false),
[email protected]ea3ee0a2012-05-15 03:43:09347 need_update_rect_for_auto_resize_(false),
initial.commit09911bf2008-07-26 23:55:29348 did_show_(false),
[email protected]1ac10dca2013-08-20 20:47:04349 is_hidden_(hidden),
sievers71c62dd52015-10-07 01:44:39350 compositor_never_visible_(never_visible),
mikhail.pozdnyakovf2c902a2015-04-14 08:09:12351 is_fullscreen_granted_(false),
mikhail.pozdnyakovc0e251b2015-04-15 06:51:12352 display_mode_(blink::WebDisplayModeUndefined),
changwanf2a707b2015-10-30 08:22:16353 ime_event_guard_(nullptr),
[email protected]661eb9d2009-02-03 02:11:48354 closing_(false),
[email protected]aeeedad2014-08-22 18:16:22355 host_closing_(false),
[email protected]14392a52012-05-02 20:28:44356 is_swapped_out_(swapped_out),
simonhong628f9812015-04-27 23:13:20357 for_oopif_(false),
dglazkov97b6c2b2016-10-25 17:35:55358 text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
[email protected]b256eca2013-07-11 10:57:40359 text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
shuchen82ce8c52014-10-23 01:55:20360 text_input_flags_(0),
[email protected]86ba5fcb2013-09-04 00:36:53361 can_compose_inline_(true),
nonafa291792016-08-10 02:36:18362 composition_range_(gfx::Range::InvalidRange()),
[email protected]3e2b375b2010-04-07 17:03:12363 popup_type_(popup_type),
[email protected]867125a02009-12-10 06:01:48364 pending_window_rect_count_(0),
[email protected]842f10652012-06-06 01:54:04365 screen_info_(screen_info),
ccameron2f451532016-09-07 21:49:27366 device_scale_factor_(screen_info_.device_scale_factor),
nonafa291792016-08-10 02:36:18367 monitor_composition_info_(false),
[email protected]b2e4c70132013-10-03 02:07:51368 popup_origin_scale_for_emulation_(0.f),
[email protected]586871b2014-07-22 17:05:11369 frame_swap_message_queue_(new FrameSwapMessageQueue()),
[email protected]a09d53ce2014-01-31 00:46:42370 resizing_mode_selector_(new ResizingModeSelector()),
lfge0c2792ec2016-05-11 18:52:08371 has_host_context_menu_location_(false),
wjmaclean1d970622017-01-21 22:28:24372 has_added_input_handler_(false),
ekaramad2a46d632016-07-19 13:33:09373 has_focus_(false),
ekaramad330ba4232016-09-23 17:57:47374#if defined(OS_MACOSX)
375 text_input_client_observer_(new TextInputClientObserver(this)),
376#endif
wjmaclean1d970622017-01-21 22:28:24377 focused_pepper_plugin_(nullptr),
378 weak_ptr_factory_(this) {
nick8331f8ad2016-11-15 20:42:45379 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
[email protected]8b3f0eb2012-05-03 19:15:05380 if (!swapped_out)
381 RenderProcess::current()->AddRefProcess();
[email protected]380244092011-10-07 17:26:27382 DCHECK(RenderThread::Get());
alexclarke7fa93942015-10-21 15:37:11383
384 // In tests there may not be a RenderThreadImpl.
385 if (RenderThreadImpl::current()) {
386 render_widget_scheduling_state_ = RenderThreadImpl::current()
387 ->GetRendererScheduler()
dcheng07945f632015-12-26 07:59:32388 ->NewRenderWidgetSchedulingState();
alexclarke7fa93942015-10-21 15:37:11389 render_widget_scheduling_state_->SetHidden(is_hidden_);
390 }
sadrul602ce1362017-01-26 06:41:10391#if defined(USE_AURA)
392 if (base::CommandLine::ForCurrentProcess()->HasSwitch(
393 switches::kUseMusInRenderer)) {
394 RendererWindowTreeClient::Create(routing_id_);
395 }
396#endif
initial.commit09911bf2008-07-26 23:55:29397}
398
399RenderWidget::~RenderWidget() {
lfg8ff33912016-09-13 20:59:21400 DCHECK(!webwidget_internal_) << "Leaking our WebWidget!";
[email protected]bffc8302014-01-23 20:52:16401
[email protected]992db4c2011-05-12 15:37:15402 // If we are swapped out, we have released already.
[email protected]d2e2f9ee2013-08-21 11:02:02403 if (!is_swapped_out_ && RenderProcess::current())
[email protected]992db4c2011-05-12 15:37:15404 RenderProcess::current()->ReleaseProcess();
initial.commit09911bf2008-07-26 23:55:29405}
406
[email protected]484955942010-08-19 16:13:18407// static
lfg1568d112016-08-30 16:06:29408void RenderWidget::InstallCreateHook(
409 CreateRenderWidgetFunction create_render_widget,
410 RenderWidgetInitializedCallback render_widget_initialized) {
411 CHECK(!g_create_render_widget && !g_render_widget_initialized);
412 g_create_render_widget = create_render_widget;
413 g_render_widget_initialized = render_widget_initialized;
414}
415
416// static
nickf7b38222016-11-22 21:59:35417RenderWidget* RenderWidget::CreateForPopup(
418 RenderViewImpl* opener,
419 CompositorDependencies* compositor_deps,
420 blink::WebPopupType popup_type,
421 const ScreenInfo& screen_info) {
nick4df698d82016-11-11 20:39:23422 // Do a synchronous IPC to obtain a routing ID.
423 int32_t routing_id = MSG_ROUTING_NONE;
424 if (!RenderThreadImpl::current_render_message_filter()->CreateNewWidget(
nickf7b38222016-11-22 21:59:35425 opener->GetRoutingID(), popup_type, &routing_id)) {
nick4df698d82016-11-11 20:39:23426 return nullptr;
427 }
428
nick8331f8ad2016-11-15 20:42:45429 scoped_refptr<RenderWidget> widget(
430 new RenderWidget(routing_id, compositor_deps, popup_type, screen_info,
431 false, false, false));
nickf7b38222016-11-22 21:59:35432 ShowCallback opener_callback =
wjmaclean1d970622017-01-21 22:28:24433 base::Bind(&RenderViewImpl::ShowCreatedPopupWidget, opener->GetWeakPtr());
nickf7b38222016-11-22 21:59:35434 widget->Init(opener_callback, RenderWidget::CreateWebWidget(widget.get()));
nick4df698d82016-11-11 20:39:23435 DCHECK(!widget->HasOneRef()); // RenderWidget::Init() adds a reference.
436 return widget.get();
initial.commit09911bf2008-07-26 23:55:29437}
438
[email protected]484955942010-08-19 16:13:18439// static
kenrba7199832015-01-22 23:44:59440RenderWidget* RenderWidget::CreateForFrame(
nick4df698d82016-11-11 20:39:23441 int widget_routing_id,
kenrba7199832015-01-22 23:44:59442 bool hidden,
ccameron2f451532016-09-07 21:49:27443 const ScreenInfo& screen_info,
kenrba7199832015-01-22 23:44:59444 CompositorDependencies* compositor_deps,
445 blink::WebLocalFrame* frame) {
nick4df698d82016-11-11 20:39:23446 CHECK_NE(widget_routing_id, MSG_ROUTING_NONE);
dcheng3ce04b62015-10-26 23:30:55447 // TODO(avi): Before RenderViewImpl has-a RenderWidget, the browser passes the
448 // same routing ID for both the view routing ID and the main frame widget
449 // routing ID. https://crbug.com/545684
nick4df698d82016-11-11 20:39:23450 RenderViewImpl* view = RenderViewImpl::FromRoutingID(widget_routing_id);
dcheng3ce04b62015-10-26 23:30:55451 if (view) {
avi8a45c1092016-03-01 16:12:34452 view->AttachWebFrameWidget(
453 RenderWidget::CreateWebFrameWidget(view->GetWidget(), frame));
454 return view->GetWidget();
dcheng3ce04b62015-10-26 23:30:55455 }
dcheng35d31c112015-07-22 00:17:36456 scoped_refptr<RenderWidget> widget(
lfg1568d112016-08-30 16:06:29457 g_create_render_widget
nick8331f8ad2016-11-15 20:42:45458 ? g_create_render_widget(widget_routing_id, compositor_deps,
459 blink::WebPopupTypeNone, screen_info, false,
460 hidden, false)
461 : new RenderWidget(widget_routing_id, compositor_deps,
462 blink::WebPopupTypeNone, screen_info, false,
463 hidden, false));
simonhong628f9812015-04-27 23:13:20464 widget->for_oopif_ = true;
nick4df698d82016-11-11 20:39:23465 // Init increments the reference count on |widget|, keeping it alive after
kenrba7199832015-01-22 23:44:59466 // this function returns.
nickf7b38222016-11-22 21:59:35467 widget->Init(RenderWidget::ShowCallback(),
nick4df698d82016-11-11 20:39:23468 RenderWidget::CreateWebFrameWidget(widget.get(), frame));
469
470 if (g_render_widget_initialized)
471 g_render_widget_initialized(widget.get());
472 return widget.get();
kenrba7199832015-01-22 23:44:59473}
474
475// static
lfgcaab5142016-02-26 19:06:52476blink::WebFrameWidget* RenderWidget::CreateWebFrameWidget(
dchengda9b4bb2015-07-20 20:58:08477 RenderWidget* render_widget,
478 blink::WebLocalFrame* frame) {
dcheng3ce04b62015-10-26 23:30:55479 if (!frame->parent()) {
480 // TODO(dcheng): The main frame widget currently has a special case.
481 // Eliminate this once WebView is no longer a WebWidget.
482 return blink::WebFrameWidget::create(render_widget, frame->view(), frame);
483 }
dchengda9b4bb2015-07-20 20:58:08484 return blink::WebFrameWidget::create(render_widget, frame);
485}
486
487// static
kenrba7199832015-01-22 23:44:59488blink::WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) {
[email protected]484955942010-08-19 16:13:18489 switch (render_widget->popup_type_) {
[email protected]180ef242013-11-07 06:50:46490 case blink::WebPopupTypeNone: // Nothing to create.
[email protected]484955942010-08-19 16:13:18491 break;
[email protected]180ef242013-11-07 06:50:46492 case blink::WebPopupTypePage:
[email protected]a7547fb2012-03-08 04:43:44493 return WebPagePopup::create(render_widget);
[email protected]484955942010-08-19 16:13:18494 default:
495 NOTREACHED();
496 }
497 return NULL;
498}
499
dchengda9b4bb2015-07-20 20:58:08500void RenderWidget::CloseForFrame() {
dchengd96a27a2015-07-24 20:17:32501 OnClose();
kenrba7199832015-01-22 23:44:59502}
503
alexmos78c9c0d2016-10-14 18:57:03504void RenderWidget::SetSwappedOut(bool is_swapped_out) {
505 // We should only toggle between states.
506 DCHECK(is_swapped_out_ != is_swapped_out);
507 is_swapped_out_ = is_swapped_out;
508
509 // If we are swapping out, we will call ReleaseProcess, allowing the process
510 // to exit if all of its RenderViews are swapped out. We wait until the
511 // WasSwappedOut call to do this, to allow the unload handler to finish.
512 // If we are swapping in, we call AddRefProcess to prevent the process from
513 // exiting.
514 if (!is_swapped_out_)
515 RenderProcess::current()->AddRefProcess();
516}
517
nickf7b38222016-11-22 21:59:35518void RenderWidget::Init(const ShowCallback& show_callback,
519 WebWidget* web_widget) {
lfg8ff33912016-09-13 20:59:21520 DCHECK(!webwidget_internal_);
nick4df698d82016-11-11 20:39:23521 DCHECK_NE(routing_id_, MSG_ROUTING_NONE);
initial.commit09911bf2008-07-26 23:55:29522
sadrul9fe48922017-01-23 18:59:49523 input_handler_ = base::MakeUnique<RenderWidgetInputHandler>(this, this);
nick8331f8ad2016-11-15 20:42:45524
nickf7b38222016-11-22 21:59:35525 show_callback_ = show_callback;
initial.commit09911bf2008-07-26 23:55:29526
lfg8ff33912016-09-13 20:59:21527 webwidget_internal_ = web_widget;
528 webwidget_mouse_lock_target_.reset(
529 new WebWidgetLockTarget(webwidget_internal_));
lfgbee1e0a2016-06-08 21:24:21530 mouse_lock_dispatcher_.reset(new RenderWidgetMouseLockDispatcher(this));
initial.commit09911bf2008-07-26 23:55:29531
nick4df698d82016-11-11 20:39:23532 RenderThread::Get()->AddRoute(routing_id_, this);
533 // Take a reference on behalf of the RenderThread. This will be balanced
534 // when we receive ViewMsg_Close.
535 AddRef();
536 if (RenderThreadImpl::current()) {
537 RenderThreadImpl::current()->WidgetCreated();
538 if (is_hidden_)
539 RenderThreadImpl::current()->WidgetHidden();
initial.commit09911bf2008-07-26 23:55:29540 }
541}
542
[email protected]949b6592014-08-20 13:17:52543void RenderWidget::WasSwappedOut() {
544 // If we have been swapped out and no one else is using this process,
545 // it's safe to exit now.
546 CHECK(is_swapped_out_);
547 RenderProcess::current()->ReleaseProcess();
548}
549
[email protected]b2e4c70132013-10-03 02:07:51550void RenderWidget::SetPopupOriginAdjustmentsForEmulation(
mfomitchev2600fd7c2016-02-17 20:53:39551 RenderWidgetScreenMetricsEmulator* emulator) {
[email protected]b2e4c70132013-10-03 02:07:51552 popup_origin_scale_for_emulation_ = emulator->scale();
[email protected]19193682014-04-03 15:01:43553 popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin();
[email protected]9a2d7ee32013-12-05 12:15:49554 popup_screen_origin_for_emulation_ = gfx::Point(
555 emulator->original_screen_rect().origin().x() + emulator->offset().x(),
556 emulator->original_screen_rect().origin().y() + emulator->offset().y());
[email protected]5f75aa42014-04-01 23:00:56557 screen_info_ = emulator->original_screen_info();
ccameron2f451532016-09-07 21:49:27558 device_scale_factor_ = screen_info_.device_scale_factor;
[email protected]b2e4c70132013-10-03 02:07:51559}
560
[email protected]2d6836f42014-07-02 17:25:31561gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) {
562 if (screen_metrics_emulator_)
563 return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor);
564 return anchor;
565}
566
haibinluc643d33c2016-06-03 02:22:34567#if defined(USE_EXTERNAL_POPUP_MENU)
[email protected]b2e4c70132013-10-03 02:07:51568void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation(
mfomitchev2600fd7c2016-02-17 20:53:39569 ExternalPopupMenu* popup,
570 RenderWidgetScreenMetricsEmulator* emulator) {
[email protected]9a2d7ee32013-12-05 12:15:49571 popup->SetOriginScaleAndOffsetForEmulation(
572 emulator->scale(), emulator->offset());
[email protected]b2e4c70132013-10-03 02:07:51573}
[email protected]53907862014-03-25 15:42:40574#endif
[email protected]b2e4c70132013-10-03 02:07:51575
576void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
577 if (screen_metrics_emulator_)
578 screen_metrics_emulator_->OnShowContextMenu(params);
579}
580
[email protected]a95986a82010-12-24 06:19:28581bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
ekaramad330ba4232016-09-23 17:57:47582#if defined(OS_MACOSX)
583 if (IPC_MESSAGE_CLASS(message) == TextInputClientMsgStart)
584 return text_input_client_observer_->OnMessageReceived(message);
585#endif
lfgbee1e0a2016-06-08 21:24:21586 if (mouse_lock_dispatcher_ &&
587 mouse_lock_dispatcher_->OnMessageReceived(message))
588 return true;
589
[email protected]a95986a82010-12-24 06:19:28590 bool handled = true;
591 IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
[email protected]c084330e02013-04-27 01:08:15592 IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
[email protected]34202de2013-05-06 23:36:22593 IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
594 OnCursorVisibilityChange)
[email protected]a2214eb2014-06-23 18:31:22595 IPC_MESSAGE_HANDLER(InputMsg_ImeSetComposition, OnImeSetComposition)
aelias87b8f7c2016-09-14 03:19:29596 IPC_MESSAGE_HANDLER(InputMsg_ImeCommitText, OnImeCommitText)
597 IPC_MESSAGE_HANDLER(InputMsg_ImeFinishComposingText,
598 OnImeFinishComposingText)
[email protected]c084330e02013-04-27 01:08:15599 IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
alexmos56567492016-09-13 00:52:46600 IPC_MESSAGE_HANDLER(InputMsg_SetEditCommandsForNextKeyEvent,
601 OnSetEditCommandsForNextKeyEvent)
[email protected]c084330e02013-04-27 01:08:15602 IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
[email protected]9017d7852013-11-21 17:47:35603 IPC_MESSAGE_HANDLER(InputMsg_SyntheticGestureCompleted,
604 OnSyntheticGestureCompleted)
[email protected]a95986a82010-12-24 06:19:28605 IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
[email protected]a95986a82010-12-24 06:19:28606 IPC_MESSAGE_HANDLER(ViewMsg_Resize, OnResize)
dgozman9260b0a12015-03-16 13:45:20607 IPC_MESSAGE_HANDLER(ViewMsg_EnableDeviceEmulation,
608 OnEnableDeviceEmulation)
609 IPC_MESSAGE_HANDLER(ViewMsg_DisableDeviceEmulation,
610 OnDisableDeviceEmulation)
[email protected]a95986a82010-12-24 06:19:28611 IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
[email protected]9e2e4632012-07-27 16:38:41612 IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
[email protected]3d9ec5052013-01-02 22:05:25613 IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
[email protected]a95986a82010-12-24 06:19:28614 IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
615 IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
[email protected]80ad8622012-11-07 16:33:03616 IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
kenrbea731792017-01-13 15:10:48617 IPC_MESSAGE_HANDLER(ViewMsg_SetViewportIntersection,
618 OnSetViewportIntersection)
lfg43e08e62016-02-03 18:51:37619 IPC_MESSAGE_HANDLER(ViewMsg_WaitForNextFrameForTests,
620 OnWaitNextFrameForTests)
nonafa291792016-08-10 02:36:18621 IPC_MESSAGE_HANDLER(InputMsg_RequestCompositionUpdate,
622 OnRequestCompositionUpdate)
paulmeyer90f6c31d2016-11-12 00:17:59623 IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter)
624 IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver, OnDragTargetDragOver)
625 IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave, OnDragTargetDragLeave)
626 IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop)
paulmeyer8fc8ea92016-11-15 05:12:21627 IPC_MESSAGE_HANDLER(DragMsg_SourceEnded, OnDragSourceEnded)
628 IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded,
629 OnDragSourceSystemDragEnded)
[email protected]105dffb42013-02-20 03:46:21630#if defined(OS_ANDROID)
changwan8c342742016-02-26 00:53:39631 IPC_MESSAGE_HANDLER(InputMsg_RequestTextInputStateUpdate,
632 OnRequestTextInputStateUpdate)
[email protected]105dffb42013-02-20 03:46:21633#endif
[email protected]a95986a82010-12-24 06:19:28634 IPC_MESSAGE_UNHANDLED(handled = false)
635 IPC_END_MESSAGE_MAP()
636 return handled;
637}
initial.commit09911bf2008-07-26 23:55:29638
639bool RenderWidget::Send(IPC::Message* message) {
[email protected]992db4c2011-05-12 15:37:15640 // Don't send any messages after the browser has told us to close, and filter
641 // most outgoing messages while swapped out.
642 if ((is_swapped_out_ &&
[email protected]e9ff79c2012-10-19 21:31:26643 !SwappedOutMessages::CanSendWhileSwappedOut(message)) ||
[email protected]c6c921e92012-05-10 23:31:11644 closing_) {
initial.commit09911bf2008-07-26 23:55:29645 delete message;
646 return false;
647 }
648
649 // If given a messsage without a routing ID, then assign our routing ID.
650 if (message->routing_id() == MSG_ROUTING_NONE)
651 message->set_routing_id(routing_id_);
652
[email protected]380244092011-10-07 17:26:27653 return RenderThread::Get()->Send(message);
[email protected]8085dbc82008-09-26 22:53:44654}
655
dtapuska014ed082016-11-11 21:58:48656void RenderWidget::SendOrCrash(IPC::Message* message) {
657 bool result = Send(message);
658 CHECK(closing_ || result) << "Failed to send message";
659}
660
ekaramad5aff1942017-01-06 01:26:35661bool RenderWidget::ShouldHandleImeEvents() const {
662 return GetWebWidget()->isWebFrameWidget() && has_focus_;
663}
664
bokanc007c3a2015-02-03 07:15:56665void RenderWidget::SetWindowRectSynchronously(
666 const gfx::Rect& new_window_rect) {
mfomitchev2600fd7c2016-02-17 20:53:39667 ResizeParams params;
668 params.screen_info = screen_info_;
669 params.new_size = new_window_rect.size();
670 params.physical_backing_size =
671 gfx::ScaleToCeiledSize(new_window_rect.size(), device_scale_factor_);
mfomitchev2600fd7c2016-02-17 20:53:39672 params.visible_viewport_size = new_window_rect.size();
mfomitchev2600fd7c2016-02-17 20:53:39673 params.is_fullscreen_granted = is_fullscreen_granted_;
674 params.display_mode = display_mode_;
675 params.needs_resize_ack = false;
676 Resize(params);
677
bokanc007c3a2015-02-03 07:15:56678 view_screen_rect_ = new_window_rect;
679 window_screen_rect_ = new_window_rect;
[email protected]92650162013-10-30 03:31:02680 if (!did_show_)
bokanc007c3a2015-02-03 07:15:56681 initial_rect_ = new_window_rect;
[email protected]92650162013-10-30 03:31:02682}
683
initial.commit09911bf2008-07-26 23:55:29684void RenderWidget::OnClose() {
dchengd96a27a2015-07-24 20:17:32685 DCHECK(content::RenderThread::Get());
686 if (closing_)
687 return;
688 NotifyOnClose();
689 closing_ = true;
690
691 // Browser correspondence is no longer needed at this point.
692 if (routing_id_ != MSG_ROUTING_NONE) {
693 RenderThread::Get()->RemoveRoute(routing_id_);
694 SetHidden(false);
695 if (RenderThreadImpl::current())
696 RenderThreadImpl::current()->WidgetDestroyed();
697 }
698
699 if (for_oopif_) {
700 // Widgets for frames may be created and closed at any time while the frame
701 // is alive. However, the closing process must happen synchronously. Frame
702 // widget and frames hold pointers to each other. If Close() is deferred to
703 // the message loop like in the non-frame widget case, WebWidget::close()
704 // can end up accessing members of an already-deleted frame.
705 Close();
706 } else {
707 // If there is a Send call on the stack, then it could be dangerous to close
708 // now. Post a task that only gets invoked when there are no nested message
709 // loops.
710 base::ThreadTaskRunnerHandle::Get()->PostNonNestableTask(
711 FROM_HERE, base::Bind(&RenderWidget::Close, this));
712 }
713
714 // Balances the AddRef taken when we called AddRoute.
715 Release();
initial.commit09911bf2008-07-26 23:55:29716}
717
fsamuel664e8b62016-01-20 19:54:01718void RenderWidget::OnResize(const ResizeParams& params) {
[email protected]5b45ad42013-10-25 00:42:04719 if (resizing_mode_selector_->ShouldAbortOnResize(this, params))
[email protected]03e88672013-10-22 21:31:32720 return;
721
[email protected]b2e4c70132013-10-03 02:07:51722 if (screen_metrics_emulator_) {
mfomitchev2600fd7c2016-02-17 20:53:39723 screen_metrics_emulator_->OnResize(params);
[email protected]b2e4c70132013-10-03 02:07:51724 return;
725 }
726
mfomitchev2600fd7c2016-02-17 20:53:39727 Resize(params);
initial.commit09911bf2008-07-26 23:55:29728}
729
dgozman9260b0a12015-03-16 13:45:20730void RenderWidget::OnEnableDeviceEmulation(
731 const blink::WebDeviceEmulationParams& params) {
mfomitchev2600fd7c2016-02-17 20:53:39732 if (!screen_metrics_emulator_) {
733 ResizeParams resize_params;
734 resize_params.screen_info = screen_info_;
735 resize_params.new_size = size_;
736 resize_params.physical_backing_size = physical_backing_size_;
737 resize_params.visible_viewport_size = visible_viewport_size_;
mfomitchev2600fd7c2016-02-17 20:53:39738 resize_params.is_fullscreen_granted = is_fullscreen_granted_;
739 resize_params.display_mode = display_mode_;
740 screen_metrics_emulator_.reset(new RenderWidgetScreenMetricsEmulator(
741 this, params, resize_params, view_screen_rect_, window_screen_rect_));
oshima50872a72016-03-04 13:26:18742 screen_metrics_emulator_->Apply();
mfomitchev2600fd7c2016-02-17 20:53:39743 } else {
dgozman9260b0a12015-03-16 13:45:20744 screen_metrics_emulator_->ChangeEmulationParams(params);
mfomitchev2600fd7c2016-02-17 20:53:39745 }
dgozman9260b0a12015-03-16 13:45:20746}
747
748void RenderWidget::OnDisableDeviceEmulation() {
749 screen_metrics_emulator_.reset();
750}
751
initial.commit09911bf2008-07-26 23:55:29752void RenderWidget::OnWasHidden() {
[email protected]9c3085f2011-06-09 02:10:31753 TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
initial.commit09911bf2008-07-26 23:55:29754 // Go into a mode where we stop generating paint and scrolling events.
[email protected]bee16aab2009-08-26 15:55:03755 SetHidden(true);
ericwilligers88e69742016-10-17 19:29:55756 for (auto& observer : render_frames_)
757 observer.WasHidden();
initial.commit09911bf2008-07-26 23:55:29758}
759
[email protected]3399dd822014-08-09 11:14:24760void RenderWidget::OnWasShown(bool needs_repainting,
761 const ui::LatencyInfo& latency_info) {
[email protected]9e2e4632012-07-27 16:38:41762 TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
initial.commit09911bf2008-07-26 23:55:29763 // During shutdown we can just ignore this message.
lfg8ff33912016-09-13 20:59:21764 if (!GetWebWidget())
initial.commit09911bf2008-07-26 23:55:29765 return;
766
767 // See OnWasHidden
[email protected]bee16aab2009-08-26 15:55:03768 SetHidden(false);
ericwilligers88e69742016-10-17 19:29:55769 for (auto& observer : render_frames_)
770 observer.WasShown();
initial.commit09911bf2008-07-26 23:55:29771
[email protected]8a23afb32014-04-30 22:40:23772 if (!needs_repainting)
initial.commit09911bf2008-07-26 23:55:29773 return;
initial.commit09911bf2008-07-26 23:55:29774
775 // Generate a full repaint.
[email protected]3399dd822014-08-09 11:14:24776 if (compositor_) {
777 ui::LatencyInfo swap_latency_info(latency_info);
dchengcedca5612016-04-09 01:40:15778 std::unique_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor(
[email protected]3399dd822014-08-09 11:14:24779 compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info));
[email protected]aca33f4f2014-05-17 17:08:05780 compositor_->SetNeedsForcedRedraw();
[email protected]3399dd822014-08-09 11:14:24781 }
jdduke491a3f0c2015-06-15 23:30:26782 ScheduleComposite();
initial.commit09911bf2008-07-26 23:55:29783}
784
[email protected]53d3f302009-12-21 04:42:05785void RenderWidget::OnRequestMoveAck() {
786 DCHECK(pending_window_rect_count_);
787 pending_window_rect_count_--;
788}
789
[email protected]ed7defa2013-03-12 21:29:59790GURL RenderWidget::GetURLForGraphicsContext3D() {
791 return GURL();
[email protected]65225772011-05-12 21:10:24792}
793
nzolghadr5d8596502017-01-23 22:59:35794void RenderWidget::OnHandleInputEvent(
795 const blink::WebInputEvent* input_event,
796 const std::vector<const blink::WebInputEvent*>& coalesced_events,
797 const ui::LatencyInfo& latency_info,
798 InputEventDispatchType dispatch_type) {
fsamuel78f86e42016-01-20 04:10:23799 if (!input_event)
800 return;
nzolghadr5d8596502017-01-23 22:59:35801
802 input_handler_->HandleInputEvent(
803 blink::WebCoalescedInputEvent(*input_event, coalesced_events),
804 latency_info, dispatch_type);
fsamuel78f86e42016-01-20 04:10:23805}
806
807void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
lfg8ff33912016-09-13 20:59:21808 if (GetWebWidget())
809 GetWebWidget()->setCursorVisibilityState(is_visible);
fsamuel78f86e42016-01-20 04:10:23810}
811
812void RenderWidget::OnMouseCaptureLost() {
lfg8ff33912016-09-13 20:59:21813 if (GetWebWidget())
814 GetWebWidget()->mouseCaptureLost();
fsamuel78f86e42016-01-20 04:10:23815}
816
alexmos56567492016-09-13 00:52:46817void RenderWidget::OnSetEditCommandsForNextKeyEvent(
818 const EditCommands& edit_commands) {
819 edit_commands_ = edit_commands;
820}
821
fsamuel78f86e42016-01-20 04:10:23822void RenderWidget::OnSetFocus(bool enable) {
lfge0c2792ec2016-05-11 18:52:08823 has_focus_ = enable;
824
lfg8ff33912016-09-13 20:59:21825 if (GetWebWidget())
826 GetWebWidget()->setFocus(enable);
lfge0c2792ec2016-05-11 18:52:08827
ericwilligers88e69742016-10-17 19:29:55828 for (auto& observer : render_frames_)
829 observer.RenderWidgetSetFocus(enable);
fsamuel78f86e42016-01-20 04:10:23830}
831
dtapuska3d5624d32016-08-30 04:34:00832void RenderWidget::SetNeedsMainFrame() {
833 RenderWidgetCompositor* rwc = compositor();
834 if (!rwc)
835 return;
836 rwc->setNeedsBeginFrame();
837}
838
fsamuel78f86e42016-01-20 04:10:23839///////////////////////////////////////////////////////////////////////////////
840// RenderWidgetCompositorDelegate
841
842void RenderWidget::ApplyViewportDeltas(
843 const gfx::Vector2dF& inner_delta,
844 const gfx::Vector2dF& outer_delta,
845 const gfx::Vector2dF& elastic_overscroll_delta,
846 float page_scale,
847 float top_controls_delta) {
lfg8ff33912016-09-13 20:59:21848 GetWebWidget()->applyViewportDeltas(inner_delta, outer_delta,
849 elastic_overscroll_delta, page_scale,
850 top_controls_delta);
fsamuel78f86e42016-01-20 04:10:23851}
852
853void RenderWidget::BeginMainFrame(double frame_time_sec) {
dtapuska3d5624d32016-08-30 04:34:00854 RenderThreadImpl* render_thread = RenderThreadImpl::current();
855 // render_thread may be NULL in tests.
856 InputHandlerManager* input_handler_manager =
857 render_thread ? render_thread->input_handler_manager() : NULL;
858 if (input_handler_manager)
859 input_handler_manager->ProcessRafAlignedInputOnMainThread(routing_id_);
860
lfg8ff33912016-09-13 20:59:21861 GetWebWidget()->beginFrame(frame_time_sec);
fsamuel78f86e42016-01-20 04:10:23862}
863
danakj1120f4c2016-09-15 02:05:32864std::unique_ptr<cc::CompositorFrameSink>
samansd5db2502017-01-13 23:18:27865RenderWidget::CreateCompositorFrameSink(const cc::FrameSinkId& frame_sink_id,
866 bool fallback) {
lfg8ff33912016-09-13 20:59:21867 DCHECK(GetWebWidget());
[email protected]7912e822014-04-16 02:37:03868 // For widgets that are never visible, we don't start the compositor, so we
danakj1120f4c2016-09-15 02:05:32869 // never get a request for a cc::CompositorFrameSink.
sievers71c62dd52015-10-07 01:44:39870 DCHECK(!compositor_never_visible_);
danakj1120f4c2016-09-15 02:05:32871 return RenderThreadImpl::current()->CreateCompositorFrameSink(
samansd5db2502017-01-13 23:18:27872 frame_sink_id, fallback, routing_id_, frame_swap_message_queue_,
danakj83066a32016-06-21 02:34:49873 GetURLForGraphicsContext3D());
[email protected]ba91a792013-02-06 09:48:28874}
875
fsamuel78f86e42016-01-20 04:10:23876void RenderWidget::DidCommitAndDrawCompositorFrame() {
877 // NOTE: Tests may break if this event is renamed or moved. See
878 // tab_capture_performancetest.cc.
879 TRACE_EVENT0("gpu", "RenderWidget::DidCommitAndDrawCompositorFrame");
lfge0c2792ec2016-05-11 18:52:08880
ericwilligers88e69742016-10-17 19:29:55881 for (auto& observer : render_frames_)
882 observer.DidCommitAndDrawCompositorFrame();
lfge0c2792ec2016-05-11 18:52:08883
fsamuel78f86e42016-01-20 04:10:23884 // Notify subclasses that we initiated the paint operation.
885 DidInitiatePaint();
886}
887
888void RenderWidget::DidCommitCompositorFrame() {
ericwilligers88e69742016-10-17 19:29:55889 for (auto& observer : render_frames_)
890 observer.DidCommitCompositorFrame();
891 for (auto& observer : render_frame_proxies_)
892 observer.DidCommitCompositorFrame();
fsamuel78f86e42016-01-20 04:10:23893}
894
895void RenderWidget::DidCompletePageScaleAnimation() {}
896
danakj6c872fc02016-10-22 04:29:49897void RenderWidget::DidReceiveCompositorFrameAck() {
898 TRACE_EVENT0("renderer", "RenderWidget::DidReceiveCompositorFrameAck");
fsamuel78f86e42016-01-20 04:10:23899
pimanbfb2ceb2016-03-18 21:32:58900 if (!next_paint_flags_ && !need_update_rect_for_auto_resize_) {
fsamuel78f86e42016-01-20 04:10:23901 return;
902 }
903
904 ViewHostMsg_UpdateRect_Params params;
905 params.view_size = size_;
fsamuel78f86e42016-01-20 04:10:23906 params.flags = next_paint_flags_;
907
908 Send(new ViewHostMsg_UpdateRect(routing_id_, params));
909 next_paint_flags_ = 0;
910 need_update_rect_for_auto_resize_ = false;
911}
912
fsamuel78f86e42016-01-20 04:10:23913bool RenderWidget::IsClosing() const {
914 return host_closing_;
915}
916
danakj53eccbc2016-03-02 22:51:07917void RenderWidget::RequestScheduleAnimation() {
fsamuel78f86e42016-01-20 04:10:23918 scheduleAnimation();
initial.commit09911bf2008-07-26 23:55:29919}
920
fsamuel78f86e42016-01-20 04:10:23921void RenderWidget::UpdateVisualState() {
lfg8ff33912016-09-13 20:59:21922 GetWebWidget()->updateAllLifecyclePhases();
fsamuel78f86e42016-01-20 04:10:23923}
924
925void RenderWidget::WillBeginCompositorFrame() {
926 TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
927
dglazkov06854c5c2016-08-31 00:19:59928 // The UpdateTextInputState can result in further layout and possibly
929 // enable GPU acceleration so they need to be called before any painting
930 // is done.
changwan75e3b2072017-01-16 02:55:00931 UpdateTextInputState();
dglazkov06854c5c2016-08-31 00:19:59932 UpdateSelectionBounds();
933
ericwilligers88e69742016-10-17 19:29:55934 for (auto& observer : render_frame_proxies_)
935 observer.WillBeginCompositorFrame();
initial.commit09911bf2008-07-26 23:55:29936}
937
jbroman6ccbc7d472016-07-27 04:45:41938std::unique_ptr<cc::SwapPromise> RenderWidget::RequestCopyOfOutputForLayoutTest(
939 std::unique_ptr<cc::CopyOutputRequest> request) {
940 return RenderThreadImpl::current()->RequestCopyOfOutputForLayoutTest(
941 routing_id_, std::move(request));
942}
943
fsamuel72464894f2015-12-15 06:59:31944///////////////////////////////////////////////////////////////////////////////
945// RenderWidgetInputHandlerDelegate
946
avid7d6b2e2016-03-04 19:41:17947void RenderWidget::FocusChangeComplete() {
948 if (owner_delegate_)
949 owner_delegate_->RenderWidgetFocusChangeComplete();
950}
fsamuel72464894f2015-12-15 06:59:31951
952bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
avid7d6b2e2016-03-04 19:41:17953 if (owner_delegate_)
954 return owner_delegate_->DoesRenderWidgetHaveTouchEventHandlersAt(point);
955
fsamuel72464894f2015-12-15 06:59:31956 return true;
957}
958
dtapuska1827dd22016-03-11 15:24:59959void RenderWidget::ObserveGestureEventAndResult(
960 const blink::WebGestureEvent& gesture_event,
961 const gfx::Vector2dF& unused_delta,
962 bool event_processed) {
963 if (!compositor_deps_->IsElasticOverscrollEnabled())
964 return;
965
966 cc::InputHandlerScrollResult scroll_result;
967 scroll_result.did_scroll = event_processed;
968 scroll_result.did_overscroll_root = !unused_delta.IsZero();
969 scroll_result.unused_scroll_delta = unused_delta;
970
971 RenderThreadImpl* render_thread = RenderThreadImpl::current();
972 InputHandlerManager* input_handler_manager =
973 render_thread ? render_thread->input_handler_manager() : NULL;
974 if (input_handler_manager) {
975 input_handler_manager->ObserveGestureEventAndResultOnMainThread(
976 routing_id_, gesture_event, scroll_result);
977 }
978}
979
avid7d6b2e2016-03-04 19:41:17980void RenderWidget::OnDidHandleKeyEvent() {
alexmos56567492016-09-13 00:52:46981 ClearEditCommands();
982}
983
984void RenderWidget::SetEditCommandForNextKeyEvent(const std::string& name,
985 const std::string& value) {
986 ClearEditCommands();
987 edit_commands_.emplace_back(name, value);
988}
989
990void RenderWidget::ClearEditCommands() {
991 edit_commands_.clear();
avid7d6b2e2016-03-04 19:41:17992}
fsamuel72464894f2015-12-15 06:59:31993
chongza8ba91fc2016-08-16 21:39:17994void RenderWidget::OnDidOverscroll(const ui::DidOverscrollParams& params) {
fsamuel72464894f2015-12-15 06:59:31995 Send(new InputHostMsg_DidOverscroll(routing_id_, params));
996}
997
dchengcedca5612016-04-09 01:40:15998void RenderWidget::OnInputEventAck(
999 std::unique_ptr<InputEventAck> input_event_ack) {
dtapuska014ed082016-11-11 21:58:481000 SendOrCrash(
1001 new InputHostMsg_HandleInputEvent_ACK(routing_id_, *input_event_ack));
fsamuel72464894f2015-12-15 06:59:311002}
1003
dtapuska46616922016-03-17 22:52:011004void RenderWidget::NotifyInputEventHandled(
dtapuskab08721e62016-06-29 03:35:071005 blink::WebInputEvent::Type handled_type,
1006 InputEventAckState ack_result) {
dtapuska0bd451a2016-02-18 17:08:101007 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1008 InputHandlerManager* input_handler_manager =
1009 render_thread ? render_thread->input_handler_manager() : NULL;
1010 if (input_handler_manager) {
dtapuskab08721e62016-06-29 03:35:071011 input_handler_manager->NotifyInputEventHandledOnMainThread(
1012 routing_id_, handled_type, ack_result);
dtapuska0bd451a2016-02-18 17:08:101013 }
1014}
1015
fsamuele8326c742016-01-12 00:49:391016void RenderWidget::SetInputHandler(RenderWidgetInputHandler* input_handler) {
1017 // Nothing to do here. RenderWidget created the |input_handler| and will take
1018 // ownership of it. We just verify here that we don't already have an input
1019 // handler.
1020 DCHECK(!input_handler_);
1021}
1022
changwan75e3b2072017-01-16 02:55:001023void RenderWidget::ShowVirtualKeyboard() {
1024 UpdateTextInputStateInternal(true, false);
1025}
1026
1027void RenderWidget::UpdateTextInputState() {
1028 UpdateTextInputStateInternal(false, false);
1029}
1030
1031void RenderWidget::UpdateTextInputStateInternal(bool show_virtual_keyboard,
1032 bool reply_to_request) {
fsamuel72464894f2015-12-15 06:59:311033 TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState");
changwan75e3b2072017-01-16 02:55:001034
fsamuel72464894f2015-12-15 06:59:311035 if (ime_event_guard_) {
changwan75e3b2072017-01-16 02:55:001036 DCHECK(!reply_to_request);
1037 // show_virtual_keyboard should still be effective even if it was set inside
1038 // the IME
fsamuel72464894f2015-12-15 06:59:311039 // event guard.
changwan75e3b2072017-01-16 02:55:001040 if (show_virtual_keyboard)
1041 ime_event_guard_->set_show_virtual_keyboard(true);
fsamuel72464894f2015-12-15 06:59:311042 return;
1043 }
1044
dglazkov97b6c2b2016-10-25 17:35:551045 ui::TextInputType new_type = GetTextInputType();
1046 if (IsDateTimeInput(new_type))
1047 return; // Not considered as a text input field in WebKit/Chromium.
fsamuel72464894f2015-12-15 06:59:311048
dglazkov97b6c2b2016-10-25 17:35:551049 blink::WebTextInputInfo new_info;
ekaramad5aff1942017-01-06 01:26:351050 if (auto* controller = GetInputMethodController())
1051 new_info = controller->textInputInfo();
dtapuskac4dd5be2016-10-25 15:11:101052 const ui::TextInputMode new_mode =
1053 ConvertWebTextInputMode(new_info.inputMode);
fsamuel72464894f2015-12-15 06:59:311054
1055 bool new_can_compose_inline = CanComposeInline();
1056
1057 // Only sends text input params if they are changed or if the ime should be
1058 // shown.
changwan75e3b2072017-01-16 02:55:001059 if (show_virtual_keyboard || reply_to_request ||
changwan38c3eb612016-12-09 01:45:561060 text_input_type_ != new_type || text_input_mode_ != new_mode ||
1061 text_input_info_ != new_info ||
1062 can_compose_inline_ != new_can_compose_inline) {
ekaramad9053e57b2016-04-26 20:00:381063 TextInputState params;
dglazkov97b6c2b2016-10-25 17:35:551064 params.type = new_type;
fsamuel72464894f2015-12-15 06:59:311065 params.mode = new_mode;
1066 params.flags = new_info.flags;
1067 params.value = new_info.value.utf8();
1068 params.selection_start = new_info.selectionStart;
1069 params.selection_end = new_info.selectionEnd;
1070 params.composition_start = new_info.compositionStart;
1071 params.composition_end = new_info.compositionEnd;
1072 params.can_compose_inline = new_can_compose_inline;
changwan75e3b2072017-01-16 02:55:001073 // TODO(changwan): change instances of show_ime_if_needed to
1074 // show_virtual_keyboard.
1075 params.show_ime_if_needed = show_virtual_keyboard;
1076 params.reply_to_request = reply_to_request;
fsamuel72464894f2015-12-15 06:59:311077 Send(new ViewHostMsg_TextInputStateChanged(routing_id(), params));
1078
1079 text_input_info_ = new_info;
dglazkov97b6c2b2016-10-25 17:35:551080 text_input_type_ = new_type;
fsamuel72464894f2015-12-15 06:59:311081 text_input_mode_ = new_mode;
1082 can_compose_inline_ = new_can_compose_inline;
1083 text_input_flags_ = new_info.flags;
1084 }
1085}
1086
1087bool RenderWidget::WillHandleGestureEvent(const blink::WebGestureEvent& event) {
paulmeyer6ef5a792016-11-08 20:33:581088 possible_drag_event_info_.event_source =
1089 ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH;
1090 possible_drag_event_info_.event_location =
1091 gfx::Point(event.globalX, event.globalY);
avid7d6b2e2016-03-04 19:41:171092
fsamuel72464894f2015-12-15 06:59:311093 return false;
1094}
1095
1096bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
ericwilligers88e69742016-10-17 19:29:551097 for (auto& observer : render_frames_)
1098 observer.RenderWidgetWillHandleMouseEvent();
lfge0c2792ec2016-05-11 18:52:081099
paulmeyer6ef5a792016-11-08 20:33:581100 possible_drag_event_info_.event_source =
1101 ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
1102 possible_drag_event_info_.event_location =
1103 gfx::Point(event.globalX, event.globalY);
1104
avid7d6b2e2016-03-04 19:41:171105 if (owner_delegate_)
1106 return owner_delegate_->RenderWidgetWillHandleMouseEvent(event);
1107
fsamuel72464894f2015-12-15 06:59:311108 return false;
[email protected]fd847792013-10-24 17:12:351109}
1110
initial.commit09911bf2008-07-26 23:55:291111///////////////////////////////////////////////////////////////////////////////
mfomitchev2600fd7c2016-02-17 20:53:391112// RenderWidgetScreenMetricsDelegate
1113
1114void RenderWidget::Redraw() {
1115 set_next_paint_is_resize_ack();
1116 if (compositor_)
1117 compositor_->SetNeedsRedrawRect(gfx::Rect(size_));
1118}
1119
bokanc63441c2016-04-27 15:49:121120void RenderWidget::ResizeWebWidget() {
lfg8ff33912016-09-13 20:59:211121 GetWebWidget()->resize(GetSizeForWebWidget());
bokanc63441c2016-04-27 15:49:121122}
1123
1124gfx::Size RenderWidget::GetSizeForWebWidget() const {
1125 if (IsUseZoomForDSFEnabled())
1126 return gfx::ScaleToCeiledSize(size_, GetOriginalDeviceScaleFactor());
1127
1128 return size_;
1129}
1130
mfomitchev2600fd7c2016-02-17 20:53:391131void RenderWidget::Resize(const ResizeParams& params) {
engedy6cb63c92016-02-23 14:14:581132 bool orientation_changed =
ccameron2f451532016-09-07 21:49:271133 screen_info_.orientation_angle != params.screen_info.orientation_angle ||
1134 screen_info_.orientation_type != params.screen_info.orientation_type;
engedy6cb63c92016-02-23 14:14:581135
mfomitchev2600fd7c2016-02-17 20:53:391136 screen_info_ = params.screen_info;
wjmaclean8a795f32016-08-11 23:49:581137
ccameron2f451532016-09-07 21:49:271138 if (device_scale_factor_ != screen_info_.device_scale_factor) {
1139 device_scale_factor_ = screen_info_.device_scale_factor;
wjmaclean8a795f32016-08-11 23:49:581140 OnDeviceScaleFactorChanged();
1141 ScheduleComposite();
1142 }
mfomitchev2600fd7c2016-02-17 20:53:391143
1144 if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
1145 // A resize ack shouldn't be requested if we have not ACK'd the previous
1146 // one.
1147 DCHECK(!params.needs_resize_ack || !next_paint_is_resize_ack());
1148 }
1149
1150 // Ignore this during shutdown.
lfg8ff33912016-09-13 20:59:211151 if (!GetWebWidget())
mfomitchev2600fd7c2016-02-17 20:53:391152 return;
1153
ianwene5fc5782016-08-18 04:05:151154 if (compositor_) {
mfomitchev2600fd7c2016-02-17 20:53:391155 compositor_->setViewportSize(params.physical_backing_size);
ianwene5fc5782016-08-18 04:05:151156 compositor_->setBottomControlsHeight(params.bottom_controls_height);
ccameronf408cab2016-09-14 16:54:421157 compositor_->SetDeviceColorSpace(screen_info_.icc_profile.GetColorSpace());
ianwene5fc5782016-08-18 04:05:151158 }
mfomitchev2600fd7c2016-02-17 20:53:391159
mfomitchev2600fd7c2016-02-17 20:53:391160 visible_viewport_size_ = params.visible_viewport_size;
mfomitchev2600fd7c2016-02-17 20:53:391161
1162 // NOTE: We may have entered fullscreen mode without changing our size.
1163 bool fullscreen_change =
1164 is_fullscreen_granted_ != params.is_fullscreen_granted;
1165 is_fullscreen_granted_ = params.is_fullscreen_granted;
1166 display_mode_ = params.display_mode;
1167
bokanc63441c2016-04-27 15:49:121168 size_ = params.new_size;
1169 physical_backing_size_ = params.physical_backing_size;
mfomitchev2600fd7c2016-02-17 20:53:391170
bokanc63441c2016-04-27 15:49:121171 ResizeWebWidget();
bokan71cb5b12016-04-27 03:45:221172
mfomitchev2600fd7c2016-02-17 20:53:391173 WebSize visual_viewport_size;
1174
1175 if (IsUseZoomForDSFEnabled()) {
oshima50872a72016-03-04 13:26:181176 visual_viewport_size = gfx::ScaleToCeiledSize(
1177 params.visible_viewport_size,
1178 GetOriginalDeviceScaleFactor());
mfomitchev2600fd7c2016-02-17 20:53:391179 } else {
1180 visual_viewport_size = visible_viewport_size_;
1181 }
1182
lfg8ff33912016-09-13 20:59:211183 GetWebWidget()->resizeVisualViewport(visual_viewport_size);
mfomitchev2600fd7c2016-02-17 20:53:391184
bokanc63441c2016-04-27 15:49:121185 // When resizing, we want to wait to paint before ACK'ing the resize. This
1186 // ensures that we only resize as fast as we can paint. We only need to
1187 // send an ACK if we are resized to a non-empty rect.
mfomitchev2600fd7c2016-02-17 20:53:391188 if (params.new_size.IsEmpty() || params.physical_backing_size.IsEmpty()) {
1189 // In this case there is no paint/composite and therefore no
1190 // ViewHostMsg_UpdateRect to send the resize ack with. We'd need to send the
1191 // ack through a fake ViewHostMsg_UpdateRect or a different message.
1192 DCHECK(!params.needs_resize_ack);
1193 }
1194
1195 // Send the Resize_ACK flag once we paint again if requested.
1196 if (params.needs_resize_ack)
1197 set_next_paint_is_resize_ack();
1198
1199 if (fullscreen_change)
1200 DidToggleFullscreen();
1201
engedy6cb63c92016-02-23 14:14:581202 if (orientation_changed)
1203 OnOrientationChange();
1204
mfomitchev2600fd7c2016-02-17 20:53:391205 // If a resize ack is requested and it isn't set-up, then no more resizes will
1206 // come in and in general things will go wrong.
1207 DCHECK(!params.needs_resize_ack || next_paint_is_resize_ack());
1208}
1209
1210void RenderWidget::SetScreenMetricsEmulationParameters(
1211 bool enabled,
1212 const blink::WebDeviceEmulationParams& params) {
1213 // This is only supported in RenderView.
1214 NOTREACHED();
1215}
1216
1217void RenderWidget::SetScreenRects(const gfx::Rect& view_screen_rect,
1218 const gfx::Rect& window_screen_rect) {
1219 view_screen_rect_ = view_screen_rect;
1220 window_screen_rect_ = window_screen_rect;
1221}
1222
1223///////////////////////////////////////////////////////////////////////////////
[email protected]f98d7e3c2010-09-13 22:30:461224// WebWidgetClient
initial.commit09911bf2008-07-26 23:55:291225
[email protected]3a1c8a8032013-03-18 22:35:321226void RenderWidget::AutoResizeCompositor() {
danakjddaec912015-09-25 19:38:401227 physical_backing_size_ = gfx::ScaleToCeiledSize(size_, device_scale_factor_);
[email protected]97e1bf72013-03-06 14:06:051228 if (compositor_)
oshima750cb4342015-10-31 00:59:011229 compositor_->setViewportSize(physical_backing_size_);
[email protected]97e1bf72013-03-06 14:06:051230}
1231
loyso50b51c22017-01-10 07:18:371232blink::WebLayerTreeView* RenderWidget::initializeLayerTreeView() {
[email protected]aeeedad2014-08-22 18:16:221233 DCHECK(!host_closing_);
1234
loyso6e6efc42017-01-21 02:23:031235 compositor_ = RenderWidgetCompositor::Create(this, compositor_deps_);
1236 auto animation_host = cc::AnimationHost::CreateMainInstance();
1237
1238 auto layer_tree_host = RenderWidgetCompositor::CreateLayerTreeHost(
1239 compositor_.get(), compositor_.get(), animation_host.get(),
1240 compositor_deps_, device_scale_factor_, screen_info_);
1241 compositor_->Initialize(std::move(layer_tree_host),
1242 std::move(animation_host));
1243
wjmaclean1d970622017-01-21 22:28:241244 compositor_->SetIsForOopif(for_oopif_);
oshima750cb4342015-10-31 00:59:011245 compositor_->setViewportSize(physical_backing_size_);
oshimad5279032015-12-16 18:22:331246 OnDeviceScaleFactorChanged();
ccameronf408cab2016-09-14 16:54:421247 compositor_->SetDeviceColorSpace(screen_info_.icc_profile.GetColorSpace());
sievers71c62dd52015-10-07 01:44:391248 // For background pages and certain tests, we don't want to trigger
danakj1120f4c2016-09-15 02:05:321249 // CompositorFrameSink creation.
sievers71c62dd52015-10-07 01:44:391250 if (compositor_never_visible_ || !RenderThreadImpl::current())
1251 compositor_->SetNeverVisible();
1252
pimanc4af3072015-10-02 03:45:591253 StartCompositor();
staraz067f58242016-11-07 21:06:411254 DCHECK_NE(MSG_ROUTING_NONE, routing_id_);
1255 compositor_->SetFrameSinkId(
1256 cc::FrameSinkId(RenderThread::Get()->GetClientId(), routing_id_));
loyso50b51c22017-01-10 07:18:371257
wjmaclean1d970622017-01-21 22:28:241258 RenderThreadImpl* render_thread = RenderThreadImpl::current();
1259 // render_thread may be NULL in tests.
1260 InputHandlerManager* input_handler_manager =
1261 render_thread ? render_thread->input_handler_manager() : NULL;
1262 if (input_handler_manager) {
1263 input_handler_manager->AddInputHandler(
1264 routing_id_, compositor()->GetInputHandler(),
1265 weak_ptr_factory_.GetWeakPtr(),
1266 compositor_deps_->IsScrollAnimatorEnabled());
1267 has_added_input_handler_ = true;
1268 }
1269
loyso50b51c22017-01-10 07:18:371270 return compositor_.get();
[email protected]e195e582013-03-08 01:32:591271}
1272
ennef3c58142014-12-09 21:44:381273void RenderWidget::WillCloseLayerTreeView() {
1274 if (host_closing_)
1275 return;
1276
1277 // Prevent new compositors or output surfaces from being created.
1278 host_closing_ = true;
1279
[email protected]aeeedad2014-08-22 18:16:221280 // Always send this notification to prevent new layer tree views from
1281 // being created, even if one hasn't been created yet.
lfg8ff33912016-09-13 20:59:211282 if (blink::WebWidget* widget = GetWebWidget())
1283 widget->willCloseLayerTreeView();
[email protected]aeeedad2014-08-22 18:16:221284}
1285
dglazkovf0e1d6d2015-10-10 02:13:481286void RenderWidget::didMeaningfulLayout(blink::WebMeaningfulLayout layout_type) {
1287 if (layout_type == blink::WebMeaningfulLayout::VisuallyNonEmpty) {
1288 QueueMessage(new ViewHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_),
1289 MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE);
1290 }
dglazkov79c426102015-08-31 21:22:431291
ericwilligers88e69742016-10-17 19:29:551292 for (auto& observer : render_frames_)
1293 observer.DidMeaningfulLayout(layout_type);
dglazkov79c426102015-08-31 21:22:431294}
1295
jdduke491a3f0c2015-06-15 23:30:261296void RenderWidget::ScheduleComposite() {
1297 if (compositor_ &&
1298 compositor_deps_->GetCompositorImplThreadTaskRunner().get()) {
skyostil32650d22016-09-26 16:58:231299 compositor_->setNeedsCompositorUpdate();
jdduke491a3f0c2015-06-15 23:30:261300 }
1301}
1302
1303void RenderWidget::ScheduleCompositeWithForcedRedraw() {
1304 if (compositor_) {
1305 // Regardless of whether threaded compositing is enabled, always
1306 // use this mechanism to force the compositor to redraw. However,
1307 // the invalidation code path below is still needed for the
1308 // non-threaded case.
1309 compositor_->SetNeedsForcedRedraw();
1310 }
1311 ScheduleComposite();
[email protected]6fceb912013-02-15 06:24:151312}
1313
[email protected]586871b2014-07-22 17:05:111314// static
dchengcedca5612016-04-09 01:40:151315std::unique_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
[email protected]586871b2014-07-22 17:05:111316 IPC::Message* msg,
1317 MessageDeliveryPolicy policy,
1318 FrameSwapMessageQueue* frame_swap_message_queue,
1319 scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
[email protected]586871b2014-07-22 17:05:111320 int source_frame_number) {
[email protected]586871b2014-07-22 17:05:111321 bool first_message_for_frame = false;
dchengcedca5612016-04-09 01:40:151322 frame_swap_message_queue->QueueMessageForFrame(policy, source_frame_number,
1323 base::WrapUnique(msg),
[email protected]586871b2014-07-22 17:05:111324 &first_message_for_frame);
1325 if (first_message_for_frame) {
dchengcedca5612016-04-09 01:40:151326 std::unique_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
[email protected]586871b2014-07-22 17:05:111327 sync_message_filter, frame_swap_message_queue, source_frame_number));
dcheng4b6b5ff2014-10-16 00:42:061328 return promise;
[email protected]586871b2014-07-22 17:05:111329 }
dcheng4b6b5ff2014-10-16 00:42:061330 return nullptr;
[email protected]586871b2014-07-22 17:05:111331}
1332
1333void RenderWidget::QueueMessage(IPC::Message* msg,
1334 MessageDeliveryPolicy policy) {
1335 // RenderThreadImpl::current() is NULL in some tests.
1336 if (!compositor_ || !RenderThreadImpl::current()) {
1337 Send(msg);
1338 return;
1339 }
1340
dchengcedca5612016-04-09 01:40:151341 std::unique_ptr<cc::SwapPromise> swap_promise =
1342 QueueMessageImpl(msg, policy, frame_swap_message_queue_.get(),
[email protected]586871b2014-07-22 17:05:111343 RenderThreadImpl::current()->sync_message_filter(),
[email protected]586871b2014-07-22 17:05:111344 compositor_->GetSourceFrameNumber());
1345
1346 if (swap_promise) {
dcheng07945f632015-12-26 07:59:321347 compositor_->QueueSwapPromise(std::move(swap_promise));
igsollaeab34cc2015-02-20 11:33:351348 // Request a commit. This might either A) request a commit ahead of time
1349 // or B) request a commit which is not needed because there are not
1350 // pending updates. If B) then the commit will be skipped and the swap
1351 // promises will be broken (see EarlyOut_NoUpdates). To achieve that we
1352 // call SetNeedsUpdateLayers instead of SetNeedsCommit so that
1353 // can_cancel_commit is not unset.
1354 compositor_->SetNeedsUpdateLayers();
[email protected]586871b2014-07-22 17:05:111355 }
1356}
1357
[email protected]4873c7d2009-07-16 06:36:281358void RenderWidget::didChangeCursor(const WebCursorInfo& cursor_info) {
[email protected]7c51b0ee2009-07-08 21:49:301359 // TODO(darin): Eliminate this temporary.
[email protected]9ec87712013-05-24 23:23:521360 WebCursor cursor;
tfarina75a0abf2015-10-06 15:07:181361 InitializeCursorFromWebCursorInfo(&cursor, cursor_info);
initial.commit09911bf2008-07-26 23:55:291362 // Only send a SetCursor message if we need to make a change.
1363 if (!current_cursor_.IsEqual(cursor)) {
1364 current_cursor_ = cursor;
1365 Send(new ViewHostMsg_SetCursor(routing_id_, cursor));
1366 }
1367}
1368
1369// We are supposed to get a single call to Show for a newly created RenderWidget
1370// that was created via RenderWidget::CreateWebView. So, we wait until this
1371// point to dispatch the ShowWidget message.
1372//
1373// This method provides us with the information about how to display the newly
[email protected]5f9de5882011-09-30 23:36:281374// created RenderWidget (i.e., as a blocked popup or as a new tab).
initial.commit09911bf2008-07-26 23:55:291375//
nickf7b38222016-11-22 21:59:351376void RenderWidget::show(WebNavigationPolicy policy) {
initial.commit09911bf2008-07-26 23:55:291377 DCHECK(!did_show_) << "received extraneous Show call";
1378 DCHECK(routing_id_ != MSG_ROUTING_NONE);
nickf7b38222016-11-22 21:59:351379 DCHECK(!show_callback_.is_null());
initial.commit09911bf2008-07-26 23:55:291380
[email protected]8de12d942010-11-17 20:42:441381 if (did_show_)
1382 return;
1383
1384 did_show_ = true;
nickf7b38222016-11-22 21:59:351385
1386 // The opener is responsible for actually showing this widget.
1387 show_callback_.Run(this, policy, initial_rect_);
nick5ae4d2d2017-01-06 01:18:351388 show_callback_.Reset();
nickf7b38222016-11-22 21:59:351389
bokanc007c3a2015-02-03 07:15:561390 // NOTE: initial_rect_ may still have its default values at this point, but
[email protected]8de12d942010-11-17 20:42:441391 // that's okay. It'll be ignored if as_popup is false, or the browser
1392 // process will impose a default position otherwise.
bokanc007c3a2015-02-03 07:15:561393 SetPendingWindowRect(initial_rect_);
initial.commit09911bf2008-07-26 23:55:291394}
1395
[email protected]2533ce12009-05-09 00:02:241396void RenderWidget::DoDeferredClose() {
ennef3c58142014-12-09 21:44:381397 WillCloseLayerTreeView();
[email protected]2533ce12009-05-09 00:02:241398 Send(new ViewHostMsg_Close(routing_id_));
1399}
1400
dgozmancf9039cd2015-04-06 12:01:311401void RenderWidget::NotifyOnClose() {
ericwilligers88e69742016-10-17 19:29:551402 for (auto& observer : render_frames_)
1403 observer.WidgetWillClose();
dgozmancf9039cd2015-04-06 12:01:311404}
1405
[email protected]4873c7d2009-07-16 06:36:281406void RenderWidget::closeWidgetSoon() {
skyostiled8969c2015-07-20 16:57:081407 DCHECK(content::RenderThread::Get());
[email protected]e1c3a552012-05-04 20:51:321408 if (is_swapped_out_) {
1409 // This widget is currently swapped out, and the active widget is in a
1410 // different process. Have the browser route the close request to the
1411 // active widget instead, so that the correct unload handlers are run.
1412 Send(new ViewHostMsg_RouteCloseEvent(routing_id_));
1413 return;
1414 }
1415
initial.commit09911bf2008-07-26 23:55:291416 // If a page calls window.close() twice, we'll end up here twice, but that's
1417 // OK. It is safe to send multiple Close messages.
1418
[email protected]2533ce12009-05-09 00:02:241419 // Ask the RenderWidgetHost to initiate close. We could be called from deep
1420 // in Javascript. If we ask the RendwerWidgetHost to close now, the window
1421 // could be closed before the JS finishes executing. So instead, post a
1422 // message back to the message loop, which won't run until the JS is
1423 // complete, and then the Close message can be sent.
skyostiled8969c2015-07-20 16:57:081424 base::ThreadTaskRunnerHandle::Get()->PostTask(
[email protected]32876ae2011-11-15 22:25:211425 FROM_HERE, base::Bind(&RenderWidget::DoDeferredClose, this));
initial.commit09911bf2008-07-26 23:55:291426}
1427
[email protected]9017d7852013-11-21 17:47:351428void RenderWidget::QueueSyntheticGesture(
dchengcedca5612016-04-09 01:40:151429 std::unique_ptr<SyntheticGestureParams> gesture_params,
[email protected]9017d7852013-11-21 17:47:351430 const SyntheticGestureCompletionCallback& callback) {
1431 DCHECK(!callback.is_null());
1432
1433 pending_synthetic_gesture_callbacks_.push(callback);
1434
1435 SyntheticGesturePacket gesture_packet;
dcheng07945f632015-12-26 07:59:321436 gesture_packet.set_gesture_params(std::move(gesture_params));
[email protected]9017d7852013-11-21 17:47:351437
1438 Send(new InputHostMsg_QueueSyntheticGesture(routing_id_, gesture_packet));
1439}
1440
initial.commit09911bf2008-07-26 23:55:291441void RenderWidget::Close() {
[email protected]404630b2014-07-03 19:33:031442 screen_metrics_emulator_.reset();
ennef3c58142014-12-09 21:44:381443 WillCloseLayerTreeView();
1444 compositor_.reset();
lfg8ff33912016-09-13 20:59:211445 if (webwidget_internal_) {
1446 webwidget_internal_->close();
1447 webwidget_internal_ = nullptr;
initial.commit09911bf2008-07-26 23:55:291448 }
1449}
1450
bokan841fdc72016-10-06 00:16:351451void RenderWidget::ScreenRectToEmulatedIfNeeded(WebRect* window_rect) const {
1452 DCHECK(window_rect);
1453 float scale = popup_origin_scale_for_emulation_;
1454 if (!scale)
1455 return;
1456 window_rect->x =
1457 popup_view_origin_for_emulation_.x() +
1458 (window_rect->x - popup_screen_origin_for_emulation_.x()) / scale;
1459 window_rect->y =
1460 popup_view_origin_for_emulation_.y() +
1461 (window_rect->y - popup_screen_origin_for_emulation_.y()) / scale;
1462}
1463
1464void RenderWidget::EmulatedToScreenRectIfNeeded(WebRect* window_rect) const {
1465 DCHECK(window_rect);
1466 float scale = popup_origin_scale_for_emulation_;
1467 if (!scale)
1468 return;
1469 window_rect->x =
1470 popup_screen_origin_for_emulation_.x() +
1471 (window_rect->x - popup_view_origin_for_emulation_.x()) * scale;
1472 window_rect->y =
1473 popup_screen_origin_for_emulation_.y() +
1474 (window_rect->y - popup_view_origin_for_emulation_.y()) * scale;
1475}
1476
[email protected]4873c7d2009-07-16 06:36:281477WebRect RenderWidget::windowRect() {
bokan841fdc72016-10-06 00:16:351478 WebRect rect;
bokan6b08cd22016-10-05 00:55:211479 if (pending_window_rect_count_) {
1480 // NOTE(mbelshe): If there is a pending_window_rect_, then getting
1481 // the RootWindowRect is probably going to return wrong results since the
1482 // browser may not have processed the Move yet. There isn't really anything
1483 // good to do in this case, and it shouldn't happen - since this size is
1484 // only really needed for windowToScreen, which is only used for Popups.
bokan841fdc72016-10-06 00:16:351485 rect = pending_window_rect_;
1486 } else {
1487 rect = window_screen_rect_;
bokan6b08cd22016-10-05 00:55:211488 }
[email protected]2533ce12009-05-09 00:02:241489
bokan841fdc72016-10-06 00:16:351490 ScreenRectToEmulatedIfNeeded(&rect);
1491 return rect;
bokan6b08cd22016-10-05 00:55:211492}
1493
1494WebRect RenderWidget::viewRect() {
bokan841fdc72016-10-06 00:16:351495 WebRect rect = view_screen_rect_;
1496 ScreenRectToEmulatedIfNeeded(&rect);
1497 return rect;
initial.commit09911bf2008-07-26 23:55:291498}
1499
[email protected]180ef242013-11-07 06:50:461500void RenderWidget::setToolTipText(const blink::WebString& text,
[email protected]8a9d6ca32011-06-06 20:11:301501 WebTextDirection hint) {
kinukoa4293022017-01-27 06:43:251502 Send(new ViewHostMsg_SetTooltipText(routing_id_, text.utf16(), hint));
[email protected]8a9d6ca32011-06-06 20:11:301503}
1504
oshima33ec97cd2015-12-14 19:40:241505void RenderWidget::setWindowRect(const WebRect& rect_in_screen) {
1506 WebRect window_rect = rect_in_screen;
bokan841fdc72016-10-06 00:16:351507 EmulatedToScreenRectIfNeeded(&window_rect);
[email protected]b2e4c70132013-10-03 02:07:511508
[email protected]5b45ad42013-10-25 00:42:041509 if (!resizing_mode_selector_->is_synchronous_mode()) {
[email protected]ec951b9d2013-10-20 06:21:201510 if (did_show_) {
bokanc007c3a2015-02-03 07:15:561511 Send(new ViewHostMsg_RequestMove(routing_id_, window_rect));
1512 SetPendingWindowRect(window_rect);
[email protected]8be1c582013-03-06 00:55:031513 } else {
bokanc007c3a2015-02-03 07:15:561514 initial_rect_ = window_rect;
[email protected]8be1c582013-03-06 00:55:031515 }
initial.commit09911bf2008-07-26 23:55:291516 } else {
bokanc007c3a2015-02-03 07:15:561517 SetWindowRectSynchronously(window_rect);
initial.commit09911bf2008-07-26 23:55:291518 }
1519}
1520
[email protected]2533ce12009-05-09 00:02:241521void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
1522 pending_window_rect_ = rect;
1523 pending_window_rect_count_++;
[email protected]2533ce12009-05-09 00:02:241524
bokan6b08cd22016-10-05 00:55:211525 // Popups don't get size updates back from the browser so just store the set
1526 // values.
1527 if (popup_type_ != blink::WebPopupTypeNone) {
1528 window_screen_rect_ = rect;
1529 view_screen_rect_ = rect;
[email protected]2533ce12009-05-09 00:02:241530 }
[email protected]d4547452008-08-28 18:36:371531}
1532
[email protected]fa7b1dc2010-06-23 17:53:041533void RenderWidget::OnImeSetComposition(
[email protected]fcf75d42013-12-03 20:11:261534 const base::string16& text,
[email protected]fa7b1dc2010-06-23 17:53:041535 const std::vector<WebCompositionUnderline>& underlines,
chongz7eb752802016-01-27 21:28:071536 const gfx::Range& replacement_range,
[email protected]fa7b1dc2010-06-23 17:53:041537 int selection_start, int selection_end) {
ekaramad5aff1942017-01-06 01:26:351538 if (!ShouldHandleImeEvents())
1539 return;
1540
brettw4b461082016-11-19 18:55:161541#if BUILDFLAG(ENABLE_PLUGINS)
ekaramad2a46d632016-07-19 13:33:091542 if (focused_pepper_plugin_) {
1543 focused_pepper_plugin_->render_frame()->OnImeSetComposition(
1544 text, underlines, selection_start, selection_end);
1545 return;
1546 }
1547#endif
1548 if (replacement_range.IsValid()) {
lfg8ff33912016-09-13 20:59:211549 GetWebWidget()->applyReplacementRange(
dglazkov0d680e32016-09-02 21:34:031550 WebRange(replacement_range.start(), replacement_range.length()));
ekaramad2a46d632016-07-19 13:33:091551 }
1552
changwan38c3eb612016-12-09 01:45:561553 if (!GetWebWidget())
[email protected]4873c7d2009-07-16 06:36:281554 return;
[email protected]66fca5bc2013-05-23 06:58:291555 ImeEventGuard guard(this);
ekaramad2daaf672016-11-10 20:29:011556 blink::WebInputMethodController* controller = GetInputMethodController();
ekaramad2daaf672016-11-10 20:29:011557 if (!controller ||
1558 !controller->setComposition(
kinukoa4293022017-01-27 06:43:251559 WebString::fromUTF16(text),
1560 WebVector<WebCompositionUnderline>(underlines), selection_start,
lfg8ff33912016-09-13 20:59:211561 selection_end)) {
[email protected]fa7b1dc2010-06-23 17:53:041562 // If we failed to set the composition text, then we need to let the browser
1563 // process to cancel the input method's ongoing composition session, to make
1564 // sure we are in a consistent state.
[email protected]a2214eb2014-06-23 18:31:221565 Send(new InputHostMsg_ImeCancelComposition(routing_id()));
[email protected]7f00efa2010-04-15 05:01:261566 }
nonafa291792016-08-10 02:36:181567 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]fa7b1dc2010-06-23 17:53:041568}
1569
rlanday7efe2302017-01-11 00:14:281570void RenderWidget::OnImeCommitText(
1571 const base::string16& text,
1572 const std::vector<WebCompositionUnderline>& underlines,
1573 const gfx::Range& replacement_range,
1574 int relative_cursor_pos) {
ekaramad5aff1942017-01-06 01:26:351575 if (!ShouldHandleImeEvents())
1576 return;
1577
brettw4b461082016-11-19 18:55:161578#if BUILDFLAG(ENABLE_PLUGINS)
ekaramad2a46d632016-07-19 13:33:091579 if (focused_pepper_plugin_) {
aelias87b8f7c2016-09-14 03:19:291580 focused_pepper_plugin_->render_frame()->OnImeCommitText(
1581 text, replacement_range, relative_cursor_pos);
ekaramad2a46d632016-07-19 13:33:091582 return;
1583 }
1584#endif
1585 if (replacement_range.IsValid()) {
lfg8ff33912016-09-13 20:59:211586 GetWebWidget()->applyReplacementRange(
dglazkov0d680e32016-09-02 21:34:031587 WebRange(replacement_range.start(), replacement_range.length()));
ekaramad2a46d632016-07-19 13:33:091588 }
1589
changwan38c3eb612016-12-09 01:45:561590 if (!GetWebWidget())
[email protected]d0be63772011-12-20 23:18:041591 return;
[email protected]66fca5bc2013-05-23 06:58:291592 ImeEventGuard guard(this);
fsamuele8326c742016-01-12 00:49:391593 input_handler_->set_handling_input_event(true);
ekaramad2daaf672016-11-10 20:29:011594 if (auto* controller = GetInputMethodController())
kinukoa4293022017-01-27 06:43:251595 controller->commitText(WebString::fromUTF16(text),
1596 WebVector<WebCompositionUnderline>(underlines),
rlanday7efe2302017-01-11 00:14:281597 relative_cursor_pos);
aelias87b8f7c2016-09-14 03:19:291598 input_handler_->set_handling_input_event(false);
1599 UpdateCompositionInfo(false /* not an immediate request */);
1600}
1601
1602void RenderWidget::OnImeFinishComposingText(bool keep_selection) {
ekaramad5aff1942017-01-06 01:26:351603 if (!ShouldHandleImeEvents())
1604 return;
1605
brettw4b461082016-11-19 18:55:161606#if BUILDFLAG(ENABLE_PLUGINS)
aelias87b8f7c2016-09-14 03:19:291607 if (focused_pepper_plugin_) {
1608 focused_pepper_plugin_->render_frame()->OnImeFinishComposingText(
1609 keep_selection);
1610 return;
1611 }
1612#endif
1613
changwan38c3eb612016-12-09 01:45:561614 if (!GetWebWidget())
aelias87b8f7c2016-09-14 03:19:291615 return;
1616 ImeEventGuard guard(this);
1617 input_handler_->set_handling_input_event(true);
ekaramad2daaf672016-11-10 20:29:011618 if (auto* controller = GetInputMethodController()) {
1619 controller->finishComposingText(
1620 keep_selection ? WebInputMethodController::KeepSelection
1621 : WebInputMethodController::DoNotKeepSelection);
1622 }
fsamuele8326c742016-01-12 00:49:391623 input_handler_->set_handling_input_event(false);
nonafa291792016-08-10 02:36:181624 UpdateCompositionInfo(false /* not an immediate request */);
initial.commit09911bf2008-07-26 23:55:291625}
1626
oshimad5279032015-12-16 18:22:331627void RenderWidget::OnDeviceScaleFactorChanged() {
1628 if (!compositor_)
1629 return;
oshimad5279032015-12-16 18:22:331630 if (IsUseZoomForDSFEnabled())
oshima50872a72016-03-04 13:26:181631 compositor_->SetPaintedDeviceScaleFactor(GetOriginalDeviceScaleFactor());
oshimad5279032015-12-16 18:22:331632 else
1633 compositor_->setDeviceScaleFactor(device_scale_factor_);
1634}
1635
[email protected]0bc1f572013-04-17 01:46:311636void RenderWidget::OnRepaint(gfx::Size size_to_paint) {
[email protected]ec7dc112008-08-06 05:30:121637 // During shutdown we can just ignore this message.
lfg8ff33912016-09-13 20:59:211638 if (!GetWebWidget())
[email protected]ec7dc112008-08-06 05:30:121639 return;
1640
[email protected]0bc1f572013-04-17 01:46:311641 // Even if the browser provides an empty damage rect, it's still expecting to
1642 // receive a repaint ack so just damage the entire widget bounds.
1643 if (size_to_paint.IsEmpty()) {
1644 size_to_paint = size_;
1645 }
1646
[email protected]ec7dc112008-08-06 05:30:121647 set_next_paint_is_repaint_ack();
[email protected]aca33f4f2014-05-17 17:08:051648 if (compositor_)
[email protected]0bc1f572013-04-17 01:46:311649 compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint));
[email protected]ec7dc112008-08-06 05:30:121650}
1651
[email protected]79fa22e2013-08-23 15:18:121652void RenderWidget::OnSyntheticGestureCompleted() {
[email protected]9017d7852013-11-21 17:47:351653 DCHECK(!pending_synthetic_gesture_callbacks_.empty());
1654
1655 pending_synthetic_gesture_callbacks_.front().Run();
1656 pending_synthetic_gesture_callbacks_.pop();
[email protected]0e241b4b2012-08-18 09:06:271657}
1658
[email protected]4873c7d2009-07-16 06:36:281659void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
lfg8ff33912016-09-13 20:59:211660 if (!GetWebWidget())
[email protected]07f953332009-03-25 04:31:111661 return;
lfg8ff33912016-09-13 20:59:211662 GetWebWidget()->setTextDirection(direction);
[email protected]07f953332009-03-25 04:31:111663}
1664
[email protected]80ad8622012-11-07 16:33:031665void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
1666 const gfx::Rect& window_screen_rect) {
[email protected]b2e4c70132013-10-03 02:07:511667 if (screen_metrics_emulator_) {
mfomitchev2600fd7c2016-02-17 20:53:391668 screen_metrics_emulator_->OnUpdateScreenRects(view_screen_rect,
1669 window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:511670 } else {
mfomitchev2600fd7c2016-02-17 20:53:391671 SetScreenRects(view_screen_rect, window_screen_rect);
[email protected]b2e4c70132013-10-03 02:07:511672 }
[email protected]80ad8622012-11-07 16:33:031673 Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
1674}
1675
lfgdb5c4ed2016-03-04 23:09:071676void RenderWidget::OnUpdateWindowScreenRect(
1677 const gfx::Rect& window_screen_rect) {
bokan6b08cd22016-10-05 00:55:211678 if (screen_metrics_emulator_)
lfgdb5c4ed2016-03-04 23:09:071679 screen_metrics_emulator_->OnUpdateWindowScreenRect(window_screen_rect);
bokan6b08cd22016-10-05 00:55:211680 else
lfgdb5c4ed2016-03-04 23:09:071681 window_screen_rect_ = window_screen_rect;
lfgdb5c4ed2016-03-04 23:09:071682}
1683
kenrbea731792017-01-13 15:10:481684void RenderWidget::OnSetViewportIntersection(
1685 const gfx::Rect& viewport_intersection) {
1686 if (GetWebWidget() && GetWebWidget()->isWebFrameWidget()) {
1687 DCHECK(popup_type_ == WebPopupType::WebPopupTypeNone);
1688 static_cast<WebFrameWidget*>(GetWebWidget())
1689 ->setRemoteViewportIntersection(viewport_intersection);
1690 }
1691}
1692
paulmeyer90f6c31d2016-11-12 00:17:591693void RenderWidget::OnDragTargetDragEnter(
1694 const std::vector<DropData::Metadata>& drop_meta_data,
1695 const gfx::Point& client_point,
1696 const gfx::Point& screen_point,
1697 WebDragOperationsMask ops,
1698 int key_modifiers) {
1699 if (!GetWebWidget())
1700 return;
1701
1702 DCHECK(GetWebWidget()->isWebFrameWidget());
1703 WebDragOperation operation = static_cast<WebFrameWidget*>(GetWebWidget())->
1704 dragTargetDragEnter(DropMetaDataToWebDragData(drop_meta_data),
1705 client_point, screen_point, ops, key_modifiers);
1706
1707 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
1708}
1709
1710void RenderWidget::OnDragTargetDragOver(const gfx::Point& client_point,
1711 const gfx::Point& screen_point,
1712 WebDragOperationsMask ops,
1713 int key_modifiers) {
1714 if (!GetWebWidget())
1715 return;
1716
1717 DCHECK(GetWebWidget()->isWebFrameWidget());
1718 WebDragOperation operation =
1719 static_cast<WebFrameWidget*>(GetWebWidget())->dragTargetDragOver(
1720 ConvertWindowPointToViewport(client_point),
1721 screen_point, ops, key_modifiers);
1722
1723 Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation));
1724}
1725
1726void RenderWidget::OnDragTargetDragLeave() {
1727 if (!GetWebWidget())
1728 return;
1729 DCHECK(GetWebWidget()->isWebFrameWidget());
1730 static_cast<WebFrameWidget*>(GetWebWidget())->dragTargetDragLeave();
1731}
1732
1733void RenderWidget::OnDragTargetDrop(const DropData& drop_data,
1734 const gfx::Point& client_point,
1735 const gfx::Point& screen_point,
1736 int key_modifiers) {
1737 if (!GetWebWidget())
1738 return;
1739
1740 DCHECK(GetWebWidget()->isWebFrameWidget());
1741 static_cast<WebFrameWidget*>(GetWebWidget())->dragTargetDrop(
1742 DropDataToWebDragData(drop_data),
1743 ConvertWindowPointToViewport(client_point),
1744 screen_point, key_modifiers);
1745}
1746
paulmeyer8fc8ea92016-11-15 05:12:211747void RenderWidget::OnDragSourceEnded(const gfx::Point& client_point,
1748 const gfx::Point& screen_point,
1749 WebDragOperation op) {
1750 if (!GetWebWidget())
1751 return;
1752
1753 static_cast<WebFrameWidget*>(GetWebWidget())->dragSourceEndedAt(
1754 ConvertWindowPointToViewport(client_point), screen_point, op);
1755}
1756
1757void RenderWidget::OnDragSourceSystemDragEnded() {
1758 if (!GetWebWidget())
1759 return;
1760
1761 static_cast<WebFrameWidget*>(GetWebWidget())->dragSourceSystemDragEnded();
1762}
1763
lukasza86f05da2017-01-24 21:23:261764void RenderWidget::showVirtualKeyboardOnElementFocus() {
changwan75e3b2072017-01-16 02:55:001765 ShowVirtualKeyboard();
boliu7b2be2f2016-11-04 04:58:311766
1767// TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
1768// virtual keyboard.
1769#if !defined(OS_ANDROID)
1770 FocusChangeComplete();
1771#endif
[email protected]0d1ebed12013-08-05 22:01:131772}
1773
fsamuel72464894f2015-12-15 06:59:311774ui::TextInputType RenderWidget::GetTextInputType() {
brettw4b461082016-11-19 18:55:161775#if BUILDFLAG(ENABLE_PLUGINS)
ekaramad2a46d632016-07-19 13:33:091776 if (focused_pepper_plugin_)
1777 return focused_pepper_plugin_->text_input_type();
1778#endif
ekaramad5aff1942017-01-06 01:26:351779 if (auto* controller = GetInputMethodController())
1780 return ConvertWebTextInputType(controller->textInputType());
fsamuel72464894f2015-12-15 06:59:311781 return ui::TEXT_INPUT_TYPE_NONE;
1782}
1783
nonafa291792016-08-10 02:36:181784void RenderWidget::UpdateCompositionInfo(bool immediate_request) {
1785 if (!monitor_composition_info_ && !immediate_request)
1786 return; // Do not calculate composition info if not requested.
nonadac0c7a2016-08-01 02:30:591787
nonafa291792016-08-10 02:36:181788 TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo");
1789 gfx::Range range;
1790 std::vector<gfx::Rect> character_bounds;
1791
1792 if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE) {
1793 // Composition information is only available on editable node.
1794 range = gfx::Range::InvalidRange();
1795 } else {
1796 GetCompositionRange(&range);
1797 GetCompositionCharacterBounds(&character_bounds);
1798 }
1799
1800 if (!immediate_request &&
1801 !ShouldUpdateCompositionInfo(range, character_bounds)) {
fsamuel72464894f2015-12-15 06:59:311802 return;
nonafa291792016-08-10 02:36:181803 }
fsamuel72464894f2015-12-15 06:59:311804 composition_character_bounds_ = character_bounds;
1805 composition_range_ = range;
1806 Send(new InputHostMsg_ImeCompositionRangeChanged(
1807 routing_id(), composition_range_, composition_character_bounds_));
fsamuel72464894f2015-12-15 06:59:311808}
1809
oshimaf866dab2015-12-05 00:41:541810void RenderWidget::convertViewportToWindow(blink::WebRect* rect) {
1811 if (IsUseZoomForDSFEnabled()) {
lfg15b235a32016-08-25 17:45:461812 float reverse = 1 / GetOriginalDeviceScaleFactor();
oshimad5279032015-12-16 18:22:331813 // TODO(oshima): We may need to allow pixel precision here as the the
oshimaf866dab2015-12-05 00:41:541814 // anchor element can be placed at half pixel.
lfg15b235a32016-08-25 17:45:461815 gfx::Rect window_rect =
1816 gfx::ScaleToEnclosedRect(gfx::Rect(*rect), reverse);
1817 rect->x = window_rect.x();
1818 rect->y = window_rect.y();
1819 rect->width = window_rect.width();
1820 rect->height = window_rect.height();
oshimaf866dab2015-12-05 00:41:541821 }
1822}
1823
oshimaa6985b62016-01-27 08:58:301824void RenderWidget::convertWindowToViewport(blink::WebFloatRect* rect) {
1825 if (IsUseZoomForDSFEnabled()) {
oshima50872a72016-03-04 13:26:181826 rect->x *= GetOriginalDeviceScaleFactor();
1827 rect->y *= GetOriginalDeviceScaleFactor();
1828 rect->width *= GetOriginalDeviceScaleFactor();
1829 rect->height *= GetOriginalDeviceScaleFactor();
oshimaa6985b62016-01-27 08:58:301830 }
1831}
1832
[email protected]adb362312014-06-28 06:04:241833#if defined(OS_ANDROID)
changwan8c342742016-02-26 00:53:391834void RenderWidget::OnRequestTextInputStateUpdate() {
1835 DCHECK(!ime_event_guard_);
1836 UpdateSelectionBounds();
changwan75e3b2072017-01-16 02:55:001837 UpdateTextInputStateInternal(false, true /* reply_to_request */);
changwan8c342742016-02-26 00:53:391838}
[email protected]105dffb42013-02-20 03:46:211839#endif
1840
nonafa291792016-08-10 02:36:181841void RenderWidget::OnRequestCompositionUpdate(bool immediate_request,
1842 bool monitor_request) {
1843 monitor_composition_info_ = monitor_request;
1844 if (!immediate_request)
1845 return;
1846 UpdateCompositionInfo(true /* immediate request */);
1847}
1848
wjmaclean8a795f32016-08-11 23:49:581849void RenderWidget::OnSetDeviceScaleFactor(float device_scale_factor) {
[email protected]468ac582012-11-20 00:53:191850 if (device_scale_factor_ == device_scale_factor)
1851 return;
1852
1853 device_scale_factor_ = device_scale_factor;
oshimad5279032015-12-16 18:22:331854
1855 OnDeviceScaleFactorChanged();
jdduke491a3f0c2015-06-15 23:30:261856 ScheduleComposite();
wjmaclean8a795f32016-08-11 23:49:581857
1858 physical_backing_size_ = gfx::ScaleToCeiledSize(size_, device_scale_factor_);
[email protected]468ac582012-11-20 00:53:191859}
1860
[email protected]fcdc5642014-05-09 14:32:241861void RenderWidget::OnOrientationChange() {
1862}
1863
[email protected]bee16aab2009-08-26 15:55:031864void RenderWidget::SetHidden(bool hidden) {
1865 if (is_hidden_ == hidden)
1866 return;
1867
jdduke8fac9d102014-12-20 02:40:131868 // The status has changed. Tell the RenderThread about it and ensure
1869 // throttled acks are released in case frame production ceases.
[email protected]bee16aab2009-08-26 15:55:031870 is_hidden_ = hidden;
jdduke8fac9d102014-12-20 02:40:131871
[email protected]bee16aab2009-08-26 15:55:031872 if (is_hidden_)
[email protected]b2db9272014-01-10 17:42:001873 RenderThreadImpl::current()->WidgetHidden();
[email protected]bee16aab2009-08-26 15:55:031874 else
[email protected]b2db9272014-01-10 17:42:001875 RenderThreadImpl::current()->WidgetRestored();
alexclarke7fa93942015-10-21 15:37:111876
1877 if (render_widget_scheduling_state_)
1878 render_widget_scheduling_state_->SetHidden(hidden);
[email protected]bee16aab2009-08-26 15:55:031879}
1880
[email protected]2b624c562011-10-27 22:58:261881void RenderWidget::DidToggleFullscreen() {
lfg8ff33912016-09-13 20:59:211882 if (!GetWebWidget())
[email protected]2b624c562011-10-27 22:58:261883 return;
1884
mikhail.pozdnyakovf2c902a2015-04-14 08:09:121885 if (is_fullscreen_granted_) {
lfg8ff33912016-09-13 20:59:211886 GetWebWidget()->didEnterFullscreen();
[email protected]2b624c562011-10-27 22:58:261887 } else {
lfg8ff33912016-09-13 20:59:211888 GetWebWidget()->didExitFullscreen();
[email protected]2b624c562011-10-27 22:58:261889 }
[email protected]2b624c562011-10-27 22:58:261890}
1891
[email protected]674741932009-02-04 23:44:461892bool RenderWidget::next_paint_is_resize_ack() const {
[email protected]53d3f302009-12-21 04:42:051893 return ViewHostMsg_UpdateRect_Flags::is_resize_ack(next_paint_flags_);
[email protected]674741932009-02-04 23:44:461894}
1895
[email protected]674741932009-02-04 23:44:461896void RenderWidget::set_next_paint_is_resize_ack() {
[email protected]53d3f302009-12-21 04:42:051897 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
[email protected]674741932009-02-04 23:44:461898}
1899
[email protected]674741932009-02-04 23:44:461900void RenderWidget::set_next_paint_is_repaint_ack() {
[email protected]53d3f302009-12-21 04:42:051901 next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK;
[email protected]674741932009-02-04 23:44:461902}
1903
changwanf2a707b2015-10-30 08:22:161904void RenderWidget::OnImeEventGuardStart(ImeEventGuard* guard) {
1905 if (!ime_event_guard_)
1906 ime_event_guard_ = guard;
[email protected]66fca5bc2013-05-23 06:58:291907}
1908
changwanf2a707b2015-10-30 08:22:161909void RenderWidget::OnImeEventGuardFinish(ImeEventGuard* guard) {
1910 if (ime_event_guard_ != guard) {
changwan75e3b2072017-01-16 02:55:001911 DCHECK(!ime_event_guard_->reply_to_request());
changwanf2a707b2015-10-30 08:22:161912 return;
1913 }
1914 ime_event_guard_ = nullptr;
1915
[email protected]66fca5bc2013-05-23 06:58:291916 // While handling an ime event, text input state and selection bounds updates
1917 // are ignored. These must explicitly be updated once finished handling the
1918 // ime event.
1919 UpdateSelectionBounds();
[email protected]cb9e2632013-06-18 11:26:471920#if defined(OS_ANDROID)
changwan75e3b2072017-01-16 02:55:001921 if (guard->show_virtual_keyboard())
1922 ShowVirtualKeyboard();
1923 else
1924 UpdateTextInputState();
[email protected]cb9e2632013-06-18 11:26:471925#endif
[email protected]66fca5bc2013-05-23 06:58:291926}
1927
[email protected]7c8873e2013-02-05 08:03:011928void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
brettw4b461082016-11-19 18:55:161929#if BUILDFLAG(ENABLE_PLUGINS)
ekaramad2a46d632016-07-19 13:33:091930 if (focused_pepper_plugin_) {
1931 // TODO(kinaba) http://crbug.com/101101
1932 // Current Pepper IME API does not handle selection bounds. So we simply
1933 // use the caret position as an empty range for now. It will be updated
1934 // after Pepper API equips features related to surrounding text retrieval.
1935 blink::WebRect caret(focused_pepper_plugin_->GetCaretBounds());
1936 convertViewportToWindow(&caret);
1937 *focus = caret;
1938 *anchor = caret;
1939 return;
1940 }
1941#endif
[email protected]7c8873e2013-02-05 08:03:011942 WebRect focus_webrect;
1943 WebRect anchor_webrect;
lfg8ff33912016-09-13 20:59:211944 GetWebWidget()->selectionBounds(focus_webrect, anchor_webrect);
oshima33ec97cd2015-12-14 19:40:241945 convertViewportToWindow(&focus_webrect);
1946 convertViewportToWindow(&anchor_webrect);
1947 *focus = focus_webrect;
1948 *anchor = anchor_webrect;
[email protected]73bf95812011-10-12 11:38:321949}
1950
[email protected]e99ef6f2011-10-16 01:13:001951void RenderWidget::UpdateSelectionBounds() {
jdduke1aebad8e2015-07-22 23:25:081952 TRACE_EVENT0("renderer", "RenderWidget::UpdateSelectionBounds");
lfg8ff33912016-09-13 20:59:211953 if (!GetWebWidget())
[email protected]e99ef6f2011-10-16 01:13:001954 return;
changwanf2a707b2015-10-30 08:22:161955 if (ime_event_guard_)
[email protected]66fca5bc2013-05-23 06:58:291956 return;
[email protected]e99ef6f2011-10-16 01:13:001957
mohsenb0eeba72015-08-09 06:20:081958#if defined(USE_AURA)
1959 // TODO(mohsen): For now, always send explicit selection IPC notifications for
1960 // Aura beucause composited selection updates are not working for webview tags
1961 // which regresses IME inside webview. Remove this when composited selection
1962 // updates are fixed for webviews. See, http://crbug.com/510568.
1963 bool send_ipc = true;
1964#else
jddukeacf809e2014-09-23 20:38:381965 // With composited selection updates, the selection bounds will be reported
1966 // directly by the compositor, in which case explicit IPC selection
1967 // notifications should be suppressed.
mohsenb0eeba72015-08-09 06:20:081968 bool send_ipc =
1969 !blink::WebRuntimeFeatures::isCompositedSelectionUpdateEnabled();
1970#endif
1971 if (send_ipc) {
jddukeacf809e2014-09-23 20:38:381972 ViewHostMsg_SelectionBounds_Params params;
1973 GetSelectionBounds(&params.anchor_rect, &params.focus_rect);
1974 if (selection_anchor_rect_ != params.anchor_rect ||
1975 selection_focus_rect_ != params.focus_rect) {
1976 selection_anchor_rect_ = params.anchor_rect;
1977 selection_focus_rect_ = params.focus_rect;
lfg8ff33912016-09-13 20:59:211978 GetWebWidget()->selectionTextDirection(params.focus_dir,
1979 params.anchor_dir);
1980 params.is_anchor_first = GetWebWidget()->isSelectionAnchorFirst();
jddukeacf809e2014-09-23 20:38:381981 Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params));
1982 }
[email protected]58b48a0d2012-06-13 07:01:351983 }
jddukeacf809e2014-09-23 20:38:381984
nonafa291792016-08-10 02:36:181985 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]e99ef6f2011-10-16 01:13:001986}
1987
lfgb00fcad2016-07-14 14:16:331988void RenderWidget::DidAutoResize(const gfx::Size& new_size) {
1989 WebRect new_size_in_window(0, 0, new_size.width(), new_size.height());
1990 convertViewportToWindow(&new_size_in_window);
1991 if (size_.width() != new_size_in_window.width ||
1992 size_.height() != new_size_in_window.height) {
1993 size_ = gfx::Size(new_size_in_window.width, new_size_in_window.height);
1994
1995 if (resizing_mode_selector_->is_synchronous_mode()) {
bokan6b08cd22016-10-05 00:55:211996 gfx::Rect new_pos(windowRect().x, windowRect().y,
lfg0140a452016-07-19 19:15:051997 size_.width(), size_.height());
lfgb00fcad2016-07-14 14:16:331998 view_screen_rect_ = new_pos;
1999 window_screen_rect_ = new_pos;
2000 }
2001
2002 AutoResizeCompositor();
2003
2004 if (!resizing_mode_selector_->is_synchronous_mode())
2005 need_update_rect_for_auto_resize_ = true;
2006 }
2007}
2008
[email protected]58b48a0d2012-06-13 07:01:352009void RenderWidget::GetCompositionCharacterBounds(
2010 std::vector<gfx::Rect>* bounds) {
2011 DCHECK(bounds);
2012 bounds->clear();
ekaramad2a46d632016-07-19 13:33:092013
brettw4b461082016-11-19 18:55:162014#if BUILDFLAG(ENABLE_PLUGINS)
ekaramad2a46d632016-07-19 13:33:092015 if (focused_pepper_plugin_)
2016 return;
2017#endif
2018
lfg8ff33912016-09-13 20:59:212019 if (!GetWebWidget())
ekaramad2a46d632016-07-19 13:33:092020 return;
2021 blink::WebVector<blink::WebRect> bounds_from_blink;
lfg8ff33912016-09-13 20:59:212022 if (!GetWebWidget()->getCompositionCharacterBounds(bounds_from_blink))
ekaramad2a46d632016-07-19 13:33:092023 return;
2024
2025 for (size_t i = 0; i < bounds_from_blink.size(); ++i) {
2026 convertViewportToWindow(&bounds_from_blink[i]);
2027 bounds->push_back(bounds_from_blink[i]);
2028 }
[email protected]58b48a0d2012-06-13 07:01:352029}
2030
[email protected]db4fc1e2013-09-06 20:01:512031void RenderWidget::GetCompositionRange(gfx::Range* range) {
brettw4b461082016-11-19 18:55:162032#if BUILDFLAG(ENABLE_PLUGINS)
ekaramad2a46d632016-07-19 13:33:092033 if (focused_pepper_plugin_)
2034 return;
2035#endif
lfg8ff33912016-09-13 20:59:212036 WebRange web_range = GetWebWidget()->compositionRange();
nona2363a3d2016-11-09 03:26:212037 if (web_range.isNull()) {
2038 *range = gfx::Range::InvalidRange();
2039 return;
[email protected]88dbe32f2013-06-20 23:31:362040 }
nona2363a3d2016-11-09 03:26:212041 range->set_start(web_range.startOffset());
2042 range->set_end(web_range.endOffset());
[email protected]88dbe32f2013-06-20 23:31:362043}
2044
[email protected]501ea13d2013-07-09 17:03:292045bool RenderWidget::ShouldUpdateCompositionInfo(
[email protected]db4fc1e2013-09-06 20:01:512046 const gfx::Range& range,
[email protected]501ea13d2013-07-09 17:03:292047 const std::vector<gfx::Rect>& bounds) {
changwan2418e1b2016-12-12 12:43:082048 if (!range.IsValid())
2049 return false;
[email protected]501ea13d2013-07-09 17:03:292050 if (composition_range_ != range)
2051 return true;
2052 if (bounds.size() != composition_character_bounds_.size())
2053 return true;
2054 for (size_t i = 0; i < bounds.size(); ++i) {
2055 if (bounds[i] != composition_character_bounds_[i])
2056 return true;
2057 }
2058 return false;
2059}
[email protected]501ea13d2013-07-09 17:03:292060
[email protected]ad26ef42011-06-17 07:59:452061bool RenderWidget::CanComposeInline() {
brettw4b461082016-11-19 18:55:162062#if BUILDFLAG(ENABLE_PLUGINS)
ekaramad2a46d632016-07-19 13:33:092063 if (focused_pepper_plugin_)
2064 return focused_pepper_plugin_->IsPluginAcceptingCompositionEvents();
2065#endif
[email protected]ad26ef42011-06-17 07:59:452066 return true;
[email protected]56ea1a62011-05-30 07:05:572067}
2068
ccameron2f451532016-09-07 21:49:272069blink::WebScreenInfo RenderWidget::screenInfo() {
2070 blink::WebScreenInfo web_screen_info;
2071 web_screen_info.deviceScaleFactor = screen_info_.device_scale_factor;
mlamouriafca06dd2017-01-27 23:35:182072 web_screen_info.iccProfile = screen_info_.icc_profile;
ccameron2f451532016-09-07 21:49:272073 web_screen_info.depth = screen_info_.depth;
2074 web_screen_info.depthPerComponent = screen_info_.depth_per_component;
2075 web_screen_info.isMonochrome = screen_info_.is_monochrome;
2076 web_screen_info.rect = blink::WebRect(screen_info_.rect);
2077 web_screen_info.availableRect = blink::WebRect(screen_info_.available_rect);
2078 switch (screen_info_.orientation_type) {
2079 case SCREEN_ORIENTATION_VALUES_PORTRAIT_PRIMARY:
2080 web_screen_info.orientationType =
2081 blink::WebScreenOrientationPortraitPrimary;
2082 break;
2083 case SCREEN_ORIENTATION_VALUES_PORTRAIT_SECONDARY:
2084 web_screen_info.orientationType =
2085 blink::WebScreenOrientationPortraitSecondary;
2086 break;
2087 case SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY:
2088 web_screen_info.orientationType =
2089 blink::WebScreenOrientationLandscapePrimary;
2090 break;
2091 case SCREEN_ORIENTATION_VALUES_LANDSCAPE_SECONDARY:
2092 web_screen_info.orientationType =
2093 blink::WebScreenOrientationLandscapeSecondary;
2094 break;
2095 default:
2096 web_screen_info.orientationType =
2097 blink::WebScreenOrientationUndefined;
2098 break;
2099 }
2100 web_screen_info.orientationAngle = screen_info_.orientation_angle;
2101 return web_screen_info;
[email protected]4873c7d2009-07-16 06:36:282102}
2103
[email protected]fa7b1dc2010-06-23 17:53:042104void RenderWidget::resetInputMethod() {
[email protected]0e45bd02013-07-12 20:20:022105 ImeEventGuard guard(this);
changwan2418e1b2016-12-12 12:43:082106 Send(new InputHostMsg_ImeCancelComposition(routing_id()));
[email protected]d4cff272011-05-02 15:46:012107
nonafa291792016-08-10 02:36:182108 UpdateCompositionInfo(false /* not an immediate request */);
[email protected]fa7b1dc2010-06-23 17:53:042109}
2110
donnda070f3c2015-01-16 19:54:112111#if defined(OS_ANDROID)
2112void RenderWidget::showUnhandledTapUIIfNeeded(
2113 const WebPoint& tapped_position,
2114 const WebNode& tapped_node,
2115 bool page_changed) {
fsamuele8326c742016-01-12 00:49:392116 DCHECK(input_handler_->handling_input_event());
donnda070f3c2015-01-16 19:54:112117 bool should_trigger = !page_changed && tapped_node.isTextNode() &&
donnd57e54f52015-02-26 19:03:372118 !tapped_node.isContentEditable() &&
2119 !tapped_node.isInsideFocusableElementOrARIAWidget();
donnda070f3c2015-01-16 19:54:112120 if (should_trigger) {
2121 Send(new ViewHostMsg_ShowUnhandledTapUIIfNeeded(routing_id_,
2122 tapped_position.x, tapped_position.y));
2123 }
2124}
2125#endif
2126
[email protected]c68c3e4e2013-01-24 00:36:562127void RenderWidget::didHandleGestureEvent(
2128 const WebGestureEvent& event,
2129 bool event_cancelled) {
[email protected]183e28d2014-01-20 18:18:022130#if defined(OS_ANDROID) || defined(USE_AURA)
[email protected]c68c3e4e2013-01-24 00:36:562131 if (event_cancelled)
2132 return;
dtapuska8c4dae12017-01-13 00:23:062133 if (event.type() == WebInputEvent::GestureTap) {
changwan75e3b2072017-01-16 02:55:002134 ShowVirtualKeyboard();
dtapuska8c4dae12017-01-13 00:23:062135 } else if (event.type() == WebInputEvent::GestureLongPress) {
lfg8ff33912016-09-13 20:59:212136 DCHECK(GetWebWidget());
ekaramad5aff1942017-01-06 01:26:352137 blink::WebInputMethodController* controller = GetInputMethodController();
2138 if (!controller || controller->textInputInfo().value.isEmpty())
changwan75e3b2072017-01-16 02:55:002139 UpdateTextInputState();
[email protected]07c70d22014-08-21 08:33:462140 else
changwan75e3b2072017-01-16 02:55:002141 ShowVirtualKeyboard();
[email protected]c68c3e4e2013-01-24 00:36:562142 }
ekaramada110f642016-12-21 19:47:282143// TODO(ananta): Piggyback off existing IPCs to communicate this information,
2144// crbug/420130.
2145#if defined(OS_WIN)
dtapuska8c4dae12017-01-13 00:23:062146 if (event.type() != blink::WebGestureEvent::GestureTap)
ekaramada110f642016-12-21 19:47:282147 return;
2148
2149 // TODO(estade): hit test the event against focused node to make sure
2150 // the tap actually hit the focused node.
ekaramad5aff1942017-01-06 01:26:352151 blink::WebInputMethodController* controller = GetInputMethodController();
2152 blink::WebTextInputType text_input_type =
2153 controller ? controller->textInputType() : blink::WebTextInputTypeNone;
ekaramada110f642016-12-21 19:47:282154
2155 Send(new ViewHostMsg_FocusedNodeTouched(
2156 routing_id_, text_input_type != blink::WebTextInputTypeNone));
2157#endif
[email protected]c68c3e4e2013-01-24 00:36:562158#endif
2159}
2160
sataya.m582c9ce2015-06-09 08:03:422161void RenderWidget::didOverscroll(
bokane53a10f2016-04-13 23:48:312162 const blink::WebFloatSize& overscrollDelta,
2163 const blink::WebFloatSize& accumulatedOverscroll,
sataya.m582c9ce2015-06-09 08:03:422164 const blink::WebFloatPoint& position,
2165 const blink::WebFloatSize& velocity) {
bokan731ec382016-04-07 03:16:482166#if defined(OS_MACOSX)
2167 // On OSX the user can disable the elastic overscroll effect. If that's the
2168 // case, don't forward the overscroll notification.
2169 DCHECK(compositor_deps());
2170 if (!compositor_deps()->IsElasticOverscrollEnabled())
2171 return;
2172#endif
bokane53a10f2016-04-13 23:48:312173 input_handler_->DidOverscrollFromBlink(overscrollDelta, accumulatedOverscroll,
fsamuele8326c742016-01-12 00:49:392174 position, velocity);
sataya.m582c9ce2015-06-09 08:03:422175}
2176
[email protected]7912e822014-04-16 02:37:032177void RenderWidget::StartCompositor() {
sievers71c62dd52015-10-07 01:44:392178 if (!is_hidden())
2179 compositor_->setVisible(true);
[email protected]7912e822014-04-16 02:37:032180}
2181
[email protected]24ed0432013-04-24 07:50:312182RenderWidgetCompositor* RenderWidget::compositor() const {
2183 return compositor_.get();
2184}
2185
fsamuel72464894f2015-12-15 06:59:312186void RenderWidget::SetHandlingInputEventForTesting(bool handling_input_event) {
fsamuele8326c742016-01-12 00:49:392187 input_handler_->set_handling_input_event(handling_input_event);
[email protected]67bfb83f2011-09-22 03:36:372188}
[email protected]c3d45532011-10-07 19:20:402189
[email protected]ce6689f2013-03-29 12:52:552190void RenderWidget::hasTouchEventHandlers(bool has_handlers) {
alexclarke7fa93942015-10-21 15:37:112191 if (render_widget_scheduling_state_)
2192 render_widget_scheduling_state_->SetHasTouchHandler(has_handlers);
[email protected]ce6689f2013-03-29 12:52:552193 Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
2194}
2195
[email protected]5d0bbdfa92013-12-10 00:35:512196void RenderWidget::setTouchAction(
2197 blink::WebTouchAction web_touch_action) {
[email protected]5d0bbdfa92013-12-10 00:35:512198 // Ignore setTouchAction calls that result from synthetic touch events (eg.
2199 // when blink is emulating touch with mouse).
fsamuele8326c742016-01-12 00:49:392200 if (input_handler_->handling_event_type() != WebInputEvent::TouchStart)
[email protected]5d0bbdfa92013-12-10 00:35:512201 return;
2202
[email protected]a18f67a2013-12-20 19:44:362203 content::TouchAction content_touch_action =
2204 static_cast<content::TouchAction>(web_touch_action);
[email protected]5d0bbdfa92013-12-10 00:35:512205 Send(new InputHostMsg_SetTouchAction(routing_id_, content_touch_action));
2206}
2207
[email protected]e3244ed2014-06-20 20:04:272208void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
2209 render_frame_proxies_.AddObserver(proxy);
[email protected]bffc8302014-01-23 20:52:162210}
2211
[email protected]e3244ed2014-06-20 20:04:272212void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
2213 render_frame_proxies_.RemoveObserver(proxy);
[email protected]bffc8302014-01-23 20:52:162214}
2215
[email protected]de3c5d82014-05-28 22:12:592216void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) {
2217 render_frames_.AddObserver(frame);
2218}
2219
2220void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) {
2221 render_frames_.RemoveObserver(frame);
2222}
2223
lfg43e08e62016-02-03 18:51:372224void RenderWidget::OnWaitNextFrameForTests(int routing_id) {
2225 QueueMessage(new ViewHostMsg_WaitForNextFrameForTests_ACK(routing_id),
2226 MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE);
2227}
2228
oshima50872a72016-03-04 13:26:182229float RenderWidget::GetOriginalDeviceScaleFactor() const {
2230 return
2231 screen_metrics_emulator_ ?
ccameron2f451532016-09-07 21:49:272232 screen_metrics_emulator_->original_screen_info().device_scale_factor :
oshima50872a72016-03-04 13:26:182233 device_scale_factor_;
2234}
2235
paulmeyer90f6c31d2016-11-12 00:17:592236gfx::Point RenderWidget::ConvertWindowPointToViewport(
2237 const gfx::Point& point) {
2238 blink::WebFloatRect point_in_viewport(point.x(), point.y(), 0, 0);
2239 convertWindowToViewport(&point_in_viewport);
2240 return gfx::Point(point_in_viewport.x, point_in_viewport.y);
2241}
2242
lfgbee1e0a2016-06-08 21:24:212243bool RenderWidget::requestPointerLock() {
2244 return mouse_lock_dispatcher_->LockMouse(webwidget_mouse_lock_target_.get());
2245}
2246
2247void RenderWidget::requestPointerUnlock() {
2248 mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
2249}
2250
2251bool RenderWidget::isPointerLocked() {
2252 return mouse_lock_dispatcher_->IsMouseLockedTo(
2253 webwidget_mouse_lock_target_.get());
2254}
2255
paulmeyer6ef5a792016-11-08 20:33:582256void RenderWidget::startDragging(blink::WebReferrerPolicy policy,
2257 const WebDragData& data,
2258 WebDragOperationsMask mask,
2259 const WebImage& image,
2260 const WebPoint& webImageOffset) {
2261 blink::WebRect offset_in_window(webImageOffset.x, webImageOffset.y, 0, 0);
2262 convertViewportToWindow(&offset_in_window);
2263 DropData drop_data(DropDataBuilder::Build(data));
2264 drop_data.referrer_policy = policy;
2265 gfx::Vector2d imageOffset(offset_in_window.x, offset_in_window.y);
paulmeyer90f6c31d2016-11-12 00:17:592266 Send(new DragHostMsg_StartDragging(routing_id(), drop_data, mask,
paulmeyer6ef5a792016-11-08 20:33:582267 image.getSkBitmap(), imageOffset,
2268 possible_drag_event_info_));
2269}
2270
lfg8ff33912016-09-13 20:59:212271blink::WebWidget* RenderWidget::GetWebWidget() const {
2272 return webwidget_internal_;
2273}
2274
ekaramad2daaf672016-11-10 20:29:012275blink::WebInputMethodController* RenderWidget::GetInputMethodController()
2276 const {
ekaramad5a9f52a2016-12-07 01:35:182277 if (!GetWebWidget()->isWebFrameWidget()) {
2278 // TODO(ekaramad): We should not get here in response to IME IPC or updates
2279 // when the RenderWidget is swapped out. We should top sending IPCs from the
2280 // browser side (https://crbug.com/669219).
2281 // If there is no WebFrameWidget, then there will be no
2282 // InputMethodControllers for a WebLocalFrame.
2283 return nullptr;
2284 }
ekaramad2daaf672016-11-10 20:29:012285 return static_cast<blink::WebFrameWidget*>(GetWebWidget())
2286 ->getActiveWebInputMethodController();
2287}
2288
[email protected]e9ff79c2012-10-19 21:31:262289} // namespace content