[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 | |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 7 | #include <cmath> |
| 8 | #include <limits> |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 9 | #include <memory> |
dcheng | 07945f63 | 2015-12-26 07:59:32 | [diff] [blame] | 10 | #include <utility> |
| 11 | |
[email protected] | c27dd4f | 2014-05-22 18:05:19 | [diff] [blame] | 12 | #include "base/auto_reset.h" |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 13 | #include "base/base_switches.h" |
[email protected] | 32876ae | 2011-11-15 22:25:21 | [diff] [blame] | 14 | #include "base/bind.h" |
[email protected] | 4fb6684 | 2009-12-04 21:41:00 | [diff] [blame] | 15 | #include "base/command_line.h" |
changwan | 7ded375 | 2016-03-09 23:25:12 | [diff] [blame] | 16 | #include "base/feature_list.h" |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 17 | #include "base/logging.h" |
avi | 1023d01 | 2015-12-25 02:39:14 | [diff] [blame] | 18 | #include "base/macros.h" |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 19 | #include "base/memory/ptr_util.h" |
[email protected] | b256eca | 2013-07-11 10:57:40 | [diff] [blame] | 20 | #include "base/memory/singleton.h" |
asvitkine | 8d51e9d | 2016-09-02 23:55:43 | [diff] [blame] | 21 | #include "base/metrics/histogram_macros.h" |
[email protected] | aa4117f | 2011-12-09 22:19:21 | [diff] [blame] | 22 | #include "base/stl_util.h" |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 23 | #include "base/strings/string_number_conversions.h" |
[email protected] | 74ebfb1 | 2013-06-07 20:48:00 | [diff] [blame] | 24 | #include "base/strings/utf_string_conversions.h" |
[email protected] | 35b4f0c | 2014-06-26 16:55:27 | [diff] [blame] | 25 | #include "base/sys_info.h" |
fdoray | a19b770 | 2016-12-23 14:19:31 | [diff] [blame] | 26 | #include "base/threading/thread_task_runner_handle.h" |
primiano | 9e38d55 | 2015-01-28 04:18:01 | [diff] [blame] | 27 | #include "base/trace_event/trace_event.h" |
[email protected] | 661eb9d | 2009-02-03 02:11:48 | [diff] [blame] | 28 | #include "build/build_config.h" |
loyso | 6e6efc4 | 2017-01-21 02:23:03 | [diff] [blame] | 29 | #include "cc/animation/animation_host.h" |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 30 | #include "cc/base/switches.h" |
xidachen | fa0199e7 | 2017-05-11 11:34:26 | [diff] [blame] | 31 | #include "cc/input/touch_action.h" |
danakj | ba65a091 | 2017-09-21 16:38:42 | [diff] [blame] | 32 | #include "cc/trees/layer_tree_frame_sink.h" |
loyso | 6e6efc4 | 2017-01-21 02:23:03 | [diff] [blame] | 33 | #include "cc/trees/layer_tree_host.h" |
danakj | 4c98765 | 2018-07-05 15:49:41 | [diff] [blame] | 34 | #include "cc/trees/ukm_manager.h" |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 35 | #include "components/viz/common/features.h" |
Fady Samuel | c645ffe | 2017-07-24 17:28:20 | [diff] [blame] | 36 | #include "components/viz/common/frame_sinks/begin_frame_source.h" |
danakj | f20f450 | 2017-09-26 17:13:31 | [diff] [blame] | 37 | #include "components/viz/common/frame_sinks/copy_output_request.h" |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 38 | #include "components/viz/common/switches.h" |
| 39 | #include "content/common/content_switches_internal.h" |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 40 | #include "content/common/drag_event_source_info.h" |
| 41 | #include "content/common/drag_messages.h" |
jonross | a2ff4f8 | 2018-02-16 17:27:46 | [diff] [blame] | 42 | #include "content/common/render_frame_metadata.mojom.h" |
jcivelli | ae1560a | 2016-11-01 22:40:23 | [diff] [blame] | 43 | #include "content/common/render_message_filter.mojom.h" |
Nasko Oskov | f97e8b0 | 2017-07-25 02:45:42 | [diff] [blame] | 44 | #include "content/common/swapped_out_messages.h" |
Sadrul Habib Chowdhury | 8bc43cc | 2018-06-06 01:48:03 | [diff] [blame] | 45 | #include "content/common/tab_switching_time_callback.h" |
ekaramad | 9053e57b | 2016-04-26 20:00:38 | [diff] [blame] | 46 | #include "content/common/text_input_state.h" |
[email protected] | 778574e | 2011-03-21 22:03:50 | [diff] [blame] | 47 | #include "content/common/view_messages.h" |
mlamouri | afca06dd | 2017-01-27 23:35:18 | [diff] [blame] | 48 | #include "content/public/common/content_client.h" |
changwan | 7ded375 | 2016-03-09 23:25:12 | [diff] [blame] | 49 | #include "content/public/common/content_features.h" |
[email protected] | c08950d2 | 2011-10-13 22:20:29 | [diff] [blame] | 50 | #include "content/public/common/content_switches.h" |
[email protected] | a09d53ce | 2014-01-31 00:46:42 | [diff] [blame] | 51 | #include "content/public/common/context_menu_params.h" |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 52 | #include "content/public/common/drop_data.h" |
Khushal | 3e96e66 | 2017-10-30 23:16:50 | [diff] [blame] | 53 | #include "content/public/common/service_names.mojom.h" |
Jaebaek Seo | 655110e | 2017-12-19 23:27:39 | [diff] [blame] | 54 | #include "content/public/common/use_zoom_for_dsf_policy.h" |
mlamouri | afca06dd | 2017-01-27 23:35:18 | [diff] [blame] | 55 | #include "content/public/renderer/content_renderer_client.h" |
Saman Sami | d189e5dfd | 2017-12-20 22:55:31 | [diff] [blame] | 56 | #include "content/renderer/browser_plugin/browser_plugin.h" |
[email protected] | 953bd006 | 2013-08-01 00:58:40 | [diff] [blame] | 57 | #include "content/renderer/cursor_utils.h" |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 58 | #include "content/renderer/devtools/render_widget_screen_metrics_emulator.h" |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 59 | #include "content/renderer/drop_data_builder.h" |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 60 | #include "content/renderer/external_popup_menu.h" |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 61 | #include "content/renderer/gpu/frame_swap_message_queue.h" |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 62 | #include "content/renderer/gpu/layer_tree_view.h" |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 63 | #include "content/renderer/gpu/queue_message_swap_promise.h" |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 64 | #include "content/renderer/idle_user_detector.h" |
[email protected] | 66fca5bc | 2013-05-23 06:58:29 | [diff] [blame] | 65 | #include "content/renderer/ime_event_guard.h" |
dtapuska | 9ec1a91 | 2017-04-21 15:18:31 | [diff] [blame] | 66 | #include "content/renderer/input/main_thread_event_queue.h" |
Dave Tapuska | 9db8084 | 2017-07-24 17:24:26 | [diff] [blame] | 67 | #include "content/renderer/input/widget_input_handler_manager.h" |
[email protected] | adab233 | 2013-07-25 18:04:32 | [diff] [blame] | 68 | #include "content/renderer/pepper/pepper_plugin_instance_impl.h" |
[email protected] | bffc830 | 2014-01-23 20:52:16 | [diff] [blame] | 69 | #include "content/renderer/render_frame_impl.h" |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 70 | #include "content/renderer/render_frame_metadata_observer_impl.h" |
[email protected] | e3244ed | 2014-06-20 20:04:27 | [diff] [blame] | 71 | #include "content/renderer/render_frame_proxy.h" |
[email protected] | 8704f89b | 2011-04-15 00:30:05 | [diff] [blame] | 72 | #include "content/renderer/render_process.h" |
[email protected] | f1a29a0 | 2011-10-06 23:08:44 | [diff] [blame] | 73 | #include "content/renderer/render_thread_impl.h" |
dcheng | 3ce04b6 | 2015-10-26 23:30:55 | [diff] [blame] | 74 | #include "content/renderer/render_view_impl.h" |
avi | 40b5be7a | 2016-03-03 21:13:44 | [diff] [blame] | 75 | #include "content/renderer/render_widget_owner_delegate.h" |
tfarina | 556a723 | 2014-10-05 01:02:09 | [diff] [blame] | 76 | #include "content/renderer/renderer_blink_platform_impl.h" |
[email protected] | 5b45ad4 | 2013-10-25 00:42:04 | [diff] [blame] | 77 | #include "content/renderer/resizing_mode_selector.h" |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 78 | #include "gpu/command_buffer/service/gpu_switches.h" |
ekaramad | 330ba423 | 2016-09-23 17:57:47 | [diff] [blame] | 79 | #include "ipc/ipc_message_start.h" |
[email protected] | 48495594 | 2010-08-19 16:13:18 | [diff] [blame] | 80 | #include "ipc/ipc_sync_message.h" |
Antoine Labour | e55c9ef8 | 2017-11-10 18:51:23 | [diff] [blame] | 81 | #include "ipc/ipc_sync_message_filter.h" |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 82 | #include "media/base/media_switches.h" |
Scott Violet | 02e38b9 | 2018-03-27 23:42:14 | [diff] [blame] | 83 | #include "ppapi/buildflags/buildflags.h" |
[email protected] | 661eb9d | 2009-02-03 02:11:48 | [diff] [blame] | 84 | #include "skia/ext/platform_canvas.h" |
Blink Reformat | a30d423 | 2018-04-07 15:31:06 | [diff] [blame] | 85 | #include "third_party/blink/public/platform/file_path_conversion.h" |
Blink Reformat | a30d423 | 2018-04-07 15:31:06 | [diff] [blame] | 86 | #include "third_party/blink/public/platform/scheduler/web_render_widget_scheduling_state.h" |
Yuta Kitamura | deb91bb | 2018-05-29 05:53:20 | [diff] [blame] | 87 | #include "third_party/blink/public/platform/scheduler/web_thread_scheduler.h" |
Blink Reformat | a30d423 | 2018-04-07 15:31:06 | [diff] [blame] | 88 | #include "third_party/blink/public/platform/web_cursor_info.h" |
| 89 | #include "third_party/blink/public/platform/web_drag_data.h" |
| 90 | #include "third_party/blink/public/platform/web_drag_operation.h" |
| 91 | #include "third_party/blink/public/platform/web_mouse_event.h" |
| 92 | #include "third_party/blink/public/platform/web_point.h" |
| 93 | #include "third_party/blink/public/platform/web_rect.h" |
| 94 | #include "third_party/blink/public/platform/web_runtime_features.h" |
| 95 | #include "third_party/blink/public/platform/web_size.h" |
| 96 | #include "third_party/blink/public/platform/web_string.h" |
| 97 | #include "third_party/blink/public/web/web_autofill_client.h" |
| 98 | #include "third_party/blink/public/web/web_device_emulation_params.h" |
| 99 | #include "third_party/blink/public/web/web_frame_widget.h" |
| 100 | #include "third_party/blink/public/web/web_input_method_controller.h" |
| 101 | #include "third_party/blink/public/web/web_local_frame.h" |
| 102 | #include "third_party/blink/public/web/web_node.h" |
| 103 | #include "third_party/blink/public/web/web_page_popup.h" |
| 104 | #include "third_party/blink/public/web/web_popup_menu_info.h" |
| 105 | #include "third_party/blink/public/web/web_range.h" |
| 106 | #include "third_party/blink/public/web/web_settings.h" |
| 107 | #include "third_party/blink/public/web/web_view.h" |
| 108 | #include "third_party/blink/public/web/web_widget.h" |
[email protected] | d353541f | 2012-05-03 22:45:41 | [diff] [blame] | 109 | #include "third_party/skia/include/core/SkShader.h" |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 110 | #include "ui/base/clipboard/clipboard.h" |
Scott Violet | 8ff9c30 | 2018-02-22 22:28:35 | [diff] [blame] | 111 | #include "ui/base/ui_base_features.h" |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 112 | #include "ui/base/ui_base_switches.h" |
dtapuska | 97286c88 | 2017-02-24 23:14:43 | [diff] [blame] | 113 | #include "ui/events/base_event_utils.h" |
tfarina | 655f81d | 2014-12-23 02:38:50 | [diff] [blame] | 114 | #include "ui/gfx/geometry/point_conversions.h" |
tfarina | 3b0452d | 2014-12-31 15:20:09 | [diff] [blame] | 115 | #include "ui/gfx/geometry/rect_conversions.h" |
tfarina | ebe974f0 | 2015-01-03 04:25:32 | [diff] [blame] | 116 | #include "ui/gfx/geometry/size_conversions.h" |
[email protected] | 1835b9e | 2012-02-28 13:12:48 | [diff] [blame] | 117 | #include "ui/gfx/skia_util.h" |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 118 | #include "ui/gfx/switches.h" |
[email protected] | c9e2cbbb | 2012-05-12 21:17:27 | [diff] [blame] | 119 | #include "ui/gl/gl_switches.h" |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 120 | #include "ui/native_theme/native_theme_features.h" |
| 121 | #include "ui/native_theme/overlay_scrollbar_constants_aura.h" |
[email protected] | d353541f | 2012-05-03 22:45:41 | [diff] [blame] | 122 | #include "ui/surface/transport_dib.h" |
[email protected] | 661eb9d | 2009-02-03 02:11:48 | [diff] [blame] | 123 | |
[email protected] | eeb9311 | 2013-05-01 19:41:10 | [diff] [blame] | 124 | #if defined(OS_ANDROID) |
[email protected] | cefe9b15 | 2014-03-27 18:16:15 | [diff] [blame] | 125 | #include <android/keycodes.h> |
wjmaclean | 1d97062 | 2017-01-21 22:28:24 | [diff] [blame] | 126 | #include "base/time/time.h" |
[email protected] | eeb9311 | 2013-05-01 19:41:10 | [diff] [blame] | 127 | #endif |
| 128 | |
[email protected] | 661eb9d | 2009-02-03 02:11:48 | [diff] [blame] | 129 | #if defined(OS_POSIX) |
[email protected] | d5282e7 | 2009-05-13 13:16:52 | [diff] [blame] | 130 | #include "third_party/skia/include/core/SkMallocPixelRef.h" |
[email protected] | d353541f | 2012-05-03 22:45:41 | [diff] [blame] | 131 | #include "third_party/skia/include/core/SkPixelRef.h" |
[email protected] | 661eb9d | 2009-02-03 02:11:48 | [diff] [blame] | 132 | #endif // defined(OS_POSIX) |
[email protected] | 8085dbc8 | 2008-09-26 22:53:44 | [diff] [blame] | 133 | |
sadrul | 943e3b3 | 2016-08-04 18:22:59 | [diff] [blame] | 134 | #if defined(USE_AURA) |
sadrul | 602ce136 | 2017-01-26 06:41:10 | [diff] [blame] | 135 | #include "content/renderer/mus/renderer_window_tree_client.h" |
penghuang | 28a5fa2 | 2015-12-02 17:58:19 | [diff] [blame] | 136 | #endif |
| 137 | |
ekaramad | 330ba423 | 2016-09-23 17:57:47 | [diff] [blame] | 138 | #if defined(OS_MACOSX) |
| 139 | #include "content/renderer/text_input_client_observer.h" |
| 140 | #endif |
| 141 | |
Ryan Landay | 9e42fd74 | 2017-08-12 01:59:11 | [diff] [blame] | 142 | using blink::WebImeTextSpan; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 143 | using blink::WebCursorInfo; |
[email protected] | 1919368 | 2014-04-03 15:01:43 | [diff] [blame] | 144 | using blink::WebDeviceEmulationParams; |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 145 | using blink::WebDragOperation; |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 146 | using blink::WebDragOperationsMask; |
| 147 | using blink::WebDragData; |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 148 | using blink::WebFrameWidget; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 149 | using blink::WebGestureEvent; |
| 150 | using blink::WebInputEvent; |
dtapuska | 5d2e9c3 | 2015-12-03 16:39:49 | [diff] [blame] | 151 | using blink::WebInputEventResult; |
ekaramad | 2daaf67 | 2016-11-10 20:29:01 | [diff] [blame] | 152 | using blink::WebInputMethodController; |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 153 | using blink::WebLocalFrame; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 154 | using blink::WebMouseEvent; |
| 155 | using blink::WebMouseWheelEvent; |
| 156 | using blink::WebNavigationPolicy; |
donnd | a070f3c | 2015-01-16 19:54:11 | [diff] [blame] | 157 | using blink::WebNode; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 158 | using blink::WebPagePopup; |
donnd | a070f3c | 2015-01-16 19:54:11 | [diff] [blame] | 159 | using blink::WebPoint; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 160 | using blink::WebPopupType; |
dglazkov | e353a37 | 2016-09-01 01:33:48 | [diff] [blame] | 161 | using blink::WebRange; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 162 | using blink::WebRect; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 163 | using blink::WebSize; |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 164 | using blink::WebString; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 165 | using blink::WebTextDirection; |
| 166 | using blink::WebTouchEvent; |
[email protected] | f8ed472 | 2013-12-03 03:27:25 | [diff] [blame] | 167 | using blink::WebTouchPoint; |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 168 | using blink::WebVector; |
| 169 | using blink::WebWidget; |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 170 | |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 171 | namespace content { |
| 172 | |
[email protected] | 6a4d7f6 | 2013-01-07 21:32:13 | [diff] [blame] | 173 | namespace { |
[email protected] | b256eca | 2013-07-11 10:57:40 | [diff] [blame] | 174 | |
Albert J. Wong | cb00463 | 2018-07-10 22:58:25 | [diff] [blame] | 175 | using RoutingIDWidgetMap = std::map<int32_t, RenderWidget*>; |
| 176 | base::LazyInstance<RoutingIDWidgetMap>::Leaky g_routing_id_widget_map = |
| 177 | LAZY_INSTANCE_INITIALIZER; |
| 178 | |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 179 | const base::Feature kUnpremultiplyAndDitherLowBitDepthTiles = { |
| 180 | "UnpremultiplyAndDitherLowBitDepthTiles", base::FEATURE_ENABLED_BY_DEFAULT}; |
| 181 | |
[email protected] | b256eca | 2013-07-11 10:57:40 | [diff] [blame] | 182 | typedef std::map<std::string, ui::TextInputMode> TextInputModeMap; |
| 183 | |
AJITH KUMAR V | 041c0b0 | 2017-08-08 10:39:20 | [diff] [blame] | 184 | static const int kInvalidNextPreviousFlagsValue = -1; |
| 185 | |
lfg | bee1e0a | 2016-06-08 21:24:21 | [diff] [blame] | 186 | class WebWidgetLockTarget : public content::MouseLockDispatcher::LockTarget { |
| 187 | public: |
| 188 | explicit WebWidgetLockTarget(blink::WebWidget* webwidget) |
| 189 | : webwidget_(webwidget) {} |
| 190 | |
| 191 | void OnLockMouseACK(bool succeeded) override { |
| 192 | if (succeeded) |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 193 | webwidget_->DidAcquirePointerLock(); |
lfg | bee1e0a | 2016-06-08 21:24:21 | [diff] [blame] | 194 | else |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 195 | webwidget_->DidNotAcquirePointerLock(); |
lfg | bee1e0a | 2016-06-08 21:24:21 | [diff] [blame] | 196 | } |
| 197 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 198 | void OnMouseLockLost() override { webwidget_->DidLosePointerLock(); } |
lfg | bee1e0a | 2016-06-08 21:24:21 | [diff] [blame] | 199 | |
| 200 | bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event) override { |
| 201 | // The WebWidget handles mouse lock in Blink's handleInputEvent(). |
| 202 | return false; |
| 203 | } |
| 204 | |
| 205 | private: |
| 206 | blink::WebWidget* webwidget_; |
| 207 | }; |
| 208 | |
dglazkov | 97b6c2b | 2016-10-25 17:35:55 | [diff] [blame] | 209 | bool IsDateTimeInput(ui::TextInputType type) { |
| 210 | return type == ui::TEXT_INPUT_TYPE_DATE || |
| 211 | type == ui::TEXT_INPUT_TYPE_DATE_TIME || |
| 212 | type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL || |
| 213 | type == ui::TEXT_INPUT_TYPE_MONTH || |
| 214 | type == ui::TEXT_INPUT_TYPE_TIME || type == ui::TEXT_INPUT_TYPE_WEEK; |
| 215 | } |
| 216 | |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 217 | WebDragData DropMetaDataToWebDragData( |
| 218 | const std::vector<DropData::Metadata>& drop_meta_data) { |
| 219 | std::vector<WebDragData::Item> item_list; |
| 220 | for (const auto& meta_data_item : drop_meta_data) { |
| 221 | if (meta_data_item.kind == DropData::Kind::STRING) { |
| 222 | WebDragData::Item item; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 223 | item.storage_type = WebDragData::Item::kStorageTypeString; |
| 224 | item.string_type = WebString::FromUTF16(meta_data_item.mime_type); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 225 | // Have to pass a dummy URL here instead of an empty URL because the |
| 226 | // DropData received by browser_plugins goes through a round trip: |
| 227 | // DropData::MetaData --> WebDragData-->DropData. In the end, DropData |
| 228 | // will contain an empty URL (which means no URL is dragged) if the URL in |
| 229 | // WebDragData is empty. |
| 230 | if (base::EqualsASCII(meta_data_item.mime_type, |
| 231 | ui::Clipboard::kMimeTypeURIList)) { |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 232 | item.string_data = WebString::FromUTF8("about:dragdrop-placeholder"); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 233 | } |
| 234 | item_list.push_back(item); |
| 235 | continue; |
| 236 | } |
| 237 | |
| 238 | // TODO(hush): crbug.com/584789. Blink needs to support creating a file with |
| 239 | // just the mimetype. This is needed to drag files to WebView on Android |
| 240 | // platform. |
| 241 | if ((meta_data_item.kind == DropData::Kind::FILENAME) && |
| 242 | !meta_data_item.filename.empty()) { |
| 243 | WebDragData::Item item; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 244 | item.storage_type = WebDragData::Item::kStorageTypeFilename; |
| 245 | item.filename_data = blink::FilePathToWebString(meta_data_item.filename); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 246 | item_list.push_back(item); |
| 247 | continue; |
| 248 | } |
| 249 | |
| 250 | if (meta_data_item.kind == DropData::Kind::FILESYSTEMFILE) { |
| 251 | WebDragData::Item item; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 252 | item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile; |
| 253 | item.file_system_url = meta_data_item.file_system_url; |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 254 | item_list.push_back(item); |
| 255 | continue; |
| 256 | } |
| 257 | } |
| 258 | |
| 259 | WebDragData result; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 260 | result.Initialize(); |
| 261 | result.SetItems(item_list); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 262 | return result; |
| 263 | } |
| 264 | |
| 265 | WebDragData DropDataToWebDragData(const DropData& drop_data) { |
| 266 | std::vector<WebDragData::Item> item_list; |
| 267 | |
| 268 | // These fields are currently unused when dragging into WebKit. |
| 269 | DCHECK(drop_data.download_metadata.empty()); |
| 270 | DCHECK(drop_data.file_contents.empty()); |
dcheng | 3dd8561 | 2017-02-08 10:46:23 | [diff] [blame] | 271 | DCHECK(drop_data.file_contents_content_disposition.empty()); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 272 | |
| 273 | if (!drop_data.text.is_null()) { |
| 274 | WebDragData::Item item; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 275 | item.storage_type = WebDragData::Item::kStorageTypeString; |
| 276 | item.string_type = WebString::FromUTF8(ui::Clipboard::kMimeTypeText); |
| 277 | item.string_data = WebString::FromUTF16(drop_data.text.string()); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 278 | item_list.push_back(item); |
| 279 | } |
| 280 | |
| 281 | if (!drop_data.url.is_empty()) { |
| 282 | WebDragData::Item item; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 283 | item.storage_type = WebDragData::Item::kStorageTypeString; |
| 284 | item.string_type = WebString::FromUTF8(ui::Clipboard::kMimeTypeURIList); |
| 285 | item.string_data = WebString::FromUTF8(drop_data.url.spec()); |
| 286 | item.title = WebString::FromUTF16(drop_data.url_title); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 287 | item_list.push_back(item); |
| 288 | } |
| 289 | |
| 290 | if (!drop_data.html.is_null()) { |
| 291 | WebDragData::Item item; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 292 | item.storage_type = WebDragData::Item::kStorageTypeString; |
| 293 | item.string_type = WebString::FromUTF8(ui::Clipboard::kMimeTypeHTML); |
| 294 | item.string_data = WebString::FromUTF16(drop_data.html.string()); |
| 295 | item.base_url = drop_data.html_base_url; |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 296 | item_list.push_back(item); |
| 297 | } |
| 298 | |
| 299 | for (std::vector<ui::FileInfo>::const_iterator it = |
| 300 | drop_data.filenames.begin(); |
| 301 | it != drop_data.filenames.end(); |
| 302 | ++it) { |
| 303 | WebDragData::Item item; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 304 | item.storage_type = WebDragData::Item::kStorageTypeFilename; |
| 305 | item.filename_data = blink::FilePathToWebString(it->path); |
| 306 | item.display_name_data = |
kinuko | a429302 | 2017-01-27 06:43:25 | [diff] [blame] | 307 | blink::FilePathToWebString(base::FilePath(it->display_name)); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 308 | item_list.push_back(item); |
| 309 | } |
| 310 | |
| 311 | for (std::vector<DropData::FileSystemFileInfo>::const_iterator it = |
| 312 | drop_data.file_system_files.begin(); |
| 313 | it != drop_data.file_system_files.end(); |
| 314 | ++it) { |
| 315 | WebDragData::Item item; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 316 | item.storage_type = WebDragData::Item::kStorageTypeFileSystemFile; |
| 317 | item.file_system_url = it->url; |
| 318 | item.file_system_file_size = it->size; |
| 319 | item.file_system_id = blink::WebString::FromASCII(it->filesystem_id); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 320 | item_list.push_back(item); |
| 321 | } |
| 322 | |
Stuart Langley | 4830039 | 2017-11-02 03:54:44 | [diff] [blame] | 323 | for (const auto& it : drop_data.custom_data) { |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 324 | WebDragData::Item item; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 325 | item.storage_type = WebDragData::Item::kStorageTypeString; |
Stuart Langley | 4830039 | 2017-11-02 03:54:44 | [diff] [blame] | 326 | item.string_type = WebString::FromUTF16(it.first); |
| 327 | item.string_data = WebString::FromUTF16(it.second); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 328 | item_list.push_back(item); |
| 329 | } |
| 330 | |
| 331 | WebDragData result; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 332 | result.Initialize(); |
| 333 | result.SetItems(item_list); |
| 334 | result.SetFilesystemId(WebString::FromUTF16(drop_data.filesystem_id)); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 335 | return result; |
| 336 | } |
| 337 | |
lfg | 1568d11 | 2016-08-30 16:06:29 | [diff] [blame] | 338 | content::RenderWidget::CreateRenderWidgetFunction g_create_render_widget = |
| 339 | nullptr; |
| 340 | |
| 341 | content::RenderWidget::RenderWidgetInitializedCallback |
| 342 | g_render_widget_initialized = nullptr; |
| 343 | |
dtapuska | c4dd5be | 2016-10-25 15:11:10 | [diff] [blame] | 344 | ui::TextInputType ConvertWebTextInputType(blink::WebTextInputType type) { |
| 345 | // Check the type is in the range representable by ui::TextInputType. |
| 346 | DCHECK_LE(type, static_cast<int>(ui::TEXT_INPUT_TYPE_MAX)) |
| 347 | << "blink::WebTextInputType and ui::TextInputType not synchronized"; |
| 348 | return static_cast<ui::TextInputType>(type); |
| 349 | } |
| 350 | |
| 351 | ui::TextInputMode ConvertWebTextInputMode(blink::WebTextInputMode mode) { |
| 352 | // Check the mode is in the range representable by ui::TextInputMode. |
| 353 | DCHECK_LE(mode, static_cast<int>(ui::TEXT_INPUT_MODE_MAX)) |
| 354 | << "blink::WebTextInputMode and ui::TextInputMode not synchronized"; |
| 355 | return static_cast<ui::TextInputMode>(mode); |
| 356 | } |
| 357 | |
Mitsuru Oshima | 3c07b33 | 2018-02-06 04:56:50 | [diff] [blame] | 358 | // Returns true if the device scale is high enough that losing subpixel |
| 359 | // antialiasing won't have a noticeable effect on text quality. |
| 360 | static bool DeviceScaleEnsuresTextQuality(float device_scale_factor) { |
| 361 | #if defined(OS_ANDROID) || defined(OS_CHROMEOS) |
| 362 | // On Android, we never have subpixel antialiasing. On Chrome OS we prefer to |
| 363 | // composite all scrollers so that we get animated overlay scrollbars. |
| 364 | return true; |
| 365 | #else |
| 366 | // 1.5 is a common touchscreen tablet device scale factor. For such |
| 367 | // devices main thread antialiasing is a heavy burden. |
| 368 | return device_scale_factor >= 1.5f; |
| 369 | #endif |
| 370 | } |
| 371 | |
| 372 | static bool PreferCompositingToLCDText(CompositorDependencies* compositor_deps, |
| 373 | float device_scale_factor) { |
| 374 | const base::CommandLine& command_line = |
| 375 | *base::CommandLine::ForCurrentProcess(); |
| 376 | if (command_line.HasSwitch(switches::kDisablePreferCompositingToLCDText)) |
| 377 | return false; |
| 378 | if (command_line.HasSwitch(switches::kEnablePreferCompositingToLCDText)) |
| 379 | return true; |
| 380 | if (!compositor_deps->IsLcdTextEnabled()) |
| 381 | return true; |
| 382 | return DeviceScaleEnsuresTextQuality(device_scale_factor); |
| 383 | } |
| 384 | |
[email protected] | b256eca | 2013-07-11 10:57:40 | [diff] [blame] | 385 | } // namespace |
| 386 | |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 387 | // RenderWidget --------------------------------------------------------------- |
| 388 | |
Hajime Hoshi | abb3c8f | 2017-12-04 18:41:39 | [diff] [blame] | 389 | RenderWidget::RenderWidget( |
| 390 | int32_t widget_routing_id, |
| 391 | CompositorDependencies* compositor_deps, |
| 392 | blink::WebPopupType popup_type, |
Scott Violet | ae08f33 | 2018-07-27 17:37:23 | [diff] [blame] | 393 | const ScreenInfo& screen_info, |
danakj | 73dd303 | 2018-07-28 17:49:53 | [diff] [blame] | 394 | blink::WebDisplayMode display_mode, |
Hajime Hoshi | abb3c8f | 2017-12-04 18:41:39 | [diff] [blame] | 395 | bool swapped_out, |
| 396 | bool hidden, |
| 397 | bool never_visible, |
| 398 | scoped_refptr<base::SingleThreadTaskRunner> task_runner, |
| 399 | mojom::WidgetRequest widget_request) |
nick | 8331f8ad | 2016-11-15 20:42:45 | [diff] [blame] | 400 | : routing_id_(widget_routing_id), |
dcheng | 35d31c11 | 2015-07-22 00:17:36 | [diff] [blame] | 401 | compositor_deps_(compositor_deps), |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 402 | webwidget_internal_(nullptr), |
avi | 40b5be7a | 2016-03-03 21:13:44 | [diff] [blame] | 403 | owner_delegate_(nullptr), |
[email protected] | 847a258 | 2013-03-09 02:29:51 | [diff] [blame] | 404 | auto_resize_mode_(false), |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 405 | did_show_(false), |
[email protected] | 1ac10dca | 2013-08-20 20:47:04 | [diff] [blame] | 406 | is_hidden_(hidden), |
sievers | 71c62dd5 | 2015-10-07 01:44:39 | [diff] [blame] | 407 | compositor_never_visible_(never_visible), |
mikhail.pozdnyakov | f2c902a | 2015-04-14 08:09:12 | [diff] [blame] | 408 | is_fullscreen_granted_(false), |
danakj | 73dd303 | 2018-07-28 17:49:53 | [diff] [blame] | 409 | display_mode_(display_mode), |
changwan | f2a707b | 2015-10-30 08:22:16 | [diff] [blame] | 410 | ime_event_guard_(nullptr), |
[email protected] | 661eb9d | 2009-02-03 02:11:48 | [diff] [blame] | 411 | closing_(false), |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 412 | host_closing_(false), |
[email protected] | 14392a5 | 2012-05-02 20:28:44 | [diff] [blame] | 413 | is_swapped_out_(swapped_out), |
dglazkov | 97b6c2b | 2016-10-25 17:35:55 | [diff] [blame] | 414 | text_input_type_(ui::TEXT_INPUT_TYPE_NONE), |
[email protected] | b256eca | 2013-07-11 10:57:40 | [diff] [blame] | 415 | text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT), |
shuchen | 82ce8c5 | 2014-10-23 01:55:20 | [diff] [blame] | 416 | text_input_flags_(0), |
AJITH KUMAR V | 041c0b0 | 2017-08-08 10:39:20 | [diff] [blame] | 417 | next_previous_flags_(kInvalidNextPreviousFlagsValue), |
[email protected] | 86ba5fcb | 2013-09-04 00:36:53 | [diff] [blame] | 418 | can_compose_inline_(true), |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 419 | composition_range_(gfx::Range::InvalidRange()), |
[email protected] | 3e2b375b | 2010-04-07 17:03:12 | [diff] [blame] | 420 | popup_type_(popup_type), |
[email protected] | 867125a0 | 2009-12-10 06:01:48 | [diff] [blame] | 421 | pending_window_rect_count_(0), |
Scott Violet | ae08f33 | 2018-07-27 17:37:23 | [diff] [blame] | 422 | screen_info_(screen_info), |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 423 | monitor_composition_info_(false), |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 424 | popup_origin_scale_for_emulation_(0.f), |
samans | 26510e44 | 2017-06-01 22:29:12 | [diff] [blame] | 425 | frame_swap_message_queue_(new FrameSwapMessageQueue(routing_id_)), |
[email protected] | a09d53ce | 2014-01-31 00:46:42 | [diff] [blame] | 426 | resizing_mode_selector_(new ResizingModeSelector()), |
lfg | e0c2792ec | 2016-05-11 18:52:08 | [diff] [blame] | 427 | has_host_context_menu_location_(false), |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 428 | has_focus_(false), |
Nicolas Pena | 75a35d66 | 2018-04-05 20:13:44 | [diff] [blame] | 429 | for_oopif_(false), |
ekaramad | 330ba423 | 2016-09-23 17:57:47 | [diff] [blame] | 430 | #if defined(OS_MACOSX) |
| 431 | text_input_client_observer_(new TextInputClientObserver(this)), |
| 432 | #endif |
Takashi SAKAMOTO | 870f626 | 2017-08-22 04:08:27 | [diff] [blame] | 433 | first_update_visual_state_after_hidden_(false), |
tasak | b95dbb50c | 2017-02-08 18:07:50 | [diff] [blame] | 434 | was_shown_time_(base::TimeTicks::Now()), |
kenrb | 5d78b84 | 2017-03-06 21:06:01 | [diff] [blame] | 435 | current_content_source_id_(0), |
Dave Tapuska | 1bdf183 | 2017-07-07 18:07:19 | [diff] [blame] | 436 | widget_binding_(this, std::move(widget_request)), |
Hajime Hoshi | abb3c8f | 2017-12-04 18:41:39 | [diff] [blame] | 437 | task_runner_(task_runner), |
wjmaclean | 1d97062 | 2017-01-21 22:28:24 | [diff] [blame] | 438 | weak_ptr_factory_(this) { |
nick | 8331f8ad | 2016-11-15 20:42:45 | [diff] [blame] | 439 | DCHECK_NE(routing_id_, MSG_ROUTING_NONE); |
[email protected] | 8b3f0eb | 2012-05-03 19:15:05 | [diff] [blame] | 440 | if (!swapped_out) |
| 441 | RenderProcess::current()->AddRefProcess(); |
[email protected] | 38024409 | 2011-10-07 17:26:27 | [diff] [blame] | 442 | DCHECK(RenderThread::Get()); |
alexclarke | 7fa9394 | 2015-10-21 15:37:11 | [diff] [blame] | 443 | |
| 444 | // In tests there may not be a RenderThreadImpl. |
| 445 | if (RenderThreadImpl::current()) { |
| 446 | render_widget_scheduling_state_ = RenderThreadImpl::current() |
Yuta Kitamura | 3331f5c | 2018-04-05 11:12:25 | [diff] [blame] | 447 | ->GetWebMainThreadScheduler() |
dcheng | 07945f63 | 2015-12-26 07:59:32 | [diff] [blame] | 448 | ->NewRenderWidgetSchedulingState(); |
alexclarke | 7fa9394 | 2015-10-21 15:37:11 | [diff] [blame] | 449 | render_widget_scheduling_state_->SetHidden(is_hidden_); |
| 450 | } |
sadrul | 602ce136 | 2017-01-26 06:41:10 | [diff] [blame] | 451 | #if defined(USE_AURA) |
fsamuel | 098eade | 2017-03-21 18:06:14 | [diff] [blame] | 452 | RendererWindowTreeClient::CreateIfNecessary(routing_id_); |
Scott Violet | 6fca131 | 2018-06-15 16:27:26 | [diff] [blame] | 453 | if (!features::IsAshInBrowserProcess()) |
Scott Violet | 1098538e | 2017-10-05 19:23:33 | [diff] [blame] | 454 | RendererWindowTreeClient::Get(routing_id_)->SetVisible(!is_hidden_); |
sadrul | 602ce136 | 2017-01-26 06:41:10 | [diff] [blame] | 455 | #endif |
Albert J. Wong | cb00463 | 2018-07-10 22:58:25 | [diff] [blame] | 456 | |
| 457 | if (routing_id_ != MSG_ROUTING_NONE) |
| 458 | g_routing_id_widget_map.Get().emplace(routing_id_, this); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 459 | } |
| 460 | |
| 461 | RenderWidget::~RenderWidget() { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 462 | DCHECK(!webwidget_internal_) << "Leaking our WebWidget!"; |
Albert J. Wong | cb00463 | 2018-07-10 22:58:25 | [diff] [blame] | 463 | // TODO(ajwong): Add in check that routing_id_ has been removed from |
| 464 | // g_routing_id_widget_map once the shutdown semantics for RenderWidget |
| 465 | // and RenderViewImpl are rationalized. Currently, too many unit and |
| 466 | // browser tests delete a RenderWidget without correclty going through |
| 467 | // the shutdown. https://crbug.com/545684 |
[email protected] | bffc830 | 2014-01-23 20:52:16 | [diff] [blame] | 468 | |
dtapuska | 9ec1a91 | 2017-04-21 15:18:31 | [diff] [blame] | 469 | if (input_event_queue_) |
| 470 | input_event_queue_->ClearClient(); |
| 471 | |
[email protected] | 992db4c | 2011-05-12 15:37:15 | [diff] [blame] | 472 | // If we are swapped out, we have released already. |
[email protected] | d2e2f9ee | 2013-08-21 11:02:02 | [diff] [blame] | 473 | if (!is_swapped_out_ && RenderProcess::current()) |
[email protected] | 992db4c | 2011-05-12 15:37:15 | [diff] [blame] | 474 | RenderProcess::current()->ReleaseProcess(); |
sadrul | 8185d97 | 2017-01-31 18:30:11 | [diff] [blame] | 475 | #if defined(USE_AURA) |
fsamuel | 098eade | 2017-03-21 18:06:14 | [diff] [blame] | 476 | // It is possible for a RenderWidget to be destroyed before it was embedded |
| 477 | // in a mus window. The RendererWindowTreeClient will leak in such cases. So |
| 478 | // explicitly delete it here. |
| 479 | RendererWindowTreeClient::Destroy(routing_id_); |
sadrul | 8185d97 | 2017-01-31 18:30:11 | [diff] [blame] | 480 | #endif |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 481 | } |
| 482 | |
[email protected] | 48495594 | 2010-08-19 16:13:18 | [diff] [blame] | 483 | // static |
lfg | 1568d11 | 2016-08-30 16:06:29 | [diff] [blame] | 484 | void RenderWidget::InstallCreateHook( |
| 485 | CreateRenderWidgetFunction create_render_widget, |
| 486 | RenderWidgetInitializedCallback render_widget_initialized) { |
| 487 | CHECK(!g_create_render_widget && !g_render_widget_initialized); |
| 488 | g_create_render_widget = create_render_widget; |
| 489 | g_render_widget_initialized = render_widget_initialized; |
| 490 | } |
| 491 | |
| 492 | // static |
Albert J. Wong | cb00463 | 2018-07-10 22:58:25 | [diff] [blame] | 493 | RenderWidget* RenderWidget::FromRoutingID(int32_t routing_id) { |
| 494 | RoutingIDWidgetMap* widgets = g_routing_id_widget_map.Pointer(); |
| 495 | RoutingIDWidgetMap::iterator it = widgets->find(routing_id); |
| 496 | return it == widgets->end() ? NULL : it->second; |
| 497 | } |
| 498 | |
| 499 | // static |
nick | f7b3822 | 2016-11-22 21:59:35 | [diff] [blame] | 500 | RenderWidget* RenderWidget::CreateForPopup( |
| 501 | RenderViewImpl* opener, |
| 502 | CompositorDependencies* compositor_deps, |
| 503 | blink::WebPopupType popup_type, |
Hajime Hoshi | abb3c8f | 2017-12-04 18:41:39 | [diff] [blame] | 504 | const ScreenInfo& screen_info, |
| 505 | scoped_refptr<base::SingleThreadTaskRunner> task_runner) { |
Dave Tapuska | 1bdf183 | 2017-07-07 18:07:19 | [diff] [blame] | 506 | mojom::WidgetPtr widget_channel; |
| 507 | mojom::WidgetRequest widget_channel_request = |
| 508 | mojo::MakeRequest(&widget_channel); |
| 509 | |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 510 | // Do a synchronous IPC to obtain a routing ID. |
| 511 | int32_t routing_id = MSG_ROUTING_NONE; |
| 512 | if (!RenderThreadImpl::current_render_message_filter()->CreateNewWidget( |
Dave Tapuska | 1bdf183 | 2017-07-07 18:07:19 | [diff] [blame] | 513 | opener->GetRoutingID(), popup_type, std::move(widget_channel), |
| 514 | &routing_id)) { |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 515 | return nullptr; |
| 516 | } |
| 517 | |
danakj | 73dd303 | 2018-07-28 17:49:53 | [diff] [blame] | 518 | scoped_refptr<RenderWidget> widget( |
| 519 | new RenderWidget(routing_id, compositor_deps, popup_type, screen_info, |
| 520 | blink::kWebDisplayModeUndefined, false, false, false, |
| 521 | task_runner, std::move(widget_channel_request))); |
danakj | df1ceb7 | 2018-07-18 20:02:25 | [diff] [blame] | 522 | ShowCallback opener_callback = base::BindOnce( |
| 523 | &RenderViewImpl::ShowCreatedPopupWidget, opener->GetWeakPtr()); |
Scott Violet | ae08f33 | 2018-07-27 17:37:23 | [diff] [blame] | 524 | widget->Init(std::move(opener_callback), |
| 525 | RenderWidget::CreateWebWidget(widget.get())); |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 526 | DCHECK(!widget->HasOneRef()); // RenderWidget::Init() adds a reference. |
| 527 | return widget.get(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 528 | } |
| 529 | |
[email protected] | 48495594 | 2010-08-19 16:13:18 | [diff] [blame] | 530 | // static |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 531 | RenderWidget* RenderWidget::CreateForFrame( |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 532 | int widget_routing_id, |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 533 | bool hidden, |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 534 | const ScreenInfo& screen_info, |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 535 | CompositorDependencies* compositor_deps, |
| 536 | blink::WebLocalFrame* frame) { |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 537 | CHECK_NE(widget_routing_id, MSG_ROUTING_NONE); |
Albert J. Wong | cb00463 | 2018-07-10 22:58:25 | [diff] [blame] | 538 | RenderFrameImpl* render_frame = RenderFrameImpl::FromWebFrame(frame); |
| 539 | // For the mainframe, the RenderWidget is attached to the RenderView. |
| 540 | // TODO(ajwong): Remove this when the widget is always attached to a frame. |
| 541 | // https://crbug.com/545684 |
| 542 | if (!frame->Parent()) { |
| 543 | RenderViewImpl* view = |
| 544 | static_cast<RenderViewImpl*>(render_frame->GetRenderView()); |
danakj | 9a8a9cf | 2018-07-17 23:52:12 | [diff] [blame] | 545 | // Use the WidgetClient() from the RenderViewImpl, rather than getting its |
| 546 | // RenderWidget directly. Layout tests may inject a different |
| 547 | // WebWidgetClient on the RenderViewImpl that intercepts calls before they |
| 548 | // get to the RenderWidget. |
avi | 8a45c109 | 2016-03-01 16:12:34 | [diff] [blame] | 549 | view->AttachWebFrameWidget( |
danakj | 9a8a9cf | 2018-07-17 23:52:12 | [diff] [blame] | 550 | RenderWidget::CreateWebFrameWidget(view->WidgetClient(), frame)); |
Lucas Furukawa Gadani | 6ccadf7 | 2018-02-13 10:29:10 | [diff] [blame] | 551 | view->GetWidget()->UpdateWebViewWithDeviceScaleFactor(); |
avi | 8a45c109 | 2016-03-01 16:12:34 | [diff] [blame] | 552 | return view->GetWidget(); |
dcheng | 3ce04b6 | 2015-10-26 23:30:55 | [diff] [blame] | 553 | } |
Hajime Hoshi | abb3c8f | 2017-12-04 18:41:39 | [diff] [blame] | 554 | scoped_refptr<base::SingleThreadTaskRunner> task_runner = |
Hajime Hoshi | 0cda875 | 2018-05-11 08:25:54 | [diff] [blame] | 555 | frame->GetTaskRunner(blink::TaskType::kInternalDefault); |
dcheng | 35d31c11 | 2015-07-22 00:17:36 | [diff] [blame] | 556 | scoped_refptr<RenderWidget> widget( |
lfg | 1568d11 | 2016-08-30 16:06:29 | [diff] [blame] | 557 | g_create_render_widget |
nick | 8331f8ad | 2016-11-15 20:42:45 | [diff] [blame] | 558 | ? g_create_render_widget(widget_routing_id, compositor_deps, |
danakj | 73dd303 | 2018-07-28 17:49:53 | [diff] [blame] | 559 | blink::kWebPopupTypeNone, screen_info, |
| 560 | blink::kWebDisplayModeUndefined, false, |
Scott Violet | ae08f33 | 2018-07-27 17:37:23 | [diff] [blame] | 561 | hidden, false) |
nick | 8331f8ad | 2016-11-15 20:42:45 | [diff] [blame] | 562 | : new RenderWidget(widget_routing_id, compositor_deps, |
danakj | 73dd303 | 2018-07-28 17:49:53 | [diff] [blame] | 563 | blink::kWebPopupTypeNone, screen_info, |
| 564 | blink::kWebDisplayModeUndefined, false, hidden, |
| 565 | false, task_runner)); |
simonhong | 628f981 | 2015-04-27 23:13:20 | [diff] [blame] | 566 | widget->for_oopif_ = true; |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 567 | // Init increments the reference count on |widget|, keeping it alive after |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 568 | // this function returns. |
Scott Violet | ae08f33 | 2018-07-27 17:37:23 | [diff] [blame] | 569 | widget->Init(base::NullCallback(), |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 570 | RenderWidget::CreateWebFrameWidget(widget.get(), frame)); |
Lucas Furukawa Gadani | 6ccadf7 | 2018-02-13 10:29:10 | [diff] [blame] | 571 | widget->UpdateWebViewWithDeviceScaleFactor(); |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 572 | |
| 573 | if (g_render_widget_initialized) |
| 574 | g_render_widget_initialized(widget.get()); |
| 575 | return widget.get(); |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 576 | } |
| 577 | |
| 578 | // static |
lfg | caab514 | 2016-02-26 19:06:52 | [diff] [blame] | 579 | blink::WebFrameWidget* RenderWidget::CreateWebFrameWidget( |
danakj | 9a8a9cf | 2018-07-17 23:52:12 | [diff] [blame] | 580 | blink::WebWidgetClient* widget_client, |
dcheng | da9b4bb | 2015-07-20 20:58:08 | [diff] [blame] | 581 | blink::WebLocalFrame* frame) { |
danakj | 9a8a9cf | 2018-07-17 23:52:12 | [diff] [blame] | 582 | return blink::WebFrameWidget::Create(widget_client, frame); |
dcheng | da9b4bb | 2015-07-20 20:58:08 | [diff] [blame] | 583 | } |
| 584 | |
| 585 | // static |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 586 | blink::WebWidget* RenderWidget::CreateWebWidget(RenderWidget* render_widget) { |
[email protected] | 48495594 | 2010-08-19 16:13:18 | [diff] [blame] | 587 | switch (render_widget->popup_type_) { |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 588 | case blink::kWebPopupTypeNone: // Nothing to create. |
[email protected] | 48495594 | 2010-08-19 16:13:18 | [diff] [blame] | 589 | break; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 590 | case blink::kWebPopupTypePage: |
| 591 | return WebPagePopup::Create(render_widget); |
[email protected] | 48495594 | 2010-08-19 16:13:18 | [diff] [blame] | 592 | default: |
| 593 | NOTREACHED(); |
| 594 | } |
Ivan Kotenkov | 2c0d2bb3 | 2017-11-01 15:41:28 | [diff] [blame] | 595 | return nullptr; |
[email protected] | 48495594 | 2010-08-19 16:13:18 | [diff] [blame] | 596 | } |
| 597 | |
dcheng | da9b4bb | 2015-07-20 20:58:08 | [diff] [blame] | 598 | void RenderWidget::CloseForFrame() { |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 599 | if (owner_delegate_) { |
| 600 | owner_delegate_->OverrideCloseForWidget(); |
| 601 | return; |
| 602 | } |
dcheng | d96a27a | 2015-07-24 20:17:32 | [diff] [blame] | 603 | OnClose(); |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 604 | } |
| 605 | |
alexmos | 78c9c0d | 2016-10-14 18:57:03 | [diff] [blame] | 606 | void RenderWidget::SetSwappedOut(bool is_swapped_out) { |
| 607 | // We should only toggle between states. |
| 608 | DCHECK(is_swapped_out_ != is_swapped_out); |
| 609 | is_swapped_out_ = is_swapped_out; |
| 610 | |
| 611 | // If we are swapping out, we will call ReleaseProcess, allowing the process |
| 612 | // to exit if all of its RenderViews are swapped out. We wait until the |
| 613 | // WasSwappedOut call to do this, to allow the unload handler to finish. |
| 614 | // If we are swapping in, we call AddRefProcess to prevent the process from |
| 615 | // exiting. |
| 616 | if (!is_swapped_out_) |
| 617 | RenderProcess::current()->AddRefProcess(); |
| 618 | } |
| 619 | |
Scott Violet | ae08f33 | 2018-07-27 17:37:23 | [diff] [blame] | 620 | void RenderWidget::Init(ShowCallback show_callback, WebWidget* web_widget) { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 621 | DCHECK(!webwidget_internal_); |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 622 | DCHECK_NE(routing_id_, MSG_ROUTING_NONE); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 623 | |
Jeremy Roman | 04f27c37 | 2017-10-27 15:20:55 | [diff] [blame] | 624 | input_handler_ = std::make_unique<RenderWidgetInputHandler>(this, this); |
nick | 8331f8ad | 2016-11-15 20:42:45 | [diff] [blame] | 625 | |
Dave Tapuska | 04bc5ee9 | 2018-04-17 19:03:31 | [diff] [blame] | 626 | RenderThreadImpl* render_thread_impl = RenderThreadImpl::current(); |
Dave Tapuska | 9db8084 | 2017-07-24 17:24:26 | [diff] [blame] | 627 | |
Alexander Timin | 41e917d | 2018-07-02 16:25:35 | [diff] [blame] | 628 | blink::scheduler::WebThreadScheduler* compositor_thread_scheduler = |
| 629 | blink::scheduler::WebThreadScheduler::CompositorThreadScheduler(); |
| 630 | |
Dave Tapuska | 04bc5ee9 | 2018-04-17 19:03:31 | [diff] [blame] | 631 | widget_input_handler_manager_ = WidgetInputHandlerManager::Create( |
| 632 | weak_ptr_factory_.GetWeakPtr(), |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 633 | compositor_thread_scheduler && layer_tree_view_ |
Alexander Timin | 41e917d | 2018-07-02 16:25:35 | [diff] [blame] | 634 | ? compositor_thread_scheduler->InputTaskRunner() |
Dave Tapuska | 04bc5ee9 | 2018-04-17 19:03:31 | [diff] [blame] | 635 | : nullptr, |
| 636 | render_thread_impl ? render_thread_impl->GetWebMainThreadScheduler() |
| 637 | : nullptr); |
Dave Tapuska | 9db8084 | 2017-07-24 17:24:26 | [diff] [blame] | 638 | |
danakj | df1ceb7 | 2018-07-18 20:02:25 | [diff] [blame] | 639 | show_callback_ = std::move(show_callback); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 640 | |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 641 | webwidget_internal_ = web_widget; |
| 642 | webwidget_mouse_lock_target_.reset( |
| 643 | new WebWidgetLockTarget(webwidget_internal_)); |
lfg | bee1e0a | 2016-06-08 21:24:21 | [diff] [blame] | 644 | mouse_lock_dispatcher_.reset(new RenderWidgetMouseLockDispatcher(this)); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 645 | |
nick | 4df698d8 | 2016-11-11 20:39:23 | [diff] [blame] | 646 | RenderThread::Get()->AddRoute(routing_id_, this); |
| 647 | // Take a reference on behalf of the RenderThread. This will be balanced |
| 648 | // when we receive ViewMsg_Close. |
| 649 | AddRef(); |
| 650 | if (RenderThreadImpl::current()) { |
| 651 | RenderThreadImpl::current()->WidgetCreated(); |
| 652 | if (is_hidden_) |
| 653 | RenderThreadImpl::current()->WidgetHidden(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 654 | } |
| 655 | } |
| 656 | |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 657 | void RenderWidget::SetUpIdleUserDetector() { |
| 658 | idle_user_detector_ = std::make_unique<IdleUserDetector>(); |
| 659 | } |
| 660 | |
[email protected] | 949b659 | 2014-08-20 13:17:52 | [diff] [blame] | 661 | void RenderWidget::WasSwappedOut() { |
| 662 | // If we have been swapped out and no one else is using this process, |
| 663 | // it's safe to exit now. |
| 664 | CHECK(is_swapped_out_); |
| 665 | RenderProcess::current()->ReleaseProcess(); |
| 666 | } |
| 667 | |
danakj | 5380269 | 2018-07-25 21:46:44 | [diff] [blame] | 668 | void RenderWidget::ApplyEmulatedScreenMetricsForPopupWidget( |
| 669 | RenderWidget* origin_widget) { |
| 670 | RenderWidgetScreenMetricsEmulator* emulator = |
| 671 | origin_widget->screen_metrics_emulator_.get(); |
| 672 | if (!emulator) |
| 673 | return; |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 674 | popup_origin_scale_for_emulation_ = emulator->scale(); |
[email protected] | 1919368 | 2014-04-03 15:01:43 | [diff] [blame] | 675 | popup_view_origin_for_emulation_ = emulator->applied_widget_rect().origin(); |
Pavel Feldman | cc099f7 | 2017-07-20 23:09:00 | [diff] [blame] | 676 | popup_screen_origin_for_emulation_ = |
Lei Zhang | 9b359d3 | 2017-11-28 00:57:02 | [diff] [blame] | 677 | emulator->original_screen_rect().origin(); |
Fady Samuel | 4255c18 | 2018-05-24 20:42:36 | [diff] [blame] | 678 | UpdateSurfaceAndScreenInfo(local_surface_id_from_parent_, |
| 679 | compositor_viewport_pixel_size_, |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 680 | emulator->original_screen_info()); |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 681 | } |
| 682 | |
[email protected] | 2d6836f4 | 2014-07-02 17:25:31 | [diff] [blame] | 683 | gfx::Rect RenderWidget::AdjustValidationMessageAnchor(const gfx::Rect& anchor) { |
| 684 | if (screen_metrics_emulator_) |
| 685 | return screen_metrics_emulator_->AdjustValidationMessageAnchor(anchor); |
| 686 | return anchor; |
| 687 | } |
| 688 | |
thakis | 18e42641 | 2017-03-15 12:06:37 | [diff] [blame] | 689 | #if BUILDFLAG(USE_EXTERNAL_POPUP_MENU) |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 690 | void RenderWidget::SetExternalPopupOriginAdjustmentsForEmulation( |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 691 | ExternalPopupMenu* popup, |
| 692 | RenderWidgetScreenMetricsEmulator* emulator) { |
Pavel Feldman | cc099f7 | 2017-07-20 23:09:00 | [diff] [blame] | 693 | popup->SetOriginScaleForEmulation(emulator->scale()); |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 694 | } |
[email protected] | 5390786 | 2014-03-25 15:42:40 | [diff] [blame] | 695 | #endif |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 696 | |
| 697 | void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) { |
| 698 | if (screen_metrics_emulator_) |
| 699 | screen_metrics_emulator_->OnShowContextMenu(params); |
| 700 | } |
| 701 | |
[email protected] | a95986a8 | 2010-12-24 06:19:28 | [diff] [blame] | 702 | bool RenderWidget::OnMessageReceived(const IPC::Message& message) { |
ekaramad | 330ba423 | 2016-09-23 17:57:47 | [diff] [blame] | 703 | #if defined(OS_MACOSX) |
| 704 | if (IPC_MESSAGE_CLASS(message) == TextInputClientMsgStart) |
| 705 | return text_input_client_observer_->OnMessageReceived(message); |
| 706 | #endif |
lfg | bee1e0a | 2016-06-08 21:24:21 | [diff] [blame] | 707 | if (mouse_lock_dispatcher_ && |
| 708 | mouse_lock_dispatcher_->OnMessageReceived(message)) |
| 709 | return true; |
| 710 | |
[email protected] | a95986a8 | 2010-12-24 06:19:28 | [diff] [blame] | 711 | bool handled = true; |
| 712 | IPC_BEGIN_MESSAGE_MAP(RenderWidget, message) |
wjmaclean | ee244e0 | 2017-05-26 21:06:07 | [diff] [blame] | 713 | IPC_MESSAGE_HANDLER(ViewMsg_ShowContextMenu, OnShowContextMenu) |
[email protected] | a95986a8 | 2010-12-24 06:19:28 | [diff] [blame] | 714 | IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose) |
Fady Samuel | 799e7219 | 2018-04-25 21:16:57 | [diff] [blame] | 715 | IPC_MESSAGE_HANDLER(ViewMsg_SynchronizeVisualProperties, |
| 716 | OnSynchronizeVisualProperties) |
dgozman | 9260b0a1 | 2015-03-16 13:45:20 | [diff] [blame] | 717 | IPC_MESSAGE_HANDLER(ViewMsg_EnableDeviceEmulation, |
| 718 | OnEnableDeviceEmulation) |
| 719 | IPC_MESSAGE_HANDLER(ViewMsg_DisableDeviceEmulation, |
| 720 | OnDisableDeviceEmulation) |
[email protected] | a95986a8 | 2010-12-24 06:19:28 | [diff] [blame] | 721 | IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden) |
[email protected] | 9e2e463 | 2012-07-27 16:38:41 | [diff] [blame] | 722 | IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown) |
Albert J. Wong | cb00463 | 2018-07-10 22:58:25 | [diff] [blame] | 723 | IPC_MESSAGE_HANDLER(ViewMsg_SetActive, OnSetActive) |
| 724 | IPC_MESSAGE_HANDLER(ViewMsg_SetBackgroundOpaque, OnSetBackgroundOpaque) |
[email protected] | a95986a8 | 2010-12-24 06:19:28 | [diff] [blame] | 725 | IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection) |
Avi Drissman | 014dec7 | 2018-06-07 02:34:01 | [diff] [blame] | 726 | IPC_MESSAGE_HANDLER(ViewMsg_SetBounds_ACK, OnRequestSetBoundsAck) |
[email protected] | 80ad862 | 2012-11-07 16:33:03 | [diff] [blame] | 727 | IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects) |
Albert J. Wong | cb00463 | 2018-07-10 22:58:25 | [diff] [blame] | 728 | IPC_MESSAGE_HANDLER(ViewMsg_ForceRedraw, OnForceRedraw) |
kenrb | ea73179 | 2017-01-13 15:10:48 | [diff] [blame] | 729 | IPC_MESSAGE_HANDLER(ViewMsg_SetViewportIntersection, |
| 730 | OnSetViewportIntersection) |
kenrb | 0432378 | 2017-06-23 01:23:32 | [diff] [blame] | 731 | IPC_MESSAGE_HANDLER(ViewMsg_SetIsInert, OnSetIsInert) |
sunxd | 540a996 | 2018-05-24 22:51:06 | [diff] [blame] | 732 | IPC_MESSAGE_HANDLER(ViewMsg_SetInheritedEffectiveTouchAction, |
| 733 | OnSetInheritedEffectiveTouchAction) |
Ken Buchanan | 8a319fb | 2017-11-15 18:37:12 | [diff] [blame] | 734 | IPC_MESSAGE_HANDLER(ViewMsg_UpdateRenderThrottlingStatus, |
| 735 | OnUpdateRenderThrottlingStatus) |
lfg | 43e08e6 | 2016-02-03 18:51:37 | [diff] [blame] | 736 | IPC_MESSAGE_HANDLER(ViewMsg_WaitForNextFrameForTests, |
| 737 | OnWaitNextFrameForTests) |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 738 | IPC_MESSAGE_HANDLER(DragMsg_TargetDragEnter, OnDragTargetDragEnter) |
| 739 | IPC_MESSAGE_HANDLER(DragMsg_TargetDragOver, OnDragTargetDragOver) |
| 740 | IPC_MESSAGE_HANDLER(DragMsg_TargetDragLeave, OnDragTargetDragLeave) |
| 741 | IPC_MESSAGE_HANDLER(DragMsg_TargetDrop, OnDragTargetDrop) |
paulmeyer | 8fc8ea9 | 2016-11-15 05:12:21 | [diff] [blame] | 742 | IPC_MESSAGE_HANDLER(DragMsg_SourceEnded, OnDragSourceEnded) |
| 743 | IPC_MESSAGE_HANDLER(DragMsg_SourceSystemDragEnded, |
| 744 | OnDragSourceSystemDragEnded) |
[email protected] | a95986a8 | 2010-12-24 06:19:28 | [diff] [blame] | 745 | IPC_MESSAGE_UNHANDLED(handled = false) |
| 746 | IPC_END_MESSAGE_MAP() |
| 747 | return handled; |
| 748 | } |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 749 | |
| 750 | bool RenderWidget::Send(IPC::Message* message) { |
Nasko Oskov | f97e8b0 | 2017-07-25 02:45:42 | [diff] [blame] | 751 | // Don't send any messages after the browser has told us to close, and filter |
| 752 | // most outgoing messages while swapped out. |
| 753 | if ((is_swapped_out_ && |
| 754 | !SwappedOutMessages::CanSendWhileSwappedOut(message)) || |
| 755 | closing_) { |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 756 | delete message; |
| 757 | return false; |
| 758 | } |
| 759 | |
| 760 | // If given a messsage without a routing ID, then assign our routing ID. |
| 761 | if (message->routing_id() == MSG_ROUTING_NONE) |
| 762 | message->set_routing_id(routing_id_); |
| 763 | |
[email protected] | 38024409 | 2011-10-07 17:26:27 | [diff] [blame] | 764 | return RenderThread::Get()->Send(message); |
[email protected] | 8085dbc8 | 2008-09-26 22:53:44 | [diff] [blame] | 765 | } |
| 766 | |
dtapuska | 014ed08 | 2016-11-11 21:58:48 | [diff] [blame] | 767 | void RenderWidget::SendOrCrash(IPC::Message* message) { |
| 768 | bool result = Send(message); |
| 769 | CHECK(closing_ || result) << "Failed to send message"; |
| 770 | } |
| 771 | |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 772 | bool RenderWidget::ShouldHandleImeEvents() const { |
ekaramad | b6483a05 | 2017-02-10 02:23:26 | [diff] [blame] | 773 | // TODO(ekaramad): We track page focus in all RenderViews on the page but the |
| 774 | // RenderWidgets corresponding to OOPIFs do not get the update. For now, this |
| 775 | // method returns true when the RenderWidget is for an OOPIF, i.e., IME events |
| 776 | // will be processed regardless of page focus. We should revisit this after |
| 777 | // page focus for OOPIFs has been fully resolved (https://crbug.com/689777). |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 778 | return GetWebWidget() && GetWebWidget()->IsWebFrameWidget() && |
ekaramad | b6483a05 | 2017-02-10 02:23:26 | [diff] [blame] | 779 | (has_focus_ || for_oopif_); |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 780 | } |
| 781 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 782 | void RenderWidget::OnClose() { |
dcheng | d96a27a | 2015-07-24 20:17:32 | [diff] [blame] | 783 | DCHECK(content::RenderThread::Get()); |
| 784 | if (closing_) |
| 785 | return; |
| 786 | NotifyOnClose(); |
| 787 | closing_ = true; |
| 788 | |
| 789 | // Browser correspondence is no longer needed at this point. |
| 790 | if (routing_id_ != MSG_ROUTING_NONE) { |
| 791 | RenderThread::Get()->RemoveRoute(routing_id_); |
Albert J. Wong | cb00463 | 2018-07-10 22:58:25 | [diff] [blame] | 792 | g_routing_id_widget_map.Get().erase(routing_id_); |
dcheng | d96a27a | 2015-07-24 20:17:32 | [diff] [blame] | 793 | SetHidden(false); |
| 794 | if (RenderThreadImpl::current()) |
| 795 | RenderThreadImpl::current()->WidgetDestroyed(); |
| 796 | } |
| 797 | |
| 798 | if (for_oopif_) { |
| 799 | // Widgets for frames may be created and closed at any time while the frame |
Ken Buchanan | ed449bb | 2018-02-01 21:02:05 | [diff] [blame] | 800 | // is alive. However, WebWidget must be closed synchronously because frame |
| 801 | // widgets and frames hold pointers to each other. The deferred call to |
| 802 | // Close() will complete cleanup and release |this|, but CloseWebWidget() |
| 803 | // prevents Close() from attempting to access members of an |
| 804 | // already-deleted frame. |
| 805 | CloseWebWidget(); |
dcheng | d96a27a | 2015-07-24 20:17:32 | [diff] [blame] | 806 | } |
Ken Buchanan | ed449bb | 2018-02-01 21:02:05 | [diff] [blame] | 807 | // If there is a Send call on the stack, then it could be dangerous to close |
| 808 | // now. Post a task that only gets invoked when there are no nested message |
| 809 | // loops. |
| 810 | task_runner_->PostNonNestableTask(FROM_HERE, |
| 811 | base::BindOnce(&RenderWidget::Close, this)); |
dcheng | d96a27a | 2015-07-24 20:17:32 | [diff] [blame] | 812 | |
| 813 | // Balances the AddRef taken when we called AddRoute. |
| 814 | Release(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 815 | } |
| 816 | |
Fady Samuel | 799e7219 | 2018-04-25 21:16:57 | [diff] [blame] | 817 | void RenderWidget::OnSynchronizeVisualProperties( |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 818 | const VisualProperties& original_params) { |
| 819 | TRACE_EVENT0("renderer", "RenderWidget::OnSynchronizeVisualProperties"); |
EhsanK | bd2cea99 | 2017-11-23 18:49:08 | [diff] [blame] | 820 | |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 821 | VisualProperties params = original_params; |
| 822 | if (owner_delegate_) { |
| 823 | owner_delegate_->ApplyNewSizeForWidget(size_, params.new_size); |
| 824 | |
| 825 | if (display_mode_ != params.display_mode) { |
| 826 | display_mode_ = params.display_mode; |
| 827 | owner_delegate_->ApplyNewDisplayModeForWidget(params.display_mode); |
| 828 | } |
| 829 | |
| 830 | bool auto_resize_mode_changed = |
| 831 | auto_resize_mode_ != params.auto_resize_enabled; |
| 832 | auto_resize_mode_ = params.auto_resize_enabled; |
| 833 | min_size_for_auto_resize_ = params.min_size_for_auto_resize; |
| 834 | max_size_for_auto_resize_ = params.max_size_for_auto_resize; |
| 835 | |
| 836 | if (auto_resize_mode_) { |
| 837 | gfx::Size min_auto_size = min_size_for_auto_resize_; |
| 838 | gfx::Size max_auto_size = max_size_for_auto_resize_; |
| 839 | if (compositor_deps_->IsUseZoomForDSFEnabled()) { |
| 840 | min_auto_size = gfx::ScaleToCeiledSize( |
| 841 | min_auto_size, params.screen_info.device_scale_factor); |
| 842 | max_auto_size = gfx::ScaleToCeiledSize( |
| 843 | max_auto_size, params.screen_info.device_scale_factor); |
| 844 | } |
| 845 | owner_delegate_->ApplyAutoResizeLimitsForWidget(min_auto_size, |
| 846 | max_auto_size); |
| 847 | } else if (auto_resize_mode_changed) { |
| 848 | owner_delegate_->DisableAutoResizeForWidget(); |
| 849 | if (params.new_size.IsEmpty()) |
| 850 | return; |
| 851 | } |
| 852 | |
| 853 | browser_controls_shrink_blink_size_ = |
| 854 | params.browser_controls_shrink_blink_size; |
| 855 | top_controls_height_ = params.top_controls_height; |
| 856 | bottom_controls_height_ = params.bottom_controls_height; |
| 857 | |
| 858 | // TODO(fsamuel): Modifies the |params| that are used for |
| 859 | // SynchronizeVisualProperties(), but does not used this modified |
| 860 | // device_scale_factor for the auto-resize values, which is probably a bug. |
| 861 | if (device_scale_factor_for_testing_) { |
| 862 | params.screen_info.device_scale_factor = |
| 863 | *device_scale_factor_for_testing_; |
| 864 | params.compositor_viewport_pixel_size = gfx::ScaleToCeiledSize( |
| 865 | params.new_size, params.screen_info.device_scale_factor); |
| 866 | } |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 867 | } |
| 868 | |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 869 | if (!resizing_mode_selector_->ShouldAbortOnResize(this, params)) { |
| 870 | if (screen_metrics_emulator_) { |
| 871 | screen_metrics_emulator_->OnSynchronizeVisualProperties(params); |
| 872 | } else { |
| 873 | gfx::Size old_visible_viewport_size = visible_viewport_size_; |
| 874 | SynchronizeVisualProperties(params); |
| 875 | if (old_visible_viewport_size != visible_viewport_size_) { |
| 876 | for (auto& render_frame : render_frames_) |
| 877 | render_frame.DidChangeVisibleViewport(); |
| 878 | } |
| 879 | } |
Fady Samuel | 799e7219 | 2018-04-25 21:16:57 | [diff] [blame] | 880 | } |
| 881 | |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 882 | if (owner_delegate_ && params.scroll_focused_node_into_view) |
| 883 | owner_delegate_->ScrollFocusedNodeIntoViewForWidget(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 884 | } |
| 885 | |
dgozman | 9260b0a1 | 2015-03-16 13:45:20 | [diff] [blame] | 886 | void RenderWidget::OnEnableDeviceEmulation( |
Lei Zhang | 9b359d3 | 2017-11-28 00:57:02 | [diff] [blame] | 887 | const blink::WebDeviceEmulationParams& params) { |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 888 | if (!screen_metrics_emulator_) { |
Fady Samuel | 4255c18 | 2018-05-24 20:42:36 | [diff] [blame] | 889 | VisualProperties visual_properties; |
| 890 | visual_properties.screen_info = screen_info_; |
| 891 | visual_properties.new_size = size_; |
| 892 | visual_properties.compositor_viewport_pixel_size = |
Christopher Cameron | aad15a0d | 2018-03-09 03:47:33 | [diff] [blame] | 893 | compositor_viewport_pixel_size_; |
Fady Samuel | 4255c18 | 2018-05-24 20:42:36 | [diff] [blame] | 894 | visual_properties.local_surface_id = local_surface_id_from_parent_; |
| 895 | visual_properties.visible_viewport_size = visible_viewport_size_; |
| 896 | visual_properties.is_fullscreen_granted = is_fullscreen_granted_; |
| 897 | visual_properties.display_mode = display_mode_; |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 898 | screen_metrics_emulator_.reset(new RenderWidgetScreenMetricsEmulator( |
Fady Samuel | 4255c18 | 2018-05-24 20:42:36 | [diff] [blame] | 899 | this, params, visual_properties, view_screen_rect_, |
| 900 | window_screen_rect_)); |
oshima | 50872a7 | 2016-03-04 13:26:18 | [diff] [blame] | 901 | screen_metrics_emulator_->Apply(); |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 902 | } else { |
dgozman | 9260b0a1 | 2015-03-16 13:45:20 | [diff] [blame] | 903 | screen_metrics_emulator_->ChangeEmulationParams(params); |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 904 | } |
dgozman | 9260b0a1 | 2015-03-16 13:45:20 | [diff] [blame] | 905 | } |
| 906 | |
| 907 | void RenderWidget::OnDisableDeviceEmulation() { |
| 908 | screen_metrics_emulator_.reset(); |
| 909 | } |
| 910 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 911 | void RenderWidget::OnWasHidden() { |
[email protected] | 9c3085f | 2011-06-09 02:10:31 | [diff] [blame] | 912 | TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden"); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 913 | // Go into a mode where we stop generating paint and scrolling events. |
[email protected] | bee16aab | 2009-08-26 15:55:03 | [diff] [blame] | 914 | SetHidden(true); |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 915 | for (auto& observer : render_frames_) |
| 916 | observer.WasHidden(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 917 | } |
| 918 | |
Saman Sami | d709592b | 2018-02-03 00:38:10 | [diff] [blame] | 919 | void RenderWidget::OnWasShown(bool needs_repainting, |
Sadrul Habib Chowdhury | 8bc43cc | 2018-06-06 01:48:03 | [diff] [blame] | 920 | base::TimeTicks show_request_timestamp) { |
[email protected] | 9e2e463 | 2012-07-27 16:38:41 | [diff] [blame] | 921 | TRACE_EVENT0("renderer", "RenderWidget::OnWasShown"); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 922 | // During shutdown we can just ignore this message. |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 923 | if (!GetWebWidget()) |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 924 | return; |
| 925 | |
tasak | b95dbb50c | 2017-02-08 18:07:50 | [diff] [blame] | 926 | was_shown_time_ = base::TimeTicks::Now(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 927 | // See OnWasHidden |
[email protected] | bee16aab | 2009-08-26 15:55:03 | [diff] [blame] | 928 | SetHidden(false); |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 929 | for (auto& observer : render_frames_) |
| 930 | observer.WasShown(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 931 | |
[email protected] | 8a23afb3 | 2014-04-30 22:40:23 | [diff] [blame] | 932 | if (!needs_repainting) |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 933 | return; |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 934 | |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 935 | if (layer_tree_view_ && !show_request_timestamp.is_null()) { |
| 936 | layer_tree_view_->layer_tree_host()->RequestPresentationTimeForNextFrame( |
Sadrul Habib Chowdhury | 8bc43cc | 2018-06-06 01:48:03 | [diff] [blame] | 937 | CreateTabSwitchingTimeRecorder(show_request_timestamp)); |
[email protected] | 3399dd82 | 2014-08-09 11:14:24 | [diff] [blame] | 938 | } |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 939 | } |
| 940 | |
Avi Drissman | 014dec7 | 2018-06-07 02:34:01 | [diff] [blame] | 941 | void RenderWidget::OnRequestSetBoundsAck() { |
[email protected] | 53d3f30 | 2009-12-21 04:42:05 | [diff] [blame] | 942 | DCHECK(pending_window_rect_count_); |
| 943 | pending_window_rect_count_--; |
| 944 | } |
| 945 | |
Albert J. Wong | cb00463 | 2018-07-10 22:58:25 | [diff] [blame] | 946 | void RenderWidget::OnForceRedraw(int snapshot_id) { |
| 947 | if (LayerTreeView* ltv = layer_tree_view()) { |
| 948 | ltv->layer_tree_host()->RequestPresentationTimeForNextFrame( |
| 949 | base::BindOnce(&RenderWidget::DidPresentForceDrawFrame, |
| 950 | weak_ptr_factory_.GetWeakPtr(), snapshot_id)); |
| 951 | ltv->SetNeedsForcedRedraw(); |
| 952 | } |
| 953 | } |
| 954 | |
| 955 | void RenderWidget::DidPresentForceDrawFrame( |
| 956 | int snapshot_id, |
| 957 | const gfx::PresentationFeedback& feedback) { |
| 958 | Send(new ViewHostMsg_ForceRedrawComplete(routing_id(), snapshot_id)); |
| 959 | } |
| 960 | |
Sadrul Habib Chowdhury | 6539b73 | 2018-01-05 21:53:27 | [diff] [blame] | 961 | viz::FrameSinkId RenderWidget::GetFrameSinkIdAtPoint(const gfx::Point& point) { |
| 962 | return input_handler_->GetFrameSinkIdAtPoint(point); |
Navid Zolghadr | 0d86e5f | 2017-10-23 18:09:22 | [diff] [blame] | 963 | } |
| 964 | |
Dave Tapuska | ea83d3bd | 2017-06-13 16:14:55 | [diff] [blame] | 965 | void RenderWidget::HandleInputEvent( |
dtapuska | 9ec1a91 | 2017-04-21 15:18:31 | [diff] [blame] | 966 | const blink::WebCoalescedInputEvent& input_event, |
| 967 | const ui::LatencyInfo& latency_info, |
Dave Tapuska | ea83d3bd | 2017-06-13 16:14:55 | [diff] [blame] | 968 | HandledEventCallback callback) { |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 969 | if (owner_delegate_ && is_swapped_out_) { |
| 970 | std::move(callback).Run(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, latency_info, |
| 971 | nullptr, base::nullopt); |
| 972 | return; |
| 973 | } |
| 974 | if (idle_user_detector_) |
| 975 | idle_user_detector_->ActivityDetected(); |
Dave Tapuska | ea83d3bd | 2017-06-13 16:14:55 | [diff] [blame] | 976 | input_handler_->HandleInputEvent(input_event, latency_info, |
| 977 | std::move(callback)); |
dtapuska | 9ec1a91 | 2017-04-21 15:18:31 | [diff] [blame] | 978 | } |
| 979 | |
dtapuska | 9d46ef7d | 2017-05-26 19:06:06 | [diff] [blame] | 980 | scoped_refptr<MainThreadEventQueue> RenderWidget::GetInputEventQueue() { |
| 981 | return input_event_queue_; |
| 982 | } |
| 983 | |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 984 | void RenderWidget::OnCursorVisibilityChange(bool is_visible) { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 985 | if (GetWebWidget()) |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 986 | GetWebWidget()->SetCursorVisibilityState(is_visible); |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 987 | } |
| 988 | |
| 989 | void RenderWidget::OnMouseCaptureLost() { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 990 | if (GetWebWidget()) |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 991 | GetWebWidget()->MouseCaptureLost(); |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 992 | } |
| 993 | |
alexmos | 5656749 | 2016-09-13 00:52:46 | [diff] [blame] | 994 | void RenderWidget::OnSetEditCommandsForNextKeyEvent( |
| 995 | const EditCommands& edit_commands) { |
| 996 | edit_commands_ = edit_commands; |
| 997 | } |
| 998 | |
Albert J. Wong | cb00463 | 2018-07-10 22:58:25 | [diff] [blame] | 999 | void RenderWidget::OnSetActive(bool active) { |
| 1000 | if (owner_delegate_) |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 1001 | owner_delegate_->SetActiveForWidget(active); |
Albert J. Wong | cb00463 | 2018-07-10 22:58:25 | [diff] [blame] | 1002 | } |
| 1003 | |
| 1004 | void RenderWidget::OnSetBackgroundOpaque(bool opaque) { |
| 1005 | if (owner_delegate_) |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 1006 | owner_delegate_->SetBackgroundOpaqueForWidget(opaque); |
Albert J. Wong | cb00463 | 2018-07-10 22:58:25 | [diff] [blame] | 1007 | } |
| 1008 | |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 1009 | void RenderWidget::OnSetFocus(bool enable) { |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 1010 | if (owner_delegate_) |
| 1011 | owner_delegate_->DidReceiveSetFocusEventForWidget(); |
| 1012 | SetFocus(enable); |
| 1013 | } |
| 1014 | |
| 1015 | void RenderWidget::SetFocus(bool enable) { |
lfg | e0c2792ec | 2016-05-11 18:52:08 | [diff] [blame] | 1016 | has_focus_ = enable; |
| 1017 | |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1018 | if (GetWebWidget()) |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1019 | GetWebWidget()->SetFocus(enable); |
lfg | e0c2792ec | 2016-05-11 18:52:08 | [diff] [blame] | 1020 | |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 1021 | for (auto& observer : render_frames_) |
| 1022 | observer.RenderWidgetSetFocus(enable); |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 1023 | |
| 1024 | if (owner_delegate_) |
| 1025 | owner_delegate_->DidChangeFocusForWidget(); |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 1026 | } |
| 1027 | |
dtapuska | 3d5624d3 | 2016-08-30 04:34:00 | [diff] [blame] | 1028 | void RenderWidget::SetNeedsMainFrame() { |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1029 | LayerTreeView* ltv = layer_tree_view(); |
| 1030 | if (!ltv) |
dtapuska | 3d5624d3 | 2016-08-30 04:34:00 | [diff] [blame] | 1031 | return; |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1032 | ltv->SetNeedsBeginFrame(); |
dtapuska | 3d5624d3 | 2016-08-30 04:34:00 | [diff] [blame] | 1033 | } |
| 1034 | |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 1035 | /////////////////////////////////////////////////////////////////////////////// |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1036 | // LayerTreeViewDelegate |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 1037 | |
| 1038 | void RenderWidget::ApplyViewportDeltas( |
| 1039 | const gfx::Vector2dF& inner_delta, |
| 1040 | const gfx::Vector2dF& outer_delta, |
| 1041 | const gfx::Vector2dF& elastic_overscroll_delta, |
| 1042 | float page_scale, |
| 1043 | float top_controls_delta) { |
Ken Buchanan | ed449bb | 2018-02-01 21:02:05 | [diff] [blame] | 1044 | if (!GetWebWidget()) |
| 1045 | return; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1046 | GetWebWidget()->ApplyViewportDeltas(inner_delta, outer_delta, |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1047 | elastic_overscroll_delta, page_scale, |
| 1048 | top_controls_delta); |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 1049 | } |
| 1050 | |
sahel | 1b47fda7 | 2017-03-28 17:03:07 | [diff] [blame] | 1051 | void RenderWidget::RecordWheelAndTouchScrollingCount( |
| 1052 | bool has_scrolled_by_wheel, |
| 1053 | bool has_scrolled_by_touch) { |
Ken Buchanan | ed449bb | 2018-02-01 21:02:05 | [diff] [blame] | 1054 | if (!GetWebWidget()) |
| 1055 | return; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1056 | GetWebWidget()->RecordWheelAndTouchScrollingCount(has_scrolled_by_wheel, |
sahel | 1b47fda7 | 2017-03-28 17:03:07 | [diff] [blame] | 1057 | has_scrolled_by_touch); |
| 1058 | } |
| 1059 | |
Daniel Cheng | 224569ee | 2018-04-25 05:45:06 | [diff] [blame] | 1060 | void RenderWidget::BeginMainFrame(base::TimeTicks frame_time) { |
Ken Buchanan | ed449bb | 2018-02-01 21:02:05 | [diff] [blame] | 1061 | if (!GetWebWidget()) |
| 1062 | return; |
Daniel Cheng | 224569ee | 2018-04-25 05:45:06 | [diff] [blame] | 1063 | if (input_event_queue_) |
| 1064 | input_event_queue_->DispatchRafAlignedInput(frame_time); |
dtapuska | 3d5624d3 | 2016-08-30 04:34:00 | [diff] [blame] | 1065 | |
Daniel Cheng | 224569ee | 2018-04-25 05:45:06 | [diff] [blame] | 1066 | GetWebWidget()->BeginFrame(frame_time); |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 1067 | } |
| 1068 | |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 1069 | void RenderWidget::RequestNewLayerTreeFrameSink( |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1070 | LayerTreeFrameSinkCallback callback) { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1071 | DCHECK(GetWebWidget()); |
[email protected] | 7912e82 | 2014-04-16 02:37:03 | [diff] [blame] | 1072 | // For widgets that are never visible, we don't start the compositor, so we |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 1073 | // never get a request for a cc::LayerTreeFrameSink. |
sievers | 71c62dd5 | 2015-10-07 01:44:39 | [diff] [blame] | 1074 | DCHECK(!compositor_never_visible_); |
jonross | a2ff4f8 | 2018-02-16 17:27:46 | [diff] [blame] | 1075 | |
| 1076 | // TODO(jonross): have this generated by the LayerTreeFrameSink itself, which |
| 1077 | // would then handle binding. |
| 1078 | mojom::RenderFrameMetadataObserverPtr ptr; |
| 1079 | mojom::RenderFrameMetadataObserverRequest request = mojo::MakeRequest(&ptr); |
| 1080 | mojom::RenderFrameMetadataObserverClientPtrInfo client_info; |
| 1081 | mojom::RenderFrameMetadataObserverClientRequest client_request = |
| 1082 | mojo::MakeRequest(&client_info); |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 1083 | auto render_frame_metadata_observer = |
| 1084 | std::make_unique<RenderFrameMetadataObserverImpl>(std::move(request), |
| 1085 | std::move(client_info)); |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1086 | layer_tree_view_->SetRenderFrameObserver( |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 1087 | std::move(render_frame_metadata_observer)); |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 1088 | RenderThreadImpl::current()->RequestNewLayerTreeFrameSink( |
danakj | ab9ef4d | 2017-10-31 23:38:33 | [diff] [blame] | 1089 | routing_id_, frame_swap_message_queue_, GetURLForGraphicsContext3D(), |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1090 | std::move(callback), std::move(client_request), std::move(ptr)); |
[email protected] | ba91a79 | 2013-02-06 09:48:28 | [diff] [blame] | 1091 | } |
| 1092 | |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 1093 | void RenderWidget::DidCommitAndDrawCompositorFrame() { |
| 1094 | // NOTE: Tests may break if this event is renamed or moved. See |
| 1095 | // tab_capture_performancetest.cc. |
| 1096 | TRACE_EVENT0("gpu", "RenderWidget::DidCommitAndDrawCompositorFrame"); |
lfg | e0c2792ec | 2016-05-11 18:52:08 | [diff] [blame] | 1097 | |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 1098 | for (auto& observer : render_frames_) |
| 1099 | observer.DidCommitAndDrawCompositorFrame(); |
lfg | e0c2792ec | 2016-05-11 18:52:08 | [diff] [blame] | 1100 | |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 1101 | // Notify subclasses that we initiated the paint operation. |
| 1102 | DidInitiatePaint(); |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 1103 | } |
| 1104 | |
Saman Sami | 766e0b0 | 2018-01-31 17:19:20 | [diff] [blame] | 1105 | void RenderWidget::DidCommitCompositorFrame() { |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 1106 | if (owner_delegate_) |
| 1107 | owner_delegate_->DidCommitCompositorFrameForWidget(); |
Saman Sami | 766e0b0 | 2018-01-31 17:19:20 | [diff] [blame] | 1108 | } |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 1109 | |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 1110 | void RenderWidget::DidCompletePageScaleAnimation() { |
| 1111 | if (owner_delegate_) |
| 1112 | owner_delegate_->DidCompletePageScaleAnimationForWidget(); |
| 1113 | } |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 1114 | |
danakj | 6c872fc0 | 2016-10-22 04:29:49 | [diff] [blame] | 1115 | void RenderWidget::DidReceiveCompositorFrameAck() { |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 1116 | } |
| 1117 | |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 1118 | bool RenderWidget::IsClosing() const { |
Albert J. Wong | cb00463 | 2018-07-10 22:58:25 | [diff] [blame] | 1119 | // TODO(ajwong): There is oddly 2 closing states. This API is used by |
| 1120 | // LayerTreeView only as part of the LayerTreeViewDelegate interface and |
| 1121 | // is the guard against creating new compositor frames unnecessarily. |
| 1122 | // Historically, when RenderViewImpl and RenderWidget shared the same |
| 1123 | // routing id, it was possible for |closing_| to be true, |host_closing_| to |
| 1124 | // false, and for the code in |
| 1125 | // RenderThreadImpl::RequestNewLayerTreeFrameSink() to still look up a valid |
| 1126 | // RenderViewImpl from the routing id. This is actually a benign shutdown |
| 1127 | // race in Android that can be triggered in the SynchronouslyComposite path |
| 1128 | // via AwContentsGarbageCollectionTest#testCreateAndGcManyTimes. |
| 1129 | // |
| 1130 | // Once RenderViewImpl and RenderWidget are split, attempt to combine two |
| 1131 | // states so the shutdown logic is cleaner. |
| 1132 | // |
| 1133 | // http://crbug.com/545684 |
| 1134 | return host_closing_ || closing_; |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 1135 | } |
| 1136 | |
danakj | 53eccbc | 2016-03-02 22:51:07 | [diff] [blame] | 1137 | void RenderWidget::RequestScheduleAnimation() { |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 1138 | if (owner_delegate_) { |
| 1139 | owner_delegate_->RequestScheduleAnimationForWidget(); |
| 1140 | return; |
| 1141 | } |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1142 | ScheduleAnimation(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1143 | } |
| 1144 | |
Eric Seckler | 8af8c0e5 | 2018-01-17 23:45:53 | [diff] [blame] | 1145 | void RenderWidget::UpdateVisualState(VisualStateUpdate requested_update) { |
Ken Buchanan | ed449bb | 2018-02-01 21:02:05 | [diff] [blame] | 1146 | if (!GetWebWidget()) |
| 1147 | return; |
| 1148 | |
Eric Seckler | 8af8c0e5 | 2018-01-17 23:45:53 | [diff] [blame] | 1149 | bool pre_paint_only = requested_update == VisualStateUpdate::kPrePaint; |
| 1150 | WebWidget::LifecycleUpdate lifecycle_update = |
| 1151 | pre_paint_only ? WebWidget::LifecycleUpdate::kPrePaint |
| 1152 | : WebWidget::LifecycleUpdate::kAll; |
| 1153 | |
| 1154 | GetWebWidget()->UpdateLifecycle(lifecycle_update); |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1155 | GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(false); |
tasak | b95dbb50c | 2017-02-08 18:07:50 | [diff] [blame] | 1156 | |
Eric Seckler | 8af8c0e5 | 2018-01-17 23:45:53 | [diff] [blame] | 1157 | if (first_update_visual_state_after_hidden_ && !pre_paint_only) { |
Takashi SAKAMOTO | 870f626 | 2017-08-22 04:08:27 | [diff] [blame] | 1158 | RecordTimeToFirstActivePaint(); |
| 1159 | first_update_visual_state_after_hidden_ = false; |
| 1160 | } |
| 1161 | } |
tasak | b95dbb50c | 2017-02-08 18:07:50 | [diff] [blame] | 1162 | |
Takashi SAKAMOTO | 870f626 | 2017-08-22 04:08:27 | [diff] [blame] | 1163 | void RenderWidget::RecordTimeToFirstActivePaint() { |
tasak | b95dbb50c | 2017-02-08 18:07:50 | [diff] [blame] | 1164 | RenderThreadImpl* render_thread_impl = RenderThreadImpl::current(); |
tasak | b95dbb50c | 2017-02-08 18:07:50 | [diff] [blame] | 1165 | base::TimeDelta sample = base::TimeTicks::Now() - was_shown_time_; |
Takashi SAKAMOTO | 870f626 | 2017-08-22 04:08:27 | [diff] [blame] | 1166 | if (render_thread_impl->NeedsToRecordFirstActivePaint(TTFAP_AFTER_PURGED)) { |
| 1167 | UMA_HISTOGRAM_TIMES("PurgeAndSuspend.Experimental.TimeToFirstActivePaint", |
| 1168 | sample); |
| 1169 | } |
| 1170 | if (render_thread_impl->NeedsToRecordFirstActivePaint( |
| 1171 | TTFAP_5MIN_AFTER_BACKGROUNDED)) { |
| 1172 | UMA_HISTOGRAM_TIMES( |
| 1173 | "PurgeAndSuspend.Experimental.TimeToFirstActivePaint." |
| 1174 | "AfterBackgrounded.5min", |
| 1175 | sample); |
| 1176 | } |
fsamuel | 78f86e4 | 2016-01-20 04:10:23 | [diff] [blame] | 1177 | } |
| 1178 | |
| 1179 | void RenderWidget::WillBeginCompositorFrame() { |
| 1180 | TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame"); |
| 1181 | |
Ken Buchanan | ed449bb | 2018-02-01 21:02:05 | [diff] [blame] | 1182 | if (!GetWebWidget()) |
| 1183 | return; |
| 1184 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1185 | GetWebWidget()->SetSuppressFrameRequestsWorkaroundFor704763Only(true); |
alancutter | 317a8e0 | 2017-04-05 10:09:29 | [diff] [blame] | 1186 | |
dglazkov | 06854c5c | 2016-08-31 00:19:59 | [diff] [blame] | 1187 | // The UpdateTextInputState can result in further layout and possibly |
| 1188 | // enable GPU acceleration so they need to be called before any painting |
| 1189 | // is done. |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1190 | UpdateTextInputState(); |
dglazkov | 06854c5c | 2016-08-31 00:19:59 | [diff] [blame] | 1191 | UpdateSelectionBounds(); |
| 1192 | |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 1193 | for (auto& observer : render_frame_proxies_) |
| 1194 | observer.WillBeginCompositorFrame(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1195 | } |
| 1196 | |
jbroman | 6ccbc7d47 | 2016-07-27 04:45:41 | [diff] [blame] | 1197 | std::unique_ptr<cc::SwapPromise> RenderWidget::RequestCopyOfOutputForLayoutTest( |
Fady Samuel | dfecb7d | 2017-07-26 11:41:04 | [diff] [blame] | 1198 | std::unique_ptr<viz::CopyOutputRequest> request) { |
jbroman | 6ccbc7d47 | 2016-07-27 04:45:41 | [diff] [blame] | 1199 | return RenderThreadImpl::current()->RequestCopyOfOutputForLayoutTest( |
| 1200 | routing_id_, std::move(request)); |
| 1201 | } |
| 1202 | |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1203 | /////////////////////////////////////////////////////////////////////////////// |
| 1204 | // RenderWidgetInputHandlerDelegate |
| 1205 | |
avi | d7d6b2e | 2016-03-04 19:41:17 | [diff] [blame] | 1206 | void RenderWidget::FocusChangeComplete() { |
Ehsan Karamad | 655d7b8a | 2018-01-12 18:38:38 | [diff] [blame] | 1207 | blink::WebFrameWidget* frame_widget = GetFrameWidget(); |
| 1208 | if (!frame_widget) |
ekaramad | 27ca69b1 | 2017-04-20 18:34:29 | [diff] [blame] | 1209 | return; |
Ehsan Karamad | 655d7b8a | 2018-01-12 18:38:38 | [diff] [blame] | 1210 | |
ekaramad | 27ca69b1 | 2017-04-20 18:34:29 | [diff] [blame] | 1211 | blink::WebLocalFrame* focused = |
Ehsan Karamad | 655d7b8a | 2018-01-12 18:38:38 | [diff] [blame] | 1212 | frame_widget->LocalRoot()->View()->FocusedFrame(); |
| 1213 | |
ekaramad | 27ca69b1 | 2017-04-20 18:34:29 | [diff] [blame] | 1214 | if (focused && focused->AutofillClient()) |
| 1215 | focused->AutofillClient()->DidCompleteFocusChangeInFrame(); |
avi | d7d6b2e | 2016-03-04 19:41:17 | [diff] [blame] | 1216 | } |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1217 | |
dtapuska | 1827dd2 | 2016-03-11 15:24:59 | [diff] [blame] | 1218 | void RenderWidget::ObserveGestureEventAndResult( |
| 1219 | const blink::WebGestureEvent& gesture_event, |
| 1220 | const gfx::Vector2dF& unused_delta, |
Sandra Sun | ac5cdd83 | 2017-12-11 03:27:13 | [diff] [blame] | 1221 | const cc::OverscrollBehavior& overscroll_behavior, |
dtapuska | 1827dd2 | 2016-03-11 15:24:59 | [diff] [blame] | 1222 | bool event_processed) { |
| 1223 | if (!compositor_deps_->IsElasticOverscrollEnabled()) |
| 1224 | return; |
| 1225 | |
| 1226 | cc::InputHandlerScrollResult scroll_result; |
| 1227 | scroll_result.did_scroll = event_processed; |
| 1228 | scroll_result.did_overscroll_root = !unused_delta.IsZero(); |
| 1229 | scroll_result.unused_scroll_delta = unused_delta; |
Sandra Sun | ac5cdd83 | 2017-12-11 03:27:13 | [diff] [blame] | 1230 | scroll_result.overscroll_behavior = overscroll_behavior; |
dtapuska | 1827dd2 | 2016-03-11 15:24:59 | [diff] [blame] | 1231 | |
Dave Tapuska | 04bc5ee9 | 2018-04-17 19:03:31 | [diff] [blame] | 1232 | widget_input_handler_manager_->ObserveGestureEventOnMainThread(gesture_event, |
| 1233 | scroll_result); |
dtapuska | 1827dd2 | 2016-03-11 15:24:59 | [diff] [blame] | 1234 | } |
| 1235 | |
avi | d7d6b2e | 2016-03-04 19:41:17 | [diff] [blame] | 1236 | void RenderWidget::OnDidHandleKeyEvent() { |
alexmos | 5656749 | 2016-09-13 00:52:46 | [diff] [blame] | 1237 | ClearEditCommands(); |
| 1238 | } |
| 1239 | |
| 1240 | void RenderWidget::SetEditCommandForNextKeyEvent(const std::string& name, |
| 1241 | const std::string& value) { |
| 1242 | ClearEditCommands(); |
| 1243 | edit_commands_.emplace_back(name, value); |
| 1244 | } |
| 1245 | |
| 1246 | void RenderWidget::ClearEditCommands() { |
| 1247 | edit_commands_.clear(); |
avi | d7d6b2e | 2016-03-04 19:41:17 | [diff] [blame] | 1248 | } |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1249 | |
chongz | a8ba91fc | 2016-08-16 21:39:17 | [diff] [blame] | 1250 | void RenderWidget::OnDidOverscroll(const ui::DidOverscrollParams& params) { |
Dave Tapuska | 04bc5ee9 | 2018-04-17 19:03:31 | [diff] [blame] | 1251 | if (mojom::WidgetInputHandlerHost* host = |
| 1252 | widget_input_handler_manager_->GetWidgetInputHandlerHost()) { |
| 1253 | host->DidOverscroll(params); |
Dave Tapuska | 139a72f | 2017-09-06 21:57:03 | [diff] [blame] | 1254 | } |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1255 | } |
| 1256 | |
fsamuel | e8326c74 | 2016-01-12 00:49:39 | [diff] [blame] | 1257 | void RenderWidget::SetInputHandler(RenderWidgetInputHandler* input_handler) { |
| 1258 | // Nothing to do here. RenderWidget created the |input_handler| and will take |
| 1259 | // ownership of it. We just verify here that we don't already have an input |
| 1260 | // handler. |
| 1261 | DCHECK(!input_handler_); |
| 1262 | } |
| 1263 | |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1264 | void RenderWidget::ShowVirtualKeyboard() { |
| 1265 | UpdateTextInputStateInternal(true, false); |
| 1266 | } |
| 1267 | |
changwan | 62f5729 | 2017-02-17 08:28:25 | [diff] [blame] | 1268 | void RenderWidget::ClearTextInputState() { |
| 1269 | text_input_info_ = blink::WebTextInputInfo(); |
| 1270 | text_input_type_ = ui::TextInputType::TEXT_INPUT_TYPE_NONE; |
| 1271 | text_input_mode_ = ui::TextInputMode::TEXT_INPUT_MODE_DEFAULT; |
| 1272 | can_compose_inline_ = false; |
| 1273 | text_input_flags_ = 0; |
AJITH KUMAR V | 041c0b0 | 2017-08-08 10:39:20 | [diff] [blame] | 1274 | next_previous_flags_ = kInvalidNextPreviousFlagsValue; |
changwan | 62f5729 | 2017-02-17 08:28:25 | [diff] [blame] | 1275 | } |
| 1276 | |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1277 | void RenderWidget::UpdateTextInputState() { |
| 1278 | UpdateTextInputStateInternal(false, false); |
| 1279 | } |
| 1280 | |
| 1281 | void RenderWidget::UpdateTextInputStateInternal(bool show_virtual_keyboard, |
| 1282 | bool reply_to_request) { |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1283 | TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState"); |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1284 | |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1285 | if (ime_event_guard_) { |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1286 | DCHECK(!reply_to_request); |
| 1287 | // show_virtual_keyboard should still be effective even if it was set inside |
| 1288 | // the IME |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1289 | // event guard. |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1290 | if (show_virtual_keyboard) |
| 1291 | ime_event_guard_->set_show_virtual_keyboard(true); |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1292 | return; |
| 1293 | } |
| 1294 | |
dglazkov | 97b6c2b | 2016-10-25 17:35:55 | [diff] [blame] | 1295 | ui::TextInputType new_type = GetTextInputType(); |
| 1296 | if (IsDateTimeInput(new_type)) |
| 1297 | return; // Not considered as a text input field in WebKit/Chromium. |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1298 | |
dglazkov | 97b6c2b | 2016-10-25 17:35:55 | [diff] [blame] | 1299 | blink::WebTextInputInfo new_info; |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 1300 | if (auto* controller = GetInputMethodController()) |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1301 | new_info = controller->TextInputInfo(); |
dtapuska | c4dd5be | 2016-10-25 15:11:10 | [diff] [blame] | 1302 | const ui::TextInputMode new_mode = |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1303 | ConvertWebTextInputMode(new_info.input_mode); |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1304 | |
| 1305 | bool new_can_compose_inline = CanComposeInline(); |
| 1306 | |
| 1307 | // Only sends text input params if they are changed or if the ime should be |
| 1308 | // shown. |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1309 | if (show_virtual_keyboard || reply_to_request || |
changwan | 38c3eb61 | 2016-12-09 01:45:56 | [diff] [blame] | 1310 | text_input_type_ != new_type || text_input_mode_ != new_mode || |
| 1311 | text_input_info_ != new_info || |
| 1312 | can_compose_inline_ != new_can_compose_inline) { |
ekaramad | 9053e57b | 2016-04-26 20:00:38 | [diff] [blame] | 1313 | TextInputState params; |
dglazkov | 97b6c2b | 2016-10-25 17:35:55 | [diff] [blame] | 1314 | params.type = new_type; |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1315 | params.mode = new_mode; |
| 1316 | params.flags = new_info.flags; |
AJITH KUMAR V | 9e7b557 | 2017-11-14 00:54:21 | [diff] [blame] | 1317 | #if defined(OS_ANDROID) |
AJITH KUMAR V | 041c0b0 | 2017-08-08 10:39:20 | [diff] [blame] | 1318 | if (next_previous_flags_ == kInvalidNextPreviousFlagsValue) { |
| 1319 | // Due to a focus change, values will be reset by the frame. |
| 1320 | // That case we only need fresh NEXT/PREVIOUS information. |
| 1321 | // Also we won't send ViewHostMsg_TextInputStateChanged if next/previous |
| 1322 | // focusable status is changed. |
| 1323 | if (auto* controller = GetInputMethodController()) { |
| 1324 | next_previous_flags_ = |
| 1325 | controller->ComputeWebTextInputNextPreviousFlags(); |
| 1326 | } else { |
| 1327 | // For safety in case GetInputMethodController() is null, because -1 is |
| 1328 | // invalid value to send to browser process. |
| 1329 | next_previous_flags_ = 0; |
| 1330 | } |
| 1331 | } |
AJITH KUMAR V | 9e7b557 | 2017-11-14 00:54:21 | [diff] [blame] | 1332 | #else |
| 1333 | next_previous_flags_ = 0; |
| 1334 | #endif |
AJITH KUMAR V | 041c0b0 | 2017-08-08 10:39:20 | [diff] [blame] | 1335 | params.flags |= next_previous_flags_; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1336 | params.value = new_info.value.Utf8(); |
| 1337 | params.selection_start = new_info.selection_start; |
| 1338 | params.selection_end = new_info.selection_end; |
| 1339 | params.composition_start = new_info.composition_start; |
| 1340 | params.composition_end = new_info.composition_end; |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1341 | params.can_compose_inline = new_can_compose_inline; |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 1342 | // TODO(changwan): change instances of show_ime_if_needed to |
| 1343 | // show_virtual_keyboard. |
| 1344 | params.show_ime_if_needed = show_virtual_keyboard; |
| 1345 | params.reply_to_request = reply_to_request; |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1346 | Send(new ViewHostMsg_TextInputStateChanged(routing_id(), params)); |
| 1347 | |
| 1348 | text_input_info_ = new_info; |
dglazkov | 97b6c2b | 2016-10-25 17:35:55 | [diff] [blame] | 1349 | text_input_type_ = new_type; |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1350 | text_input_mode_ = new_mode; |
| 1351 | can_compose_inline_ = new_can_compose_inline; |
| 1352 | text_input_flags_ = new_info.flags; |
| 1353 | } |
| 1354 | } |
| 1355 | |
| 1356 | bool RenderWidget::WillHandleGestureEvent(const blink::WebGestureEvent& event) { |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 1357 | possible_drag_event_info_.event_source = |
| 1358 | ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH; |
| 1359 | possible_drag_event_info_.event_location = |
Ella Ge | 1116059d | 2018-03-21 02:06:13 | [diff] [blame] | 1360 | gfx::ToFlooredPoint(event.PositionInScreen()); |
avi | d7d6b2e | 2016-03-04 19:41:17 | [diff] [blame] | 1361 | |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1362 | return false; |
| 1363 | } |
| 1364 | |
| 1365 | bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) { |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 1366 | for (auto& observer : render_frames_) |
| 1367 | observer.RenderWidgetWillHandleMouseEvent(); |
lfg | e0c2792ec | 2016-05-11 18:52:08 | [diff] [blame] | 1368 | |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 1369 | possible_drag_event_info_.event_source = |
| 1370 | ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE; |
| 1371 | possible_drag_event_info_.event_location = |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1372 | gfx::Point(event.PositionInScreen().x, event.PositionInScreen().y); |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 1373 | |
avi | d7d6b2e | 2016-03-04 19:41:17 | [diff] [blame] | 1374 | if (owner_delegate_) |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 1375 | return owner_delegate_->RenderWidgetWillHandleMouseEventForWidget(event); |
avi | d7d6b2e | 2016-03-04 19:41:17 | [diff] [blame] | 1376 | |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 1377 | return false; |
[email protected] | fd84779 | 2013-10-24 17:12:35 | [diff] [blame] | 1378 | } |
| 1379 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1380 | /////////////////////////////////////////////////////////////////////////////// |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1381 | // RenderWidgetScreenMetricsDelegate |
| 1382 | |
| 1383 | void RenderWidget::Redraw() { |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1384 | if (layer_tree_view_) |
| 1385 | layer_tree_view_->SetNeedsRedrawRect(gfx::Rect(size_)); |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1386 | } |
| 1387 | |
bokan | c63441c | 2016-04-27 15:49:12 | [diff] [blame] | 1388 | void RenderWidget::ResizeWebWidget() { |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 1389 | gfx::Size size = GetSizeForWebWidget(); |
| 1390 | if (owner_delegate_) { |
| 1391 | owner_delegate_->ResizeWebWidgetForWidget( |
| 1392 | size, top_controls_height_, bottom_controls_height_, |
| 1393 | browser_controls_shrink_blink_size_); |
| 1394 | return; |
| 1395 | } |
| 1396 | GetWebWidget()->Resize(size); |
bokan | c63441c | 2016-04-27 15:49:12 | [diff] [blame] | 1397 | } |
| 1398 | |
| 1399 | gfx::Size RenderWidget::GetSizeForWebWidget() const { |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 1400 | if (compositor_deps_->IsUseZoomForDSFEnabled()) { |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 1401 | return gfx::ScaleToCeiledSize(size_, |
| 1402 | GetOriginalScreenInfo().device_scale_factor); |
| 1403 | } |
bokan | c63441c | 2016-04-27 15:49:12 | [diff] [blame] | 1404 | |
| 1405 | return size_; |
| 1406 | } |
| 1407 | |
akaba | 3483d8f | 2018-07-10 21:43:09 | [diff] [blame] | 1408 | void RenderWidget::UpdateZoom(double zoom_level) { |
akaba | c6bd121 | 2018-06-25 20:10:48 | [diff] [blame] | 1409 | blink::WebFrameWidget* frame_widget = GetFrameWidget(); |
| 1410 | if (!frame_widget) |
| 1411 | return; |
| 1412 | RenderFrameImpl* render_frame = |
| 1413 | RenderFrameImpl::FromWebFrame(frame_widget->LocalRoot()); |
| 1414 | |
akaba | 3483d8f | 2018-07-10 21:43:09 | [diff] [blame] | 1415 | // Return early if zoom level is unchanged. |
| 1416 | if (render_frame->GetZoomLevel() == zoom_level) { |
akaba | c6bd121 | 2018-06-25 20:10:48 | [diff] [blame] | 1417 | return; |
| 1418 | } |
| 1419 | |
akaba | 3483d8f | 2018-07-10 21:43:09 | [diff] [blame] | 1420 | render_frame->SetZoomLevel(zoom_level); |
akaba | c6bd121 | 2018-06-25 20:10:48 | [diff] [blame] | 1421 | |
| 1422 | for (auto& observer : render_frame_proxies_) |
akaba | 3483d8f | 2018-07-10 21:43:09 | [diff] [blame] | 1423 | observer.OnZoomLevelChanged(zoom_level); |
akaba | c6bd121 | 2018-06-25 20:10:48 | [diff] [blame] | 1424 | |
| 1425 | for (auto& plugin : browser_plugins_) |
akaba | 3483d8f | 2018-07-10 21:43:09 | [diff] [blame] | 1426 | plugin.OnZoomLevelChanged(zoom_level); |
akaba | c6bd121 | 2018-06-25 20:10:48 | [diff] [blame] | 1427 | } |
| 1428 | |
Fady Samuel | 799e7219 | 2018-04-25 21:16:57 | [diff] [blame] | 1429 | void RenderWidget::SynchronizeVisualProperties(const VisualProperties& params) { |
Christopher Cameron | be7ecea | 2018-02-27 00:47:19 | [diff] [blame] | 1430 | // Inform the rendering thread of the color space indicate the presence of HDR |
| 1431 | // capabilities. |
Miguel Casas | 5e101805 | 2018-01-09 19:17:36 | [diff] [blame] | 1432 | RenderThreadImpl* render_thread = RenderThreadImpl::current(); |
| 1433 | if (render_thread) |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 1434 | render_thread->SetRenderingColorSpace(params.screen_info.color_space); |
Miguel Casas | 5e101805 | 2018-01-09 19:17:36 | [diff] [blame] | 1435 | |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1436 | // Ignore this during shutdown. |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1437 | if (!GetWebWidget()) |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1438 | return; |
| 1439 | |
Fady Samuel | e62be40 | 2018-03-29 03:19:53 | [diff] [blame] | 1440 | gfx::Size new_compositor_viewport_pixel_size = |
| 1441 | params.auto_resize_enabled |
| 1442 | ? gfx::ScaleToCeiledSize(size_, |
| 1443 | params.screen_info.device_scale_factor) |
| 1444 | : params.compositor_viewport_pixel_size; |
Fady Samuel | 4392abb | 2018-05-10 21:01:21 | [diff] [blame] | 1445 | UpdateSurfaceAndScreenInfo( |
| 1446 | params.local_surface_id.value_or(viz::LocalSurfaceId()), |
| 1447 | new_compositor_viewport_pixel_size, params.screen_info); |
Vladimir Levin | 98d76dad | 2018-04-21 00:21:29 | [diff] [blame] | 1448 | UpdateCaptureSequenceNumber(params.capture_sequence_number); |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1449 | if (layer_tree_view_) { |
| 1450 | layer_tree_view_->SetBrowserControlsHeight( |
Sadrul Habib Chowdhury | 04d5dd4d | 2017-08-10 01:59:27 | [diff] [blame] | 1451 | params.top_controls_height, params.bottom_controls_height, |
| 1452 | params.browser_controls_shrink_blink_size); |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1453 | layer_tree_view_->SetRasterColorSpace( |
Sadrul Habib Chowdhury | 04d5dd4d | 2017-08-10 01:59:27 | [diff] [blame] | 1454 | screen_info_.color_space.GetRasterColorSpace()); |
ianwen | e5fc578 | 2016-08-18 04:05:15 | [diff] [blame] | 1455 | } |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1456 | |
akaba | 3483d8f | 2018-07-10 21:43:09 | [diff] [blame] | 1457 | UpdateZoom(params.zoom_level); |
akaba | c6bd121 | 2018-06-25 20:10:48 | [diff] [blame] | 1458 | |
Fady Samuel | e62be40 | 2018-03-29 03:19:53 | [diff] [blame] | 1459 | if (params.auto_resize_enabled) |
| 1460 | return; |
| 1461 | |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1462 | visible_viewport_size_ = params.visible_viewport_size; |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1463 | |
| 1464 | // NOTE: We may have entered fullscreen mode without changing our size. |
| 1465 | bool fullscreen_change = |
| 1466 | is_fullscreen_granted_ != params.is_fullscreen_granted; |
| 1467 | is_fullscreen_granted_ = params.is_fullscreen_granted; |
| 1468 | display_mode_ = params.display_mode; |
| 1469 | |
bokan | c63441c | 2016-04-27 15:49:12 | [diff] [blame] | 1470 | size_ = params.new_size; |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1471 | |
bokan | c63441c | 2016-04-27 15:49:12 | [diff] [blame] | 1472 | ResizeWebWidget(); |
bokan | 71cb5b1 | 2016-04-27 03:45:22 | [diff] [blame] | 1473 | |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1474 | WebSize visual_viewport_size; |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 1475 | if (compositor_deps_->IsUseZoomForDSFEnabled()) { |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 1476 | visual_viewport_size = |
| 1477 | gfx::ScaleToCeiledSize(params.visible_viewport_size, |
| 1478 | GetOriginalScreenInfo().device_scale_factor); |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1479 | } else { |
| 1480 | visual_viewport_size = visible_viewport_size_; |
| 1481 | } |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1482 | GetWebWidget()->ResizeVisualViewport(visual_viewport_size); |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1483 | |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1484 | if (fullscreen_change) |
| 1485 | DidToggleFullscreen(); |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1486 | } |
| 1487 | |
| 1488 | void RenderWidget::SetScreenMetricsEmulationParameters( |
| 1489 | bool enabled, |
| 1490 | const blink::WebDeviceEmulationParams& params) { |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 1491 | // This is only supported in RenderView, which has an |owner_delegate_|. |
| 1492 | DCHECK(owner_delegate_); |
| 1493 | owner_delegate_->SetScreenMetricsEmulationParametersForWidget(enabled, |
| 1494 | params); |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 1495 | } |
| 1496 | |
| 1497 | void RenderWidget::SetScreenRects(const gfx::Rect& view_screen_rect, |
| 1498 | const gfx::Rect& window_screen_rect) { |
| 1499 | view_screen_rect_ = view_screen_rect; |
| 1500 | window_screen_rect_ = window_screen_rect; |
| 1501 | } |
| 1502 | |
| 1503 | /////////////////////////////////////////////////////////////////////////////// |
[email protected] | f98d7e3c | 2010-09-13 22:30:46 | [diff] [blame] | 1504 | // WebWidgetClient |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1505 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1506 | blink::WebLayerTreeView* RenderWidget::InitializeLayerTreeView() { |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 1507 | DCHECK(!host_closing_); |
| 1508 | |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1509 | layer_tree_view_ = std::make_unique<LayerTreeView>( |
danakj | 4c98765 | 2018-07-05 15:49:41 | [diff] [blame] | 1510 | this, compositor_deps_->GetCompositorMainThreadTaskRunner(), |
| 1511 | compositor_deps_->GetCompositorImplThreadTaskRunner(), |
| 1512 | compositor_deps_->GetTaskGraphRunner(), |
| 1513 | compositor_deps_->GetWebMainThreadScheduler()); |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1514 | layer_tree_view_->Initialize( |
danakj | 4c98765 | 2018-07-05 15:49:41 | [diff] [blame] | 1515 | GenerateLayerTreeSettings(compositor_deps_, for_oopif_, |
| 1516 | screen_info_.rect.size(), |
| 1517 | screen_info_.device_scale_factor), |
| 1518 | compositor_deps_->CreateUkmRecorderFactory()); |
loyso | 6e6efc4 | 2017-01-21 02:23:03 | [diff] [blame] | 1519 | |
Fady Samuel | 4255c18 | 2018-05-24 20:42:36 | [diff] [blame] | 1520 | UpdateSurfaceAndScreenInfo(local_surface_id_from_parent_, |
| 1521 | compositor_viewport_pixel_size_, screen_info_); |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1522 | layer_tree_view_->SetRasterColorSpace( |
Christopher Cameron | a1ea2b7 | 2017-08-02 01:59:09 | [diff] [blame] | 1523 | screen_info_.color_space.GetRasterColorSpace()); |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1524 | layer_tree_view_->SetContentSourceId(current_content_source_id_); |
sievers | 71c62dd5 | 2015-10-07 01:44:39 | [diff] [blame] | 1525 | // For background pages and certain tests, we don't want to trigger |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 1526 | // LayerTreeFrameSink creation. |
dtapuska | b08611f | 2017-04-24 16:10:22 | [diff] [blame] | 1527 | bool should_generate_frame_sink = |
| 1528 | !compositor_never_visible_ && RenderThreadImpl::current(); |
| 1529 | if (!should_generate_frame_sink) |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1530 | layer_tree_view_->SetNeverVisible(); |
sievers | 71c62dd5 | 2015-10-07 01:44:39 | [diff] [blame] | 1531 | |
piman | c4af307 | 2015-10-02 03:45:59 | [diff] [blame] | 1532 | StartCompositor(); |
staraz | 067f5824 | 2016-11-07 21:06:41 | [diff] [blame] | 1533 | DCHECK_NE(MSG_ROUTING_NONE, routing_id_); |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1534 | layer_tree_view_->SetFrameSinkId( |
Fady Samuel | d5c2618 | 2017-07-12 02:43:33 | [diff] [blame] | 1535 | viz::FrameSinkId(RenderThread::Get()->GetClientId(), routing_id_)); |
loyso | 50b51c2 | 2017-01-10 07:18:37 | [diff] [blame] | 1536 | |
wjmaclean | 1d97062 | 2017-01-21 22:28:24 | [diff] [blame] | 1537 | RenderThreadImpl* render_thread = RenderThreadImpl::current(); |
Dave Tapuska | 9db8084 | 2017-07-24 17:24:26 | [diff] [blame] | 1538 | if (render_thread) { |
dtapuska | 9ec1a91 | 2017-04-21 15:18:31 | [diff] [blame] | 1539 | input_event_queue_ = new MainThreadEventQueue( |
Yuta Kitamura | 3331f5c | 2018-04-05 11:12:25 | [diff] [blame] | 1540 | this, render_thread->GetWebMainThreadScheduler()->InputTaskRunner(), |
| 1541 | render_thread->GetWebMainThreadScheduler(), should_generate_frame_sink); |
wjmaclean | 1d97062 | 2017-01-21 22:28:24 | [diff] [blame] | 1542 | } |
| 1543 | |
Khushal | 3e96e66 | 2017-10-30 23:16:50 | [diff] [blame] | 1544 | UpdateURLForCompositorUkm(); |
| 1545 | |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1546 | return layer_tree_view_.get(); |
[email protected] | e195e58 | 2013-03-08 01:32:59 | [diff] [blame] | 1547 | } |
| 1548 | |
Chris Harrelson | d7ab99b | 2018-01-24 17:51:36 | [diff] [blame] | 1549 | void RenderWidget::IntrinsicSizingInfoChanged( |
| 1550 | const blink::WebIntrinsicSizingInfo& sizing_info) { |
| 1551 | Send(new ViewHostMsg_IntrinsicSizingInfoChanged(routing_id_, sizing_info)); |
| 1552 | } |
| 1553 | |
enne | f3c5814 | 2014-12-09 21:44:38 | [diff] [blame] | 1554 | void RenderWidget::WillCloseLayerTreeView() { |
| 1555 | if (host_closing_) |
| 1556 | return; |
| 1557 | |
| 1558 | // Prevent new compositors or output surfaces from being created. |
| 1559 | host_closing_ = true; |
| 1560 | |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 1561 | // Always send this notification to prevent new layer tree views from |
| 1562 | // being created, even if one hasn't been created yet. |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1563 | if (blink::WebWidget* widget = GetWebWidget()) |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1564 | widget->WillCloseLayerTreeView(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 1565 | } |
| 1566 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1567 | void RenderWidget::DidMeaningfulLayout(blink::WebMeaningfulLayout layout_type) { |
| 1568 | if (layout_type == blink::WebMeaningfulLayout::kVisuallyNonEmpty) { |
Sadrul Habib Chowdhury | 4e0335cf | 2018-07-31 20:08:49 | [diff] [blame^] | 1569 | QueueMessage(new ViewHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_)); |
dglazkov | f0e1d6d | 2015-10-10 02:13:48 | [diff] [blame] | 1570 | } |
dglazkov | 79c42610 | 2015-08-31 21:22:43 | [diff] [blame] | 1571 | |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 1572 | for (auto& observer : render_frames_) |
| 1573 | observer.DidMeaningfulLayout(layout_type); |
dglazkov | 79c42610 | 2015-08-31 21:22:43 | [diff] [blame] | 1574 | } |
| 1575 | |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1576 | // static |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 1577 | std::unique_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl( |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1578 | IPC::Message* msg, |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1579 | FrameSwapMessageQueue* frame_swap_message_queue, |
| 1580 | scoped_refptr<IPC::SyncMessageFilter> sync_message_filter, |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1581 | int source_frame_number) { |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1582 | bool first_message_for_frame = false; |
Sadrul Habib Chowdhury | 4e0335cf | 2018-07-31 20:08:49 | [diff] [blame^] | 1583 | frame_swap_message_queue->QueueMessageForFrame( |
| 1584 | source_frame_number, base::WrapUnique(msg), &first_message_for_frame); |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1585 | if (first_message_for_frame) { |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 1586 | std::unique_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise( |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1587 | sync_message_filter, frame_swap_message_queue, source_frame_number)); |
dcheng | 4b6b5ff | 2014-10-16 00:42:06 | [diff] [blame] | 1588 | return promise; |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1589 | } |
dcheng | 4b6b5ff | 2014-10-16 00:42:06 | [diff] [blame] | 1590 | return nullptr; |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1591 | } |
| 1592 | |
danakj | 5380269 | 2018-07-25 21:46:44 | [diff] [blame] | 1593 | void RenderWidget::SetHandlingInputEvent(bool handling_input_event) { |
| 1594 | input_handler_->set_handling_input_event(handling_input_event); |
| 1595 | } |
| 1596 | |
Sadrul Habib Chowdhury | 4e0335cf | 2018-07-31 20:08:49 | [diff] [blame^] | 1597 | void RenderWidget::QueueMessage(IPC::Message* msg) { |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1598 | // RenderThreadImpl::current() is NULL in some tests. |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1599 | if (!layer_tree_view_ || !RenderThreadImpl::current()) { |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1600 | Send(msg); |
| 1601 | return; |
| 1602 | } |
| 1603 | |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 1604 | std::unique_ptr<cc::SwapPromise> swap_promise = |
Sadrul Habib Chowdhury | 4e0335cf | 2018-07-31 20:08:49 | [diff] [blame^] | 1605 | QueueMessageImpl(msg, frame_swap_message_queue_.get(), |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1606 | RenderThreadImpl::current()->sync_message_filter(), |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1607 | layer_tree_view_->GetSourceFrameNumber()); |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1608 | |
Ken Buchanan | ce710eb | 2017-08-30 23:46:52 | [diff] [blame] | 1609 | if (swap_promise) |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1610 | layer_tree_view_->QueueSwapPromise(std::move(swap_promise)); |
[email protected] | 586871b | 2014-07-22 17:05:11 | [diff] [blame] | 1611 | } |
| 1612 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1613 | void RenderWidget::DidChangeCursor(const WebCursorInfo& cursor_info) { |
[email protected] | 7c51b0ee | 2009-07-08 21:49:30 | [diff] [blame] | 1614 | // TODO(darin): Eliminate this temporary. |
[email protected] | 9ec8771 | 2013-05-24 23:23:52 | [diff] [blame] | 1615 | WebCursor cursor; |
tfarina | 75a0abf | 2015-10-06 15:07:18 | [diff] [blame] | 1616 | InitializeCursorFromWebCursorInfo(&cursor, cursor_info); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1617 | // Only send a SetCursor message if we need to make a change. |
| 1618 | if (!current_cursor_.IsEqual(cursor)) { |
| 1619 | current_cursor_ = cursor; |
| 1620 | Send(new ViewHostMsg_SetCursor(routing_id_, cursor)); |
| 1621 | } |
| 1622 | } |
| 1623 | |
aelias | 5971e47d | 2017-06-16 02:39:38 | [diff] [blame] | 1624 | void RenderWidget::AutoscrollStart(const blink::WebFloatPoint& point) { |
| 1625 | Send(new ViewHostMsg_AutoscrollStart(routing_id_, point)); |
| 1626 | } |
| 1627 | |
| 1628 | void RenderWidget::AutoscrollFling(const blink::WebFloatSize& velocity) { |
| 1629 | Send(new ViewHostMsg_AutoscrollFling(routing_id_, velocity)); |
| 1630 | } |
| 1631 | |
| 1632 | void RenderWidget::AutoscrollEnd() { |
| 1633 | Send(new ViewHostMsg_AutoscrollEnd(routing_id_)); |
| 1634 | } |
| 1635 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1636 | // We are supposed to get a single call to Show for a newly created RenderWidget |
| 1637 | // that was created via RenderWidget::CreateWebView. So, we wait until this |
| 1638 | // point to dispatch the ShowWidget message. |
| 1639 | // |
| 1640 | // This method provides us with the information about how to display the newly |
[email protected] | 5f9de588 | 2011-09-30 23:36:28 | [diff] [blame] | 1641 | // created RenderWidget (i.e., as a blocked popup or as a new tab). |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1642 | // |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1643 | void RenderWidget::Show(WebNavigationPolicy policy) { |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 1644 | if (did_show_) { |
| 1645 | if (owner_delegate_) { |
| 1646 | // When SupportsMultipleWindows is disabled, popups are reusing |
| 1647 | // the same view. In some scenarios, this makes blink to call Show() |
| 1648 | // twice. But otherwise, if it is enabled, we should not visit Show() more |
| 1649 | // than once. |
| 1650 | DCHECK(!owner_delegate_->SupportsMultipleWindowsForWidget()); |
| 1651 | } else { |
| 1652 | DCHECK(!did_show_) << "received extraneous Show call"; |
| 1653 | } |
| 1654 | return; |
| 1655 | } |
| 1656 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1657 | DCHECK(routing_id_ != MSG_ROUTING_NONE); |
danakj | df1ceb7 | 2018-07-18 20:02:25 | [diff] [blame] | 1658 | DCHECK(show_callback_); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1659 | |
[email protected] | 8de12d94 | 2010-11-17 20:42:44 | [diff] [blame] | 1660 | did_show_ = true; |
nick | f7b3822 | 2016-11-22 21:59:35 | [diff] [blame] | 1661 | |
| 1662 | // The opener is responsible for actually showing this widget. |
danakj | df1ceb7 | 2018-07-18 20:02:25 | [diff] [blame] | 1663 | std::move(show_callback_).Run(this, policy, initial_rect_); |
nick | f7b3822 | 2016-11-22 21:59:35 | [diff] [blame] | 1664 | |
bokan | c007c3a | 2015-02-03 07:15:56 | [diff] [blame] | 1665 | // NOTE: initial_rect_ may still have its default values at this point, but |
[email protected] | 8de12d94 | 2010-11-17 20:42:44 | [diff] [blame] | 1666 | // that's okay. It'll be ignored if as_popup is false, or the browser |
| 1667 | // process will impose a default position otherwise. |
bokan | c007c3a | 2015-02-03 07:15:56 | [diff] [blame] | 1668 | SetPendingWindowRect(initial_rect_); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1669 | } |
| 1670 | |
[email protected] | 2533ce1 | 2009-05-09 00:02:24 | [diff] [blame] | 1671 | void RenderWidget::DoDeferredClose() { |
enne | f3c5814 | 2014-12-09 21:44:38 | [diff] [blame] | 1672 | WillCloseLayerTreeView(); |
[email protected] | 2533ce1 | 2009-05-09 00:02:24 | [diff] [blame] | 1673 | Send(new ViewHostMsg_Close(routing_id_)); |
| 1674 | } |
| 1675 | |
dgozman | cf9039cd | 2015-04-06 12:01:31 | [diff] [blame] | 1676 | void RenderWidget::NotifyOnClose() { |
ericwilligers | 88e6974 | 2016-10-17 19:29:55 | [diff] [blame] | 1677 | for (auto& observer : render_frames_) |
| 1678 | observer.WidgetWillClose(); |
dgozman | cf9039cd | 2015-04-06 12:01:31 | [diff] [blame] | 1679 | } |
| 1680 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1681 | void RenderWidget::CloseWidgetSoon() { |
skyostil | ed8969c | 2015-07-20 16:57:08 | [diff] [blame] | 1682 | DCHECK(content::RenderThread::Get()); |
[email protected] | e1c3a55 | 2012-05-04 20:51:32 | [diff] [blame] | 1683 | if (is_swapped_out_) { |
| 1684 | // This widget is currently swapped out, and the active widget is in a |
| 1685 | // different process. Have the browser route the close request to the |
| 1686 | // active widget instead, so that the correct unload handlers are run. |
| 1687 | Send(new ViewHostMsg_RouteCloseEvent(routing_id_)); |
| 1688 | return; |
| 1689 | } |
| 1690 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1691 | // If a page calls window.close() twice, we'll end up here twice, but that's |
| 1692 | // OK. It is safe to send multiple Close messages. |
| 1693 | |
[email protected] | 2533ce1 | 2009-05-09 00:02:24 | [diff] [blame] | 1694 | // Ask the RenderWidgetHost to initiate close. We could be called from deep |
| 1695 | // in Javascript. If we ask the RendwerWidgetHost to close now, the window |
| 1696 | // could be closed before the JS finishes executing. So instead, post a |
| 1697 | // message back to the message loop, which won't run until the JS is |
| 1698 | // complete, and then the Close message can be sent. |
Hajime Hoshi | abb3c8f | 2017-12-04 18:41:39 | [diff] [blame] | 1699 | task_runner_->PostTask(FROM_HERE, |
| 1700 | base::BindOnce(&RenderWidget::DoDeferredClose, this)); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1701 | } |
| 1702 | |
| 1703 | void RenderWidget::Close() { |
[email protected] | 404630b | 2014-07-03 19:33:03 | [diff] [blame] | 1704 | screen_metrics_emulator_.reset(); |
Ken Buchanan | ed449bb | 2018-02-01 21:02:05 | [diff] [blame] | 1705 | CloseWebWidget(); |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1706 | layer_tree_view_.reset(); |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 1707 | if (owner_delegate_) |
| 1708 | owner_delegate_->DidCloseWidget(); |
Ken Buchanan | ed449bb | 2018-02-01 21:02:05 | [diff] [blame] | 1709 | } |
| 1710 | |
| 1711 | void RenderWidget::CloseWebWidget() { |
| 1712 | WillCloseLayerTreeView(); |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1713 | if (webwidget_internal_) { |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1714 | webwidget_internal_->Close(); |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 1715 | webwidget_internal_ = nullptr; |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1716 | } |
| 1717 | } |
| 1718 | |
Mitsuru Oshima | 3c07b33 | 2018-02-06 04:56:50 | [diff] [blame] | 1719 | void RenderWidget::UpdateWebViewWithDeviceScaleFactor() { |
| 1720 | blink::WebFrameWidget* frame_widget = GetFrameWidget(); |
| 1721 | blink::WebFrame* current_frame = |
| 1722 | frame_widget ? frame_widget->LocalRoot() : nullptr; |
| 1723 | blink::WebView* webview = current_frame ? current_frame->View() : nullptr; |
| 1724 | if (webview) { |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 1725 | if (compositor_deps_->IsUseZoomForDSFEnabled()) |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 1726 | webview->SetZoomFactorForDeviceScaleFactor( |
| 1727 | GetWebScreenInfo().device_scale_factor); |
Mitsuru Oshima | 3c07b33 | 2018-02-06 04:56:50 | [diff] [blame] | 1728 | else |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 1729 | webview->SetDeviceScaleFactor(GetWebScreenInfo().device_scale_factor); |
Mitsuru Oshima | 3c07b33 | 2018-02-06 04:56:50 | [diff] [blame] | 1730 | |
| 1731 | webview->GetSettings()->SetPreferCompositingToLCDTextEnabled( |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 1732 | PreferCompositingToLCDText(compositor_deps_, |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 1733 | GetWebScreenInfo().device_scale_factor)); |
Mitsuru Oshima | 3c07b33 | 2018-02-06 04:56:50 | [diff] [blame] | 1734 | } |
| 1735 | } |
| 1736 | |
Ehsan Karamad | 655d7b8a | 2018-01-12 18:38:38 | [diff] [blame] | 1737 | blink::WebFrameWidget* RenderWidget::GetFrameWidget() const { |
| 1738 | blink::WebWidget* web_widget = GetWebWidget(); |
| 1739 | if (!web_widget) |
| 1740 | return nullptr; |
| 1741 | |
| 1742 | if (!web_widget->IsWebFrameWidget()) { |
| 1743 | // TODO(ekaramad): This should not happen. If we have a WebWidget and we |
| 1744 | // need a WebFrameWidget then we should be getting a WebFrameWidget. But |
| 1745 | // unfortunately this does not seem to be the case in some scenarios -- |
| 1746 | // specifically when a RenderViewImpl swaps out during navigation the |
| 1747 | // WebViewImpl loses its WebViewFrameWidget but sometimes we receive IPCs |
| 1748 | // which are destined for WebFrameWidget (https://crbug.com/669219). |
| 1749 | return nullptr; |
| 1750 | } |
| 1751 | |
| 1752 | return static_cast<blink::WebFrameWidget*>(web_widget); |
| 1753 | } |
| 1754 | |
bokan | 841fdc7 | 2016-10-06 00:16:35 | [diff] [blame] | 1755 | void RenderWidget::ScreenRectToEmulatedIfNeeded(WebRect* window_rect) const { |
| 1756 | DCHECK(window_rect); |
| 1757 | float scale = popup_origin_scale_for_emulation_; |
| 1758 | if (!scale) |
| 1759 | return; |
| 1760 | window_rect->x = |
| 1761 | popup_view_origin_for_emulation_.x() + |
| 1762 | (window_rect->x - popup_screen_origin_for_emulation_.x()) / scale; |
| 1763 | window_rect->y = |
| 1764 | popup_view_origin_for_emulation_.y() + |
| 1765 | (window_rect->y - popup_screen_origin_for_emulation_.y()) / scale; |
| 1766 | } |
| 1767 | |
| 1768 | void RenderWidget::EmulatedToScreenRectIfNeeded(WebRect* window_rect) const { |
| 1769 | DCHECK(window_rect); |
| 1770 | float scale = popup_origin_scale_for_emulation_; |
| 1771 | if (!scale) |
| 1772 | return; |
| 1773 | window_rect->x = |
| 1774 | popup_screen_origin_for_emulation_.x() + |
| 1775 | (window_rect->x - popup_view_origin_for_emulation_.x()) * scale; |
| 1776 | window_rect->y = |
| 1777 | popup_screen_origin_for_emulation_.y() + |
| 1778 | (window_rect->y - popup_view_origin_for_emulation_.y()) * scale; |
| 1779 | } |
| 1780 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1781 | WebRect RenderWidget::WindowRect() { |
bokan | 841fdc7 | 2016-10-06 00:16:35 | [diff] [blame] | 1782 | WebRect rect; |
bokan | 6b08cd2 | 2016-10-05 00:55:21 | [diff] [blame] | 1783 | if (pending_window_rect_count_) { |
| 1784 | // NOTE(mbelshe): If there is a pending_window_rect_, then getting |
| 1785 | // the RootWindowRect is probably going to return wrong results since the |
| 1786 | // browser may not have processed the Move yet. There isn't really anything |
| 1787 | // good to do in this case, and it shouldn't happen - since this size is |
| 1788 | // only really needed for windowToScreen, which is only used for Popups. |
bokan | 841fdc7 | 2016-10-06 00:16:35 | [diff] [blame] | 1789 | rect = pending_window_rect_; |
| 1790 | } else { |
| 1791 | rect = window_screen_rect_; |
bokan | 6b08cd2 | 2016-10-05 00:55:21 | [diff] [blame] | 1792 | } |
[email protected] | 2533ce1 | 2009-05-09 00:02:24 | [diff] [blame] | 1793 | |
bokan | 841fdc7 | 2016-10-06 00:16:35 | [diff] [blame] | 1794 | ScreenRectToEmulatedIfNeeded(&rect); |
| 1795 | return rect; |
bokan | 6b08cd2 | 2016-10-05 00:55:21 | [diff] [blame] | 1796 | } |
| 1797 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1798 | WebRect RenderWidget::ViewRect() { |
bokan | 841fdc7 | 2016-10-06 00:16:35 | [diff] [blame] | 1799 | WebRect rect = view_screen_rect_; |
| 1800 | ScreenRectToEmulatedIfNeeded(&rect); |
| 1801 | return rect; |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1802 | } |
| 1803 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1804 | void RenderWidget::SetToolTipText(const blink::WebString& text, |
[email protected] | 8a9d6ca3 | 2011-06-06 20:11:30 | [diff] [blame] | 1805 | WebTextDirection hint) { |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1806 | Send(new ViewHostMsg_SetTooltipText(routing_id_, text.Utf16(), hint)); |
[email protected] | 8a9d6ca3 | 2011-06-06 20:11:30 | [diff] [blame] | 1807 | } |
| 1808 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1809 | void RenderWidget::SetWindowRect(const WebRect& rect_in_screen) { |
oshima | 33ec97cd | 2015-12-14 19:40:24 | [diff] [blame] | 1810 | WebRect window_rect = rect_in_screen; |
bokan | 841fdc7 | 2016-10-06 00:16:35 | [diff] [blame] | 1811 | EmulatedToScreenRectIfNeeded(&window_rect); |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 1812 | |
[email protected] | 5b45ad4 | 2013-10-25 00:42:04 | [diff] [blame] | 1813 | if (!resizing_mode_selector_->is_synchronous_mode()) { |
[email protected] | ec951b9d | 2013-10-20 06:21:20 | [diff] [blame] | 1814 | if (did_show_) { |
Avi Drissman | 014dec7 | 2018-06-07 02:34:01 | [diff] [blame] | 1815 | Send(new ViewHostMsg_RequestSetBounds(routing_id_, window_rect)); |
bokan | c007c3a | 2015-02-03 07:15:56 | [diff] [blame] | 1816 | SetPendingWindowRect(window_rect); |
[email protected] | 8be1c58 | 2013-03-06 00:55:03 | [diff] [blame] | 1817 | } else { |
bokan | c007c3a | 2015-02-03 07:15:56 | [diff] [blame] | 1818 | initial_rect_ = window_rect; |
[email protected] | 8be1c58 | 2013-03-06 00:55:03 | [diff] [blame] | 1819 | } |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1820 | } else { |
bokan | c007c3a | 2015-02-03 07:15:56 | [diff] [blame] | 1821 | SetWindowRectSynchronously(window_rect); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1822 | } |
| 1823 | } |
| 1824 | |
[email protected] | 2533ce1 | 2009-05-09 00:02:24 | [diff] [blame] | 1825 | void RenderWidget::SetPendingWindowRect(const WebRect& rect) { |
| 1826 | pending_window_rect_ = rect; |
| 1827 | pending_window_rect_count_++; |
[email protected] | 2533ce1 | 2009-05-09 00:02:24 | [diff] [blame] | 1828 | |
bokan | 6b08cd2 | 2016-10-05 00:55:21 | [diff] [blame] | 1829 | // Popups don't get size updates back from the browser so just store the set |
| 1830 | // values. |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1831 | if (popup_type_ != blink::kWebPopupTypeNone) { |
| 1832 | window_screen_rect_ = rect; |
| 1833 | view_screen_rect_ = rect; |
[email protected] | 2533ce1 | 2009-05-09 00:02:24 | [diff] [blame] | 1834 | } |
[email protected] | d454745 | 2008-08-28 18:36:37 | [diff] [blame] | 1835 | } |
| 1836 | |
wjmaclean | ee244e0 | 2017-05-26 21:06:07 | [diff] [blame] | 1837 | void RenderWidget::OnShowContextMenu(ui::MenuSourceType source_type, |
| 1838 | const gfx::Point& location) { |
wjmaclean | ee244e0 | 2017-05-26 21:06:07 | [diff] [blame] | 1839 | has_host_context_menu_location_ = true; |
| 1840 | host_context_menu_location_ = location; |
| 1841 | if (GetWebWidget()) { |
| 1842 | GetWebWidget()->ShowContextMenu( |
| 1843 | static_cast<blink::WebMenuSourceType>(source_type)); |
| 1844 | } |
| 1845 | has_host_context_menu_location_ = false; |
| 1846 | } |
| 1847 | |
[email protected] | fa7b1dc | 2010-06-23 17:53:04 | [diff] [blame] | 1848 | void RenderWidget::OnImeSetComposition( |
[email protected] | fcf75d4 | 2013-12-03 20:11:26 | [diff] [blame] | 1849 | const base::string16& text, |
Ryan Landay | 9e42fd74 | 2017-08-12 01:59:11 | [diff] [blame] | 1850 | const std::vector<WebImeTextSpan>& ime_text_spans, |
chongz | 7eb75280 | 2016-01-27 21:28:07 | [diff] [blame] | 1851 | const gfx::Range& replacement_range, |
Ryan Landay | 9e42fd74 | 2017-08-12 01:59:11 | [diff] [blame] | 1852 | int selection_start, |
| 1853 | int selection_end) { |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 1854 | if (!ShouldHandleImeEvents()) |
| 1855 | return; |
| 1856 | |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 1857 | #if BUILDFLAG(ENABLE_PLUGINS) |
EhsanK | 22d482e | 2017-08-10 17:29:49 | [diff] [blame] | 1858 | if (auto* plugin = GetFocusedPepperPluginInsideWidget()) { |
Ryan Landay | 9e42fd74 | 2017-08-12 01:59:11 | [diff] [blame] | 1859 | plugin->render_frame()->OnImeSetComposition(text, ime_text_spans, |
EhsanK | 22d482e | 2017-08-10 17:29:49 | [diff] [blame] | 1860 | selection_start, selection_end); |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 1861 | return; |
| 1862 | } |
| 1863 | #endif |
[email protected] | 66fca5bc | 2013-05-23 06:58:29 | [diff] [blame] | 1864 | ImeEventGuard guard(this); |
ekaramad | 2daaf67 | 2016-11-10 20:29:01 | [diff] [blame] | 1865 | blink::WebInputMethodController* controller = GetInputMethodController(); |
ekaramad | 2daaf67 | 2016-11-10 20:29:01 | [diff] [blame] | 1866 | if (!controller || |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1867 | !controller->SetComposition( |
Ryan Landay | 9e42fd74 | 2017-08-12 01:59:11 | [diff] [blame] | 1868 | WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans), |
ekaramad | ce32ef9f | 2017-02-09 17:33:56 | [diff] [blame] | 1869 | replacement_range.IsValid() |
| 1870 | ? WebRange(replacement_range.start(), replacement_range.length()) |
| 1871 | : WebRange(), |
| 1872 | selection_start, selection_end)) { |
[email protected] | fa7b1dc | 2010-06-23 17:53:04 | [diff] [blame] | 1873 | // If we failed to set the composition text, then we need to let the browser |
| 1874 | // process to cancel the input method's ongoing composition session, to make |
| 1875 | // sure we are in a consistent state. |
Dave Tapuska | 04bc5ee9 | 2018-04-17 19:03:31 | [diff] [blame] | 1876 | if (mojom::WidgetInputHandlerHost* host = |
| 1877 | widget_input_handler_manager_->GetWidgetInputHandlerHost()) { |
| 1878 | host->ImeCancelComposition(); |
Dave Tapuska | 139a72f | 2017-09-06 21:57:03 | [diff] [blame] | 1879 | } |
[email protected] | 7f00efa | 2010-04-15 05:01:26 | [diff] [blame] | 1880 | } |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 1881 | UpdateCompositionInfo(false /* not an immediate request */); |
[email protected] | fa7b1dc | 2010-06-23 17:53:04 | [diff] [blame] | 1882 | } |
| 1883 | |
rlanday | 7efe230 | 2017-01-11 00:14:28 | [diff] [blame] | 1884 | void RenderWidget::OnImeCommitText( |
| 1885 | const base::string16& text, |
Ryan Landay | 9e42fd74 | 2017-08-12 01:59:11 | [diff] [blame] | 1886 | const std::vector<WebImeTextSpan>& ime_text_spans, |
rlanday | 7efe230 | 2017-01-11 00:14:28 | [diff] [blame] | 1887 | const gfx::Range& replacement_range, |
| 1888 | int relative_cursor_pos) { |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 1889 | if (!ShouldHandleImeEvents()) |
| 1890 | return; |
| 1891 | |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 1892 | #if BUILDFLAG(ENABLE_PLUGINS) |
EhsanK | 22d482e | 2017-08-10 17:29:49 | [diff] [blame] | 1893 | if (auto* plugin = GetFocusedPepperPluginInsideWidget()) { |
| 1894 | plugin->render_frame()->OnImeCommitText(text, replacement_range, |
| 1895 | relative_cursor_pos); |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 1896 | return; |
| 1897 | } |
| 1898 | #endif |
[email protected] | 66fca5bc | 2013-05-23 06:58:29 | [diff] [blame] | 1899 | ImeEventGuard guard(this); |
fsamuel | e8326c74 | 2016-01-12 00:49:39 | [diff] [blame] | 1900 | input_handler_->set_handling_input_event(true); |
ekaramad | b6483a05 | 2017-02-10 02:23:26 | [diff] [blame] | 1901 | if (auto* controller = GetInputMethodController()) { |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1902 | controller->CommitText( |
Ryan Landay | 9e42fd74 | 2017-08-12 01:59:11 | [diff] [blame] | 1903 | WebString::FromUTF16(text), WebVector<WebImeTextSpan>(ime_text_spans), |
ekaramad | ce32ef9f | 2017-02-09 17:33:56 | [diff] [blame] | 1904 | replacement_range.IsValid() |
| 1905 | ? WebRange(replacement_range.start(), replacement_range.length()) |
| 1906 | : WebRange(), |
| 1907 | relative_cursor_pos); |
ekaramad | b6483a05 | 2017-02-10 02:23:26 | [diff] [blame] | 1908 | } |
aelias | 87b8f7c | 2016-09-14 03:19:29 | [diff] [blame] | 1909 | input_handler_->set_handling_input_event(false); |
| 1910 | UpdateCompositionInfo(false /* not an immediate request */); |
| 1911 | } |
| 1912 | |
| 1913 | void RenderWidget::OnImeFinishComposingText(bool keep_selection) { |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 1914 | if (!ShouldHandleImeEvents()) |
| 1915 | return; |
| 1916 | |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 1917 | #if BUILDFLAG(ENABLE_PLUGINS) |
EhsanK | 22d482e | 2017-08-10 17:29:49 | [diff] [blame] | 1918 | if (auto* plugin = GetFocusedPepperPluginInsideWidget()) { |
| 1919 | plugin->render_frame()->OnImeFinishComposingText(keep_selection); |
aelias | 87b8f7c | 2016-09-14 03:19:29 | [diff] [blame] | 1920 | return; |
| 1921 | } |
| 1922 | #endif |
| 1923 | |
changwan | 38c3eb61 | 2016-12-09 01:45:56 | [diff] [blame] | 1924 | if (!GetWebWidget()) |
aelias | 87b8f7c | 2016-09-14 03:19:29 | [diff] [blame] | 1925 | return; |
| 1926 | ImeEventGuard guard(this); |
| 1927 | input_handler_->set_handling_input_event(true); |
ekaramad | 2daaf67 | 2016-11-10 20:29:01 | [diff] [blame] | 1928 | if (auto* controller = GetInputMethodController()) { |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 1929 | controller->FinishComposingText( |
| 1930 | keep_selection ? WebInputMethodController::kKeepSelection |
| 1931 | : WebInputMethodController::kDoNotKeepSelection); |
ekaramad | 2daaf67 | 2016-11-10 20:29:01 | [diff] [blame] | 1932 | } |
fsamuel | e8326c74 | 2016-01-12 00:49:39 | [diff] [blame] | 1933 | input_handler_->set_handling_input_event(false); |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 1934 | UpdateCompositionInfo(false /* not an immediate request */); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 1935 | } |
| 1936 | |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 1937 | void RenderWidget::UpdateSurfaceAndScreenInfo( |
Fady Samuel | 4392abb | 2018-05-10 21:01:21 | [diff] [blame] | 1938 | const viz::LocalSurfaceId& new_local_surface_id, |
Christopher Cameron | aad15a0d | 2018-03-09 03:47:33 | [diff] [blame] | 1939 | const gfx::Size& new_compositor_viewport_pixel_size, |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 1940 | const ScreenInfo& new_screen_info) { |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 1941 | bool orientation_changed = |
| 1942 | screen_info_.orientation_angle != new_screen_info.orientation_angle || |
| 1943 | screen_info_.orientation_type != new_screen_info.orientation_type; |
| 1944 | bool web_device_scale_factor_changed = |
| 1945 | screen_info_.device_scale_factor != new_screen_info.device_scale_factor; |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 1946 | ScreenInfo previous_original_screen_info = GetOriginalScreenInfo(); |
Christopher Cameron | be7ecea | 2018-02-27 00:47:19 | [diff] [blame] | 1947 | |
Fady Samuel | 4255c18 | 2018-05-24 20:42:36 | [diff] [blame] | 1948 | local_surface_id_from_parent_ = new_local_surface_id; |
Christopher Cameron | aad15a0d | 2018-03-09 03:47:33 | [diff] [blame] | 1949 | compositor_viewport_pixel_size_ = new_compositor_viewport_pixel_size; |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 1950 | screen_info_ = new_screen_info; |
Christopher Cameron | be7ecea | 2018-02-27 00:47:19 | [diff] [blame] | 1951 | |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1952 | if (layer_tree_view_) { |
| 1953 | layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect()); |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 1954 | // Note carefully that the DSF specified in |new_screen_info| is not the |
| 1955 | // DSF used by the compositor during device emulation! |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 1956 | layer_tree_view_->SetViewportSizeAndScale( |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 1957 | compositor_viewport_pixel_size_, |
Fady Samuel | 4255c18 | 2018-05-24 20:42:36 | [diff] [blame] | 1958 | GetOriginalScreenInfo().device_scale_factor, |
| 1959 | local_surface_id_from_parent_); |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 1960 | } |
Christopher Cameron | be7ecea | 2018-02-27 00:47:19 | [diff] [blame] | 1961 | |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 1962 | if (orientation_changed) |
| 1963 | OnOrientationChange(); |
Christopher Cameron | be7ecea | 2018-02-27 00:47:19 | [diff] [blame] | 1964 | |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 1965 | if (previous_original_screen_info != GetOriginalScreenInfo()) { |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 1966 | for (auto& observer : render_frame_proxies_) |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 1967 | observer.OnScreenInfoChanged(GetOriginalScreenInfo()); |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 1968 | |
| 1969 | // Notify all embedded BrowserPlugins of the updated ScreenInfo. |
| 1970 | for (auto& observer : browser_plugins_) |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 1971 | observer.ScreenInfoChanged(GetOriginalScreenInfo()); |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 1972 | } |
| 1973 | |
| 1974 | if (web_device_scale_factor_changed) |
Christopher Cameron | be7ecea | 2018-02-27 00:47:19 | [diff] [blame] | 1975 | UpdateWebViewWithDeviceScaleFactor(); |
oshima | d527903 | 2015-12-16 18:22:33 | [diff] [blame] | 1976 | } |
| 1977 | |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 1978 | void RenderWidget::SetWindowRectSynchronously( |
| 1979 | const gfx::Rect& new_window_rect) { |
| 1980 | VisualProperties visual_properties; |
| 1981 | visual_properties.screen_info = screen_info_; |
| 1982 | visual_properties.new_size = new_window_rect.size(); |
| 1983 | visual_properties.compositor_viewport_pixel_size = gfx::ScaleToCeiledSize( |
| 1984 | new_window_rect.size(), GetWebScreenInfo().device_scale_factor); |
| 1985 | visual_properties.visible_viewport_size = new_window_rect.size(); |
| 1986 | visual_properties.is_fullscreen_granted = is_fullscreen_granted_; |
| 1987 | visual_properties.display_mode = display_mode_; |
| 1988 | visual_properties.local_surface_id = local_surface_id_from_parent_; |
| 1989 | // We are resizing the window from the renderer, so allocate a new |
| 1990 | // viz::LocalSurfaceId to avoid surface invariants violations in tests. |
| 1991 | if (layer_tree_view_) |
| 1992 | layer_tree_view_->RequestNewLocalSurfaceId(); |
| 1993 | SynchronizeVisualProperties(visual_properties); |
| 1994 | |
| 1995 | view_screen_rect_ = new_window_rect; |
| 1996 | window_screen_rect_ = new_window_rect; |
| 1997 | if (!did_show_) |
| 1998 | initial_rect_ = new_window_rect; |
| 1999 | } |
| 2000 | |
Vladimir Levin | 98d76dad | 2018-04-21 00:21:29 | [diff] [blame] | 2001 | void RenderWidget::UpdateCaptureSequenceNumber( |
| 2002 | uint32_t capture_sequence_number) { |
| 2003 | if (capture_sequence_number == last_capture_sequence_number_) |
| 2004 | return; |
| 2005 | last_capture_sequence_number_ = capture_sequence_number; |
| 2006 | |
| 2007 | // Notify observers of the new capture sequence number. |
| 2008 | for (auto& observer : render_frame_proxies_) |
| 2009 | observer.UpdateCaptureSequenceNumber(capture_sequence_number); |
| 2010 | for (auto& observer : browser_plugins_) |
| 2011 | observer.UpdateCaptureSequenceNumber(capture_sequence_number); |
| 2012 | } |
| 2013 | |
[email protected] | 4873c7d | 2009-07-16 06:36:28 | [diff] [blame] | 2014 | void RenderWidget::OnSetTextDirection(WebTextDirection direction) { |
EhsanK | 955ba58 | 2017-11-30 21:14:40 | [diff] [blame] | 2015 | if (auto* frame = GetFocusedWebLocalFrameInWidget()) |
| 2016 | frame->SetTextDirection(direction); |
[email protected] | 07f95333 | 2009-03-25 04:31:11 | [diff] [blame] | 2017 | } |
| 2018 | |
[email protected] | 80ad862 | 2012-11-07 16:33:03 | [diff] [blame] | 2019 | void RenderWidget::OnUpdateScreenRects(const gfx::Rect& view_screen_rect, |
| 2020 | const gfx::Rect& window_screen_rect) { |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 2021 | if (screen_metrics_emulator_) { |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 2022 | screen_metrics_emulator_->OnUpdateScreenRects(view_screen_rect, |
| 2023 | window_screen_rect); |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 2024 | } else { |
mfomitchev | 2600fd7c | 2016-02-17 20:53:39 | [diff] [blame] | 2025 | SetScreenRects(view_screen_rect, window_screen_rect); |
[email protected] | b2e4c7013 | 2013-10-03 02:07:51 | [diff] [blame] | 2026 | } |
[email protected] | 80ad862 | 2012-11-07 16:33:03 | [diff] [blame] | 2027 | Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id())); |
| 2028 | } |
| 2029 | |
kenrb | ea73179 | 2017-01-13 15:10:48 | [diff] [blame] | 2030 | void RenderWidget::OnSetViewportIntersection( |
Ken Buchanan | b2c9e26 | 2018-03-10 16:53:31 | [diff] [blame] | 2031 | const gfx::Rect& viewport_intersection, |
| 2032 | const gfx::Rect& compositor_visible_rect) { |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2033 | if (auto* frame_widget = GetFrameWidget()) { |
Ken Buchanan | 8a319fb | 2017-11-15 18:37:12 | [diff] [blame] | 2034 | DCHECK_EQ(popup_type_, WebPopupType::kWebPopupTypeNone); |
Ken Buchanan | b2c9e26 | 2018-03-10 16:53:31 | [diff] [blame] | 2035 | compositor_visible_rect_ = compositor_visible_rect; |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2036 | frame_widget->SetRemoteViewportIntersection(viewport_intersection); |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 2037 | layer_tree_view_->SetViewportVisibleRect(ViewportVisibleRect()); |
kenrb | ea73179 | 2017-01-13 15:10:48 | [diff] [blame] | 2038 | } |
| 2039 | } |
| 2040 | |
kenrb | 0432378 | 2017-06-23 01:23:32 | [diff] [blame] | 2041 | void RenderWidget::OnSetIsInert(bool inert) { |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2042 | if (auto* frame_widget = GetFrameWidget()) { |
Ken Buchanan | 8a319fb | 2017-11-15 18:37:12 | [diff] [blame] | 2043 | DCHECK_EQ(popup_type_, WebPopupType::kWebPopupTypeNone); |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2044 | frame_widget->SetIsInert(inert); |
kenrb | 0432378 | 2017-06-23 01:23:32 | [diff] [blame] | 2045 | } |
| 2046 | } |
| 2047 | |
sunxd | 540a996 | 2018-05-24 22:51:06 | [diff] [blame] | 2048 | void RenderWidget::OnSetInheritedEffectiveTouchAction( |
| 2049 | cc::TouchAction touch_action) { |
| 2050 | if (auto* frame_widget = GetFrameWidget()) { |
| 2051 | DCHECK_EQ(popup_type_, WebPopupType::kWebPopupTypeNone); |
| 2052 | frame_widget->SetInheritedEffectiveTouchAction(touch_action); |
| 2053 | } |
| 2054 | } |
| 2055 | |
Ken Buchanan | 8a319fb | 2017-11-15 18:37:12 | [diff] [blame] | 2056 | void RenderWidget::OnUpdateRenderThrottlingStatus(bool is_throttled, |
| 2057 | bool subtree_throttled) { |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2058 | if (auto* frame_widget = GetFrameWidget()) { |
Ken Buchanan | 8a319fb | 2017-11-15 18:37:12 | [diff] [blame] | 2059 | DCHECK_EQ(popup_type_, WebPopupType::kWebPopupTypeNone); |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2060 | frame_widget->UpdateRenderThrottlingStatus(is_throttled, subtree_throttled); |
Ken Buchanan | 8a319fb | 2017-11-15 18:37:12 | [diff] [blame] | 2061 | } |
| 2062 | } |
| 2063 | |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 2064 | void RenderWidget::OnDragTargetDragEnter( |
| 2065 | const std::vector<DropData::Metadata>& drop_meta_data, |
Ella Ge | 80a52dce | 2017-11-15 18:01:52 | [diff] [blame] | 2066 | const gfx::PointF& client_point, |
| 2067 | const gfx::PointF& screen_point, |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 2068 | WebDragOperationsMask ops, |
| 2069 | int key_modifiers) { |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2070 | blink::WebFrameWidget* frame_widget = GetFrameWidget(); |
| 2071 | if (!frame_widget) |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 2072 | return; |
| 2073 | |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2074 | WebDragOperation operation = frame_widget->DragTargetDragEnter( |
| 2075 | DropMetaDataToWebDragData(drop_meta_data), client_point, screen_point, |
| 2076 | ops, key_modifiers); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 2077 | |
| 2078 | Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation)); |
| 2079 | } |
| 2080 | |
Ella Ge | 80a52dce | 2017-11-15 18:01:52 | [diff] [blame] | 2081 | void RenderWidget::OnDragTargetDragOver(const gfx::PointF& client_point, |
| 2082 | const gfx::PointF& screen_point, |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 2083 | WebDragOperationsMask ops, |
| 2084 | int key_modifiers) { |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2085 | blink::WebFrameWidget* frame_widget = GetFrameWidget(); |
| 2086 | if (!frame_widget) |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 2087 | return; |
| 2088 | |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2089 | WebDragOperation operation = frame_widget->DragTargetDragOver( |
| 2090 | ConvertWindowPointToViewport(client_point), screen_point, ops, |
| 2091 | key_modifiers); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 2092 | |
| 2093 | Send(new DragHostMsg_UpdateDragCursor(routing_id(), operation)); |
| 2094 | } |
| 2095 | |
Ella Ge | 80a52dce | 2017-11-15 18:01:52 | [diff] [blame] | 2096 | void RenderWidget::OnDragTargetDragLeave(const gfx::PointF& client_point, |
| 2097 | const gfx::PointF& screen_point) { |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2098 | blink::WebFrameWidget* frame_widget = GetFrameWidget(); |
| 2099 | if (!frame_widget) |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 2100 | return; |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2101 | |
| 2102 | frame_widget |
| 2103 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2104 | ->DragTargetDragLeave(ConvertWindowPointToViewport(client_point), |
kenrb | 07c27280 | 2017-02-07 23:48:17 | [diff] [blame] | 2105 | screen_point); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 2106 | } |
| 2107 | |
| 2108 | void RenderWidget::OnDragTargetDrop(const DropData& drop_data, |
Ella Ge | 80a52dce | 2017-11-15 18:01:52 | [diff] [blame] | 2109 | const gfx::PointF& client_point, |
| 2110 | const gfx::PointF& screen_point, |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 2111 | int key_modifiers) { |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2112 | blink::WebFrameWidget* frame_widget = GetFrameWidget(); |
| 2113 | if (!frame_widget) |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 2114 | return; |
| 2115 | |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2116 | frame_widget->DragTargetDrop(DropDataToWebDragData(drop_data), |
| 2117 | ConvertWindowPointToViewport(client_point), |
| 2118 | screen_point, key_modifiers); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 2119 | } |
| 2120 | |
Ella Ge | 80a52dce | 2017-11-15 18:01:52 | [diff] [blame] | 2121 | void RenderWidget::OnDragSourceEnded(const gfx::PointF& client_point, |
| 2122 | const gfx::PointF& screen_point, |
paulmeyer | 8fc8ea9 | 2016-11-15 05:12:21 | [diff] [blame] | 2123 | WebDragOperation op) { |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2124 | blink::WebFrameWidget* frame_widget = GetFrameWidget(); |
| 2125 | if (!frame_widget) |
paulmeyer | 8fc8ea9 | 2016-11-15 05:12:21 | [diff] [blame] | 2126 | return; |
| 2127 | |
Ehsan Karamad | f3ca2a8 | 2018-01-20 01:05:25 | [diff] [blame] | 2128 | frame_widget->DragSourceEndedAt(ConvertWindowPointToViewport(client_point), |
| 2129 | screen_point, op); |
paulmeyer | 8fc8ea9 | 2016-11-15 05:12:21 | [diff] [blame] | 2130 | } |
| 2131 | |
| 2132 | void RenderWidget::OnDragSourceSystemDragEnded() { |
| 2133 | if (!GetWebWidget()) |
| 2134 | return; |
| 2135 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2136 | static_cast<WebFrameWidget*>(GetWebWidget())->DragSourceSystemDragEnded(); |
paulmeyer | 8fc8ea9 | 2016-11-15 05:12:21 | [diff] [blame] | 2137 | } |
| 2138 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2139 | void RenderWidget::ShowVirtualKeyboardOnElementFocus() { |
oka | a398f50b | 2017-03-21 06:30:26 | [diff] [blame] | 2140 | #if defined(OS_CHROMEOS) |
| 2141 | // On ChromeOS, virtual keyboard is triggered only when users leave the |
| 2142 | // mouse button or the finger and a text input element is focused at that |
| 2143 | // time. Focus event itself shouldn't trigger virtual keyboard. |
| 2144 | UpdateTextInputState(); |
| 2145 | #else |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 2146 | ShowVirtualKeyboard(); |
oka | a398f50b | 2017-03-21 06:30:26 | [diff] [blame] | 2147 | #endif |
boliu | 7b2be2f | 2016-11-04 04:58:31 | [diff] [blame] | 2148 | |
| 2149 | // TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with |
| 2150 | // virtual keyboard. |
| 2151 | #if !defined(OS_ANDROID) |
| 2152 | FocusChangeComplete(); |
| 2153 | #endif |
[email protected] | 0d1ebed1 | 2013-08-05 22:01:13 | [diff] [blame] | 2154 | } |
| 2155 | |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 2156 | ui::TextInputType RenderWidget::GetTextInputType() { |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 2157 | #if BUILDFLAG(ENABLE_PLUGINS) |
EhsanK | 22d482e | 2017-08-10 17:29:49 | [diff] [blame] | 2158 | if (auto* plugin = GetFocusedPepperPluginInsideWidget()) |
| 2159 | return plugin->text_input_type(); |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2160 | #endif |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 2161 | if (auto* controller = GetInputMethodController()) |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2162 | return ConvertWebTextInputType(controller->TextInputType()); |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 2163 | return ui::TEXT_INPUT_TYPE_NONE; |
| 2164 | } |
| 2165 | |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 2166 | void RenderWidget::UpdateCompositionInfo(bool immediate_request) { |
| 2167 | if (!monitor_composition_info_ && !immediate_request) |
| 2168 | return; // Do not calculate composition info if not requested. |
nona | dac0c7a | 2016-08-01 02:30:59 | [diff] [blame] | 2169 | |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 2170 | TRACE_EVENT0("renderer", "RenderWidget::UpdateCompositionInfo"); |
| 2171 | gfx::Range range; |
| 2172 | std::vector<gfx::Rect> character_bounds; |
| 2173 | |
| 2174 | if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE) { |
| 2175 | // Composition information is only available on editable node. |
| 2176 | range = gfx::Range::InvalidRange(); |
| 2177 | } else { |
| 2178 | GetCompositionRange(&range); |
| 2179 | GetCompositionCharacterBounds(&character_bounds); |
| 2180 | } |
| 2181 | |
| 2182 | if (!immediate_request && |
| 2183 | !ShouldUpdateCompositionInfo(range, character_bounds)) { |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 2184 | return; |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 2185 | } |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 2186 | composition_character_bounds_ = character_bounds; |
| 2187 | composition_range_ = range; |
Dave Tapuska | 04bc5ee9 | 2018-04-17 19:03:31 | [diff] [blame] | 2188 | if (mojom::WidgetInputHandlerHost* host = |
| 2189 | widget_input_handler_manager_->GetWidgetInputHandlerHost()) { |
| 2190 | host->ImeCompositionRangeChanged(composition_range_, |
| 2191 | composition_character_bounds_); |
Dave Tapuska | 139a72f | 2017-09-06 21:57:03 | [diff] [blame] | 2192 | } |
fsamuel | 72464894f | 2015-12-15 06:59:31 | [diff] [blame] | 2193 | } |
| 2194 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2195 | void RenderWidget::ConvertViewportToWindow(blink::WebRect* rect) { |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 2196 | if (compositor_deps_->IsUseZoomForDSFEnabled()) { |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 2197 | float reverse = 1 / GetOriginalScreenInfo().device_scale_factor; |
oshima | d527903 | 2015-12-16 18:22:33 | [diff] [blame] | 2198 | // TODO(oshima): We may need to allow pixel precision here as the the |
oshima | f866dab | 2015-12-05 00:41:54 | [diff] [blame] | 2199 | // anchor element can be placed at half pixel. |
lfg | 15b235a3 | 2016-08-25 17:45:46 | [diff] [blame] | 2200 | gfx::Rect window_rect = |
| 2201 | gfx::ScaleToEnclosedRect(gfx::Rect(*rect), reverse); |
| 2202 | rect->x = window_rect.x(); |
| 2203 | rect->y = window_rect.y(); |
| 2204 | rect->width = window_rect.width(); |
| 2205 | rect->height = window_rect.height(); |
oshima | f866dab | 2015-12-05 00:41:54 | [diff] [blame] | 2206 | } |
| 2207 | } |
| 2208 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2209 | void RenderWidget::ConvertWindowToViewport(blink::WebFloatRect* rect) { |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 2210 | if (compositor_deps_->IsUseZoomForDSFEnabled()) { |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 2211 | rect->x *= GetOriginalScreenInfo().device_scale_factor; |
| 2212 | rect->y *= GetOriginalScreenInfo().device_scale_factor; |
| 2213 | rect->width *= GetOriginalScreenInfo().device_scale_factor; |
| 2214 | rect->height *= GetOriginalScreenInfo().device_scale_factor; |
oshima | a6985b6 | 2016-01-27 08:58:30 | [diff] [blame] | 2215 | } |
| 2216 | } |
| 2217 | |
changwan | 8c34274 | 2016-02-26 00:53:39 | [diff] [blame] | 2218 | void RenderWidget::OnRequestTextInputStateUpdate() { |
Dave Tapuska | 9db8084 | 2017-07-24 17:24:26 | [diff] [blame] | 2219 | #if defined(OS_ANDROID) |
changwan | 8c34274 | 2016-02-26 00:53:39 | [diff] [blame] | 2220 | DCHECK(!ime_event_guard_); |
| 2221 | UpdateSelectionBounds(); |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 2222 | UpdateTextInputStateInternal(false, true /* reply_to_request */); |
[email protected] | 105dffb4 | 2013-02-20 03:46:21 | [diff] [blame] | 2223 | #endif |
Dave Tapuska | 9db8084 | 2017-07-24 17:24:26 | [diff] [blame] | 2224 | } |
[email protected] | 105dffb4 | 2013-02-20 03:46:21 | [diff] [blame] | 2225 | |
ekaramad | c9b70a7 | 2017-03-23 16:14:23 | [diff] [blame] | 2226 | void RenderWidget::OnRequestCompositionUpdates(bool immediate_request, |
| 2227 | bool monitor_updates) { |
| 2228 | monitor_composition_info_ = monitor_updates; |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 2229 | if (!immediate_request) |
| 2230 | return; |
| 2231 | UpdateCompositionInfo(true /* immediate request */); |
| 2232 | } |
| 2233 | |
[email protected] | fcdc564 | 2014-05-09 14:32:24 | [diff] [blame] | 2234 | void RenderWidget::OnOrientationChange() { |
Ehsan Karamad | 655d7b8a | 2018-01-12 18:38:38 | [diff] [blame] | 2235 | if (auto* frame_widget = GetFrameWidget()) { |
Alex Moshchuk | 0b409c4 | 2017-09-13 02:09:00 | [diff] [blame] | 2236 | // LocalRoot() might return null for provisional main frames. In this case, |
| 2237 | // the frame hasn't committed a navigation and is not swapped into the tree |
| 2238 | // yet, so it doesn't make sense to send orientation change events to it. |
| 2239 | // |
| 2240 | // TODO(https://crbug.com/578349): This check should be cleaned up |
| 2241 | // once provisional frames are gone. |
Ehsan Karamad | 655d7b8a | 2018-01-12 18:38:38 | [diff] [blame] | 2242 | if (frame_widget->LocalRoot()) |
| 2243 | frame_widget->LocalRoot()->SendOrientationChangeEvent(); |
lfg | 8d649cc | 2017-04-28 18:04:30 | [diff] [blame] | 2244 | } |
[email protected] | fcdc564 | 2014-05-09 14:32:24 | [diff] [blame] | 2245 | } |
| 2246 | |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 2247 | GURL RenderWidget::GetURLForGraphicsContext3D() { |
| 2248 | if (owner_delegate_) |
| 2249 | return owner_delegate_->GetURLForGraphicsContext3DForWidget(); |
| 2250 | return GURL(); |
| 2251 | } |
| 2252 | |
[email protected] | bee16aab | 2009-08-26 15:55:03 | [diff] [blame] | 2253 | void RenderWidget::SetHidden(bool hidden) { |
| 2254 | if (is_hidden_ == hidden) |
| 2255 | return; |
| 2256 | |
jdduke | 8fac9d10 | 2014-12-20 02:40:13 | [diff] [blame] | 2257 | // The status has changed. Tell the RenderThread about it and ensure |
| 2258 | // throttled acks are released in case frame production ceases. |
[email protected] | bee16aab | 2009-08-26 15:55:03 | [diff] [blame] | 2259 | is_hidden_ = hidden; |
jdduke | 8fac9d10 | 2014-12-20 02:40:13 | [diff] [blame] | 2260 | |
Scott Violet | 1098538e | 2017-10-05 19:23:33 | [diff] [blame] | 2261 | #if defined(USE_AURA) |
Scott Violet | 6fca131 | 2018-06-15 16:27:26 | [diff] [blame] | 2262 | if (!features::IsAshInBrowserProcess()) |
Scott Violet | 1098538e | 2017-10-05 19:23:33 | [diff] [blame] | 2263 | RendererWindowTreeClient::Get(routing_id_)->SetVisible(!hidden); |
| 2264 | #endif |
| 2265 | |
Saman Sami | 58ed439 | 2018-01-31 20:54:19 | [diff] [blame] | 2266 | // RenderThreadImpl::current() could be null in tests. |
| 2267 | if (RenderThreadImpl::current()) { |
| 2268 | if (is_hidden_) { |
| 2269 | RenderThreadImpl::current()->WidgetHidden(); |
| 2270 | first_update_visual_state_after_hidden_ = true; |
| 2271 | } else { |
| 2272 | RenderThreadImpl::current()->WidgetRestored(); |
| 2273 | } |
Lei Zhang | 9b359d3 | 2017-11-28 00:57:02 | [diff] [blame] | 2274 | } |
alexclarke | 7fa9394 | 2015-10-21 15:37:11 | [diff] [blame] | 2275 | |
| 2276 | if (render_widget_scheduling_state_) |
| 2277 | render_widget_scheduling_state_->SetHidden(hidden); |
[email protected] | bee16aab | 2009-08-26 15:55:03 | [diff] [blame] | 2278 | } |
| 2279 | |
[email protected] | 2b624c56 | 2011-10-27 22:58:26 | [diff] [blame] | 2280 | void RenderWidget::DidToggleFullscreen() { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 2281 | if (!GetWebWidget()) |
[email protected] | 2b624c56 | 2011-10-27 22:58:26 | [diff] [blame] | 2282 | return; |
| 2283 | |
mikhail.pozdnyakov | f2c902a | 2015-04-14 08:09:12 | [diff] [blame] | 2284 | if (is_fullscreen_granted_) { |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2285 | GetWebWidget()->DidEnterFullscreen(); |
[email protected] | 2b624c56 | 2011-10-27 22:58:26 | [diff] [blame] | 2286 | } else { |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2287 | GetWebWidget()->DidExitFullscreen(); |
[email protected] | 2b624c56 | 2011-10-27 22:58:26 | [diff] [blame] | 2288 | } |
[email protected] | 2b624c56 | 2011-10-27 22:58:26 | [diff] [blame] | 2289 | } |
| 2290 | |
changwan | f2a707b | 2015-10-30 08:22:16 | [diff] [blame] | 2291 | void RenderWidget::OnImeEventGuardStart(ImeEventGuard* guard) { |
| 2292 | if (!ime_event_guard_) |
| 2293 | ime_event_guard_ = guard; |
[email protected] | 66fca5bc | 2013-05-23 06:58:29 | [diff] [blame] | 2294 | } |
| 2295 | |
changwan | f2a707b | 2015-10-30 08:22:16 | [diff] [blame] | 2296 | void RenderWidget::OnImeEventGuardFinish(ImeEventGuard* guard) { |
| 2297 | if (ime_event_guard_ != guard) { |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 2298 | DCHECK(!ime_event_guard_->reply_to_request()); |
changwan | f2a707b | 2015-10-30 08:22:16 | [diff] [blame] | 2299 | return; |
| 2300 | } |
| 2301 | ime_event_guard_ = nullptr; |
| 2302 | |
[email protected] | 66fca5bc | 2013-05-23 06:58:29 | [diff] [blame] | 2303 | // While handling an ime event, text input state and selection bounds updates |
| 2304 | // are ignored. These must explicitly be updated once finished handling the |
| 2305 | // ime event. |
| 2306 | UpdateSelectionBounds(); |
[email protected] | cb9e263 | 2013-06-18 11:26:47 | [diff] [blame] | 2307 | #if defined(OS_ANDROID) |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 2308 | if (guard->show_virtual_keyboard()) |
| 2309 | ShowVirtualKeyboard(); |
| 2310 | else |
| 2311 | UpdateTextInputState(); |
[email protected] | cb9e263 | 2013-06-18 11:26:47 | [diff] [blame] | 2312 | #endif |
[email protected] | 66fca5bc | 2013-05-23 06:58:29 | [diff] [blame] | 2313 | } |
| 2314 | |
[email protected] | 7c8873e | 2013-02-05 08:03:01 | [diff] [blame] | 2315 | void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) { |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 2316 | #if BUILDFLAG(ENABLE_PLUGINS) |
EhsanK | 22d482e | 2017-08-10 17:29:49 | [diff] [blame] | 2317 | if (auto* plugin = GetFocusedPepperPluginInsideWidget()) { |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2318 | // TODO(kinaba) http://crbug.com/101101 |
| 2319 | // Current Pepper IME API does not handle selection bounds. So we simply |
| 2320 | // use the caret position as an empty range for now. It will be updated |
| 2321 | // after Pepper API equips features related to surrounding text retrieval. |
EhsanK | 22d482e | 2017-08-10 17:29:49 | [diff] [blame] | 2322 | blink::WebRect caret(plugin->GetCaretBounds()); |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2323 | ConvertViewportToWindow(&caret); |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2324 | *focus = caret; |
| 2325 | *anchor = caret; |
| 2326 | return; |
| 2327 | } |
| 2328 | #endif |
[email protected] | 7c8873e | 2013-02-05 08:03:01 | [diff] [blame] | 2329 | WebRect focus_webrect; |
| 2330 | WebRect anchor_webrect; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2331 | GetWebWidget()->SelectionBounds(focus_webrect, anchor_webrect); |
| 2332 | ConvertViewportToWindow(&focus_webrect); |
| 2333 | ConvertViewportToWindow(&anchor_webrect); |
oshima | 33ec97cd | 2015-12-14 19:40:24 | [diff] [blame] | 2334 | *focus = focus_webrect; |
| 2335 | *anchor = anchor_webrect; |
[email protected] | 73bf9581 | 2011-10-12 11:38:32 | [diff] [blame] | 2336 | } |
| 2337 | |
[email protected] | e99ef6f | 2011-10-16 01:13:00 | [diff] [blame] | 2338 | void RenderWidget::UpdateSelectionBounds() { |
jdduke | 1aebad8e | 2015-07-22 23:25:08 | [diff] [blame] | 2339 | TRACE_EVENT0("renderer", "RenderWidget::UpdateSelectionBounds"); |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 2340 | if (!GetWebWidget()) |
[email protected] | e99ef6f | 2011-10-16 01:13:00 | [diff] [blame] | 2341 | return; |
changwan | f2a707b | 2015-10-30 08:22:16 | [diff] [blame] | 2342 | if (ime_event_guard_) |
[email protected] | 66fca5bc | 2013-05-23 06:58:29 | [diff] [blame] | 2343 | return; |
[email protected] | e99ef6f | 2011-10-16 01:13:00 | [diff] [blame] | 2344 | |
mohsen | b0eeba7 | 2015-08-09 06:20:08 | [diff] [blame] | 2345 | #if defined(USE_AURA) |
| 2346 | // TODO(mohsen): For now, always send explicit selection IPC notifications for |
| 2347 | // Aura beucause composited selection updates are not working for webview tags |
| 2348 | // which regresses IME inside webview. Remove this when composited selection |
| 2349 | // updates are fixed for webviews. See, http://crbug.com/510568. |
| 2350 | bool send_ipc = true; |
| 2351 | #else |
jdduke | acf809e | 2014-09-23 20:38:38 | [diff] [blame] | 2352 | // With composited selection updates, the selection bounds will be reported |
| 2353 | // directly by the compositor, in which case explicit IPC selection |
| 2354 | // notifications should be suppressed. |
mohsen | b0eeba7 | 2015-08-09 06:20:08 | [diff] [blame] | 2355 | bool send_ipc = |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2356 | !blink::WebRuntimeFeatures::IsCompositedSelectionUpdateEnabled(); |
mohsen | b0eeba7 | 2015-08-09 06:20:08 | [diff] [blame] | 2357 | #endif |
| 2358 | if (send_ipc) { |
jdduke | acf809e | 2014-09-23 20:38:38 | [diff] [blame] | 2359 | ViewHostMsg_SelectionBounds_Params params; |
EhsanK | 955ba58 | 2017-11-30 21:14:40 | [diff] [blame] | 2360 | params.is_anchor_first = false; |
jdduke | acf809e | 2014-09-23 20:38:38 | [diff] [blame] | 2361 | GetSelectionBounds(¶ms.anchor_rect, ¶ms.focus_rect); |
| 2362 | if (selection_anchor_rect_ != params.anchor_rect || |
| 2363 | selection_focus_rect_ != params.focus_rect) { |
| 2364 | selection_anchor_rect_ = params.anchor_rect; |
| 2365 | selection_focus_rect_ = params.focus_rect; |
EhsanK | 955ba58 | 2017-11-30 21:14:40 | [diff] [blame] | 2366 | if (auto* focused_frame = GetFocusedWebLocalFrameInWidget()) { |
| 2367 | focused_frame->SelectionTextDirection(params.focus_dir, |
| 2368 | params.anchor_dir); |
| 2369 | params.is_anchor_first = focused_frame->IsSelectionAnchorFirst(); |
| 2370 | } |
jdduke | acf809e | 2014-09-23 20:38:38 | [diff] [blame] | 2371 | Send(new ViewHostMsg_SelectionBoundsChanged(routing_id_, params)); |
| 2372 | } |
[email protected] | 58b48a0d | 2012-06-13 07:01:35 | [diff] [blame] | 2373 | } |
jdduke | acf809e | 2014-09-23 20:38:38 | [diff] [blame] | 2374 | |
nona | fa29179 | 2016-08-10 02:36:18 | [diff] [blame] | 2375 | UpdateCompositionInfo(false /* not an immediate request */); |
[email protected] | e99ef6f | 2011-10-16 01:13:00 | [diff] [blame] | 2376 | } |
| 2377 | |
lfg | b00fcad | 2016-07-14 14:16:33 | [diff] [blame] | 2378 | void RenderWidget::DidAutoResize(const gfx::Size& new_size) { |
| 2379 | WebRect new_size_in_window(0, 0, new_size.width(), new_size.height()); |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2380 | ConvertViewportToWindow(&new_size_in_window); |
lfg | b00fcad | 2016-07-14 14:16:33 | [diff] [blame] | 2381 | if (size_.width() != new_size_in_window.width || |
| 2382 | size_.height() != new_size_in_window.height) { |
| 2383 | size_ = gfx::Size(new_size_in_window.width, new_size_in_window.height); |
| 2384 | |
| 2385 | if (resizing_mode_selector_->is_synchronous_mode()) { |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2386 | gfx::Rect new_pos(WindowRect().x, WindowRect().y, size_.width(), |
| 2387 | size_.height()); |
lfg | b00fcad | 2016-07-14 14:16:33 | [diff] [blame] | 2388 | view_screen_rect_ = new_pos; |
| 2389 | window_screen_rect_ = new_pos; |
| 2390 | } |
| 2391 | |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 2392 | // TODO(ccameron): Note that this destroys any information differentiating |
Christopher Cameron | aad15a0d | 2018-03-09 03:47:33 | [diff] [blame] | 2393 | // |size_| from |compositor_viewport_pixel_size_|. Also note that the |
| 2394 | // calculation of |new_compositor_viewport_pixel_size| does not appear to |
| 2395 | // take into account device emulation. |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 2396 | if (layer_tree_view_) |
| 2397 | layer_tree_view_->RequestNewLocalSurfaceId(); |
Christopher Cameron | aad15a0d | 2018-03-09 03:47:33 | [diff] [blame] | 2398 | gfx::Size new_compositor_viewport_pixel_size = |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 2399 | gfx::ScaleToCeiledSize(size_, GetWebScreenInfo().device_scale_factor); |
Fady Samuel | 4255c18 | 2018-05-24 20:42:36 | [diff] [blame] | 2400 | UpdateSurfaceAndScreenInfo(local_surface_id_from_parent_, |
| 2401 | new_compositor_viewport_pixel_size, |
| 2402 | screen_info_); |
lfg | b00fcad | 2016-07-14 14:16:33 | [diff] [blame] | 2403 | } |
| 2404 | } |
| 2405 | |
[email protected] | 58b48a0d | 2012-06-13 07:01:35 | [diff] [blame] | 2406 | void RenderWidget::GetCompositionCharacterBounds( |
| 2407 | std::vector<gfx::Rect>* bounds) { |
| 2408 | DCHECK(bounds); |
| 2409 | bounds->clear(); |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2410 | |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 2411 | #if BUILDFLAG(ENABLE_PLUGINS) |
EhsanK | 22d482e | 2017-08-10 17:29:49 | [diff] [blame] | 2412 | if (GetFocusedPepperPluginInsideWidget()) |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2413 | return; |
| 2414 | #endif |
| 2415 | |
Ehsan Karamad | 4975af6d | 2018-02-09 16:58:16 | [diff] [blame] | 2416 | blink::WebInputMethodController* controller = GetInputMethodController(); |
| 2417 | if (!controller) |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2418 | return; |
| 2419 | blink::WebVector<blink::WebRect> bounds_from_blink; |
Ehsan Karamad | 4975af6d | 2018-02-09 16:58:16 | [diff] [blame] | 2420 | if (!controller->GetCompositionCharacterBounds(bounds_from_blink)) |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2421 | return; |
| 2422 | |
| 2423 | for (size_t i = 0; i < bounds_from_blink.size(); ++i) { |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2424 | ConvertViewportToWindow(&bounds_from_blink[i]); |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2425 | bounds->push_back(bounds_from_blink[i]); |
| 2426 | } |
[email protected] | 58b48a0d | 2012-06-13 07:01:35 | [diff] [blame] | 2427 | } |
| 2428 | |
[email protected] | db4fc1e | 2013-09-06 20:01:51 | [diff] [blame] | 2429 | void RenderWidget::GetCompositionRange(gfx::Range* range) { |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 2430 | #if BUILDFLAG(ENABLE_PLUGINS) |
EhsanK | 22d482e | 2017-08-10 17:29:49 | [diff] [blame] | 2431 | if (GetFocusedPepperPluginInsideWidget()) |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2432 | return; |
| 2433 | #endif |
EhsanK | cdee7b7 | 2017-11-08 21:30:09 | [diff] [blame] | 2434 | blink::WebInputMethodController* controller = GetInputMethodController(); |
| 2435 | WebRange web_range = controller ? controller->CompositionRange() : WebRange(); |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2436 | if (web_range.IsNull()) { |
nona | 2363a3d | 2016-11-09 03:26:21 | [diff] [blame] | 2437 | *range = gfx::Range::InvalidRange(); |
| 2438 | return; |
[email protected] | 88dbe32f | 2013-06-20 23:31:36 | [diff] [blame] | 2439 | } |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2440 | range->set_start(web_range.StartOffset()); |
| 2441 | range->set_end(web_range.EndOffset()); |
[email protected] | 88dbe32f | 2013-06-20 23:31:36 | [diff] [blame] | 2442 | } |
| 2443 | |
[email protected] | 501ea13d | 2013-07-09 17:03:29 | [diff] [blame] | 2444 | bool RenderWidget::ShouldUpdateCompositionInfo( |
[email protected] | db4fc1e | 2013-09-06 20:01:51 | [diff] [blame] | 2445 | const gfx::Range& range, |
[email protected] | 501ea13d | 2013-07-09 17:03:29 | [diff] [blame] | 2446 | const std::vector<gfx::Rect>& bounds) { |
changwan | 2418e1b | 2016-12-12 12:43:08 | [diff] [blame] | 2447 | if (!range.IsValid()) |
| 2448 | return false; |
[email protected] | 501ea13d | 2013-07-09 17:03:29 | [diff] [blame] | 2449 | if (composition_range_ != range) |
| 2450 | return true; |
| 2451 | if (bounds.size() != composition_character_bounds_.size()) |
| 2452 | return true; |
| 2453 | for (size_t i = 0; i < bounds.size(); ++i) { |
| 2454 | if (bounds[i] != composition_character_bounds_[i]) |
| 2455 | return true; |
| 2456 | } |
| 2457 | return false; |
| 2458 | } |
[email protected] | 501ea13d | 2013-07-09 17:03:29 | [diff] [blame] | 2459 | |
[email protected] | ad26ef4 | 2011-06-17 07:59:45 | [diff] [blame] | 2460 | bool RenderWidget::CanComposeInline() { |
brettw | 4b46108 | 2016-11-19 18:55:16 | [diff] [blame] | 2461 | #if BUILDFLAG(ENABLE_PLUGINS) |
EhsanK | 22d482e | 2017-08-10 17:29:49 | [diff] [blame] | 2462 | if (auto* plugin = GetFocusedPepperPluginInsideWidget()) |
| 2463 | return plugin->IsPluginAcceptingCompositionEvents(); |
ekaramad | 2a46d63 | 2016-07-19 13:33:09 | [diff] [blame] | 2464 | #endif |
[email protected] | ad26ef4 | 2011-06-17 07:59:45 | [diff] [blame] | 2465 | return true; |
[email protected] | 56ea1a6 | 2011-05-30 07:05:57 | [diff] [blame] | 2466 | } |
| 2467 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2468 | blink::WebScreenInfo RenderWidget::GetScreenInfo() { |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 2469 | blink::WebScreenInfo web_screen_info; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2470 | web_screen_info.device_scale_factor = screen_info_.device_scale_factor; |
ccameron | ab0aab8 | 2017-06-24 17:21:54 | [diff] [blame] | 2471 | web_screen_info.color_space = screen_info_.color_space; |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 2472 | web_screen_info.depth = screen_info_.depth; |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2473 | web_screen_info.depth_per_component = screen_info_.depth_per_component; |
| 2474 | web_screen_info.is_monochrome = screen_info_.is_monochrome; |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 2475 | web_screen_info.rect = blink::WebRect(screen_info_.rect); |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2476 | web_screen_info.available_rect = blink::WebRect(screen_info_.available_rect); |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 2477 | switch (screen_info_.orientation_type) { |
| 2478 | case SCREEN_ORIENTATION_VALUES_PORTRAIT_PRIMARY: |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2479 | web_screen_info.orientation_type = |
| 2480 | blink::kWebScreenOrientationPortraitPrimary; |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 2481 | break; |
| 2482 | case SCREEN_ORIENTATION_VALUES_PORTRAIT_SECONDARY: |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2483 | web_screen_info.orientation_type = |
| 2484 | blink::kWebScreenOrientationPortraitSecondary; |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 2485 | break; |
| 2486 | case SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY: |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2487 | web_screen_info.orientation_type = |
| 2488 | blink::kWebScreenOrientationLandscapePrimary; |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 2489 | break; |
| 2490 | case SCREEN_ORIENTATION_VALUES_LANDSCAPE_SECONDARY: |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2491 | web_screen_info.orientation_type = |
| 2492 | blink::kWebScreenOrientationLandscapeSecondary; |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 2493 | break; |
| 2494 | default: |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2495 | web_screen_info.orientation_type = blink::kWebScreenOrientationUndefined; |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 2496 | break; |
| 2497 | } |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2498 | web_screen_info.orientation_angle = screen_info_.orientation_angle; |
Fady Samuel | 85a1bf7 | 2017-10-27 14:30:20 | [diff] [blame] | 2499 | |
ccameron | 2f45153 | 2016-09-07 21:49:27 | [diff] [blame] | 2500 | return web_screen_info; |
[email protected] | 4873c7d | 2009-07-16 06:36:28 | [diff] [blame] | 2501 | } |
| 2502 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2503 | void RenderWidget::DidHandleGestureEvent(const WebGestureEvent& event, |
| 2504 | bool event_cancelled) { |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 2505 | if (event_cancelled) { |
| 2506 | // The |owner_delegate_| doesn't need to hear about cancelled events. |
[email protected] | c68c3e4e | 2013-01-24 00:36:56 | [diff] [blame] | 2507 | return; |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 2508 | } |
| 2509 | |
| 2510 | #if defined(OS_ANDROID) || defined(USE_AURA) |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2511 | if (event.GetType() == WebInputEvent::kGestureTap) { |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 2512 | ShowVirtualKeyboard(); |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2513 | } else if (event.GetType() == WebInputEvent::kGestureLongPress) { |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 2514 | DCHECK(GetWebWidget()); |
ekaramad | 5aff194 | 2017-01-06 01:26:35 | [diff] [blame] | 2515 | blink::WebInputMethodController* controller = GetInputMethodController(); |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2516 | if (!controller || controller->TextInputInfo().value.IsEmpty()) |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 2517 | UpdateTextInputState(); |
[email protected] | 07c70d2 | 2014-08-21 08:33:46 | [diff] [blame] | 2518 | else |
changwan | 75e3b207 | 2017-01-16 02:55:00 | [diff] [blame] | 2519 | ShowVirtualKeyboard(); |
[email protected] | c68c3e4e | 2013-01-24 00:36:56 | [diff] [blame] | 2520 | } |
ekaramad | a110f64 | 2016-12-21 19:47:28 | [diff] [blame] | 2521 | // TODO(ananta): Piggyback off existing IPCs to communicate this information, |
| 2522 | // crbug/420130. |
| 2523 | #if defined(OS_WIN) |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 2524 | if (event.GetType() == blink::WebGestureEvent::kGestureTap) { |
| 2525 | // TODO(estade): hit test the event against focused node to make sure |
| 2526 | // the tap actually hit the focused node. |
| 2527 | blink::WebInputMethodController* controller = GetInputMethodController(); |
| 2528 | blink::WebTextInputType text_input_type = |
| 2529 | controller ? controller->TextInputType() : blink::kWebTextInputTypeNone; |
ekaramad | a110f64 | 2016-12-21 19:47:28 | [diff] [blame] | 2530 | |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 2531 | Send(new ViewHostMsg_FocusedNodeTouched( |
| 2532 | routing_id_, text_input_type != blink::kWebTextInputTypeNone)); |
| 2533 | } |
ekaramad | a110f64 | 2016-12-21 19:47:28 | [diff] [blame] | 2534 | #endif |
[email protected] | c68c3e4e | 2013-01-24 00:36:56 | [diff] [blame] | 2535 | #endif |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 2536 | |
| 2537 | // The |owner_delegate_| gets to respond to handling gestures last. |
| 2538 | if (owner_delegate_) |
| 2539 | owner_delegate_->DidHandleGestureEventForWidget(event); |
[email protected] | c68c3e4e | 2013-01-24 00:36:56 | [diff] [blame] | 2540 | } |
| 2541 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2542 | void RenderWidget::DidOverscroll( |
bokan | e53a10f | 2016-04-13 23:48:31 | [diff] [blame] | 2543 | const blink::WebFloatSize& overscrollDelta, |
| 2544 | const blink::WebFloatSize& accumulatedOverscroll, |
sataya.m | 582c9ce | 2015-06-09 08:03:42 | [diff] [blame] | 2545 | const blink::WebFloatPoint& position, |
sunyunjia | bbea8a9 | 2017-08-31 11:18:54 | [diff] [blame] | 2546 | const blink::WebFloatSize& velocity, |
danakj | e819b62 | 2018-05-01 20:27:14 | [diff] [blame] | 2547 | const cc::OverscrollBehavior& behavior) { |
bokan | 731ec38 | 2016-04-07 03:16:48 | [diff] [blame] | 2548 | #if defined(OS_MACOSX) |
| 2549 | // On OSX the user can disable the elastic overscroll effect. If that's the |
| 2550 | // case, don't forward the overscroll notification. |
| 2551 | DCHECK(compositor_deps()); |
| 2552 | if (!compositor_deps()->IsElasticOverscrollEnabled()) |
| 2553 | return; |
| 2554 | #endif |
bokan | e53a10f | 2016-04-13 23:48:31 | [diff] [blame] | 2555 | input_handler_->DidOverscrollFromBlink(overscrollDelta, accumulatedOverscroll, |
sunyunjia | bbea8a9 | 2017-08-31 11:18:54 | [diff] [blame] | 2556 | position, velocity, behavior); |
sataya.m | 582c9ce | 2015-06-09 08:03:42 | [diff] [blame] | 2557 | } |
| 2558 | |
danakj | 4b34721 | 2018-07-04 17:55:17 | [diff] [blame] | 2559 | // static |
| 2560 | cc::LayerTreeSettings RenderWidget::GenerateLayerTreeSettings( |
| 2561 | CompositorDependencies* compositor_deps, |
| 2562 | bool is_for_subframe, |
| 2563 | const gfx::Size& initial_screen_size, |
| 2564 | float initial_device_scale_factor) { |
| 2565 | const bool is_threaded = |
| 2566 | !!compositor_deps->GetCompositorImplThreadTaskRunner(); |
| 2567 | |
| 2568 | const base::CommandLine& cmd = *base::CommandLine::ForCurrentProcess(); |
| 2569 | cc::LayerTreeSettings settings; |
| 2570 | |
| 2571 | settings.resource_settings.use_r16_texture = |
| 2572 | base::FeatureList::IsEnabled(media::kUseR16Texture); |
| 2573 | |
| 2574 | settings.commit_to_active_tree = !is_threaded; |
| 2575 | settings.is_layer_tree_for_subframe = is_for_subframe; |
| 2576 | |
| 2577 | // For web contents, layer transforms should scale up the contents of layers |
| 2578 | // to keep content always crisp when possible. |
| 2579 | settings.layer_transforms_should_scale_layer_contents = true; |
| 2580 | |
| 2581 | settings.main_frame_before_activation_enabled = |
| 2582 | cmd.HasSwitch(cc::switches::kEnableMainFrameBeforeActivation); |
| 2583 | |
| 2584 | // Checkerimaging is not supported for synchronous single-threaded mode, which |
| 2585 | // is what the renderer uses if its not threaded. |
| 2586 | settings.enable_checker_imaging = |
| 2587 | !cmd.HasSwitch(cc::switches::kDisableCheckerImaging) && is_threaded; |
| 2588 | |
| 2589 | #if defined(OS_ANDROID) |
| 2590 | // We can use a more aggressive limit on Android since decodes tend to take |
| 2591 | // longer on these devices. |
| 2592 | settings.min_image_bytes_to_checker = 512 * 1024; // 512kB |
| 2593 | |
| 2594 | // Re-rasterization of checker-imaged content with software raster can be too |
| 2595 | // costly on Android. |
| 2596 | settings.only_checker_images_with_gpu_raster = true; |
| 2597 | #endif |
| 2598 | |
| 2599 | auto switch_value_as_int = [](const base::CommandLine& command_line, |
| 2600 | const std::string& switch_string, int min_value, |
| 2601 | int max_value, int* result) { |
| 2602 | std::string string_value = command_line.GetSwitchValueASCII(switch_string); |
| 2603 | int int_value; |
| 2604 | if (base::StringToInt(string_value, &int_value) && int_value >= min_value && |
| 2605 | int_value <= max_value) { |
| 2606 | *result = int_value; |
| 2607 | return true; |
| 2608 | } else { |
| 2609 | LOG(WARNING) << "Failed to parse switch " << switch_string << ": " |
| 2610 | << string_value; |
| 2611 | return false; |
| 2612 | } |
| 2613 | }; |
| 2614 | |
| 2615 | int default_tile_size = 256; |
| 2616 | #if defined(OS_ANDROID) |
| 2617 | const gfx::Size screen_size = |
| 2618 | gfx::ScaleToFlooredSize(initial_screen_size, initial_device_scale_factor); |
| 2619 | int display_width = screen_size.width(); |
| 2620 | int display_height = screen_size.height(); |
| 2621 | int numTiles = (display_width * display_height) / (256 * 256); |
| 2622 | if (numTiles > 16) |
| 2623 | default_tile_size = 384; |
| 2624 | if (numTiles >= 40) |
| 2625 | default_tile_size = 512; |
| 2626 | |
| 2627 | // Adjust for some resolutions that barely straddle an extra |
| 2628 | // tile when in portrait mode. This helps worst case scroll/raster |
| 2629 | // by not needing a full extra tile for each row. |
| 2630 | constexpr int tolerance = 10; // To avoid rounding errors. |
| 2631 | int portrait_width = std::min(display_width, display_height); |
| 2632 | if (default_tile_size == 256 && std::abs(portrait_width - 768) < tolerance) |
| 2633 | default_tile_size += 32; |
| 2634 | if (default_tile_size == 384 && std::abs(portrait_width - 1200) < tolerance) |
| 2635 | default_tile_size += 32; |
| 2636 | #elif defined(OS_CHROMEOS) || defined(OS_MACOSX) |
| 2637 | // Use 512 for high DPI (dsf=2.0f) devices. |
| 2638 | if (initial_device_scale_factor >= 2.0f) |
| 2639 | default_tile_size = 512; |
| 2640 | #endif |
| 2641 | |
| 2642 | // TODO(danakj): This should not be a setting O_O; it should change when the |
| 2643 | // device scale factor on LayerTreeHost changes. |
| 2644 | settings.default_tile_size = gfx::Size(default_tile_size, default_tile_size); |
| 2645 | if (cmd.HasSwitch(switches::kDefaultTileWidth)) { |
| 2646 | int tile_width = 0; |
| 2647 | switch_value_as_int(cmd, switches::kDefaultTileWidth, 1, |
| 2648 | std::numeric_limits<int>::max(), &tile_width); |
| 2649 | settings.default_tile_size.set_width(tile_width); |
| 2650 | } |
| 2651 | if (cmd.HasSwitch(switches::kDefaultTileHeight)) { |
| 2652 | int tile_height = 0; |
| 2653 | switch_value_as_int(cmd, switches::kDefaultTileHeight, 1, |
| 2654 | std::numeric_limits<int>::max(), &tile_height); |
| 2655 | settings.default_tile_size.set_height(tile_height); |
| 2656 | } |
| 2657 | |
| 2658 | int max_untiled_layer_width = settings.max_untiled_layer_size.width(); |
| 2659 | if (cmd.HasSwitch(switches::kMaxUntiledLayerWidth)) { |
| 2660 | switch_value_as_int(cmd, switches::kMaxUntiledLayerWidth, 1, |
| 2661 | std::numeric_limits<int>::max(), |
| 2662 | &max_untiled_layer_width); |
| 2663 | } |
| 2664 | int max_untiled_layer_height = settings.max_untiled_layer_size.height(); |
| 2665 | if (cmd.HasSwitch(switches::kMaxUntiledLayerHeight)) { |
| 2666 | switch_value_as_int(cmd, switches::kMaxUntiledLayerHeight, 1, |
| 2667 | std::numeric_limits<int>::max(), |
| 2668 | &max_untiled_layer_height); |
| 2669 | } |
| 2670 | |
| 2671 | settings.max_untiled_layer_size = |
| 2672 | gfx::Size(max_untiled_layer_width, max_untiled_layer_height); |
| 2673 | |
| 2674 | settings.gpu_rasterization_msaa_sample_count = |
| 2675 | compositor_deps->GetGpuRasterizationMSAASampleCount(); |
| 2676 | settings.gpu_rasterization_forced = |
| 2677 | compositor_deps->IsGpuRasterizationForced(); |
| 2678 | |
| 2679 | settings.can_use_lcd_text = compositor_deps->IsLcdTextEnabled(); |
| 2680 | settings.use_zero_copy = compositor_deps->IsZeroCopyEnabled(); |
| 2681 | settings.use_partial_raster = compositor_deps->IsPartialRasterEnabled(); |
| 2682 | settings.enable_elastic_overscroll = |
| 2683 | compositor_deps->IsElasticOverscrollEnabled(); |
| 2684 | settings.resource_settings.use_gpu_memory_buffer_resources = |
| 2685 | compositor_deps->IsGpuMemoryBufferCompositorResourcesEnabled(); |
| 2686 | settings.use_painted_device_scale_factor = |
| 2687 | compositor_deps->IsUseZoomForDSFEnabled(); |
| 2688 | |
| 2689 | // Build LayerTreeSettings from command line args. |
| 2690 | if (cmd.HasSwitch(cc::switches::kBrowserControlsShowThreshold)) { |
| 2691 | std::string top_threshold_str = |
| 2692 | cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsShowThreshold); |
| 2693 | double show_threshold; |
| 2694 | if (base::StringToDouble(top_threshold_str, &show_threshold) && |
| 2695 | show_threshold >= 0.f && show_threshold <= 1.f) |
| 2696 | settings.top_controls_show_threshold = show_threshold; |
| 2697 | } |
| 2698 | |
| 2699 | if (cmd.HasSwitch(cc::switches::kBrowserControlsHideThreshold)) { |
| 2700 | std::string top_threshold_str = |
| 2701 | cmd.GetSwitchValueASCII(cc::switches::kBrowserControlsHideThreshold); |
| 2702 | double hide_threshold; |
| 2703 | if (base::StringToDouble(top_threshold_str, &hide_threshold) && |
| 2704 | hide_threshold >= 0.f && hide_threshold <= 1.f) |
| 2705 | settings.top_controls_hide_threshold = hide_threshold; |
| 2706 | } |
| 2707 | |
| 2708 | settings.use_layer_lists = cmd.HasSwitch(cc::switches::kEnableLayerLists); |
| 2709 | |
| 2710 | // The means the renderer compositor has 2 possible modes: |
| 2711 | // - Threaded compositing with a scheduler. |
| 2712 | // - Single threaded compositing without a scheduler (for layout tests only). |
| 2713 | // Using the scheduler in layout tests introduces additional composite steps |
| 2714 | // that create flakiness. |
| 2715 | settings.single_thread_proxy_scheduler = false; |
| 2716 | |
| 2717 | // These flags should be mirrored by UI versions in ui/compositor/. |
| 2718 | if (cmd.HasSwitch(cc::switches::kShowCompositedLayerBorders)) |
| 2719 | settings.initial_debug_state.show_debug_borders.set(); |
| 2720 | settings.initial_debug_state.show_layer_animation_bounds_rects = |
| 2721 | cmd.HasSwitch(cc::switches::kShowLayerAnimationBounds); |
| 2722 | settings.initial_debug_state.show_paint_rects = |
| 2723 | cmd.HasSwitch(switches::kShowPaintRects); |
| 2724 | settings.initial_debug_state.show_property_changed_rects = |
| 2725 | cmd.HasSwitch(cc::switches::kShowPropertyChangedRects); |
| 2726 | settings.initial_debug_state.show_surface_damage_rects = |
| 2727 | cmd.HasSwitch(cc::switches::kShowSurfaceDamageRects); |
| 2728 | settings.initial_debug_state.show_screen_space_rects = |
| 2729 | cmd.HasSwitch(cc::switches::kShowScreenSpaceRects); |
| 2730 | |
| 2731 | settings.initial_debug_state.SetRecordRenderingStats( |
| 2732 | cmd.HasSwitch(cc::switches::kEnableGpuBenchmarking)); |
| 2733 | settings.enable_surface_synchronization = |
| 2734 | features::IsSurfaceSynchronizationEnabled(); |
| 2735 | settings.build_hit_test_data = features::IsVizHitTestingSurfaceLayerEnabled(); |
| 2736 | |
| 2737 | if (cmd.HasSwitch(cc::switches::kSlowDownRasterScaleFactor)) { |
| 2738 | const int kMinSlowDownScaleFactor = 0; |
| 2739 | const int kMaxSlowDownScaleFactor = INT_MAX; |
| 2740 | switch_value_as_int( |
| 2741 | cmd, cc::switches::kSlowDownRasterScaleFactor, kMinSlowDownScaleFactor, |
| 2742 | kMaxSlowDownScaleFactor, |
| 2743 | &settings.initial_debug_state.slow_down_raster_scale_factor); |
| 2744 | } |
| 2745 | |
| 2746 | // This is default overlay scrollbar settings for Android and DevTools mobile |
| 2747 | // emulator. Aura Overlay Scrollbar will override below. |
| 2748 | settings.scrollbar_animator = cc::LayerTreeSettings::ANDROID_OVERLAY; |
| 2749 | settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128); |
| 2750 | settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(300); |
| 2751 | settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(300); |
| 2752 | |
| 2753 | #if defined(OS_ANDROID) |
| 2754 | bool using_synchronous_compositor = |
| 2755 | compositor_deps->UsingSynchronousCompositing(); |
| 2756 | bool using_low_memory_policy = base::SysInfo::IsLowEndDevice(); |
| 2757 | |
| 2758 | settings.use_stream_video_draw_quad = true; |
| 2759 | settings.using_synchronous_renderer_compositor = using_synchronous_compositor; |
| 2760 | if (using_synchronous_compositor) { |
| 2761 | // Android WebView uses system scrollbars, so make ours invisible. |
| 2762 | // http://crbug.com/677348: This can't be done using hide_scrollbars |
| 2763 | // setting because supporting -webkit custom scrollbars is still desired |
| 2764 | // on sublayers. |
| 2765 | settings.scrollbar_animator = cc::LayerTreeSettings::NO_ANIMATOR; |
| 2766 | settings.solid_color_scrollbar_color = SK_ColorTRANSPARENT; |
| 2767 | |
| 2768 | settings.enable_early_damage_check = |
| 2769 | cmd.HasSwitch(cc::switches::kCheckDamageEarly); |
| 2770 | } |
| 2771 | // Android WebView handles root layer flings itself. |
| 2772 | settings.ignore_root_layer_flings = using_synchronous_compositor; |
| 2773 | // Memory policy on Android WebView does not depend on whether device is |
| 2774 | // low end, so always use default policy. |
| 2775 | if (using_low_memory_policy && !using_synchronous_compositor) { |
| 2776 | // On low-end we want to be very carefull about killing other |
| 2777 | // apps. So initially we use 50% more memory to avoid flickering |
| 2778 | // or raster-on-demand. |
| 2779 | settings.max_memory_for_prepaint_percentage = 67; |
| 2780 | } else { |
| 2781 | // On other devices we have increased memory excessively to avoid |
| 2782 | // raster-on-demand already, so now we reserve 50% _only_ to avoid |
| 2783 | // raster-on-demand, and use 50% of the memory otherwise. |
| 2784 | settings.max_memory_for_prepaint_percentage = 50; |
| 2785 | } |
| 2786 | |
| 2787 | // TODO(danakj): Only do this on low end devices. |
| 2788 | settings.create_low_res_tiling = true; |
| 2789 | |
| 2790 | #else // defined(OS_ANDROID) |
| 2791 | bool using_synchronous_compositor = false; // Only for Android WebView. |
| 2792 | // On desktop, we never use the low memory policy unless we are simulating |
| 2793 | // low-end mode via a switch. |
| 2794 | bool using_low_memory_policy = |
| 2795 | cmd.HasSwitch(switches::kEnableLowEndDeviceMode); |
| 2796 | |
| 2797 | if (ui::IsOverlayScrollbarEnabled()) { |
| 2798 | settings.scrollbar_animator = cc::LayerTreeSettings::AURA_OVERLAY; |
| 2799 | settings.scrollbar_fade_delay = ui::kOverlayScrollbarFadeDelay; |
| 2800 | settings.scrollbar_fade_duration = ui::kOverlayScrollbarFadeDuration; |
| 2801 | settings.scrollbar_thinning_duration = |
| 2802 | ui::kOverlayScrollbarThinningDuration; |
| 2803 | settings.scrollbar_flash_after_any_scroll_update = |
| 2804 | ui::OverlayScrollbarFlashAfterAnyScrollUpdate(); |
| 2805 | settings.scrollbar_flash_when_mouse_enter = |
| 2806 | ui::OverlayScrollbarFlashWhenMouseEnter(); |
| 2807 | } |
| 2808 | |
| 2809 | // On desktop, if there's over 4GB of memory on the machine, increase the |
| 2810 | // working set size to 256MB for both gpu and software. |
| 2811 | const int kImageDecodeMemoryThresholdMB = 4 * 1024; |
| 2812 | if (base::SysInfo::AmountOfPhysicalMemoryMB() >= |
| 2813 | kImageDecodeMemoryThresholdMB) { |
| 2814 | settings.decoded_image_working_set_budget_bytes = 256 * 1024 * 1024; |
| 2815 | } else { |
| 2816 | // This is the default, but recorded here as well. |
| 2817 | settings.decoded_image_working_set_budget_bytes = 128 * 1024 * 1024; |
| 2818 | } |
| 2819 | #endif // defined(OS_ANDROID) |
| 2820 | |
| 2821 | if (using_low_memory_policy) { |
| 2822 | // RGBA_4444 textures are only enabled: |
| 2823 | // - If the user hasn't explicitly disabled them |
| 2824 | // - If system ram is <= 512MB (1GB devices are sometimes low-end). |
| 2825 | // - If we are not running in a WebView, where 4444 isn't supported. |
| 2826 | if (!cmd.HasSwitch(switches::kDisableRGBA4444Textures) && |
| 2827 | base::SysInfo::AmountOfPhysicalMemoryMB() <= 512 && |
| 2828 | !using_synchronous_compositor) { |
| 2829 | settings.use_rgba_4444 = viz::RGBA_4444; |
| 2830 | |
| 2831 | // If we are going to unpremultiply and dither these tiles, we need to |
| 2832 | // allocate an additional RGBA_8888 intermediate for each tile |
| 2833 | // rasterization when rastering to RGBA_4444 to allow for dithering. |
| 2834 | // Setting a reasonable sized max tile size allows this intermediate to |
| 2835 | // be consistently reused. |
| 2836 | if (base::FeatureList::IsEnabled( |
| 2837 | kUnpremultiplyAndDitherLowBitDepthTiles)) { |
| 2838 | settings.max_gpu_raster_tile_size = gfx::Size(512, 256); |
| 2839 | settings.unpremultiply_and_dither_low_bit_depth_tiles = true; |
| 2840 | } |
| 2841 | } |
| 2842 | } |
| 2843 | |
| 2844 | if (cmd.HasSwitch(switches::kEnableLowResTiling)) |
| 2845 | settings.create_low_res_tiling = true; |
| 2846 | if (cmd.HasSwitch(switches::kDisableLowResTiling)) |
| 2847 | settings.create_low_res_tiling = false; |
| 2848 | |
| 2849 | if (cmd.HasSwitch(switches::kEnableRGBA4444Textures) && |
| 2850 | !cmd.HasSwitch(switches::kDisableRGBA4444Textures)) { |
| 2851 | settings.use_rgba_4444 = true; |
| 2852 | } |
| 2853 | |
| 2854 | settings.max_staging_buffer_usage_in_bytes = 32 * 1024 * 1024; // 32MB |
| 2855 | // Use 1/4th of staging buffers on low-end devices. |
| 2856 | if (base::SysInfo::IsLowEndDevice()) |
| 2857 | settings.max_staging_buffer_usage_in_bytes /= 4; |
| 2858 | |
| 2859 | cc::ManagedMemoryPolicy defaults = settings.memory_policy; |
| 2860 | settings.memory_policy = GetGpuMemoryPolicy(defaults, initial_screen_size, |
| 2861 | initial_device_scale_factor); |
| 2862 | |
| 2863 | settings.disallow_non_exact_resource_reuse = |
| 2864 | cmd.HasSwitch(switches::kDisallowNonExactResourceReuse); |
| 2865 | #if defined(OS_ANDROID) |
| 2866 | // TODO(crbug.com/746931): This feature appears to be causing visual |
| 2867 | // corruption on certain android devices. Will investigate and re-enable. |
| 2868 | settings.disallow_non_exact_resource_reuse = true; |
| 2869 | #endif |
| 2870 | |
| 2871 | if (cmd.HasSwitch(switches::kRunAllCompositorStagesBeforeDraw)) { |
| 2872 | settings.wait_for_all_pipeline_stages_before_draw = true; |
| 2873 | settings.enable_latency_recovery = false; |
| 2874 | } |
| 2875 | |
| 2876 | settings.enable_image_animation_resync = |
| 2877 | !cmd.HasSwitch(switches::kDisableImageAnimationResync); |
| 2878 | |
| 2879 | settings.always_request_presentation_time = |
| 2880 | cmd.HasSwitch(cc::switches::kAlwaysRequestPresentationTime); |
| 2881 | return settings; |
| 2882 | } |
| 2883 | |
| 2884 | // static |
| 2885 | cc::ManagedMemoryPolicy RenderWidget::GetGpuMemoryPolicy( |
| 2886 | const cc::ManagedMemoryPolicy& default_policy, |
| 2887 | const gfx::Size& initial_screen_size, |
| 2888 | float initial_device_scale_factor) { |
| 2889 | cc::ManagedMemoryPolicy actual = default_policy; |
| 2890 | actual.bytes_limit_when_visible = 0; |
| 2891 | |
| 2892 | // If the value was overridden on the command line, use the specified value. |
| 2893 | static bool client_hard_limit_bytes_overridden = |
| 2894 | base::CommandLine::ForCurrentProcess()->HasSwitch( |
| 2895 | switches::kForceGpuMemAvailableMb); |
| 2896 | if (client_hard_limit_bytes_overridden) { |
| 2897 | if (base::StringToSizeT( |
| 2898 | base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII( |
| 2899 | switches::kForceGpuMemAvailableMb), |
| 2900 | &actual.bytes_limit_when_visible)) |
| 2901 | actual.bytes_limit_when_visible *= 1024 * 1024; |
| 2902 | return actual; |
| 2903 | } |
| 2904 | |
| 2905 | #if defined(OS_ANDROID) |
| 2906 | // We can't query available GPU memory from the system on Android. |
| 2907 | // Physical memory is also mis-reported sometimes (eg. Nexus 10 reports |
| 2908 | // 1262MB when it actually has 2GB, while Razr M has 1GB but only reports |
| 2909 | // 128MB java heap size). First we estimate physical memory using both. |
| 2910 | size_t dalvik_mb = base::SysInfo::DalvikHeapSizeMB(); |
| 2911 | size_t physical_mb = base::SysInfo::AmountOfPhysicalMemoryMB(); |
| 2912 | size_t physical_memory_mb = 0; |
| 2913 | if (base::SysInfo::IsLowEndDevice()) { |
| 2914 | // TODO(crbug.com/742534): The code below appears to no longer work. |
| 2915 | // |dalvik_mb| no longer follows the expected heuristic pattern, causing us |
| 2916 | // to over-estimate memory on low-end devices. This entire section probably |
| 2917 | // needs to be re-written, but for now we can address the low-end Android |
| 2918 | // issues by ignoring |dalvik_mb|. |
| 2919 | physical_memory_mb = physical_mb; |
| 2920 | } else if (dalvik_mb >= 256) { |
| 2921 | physical_memory_mb = dalvik_mb * 4; |
| 2922 | } else { |
| 2923 | physical_memory_mb = std::max(dalvik_mb * 4, (physical_mb * 4) / 3); |
| 2924 | } |
| 2925 | |
| 2926 | // Now we take a default of 1/8th of memory on high-memory devices, |
| 2927 | // and gradually scale that back for low-memory devices (to be nicer |
| 2928 | // to other apps so they don't get killed). Examples: |
| 2929 | // Nexus 4/10(2GB) 256MB (normally 128MB) |
| 2930 | // Droid Razr M(1GB) 114MB (normally 57MB) |
| 2931 | // Galaxy Nexus(1GB) 100MB (normally 50MB) |
| 2932 | // Xoom(1GB) 100MB (normally 50MB) |
| 2933 | // Nexus S(low-end) 8MB (normally 8MB) |
| 2934 | // Note that the compositor now uses only some of this memory for |
| 2935 | // pre-painting and uses the rest only for 'emergencies'. |
| 2936 | if (actual.bytes_limit_when_visible == 0) { |
| 2937 | // NOTE: Non-low-end devices use only 50% of these limits, |
| 2938 | // except during 'emergencies' where 100% can be used. |
| 2939 | if (physical_memory_mb >= 1536) |
| 2940 | actual.bytes_limit_when_visible = physical_memory_mb / 8; // >192MB |
| 2941 | else if (physical_memory_mb >= 1152) |
| 2942 | actual.bytes_limit_when_visible = physical_memory_mb / 8; // >144MB |
| 2943 | else if (physical_memory_mb >= 768) |
| 2944 | actual.bytes_limit_when_visible = physical_memory_mb / 10; // >76MB |
| 2945 | else if (physical_memory_mb >= 513) |
| 2946 | actual.bytes_limit_when_visible = physical_memory_mb / 12; // <64MB |
| 2947 | else |
| 2948 | // Devices with this little RAM have very little headroom so we hardcode |
| 2949 | // the limit rather than relying on the heuristics above. (They also use |
| 2950 | // 4444 textures so we can use a lower limit.) |
| 2951 | actual.bytes_limit_when_visible = 8; |
| 2952 | |
| 2953 | actual.bytes_limit_when_visible = |
| 2954 | actual.bytes_limit_when_visible * 1024 * 1024; |
| 2955 | // Clamp the observed value to a specific range on Android. |
| 2956 | actual.bytes_limit_when_visible = std::max( |
| 2957 | actual.bytes_limit_when_visible, static_cast<size_t>(8 * 1024 * 1024)); |
| 2958 | actual.bytes_limit_when_visible = |
| 2959 | std::min(actual.bytes_limit_when_visible, |
| 2960 | static_cast<size_t>(256 * 1024 * 1024)); |
| 2961 | } |
| 2962 | actual.priority_cutoff_when_visible = |
| 2963 | gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING; |
| 2964 | #else |
| 2965 | // Ignore what the system said and give all clients the same maximum |
| 2966 | // allocation on desktop platforms. |
| 2967 | actual.bytes_limit_when_visible = 512 * 1024 * 1024; |
| 2968 | actual.priority_cutoff_when_visible = |
| 2969 | gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE; |
| 2970 | |
| 2971 | // For large monitors (4k), double the tile memory to avoid frequent out of |
| 2972 | // memory problems. 4k could mean a screen width of anywhere from 3840 to 4096 |
| 2973 | // (see https://en.wikipedia.org/wiki/4K_resolution). We use 3500 as a proxy |
| 2974 | // for "large enough". |
| 2975 | static const int kLargeDisplayThreshold = 3500; |
| 2976 | int display_width = |
| 2977 | std::round(initial_screen_size.width() * initial_device_scale_factor); |
| 2978 | if (display_width >= kLargeDisplayThreshold) |
| 2979 | actual.bytes_limit_when_visible *= 2; |
| 2980 | #endif |
| 2981 | return actual; |
| 2982 | } |
| 2983 | |
[email protected] | 7912e82 | 2014-04-16 02:37:03 | [diff] [blame] | 2984 | void RenderWidget::StartCompositor() { |
sievers | 71c62dd5 | 2015-10-07 01:44:39 | [diff] [blame] | 2985 | if (!is_hidden()) |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 2986 | layer_tree_view_->SetVisible(true); |
[email protected] | 24ed043 | 2013-04-24 07:50:31 | [diff] [blame] | 2987 | } |
| 2988 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 2989 | void RenderWidget::HasTouchEventHandlers(bool has_handlers) { |
W. James MacLean | 662d538 | 2018-03-29 18:33:08 | [diff] [blame] | 2990 | if (has_touch_handlers_ && *has_touch_handlers_ == has_handlers) |
| 2991 | return; |
| 2992 | |
| 2993 | has_touch_handlers_ = has_handlers; |
alexclarke | 7fa9394 | 2015-10-21 15:37:11 | [diff] [blame] | 2994 | if (render_widget_scheduling_state_) |
| 2995 | render_widget_scheduling_state_->SetHasTouchHandler(has_handlers); |
[email protected] | ce6689f | 2013-03-29 12:52:55 | [diff] [blame] | 2996 | Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers)); |
| 2997 | } |
| 2998 | |
Dave Tapuska | dfe486c1 | 2017-06-09 16:53:13 | [diff] [blame] | 2999 | void RenderWidget::SetNeedsLowLatencyInput(bool needs_low_latency) { |
| 3000 | if (input_event_queue_) |
| 3001 | input_event_queue_->SetNeedsLowLatency(needs_low_latency); |
| 3002 | } |
| 3003 | |
Dave Tapuska | bafc2ba3 | 2017-11-28 01:54:37 | [diff] [blame] | 3004 | void RenderWidget::RequestUnbufferedInputEvents() { |
| 3005 | if (input_event_queue_) |
| 3006 | input_event_queue_->RequestUnbufferedInputEvents(); |
| 3007 | } |
| 3008 | |
xidachen | fa0199e7 | 2017-05-11 11:34:26 | [diff] [blame] | 3009 | void RenderWidget::SetTouchAction(cc::TouchAction touch_action) { |
Dave Tapuska | b28a108 | 2017-08-30 15:37:26 | [diff] [blame] | 3010 | if (!input_handler_->ProcessTouchAction(touch_action)) |
[email protected] | 5d0bbdfa9 | 2013-12-10 00:35:51 | [diff] [blame] | 3011 | return; |
| 3012 | |
Dave Tapuska | 04bc5ee9 | 2018-04-17 19:03:31 | [diff] [blame] | 3013 | widget_input_handler_manager_->ProcessTouchAction(touch_action); |
[email protected] | 5d0bbdfa9 | 2013-12-10 00:35:51 | [diff] [blame] | 3014 | } |
| 3015 | |
[email protected] | e3244ed | 2014-06-20 20:04:27 | [diff] [blame] | 3016 | void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) { |
| 3017 | render_frame_proxies_.AddObserver(proxy); |
[email protected] | bffc830 | 2014-01-23 20:52:16 | [diff] [blame] | 3018 | } |
| 3019 | |
[email protected] | e3244ed | 2014-06-20 20:04:27 | [diff] [blame] | 3020 | void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) { |
| 3021 | render_frame_proxies_.RemoveObserver(proxy); |
[email protected] | bffc830 | 2014-01-23 20:52:16 | [diff] [blame] | 3022 | } |
| 3023 | |
[email protected] | de3c5d8 | 2014-05-28 22:12:59 | [diff] [blame] | 3024 | void RenderWidget::RegisterRenderFrame(RenderFrameImpl* frame) { |
| 3025 | render_frames_.AddObserver(frame); |
| 3026 | } |
| 3027 | |
| 3028 | void RenderWidget::UnregisterRenderFrame(RenderFrameImpl* frame) { |
| 3029 | render_frames_.RemoveObserver(frame); |
| 3030 | } |
| 3031 | |
Saman Sami | d189e5dfd | 2017-12-20 22:55:31 | [diff] [blame] | 3032 | void RenderWidget::RegisterBrowserPlugin(BrowserPlugin* browser_plugin) { |
| 3033 | browser_plugins_.AddObserver(browser_plugin); |
Saman Sami | 50d1e0c | 2018-03-13 20:03:49 | [diff] [blame] | 3034 | browser_plugin->ScreenInfoChanged(GetOriginalScreenInfo()); |
Saman Sami | d189e5dfd | 2017-12-20 22:55:31 | [diff] [blame] | 3035 | } |
| 3036 | |
| 3037 | void RenderWidget::UnregisterBrowserPlugin(BrowserPlugin* browser_plugin) { |
| 3038 | browser_plugins_.RemoveObserver(browser_plugin); |
| 3039 | } |
| 3040 | |
lfg | 43e08e6 | 2016-02-03 18:51:37 | [diff] [blame] | 3041 | void RenderWidget::OnWaitNextFrameForTests(int routing_id) { |
danakj | 5380269 | 2018-07-25 21:46:44 | [diff] [blame] | 3042 | // Sends an ACK to the browser process during the next compositor frame. |
Sadrul Habib Chowdhury | 4e0335cf | 2018-07-31 20:08:49 | [diff] [blame^] | 3043 | QueueMessage(new ViewHostMsg_WaitForNextFrameForTests_ACK(routing_id)); |
lfg | 43e08e6 | 2016-02-03 18:51:37 | [diff] [blame] | 3044 | } |
| 3045 | |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 3046 | const ScreenInfo& RenderWidget::GetWebScreenInfo() const { |
| 3047 | return screen_info_; |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 3048 | } |
| 3049 | |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 3050 | const ScreenInfo& RenderWidget::GetOriginalScreenInfo() const { |
Christopher Cameron | e9a30c1 | 2018-03-07 08:23:38 | [diff] [blame] | 3051 | return screen_metrics_emulator_ |
| 3052 | ? screen_metrics_emulator_->original_screen_info() |
Fady Samuel | a863f15 | 2018-03-09 16:10:03 | [diff] [blame] | 3053 | : screen_info_; |
oshima | 50872a7 | 2016-03-04 13:26:18 | [diff] [blame] | 3054 | } |
| 3055 | |
Ella Ge | 80a52dce | 2017-11-15 18:01:52 | [diff] [blame] | 3056 | gfx::PointF RenderWidget::ConvertWindowPointToViewport( |
| 3057 | const gfx::PointF& point) { |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 3058 | blink::WebFloatRect point_in_viewport(point.x(), point.y(), 0, 0); |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 3059 | ConvertWindowToViewport(&point_in_viewport); |
Ella Ge | 80a52dce | 2017-11-15 18:01:52 | [diff] [blame] | 3060 | return gfx::PointF(point_in_viewport.x, point_in_viewport.y); |
| 3061 | } |
| 3062 | |
| 3063 | gfx::Point RenderWidget::ConvertWindowPointToViewport(const gfx::Point& point) { |
| 3064 | return gfx::ToRoundedPoint(ConvertWindowPointToViewport(gfx::PointF(point))); |
paulmeyer | 90f6c31d | 2016-11-12 00:17:59 | [diff] [blame] | 3065 | } |
| 3066 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 3067 | bool RenderWidget::RequestPointerLock() { |
lfg | bee1e0a | 2016-06-08 21:24:21 | [diff] [blame] | 3068 | return mouse_lock_dispatcher_->LockMouse(webwidget_mouse_lock_target_.get()); |
| 3069 | } |
| 3070 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 3071 | void RenderWidget::RequestPointerUnlock() { |
lfg | bee1e0a | 2016-06-08 21:24:21 | [diff] [blame] | 3072 | mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get()); |
| 3073 | } |
| 3074 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 3075 | bool RenderWidget::IsPointerLocked() { |
lfg | bee1e0a | 2016-06-08 21:24:21 | [diff] [blame] | 3076 | return mouse_lock_dispatcher_->IsMouseLockedTo( |
| 3077 | webwidget_mouse_lock_target_.get()); |
| 3078 | } |
| 3079 | |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 3080 | void RenderWidget::StartDragging(blink::WebReferrerPolicy policy, |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 3081 | const WebDragData& data, |
| 3082 | WebDragOperationsMask mask, |
danakj | 0c75ad8 | 2018-07-10 19:50:12 | [diff] [blame] | 3083 | const SkBitmap& drag_image, |
| 3084 | const WebPoint& web_image_offset) { |
| 3085 | blink::WebRect offset_in_window(web_image_offset.x, web_image_offset.y, 0, 0); |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 3086 | ConvertViewportToWindow(&offset_in_window); |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 3087 | DropData drop_data(DropDataBuilder::Build(data)); |
| 3088 | drop_data.referrer_policy = policy; |
danakj | 0c75ad8 | 2018-07-10 19:50:12 | [diff] [blame] | 3089 | gfx::Vector2d image_offset(offset_in_window.x, offset_in_window.y); |
| 3090 | Send(new DragHostMsg_StartDragging(routing_id(), drop_data, mask, drag_image, |
| 3091 | image_offset, possible_drag_event_info_)); |
paulmeyer | 6ef5a79 | 2016-11-08 20:33:58 | [diff] [blame] | 3092 | } |
| 3093 | |
kenrb | 5d78b84 | 2017-03-06 21:06:01 | [diff] [blame] | 3094 | uint32_t RenderWidget::GetContentSourceId() { |
| 3095 | return current_content_source_id_; |
| 3096 | } |
| 3097 | |
Saman Sami | f773134 | 2018-01-24 22:18:44 | [diff] [blame] | 3098 | void RenderWidget::DidNavigate() { |
Saman Sami | 26a1fcd | 2018-04-10 17:12:21 | [diff] [blame] | 3099 | ++current_content_source_id_; |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 3100 | if (!layer_tree_view_) |
Saman Sami | f773134 | 2018-01-24 22:18:44 | [diff] [blame] | 3101 | return; |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 3102 | layer_tree_view_->SetContentSourceId(current_content_source_id_); |
| 3103 | layer_tree_view_->ClearCachesOnNextCommit(); |
kenrb | 5d78b84 | 2017-03-06 21:06:01 | [diff] [blame] | 3104 | } |
| 3105 | |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 3106 | blink::WebWidget* RenderWidget::GetWebWidget() const { |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 3107 | if (owner_delegate_) { |
| 3108 | blink::WebWidget* delegate_widget = |
| 3109 | owner_delegate_->GetWebWidgetForWidget(); |
| 3110 | if (delegate_widget) |
| 3111 | return delegate_widget; |
| 3112 | } |
lfg | 8ff3391 | 2016-09-13 20:59:21 | [diff] [blame] | 3113 | return webwidget_internal_; |
| 3114 | } |
| 3115 | |
ekaramad | 2daaf67 | 2016-11-10 20:29:01 | [diff] [blame] | 3116 | blink::WebInputMethodController* RenderWidget::GetInputMethodController() |
| 3117 | const { |
Ehsan Karamad | 655d7b8a | 2018-01-12 18:38:38 | [diff] [blame] | 3118 | if (auto* frame_widget = GetFrameWidget()) |
| 3119 | return frame_widget->GetActiveWebInputMethodController(); |
| 3120 | |
| 3121 | return nullptr; |
ekaramad | 2daaf67 | 2016-11-10 20:29:01 | [diff] [blame] | 3122 | } |
| 3123 | |
Dave Tapuska | 139a72f | 2017-09-06 21:57:03 | [diff] [blame] | 3124 | void RenderWidget::SetupWidgetInputHandler( |
| 3125 | mojom::WidgetInputHandlerRequest request, |
| 3126 | mojom::WidgetInputHandlerHostPtr host) { |
Dave Tapuska | b66c28f | 2017-11-15 17:18:47 | [diff] [blame] | 3127 | widget_input_handler_manager_->AddInterface(std::move(request), |
| 3128 | std::move(host)); |
Dave Tapuska | 525eb15e | 2017-08-17 21:05:50 | [diff] [blame] | 3129 | } |
| 3130 | |
Dave Tapuska | 485aca9 | 2017-08-08 00:47:58 | [diff] [blame] | 3131 | void RenderWidget::SetWidgetBinding(mojom::WidgetRequest request) { |
| 3132 | // Close the old binding if there was one. |
| 3133 | // A RenderWidgetHost should not need more than one channel. |
| 3134 | widget_binding_.Close(); |
| 3135 | widget_binding_.Bind(std::move(request)); |
| 3136 | } |
| 3137 | |
Ken Buchanan | 94c0beb6 | 2018-06-22 19:56:24 | [diff] [blame] | 3138 | void RenderWidget::SetMouseCapture(bool capture) { |
| 3139 | if (mojom::WidgetInputHandlerHost* host = |
| 3140 | widget_input_handler_manager_->GetWidgetInputHandlerHost()) { |
| 3141 | host->SetMouseCapture(capture); |
| 3142 | } |
| 3143 | } |
| 3144 | |
danakj | 5380269 | 2018-07-25 21:46:44 | [diff] [blame] | 3145 | void RenderWidget::SetWindowScreenRect(const gfx::Rect& window_screen_rect) { |
| 3146 | if (screen_metrics_emulator_) |
| 3147 | screen_metrics_emulator_->OnUpdateWindowScreenRect(window_screen_rect); |
| 3148 | else |
| 3149 | window_screen_rect_ = window_screen_rect; |
| 3150 | } |
| 3151 | |
Fady Samuel | ca9ecb7 | 2018-05-05 05:59:27 | [diff] [blame] | 3152 | bool RenderWidget::IsSurfaceSynchronizationEnabled() const { |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 3153 | return layer_tree_view_ && |
| 3154 | layer_tree_view_->IsSurfaceSynchronizationEnabled(); |
Fady Samuel | ca9ecb7 | 2018-05-05 05:59:27 | [diff] [blame] | 3155 | } |
| 3156 | |
danakj | 5380269 | 2018-07-25 21:46:44 | [diff] [blame] | 3157 | void RenderWidget::UseSynchronousResizeModeForTesting(bool enable) { |
| 3158 | resizing_mode_selector_->set_is_synchronous_mode(enable); |
danakj | a2c9d0a9 | 2018-07-25 20:01:18 | [diff] [blame] | 3159 | } |
| 3160 | |
| 3161 | void RenderWidget::SetDeviceScaleFactorForTesting(float factor) { |
| 3162 | device_scale_factor_for_testing_ = factor; |
| 3163 | |
| 3164 | VisualProperties visual_properties; |
| 3165 | visual_properties.screen_info = screen_info_; |
| 3166 | visual_properties.screen_info.device_scale_factor = factor; |
| 3167 | visual_properties.new_size = size(); |
| 3168 | visual_properties.visible_viewport_size = visible_viewport_size_; |
| 3169 | visual_properties.compositor_viewport_pixel_size = |
| 3170 | gfx::ScaleToCeiledSize(size(), factor); |
| 3171 | visual_properties.browser_controls_shrink_blink_size = false; |
| 3172 | visual_properties.top_controls_height = 0.f; |
| 3173 | visual_properties.is_fullscreen_granted = is_fullscreen_granted_; |
| 3174 | visual_properties.display_mode = display_mode_; |
| 3175 | visual_properties.local_surface_id = local_surface_id_from_parent_; |
| 3176 | // We are changing the device scale factor from the renderer, so allocate a |
| 3177 | // new viz::LocalSurfaceId to avoid surface invariants violations in tests. |
| 3178 | if (layer_tree_view_) |
| 3179 | layer_tree_view_->RequestNewLocalSurfaceId(); |
| 3180 | |
| 3181 | OnSynchronizeVisualProperties(visual_properties); |
| 3182 | } |
| 3183 | |
| 3184 | void RenderWidget::SetDeviceColorSpaceForTesting( |
| 3185 | const gfx::ColorSpace& color_space) { |
| 3186 | VisualProperties visual_properties; |
| 3187 | visual_properties.screen_info = screen_info_; |
| 3188 | visual_properties.screen_info.color_space = color_space; |
| 3189 | visual_properties.new_size = size(); |
| 3190 | visual_properties.visible_viewport_size = visible_viewport_size_; |
| 3191 | visual_properties.compositor_viewport_pixel_size = |
| 3192 | compositor_viewport_pixel_size_; |
| 3193 | visual_properties.browser_controls_shrink_blink_size = false; |
| 3194 | visual_properties.top_controls_height = 0.f; |
| 3195 | visual_properties.is_fullscreen_granted = is_fullscreen_granted_; |
| 3196 | visual_properties.display_mode = display_mode_; |
| 3197 | visual_properties.local_surface_id = local_surface_id_from_parent_; |
| 3198 | // We are changing the device color space from the renderer, so allocate a |
| 3199 | // new viz::LocalSurfaceId to avoid surface invariants violations in tests. |
| 3200 | if (layer_tree_view_) |
| 3201 | layer_tree_view_->RequestNewLocalSurfaceId(); |
| 3202 | OnSynchronizeVisualProperties(visual_properties); |
| 3203 | } |
| 3204 | |
| 3205 | void RenderWidget::SetWindowRectSynchronouslyForTesting( |
| 3206 | const gfx::Rect& new_window_rect) { |
| 3207 | SetWindowRectSynchronously(new_window_rect); |
| 3208 | } |
| 3209 | |
| 3210 | void RenderWidget::EnableAutoResizeForTesting(const gfx::Size& min_size, |
| 3211 | const gfx::Size& max_size) { |
| 3212 | VisualProperties visual_properties; |
| 3213 | visual_properties.auto_resize_enabled = true; |
| 3214 | visual_properties.min_size_for_auto_resize = min_size; |
| 3215 | visual_properties.max_size_for_auto_resize = max_size; |
| 3216 | visual_properties.local_surface_id = base::Optional<viz::LocalSurfaceId>( |
| 3217 | viz::LocalSurfaceId(1, 1, base::UnguessableToken::Create())); |
| 3218 | OnSynchronizeVisualProperties(visual_properties); |
| 3219 | } |
| 3220 | |
| 3221 | void RenderWidget::DisableAutoResizeForTesting(const gfx::Size& new_size) { |
| 3222 | if (!auto_resize_mode_) |
| 3223 | return; |
| 3224 | |
| 3225 | VisualProperties visual_properties; |
| 3226 | visual_properties.auto_resize_enabled = false; |
| 3227 | visual_properties.screen_info = screen_info_; |
| 3228 | visual_properties.new_size = new_size; |
| 3229 | visual_properties.compositor_viewport_pixel_size = |
| 3230 | compositor_viewport_pixel_size_; |
| 3231 | visual_properties.browser_controls_shrink_blink_size = |
| 3232 | browser_controls_shrink_blink_size_; |
| 3233 | visual_properties.top_controls_height = top_controls_height_; |
| 3234 | visual_properties.visible_viewport_size = visible_viewport_size_; |
| 3235 | visual_properties.is_fullscreen_granted = is_fullscreen_granted_; |
| 3236 | visual_properties.display_mode = display_mode_; |
| 3237 | OnSynchronizeVisualProperties(visual_properties); |
| 3238 | } |
| 3239 | |
Khushal | 3e96e66 | 2017-10-30 23:16:50 | [diff] [blame] | 3240 | void RenderWidget::UpdateURLForCompositorUkm() { |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 3241 | DCHECK(layer_tree_view_); |
Ehsan Karamad | 655d7b8a | 2018-01-12 18:38:38 | [diff] [blame] | 3242 | blink::WebFrameWidget* frame_widget = GetFrameWidget(); |
| 3243 | if (!frame_widget) |
Khushal | 3e96e66 | 2017-10-30 23:16:50 | [diff] [blame] | 3244 | return; |
| 3245 | |
Ehsan Karamad | 655d7b8a | 2018-01-12 18:38:38 | [diff] [blame] | 3246 | auto* render_frame = RenderFrameImpl::FromWebFrame(frame_widget->LocalRoot()); |
Khushal | 3e96e66 | 2017-10-30 23:16:50 | [diff] [blame] | 3247 | if (!render_frame->IsMainFrame()) |
| 3248 | return; |
| 3249 | |
danakj | a6c1001 | 2018-07-06 14:25:36 | [diff] [blame] | 3250 | layer_tree_view_->SetURLForUkm( |
| 3251 | render_frame->GetWebFrame()->GetDocument().Url()); |
Khushal | 3e96e66 | 2017-10-30 23:16:50 | [diff] [blame] | 3252 | } |
| 3253 | |
EhsanK | 955ba58 | 2017-11-30 21:14:40 | [diff] [blame] | 3254 | blink::WebLocalFrame* RenderWidget::GetFocusedWebLocalFrameInWidget() const { |
Ehsan Karamad | 655d7b8a | 2018-01-12 18:38:38 | [diff] [blame] | 3255 | if (auto* frame_widget = GetFrameWidget()) |
| 3256 | return frame_widget->FocusedWebLocalFrameInWidget(); |
| 3257 | return nullptr; |
EhsanK | 955ba58 | 2017-11-30 21:14:40 | [diff] [blame] | 3258 | } |
| 3259 | |
EhsanK | 22d482e | 2017-08-10 17:29:49 | [diff] [blame] | 3260 | #if BUILDFLAG(ENABLE_PLUGINS) |
| 3261 | PepperPluginInstanceImpl* RenderWidget::GetFocusedPepperPluginInsideWidget() { |
Ehsan Karamad | 655d7b8a | 2018-01-12 18:38:38 | [diff] [blame] | 3262 | blink::WebFrameWidget* frame_widget = GetFrameWidget(); |
| 3263 | if (!frame_widget) |
EhsanK | 22d482e | 2017-08-10 17:29:49 | [diff] [blame] | 3264 | return nullptr; |
| 3265 | |
| 3266 | // Focused pepper instance might not always be in the focused frame. For |
| 3267 | // instance if a pepper instance and its embedder frame are focused an then |
| 3268 | // another frame takes focus using javascript, the embedder frame will no |
| 3269 | // longer be focused while the pepper instance is (the embedder frame's |
| 3270 | // |focused_pepper_plugin_| is not nullptr). Especially, if the pepper plugin |
| 3271 | // is fullscreen, clicking into the pepper will not refocus the embedder |
| 3272 | // frame. This is why we have to traverse the whole frame tree to find the |
| 3273 | // focused plugin. |
Ehsan Karamad | 655d7b8a | 2018-01-12 18:38:38 | [diff] [blame] | 3274 | blink::WebFrame* current_frame = frame_widget->LocalRoot(); |
EhsanK | 22d482e | 2017-08-10 17:29:49 | [diff] [blame] | 3275 | while (current_frame) { |
| 3276 | RenderFrameImpl* render_frame = |
| 3277 | current_frame->IsWebLocalFrame() |
| 3278 | ? RenderFrameImpl::FromWebFrame(current_frame) |
| 3279 | : nullptr; |
| 3280 | if (render_frame && render_frame->focused_pepper_plugin()) |
| 3281 | return render_frame->focused_pepper_plugin(); |
| 3282 | current_frame = current_frame->TraverseNext(); |
| 3283 | } |
| 3284 | return nullptr; |
| 3285 | } |
| 3286 | #endif |
| 3287 | |
Ken Buchanan | b2c9e26 | 2018-03-10 16:53:31 | [diff] [blame] | 3288 | gfx::Rect RenderWidget::ViewportVisibleRect() { |
| 3289 | return for_oopif_ ? compositor_visible_rect_ |
| 3290 | : gfx::Rect(compositor_viewport_pixel_size_); |
| 3291 | } |
| 3292 | |
Saman Sami | 50d1e0c | 2018-03-13 20:03:49 | [diff] [blame] | 3293 | base::WeakPtr<RenderWidget> RenderWidget::AsWeakPtr() { |
| 3294 | return weak_ptr_factory_.GetWeakPtr(); |
| 3295 | } |
| 3296 | |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 3297 | } // namespace content |