[email protected] | 60a5007 | 2012-01-11 02:05:35 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
license.bot | bf09a50 | 2008-08-24 00:55:55 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 4 | |
[email protected] | 2cff005 | 2011-03-18 16:51:44 | [diff] [blame] | 5 | #include "content/renderer/render_widget.h" |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 6 | |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 7 | #include <memory> |
dcheng | 07945f63 | 2015-12-26 07:59:32 | [diff] [blame] | 8 | #include <utility> |
| 9 | |
[email protected] | c27dd4f | 2014-05-22 18:05:19 | [diff] [blame] | 10 | #include "base/auto_reset.h" |
[email protected] | 32876ae | 2011-11-15 22:25:21 | [diff] [blame] | 11 | #include "base/bind.h" |
[email protected] | 4fb6684 | 2009-12-04 21:41:00 | [diff] [blame] | 12 | #include "base/command_line.h" |
changwan | 7ded375 | 2016-03-09 23:25:12 | [diff] [blame] | 13 | #include "base/feature_list.h" |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 14 | #include "base/logging.h" |
avi | 1023d01 | 2015-12-25 02:39:14 | [diff] [blame] | 15 | #include "base/macros.h" |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 16 | #include "base/memory/ptr_util.h" |
[email protected] | b256eca | 2013-07-11 10:57:40 | [diff] [blame] | 17 | #include "base/memory/singleton.h" |
[email protected] | aaf6889 | 2013-07-18 00:11:30 | [diff] [blame] | 18 | #include "base/message_loop/message_loop.h" |
asvitkine | 8d51e9d | 2016-09-02 23:55:43 | [diff] [blame] | 19 | #include "base/metrics/histogram_macros.h" |
[email protected] | aa4117f | 2011-12-09 22:19:21 | [diff] [blame] | 20 | #include "base/stl_util.h" |
[email protected] | 74ebfb1 | 2013-06-07 20:48:00 | [diff] [blame] | 21 | #include "base/strings/utf_string_conversions.h" |
[email protected] | 35b4f0c | 2014-06-26 16:55:27 | [diff] [blame] | 22 | #include "base/sys_info.h" |
fdoray | a19b770 | 2016-12-23 14:19:31 | [diff] [blame] | 23 | #include "base/threading/thread_task_runner_handle.h" |
primiano | 9e38d55 | 2015-01-28 04:18:01 | [diff] [blame] | 24 | #include "base/trace_event/trace_event.h" |
| 25 | #include "base/trace_event/trace_event_synthetic_delay.h" |
[email protected] | 661eb9d | 2009-02-03 02:11:48 | [diff] [blame] | 26 | #include "build/build_config.h" |
loyso | 6e6efc4 | 2017-01-21 02:23:03 | [diff] [blame] | 27 | #include "cc/animation/animation_host.h" |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 28 | #include "cc/output/compositor_frame_sink.h" |
jbroman | 6ccbc7d47 | 2016-07-27 04:45:41 | [diff] [blame] | 29 | #include "cc/output/copy_output_request.h" |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 30 | #include "cc/scheduler/begin_frame_source.h" |
loyso | 6e6efc4 | 2017-01-21 02:23:03 | [diff] [blame] | 31 | #include "cc/trees/layer_tree_host.h" |
oshima | 750cb434 | 2015-10-31 00:59:01 | [diff] [blame] | 32 | #include "content/common/content_switches_internal.h" |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 33 | #include "content/common/drag_event_source_info.h" |
| 34 | #include "content/common/drag_messages.h" |
[email protected] | 9017d785 | 2013-11-21 17:47:35 | [diff] [blame] | 35 | #include "content/common/input/synthetic_gesture_packet.h" |
[email protected] | c084330e0 | 2013-04-27 01:08:15 | [diff] [blame] | 36 | #include "content/common/input_messages.h" |
jcivelli | ae1560a | 2016-11-01 22:40:23 | [diff] [blame] | 37 | #include "content/common/render_message_filter.mojom.h" |
[email protected] | 992db4c | 2011-05-12 15:37:15 | [diff] [blame] | 38 | #include "content/common/swapped_out_messages.h" |
ekaramad | 9053e57b | 2016-04-26 20:00:38 | [diff] [blame] | 39 | #include "content/common/text_input_state.h" |
[email protected] | 778574e | 2011-03-21 22:03:50 | [diff] [blame] | 40 | #include "content/common/view_messages.h" |
mlamouri | afca06dd | 2017-01-27 23:35:18 | [diff] [blame] | 41 | #include "content/public/common/content_client.h" |
changwan | 7ded375 | 2016-03-09 23:25:12 | [diff] [blame] | 42 | #include "content/public/common/content_features.h" |
[email protected] | c08950d2 | 2011-10-13 22:20:29 | [diff] [blame] | 43 | #include "content/public/common/content_switches.h" |
[email protected] | a09d53ce | 2014-01-31 00:46:42 | [diff] [blame] | 44 | #include "content/public/common/context_menu_params.h" |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 45 | #include "content/public/common/drop_data.h" |
mlamouri | afca06dd | 2017-01-27 23:35:18 | [diff] [blame] | 46 | #include "content/public/renderer/content_renderer_client.h" |
[email protected] | 953bd006 | 2013-08-01 00:58:40 | [diff] [blame] | 47 | #include "content/renderer/cursor_utils.h" |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 48 | #include "content/renderer/devtools/render_widget_screen_metrics_emulator.h" |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 49 | #include "content/renderer/drop_data_builder.h" |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 50 | #include "content/renderer/external_popup_menu.h" |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 51 | #include "content/renderer/gpu/frame_swap_message_queue.h" |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 52 | #include "content/renderer/gpu/queue_message_swap_promise.h" |
[email protected] | ba91a79 | 2013-02-06 09:48:28 | [diff] [blame] | 53 | #include "content/renderer/gpu/render_widget_compositor.h" |
[email protected] | 66fca5bc | 2013-05-23 06:58:29 | [diff] [blame] | 54 | #include "content/renderer/ime_event_guard.h" |
[email protected] | 7a72d45 | 2013-12-13 10:01:13 | [diff] [blame] | 55 | #include "content/renderer/input/input_handler_manager.h" |
[email protected] | adab233 | 2013-07-25 18:04:32 | [diff] [blame] | 56 | #include "content/renderer/pepper/pepper_plugin_instance_impl.h" |
[email protected] | bffc830 | 2014-01-23 20:52:16 | [diff] [blame] | 57 | #include "content/renderer/render_frame_impl.h" |
[email protected] | e3244ed | 2014-06-20 20:04:27 | [diff] [blame] | 58 | #include "content/renderer/render_frame_proxy.h" |
[email protected] | 8704f89b | 2011-04-15 00:30:05 | [diff] [blame] | 59 | #include "content/renderer/render_process.h" |
[email protected] | f1a29a0 | 2011-10-06 23:08:44 | [diff] [blame] | 60 | #include "content/renderer/render_thread_impl.h" |
dcheng | 3ce04b6 | 2015-10-26 23:30:55 | [diff] [blame] | 61 | #include "content/renderer/render_view_impl.h" |
avi | 40b5be7a | 2016-03-03 21:13:44 | [diff] [blame] | 62 | #include "content/renderer/render_widget_owner_delegate.h" |
tfarina | 556a723 | 2014-10-05 01:02:09 | [diff] [blame] | 63 | #include "content/renderer/renderer_blink_platform_impl.h" |
[email protected] | 5b45ad4 | 2013-10-25 00:42:04 | [diff] [blame] | 64 | #include "content/renderer/resizing_mode_selector.h" |
ekaramad | 330ba423 | 2016-09-23 17:57:47 | [diff] [blame] | 65 | #include "ipc/ipc_message_start.h" |
[email protected] | 48495594 | 2010-08-19 16:13:18 | [diff] [blame] | 66 | #include "ipc/ipc_sync_message.h" |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 67 | #include "ppapi/features/features.h" |
[email protected] | 661eb9d | 2009-02-03 02:11:48 | [diff] [blame] | 68 | #include "skia/ext/platform_canvas.h" |
kinuko | a429302 | 2017-01-27 06:43:25 | [diff] [blame] | 69 | #include "third_party/WebKit/public/platform/FilePathConversion.h" |
[email protected] | ec173b52 | 2013-11-14 11:01:18 | [diff] [blame] | 70 | #include "third_party/WebKit/public/platform/WebCursorInfo.h" |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 71 | #include "third_party/WebKit/public/platform/WebDragData.h" |
| 72 | #include "third_party/WebKit/public/platform/WebDragOperation.h" |
dtapuska | a794bd081 | 2017-01-06 15:22:55 | [diff] [blame] | 73 | #include "third_party/WebKit/public/platform/WebMouseEvent.h" |
donnd | a070f3c | 2015-01-16 19:54:11 | [diff] [blame] | 74 | #include "third_party/WebKit/public/platform/WebPoint.h" |
[email protected] | aaf6889 | 2013-07-18 00:11:30 | [diff] [blame] | 75 | #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" |
skyostil | 529caa29 | 2016-08-10 17:44:51 | [diff] [blame] | 78 | #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] | 1919368 | 2014-04-03 15:01:43 | [diff] [blame] | 80 | #include "third_party/WebKit/public/web/WebDeviceEmulationParams.h" |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 81 | #include "third_party/WebKit/public/web/WebFrameWidget.h" |
ekaramad | 2daaf67 | 2016-11-10 20:29:01 | [diff] [blame] | 82 | #include "third_party/WebKit/public/web/WebInputMethodController.h" |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 83 | #include "third_party/WebKit/public/web/WebLocalFrame.h" |
donnd | a070f3c | 2015-01-16 19:54:11 | [diff] [blame] | 84 | #include "third_party/WebKit/public/web/WebNode.h" |
[email protected] | 2255a933 | 2013-06-17 05:12:31 | [diff] [blame] | 85 | #include "third_party/WebKit/public/web/WebPagePopup.h" |
[email protected] | 2255a933 | 2013-06-17 05:12:31 | [diff] [blame] | 86 | #include "third_party/WebKit/public/web/WebPopupMenuInfo.h" |
| 87 | #include "third_party/WebKit/public/web/WebRange.h" |
jdduke | acf809e | 2014-09-23 20:38:38 | [diff] [blame] | 88 | #include "third_party/WebKit/public/web/WebRuntimeFeatures.h" |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 89 | #include "third_party/WebKit/public/web/WebView.h" |
lfg | e0c2792ec | 2016-05-11 18:52:08 | [diff] [blame] | 90 | #include "third_party/WebKit/public/web/WebWidget.h" |
[email protected] | d353541f | 2012-05-03 22:45:41 | [diff] [blame] | 91 | #include "third_party/skia/include/core/SkShader.h" |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 92 | #include "ui/base/clipboard/clipboard.h" |
[email protected] | faec7b1 | 2012-06-19 14:42:13 | [diff] [blame] | 93 | #include "ui/base/ui_base_switches.h" |
dtapuska | 97286c88 | 2017-02-24 23:14:43 | [diff] [blame] | 94 | #include "ui/events/base_event_utils.h" |
tfarina | 655f81d | 2014-12-23 02:38:50 | [diff] [blame] | 95 | #include "ui/gfx/geometry/point_conversions.h" |
tfarina | 3b0452d | 2014-12-31 15:20:09 | [diff] [blame] | 96 | #include "ui/gfx/geometry/rect_conversions.h" |
tfarina | ebe974f0 | 2015-01-03 04:25:32 | [diff] [blame] | 97 | #include "ui/gfx/geometry/size_conversions.h" |
[email protected] | 1835b9e | 2012-02-28 13:12:48 | [diff] [blame] | 98 | #include "ui/gfx/skia_util.h" |
[email protected] | c9e2cbbb | 2012-05-12 21:17:27 | [diff] [blame] | 99 | #include "ui/gl/gl_switches.h" |
[email protected] | d353541f | 2012-05-03 22:45:41 | [diff] [blame] | 100 | #include "ui/surface/transport_dib.h" |
[email protected] | 661eb9d | 2009-02-03 02:11:48 | [diff] [blame] | 101 | |
[email protected] | eeb9311 | 2013-05-01 19:41:10 | [diff] [blame] | 102 | #if defined(OS_ANDROID) |
[email protected] | cefe9b15 | 2014-03-27 18:16:15 | [diff] [blame] | 103 | #include <android/keycodes.h> |
wjmaclean | 1d97062 | 2017-01-21 22:28:24 | [diff] [blame] | 104 | #include "base/time/time.h" |
[email protected] | eeb9311 | 2013-05-01 19:41:10 | [diff] [blame] | 105 | #endif |
| 106 | |
[email protected] | 661eb9d | 2009-02-03 02:11:48 | [diff] [blame] | 107 | #if defined(OS_POSIX) |
[email protected] | d5282e7 | 2009-05-13 13:16:52 | [diff] [blame] | 108 | #include "third_party/skia/include/core/SkMallocPixelRef.h" |
[email protected] | d353541f | 2012-05-03 22:45:41 | [diff] [blame] | 109 | #include "third_party/skia/include/core/SkPixelRef.h" |
[email protected] | 661eb9d | 2009-02-03 02:11:48 | [diff] [blame] | 110 | #endif // defined(OS_POSIX) |
[email protected] | 8085dbc8 | 2008-09-26 22:53:44 | [diff] [blame] | 111 | |
sadrul | 943e3b3 | 2016-08-04 18:22:59 | [diff] [blame] | 112 | #if defined(USE_AURA) |
sadrul | 602ce136 | 2017-01-26 06:41:10 | [diff] [blame] | 113 | #include "content/renderer/mus/renderer_window_tree_client.h" |
penghuang | 28a5fa2 | 2015-12-02 17:58:19 | [diff] [blame] | 114 | #endif |
| 115 | |
ekaramad | 330ba423 | 2016-09-23 17:57:47 | [diff] [blame] | 116 | #if defined(OS_MACOSX) |
| 117 | #include "content/renderer/text_input_client_observer.h" |
| 118 | #endif |
| 119 | |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 120 | using blink::WebCompositionUnderline; |
| 121 | using blink::WebCursorInfo; |
[email protected] | 1919368 | 2014-04-03 15:01:43 | [diff] [blame] | 122 | using blink::WebDeviceEmulationParams; |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 123 | using blink::WebDragOperation; |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 124 | using blink::WebDragOperationsMask; |
| 125 | using blink::WebDragData; |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 126 | using blink::WebFrameWidget; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 127 | using blink::WebGestureEvent; |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 128 | using blink::WebImage; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 129 | using blink::WebInputEvent; |
dtapuska | 5d2e9c3 | 2015-12-03 16:39:49 | [diff] [blame] | 130 | using blink::WebInputEventResult; |
ekaramad | 2daaf67 | 2016-11-10 20:29:01 | [diff] [blame] | 131 | using blink::WebInputMethodController; |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 132 | using blink::WebLocalFrame; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 133 | using blink::WebMouseEvent; |
| 134 | using blink::WebMouseWheelEvent; |
| 135 | using blink::WebNavigationPolicy; |
donnd | a070f3c | 2015-01-16 19:54:11 | [diff] [blame] | 136 | using blink::WebNode; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 137 | using blink::WebPagePopup; |
donnd | a070f3c | 2015-01-16 19:54:11 | [diff] [blame] | 138 | using blink::WebPoint; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 139 | using blink::WebPopupType; |
dglazkov | e353a37 | 2016-09-01 01:33:48 | [diff] [blame] | 140 | using blink::WebRange; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 141 | using blink::WebRect; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 142 | using blink::WebSize; |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 143 | using blink::WebString; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 144 | using blink::WebTextDirection; |
| 145 | using blink::WebTouchEvent; |
[email protected] | f8ed472 | 2013-12-03 03:27:25 | [diff] [blame] | 146 | using blink::WebTouchPoint; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 147 | using blink::WebVector; |
| 148 | using blink::WebWidget; |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 149 | |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 150 | namespace content { |
| 151 | |
[email protected] | 6a4d7f6 | 2013-01-07 21:32:13 | [diff] [blame] | 152 | namespace { |
[email protected] | b256eca | 2013-07-11 10:57:40 | [diff] [blame] | 153 | |
| 154 | typedef std::map<std::string, ui::TextInputMode> TextInputModeMap; |
| 155 | |
lfg | bee1e0a | 2016-06-08 21:24:21 | [diff] [blame] | 156 | class WebWidgetLockTarget : public content::MouseLockDispatcher::LockTarget { |
| 157 | public: |
| 158 | explicit WebWidgetLockTarget(blink::WebWidget* webwidget) |
| 159 | : webwidget_(webwidget) {} |
| 160 | |
| 161 | void OnLockMouseACK(bool succeeded) override { |
| 162 | if (succeeded) |
| 163 | webwidget_->didAcquirePointerLock(); |
| 164 | else |
| 165 | webwidget_->didNotAcquirePointerLock(); |
| 166 | } |
| 167 | |
| 168 | void OnMouseLockLost() override { webwidget_->didLosePointerLock(); } |
| 169 | |
| 170 | bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event) override { |
| 171 | // The WebWidget handles mouse lock in Blink's handleInputEvent(). |
| 172 | return false; |
| 173 | } |
| 174 | |
| 175 | private: |
| 176 | blink::WebWidget* webwidget_; |
| 177 | }; |
| 178 | |
dglazkov | 97b6c2b | 2016-10-25 17:35:55 | [diff] [blame] | 179 | bool IsDateTimeInput(ui::TextInputType type) { |
| 180 | return type == ui::TEXT_INPUT_TYPE_DATE || |
| 181 | type == ui::TEXT_INPUT_TYPE_DATE_TIME || |
| 182 | type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL || |
| 183 | type == ui::TEXT_INPUT_TYPE_MONTH || |
| 184 | type == ui::TEXT_INPUT_TYPE_TIME || type == ui::TEXT_INPUT_TYPE_WEEK; |
| 185 | } |
| 186 | |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 187 | WebDragData DropMetaDataToWebDragData( |
| 188 | const std::vector<DropData::Metadata>& drop_meta_data) { |
| 189 | std::vector<WebDragData::Item> item_list; |
| 190 | for (const auto& meta_data_item : drop_meta_data) { |
| 191 | if (meta_data_item.kind == DropData::Kind::STRING) { |
| 192 | WebDragData::Item item; |
| 193 | item.storageType = WebDragData::Item::StorageTypeString; |
kinuko | a429302 | 2017-01-27 06:43:25 | [diff] [blame] | 194 | item.stringType = WebString::fromUTF16(meta_data_item.mime_type); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 195 | // Have to pass a dummy URL here instead of an empty URL because the |
| 196 | // DropData received by browser_plugins goes through a round trip: |
| 197 | // DropData::MetaData --> WebDragData-->DropData. In the end, DropData |
| 198 | // will contain an empty URL (which means no URL is dragged) if the URL in |
| 199 | // WebDragData is empty. |
| 200 | if (base::EqualsASCII(meta_data_item.mime_type, |
| 201 | ui::Clipboard::kMimeTypeURIList)) { |
| 202 | item.stringData = WebString::fromUTF8("about:dragdrop-placeholder"); |
| 203 | } |
| 204 | item_list.push_back(item); |
| 205 | continue; |
| 206 | } |
| 207 | |
| 208 | // TODO(hush): crbug.com/584789. Blink needs to support creating a file with |
| 209 | // just the mimetype. This is needed to drag files to WebView on Android |
| 210 | // platform. |
| 211 | if ((meta_data_item.kind == DropData::Kind::FILENAME) && |
| 212 | !meta_data_item.filename.empty()) { |
| 213 | WebDragData::Item item; |
| 214 | item.storageType = WebDragData::Item::StorageTypeFilename; |
kinuko | a429302 | 2017-01-27 06:43:25 | [diff] [blame] | 215 | item.filenameData = blink::FilePathToWebString(meta_data_item.filename); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 216 | item_list.push_back(item); |
| 217 | continue; |
| 218 | } |
| 219 | |
| 220 | if (meta_data_item.kind == DropData::Kind::FILESYSTEMFILE) { |
| 221 | WebDragData::Item item; |
| 222 | item.storageType = WebDragData::Item::StorageTypeFileSystemFile; |
| 223 | item.fileSystemURL = meta_data_item.file_system_url; |
| 224 | item_list.push_back(item); |
| 225 | continue; |
| 226 | } |
| 227 | } |
| 228 | |
| 229 | WebDragData result; |
| 230 | result.initialize(); |
| 231 | result.setItems(item_list); |
| 232 | return result; |
| 233 | } |
| 234 | |
| 235 | WebDragData DropDataToWebDragData(const DropData& drop_data) { |
| 236 | std::vector<WebDragData::Item> item_list; |
| 237 | |
| 238 | // These fields are currently unused when dragging into WebKit. |
| 239 | DCHECK(drop_data.download_metadata.empty()); |
| 240 | DCHECK(drop_data.file_contents.empty()); |
dcheng | 3dd8561 | 2017-02-08 10:46:23 | [diff] [blame] | 241 | DCHECK(drop_data.file_contents_content_disposition.empty()); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 242 | |
| 243 | if (!drop_data.text.is_null()) { |
| 244 | WebDragData::Item item; |
| 245 | item.storageType = WebDragData::Item::StorageTypeString; |
| 246 | item.stringType = WebString::fromUTF8(ui::Clipboard::kMimeTypeText); |
kinuko | a429302 | 2017-01-27 06:43:25 | [diff] [blame] | 247 | item.stringData = WebString::fromUTF16(drop_data.text.string()); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 248 | item_list.push_back(item); |
| 249 | } |
| 250 | |
| 251 | if (!drop_data.url.is_empty()) { |
| 252 | WebDragData::Item item; |
| 253 | item.storageType = WebDragData::Item::StorageTypeString; |
| 254 | item.stringType = WebString::fromUTF8(ui::Clipboard::kMimeTypeURIList); |
| 255 | item.stringData = WebString::fromUTF8(drop_data.url.spec()); |
kinuko | a429302 | 2017-01-27 06:43:25 | [diff] [blame] | 256 | item.title = WebString::fromUTF16(drop_data.url_title); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 257 | item_list.push_back(item); |
| 258 | } |
| 259 | |
| 260 | if (!drop_data.html.is_null()) { |
| 261 | WebDragData::Item item; |
| 262 | item.storageType = WebDragData::Item::StorageTypeString; |
| 263 | item.stringType = WebString::fromUTF8(ui::Clipboard::kMimeTypeHTML); |
kinuko | a429302 | 2017-01-27 06:43:25 | [diff] [blame] | 264 | item.stringData = WebString::fromUTF16(drop_data.html.string()); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 265 | item.baseURL = drop_data.html_base_url; |
| 266 | item_list.push_back(item); |
| 267 | } |
| 268 | |
| 269 | for (std::vector<ui::FileInfo>::const_iterator it = |
| 270 | drop_data.filenames.begin(); |
| 271 | it != drop_data.filenames.end(); |
| 272 | ++it) { |
| 273 | WebDragData::Item item; |
| 274 | item.storageType = WebDragData::Item::StorageTypeFilename; |
kinuko | a429302 | 2017-01-27 06:43:25 | [diff] [blame] | 275 | item.filenameData = blink::FilePathToWebString(it->path); |
| 276 | item.displayNameData = |
| 277 | blink::FilePathToWebString(base::FilePath(it->display_name)); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 278 | item_list.push_back(item); |
| 279 | } |
| 280 | |
| 281 | for (std::vector<DropData::FileSystemFileInfo>::const_iterator it = |
| 282 | drop_data.file_system_files.begin(); |
| 283 | it != drop_data.file_system_files.end(); |
| 284 | ++it) { |
| 285 | WebDragData::Item item; |
| 286 | item.storageType = WebDragData::Item::StorageTypeFileSystemFile; |
| 287 | item.fileSystemURL = it->url; |
| 288 | item.fileSystemFileSize = it->size; |
hirono | da08349d | 2016-12-14 07:36:16 | [diff] [blame] | 289 | item.fileSystemId = blink::WebString::fromASCII(it->filesystem_id); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 290 | item_list.push_back(item); |
| 291 | } |
| 292 | |
| 293 | for (std::map<base::string16, base::string16>::const_iterator it = |
| 294 | drop_data.custom_data.begin(); |
| 295 | it != drop_data.custom_data.end(); |
| 296 | ++it) { |
| 297 | WebDragData::Item item; |
| 298 | item.storageType = WebDragData::Item::StorageTypeString; |
kinuko | a429302 | 2017-01-27 06:43:25 | [diff] [blame] | 299 | item.stringType = WebString::fromUTF16(it->first); |
| 300 | item.stringData = WebString::fromUTF16(it->second); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 301 | item_list.push_back(item); |
| 302 | } |
| 303 | |
| 304 | WebDragData result; |
| 305 | result.initialize(); |
| 306 | result.setItems(item_list); |
kinuko | a429302 | 2017-01-27 06:43:25 | [diff] [blame] | 307 | result.setFilesystemId(WebString::fromUTF16(drop_data.filesystem_id)); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 308 | return result; |
| 309 | } |
| 310 | |
lfg | 1568d11 | 2016-08-30 16:06:29 | [diff] [blame] | 311 | content::RenderWidget::CreateRenderWidgetFunction g_create_render_widget = |
| 312 | nullptr; |
| 313 | |
| 314 | content::RenderWidget::RenderWidgetInitializedCallback |
| 315 | g_render_widget_initialized = nullptr; |
| 316 | |
dtapuska | c4dd5be | 2016-10-25 15:11:10 | [diff] [blame] | 317 | ui::TextInputType ConvertWebTextInputType(blink::WebTextInputType type) { |
| 318 | // Check the type is in the range representable by ui::TextInputType. |
| 319 | DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX)) |
| 320 | << "blink::WebTextInputType and ui::TextInputType not synchronized"; |
| 321 | return static_cast<ui::TextInputType>(type); |
| 322 | } |
| 323 | |
| 324 | ui::TextInputMode ConvertWebTextInputMode(blink::WebTextInputMode mode) { |
| 325 | // Check the mode is in the range representable by ui::TextInputMode. |
| 326 | DCHECK_LE(mode, static_cast<int>(ui::TEXT_INPUT_MODE_MAX)) |
| 327 | << "blink::WebTextInputMode and ui::TextInputMode not synchronized"; |
| 328 | return static_cast<ui::TextInputMode>(mode); |
| 329 | } |
| 330 | |
[email protected] | b256eca | 2013-07-11 10:57:40 | [diff] [blame] | 331 | } // namespace |
| 332 | |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 333 | // RenderWidget --------------------------------------------------------------- |
| 334 | |
nick | 8331f8ad | 2016-11-15 20:42:45 | [diff] [blame] | 335 | RenderWidget::RenderWidget(int32_t widget_routing_id, |
| 336 | CompositorDependencies* compositor_deps, |
dcheng | 35d31c11 | 2015-07-22 00:17:36 | [diff] [blame] | 337 | blink::WebPopupType popup_type, |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 338 | const ScreenInfo& screen_info, |
[email protected] | 1ac10dca | 2013-08-20 20:47:04 | [diff] [blame] | 339 | bool swapped_out, |
[email protected] | 7912e82 | 2014-04-16 02:37:03 | [diff] [blame] | 340 | bool hidden, |
| 341 | bool never_visible) |
nick | 8331f8ad | 2016-11-15 20:42:45 | [diff] [blame] | 342 | : routing_id_(widget_routing_id), |
dcheng | 35d31c11 | 2015-07-22 00:17:36 | [diff] [blame] | 343 | compositor_deps_(compositor_deps), |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 344 | webwidget_internal_(nullptr), |
avi | 40b5be7a | 2016-03-03 21:13:44 | [diff] [blame] | 345 | owner_delegate_(nullptr), |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 346 | next_paint_flags_(0), |
[email protected] | 847a258 | 2013-03-09 02:29:51 | [diff] [blame] | 347 | auto_resize_mode_(false), |
[email protected] | ea3ee0a | 2012-05-15 03:43:09 | [diff] [blame] | 348 | need_update_rect_for_auto_resize_(false), |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 349 | did_show_(false), |
[email protected] | 1ac10dca | 2013-08-20 20:47:04 | [diff] [blame] | 350 | is_hidden_(hidden), |
sievers | 71c62dd5 | 2015-10-07 01:44:39 | [diff] [blame] | 351 | compositor_never_visible_(never_visible), |
mikhail.pozdnyakov | f2c902a | 2015-04-14 08:09:12 | [diff] [blame] | 352 | is_fullscreen_granted_(false), |
mikhail.pozdnyakov | c0e251b | 2015-04-15 06:51:12 | [diff] [blame] | 353 | display_mode_(blink::WebDisplayModeUndefined), |
changwan | f2a707b | 2015-10-30 08:22:16 | [diff] [blame] | 354 | ime_event_guard_(nullptr), |
[email protected] | 661eb9d | 2009-02-03 02:11:48 | [diff] [blame] | 355 | closing_(false), |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 356 | host_closing_(false), |
[email protected] | 14392a5 | 2012-05-02 20:28:44 | [diff] [blame] | 357 | is_swapped_out_(swapped_out), |
simonhong | 628f981 | 2015-04-27 23:13:20 | [diff] [blame] | 358 | for_oopif_(false), |
dglazkov | 97b6c2b | 2016-10-25 17:35:55 | [diff] [blame] | 359 | text_input_type_(ui::TEXT_INPUT_TYPE_NONE), |
[email protected] | b256eca | 2013-07-11 10:57:40 | [diff] [blame] | 360 | text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT), |
shuchen | 82ce8c5 | 2014-10-23 01:55:20 | [diff] [blame] | 361 | text_input_flags_(0), |
[email protected] | 86ba5fcb | 2013-09-04 00:36:53 | [diff] [blame] | 362 | can_compose_inline_(true), |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 363 | composition_range_(gfx::Range::InvalidRange()), |
[email protected] | 3e2b375b | 2010-04-07 17:03:12 | [diff] [blame] | 364 | popup_type_(popup_type), |
[email protected] | 867125a0 | 2009-12-10 06:01:48 | [diff] [blame] | 365 | pending_window_rect_count_(0), |
[email protected] | 842f1065 | 2012-06-06 01:54:04 | [diff] [blame] | 366 | screen_info_(screen_info), |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 367 | device_scale_factor_(screen_info_.device_scale_factor), |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 368 | monitor_composition_info_(false), |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 369 | popup_origin_scale_for_emulation_(0.f), |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 370 | frame_swap_message_queue_(new FrameSwapMessageQueue()), |
[email protected] | a09d53ce | 2014-01-31 00:46:42 | [diff] [blame] | 371 | resizing_mode_selector_(new ResizingModeSelector()), |
lfg | e0c2792ec | 2016-05-11 18:52:08 | [diff] [blame] | 372 | has_host_context_menu_location_(false), |
wjmaclean | 1d97062 | 2017-01-21 22:28:24 | [diff] [blame] | 373 | has_added_input_handler_(false), |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 374 | has_focus_(false), |
ekaramad | 330ba423 | 2016-09-23 17:57:47 | [diff] [blame] | 375 | #if defined(OS_MACOSX) |
| 376 | text_input_client_observer_(new TextInputClientObserver(this)), |
| 377 | #endif |
wjmaclean | 1d97062 | 2017-01-21 22:28:24 | [diff] [blame] | 378 | focused_pepper_plugin_(nullptr), |
tasak | b95dbb50c | 2017-02-08 18:07:50 | [diff] [blame] | 379 | time_to_first_active_paint_recorded_(true), |
| 380 | was_shown_time_(base::TimeTicks::Now()), |
kenrb | 5d78b84 | 2017-03-06 21:06:01 | [diff] [blame] | 381 | current_content_source_id_(0), |
wjmaclean | 1d97062 | 2017-01-21 22:28:24 | [diff] [blame] | 382 | weak_ptr_factory_(this) { |
nick | 8331f8ad | 2016-11-15 20:42:45 | [diff] [blame] | 383 | DCHECK_NE(routing_id_, MSG_ROUTING_NONE); |
[email protected] | 8b3f0eb | 2012-05-03 19:15:05 | [diff] [blame] | 384 | if (!swapped_out) |
| 385 | RenderProcess::current()->AddRefProcess(); |
[email protected] | 38024409 | 2011-10-07 17:26:27 | [diff] [blame] | 386 | DCHECK(RenderThread::Get()); |
alexclarke | 7fa9394 | 2015-10-21 15:37:11 | [diff] [blame] | 387 | |
| 388 | // In tests there may not be a RenderThreadImpl. |
| 389 | if (RenderThreadImpl::current()) { |
| 390 | render_widget_scheduling_state_ = RenderThreadImpl::current() |
| 391 | ->GetRendererScheduler() |
dcheng | 07945f63 | 2015-12-26 07:59:32 | [diff] [blame] | 392 | ->NewRenderWidgetSchedulingState(); |
alexclarke | 7fa9394 | 2015-10-21 15:37:11 | [diff] [blame] | 393 | render_widget_scheduling_state_->SetHidden(is_hidden_); |
| 394 | } |
sadrul | 602ce136 | 2017-01-26 06:41:10 | [diff] [blame] | 395 | #if defined(USE_AURA) |
sadrul | 8185d97 | 2017-01-31 18:30:11 | [diff] [blame] | 396 | if (!base::CommandLine::ForCurrentProcess()->HasSwitch( |
| 397 | switches::kNoUseMusInRenderer)) { |
sadrul | be523b7c | 2017-02-06 19:35:24 | [diff] [blame] | 398 | RendererWindowTreeClient::CreateIfNecessary(routing_id_); |
sadrul | 602ce136 | 2017-01-26 06:41:10 | [diff] [blame] | 399 | } |
| 400 | #endif |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 401 | } |
| 402 | |
| 403 | RenderWidget::~RenderWidget() { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 404 | DCHECK(!webwidget_internal_) << "Leaking our WebWidget!"; |
[email protected] | bffc830 | 2014-01-23 20:52:16 | [diff] [blame] | 405 | |
[email protected] | 992db4c | 2011-05-12 15:37:15 | [diff] [blame] | 406 | // If we are swapped out, we have released already. |
[email protected] | d2e2f9ee | 2013-08-21 11:02:02 | [diff] [blame] | 407 | if (!is_swapped_out_ && RenderProcess::current()) |
[email protected] | 992db4c | 2011-05-12 15:37:15 | [diff] [blame] | 408 | RenderProcess::current()->ReleaseProcess(); |
sadrul | 8185d97 | 2017-01-31 18:30:11 | [diff] [blame] | 409 | #if defined(USE_AURA) |
| 410 | if (!base::CommandLine::ForCurrentProcess()->HasSwitch( |
| 411 | switches::kNoUseMusInRenderer)) { |
| 412 | // It is possible for a RenderWidget to be destroyed before it was embedded |
| 413 | // in a mus window. The RendererWindowTreeClient will leak in such cases. So |
| 414 | // explicitly delete it here. |
| 415 | RendererWindowTreeClient::Destroy(routing_id_); |
| 416 | } |
| 417 | #endif |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 418 | } |
| 419 | |
[email protected] | 48495594 | 2010-08-19 16:13:18 | [diff] [blame] | 420 | // static |
lfg | 1568d11 | 2016-08-30 16:06:29 | [diff] [blame] | 421 | void RenderWidget::InstallCreateHook( |
| 422 | CreateRenderWidgetFunction create_render_widget, |
| 423 | RenderWidgetInitializedCallback render_widget_initialized) { |
| 424 | CHECK(!g_create_render_widget && !g_render_widget_initialized); |
| 425 | g_create_render_widget = create_render_widget; |
| 426 | g_render_widget_initialized = render_widget_initialized; |
| 427 | } |
| 428 | |
| 429 | // static |
nick | f7b3822 | 2016-11-22 21:59:35 | [diff] [blame] | 430 | RenderWidget* RenderWidget::CreateForPopup( |
| 431 | RenderViewImpl* opener, |
| 432 | CompositorDependencies* compositor_deps, |
| 433 | blink::WebPopupType popup_type, |
| 434 | const ScreenInfo& screen_info) { |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 435 | // Do a synchronous IPC to obtain a routing ID. |
| 436 | int32_t routing_id = MSG_ROUTING_NONE; |
| 437 | if (!RenderThreadImpl::current_render_message_filter()->CreateNewWidget( |
nick | f7b3822 | 2016-11-22 21:59:35 | [diff] [blame] | 438 | opener->GetRoutingID(), popup_type, &routing_id)) { |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 439 | return nullptr; |
| 440 | } |
| 441 | |
nick | 8331f8ad | 2016-11-15 20:42:45 | [diff] [blame] | 442 | scoped_refptr<RenderWidget> widget( |
| 443 | new RenderWidget(routing_id, compositor_deps, popup_type, screen_info, |
| 444 | false, false, false)); |
nick | f7b3822 | 2016-11-22 21:59:35 | [diff] [blame] | 445 | ShowCallback opener_callback = |
wjmaclean | 1d97062 | 2017-01-21 22:28:24 | [diff] [blame] | 446 | base::Bind(&RenderViewImpl::ShowCreatedPopupWidget, opener->GetWeakPtr()); |
nick | f7b3822 | 2016-11-22 21:59:35 | [diff] [blame] | 447 | widget->Init(opener_callback, RenderWidget::CreateWebWidget(widget.get())); |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 448 | DCHECK(!widget->HasOneRef()); // RenderWidget::Init() adds a reference. |
| 449 | return widget.get(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 450 | } |
| 451 | |
[email protected] | 48495594 | 2010-08-19 16:13:18 | [diff] [blame] | 452 | // static |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 453 | RenderWidget* RenderWidget::CreateForFrame( |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 454 | int widget_routing_id, |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 455 | bool hidden, |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 456 | const ScreenInfo& screen_info, |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 457 | CompositorDependencies* compositor_deps, |
| 458 | blink::WebLocalFrame* frame) { |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 459 | CHECK_NE(widget_routing_id, MSG_ROUTING_NONE); |
dcheng | 3ce04b6 | 2015-10-26 23:30:55 | [diff] [blame] | 460 | // TODO(avi): Before RenderViewImpl has-a RenderWidget, the browser passes the |
| 461 | // same routing ID for both the view routing ID and the main frame widget |
| 462 | // routing ID. https://crbug.com/545684 |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 463 | RenderViewImpl* view = RenderViewImpl::FromRoutingID(widget_routing_id); |
dcheng | 3ce04b6 | 2015-10-26 23:30:55 | [diff] [blame] | 464 | if (view) { |
avi | 8a45c109 | 2016-03-01 16:12:34 | [diff] [blame] | 465 | view->AttachWebFrameWidget( |
| 466 | RenderWidget::CreateWebFrameWidget(view->GetWidget(), frame)); |
| 467 | return view->GetWidget(); |
dcheng | 3ce04b6 | 2015-10-26 23:30:55 | [diff] [blame] | 468 | } |
dcheng | 35d31c11 | 2015-07-22 00:17:36 | [diff] [blame] | 469 | scoped_refptr<RenderWidget> widget( |
lfg | 1568d11 | 2016-08-30 16:06:29 | [diff] [blame] | 470 | g_create_render_widget |
nick | 8331f8ad | 2016-11-15 20:42:45 | [diff] [blame] | 471 | ? g_create_render_widget(widget_routing_id, compositor_deps, |
| 472 | blink::WebPopupTypeNone, screen_info, false, |
| 473 | hidden, false) |
| 474 | : new RenderWidget(widget_routing_id, compositor_deps, |
| 475 | blink::WebPopupTypeNone, screen_info, false, |
| 476 | hidden, false)); |
simonhong | 628f981 | 2015-04-27 23:13:20 | [diff] [blame] | 477 | widget->for_oopif_ = true; |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 478 | // Init increments the reference count on |widget|, keeping it alive after |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 479 | // this function returns. |
nick | f7b3822 | 2016-11-22 21:59:35 | [diff] [blame] | 480 | widget->Init(RenderWidget::ShowCallback(), |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 481 | RenderWidget::CreateWebFrameWidget(widget.get(), frame)); |
| 482 | |
| 483 | if (g_render_widget_initialized) |
| 484 | g_render_widget_initialized(widget.get()); |
| 485 | return widget.get(); |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 486 | } |
| 487 | |
| 488 | // static |
lfg | caab514 | 2016-02-26 19:06:52 | [diff] [blame] | 489 | blink::WebFrameWidget* RenderWidget::CreateWebFrameWidget( |
dcheng | da9b4bb | 2015-07-20 20:58:08 | [diff] [blame] | 490 | RenderWidget* render_widget, |
| 491 | blink::WebLocalFrame* frame) { |
dcheng | 3ce04b6 | 2015-10-26 23:30:55 | [diff] [blame] | 492 | if (!frame->parent()) { |
| 493 | // TODO(dcheng): The main frame widget currently has a special case. |
| 494 | // Eliminate this once WebView is no longer a WebWidget. |
| 495 | return blink::WebFrameWidget::create(render_widget, frame->view(), frame); |
| 496 | } |
dcheng | da9b4bb | 2015-07-20 20:58:08 | [diff] [blame] | 497 | return blink::WebFrameWidget::create(render_widget, frame); |
| 498 | } |
| 499 | |
| 500 | // static |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 501 | blink::WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) { |
[email protected] | 48495594 | 2010-08-19 16:13:18 | [diff] [blame] | 502 | switch (render_widget->popup_type_) { |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 503 | case blink::WebPopupTypeNone: // Nothing to create. |
[email protected] | 48495594 | 2010-08-19 16:13:18 | [diff] [blame] | 504 | break; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 505 | case blink::WebPopupTypePage: |
[email protected] | a7547fb | 2012-03-08 04:43:44 | [diff] [blame] | 506 | return WebPagePopup::create(render_widget); |
[email protected] | 48495594 | 2010-08-19 16:13:18 | [diff] [blame] | 507 | default: |
| 508 | NOTREACHED(); |
| 509 | } |
| 510 | return NULL; |
| 511 | } |
| 512 | |
dcheng | da9b4bb | 2015-07-20 20:58:08 | [diff] [blame] | 513 | void RenderWidget::CloseForFrame() { |
dcheng | d96a27a | 2015-07-24 20:17:32 | [diff] [blame] | 514 | OnClose(); |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 515 | } |
| 516 | |
alexmos | 78c9c0d | 2016-10-14 18:57:03 | [diff] [blame] | 517 | void RenderWidget::SetSwappedOut(bool is_swapped_out) { |
| 518 | // We should only toggle between states. |
| 519 | DCHECK(is_swapped_out_ != is_swapped_out); |
| 520 | is_swapped_out_ = is_swapped_out; |
| 521 | |
| 522 | // If we are swapping out, we will call ReleaseProcess, allowing the process |
| 523 | // to exit if all of its RenderViews are swapped out. We wait until the |
| 524 | // WasSwappedOut call to do this, to allow the unload handler to finish. |
| 525 | // If we are swapping in, we call AddRefProcess to prevent the process from |
| 526 | // exiting. |
| 527 | if (!is_swapped_out_) |
| 528 | RenderProcess::current()->AddRefProcess(); |
| 529 | } |
| 530 | |
nick | f7b3822 | 2016-11-22 21:59:35 | [diff] [blame] | 531 | void RenderWidget::Init(const ShowCallback& show_callback, |
| 532 | WebWidget* web_widget) { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 533 | DCHECK(!webwidget_internal_); |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 534 | DCHECK_NE(routing_id_, MSG_ROUTING_NONE); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 535 | |
sadrul | 9fe4892 | 2017-01-23 18:59:49 | [diff] [blame] | 536 | input_handler_ = base::MakeUnique<RenderWidgetInputHandler>(this, this); |
nick | 8331f8ad | 2016-11-15 20:42:45 | [diff] [blame] | 537 | |
nick | f7b3822 | 2016-11-22 21:59:35 | [diff] [blame] | 538 | show_callback_ = show_callback; |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 539 | |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 540 | webwidget_internal_ = web_widget; |
| 541 | webwidget_mouse_lock_target_.reset( |
| 542 | new WebWidgetLockTarget(webwidget_internal_)); |
lfg | bee1e0a | 2016-06-08 21:24:21 | [diff] [blame] | 543 | mouse_lock_dispatcher_.reset(new RenderWidgetMouseLockDispatcher(this)); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 544 | |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 545 | RenderThread::Get()->AddRoute(routing_id_, this); |
| 546 | // Take a reference on behalf of the RenderThread. This will be balanced |
| 547 | // when we receive ViewMsg_Close. |
| 548 | AddRef(); |
| 549 | if (RenderThreadImpl::current()) { |
| 550 | RenderThreadImpl::current()->WidgetCreated(); |
| 551 | if (is_hidden_) |
| 552 | RenderThreadImpl::current()->WidgetHidden(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 553 | } |
| 554 | } |
| 555 | |
[email protected] | 949b659 | 2014-08-20 13:17:52 | [diff] [blame] | 556 | void RenderWidget::WasSwappedOut() { |
| 557 | // If we have been swapped out and no one else is using this process, |
| 558 | // it's safe to exit now. |
| 559 | CHECK(is_swapped_out_); |
| 560 | RenderProcess::current()->ReleaseProcess(); |
| 561 | } |
| 562 | |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 563 | void RenderWidget::SetPopupOriginAdjustmentsForEmulation( |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 564 | RenderWidgetScreenMetricsEmulator* emulator) { |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 565 | popup_origin_scale_for_emulation_ = emulator->scale(); |
[email protected] | 1919368 | 2014-04-03 15:01:43 | [diff] [blame] | 566 | popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin(); |
[email protected] | 9a2d7ee3 | 2013-12-05 12:15:49 | [diff] [blame] | 567 | popup_screen_origin_for_emulation_ = gfx::Point( |
| 568 | emulator->original_screen_rect().origin().x() + emulator->offset().x(), |
| 569 | emulator->original_screen_rect().origin().y() + emulator->offset().y()); |
[email protected] | 5f75aa4 | 2014-04-01 23:00:56 | [diff] [blame] | 570 | screen_info_ = emulator->original_screen_info(); |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 571 | device_scale_factor_ = screen_info_.device_scale_factor; |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 572 | } |
| 573 | |
[email protected] | 2d6836f4 | 2014-07-02 17:25:31 | [diff] [blame] | 574 | gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) { |
| 575 | if (screen_metrics_emulator_) |
| 576 | return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor); |
| 577 | return anchor; |
| 578 | } |
| 579 | |
thakis | 18e42641 | 2017-03-15 12:06:37 | [diff] [blame^] | 580 | #if BUILDFLAG(USE_EXTERNAL_POPUP_MENU) |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 581 | void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation( |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 582 | ExternalPopupMenu* popup, |
| 583 | RenderWidgetScreenMetricsEmulator* emulator) { |
[email protected] | 9a2d7ee3 | 2013-12-05 12:15:49 | [diff] [blame] | 584 | popup->SetOriginScaleAndOffsetForEmulation( |
| 585 | emulator->scale(), emulator->offset()); |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 586 | } |
[email protected] | 5390786 | 2014-03-25 15:42:40 | [diff] [blame] | 587 | #endif |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 588 | |
| 589 | void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) { |
| 590 | if (screen_metrics_emulator_) |
| 591 | screen_metrics_emulator_->OnShowContextMenu(params); |
| 592 | } |
| 593 | |
[email protected] | a95986a8 | 2010-12-24 06:19:28 | [diff] [blame] | 594 | bool RenderWidget::OnMessageReceived(const IPC::Message& message) { |
ekaramad | 330ba423 | 2016-09-23 17:57:47 | [diff] [blame] | 595 | #if defined(OS_MACOSX) |
| 596 | if (IPC_MESSAGE_CLASS(message) == TextInputClientMsgStart) |
| 597 | return text_input_client_observer_->OnMessageReceived(message); |
| 598 | #endif |
lfg | bee1e0a | 2016-06-08 21:24:21 | [diff] [blame] | 599 | if (mouse_lock_dispatcher_ && |
| 600 | mouse_lock_dispatcher_->OnMessageReceived(message)) |
| 601 | return true; |
| 602 | |
[email protected] | a95986a8 | 2010-12-24 06:19:28 | [diff] [blame] | 603 | bool handled = true; |
| 604 | IPC_BEGIN_MESSAGE_MAP(RenderWidget, message) |
[email protected] | c084330e0 | 2013-04-27 01:08:15 | [diff] [blame] | 605 | IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent) |
[email protected] | 34202de | 2013-05-06 23:36:22 | [diff] [blame] | 606 | IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange, |
| 607 | OnCursorVisibilityChange) |
[email protected] | a2214eb | 2014-06-23 18:31:22 | [diff] [blame] | 608 | IPC_MESSAGE_HANDLER(InputMsg_ImeSetComposition, OnImeSetComposition) |
aelias | 87b8f7c | 2016-09-14 03:19:29 | [diff] [blame] | 609 | IPC_MESSAGE_HANDLER(InputMsg_ImeCommitText, OnImeCommitText) |
| 610 | IPC_MESSAGE_HANDLER(InputMsg_ImeFinishComposingText, |
| 611 | OnImeFinishComposingText) |
[email protected] | c084330e0 | 2013-04-27 01:08:15 | [diff] [blame] | 612 | IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost) |
alexmos | 5656749 | 2016-09-13 00:52:46 | [diff] [blame] | 613 | IPC_MESSAGE_HANDLER(InputMsg_SetEditCommandsForNextKeyEvent, |
| 614 | OnSetEditCommandsForNextKeyEvent) |
[email protected] | c084330e0 | 2013-04-27 01:08:15 | [diff] [blame] | 615 | IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus) |
[email protected] | 9017d785 | 2013-11-21 17:47:35 | [diff] [blame] | 616 | IPC_MESSAGE_HANDLER(InputMsg_SyntheticGestureCompleted, |
| 617 | OnSyntheticGestureCompleted) |
[email protected] | a95986a8 | 2010-12-24 06:19:28 | [diff] [blame] | 618 | IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose) |
[email protected] | a95986a8 | 2010-12-24 06:19:28 | [diff] [blame] | 619 | IPC_MESSAGE_HANDLER(ViewMsg_Resize, OnResize) |
dgozman | 9260b0a1 | 2015-03-16 13:45:20 | [diff] [blame] | 620 | IPC_MESSAGE_HANDLER(ViewMsg_EnableDeviceEmulation, |
| 621 | OnEnableDeviceEmulation) |
| 622 | IPC_MESSAGE_HANDLER(ViewMsg_DisableDeviceEmulation, |
| 623 | OnDisableDeviceEmulation) |
[email protected] | a95986a8 | 2010-12-24 06:19:28 | [diff] [blame] | 624 | IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden) |
[email protected] | 9e2e463 | 2012-07-27 16:38:41 | [diff] [blame] | 625 | IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown) |
[email protected] | 3d9ec505 | 2013-01-02 22:05:25 | [diff] [blame] | 626 | IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint) |
[email protected] | a95986a8 | 2010-12-24 06:19:28 | [diff] [blame] | 627 | IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection) |
| 628 | IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck) |
[email protected] | 80ad862 | 2012-11-07 16:33:03 | [diff] [blame] | 629 | IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects) |
kenrb | ea73179 | 2017-01-13 15:10:48 | [diff] [blame] | 630 | IPC_MESSAGE_HANDLER(ViewMsg_SetViewportIntersection, |
| 631 | OnSetViewportIntersection) |
lfg | 43e08e6 | 2016-02-03 18:51:37 | [diff] [blame] | 632 | IPC_MESSAGE_HANDLER(ViewMsg_WaitForNextFrameForTests, |
| 633 | OnWaitNextFrameForTests) |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 634 | IPC_MESSAGE_HANDLER(InputMsg_RequestCompositionUpdate, |
| 635 | OnRequestCompositionUpdate) |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 636 | IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter) |
| 637 | IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver, OnDragTargetDragOver) |
| 638 | IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave, OnDragTargetDragLeave) |
| 639 | IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop) |
paulmeyer | 8fc8ea9 | 2016-11-15 05:12:21 | [diff] [blame] | 640 | IPC_MESSAGE_HANDLER(DragMsg_SourceEnded, OnDragSourceEnded) |
| 641 | IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded, |
| 642 | OnDragSourceSystemDragEnded) |
[email protected] | 105dffb4 | 2013-02-20 03:46:21 | [diff] [blame] | 643 | #if defined(OS_ANDROID) |
changwan | 8c34274 | 2016-02-26 00:53:39 | [diff] [blame] | 644 | IPC_MESSAGE_HANDLER(InputMsg_RequestTextInputStateUpdate, |
| 645 | OnRequestTextInputStateUpdate) |
[email protected] | 105dffb4 | 2013-02-20 03:46:21 | [diff] [blame] | 646 | #endif |
[email protected] | a95986a8 | 2010-12-24 06:19:28 | [diff] [blame] | 647 | IPC_MESSAGE_UNHANDLED(handled = false) |
| 648 | IPC_END_MESSAGE_MAP() |
| 649 | return handled; |
| 650 | } |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 651 | |
| 652 | bool RenderWidget::Send(IPC::Message* message) { |
[email protected] | 992db4c | 2011-05-12 15:37:15 | [diff] [blame] | 653 | // Don't send any messages after the browser has told us to close, and filter |
| 654 | // most outgoing messages while swapped out. |
| 655 | if ((is_swapped_out_ && |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 656 | !SwappedOutMessages::CanSendWhileSwappedOut(message)) || |
[email protected] | c6c921e9 | 2012-05-10 23:31:11 | [diff] [blame] | 657 | closing_) { |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 658 | delete message; |
| 659 | return false; |
| 660 | } |
| 661 | |
| 662 | // If given a messsage without a routing ID, then assign our routing ID. |
| 663 | if (message->routing_id() == MSG_ROUTING_NONE) |
| 664 | message->set_routing_id(routing_id_); |
| 665 | |
[email protected] | 38024409 | 2011-10-07 17:26:27 | [diff] [blame] | 666 | return RenderThread::Get()->Send(message); |
[email protected] | 8085dbc8 | 2008-09-26 22:53:44 | [diff] [blame] | 667 | } |
| 668 | |
dtapuska | 014ed08 | 2016-11-11 21:58:48 | [diff] [blame] | 669 | void RenderWidget::SendOrCrash(IPC::Message* message) { |
| 670 | bool result = Send(message); |
| 671 | CHECK(closing_ || result) << "Failed to send message"; |
| 672 | } |
| 673 | |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 674 | bool RenderWidget::ShouldHandleImeEvents() const { |
ekaramad | b6483a05 | 2017-02-10 02:23:26 | [diff] [blame] | 675 | // TODO(ekaramad): We track page focus in all RenderViews on the page but the |
| 676 | // RenderWidgets corresponding to OOPIFs do not get the update. For now, this |
| 677 | // method returns true when the RenderWidget is for an OOPIF, i.e., IME events |
| 678 | // will be processed regardless of page focus. We should revisit this after |
| 679 | // page focus for OOPIFs has been fully resolved (https://crbug.com/689777). |
| 680 | return GetWebWidget() && GetWebWidget()->isWebFrameWidget() && |
| 681 | (has_focus_ || for_oopif_); |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 682 | } |
| 683 | |
bokan | c007c3a | 2015-02-03 07:15:56 | [diff] [blame] | 684 | void RenderWidget::SetWindowRectSynchronously( |
| 685 | const gfx::Rect& new_window_rect) { |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 686 | ResizeParams params; |
| 687 | params.screen_info = screen_info_; |
| 688 | params.new_size = new_window_rect.size(); |
| 689 | params.physical_backing_size = |
| 690 | gfx::ScaleToCeiledSize(new_window_rect.size(), device_scale_factor_); |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 691 | params.visible_viewport_size = new_window_rect.size(); |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 692 | params.is_fullscreen_granted = is_fullscreen_granted_; |
| 693 | params.display_mode = display_mode_; |
| 694 | params.needs_resize_ack = false; |
| 695 | Resize(params); |
| 696 | |
bokan | c007c3a | 2015-02-03 07:15:56 | [diff] [blame] | 697 | view_screen_rect_ = new_window_rect; |
| 698 | window_screen_rect_ = new_window_rect; |
[email protected] | 9265016 | 2013-10-30 03:31:02 | [diff] [blame] | 699 | if (!did_show_) |
bokan | c007c3a | 2015-02-03 07:15:56 | [diff] [blame] | 700 | initial_rect_ = new_window_rect; |
[email protected] | 9265016 | 2013-10-30 03:31:02 | [diff] [blame] | 701 | } |
| 702 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 703 | void RenderWidget::OnClose() { |
dcheng | d96a27a | 2015-07-24 20:17:32 | [diff] [blame] | 704 | DCHECK(content::RenderThread::Get()); |
| 705 | if (closing_) |
| 706 | return; |
| 707 | NotifyOnClose(); |
| 708 | closing_ = true; |
| 709 | |
| 710 | // Browser correspondence is no longer needed at this point. |
| 711 | if (routing_id_ != MSG_ROUTING_NONE) { |
| 712 | RenderThread::Get()->RemoveRoute(routing_id_); |
| 713 | SetHidden(false); |
| 714 | if (RenderThreadImpl::current()) |
| 715 | RenderThreadImpl::current()->WidgetDestroyed(); |
| 716 | } |
| 717 | |
| 718 | if (for_oopif_) { |
| 719 | // Widgets for frames may be created and closed at any time while the frame |
| 720 | // is alive. However, the closing process must happen synchronously. Frame |
| 721 | // widget and frames hold pointers to each other. If Close() is deferred to |
| 722 | // the message loop like in the non-frame widget case, WebWidget::close() |
| 723 | // can end up accessing members of an already-deleted frame. |
| 724 | Close(); |
| 725 | } else { |
| 726 | // If there is a Send call on the stack, then it could be dangerous to close |
| 727 | // now. Post a task that only gets invoked when there are no nested message |
| 728 | // loops. |
| 729 | base::ThreadTaskRunnerHandle::Get()->PostNonNestableTask( |
| 730 | FROM_HERE, base::Bind(&RenderWidget::Close, this)); |
| 731 | } |
| 732 | |
| 733 | // Balances the AddRef taken when we called AddRoute. |
| 734 | Release(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 735 | } |
| 736 | |
fsamuel | 664e8b6 | 2016-01-20 19:54:01 | [diff] [blame] | 737 | void RenderWidget::OnResize(const ResizeParams& params) { |
[email protected] | 5b45ad4 | 2013-10-25 00:42:04 | [diff] [blame] | 738 | if (resizing_mode_selector_->ShouldAbortOnResize(this, params)) |
[email protected] | 03e8867 | 2013-10-22 21:31:32 | [diff] [blame] | 739 | return; |
| 740 | |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 741 | if (screen_metrics_emulator_) { |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 742 | screen_metrics_emulator_->OnResize(params); |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 743 | return; |
| 744 | } |
| 745 | |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 746 | Resize(params); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 747 | } |
| 748 | |
dgozman | 9260b0a1 | 2015-03-16 13:45:20 | [diff] [blame] | 749 | void RenderWidget::OnEnableDeviceEmulation( |
| 750 | const blink::WebDeviceEmulationParams& params) { |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 751 | if (!screen_metrics_emulator_) { |
| 752 | ResizeParams resize_params; |
| 753 | resize_params.screen_info = screen_info_; |
| 754 | resize_params.new_size = size_; |
| 755 | resize_params.physical_backing_size = physical_backing_size_; |
| 756 | resize_params.visible_viewport_size = visible_viewport_size_; |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 757 | resize_params.is_fullscreen_granted = is_fullscreen_granted_; |
| 758 | resize_params.display_mode = display_mode_; |
| 759 | screen_metrics_emulator_.reset(new RenderWidgetScreenMetricsEmulator( |
| 760 | this, params, resize_params, view_screen_rect_, window_screen_rect_)); |
oshima | 50872a7 | 2016-03-04 13:26:18 | [diff] [blame] | 761 | screen_metrics_emulator_->Apply(); |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 762 | } else { |
dgozman | 9260b0a1 | 2015-03-16 13:45:20 | [diff] [blame] | 763 | screen_metrics_emulator_->ChangeEmulationParams(params); |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 764 | } |
dgozman | 9260b0a1 | 2015-03-16 13:45:20 | [diff] [blame] | 765 | } |
| 766 | |
| 767 | void RenderWidget::OnDisableDeviceEmulation() { |
| 768 | screen_metrics_emulator_.reset(); |
| 769 | } |
| 770 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 771 | void RenderWidget::OnWasHidden() { |
[email protected] | 9c3085f | 2011-06-09 02:10:31 | [diff] [blame] | 772 | TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden"); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 773 | // Go into a mode where we stop generating paint and scrolling events. |
[email protected] | bee16aab | 2009-08-26 15:55:03 | [diff] [blame] | 774 | SetHidden(true); |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 775 | for (auto& observer : render_frames_) |
| 776 | observer.WasHidden(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 777 | } |
| 778 | |
[email protected] | 3399dd82 | 2014-08-09 11:14:24 | [diff] [blame] | 779 | void RenderWidget::OnWasShown(bool needs_repainting, |
| 780 | const ui::LatencyInfo& latency_info) { |
[email protected] | 9e2e463 | 2012-07-27 16:38:41 | [diff] [blame] | 781 | TRACE_EVENT0("renderer", "RenderWidget::OnWasShown"); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 782 | // During shutdown we can just ignore this message. |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 783 | if (!GetWebWidget()) |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 784 | return; |
| 785 | |
tasak | b95dbb50c | 2017-02-08 18:07:50 | [diff] [blame] | 786 | was_shown_time_ = base::TimeTicks::Now(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 787 | // See OnWasHidden |
[email protected] | bee16aab | 2009-08-26 15:55:03 | [diff] [blame] | 788 | SetHidden(false); |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 789 | for (auto& observer : render_frames_) |
| 790 | observer.WasShown(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 791 | |
[email protected] | 8a23afb3 | 2014-04-30 22:40:23 | [diff] [blame] | 792 | if (!needs_repainting) |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 793 | return; |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 794 | |
| 795 | // Generate a full repaint. |
[email protected] | 3399dd82 | 2014-08-09 11:14:24 | [diff] [blame] | 796 | if (compositor_) { |
| 797 | ui::LatencyInfo swap_latency_info(latency_info); |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 798 | std::unique_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor( |
[email protected] | 3399dd82 | 2014-08-09 11:14:24 | [diff] [blame] | 799 | compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info)); |
[email protected] | aca33f4f | 2014-05-17 17:08:05 | [diff] [blame] | 800 | compositor_->SetNeedsForcedRedraw(); |
[email protected] | 3399dd82 | 2014-08-09 11:14:24 | [diff] [blame] | 801 | } |
jdduke | 491a3f0c | 2015-06-15 23:30:26 | [diff] [blame] | 802 | ScheduleComposite(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 803 | } |
| 804 | |
[email protected] | 53d3f30 | 2009-12-21 04:42:05 | [diff] [blame] | 805 | void RenderWidget::OnRequestMoveAck() { |
| 806 | DCHECK(pending_window_rect_count_); |
| 807 | pending_window_rect_count_--; |
| 808 | } |
| 809 | |
[email protected] | ed7defa | 2013-03-12 21:29:59 | [diff] [blame] | 810 | GURL RenderWidget::GetURLForGraphicsContext3D() { |
| 811 | return GURL(); |
[email protected] | 6522577 | 2011-05-12 21:10:24 | [diff] [blame] | 812 | } |
| 813 | |
nzolghadr | 5d859650 | 2017-01-23 22:59:35 | [diff] [blame] | 814 | void RenderWidget::OnHandleInputEvent( |
| 815 | const blink::WebInputEvent* input_event, |
| 816 | const std::vector<const blink::WebInputEvent*>& coalesced_events, |
| 817 | const ui::LatencyInfo& latency_info, |
| 818 | InputEventDispatchType dispatch_type) { |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 819 | if (!input_event) |
| 820 | return; |
nzolghadr | 5d859650 | 2017-01-23 22:59:35 | [diff] [blame] | 821 | |
| 822 | input_handler_->HandleInputEvent( |
| 823 | blink::WebCoalescedInputEvent(*input_event, coalesced_events), |
| 824 | latency_info, dispatch_type); |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 825 | } |
| 826 | |
| 827 | void RenderWidget::OnCursorVisibilityChange(bool is_visible) { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 828 | if (GetWebWidget()) |
| 829 | GetWebWidget()->setCursorVisibilityState(is_visible); |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 830 | } |
| 831 | |
| 832 | void RenderWidget::OnMouseCaptureLost() { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 833 | if (GetWebWidget()) |
| 834 | GetWebWidget()->mouseCaptureLost(); |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 835 | } |
| 836 | |
alexmos | 5656749 | 2016-09-13 00:52:46 | [diff] [blame] | 837 | void RenderWidget::OnSetEditCommandsForNextKeyEvent( |
| 838 | const EditCommands& edit_commands) { |
| 839 | edit_commands_ = edit_commands; |
| 840 | } |
| 841 | |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 842 | void RenderWidget::OnSetFocus(bool enable) { |
lfg | e0c2792ec | 2016-05-11 18:52:08 | [diff] [blame] | 843 | has_focus_ = enable; |
| 844 | |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 845 | if (GetWebWidget()) |
| 846 | GetWebWidget()->setFocus(enable); |
lfg | e0c2792ec | 2016-05-11 18:52:08 | [diff] [blame] | 847 | |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 848 | for (auto& observer : render_frames_) |
| 849 | observer.RenderWidgetSetFocus(enable); |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 850 | } |
| 851 | |
dtapuska | 3d5624d3 | 2016-08-30 04:34:00 | [diff] [blame] | 852 | void RenderWidget::SetNeedsMainFrame() { |
| 853 | RenderWidgetCompositor* rwc = compositor(); |
| 854 | if (!rwc) |
| 855 | return; |
| 856 | rwc->setNeedsBeginFrame(); |
| 857 | } |
| 858 | |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 859 | /////////////////////////////////////////////////////////////////////////////// |
| 860 | // RenderWidgetCompositorDelegate |
| 861 | |
| 862 | void RenderWidget::ApplyViewportDeltas( |
| 863 | const gfx::Vector2dF& inner_delta, |
| 864 | const gfx::Vector2dF& outer_delta, |
| 865 | const gfx::Vector2dF& elastic_overscroll_delta, |
| 866 | float page_scale, |
| 867 | float top_controls_delta) { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 868 | GetWebWidget()->applyViewportDeltas(inner_delta, outer_delta, |
| 869 | elastic_overscroll_delta, page_scale, |
| 870 | top_controls_delta); |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 871 | } |
| 872 | |
| 873 | void RenderWidget::BeginMainFrame(double frame_time_sec) { |
dtapuska | 3d5624d3 | 2016-08-30 04:34:00 | [diff] [blame] | 874 | RenderThreadImpl* render_thread = RenderThreadImpl::current(); |
| 875 | // render_thread may be NULL in tests. |
| 876 | InputHandlerManager* input_handler_manager = |
| 877 | render_thread ? render_thread->input_handler_manager() : NULL; |
| 878 | if (input_handler_manager) |
dtapuska | 97286c88 | 2017-02-24 23:14:43 | [diff] [blame] | 879 | input_handler_manager->ProcessRafAlignedInputOnMainThread( |
| 880 | routing_id_, ui::EventTimeStampFromSeconds(frame_time_sec)); |
dtapuska | 3d5624d3 | 2016-08-30 04:34:00 | [diff] [blame] | 881 | |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 882 | GetWebWidget()->beginFrame(frame_time_sec); |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 883 | } |
| 884 | |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 885 | std::unique_ptr<cc::CompositorFrameSink> |
samans | d5db250 | 2017-01-13 23:18:27 | [diff] [blame] | 886 | RenderWidget::CreateCompositorFrameSink(const cc::FrameSinkId& frame_sink_id, |
| 887 | bool fallback) { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 888 | DCHECK(GetWebWidget()); |
[email protected] | 7912e82 | 2014-04-16 02:37:03 | [diff] [blame] | 889 | // For widgets that are never visible, we don't start the compositor, so we |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 890 | // never get a request for a cc::CompositorFrameSink. |
sievers | 71c62dd5 | 2015-10-07 01:44:39 | [diff] [blame] | 891 | DCHECK(!compositor_never_visible_); |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 892 | return RenderThreadImpl::current()->CreateCompositorFrameSink( |
samans | d5db250 | 2017-01-13 23:18:27 | [diff] [blame] | 893 | frame_sink_id, fallback, routing_id_, frame_swap_message_queue_, |
danakj | 83066a3 | 2016-06-21 02:34:49 | [diff] [blame] | 894 | GetURLForGraphicsContext3D()); |
[email protected] | ba91a79 | 2013-02-06 09:48:28 | [diff] [blame] | 895 | } |
| 896 | |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 897 | void RenderWidget::DidCommitAndDrawCompositorFrame() { |
| 898 | // NOTE: Tests may break if this event is renamed or moved. See |
| 899 | // tab_capture_performancetest.cc. |
| 900 | TRACE_EVENT0("gpu", "RenderWidget::DidCommitAndDrawCompositorFrame"); |
lfg | e0c2792ec | 2016-05-11 18:52:08 | [diff] [blame] | 901 | |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 902 | for (auto& observer : render_frames_) |
| 903 | observer.DidCommitAndDrawCompositorFrame(); |
lfg | e0c2792ec | 2016-05-11 18:52:08 | [diff] [blame] | 904 | |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 905 | // Notify subclasses that we initiated the paint operation. |
| 906 | DidInitiatePaint(); |
| 907 | } |
| 908 | |
| 909 | void RenderWidget::DidCommitCompositorFrame() { |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 910 | for (auto& observer : render_frames_) |
| 911 | observer.DidCommitCompositorFrame(); |
| 912 | for (auto& observer : render_frame_proxies_) |
| 913 | observer.DidCommitCompositorFrame(); |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 914 | } |
| 915 | |
| 916 | void RenderWidget::DidCompletePageScaleAnimation() {} |
| 917 | |
danakj | 6c872fc0 | 2016-10-22 04:29:49 | [diff] [blame] | 918 | void RenderWidget::DidReceiveCompositorFrameAck() { |
| 919 | TRACE_EVENT0("renderer", "RenderWidget::DidReceiveCompositorFrameAck"); |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 920 | |
piman | bfb2ceb | 2016-03-18 21:32:58 | [diff] [blame] | 921 | if (!next_paint_flags_ && !need_update_rect_for_auto_resize_) { |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 922 | return; |
| 923 | } |
| 924 | |
| 925 | ViewHostMsg_UpdateRect_Params params; |
| 926 | params.view_size = size_; |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 927 | params.flags = next_paint_flags_; |
| 928 | |
| 929 | Send(new ViewHostMsg_UpdateRect(routing_id_, params)); |
| 930 | next_paint_flags_ = 0; |
| 931 | need_update_rect_for_auto_resize_ = false; |
| 932 | } |
| 933 | |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 934 | bool RenderWidget::IsClosing() const { |
| 935 | return host_closing_; |
| 936 | } |
| 937 | |
danakj | 53eccbc | 2016-03-02 22:51:07 | [diff] [blame] | 938 | void RenderWidget::RequestScheduleAnimation() { |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 939 | scheduleAnimation(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 940 | } |
| 941 | |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 942 | void RenderWidget::UpdateVisualState() { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 943 | GetWebWidget()->updateAllLifecyclePhases(); |
tasak | b95dbb50c | 2017-02-08 18:07:50 | [diff] [blame] | 944 | |
| 945 | if (time_to_first_active_paint_recorded_) |
| 946 | return; |
| 947 | |
| 948 | RenderThreadImpl* render_thread_impl = RenderThreadImpl::current(); |
| 949 | if (!render_thread_impl->NeedsToRecordFirstActivePaint()) |
| 950 | return; |
| 951 | |
| 952 | time_to_first_active_paint_recorded_ = true; |
| 953 | base::TimeDelta sample = base::TimeTicks::Now() - was_shown_time_; |
| 954 | UMA_HISTOGRAM_TIMES("PurgeAndSuspend.Experimental.TimeToFirstActivePaint", |
| 955 | sample); |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 956 | } |
| 957 | |
| 958 | void RenderWidget::WillBeginCompositorFrame() { |
| 959 | TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame"); |
| 960 | |
dglazkov | 06854c5c | 2016-08-31 00:19:59 | [diff] [blame] | 961 | // The UpdateTextInputState can result in further layout and possibly |
| 962 | // enable GPU acceleration so they need to be called before any painting |
| 963 | // is done. |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 964 | UpdateTextInputState(); |
dglazkov | 06854c5c | 2016-08-31 00:19:59 | [diff] [blame] | 965 | UpdateSelectionBounds(); |
| 966 | |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 967 | for (auto& observer : render_frame_proxies_) |
| 968 | observer.WillBeginCompositorFrame(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 969 | } |
| 970 | |
jbroman | 6ccbc7d47 | 2016-07-27 04:45:41 | [diff] [blame] | 971 | std::unique_ptr<cc::SwapPromise> RenderWidget::RequestCopyOfOutputForLayoutTest( |
| 972 | std::unique_ptr<cc::CopyOutputRequest> request) { |
| 973 | return RenderThreadImpl::current()->RequestCopyOfOutputForLayoutTest( |
| 974 | routing_id_, std::move(request)); |
| 975 | } |
| 976 | |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 977 | /////////////////////////////////////////////////////////////////////////////// |
| 978 | // RenderWidgetInputHandlerDelegate |
| 979 | |
avi | d7d6b2e | 2016-03-04 19:41:17 | [diff] [blame] | 980 | void RenderWidget::FocusChangeComplete() { |
| 981 | if (owner_delegate_) |
| 982 | owner_delegate_->RenderWidgetFocusChangeComplete(); |
| 983 | } |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 984 | |
| 985 | bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const { |
avi | d7d6b2e | 2016-03-04 19:41:17 | [diff] [blame] | 986 | if (owner_delegate_) |
| 987 | return owner_delegate_->DoesRenderWidgetHaveTouchEventHandlersAt(point); |
| 988 | |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 989 | return true; |
| 990 | } |
| 991 | |
dtapuska | 1827dd2 | 2016-03-11 15:24:59 | [diff] [blame] | 992 | void RenderWidget::ObserveGestureEventAndResult( |
| 993 | const blink::WebGestureEvent& gesture_event, |
| 994 | const gfx::Vector2dF& unused_delta, |
| 995 | bool event_processed) { |
| 996 | if (!compositor_deps_->IsElasticOverscrollEnabled()) |
| 997 | return; |
| 998 | |
| 999 | cc::InputHandlerScrollResult scroll_result; |
| 1000 | scroll_result.did_scroll = event_processed; |
| 1001 | scroll_result.did_overscroll_root = !unused_delta.IsZero(); |
| 1002 | scroll_result.unused_scroll_delta = unused_delta; |
| 1003 | |
| 1004 | RenderThreadImpl* render_thread = RenderThreadImpl::current(); |
| 1005 | InputHandlerManager* input_handler_manager = |
| 1006 | render_thread ? render_thread->input_handler_manager() : NULL; |
| 1007 | if (input_handler_manager) { |
| 1008 | input_handler_manager->ObserveGestureEventAndResultOnMainThread( |
| 1009 | routing_id_, gesture_event, scroll_result); |
| 1010 | } |
| 1011 | } |
| 1012 | |
avi | d7d6b2e | 2016-03-04 19:41:17 | [diff] [blame] | 1013 | void RenderWidget::OnDidHandleKeyEvent() { |
alexmos | 5656749 | 2016-09-13 00:52:46 | [diff] [blame] | 1014 | ClearEditCommands(); |
| 1015 | } |
| 1016 | |
| 1017 | void RenderWidget::SetEditCommandForNextKeyEvent(const std::string& name, |
| 1018 | const std::string& value) { |
| 1019 | ClearEditCommands(); |
| 1020 | edit_commands_.emplace_back(name, value); |
| 1021 | } |
| 1022 | |
| 1023 | void RenderWidget::ClearEditCommands() { |
| 1024 | edit_commands_.clear(); |
avi | d7d6b2e | 2016-03-04 19:41:17 | [diff] [blame] | 1025 | } |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1026 | |
chongz | a8ba91fc | 2016-08-16 21:39:17 | [diff] [blame] | 1027 | void RenderWidget::OnDidOverscroll(const ui::DidOverscrollParams& params) { |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1028 | Send(new InputHostMsg_DidOverscroll(routing_id_, params)); |
| 1029 | } |
| 1030 | |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 1031 | void RenderWidget::OnInputEventAck( |
| 1032 | std::unique_ptr<InputEventAck> input_event_ack) { |
dtapuska | 014ed08 | 2016-11-11 21:58:48 | [diff] [blame] | 1033 | SendOrCrash( |
| 1034 | new InputHostMsg_HandleInputEvent_ACK(routing_id_, *input_event_ack)); |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1035 | } |
| 1036 | |
dtapuska | 4661692 | 2016-03-17 22:52:01 | [diff] [blame] | 1037 | void RenderWidget::NotifyInputEventHandled( |
dtapuska | b08721e6 | 2016-06-29 03:35:07 | [diff] [blame] | 1038 | blink::WebInputEvent::Type handled_type, |
skyostil | cff6288 | 2017-01-28 13:18:04 | [diff] [blame] | 1039 | blink::WebInputEventResult result, |
dtapuska | b08721e6 | 2016-06-29 03:35:07 | [diff] [blame] | 1040 | InputEventAckState ack_result) { |
dtapuska | 0bd451a | 2016-02-18 17:08:10 | [diff] [blame] | 1041 | RenderThreadImpl* render_thread = RenderThreadImpl::current(); |
| 1042 | InputHandlerManager* input_handler_manager = |
| 1043 | render_thread ? render_thread->input_handler_manager() : NULL; |
| 1044 | if (input_handler_manager) { |
dtapuska | b08721e6 | 2016-06-29 03:35:07 | [diff] [blame] | 1045 | input_handler_manager->NotifyInputEventHandledOnMainThread( |
skyostil | cff6288 | 2017-01-28 13:18:04 | [diff] [blame] | 1046 | routing_id_, handled_type, result, ack_result); |
dtapuska | 0bd451a | 2016-02-18 17:08:10 | [diff] [blame] | 1047 | } |
| 1048 | } |
| 1049 | |
fsamuel | e8326c74 | 2016-01-12 00:49:39 | [diff] [blame] | 1050 | void RenderWidget::SetInputHandler(RenderWidgetInputHandler* input_handler) { |
| 1051 | // Nothing to do here. RenderWidget created the |input_handler| and will take |
| 1052 | // ownership of it. We just verify here that we don't already have an input |
| 1053 | // handler. |
| 1054 | DCHECK(!input_handler_); |
| 1055 | } |
| 1056 | |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1057 | void RenderWidget::ShowVirtualKeyboard() { |
| 1058 | UpdateTextInputStateInternal(true, false); |
| 1059 | } |
| 1060 | |
changwan | 62f5729 | 2017-02-17 08:28:25 | [diff] [blame] | 1061 | void RenderWidget::ClearTextInputState() { |
| 1062 | text_input_info_ = blink::WebTextInputInfo(); |
| 1063 | text_input_type_ = ui::TextInputType::TEXT_INPUT_TYPE_NONE; |
| 1064 | text_input_mode_ = ui::TextInputMode::TEXT_INPUT_MODE_DEFAULT; |
| 1065 | can_compose_inline_ = false; |
| 1066 | text_input_flags_ = 0; |
| 1067 | } |
| 1068 | |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1069 | void RenderWidget::UpdateTextInputState() { |
| 1070 | UpdateTextInputStateInternal(false, false); |
| 1071 | } |
| 1072 | |
| 1073 | void RenderWidget::UpdateTextInputStateInternal(bool show_virtual_keyboard, |
| 1074 | bool reply_to_request) { |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1075 | TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState"); |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1076 | |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1077 | if (ime_event_guard_) { |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1078 | DCHECK(!reply_to_request); |
| 1079 | // show_virtual_keyboard should still be effective even if it was set inside |
| 1080 | // the IME |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1081 | // event guard. |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1082 | if (show_virtual_keyboard) |
| 1083 | ime_event_guard_->set_show_virtual_keyboard(true); |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1084 | return; |
| 1085 | } |
| 1086 | |
dglazkov | 97b6c2b | 2016-10-25 17:35:55 | [diff] [blame] | 1087 | ui::TextInputType new_type = GetTextInputType(); |
| 1088 | if (IsDateTimeInput(new_type)) |
| 1089 | return; // Not considered as a text input field in WebKit/Chromium. |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1090 | |
dglazkov | 97b6c2b | 2016-10-25 17:35:55 | [diff] [blame] | 1091 | blink::WebTextInputInfo new_info; |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 1092 | if (auto* controller = GetInputMethodController()) |
| 1093 | new_info = controller->textInputInfo(); |
dtapuska | c4dd5be | 2016-10-25 15:11:10 | [diff] [blame] | 1094 | const ui::TextInputMode new_mode = |
| 1095 | ConvertWebTextInputMode(new_info.inputMode); |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1096 | |
| 1097 | bool new_can_compose_inline = CanComposeInline(); |
| 1098 | |
| 1099 | // Only sends text input params if they are changed or if the ime should be |
| 1100 | // shown. |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1101 | if (show_virtual_keyboard || reply_to_request || |
changwan | 38c3eb61 | 2016-12-09 01:45:56 | [diff] [blame] | 1102 | text_input_type_ != new_type || text_input_mode_ != new_mode || |
| 1103 | text_input_info_ != new_info || |
| 1104 | can_compose_inline_ != new_can_compose_inline) { |
ekaramad | 9053e57b | 2016-04-26 20:00:38 | [diff] [blame] | 1105 | TextInputState params; |
dglazkov | 97b6c2b | 2016-10-25 17:35:55 | [diff] [blame] | 1106 | params.type = new_type; |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1107 | params.mode = new_mode; |
| 1108 | params.flags = new_info.flags; |
| 1109 | params.value = new_info.value.utf8(); |
| 1110 | params.selection_start = new_info.selectionStart; |
| 1111 | params.selection_end = new_info.selectionEnd; |
| 1112 | params.composition_start = new_info.compositionStart; |
| 1113 | params.composition_end = new_info.compositionEnd; |
| 1114 | params.can_compose_inline = new_can_compose_inline; |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1115 | // TODO(changwan): change instances of show_ime_if_needed to |
| 1116 | // show_virtual_keyboard. |
| 1117 | params.show_ime_if_needed = show_virtual_keyboard; |
| 1118 | params.reply_to_request = reply_to_request; |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1119 | Send(new ViewHostMsg_TextInputStateChanged(routing_id(), params)); |
| 1120 | |
| 1121 | text_input_info_ = new_info; |
dglazkov | 97b6c2b | 2016-10-25 17:35:55 | [diff] [blame] | 1122 | text_input_type_ = new_type; |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1123 | text_input_mode_ = new_mode; |
| 1124 | can_compose_inline_ = new_can_compose_inline; |
| 1125 | text_input_flags_ = new_info.flags; |
| 1126 | } |
| 1127 | } |
| 1128 | |
| 1129 | bool RenderWidget::WillHandleGestureEvent(const blink::WebGestureEvent& event) { |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 1130 | possible_drag_event_info_.event_source = |
| 1131 | ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH; |
| 1132 | possible_drag_event_info_.event_location = |
| 1133 | gfx::Point(event.globalX, event.globalY); |
avi | d7d6b2e | 2016-03-04 19:41:17 | [diff] [blame] | 1134 | |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1135 | return false; |
| 1136 | } |
| 1137 | |
| 1138 | bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) { |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 1139 | for (auto& observer : render_frames_) |
| 1140 | observer.RenderWidgetWillHandleMouseEvent(); |
lfg | e0c2792ec | 2016-05-11 18:52:08 | [diff] [blame] | 1141 | |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 1142 | possible_drag_event_info_.event_source = |
| 1143 | ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE; |
| 1144 | possible_drag_event_info_.event_location = |
| 1145 | gfx::Point(event.globalX, event.globalY); |
| 1146 | |
avi | d7d6b2e | 2016-03-04 19:41:17 | [diff] [blame] | 1147 | if (owner_delegate_) |
| 1148 | return owner_delegate_->RenderWidgetWillHandleMouseEvent(event); |
| 1149 | |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1150 | return false; |
[email protected] | fd84779 | 2013-10-24 17:12:35 | [diff] [blame] | 1151 | } |
| 1152 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1153 | /////////////////////////////////////////////////////////////////////////////// |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1154 | // RenderWidgetScreenMetricsDelegate |
| 1155 | |
| 1156 | void RenderWidget::Redraw() { |
| 1157 | set_next_paint_is_resize_ack(); |
| 1158 | if (compositor_) |
| 1159 | compositor_->SetNeedsRedrawRect(gfx::Rect(size_)); |
| 1160 | } |
| 1161 | |
bokan | c63441c | 2016-04-27 15:49:12 | [diff] [blame] | 1162 | void RenderWidget::ResizeWebWidget() { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1163 | GetWebWidget()->resize(GetSizeForWebWidget()); |
bokan | c63441c | 2016-04-27 15:49:12 | [diff] [blame] | 1164 | } |
| 1165 | |
| 1166 | gfx::Size RenderWidget::GetSizeForWebWidget() const { |
| 1167 | if (IsUseZoomForDSFEnabled()) |
| 1168 | return gfx::ScaleToCeiledSize(size_, GetOriginalDeviceScaleFactor()); |
| 1169 | |
| 1170 | return size_; |
| 1171 | } |
| 1172 | |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1173 | void RenderWidget::Resize(const ResizeParams& params) { |
engedy | 6cb63c9 | 2016-02-23 14:14:58 | [diff] [blame] | 1174 | bool orientation_changed = |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 1175 | screen_info_.orientation_angle != params.screen_info.orientation_angle || |
| 1176 | screen_info_.orientation_type != params.screen_info.orientation_type; |
engedy | 6cb63c9 | 2016-02-23 14:14:58 | [diff] [blame] | 1177 | |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1178 | screen_info_ = params.screen_info; |
wjmaclean | 8a795f3 | 2016-08-11 23:49:58 | [diff] [blame] | 1179 | |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 1180 | if (device_scale_factor_ != screen_info_.device_scale_factor) { |
| 1181 | device_scale_factor_ = screen_info_.device_scale_factor; |
wjmaclean | 8a795f3 | 2016-08-11 23:49:58 | [diff] [blame] | 1182 | OnDeviceScaleFactorChanged(); |
| 1183 | ScheduleComposite(); |
| 1184 | } |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1185 | |
| 1186 | if (resizing_mode_selector_->NeverUsesSynchronousResize()) { |
| 1187 | // A resize ack shouldn't be requested if we have not ACK'd the previous |
| 1188 | // one. |
| 1189 | DCHECK(!params.needs_resize_ack || !next_paint_is_resize_ack()); |
| 1190 | } |
| 1191 | |
| 1192 | // Ignore this during shutdown. |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1193 | if (!GetWebWidget()) |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1194 | return; |
| 1195 | |
ianwen | e5fc578 | 2016-08-18 04:05:15 | [diff] [blame] | 1196 | if (compositor_) { |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1197 | compositor_->setViewportSize(params.physical_backing_size); |
ianwen | e5fc578 | 2016-08-18 04:05:15 | [diff] [blame] | 1198 | compositor_->setBottomControlsHeight(params.bottom_controls_height); |
ccameron | 24c87c3 | 2017-03-14 21:50:42 | [diff] [blame] | 1199 | compositor_->SetRasterColorSpace( |
| 1200 | screen_info_.icc_profile.GetParametricColorSpace()); |
ianwen | e5fc578 | 2016-08-18 04:05:15 | [diff] [blame] | 1201 | } |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1202 | |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1203 | visible_viewport_size_ = params.visible_viewport_size; |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1204 | |
| 1205 | // NOTE: We may have entered fullscreen mode without changing our size. |
| 1206 | bool fullscreen_change = |
| 1207 | is_fullscreen_granted_ != params.is_fullscreen_granted; |
| 1208 | is_fullscreen_granted_ = params.is_fullscreen_granted; |
| 1209 | display_mode_ = params.display_mode; |
| 1210 | |
bokan | c63441c | 2016-04-27 15:49:12 | [diff] [blame] | 1211 | size_ = params.new_size; |
| 1212 | physical_backing_size_ = params.physical_backing_size; |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1213 | |
bokan | c63441c | 2016-04-27 15:49:12 | [diff] [blame] | 1214 | ResizeWebWidget(); |
bokan | 71cb5b1 | 2016-04-27 03:45:22 | [diff] [blame] | 1215 | |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1216 | WebSize visual_viewport_size; |
| 1217 | |
| 1218 | if (IsUseZoomForDSFEnabled()) { |
oshima | 50872a7 | 2016-03-04 13:26:18 | [diff] [blame] | 1219 | visual_viewport_size = gfx::ScaleToCeiledSize( |
| 1220 | params.visible_viewport_size, |
| 1221 | GetOriginalDeviceScaleFactor()); |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1222 | } else { |
| 1223 | visual_viewport_size = visible_viewport_size_; |
| 1224 | } |
| 1225 | |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1226 | GetWebWidget()->resizeVisualViewport(visual_viewport_size); |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1227 | |
bokan | c63441c | 2016-04-27 15:49:12 | [diff] [blame] | 1228 | // When resizing, we want to wait to paint before ACK'ing the resize. This |
| 1229 | // ensures that we only resize as fast as we can paint. We only need to |
| 1230 | // send an ACK if we are resized to a non-empty rect. |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1231 | if (params.new_size.IsEmpty() || params.physical_backing_size.IsEmpty()) { |
| 1232 | // In this case there is no paint/composite and therefore no |
| 1233 | // ViewHostMsg_UpdateRect to send the resize ack with. We'd need to send the |
| 1234 | // ack through a fake ViewHostMsg_UpdateRect or a different message. |
| 1235 | DCHECK(!params.needs_resize_ack); |
| 1236 | } |
| 1237 | |
| 1238 | // Send the Resize_ACK flag once we paint again if requested. |
| 1239 | if (params.needs_resize_ack) |
| 1240 | set_next_paint_is_resize_ack(); |
| 1241 | |
| 1242 | if (fullscreen_change) |
| 1243 | DidToggleFullscreen(); |
| 1244 | |
engedy | 6cb63c9 | 2016-02-23 14:14:58 | [diff] [blame] | 1245 | if (orientation_changed) |
| 1246 | OnOrientationChange(); |
| 1247 | |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1248 | // If a resize ack is requested and it isn't set-up, then no more resizes will |
| 1249 | // come in and in general things will go wrong. |
| 1250 | DCHECK(!params.needs_resize_ack || next_paint_is_resize_ack()); |
| 1251 | } |
| 1252 | |
| 1253 | void RenderWidget::SetScreenMetricsEmulationParameters( |
| 1254 | bool enabled, |
| 1255 | const blink::WebDeviceEmulationParams& params) { |
| 1256 | // This is only supported in RenderView. |
| 1257 | NOTREACHED(); |
| 1258 | } |
| 1259 | |
| 1260 | void RenderWidget::SetScreenRects(const gfx::Rect& view_screen_rect, |
| 1261 | const gfx::Rect& window_screen_rect) { |
| 1262 | view_screen_rect_ = view_screen_rect; |
| 1263 | window_screen_rect_ = window_screen_rect; |
| 1264 | } |
| 1265 | |
| 1266 | /////////////////////////////////////////////////////////////////////////////// |
[email protected] | f98d7e3c | 2010-09-13 22:30:46 | [diff] [blame] | 1267 | // WebWidgetClient |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1268 | |
[email protected] | 3a1c8a803 | 2013-03-18 22:35:32 | [diff] [blame] | 1269 | void RenderWidget::AutoResizeCompositor() { |
danakj | ddaec91 | 2015-09-25 19:38:40 | [diff] [blame] | 1270 | physical_backing_size_ = gfx::ScaleToCeiledSize(size_, device_scale_factor_); |
[email protected] | 97e1bf7 | 2013-03-06 14:06:05 | [diff] [blame] | 1271 | if (compositor_) |
oshima | 750cb434 | 2015-10-31 00:59:01 | [diff] [blame] | 1272 | compositor_->setViewportSize(physical_backing_size_); |
[email protected] | 97e1bf7 | 2013-03-06 14:06:05 | [diff] [blame] | 1273 | } |
| 1274 | |
loyso | 50b51c2 | 2017-01-10 07:18:37 | [diff] [blame] | 1275 | blink::WebLayerTreeView* RenderWidget::initializeLayerTreeView() { |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 1276 | DCHECK(!host_closing_); |
| 1277 | |
loyso | 6e6efc4 | 2017-01-21 02:23:03 | [diff] [blame] | 1278 | compositor_ = RenderWidgetCompositor::Create(this, compositor_deps_); |
| 1279 | auto animation_host = cc::AnimationHost::CreateMainInstance(); |
| 1280 | |
| 1281 | auto layer_tree_host = RenderWidgetCompositor::CreateLayerTreeHost( |
| 1282 | compositor_.get(), compositor_.get(), animation_host.get(), |
| 1283 | compositor_deps_, device_scale_factor_, screen_info_); |
| 1284 | compositor_->Initialize(std::move(layer_tree_host), |
| 1285 | std::move(animation_host)); |
| 1286 | |
wjmaclean | 1d97062 | 2017-01-21 22:28:24 | [diff] [blame] | 1287 | compositor_->SetIsForOopif(for_oopif_); |
oshima | 750cb434 | 2015-10-31 00:59:01 | [diff] [blame] | 1288 | compositor_->setViewportSize(physical_backing_size_); |
oshima | d527903 | 2015-12-16 18:22:33 | [diff] [blame] | 1289 | OnDeviceScaleFactorChanged(); |
ccameron | 2c6d270 | 2017-03-08 19:42:42 | [diff] [blame] | 1290 | compositor_->SetRasterColorSpace(screen_info_.icc_profile.GetColorSpace()); |
kenrb | 5d78b84 | 2017-03-06 21:06:01 | [diff] [blame] | 1291 | compositor_->SetContentSourceId(current_content_source_id_); |
sievers | 71c62dd5 | 2015-10-07 01:44:39 | [diff] [blame] | 1292 | // For background pages and certain tests, we don't want to trigger |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 1293 | // CompositorFrameSink creation. |
sievers | 71c62dd5 | 2015-10-07 01:44:39 | [diff] [blame] | 1294 | if (compositor_never_visible_ || !RenderThreadImpl::current()) |
| 1295 | compositor_->SetNeverVisible(); |
| 1296 | |
piman | c4af307 | 2015-10-02 03:45:59 | [diff] [blame] | 1297 | StartCompositor(); |
staraz | 067f5824 | 2016-11-07 21:06:41 | [diff] [blame] | 1298 | DCHECK_NE(MSG_ROUTING_NONE, routing_id_); |
| 1299 | compositor_->SetFrameSinkId( |
| 1300 | cc::FrameSinkId(RenderThread::Get()->GetClientId(), routing_id_)); |
loyso | 50b51c2 | 2017-01-10 07:18:37 | [diff] [blame] | 1301 | |
wjmaclean | 1d97062 | 2017-01-21 22:28:24 | [diff] [blame] | 1302 | RenderThreadImpl* render_thread = RenderThreadImpl::current(); |
| 1303 | // render_thread may be NULL in tests. |
| 1304 | InputHandlerManager* input_handler_manager = |
| 1305 | render_thread ? render_thread->input_handler_manager() : NULL; |
| 1306 | if (input_handler_manager) { |
| 1307 | input_handler_manager->AddInputHandler( |
| 1308 | routing_id_, compositor()->GetInputHandler(), |
| 1309 | weak_ptr_factory_.GetWeakPtr(), |
| 1310 | compositor_deps_->IsScrollAnimatorEnabled()); |
| 1311 | has_added_input_handler_ = true; |
| 1312 | } |
| 1313 | |
loyso | 50b51c2 | 2017-01-10 07:18:37 | [diff] [blame] | 1314 | return compositor_.get(); |
[email protected] | e195e58 | 2013-03-08 01:32:59 | [diff] [blame] | 1315 | } |
| 1316 | |
enne | f3c5814 | 2014-12-09 21:44:38 | [diff] [blame] | 1317 | void RenderWidget::WillCloseLayerTreeView() { |
| 1318 | if (host_closing_) |
| 1319 | return; |
| 1320 | |
| 1321 | // Prevent new compositors or output surfaces from being created. |
| 1322 | host_closing_ = true; |
| 1323 | |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 1324 | // Always send this notification to prevent new layer tree views from |
| 1325 | // being created, even if one hasn't been created yet. |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1326 | if (blink::WebWidget* widget = GetWebWidget()) |
| 1327 | widget->willCloseLayerTreeView(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 1328 | } |
| 1329 | |
dglazkov | f0e1d6d | 2015-10-10 02:13:48 | [diff] [blame] | 1330 | void RenderWidget::didMeaningfulLayout(blink::WebMeaningfulLayout layout_type) { |
| 1331 | if (layout_type == blink::WebMeaningfulLayout::VisuallyNonEmpty) { |
| 1332 | QueueMessage(new ViewHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_), |
| 1333 | MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE); |
| 1334 | } |
dglazkov | 79c42610 | 2015-08-31 21:22:43 | [diff] [blame] | 1335 | |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 1336 | for (auto& observer : render_frames_) |
| 1337 | observer.DidMeaningfulLayout(layout_type); |
dglazkov | 79c42610 | 2015-08-31 21:22:43 | [diff] [blame] | 1338 | } |
| 1339 | |
jdduke | 491a3f0c | 2015-06-15 23:30:26 | [diff] [blame] | 1340 | void RenderWidget::ScheduleComposite() { |
| 1341 | if (compositor_ && |
| 1342 | compositor_deps_->GetCompositorImplThreadTaskRunner().get()) { |
skyostil | 32650d2 | 2016-09-26 16:58:23 | [diff] [blame] | 1343 | compositor_->setNeedsCompositorUpdate(); |
jdduke | 491a3f0c | 2015-06-15 23:30:26 | [diff] [blame] | 1344 | } |
| 1345 | } |
| 1346 | |
| 1347 | void RenderWidget::ScheduleCompositeWithForcedRedraw() { |
| 1348 | if (compositor_) { |
| 1349 | // Regardless of whether threaded compositing is enabled, always |
| 1350 | // use this mechanism to force the compositor to redraw. However, |
| 1351 | // the invalidation code path below is still needed for the |
| 1352 | // non-threaded case. |
| 1353 | compositor_->SetNeedsForcedRedraw(); |
| 1354 | } |
| 1355 | ScheduleComposite(); |
[email protected] | 6fceb91 | 2013-02-15 06:24:15 | [diff] [blame] | 1356 | } |
| 1357 | |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1358 | // static |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 1359 | std::unique_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl( |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1360 | IPC::Message* msg, |
| 1361 | MessageDeliveryPolicy policy, |
| 1362 | FrameSwapMessageQueue* frame_swap_message_queue, |
| 1363 | scoped_refptr<IPC::SyncMessageFilter> sync_message_filter, |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1364 | int source_frame_number) { |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1365 | bool first_message_for_frame = false; |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 1366 | frame_swap_message_queue->QueueMessageForFrame(policy, source_frame_number, |
| 1367 | base::WrapUnique(msg), |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1368 | &first_message_for_frame); |
| 1369 | if (first_message_for_frame) { |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 1370 | std::unique_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise( |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1371 | sync_message_filter, frame_swap_message_queue, source_frame_number)); |
dcheng | 4b6b5ff | 2014-10-16 00:42:06 | [diff] [blame] | 1372 | return promise; |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1373 | } |
dcheng | 4b6b5ff | 2014-10-16 00:42:06 | [diff] [blame] | 1374 | return nullptr; |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1375 | } |
| 1376 | |
| 1377 | void RenderWidget::QueueMessage(IPC::Message* msg, |
| 1378 | MessageDeliveryPolicy policy) { |
| 1379 | // RenderThreadImpl::current() is NULL in some tests. |
| 1380 | if (!compositor_ || !RenderThreadImpl::current()) { |
| 1381 | Send(msg); |
| 1382 | return; |
| 1383 | } |
| 1384 | |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 1385 | std::unique_ptr<cc::SwapPromise> swap_promise = |
| 1386 | QueueMessageImpl(msg, policy, frame_swap_message_queue_.get(), |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1387 | RenderThreadImpl::current()->sync_message_filter(), |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1388 | compositor_->GetSourceFrameNumber()); |
| 1389 | |
| 1390 | if (swap_promise) { |
dcheng | 07945f63 | 2015-12-26 07:59:32 | [diff] [blame] | 1391 | compositor_->QueueSwapPromise(std::move(swap_promise)); |
igsolla | eab34cc | 2015-02-20 11:33:35 | [diff] [blame] | 1392 | // Request a commit. This might either A) request a commit ahead of time |
| 1393 | // or B) request a commit which is not needed because there are not |
| 1394 | // pending updates. If B) then the commit will be skipped and the swap |
| 1395 | // promises will be broken (see EarlyOut_NoUpdates). To achieve that we |
| 1396 | // call SetNeedsUpdateLayers instead of SetNeedsCommit so that |
| 1397 | // can_cancel_commit is not unset. |
| 1398 | compositor_->SetNeedsUpdateLayers(); |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1399 | } |
| 1400 | } |
| 1401 | |
[email protected] | 4873c7d | 2009-07-16 06:36:28 | [diff] [blame] | 1402 | void RenderWidget::didChangeCursor(const WebCursorInfo& cursor_info) { |
[email protected] | 7c51b0ee | 2009-07-08 21:49:30 | [diff] [blame] | 1403 | // TODO(darin): Eliminate this temporary. |
[email protected] | 9ec8771 | 2013-05-24 23:23:52 | [diff] [blame] | 1404 | WebCursor cursor; |
tfarina | 75a0abf | 2015-10-06 15:07:18 | [diff] [blame] | 1405 | InitializeCursorFromWebCursorInfo(&cursor, cursor_info); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1406 | // Only send a SetCursor message if we need to make a change. |
| 1407 | if (!current_cursor_.IsEqual(cursor)) { |
| 1408 | current_cursor_ = cursor; |
| 1409 | Send(new ViewHostMsg_SetCursor(routing_id_, cursor)); |
| 1410 | } |
| 1411 | } |
| 1412 | |
| 1413 | // We are supposed to get a single call to Show for a newly created RenderWidget |
| 1414 | // that was created via RenderWidget::CreateWebView. So, we wait until this |
| 1415 | // point to dispatch the ShowWidget message. |
| 1416 | // |
| 1417 | // This method provides us with the information about how to display the newly |
[email protected] | 5f9de588 | 2011-09-30 23:36:28 | [diff] [blame] | 1418 | // created RenderWidget (i.e., as a blocked popup or as a new tab). |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1419 | // |
nick | f7b3822 | 2016-11-22 21:59:35 | [diff] [blame] | 1420 | void RenderWidget::show(WebNavigationPolicy policy) { |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1421 | DCHECK(!did_show_) << "received extraneous Show call"; |
| 1422 | DCHECK(routing_id_ != MSG_ROUTING_NONE); |
nick | f7b3822 | 2016-11-22 21:59:35 | [diff] [blame] | 1423 | DCHECK(!show_callback_.is_null()); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1424 | |
[email protected] | 8de12d94 | 2010-11-17 20:42:44 | [diff] [blame] | 1425 | if (did_show_) |
| 1426 | return; |
| 1427 | |
| 1428 | did_show_ = true; |
nick | f7b3822 | 2016-11-22 21:59:35 | [diff] [blame] | 1429 | |
| 1430 | // The opener is responsible for actually showing this widget. |
| 1431 | show_callback_.Run(this, policy, initial_rect_); |
nick | 5ae4d2d | 2017-01-06 01:18:35 | [diff] [blame] | 1432 | show_callback_.Reset(); |
nick | f7b3822 | 2016-11-22 21:59:35 | [diff] [blame] | 1433 | |
bokan | c007c3a | 2015-02-03 07:15:56 | [diff] [blame] | 1434 | // NOTE: initial_rect_ may still have its default values at this point, but |
[email protected] | 8de12d94 | 2010-11-17 20:42:44 | [diff] [blame] | 1435 | // that's okay. It'll be ignored if as_popup is false, or the browser |
| 1436 | // process will impose a default position otherwise. |
bokan | c007c3a | 2015-02-03 07:15:56 | [diff] [blame] | 1437 | SetPendingWindowRect(initial_rect_); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1438 | } |
| 1439 | |
[email protected] | 2533ce1 | 2009-05-09 00:02:24 | [diff] [blame] | 1440 | void RenderWidget::DoDeferredClose() { |
enne | f3c5814 | 2014-12-09 21:44:38 | [diff] [blame] | 1441 | WillCloseLayerTreeView(); |
[email protected] | 2533ce1 | 2009-05-09 00:02:24 | [diff] [blame] | 1442 | Send(new ViewHostMsg_Close(routing_id_)); |
| 1443 | } |
| 1444 | |
dgozman | cf9039cd | 2015-04-06 12:01:31 | [diff] [blame] | 1445 | void RenderWidget::NotifyOnClose() { |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 1446 | for (auto& observer : render_frames_) |
| 1447 | observer.WidgetWillClose(); |
dgozman | cf9039cd | 2015-04-06 12:01:31 | [diff] [blame] | 1448 | } |
| 1449 | |
[email protected] | 4873c7d | 2009-07-16 06:36:28 | [diff] [blame] | 1450 | void RenderWidget::closeWidgetSoon() { |
skyostil | ed8969c | 2015-07-20 16:57:08 | [diff] [blame] | 1451 | DCHECK(content::RenderThread::Get()); |
[email protected] | e1c3a55 | 2012-05-04 20:51:32 | [diff] [blame] | 1452 | if (is_swapped_out_) { |
| 1453 | // This widget is currently swapped out, and the active widget is in a |
| 1454 | // different process. Have the browser route the close request to the |
| 1455 | // active widget instead, so that the correct unload handlers are run. |
| 1456 | Send(new ViewHostMsg_RouteCloseEvent(routing_id_)); |
| 1457 | return; |
| 1458 | } |
| 1459 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1460 | // If a page calls window.close() twice, we'll end up here twice, but that's |
| 1461 | // OK. It is safe to send multiple Close messages. |
| 1462 | |
[email protected] | 2533ce1 | 2009-05-09 00:02:24 | [diff] [blame] | 1463 | // Ask the RenderWidgetHost to initiate close. We could be called from deep |
| 1464 | // in Javascript. If we ask the RendwerWidgetHost to close now, the window |
| 1465 | // could be closed before the JS finishes executing. So instead, post a |
| 1466 | // message back to the message loop, which won't run until the JS is |
| 1467 | // complete, and then the Close message can be sent. |
skyostil | ed8969c | 2015-07-20 16:57:08 | [diff] [blame] | 1468 | base::ThreadTaskRunnerHandle::Get()->PostTask( |
[email protected] | 32876ae | 2011-11-15 22:25:21 | [diff] [blame] | 1469 | FROM_HERE, base::Bind(&RenderWidget::DoDeferredClose, this)); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1470 | } |
| 1471 | |
[email protected] | 9017d785 | 2013-11-21 17:47:35 | [diff] [blame] | 1472 | void RenderWidget::QueueSyntheticGesture( |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 1473 | std::unique_ptr<SyntheticGestureParams> gesture_params, |
[email protected] | 9017d785 | 2013-11-21 17:47:35 | [diff] [blame] | 1474 | const SyntheticGestureCompletionCallback& callback) { |
| 1475 | DCHECK(!callback.is_null()); |
| 1476 | |
| 1477 | pending_synthetic_gesture_callbacks_.push(callback); |
| 1478 | |
| 1479 | SyntheticGesturePacket gesture_packet; |
dcheng | 07945f63 | 2015-12-26 07:59:32 | [diff] [blame] | 1480 | gesture_packet.set_gesture_params(std::move(gesture_params)); |
[email protected] | 9017d785 | 2013-11-21 17:47:35 | [diff] [blame] | 1481 | |
| 1482 | Send(new InputHostMsg_QueueSyntheticGesture(routing_id_, gesture_packet)); |
| 1483 | } |
| 1484 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1485 | void RenderWidget::Close() { |
[email protected] | 404630b | 2014-07-03 19:33:03 | [diff] [blame] | 1486 | screen_metrics_emulator_.reset(); |
enne | f3c5814 | 2014-12-09 21:44:38 | [diff] [blame] | 1487 | WillCloseLayerTreeView(); |
| 1488 | compositor_.reset(); |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1489 | if (webwidget_internal_) { |
| 1490 | webwidget_internal_->close(); |
| 1491 | webwidget_internal_ = nullptr; |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1492 | } |
| 1493 | } |
| 1494 | |
bokan | 841fdc7 | 2016-10-06 00:16:35 | [diff] [blame] | 1495 | void RenderWidget::ScreenRectToEmulatedIfNeeded(WebRect* window_rect) const { |
| 1496 | DCHECK(window_rect); |
| 1497 | float scale = popup_origin_scale_for_emulation_; |
| 1498 | if (!scale) |
| 1499 | return; |
| 1500 | window_rect->x = |
| 1501 | popup_view_origin_for_emulation_.x() + |
| 1502 | (window_rect->x - popup_screen_origin_for_emulation_.x()) / scale; |
| 1503 | window_rect->y = |
| 1504 | popup_view_origin_for_emulation_.y() + |
| 1505 | (window_rect->y - popup_screen_origin_for_emulation_.y()) / scale; |
| 1506 | } |
| 1507 | |
| 1508 | void RenderWidget::EmulatedToScreenRectIfNeeded(WebRect* window_rect) const { |
| 1509 | DCHECK(window_rect); |
| 1510 | float scale = popup_origin_scale_for_emulation_; |
| 1511 | if (!scale) |
| 1512 | return; |
| 1513 | window_rect->x = |
| 1514 | popup_screen_origin_for_emulation_.x() + |
| 1515 | (window_rect->x - popup_view_origin_for_emulation_.x()) * scale; |
| 1516 | window_rect->y = |
| 1517 | popup_screen_origin_for_emulation_.y() + |
| 1518 | (window_rect->y - popup_view_origin_for_emulation_.y()) * scale; |
| 1519 | } |
| 1520 | |
[email protected] | 4873c7d | 2009-07-16 06:36:28 | [diff] [blame] | 1521 | WebRect RenderWidget::windowRect() { |
bokan | 841fdc7 | 2016-10-06 00:16:35 | [diff] [blame] | 1522 | WebRect rect; |
bokan | 6b08cd2 | 2016-10-05 00:55:21 | [diff] [blame] | 1523 | if (pending_window_rect_count_) { |
| 1524 | // NOTE(mbelshe): If there is a pending_window_rect_, then getting |
| 1525 | // the RootWindowRect is probably going to return wrong results since the |
| 1526 | // browser may not have processed the Move yet. There isn't really anything |
| 1527 | // good to do in this case, and it shouldn't happen - since this size is |
| 1528 | // only really needed for windowToScreen, which is only used for Popups. |
bokan | 841fdc7 | 2016-10-06 00:16:35 | [diff] [blame] | 1529 | rect = pending_window_rect_; |
| 1530 | } else { |
| 1531 | rect = window_screen_rect_; |
bokan | 6b08cd2 | 2016-10-05 00:55:21 | [diff] [blame] | 1532 | } |
[email protected] | 2533ce1 | 2009-05-09 00:02:24 | [diff] [blame] | 1533 | |
bokan | 841fdc7 | 2016-10-06 00:16:35 | [diff] [blame] | 1534 | ScreenRectToEmulatedIfNeeded(&rect); |
| 1535 | return rect; |
bokan | 6b08cd2 | 2016-10-05 00:55:21 | [diff] [blame] | 1536 | } |
| 1537 | |
| 1538 | WebRect RenderWidget::viewRect() { |
bokan | 841fdc7 | 2016-10-06 00:16:35 | [diff] [blame] | 1539 | WebRect rect = view_screen_rect_; |
| 1540 | ScreenRectToEmulatedIfNeeded(&rect); |
| 1541 | return rect; |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1542 | } |
| 1543 | |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 1544 | void RenderWidget::setToolTipText(const blink::WebString& text, |
[email protected] | 8a9d6ca3 | 2011-06-06 20:11:30 | [diff] [blame] | 1545 | WebTextDirection hint) { |
kinuko | a429302 | 2017-01-27 06:43:25 | [diff] [blame] | 1546 | Send(new ViewHostMsg_SetTooltipText(routing_id_, text.utf16(), hint)); |
[email protected] | 8a9d6ca3 | 2011-06-06 20:11:30 | [diff] [blame] | 1547 | } |
| 1548 | |
oshima | 33ec97cd | 2015-12-14 19:40:24 | [diff] [blame] | 1549 | void RenderWidget::setWindowRect(const WebRect& rect_in_screen) { |
| 1550 | WebRect window_rect = rect_in_screen; |
bokan | 841fdc7 | 2016-10-06 00:16:35 | [diff] [blame] | 1551 | EmulatedToScreenRectIfNeeded(&window_rect); |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 1552 | |
[email protected] | 5b45ad4 | 2013-10-25 00:42:04 | [diff] [blame] | 1553 | if (!resizing_mode_selector_->is_synchronous_mode()) { |
[email protected] | ec951b9d | 2013-10-20 06:21:20 | [diff] [blame] | 1554 | if (did_show_) { |
bokan | c007c3a | 2015-02-03 07:15:56 | [diff] [blame] | 1555 | Send(new ViewHostMsg_RequestMove(routing_id_, window_rect)); |
| 1556 | SetPendingWindowRect(window_rect); |
[email protected] | 8be1c58 | 2013-03-06 00:55:03 | [diff] [blame] | 1557 | } else { |
bokan | c007c3a | 2015-02-03 07:15:56 | [diff] [blame] | 1558 | initial_rect_ = window_rect; |
[email protected] | 8be1c58 | 2013-03-06 00:55:03 | [diff] [blame] | 1559 | } |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1560 | } else { |
bokan | c007c3a | 2015-02-03 07:15:56 | [diff] [blame] | 1561 | SetWindowRectSynchronously(window_rect); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1562 | } |
| 1563 | } |
| 1564 | |
[email protected] | 2533ce1 | 2009-05-09 00:02:24 | [diff] [blame] | 1565 | void RenderWidget::SetPendingWindowRect(const WebRect& rect) { |
| 1566 | pending_window_rect_ = rect; |
| 1567 | pending_window_rect_count_++; |
[email protected] | 2533ce1 | 2009-05-09 00:02:24 | [diff] [blame] | 1568 | |
bokan | 6b08cd2 | 2016-10-05 00:55:21 | [diff] [blame] | 1569 | // Popups don't get size updates back from the browser so just store the set |
| 1570 | // values. |
| 1571 | if (popup_type_ != blink::WebPopupTypeNone) { |
| 1572 | window_screen_rect_ = rect; |
| 1573 | view_screen_rect_ = rect; |
[email protected] | 2533ce1 | 2009-05-09 00:02:24 | [diff] [blame] | 1574 | } |
[email protected] | d454745 | 2008-08-28 18:36:37 | [diff] [blame] | 1575 | } |
| 1576 | |
[email protected] | fa7b1dc | 2010-06-23 17:53:04 | [diff] [blame] | 1577 | void RenderWidget::OnImeSetComposition( |
[email protected] | fcf75d4 | 2013-12-03 20:11:26 | [diff] [blame] | 1578 | const base::string16& text, |
[email protected] | fa7b1dc | 2010-06-23 17:53:04 | [diff] [blame] | 1579 | const std::vector<WebCompositionUnderline>& underlines, |
chongz | 7eb75280 | 2016-01-27 21:28:07 | [diff] [blame] | 1580 | const gfx::Range& replacement_range, |
[email protected] | fa7b1dc | 2010-06-23 17:53:04 | [diff] [blame] | 1581 | int selection_start, int selection_end) { |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 1582 | if (!ShouldHandleImeEvents()) |
| 1583 | return; |
| 1584 | |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 1585 | #if BUILDFLAG(ENABLE_PLUGINS) |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 1586 | if (focused_pepper_plugin_) { |
| 1587 | focused_pepper_plugin_->render_frame()->OnImeSetComposition( |
| 1588 | text, underlines, selection_start, selection_end); |
| 1589 | return; |
| 1590 | } |
| 1591 | #endif |
[email protected] | 66fca5bc | 2013-05-23 06:58:29 | [diff] [blame] | 1592 | ImeEventGuard guard(this); |
ekaramad | 2daaf67 | 2016-11-10 20:29:01 | [diff] [blame] | 1593 | blink::WebInputMethodController* controller = GetInputMethodController(); |
ekaramad | 2daaf67 | 2016-11-10 20:29:01 | [diff] [blame] | 1594 | if (!controller || |
| 1595 | !controller->setComposition( |
kinuko | a429302 | 2017-01-27 06:43:25 | [diff] [blame] | 1596 | WebString::fromUTF16(text), |
ekaramad | ce32ef9f | 2017-02-09 17:33:56 | [diff] [blame] | 1597 | WebVector<WebCompositionUnderline>(underlines), |
| 1598 | replacement_range.IsValid() |
| 1599 | ? WebRange(replacement_range.start(), replacement_range.length()) |
| 1600 | : WebRange(), |
| 1601 | selection_start, selection_end)) { |
[email protected] | fa7b1dc | 2010-06-23 17:53:04 | [diff] [blame] | 1602 | // If we failed to set the composition text, then we need to let the browser |
| 1603 | // process to cancel the input method's ongoing composition session, to make |
| 1604 | // sure we are in a consistent state. |
[email protected] | a2214eb | 2014-06-23 18:31:22 | [diff] [blame] | 1605 | Send(new InputHostMsg_ImeCancelComposition(routing_id())); |
[email protected] | 7f00efa | 2010-04-15 05:01:26 | [diff] [blame] | 1606 | } |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 1607 | UpdateCompositionInfo(false /* not an immediate request */); |
[email protected] | fa7b1dc | 2010-06-23 17:53:04 | [diff] [blame] | 1608 | } |
| 1609 | |
rlanday | 7efe230 | 2017-01-11 00:14:28 | [diff] [blame] | 1610 | void RenderWidget::OnImeCommitText( |
| 1611 | const base::string16& text, |
| 1612 | const std::vector<WebCompositionUnderline>& underlines, |
| 1613 | const gfx::Range& replacement_range, |
| 1614 | int relative_cursor_pos) { |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 1615 | if (!ShouldHandleImeEvents()) |
| 1616 | return; |
| 1617 | |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 1618 | #if BUILDFLAG(ENABLE_PLUGINS) |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 1619 | if (focused_pepper_plugin_) { |
aelias | 87b8f7c | 2016-09-14 03:19:29 | [diff] [blame] | 1620 | focused_pepper_plugin_->render_frame()->OnImeCommitText( |
| 1621 | text, replacement_range, relative_cursor_pos); |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 1622 | return; |
| 1623 | } |
| 1624 | #endif |
[email protected] | 66fca5bc | 2013-05-23 06:58:29 | [diff] [blame] | 1625 | ImeEventGuard guard(this); |
fsamuel | e8326c74 | 2016-01-12 00:49:39 | [diff] [blame] | 1626 | input_handler_->set_handling_input_event(true); |
ekaramad | b6483a05 | 2017-02-10 02:23:26 | [diff] [blame] | 1627 | if (auto* controller = GetInputMethodController()) { |
ekaramad | ce32ef9f | 2017-02-09 17:33:56 | [diff] [blame] | 1628 | controller->commitText( |
| 1629 | WebString::fromUTF16(text), |
| 1630 | WebVector<WebCompositionUnderline>(underlines), |
| 1631 | replacement_range.IsValid() |
| 1632 | ? WebRange(replacement_range.start(), replacement_range.length()) |
| 1633 | : WebRange(), |
| 1634 | relative_cursor_pos); |
ekaramad | b6483a05 | 2017-02-10 02:23:26 | [diff] [blame] | 1635 | } |
aelias | 87b8f7c | 2016-09-14 03:19:29 | [diff] [blame] | 1636 | input_handler_->set_handling_input_event(false); |
| 1637 | UpdateCompositionInfo(false /* not an immediate request */); |
| 1638 | } |
| 1639 | |
| 1640 | void RenderWidget::OnImeFinishComposingText(bool keep_selection) { |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 1641 | if (!ShouldHandleImeEvents()) |
| 1642 | return; |
| 1643 | |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 1644 | #if BUILDFLAG(ENABLE_PLUGINS) |
aelias | 87b8f7c | 2016-09-14 03:19:29 | [diff] [blame] | 1645 | if (focused_pepper_plugin_) { |
| 1646 | focused_pepper_plugin_->render_frame()->OnImeFinishComposingText( |
| 1647 | keep_selection); |
| 1648 | return; |
| 1649 | } |
| 1650 | #endif |
| 1651 | |
changwan | 38c3eb61 | 2016-12-09 01:45:56 | [diff] [blame] | 1652 | if (!GetWebWidget()) |
aelias | 87b8f7c | 2016-09-14 03:19:29 | [diff] [blame] | 1653 | return; |
| 1654 | ImeEventGuard guard(this); |
| 1655 | input_handler_->set_handling_input_event(true); |
ekaramad | 2daaf67 | 2016-11-10 20:29:01 | [diff] [blame] | 1656 | if (auto* controller = GetInputMethodController()) { |
| 1657 | controller->finishComposingText( |
| 1658 | keep_selection ? WebInputMethodController::KeepSelection |
| 1659 | : WebInputMethodController::DoNotKeepSelection); |
| 1660 | } |
fsamuel | e8326c74 | 2016-01-12 00:49:39 | [diff] [blame] | 1661 | input_handler_->set_handling_input_event(false); |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 1662 | UpdateCompositionInfo(false /* not an immediate request */); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1663 | } |
| 1664 | |
oshima | d527903 | 2015-12-16 18:22:33 | [diff] [blame] | 1665 | void RenderWidget::OnDeviceScaleFactorChanged() { |
| 1666 | if (!compositor_) |
| 1667 | return; |
oshima | d527903 | 2015-12-16 18:22:33 | [diff] [blame] | 1668 | if (IsUseZoomForDSFEnabled()) |
oshima | 50872a7 | 2016-03-04 13:26:18 | [diff] [blame] | 1669 | compositor_->SetPaintedDeviceScaleFactor(GetOriginalDeviceScaleFactor()); |
oshima | d527903 | 2015-12-16 18:22:33 | [diff] [blame] | 1670 | else |
| 1671 | compositor_->setDeviceScaleFactor(device_scale_factor_); |
| 1672 | } |
| 1673 | |
[email protected] | 0bc1f57 | 2013-04-17 01:46:31 | [diff] [blame] | 1674 | void RenderWidget::OnRepaint(gfx::Size size_to_paint) { |
[email protected] | ec7dc11 | 2008-08-06 05:30:12 | [diff] [blame] | 1675 | // During shutdown we can just ignore this message. |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1676 | if (!GetWebWidget()) |
[email protected] | ec7dc11 | 2008-08-06 05:30:12 | [diff] [blame] | 1677 | return; |
| 1678 | |
[email protected] | 0bc1f57 | 2013-04-17 01:46:31 | [diff] [blame] | 1679 | // Even if the browser provides an empty damage rect, it's still expecting to |
| 1680 | // receive a repaint ack so just damage the entire widget bounds. |
| 1681 | if (size_to_paint.IsEmpty()) { |
| 1682 | size_to_paint = size_; |
| 1683 | } |
| 1684 | |
[email protected] | ec7dc11 | 2008-08-06 05:30:12 | [diff] [blame] | 1685 | set_next_paint_is_repaint_ack(); |
[email protected] | aca33f4f | 2014-05-17 17:08:05 | [diff] [blame] | 1686 | if (compositor_) |
[email protected] | 0bc1f57 | 2013-04-17 01:46:31 | [diff] [blame] | 1687 | compositor_->SetNeedsRedrawRect(gfx::Rect(size_to_paint)); |
[email protected] | ec7dc11 | 2008-08-06 05:30:12 | [diff] [blame] | 1688 | } |
| 1689 | |
[email protected] | 79fa22e | 2013-08-23 15:18:12 | [diff] [blame] | 1690 | void RenderWidget::OnSyntheticGestureCompleted() { |
[email protected] | 9017d785 | 2013-11-21 17:47:35 | [diff] [blame] | 1691 | DCHECK(!pending_synthetic_gesture_callbacks_.empty()); |
| 1692 | |
| 1693 | pending_synthetic_gesture_callbacks_.front().Run(); |
| 1694 | pending_synthetic_gesture_callbacks_.pop(); |
[email protected] | 0e241b4b | 2012-08-18 09:06:27 | [diff] [blame] | 1695 | } |
| 1696 | |
[email protected] | 4873c7d | 2009-07-16 06:36:28 | [diff] [blame] | 1697 | void RenderWidget::OnSetTextDirection(WebTextDirection direction) { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1698 | if (!GetWebWidget()) |
[email protected] | 07f95333 | 2009-03-25 04:31:11 | [diff] [blame] | 1699 | return; |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1700 | GetWebWidget()->setTextDirection(direction); |
[email protected] | 07f95333 | 2009-03-25 04:31:11 | [diff] [blame] | 1701 | } |
| 1702 | |
[email protected] | 80ad862 | 2012-11-07 16:33:03 | [diff] [blame] | 1703 | void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect, |
| 1704 | const gfx::Rect& window_screen_rect) { |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 1705 | if (screen_metrics_emulator_) { |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1706 | screen_metrics_emulator_->OnUpdateScreenRects(view_screen_rect, |
| 1707 | window_screen_rect); |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 1708 | } else { |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1709 | SetScreenRects(view_screen_rect, window_screen_rect); |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 1710 | } |
[email protected] | 80ad862 | 2012-11-07 16:33:03 | [diff] [blame] | 1711 | Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id())); |
| 1712 | } |
| 1713 | |
lfg | db5c4ed | 2016-03-04 23:09:07 | [diff] [blame] | 1714 | void RenderWidget::OnUpdateWindowScreenRect( |
| 1715 | const gfx::Rect& window_screen_rect) { |
bokan | 6b08cd2 | 2016-10-05 00:55:21 | [diff] [blame] | 1716 | if (screen_metrics_emulator_) |
lfg | db5c4ed | 2016-03-04 23:09:07 | [diff] [blame] | 1717 | screen_metrics_emulator_->OnUpdateWindowScreenRect(window_screen_rect); |
bokan | 6b08cd2 | 2016-10-05 00:55:21 | [diff] [blame] | 1718 | else |
lfg | db5c4ed | 2016-03-04 23:09:07 | [diff] [blame] | 1719 | window_screen_rect_ = window_screen_rect; |
lfg | db5c4ed | 2016-03-04 23:09:07 | [diff] [blame] | 1720 | } |
| 1721 | |
kenrb | ea73179 | 2017-01-13 15:10:48 | [diff] [blame] | 1722 | void RenderWidget::OnSetViewportIntersection( |
| 1723 | const gfx::Rect& viewport_intersection) { |
| 1724 | if (GetWebWidget() && GetWebWidget()->isWebFrameWidget()) { |
| 1725 | DCHECK(popup_type_ == WebPopupType::WebPopupTypeNone); |
| 1726 | static_cast<WebFrameWidget*>(GetWebWidget()) |
| 1727 | ->setRemoteViewportIntersection(viewport_intersection); |
| 1728 | } |
| 1729 | } |
| 1730 | |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 1731 | void RenderWidget::OnDragTargetDragEnter( |
| 1732 | const std::vector<DropData::Metadata>& drop_meta_data, |
| 1733 | const gfx::Point& client_point, |
| 1734 | const gfx::Point& screen_point, |
| 1735 | WebDragOperationsMask ops, |
| 1736 | int key_modifiers) { |
| 1737 | if (!GetWebWidget()) |
| 1738 | return; |
| 1739 | |
| 1740 | DCHECK(GetWebWidget()->isWebFrameWidget()); |
| 1741 | WebDragOperation operation = static_cast<WebFrameWidget*>(GetWebWidget())-> |
| 1742 | dragTargetDragEnter(DropMetaDataToWebDragData(drop_meta_data), |
| 1743 | client_point, screen_point, ops, key_modifiers); |
| 1744 | |
| 1745 | Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation)); |
| 1746 | } |
| 1747 | |
| 1748 | void RenderWidget::OnDragTargetDragOver(const gfx::Point& client_point, |
| 1749 | const gfx::Point& screen_point, |
| 1750 | WebDragOperationsMask ops, |
| 1751 | int key_modifiers) { |
| 1752 | if (!GetWebWidget()) |
| 1753 | return; |
| 1754 | |
| 1755 | DCHECK(GetWebWidget()->isWebFrameWidget()); |
| 1756 | WebDragOperation operation = |
| 1757 | static_cast<WebFrameWidget*>(GetWebWidget())->dragTargetDragOver( |
| 1758 | ConvertWindowPointToViewport(client_point), |
| 1759 | screen_point, ops, key_modifiers); |
| 1760 | |
| 1761 | Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation)); |
| 1762 | } |
| 1763 | |
kenrb | 07c27280 | 2017-02-07 23:48:17 | [diff] [blame] | 1764 | void RenderWidget::OnDragTargetDragLeave(const gfx::Point& client_point, |
| 1765 | const gfx::Point& screen_point) { |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 1766 | if (!GetWebWidget()) |
| 1767 | return; |
| 1768 | DCHECK(GetWebWidget()->isWebFrameWidget()); |
kenrb | 07c27280 | 2017-02-07 23:48:17 | [diff] [blame] | 1769 | static_cast<WebFrameWidget*>(GetWebWidget()) |
| 1770 | ->dragTargetDragLeave(ConvertWindowPointToViewport(client_point), |
| 1771 | screen_point); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 1772 | } |
| 1773 | |
| 1774 | void RenderWidget::OnDragTargetDrop(const DropData& drop_data, |
| 1775 | const gfx::Point& client_point, |
| 1776 | const gfx::Point& screen_point, |
| 1777 | int key_modifiers) { |
| 1778 | if (!GetWebWidget()) |
| 1779 | return; |
| 1780 | |
| 1781 | DCHECK(GetWebWidget()->isWebFrameWidget()); |
| 1782 | static_cast<WebFrameWidget*>(GetWebWidget())->dragTargetDrop( |
| 1783 | DropDataToWebDragData(drop_data), |
| 1784 | ConvertWindowPointToViewport(client_point), |
| 1785 | screen_point, key_modifiers); |
| 1786 | } |
| 1787 | |
paulmeyer | 8fc8ea9 | 2016-11-15 05:12:21 | [diff] [blame] | 1788 | void RenderWidget::OnDragSourceEnded(const gfx::Point& client_point, |
| 1789 | const gfx::Point& screen_point, |
| 1790 | WebDragOperation op) { |
| 1791 | if (!GetWebWidget()) |
| 1792 | return; |
| 1793 | |
| 1794 | static_cast<WebFrameWidget*>(GetWebWidget())->dragSourceEndedAt( |
| 1795 | ConvertWindowPointToViewport(client_point), screen_point, op); |
| 1796 | } |
| 1797 | |
| 1798 | void RenderWidget::OnDragSourceSystemDragEnded() { |
| 1799 | if (!GetWebWidget()) |
| 1800 | return; |
| 1801 | |
| 1802 | static_cast<WebFrameWidget*>(GetWebWidget())->dragSourceSystemDragEnded(); |
| 1803 | } |
| 1804 | |
lukasza | 86f05da | 2017-01-24 21:23:26 | [diff] [blame] | 1805 | void RenderWidget::showVirtualKeyboardOnElementFocus() { |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1806 | ShowVirtualKeyboard(); |
boliu | 7b2be2f | 2016-11-04 04:58:31 | [diff] [blame] | 1807 | |
| 1808 | // TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with |
| 1809 | // virtual keyboard. |
| 1810 | #if !defined(OS_ANDROID) |
| 1811 | FocusChangeComplete(); |
| 1812 | #endif |
[email protected] | 0d1ebed1 | 2013-08-05 22:01:13 | [diff] [blame] | 1813 | } |
| 1814 | |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1815 | ui::TextInputType RenderWidget::GetTextInputType() { |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 1816 | #if BUILDFLAG(ENABLE_PLUGINS) |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 1817 | if (focused_pepper_plugin_) |
| 1818 | return focused_pepper_plugin_->text_input_type(); |
| 1819 | #endif |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 1820 | if (auto* controller = GetInputMethodController()) |
| 1821 | return ConvertWebTextInputType(controller->textInputType()); |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1822 | return ui::TEXT_INPUT_TYPE_NONE; |
| 1823 | } |
| 1824 | |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 1825 | void RenderWidget::UpdateCompositionInfo(bool immediate_request) { |
| 1826 | if (!monitor_composition_info_ && !immediate_request) |
| 1827 | return; // Do not calculate composition info if not requested. |
nona | dac0c7a | 2016-08-01 02:30:59 | [diff] [blame] | 1828 | |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 1829 | TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo"); |
| 1830 | gfx::Range range; |
| 1831 | std::vector<gfx::Rect> character_bounds; |
| 1832 | |
| 1833 | if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE) { |
| 1834 | // Composition information is only available on editable node. |
| 1835 | range = gfx::Range::InvalidRange(); |
| 1836 | } else { |
| 1837 | GetCompositionRange(&range); |
| 1838 | GetCompositionCharacterBounds(&character_bounds); |
| 1839 | } |
| 1840 | |
| 1841 | if (!immediate_request && |
| 1842 | !ShouldUpdateCompositionInfo(range, character_bounds)) { |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1843 | return; |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 1844 | } |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1845 | composition_character_bounds_ = character_bounds; |
| 1846 | composition_range_ = range; |
| 1847 | Send(new InputHostMsg_ImeCompositionRangeChanged( |
| 1848 | routing_id(), composition_range_, composition_character_bounds_)); |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1849 | } |
| 1850 | |
oshima | f866dab | 2015-12-05 00:41:54 | [diff] [blame] | 1851 | void RenderWidget::convertViewportToWindow(blink::WebRect* rect) { |
| 1852 | if (IsUseZoomForDSFEnabled()) { |
lfg | 15b235a3 | 2016-08-25 17:45:46 | [diff] [blame] | 1853 | float reverse = 1 / GetOriginalDeviceScaleFactor(); |
oshima | d527903 | 2015-12-16 18:22:33 | [diff] [blame] | 1854 | // TODO(oshima): We may need to allow pixel precision here as the the |
oshima | f866dab | 2015-12-05 00:41:54 | [diff] [blame] | 1855 | // anchor element can be placed at half pixel. |
lfg | 15b235a3 | 2016-08-25 17:45:46 | [diff] [blame] | 1856 | gfx::Rect window_rect = |
| 1857 | gfx::ScaleToEnclosedRect(gfx::Rect(*rect), reverse); |
| 1858 | rect->x = window_rect.x(); |
| 1859 | rect->y = window_rect.y(); |
| 1860 | rect->width = window_rect.width(); |
| 1861 | rect->height = window_rect.height(); |
oshima | f866dab | 2015-12-05 00:41:54 | [diff] [blame] | 1862 | } |
| 1863 | } |
| 1864 | |
oshima | a6985b6 | 2016-01-27 08:58:30 | [diff] [blame] | 1865 | void RenderWidget::convertWindowToViewport(blink::WebFloatRect* rect) { |
| 1866 | if (IsUseZoomForDSFEnabled()) { |
oshima | 50872a7 | 2016-03-04 13:26:18 | [diff] [blame] | 1867 | rect->x *= GetOriginalDeviceScaleFactor(); |
| 1868 | rect->y *= GetOriginalDeviceScaleFactor(); |
| 1869 | rect->width *= GetOriginalDeviceScaleFactor(); |
| 1870 | rect->height *= GetOriginalDeviceScaleFactor(); |
oshima | a6985b6 | 2016-01-27 08:58:30 | [diff] [blame] | 1871 | } |
| 1872 | } |
| 1873 | |
[email protected] | adb36231 | 2014-06-28 06:04:24 | [diff] [blame] | 1874 | #if defined(OS_ANDROID) |
changwan | 8c34274 | 2016-02-26 00:53:39 | [diff] [blame] | 1875 | void RenderWidget::OnRequestTextInputStateUpdate() { |
| 1876 | DCHECK(!ime_event_guard_); |
| 1877 | UpdateSelectionBounds(); |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1878 | UpdateTextInputStateInternal(false, true /* reply_to_request */); |
changwan | 8c34274 | 2016-02-26 00:53:39 | [diff] [blame] | 1879 | } |
[email protected] | 105dffb4 | 2013-02-20 03:46:21 | [diff] [blame] | 1880 | #endif |
| 1881 | |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 1882 | void RenderWidget::OnRequestCompositionUpdate(bool immediate_request, |
| 1883 | bool monitor_request) { |
| 1884 | monitor_composition_info_ = monitor_request; |
| 1885 | if (!immediate_request) |
| 1886 | return; |
| 1887 | UpdateCompositionInfo(true /* immediate request */); |
| 1888 | } |
| 1889 | |
wjmaclean | 8a795f3 | 2016-08-11 23:49:58 | [diff] [blame] | 1890 | void RenderWidget::OnSetDeviceScaleFactor(float device_scale_factor) { |
[email protected] | 468ac58 | 2012-11-20 00:53:19 | [diff] [blame] | 1891 | if (device_scale_factor_ == device_scale_factor) |
| 1892 | return; |
| 1893 | |
| 1894 | device_scale_factor_ = device_scale_factor; |
oshima | d527903 | 2015-12-16 18:22:33 | [diff] [blame] | 1895 | |
| 1896 | OnDeviceScaleFactorChanged(); |
jdduke | 491a3f0c | 2015-06-15 23:30:26 | [diff] [blame] | 1897 | ScheduleComposite(); |
wjmaclean | 8a795f3 | 2016-08-11 23:49:58 | [diff] [blame] | 1898 | |
| 1899 | physical_backing_size_ = gfx::ScaleToCeiledSize(size_, device_scale_factor_); |
[email protected] | 468ac58 | 2012-11-20 00:53:19 | [diff] [blame] | 1900 | } |
| 1901 | |
[email protected] | fcdc564 | 2014-05-09 14:32:24 | [diff] [blame] | 1902 | void RenderWidget::OnOrientationChange() { |
| 1903 | } |
| 1904 | |
[email protected] | bee16aab | 2009-08-26 15:55:03 | [diff] [blame] | 1905 | void RenderWidget::SetHidden(bool hidden) { |
| 1906 | if (is_hidden_ == hidden) |
| 1907 | return; |
| 1908 | |
jdduke | 8fac9d10 | 2014-12-20 02:40:13 | [diff] [blame] | 1909 | // The status has changed. Tell the RenderThread about it and ensure |
| 1910 | // throttled acks are released in case frame production ceases. |
[email protected] | bee16aab | 2009-08-26 15:55:03 | [diff] [blame] | 1911 | is_hidden_ = hidden; |
jdduke | 8fac9d10 | 2014-12-20 02:40:13 | [diff] [blame] | 1912 | |
tasak | b95dbb50c | 2017-02-08 18:07:50 | [diff] [blame] | 1913 | if (is_hidden_) { |
[email protected] | b2db927 | 2014-01-10 17:42:00 | [diff] [blame] | 1914 | RenderThreadImpl::current()->WidgetHidden(); |
tasak | b95dbb50c | 2017-02-08 18:07:50 | [diff] [blame] | 1915 | time_to_first_active_paint_recorded_ = false; |
| 1916 | } else |
[email protected] | b2db927 | 2014-01-10 17:42:00 | [diff] [blame] | 1917 | RenderThreadImpl::current()->WidgetRestored(); |
alexclarke | 7fa9394 | 2015-10-21 15:37:11 | [diff] [blame] | 1918 | |
| 1919 | if (render_widget_scheduling_state_) |
| 1920 | render_widget_scheduling_state_->SetHidden(hidden); |
[email protected] | bee16aab | 2009-08-26 15:55:03 | [diff] [blame] | 1921 | } |
| 1922 | |
[email protected] | 2b624c56 | 2011-10-27 22:58:26 | [diff] [blame] | 1923 | void RenderWidget::DidToggleFullscreen() { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1924 | if (!GetWebWidget()) |
[email protected] | 2b624c56 | 2011-10-27 22:58:26 | [diff] [blame] | 1925 | return; |
| 1926 | |
mikhail.pozdnyakov | f2c902a | 2015-04-14 08:09:12 | [diff] [blame] | 1927 | if (is_fullscreen_granted_) { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1928 | GetWebWidget()->didEnterFullscreen(); |
[email protected] | 2b624c56 | 2011-10-27 22:58:26 | [diff] [blame] | 1929 | } else { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1930 | GetWebWidget()->didExitFullscreen(); |
[email protected] | 2b624c56 | 2011-10-27 22:58:26 | [diff] [blame] | 1931 | } |
[email protected] | 2b624c56 | 2011-10-27 22:58:26 | [diff] [blame] | 1932 | } |
| 1933 | |
[email protected] | 67474193 | 2009-02-04 23:44:46 | [diff] [blame] | 1934 | bool RenderWidget::next_paint_is_resize_ack() const { |
[email protected] | 53d3f30 | 2009-12-21 04:42:05 | [diff] [blame] | 1935 | return ViewHostMsg_UpdateRect_Flags::is_resize_ack(next_paint_flags_); |
[email protected] | 67474193 | 2009-02-04 23:44:46 | [diff] [blame] | 1936 | } |
| 1937 | |
[email protected] | 67474193 | 2009-02-04 23:44:46 | [diff] [blame] | 1938 | void RenderWidget::set_next_paint_is_resize_ack() { |
[email protected] | 53d3f30 | 2009-12-21 04:42:05 | [diff] [blame] | 1939 | next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK; |
[email protected] | 67474193 | 2009-02-04 23:44:46 | [diff] [blame] | 1940 | } |
| 1941 | |
[email protected] | 67474193 | 2009-02-04 23:44:46 | [diff] [blame] | 1942 | void RenderWidget::set_next_paint_is_repaint_ack() { |
[email protected] | 53d3f30 | 2009-12-21 04:42:05 | [diff] [blame] | 1943 | next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK; |
[email protected] | 67474193 | 2009-02-04 23:44:46 | [diff] [blame] | 1944 | } |
| 1945 | |
changwan | f2a707b | 2015-10-30 08:22:16 | [diff] [blame] | 1946 | void RenderWidget::OnImeEventGuardStart(ImeEventGuard* guard) { |
| 1947 | if (!ime_event_guard_) |
| 1948 | ime_event_guard_ = guard; |
[email protected] | 66fca5bc | 2013-05-23 06:58:29 | [diff] [blame] | 1949 | } |
| 1950 | |
changwan | f2a707b | 2015-10-30 08:22:16 | [diff] [blame] | 1951 | void RenderWidget::OnImeEventGuardFinish(ImeEventGuard* guard) { |
| 1952 | if (ime_event_guard_ != guard) { |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1953 | DCHECK(!ime_event_guard_->reply_to_request()); |
changwan | f2a707b | 2015-10-30 08:22:16 | [diff] [blame] | 1954 | return; |
| 1955 | } |
| 1956 | ime_event_guard_ = nullptr; |
| 1957 | |
[email protected] | 66fca5bc | 2013-05-23 06:58:29 | [diff] [blame] | 1958 | // While handling an ime event, text input state and selection bounds updates |
| 1959 | // are ignored. These must explicitly be updated once finished handling the |
| 1960 | // ime event. |
| 1961 | UpdateSelectionBounds(); |
[email protected] | cb9e263 | 2013-06-18 11:26:47 | [diff] [blame] | 1962 | #if defined(OS_ANDROID) |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1963 | if (guard->show_virtual_keyboard()) |
| 1964 | ShowVirtualKeyboard(); |
| 1965 | else |
| 1966 | UpdateTextInputState(); |
[email protected] | cb9e263 | 2013-06-18 11:26:47 | [diff] [blame] | 1967 | #endif |
[email protected] | 66fca5bc | 2013-05-23 06:58:29 | [diff] [blame] | 1968 | } |
| 1969 | |
[email protected] | 7c8873e | 2013-02-05 08:03:01 | [diff] [blame] | 1970 | void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) { |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 1971 | #if BUILDFLAG(ENABLE_PLUGINS) |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 1972 | if (focused_pepper_plugin_) { |
| 1973 | // TODO(kinaba) http://crbug.com/101101 |
| 1974 | // Current Pepper IME API does not handle selection bounds. So we simply |
| 1975 | // use the caret position as an empty range for now. It will be updated |
| 1976 | // after Pepper API equips features related to surrounding text retrieval. |
| 1977 | blink::WebRect caret(focused_pepper_plugin_->GetCaretBounds()); |
| 1978 | convertViewportToWindow(&caret); |
| 1979 | *focus = caret; |
| 1980 | *anchor = caret; |
| 1981 | return; |
| 1982 | } |
| 1983 | #endif |
[email protected] | 7c8873e | 2013-02-05 08:03:01 | [diff] [blame] | 1984 | WebRect focus_webrect; |
| 1985 | WebRect anchor_webrect; |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1986 | GetWebWidget()->selectionBounds(focus_webrect, anchor_webrect); |
oshima | 33ec97cd | 2015-12-14 19:40:24 | [diff] [blame] | 1987 | convertViewportToWindow(&focus_webrect); |
| 1988 | convertViewportToWindow(&anchor_webrect); |
| 1989 | *focus = focus_webrect; |
| 1990 | *anchor = anchor_webrect; |
[email protected] | 73bf9581 | 2011-10-12 11:38:32 | [diff] [blame] | 1991 | } |
| 1992 | |
[email protected] | e99ef6f | 2011-10-16 01:13:00 | [diff] [blame] | 1993 | void RenderWidget::UpdateSelectionBounds() { |
jdduke | 1aebad8e | 2015-07-22 23:25:08 | [diff] [blame] | 1994 | TRACE_EVENT0("renderer", "RenderWidget::UpdateSelectionBounds"); |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1995 | if (!GetWebWidget()) |
[email protected] | e99ef6f | 2011-10-16 01:13:00 | [diff] [blame] | 1996 | return; |
changwan | f2a707b | 2015-10-30 08:22:16 | [diff] [blame] | 1997 | if (ime_event_guard_) |
[email protected] | 66fca5bc | 2013-05-23 06:58:29 | [diff] [blame] | 1998 | return; |
[email protected] | e99ef6f | 2011-10-16 01:13:00 | [diff] [blame] | 1999 | |
mohsen | b0eeba7 | 2015-08-09 06:20:08 | [diff] [blame] | 2000 | #if defined(USE_AURA) |
| 2001 | // TODO(mohsen): For now, always send explicit selection IPC notifications for |
| 2002 | // Aura beucause composited selection updates are not working for webview tags |
| 2003 | // which regresses IME inside webview. Remove this when composited selection |
| 2004 | // updates are fixed for webviews. See, http://crbug.com/510568. |
| 2005 | bool send_ipc = true; |
| 2006 | #else |
jdduke | acf809e | 2014-09-23 20:38:38 | [diff] [blame] | 2007 | // With composited selection updates, the selection bounds will be reported |
| 2008 | // directly by the compositor, in which case explicit IPC selection |
| 2009 | // notifications should be suppressed. |
mohsen | b0eeba7 | 2015-08-09 06:20:08 | [diff] [blame] | 2010 | bool send_ipc = |
| 2011 | !blink::WebRuntimeFeatures::isCompositedSelectionUpdateEnabled(); |
| 2012 | #endif |
| 2013 | if (send_ipc) { |
jdduke | acf809e | 2014-09-23 20:38:38 | [diff] [blame] | 2014 | ViewHostMsg_SelectionBounds_Params params; |
| 2015 | GetSelectionBounds(¶ms.anchor_rect, ¶ms.focus_rect); |
| 2016 | if (selection_anchor_rect_ != params.anchor_rect || |
| 2017 | selection_focus_rect_ != params.focus_rect) { |
| 2018 | selection_anchor_rect_ = params.anchor_rect; |
| 2019 | selection_focus_rect_ = params.focus_rect; |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 2020 | GetWebWidget()->selectionTextDirection(params.focus_dir, |
| 2021 | params.anchor_dir); |
| 2022 | params.is_anchor_first = GetWebWidget()->isSelectionAnchorFirst(); |
jdduke | acf809e | 2014-09-23 20:38:38 | [diff] [blame] | 2023 | Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params)); |
| 2024 | } |
[email protected] | 58b48a0d | 2012-06-13 07:01:35 | [diff] [blame] | 2025 | } |
jdduke | acf809e | 2014-09-23 20:38:38 | [diff] [blame] | 2026 | |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 2027 | UpdateCompositionInfo(false /* not an immediate request */); |
[email protected] | e99ef6f | 2011-10-16 01:13:00 | [diff] [blame] | 2028 | } |
| 2029 | |
lfg | b00fcad | 2016-07-14 14:16:33 | [diff] [blame] | 2030 | void RenderWidget::DidAutoResize(const gfx::Size& new_size) { |
| 2031 | WebRect new_size_in_window(0, 0, new_size.width(), new_size.height()); |
| 2032 | convertViewportToWindow(&new_size_in_window); |
| 2033 | if (size_.width() != new_size_in_window.width || |
| 2034 | size_.height() != new_size_in_window.height) { |
| 2035 | size_ = gfx::Size(new_size_in_window.width, new_size_in_window.height); |
| 2036 | |
| 2037 | if (resizing_mode_selector_->is_synchronous_mode()) { |
bokan | 6b08cd2 | 2016-10-05 00:55:21 | [diff] [blame] | 2038 | gfx::Rect new_pos(windowRect().x, windowRect().y, |
lfg | 0140a45 | 2016-07-19 19:15:05 | [diff] [blame] | 2039 | size_.width(), size_.height()); |
lfg | b00fcad | 2016-07-14 14:16:33 | [diff] [blame] | 2040 | view_screen_rect_ = new_pos; |
| 2041 | window_screen_rect_ = new_pos; |
| 2042 | } |
| 2043 | |
| 2044 | AutoResizeCompositor(); |
| 2045 | |
| 2046 | if (!resizing_mode_selector_->is_synchronous_mode()) |
| 2047 | need_update_rect_for_auto_resize_ = true; |
| 2048 | } |
| 2049 | } |
| 2050 | |
[email protected] | 58b48a0d | 2012-06-13 07:01:35 | [diff] [blame] | 2051 | void RenderWidget::GetCompositionCharacterBounds( |
| 2052 | std::vector<gfx::Rect>* bounds) { |
| 2053 | DCHECK(bounds); |
| 2054 | bounds->clear(); |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2055 | |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 2056 | #if BUILDFLAG(ENABLE_PLUGINS) |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2057 | if (focused_pepper_plugin_) |
| 2058 | return; |
| 2059 | #endif |
| 2060 | |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 2061 | if (!GetWebWidget()) |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2062 | return; |
| 2063 | blink::WebVector<blink::WebRect> bounds_from_blink; |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 2064 | if (!GetWebWidget()->getCompositionCharacterBounds(bounds_from_blink)) |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2065 | return; |
| 2066 | |
| 2067 | for (size_t i = 0; i < bounds_from_blink.size(); ++i) { |
| 2068 | convertViewportToWindow(&bounds_from_blink[i]); |
| 2069 | bounds->push_back(bounds_from_blink[i]); |
| 2070 | } |
[email protected] | 58b48a0d | 2012-06-13 07:01:35 | [diff] [blame] | 2071 | } |
| 2072 | |
[email protected] | db4fc1e | 2013-09-06 20:01:51 | [diff] [blame] | 2073 | void RenderWidget::GetCompositionRange(gfx::Range* range) { |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 2074 | #if BUILDFLAG(ENABLE_PLUGINS) |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2075 | if (focused_pepper_plugin_) |
| 2076 | return; |
| 2077 | #endif |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 2078 | WebRange web_range = GetWebWidget()->compositionRange(); |
nona | 2363a3d | 2016-11-09 03:26:21 | [diff] [blame] | 2079 | if (web_range.isNull()) { |
| 2080 | *range = gfx::Range::InvalidRange(); |
| 2081 | return; |
[email protected] | 88dbe32f | 2013-06-20 23:31:36 | [diff] [blame] | 2082 | } |
nona | 2363a3d | 2016-11-09 03:26:21 | [diff] [blame] | 2083 | range->set_start(web_range.startOffset()); |
| 2084 | range->set_end(web_range.endOffset()); |
[email protected] | 88dbe32f | 2013-06-20 23:31:36 | [diff] [blame] | 2085 | } |
| 2086 | |
[email protected] | 501ea13d | 2013-07-09 17:03:29 | [diff] [blame] | 2087 | bool RenderWidget::ShouldUpdateCompositionInfo( |
[email protected] | db4fc1e | 2013-09-06 20:01:51 | [diff] [blame] | 2088 | const gfx::Range& range, |
[email protected] | 501ea13d | 2013-07-09 17:03:29 | [diff] [blame] | 2089 | const std::vector<gfx::Rect>& bounds) { |
changwan | 2418e1b | 2016-12-12 12:43:08 | [diff] [blame] | 2090 | if (!range.IsValid()) |
| 2091 | return false; |
[email protected] | 501ea13d | 2013-07-09 17:03:29 | [diff] [blame] | 2092 | if (composition_range_ != range) |
| 2093 | return true; |
| 2094 | if (bounds.size() != composition_character_bounds_.size()) |
| 2095 | return true; |
| 2096 | for (size_t i = 0; i < bounds.size(); ++i) { |
| 2097 | if (bounds[i] != composition_character_bounds_[i]) |
| 2098 | return true; |
| 2099 | } |
| 2100 | return false; |
| 2101 | } |
[email protected] | 501ea13d | 2013-07-09 17:03:29 | [diff] [blame] | 2102 | |
[email protected] | ad26ef4 | 2011-06-17 07:59:45 | [diff] [blame] | 2103 | bool RenderWidget::CanComposeInline() { |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 2104 | #if BUILDFLAG(ENABLE_PLUGINS) |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2105 | if (focused_pepper_plugin_) |
| 2106 | return focused_pepper_plugin_->IsPluginAcceptingCompositionEvents(); |
| 2107 | #endif |
[email protected] | ad26ef4 | 2011-06-17 07:59:45 | [diff] [blame] | 2108 | return true; |
[email protected] | 56ea1a6 | 2011-05-30 07:05:57 | [diff] [blame] | 2109 | } |
| 2110 | |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 2111 | blink::WebScreenInfo RenderWidget::screenInfo() { |
| 2112 | blink::WebScreenInfo web_screen_info; |
| 2113 | web_screen_info.deviceScaleFactor = screen_info_.device_scale_factor; |
mlamouri | afca06dd | 2017-01-27 23:35:18 | [diff] [blame] | 2114 | web_screen_info.iccProfile = screen_info_.icc_profile; |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 2115 | web_screen_info.depth = screen_info_.depth; |
| 2116 | web_screen_info.depthPerComponent = screen_info_.depth_per_component; |
| 2117 | web_screen_info.isMonochrome = screen_info_.is_monochrome; |
| 2118 | web_screen_info.rect = blink::WebRect(screen_info_.rect); |
| 2119 | web_screen_info.availableRect = blink::WebRect(screen_info_.available_rect); |
| 2120 | switch (screen_info_.orientation_type) { |
| 2121 | case SCREEN_ORIENTATION_VALUES_PORTRAIT_PRIMARY: |
| 2122 | web_screen_info.orientationType = |
| 2123 | blink::WebScreenOrientationPortraitPrimary; |
| 2124 | break; |
| 2125 | case SCREEN_ORIENTATION_VALUES_PORTRAIT_SECONDARY: |
| 2126 | web_screen_info.orientationType = |
| 2127 | blink::WebScreenOrientationPortraitSecondary; |
| 2128 | break; |
| 2129 | case SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY: |
| 2130 | web_screen_info.orientationType = |
| 2131 | blink::WebScreenOrientationLandscapePrimary; |
| 2132 | break; |
| 2133 | case SCREEN_ORIENTATION_VALUES_LANDSCAPE_SECONDARY: |
| 2134 | web_screen_info.orientationType = |
| 2135 | blink::WebScreenOrientationLandscapeSecondary; |
| 2136 | break; |
| 2137 | default: |
| 2138 | web_screen_info.orientationType = |
| 2139 | blink::WebScreenOrientationUndefined; |
| 2140 | break; |
| 2141 | } |
| 2142 | web_screen_info.orientationAngle = screen_info_.orientation_angle; |
| 2143 | return web_screen_info; |
[email protected] | 4873c7d | 2009-07-16 06:36:28 | [diff] [blame] | 2144 | } |
| 2145 | |
donnd | a070f3c | 2015-01-16 19:54:11 | [diff] [blame] | 2146 | #if defined(OS_ANDROID) |
| 2147 | void RenderWidget::showUnhandledTapUIIfNeeded( |
| 2148 | const WebPoint& tapped_position, |
| 2149 | const WebNode& tapped_node, |
| 2150 | bool page_changed) { |
fsamuel | e8326c74 | 2016-01-12 00:49:39 | [diff] [blame] | 2151 | DCHECK(input_handler_->handling_input_event()); |
donnd | a070f3c | 2015-01-16 19:54:11 | [diff] [blame] | 2152 | bool should_trigger = !page_changed && tapped_node.isTextNode() && |
donnd | 57e54f5 | 2015-02-26 19:03:37 | [diff] [blame] | 2153 | !tapped_node.isContentEditable() && |
| 2154 | !tapped_node.isInsideFocusableElementOrARIAWidget(); |
donnd | a070f3c | 2015-01-16 19:54:11 | [diff] [blame] | 2155 | if (should_trigger) { |
| 2156 | Send(new ViewHostMsg_ShowUnhandledTapUIIfNeeded(routing_id_, |
| 2157 | tapped_position.x, tapped_position.y)); |
| 2158 | } |
| 2159 | } |
| 2160 | #endif |
| 2161 | |
[email protected] | c68c3e4e | 2013-01-24 00:36:56 | [diff] [blame] | 2162 | void RenderWidget::didHandleGestureEvent( |
| 2163 | const WebGestureEvent& event, |
| 2164 | bool event_cancelled) { |
[email protected] | 183e28d | 2014-01-20 18:18:02 | [diff] [blame] | 2165 | #if defined(OS_ANDROID) || defined(USE_AURA) |
[email protected] | c68c3e4e | 2013-01-24 00:36:56 | [diff] [blame] | 2166 | if (event_cancelled) |
| 2167 | return; |
dtapuska | 8c4dae1 | 2017-01-13 00:23:06 | [diff] [blame] | 2168 | if (event.type() == WebInputEvent::GestureTap) { |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 2169 | ShowVirtualKeyboard(); |
dtapuska | 8c4dae1 | 2017-01-13 00:23:06 | [diff] [blame] | 2170 | } else if (event.type() == WebInputEvent::GestureLongPress) { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 2171 | DCHECK(GetWebWidget()); |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 2172 | blink::WebInputMethodController* controller = GetInputMethodController(); |
| 2173 | if (!controller || controller->textInputInfo().value.isEmpty()) |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 2174 | UpdateTextInputState(); |
[email protected] | 07c70d2 | 2014-08-21 08:33:46 | [diff] [blame] | 2175 | else |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 2176 | ShowVirtualKeyboard(); |
[email protected] | c68c3e4e | 2013-01-24 00:36:56 | [diff] [blame] | 2177 | } |
ekaramad | a110f64 | 2016-12-21 19:47:28 | [diff] [blame] | 2178 | // TODO(ananta): Piggyback off existing IPCs to communicate this information, |
| 2179 | // crbug/420130. |
| 2180 | #if defined(OS_WIN) |
dtapuska | 8c4dae1 | 2017-01-13 00:23:06 | [diff] [blame] | 2181 | if (event.type() != blink::WebGestureEvent::GestureTap) |
ekaramad | a110f64 | 2016-12-21 19:47:28 | [diff] [blame] | 2182 | return; |
| 2183 | |
| 2184 | // TODO(estade): hit test the event against focused node to make sure |
| 2185 | // the tap actually hit the focused node. |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 2186 | blink::WebInputMethodController* controller = GetInputMethodController(); |
| 2187 | blink::WebTextInputType text_input_type = |
| 2188 | controller ? controller->textInputType() : blink::WebTextInputTypeNone; |
ekaramad | a110f64 | 2016-12-21 19:47:28 | [diff] [blame] | 2189 | |
| 2190 | Send(new ViewHostMsg_FocusedNodeTouched( |
| 2191 | routing_id_, text_input_type != blink::WebTextInputTypeNone)); |
| 2192 | #endif |
[email protected] | c68c3e4e | 2013-01-24 00:36:56 | [diff] [blame] | 2193 | #endif |
| 2194 | } |
| 2195 | |
sataya.m | 582c9ce | 2015-06-09 08:03:42 | [diff] [blame] | 2196 | void RenderWidget::didOverscroll( |
bokan | e53a10f | 2016-04-13 23:48:31 | [diff] [blame] | 2197 | const blink::WebFloatSize& overscrollDelta, |
| 2198 | const blink::WebFloatSize& accumulatedOverscroll, |
sataya.m | 582c9ce | 2015-06-09 08:03:42 | [diff] [blame] | 2199 | const blink::WebFloatPoint& position, |
| 2200 | const blink::WebFloatSize& velocity) { |
bokan | 731ec38 | 2016-04-07 03:16:48 | [diff] [blame] | 2201 | #if defined(OS_MACOSX) |
| 2202 | // On OSX the user can disable the elastic overscroll effect. If that's the |
| 2203 | // case, don't forward the overscroll notification. |
| 2204 | DCHECK(compositor_deps()); |
| 2205 | if (!compositor_deps()->IsElasticOverscrollEnabled()) |
| 2206 | return; |
| 2207 | #endif |
bokan | e53a10f | 2016-04-13 23:48:31 | [diff] [blame] | 2208 | input_handler_->DidOverscrollFromBlink(overscrollDelta, accumulatedOverscroll, |
fsamuel | e8326c74 | 2016-01-12 00:49:39 | [diff] [blame] | 2209 | position, velocity); |
sataya.m | 582c9ce | 2015-06-09 08:03:42 | [diff] [blame] | 2210 | } |
| 2211 | |
[email protected] | 7912e82 | 2014-04-16 02:37:03 | [diff] [blame] | 2212 | void RenderWidget::StartCompositor() { |
sievers | 71c62dd5 | 2015-10-07 01:44:39 | [diff] [blame] | 2213 | if (!is_hidden()) |
| 2214 | compositor_->setVisible(true); |
[email protected] | 7912e82 | 2014-04-16 02:37:03 | [diff] [blame] | 2215 | } |
| 2216 | |
[email protected] | 24ed043 | 2013-04-24 07:50:31 | [diff] [blame] | 2217 | RenderWidgetCompositor* RenderWidget::compositor() const { |
| 2218 | return compositor_.get(); |
| 2219 | } |
| 2220 | |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 2221 | void RenderWidget::SetHandlingInputEventForTesting(bool handling_input_event) { |
fsamuel | e8326c74 | 2016-01-12 00:49:39 | [diff] [blame] | 2222 | input_handler_->set_handling_input_event(handling_input_event); |
[email protected] | 67bfb83f | 2011-09-22 03:36:37 | [diff] [blame] | 2223 | } |
[email protected] | c3d4553 | 2011-10-07 19:20:40 | [diff] [blame] | 2224 | |
[email protected] | ce6689f | 2013-03-29 12:52:55 | [diff] [blame] | 2225 | void RenderWidget::hasTouchEventHandlers(bool has_handlers) { |
alexclarke | 7fa9394 | 2015-10-21 15:37:11 | [diff] [blame] | 2226 | if (render_widget_scheduling_state_) |
| 2227 | render_widget_scheduling_state_->SetHasTouchHandler(has_handlers); |
[email protected] | ce6689f | 2013-03-29 12:52:55 | [diff] [blame] | 2228 | Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers)); |
| 2229 | } |
| 2230 | |
[email protected] | 5d0bbdfa9 | 2013-12-10 00:35:51 | [diff] [blame] | 2231 | void RenderWidget::setTouchAction( |
| 2232 | blink::WebTouchAction web_touch_action) { |
[email protected] | 5d0bbdfa9 | 2013-12-10 00:35:51 | [diff] [blame] | 2233 | // Ignore setTouchAction calls that result from synthetic touch events (eg. |
| 2234 | // when blink is emulating touch with mouse). |
fsamuel | e8326c74 | 2016-01-12 00:49:39 | [diff] [blame] | 2235 | if (input_handler_->handling_event_type() != WebInputEvent::TouchStart) |
[email protected] | 5d0bbdfa9 | 2013-12-10 00:35:51 | [diff] [blame] | 2236 | return; |
| 2237 | |
[email protected] | a18f67a | 2013-12-20 19:44:36 | [diff] [blame] | 2238 | content::TouchAction content_touch_action = |
| 2239 | static_cast<content::TouchAction>(web_touch_action); |
[email protected] | 5d0bbdfa9 | 2013-12-10 00:35:51 | [diff] [blame] | 2240 | Send(new InputHostMsg_SetTouchAction(routing_id_, content_touch_action)); |
| 2241 | } |
| 2242 | |
[email protected] | e3244ed | 2014-06-20 20:04:27 | [diff] [blame] | 2243 | void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) { |
| 2244 | render_frame_proxies_.AddObserver(proxy); |
[email protected] | bffc830 | 2014-01-23 20:52:16 | [diff] [blame] | 2245 | } |
| 2246 | |
[email protected] | e3244ed | 2014-06-20 20:04:27 | [diff] [blame] | 2247 | void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) { |
| 2248 | render_frame_proxies_.RemoveObserver(proxy); |
[email protected] | bffc830 | 2014-01-23 20:52:16 | [diff] [blame] | 2249 | } |
| 2250 | |
[email protected] | de3c5d8 | 2014-05-28 22:12:59 | [diff] [blame] | 2251 | void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) { |
| 2252 | render_frames_.AddObserver(frame); |
| 2253 | } |
| 2254 | |
| 2255 | void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) { |
| 2256 | render_frames_.RemoveObserver(frame); |
| 2257 | } |
| 2258 | |
lfg | 43e08e6 | 2016-02-03 18:51:37 | [diff] [blame] | 2259 | void RenderWidget::OnWaitNextFrameForTests(int routing_id) { |
| 2260 | QueueMessage(new ViewHostMsg_WaitForNextFrameForTests_ACK(routing_id), |
| 2261 | MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE); |
| 2262 | } |
| 2263 | |
oshima | 50872a7 | 2016-03-04 13:26:18 | [diff] [blame] | 2264 | float RenderWidget::GetOriginalDeviceScaleFactor() const { |
| 2265 | return |
| 2266 | screen_metrics_emulator_ ? |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 2267 | screen_metrics_emulator_->original_screen_info().device_scale_factor : |
oshima | 50872a7 | 2016-03-04 13:26:18 | [diff] [blame] | 2268 | device_scale_factor_; |
| 2269 | } |
| 2270 | |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 2271 | gfx::Point RenderWidget::ConvertWindowPointToViewport( |
| 2272 | const gfx::Point& point) { |
| 2273 | blink::WebFloatRect point_in_viewport(point.x(), point.y(), 0, 0); |
| 2274 | convertWindowToViewport(&point_in_viewport); |
| 2275 | return gfx::Point(point_in_viewport.x, point_in_viewport.y); |
| 2276 | } |
| 2277 | |
lfg | bee1e0a | 2016-06-08 21:24:21 | [diff] [blame] | 2278 | bool RenderWidget::requestPointerLock() { |
| 2279 | return mouse_lock_dispatcher_->LockMouse(webwidget_mouse_lock_target_.get()); |
| 2280 | } |
| 2281 | |
| 2282 | void RenderWidget::requestPointerUnlock() { |
| 2283 | mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get()); |
| 2284 | } |
| 2285 | |
| 2286 | bool RenderWidget::isPointerLocked() { |
| 2287 | return mouse_lock_dispatcher_->IsMouseLockedTo( |
| 2288 | webwidget_mouse_lock_target_.get()); |
| 2289 | } |
| 2290 | |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 2291 | void RenderWidget::startDragging(blink::WebReferrerPolicy policy, |
| 2292 | const WebDragData& data, |
| 2293 | WebDragOperationsMask mask, |
| 2294 | const WebImage& image, |
| 2295 | const WebPoint& webImageOffset) { |
| 2296 | blink::WebRect offset_in_window(webImageOffset.x, webImageOffset.y, 0, 0); |
| 2297 | convertViewportToWindow(&offset_in_window); |
| 2298 | DropData drop_data(DropDataBuilder::Build(data)); |
| 2299 | drop_data.referrer_policy = policy; |
| 2300 | gfx::Vector2d imageOffset(offset_in_window.x, offset_in_window.y); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 2301 | Send(new DragHostMsg_StartDragging(routing_id(), drop_data, mask, |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 2302 | image.getSkBitmap(), imageOffset, |
| 2303 | possible_drag_event_info_)); |
| 2304 | } |
| 2305 | |
kenrb | 5d78b84 | 2017-03-06 21:06:01 | [diff] [blame] | 2306 | uint32_t RenderWidget::GetContentSourceId() { |
| 2307 | return current_content_source_id_; |
| 2308 | } |
| 2309 | |
| 2310 | void RenderWidget::IncrementContentSourceId() { |
| 2311 | if (compositor_) |
| 2312 | compositor_->SetContentSourceId(++current_content_source_id_); |
| 2313 | } |
| 2314 | |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 2315 | blink::WebWidget* RenderWidget::GetWebWidget() const { |
| 2316 | return webwidget_internal_; |
| 2317 | } |
| 2318 | |
ekaramad | 2daaf67 | 2016-11-10 20:29:01 | [diff] [blame] | 2319 | blink::WebInputMethodController* RenderWidget::GetInputMethodController() |
| 2320 | const { |
ekaramad | 5a9f52a | 2016-12-07 01:35:18 | [diff] [blame] | 2321 | if (!GetWebWidget()->isWebFrameWidget()) { |
| 2322 | // TODO(ekaramad): We should not get here in response to IME IPC or updates |
| 2323 | // when the RenderWidget is swapped out. We should top sending IPCs from the |
| 2324 | // browser side (https://crbug.com/669219). |
| 2325 | // If there is no WebFrameWidget, then there will be no |
| 2326 | // InputMethodControllers for a WebLocalFrame. |
| 2327 | return nullptr; |
| 2328 | } |
ekaramad | 2daaf67 | 2016-11-10 20:29:01 | [diff] [blame] | 2329 | return static_cast<blink::WebFrameWidget*>(GetWebWidget()) |
| 2330 | ->getActiveWebInputMethodController(); |
| 2331 | } |
| 2332 | |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 2333 | } // namespace content |