blob: 8805f68abaa2cc57feebe63b9ece5009d4d91c2e [file] [log] [blame]
[email protected]91854cd2012-01-10 19:43:571// Copyright (c) 2012 The Chromium Authors. All rights reserved.
license.botbf09a502008-08-24 00:55:552// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commit09911bf2008-07-26 23:55:294
[email protected]93ddb3c2012-04-11 21:44:295#include "content/browser/web_contents/web_contents_impl.h"
[email protected]39526562011-02-05 03:41:516
avib7348942015-12-25 20:57:107#include <stddef.h>
8
w.shackleton49bcd392016-01-06 17:38:229#include <cmath>
[email protected]2bb171882012-03-07 02:09:4610#include <utility>
rkaplowe56a52032017-02-07 00:14:5411#include <vector>
[email protected]b75b8292010-10-01 07:28:2512
Sebastien Marchandf8cbfab2019-01-25 16:02:3013#include "base/bind.h"
[email protected]36fb2c7c2011-04-04 15:49:0814#include "base/command_line.h"
creisfafed882016-07-29 00:03:0915#include "base/debug/dump_without_crashing.h"
zqzhang181047e62016-07-01 13:37:1716#include "base/feature_list.h"
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:4717#include "base/files/file_path.h"
[email protected]cbb1ef592013-06-05 19:49:4618#include "base/lazy_instance.h"
skyostil95082a62015-06-05 19:53:0719#include "base/location.h"
[email protected]6d636e62013-07-31 03:15:5620#include "base/logging.h"
avib7348942015-12-25 20:57:1021#include "base/macros.h"
fdorayba121422016-12-23 19:51:4822#include "base/memory/ptr_util.h"
dmazzonid95ae842016-04-12 21:17:3923#include "base/memory/ref_counted.h"
asvitkine8d51e9d2016-09-02 23:55:4324#include "base/metrics/histogram_macros.h"
bratell0a7406f2017-03-28 07:46:3725#include "base/metrics/user_metrics.h"
Avi Drissman4891b852018-09-25 18:12:5826#include "base/no_destructor.h"
Carlos Caballero1215f882019-10-29 15:58:4327#include "base/optional.h"
[email protected]04cbd3d2013-12-04 04:58:2028#include "base/process/process.h"
skyostil95082a62015-06-05 19:53:0729#include "base/single_thread_task_runner.h"
Arthur Sonzogni929d29f2018-09-17 14:19:4430#include "base/stl_util.h"
[email protected]348fbaac2013-06-11 06:31:5131#include "base/strings/string16.h"
32#include "base/strings/string_number_conversions.h"
Avi Drissman4891b852018-09-25 18:12:5833#include "base/strings/string_split.h"
[email protected]348fbaac2013-06-11 06:31:5134#include "base/strings/string_util.h"
[email protected]74ebfb12013-06-07 20:48:0035#include "base/strings/utf_string_conversions.h"
Eric Seckler8652dcd52018-09-20 10:42:2836#include "base/task/post_task.h"
gab30f26df2016-05-11 19:37:5537#include "base/threading/thread_task_runner_handle.h"
[email protected]a43858f2013-06-28 15:18:3738#include "base/time/time.h"
ssid3e765612015-01-28 04:03:4239#include "base/trace_event/trace_event.h"
avib7348942015-12-25 20:57:1040#include "build/build_config.h"
Min Qinda0ed2062018-02-23 22:00:5341#include "components/download/public/common/download_stats.h"
nzolghadrd87a308d2016-12-07 15:45:5642#include "components/rappor/public/rappor_utils.h"
rsleevi24f64dc22015-08-07 21:39:2143#include "components/url_formatter/url_formatter.h"
Abigail Kleinaa898742019-11-01 02:31:2544#include "content/browser/accessibility/accessibility_event_recorder.h"
James Wallace-Leeeafc94cb92018-07-23 21:35:0945#include "content/browser/accessibility/accessibility_tree_formatter_blink.h"
jamescookda2505812015-03-20 18:01:1846#include "content/browser/bad_message.h"
Max Morinddebb972018-09-20 10:04:1447#include "content/browser/browser_main_loop.h"
[email protected]7a846df2012-09-20 19:17:3948#include "content/browser/browser_plugin/browser_plugin_embedder.h"
49#include "content/browser/browser_plugin/browser_plugin_guest.h"
[email protected]b9535422012-02-09 01:47:5950#include "content/browser/child_process_security_policy_impl.h"
Andrey Lushnikov81b992e2019-06-27 23:27:2151#include "content/browser/devtools/devtools_instrumentation.h"
Pavel Feldman3c1842b2017-08-02 05:00:1652#include "content/browser/devtools/protocol/page_handler.h"
dgozmanf00c4f72016-10-19 17:45:1553#include "content/browser/devtools/render_frame_devtools_agent_host.h"
Becca Hughes3b5a43482018-07-17 22:31:5554#include "content/browser/display_cutout/display_cutout_host_impl.h"
[email protected]5f2aa722013-08-07 16:59:4155#include "content/browser/dom_storage/dom_storage_context_wrapper.h"
[email protected]1ea3c792012-04-17 01:25:0456#include "content/browser/dom_storage/session_storage_namespace_impl.h"
[email protected]aa4f3972012-03-01 18:12:1257#include "content/browser/download/mhtml_generation_manager.h"
[email protected]a53209b2012-01-20 16:48:1658#include "content/browser/download/save_package.h"
paulmeyerc0b762b2016-04-13 11:55:1759#include "content/browser/find_request_manager.h"
[email protected]bffc8302014-01-23 20:52:1660#include "content/browser/frame_host/cross_process_frame_connector.h"
ananta4b7467a52016-09-23 01:42:3861#include "content/browser/frame_host/frame_tree_node.h"
[email protected]d4a8ca482013-10-30 21:06:4062#include "content/browser/frame_host/interstitial_page_impl.h"
63#include "content/browser/frame_host/navigation_entry_impl.h"
Arthur Hemeryc3380172018-01-22 14:00:1764#include "content/browser/frame_host/navigation_request.h"
[email protected]6ea6bdf2013-12-06 13:35:0165#include "content/browser/frame_host/navigator_impl.h"
[email protected]52913802013-12-10 05:52:1866#include "content/browser/frame_host/render_frame_host_impl.h"
lfgdb5c4ed2016-03-04 23:09:0767#include "content/browser/frame_host/render_frame_proxy_host.h"
Kenneth Russell954ed9ce2018-04-12 23:07:0168#include "content/browser/gpu/gpu_data_manager_impl.h"
mlamouriefdca9d2014-09-16 16:55:4069#include "content/browser/manifest/manifest_manager_host.h"
Max Morin5bc74f52018-05-09 07:00:2170#include "content/browser/media/audio_stream_broker.h"
dalecurtisbc6572e12014-09-12 19:22:3071#include "content/browser/media/audio_stream_monitor.h"
miu50f97892014-09-22 22:49:5272#include "content/browser/media/capture/web_contents_audio_muter.h"
dalecurtis88c240072015-12-09 02:11:1873#include "content/browser/media/media_web_contents_observer.h"
zqzhang1adf3cb2016-11-01 11:26:4574#include "content/browser/media/session/media_session_impl.h"
tommyclieb25b2a2014-11-03 19:45:0975#include "content/browser/plugin_content_origin_whitelist.h"
David Black9cca3592019-11-06 23:02:2276#include "content/browser/renderer_host/frame_token_message_queue.h"
[email protected]f3b1a082011-11-18 00:34:3077#include "content/browser/renderer_host/render_process_host_impl.h"
[email protected]21161032014-05-05 16:56:5078#include "content/browser/renderer_host/render_view_host_delegate_view.h"
[email protected]b3c41c0b2012-03-06 15:48:3279#include "content/browser/renderer_host/render_view_host_impl.h"
[email protected]bafe6cd2012-05-23 23:09:5080#include "content/browser/renderer_host/render_widget_host_impl.h"
kenrb2a565f82015-09-02 20:24:5981#include "content/browser/renderer_host/render_widget_host_input_event_router.h"
[email protected]cfd80b02014-05-01 17:46:4882#include "content/browser/renderer_host/render_widget_host_view_base.h"
Ken Buchanandaef006b2017-08-17 18:32:1583#include "content/browser/renderer_host/render_widget_host_view_child_frame.h"
ekaramadadd882292016-06-08 15:22:5684#include "content/browser/renderer_host/text_input_manager.h"
leon.han552e9de2017-02-09 14:37:3085#include "content/browser/screen_orientation/screen_orientation_provider.h"
[email protected]b6583592012-01-25 19:52:3386#include "content/browser/site_instance_impl.h"
Charlie Reis96077362019-07-04 00:34:0487#include "content/browser/web_contents/javascript_dialog_navigation_deferrer.h"
lfgc740d4b22016-04-15 16:45:3388#include "content/browser/web_contents/web_contents_view_child_frame.h"
[email protected]b5a40842012-11-28 15:26:1189#include "content/browser/web_contents/web_contents_view_guest.h"
[email protected]86a0a6e2013-01-28 06:33:0390#include "content/browser/webui/web_ui_controller_factory_registry.h"
[email protected]d2353452012-01-19 19:53:5691#include "content/browser/webui/web_ui_impl.h"
[email protected]8eb04562013-03-06 03:41:1492#include "content/common/browser_plugin/browser_plugin_constants.h"
[email protected]703dd662013-03-05 07:37:4293#include "content/common/browser_plugin/browser_plugin_messages.h"
Paul Meyer0c58c3712016-11-17 22:59:5194#include "content/common/drag_messages.h"
[email protected]f114fa42013-12-06 17:06:4495#include "content/common/frame_messages.h"
[email protected]1f3fc1d2014-04-03 14:50:1796#include "content/common/input_messages.h"
lfgdb5c4ed2016-03-04 23:09:0797#include "content/common/page_messages.h"
nasko34634672016-07-29 18:46:0698#include "content/common/page_state_serialization.h"
rockot5c478a72016-09-28 23:14:1899#include "content/common/render_message_filter.mojom.h"
[email protected]2c5569662011-03-22 20:45:02100#include "content/common/view_messages.h"
Albert J. Wong3c93c182018-09-27 17:29:43101#include "content/common/widget_messages.h"
Abigail Kleinabb428332019-09-13 18:26:21102#include "content/public/browser/accessibility_tree_formatter.h"
[email protected]31a71eaf2014-03-13 01:47:36103#include "content/public/browser/ax_event_notification_details.h"
[email protected]ccb797302011-12-15 16:55:11104#include "content/public/browser/browser_context.h"
[email protected]139355f2014-05-11 14:21:28105#include "content/public/browser/browser_plugin_guest_manager.h"
Eric Seckler8652dcd52018-09-20 10:42:28106#include "content/public/browser/browser_task_traits.h"
Gabriel Charette790754c2018-03-16 21:32:59107#include "content/public/browser/browser_thread.h"
[email protected]87f3c082011-10-19 18:07:44108#include "content/public/browser/content_browser_client.h"
[email protected]e582fdd2011-12-20 16:48:17109#include "content/public/browser/download_manager.h"
Kent Tamura512a27e2018-10-04 00:49:32110#include "content/public/browser/file_select_listener.h"
ekaramada110f642016-12-21 19:47:28111#include "content/public/browser/focused_node_details.h"
ekaramad1beabecc2016-09-23 20:18:17112#include "content/public/browser/guest_mode.h"
[email protected]d9083482012-01-06 00:38:46113#include "content/public/browser/invalidate_type.h"
[email protected]71a88bb2013-02-01 22:05:15114#include "content/public/browser/javascript_dialog_manager.h"
skyf65d9bb2017-03-24 02:26:39115#include "content/public/browser/keyboard_event_processing_result.h"
[email protected]09d31d52012-03-11 22:30:27116#include "content/public/browser/load_notification_details.h"
[email protected]5b96836f2011-12-22 07:39:00117#include "content/public/browser/navigation_details.h"
[email protected]375fa1b2012-05-22 22:05:37118#include "content/public/browser/notification_details.h"
[email protected]be2510c02012-05-28 14:52:14119#include "content/public/browser/notification_service.h"
scottmg011d96e32016-06-29 19:15:08120#include "content/public/browser/notification_types.h"
[email protected]95640212014-07-26 18:14:30121#include "content/public/browser/render_widget_host_iterator.h"
Lukasz Anforowicze1b954d92017-10-30 21:28:06122#include "content/public/browser/restore_type.h"
estark5ea80e52015-06-19 18:43:12123#include "content/public/browser/security_style_explanations.h"
falken52a56e32016-12-08 05:02:40124#include "content/public/browser/ssl_status.h"
[email protected]4c3a23582012-08-18 08:54:34125#include "content/public/browser/storage_partition.h"
Ken Rockotfd03e682019-06-20 21:13:54126#include "content/public/browser/system_connector.h"
rockotf62002a2016-09-15 00:08:59127#include "content/public/browser/web_contents_binding_set.h"
[email protected]674bc592011-12-20 23:00:42128#include "content/public/browser/web_contents_delegate.h"
Lei Zhangee3b63ad2018-06-06 23:25:31129#include "content/public/browser/web_ui_controller.h"
[email protected]e091df82011-10-11 18:13:21130#include "content/public/common/bindings_policy.h"
alexmosc9e76ec2016-05-16 22:59:37131#include "content/public/common/child_process_host.h"
Hans Wennborg5ffd1392019-10-16 11:00:02132#include "content/public/common/content_client.h"
[email protected]54087fe2011-10-28 22:02:48133#include "content/public/common/content_constants.h"
Francois Doray3f2afbd2018-04-06 19:18:18134#include "content/public/common/content_features.h"
[email protected]64d69de42012-02-06 00:19:54135#include "content/public/common/content_switches.h"
Lukasz Anforowicze1b954d92017-10-30 21:28:06136#include "content/public/common/page_state.h"
Leon Han963dc182018-11-06 05:41:48137#include "content/public/common/referrer_type_converters.h"
[email protected]04cbd3d2013-12-04 04:58:20138#include "content/public/common/result_codes.h"
[email protected]f16cc6782013-12-16 23:42:57139#include "content/public/common/url_utils.h"
danakjffc8baf2019-10-10 23:49:42140#include "content/public/common/use_zoom_for_dsf_policy.h"
[email protected]b3a97b52014-07-09 06:25:05141#include "content/public/common/web_preferences.h"
Max Morinddebb972018-09-20 10:04:14142#include "media/base/user_input_monitor.h"
wjmaclean64951902016-04-29 20:59:12143#include "net/base/url_util.h"
[email protected]8bfc8272013-09-09 20:10:53144#include "net/http/http_cache.h"
145#include "net/http/http_transaction_factory.h"
rhalavati0fbaeef32017-06-01 15:56:30146#include "net/traffic_annotation/network_traffic_annotation.h"
[email protected]8bfc8272013-09-09 20:10:53147#include "net/url_request/url_request_context.h"
[email protected]abe2c032011-03-31 18:49:34148#include "net/url_request/url_request_context_getter.h"
Scott Violet02e38b92018-03-27 23:42:14149#include "ppapi/buildflags/buildflags.h"
Ke He31d0bb02018-02-24 07:16:24150#include "services/device/public/mojom/constants.mojom.h"
Mounir Lamourifd9dcefa2017-07-06 10:26:55151#include "services/metrics/public/cpp/ukm_recorder.h"
John Abd-El-Malekb175a612018-12-03 20:11:58152#include "services/network/public/cpp/features.h"
Ke He7319dbe2017-11-09 05:54:44153#include "services/service_manager/public/cpp/connector.h"
rockot734fb662016-10-15 16:41:30154#include "services/service_manager/public/cpp/interface_provider.h"
Becca Hughes6daf5662018-06-27 16:50:54155#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
Blink Reformata30d4232018-04-07 15:31:06156#include "third_party/blink/public/common/frame/sandbox_flags.h"
157#include "third_party/blink/public/common/mime_util/mime_util.h"
danakj938b37a62019-09-24 18:35:54158#include "third_party/blink/public/common/page/page_zoom.h"
Sergio Villar Senin9d9d4f52019-10-15 10:57:57159#include "third_party/blink/public/common/security/security_style.h"
Dave Tapuskaa4189512019-10-15 20:27:34160#include "third_party/blink/public/mojom/frame/fullscreen.mojom.h"
Takuto Ikutaaa3b796c2019-02-06 02:54:56161#include "third_party/blink/public/mojom/loader/pause_subresource_loading_handle.mojom.h"
Antonio Gomes0d42960a2019-06-05 12:35:51162#include "third_party/blink/public/mojom/mediastream/media_stream.mojom-shared.h"
halton.huoca2eabd2015-07-06 08:17:40163#include "third_party/skia/include/core/SkBitmap.h"
dmazzonid95ae842016-04-12 21:17:39164#include "ui/accessibility/ax_tree_combiner.h"
[email protected]a08412b62012-05-29 21:28:56165#include "ui/base/layout.h"
Daniel Cheng90196c82018-04-25 21:49:14166#include "ui/events/base_event_utils.h"
chongz4a9751942016-08-17 17:49:39167#include "ui/events/blink/web_input_event_traits.h"
[email protected]66bd5512012-08-01 02:02:52168#include "ui/gl/gl_switches.h"
[email protected]3c733bde2010-12-21 19:56:31169
ekaramada110f642016-12-21 19:47:28170#if defined(OS_WIN)
171#include "content/browser/renderer_host/dip_util.h"
172#include "ui/gfx/geometry/dip_util.h"
173#endif
174
[email protected]583418cc2013-01-17 14:01:10175#if defined(OS_ANDROID)
mfomitchev2b8b066a2016-01-28 19:23:15176#include "content/browser/android/date_time_chooser_android.h"
sammcf5f1b0f2016-09-20 23:05:11177#include "content/browser/android/java_interfaces_impl.h"
Leon Hanccb985f2019-08-26 02:43:24178#include "content/browser/android/nfc_host.h"
[email protected]155c7f22013-12-09 17:07:18179#include "content/browser/web_contents/web_contents_android.h"
Ke He31d0bb02018-02-24 07:16:24180#include "services/device/public/mojom/nfc.mojom.h"
mcnee336ea2c2017-05-23 22:50:59181#else // !OS_ANDROID
182#include "content/browser/host_zoom_map_impl.h"
mfomitchev2b8b066a2016-01-28 19:23:15183#endif // OS_ANDROID
[email protected]583418cc2013-01-17 14:01:10184
brettw4b461082016-11-19 18:55:16185#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17186#include "content/browser/media/session/pepper_playback_observer.h"
Lei Zhangebcc6302018-01-12 19:46:45187#endif
zqzhang181047e62016-07-01 13:37:17188
[email protected]8ff00d72012-10-23 19:12:21189namespace content {
Abigail Kleinaa898742019-11-01 02:31:25190
191using AccessibilityEventCallback =
192 base::RepeatingCallback<void(const std::string&)>;
193
[email protected]420ae012009-04-24 05:16:32194namespace {
195
[email protected]960b0372014-05-19 18:01:00196const int kMinimumDelayBetweenLoadingUpdatesMS = 100;
[email protected]82114f52012-03-20 22:53:41197const char kDotGoogleDotCom[] = ".google.com";
[email protected]ca406032011-07-19 21:53:05198
Avi Drissmana9114822018-03-23 18:25:55199base::LazyInstance<std::vector<
200 WebContentsImpl::FriendWrapper::CreatedCallback>>::DestructorAtExit
201 g_created_callbacks = LAZY_INSTANCE_INITIALIZER;
[email protected]cbb1ef592013-06-05 19:49:46202
dcheng57e39e22016-01-21 00:25:38203bool HasMatchingProcess(FrameTree* tree, int render_process_id) {
204 for (FrameTreeNode* node : tree->Nodes()) {
205 if (node->current_frame_host()->GetProcess()->GetID() == render_process_id)
206 return true;
alexmos4cf2aa32015-07-15 23:40:43207 }
dcheng57e39e22016-01-21 00:25:38208 return false;
[email protected]95640212014-07-26 18:14:30209}
210
kenrb19221852016-04-29 17:21:40211bool HasMatchingWidgetHost(FrameTree* tree, RenderWidgetHost* host) {
212 // This method scans the frame tree rather than checking whether
213 // host->delegate() == this, which allows it to return false when the host
214 // for a frame that is pending or pending deletion.
215 if (!host)
216 return false;
217
218 for (FrameTreeNode* node : tree->Nodes()) {
219 if (node->current_frame_host()->GetRenderWidgetHost() == host)
220 return true;
221 }
222 return false;
223}
224
dmazzonif8a31042016-12-03 00:52:13225void UpdateAccessibilityModeOnFrame(RenderFrameHost* frame_host) {
226 static_cast<RenderFrameHostImpl*>(frame_host)->UpdateAccessibilityMode();
[email protected]95640212014-07-26 18:14:30227}
228
dtseng0dd3fa12015-07-22 19:00:52229void ResetAccessibility(RenderFrameHost* rfh) {
230 static_cast<RenderFrameHostImpl*>(rfh)->AccessibilityReset();
231}
232
paulmeyerfeafc2d2017-04-25 21:46:40233// Helper for GetInnerWebContents().
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:16234bool GetInnerWebContentsHelper(std::vector<WebContents*>* all_guest_contents,
235 WebContents* guest_contents) {
Ehsan Karamad6beb2ea2018-11-25 18:15:13236 auto* web_contents_impl = static_cast<WebContentsImpl*>(guest_contents);
237 if (web_contents_impl->GetBrowserPluginGuest()->attached() &&
238 !GuestMode::IsCrossProcessFrameGuest(web_contents_impl)) {
239 all_guest_contents->push_back(web_contents_impl);
240 }
paulmeyerfeafc2d2017-04-25 21:46:40241 return false;
242}
243
Ian Clelland5cbaaf82017-11-27 22:00:03244RenderFrameHostImpl* FindOpenerRFH(const WebContents::CreateParams& params) {
245 RenderFrameHostImpl* opener_rfh = nullptr;
alexmose201c7cd2015-06-10 17:14:21246 if (params.opener_render_frame_id != MSG_ROUTING_NONE) {
Ian Clelland5cbaaf82017-11-27 22:00:03247 opener_rfh = RenderFrameHostImpl::FromID(params.opener_render_process_id,
248 params.opener_render_frame_id);
alexmose201c7cd2015-06-10 17:14:21249 }
Ian Clelland5cbaaf82017-11-27 22:00:03250 return opener_rfh;
lukasza6f8ac622017-06-06 03:10:20251}
252
Dominick Ng37a15052018-07-17 23:56:35253// Returns |true| if |type| is the kind of user input that should trigger the
254// user interaction observers.
255bool IsUserInteractionInputType(blink::WebInputEvent::Type type) {
256 // Ideally, this list would be based more off of
257 // https://whatwg.org/C/interaction.html#triggered-by-user-activation.
258 return type == blink::WebInputEvent::kMouseDown ||
259 type == blink::WebInputEvent::kGestureScrollBegin ||
260 type == blink::WebInputEvent::kTouchStart ||
261 type == blink::WebInputEvent::kRawKeyDown;
262}
263
Pavel Feldman3c1842b2017-08-02 05:00:16264// Ensures that OnDialogClosed is only called once.
265class CloseDialogCallbackWrapper
266 : public base::RefCountedThreadSafe<CloseDialogCallbackWrapper> {
267 public:
Avi Drissmane04d3992017-10-05 15:11:36268 using CloseCallback =
269 base::OnceCallback<void(bool, bool, const base::string16&)>;
270
271 explicit CloseDialogCallbackWrapper(CloseCallback callback)
272 : callback_(std::move(callback)) {}
Pavel Feldman3c1842b2017-08-02 05:00:16273
274 void Run(bool dialog_was_suppressed,
275 bool success,
276 const base::string16& user_input) {
Avi Drissmane04d3992017-10-05 15:11:36277 if (callback_.is_null())
Pavel Feldman3c1842b2017-08-02 05:00:16278 return;
Avi Drissmane04d3992017-10-05 15:11:36279 std::move(callback_).Run(dialog_was_suppressed, success, user_input);
Pavel Feldman3c1842b2017-08-02 05:00:16280 }
281
282 private:
283 friend class base::RefCountedThreadSafe<CloseDialogCallbackWrapper>;
284 ~CloseDialogCallbackWrapper() {}
Avi Drissmane04d3992017-10-05 15:11:36285
286 CloseCallback callback_;
Pavel Feldman3c1842b2017-08-02 05:00:16287};
288
Arthur Sonzogni929d29f2018-09-17 14:19:44289bool FrameCompareDepth(RenderFrameHostImpl* a, RenderFrameHostImpl* b) {
290 return a->frame_tree_node()->depth() < b->frame_tree_node()->depth();
291}
292
Raymes Khoury58373df2019-08-06 06:29:20293bool AreValidRegisterProtocolHandlerArguments(const std::string& protocol,
294 const GURL& url,
295 const url::Origin& origin) {
296 ChildProcessSecurityPolicyImpl* policy =
297 ChildProcessSecurityPolicyImpl::GetInstance();
298 if (policy->IsPseudoScheme(protocol))
299 return false;
300
301 url::Origin url_origin = url::Origin::Create(url);
302 if (url_origin.opaque())
303 return false;
304
305 if (!url_origin.IsSameOriginWith(origin))
306 return false;
307
308 return true;
309}
310
yilkal796e89e2019-10-02 23:58:28311void RecordMaxFrameCountUMA(size_t max_frame_count) {
312 UMA_HISTOGRAM_COUNTS_10000("Navigation.MainFrame.MaxFrameCount",
313 max_frame_count);
314}
315
lukasza6f8ac622017-06-06 03:10:20316} // namespace
317
Erik Chenbb8e738e2018-04-28 14:10:43318std::unique_ptr<WebContents> WebContents::Create(
319 const WebContents::CreateParams& params) {
Albert J. Wong65fe64d2019-09-20 02:48:14320 return WebContentsImpl::Create(params);
321}
322
323std::unique_ptr<WebContentsImpl> WebContentsImpl::Create(
324 const CreateParams& params) {
325 return CreateWithOpener(params, FindOpenerRFH(params));
[email protected]d1198fd2012-08-13 22:50:19326}
327
erikchenade1fef2018-05-02 22:07:57328std::unique_ptr<WebContents> WebContents::CreateWithSessionStorage(
[email protected]54944cde2012-12-09 09:24:59329 const WebContents::CreateParams& params,
[email protected]fdac6ade2013-07-20 01:06:30330 const SessionStorageNamespaceMap& session_storage_namespace_map) {
erikchenade1fef2018-05-02 22:07:57331 std::unique_ptr<WebContentsImpl> new_contents(
332 new WebContentsImpl(params.browser_context));
Ian Clelland5cbaaf82017-11-27 22:00:03333 RenderFrameHostImpl* opener_rfh = FindOpenerRFH(params);
334 FrameTreeNode* opener = nullptr;
335 if (opener_rfh)
336 opener = opener_rfh->frame_tree_node();
337 new_contents->SetOpenerForNewContents(opener, params.opener_suppressed);
[email protected]fdac6ade2013-07-20 01:06:30338
jdoerrie55ec69d2018-10-08 13:34:46339 for (auto it = session_storage_namespace_map.begin();
340 it != session_storage_namespace_map.end(); ++it) {
[email protected]fdac6ade2013-07-20 01:06:30341 new_contents->GetController()
342 .SetSessionStorageNamespace(it->first, it->second.get());
343 }
344
Sean Toppingbbc4a2bd2019-01-30 02:16:14345 WebContentsImpl* outer_web_contents = nullptr;
Sam McNally69a33772018-06-27 16:54:12346 if (params.guest_delegate) {
347 // This makes |new_contents| act as a guest.
348 // For more info, see comment above class BrowserPluginGuest.
Albert J. Wongc55cc64d2018-10-12 02:50:04349 BrowserPluginGuest::CreateInWebContents(new_contents.get(),
350 params.guest_delegate);
Sean Toppingbbc4a2bd2019-01-30 02:16:14351 outer_web_contents = static_cast<WebContentsImpl*>(
352 params.guest_delegate->GetOwnerWebContents());
Sam McNally69a33772018-06-27 16:54:12353 }
354
[email protected]54944cde2012-12-09 09:24:59355 new_contents->Init(params);
Sean Toppingbbc4a2bd2019-01-30 02:16:14356 if (outer_web_contents)
357 outer_web_contents->InnerWebContentsCreated(new_contents.get());
[email protected]d1198fd2012-08-13 22:50:19358 return new_contents;
[email protected]a81343d232011-12-27 07:39:20359}
[email protected]746d3052012-05-22 15:15:47360
benwells5e7260d2017-03-20 23:36:33361void WebContentsImpl::FriendWrapper::AddCreatedCallbackForTesting(
nickf9acfbe2014-12-23 19:12:37362 const CreatedCallback& callback) {
[email protected]cbb1ef592013-06-05 19:49:46363 g_created_callbacks.Get().push_back(callback);
364}
365
benwells5e7260d2017-03-20 23:36:33366void WebContentsImpl::FriendWrapper::RemoveCreatedCallbackForTesting(
nickf9acfbe2014-12-23 19:12:37367 const CreatedCallback& callback) {
[email protected]cbb1ef592013-06-05 19:49:46368 for (size_t i = 0; i < g_created_callbacks.Get().size(); ++i) {
Robert Liao1db5a352019-06-05 20:57:34369 if (g_created_callbacks.Get().at(i) == callback) {
[email protected]cbb1ef592013-06-05 19:49:46370 g_created_callbacks.Get().erase(g_created_callbacks.Get().begin() + i);
371 return;
372 }
373 }
374}
375
avidf38c952015-10-27 13:45:13376WebContents* WebContents::FromRenderViewHost(RenderViewHost* rvh) {
377 if (!rvh)
378 return nullptr;
[email protected]746d3052012-05-22 15:15:47379 return rvh->GetDelegate()->GetAsWebContents();
380}
381
[email protected]a86c0e962013-12-17 17:10:39382WebContents* WebContents::FromRenderFrameHost(RenderFrameHost* rfh) {
avidf38c952015-10-27 13:45:13383 if (!rfh)
384 return nullptr;
385 return static_cast<RenderFrameHostImpl*>(rfh)->delegate()->GetAsWebContents();
[email protected]a86c0e962013-12-17 17:10:39386}
387
ananta4b7467a52016-09-23 01:42:38388WebContents* WebContents::FromFrameTreeNodeId(int frame_tree_node_id) {
389 FrameTreeNode* frame_tree_node =
390 FrameTreeNode::GloballyFindByID(frame_tree_node_id);
anantab8cfa3b2016-10-14 22:43:19391 if (!frame_tree_node)
392 return nullptr;
jam8c4edd02017-05-06 18:50:33393 return WebContentsImpl::FromFrameTreeNode(frame_tree_node);
ananta4b7467a52016-09-23 01:42:38394}
395
leon.han552e9de2017-02-09 14:37:30396void WebContents::SetScreenOrientationDelegate(
397 ScreenOrientationDelegate* delegate) {
398 ScreenOrientationProvider::SetDelegate(delegate);
399}
400
[email protected]7fff43e2013-05-21 20:21:10401// WebContentsImpl::DestructionObserver ----------------------------------------
402
403class WebContentsImpl::DestructionObserver : public WebContentsObserver {
404 public:
405 DestructionObserver(WebContentsImpl* owner, WebContents* watched_contents)
406 : WebContentsObserver(watched_contents),
407 owner_(owner) {
408 }
409
410 // WebContentsObserver:
dchengc2282aa2014-10-21 12:07:58411 void WebContentsDestroyed() override {
[email protected]12a46832014-05-09 13:35:58412 owner_->OnWebContentsDestroyed(
413 static_cast<WebContentsImpl*>(web_contents()));
[email protected]7fff43e2013-05-21 20:21:10414 }
415
416 private:
417 WebContentsImpl* owner_;
418
419 DISALLOW_COPY_AND_ASSIGN(DestructionObserver);
420};
421
Joel Hockey85b379d2017-12-11 10:42:13422// WebContentsImpl::ColorChooser ----------------------------------------------
Joel Hockey163835a2017-12-20 11:51:57423class WebContentsImpl::ColorChooser : public blink::mojom::ColorChooser {
Joel Hockey85b379d2017-12-11 10:42:13424 public:
425 ColorChooser(content::ColorChooser* chooser,
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20426 mojo::PendingReceiver<blink::mojom::ColorChooser> receiver,
427 mojo::PendingRemote<blink::mojom::ColorChooserClient> client)
Joel Hockey85b379d2017-12-11 10:42:13428 : chooser_(chooser),
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20429 receiver_(this, std::move(receiver)),
Joel Hockey85b379d2017-12-11 10:42:13430 client_(std::move(client)) {
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20431 receiver_.set_disconnect_handler(
Joel Hockey85b379d2017-12-11 10:42:13432 base::BindOnce([](content::ColorChooser* chooser) { chooser->End(); },
433 base::Unretained(chooser)));
434 }
[email protected]8ed16472014-04-11 19:02:48435
Joel Hockey85b379d2017-12-11 10:42:13436 ~ColorChooser() override { chooser_->End(); }
[email protected]8ed16472014-04-11 19:02:48437
Joel Hockey85b379d2017-12-11 10:42:13438 void SetSelectedColor(SkColor color) override {
439 chooser_->SetSelectedColor(color);
440 }
441
442 void DidChooseColorInColorChooser(SkColor color) {
443 client_->DidChooseColor(color);
444 }
445
446 private:
447 // Color chooser that was opened by this tab.
448 std::unique_ptr<content::ColorChooser> chooser_;
449
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20450 // mojo receiver.
451 mojo::Receiver<blink::mojom::ColorChooser> receiver_;
Joel Hockey85b379d2017-12-11 10:42:13452
453 // mojo renderer client.
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20454 mojo::Remote<blink::mojom::ColorChooserClient> client_;
Joel Hockey85b379d2017-12-11 10:42:13455};
nicka0ac8382016-12-15 23:59:23456
lazyboy6ec48b2a2015-06-29 15:18:14457// WebContentsImpl::WebContentsTreeNode ----------------------------------------
lfg601233692017-03-06 22:45:44458WebContentsImpl::WebContentsTreeNode::WebContentsTreeNode(
459 WebContentsImpl* current_web_contents)
460 : current_web_contents_(current_web_contents),
461 outer_web_contents_(nullptr),
lazyboy6ec48b2a2015-06-29 15:18:14462 outer_contents_frame_tree_node_id_(
avallee0206f782016-07-28 18:55:33463 FrameTreeNode::kFrameTreeNodeInvalidId),
lfg601233692017-03-06 22:45:44464 focused_web_contents_(current_web_contents) {}
lazyboy6ec48b2a2015-06-29 15:18:14465
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18466WebContentsImpl::WebContentsTreeNode::~WebContentsTreeNode() {}
lazyboy6ec48b2a2015-06-29 15:18:14467
Lucas Furukawa Gadani99125822019-01-03 15:41:49468std::unique_ptr<WebContents>
469WebContentsImpl::WebContentsTreeNode::DisconnectFromOuterWebContents() {
470 std::unique_ptr<WebContents> inner_contents =
471 outer_web_contents_->node_.DetachInnerWebContents(current_web_contents_);
472 OuterContentsFrameTreeNode()->RemoveObserver(this);
473 outer_contents_frame_tree_node_id_ = FrameTreeNode::kFrameTreeNodeInvalidId;
474 outer_web_contents_ = nullptr;
475 return inner_contents;
476}
477
paulmeyerfeafc2d2017-04-25 21:46:40478void WebContentsImpl::WebContentsTreeNode::AttachInnerWebContents(
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:50479 std::unique_ptr<WebContents> inner_web_contents,
480 RenderFrameHostImpl* render_frame_host) {
481 WebContentsImpl* inner_web_contents_impl =
482 static_cast<WebContentsImpl*>(inner_web_contents.get());
483 WebContentsTreeNode& inner_web_contents_node = inner_web_contents_impl->node_;
484
485 inner_web_contents_node.focused_web_contents_ = nullptr;
486 inner_web_contents_node.outer_web_contents_ = current_web_contents_;
487 inner_web_contents_node.outer_contents_frame_tree_node_id_ =
488 render_frame_host->frame_tree_node()->frame_tree_node_id();
489
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18490 inner_web_contents_.push_back(std::move(inner_web_contents));
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:50491
492 render_frame_host->frame_tree_node()->AddObserver(&inner_web_contents_node);
paulmeyerfeafc2d2017-04-25 21:46:40493}
494
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18495std::unique_ptr<WebContents>
496WebContentsImpl::WebContentsTreeNode::DetachInnerWebContents(
paulmeyerfeafc2d2017-04-25 21:46:40497 WebContentsImpl* inner_web_contents) {
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18498 std::unique_ptr<WebContents> detached_contents;
499 for (std::unique_ptr<WebContents>& web_contents : inner_web_contents_) {
500 if (web_contents.get() == inner_web_contents) {
501 detached_contents = std::move(web_contents);
502 std::swap(web_contents, inner_web_contents_.back());
503 inner_web_contents_.pop_back();
504 return detached_contents;
505 }
506 }
507
508 NOTREACHED();
509 return nullptr;
paulmeyerfeafc2d2017-04-25 21:46:40510}
511
lfga3e2bdc2017-03-07 20:44:01512FrameTreeNode*
513WebContentsImpl::WebContentsTreeNode::OuterContentsFrameTreeNode() const {
514 return FrameTreeNode::GloballyFindByID(outer_contents_frame_tree_node_id_);
lfg601233692017-03-06 22:45:44515}
516
lfga3e2bdc2017-03-07 20:44:01517void WebContentsImpl::WebContentsTreeNode::OnFrameTreeNodeDestroyed(
518 FrameTreeNode* node) {
519 DCHECK_EQ(outer_contents_frame_tree_node_id_, node->frame_tree_node_id())
520 << "WebContentsTreeNode should only receive notifications for the "
521 "FrameTreeNode in its outer WebContents that hosts it.";
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18522
523 // Deletes |this| too.
524 outer_web_contents_->node_.DetachInnerWebContents(current_web_contents_);
lazyboy6ec48b2a2015-06-29 15:18:14525}
526
avallee0206f782016-07-28 18:55:33527void WebContentsImpl::WebContentsTreeNode::SetFocusedWebContents(
528 WebContentsImpl* web_contents) {
529 DCHECK(!outer_web_contents())
530 << "Only the outermost WebContents tracks focus.";
531 focused_web_contents_ = web_contents;
532}
533
paulmeyerfeafc2d2017-04-25 21:46:40534WebContentsImpl*
535WebContentsImpl::WebContentsTreeNode::GetInnerWebContentsInFrame(
536 const FrameTreeNode* frame) {
537 auto ftn_id = frame->frame_tree_node_id();
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18538 for (auto& contents : inner_web_contents_) {
539 WebContentsImpl* impl = static_cast<WebContentsImpl*>(contents.get());
540 if (impl->node_.outer_contents_frame_tree_node_id() == ftn_id) {
541 return impl;
paulmeyerfeafc2d2017-04-25 21:46:40542 }
543 }
544 return nullptr;
545}
546
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18547std::vector<WebContentsImpl*>
548WebContentsImpl::WebContentsTreeNode::GetInnerWebContents() const {
549 std::vector<WebContentsImpl*> inner_web_contents;
550 for (auto& contents : inner_web_contents_)
551 inner_web_contents.push_back(static_cast<WebContentsImpl*>(contents.get()));
552
553 return inner_web_contents;
paulmeyerfeafc2d2017-04-25 21:46:40554}
555
[email protected]b172aee2012-04-10 17:05:26556// WebContentsImpl -------------------------------------------------------------
[email protected]420ae012009-04-24 05:16:32557
alexmose201c7cd2015-06-10 17:14:21558WebContentsImpl::WebContentsImpl(BrowserContext* browser_context)
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28559 : delegate_(nullptr),
[email protected]69e797f2013-04-30 01:10:22560 controller_(this, browser_context),
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28561 render_view_host_delegate_view_(nullptr),
alexmose201c7cd2015-06-10 17:14:21562 created_with_opener_(false),
Lucas Furukawa Gadani99125822019-01-03 15:41:49563 node_(this),
[email protected]6ea6bdf2013-12-06 13:35:01564 frame_tree_(new NavigatorImpl(&controller_, this),
blundellc57b93f2014-10-29 13:19:57565 this,
566 this,
567 this,
568 this),
[email protected]6dfed692014-05-22 04:18:03569 is_load_to_different_document_(false),
[email protected]443b80e2010-12-14 00:42:23570 crashed_status_(base::TERMINATION_STATUS_STILL_RUNNING),
571 crashed_error_code_(0),
[email protected]d5f942ba2008-09-26 19:30:34572 waiting_for_response_(false),
[email protected]fcf75d42013-12-03 20:11:26573 load_state_(net::LOAD_STATE_IDLE, base::string16()),
[email protected]094e5b22009-09-25 04:23:56574 upload_size_(0),
575 upload_position_(0),
dfalcantarae6b7b46752015-07-10 18:14:16576 is_resume_pending_(false),
creisadca9862017-06-16 19:12:11577 interstitial_page_(nullptr),
[email protected]b4c84012014-04-28 19:51:10578 has_accessed_initial_document_(false),
[email protected]54597982013-02-06 01:59:55579 capturer_count_(0),
[email protected]fdd61c62009-04-22 19:22:57580 is_being_destroyed_(false),
creis97867aa2017-02-17 18:39:45581 is_notifying_observers_(false),
[email protected]fdd61c62009-04-22 19:22:57582 notify_disconnection_(false),
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28583 dialog_manager_(nullptr),
[email protected]7ab1e7d62009-10-14 23:32:01584 is_showing_before_unload_dialog_(false),
gab0dccfef2015-05-20 18:43:39585 last_active_time_(base::TimeTicks::Now()),
[email protected]ebf40a72010-07-22 01:46:38586 closed_by_user_gesture_(false),
danakj938b37a62019-09-24 18:35:54587 minimum_zoom_percent_(
588 static_cast<int>(blink::kMinimumPageZoomFactor * 100)),
589 maximum_zoom_percent_(
590 static_cast<int>(blink::kMaximumPageZoomFactor * 100)),
w.shackleton49bcd392016-01-06 17:38:22591 zoom_scroll_remainder_(0),
alexmosc9e76ec2016-05-16 22:59:37592 fullscreen_widget_process_id_(ChildProcessHost::kInvalidUniqueID),
[email protected]5dcaf8e2013-12-28 01:31:42593 fullscreen_widget_routing_id_(MSG_ROUTING_NONE),
[email protected]0b431992014-06-24 00:08:03594 fullscreen_widget_had_focus_at_shutdown_(false),
[email protected]34ff1cfc2014-08-20 06:16:05595 force_disable_overscroll_content_(false),
[email protected]95640212014-07-26 18:14:30596 last_dialog_suppressed_(false),
waffles1c12bf402016-02-10 17:45:48597 accessibility_mode_(
Dominic Mazzoni21fb0282019-02-13 18:32:47598 GetContentClient()->browser()->GetAXModeForBrowserContext(
599 browser_context)),
avayvodcc85bbd2015-08-28 19:11:15600 audio_stream_monitor_(this),
Thomas Guilbert882c4cec2019-02-14 05:55:45601 media_web_contents_observer_(
602 std::make_unique<MediaWebContentsObserver>(this)),
mcnee336ea2c2017-05-23 22:50:59603#if !defined(OS_ANDROID)
mcnee432e47d2015-11-09 19:37:46604 page_scale_factor_is_one_(true),
mcnee336ea2c2017-05-23 22:50:59605#endif // !defined(OS_ANDROID)
qinmin72e8bd02016-10-21 19:35:37606 is_overlay_content_(false),
ekaramadf6750aa2017-06-06 18:29:42607 showing_context_menu_(false),
W. James MacLean62198672019-06-04 16:46:10608 text_autosizer_page_info_({0, 0, 1.f}),
Jeremy Roman3bca4bf2019-07-11 03:41:25609 had_inner_webcontents_(false) {
[email protected]9b159a52013-10-03 17:24:55610 frame_tree_.SetFrameRemoveListener(
611 base::Bind(&WebContentsImpl::OnFrameRemoved,
612 base::Unretained(this)));
brettw4b461082016-11-19 18:55:16613#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17614 pepper_playback_observer_.reset(new PepperPlaybackObserver(this));
615#endif
blundelle75a8f92017-03-27 08:11:17616
Becca Hughes86334622018-07-09 21:29:38617#if defined(OS_ANDROID)
Elly Fong-Jonescdd7ae82019-02-20 23:26:33618 display_cutout_host_impl_ = std::make_unique<DisplayCutoutHostImpl>(this);
Becca Hughes86334622018-07-09 21:29:38619#endif
[email protected]332af7732009-03-11 13:21:35620}
initial.commit09911bf2008-07-26 23:55:29621
[email protected]b172aee2012-04-10 17:05:26622WebContentsImpl::~WebContentsImpl() {
creisba91ba82017-05-12 22:56:19623 // Imperfect sanity check against double free, given some crashes unexpectedly
624 // observed in the wild.
625 CHECK(!is_being_destroyed_);
626
627 // We generally keep track of is_being_destroyed_ to let other features know
628 // to avoid certain actions during destruction.
[email protected]420ae012009-04-24 05:16:32629 is_being_destroyed_ = true;
630
creis97867aa2017-02-17 18:39:45631 // A WebContents should never be deleted while it is notifying observers,
creisba91ba82017-05-12 22:56:19632 // since this will lead to a use-after-free as it continues to notify later
creis97867aa2017-02-17 18:39:45633 // observers.
634 CHECK(!is_notifying_observers_);
635
kenrb2a565f82015-09-02 20:24:59636 rwh_input_event_router_.reset();
637
rockotf62002a2016-09-15 00:08:59638 for (auto& entry : binding_sets_)
639 entry.second->CloseAllBindings();
640
avallee0206f782016-07-28 18:55:33641 WebContentsImpl* outermost = GetOutermostWebContents();
avallee9993fca2016-11-17 06:16:50642 if (this != outermost && ContainsOrIsFocusedWebContents()) {
avallee0206f782016-07-28 18:55:33643 // If the current WebContents is in focus, unset it.
avallee9993fca2016-11-17 06:16:50644 outermost->SetAsFocusedWebContentsIfNecessary();
avallee0206f782016-07-28 18:55:33645 }
646
Nick Carterd73635b2018-03-13 18:31:41647 if (mouse_lock_widget_)
648 mouse_lock_widget_->RejectMouseLockOrUnlockIfNecessary();
649
dcheng72be33c2016-01-21 04:11:31650 for (FrameTreeNode* node : frame_tree_.Nodes()) {
651 // Delete all RFHs pending shutdown, which will lead the corresponding RVHs
652 // to be shutdown and be deleted as well.
dcheng57e39e22016-01-21 00:25:38653 node->render_manager()->ClearRFHsPendingShutdown();
dcheng57e39e22016-01-21 00:25:38654 node->render_manager()->ClearWebUIInstances();
dcheng72be33c2016-01-21 04:11:31655 }
carlosk35f35af2015-12-01 10:55:40656
dcheng57e39e22016-01-21 00:25:38657 for (RenderWidgetHostImpl* widget : created_widgets_)
658 widget->DetachDelegate();
[email protected]b24b68a2012-09-24 21:57:26659 created_widgets_.clear();
660
[email protected]3ab9cb82011-06-03 18:02:07661 // Clear out any JavaScript state.
avi5d3b8692016-10-12 22:00:46662 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:53663 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:46664 }
[email protected]3ab9cb82011-06-03 18:02:07665
Joel Hockey85b379d2017-12-11 10:42:13666 color_chooser_.reset();
Rakina Zata Amni16196122018-11-14 02:14:00667 find_request_manager_.reset();
[email protected]da8543762012-03-20 08:52:20668
[email protected]420ae012009-04-24 05:16:32669 NotifyDisconnected();
[email protected]420ae012009-04-24 05:16:32670
[email protected]ca13a442012-04-17 14:00:12671 // Notify any observer that have a reference on this WebContents.
[email protected]8ff00d72012-10-23 19:12:21672 NotificationService::current()->Notify(
673 NOTIFICATION_WEB_CONTENTS_DESTROYED,
674 Source<WebContents>(this),
675 NotificationService::NoDetails());
[email protected]420ae012009-04-24 05:16:32676
Arthur Sonzogni5a9a88c2018-10-18 13:16:00677 // Destroy all subframes now. This notifies observers.
678 GetMainFrame()->ResetChildren();
[email protected]df0c843f2014-05-23 20:37:23679 GetRenderManager()->ResetProxyHosts();
[email protected]c06c58c2014-03-12 20:31:59680
clamy0e119882015-07-31 16:12:33681 // Manually call the observer methods for the root frame tree node. It is
682 // necessary to manually delete all objects tracking navigations
683 // (NavigationHandle, NavigationRequest) for observers to be properly
684 // notified of these navigations stopping before the WebContents is
685 // destroyed.
[email protected]df0c843f2014-05-23 20:37:23686 RenderFrameHostManager* root = GetRenderManager();
naskob21fe4872015-02-24 14:15:56687
Lowell Manners20250112019-10-18 15:06:15688 GetController().GetBackForwardCache().Shutdown();
689
naskob21fe4872015-02-24 14:15:56690 root->current_frame_host()->SetRenderFrameCreated(false);
clamyfc3850d2018-02-23 14:35:28691 root->current_frame_host()->ResetNavigationRequests();
clamy0e119882015-07-31 16:12:33692
Arthur Hemeryc3380172018-01-22 14:00:17693 // Do not update state as the WebContents is being destroyed.
Arthur Hemery241b9392019-10-24 11:08:41694 frame_tree_.root()->ResetNavigationRequest(true);
Arthur Hemeryc3380172018-01-22 14:00:17695 if (root->speculative_frame_host()) {
danakjf2342432019-05-15 21:46:09696 root->speculative_frame_host()->DeleteRenderFrame(
697 FrameDeleteIntention::kSpeculativeMainFrameForShutdown);
Arthur Hemeryc3380172018-01-22 14:00:17698 root->speculative_frame_host()->SetRenderFrameCreated(false);
clamyfc3850d2018-02-23 14:35:28699 root->speculative_frame_host()->ResetNavigationRequests();
clamy0e119882015-07-31 16:12:33700 }
[email protected]f273ee52013-10-18 16:05:27701
brettw4b461082016-11-19 18:55:16702#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17703 // Call this before WebContentsDestroyed() is broadcasted since
704 // AudioFocusManager will be destroyed after that.
705 pepper_playback_observer_.reset();
706#endif // defined(ENABLED_PLUGINS)
707
Chris Hamiltondf0d72cd2018-05-29 16:23:53708 // If audio is playing then notify external observers of the audio stream
709 // disappearing.
710 if (is_currently_audible_) {
711 is_currently_audible_ = false;
712 for (auto& observer : observers_)
713 observer.OnAudioStateChanged(false);
714
715 if (GetOuterWebContents())
716 GetOuterWebContents()->OnAudioStateChanged();
717 }
718
ericwilligersde386342016-10-19 02:35:09719 for (auto& observer : observers_)
720 observer.FrameDeleted(root->current_frame_host());
naskoa83483fb2015-02-27 16:57:10721
ericwilligersde386342016-10-19 02:35:09722 for (auto& observer : observers_)
723 observer.RenderViewDeleted(root->current_host());
[email protected]f273ee52013-10-18 16:05:27724
Kevin McNee576bb5d82019-05-29 16:47:51725#if defined(OS_ANDROID)
726 // For simplicity, destroy the Java WebContents before we notify of the
727 // destruction of the WebContents.
728 ClearWebContentsAndroid();
729#endif
730
ericwilligersde386342016-10-19 02:35:09731 for (auto& observer : observers_)
732 observer.WebContentsDestroyed();
[email protected]12a46832014-05-09 13:35:58733
Becca Hughesd11d6502018-07-31 17:01:28734 if (display_cutout_host_impl_)
735 display_cutout_host_impl_->WebContentsDestroyed();
736
ericwilligersde386342016-10-19 02:35:09737 for (auto& observer : observers_)
738 observer.ResetWebContents();
[email protected]232a5812011-03-04 22:42:08739
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28740 SetDelegate(nullptr);
[email protected]b5a1d11c2011-02-17 03:09:42741}
742
erikchen50735fd2018-05-05 15:08:33743std::unique_ptr<WebContentsImpl> WebContentsImpl::CreateWithOpener(
[email protected]54944cde2012-12-09 09:24:59744 const WebContents::CreateParams& params,
Ian Clelland5cbaaf82017-11-27 22:00:03745 RenderFrameHostImpl* opener_rfh) {
[email protected]e11f0e92013-06-12 15:12:03746 TRACE_EVENT0("browser", "WebContentsImpl::CreateWithOpener");
Ian Clelland5cbaaf82017-11-27 22:00:03747 FrameTreeNode* opener = nullptr;
748 if (opener_rfh)
749 opener = opener_rfh->frame_tree_node();
erikchen50735fd2018-05-05 15:08:33750 std::unique_ptr<WebContentsImpl> new_contents(
751 new WebContentsImpl(params.browser_context));
lukasza6f8ac622017-06-06 03:10:20752 new_contents->SetOpenerForNewContents(opener, params.opener_suppressed);
alexmose201c7cd2015-06-10 17:14:21753
alexmosaedfc6f2016-01-21 23:57:38754 // If the opener is sandboxed, a new popup must inherit the opener's sandbox
755 // flags, and these flags take effect immediately. An exception is if the
756 // opener's sandbox flags lack the PropagatesToAuxiliaryBrowsingContexts
757 // bit (which is controlled by the "allow-popups-to-escape-sandbox" token).
758 // See https://html.spec.whatwg.org/#attr-iframe-sandbox.
lukasza6f8ac622017-06-06 03:10:20759 FrameTreeNode* new_root = new_contents->GetFrameTree()->root();
alexmosaedfc6f2016-01-21 23:57:38760 if (opener) {
Ian Clelland5cbaaf82017-11-27 22:00:03761 blink::WebSandboxFlags opener_flags = opener_rfh->active_sandbox_flags();
alexmosaedfc6f2016-01-21 23:57:38762 const blink::WebSandboxFlags inherit_flag =
Blink Reformat1c4d759e2017-04-09 16:34:54763 blink::WebSandboxFlags::kPropagatesToAuxiliaryBrowsingContexts;
Ehsan Karamad39407082019-02-19 23:38:19764 bool sandbox_propagates_to_auxilary_context =
765 (opener_flags & inherit_flag) == inherit_flag;
766 if (sandbox_propagates_to_auxilary_context)
Ian Clellandcdc4f312017-10-13 22:24:12767 new_root->SetPendingFramePolicy({opener_flags, {}});
Ehsan Karamad39407082019-02-19 23:38:19768 if (opener_flags == blink::WebSandboxFlags::kNone ||
769 sandbox_propagates_to_auxilary_context) {
770 // TODO(ekaramad, iclelland): Do not propagate feature policies from non-
771 // sandboxed disowned openers (rel=noopener).
772 // If the current page is not sandboxed, or if the sandbox is to propagate
773 // to the popups then opener's feature policy will apply to the new popup
774 // as well.
775 new_root->SetOpenerFeaturePolicyState(
Ehsan Karamad34d10682019-02-26 20:55:04776 opener_rfh->feature_policy()->GetFeatureState());
alexmosaedfc6f2016-01-21 23:57:38777 }
778 }
779
mark a. foltzef394fce2017-10-21 09:11:02780 // Apply starting sandbox flags.
Luna Luc3fdacdf2017-11-08 04:48:53781 blink::FramePolicy frame_policy(new_root->pending_frame_policy());
mark a. foltzef394fce2017-10-21 09:11:02782 frame_policy.sandbox_flags |= params.starting_sandbox_flags;
783 new_root->SetPendingFramePolicy(frame_policy);
784 new_root->CommitPendingFramePolicy();
785
alexmose201c7cd2015-06-10 17:14:21786 // This may be true even when opener is null, such as when opening blocked
787 // popups.
alexmos090fae8e2015-05-28 17:09:28788 if (params.created_with_opener)
789 new_contents->created_with_opener_ = true;
790
Sean Toppingbbc4a2bd2019-01-30 02:16:14791 WebContentsImpl* outer_web_contents = nullptr;
[email protected]4858e432014-06-23 18:14:17792 if (params.guest_delegate) {
[email protected]83100cd2014-05-10 11:50:06793 // This makes |new_contents| act as a guest.
794 // For more info, see comment above class BrowserPluginGuest.
Albert J. Wongc55cc64d2018-10-12 02:50:04795 BrowserPluginGuest::CreateInWebContents(new_contents.get(),
796 params.guest_delegate);
Sean Toppingbbc4a2bd2019-01-30 02:16:14797 outer_web_contents = static_cast<WebContentsImpl*>(
798 params.guest_delegate->GetOwnerWebContents());
[email protected]83100cd2014-05-10 11:50:06799 }
mark a. foltzef394fce2017-10-21 09:11:02800
[email protected]54944cde2012-12-09 09:24:59801 new_contents->Init(params);
Sean Toppingbbc4a2bd2019-01-30 02:16:14802 if (outer_web_contents)
803 outer_web_contents->InnerWebContentsCreated(new_contents.get());
[email protected]d1198fd2012-08-13 22:50:19804 return new_contents;
805}
806
[email protected]95640212014-07-26 18:14:30807// static
808std::vector<WebContentsImpl*> WebContentsImpl::GetAllWebContents() {
809 std::vector<WebContentsImpl*> result;
dcheng59716272016-04-09 05:19:08810 std::unique_ptr<RenderWidgetHostIterator> widgets(
[email protected]95640212014-07-26 18:14:30811 RenderWidgetHostImpl::GetRenderWidgetHosts());
[email protected]95640212014-07-26 18:14:30812 while (RenderWidgetHost* rwh = widgets->GetNextHost()) {
[email protected]95640212014-07-26 18:14:30813 RenderViewHost* rvh = RenderViewHost::From(rwh);
814 if (!rvh)
815 continue;
816 WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
817 if (!web_contents)
818 continue;
avidf38c952015-10-27 13:45:13819 if (web_contents->GetRenderViewHost() != rvh)
820 continue;
821 // Because a WebContents can only have one current RVH at a time, there will
822 // be no duplicate WebContents here.
823 result.push_back(static_cast<WebContentsImpl*>(web_contents));
[email protected]95640212014-07-26 18:14:30824 }
825 return result;
826}
827
clamya16aa8172015-05-26 13:07:25828// static
829WebContentsImpl* WebContentsImpl::FromFrameTreeNode(
paulmeyerfeafc2d2017-04-25 21:46:40830 const FrameTreeNode* frame_tree_node) {
clamya16aa8172015-05-26 13:07:25831 return static_cast<WebContentsImpl*>(
832 WebContents::FromRenderFrameHost(frame_tree_node->current_frame_host()));
833}
834
clamy0d32d6d2015-11-24 11:16:26835// static
836WebContents* WebContentsImpl::FromRenderFrameHostID(int render_process_host_id,
837 int render_frame_host_id) {
Min Qina1150112019-02-15 01:47:49838 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
839 !BrowserThread::IsThreadInitialized(BrowserThread::UI));
clamy0d32d6d2015-11-24 11:16:26840 RenderFrameHost* render_frame_host =
841 RenderFrameHost::FromID(render_process_host_id, render_frame_host_id);
842 if (!render_frame_host)
843 return nullptr;
844
845 return WebContents::FromRenderFrameHost(render_frame_host);
846}
847
paulmeyerfeafc2d2017-04-25 21:46:40848// static
849WebContentsImpl* WebContentsImpl::FromOuterFrameTreeNode(
850 const FrameTreeNode* frame_tree_node) {
851 return WebContentsImpl::FromFrameTreeNode(frame_tree_node)
852 ->node_.GetInnerWebContentsInFrame(frame_tree_node);
853}
854
[email protected]b0936d22013-11-28 06:47:36855RenderFrameHostManager* WebContentsImpl::GetRenderManagerForTesting() {
[email protected]fa944cb82013-11-15 17:51:21856 return GetRenderManager();
[email protected]765187182012-01-11 23:59:28857}
858
nicka0ac8382016-12-15 23:59:23859bool WebContentsImpl::OnMessageReceived(RenderViewHostImpl* render_view_host,
[email protected]7bb761892012-07-20 09:32:47860 const IPC::Message& message) {
nicka0ac8382016-12-15 23:59:23861 for (auto& observer : observers_) {
Lukasz Anforowicz89f2c1b2017-08-30 21:36:46862 // TODO(nick, creis): https://crbug.com/758026: Replace all uses of this
863 // variant of OnMessageReceived with the version that takes a
864 // RenderFrameHost, and then delete it.
nicka0ac8382016-12-15 23:59:23865 if (observer.OnMessageReceived(message))
866 return true;
[email protected]64ffefa2014-05-10 12:06:33867 }
[email protected]403415a2011-01-10 18:57:53868
[email protected]724159a2010-12-30 01:11:18869 bool handled = true;
nicka0ac8382016-12-15 23:59:23870 IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(WebContentsImpl, message, render_view_host)
nicka0ac8382016-12-15 23:59:23871 IPC_MESSAGE_HANDLER(ViewHostMsg_PageScaleFactorChanged,
872 OnPageScaleFactorChanged)
W. James MacLean62198672019-06-04 16:46:10873 IPC_MESSAGE_HANDLER(
874 ViewHostMsg_NotifyTextAutosizerPageInfoChangedInLocalMainFrame,
875 OnTextAutosizerPageInfoChanged)
nicka0ac8382016-12-15 23:59:23876#if BUILDFLAG(ENABLE_PLUGINS)
877 IPC_MESSAGE_HANDLER(ViewHostMsg_RequestPpapiBrokerPermission,
878 OnRequestPpapiBrokerPermission)
879#endif
nicka0ac8382016-12-15 23:59:23880 IPC_MESSAGE_UNHANDLED(handled = false)
881 IPC_END_MESSAGE_MAP()
882
883 return handled;
884}
885
886bool WebContentsImpl::OnMessageReceived(RenderFrameHostImpl* render_frame_host,
887 const IPC::Message& message) {
Lukasz Anforowicz02923102017-10-09 18:11:37888 {
889 WebUIImpl* web_ui = render_frame_host->web_ui();
890 if (web_ui && web_ui->OnMessageReceived(message, render_frame_host))
891 return true;
892 }
893
nicka0ac8382016-12-15 23:59:23894 for (auto& observer : observers_) {
895 if (observer.OnMessageReceived(message, render_frame_host))
896 return true;
897 }
898
899 bool handled = true;
900 IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(WebContentsImpl, message, render_frame_host)
[email protected]cfa856d62014-02-22 07:58:40901 IPC_MESSAGE_HANDLER(FrameHostMsg_DomOperationResponse,
902 OnDomOperationResponse)
[email protected]8ed16472014-04-11 19:02:48903 IPC_MESSAGE_HANDLER(FrameHostMsg_DidFinishLoad, OnDidFinishLoad)
avi7830c852015-08-31 23:46:25904 IPC_MESSAGE_HANDLER(FrameHostMsg_DidLoadResourceFromMemoryCache,
[email protected]724159a2010-12-30 01:11:18905 OnDidLoadResourceFromMemoryCache)
avi3a3332622015-09-01 01:18:54906 IPC_MESSAGE_HANDLER(FrameHostMsg_DidRunInsecureContent,
[email protected]724159a2010-12-30 01:11:18907 OnDidRunInsecureContent)
estark910b4572015-12-09 20:55:41908 IPC_MESSAGE_HANDLER(FrameHostMsg_DidDisplayContentWithCertificateErrors,
909 OnDidDisplayContentWithCertificateErrors)
910 IPC_MESSAGE_HANDLER(FrameHostMsg_DidRunContentWithCertificateErrors,
911 OnDidRunContentWithCertificateErrors)
Dave Tapuska549baab2019-03-19 15:52:40912 IPC_MESSAGE_HANDLER(FrameHostMsg_GoToEntryAtOffset, OnGoToEntryAtOffset)
kouhei40f03cb2015-09-24 07:47:01913 IPC_MESSAGE_HANDLER(FrameHostMsg_UpdatePageImportanceSignals,
914 OnUpdatePageImportanceSignals)
lukasza178ff092017-06-07 23:39:50915 IPC_MESSAGE_HANDLER(FrameHostMsg_UpdateFaviconURL, OnUpdateFaviconURL)
brettw4b461082016-11-19 18:55:16916#if BUILDFLAG(ENABLE_PLUGINS)
emaxxe70f5e12015-05-29 11:26:00917 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperInstanceCreated,
918 OnPepperInstanceCreated)
919 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperInstanceDeleted,
920 OnPepperInstanceDeleted)
tommyclie6633ca72014-10-31 00:40:42921 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperPluginHung, OnPepperPluginHung)
zqzhang181047e62016-07-01 13:37:17922 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperStartsPlayback,
923 OnPepperStartsPlayback)
924 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperStopsPlayback,
925 OnPepperStopsPlayback)
tommyclie6633ca72014-10-31 00:40:42926 IPC_MESSAGE_HANDLER(FrameHostMsg_PluginCrashed, OnPluginCrashed)
[email protected]c4538072013-03-18 02:17:55927 IPC_MESSAGE_HANDLER_GENERIC(BrowserPluginHostMsg_Attach,
fsamuel833ee7c2015-02-13 23:40:40928 OnBrowserPluginMessage(render_frame_host,
929 message))
thestigc4cac8f2014-09-04 21:17:50930#endif
[email protected]724159a2010-12-30 01:11:18931 IPC_MESSAGE_UNHANDLED(handled = false)
[email protected]e44d1342014-05-16 21:29:33932 IPC_END_MESSAGE_MAP()
[email protected]724159a2010-12-30 01:11:18933
[email protected]724159a2010-12-30 01:11:18934 return handled;
935}
936
[email protected]d1198fd2012-08-13 22:50:19937NavigationControllerImpl& WebContentsImpl::GetController() {
[email protected]f5fa20e2011-12-21 22:35:56938 return controller_;
939}
940
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41941BrowserContext* WebContentsImpl::GetBrowserContext() {
[email protected]a26023822011-12-29 00:23:55942 return controller_.GetBrowserContext();
[email protected]627e0512011-12-21 22:55:30943}
944
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41945const GURL& WebContentsImpl::GetURL() {
Peter Boström101d7672018-12-15 00:43:59946 return GetVisibleURL();
[email protected]be1f56ab2011-12-22 06:55:31947}
948
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41949const GURL& WebContentsImpl::GetVisibleURL() {
[email protected]c854a7e2013-05-21 16:42:24950 // We may not have a navigation entry yet.
[email protected]59167c22013-06-03 18:07:32951 NavigationEntry* entry = controller_.GetVisibleEntry();
[email protected]c854a7e2013-05-21 16:42:24952 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
953}
954
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41955const GURL& WebContentsImpl::GetLastCommittedURL() {
[email protected]c854a7e2013-05-21 16:42:24956 // We may not have a navigation entry yet.
957 NavigationEntry* entry = controller_.GetLastCommittedEntry();
958 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
959}
960
[email protected]8ff00d72012-10-23 19:12:21961WebContentsDelegate* WebContentsImpl::GetDelegate() {
[email protected]be1f56ab2011-12-22 06:55:31962 return delegate_;
963}
964
[email protected]8ff00d72012-10-23 19:12:21965void WebContentsImpl::SetDelegate(WebContentsDelegate* delegate) {
[email protected]be1f56ab2011-12-22 06:55:31966 // TODO(cbentzel): remove this debugging code?
967 if (delegate == delegate_)
968 return;
969 if (delegate_)
970 delegate_->Detach(this);
971 delegate_ = delegate;
[email protected]a6b73c62013-02-11 23:05:08972 if (delegate_) {
[email protected]be1f56ab2011-12-22 06:55:31973 delegate_->Attach(this);
[email protected]a6b73c62013-02-11 23:05:08974 // Ensure the visible RVH reflects the new delegate's preferences.
[email protected]86f98a22013-03-20 14:35:00975 if (view_)
[email protected]e85165c642014-06-10 14:34:31976 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
Joel Einbinder848001c2017-09-19 21:39:31977 if (GetRenderViewHost())
978 RenderFrameDevToolsAgentHost::WebContentsCreated(this);
[email protected]a6b73c62013-02-11 23:05:08979 }
[email protected]be1f56ab2011-12-22 06:55:31980}
981
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41982RenderFrameHostImpl* WebContentsImpl::GetMainFrame() {
[email protected]94d0cc12013-12-18 00:07:41983 return frame_tree_.root()->current_frame_host();
[email protected]60eca4eb2013-12-06 00:02:16984}
985
nick53d5cbf2015-04-23 22:50:14986RenderFrameHostImpl* WebContentsImpl::GetFocusedFrame() {
987 FrameTreeNode* focused_node = frame_tree_.GetFocusedFrame();
988 if (!focused_node)
989 return nullptr;
990 return focused_node->current_frame_host();
[email protected]9c9343b2014-03-08 02:56:07991}
992
rob3e2a0732016-01-06 21:22:09993RenderFrameHostImpl* WebContentsImpl::FindFrameByFrameTreeNodeId(
creisf71a2632017-05-04 19:03:50994 int frame_tree_node_id,
995 int process_id) {
996 FrameTreeNode* frame = frame_tree_.FindByID(frame_tree_node_id);
997
998 // Sanity check that this is in the caller's expected process. Otherwise a
999 // recent cross-process navigation may have led to a privilege change that the
1000 // caller is not expecting.
1001 if (!frame ||
1002 frame->current_frame_host()->GetProcess()->GetID() != process_id)
1003 return nullptr;
1004
1005 return frame->current_frame_host();
1006}
1007
1008RenderFrameHostImpl* WebContentsImpl::UnsafeFindFrameByFrameTreeNodeId(
rob3e2a0732016-01-06 21:22:091009 int frame_tree_node_id) {
creisf71a2632017-05-04 19:03:501010 // Beware using this! The RenderFrameHost may have changed since the caller
1011 // obtained frame_tree_node_id.
rob3e2a0732016-01-06 21:22:091012 FrameTreeNode* frame = frame_tree_.FindByID(frame_tree_node_id);
1013 return frame ? frame->current_frame_host() : nullptr;
1014}
1015
[email protected]a86c0e962013-12-17 17:10:391016void WebContentsImpl::ForEachFrame(
Lei Zhangebcc6302018-01-12 19:46:451017 const base::RepeatingCallback<void(RenderFrameHost*)>& on_frame) {
dcheng57e39e22016-01-21 00:25:381018 for (FrameTreeNode* node : frame_tree_.Nodes()) {
1019 on_frame.Run(node->current_frame_host());
1020 }
[email protected]a86c0e962013-12-17 17:10:391021}
1022
dchengafb53e22016-02-04 08:11:081023std::vector<RenderFrameHost*> WebContentsImpl::GetAllFrames() {
1024 std::vector<RenderFrameHost*> frame_hosts;
1025 for (FrameTreeNode* node : frame_tree_.Nodes())
1026 frame_hosts.push_back(node->current_frame_host());
1027 return frame_hosts;
1028}
1029
lukaszacbdf52e2016-01-15 21:19:511030int WebContentsImpl::SendToAllFrames(IPC::Message* message) {
1031 int number_of_messages = 0;
dchengafb53e22016-02-04 08:11:081032 for (RenderFrameHost* rfh : GetAllFrames()) {
lukasza1a9ab2422016-03-02 18:47:251033 if (!rfh->IsRenderFrameLive())
1034 continue;
1035
dchengafb53e22016-02-04 08:11:081036 ++number_of_messages;
1037 IPC::Message* message_copy = new IPC::Message(*message);
1038 message_copy->set_routing_id(rfh->GetRoutingID());
1039 rfh->Send(message_copy);
1040 }
[email protected]a86c0e962013-12-17 17:10:391041 delete message;
lukaszacbdf52e2016-01-15 21:19:511042 return number_of_messages;
[email protected]a86c0e962013-12-17 17:10:391043}
1044
lfgdb5c4ed2016-03-04 23:09:071045void WebContentsImpl::SendPageMessage(IPC::Message* msg) {
alexmos136fd6e62016-08-15 20:58:411046 frame_tree_.root()->render_manager()->SendPageMessage(msg, nullptr);
lfgdb5c4ed2016-03-04 23:09:071047}
1048
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411049RenderViewHostImpl* WebContentsImpl::GetRenderViewHost() {
[email protected]fa944cb82013-11-15 17:51:211050 return GetRenderManager()->current_host();
[email protected]be1f56ab2011-12-22 06:55:311051}
1052
creis89a0f782015-05-27 16:13:171053void WebContentsImpl::CancelActiveAndPendingDialogs() {
avi5d3b8692016-10-12 22:00:461054 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:531055 dialog_manager_->CancelDialogs(this, /*reset_state=*/false);
avi5d3b8692016-10-12 22:00:461056 }
creis89a0f782015-05-27 16:13:171057 if (browser_plugin_embedder_)
1058 browser_plugin_embedder_->CancelGuestDialogs();
1059}
1060
naskoc0fceff2015-04-30 15:53:521061void WebContentsImpl::ClosePage() {
1062 GetRenderViewHost()->ClosePage();
1063}
1064
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411065RenderWidgetHostView* WebContentsImpl::GetRenderWidgetHostView() {
[email protected]fa944cb82013-11-15 17:51:211066 return GetRenderManager()->GetRenderWidgetHostView();
[email protected]be1f56ab2011-12-22 06:55:311067}
1068
lfg265a2672016-04-23 03:11:021069RenderWidgetHostView* WebContentsImpl::GetTopLevelRenderWidgetHostView() {
1070 if (GetOuterWebContents())
1071 return GetOuterWebContents()->GetTopLevelRenderWidgetHostView();
1072 return GetRenderManager()->GetRenderWidgetHostView();
1073}
1074
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411075RenderWidgetHostView* WebContentsImpl::GetFullscreenRenderWidgetHostView() {
vmpstr6d9996c82017-02-23 00:43:251076 if (auto* widget_host = GetFullscreenRenderWidgetHost())
ekaramadaeb3c5c2016-11-09 03:22:351077 return widget_host->GetView();
1078 return nullptr;
[email protected]4aebbca2013-09-17 22:26:491079}
1080
[email protected]8ff00d72012-10-23 19:12:211081WebContentsView* WebContentsImpl::GetView() const {
[email protected]be1f56ab2011-12-22 06:55:311082 return view_.get();
1083}
1084
leon.han552e9de2017-02-09 14:37:301085void WebContentsImpl::OnScreenOrientationChange() {
1086 DCHECK(screen_orientation_provider_);
Becca Hughese9e27952018-06-25 17:08:271087 screen_orientation_provider_->OnOrientationChange();
leon.hane4db177a2017-02-07 14:19:161088}
1089
Alan Cutter92d59252019-03-29 02:32:331090base::Optional<SkColor> WebContentsImpl::GetThemeColor() {
Carlos Caballero1215f882019-10-29 15:58:431091 return GetRenderViewHost()->theme_color();
yusufod41c5f92015-03-06 00:14:281092}
1093
Doug Turner63f3c7b2017-07-29 05:10:011094void WebContentsImpl::SetAccessibilityMode(ui::AXMode mode) {
[email protected]95640212014-07-26 18:14:301095 if (mode == accessibility_mode_)
1096 return;
1097
dmazzonif8a31042016-12-03 00:52:131098 // Don't allow accessibility to be enabled for WebContents that are never
1099 // visible, like background pages.
1100 if (IsNeverVisible())
1101 return;
1102
[email protected]95640212014-07-26 18:14:301103 accessibility_mode_ = mode;
dcheng57e39e22016-01-21 00:25:381104
1105 for (FrameTreeNode* node : frame_tree_.Nodes()) {
dmazzonif8a31042016-12-03 00:52:131106 UpdateAccessibilityModeOnFrame(node->current_frame_host());
clamy610c63b32017-12-22 15:05:181107 // Also update accessibility mode on the speculative RenderFrameHost for
1108 // this FrameTreeNode, if one exists.
Alex Moshchuk3d8a1f392017-10-24 19:01:261109 RenderFrameHost* speculative_frame_host =
1110 node->render_manager()->speculative_frame_host();
1111 if (speculative_frame_host)
1112 UpdateAccessibilityModeOnFrame(speculative_frame_host);
dcheng57e39e22016-01-21 00:25:381113 }
[email protected]95640212014-07-26 18:14:301114}
1115
Doug Turner63f3c7b2017-07-29 05:10:011116void WebContentsImpl::AddAccessibilityMode(ui::AXMode mode) {
1117 ui::AXMode new_mode(accessibility_mode_);
dougtcd3dad732017-03-14 03:26:231118 new_mode |= mode;
1119 SetAccessibilityMode(new_mode);
[email protected]95640212014-07-26 18:14:301120}
1121
Avi Drissman1e620f32018-03-16 13:57:291122// Helper class used by WebContentsImpl::RequestAXTreeSnapshot.
1123// Handles the callbacks from parallel snapshot requests to each frame,
1124// and feeds the results to an AXTreeCombiner, which converts them into a
1125// single combined accessibility tree.
1126class WebContentsImpl::AXTreeSnapshotCombiner
1127 : public base::RefCounted<AXTreeSnapshotCombiner> {
1128 public:
1129 explicit AXTreeSnapshotCombiner(AXTreeSnapshotCallback callback)
1130 : callback_(std::move(callback)) {}
1131
1132 AXTreeSnapshotCallback AddFrame(bool is_root) {
1133 // Adds a reference to |this|.
1134 return base::BindOnce(&AXTreeSnapshotCombiner::ReceiveSnapshot, this,
1135 is_root);
1136 }
1137
1138 void ReceiveSnapshot(bool is_root, const ui::AXTreeUpdate& snapshot) {
1139 combiner_.AddTree(snapshot, is_root);
1140 }
1141
1142 private:
1143 friend class base::RefCounted<AXTreeSnapshotCombiner>;
1144
1145 // This is called automatically after the last call to ReceiveSnapshot
1146 // when there are no more references to this object.
1147 ~AXTreeSnapshotCombiner() {
1148 combiner_.Combine();
1149 std::move(callback_).Run(combiner_.combined());
1150 }
1151
1152 ui::AXTreeCombiner combiner_;
1153 AXTreeSnapshotCallback callback_;
1154};
1155
1156void WebContentsImpl::RequestAXTreeSnapshot(AXTreeSnapshotCallback callback,
1157 ui::AXMode ax_mode) {
dmazzonid95ae842016-04-12 21:17:391158 // Send a request to each of the frames in parallel. Each one will return
1159 // an accessibility tree snapshot, and AXTreeSnapshotCombiner will combine
1160 // them into a single tree and call |callback| with that result, then
1161 // delete |combiner|.
Avi Drissman1e620f32018-03-16 13:57:291162 FrameTreeNode* root_node = frame_tree_.root();
tzik58faa742018-08-01 10:54:181163 auto combiner =
1164 base::MakeRefCounted<AXTreeSnapshotCombiner>(std::move(callback));
Avi Drissman1e620f32018-03-16 13:57:291165
tzik58faa742018-08-01 10:54:181166 RecursiveRequestAXTreeSnapshotOnFrame(root_node, combiner.get(), ax_mode);
Avi Drissman1e620f32018-03-16 13:57:291167}
1168
1169void WebContentsImpl::RecursiveRequestAXTreeSnapshotOnFrame(
1170 FrameTreeNode* root_node,
1171 AXTreeSnapshotCombiner* combiner,
1172 ui::AXMode ax_mode) {
dmazzonid95ae842016-04-12 21:17:391173 for (FrameTreeNode* frame_tree_node : frame_tree_.Nodes()) {
Avi Drissman1e620f32018-03-16 13:57:291174 WebContentsImpl* inner_contents =
1175 node_.GetInnerWebContentsInFrame(frame_tree_node);
1176 if (inner_contents) {
1177 inner_contents->RecursiveRequestAXTreeSnapshotOnFrame(root_node, combiner,
1178 ax_mode);
1179 } else {
1180 bool is_root = frame_tree_node == root_node;
1181 frame_tree_node->current_frame_host()->RequestAXTreeSnapshot(
1182 combiner->AddFrame(is_root), ax_mode);
1183 }
dmazzonid95ae842016-04-12 21:17:391184 }
dmazzoni83ba5c82015-04-14 07:11:511185}
1186
Becca Hughes3b5a43482018-07-17 22:31:551187void WebContentsImpl::NotifyViewportFitChanged(
1188 blink::mojom::ViewportFit value) {
1189 for (auto& observer : observers_)
1190 observer.ViewportFitChanged(value);
1191}
1192
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411193FindRequestManager* WebContentsImpl::GetFindRequestManagerForTesting() {
Ehsan Karamad6beb2ea2018-11-25 18:15:131194 return GetFindRequestManager();
1195}
1196
mcnee336ea2c2017-05-23 22:50:591197#if !defined(OS_ANDROID)
akabac6bd1212018-06-25 20:10:481198void WebContentsImpl::UpdateZoom() {
1199 RenderWidgetHostImpl* rwh = GetRenderViewHost()->GetWidget();
1200 if (rwh->GetView())
1201 rwh->SynchronizeVisualProperties();
wjmaclean64951902016-04-29 20:59:121202}
1203
wjmaclean64951902016-04-29 20:59:121204
1205void WebContentsImpl::UpdateZoomIfNecessary(const std::string& scheme,
akabac6bd1212018-06-25 20:10:481206 const std::string& host) {
wjmaclean64951902016-04-29 20:59:121207 NavigationEntry* entry = GetController().GetLastCommittedEntry();
1208 if (!entry)
1209 return;
1210
1211 GURL url = HostZoomMap::GetURLFromEntry(entry);
1212 if (host != net::GetHostOrSpecFromURL(url) ||
1213 (!scheme.empty() && !url.SchemeIs(scheme))) {
1214 return;
1215 }
1216
akabac6bd1212018-06-25 20:10:481217 UpdateZoom();
wjmaclean64951902016-04-29 20:59:121218}
mcnee336ea2c2017-05-23 22:50:591219#endif // !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:121220
rockotf62002a2016-09-15 00:08:591221base::Closure WebContentsImpl::AddBindingSet(
1222 const std::string& interface_name,
1223 WebContentsBindingSet* binding_set) {
1224 auto result =
1225 binding_sets_.insert(std::make_pair(interface_name, binding_set));
1226 DCHECK(result.second);
1227 return base::Bind(&WebContentsImpl::RemoveBindingSet,
1228 weak_factory_.GetWeakPtr(), interface_name);
1229}
1230
rockot8bbad222017-03-22 04:34:051231WebContentsBindingSet* WebContentsImpl::GetBindingSet(
1232 const std::string& interface_name) {
1233 auto it = binding_sets_.find(interface_name);
1234 if (it == binding_sets_.end())
1235 return nullptr;
1236 return it->second;
1237}
1238
paulmeyerfeafc2d2017-04-25 21:46:401239std::vector<WebContentsImpl*> WebContentsImpl::GetWebContentsAndAllInner() {
1240 std::vector<WebContentsImpl*> all_contents(1, this);
1241
1242 for (size_t i = 0; i != all_contents.size(); ++i) {
1243 for (auto* inner_contents : all_contents[i]->GetInnerWebContents()) {
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:161244 all_contents.push_back(static_cast<WebContentsImpl*>(inner_contents));
paulmeyerfeafc2d2017-04-25 21:46:401245 }
1246 }
1247
1248 return all_contents;
1249}
1250
Sam McNally145fb172017-05-10 00:13:231251void WebContentsImpl::NotifyManifestUrlChanged(
1252 const base::Optional<GURL>& manifest_url) {
1253 for (auto& observer : observers_)
1254 observer.DidUpdateWebManifestURL(manifest_url);
1255}
1256
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411257WebUI* WebContentsImpl::GetWebUI() {
Nasko Oskov2f7d2112019-10-29 03:26:571258 WebUI* committed_web_ui = GetCommittedWebUI();
1259 if (committed_web_ui)
1260 return committed_web_ui;
1261
1262 if (GetRenderManager()->speculative_frame_host())
1263 return GetRenderManager()->speculative_frame_host()->web_ui();
1264
1265 return nullptr;
[email protected]be1f56ab2011-12-22 06:55:311266}
1267
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411268WebUI* WebContentsImpl::GetCommittedWebUI() {
carlosk35f35af2015-12-01 10:55:401269 return frame_tree_.root()->current_frame_host()->web_ui();
[email protected]d5f942ba2008-09-26 19:30:341270}
1271
Changwan Ryuc1134a82018-03-07 02:10:141272void WebContentsImpl::SetUserAgentOverride(const std::string& override,
1273 bool override_in_new_tabs) {
[email protected]bf70edce2012-06-20 22:32:221274 if (GetUserAgentOverride() == override)
1275 return;
1276
Changwan Ryuc1134a82018-03-07 02:10:141277 should_override_user_agent_in_new_tabs_ = override_in_new_tabs;
1278
[email protected]bf70edce2012-06-20 22:32:221279 renderer_preferences_.user_agent_override = override;
1280
Bruce Long1e3e1f542019-10-16 17:56:281281 // Send the new override string to all renderers in the current page.
1282 SyncRendererPrefs();
[email protected]bf70edce2012-06-20 22:32:221283
1284 // Reload the page if a load is currently in progress to avoid having
1285 // different parts of the page loaded using different user agents.
[email protected]6286a372013-10-09 04:03:271286 NavigationEntry* entry = controller_.GetVisibleEntry();
Ivan Kotenkov2c0d2bb32017-11-01 15:41:281287 if (IsLoading() && entry != nullptr && entry->GetIsOverridingUserAgent())
toyoshim6142d96f2016-12-19 09:07:251288 controller_.Reload(ReloadType::BYPASSING_CACHE, true);
[email protected]8d0f3312012-08-18 01:47:531289
ericwilligersde386342016-10-19 02:35:091290 for (auto& observer : observers_)
1291 observer.UserAgentOverrideSet(override);
[email protected]86ef6a392012-05-11 22:03:111292}
1293
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411294const std::string& WebContentsImpl::GetUserAgentOverride() {
[email protected]bf70edce2012-06-20 22:32:221295 return renderer_preferences_.user_agent_override;
[email protected]86ef6a392012-05-11 22:03:111296}
1297
Changwan Ryuc1134a82018-03-07 02:10:141298bool WebContentsImpl::ShouldOverrideUserAgentInNewTabs() {
1299 return should_override_user_agent_in_new_tabs_;
1300}
1301
dmazzonidd3d51a72016-12-14 18:41:011302void WebContentsImpl::EnableWebContentsOnlyAccessibilityMode() {
Dominic Mazzonid9fda172019-03-07 17:12:071303 // If accessibility is already enabled, we'll need to force a reset
1304 // in order to ensure new observers of accessibility events get the
1305 // full accessibility tree from scratch.
1306 bool need_reset = GetAccessibilityMode().has_mode(ui::AXMode::kWebContents);
1307
1308 ui::AXMode desired_mode =
1309 GetContentClient()->browser()->GetAXModeForBrowserContext(
1310 GetBrowserContext());
1311 desired_mode |= ui::kAXModeWebContentsOnly;
1312 AddAccessibilityMode(desired_mode);
1313
1314 if (need_reset) {
dchengafb53e22016-02-04 08:11:081315 for (RenderFrameHost* rfh : GetAllFrames())
1316 ResetAccessibility(rfh);
dchengafb53e22016-02-04 08:11:081317 }
[email protected]95640212014-07-26 18:14:301318}
1319
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411320bool WebContentsImpl::IsWebContentsOnlyAccessibilityModeForTesting() {
Doug Turner63f3c7b2017-07-29 05:10:011321 return accessibility_mode_ == ui::kAXModeWebContentsOnly;
[email protected]95640212014-07-26 18:14:301322}
1323
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411324bool WebContentsImpl::IsFullAccessibilityModeForTesting() {
Doug Turner63f3c7b2017-07-29 05:10:011325 return accessibility_mode_ == ui::kAXModeComplete;
[email protected]95640212014-07-26 18:14:301326}
1327
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411328const PageImportanceSignals& WebContentsImpl::GetPageImportanceSignals() {
kouhei40f03cb2015-09-24 07:47:011329 return page_importance_signals_;
1330}
1331
Becca Hughes6daf5662018-06-27 16:50:541332#if defined(OS_ANDROID)
1333
1334void WebContentsImpl::SetDisplayCutoutSafeArea(gfx::Insets insets) {
Becca Hughes86334622018-07-09 21:29:381335 if (display_cutout_host_impl_)
1336 display_cutout_host_impl_->SetDisplayCutoutSafeArea(insets);
Becca Hughes6daf5662018-06-27 16:50:541337}
1338
1339#endif
1340
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411341const base::string16& WebContentsImpl::GetTitle() {
[email protected]4c6092c5b2009-06-06 00:23:551342 // Transient entries take precedence. They are used for interstitial pages
1343 // that are shown on top of existing pages.
[email protected]10f417c52011-12-28 21:04:231344 NavigationEntry* entry = controller_.GetTransientEntry();
[email protected]45d0ef7f2011-01-05 13:46:231345 if (entry) {
jshin1fb76462016-04-05 22:13:031346 return entry->GetTitleForDisplay();
[email protected]45d0ef7f2011-01-05 13:46:231347 }
carlosk35f35af2015-12-01 10:55:401348
Nasko Oskov2f7d2112019-10-29 03:26:571349 WebUI* our_web_ui =
1350 GetRenderManager()->speculative_frame_host()
1351 ? GetRenderManager()->speculative_frame_host()->web_ui()
1352 : GetRenderManager()->current_frame_host()->web_ui();
[email protected]7ade2732011-02-10 00:13:581353 if (our_web_ui) {
[email protected]96d185d2009-04-24 03:28:541354 // Don't override the title in view source mode.
[email protected]59167c22013-06-03 18:07:321355 entry = controller_.GetVisibleEntry();
[email protected]96d185d2009-04-24 03:28:541356 if (!(entry && entry->IsViewSourceMode())) {
[email protected]e0112912011-02-02 22:54:351357 // Give the Web UI the chance to override our title.
[email protected]fcf75d42013-12-03 20:11:261358 const base::string16& title = our_web_ui->GetOverriddenTitle();
[email protected]96d185d2009-04-24 03:28:541359 if (!title.empty())
1360 return title;
1361 }
1362 }
1363
1364 // We use the title for the last committed entry rather than a pending
1365 // navigation entry. For example, when the user types in a URL, we want to
1366 // keep the old page's title until the new load has committed and we get a new
1367 // title.
[email protected]96d185d2009-04-24 03:28:541368 entry = controller_.GetLastCommittedEntry();
[email protected]59167c22013-06-03 18:07:321369
creis072b61f2015-09-28 20:52:241370 // We make an exception for initial navigations. We only want to use the title
1371 // from the visible entry if:
1372 // 1. The pending entry has been explicitly assigned a title to display.
1373 // 2. The user is doing a history navigation in a new tab (e.g., Ctrl+Back),
1374 // which case there is a pending entry index other than -1.
1375 //
1376 // Otherwise, we want to stick with the last committed entry's title during
1377 // new navigations, which have pending entries at index -1 with no title.
1378 if (controller_.IsInitialNavigation() &&
1379 ((controller_.GetVisibleEntry() &&
1380 !controller_.GetVisibleEntry()->GetTitle().empty()) ||
1381 controller_.GetPendingEntryIndex() != -1)) {
1382 entry = controller_.GetVisibleEntry();
[email protected]9eeafc012013-11-25 23:49:471383 }
[email protected]59167c22013-06-03 18:07:321384
[email protected]45d0ef7f2011-01-05 13:46:231385 if (entry) {
jshin1fb76462016-04-05 22:13:031386 return entry->GetTitleForDisplay();
[email protected]45d0ef7f2011-01-05 13:46:231387 }
[email protected]987fc3a2011-05-26 14:18:091388
1389 // |page_title_when_no_navigation_entry_| is finally used
1390 // if no title cannot be retrieved.
1391 return page_title_when_no_navigation_entry_;
[email protected]96d185d2009-04-24 03:28:541392}
1393
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411394SiteInstanceImpl* WebContentsImpl::GetSiteInstance() {
[email protected]fa944cb82013-11-15 17:51:211395 return GetRenderManager()->current_host()->GetSiteInstance();
[email protected]96d185d2009-04-24 03:28:541396}
1397
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411398bool WebContentsImpl::IsLoading() {
clamy44e84ce2016-02-22 15:38:251399 return frame_tree_.IsLoading() &&
creisadca9862017-06-16 19:12:111400 !(ShowingInterstitialPage() && interstitial_page_->pause_throbber());
[email protected]3c9e1872010-11-18 16:17:491401}
1402
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411403double WebContentsImpl::GetLoadProgress() {
Peter Boström18a40fa2018-10-31 19:03:501404 return frame_tree_.load_progress();
1405}
1406
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411407bool WebContentsImpl::IsLoadingToDifferentDocument() {
clamy44e84ce2016-02-22 15:38:251408 return IsLoading() && is_load_to_different_document_;
[email protected]6dfed692014-05-22 04:18:031409}
1410
Alexander Timindd0fa0c52019-11-06 13:03:371411bool WebContentsImpl::IsDocumentOnLoadCompletedInMainFrame() {
1412 return GetRenderViewHost()->IsDocumentOnLoadCompletedInMainFrame();
1413}
1414
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411415bool WebContentsImpl::IsWaitingForResponse() {
Peter Boströma9a27f6e2018-11-21 13:12:191416 NavigationRequest* ongoing_navigation_request =
1417 frame_tree_.root()->navigation_request();
1418
1419 // An ongoing navigation request means we're waiting for a response.
1420 return ongoing_navigation_request != nullptr;
[email protected]be1f56ab2011-12-22 06:55:311421}
1422
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411423const net::LoadStateWithParam& WebContentsImpl::GetLoadState() {
[email protected]be1f56ab2011-12-22 06:55:311424 return load_state_;
1425}
1426
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411427const base::string16& WebContentsImpl::GetLoadStateHost() {
[email protected]be1f56ab2011-12-22 06:55:311428 return load_state_host_;
1429}
1430
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411431uint64_t WebContentsImpl::GetUploadSize() {
[email protected]be1f56ab2011-12-22 06:55:311432 return upload_size_;
1433}
1434
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411435uint64_t WebContentsImpl::GetUploadPosition() {
[email protected]be1f56ab2011-12-22 06:55:311436 return upload_position_;
1437}
1438
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411439const std::string& WebContentsImpl::GetEncoding() {
Alexander Timine5f20e22019-10-09 23:22:351440 return GetMainFrame()->GetEncoding();
[email protected]be1f56ab2011-12-22 06:55:311441}
1442
Charles Zhaod72f99d2018-09-17 14:18:271443bool WebContentsImpl::WasDiscarded() {
1444 return GetFrameTree()->root()->was_discarded();
1445}
1446
Shubhie Panickerddf2a4e2018-03-06 00:09:061447void WebContentsImpl::SetWasDiscarded(bool was_discarded) {
1448 GetFrameTree()->root()->set_was_discarded();
1449}
1450
[email protected]222f5822014-02-05 23:40:491451void WebContentsImpl::IncrementCapturerCount(const gfx::Size& capture_size) {
[email protected]5a652232013-02-12 06:15:251452 DCHECK(!is_being_destroyed_);
Francois Doraye6161152018-03-27 22:05:371453 const bool was_captured = IsBeingCaptured();
[email protected]54597982013-02-06 01:59:551454 ++capturer_count_;
1455 DVLOG(1) << "There are now " << capturer_count_
1456 << " capturing(s) of WebContentsImpl@" << this;
[email protected]222f5822014-02-05 23:40:491457
1458 // Note: This provides a hint to upstream code to size the views optimally
1459 // for quality (e.g., to avoid scaling).
1460 if (!capture_size.IsEmpty() && preferred_size_for_capture_.IsEmpty()) {
1461 preferred_size_for_capture_ = capture_size;
1462 OnPreferredSizeChanged(preferred_size_);
1463 }
ccameron8807c38f2015-01-17 00:29:191464
Collin Baker989e0882019-11-01 01:27:171465 if (!was_captured)
1466 UpdateVisibilityAndNotifyPageAndView(GetVisibility());
[email protected]54597982013-02-06 01:59:551467}
1468
1469void WebContentsImpl::DecrementCapturerCount() {
1470 --capturer_count_;
1471 DVLOG(1) << "There are now " << capturer_count_
1472 << " capturing(s) of WebContentsImpl@" << this;
1473 DCHECK_LE(0, capturer_count_);
1474
[email protected]5a652232013-02-12 06:15:251475 if (is_being_destroyed_)
1476 return;
1477
Francois Doray24fc62c2017-12-11 17:27:331478 if (!IsBeingCaptured()) {
[email protected]222f5822014-02-05 23:40:491479 const gfx::Size old_size = preferred_size_for_capture_;
1480 preferred_size_for_capture_ = gfx::Size();
1481 OnPreferredSizeChanged(old_size);
Collin Baker989e0882019-11-01 01:27:171482 UpdateVisibilityAndNotifyPageAndView(GetVisibility());
[email protected]54597982013-02-06 01:59:551483 }
[email protected]be1f56ab2011-12-22 06:55:311484}
1485
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411486bool WebContentsImpl::IsBeingCaptured() {
Francois Doray24fc62c2017-12-11 17:27:331487 return capturer_count_ > 0;
[email protected]f2bd40812013-07-20 04:30:441488}
1489
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411490bool WebContentsImpl::IsAudioMuted() {
Max Morinb5506f72018-05-16 07:33:101491 if (base::FeatureList::IsEnabled(features::kAudioServiceAudioStreams)) {
1492 return audio_stream_factory_ && audio_stream_factory_->IsMuted();
1493 }
miu50f97892014-09-22 22:49:521494 return audio_muter_.get() && audio_muter_->is_muting();
1495}
1496
1497void WebContentsImpl::SetAudioMuted(bool mute) {
1498 DVLOG(1) << "SetAudioMuted(mute=" << mute << "), was " << IsAudioMuted()
1499 << " for WebContentsImpl@" << this;
1500
1501 if (mute == IsAudioMuted())
1502 return;
1503
Max Morinb5506f72018-05-16 07:33:101504 if (base::FeatureList::IsEnabled(features::kAudioServiceAudioStreams)) {
1505 GetAudioStreamFactory()->SetMuted(mute);
miu50f97892014-09-22 22:49:521506 } else {
Max Morinb5506f72018-05-16 07:33:101507 if (mute) {
1508 if (!audio_muter_)
1509 audio_muter_.reset(new WebContentsAudioMuter(this));
1510 audio_muter_->StartMuting();
1511 } else {
1512 DCHECK(audio_muter_);
1513 audio_muter_->StopMuting();
1514 }
miu50f97892014-09-22 22:49:521515 }
1516
ericwilligersde386342016-10-19 02:35:091517 for (auto& observer : observers_)
1518 observer.DidUpdateAudioMutingState(mute);
wjmaclean2f797c782016-01-07 14:52:031519
Jan Rucka442c83f2017-08-08 13:27:541520 // Notification for UI updates in response to the changed muting state.
Collin Bakeraf540cf2019-09-20 20:54:161521 NotifyNavigationStateChanged(INVALIDATE_TYPE_AUDIO);
Jan Rucka442c83f2017-08-08 13:27:541522}
1523
1524bool WebContentsImpl::IsCurrentlyAudible() {
Chris Hamiltondf0d72cd2018-05-29 16:23:531525 return is_currently_audible_;
miu50f97892014-09-22 22:49:521526}
1527
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411528bool WebContentsImpl::IsConnectedToBluetoothDevice() {
ortunodf4d7982016-04-08 02:33:351529 return bluetooth_connected_device_count_ > 0;
ortuno32e7db3c2016-03-29 16:14:201530}
1531
Lucas Furukawa Gadani4b4eed02019-06-04 23:12:041532bool WebContentsImpl::IsConnectedToSerialPort() {
Reilly Grant5e7c79b22019-04-09 17:26:201533 return serial_active_frame_count_ > 0;
1534}
1535
Matt Reynoldse8c6c1f2019-11-02 09:53:531536bool WebContentsImpl::IsConnectedToHidDevice() {
1537 return hid_active_frame_count_ > 0;
1538}
1539
Marijn Kruisselbrink29051042019-08-06 22:56:551540bool WebContentsImpl::HasNativeFileSystemHandles() {
1541 return native_file_system_handle_count_ > 0;
1542}
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:331543bool WebContentsImpl::HasNativeFileSystemDirectoryHandles() {
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:471544 return !native_file_system_directory_handles_.empty();
1545}
1546
1547std::vector<base::FilePath>
1548WebContentsImpl::GetNativeFileSystemDirectoryHandles() {
1549 std::vector<base::FilePath> result;
1550 result.reserve(native_file_system_directory_handles_.size());
1551 for (auto const& entry : native_file_system_directory_handles_)
1552 result.push_back(entry.first);
1553 return result;
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:331554}
1555
1556bool WebContentsImpl::HasWritableNativeFileSystemHandles() {
1557 return native_file_system_writable_handle_count_ > 0;
1558}
1559
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411560bool WebContentsImpl::HasPictureInPictureVideo() {
sawtellea7333a82018-05-31 02:36:361561 return has_picture_in_picture_video_;
1562}
1563
1564void WebContentsImpl::SetHasPictureInPictureVideo(
1565 bool has_picture_in_picture_video) {
1566 // If status of |this| is already accurate, there is no need to update.
1567 if (has_picture_in_picture_video == has_picture_in_picture_video_)
1568 return;
1569 has_picture_in_picture_video_ = has_picture_in_picture_video;
1570 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
François Beaufort058085d2018-08-30 15:29:141571 for (auto& observer : observers_)
1572 observer.MediaPictureInPictureChanged(has_picture_in_picture_video_);
sawtellea7333a82018-05-31 02:36:361573}
1574
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411575bool WebContentsImpl::IsCrashed() {
Dominic Mazzoni73a48322018-05-25 18:14:071576 switch (crashed_status_) {
1577 case base::TERMINATION_STATUS_PROCESS_CRASHED:
1578 case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
1579 case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
1580 case base::TERMINATION_STATUS_OOM:
1581 case base::TERMINATION_STATUS_LAUNCH_FAILED:
oshima620225722015-06-04 19:45:271582#if defined(OS_CHROMEOS)
Dominic Mazzoni73a48322018-05-25 18:14:071583 case base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM:
oshima620225722015-06-04 19:45:271584#endif
Dominic Mazzoni73a48322018-05-25 18:14:071585#if defined(OS_ANDROID)
1586 case base::TERMINATION_STATUS_OOM_PROTECTED:
1587#endif
Will Harris07925d12019-10-31 03:03:051588#if defined(OS_WIN)
1589 case base::TERMINATION_STATUS_INTEGRITY_FAILURE:
1590#endif
Dominic Mazzoni73a48322018-05-25 18:14:071591 return true;
1592 case base::TERMINATION_STATUS_NORMAL_TERMINATION:
1593 case base::TERMINATION_STATUS_STILL_RUNNING:
1594 return false;
1595 case base::TERMINATION_STATUS_MAX_ENUM:
1596 NOTREACHED();
1597 return false;
1598 }
1599
1600 NOTREACHED();
1601 return false;
[email protected]3c9e1872010-11-18 16:17:491602}
1603
[email protected]b172aee2012-04-10 17:05:261604void WebContentsImpl::SetIsCrashed(base::TerminationStatus status,
1605 int error_code) {
[email protected]443b80e2010-12-14 00:42:231606 if (status == crashed_status_)
[email protected]d5f942ba2008-09-26 19:30:341607 return;
1608
[email protected]443b80e2010-12-14 00:42:231609 crashed_status_ = status;
1610 crashed_error_code_ = error_code;
[email protected]8ff00d72012-10-23 19:12:211611 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
[email protected]d5f942ba2008-09-26 19:30:341612}
1613
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411614base::TerminationStatus WebContentsImpl::GetCrashedStatus() {
[email protected]be1f56ab2011-12-22 06:55:311615 return crashed_status_;
1616}
1617
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411618int WebContentsImpl::GetCrashedErrorCode() {
afakhry98241832016-03-11 19:27:471619 return crashed_error_code_;
1620}
1621
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411622bool WebContentsImpl::IsBeingDestroyed() {
[email protected]be1f56ab2011-12-22 06:55:311623 return is_being_destroyed_;
1624}
1625
[email protected]7f924832014-08-09 05:57:221626void WebContentsImpl::NotifyNavigationStateChanged(
1627 InvalidateTypes changed_flags) {
dalecurtis88c240072015-12-09 02:11:181628 // Notify the media observer of potential audibility changes.
Collin Bakeraf540cf2019-09-20 20:54:161629 if (changed_flags & INVALIDATE_TYPE_AUDIO) {
mlamouri44e4ef42016-01-20 18:42:271630 media_web_contents_observer_->MaybeUpdateAudibleState();
dalecurtisbc6572e12014-09-12 19:22:301631 }
1632
[email protected]d5f942ba2008-09-26 19:30:341633 if (delegate_)
1634 delegate_->NavigationStateChanged(this, changed_flags);
wjmaclean1dabf3e32016-05-13 23:34:441635
1636 if (GetOuterWebContents())
1637 GetOuterWebContents()->NotifyNavigationStateChanged(changed_flags);
[email protected]d5f942ba2008-09-26 19:30:341638}
1639
W. James MacLean6f34b042019-07-12 19:25:301640RenderFrameHostImpl* WebContentsImpl::GetFocusedFrameFromFocusedDelegate() {
1641 FrameTreeNode* focused_node =
1642 GetFocusedWebContents()->frame_tree_.GetFocusedFrame();
1643 return focused_node ? focused_node->current_frame_host() : nullptr;
1644}
1645
David Black9cca3592019-11-06 23:02:221646void WebContentsImpl::OnVerticalScrollDirectionChanged(
1647 viz::VerticalScrollDirection scroll_direction) {
1648 for (auto& observer : observers_)
1649 observer.DidChangeVerticalScrollDirection(scroll_direction);
1650}
1651
Chris Hamiltondf0d72cd2018-05-29 16:23:531652void WebContentsImpl::OnAudioStateChanged() {
1653 // This notification can come from any embedded contents or from this
1654 // WebContents' stream monitor. Aggregate these signals to get the actual
1655 // state.
1656 bool is_currently_audible =
1657 audio_stream_monitor_.IsCurrentlyAudible() ||
1658 (browser_plugin_embedder_ &&
1659 browser_plugin_embedder_->AreAnyGuestsCurrentlyAudible());
1660 if (is_currently_audible == is_currently_audible_)
1661 return;
1662
1663 // Update internal state.
1664 is_currently_audible_ = is_currently_audible;
1665 was_ever_audible_ = was_ever_audible_ || is_currently_audible_;
1666
1667 SendPageMessage(
1668 new PageMsg_AudioStateChanged(MSG_ROUTING_NONE, is_currently_audible_));
altimind8bd26c2016-11-04 11:44:541669
altiminec87fd1f2016-11-17 20:22:491670 // Notification for UI updates in response to the changed audio state.
Collin Bakeraf540cf2019-09-20 20:54:161671 NotifyNavigationStateChanged(INVALIDATE_TYPE_AUDIO);
Jan Rucka442c83f2017-08-08 13:27:541672
Chris Hamiltondf0d72cd2018-05-29 16:23:531673 // Ensure that audio state changes propagate from innermost to outermost
1674 // WebContents.
1675 if (GetOuterWebContents())
1676 GetOuterWebContents()->OnAudioStateChanged();
Tommy Steimel18360512017-11-01 00:38:191677
Chris Hamiltoneb41198f2018-05-24 18:41:261678 for (auto& observer : observers_)
Chris Hamiltondf0d72cd2018-05-29 16:23:531679 observer.OnAudioStateChanged(is_currently_audible_);
altimind8bd26c2016-11-04 11:44:541680}
1681
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411682base::TimeTicks WebContentsImpl::GetLastActiveTime() {
[email protected]9a890452014-02-13 22:21:021683 return last_active_time_;
[email protected]3e324142012-06-25 18:26:331684}
1685
[email protected]9e2e4632012-07-27 16:38:411686void WebContentsImpl::WasShown() {
Collin Baker989e0882019-11-01 01:27:171687 UpdateVisibilityAndNotifyPageAndView(Visibility::VISIBLE);
[email protected]be1f56ab2011-12-22 06:55:311688}
1689
[email protected]b172aee2012-04-10 17:05:261690void WebContentsImpl::WasHidden() {
Collin Baker989e0882019-11-01 01:27:171691 UpdateVisibilityAndNotifyPageAndView(Visibility::HIDDEN);
[email protected]375fa1b2012-05-22 22:05:371692}
1693
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411694bool WebContentsImpl::HasRecentInteractiveInputEvent() {
Daniel Cheng90196c82018-04-25 21:49:141695 static constexpr base::TimeDelta kMaxInterval =
1696 base::TimeDelta::FromSeconds(5);
1697 base::TimeDelta delta =
1698 ui::EventTimeForNow() - last_interactive_input_event_time_;
1699 // Note: the expectation is that the caller is typically expecting an input
1700 // event, e.g. validating that a WebUI message that requires a gesture is
Daniel Chenge81030b32019-07-17 20:20:231701 // actually attached to a gesture.
Daniel Cheng90196c82018-04-25 21:49:141702 return delta <= kMaxInterval;
1703}
1704
Avi Drissman738ea192018-08-29 20:24:161705void WebContentsImpl::SetIgnoreInputEvents(bool ignore_input_events) {
1706 ignore_input_events_ = ignore_input_events;
1707}
1708
Bo Liu168c8642017-08-28 18:26:021709#if defined(OS_ANDROID)
Bo Liu16dd7b8322018-05-02 21:19:501710void WebContentsImpl::SetMainFrameImportance(
1711 ChildProcessImportance importance) {
1712 GetMainFrame()->GetRenderWidgetHost()->SetImportance(importance);
Bo Liu7c6779e92017-08-16 02:02:281713 if (ShowingInterstitialPage()) {
Bo Liu16dd7b8322018-05-02 21:19:501714 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
1715 ->GetRenderWidgetHost()
1716 ->SetImportance(importance);
Bo Liu7c6779e92017-08-16 02:02:281717 }
Bo Liu7c6779e92017-08-16 02:02:281718}
Bo Liu168c8642017-08-28 18:26:021719#endif
Bo Liu7c6779e92017-08-16 02:02:281720
ccameron8807c38f2015-01-17 00:29:191721void WebContentsImpl::WasOccluded() {
Collin Baker989e0882019-11-01 01:27:171722 UpdateVisibilityAndNotifyPageAndView(Visibility::OCCLUDED);
ccameron8807c38f2015-01-17 00:29:191723}
1724
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411725Visibility WebContentsImpl::GetVisibility() {
Francois Doraye6161152018-03-27 22:05:371726 return visibility_;
Francois Dorayfe4a1772018-02-17 04:17:091727}
1728
Alex Moshchuk5bcd7c12019-11-12 22:55:311729bool WebContentsImpl::NeedToFireBeforeUnloadOrUnload() {
[email protected]be1f56ab2011-12-22 06:55:311730 // TODO(creis): Should we fire even for interstitial pages?
Alex Moshchuk6fcaca752018-07-14 02:13:591731 if (ShowingInterstitialPage())
1732 return false;
1733
1734 if (!WillNotifyDisconnection())
1735 return false;
1736
1737 // Don't fire if the main frame's RenderViewHost indicates that beforeunload
1738 // and unload have already executed (e.g., after receiving a ClosePage ACK)
1739 // or should be ignored.
1740 if (GetRenderViewHost()->SuddenTerminationAllowed())
1741 return false;
1742
Alex Moshchukc78dbc722019-10-31 20:00:501743 // Check whether any frame in the frame tree needs to run beforeunload or
1744 // unload handlers.
1745 for (FrameTreeNode* node : frame_tree_.Nodes()) {
1746 RenderFrameHostImpl* rfh = node->current_frame_host();
1747
1748 // No need to run beforeunload/unload if the RenderFrame isn't live.
1749 if (!rfh->IsRenderFrameLive())
1750 continue;
1751
1752 if (rfh->GetSuddenTerminationDisablerState(blink::kBeforeUnloadHandler |
1753 blink::kUnloadHandler)) {
1754 return true;
1755 }
Aditya Keerthi34f37e62019-03-08 15:54:531756 }
Alex Moshchuk6fcaca752018-07-14 02:13:591757
Alex Moshchukc78dbc722019-10-31 20:00:501758 return false;
[email protected]be1f56ab2011-12-22 06:55:311759}
1760
Chris Hamilton3b3e315d2018-09-19 13:16:211761void WebContentsImpl::DispatchBeforeUnload(bool auto_cancel) {
1762 auto before_unload_type =
1763 auto_cancel ? RenderFrameHostImpl::BeforeUnloadType::DISCARD
1764 : RenderFrameHostImpl::BeforeUnloadType::TAB_CLOSE;
1765 GetMainFrame()->DispatchBeforeUnload(before_unload_type, false);
[email protected]1c3f80bd2014-04-08 23:02:061766}
1767
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501768void WebContentsImpl::AttachInnerWebContents(
1769 std::unique_ptr<WebContents> inner_web_contents,
W. James MacLean62883982019-11-12 20:39:001770 RenderFrameHost* render_frame_host,
1771 bool is_full_page) {
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501772 WebContentsImpl* inner_web_contents_impl =
1773 static_cast<WebContentsImpl*>(inner_web_contents.get());
1774 DCHECK(!inner_web_contents_impl->node_.outer_web_contents());
1775 auto* render_frame_host_impl =
1776 static_cast<RenderFrameHostImpl*>(render_frame_host);
1777 DCHECK_EQ(&frame_tree_,
1778 render_frame_host_impl->frame_tree_node()->frame_tree());
Lucas Furukawa Gadani105de1e812018-05-31 19:38:391779
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501780 RenderFrameHostManager* inner_render_manager =
1781 inner_web_contents_impl->GetRenderManager();
1782 RenderFrameHostImpl* inner_main_frame =
1783 inner_render_manager->current_frame_host();
1784 RenderViewHostImpl* inner_render_view_host =
1785 inner_render_manager->current_host();
1786 auto* outer_render_manager =
1787 render_frame_host_impl->frame_tree_node()->render_manager();
lfg91a79e12016-04-01 23:52:191788
Lucas Furukawa Gadani105de1e812018-05-31 19:38:391789 // When attaching a WebContents as an inner WebContents, we need to replace
1790 // the Webcontents' view with a WebContentsViewChildFrame.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501791 inner_web_contents_impl->view_.reset(new WebContentsViewChildFrame(
1792 inner_web_contents_impl,
1793 GetContentClient()->browser()->GetWebContentsViewDelegate(
1794 inner_web_contents_impl),
1795 &inner_web_contents_impl->render_view_host_delegate_view_));
Lucas Furukawa Gadani105de1e812018-05-31 19:38:391796
lfg91a79e12016-04-01 23:52:191797 // When the WebContents being initialized has an opener, the browser side
1798 // Render{View,Frame}Host must be initialized and the RenderWidgetHostView
1799 // created. This is needed because the usual initialization happens during
1800 // the first navigation, but when attaching a new window we don't navigate
1801 // before attaching. If the browser side is already initialized, the calls
1802 // below will just early return.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501803 inner_render_manager->InitRenderView(inner_render_view_host, nullptr);
1804 inner_main_frame->Init();
1805 if (!inner_render_manager->GetRenderWidgetHostView()) {
1806 inner_web_contents_impl->CreateRenderWidgetHostViewForRenderManager(
1807 inner_render_view_host);
1808 }
lfg91a79e12016-04-01 23:52:191809
lazyboy6ec48b2a2015-06-29 15:18:141810 // Create a link to our outer WebContents.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501811 node_.AttachInnerWebContents(std::move(inner_web_contents),
1812 render_frame_host_impl);
lazyboy6ec48b2a2015-06-29 15:18:141813
lazyboy6ec48b2a2015-06-29 15:18:141814 // Create a proxy in top-level RenderFrameHostManager, pointing to the
1815 // SiteInstance of the outer WebContents. The proxy will be used to send
1816 // postMessage to the inner WebContents.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501817 auto* proxy = inner_render_manager->CreateOuterDelegateProxy(
1818 render_frame_host_impl->GetSiteInstance());
lazyboy6ec48b2a2015-06-29 15:18:141819
Lucas Furukawa Gadani99125822019-01-03 15:41:491820 // When attaching a GuestView as an inner WebContents, there should already be
1821 // a live RenderFrame, which has to be swapped. When attaching a portal, there
1822 // will not be a live RenderFrame before creating the proxy.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501823 if (render_frame_host_impl->IsRenderFrameLive()) {
1824 inner_render_manager->SwapOuterDelegateFrame(render_frame_host_impl, proxy);
Lucas Furukawa Gadani99125822019-01-03 15:41:491825
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501826 inner_web_contents_impl->ReattachToOuterWebContentsFrame();
Lucas Furukawa Gadani99125822019-01-03 15:41:491827 }
ekaramadadd882292016-06-08 15:22:561828
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501829 if (frame_tree_.GetFocusedFrame() ==
1830 render_frame_host_impl->frame_tree_node()) {
1831 inner_web_contents_impl->SetFocusedFrame(
1832 inner_web_contents_impl->frame_tree_.root(),
1833 render_frame_host_impl->GetSiteInstance());
avallee7529b2a2017-04-26 11:37:511834 }
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501835 outer_render_manager->set_attach_complete();
W. James MacLean62883982019-11-12 20:39:001836
1837 // If the inner WebContents is full frame, give it focus.
1838 if (is_full_page) {
1839 // There should only ever be one inner WebContents when |is_full_page| is
1840 // true, and it is the one we just attached.
1841 DCHECK_EQ(1u, node_.GetInnerWebContents().size());
1842 inner_web_contents_impl->SetAsFocusedWebContentsIfNecessary();
1843 }
lazyboy6ec48b2a2015-06-29 15:18:141844}
1845
Lucas Furukawa Gadani99125822019-01-03 15:41:491846std::unique_ptr<WebContents> WebContentsImpl::DetachFromOuterWebContents() {
1847 DCHECK(node_.outer_web_contents());
1848 if (RenderWidgetHostViewBase* view =
1849 static_cast<RenderWidgetHostViewBase*>(GetMainFrame()->GetView())) {
1850 view->Destroy();
1851 }
1852 GetRenderManager()->DeleteOuterDelegateProxy(
1853 node_.OuterContentsFrameTreeNode()
1854 ->current_frame_host()
1855 ->GetSiteInstance());
1856 view_.reset(CreateWebContentsView(
1857 this, GetContentClient()->browser()->GetWebContentsViewDelegate(this),
1858 &render_view_host_delegate_view_));
danakjfc5184932019-09-12 18:08:321859 view_->CreateView(nullptr);
Lucas Furukawa Gadani99125822019-01-03 15:41:491860 std::unique_ptr<WebContents> web_contents =
1861 node_.DisconnectFromOuterWebContents();
1862 DCHECK_EQ(web_contents.get(), this);
1863 node_.SetFocusedWebContents(this);
1864 CreateRenderWidgetHostViewForRenderManager(GetRenderViewHost());
1865 return web_contents;
1866}
1867
W. James MacLean2dc75ed42019-03-06 14:31:091868void WebContentsImpl::RecursivelyRegisterFrameSinkIds() {
1869 auto* view = static_cast<RenderWidgetHostViewBase*>(
1870 GetRenderManager()->GetRenderWidgetHostView());
1871 DCHECK(view);
1872 if (!view->IsRenderWidgetHostViewChildFrame())
1873 return;
1874 static_cast<RenderWidgetHostViewChildFrame*>(view)->RegisterFrameSinkId();
1875
1876 for (auto* inner_web_contents : node_.GetInnerWebContents()) {
1877 static_cast<WebContentsImpl*>(inner_web_contents)
1878 ->RecursivelyRegisterFrameSinkIds();
1879 }
1880}
1881
Lucas Furukawa Gadaniaed1fed2017-10-13 17:34:141882void WebContentsImpl::ReattachToOuterWebContentsFrame() {
1883 DCHECK(node_.outer_web_contents());
1884 auto* render_manager = GetRenderManager();
1885 auto* parent_frame =
1886 node_.OuterContentsFrameTreeNode()->current_frame_host()->GetParent();
1887 render_manager->SetRWHViewForInnerContents(
1888 render_manager->GetRenderWidgetHostView());
1889
W. James MacLean2dc75ed42019-03-06 14:31:091890 RecursivelyRegisterFrameSinkIds();
Lucas Furukawa Gadaniaed1fed2017-10-13 17:34:141891
1892 // Set up the the guest's AX tree to point back at the embedder's AX tree.
1893 GetMainFrame()->set_browser_plugin_embedder_ax_tree_id(
1894 parent_frame->GetAXTreeID());
1895 GetMainFrame()->UpdateAXTreeData();
1896}
1897
dalecurtis6c58ed02016-10-28 23:02:371898void WebContentsImpl::DidChangeVisibleSecurityState() {
Emily Starkc663b0242019-04-26 19:34:451899 if (delegate_)
dalecurtis6c58ed02016-10-28 23:02:371900 delegate_->VisibleSecurityStateChanged(this);
Emily Starkc663b0242019-04-26 19:34:451901 for (auto& observer : observers_)
1902 observer.DidChangeVisibleSecurityState();
dalecurtis6c58ed02016-10-28 23:02:371903}
1904
Ahmed Fakhryd70bf37b2018-04-04 17:07:241905void WebContentsImpl::NotifyPreferencesChanged() {
1906 std::set<RenderViewHost*> render_view_host_set;
1907 for (FrameTreeNode* node : frame_tree_.Nodes()) {
Giovanni Ortuño Urquidi17a5d7c2018-04-30 06:48:531908 render_view_host_set.insert(
1909 node->current_frame_host()->GetRenderViewHost());
Ahmed Fakhryd70bf37b2018-04-04 17:07:241910 }
Giovanni Ortuño Urquidi17a5d7c2018-04-30 06:48:531911
Ahmed Fakhryd70bf37b2018-04-04 17:07:241912 for (RenderViewHost* render_view_host : render_view_host_set)
1913 render_view_host->OnWebkitPreferencesChanged();
1914}
1915
Bruce Long1e3e1f542019-10-16 17:56:281916void WebContentsImpl::SyncRendererPrefs() {
1917 blink::mojom::RendererPreferences renderer_preferences =
1918 GetRendererPrefs(GetBrowserContext());
1919 RenderViewHostImpl::GetPlatformSpecificPrefs(&renderer_preferences);
1920 SendPageMessage(
1921 new PageMsg_SetRendererPrefs(MSG_ROUTING_NONE, renderer_preferences));
1922}
1923
Josh Karlindaba39322019-07-17 23:24:331924void WebContentsImpl::OnCookiesRead(const GURL& url,
1925 const GURL& first_party_url,
1926 const net::CookieList& cookie_list,
1927 bool blocked_by_policy) {
1928 for (auto& observer : observers_) {
1929 observer.OnCookiesRead(url, first_party_url, cookie_list,
1930 blocked_by_policy);
1931 }
1932}
1933
1934void WebContentsImpl::OnCookieChange(const GURL& url,
1935 const GURL& first_party_url,
1936 const net::CanonicalCookie& cookie,
1937 bool blocked_by_policy) {
1938 for (auto& observer : observers_) {
1939 observer.OnCookieChange(url, first_party_url, cookie, blocked_by_policy);
1940 }
1941}
1942
[email protected]b172aee2012-04-10 17:05:261943void WebContentsImpl::Stop() {
dcheng57e39e22016-01-21 00:25:381944 for (FrameTreeNode* node : frame_tree_.Nodes())
1945 node->StopLoading();
ericwilligersde386342016-10-19 02:35:091946 for (auto& observer : observers_)
1947 observer.NavigationStopped();
[email protected]0bfbf882011-12-22 18:19:271948}
1949
Francois Doray47f759d2018-06-11 18:13:511950void WebContentsImpl::SetPageFrozen(bool frozen) {
1951 // A visible page is never frozen.
1952 DCHECK_NE(Visibility::VISIBLE, GetVisibility());
1953
1954 SendPageMessage(new PageMsg_SetPageFrozen(MSG_ROUTING_NONE, frozen));
Fadi Meawada6573e02018-03-10 00:52:111955}
1956
erikchen6c7df7f7a2018-05-03 18:13:591957std::unique_ptr<WebContents> WebContentsImpl::Clone() {
[email protected]14392a52012-05-02 20:28:441958 // We use our current SiteInstance since the cloned entry will use it anyway.
alexmose201c7cd2015-06-10 17:14:211959 // We pass our own opener so that the cloned page can access it if it was set
[email protected]ed245db2012-12-18 08:00:451960 // before.
[email protected]54944cde2012-12-09 09:24:591961 CreateParams create_params(GetBrowserContext(), GetSiteInstance());
Ian Clelland5cbaaf82017-11-27 22:00:031962 FrameTreeNode* opener = frame_tree_.root()->opener();
1963 RenderFrameHostImpl* opener_rfh = nullptr;
1964 if (opener)
1965 opener_rfh = opener->current_frame_host();
erikchen6c7df7f7a2018-05-03 18:13:591966 std::unique_ptr<WebContentsImpl> tc =
erikchen50735fd2018-05-05 15:08:331967 CreateWithOpener(create_params, opener_rfh);
Lucas Furukawa Gadani5553a152019-01-08 18:55:571968 tc->GetController().CopyStateFrom(&controller_, true);
ericwilligersde386342016-10-19 02:35:091969 for (auto& observer : observers_)
erikchen6c7df7f7a2018-05-03 18:13:591970 observer.DidCloneToNewWebContents(this, tc.get());
[email protected]0bfbf882011-12-22 18:19:271971 return tc;
1972}
1973
[email protected]14392a52012-05-02 20:28:441974void WebContentsImpl::Observe(int type,
[email protected]8ff00d72012-10-23 19:12:211975 const NotificationSource& source,
1976 const NotificationDetails& details) {
[email protected]14392a52012-05-02 20:28:441977 switch (type) {
[email protected]8ff00d72012-10-23 19:12:211978 case NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: {
1979 RenderWidgetHost* host = Source<RenderWidgetHost>(source).ptr();
[email protected]0b431992014-06-24 00:08:031980 RenderWidgetHostView* view = host->GetView();
1981 if (view == GetFullscreenRenderWidgetHostView()) {
1982 // We cannot just call view_->RestoreFocus() here. On some platforms,
1983 // attempting to focus the currently-invisible WebContentsView will be
1984 // flat-out ignored. Therefore, this boolean is used to track whether
1985 // we will request focus after the fullscreen widget has been
1986 // destroyed.
1987 fullscreen_widget_had_focus_at_shutdown_ = (view && view->HasFocus());
1988 } else {
alexmosc2a8cec2016-05-23 22:19:531989 for (auto i = pending_widget_views_.begin();
[email protected]0b431992014-06-24 00:08:031990 i != pending_widget_views_.end(); ++i) {
1991 if (host->GetView() == i->second) {
1992 pending_widget_views_.erase(i);
1993 break;
1994 }
[email protected]bafe6cd2012-05-23 23:09:501995 }
1996 }
1997 break;
1998 }
[email protected]14392a52012-05-02 20:28:441999 default:
2000 NOTREACHED();
2001 }
2002}
2003
[email protected]ec6c05f2013-10-23 18:41:572004WebContents* WebContentsImpl::GetWebContents() {
2005 return this;
2006}
2007
[email protected]54944cde2012-12-09 09:24:592008void WebContentsImpl::Init(const WebContents::CreateParams& params) {
[email protected]fa944cb82013-11-15 17:51:212009 // This is set before initializing the render manager since
[email protected]b0936d22013-11-28 06:47:362010 // RenderFrameHostManager::Init calls back into us via its delegate to ask if
[email protected]fa944cb82013-11-15 17:51:212011 // it should be hidden.
Francois Doraye6161152018-03-27 22:05:372012 visibility_ =
2013 params.initially_hidden ? Visibility::HIDDEN : Visibility::VISIBLE;
[email protected]d6fa88f2013-10-18 16:00:432014
Sebastien Marchand28cf23182018-06-20 02:39:352015 if (!params.last_active_time.is_null())
2016 last_active_time_ = params.last_active_time;
2017
dcheng3ce04b62015-10-26 23:30:552018 // The routing ids must either all be set or all be unset.
avic2c29d782014-12-12 00:23:542019 DCHECK((params.routing_id == MSG_ROUTING_NONE &&
dcheng3ce04b62015-10-26 23:30:552020 params.main_frame_routing_id == MSG_ROUTING_NONE &&
2021 params.main_frame_widget_routing_id == MSG_ROUTING_NONE) ||
avic2c29d782014-12-12 00:23:542022 (params.routing_id != MSG_ROUTING_NONE &&
dcheng3ce04b62015-10-26 23:30:552023 params.main_frame_routing_id != MSG_ROUTING_NONE &&
2024 params.main_frame_widget_routing_id != MSG_ROUTING_NONE));
2025
2026 scoped_refptr<SiteInstance> site_instance = params.site_instance;
2027 if (!site_instance)
2028 site_instance = SiteInstance::Create(params.browser_context);
Lukasz Anforowicz3caa8372018-06-05 17:22:072029 if (params.desired_renderer_state == CreateParams::kNoRendererProcess) {
2030 static_cast<SiteInstanceImpl*>(site_instance.get())
2031 ->PreventAssociationWithSpareProcess();
2032 }
dcheng3ce04b62015-10-26 23:30:552033
2034 // A main RenderFrameHost always has a RenderWidgetHost, since it is always a
2035 // local root by definition.
2036 // TODO(avi): Once RenderViewHostImpl has-a RenderWidgetHostImpl, it will no
2037 // longer be necessary to eagerly grab a routing ID for the view.
2038 // https://crbug.com/545684
2039 int32_t view_routing_id = params.routing_id;
2040 int32_t main_frame_widget_routing_id = params.main_frame_widget_routing_id;
2041 if (main_frame_widget_routing_id == MSG_ROUTING_NONE) {
Albert J. Wongcb004632018-07-10 22:58:252042 view_routing_id = site_instance->GetProcess()->GetNextRoutingID();
2043 main_frame_widget_routing_id =
dcheng3ce04b62015-10-26 23:30:552044 site_instance->GetProcess()->GetNextRoutingID();
2045 }
2046
Albert J. Wongcb004632018-07-10 22:58:252047 DCHECK_NE(view_routing_id, main_frame_widget_routing_id);
2048
Dave Tapuska485aca92017-08-08 00:47:582049 GetRenderManager()->Init(
2050 site_instance.get(), view_routing_id, params.main_frame_routing_id,
2051 main_frame_widget_routing_id, params.renderer_initiated_creation);
lukasza464d8692016-02-22 19:26:322052
lukasza5140a412016-09-15 21:12:302053 // blink::FrameTree::setName always keeps |unique_name| empty in case of a
2054 // main frame - let's do the same thing here.
2055 std::string unique_name;
lukasza464d8692016-02-22 19:26:322056 frame_tree_.root()->SetFrameName(params.main_frame_name, unique_name);
[email protected]d1198fd2012-08-13 22:50:192057
[email protected]fc2b46b2014-05-03 16:33:452058 WebContentsViewDelegate* delegate =
2059 GetContentClient()->browser()->GetWebContentsViewDelegate(this);
2060
sky52a39e342016-12-17 17:23:222061 if (GuestMode::IsCrossProcessFrameGuest(this)) {
2062 view_.reset(new WebContentsViewChildFrame(
2063 this, delegate, &render_view_host_delegate_view_));
2064 } else {
2065 view_.reset(CreateWebContentsView(this, delegate,
2066 &render_view_host_delegate_view_));
Scott Violetc884c7fd2017-11-03 23:51:012067 if (browser_plugin_guest_) {
2068 view_ = std::make_unique<WebContentsViewGuest>(
2069 this, browser_plugin_guest_.get(), std::move(view_),
2070 &render_view_host_delegate_view_);
2071 }
[email protected]d1198fd2012-08-13 22:50:192072 }
[email protected]fc2b46b2014-05-03 16:33:452073 CHECK(render_view_host_delegate_view_);
[email protected]d1198fd2012-08-13 22:50:192074 CHECK(view_.get());
2075
danakjfc5184932019-09-12 18:08:322076 view_->CreateView(params.context);
[email protected]d1198fd2012-08-13 22:50:192077
brettw4b461082016-11-19 18:55:162078#if BUILDFLAG(ENABLE_PLUGINS)
tommyclieb25b2a2014-11-03 19:45:092079 plugin_content_origin_whitelist_.reset(
2080 new PluginContentOriginWhitelist(this));
2081#endif
2082
[email protected]d1198fd2012-08-13 22:50:192083 registrar_.Add(this,
[email protected]8ff00d72012-10-23 19:12:212084 NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
2085 NotificationService::AllBrowserContextsAndSources());
[email protected]f28ef9a32014-05-12 16:36:102086
leon.hane4db177a2017-02-07 14:19:162087 screen_orientation_provider_.reset(new ScreenOrientationProvider(this));
[email protected]01f83f92014-06-17 14:41:542088
mlamouriefdca9d2014-09-16 16:55:402089 manifest_manager_host_.reset(new ManifestManagerHost(this));
2090
mfomitchev2b8b066a2016-01-28 19:23:152091#if defined(OS_ANDROID)
Oksana Zhuravlova0b634332019-10-28 23:04:222092 DateTimeChooserAndroid::CreateForWebContents(this);
[email protected]583418cc2013-01-17 14:01:102093#endif
fsamuel7310a4262014-12-05 05:06:442094
2095 // BrowserPluginGuest::Init needs to be called after this WebContents has
2096 // a RenderWidgetHostViewGuest. That is, |view_->CreateView| above.
2097 if (browser_plugin_guest_)
2098 browser_plugin_guest_->Init();
nickf9acfbe2014-12-23 19:12:372099
2100 for (size_t i = 0; i < g_created_callbacks.Get().size(); i++)
2101 g_created_callbacks.Get().at(i).Run(this);
naskob21fe4872015-02-24 14:15:562102
2103 // If the WebContents creation was renderer-initiated, it means that the
2104 // corresponding RenderView and main RenderFrame have already been created.
2105 // Ensure observers are notified about this.
2106 if (params.renderer_initiated_creation) {
avi3627ecac2015-10-16 17:40:432107 GetRenderViewHost()->GetWidget()->set_renderer_initialized(true);
Alex Moshchuk27caae82017-09-11 23:11:182108 GetRenderViewHost()->DispatchRenderViewCreated();
naskob21fe4872015-02-24 14:15:562109 GetRenderManager()->current_frame_host()->SetRenderFrameCreated(true);
2110 }
naskof5940b9f2015-03-02 23:04:052111
lof84501da082016-05-23 21:22:542112 // Create the renderer process in advance if requested.
Lukasz Anforowicz3caa8372018-06-05 17:22:072113 if (params.desired_renderer_state ==
2114 CreateParams::kInitializeAndWarmupRendererProcess) {
lof84501da082016-05-23 21:22:542115 if (!GetRenderManager()->current_frame_host()->IsRenderFrameLive()) {
2116 GetRenderManager()->InitRenderView(GetRenderViewHost(), nullptr);
2117 }
2118 }
2119
naskof5940b9f2015-03-02 23:04:052120 // Ensure that observers are notified of the creation of this WebContents's
2121 // main RenderFrameHost. It must be done here for main frames, since the
2122 // NotifySwappedFromRenderManager expects view_ to already be created and that
2123 // happens after RenderFrameHostManager::Init.
2124 NotifySwappedFromRenderManager(
2125 nullptr, GetRenderManager()->current_frame_host(), true);
Albert J. Wonge76bf0b82019-09-27 07:47:062126
2127 // For WebContents that are never shown, do critical initialization here which
2128 // would normally only happen when the WebContents is shown.
2129 if (params.is_never_visible) {
2130 // This has just been created so there can only be one frame. Thus it is
2131 // safe to initialize the root.
2132 GetMainFrame()->Init();
2133 }
[email protected]d1198fd2012-08-13 22:50:192134}
2135
[email protected]7fff43e2013-05-21 20:21:102136void WebContentsImpl::OnWebContentsDestroyed(WebContentsImpl* web_contents) {
2137 RemoveDestructionObserver(web_contents);
2138
[email protected]ceee8cd2013-03-08 04:59:512139 // Clear a pending contents that has been closed before being shown.
alexmosc2a8cec2016-05-23 22:19:532140 for (auto iter = pending_contents_.begin(); iter != pending_contents_.end();
[email protected]ceee8cd2013-03-08 04:59:512141 ++iter) {
erikchenbee5c9622018-04-27 19:30:252142 if (iter->second.get() != web_contents)
[email protected]ceee8cd2013-03-08 04:59:512143 continue;
erikchenbee5c9622018-04-27 19:30:252144
2145 // Someone else has deleted the WebContents. That should never happen!
2146 // TODO(erikchen): Fix semantics here. https://crbug.com/832879.
2147 iter->second.release();
[email protected]ceee8cd2013-03-08 04:59:512148 pending_contents_.erase(iter);
[email protected]ceee8cd2013-03-08 04:59:512149 return;
2150 }
2151 NOTREACHED();
[email protected]14392a52012-05-02 20:28:442152}
2153
[email protected]7fff43e2013-05-21 20:21:102154void WebContentsImpl::AddDestructionObserver(WebContentsImpl* web_contents) {
Jan Wilken Dörrie73c901e2019-06-12 09:02:322155 if (!base::Contains(destruction_observers_, web_contents)) {
[email protected]7fff43e2013-05-21 20:21:102156 destruction_observers_[web_contents] =
Jeremy Roman04f27c372017-10-27 15:20:552157 std::make_unique<DestructionObserver>(this, web_contents);
[email protected]7fff43e2013-05-21 20:21:102158 }
2159}
2160
2161void WebContentsImpl::RemoveDestructionObserver(WebContentsImpl* web_contents) {
avia8cf81982016-08-12 20:28:462162 destruction_observers_.erase(web_contents);
[email protected]7fff43e2013-05-21 20:21:102163}
2164
[email protected]b172aee2012-04-10 17:05:262165void WebContentsImpl::AddObserver(WebContentsObserver* observer) {
[email protected]be1f56ab2011-12-22 06:55:312166 observers_.AddObserver(observer);
2167}
2168
[email protected]b172aee2012-04-10 17:05:262169void WebContentsImpl::RemoveObserver(WebContentsObserver* observer) {
[email protected]be1f56ab2011-12-22 06:55:312170 observers_.RemoveObserver(observer);
2171}
2172
[email protected]948481d2014-06-11 18:32:222173std::set<RenderWidgetHostView*>
2174WebContentsImpl::GetRenderWidgetHostViewsInTree() {
2175 std::set<RenderWidgetHostView*> set;
2176 if (ShowingInterstitialPage()) {
lfgf949e0e2017-05-10 22:18:112177 if (RenderWidgetHostView* rwhv = GetRenderWidgetHostView())
2178 set.insert(rwhv);
[email protected]948481d2014-06-11 18:32:222179 } else {
dchengafb53e22016-02-04 08:11:082180 for (RenderFrameHost* rfh : GetAllFrames()) {
lfgf949e0e2017-05-10 22:18:112181 if (RenderWidgetHostView* rwhv = static_cast<RenderFrameHostImpl*>(rfh)
2182 ->frame_tree_node()
2183 ->render_manager()
2184 ->GetRenderWidgetHostView()) {
2185 set.insert(rwhv);
2186 }
dchengafb53e22016-02-04 08:11:082187 }
[email protected]948481d2014-06-11 18:32:222188 }
[email protected]de3c5d82014-05-28 22:12:592189 return set;
2190}
2191
[email protected]b172aee2012-04-10 17:05:262192void WebContentsImpl::Activate() {
[email protected]d5f942ba2008-09-26 19:30:342193 if (delegate_)
2194 delegate_->ActivateContents(this);
2195}
2196
avi3e4b8512015-11-11 01:55:492197void WebContentsImpl::LostCapture(RenderWidgetHostImpl* render_widget_host) {
2198 if (!RenderViewHostImpl::From(render_widget_host))
2199 return;
2200
[email protected]63954792011-07-11 04:17:482201 if (delegate_)
2202 delegate_->LostCapture();
2203}
2204
Steven Holte38041342018-06-22 22:00:572205ukm::SourceId WebContentsImpl::GetUkmSourceIdForLastCommittedSource() const {
2206 return last_committed_source_id_;
2207}
2208
Yue Ru Sun979c4b162019-11-06 16:11:042209ukm::SourceId
2210WebContentsImpl::GetUkmSourceIdForLastCommittedSourceIncludingSameDocument()
2211 const {
2212 return last_committed_source_id_including_same_document_;
2213}
2214
Ahmed Fakhryfaa32d22018-10-05 15:56:162215void WebContentsImpl::SetTopControlsShownRatio(
2216 RenderWidgetHostImpl* render_widget_host,
2217 float ratio) {
2218 if (!delegate_)
2219 return;
2220
2221 RenderFrameHostImpl* rfh = GetMainFrame();
2222 if (!rfh || render_widget_host != rfh->GetRenderWidgetHost())
2223 return;
2224
2225 delegate_->SetTopControlsShownRatio(this, ratio);
Ahmed Fakhry58e6ef542018-09-04 18:05:382226}
2227
Ahmed Fakhry58e6ef542018-09-04 18:05:382228void WebContentsImpl::SetTopControlsGestureScrollInProgress(bool in_progress) {
2229 if (delegate_)
2230 delegate_->SetTopControlsGestureScrollInProgress(in_progress);
2231}
2232
lazyboy63f5b312015-11-23 20:19:522233void WebContentsImpl::RenderWidgetCreated(
2234 RenderWidgetHostImpl* render_widget_host) {
2235 created_widgets_.insert(render_widget_host);
2236}
2237
[email protected]b24b68a2012-09-24 21:57:262238void WebContentsImpl::RenderWidgetDeleted(
2239 RenderWidgetHostImpl* render_widget_host) {
lazyboy63f5b312015-11-23 20:19:522240 // Note that |is_being_destroyed_| can be true at this point as
2241 // ~WebContentsImpl() calls RFHM::ClearRFHsPendingShutdown(), which might lead
2242 // us here.
2243 created_widgets_.erase(render_widget_host);
[email protected]b24b68a2012-09-24 21:57:262244
lazyboy63f5b312015-11-23 20:19:522245 if (is_being_destroyed_)
2246 return;
[email protected]44470a22013-01-24 01:21:542247
2248 if (render_widget_host &&
alexmosc9e76ec2016-05-16 22:59:372249 render_widget_host->GetRoutingID() == fullscreen_widget_routing_id_ &&
2250 render_widget_host->GetProcess()->GetID() ==
2251 fullscreen_widget_process_id_) {
[email protected]4aebbca2013-09-17 22:26:492252 if (delegate_ && delegate_->EmbedsFullscreenWidget())
mlamouri7a78d6fd2015-01-17 13:23:532253 delegate_->ExitFullscreenModeForTab(this);
ericwilligersde386342016-10-19 02:35:092254 for (auto& observer : observers_)
2255 observer.DidDestroyFullscreenWidget();
alexmosc9e76ec2016-05-16 22:59:372256 fullscreen_widget_process_id_ = ChildProcessHost::kInvalidUniqueID;
[email protected]44470a22013-01-24 01:21:542257 fullscreen_widget_routing_id_ = MSG_ROUTING_NONE;
[email protected]0b431992014-06-24 00:08:032258 if (fullscreen_widget_had_focus_at_shutdown_)
2259 view_->RestoreFocus();
[email protected]44470a22013-01-24 01:21:542260 }
lfgbee1e0a2016-06-08 21:24:212261
lfg7d4caad2017-03-22 09:01:452262 if (render_widget_host == mouse_lock_widget_)
lfgff8dfc8d2016-10-21 17:42:322263 LostMouseLock(mouse_lock_widget_);
Joe Downing192998b22018-03-22 15:51:362264
Joe Downingc1a57efe2018-05-09 18:23:542265 CancelKeyboardLock(render_widget_host);
[email protected]b24b68a2012-09-24 21:57:262266}
2267
miu9e14e492014-10-25 02:39:042268void WebContentsImpl::RenderWidgetGotFocus(
2269 RenderWidgetHostImpl* render_widget_host) {
calamity7fe55ce2015-04-10 03:59:372270 // Notify the observers if an embedded fullscreen widget was focused.
2271 if (delegate_ && render_widget_host && delegate_->EmbedsFullscreenWidget() &&
2272 render_widget_host->GetView() == GetFullscreenRenderWidgetHostView()) {
Michael Thiessen896405db2017-07-20 17:52:322273 NotifyWebContentsFocused(render_widget_host);
calamity7fe55ce2015-04-10 03:59:372274 }
miu9e14e492014-10-25 02:39:042275}
2276
zijiehe3bee08e22017-05-17 04:14:462277void WebContentsImpl::RenderWidgetLostFocus(
2278 RenderWidgetHostImpl* render_widget_host) {
Michael Thiessen896405db2017-07-20 17:52:322279 // Notify the observers if an embedded fullscreen widget lost focus.
2280 if (delegate_ && render_widget_host && delegate_->EmbedsFullscreenWidget() &&
2281 render_widget_host->GetView() == GetFullscreenRenderWidgetHostView()) {
2282 NotifyWebContentsLostFocus(render_widget_host);
2283 }
zijiehe3bee08e22017-05-17 04:14:462284}
2285
estaded0a0c992015-01-21 14:12:062286void WebContentsImpl::RenderWidgetWasResized(
rouslan2f5993f2015-01-29 00:18:312287 RenderWidgetHostImpl* render_widget_host,
2288 bool width_changed) {
creisc014b402015-04-23 16:41:452289 RenderFrameHostImpl* rfh = GetMainFrame();
estadece344ec2015-01-23 00:12:292290 if (!rfh || render_widget_host != rfh->GetRenderWidgetHost())
estaded0a0c992015-01-21 14:12:062291 return;
estaded0a0c992015-01-21 14:12:062292
ericwilligersde386342016-10-19 02:35:092293 for (auto& observer : observers_)
2294 observer.MainFrameWasResized(width_changed);
estaded0a0c992015-01-21 14:12:062295}
2296
skyf65d9bb2017-03-24 02:26:392297KeyboardEventProcessingResult WebContentsImpl::PreHandleKeyboardEvent(
2298 const NativeWebKeyboardEvent& event) {
W. James MacLeane1187272019-11-12 03:42:482299 auto* outermost_contents = GetOutermostWebContents();
2300 // TODO(wjmaclean): Generalize this to forward all key events to the outermost
2301 // delegate's handler.
2302 if (outermost_contents != this && IsFullscreenForCurrentTab() &&
2303 event.windows_key_code == ui::VKEY_ESCAPE) {
2304 // When an inner WebContents has focus and is fullscreen, redirect <esc>
2305 // key events to the outermost WebContents so it can be handled by that
2306 // WebContents' delegate.
2307 if (outermost_contents->PreHandleKeyboardEvent(event) ==
2308 KeyboardEventProcessingResult::HANDLED) {
2309 return KeyboardEventProcessingResult::HANDLED;
2310 }
2311 }
skyf65d9bb2017-03-24 02:26:392312 return delegate_ ? delegate_->PreHandleKeyboardEvent(this, event)
2313 : KeyboardEventProcessingResult::NOT_HANDLED;
[email protected]63954792011-07-11 04:17:482314}
2315
Dave Tapuska344399e2019-09-09 15:18:262316bool WebContentsImpl::HandleMouseEvent(const blink::WebMouseEvent& event) {
2317 // Handle mouse button back/forward in the browser process after the render
2318 // process is done with the event. This ensures all renderer-initiated history
2319 // navigations can be treated consistently.
2320 if (event.GetType() == blink::WebInputEvent::Type::kMouseUp) {
2321 WebContentsImpl* outermost = GetOutermostWebContents();
2322 if (event.button == blink::WebPointerProperties::Button::kBack &&
2323 outermost->controller_.CanGoBack()) {
2324 outermost->controller_.GoBack();
2325 return true;
2326 } else if (event.button == blink::WebPointerProperties::Button::kForward &&
2327 outermost->controller_.CanGoForward()) {
2328 outermost->controller_.GoForward();
2329 return true;
2330 }
2331 }
2332 return false;
2333}
2334
Scott Violetd5caa872018-10-16 22:00:512335bool WebContentsImpl::HandleKeyboardEvent(const NativeWebKeyboardEvent& event) {
[email protected]0b094002014-08-20 18:28:102336 if (browser_plugin_embedder_ &&
2337 browser_plugin_embedder_->HandleKeyboardEvent(event)) {
Scott Violetd5caa872018-10-16 22:00:512338 return true;
[email protected]0b094002014-08-20 18:28:102339 }
Scott Violetd5caa872018-10-16 22:00:512340 return delegate_ && delegate_->HandleKeyboardEvent(this, event);
[email protected]63954792011-07-11 04:17:482341}
2342
[email protected]d92026ef2014-03-03 21:04:132343bool WebContentsImpl::HandleWheelEvent(
[email protected]180ef242013-11-07 06:50:462344 const blink::WebMouseWheelEvent& event) {
[email protected]bccc4472013-04-18 16:37:192345#if !defined(OS_MACOSX)
lanweia93644f2015-01-21 22:00:332346 // On platforms other than Mac, control+mousewheel may change zoom. On Mac,
2347 // this isn't done for two reasons:
[email protected]bccc4472013-04-18 16:37:192348 // -the OS already has a gesture to do this through pinch-zoom
2349 // -if a user starts an inertial scroll, let's go, and presses control
2350 // (i.e. control+tab) then the OS's buffered scroll events will come in
2351 // with control key set which isn't what the user wants
Blink Reformat1c4d759e2017-04-09 16:34:542352 if (delegate_ && event.wheel_ticks_y &&
Ehsan Karamad0f83cb112018-09-06 22:07:362353 event.event_action == blink::WebMouseWheelEvent::EventAction::kPageZoom) {
w.shackleton49bcd392016-01-06 17:38:222354 // Count only integer cumulative scrolls as zoom events; this handles
2355 // smooth scroll and regular scroll device behavior.
Blink Reformat1c4d759e2017-04-09 16:34:542356 zoom_scroll_remainder_ += event.wheel_ticks_y;
w.shackleton49bcd392016-01-06 17:38:222357 int whole_zoom_scroll_remainder_ = std::lround(zoom_scroll_remainder_);
2358 zoom_scroll_remainder_ -= whole_zoom_scroll_remainder_;
2359 if (whole_zoom_scroll_remainder_ != 0) {
2360 delegate_->ContentsZoomChange(whole_zoom_scroll_remainder_ > 0);
2361 }
[email protected]fb3f066e2013-02-12 19:12:522362 return true;
2363 }
[email protected]bccc4472013-04-18 16:37:192364#endif
[email protected]fb3f066e2013-02-12 19:12:522365 return false;
2366}
2367
[email protected]04bce562014-01-30 05:34:542368bool WebContentsImpl::PreHandleGestureEvent(
2369 const blink::WebGestureEvent& event) {
[email protected]28042d32014-02-03 14:10:032370 return delegate_ && delegate_->PreHandleGestureEvent(this, event);
[email protected]04bce562014-01-30 05:34:542371}
2372
kenrb2a565f82015-09-02 20:24:592373RenderWidgetHostInputEventRouter* WebContentsImpl::GetInputEventRouter() {
wjmacleane31234f2015-12-14 17:20:452374 if (!is_being_destroyed_ && GetOuterWebContents())
2375 return GetOuterWebContents()->GetInputEventRouter();
2376
2377 if (!rwh_input_event_router_.get() && !is_being_destroyed_)
kenrb2a565f82015-09-02 20:24:592378 rwh_input_event_router_.reset(new RenderWidgetHostInputEventRouter);
2379 return rwh_input_event_router_.get();
2380}
2381
alexmos3fcd0ca2015-10-23 18:18:332382void WebContentsImpl::ReplicatePageFocus(bool is_focused) {
2383 // Focus loss may occur while this WebContents is being destroyed. Don't
2384 // send the message in this case, as the main frame's RenderFrameHost and
2385 // other state has already been cleared.
2386 if (is_being_destroyed_)
2387 return;
2388
2389 frame_tree_.ReplicatePageFocus(is_focused);
2390}
2391
alexmosc4cbacb2015-11-21 01:29:222392RenderWidgetHostImpl* WebContentsImpl::GetFocusedRenderWidgetHost(
2393 RenderWidgetHostImpl* receiving_widget) {
alexmosc4cbacb2015-11-21 01:29:222394 // Events for widgets other than the main frame (e.g., popup menus) should be
2395 // forwarded directly to the widget they arrived on.
2396 if (receiving_widget != GetMainFrame()->GetRenderWidgetHost())
2397 return receiving_widget;
alexmosc4d183e2015-11-06 00:46:522398
lfg1453e412017-04-11 00:48:502399 WebContentsImpl* focused_contents = GetFocusedWebContents();
2400
2401 // If the focused WebContents is showing an interstitial, return the
2402 // interstitial's widget.
2403 if (focused_contents->ShowingInterstitialPage()) {
2404 return static_cast<RenderFrameHostImpl*>(
creisadca9862017-06-16 19:12:112405 focused_contents->interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:502406 ->GetRenderWidgetHost();
2407 }
2408
paulmeyerfeafc2d2017-04-25 21:46:402409 // If the focused WebContents is a guest WebContents, then get the focused
2410 // frame in the embedder WebContents instead.
2411 FrameTreeNode* focused_frame = nullptr;
2412 if (focused_contents->browser_plugin_guest_ &&
2413 !GuestMode::IsCrossProcessFrameGuest(focused_contents)) {
2414 focused_frame = frame_tree_.GetFocusedFrame();
2415 } else {
2416 focused_frame = GetFocusedWebContents()->frame_tree_.GetFocusedFrame();
2417 }
lfg1453e412017-04-11 00:48:502418
alexmosc4d183e2015-11-06 00:46:522419 if (!focused_frame)
alexmosc4cbacb2015-11-21 01:29:222420 return receiving_widget;
alexmosc4d183e2015-11-06 00:46:522421
alexmos732ca3a2015-12-08 02:01:022422 // The view may be null if a subframe's renderer process has crashed while
2423 // the subframe has focus. Drop the event in that case. Do not give
2424 // it to the main frame, so that the user doesn't unexpectedly type into the
2425 // wrong frame if a focused subframe renderer crashes while they type.
2426 RenderWidgetHostView* view = focused_frame->current_frame_host()->GetView();
2427 if (!view)
2428 return nullptr;
2429
2430 return RenderWidgetHostImpl::From(view->GetRenderWidgetHost());
alexmosc4d183e2015-11-06 00:46:522431}
2432
avallee9993fca2016-11-17 06:16:502433RenderWidgetHostImpl* WebContentsImpl::GetRenderWidgetHostWithPageFocus() {
lfg1453e412017-04-11 00:48:502434 WebContentsImpl* focused_web_contents = GetFocusedWebContents();
2435
2436 if (focused_web_contents->ShowingInterstitialPage()) {
2437 return static_cast<RenderFrameHostImpl*>(
creisadca9862017-06-16 19:12:112438 focused_web_contents->interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:502439 ->GetRenderWidgetHost();
2440 }
Alex Valléedc80ae2ed2017-09-06 21:55:442441 if (!GuestMode::IsCrossProcessFrameGuest(focused_web_contents) &&
2442 focused_web_contents->browser_plugin_guest_) {
2443 // If this is a guest, we need to be controlled by our embedder.
2444 return focused_web_contents->GetOuterWebContents()
2445 ->GetMainFrame()
2446 ->GetRenderWidgetHost();
2447 }
lfg1453e412017-04-11 00:48:502448
2449 return focused_web_contents->GetMainFrame()->GetRenderWidgetHost();
avallee9993fca2016-11-17 06:16:502450}
2451
Dave Tapuska3ed44192018-05-01 18:53:302452void WebContentsImpl::EnterFullscreenMode(
2453 const GURL& origin,
Dave Tapuskaa4189512019-10-15 20:27:342454 const blink::mojom::FullscreenOptions& options) {
mlamouri7a78d6fd2015-01-17 13:23:532455 // This method is being called to enter renderer-initiated fullscreen mode.
2456 // Make sure any existing fullscreen widget is shut down first.
[email protected]4aebbca2013-09-17 22:26:492457 RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
avi85a4cef2015-12-18 20:13:372458 if (widget_view) {
2459 RenderWidgetHostImpl::From(widget_view->GetRenderWidgetHost())
2460 ->ShutdownAndDestroyWidget(true);
2461 }
[email protected]4aebbca2013-09-17 22:26:492462
Joe Downing13dd76b2018-04-09 18:32:152463 if (delegate_) {
Dave Tapuska3ed44192018-05-01 18:53:302464 delegate_->EnterFullscreenModeForTab(this, origin, options);
mlamouri7a78d6fd2015-01-17 13:23:532465
Joe Downing13dd76b2018-04-09 18:32:152466 if (keyboard_lock_widget_)
2467 delegate_->RequestKeyboardLock(this, esc_key_locked_);
2468 }
2469
ericwilligersde386342016-10-19 02:35:092470 for (auto& observer : observers_)
2471 observer.DidToggleFullscreenModeForTab(IsFullscreenForCurrentTab(), false);
mlamouri7a78d6fd2015-01-17 13:23:532472}
2473
bokanece34a82016-01-28 19:49:462474void WebContentsImpl::ExitFullscreenMode(bool will_cause_resize) {
mlamouri7a78d6fd2015-01-17 13:23:532475 // This method is being called to leave renderer-initiated fullscreen mode.
2476 // Make sure any existing fullscreen widget is shut down first.
2477 RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
avi85a4cef2015-12-18 20:13:372478 if (widget_view) {
2479 RenderWidgetHostImpl::From(widget_view->GetRenderWidgetHost())
2480 ->ShutdownAndDestroyWidget(true);
2481 }
mlamouri7a78d6fd2015-01-17 13:23:532482
Joe Downing13dd76b2018-04-09 18:32:152483 if (delegate_) {
mlamouri7a78d6fd2015-01-17 13:23:532484 delegate_->ExitFullscreenModeForTab(this);
[email protected]657c8e02014-03-19 19:18:372485
Joe Downing13dd76b2018-04-09 18:32:152486 if (keyboard_lock_widget_)
2487 delegate_->CancelKeyboardLockRequest(this);
2488 }
2489
bokanece34a82016-01-28 19:49:462490 // The fullscreen state is communicated to the renderer through a resize
2491 // message. If the change in fullscreen state doesn't cause a view resize
2492 // then we must ensure web contents exit the fullscreen state by explicitly
2493 // sending a resize message. This is required for the situation of the browser
2494 // moving the view into a "browser fullscreen" state and then the contents
2495 // entering "tab fullscreen". Exiting the contents "tab fullscreen" then won't
2496 // have the side effect of the view resizing, hence the explicit call here is
2497 // required.
2498 if (!will_cause_resize) {
2499 if (RenderWidgetHostView* rwhv = GetRenderWidgetHostView()) {
2500 if (RenderWidgetHost* render_widget_host = rwhv->GetRenderWidgetHost())
Fady Samuel0b911822018-04-25 13:22:162501 render_widget_host->SynchronizeVisualProperties();
bokanece34a82016-01-28 19:49:462502 }
scheib3dcb6c932015-02-23 10:55:582503 }
2504
Arthur Sonzogni929d29f2018-09-17 14:19:442505 current_fullscreen_frame_ = nullptr;
Becca Hughese9e27952018-06-25 17:08:272506
ericwilligersde386342016-10-19 02:35:092507 for (auto& observer : observers_) {
2508 observer.DidToggleFullscreenModeForTab(IsFullscreenForCurrentTab(),
2509 will_cause_resize);
2510 }
Becca Hughesd11d6502018-07-31 17:01:282511
2512 if (display_cutout_host_impl_)
2513 display_cutout_host_impl_->DidExitFullscreen();
[email protected]8a5e0ca2011-08-25 06:30:472514}
2515
Becca Hughesfd5d8f892018-06-14 18:23:362516void WebContentsImpl::FullscreenStateChanged(RenderFrameHost* rfh,
2517 bool is_fullscreen) {
Arthur Sonzogni929d29f2018-09-17 14:19:442518 RenderFrameHostImpl* frame = static_cast<RenderFrameHostImpl*>(rfh);
Becca Hughesfd5d8f892018-06-14 18:23:362519
2520 if (is_fullscreen) {
Jan Wilken Dörrie531be7ca2019-06-07 10:05:572521 if (!base::Contains(fullscreen_frames_, frame)) {
Arthur Sonzogni929d29f2018-09-17 14:19:442522 fullscreen_frames_.insert(frame);
2523 FullscreenFrameSetUpdated();
Becca Hughesfd5d8f892018-06-14 18:23:362524 }
Arthur Sonzogni929d29f2018-09-17 14:19:442525 return;
2526 }
Becca Hughesfd5d8f892018-06-14 18:23:362527
Arthur Sonzogni929d29f2018-09-17 14:19:442528 // If |frame| is no longer in fullscreen, remove it and any descendants.
2529 // See https://fullscreen.spec.whatwg.org.
Arthur Sonzogni969a794e2018-10-11 08:56:092530 size_t size_before_deletion = fullscreen_frames_.size();
2531 base::EraseIf(fullscreen_frames_, [&](RenderFrameHostImpl* current) {
2532 return (current == frame || current->IsDescendantOf(frame));
Arthur Sonzogni929d29f2018-09-17 14:19:442533 });
2534
Arthur Sonzogni969a794e2018-10-11 08:56:092535 if (size_before_deletion != fullscreen_frames_.size())
Arthur Sonzogni929d29f2018-09-17 14:19:442536 FullscreenFrameSetUpdated();
2537}
2538
2539void WebContentsImpl::FullscreenFrameSetUpdated() {
2540 if (fullscreen_frames_.empty()) {
2541 current_fullscreen_frame_ = nullptr;
2542 return;
Becca Hughesfd5d8f892018-06-14 18:23:362543 }
2544
Arthur Sonzogni929d29f2018-09-17 14:19:442545 // Find the current fullscreen frame and call the observers.
2546 // If frame A is fullscreen, then frame B goes into inner fullscreen, then B
2547 // exits fullscreen - that will result in A being fullscreen.
2548 RenderFrameHostImpl* new_fullscreen_frame = *std::max_element(
2549 fullscreen_frames_.begin(), fullscreen_frames_.end(), FrameCompareDepth);
Becca Hughesfd5d8f892018-06-14 18:23:362550
Arthur Sonzogni929d29f2018-09-17 14:19:442551 // If we have already notified observers about this frame then we should not
2552 // fire the observers again.
2553 if (new_fullscreen_frame == current_fullscreen_frame_)
2554 return;
2555 current_fullscreen_frame_ = new_fullscreen_frame;
Becca Hughesfd5d8f892018-06-14 18:23:362556
Arthur Sonzogni929d29f2018-09-17 14:19:442557 for (auto& observer : observers_)
2558 observer.DidAcquireFullscreen(new_fullscreen_frame);
Becca Hughesfd5d8f892018-06-14 18:23:362559
Arthur Sonzogni929d29f2018-09-17 14:19:442560 if (display_cutout_host_impl_)
2561 display_cutout_host_impl_->DidAcquireFullscreen(new_fullscreen_frame);
Becca Hughesfd5d8f892018-06-14 18:23:362562}
2563
Collin Baker989e0882019-11-01 01:27:172564void WebContentsImpl::UpdateVisibilityAndNotifyPageAndView(
2565 Visibility new_visibility) {
Collin Baker989e0882019-11-01 01:27:172566 // Only hide the page if there are no entities capturing screenshots
2567 // or video (e.g. mirroring).
2568 const bool page_is_visible =
2569 new_visibility == Visibility::VISIBLE || IsBeingCaptured();
2570 // If there are entities in Picture-in-Picture mode, don't activate
2571 // the "disable rendering" optimization.
2572 const bool view_is_visible = page_is_visible || HasPictureInPictureVideo();
2573
Collin Baker98457b52019-11-06 21:34:292574 if (page_is_visible) {
Dana Friedcf3bc8e2019-11-13 20:00:242575 // We cannot show a page or capture video unless there is a valid renderer
2576 // associated with this web contents. The navigation controller for this
2577 // page must be set to active (allowing navigation to complete, a renderer
2578 // and its associated views to be created, etc.) if any of these conditions
2579 // holds.
2580 //
2581 // Previously, it was possible for browser-side code to try to capture video
2582 // from a restored tab (for a variety of reasons, including the browser
2583 // creating preview thumbnails) and the tab would never actually load. By
2584 // keying this behavior off of |page_is_visible| instead of just
2585 // |new_visibility| we avoid this case. See crbug.com/1020782 for more
2586 // context.
2587 controller_.SetActive(true);
2588
2589 // This shows the Page before showing the individual RenderWidgets, as
2590 // RenderWidgets will work to produce compositor frames and handle input
2591 // as soon as they are shown. But the Page and other classes do not expect
2592 // to be producing frames when the Page is hidden. So we make sure the Page
2593 // is shown first.
Collin Baker98457b52019-11-06 21:34:292594 SendPageMessage(new PageMsg_VisibilityChanged(
2595 MSG_ROUTING_NONE, PageVisibilityState::kVisible));
2596 }
Collin Baker989e0882019-11-01 01:27:172597
2598 // |GetRenderWidgetHostView()| can be null if the user middle clicks a link to
2599 // open a tab in the background, then closes the tab before selecting it.
2600 // This is because closing the tab calls WebContentsImpl::Destroy(), which
2601 // removes the |GetRenderViewHost()|; then when we actually destroy the
2602 // window, OnWindowPosChanged() notices and calls WasHidden() (which
2603 // calls us).
2604 if (auto* view = GetRenderWidgetHostView()) {
2605 if (view_is_visible) {
2606 view->Show();
2607#if defined(OS_MACOSX)
2608 view->SetActive(true);
2609#endif
2610 } else if (new_visibility == Visibility::HIDDEN) {
2611 view->Hide();
2612 } else {
2613 view->WasOccluded();
2614 }
2615 }
2616
2617 if (!ShowingInterstitialPage())
2618 SetVisibilityForChildViews(view_is_visible);
2619
2620 // Make sure to call SetVisibilityAndNotifyObservers(VISIBLE) before notifying
2621 // the CrossProcessFrameConnector.
2622 if (new_visibility == Visibility::VISIBLE) {
2623 last_active_time_ = base::TimeTicks::Now();
2624 SetVisibilityAndNotifyObservers(new_visibility);
2625 }
2626
2627 if (!page_is_visible) {
2628 // Similar to when showing the page, we only hide the page after
2629 // hiding the individual RenderWidgets.
Collin Baker98457b52019-11-06 21:34:292630 SendPageMessage(new PageMsg_VisibilityChanged(
2631 MSG_ROUTING_NONE, PageVisibilityState::kHidden));
Collin Baker989e0882019-11-01 01:27:172632 } else {
2633 for (FrameTreeNode* node : frame_tree_.Nodes()) {
2634 RenderFrameProxyHost* parent = node->render_manager()->GetProxyToParent();
2635 if (!parent)
2636 continue;
2637
2638 parent->cross_process_frame_connector()->DelegateWasShown();
2639 }
2640 }
2641
2642 if (new_visibility != Visibility::VISIBLE)
2643 SetVisibilityAndNotifyObservers(new_visibility);
2644}
2645
Clark DuValla0e42992018-09-17 17:00:112646#if defined(OS_ANDROID)
2647void WebContentsImpl::UpdateUserGestureCarryoverInfo() {
2648 if (delegate_)
2649 delegate_->UpdateUserGestureCarryoverInfo(this);
2650}
2651#endif
2652
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:412653bool WebContentsImpl::IsFullscreenForCurrentTab() {
[email protected]199bba6e2012-04-04 16:19:382654 return delegate_ ? delegate_->IsFullscreenForTabOrPending(this) : false;
[email protected]5d5f7af2011-10-01 01:38:122655}
2656
Malay Keshav87c42c02019-01-15 08:37:472657bool WebContentsImpl::ShouldShowStaleContentOnEviction() {
2658 return GetDelegate() && GetDelegate()->ShouldShowStaleContentOnEviction(this);
2659}
2660
billorr21c005d2016-11-17 03:57:042661bool WebContentsImpl::IsFullscreen() {
2662 return IsFullscreenForCurrentTab();
2663}
2664
Eric Willigers052f0432019-10-04 04:06:572665blink::mojom::DisplayMode WebContentsImpl::GetDisplayMode(
avibf58fa0c2015-11-11 01:45:522666 RenderWidgetHostImpl* render_widget_host) const {
2667 if (!RenderViewHostImpl::From(render_widget_host))
Eric Willigers052f0432019-10-04 04:06:572668 return blink::mojom::DisplayMode::kBrowser;
avibf58fa0c2015-11-11 01:45:522669
mikhail.pozdnyakovc0e251b2015-04-15 06:51:122670 return delegate_ ? delegate_->GetDisplayMode(this)
Eric Willigers052f0432019-10-04 04:06:572671 : blink::mojom::DisplayMode::kBrowser;
mikhail.pozdnyakovc0e251b2015-04-15 06:51:122672}
2673
avic3aa8422015-11-09 20:57:222674void WebContentsImpl::RequestToLockMouse(
2675 RenderWidgetHostImpl* render_widget_host,
2676 bool user_gesture,
lfgad8244352016-07-13 16:55:512677 bool last_unlocked_by_target,
2678 bool privileged) {
lfgf0cd46e2017-01-04 00:05:232679 for (WebContentsImpl* current = this; current;
2680 current = current->GetOuterWebContents()) {
2681 if (current->mouse_lock_widget_) {
2682 render_widget_host->GotResponseToLockMouseRequest(false);
2683 return;
2684 }
[email protected]e9621112011-10-17 05:38:372685 }
avic3aa8422015-11-09 20:57:222686
lfgad8244352016-07-13 16:55:512687 if (privileged) {
lfgf0cd46e2017-01-04 00:05:232688 DCHECK(!GetOuterWebContents());
lfgad8244352016-07-13 16:55:512689 mouse_lock_widget_ = render_widget_host;
2690 render_widget_host->GotResponseToLockMouseRequest(true);
2691 return;
2692 }
2693
lfgbee1e0a2016-06-08 21:24:212694 bool widget_in_frame_tree = false;
2695 for (FrameTreeNode* node : frame_tree_.Nodes()) {
2696 if (node->current_frame_host()->GetRenderWidgetHost() ==
2697 render_widget_host) {
2698 widget_in_frame_tree = true;
2699 break;
2700 }
2701 }
2702
2703 if (widget_in_frame_tree && delegate_) {
lfgf0cd46e2017-01-04 00:05:232704 for (WebContentsImpl* current = this; current;
2705 current = current->GetOuterWebContents()) {
2706 current->mouse_lock_widget_ = render_widget_host;
2707 }
2708
avic3aa8422015-11-09 20:57:222709 delegate_->RequestToLockMouse(this, user_gesture, last_unlocked_by_target);
lfgbee1e0a2016-06-08 21:24:212710 } else {
2711 render_widget_host->GotResponseToLockMouseRequest(false);
2712 }
[email protected]e9621112011-10-17 05:38:372713}
2714
avi3e4b8512015-11-11 01:55:492715void WebContentsImpl::LostMouseLock(RenderWidgetHostImpl* render_widget_host) {
lfgbee1e0a2016-06-08 21:24:212716 CHECK(mouse_lock_widget_);
lfgf0cd46e2017-01-04 00:05:232717
2718 if (mouse_lock_widget_->delegate()->GetAsWebContents() != this)
2719 return mouse_lock_widget_->delegate()->LostMouseLock(render_widget_host);
2720
lfgbee1e0a2016-06-08 21:24:212721 mouse_lock_widget_->SendMouseLockLost();
lfgf0cd46e2017-01-04 00:05:232722 for (WebContentsImpl* current = this; current;
2723 current = current->GetOuterWebContents()) {
2724 current->mouse_lock_widget_ = nullptr;
2725 }
avi3e4b8512015-11-11 01:55:492726
[email protected]e9621112011-10-17 05:38:372727 if (delegate_)
2728 delegate_->LostMouseLock();
2729}
2730
lfgad8244352016-07-13 16:55:512731bool WebContentsImpl::HasMouseLock(RenderWidgetHostImpl* render_widget_host) {
2732 // To verify if the mouse is locked, the mouse_lock_widget_ needs to be
2733 // assigned to the widget that requested the mouse lock, and the top-level
2734 // platform RenderWidgetHostView needs to hold the mouse lock from the OS.
Lucas Gadania0ea0172018-09-20 18:31:372735 auto* widget_host = GetTopLevelRenderWidgetHostView();
2736 return mouse_lock_widget_ == render_widget_host && widget_host &&
2737 widget_host->IsMouseLocked();
lfgad8244352016-07-13 16:55:512738}
2739
lfg84763c92017-02-16 18:55:152740RenderWidgetHostImpl* WebContentsImpl::GetMouseLockWidget() {
Lucas Gadania0ea0172018-09-20 18:31:372741 auto* widget_host = GetTopLevelRenderWidgetHostView();
2742 if ((widget_host && widget_host->IsMouseLocked()) ||
lfge2176fb2017-03-26 00:45:472743 (GetFullscreenRenderWidgetHostView() &&
Lucas Gadania0ea0172018-09-20 18:31:372744 GetFullscreenRenderWidgetHostView()->IsMouseLocked())) {
lfg84763c92017-02-16 18:55:152745 return mouse_lock_widget_;
Lucas Gadania0ea0172018-09-20 18:31:372746 }
lfg84763c92017-02-16 18:55:152747
2748 return nullptr;
2749}
2750
Joe Downing192998b22018-03-22 15:51:362751bool WebContentsImpl::RequestKeyboardLock(
Joe Downing13dd76b2018-04-09 18:32:152752 RenderWidgetHostImpl* render_widget_host,
2753 bool esc_key_locked) {
Joe Downing192998b22018-03-22 15:51:362754 DCHECK(render_widget_host);
Joe Downing192998b22018-03-22 15:51:362755 if (render_widget_host->delegate()->GetAsWebContents() != this) {
2756 NOTREACHED();
2757 return false;
2758 }
2759
2760 // KeyboardLock is only supported when called by the top-level browsing
2761 // context and is not supported in embedded content scenarios.
2762 if (GetOuterWebContents())
2763 return false;
2764
Joe Downing13dd76b2018-04-09 18:32:152765 esc_key_locked_ = esc_key_locked;
Joe Downing192998b22018-03-22 15:51:362766 keyboard_lock_widget_ = render_widget_host;
2767
Joe Downing13dd76b2018-04-09 18:32:152768 if (delegate_)
2769 delegate_->RequestKeyboardLock(this, esc_key_locked_);
Joe Downing192998b22018-03-22 15:51:362770 return true;
2771}
2772
2773void WebContentsImpl::CancelKeyboardLock(
2774 RenderWidgetHostImpl* render_widget_host) {
2775 if (!keyboard_lock_widget_ || render_widget_host != keyboard_lock_widget_)
2776 return;
2777
2778 RenderWidgetHostImpl* old_keyboard_lock_widget = keyboard_lock_widget_;
2779 keyboard_lock_widget_ = nullptr;
2780
Joe Downing13dd76b2018-04-09 18:32:152781 if (delegate_)
2782 delegate_->CancelKeyboardLockRequest(this);
2783
Joe Downing192998b22018-03-22 15:51:362784 old_keyboard_lock_widget->CancelKeyboardLock();
2785}
2786
2787RenderWidgetHostImpl* WebContentsImpl::GetKeyboardLockWidget() {
2788 return keyboard_lock_widget_;
2789}
2790
Dave Tapuskac3344362019-02-20 17:54:282791void WebContentsImpl::OnRenderFrameProxyVisibilityChanged(
2792 blink::mojom::FrameVisibility visibility) {
2793 switch (visibility) {
2794 case blink::mojom::FrameVisibility::kRenderedInViewport:
2795 WasShown();
2796 break;
2797 case blink::mojom::FrameVisibility::kNotRendered:
2798 WasHidden();
2799 break;
2800 case blink::mojom::FrameVisibility::kRenderedOutOfViewport:
2801 WasOccluded();
2802 break;
2803 }
ekaramada4f42692016-02-11 19:48:372804}
2805
Albert J. Wong65fe64d2019-09-20 02:48:142806RenderFrameHostDelegate* WebContentsImpl::CreateNewWindow(
csharrison95f01e922017-04-24 18:52:352807 RenderFrameHost* opener,
rockot5c478a72016-09-28 23:14:182808 const mojom::CreateNewWindowParams& params,
Albert J. Wong65fe64d2019-09-20 02:48:142809 bool is_new_browsing_instance,
Sergey Kuznetsov32257a22019-02-11 20:26:502810 bool has_user_gesture,
[email protected]97714c82012-06-06 10:15:132811 SessionStorageNamespace* session_storage_namespace) {
csharrison95f01e922017-04-24 18:52:352812 DCHECK(opener);
nick5ae4d2d2017-01-06 01:18:352813
csharrison95f01e922017-04-24 18:52:352814 int render_process_id = opener->GetProcess()->GetID();
csharrison95f01e922017-04-24 18:52:352815
Albert J. Wong65fe64d2019-09-20 02:48:142816 SiteInstance* source_site_instance = opener->GetSiteInstance();
nick5ae4d2d2017-01-06 01:18:352817
[email protected]bafe6cd2012-05-23 23:09:502818 // We usually create the new window in the same BrowsingInstance (group of
2819 // script-related windows), by passing in the current SiteInstance. However,
[email protected]c4538072013-03-18 02:17:552820 // if the opener is being suppressed (in a non-guest), we create a new
2821 // SiteInstance in its own BrowsingInstance.
[email protected]a24efc22014-05-26 15:50:252822 bool is_guest = BrowserPluginGuest::IsGuest(this);
[email protected]c4538072013-03-18 02:17:552823
[email protected]bafe6cd2012-05-23 23:09:502824 scoped_refptr<SiteInstance> site_instance =
alexmos4cf2aa32015-07-15 23:40:432825 params.opener_suppressed && !is_guest
2826 ? SiteInstance::CreateForURL(GetBrowserContext(), params.target_url)
2827 : source_site_instance;
[email protected]bafe6cd2012-05-23 23:09:502828
[email protected]d1198fd2012-08-13 22:50:192829 // We must assign the SessionStorageNamespace before calling Init().
[email protected]4c3a23582012-08-18 08:54:342830 //
2831 // http://crbug.com/142685
[email protected]fdac6ade2013-07-20 01:06:302832 const std::string& partition_id =
2833 GetContentClient()->browser()->
2834 GetStoragePartitionIdForSite(GetBrowserContext(),
2835 site_instance->GetSiteURL());
[email protected]fc72bb12013-06-02 21:13:462836 StoragePartition* partition = BrowserContext::GetStoragePartition(
2837 GetBrowserContext(), site_instance.get());
[email protected]5f2aa722013-08-07 16:59:412838 DOMStorageContextWrapper* dom_storage_context =
2839 static_cast<DOMStorageContextWrapper*>(partition->GetDOMStorageContext());
[email protected]d1198fd2012-08-13 22:50:192840 SessionStorageNamespaceImpl* session_storage_namespace_impl =
2841 static_cast<SessionStorageNamespaceImpl*>(session_storage_namespace);
2842 CHECK(session_storage_namespace_impl->IsFromContext(dom_storage_context));
[email protected]dd6730412013-08-14 15:03:372843
Albert J. Wong1ceccef92019-10-08 08:25:202844 if (delegate_ && delegate_->IsWebContentsCreationOverridden(
2845 source_site_instance, params.window_container_type,
2846 opener->GetLastCommittedURL(), params.frame_name,
2847 params.target_url)) {
2848 return static_cast<WebContentsImpl*>(delegate_->CreateCustomWebContents(
2849 opener, source_site_instance, is_new_browsing_instance,
2850 opener->GetLastCommittedURL(), params.frame_name, params.target_url,
2851 partition_id, session_storage_namespace));
[email protected]dd6730412013-08-14 15:03:372852 }
2853
danakj22b4e8b2019-08-01 23:14:392854 bool renderer_started_hidden =
2855 params.disposition == WindowOpenDisposition::NEW_BACKGROUND_TAB;
2856
[email protected]dd6730412013-08-14 15:03:372857 // Create the new web contents. This will automatically create the new
2858 // WebContentsView. In the future, we may want to create the view separately.
[email protected]fc72bb12013-06-02 21:13:462859 CreateParams create_params(GetBrowserContext(), site_instance.get());
nasko48321ca32015-07-02 20:44:122860 create_params.main_frame_name = params.frame_name;
alexmos4cf2aa32015-07-15 23:40:432861 create_params.opener_render_process_id = render_process_id;
csharrison95f01e922017-04-24 18:52:352862 create_params.opener_render_frame_id = opener->GetRoutingID();
[email protected]50d326e2014-05-20 17:59:062863 create_params.opener_suppressed = params.opener_suppressed;
danakj22b4e8b2019-08-01 23:14:392864 create_params.initially_hidden = renderer_started_hidden;
[email protected]50d326e2014-05-20 17:59:062865
Albert J. Wong65fe64d2019-09-20 02:48:142866 // Even though all codepaths leading here are in response to a renderer
2867 // tryng to open a new window, if the new window ends up in a different
2868 // browsing instance, then the RenderViewHost, RenderWidgetHost,
2869 // RenderFrameHost constellation is effectively browser initiated
2870 // the opener's process will not given the routing IDs for the new
2871 // objects.
2872 create_params.renderer_initiated_creation = !is_new_browsing_instance;
Albert J. Wong1ceccef92019-10-08 08:25:202873
2874 // If |is_new_browsing_instance| is true, defer routing_id allocation
2875 // to the WebContentsImpl::Create() call. This is required because with
2876 // a new browsing instance, WebContentsImpl::Create() may elect a different
2877 // SiteInstance from |site_instance| (which happens if |site_instance| is
2878 // nullptr for example).
2879 //
2880 // TODO(ajwong): This routing id allocation should be pushed down further
2881 // into WebContentsImpl::Create().
2882 if (!is_new_browsing_instance) {
2883 create_params.routing_id = opener->GetProcess()->GetNextRoutingID();
2884 create_params.main_frame_routing_id =
2885 opener->GetProcess()->GetNextRoutingID();
2886 create_params.main_frame_widget_routing_id =
2887 opener->GetProcess()->GetNextRoutingID();
2888 }
Albert J. Wong65fe64d2019-09-20 02:48:142889
2890 std::unique_ptr<WebContentsImpl> new_contents;
[email protected]c4538072013-03-18 02:17:552891 if (!is_guest) {
2892 create_params.context = view_->GetNativeView();
Albert J. Wong65fe64d2019-09-20 02:48:142893 new_contents = WebContentsImpl::Create(create_params);
2894 } else {
2895 new_contents = base::WrapUnique(static_cast<WebContentsImpl*>(
2896 GetBrowserPluginGuest()->CreateNewGuestWindow(create_params)));
[email protected]c4538072013-03-18 02:17:552897 }
Albert J. Wong65fe64d2019-09-20 02:48:142898 auto* new_contents_impl = new_contents.get();
danakje6c01622018-10-05 19:39:262899
2900 new_contents_impl->GetController().SetSessionStorageNamespace(
erikchenbee5c9622018-04-27 19:30:252901 partition_id, session_storage_namespace);
[email protected]d1198fd2012-08-13 22:50:192902
alexmos646fec02015-07-25 00:11:492903 // If the new frame has a name, make sure any SiteInstances that can find
2904 // this named frame have proxies for it. Must be called after
2905 // SetSessionStorageNamespace, since this calls CreateRenderView, which uses
2906 // GetSessionStorageNamespace.
2907 if (!params.frame_name.empty())
danakje6c01622018-10-05 19:39:262908 new_contents_impl->GetRenderManager()->CreateProxiesForNewNamedFrame();
alexmos646fec02015-07-25 00:11:492909
[email protected]c4538072013-03-18 02:17:552910 // Save the window for later if we're not suppressing the opener (since it
[email protected]d70bea92013-04-05 04:23:342911 // will be shown immediately).
2912 if (!params.opener_suppressed) {
2913 if (!is_guest) {
danakje6c01622018-10-05 19:39:262914 WebContentsView* new_view = new_contents_impl->view_.get();
[email protected]bafe6cd2012-05-23 23:09:502915
[email protected]d70bea92013-04-05 04:23:342916 // TODO(brettw): It seems bogus that we have to call this function on the
2917 // newly created object and give it one of its own member variables.
danakj22b4e8b2019-08-01 23:14:392918 RenderWidgetHostView* widget_view = new_view->CreateViewForWidget(
danakje6c01622018-10-05 19:39:262919 new_contents_impl->GetRenderViewHost()->GetWidget(), false);
danakj22b4e8b2019-08-01 23:14:392920 if (!renderer_started_hidden) {
2921 // RenderWidgets for frames always initialize as hidden. If the renderer
2922 // created this window as visible, then we show it here.
2923 widget_view->Show();
2924 }
[email protected]d70bea92013-04-05 04:23:342925 }
[email protected]bafe6cd2012-05-23 23:09:502926 // Save the created window associated with the route so we can show it
2927 // later.
Albert J. Wongcb004632018-07-10 22:58:252928 //
2929 // TODO(ajwong): This should be keyed off the RenderFrame routing id or the
2930 // FrameTreeNode id instead of the routing id of the Widget for the main
2931 // frame. https://crbug.com/545684
Albert J. Wong1ceccef92019-10-08 08:25:202932 DCHECK_NE(MSG_ROUTING_NONE, create_params.main_frame_routing_id);
2933 GlobalRoutingID id(render_process_id,
2934 create_params.main_frame_widget_routing_id);
Albert J. Wong65fe64d2019-09-20 02:48:142935 pending_contents_[id] = std::move(new_contents);
danakje6c01622018-10-05 19:39:262936 AddDestructionObserver(new_contents_impl);
[email protected]bafe6cd2012-05-23 23:09:502937 }
2938
2939 if (delegate_) {
Bryan McQuaded2b93c02017-07-14 22:26:312940 delegate_->WebContentsCreated(this, render_process_id,
2941 opener->GetRoutingID(), params.frame_name,
danakje6c01622018-10-05 19:39:262942 params.target_url, new_contents_impl);
[email protected]bafe6cd2012-05-23 23:09:502943 }
2944
Charlie Harrisonf60dd1c2018-08-15 21:15:412945 for (auto& observer : observers_) {
danakje6c01622018-10-05 19:39:262946 observer.DidOpenRequestedURL(new_contents_impl, opener, params.target_url,
Leon Han963dc182018-11-06 05:41:482947 params.referrer.To<Referrer>(),
2948 params.disposition, ui::PAGE_TRANSITION_LINK,
Charlie Harrisonf60dd1c2018-08-15 21:15:412949 false, // started_from_context_menu
2950 true); // renderer_initiated
pnolandaae574e2017-03-06 21:04:212951 }
2952
Avi Drissmanba3b1b342017-08-29 18:16:132953 // Any new WebContents opened while this WebContents is in fullscreen can be
2954 // used to confuse the user, so drop fullscreen.
Avi Drissmand18c51972018-08-15 18:32:092955 ForSecurityDropFullscreen();
Avi Drissmanba3b1b342017-08-29 18:16:132956
[email protected]bafe6cd2012-05-23 23:09:502957 if (params.opener_suppressed) {
2958 // When the opener is suppressed, the original renderer cannot access the
2959 // new window. As a result, we need to show and navigate the window here.
[email protected]eda238a12012-09-07 23:44:002960 bool was_blocked = false;
erikchenbee5c9622018-04-27 19:30:252961
[email protected]eda238a12012-09-07 23:44:002962 if (delegate_) {
danakje6c01622018-10-05 19:39:262963 base::WeakPtr<WebContentsImpl> weak_new_contents =
2964 new_contents_impl->weak_factory_.GetWeakPtr();
nick0d558482017-02-13 22:27:222965
danakje6c01622018-10-05 19:39:262966 gfx::Rect initial_rect; // Report an empty initial rect.
Albert J. Wong65fe64d2019-09-20 02:48:142967 delegate_->AddNewContents(this, std::move(new_contents),
erikchenbee5c9622018-04-27 19:30:252968 params.disposition, initial_rect,
Sergey Kuznetsov32257a22019-02-11 20:26:502969 has_user_gesture, &was_blocked);
danakje6c01622018-10-05 19:39:262970 // The delegate may delete |new_contents_impl| during AddNewContents().
nick0d558482017-02-13 22:27:222971 if (!weak_new_contents)
Albert J. Wong65fe64d2019-09-20 02:48:142972 return nullptr;
[email protected]eda238a12012-09-07 23:44:002973 }
erikchenbee5c9622018-04-27 19:30:252974
[email protected]eda238a12012-09-07 23:44:002975 if (!was_blocked) {
Nasko Oskov83a8cf92018-10-19 14:58:562976 std::unique_ptr<NavigationController::LoadURLParams> load_params =
2977 std::make_unique<NavigationController::LoadURLParams>(
2978 params.target_url);
Nasko Oskov93e7c55c2018-12-19 01:59:292979 load_params->initiator_origin = opener->GetLastCommittedOrigin();
Leon Han963dc182018-11-06 05:41:482980 load_params->referrer = params.referrer.To<Referrer>();
Nasko Oskov83a8cf92018-10-19 14:58:562981 load_params->transition_type = ui::PAGE_TRANSITION_LINK;
2982 load_params->is_renderer_initiated = true;
Sergey Kuznetsov32257a22019-02-11 20:26:502983 load_params->has_user_gesture = has_user_gesture;
mariakhomenkoa4971c12015-07-21 19:04:372984
2985 if (delegate_ && !is_guest &&
2986 !delegate_->ShouldResumeRequestsForCreatedWindow()) {
Nasko Oskov83a8cf92018-10-19 14:58:562987 // We are in asynchronous add new contents path, delay navigation.
2988 DCHECK(!new_contents_impl->delayed_open_url_params_);
2989 new_contents_impl->delayed_load_url_params_ = std::move(load_params);
mariakhomenkoa4971c12015-07-21 19:04:372990 } else {
Nasko Oskov83a8cf92018-10-19 14:58:562991 new_contents_impl->controller_.LoadURLWithParams(*load_params.get());
Nasko Oskov28ebd5b2018-12-07 22:29:332992 if (!is_guest)
2993 new_contents_impl->Focus();
mariakhomenkoa4971c12015-07-21 19:04:372994 }
[email protected]eda238a12012-09-07 23:44:002995 }
[email protected]bafe6cd2012-05-23 23:09:502996 }
Albert J. Wong65fe64d2019-09-20 02:48:142997 return new_contents_impl;
[email protected]bafe6cd2012-05-23 23:09:502998}
2999
Erik Chenc71b51fe2019-09-19 21:34:273000void WebContentsImpl::CreateNewWidget(int32_t render_process_id,
3001 int32_t widget_route_id,
3002 mojo::PendingRemote<mojom::Widget> widget,
3003 RenderViewHostImpl* render_view_host) {
Albert J. Wongf6e13ed2018-09-18 15:25:473004 CreateNewWidget(render_process_id, widget_route_id, /*is_fullscreen=*/false,
Erik Chenc71b51fe2019-09-19 21:34:273005 std::move(widget), render_view_host);
[email protected]bafe6cd2012-05-23 23:09:503006}
3007
Julie Jeongeun Kimcaacf9102019-09-12 02:13:053008void WebContentsImpl::CreateNewFullscreenWidget(
3009 int32_t render_process_id,
3010 int32_t widget_route_id,
Erik Chenc71b51fe2019-09-19 21:34:273011 mojo::PendingRemote<mojom::Widget> widget,
3012 RenderViewHostImpl* render_view_host) {
Albert J. Wongf6e13ed2018-09-18 15:25:473013 CreateNewWidget(render_process_id, widget_route_id, /*is_fullscreen=*/true,
Erik Chenc71b51fe2019-09-19 21:34:273014 std::move(widget), render_view_host);
[email protected]bafe6cd2012-05-23 23:09:503015}
3016
Erik Chenc71b51fe2019-09-19 21:34:273017void WebContentsImpl::CreateNewWidget(int32_t render_process_id,
3018 int32_t route_id,
3019 bool is_fullscreen,
3020 mojo::PendingRemote<mojom::Widget> widget,
3021 RenderViewHostImpl* render_view_host) {
kenrba26d15092016-02-10 22:00:253022 RenderProcessHost* process = RenderProcessHost::FromID(render_process_id);
kenrbb46f86a2015-12-07 07:53:233023 // A message to create a new widget can only come from an active process for
[email protected]a8504022013-12-04 20:23:513024 // this WebContentsImpl instance. If any other process sends the request,
3025 // it is invalid and the process must be terminated.
dcheng57e39e22016-01-21 00:25:383026 if (!HasMatchingProcess(&frame_tree_, render_process_id)) {
Lukasz Anforowicz6f746282018-01-04 23:24:513027 ReceivedBadMessage(process, bad_message::WCI_NEW_WIDGET_PROCESS_MISMATCH);
[email protected]a8504022013-12-04 20:23:513028 return;
3029 }
3030
Dave Tapuska485aca92017-08-08 00:47:583031 RenderWidgetHostImpl* widget_host = new RenderWidgetHostImpl(
David Black9cca3592019-11-06 23:02:223032 this, process, route_id, std::move(widget), IsHidden(),
3033 std::make_unique<FrameTokenMessageQueue>());
[email protected]cfd80b02014-05-01 17:46:483034 RenderWidgetHostViewBase* widget_view =
3035 static_cast<RenderWidgetHostViewBase*>(
danakj0b246942018-09-17 21:30:273036 view_->CreateViewForChildWidget(widget_host));
[email protected]83918ec2013-01-10 15:37:193037 if (!widget_view)
3038 return;
danakj0b246942018-09-17 21:30:273039 // Fullscreen child widgets are frames, other child widgets are popups, and
3040 // popups should not get activated.
3041 if (!is_fullscreen)
3042 widget_view->SetWidgetType(WidgetType::kPopup);
[email protected]bafe6cd2012-05-23 23:09:503043 // Save the created widget associated with the route so we can show it later.
Lukasz Anforowicz09060bdf72018-08-23 15:53:173044 pending_widget_views_[GlobalRoutingID(render_process_id, route_id)] =
alexmosc2a8cec2016-05-23 22:19:533045 widget_view;
[email protected]bafe6cd2012-05-23 23:09:503046}
3047
alexmosc2a8cec2016-05-23 22:19:533048void WebContentsImpl::ShowCreatedWindow(int process_id,
nick5ae4d2d2017-01-06 01:18:353049 int main_frame_widget_route_id,
[email protected]bafe6cd2012-05-23 23:09:503050 WindowOpenDisposition disposition,
bokan107a47f2015-02-03 23:23:393051 const gfx::Rect& initial_rect,
[email protected]bafe6cd2012-05-23 23:09:503052 bool user_gesture) {
danakje6c01622018-10-05 19:39:263053 // This method is the renderer requesting an existing top level window to
3054 // show a new top level window that the renderer created. Each top level
3055 // window is associated with a WebContents. In this case it was created
3056 // earlier but showing it was deferred until the renderer requested for it
3057 // to be shown. We find that previously created WebContents here.
3058 // TODO(danakj): Why do we defer this show step until the renderer asks for it
3059 // when it will always do so. What needs to happen in the renderer before we
3060 // reach here?
3061 std::unique_ptr<WebContentsImpl> owned_created =
nick5ae4d2d2017-01-06 01:18:353062 GetCreatedWindow(process_id, main_frame_widget_route_id);
danakje6c01622018-10-05 19:39:263063 WebContentsImpl* created = owned_created.get();
3064 // The browser may have rejected the request to make a new window, or the
3065 // renderer could be sending an invalid route id. Ignore the request then.
3066 if (!created)
3067 return;
mariakhomenko44bdc4732015-04-29 01:55:383068
danakje6c01622018-10-05 19:39:263069 // This uses the delegate for the WebContents where the window was created
3070 // from, to control how to show the newly created window.
3071 WebContentsDelegate* delegate = GetDelegate();
nick5ae4d2d2017-01-06 01:18:353072
danakje6c01622018-10-05 19:39:263073 // The delegate can be null in tests, so we must check for it :(.
3074 if (delegate) {
3075 // Mark the web contents as pending resume, then immediately do
3076 // the resume if the delegate wants it.
3077 created->is_resume_pending_ = true;
3078 if (delegate->ShouldResumeRequestsForCreatedWindow())
3079 created->ResumeLoadingCreatedWebContents();
3080
3081 base::WeakPtr<WebContentsImpl> weak_created =
3082 created->weak_factory_.GetWeakPtr();
3083 delegate->AddNewContents(this, std::move(owned_created), disposition,
3084 initial_rect, user_gesture, nullptr);
3085 // The delegate may delete |created| during AddNewContents().
3086 if (!weak_created)
3087 return;
[email protected]eda238a12012-09-07 23:44:003088 }
danakje6c01622018-10-05 19:39:263089
3090 RenderWidgetHostImpl* rwh = created->GetMainFrame()->GetRenderWidgetHost();
3091 DCHECK_EQ(main_frame_widget_route_id, rwh->GetRoutingID());
3092 rwh->Send(new WidgetMsg_SetBounds_ACK(rwh->GetRoutingID()));
[email protected]bafe6cd2012-05-23 23:09:503093}
3094
alexmosc2a8cec2016-05-23 22:19:533095void WebContentsImpl::ShowCreatedWidget(int process_id,
Albert J. Wongf6e13ed2018-09-18 15:25:473096 int widget_route_id,
bokan107a47f2015-02-03 23:23:393097 const gfx::Rect& initial_rect) {
Albert J. Wongf6e13ed2018-09-18 15:25:473098 ShowCreatedWidget(process_id, widget_route_id, false, initial_rect);
[email protected]bafe6cd2012-05-23 23:09:503099}
3100
alexmosc2a8cec2016-05-23 22:19:533101void WebContentsImpl::ShowCreatedFullscreenWidget(int process_id,
Albert J. Wongf6e13ed2018-09-18 15:25:473102 int widget_route_id) {
3103 ShowCreatedWidget(process_id, widget_route_id, true, gfx::Rect());
[email protected]bafe6cd2012-05-23 23:09:503104}
3105
alexmosc2a8cec2016-05-23 22:19:533106void WebContentsImpl::ShowCreatedWidget(int process_id,
3107 int route_id,
[email protected]bafe6cd2012-05-23 23:09:503108 bool is_fullscreen,
bokan107a47f2015-02-03 23:23:393109 const gfx::Rect& initial_rect) {
[email protected]cfd80b02014-05-01 17:46:483110 RenderWidgetHostViewBase* widget_host_view =
alexmosc2a8cec2016-05-23 22:19:533111 static_cast<RenderWidgetHostViewBase*>(
3112 GetCreatedWidget(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:503113 if (!widget_host_view)
3114 return;
[email protected]cfd80b02014-05-01 17:46:483115
W. James MacLeanec4125c2019-09-27 18:56:003116 // GetOutermostWebContents() returns |this| if there are no outer WebContents.
W. James MacLean3c5f50462019-10-28 16:24:213117 auto* outer_web_contents = GetOuterWebContents();
3118 auto* outermost_web_contents = GetOutermostWebContents();
W. James MacLeanec4125c2019-09-27 18:56:003119 RenderWidgetHostView* view =
W. James MacLean3c5f50462019-10-28 16:24:213120 outermost_web_contents->GetRenderWidgetHostView();
3121 // It's not entirely obvious why we need the transform only in the case where
3122 // the outer webcontents is not the same as the outermost webcontents. It may
3123 // be due to the fact that oopifs that are children of the mainframe get
3124 // correct values for their screenrects, but deeper cross-process frames do
3125 // not. Hopefully this can be resolved with https://crbug.com/928825.
3126 // Handling these cases separately is needed for http://crbug.com/1015298.
3127 bool needs_transform = this != outermost_web_contents &&
3128 outermost_web_contents != outer_web_contents;
W. James MacLeanec4125c2019-09-27 18:56:003129
3130 gfx::Rect transformed_rect(initial_rect);
3131 RenderWidgetHostView* this_view = GetRenderWidgetHostView();
W. James MacLean3c5f50462019-10-28 16:24:213132 if (needs_transform) {
W. James MacLeanec4125c2019-09-27 18:56:003133 // We need to transform the coordinates of initial_rect.
3134 gfx::Point origin =
3135 this_view->TransformPointToRootCoordSpace(initial_rect.origin());
3136 gfx::Point bottom_right =
3137 this_view->TransformPointToRootCoordSpace(initial_rect.bottom_right());
3138 transformed_rect =
3139 gfx::Rect(origin.x(), origin.y(), bottom_right.x() - origin.x(),
3140 bottom_right.y() - origin.y());
[email protected]cfd80b02014-05-01 17:46:483141 }
3142
danakj0b246942018-09-17 21:30:273143 // Fullscreen child widgets are frames, other child widgets are popups.
[email protected]4aebbca2013-09-17 22:26:493144 if (is_fullscreen) {
[email protected]d7f80ba2013-10-12 07:42:313145 DCHECK_EQ(MSG_ROUTING_NONE, fullscreen_widget_routing_id_);
[email protected]0b431992014-06-24 00:08:033146 view_->StoreFocus();
alexmosc9e76ec2016-05-16 22:59:373147 fullscreen_widget_process_id_ =
3148 widget_host_view->GetRenderWidgetHost()->GetProcess()->GetID();
[email protected]d7f80ba2013-10-12 07:42:313149 fullscreen_widget_routing_id_ = route_id;
[email protected]4aebbca2013-09-17 22:26:493150 if (delegate_ && delegate_->EmbedsFullscreenWidget()) {
3151 widget_host_view->InitAsChild(GetRenderWidgetHostView()->GetNativeView());
Dave Tapuska3ed44192018-05-01 18:53:303152 delegate_->EnterFullscreenModeForTab(this, GURL(),
Dave Tapuskaa4189512019-10-15 20:27:343153 blink::mojom::FullscreenOptions());
[email protected]4aebbca2013-09-17 22:26:493154 } else {
[email protected]cfd80b02014-05-01 17:46:483155 widget_host_view->InitAsFullscreen(view);
[email protected]4aebbca2013-09-17 22:26:493156 }
ericwilligersde386342016-10-19 02:35:093157 for (auto& observer : observers_)
3158 observer.DidShowFullscreenWidget();
[email protected]4aebbca2013-09-17 22:26:493159 if (!widget_host_view->HasFocus())
3160 widget_host_view->Focus();
3161 } else {
W. James MacLeanec4125c2019-09-27 18:56:003162 widget_host_view->InitAsPopup(view, transformed_rect);
[email protected]4aebbca2013-09-17 22:26:493163 }
[email protected]89054502012-06-03 10:29:243164
yiyixcb1fbc4f2018-03-16 19:54:083165 RenderWidgetHostImpl* render_widget_host_impl = widget_host_view->host();
[email protected]89054502012-06-03 10:29:243166 render_widget_host_impl->Init();
[email protected]d7f80ba2013-10-12 07:42:313167 // Only allow privileged mouse lock for fullscreen render widget, which is
3168 // used to implement Pepper Flash fullscreen.
3169 render_widget_host_impl->set_allow_privileged_mouse_lock(is_fullscreen);
[email protected]bafe6cd2012-05-23 23:09:503170}
3171
danakje6c01622018-10-05 19:39:263172std::unique_ptr<WebContentsImpl> WebContentsImpl::GetCreatedWindow(
nick5ae4d2d2017-01-06 01:18:353173 int process_id,
3174 int main_frame_widget_route_id) {
Lukasz Anforowicz09060bdf72018-08-23 15:53:173175 auto key = GlobalRoutingID(process_id, main_frame_widget_route_id);
nick5ae4d2d2017-01-06 01:18:353176 auto iter = pending_contents_.find(key);
[email protected]bafe6cd2012-05-23 23:09:503177
3178 // Certain systems can block the creation of new windows. If we didn't succeed
3179 // in creating one, just return NULL.
alexmosc2a8cec2016-05-23 22:19:533180 if (iter == pending_contents_.end())
3181 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:503182
danakje6c01622018-10-05 19:39:263183 std::unique_ptr<WebContentsImpl> new_contents = std::move(iter->second);
nick5ae4d2d2017-01-06 01:18:353184 pending_contents_.erase(key);
danakje6c01622018-10-05 19:39:263185 RemoveDestructionObserver(new_contents.get());
[email protected]bafe6cd2012-05-23 23:09:503186
[email protected]d70bea92013-04-05 04:23:343187 // Don't initialize the guest WebContents immediately.
danakje6c01622018-10-05 19:39:263188 if (BrowserPluginGuest::IsGuest(new_contents.get()))
[email protected]d70bea92013-04-05 04:23:343189 return new_contents;
3190
Lukasz Anforowicz5510ed652018-06-06 16:16:193191 if (!new_contents->GetMainFrame()->GetProcess()->IsInitializedAndNotDead() ||
nick5ae4d2d2017-01-06 01:18:353192 !new_contents->GetMainFrame()->GetView()) {
alexmosc2a8cec2016-05-23 22:19:533193 return nullptr;
nick5ae4d2d2017-01-06 01:18:353194 }
[email protected]bafe6cd2012-05-23 23:09:503195
[email protected]bafe6cd2012-05-23 23:09:503196 return new_contents;
3197}
3198
alexmosc2a8cec2016-05-23 22:19:533199RenderWidgetHostView* WebContentsImpl::GetCreatedWidget(int process_id,
3200 int route_id) {
Lukasz Anforowicz09060bdf72018-08-23 15:53:173201 auto iter = pending_widget_views_.find(GlobalRoutingID(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:503202 if (iter == pending_widget_views_.end()) {
3203 DCHECK(false);
alexmosc2a8cec2016-05-23 22:19:533204 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:503205 }
3206
3207 RenderWidgetHostView* widget_host_view = iter->second;
Lukasz Anforowicz09060bdf72018-08-23 15:53:173208 pending_widget_views_.erase(GlobalRoutingID(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:503209
3210 RenderWidgetHost* widget_host = widget_host_view->GetRenderWidgetHost();
Lukasz Anforowicz5510ed652018-06-06 16:16:193211 if (!widget_host->GetProcess()->IsInitializedAndNotDead()) {
[email protected]bafe6cd2012-05-23 23:09:503212 // The view has gone away or the renderer crashed. Nothing to do.
alexmosc2a8cec2016-05-23 22:19:533213 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:503214 }
3215
3216 return widget_host_view;
3217}
3218
[email protected]f13b4202012-06-12 23:53:233219void WebContentsImpl::RequestMediaAccessPermission(
[email protected]33662e52013-01-07 21:31:093220 const MediaStreamRequest& request,
Mark Pilgrim57499082018-06-12 12:38:303221 MediaResponseCallback callback) {
[email protected]d19b84b2014-03-14 11:52:373222 if (delegate_) {
Mark Pilgrim57499082018-06-12 12:38:303223 delegate_->RequestMediaAccessPermission(this, request, std::move(callback));
[email protected]d19b84b2014-03-14 11:52:373224 } else {
Antonio Gomes0d42960a2019-06-05 12:35:513225 std::move(callback).Run(
3226 blink::MediaStreamDevices(),
3227 blink::mojom::MediaStreamRequestResult::FAILED_DUE_TO_SHUTDOWN,
3228 std::unique_ptr<MediaStreamUI>());
[email protected]d19b84b2014-03-14 11:52:373229 }
[email protected]f13b4202012-06-12 23:53:233230}
3231
Chandan Padhia4b8bcb72017-09-12 16:41:043232bool WebContentsImpl::CheckMediaAccessPermission(
Raymes Khouryad7c24a12018-03-05 23:22:583233 RenderFrameHost* render_frame_host,
Chandan Padhia4b8bcb72017-09-12 16:41:043234 const url::Origin& security_origin,
Antonio Gomesc8b734b2019-06-05 18:22:163235 blink::mojom::MediaStreamType type) {
3236 DCHECK(type == blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE ||
3237 type == blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE);
Chandan Padhia4b8bcb72017-09-12 16:41:043238 return delegate_ && delegate_->CheckMediaAccessPermission(
Raymes Khouryad7c24a12018-03-05 23:22:583239 render_frame_host, security_origin.GetURL(), type);
grunell657d4d82014-09-18 00:09:433240}
3241
Guido Urdaneta73fa6632019-01-14 18:46:263242std::string WebContentsImpl::GetDefaultMediaDeviceID(
Antonio Gomesc8b734b2019-06-05 18:22:163243 blink::mojom::MediaStreamType type) {
guidou8a440b842017-01-30 13:58:433244 if (!delegate_)
3245 return std::string();
3246 return delegate_->GetDefaultMediaDeviceID(this, type);
3247}
3248
[email protected]cc9200432013-07-23 23:02:403249SessionStorageNamespace* WebContentsImpl::GetSessionStorageNamespace(
3250 SiteInstance* instance) {
3251 return controller_.GetSessionStorageNamespace(instance);
3252}
3253
[email protected]6de7fc482014-06-06 10:46:443254SessionStorageNamespaceMap WebContentsImpl::GetSessionStorageNamespaceMap() {
3255 return controller_.GetSessionStorageNamespaceMap();
3256}
3257
[email protected]9b159a52013-10-03 17:24:553258FrameTree* WebContentsImpl::GetFrameTree() {
3259 return &frame_tree_;
3260}
3261
aelias5252baa2016-04-10 01:18:023262bool WebContentsImpl::IsOverridingUserAgent() {
3263 return GetController().GetVisibleEntry() &&
3264 GetController().GetVisibleEntry()->GetIsOverridingUserAgent();
3265}
3266
avi85ee8362016-10-08 02:09:083267bool WebContentsImpl::IsJavaScriptDialogShowing() const {
3268 return is_showing_javascript_dialog_;
3269}
3270
avic031d392017-03-03 03:09:423271bool WebContentsImpl::ShouldIgnoreUnresponsiveRenderer() {
3272 // Ignore unresponsive renderers if the debugger is attached to them since the
3273 // unresponsiveness might be a result of the renderer sitting on a breakpoint.
3274 //
David Bienvenu525f8a02019-02-15 02:02:423275#ifdef OS_WIN
3276 // Check if a windows debugger is attached to the renderer process.
3277 base::ProcessHandle process_handle =
3278 GetMainFrame()->GetProcess()->GetProcess().Handle();
3279 BOOL debugger_present = FALSE;
3280 if (CheckRemoteDebuggerPresent(process_handle, &debugger_present) &&
3281 debugger_present)
3282 return true;
3283#endif // OS_WIN
3284
avic031d392017-03-03 03:09:423285 // TODO(pfeldman): Fix this to only return true if the renderer is *actually*
3286 // sitting on a breakpoint. https://crbug.com/684202
3287 return DevToolsAgentHost::IsDebuggerAttached(this);
3288}
3289
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:413290ui::AXMode WebContentsImpl::GetAccessibilityMode() {
[email protected]95640212014-07-26 18:14:303291 return accessibility_mode_;
3292}
3293
Dominic Mazzonia7b0edb22017-08-09 16:32:513294void WebContentsImpl::AccessibilityEventReceived(
Dominic Mazzoniccbaa9b2018-06-06 07:44:233295 const AXEventNotificationDetails& details) {
ericwilligersde386342016-10-19 02:35:093296 for (auto& observer : observers_)
Dominic Mazzonia7b0edb22017-08-09 16:32:513297 observer.AccessibilityEventReceived(details);
[email protected]31a71eaf2014-03-13 01:47:363298}
3299
dmazzoni2400c462016-08-23 15:07:133300void WebContentsImpl::AccessibilityLocationChangesReceived(
3301 const std::vector<AXLocationChangeNotificationDetails>& details) {
ericwilligersde386342016-10-19 02:35:093302 for (auto& observer : observers_)
Dominic Mazzonia7b0edb22017-08-09 16:32:513303 observer.AccessibilityLocationChangesReceived(details);
dmazzoni2400c462016-08-23 15:07:133304}
3305
Abigail Kleinabb428332019-09-13 18:26:213306base::string16 WebContentsImpl::DumpAccessibilityTree(
3307 bool internal,
3308 std::vector<AccessibilityTreeFormatter::PropertyFilter> property_filters) {
James Wallace-Leeeafc94cb92018-07-23 21:35:093309 auto* ax_mgr = GetOrCreateRootBrowserAccessibilityManager();
3310 DCHECK(ax_mgr);
Lei Zhangc98caa3822019-11-07 19:17:273311 return AccessibilityTreeFormatterBase::DumpAccessibilityTreeFromManager(
Abigail Kleinabb428332019-09-13 18:26:213312 ax_mgr, internal, property_filters);
James Wallace-Leeeafc94cb92018-07-23 21:35:093313}
3314
Abigail Kleinaa898742019-11-01 02:31:253315void WebContentsImpl::RecordAccessibilityEvents(
3316 AccessibilityEventCallback callback,
3317 bool start) {
3318 if (start) {
3319 SetAccessibilityMode(ui::AXMode::kWebContents);
3320 auto* ax_mgr = GetOrCreateRootBrowserAccessibilityManager();
3321 DCHECK(ax_mgr);
3322 base::ProcessId pid = base::Process::Current().Pid();
3323 event_recorder_ = content::AccessibilityEventRecorder::Create(
3324 ax_mgr, pid, base::StringPiece{});
3325 event_recorder_->ListenToEvents(callback);
3326 } else {
3327 DCHECK(event_recorder_);
3328 event_recorder_->FlushAsyncEvents();
3329 event_recorder_ = nullptr;
3330 }
3331}
3332
dmazzonia656928e2014-09-15 20:28:543333RenderFrameHost* WebContentsImpl::GetGuestByInstanceID(
fsamuel833ee7c2015-02-13 23:40:403334 RenderFrameHost* render_frame_host,
dmazzonia656928e2014-09-15 20:28:543335 int browser_plugin_instance_id) {
3336 BrowserPluginGuestManager* guest_manager =
3337 GetBrowserContext()->GetGuestManager();
fsamuel9cbc00a2015-04-17 20:30:203338 if (!guest_manager)
3339 return nullptr;
3340
dmazzonia656928e2014-09-15 20:28:543341 WebContents* guest = guest_manager->GetGuestByInstanceID(
fsamuel2e9413d2015-02-25 01:25:443342 render_frame_host->GetProcess()->GetID(), browser_plugin_instance_id);
dmazzonia656928e2014-09-15 20:28:543343 if (!guest)
fsamuel9cbc00a2015-04-17 20:30:203344 return nullptr;
3345
dmazzonia656928e2014-09-15 20:28:543346 return guest->GetMainFrame();
3347}
3348
Ke He7319dbe2017-11-09 05:54:443349device::mojom::GeolocationContext* WebContentsImpl::GetGeolocationContext() {
3350 if (geolocation_context_)
3351 return geolocation_context_.get();
3352
Ken Rockotfd03e682019-06-20 21:13:543353 service_manager::Connector* connector = GetSystemConnector();
Miyoung Shin0f4480d2019-09-12 01:15:263354 auto receiver = geolocation_context_.BindNewPipeAndPassReceiver();
Ken Rockotfd03e682019-06-20 21:13:543355 if (connector)
Miyoung Shin0f4480d2019-09-12 01:15:263356 connector->Connect(device::mojom::kServiceName, std::move(receiver));
Conley Owens6894c4f2017-07-10 19:29:133357 return geolocation_context_.get();
blundellc57b93f2014-10-29 13:19:573358}
3359
ke.he98b761e2017-05-09 05:59:173360device::mojom::WakeLockContext* WebContentsImpl::GetWakeLockContext() {
blundelld8cd72b2017-03-28 07:18:383361 if (!wake_lock_context_host_)
3362 wake_lock_context_host_.reset(new WakeLockContextHost(this));
blundelle75a8f92017-03-27 08:11:173363 return wake_lock_context_host_->GetWakeLockContext();
alogvinovf50445a2015-10-30 13:00:123364}
3365
blundellf5316fc2017-05-15 11:49:033366#if defined(OS_ANDROID)
Miyoung Shin59f39ff2019-09-17 07:23:203367void WebContentsImpl::GetNFC(
3368 mojo::PendingReceiver<device::mojom::NFC> receiver) {
Leon Hanccb985f2019-08-26 02:43:243369 NFCHost nfc_host(this);
Miyoung Shin59f39ff2019-09-17 07:23:203370 nfc_host.GetNFC(std::move(receiver));
blundellf5316fc2017-05-15 11:49:033371}
3372#endif
3373
Evan Stade5e750ad02017-08-07 21:59:273374void WebContentsImpl::SetNotWaitingForResponse() {
3375 if (waiting_for_response_ == false)
3376 return;
3377
3378 waiting_for_response_ = false;
3379 if (delegate_)
3380 delegate_->LoadingStateChanged(this, is_load_to_different_document_);
Chris Hamiltonf82f2a702018-02-15 19:37:293381 for (auto& observer : observers_)
3382 observer.DidReceiveResponse();
Evan Stade5e750ad02017-08-07 21:59:273383}
3384
lfgbb9c28a2016-03-01 03:19:493385void WebContentsImpl::SendScreenRects() {
kenrbc52e1b4e2016-03-20 01:03:373386 for (FrameTreeNode* node : frame_tree_.Nodes()) {
kenrb0e8dc202016-05-30 19:51:403387 if (node->current_frame_host()->is_local_root())
kenrbc52e1b4e2016-03-20 01:03:373388 node->current_frame_host()->GetRenderWidgetHost()->SendScreenRects();
3389 }
lfgbb9c28a2016-03-01 03:19:493390
danakj4df8a9d02019-02-05 20:36:593391 // Interstitials have their own |frame_tree_|.
3392 if (interstitial_page_) {
3393 FrameTree* interstitial_frame_tree = interstitial_page_->GetFrameTree();
3394 for (FrameTreeNode* node : interstitial_frame_tree->Nodes()) {
3395 if (node->current_frame_host()->is_local_root())
3396 node->current_frame_host()->GetRenderWidgetHost()->SendScreenRects();
3397 }
lfgdb5c4ed2016-03-04 23:09:073398 }
3399
avallee9f43b012016-11-26 07:02:103400 if (browser_plugin_embedder_ && !is_being_destroyed_)
[email protected]a7568e62013-06-14 07:50:443401 browser_plugin_embedder_->DidSendScreenRects();
[email protected]32deec62013-05-15 23:55:043402}
3403
ekaramadadd882292016-06-08 15:22:563404TextInputManager* WebContentsImpl::GetTextInputManager() {
3405 if (GetOuterWebContents())
3406 return GetOuterWebContents()->GetTextInputManager();
3407
Ehsan Karamadc179dc02018-12-15 03:09:293408 if (!text_input_manager_ && !browser_plugin_guest_) {
Darren Shenca53d5f2018-05-15 04:56:013409 text_input_manager_.reset(new TextInputManager(
3410 GetBrowserContext() &&
3411 !GetBrowserContext()->IsOffTheRecord()) /* should_do_learning */);
3412 }
ekaramadadd882292016-06-08 15:22:563413
3414 return text_input_manager_.get();
3415}
3416
paulmeyer7f6f1d4f2016-11-15 00:00:273417bool WebContentsImpl::OnUpdateDragCursor() {
Lei Zhang6410ec1a2019-01-31 21:38:583418 return browser_plugin_embedder_ &&
3419 browser_plugin_embedder_->OnUpdateDragCursor();
paulmeyer7f6f1d4f2016-11-15 00:00:273420}
3421
kenrb11f213a2017-03-24 18:12:063422bool WebContentsImpl::IsWidgetForMainFrame(
3423 RenderWidgetHostImpl* render_widget_host) {
3424 return render_widget_host == GetMainFrame()->GetRenderWidgetHost();
3425}
3426
[email protected]95640212014-07-26 18:14:303427BrowserAccessibilityManager*
3428 WebContentsImpl::GetRootBrowserAccessibilityManager() {
Dominic Mazzoniefb5f9e32017-12-21 01:08:223429 RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(
3430 ShowingInterstitialPage() ? GetInterstitialPage()->GetMainFrame()
3431 : GetMainFrame());
creisc014b402015-04-23 16:41:453432 return rfh ? rfh->browser_accessibility_manager() : nullptr;
[email protected]95640212014-07-26 18:14:303433}
3434
3435BrowserAccessibilityManager*
3436 WebContentsImpl::GetOrCreateRootBrowserAccessibilityManager() {
Dominic Mazzoniefb5f9e32017-12-21 01:08:223437 RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(
3438 ShowingInterstitialPage() ? GetInterstitialPage()->GetMainFrame()
3439 : GetMainFrame());
creisc014b402015-04-23 16:41:453440 return rfh ? rfh->GetOrCreateBrowserAccessibilityManager() : nullptr;
[email protected]95640212014-07-26 18:14:303441}
3442
Dave Tapuskab336b922017-07-06 19:24:053443void WebContentsImpl::ExecuteEditCommand(
3444 const std::string& command,
3445 const base::Optional<base::string16>& value) {
Dave Tapuskae782bea2019-07-09 16:21:513446 auto* input_handler = GetFocusedFrameInputHandler();
3447 if (!input_handler)
Dave Tapuskab336b922017-07-06 19:24:053448 return;
3449
Dave Tapuskae782bea2019-07-09 16:21:513450 input_handler->ExecuteEditCommand(command, value);
Dave Tapuskab336b922017-07-06 19:24:053451}
3452
mohsen7ab1ec16ec2015-07-02 18:26:233453void WebContentsImpl::MoveRangeSelectionExtent(const gfx::Point& extent) {
Dave Tapuskae782bea2019-07-09 16:21:513454 auto* input_handler = GetFocusedFrameInputHandler();
3455 if (!input_handler)
mohsen7ab1ec16ec2015-07-02 18:26:233456 return;
3457
Dave Tapuskae782bea2019-07-09 16:21:513458 input_handler->MoveRangeSelectionExtent(extent);
mohsen7ab1ec16ec2015-07-02 18:26:233459}
3460
3461void WebContentsImpl::SelectRange(const gfx::Point& base,
3462 const gfx::Point& extent) {
Dave Tapuskae782bea2019-07-09 16:21:513463 auto* input_handler = GetFocusedFrameInputHandler();
3464 if (!input_handler)
mohsen7ab1ec16ec2015-07-02 18:26:233465 return;
3466
Dave Tapuskae782bea2019-07-09 16:21:513467 input_handler->SelectRange(base, extent);
mohsen7ab1ec16ec2015-07-02 18:26:233468}
3469
Dave Tapuskab336b922017-07-06 19:24:053470void WebContentsImpl::MoveCaret(const gfx::Point& extent) {
Dave Tapuskae782bea2019-07-09 16:21:513471 auto* input_handler = GetFocusedFrameInputHandler();
3472 if (!input_handler)
Dave Tapuskab336b922017-07-06 19:24:053473 return;
3474
Dave Tapuskae782bea2019-07-09 16:21:513475 input_handler->MoveCaret(extent);
Dave Tapuskab336b922017-07-06 19:24:053476}
3477
Shimi Zhang37deeb22017-09-28 00:59:013478void WebContentsImpl::AdjustSelectionByCharacterOffset(
3479 int start_adjust,
3480 int end_adjust,
3481 bool show_selection_menu) {
Dave Tapuskae782bea2019-07-09 16:21:513482 auto* input_handler = GetFocusedFrameInputHandler();
3483 if (!input_handler)
aurimasab0319022015-07-10 21:57:383484 return;
3485
Shimi Zhang37deeb22017-09-28 00:59:013486 using blink::mojom::SelectionMenuBehavior;
Dave Tapuskae782bea2019-07-09 16:21:513487 input_handler->AdjustSelectionByCharacterOffset(
Shimi Zhang37deeb22017-09-28 00:59:013488 start_adjust, end_adjust,
3489 show_selection_menu ? SelectionMenuBehavior::kShow
3490 : SelectionMenuBehavior::kHide);
aurimasab0319022015-07-10 21:57:383491}
3492
[email protected]b172aee2012-04-10 17:05:263493void WebContentsImpl::UpdatePreferredSize(const gfx::Size& pref_size) {
[email protected]222f5822014-02-05 23:40:493494 const gfx::Size old_size = GetPreferredSize();
[email protected]bcd2815602012-01-14 18:17:233495 preferred_size_ = pref_size;
[email protected]222f5822014-02-05 23:40:493496 OnPreferredSizeChanged(old_size);
[email protected]0548c5352011-09-07 00:33:333497}
3498
avic3aa8422015-11-09 20:57:223499void WebContentsImpl::ResizeDueToAutoResize(
3500 RenderWidgetHostImpl* render_widget_host,
Fady Samuel97947112018-05-05 16:24:543501 const gfx::Size& new_size) {
avic3aa8422015-11-09 20:57:223502 if (render_widget_host != GetRenderViewHost()->GetWidget())
3503 return;
3504
kenrbe4f91082017-06-02 20:32:083505 auto_resize_size_ = new_size;
3506
3507 // Out-of-process iframe visible viewport sizes usually come from the
3508 // top-level RenderWidgetHostView, but when auto-resize is enabled on the
3509 // top frame then that size is used instead.
3510 for (FrameTreeNode* node : frame_tree_.Nodes()) {
3511 if (node->current_frame_host()->is_local_root()) {
3512 RenderWidgetHostImpl* host =
3513 node->current_frame_host()->GetRenderWidgetHost();
3514 if (host != render_widget_host)
Fady Samuel0b911822018-04-25 13:22:163515 host->SynchronizeVisualProperties();
kenrbe4f91082017-06-02 20:32:083516 }
3517 }
3518
[email protected]61e2b3cc2012-03-02 16:13:343519 if (delegate_)
3520 delegate_->ResizeDueToAutoResize(this, new_size);
3521}
3522
kenrbe4f91082017-06-02 20:32:083523gfx::Size WebContentsImpl::GetAutoResizeSize() {
3524 return auto_resize_size_;
3525}
3526
3527void WebContentsImpl::ResetAutoResizeSize() {
3528 auto_resize_size_ = gfx::Size();
3529}
3530
Albert J. Wongeb28e7e2018-10-12 00:57:433531InputEventShim* WebContentsImpl::GetInputEventShim() const {
3532 // The only thing that intercepts text input and mouse lock is the
3533 // BrowserPluginGuest. Delegate to the BrowserPluginGuest logic for
3534 // whether or not it needs to shim these events.
3535 if (browser_plugin_guest_) {
3536 return browser_plugin_guest_->GetInputEventShim();
3537 }
3538 return nullptr;
3539}
3540
[email protected]b172aee2012-04-10 17:05:263541WebContents* WebContentsImpl::OpenURL(const OpenURLParams& params) {
Bo Liu300c6052018-06-12 04:46:073542 if (!delegate_) {
3543 // Embedder can delay setting a delegate on new WebContents with
3544 // WebContentsDelegate::ShouldResumeRequestsForCreatedWindow. In the mean
3545 // time, navigations, including the initial one, that goes through OpenURL
3546 // should be delayed until embedder is ready to resume loading.
3547 delayed_open_url_params_ = std::make_unique<OpenURLParams>(params);
Nasko Oskov83a8cf92018-10-19 14:58:563548
3549 // If there was a navigation deferred when creating the window through
3550 // CreateNewWindow, drop it in favor of this navigation.
3551 delayed_load_url_params_.reset();
3552
Ivan Kotenkov2c0d2bb32017-11-01 15:41:283553 return nullptr;
Bo Liu300c6052018-06-12 04:46:073554 }
[email protected]00c37fc2011-08-02 00:22:503555
[email protected]e5d549d2011-12-28 01:29:203556 WebContents* new_contents = delegate_->OpenURLFromTab(this, params);
pnoland488944652017-02-22 18:58:543557
3558 RenderFrameHost* source_render_frame_host = RenderFrameHost::FromID(
3559 params.source_render_process_id, params.source_render_frame_id);
3560
3561 if (source_render_frame_host && params.source_site_instance) {
3562 CHECK_EQ(source_render_frame_host->GetSiteInstance(),
3563 params.source_site_instance.get());
3564 }
3565
3566 if (new_contents && source_render_frame_host && new_contents != this) {
3567 for (auto& observer : observers_) {
Lukasz Anforowicz48c9f872018-08-01 00:58:413568 observer.DidOpenRequestedURL(
3569 new_contents, source_render_frame_host, params.url, params.referrer,
3570 params.disposition, params.transition,
3571 params.started_from_context_menu, params.is_renderer_initiated);
pnoland488944652017-02-22 18:58:543572 }
3573 }
3574
[email protected]e5d549d2011-12-28 01:29:203575 return new_contents;
[email protected]d5f942ba2008-09-26 19:30:343576}
3577
[email protected]a86c0e962013-12-17 17:10:393578void WebContentsImpl::RenderFrameForInterstitialPageCreated(
3579 RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:093580 for (auto& observer : observers_)
3581 observer.RenderFrameForInterstitialPageCreated(render_frame_host);
[email protected]ba45bfd2012-05-22 21:51:443582}
3583
[email protected]20ca0382013-02-28 19:50:073584void WebContentsImpl::AttachInterstitialPage(
3585 InterstitialPageImpl* interstitial_page) {
creisadca9862017-06-16 19:12:113586 DCHECK(!interstitial_page_ && interstitial_page);
3587 interstitial_page_ = interstitial_page;
[email protected]90fb08ed2013-09-24 17:43:293588
3589 // Cancel any visible dialogs so that they don't interfere with the
3590 // interstitial.
creis89a0f782015-05-27 16:13:173591 CancelActiveAndPendingDialogs();
[email protected]90fb08ed2013-09-24 17:43:293592
ericwilligersde386342016-10-19 02:35:093593 for (auto& observer : observers_)
3594 observer.DidAttachInterstitialPage();
clamy44e84ce2016-02-22 15:38:253595
3596 // Stop the throbber if needed while the interstitial page is shown.
3597 if (frame_tree_.IsLoading())
3598 LoadingStateChanged(true, true, nullptr);
lfg1453e412017-04-11 00:48:503599
3600 // Connect to outer WebContents if necessary.
3601 if (node_.OuterContentsFrameTreeNode()) {
3602 if (GetRenderManager()->GetProxyToOuterDelegate()) {
3603 DCHECK(
3604 static_cast<RenderWidgetHostViewBase*>(interstitial_page->GetView())
3605 ->IsRenderWidgetHostViewChildFrame());
3606 RenderWidgetHostViewChildFrame* view =
3607 static_cast<RenderWidgetHostViewChildFrame*>(
3608 interstitial_page->GetView());
3609 GetRenderManager()->SetRWHViewForInnerContents(view);
3610 }
3611 }
Bo Liu7c6779e92017-08-16 02:02:283612
Bo Liu168c8642017-08-28 18:26:023613#if defined(OS_ANDROID)
Bo Liu7c6779e92017-08-16 02:02:283614 // Update importance of the interstitial.
3615 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
3616 ->GetRenderWidgetHost()
3617 ->SetImportance(GetMainFrame()->GetRenderWidgetHost()->importance());
Bo Liu168c8642017-08-28 18:26:023618#endif
Dominic Mazzoniefb5f9e32017-12-21 01:08:223619
3620 if (accessibility_mode_.has_mode(ui::AXMode::kNativeAPIs)) {
3621 // Make sure that the main page's accessibility tree is hidden and the
3622 // interstitial gets focus.
3623 RenderFrameHostImpl* rfh =
3624 static_cast<RenderFrameHostImpl*>(GetMainFrame());
3625 if (rfh) {
3626 BrowserAccessibilityManager* accessibility_manager =
3627 rfh->browser_accessibility_manager();
3628 if (accessibility_manager)
3629 accessibility_manager->set_hidden_by_interstitial_page(true);
3630 }
3631 rfh = static_cast<RenderFrameHostImpl*>(
3632 GetInterstitialPage()->GetMainFrame());
3633 if (rfh) {
3634 BrowserAccessibilityManager* accessibility_manager =
3635 rfh->GetOrCreateBrowserAccessibilityManager();
3636 if (accessibility_manager)
3637 accessibility_manager->OnWindowFocused();
3638 }
3639 }
clamy44e84ce2016-02-22 15:38:253640}
3641
3642void WebContentsImpl::DidProceedOnInterstitial() {
3643 // The interstitial page should no longer be pausing the throbber.
creisadca9862017-06-16 19:12:113644 DCHECK(!(ShowingInterstitialPage() && interstitial_page_->pause_throbber()));
clamy44e84ce2016-02-22 15:38:253645
3646 // Restart the throbber now that the interstitial page no longer pauses it.
3647 if (ShowingInterstitialPage() && frame_tree_.IsLoading())
3648 LoadingStateChanged(true, true, nullptr);
[email protected]20ca0382013-02-28 19:50:073649}
3650
Shivani Sharma985474f2019-05-23 21:36:473651bool WebContentsImpl::HadInnerWebContents() {
3652 return had_inner_webcontents_;
3653}
3654
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043655void WebContentsImpl::DetachInterstitialPage(bool has_focus) {
Lucas Furukawa Gadani69b609192017-07-10 17:08:343656 bool interstitial_pausing_throbber =
3657 ShowingInterstitialPage() && interstitial_page_->pause_throbber();
3658 if (ShowingInterstitialPage())
3659 interstitial_page_ = nullptr;
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043660
Dominic Mazzoniefb5f9e32017-12-21 01:08:223661 // Make sure that the main page's accessibility tree is no longer
3662 // suppressed.
3663 RenderFrameHostImpl* rfh = GetMainFrame();
3664 if (rfh) {
3665 BrowserAccessibilityManager* accessibility_manager =
3666 rfh->browser_accessibility_manager();
3667 if (accessibility_manager)
3668 accessibility_manager->set_hidden_by_interstitial_page(false);
3669 }
3670
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043671 // If the focus was on the interstitial, let's keep it to the page.
3672 // (Note that in unit-tests the RVH may not have a view).
3673 if (has_focus && GetRenderViewHost()->GetWidget()->GetView())
3674 GetRenderViewHost()->GetWidget()->GetView()->Focus();
3675
Lucas Furukawa Gadani69b609192017-07-10 17:08:343676 for (auto& observer : observers_)
3677 observer.DidDetachInterstitialPage();
3678
3679 // Disconnect from outer WebContents if necessary. This must happen after the
3680 // interstitial page is cleared above, since the call to
3681 // SetRWHViewForInnerContents below may loop over all the
3682 // RenderWidgetHostViews in the tree (otherwise, including the now-deleted
3683 // view for the interstitial).
lfg1453e412017-04-11 00:48:503684 if (node_.OuterContentsFrameTreeNode()) {
3685 if (GetRenderManager()->GetProxyToOuterDelegate()) {
3686 DCHECK(static_cast<RenderWidgetHostViewBase*>(
3687 GetRenderManager()->current_frame_host()->GetView())
3688 ->IsRenderWidgetHostViewChildFrame());
3689 RenderWidgetHostViewChildFrame* view =
3690 static_cast<RenderWidgetHostViewChildFrame*>(
3691 GetRenderManager()->current_frame_host()->GetView());
3692 GetRenderManager()->SetRWHViewForInnerContents(view);
3693 }
3694 }
3695
clamy44e84ce2016-02-22 15:38:253696 // Restart the throbber if needed now that the interstitial page is going
3697 // away.
3698 if (interstitial_pausing_throbber && frame_tree_.IsLoading())
3699 LoadingStateChanged(true, true, nullptr);
[email protected]20ca0382013-02-28 19:50:073700}
3701
avi2b177592014-12-10 02:08:023702void WebContentsImpl::SetHistoryOffsetAndLength(int history_offset,
3703 int history_length) {
alexmos136fd6e62016-08-15 20:58:413704 SendPageMessage(new PageMsg_SetHistoryOffsetAndLength(
3705 MSG_ROUTING_NONE, history_offset, history_length));
avi2b177592014-12-10 02:08:023706}
3707
3708void WebContentsImpl::SetHistoryOffsetAndLengthForView(
3709 RenderViewHost* render_view_host,
3710 int history_offset,
3711 int history_length) {
alexmos136fd6e62016-08-15 20:58:413712 render_view_host->Send(new PageMsg_SetHistoryOffsetAndLength(
avi2b177592014-12-10 02:08:023713 render_view_host->GetRoutingID(), history_offset, history_length));
[email protected]796931a92011-08-10 01:32:143714}
3715
arthursonzogni818c2642019-09-27 12:18:103716void WebContentsImpl::ReloadFocusedFrame() {
[email protected]1f3fc1d2014-04-03 14:50:173717 RenderFrameHost* focused_frame = GetFocusedFrame();
3718 if (!focused_frame)
3719 return;
3720
yilkal921048bd2019-10-09 23:51:043721 focused_frame->Reload();
[email protected]959be4c2014-04-08 15:01:333722}
3723
Miyoung Shin298d5ad2019-09-05 01:52:373724std::vector<mojo::Remote<blink::mojom::PauseSubresourceLoadingHandle>>
Ryan Sturmc65dbe42018-05-31 20:37:043725WebContentsImpl::PauseSubresourceLoading() {
Miyoung Shin298d5ad2019-09-05 01:52:373726 std::vector<mojo::Remote<blink::mojom::PauseSubresourceLoadingHandle>>
3727 handles;
Ryan Sturmc65dbe42018-05-31 20:37:043728 for (RenderFrameHost* rfh : GetAllFrames()) {
3729 if (!rfh->IsRenderFrameLive())
3730 continue;
3731 handles.push_back(rfh->PauseSubresourceLoading());
3732 }
3733 return handles;
3734}
3735
[email protected]959be4c2014-04-08 15:01:333736void WebContentsImpl::Undo() {
Dave Tapuskae782bea2019-07-09 16:21:513737 auto* input_handler = GetFocusedFrameInputHandler();
3738 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333739 return;
3740
Dave Tapuskae782bea2019-07-09 16:21:513741 input_handler->Undo();
[email protected]959be4c2014-04-08 15:01:333742 RecordAction(base::UserMetricsAction("Undo"));
3743}
3744
3745void WebContentsImpl::Redo() {
Dave Tapuskae782bea2019-07-09 16:21:513746 auto* input_handler = GetFocusedFrameInputHandler();
3747 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333748 return;
Dave Tapuskae782bea2019-07-09 16:21:513749
3750 input_handler->Redo();
[email protected]959be4c2014-04-08 15:01:333751 RecordAction(base::UserMetricsAction("Redo"));
3752}
3753
3754void WebContentsImpl::Cut() {
Dave Tapuskae782bea2019-07-09 16:21:513755 auto* input_handler = GetFocusedFrameInputHandler();
3756 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333757 return;
3758
Dave Tapuskae782bea2019-07-09 16:21:513759 input_handler->Cut();
[email protected]959be4c2014-04-08 15:01:333760 RecordAction(base::UserMetricsAction("Cut"));
3761}
3762
3763void WebContentsImpl::Copy() {
Dave Tapuskae782bea2019-07-09 16:21:513764 auto* input_handler = GetFocusedFrameInputHandler();
3765 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333766 return;
3767
Dave Tapuskae782bea2019-07-09 16:21:513768 input_handler->Copy();
[email protected]959be4c2014-04-08 15:01:333769 RecordAction(base::UserMetricsAction("Copy"));
3770}
3771
3772void WebContentsImpl::CopyToFindPboard() {
3773#if defined(OS_MACOSX)
Dave Tapuskae782bea2019-07-09 16:21:513774 auto* input_handler = GetFocusedFrameInputHandler();
3775 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333776 return;
3777
3778 // Windows/Linux don't have the concept of a find pasteboard.
Dave Tapuskae782bea2019-07-09 16:21:513779 input_handler->CopyToFindPboard();
[email protected]959be4c2014-04-08 15:01:333780 RecordAction(base::UserMetricsAction("CopyToFindPboard"));
3781#endif
3782}
3783
3784void WebContentsImpl::Paste() {
Dave Tapuskae782bea2019-07-09 16:21:513785 auto* input_handler = GetFocusedFrameInputHandler();
3786 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333787 return;
3788
Dave Tapuskae782bea2019-07-09 16:21:513789 input_handler->Paste();
Archana Simhaf67090c2019-05-06 23:43:233790 for (auto& observer : observers_)
3791 observer.OnPaste();
[email protected]959be4c2014-04-08 15:01:333792 RecordAction(base::UserMetricsAction("Paste"));
3793}
3794
3795void WebContentsImpl::PasteAndMatchStyle() {
Dave Tapuskae782bea2019-07-09 16:21:513796 auto* input_handler = GetFocusedFrameInputHandler();
3797 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333798 return;
3799
Dave Tapuskae782bea2019-07-09 16:21:513800 input_handler->PasteAndMatchStyle();
Archana Simhaf67090c2019-05-06 23:43:233801 for (auto& observer : observers_)
3802 observer.OnPaste();
[email protected]959be4c2014-04-08 15:01:333803 RecordAction(base::UserMetricsAction("PasteAndMatchStyle"));
3804}
3805
3806void WebContentsImpl::Delete() {
Dave Tapuskae782bea2019-07-09 16:21:513807 auto* input_handler = GetFocusedFrameInputHandler();
3808 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333809 return;
3810
Dave Tapuskae782bea2019-07-09 16:21:513811 input_handler->Delete();
[email protected]959be4c2014-04-08 15:01:333812 RecordAction(base::UserMetricsAction("DeleteSelection"));
3813}
3814
3815void WebContentsImpl::SelectAll() {
Dave Tapuskae782bea2019-07-09 16:21:513816 auto* input_handler = GetFocusedFrameInputHandler();
3817 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333818 return;
3819
Dave Tapuskae782bea2019-07-09 16:21:513820 input_handler->SelectAll();
[email protected]959be4c2014-04-08 15:01:333821 RecordAction(base::UserMetricsAction("SelectAll"));
3822}
3823
yabinh351e7ec2017-03-10 02:43:243824void WebContentsImpl::CollapseSelection() {
Dave Tapuskae782bea2019-07-09 16:21:513825 auto* input_handler = GetFocusedFrameInputHandler();
3826 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333827 return;
3828
Dave Tapuskae782bea2019-07-09 16:21:513829 input_handler->CollapseSelection();
[email protected]1f3fc1d2014-04-03 14:50:173830}
3831
3832void WebContentsImpl::Replace(const base::string16& word) {
Dave Tapuskae782bea2019-07-09 16:21:513833 auto* input_handler = GetFocusedFrameInputHandler();
3834 if (!input_handler)
[email protected]1f3fc1d2014-04-03 14:50:173835 return;
3836
Dave Tapuskae782bea2019-07-09 16:21:513837 input_handler->Replace(word);
[email protected]1f3fc1d2014-04-03 14:50:173838}
3839
3840void WebContentsImpl::ReplaceMisspelling(const base::string16& word) {
Dave Tapuskae782bea2019-07-09 16:21:513841 auto* input_handler = GetFocusedFrameInputHandler();
3842 if (!input_handler)
[email protected]1f3fc1d2014-04-03 14:50:173843 return;
3844
Dave Tapuskae782bea2019-07-09 16:21:513845 input_handler->ReplaceMisspelling(word);
[email protected]959be4c2014-04-08 15:01:333846}
3847
3848void WebContentsImpl::NotifyContextMenuClosed(
3849 const CustomContextMenuContext& context) {
3850 RenderFrameHost* focused_frame = GetFocusedFrame();
3851 if (!focused_frame)
3852 return;
3853
3854 focused_frame->Send(new FrameMsg_ContextMenuClosed(
3855 focused_frame->GetRoutingID(), context));
3856}
3857
3858void WebContentsImpl::ExecuteCustomContextMenuCommand(
3859 int action, const CustomContextMenuContext& context) {
3860 RenderFrameHost* focused_frame = GetFocusedFrame();
3861 if (!focused_frame)
3862 return;
3863
3864 focused_frame->Send(new FrameMsg_CustomContextMenuAction(
3865 focused_frame->GetRoutingID(), context, action));
[email protected]4fed3702014-04-01 09:08:003866}
3867
[email protected]fc2b46b2014-05-03 16:33:453868gfx::NativeView WebContentsImpl::GetNativeView() {
3869 return view_->GetNativeView();
3870}
3871
3872gfx::NativeView WebContentsImpl::GetContentNativeView() {
3873 return view_->GetContentNativeView();
3874}
3875
3876gfx::NativeWindow WebContentsImpl::GetTopLevelNativeWindow() {
3877 return view_->GetTopLevelNativeWindow();
3878}
3879
3880gfx::Rect WebContentsImpl::GetViewBounds() {
3881 return view_->GetViewBounds();
3882}
3883
3884gfx::Rect WebContentsImpl::GetContainerBounds() {
3885 gfx::Rect rv;
3886 view_->GetContainerBounds(&rv);
3887 return rv;
3888}
3889
3890DropData* WebContentsImpl::GetDropData() {
3891 return view_->GetDropData();
3892}
3893
3894void WebContentsImpl::Focus() {
miu9e14e492014-10-25 02:39:043895 view_->Focus();
[email protected]fc2b46b2014-05-03 16:33:453896}
3897
3898void WebContentsImpl::SetInitialFocus() {
miu9e14e492014-10-25 02:39:043899 view_->SetInitialFocus();
[email protected]fc2b46b2014-05-03 16:33:453900}
3901
3902void WebContentsImpl::StoreFocus() {
miu9e14e492014-10-25 02:39:043903 view_->StoreFocus();
[email protected]fc2b46b2014-05-03 16:33:453904}
3905
3906void WebContentsImpl::RestoreFocus() {
miu9e14e492014-10-25 02:39:043907 view_->RestoreFocus();
[email protected]fc2b46b2014-05-03 16:33:453908}
3909
[email protected]b172aee2012-04-10 17:05:263910void WebContentsImpl::FocusThroughTabTraversal(bool reverse) {
Maxim Podgorodskiya926c4ff2017-11-20 02:06:393911 view_->FocusThroughTabTraversal(reverse);
[email protected]96d185d2009-04-24 03:28:543912}
3913
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:413914bool WebContentsImpl::ShowingInterstitialPage() {
creisadca9862017-06-16 19:12:113915 return interstitial_page_ != nullptr;
[email protected]96d185d2009-04-24 03:28:543916}
3917
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:413918InterstitialPageImpl* WebContentsImpl::GetInterstitialPage() {
creisadca9862017-06-16 19:12:113919 return interstitial_page_;
[email protected]686493142011-07-15 21:47:223920}
3921
[email protected]b172aee2012-04-10 17:05:263922bool WebContentsImpl::IsSavable() {
[email protected]a53209b2012-01-20 16:48:163923 // WebKit creates Document object when MIME type is application/xhtml+xml,
3924 // so we also support this MIME type.
3925 return contents_mime_type_ == "text/html" ||
3926 contents_mime_type_ == "text/xml" ||
3927 contents_mime_type_ == "application/xhtml+xml" ||
3928 contents_mime_type_ == "text/plain" ||
3929 contents_mime_type_ == "text/css" ||
Kinuko Yasuda74702f92017-07-31 03:27:533930 blink::IsSupportedJavascriptMimeType(contents_mime_type_);
[email protected]a53209b2012-01-20 16:48:163931}
3932
[email protected]b172aee2012-04-10 17:05:263933void WebContentsImpl::OnSavePage() {
[email protected]c7dd2f62011-07-18 15:57:593934 // If we can not save the page, try to download it.
[email protected]a53209b2012-01-20 16:48:163935 if (!IsSavable()) {
Min Qinda0ed2062018-02-23 22:00:533936 download::RecordSavePackageEvent(
3937 download::SAVE_PACKAGE_DOWNLOAD_ON_NON_HTML);
nasko89ad7742015-03-05 22:14:193938 SaveFrame(GetLastCommittedURL(), Referrer());
[email protected]27678b2a2012-02-04 22:09:143939 return;
[email protected]c7dd2f62011-07-18 15:57:593940 }
3941
3942 Stop();
3943
3944 // Create the save package and possibly prompt the user for the name to save
3945 // the page as. The user prompt is an asynchronous operation that runs on
3946 // another thread.
3947 save_package_ = new SavePackage(this);
3948 save_package_->GetSaveInfo();
3949}
3950
3951// Used in automated testing to bypass prompting the user for file names.
3952// Instead, the names and paths are hard coded rather than running them through
3953// file name sanitation and extension / mime checking.
[email protected]2dec8ec2013-02-07 19:20:343954bool WebContentsImpl::SavePage(const base::FilePath& main_file,
3955 const base::FilePath& dir_path,
[email protected]8ff00d72012-10-23 19:12:213956 SavePageType save_type) {
[email protected]c7dd2f62011-07-18 15:57:593957 // Stop the page from navigating.
3958 Stop();
3959
3960 save_package_ = new SavePackage(this, save_type, main_file, dir_path);
[email protected]8ff00d72012-10-23 19:12:213961 return save_package_->Init(SavePackageDownloadCreatedCallback());
[email protected]c7dd2f62011-07-18 15:57:593962}
3963
[email protected]3c71576ce2013-07-23 02:00:013964void WebContentsImpl::SaveFrame(const GURL& url,
3965 const Referrer& referrer) {
Xing Liu10329bf2018-03-20 19:22:143966 SaveFrameWithHeaders(url, referrer, std::string(), base::string16());
kundaji6c7f9692015-03-09 18:00:373967}
3968
Xing Liu10329bf2018-03-20 19:22:143969void WebContentsImpl::SaveFrameWithHeaders(
3970 const GURL& url,
3971 const Referrer& referrer,
3972 const std::string& headers,
3973 const base::string16& suggested_filename) {
Lei Zhang13a42e42019-02-19 23:28:113974 // Check and see if the guest can handle this.
3975 if (delegate_) {
3976 WebContents* guest_web_contents = nullptr;
3977 if (browser_plugin_embedder_) {
3978 BrowserPluginGuest* guest = browser_plugin_embedder_->GetFullPageGuest();
3979 if (guest)
3980 guest_web_contents = guest->GetWebContents();
3981 } else if (browser_plugin_guest_) {
3982 guest_web_contents = this;
3983 }
3984
3985 if (guest_web_contents && delegate_->GuestSaveFrame(guest_web_contents))
3986 return;
3987 }
3988
nasko89ad7742015-03-05 22:14:193989 if (!GetLastCommittedURL().is_valid())
[email protected]3c71576ce2013-07-23 02:00:013990 return;
sammc92af61552014-11-19 23:27:403991 if (delegate_ && delegate_->SaveFrame(url, referrer))
3992 return;
3993
nasko89ad7742015-03-05 22:14:193994 // TODO(nasko): This check for main frame is incorrect and should be fixed
brettw760f7442016-05-23 21:19:223995 // by explicitly passing in which frame this method should target. This would
3996 // indicate whether it's the main frame, and also tell us the frame pointer
3997 // to use for routing.
nasko89ad7742015-03-05 22:14:193998 bool is_main_frame = (url == GetLastCommittedURL());
brettw760f7442016-05-23 21:19:223999 RenderFrameHost* frame_host = GetMainFrame();
[email protected]3c71576ce2013-07-23 02:00:014000
avib7348942015-12-25 20:57:104001 int64_t post_id = -1;
[email protected]3c71576ce2013-07-23 02:00:014002 if (is_main_frame) {
Lucas Furukawa Gadani5553a152019-01-08 18:55:574003 NavigationEntry* entry = controller_.GetLastCommittedEntry();
[email protected]3c71576ce2013-07-23 02:00:014004 if (entry)
4005 post_id = entry->GetPostID();
4006 }
Ramin Halavati24e21012017-07-10 12:56:064007 net::NetworkTrafficAnnotationTag traffic_annotation =
4008 net::DefineNetworkTrafficAnnotation("download_web_contents_frame", R"(
4009 semantics {
4010 sender: "Save Page Action"
4011 description:
4012 "Saves the given frame's URL to the local file system."
4013 trigger:
4014 "The user has triggered a save operation on the frame through a "
4015 "context menu or other mechanism."
4016 data: "None."
4017 destination: WEBSITE
4018 }
4019 policy {
Ramin Halavati3b979782017-07-21 11:40:264020 cookies_allowed: YES
Ramin Halavati24e21012017-07-10 12:56:064021 cookies_store: "user"
4022 setting:
4023 "This feature cannot be disabled by settings, but it's is only "
4024 "triggered by user request."
4025 policy_exception_justification: "Not implemented."
4026 })");
Min Qina904f3302018-02-13 23:33:344027 auto params = std::make_unique<download::DownloadUrlParameters>(
brettw760f7442016-05-23 21:19:224028 url, frame_host->GetProcess()->GetID(),
4029 frame_host->GetRenderViewHost()->GetRoutingID(),
Matt Menke6d93c3c2018-10-10 15:21:504030 frame_host->GetRoutingID(), traffic_annotation);
Min Qina904f3302018-02-13 23:33:344031 params->set_referrer(referrer.url);
4032 params->set_referrer_policy(
4033 Referrer::ReferrerPolicyForUrlRequest(referrer.policy));
[email protected]3c71576ce2013-07-23 02:00:014034 params->set_post_id(post_id);
[email protected]3c71576ce2013-07-23 02:00:014035 if (post_id >= 0)
4036 params->set_method("POST");
4037 params->set_prompt(true);
kundaji6c7f9692015-03-09 18:00:374038
4039 if (headers.empty()) {
4040 params->set_prefer_cache(true);
4041 } else {
Min Qina904f3302018-02-13 23:33:344042 for (download::DownloadUrlParameters::RequestHeadersNameValuePair
4043 key_value : ParseDownloadHeaders(headers)) {
Megan Jablonski2f6a4c52017-07-10 23:01:254044 params->add_request_header(key_value.first, key_value.second);
kundaji6c7f9692015-03-09 18:00:374045 }
4046 }
Xing Liu10329bf2018-03-20 19:22:144047 params->set_suggested_name(suggested_filename);
Min Qin0ca8e1ee2018-01-31 00:49:354048 params->set_download_source(download::DownloadSource::WEB_CONTENTS_API);
thestig859c78892017-05-15 21:17:064049 BrowserContext::GetDownloadManager(GetBrowserContext())
Ramin Halavati03efa732017-06-12 09:28:204050 ->DownloadUrl(std::move(params));
[email protected]3c71576ce2013-07-23 02:00:014051}
4052
[email protected]b172aee2012-04-10 17:05:264053void WebContentsImpl::GenerateMHTML(
dewittj6dc5747a2016-05-17 01:48:474054 const MHTMLGenerationParams& params,
Avi Drissman149b7832018-03-23 14:31:494055 base::OnceCallback<void(int64_t)> callback) {
Angel Alvarez902496682019-08-27 22:58:424056 base::OnceCallback<void(const MHTMLGenerationResult&)> wrapper_callback =
4057 base::BindOnce(
4058 [](base::OnceCallback<void(int64_t)> size_callback,
4059 const MHTMLGenerationResult& result) {
4060 std::move(size_callback).Run(result.file_size);
4061 },
4062 std::move(callback));
4063 MHTMLGenerationManager::GetInstance()->SaveMHTML(this, params,
4064 std::move(wrapper_callback));
4065}
4066
4067void WebContentsImpl::GenerateMHTMLWithResult(
4068 const MHTMLGenerationParams& params,
4069 MHTMLGenerationResult::GenerateMHTMLCallback callback) {
Avi Drissman149b7832018-03-23 14:31:494070 MHTMLGenerationManager::GetInstance()->SaveMHTML(this, params,
4071 std::move(callback));
[email protected]aa4f3972012-03-01 18:12:124072}
4073
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414074const std::string& WebContentsImpl::GetContentsMimeType() {
[email protected]0bfbf882011-12-22 18:19:274075 return contents_mime_type_;
4076}
4077
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414078bool WebContentsImpl::WillNotifyDisconnection() {
[email protected]0bfbf882011-12-22 18:19:274079 return notify_disconnection_;
4080}
4081
Leon Hanc819dc62019-01-28 04:30:194082blink::mojom::RendererPreferences* WebContentsImpl::GetMutableRendererPrefs() {
[email protected]0bfbf882011-12-22 18:19:274083 return &renderer_preferences_;
4084}
4085
[email protected]e35ccd52012-05-23 16:22:474086void WebContentsImpl::Close() {
4087 Close(GetRenderViewHost());
4088}
4089
Ella Ge80a52dce2017-11-15 18:01:524090void WebContentsImpl::DragSourceEndedAt(float client_x,
4091 float client_y,
4092 float screen_x,
4093 float screen_y,
Paul Meyer0c58c3712016-11-17 22:59:514094 blink::WebDragOperation operation,
4095 RenderWidgetHost* source_rwh) {
Lei Zhang6410ec1a2019-01-31 21:38:584096 if (browser_plugin_embedder_) {
paulmeyer8fc8ea92016-11-15 05:12:214097 browser_plugin_embedder_->DragSourceEndedAt(
4098 client_x, client_y, screen_x, screen_y, operation);
Lei Zhang6410ec1a2019-01-31 21:38:584099 }
Paul Meyer0c58c3712016-11-17 22:59:514100 if (source_rwh) {
Ella Ge80a52dce2017-11-15 18:01:524101 source_rwh->DragSourceEndedAt(gfx::PointF(client_x, client_y),
4102 gfx::PointF(screen_x, screen_y), operation);
Paul Meyer0c58c3712016-11-17 22:59:514103 }
[email protected]cf200a562013-05-03 16:24:294104}
4105
jam73f892642016-09-11 06:04:064106void WebContentsImpl::LoadStateChanged(
Charles Harrison911fa062018-03-06 21:01:464107 const std::string& host,
jam73f892642016-09-11 06:04:064108 const net::LoadStateWithParam& load_state,
4109 uint64_t upload_position,
4110 uint64_t upload_size) {
Charles Harrison911fa062018-03-06 21:01:464111 base::string16 host16 = url_formatter::IDNToUnicode(host);
Elly Fong-Jonescad9c3d12018-01-31 17:26:104112 // Drop no-op updates.
4113 if (load_state_.state == load_state.state &&
4114 load_state_.param == load_state.param &&
4115 upload_position_ == upload_position && upload_size_ == upload_size &&
Charles Harrison911fa062018-03-06 21:01:464116 load_state_host_ == host16) {
Elly Fong-Jonescad9c3d12018-01-31 17:26:104117 return;
4118 }
jam73f892642016-09-11 06:04:064119 load_state_ = load_state;
4120 upload_position_ = upload_position;
4121 upload_size_ = upload_size;
Charles Harrison911fa062018-03-06 21:01:464122 load_state_host_ = host16;
jam73f892642016-09-11 06:04:064123 if (load_state_.state == net::LOAD_STATE_READING_RESPONSE)
4124 SetNotWaitingForResponse();
4125 if (IsLoading()) {
4126 NotifyNavigationStateChanged(static_cast<InvalidateTypes>(
4127 INVALIDATE_TYPE_LOAD | INVALIDATE_TYPE_TAB));
4128 }
4129}
4130
Collin Baker989e0882019-11-01 01:27:174131void WebContentsImpl::SetVisibilityAndNotifyObservers(Visibility visibility) {
Francois Doraye6161152018-03-27 22:05:374132 const Visibility previous_visibility = visibility_;
4133 visibility_ = visibility;
4134
Francois Dorayfe4a1772018-02-17 04:17:094135 // Notify observers if the visibility changed or if WasShown() is being called
4136 // for the first time.
Francois Dorayfe4a1772018-02-17 04:17:094137 if (visibility != previous_visibility ||
4138 (visibility == Visibility::VISIBLE && !did_first_set_visible_)) {
4139 for (auto& observer : observers_)
4140 observer.OnVisibilityChanged(visibility);
4141 }
4142}
4143
Michael Thiessen896405db2017-07-20 17:52:324144void WebContentsImpl::NotifyWebContentsFocused(
4145 RenderWidgetHost* render_widget_host) {
ericwilligersde386342016-10-19 02:35:094146 for (auto& observer : observers_)
Michael Thiessen896405db2017-07-20 17:52:324147 observer.OnWebContentsFocused(render_widget_host);
calamity7fe55ce2015-04-10 03:59:374148}
4149
Michael Thiessen896405db2017-07-20 17:52:324150void WebContentsImpl::NotifyWebContentsLostFocus(
4151 RenderWidgetHost* render_widget_host) {
zijiehe3bee08e22017-05-17 04:14:464152 for (auto& observer : observers_)
Michael Thiessen896405db2017-07-20 17:52:324153 observer.OnWebContentsLostFocus(render_widget_host);
zijiehe3bee08e22017-05-17 04:14:464154}
4155
Paul Meyer0c58c3712016-11-17 22:59:514156void WebContentsImpl::SystemDragEnded(RenderWidgetHost* source_rwh) {
4157 if (source_rwh)
4158 source_rwh->DragSourceSystemDragEnded();
Lei Zhang6410ec1a2019-01-31 21:38:584159 if (browser_plugin_embedder_)
[email protected]cf200a562013-05-03 16:24:294160 browser_plugin_embedder_->SystemDragEnded();
[email protected]7813bd72011-02-05 02:19:344161}
4162
[email protected]b172aee2012-04-10 17:05:264163void WebContentsImpl::SetClosedByUserGesture(bool value) {
[email protected]0bfbf882011-12-22 18:19:274164 closed_by_user_gesture_ = value;
4165}
4166
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414167bool WebContentsImpl::GetClosedByUserGesture() {
[email protected]0bfbf882011-12-22 18:19:274168 return closed_by_user_gesture_;
4169}
4170
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414171int WebContentsImpl::GetMinimumZoomPercent() {
[email protected]0bfbf882011-12-22 18:19:274172 return minimum_zoom_percent_;
4173}
4174
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414175int WebContentsImpl::GetMaximumZoomPercent() {
[email protected]0bfbf882011-12-22 18:19:274176 return maximum_zoom_percent_;
4177}
4178
mcnee432e47d2015-11-09 19:37:464179void WebContentsImpl::SetPageScale(float page_scale_factor) {
Lukasz Anforowiczf4357ca2017-09-07 01:43:324180 GetRenderViewHost()->Send(new ViewMsg_SetPageScale(
4181 GetRenderViewHost()->GetRoutingID(), page_scale_factor));
ccameronb7c1d6c2015-03-09 17:08:244182}
4183
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414184gfx::Size WebContentsImpl::GetPreferredSize() {
Francois Doray24fc62c2017-12-11 17:27:334185 return IsBeingCaptured() ? preferred_size_for_capture_ : preferred_size_;
[email protected]bcd2815602012-01-14 18:17:234186}
4187
[email protected]b172aee2012-04-10 17:05:264188bool WebContentsImpl::GotResponseToLockMouseRequest(bool allowed) {
lfgf0cd46e2017-01-04 00:05:234189 if (!GuestMode::IsCrossProcessFrameGuest(GetWebContents()) &&
4190 GetBrowserPluginGuest())
[email protected]660f18e2014-05-15 20:53:054191 return GetBrowserPluginGuest()->LockMouse(allowed);
4192
lfgf0cd46e2017-01-04 00:05:234193 if (mouse_lock_widget_) {
4194 if (mouse_lock_widget_->delegate()->GetAsWebContents() != this) {
4195 return mouse_lock_widget_->delegate()
4196 ->GetAsWebContents()
4197 ->GotResponseToLockMouseRequest(allowed);
4198 }
lfgad8244352016-07-13 16:55:514199
lfgf0cd46e2017-01-04 00:05:234200 if (mouse_lock_widget_->GotResponseToLockMouseRequest(allowed))
4201 return true;
4202 }
4203
4204 for (WebContentsImpl* current = this; current;
4205 current = current->GetOuterWebContents()) {
4206 current->mouse_lock_widget_ = nullptr;
4207 }
4208
lfgbee1e0a2016-06-08 21:24:214209 return false;
[email protected]0bfbf882011-12-22 18:19:274210}
4211
Joe Downing13dd76b2018-04-09 18:32:154212bool WebContentsImpl::GotResponseToKeyboardLockRequest(bool allowed) {
4213 if (!keyboard_lock_widget_)
4214 return false;
4215
4216 if (keyboard_lock_widget_->delegate()->GetAsWebContents() != this) {
4217 NOTREACHED();
4218 return false;
4219 }
4220
4221 // KeyboardLock is only supported when called by the top-level browsing
4222 // context and is not supported in embedded content scenarios.
4223 if (GetOuterWebContents())
4224 return false;
4225
4226 keyboard_lock_widget_->GotResponseToKeyboardLockRequest(allowed);
4227 return true;
4228}
4229
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414230bool WebContentsImpl::HasOpener() {
Ivan Kotenkov2c0d2bb32017-11-01 15:41:284231 return GetOpener() != nullptr;
[email protected]a0358d72012-03-09 14:06:504232}
4233
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414234RenderFrameHostImpl* WebContentsImpl::GetOpener() {
alexmose201c7cd2015-06-10 17:14:214235 FrameTreeNode* opener_ftn = frame_tree_.root()->opener();
lukasza6f8ac622017-06-06 03:10:204236 return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
jochen55ff3502014-12-18 20:52:574237}
4238
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414239bool WebContentsImpl::HasOriginalOpener() {
Ivan Kotenkov2c0d2bb32017-11-01 15:41:284240 return GetOriginalOpener() != nullptr;
jochen6004a362017-02-04 00:11:404241}
4242
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414243RenderFrameHostImpl* WebContentsImpl::GetOriginalOpener() {
jochen6004a362017-02-04 00:11:404244 FrameTreeNode* opener_ftn = frame_tree_.root()->original_opener();
lukasza6f8ac622017-06-06 03:10:204245 return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
jochen6004a362017-02-04 00:11:404246}
4247
[email protected]cb805452013-05-22 15:16:214248void WebContentsImpl::DidChooseColorInColorChooser(SkColor color) {
Joel Hockey85b379d2017-12-11 10:42:134249 color_chooser_->DidChooseColorInColorChooser(color);
[email protected]da8543762012-03-20 08:52:204250}
4251
[email protected]cb805452013-05-22 15:16:214252void WebContentsImpl::DidEndColorChooser() {
Joel Hockey85b379d2017-12-11 10:42:134253 color_chooser_.reset();
[email protected]da8543762012-03-20 08:52:204254}
4255
halton.huoca2eabd2015-07-06 08:17:404256int WebContentsImpl::DownloadImage(
4257 const GURL& url,
4258 bool is_favicon,
4259 uint32_t max_bitmap_size,
4260 bool bypass_cache,
Avi Drissmana5a52dd2018-03-27 03:39:024261 WebContents::ImageDownloadCallback callback) {
amistry9f01b772015-07-29 01:54:554262 DCHECK_CURRENTLY_ON(BrowserThread::UI);
halton.huoca2eabd2015-07-06 08:17:404263 static int next_image_download_id = 0;
Julie Jeongeun Kimb1473572019-08-15 05:59:134264 const mojo::Remote<blink::mojom::ImageDownloader>& mojo_image_downloader =
halton.huoca2eabd2015-07-06 08:17:404265 GetMainFrame()->GetMojoImageDownloader();
amistry9f01b772015-07-29 01:54:554266 const int download_id = ++next_image_download_id;
4267 if (!mojo_image_downloader) {
4268 // If the renderer process is dead (i.e. crash, or memory pressure on
4269 // Android), the downloader service will be invalid. Pre-Mojo, this would
Avi Drissmana5a52dd2018-03-27 03:39:024270 // hang the callback indefinitely since the IPC would be dropped. Now,
amistry9f01b772015-07-29 01:54:554271 // respond with a 400 HTTP error code to indicate that something went wrong.
Sami Kyostila8e4d5a92019-08-02 12:45:054272 base::PostTask(
Eric Seckler8652dcd52018-09-20 10:42:284273 FROM_HERE, {BrowserThread::UI},
tzike2aca992017-09-05 08:50:544274 base::BindOnce(&WebContentsImpl::OnDidDownloadImage,
Avi Drissmana5a52dd2018-03-27 03:39:024275 weak_factory_.GetWeakPtr(), std::move(callback),
4276 download_id, url, 400, std::vector<SkBitmap>(),
4277 std::vector<gfx::Size>()));
amistry9f01b772015-07-29 01:54:554278 return download_id;
4279 }
4280
halton.huoca2eabd2015-07-06 08:17:404281 mojo_image_downloader->DownloadImage(
sammcf6f4fcf2016-06-21 05:39:394282 url, is_favicon, max_bitmap_size, bypass_cache,
tzike2aca992017-09-05 08:50:544283 base::BindOnce(&WebContentsImpl::OnDidDownloadImage,
Avi Drissmana5a52dd2018-03-27 03:39:024284 weak_factory_.GetWeakPtr(), std::move(callback),
4285 download_id, url));
amistry9f01b772015-07-29 01:54:554286 return download_id;
[email protected]795c28972012-12-06 06:13:394287}
4288
[email protected]36ec24f2014-01-09 00:32:084289void WebContentsImpl::Find(int request_id,
4290 const base::string16& search_text,
Rakina Zata Amni3f77dff2018-09-08 16:19:434291 blink::mojom::FindOptionsPtr options) {
thestig6057a6b22015-11-12 23:01:334292 // Cowardly refuse to search for no text.
4293 if (search_text.empty()) {
4294 NOTREACHED();
4295 return;
4296 }
4297
Rakina Zata Amni3f77dff2018-09-08 16:19:434298 GetOrCreateFindRequestManager()->Find(request_id, search_text,
4299 std::move(options));
[email protected]36ec24f2014-01-09 00:32:084300}
4301
4302void WebContentsImpl::StopFinding(StopFindAction action) {
paulmeyerfeafc2d2017-04-25 21:46:404303 if (FindRequestManager* manager = GetFindRequestManager())
4304 manager->StopFinding(action);
[email protected]36ec24f2014-01-09 00:32:084305}
4306
Tommy Steimel18360512017-11-01 00:38:194307bool WebContentsImpl::WasEverAudible() {
4308 return was_ever_audible_;
4309}
4310
Avi Drissmana5a52dd2018-03-27 03:39:024311void WebContentsImpl::GetManifest(GetManifestCallback callback) {
4312 manifest_manager_host_->GetManifest(std::move(callback));
mlamouriefdca9d2014-09-16 16:55:404313}
4314
bokanece34a82016-01-28 19:49:464315void WebContentsImpl::ExitFullscreen(bool will_cause_resize) {
mlamouri7a78d6fd2015-01-17 13:23:534316 // Clean up related state and initiate the fullscreen exit.
avi3627ecac2015-10-16 17:40:434317 GetRenderViewHost()->GetWidget()->RejectMouseLockOrUnlockIfNecessary();
bokanece34a82016-01-28 19:49:464318 ExitFullscreenMode(will_cause_resize);
mlamouri7a78d6fd2015-01-17 13:23:534319}
4320
Avi Drissmanced52b62019-08-14 21:25:464321void WebContentsImpl::ForSecurityDropFullscreen() {
4322 // There are two chains of WebContents to kick out of fullscreen.
4323 //
4324 // Chain 1, the inner/outer WebContents chain. If an inner WebContents has
4325 // done something that requires the browser to drop fullscreen, drop
4326 // fullscreen from it and any outer WebContents that may be in fullscreen.
4327 //
4328 // Chain 2, the opener WebContents chain. If a WebContents has done something
4329 // that requires the browser to drop fullscreen, drop fullscreen from any
4330 // WebContents that was involved in the chain of opening it.
4331 //
4332 // Note that these two chains don't interact, as only a top-level WebContents
4333 // can have an opener. This simplifies things.
4334
4335 WebContents* web_contents = this;
4336 while (web_contents) {
4337 if (web_contents->IsFullscreenForCurrentTab())
4338 web_contents->ExitFullscreen(true);
4339
4340 if (web_contents->HasOriginalOpener())
4341 web_contents = FromRenderFrameHost(web_contents->GetOriginalOpener());
4342 else
4343 web_contents = web_contents->GetOuterWebContents();
4344 }
4345}
4346
mariakhomenko44bdc4732015-04-29 01:55:384347void WebContentsImpl::ResumeLoadingCreatedWebContents() {
Nasko Oskov83a8cf92018-10-19 14:58:564348 if (delayed_load_url_params_.get()) {
4349 DCHECK(!delayed_open_url_params_);
4350 controller_.LoadURLWithParams(*delayed_load_url_params_.get());
4351 delayed_load_url_params_.reset(nullptr);
4352 return;
4353 }
4354
mariakhomenkoa4971c12015-07-21 19:04:374355 if (delayed_open_url_params_.get()) {
4356 OpenURL(*delayed_open_url_params_.get());
4357 delayed_open_url_params_.reset(nullptr);
4358 return;
4359 }
4360
mariakhomenko44bdc4732015-04-29 01:55:384361 // Resume blocked requests for both the RenderViewHost and RenderFrameHost.
4362 // TODO(brettw): It seems bogus to reach into here and initialize the host.
dfalcantarae6b7b46752015-07-10 18:14:164363 if (is_resume_pending_) {
4364 is_resume_pending_ = false;
avi0f1bbc9712015-11-17 02:58:134365 GetRenderViewHost()->GetWidget()->Init();
dfalcantarae6b7b46752015-07-10 18:14:164366 GetMainFrame()->Init();
4367 }
mariakhomenko44bdc4732015-04-29 01:55:384368}
4369
[email protected]b172aee2012-04-10 17:05:264370bool WebContentsImpl::FocusLocationBarByDefault() {
Xiyuan Xia2a66b112018-12-06 15:52:164371 if (should_focus_location_bar_by_default_)
[email protected]0c9406632013-02-08 01:13:334372 return true;
Xiyuan Xia2a66b112018-12-06 15:52:164373
[email protected]0c9406632013-02-08 01:13:334374 return delegate_ && delegate_->ShouldFocusLocationBarByDefault(this);
[email protected]0bfbf882011-12-22 18:19:274375}
4376
Tommy C. Li8bb5bf42019-01-18 18:45:514377void WebContentsImpl::SetFocusToLocationBar() {
[email protected]0bfbf882011-12-22 18:19:274378 if (delegate_)
Tommy C. Li8bb5bf42019-01-18 18:45:514379 delegate_->SetFocusToLocationBar();
[email protected]c40d6232011-03-25 00:16:214380}
4381
clamy0e119882015-07-31 16:12:334382void WebContentsImpl::DidStartNavigation(NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484383 TRACE_EVENT1("navigation", "WebContentsImpl::DidStartNavigation",
4384 "navigation_handle", navigation_handle);
ericwilligersde386342016-10-19 02:35:094385 for (auto& observer : observers_)
4386 observer.DidStartNavigation(navigation_handle);
Becca Hughesd11d6502018-07-31 17:01:284387
4388 if (display_cutout_host_impl_)
4389 display_cutout_host_impl_->DidStartNavigation(navigation_handle);
Xiyuan Xia2a66b112018-12-06 15:52:164390
4391 if (navigation_handle->IsInMainFrame()) {
4392 // When the browser is started with about:blank as the startup URL, focus
4393 // the location bar (which will also select its contents) so people can
4394 // simply begin typing to navigate elsewhere.
4395 //
4396 // We need to be careful not to trigger this for anything other than the
4397 // startup navigation. In particular, if we allow an attacker to open a
4398 // popup to about:blank, then navigate, focusing the Omnibox will cause the
4399 // end of the new URL to be scrolled into view instead of the start,
4400 // allowing the attacker to spoof other URLs. The conditions checked here
4401 // are all aimed at ensuring no such attacker-controlled navigation can
4402 // trigger this.
4403 should_focus_location_bar_by_default_ =
4404 controller_.IsInitialNavigation() &&
4405 !navigation_handle->IsRendererInitiated() &&
4406 navigation_handle->GetURL() == url::kAboutBlankURL;
4407 }
clamy0e119882015-07-31 16:12:334408}
4409
4410void WebContentsImpl::DidRedirectNavigation(
4411 NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484412 TRACE_EVENT1("navigation", "WebContentsImpl::DidRedirectNavigation",
4413 "navigation_handle", navigation_handle);
ericwilligersde386342016-10-19 02:35:094414 for (auto& observer : observers_)
4415 observer.DidRedirectNavigation(navigation_handle);
jam5f358e52017-02-13 16:37:034416
4417 // Notify accessibility if this is a reload. This has to called on the
4418 // BrowserAccessibilityManager associated with the old RFHI.
4419 if (navigation_handle->GetReloadType() != ReloadType::NONE) {
Mohamed Abdelhalim95794962019-09-20 11:16:494420 NavigationRequest* request = NavigationRequest::From(navigation_handle);
jam5f358e52017-02-13 16:37:034421 BrowserAccessibilityManager* manager =
Mohamed Abdelhalim95794962019-09-20 11:16:494422 request->frame_tree_node()
jam5f358e52017-02-13 16:37:034423 ->current_frame_host()
4424 ->browser_accessibility_manager();
4425 if (manager)
4426 manager->UserIsReloading();
4427 }
clamy0e119882015-07-31 16:12:334428}
4429
clamyefca29e2015-09-17 00:22:114430void WebContentsImpl::ReadyToCommitNavigation(
4431 NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484432 TRACE_EVENT1("navigation", "WebContentsImpl::ReadyToCommitNavigation",
4433 "navigation_handle", navigation_handle);
ericwilligersde386342016-10-19 02:35:094434 for (auto& observer : observers_)
4435 observer.ReadyToCommitNavigation(navigation_handle);
John Abd-El-Malekd4882642017-12-04 21:45:194436
Kenneth Russell954ed9ce2018-04-12 23:07:014437 // If any domains are blocked from accessing 3D APIs because they may
4438 // have caused the GPU to reset recently, unblock them here if the user
4439 // initiated this navigation. This implies that the user was involved in
4440 // the decision to navigate, so there's no concern about
4441 // denial-of-service issues. Want to do this as early as
4442 // possible to avoid race conditions with pages attempting to access
4443 // WebGL early on.
4444 //
4445 // TODO(crbug.com/617904): currently navigations initiated by the browser
4446 // (reload button, reload menu option, pressing return in the Omnibox)
4447 // return false from HasUserGesture(). If or when that is addressed,
4448 // remove the check for IsRendererInitiated() below.
4449 //
4450 // TODO(crbug.com/832180): HasUserGesture comes from the renderer
4451 // process and isn't validated. Until it is, don't trust it.
4452 if (!navigation_handle->IsRendererInitiated()) {
4453 GpuDataManagerImpl::GetInstance()->UnblockDomainFrom3DAPIs(
4454 navigation_handle->GetURL());
4455 }
4456
John Abd-El-Malekfde08e6da2017-12-05 04:06:244457 if (navigation_handle->IsSameDocument())
4458 return;
4459
Livvie Lin139bf442018-08-10 00:18:544460 // SSLInfo is not needed on subframe navigations since the main-frame
4461 // certificate is the only one that can be inspected (using the info
4462 // bubble) without refreshing the page with DevTools open.
Carlos ILaed1e7b2019-03-12 19:27:214463 // We don't call DidStartResourceResponse on net errors, since that results on
4464 // existing cert exceptions being revoked, which leads to weird behavior with
4465 // committed interstitials or while offline. We only need the error check for
4466 // the main frame case because unlike this method, SubresourceResponseStarted
4467 // does not get called on network errors.
4468 if (navigation_handle->IsInMainFrame() &&
4469 navigation_handle->GetNetErrorCode() == net::OK) {
Livvie Lin139bf442018-08-10 00:18:544470 controller_.ssl_manager()->DidStartResourceResponse(
4471 navigation_handle->GetURL(),
Camille Lamy62b826012019-02-26 09:15:474472 navigation_handle->GetSSLInfo().has_value()
4473 ? net::IsCertStatusError(
4474 navigation_handle->GetSSLInfo()->cert_status)
4475 : false);
4476 }
John Abd-El-Malekfde08e6da2017-12-05 04:06:244477
4478 SetNotWaitingForResponse();
clamyefca29e2015-09-17 00:22:114479}
4480
clamy0e119882015-07-31 16:12:334481void WebContentsImpl::DidFinishNavigation(NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484482 TRACE_EVENT1("navigation", "WebContentsImpl::DidFinishNavigation",
4483 "navigation_handle", navigation_handle);
Steven Holte38041342018-06-22 22:00:574484
ericwilligersde386342016-10-19 02:35:094485 for (auto& observer : observers_)
4486 observer.DidFinishNavigation(navigation_handle);
clamy0e119882015-07-31 16:12:334487
Becca Hughesd11d6502018-07-31 17:01:284488 if (display_cutout_host_impl_)
4489 display_cutout_host_impl_->DidFinishNavigation(navigation_handle);
4490
jam5f358e52017-02-13 16:37:034491 if (navigation_handle->HasCommitted()) {
Dominic Farolinof87ec2a2019-07-04 09:18:094492 // TODO(domfarolino, dmazzoni): Do this using WebContentsObserver. See
4493 // https://crbug.com/981271.
dmazzonibf8cec42015-02-08 08:28:084494 BrowserAccessibilityManager* manager =
jam5f358e52017-02-13 16:37:034495 static_cast<RenderFrameHostImpl*>(
4496 navigation_handle->GetRenderFrameHost())
4497 ->browser_accessibility_manager();
4498 if (manager) {
4499 if (navigation_handle->IsErrorPage()) {
4500 manager->NavigationFailed();
4501 } else {
4502 manager->NavigationSucceeded();
4503 }
4504 }
Tommy Steimel18360512017-11-01 00:38:194505
Yue Ru Sun979c4b162019-11-06 16:11:044506 if (navigation_handle->IsInMainFrame()) {
4507 last_committed_source_id_including_same_document_ =
Steven Holte38041342018-06-22 22:00:574508 ukm::ConvertToSourceId(navigation_handle->GetNavigationId(),
4509 ukm::SourceIdType::NAVIGATION_ID);
Yue Ru Sun979c4b162019-11-06 16:11:044510
4511 if (!navigation_handle->IsSameDocument()) {
4512 was_ever_audible_ = false;
4513 last_committed_source_id_ =
4514 last_committed_source_id_including_same_document_;
4515 }
Tommy Steimel18360512017-11-01 00:38:194516 }
dmazzonibf8cec42015-02-08 08:28:084517 }
Xiyuan Xia2a66b112018-12-06 15:52:164518
4519 // If we didn't end up on about:blank after setting this in DidStartNavigation
4520 // then don't focus the location bar.
4521 if (should_focus_location_bar_by_default_ &&
4522 navigation_handle->GetURL() != url::kAboutBlankURL) {
4523 should_focus_location_bar_by_default_ = false;
4524 }
yilkal796e89e2019-10-02 23:58:284525
yilkal172da772019-11-06 22:49:074526 if (navigation_handle->IsInMainFrame() && first_navigation_completed_)
4527 RecordMaxFrameCountUMA(max_loaded_frame_count_);
yilkal796e89e2019-10-02 23:58:284528
yilkal172da772019-11-06 22:49:074529 // If navigation has successfully finished in the main frame, set
4530 // |first_navigation_completed_| to true so that we will record
4531 // |max_loaded_frame_count_| above when future main frame navigations finish.
4532 if (navigation_handle->IsInMainFrame() && !navigation_handle->IsErrorPage()) {
4533 first_navigation_completed_ = true;
4534
4535 // Navigation has completed in main frame. Reset |max_loaded_frame_count_|.
4536 // |max_loaded_frame_count_| is not necessarily 1 if the navigation was
4537 // served from BackForwardCache.
4538 max_loaded_frame_count_ =
4539 GetMainFrame()->frame_tree_node()->GetFrameTreeSize();
yilkal796e89e2019-10-02 23:58:284540 }
[email protected]400992b2012-06-14 00:03:544541}
4542
[email protected]b80624c2014-02-09 02:46:554543void WebContentsImpl::DidFailLoadWithError(
4544 RenderFrameHostImpl* render_frame_host,
[email protected]b80624c2014-02-09 02:46:554545 const GURL& url,
[email protected]b80624c2014-02-09 02:46:554546 int error_code,
Yutaka Hirano16d3c5d2017-07-31 06:17:304547 const base::string16& error_description) {
ericwilligersde386342016-10-19 02:35:094548 for (auto& observer : observers_) {
Yutaka Hirano16d3c5d2017-07-31 06:17:304549 observer.DidFailLoad(render_frame_host, url, error_code, error_description);
ericwilligersde386342016-10-19 02:35:094550 }
[email protected]b80624c2014-02-09 02:46:554551}
4552
[email protected]52913802013-12-10 05:52:184553void WebContentsImpl::NotifyChangedNavigationState(
4554 InvalidateTypes changed_flags) {
4555 NotifyNavigationStateChanged(changed_flags);
4556}
4557
toyoshim0df1d3a2016-09-09 09:52:484558void WebContentsImpl::DidStartNavigationToPendingEntry(const GURL& url,
4559 ReloadType reload_type) {
[email protected]3691e5cf2014-01-22 10:16:204560 // Notify observers about navigation.
ericwilligersde386342016-10-19 02:35:094561 for (auto& observer : observers_)
4562 observer.DidStartNavigationToPendingEntry(url, reload_type);
[email protected]3691e5cf2014-01-22 10:16:204563}
4564
lukasza1d025732016-09-28 21:36:084565bool WebContentsImpl::ShouldTransferNavigation(bool is_main_frame_navigation) {
creis29460272015-12-16 04:38:224566 if (!delegate_)
4567 return true;
lukasza1d025732016-09-28 21:36:084568 return delegate_->ShouldTransferNavigation(is_main_frame_navigation);
creis29460272015-12-16 04:38:224569}
4570
[email protected]aa62afd2014-04-22 19:22:464571bool WebContentsImpl::ShouldPreserveAbortedURLs() {
4572 if (!delegate_)
4573 return false;
4574 return delegate_->ShouldPreserveAbortedURLs(this);
4575}
4576
[email protected]0d0f4c492014-04-02 06:42:574577void WebContentsImpl::DidNavigateMainFramePreCommit(
[email protected]5cfbddc2014-06-23 23:52:234578 bool navigation_is_within_page) {
[email protected]0d0f4c492014-04-02 06:42:574579 // Ensure fullscreen mode is exited before committing the navigation to a
4580 // different page. The next page will not start out assuming it is in
4581 // fullscreen mode.
[email protected]5cfbddc2014-06-23 23:52:234582 if (navigation_is_within_page) {
[email protected]dfc39cb2014-04-09 22:58:194583 // No page change? Then, the renderer and browser can remain in fullscreen.
[email protected]0d0f4c492014-04-02 06:42:574584 return;
4585 }
alexmos5dd617d2016-06-07 04:21:154586 if (IsFullscreenForCurrentTab())
bokanece34a82016-01-28 19:49:464587 ExitFullscreen(false);
alexmos5dd617d2016-06-07 04:21:154588 DCHECK(!IsFullscreenForCurrentTab());
Joe Downingc1a57efe2018-05-09 18:23:544589
4590 // Clean up keyboard lock state when navigating.
4591 CancelKeyboardLock(keyboard_lock_widget_);
[email protected]0d0f4c492014-04-02 06:42:574592}
4593
[email protected]37567b432014-02-12 01:12:224594void WebContentsImpl::DidNavigateMainFramePostCommit(
sky8b00392d2015-01-10 00:30:284595 RenderFrameHostImpl* render_frame_host,
[email protected]37567b432014-02-12 01:12:224596 const LoadCommittedDetails& details,
4597 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
4598 if (details.is_navigation_to_different_page()) {
4599 // Clear the status bubble. This is a workaround for a bug where WebKit
4600 // doesn't let us know that the cursor left an element during a
4601 // transition (this is also why the mouse cursor remains as a hand after
4602 // clicking on a link); see bugs 1184641 and 980803. We don't want to
4603 // clear the bubble when a user navigates to a named anchor in the same
4604 // page.
Lukasz Anforowiczfd707142018-02-07 19:46:134605 ClearTargetURL();
lanwei9d343ad22015-02-11 01:46:004606
4607 RenderWidgetHostViewBase* rwhvb =
4608 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
4609 if (rwhvb)
4610 rwhvb->OnDidNavigateMainFrameToNewPage();
[email protected]37567b432014-02-12 01:12:224611 }
4612
[email protected]e85165c642014-06-10 14:34:314613 if (delegate_)
[email protected]37567b432014-02-12 01:12:224614 delegate_->DidNavigateMainFramePostCommit(this);
[email protected]e85165c642014-06-10 14:34:314615 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
Shivani Sharma985474f2019-05-23 21:36:474616
4617 if (!details.is_same_document && GetInnerWebContents().empty())
4618 had_inner_webcontents_ = false;
Carlos Caballero91fffb22019-10-29 15:24:304619
4620 if (details.is_navigation_to_different_page() &&
4621 GetRenderViewHost()->did_first_visually_non_empty_paint()) {
4622 // This event will not fire again if the page is restored from the
4623 // BackForwardCache. So fire it ourselves if needed.
4624 DidFirstVisuallyNonEmptyPaint(GetRenderViewHost());
4625 }
Carlos Caballero1215f882019-10-29 15:58:434626
4627 if (GetRenderViewHost()->theme_color() != last_sent_theme_color_) {
4628 // This event will not fire again if the page is restored from the
4629 // BackForwardCache. So fire it ourselves if needed.
4630 OnThemeColorChanged(GetRenderViewHost());
4631 }
[email protected]37567b432014-02-12 01:12:224632}
4633
4634void WebContentsImpl::DidNavigateAnyFramePostCommit(
4635 RenderFrameHostImpl* render_frame_host,
4636 const LoadCommittedDetails& details,
4637 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
[email protected]b4c84012014-04-28 19:51:104638 // Now that something has committed, we don't need to track whether the
4639 // initial page has been accessed.
4640 has_accessed_initial_document_ = false;
4641
[email protected]37567b432014-02-12 01:12:224642 // If we navigate off the page, close all JavaScript dialogs.
eugenebutee08663a2017-04-27 17:43:124643 if (!details.is_same_document)
creis89a0f782015-05-27 16:13:174644 CancelActiveAndPendingDialogs();
[email protected]37567b432014-02-12 01:12:224645
avid53461d2016-02-25 17:15:044646 // If this is a user-initiated navigation, start allowing JavaScript dialogs
4647 // again.
avi5d3b8692016-10-12 22:00:464648 if (params.gesture == NavigationGestureUser && dialog_manager_) {
avi6879fcf2017-01-21 05:27:534649 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:464650 }
[email protected]37567b432014-02-12 01:12:224651}
4652
4653void WebContentsImpl::SetMainFrameMimeType(const std::string& mime_type) {
4654 contents_mime_type_ = mime_type;
4655}
4656
[email protected]277857a2014-06-03 10:38:014657bool WebContentsImpl::CanOverscrollContent() const {
[email protected]e85165c642014-06-10 14:34:314658 // Disable overscroll when touch emulation is on. See crbug.com/369938.
[email protected]34ff1cfc2014-08-20 06:16:054659 if (force_disable_overscroll_content_)
[email protected]e85165c642014-06-10 14:34:314660 return false;
4661
[email protected]37567b432014-02-12 01:12:224662 if (delegate_)
4663 return delegate_->CanOverscrollContent();
4664
4665 return false;
4666}
4667
Carlos Caballero1215f882019-10-29 15:58:434668void WebContentsImpl::OnThemeColorChanged(RenderViewHostImpl* source) {
4669 if (source->did_first_visually_non_empty_paint() &&
4670 last_sent_theme_color_ != source->theme_color()) {
ericwilligersde386342016-10-19 02:35:094671 for (auto& observer : observers_)
Carlos Caballero1215f882019-10-29 15:58:434672 observer.DidChangeThemeColor(source->theme_color());
4673 last_sent_theme_color_ = source->theme_color();
peter90afaba2015-06-01 12:05:294674 }
[email protected]e7104762014-06-20 19:17:254675}
4676
[email protected]b172aee2012-04-10 17:05:264677void WebContentsImpl::OnDidLoadResourceFromMemoryCache(
nicka0ac8382016-12-15 23:59:234678 RenderFrameHostImpl* source,
[email protected]724159a2010-12-30 01:11:184679 const GURL& url,
[email protected]70435962011-08-02 20:13:284680 const std::string& http_method,
[email protected]6d6cfb3a2012-05-23 22:53:184681 const std::string& mime_type,
[email protected]6c1e05212014-07-31 00:59:404682 ResourceType resource_type) {
ericwilligersde386342016-10-19 02:35:094683 for (auto& observer : observers_)
4684 observer.DidLoadResourceFromMemoryCache(url, mime_type, resource_type);
[email protected]b0f724c2013-09-05 04:21:134685
Steven Bingler674fb0822018-12-12 18:04:524686 if (url.is_valid() && url.SchemeIsHTTPOrHTTPS()) {
nicka0ac8382016-12-15 23:59:234687 StoragePartition* partition = source->GetProcess()->GetStoragePartition();
John Abd-El-Malekf4fe9d82019-07-31 04:05:594688 partition->GetNetworkContext()->NotifyExternalCacheHit(
Alex Turner48442b542019-08-21 14:01:144689 url, http_method, source->network_isolation_key());
[email protected]8bfc8272013-09-09 20:10:534690 }
[email protected]724159a2010-12-30 01:11:184691}
4692
carloskd9d97942017-02-16 08:58:094693void WebContentsImpl::DidDisplayInsecureContent() {
estarkc2273502016-10-12 22:03:024694 controller_.ssl_manager()->DidDisplayMixedContent();
[email protected]724159a2010-12-30 01:11:184695}
4696
Dave Tapuskaa657d872019-10-21 20:23:214697void WebContentsImpl::DidContainInsecureFormAction() {
elawrenceb2ac2a232017-03-27 21:46:254698 controller_.ssl_manager()->DidContainInsecureFormAction();
4699}
4700
nicka0ac8382016-12-15 23:59:234701void WebContentsImpl::OnDidRunInsecureContent(RenderFrameHostImpl* source,
4702 const GURL& security_origin,
estark910b4572015-12-09 20:55:414703 const GURL& target_url) {
nicka0ac8382016-12-15 23:59:234704 // TODO(nick, estark): Should we call FilterURL using |source|'s process on
4705 // these parameters? |target_url| seems unused, except for a log message. And
4706 // |security_origin| might be replaceable with the origin of the main frame.
carloskd9d97942017-02-16 08:58:094707 DidRunInsecureContent(security_origin, target_url);
4708}
4709
4710void WebContentsImpl::DidRunInsecureContent(const GURL& security_origin,
4711 const GURL& target_url) {
[email protected]9450c462013-11-23 01:22:584712 LOG(WARNING) << security_origin << " ran insecure content from "
4713 << target_url.possibly_invalid_spec();
[email protected]e6e30ac2014-01-13 21:24:394714 RecordAction(base::UserMetricsAction("SSL.RanInsecureContent"));
estark910b4572015-12-09 20:55:414715 if (base::EndsWith(security_origin.spec(), kDotGoogleDotCom,
brettwa7ff1b292015-07-16 17:49:294716 base::CompareCase::INSENSITIVE_ASCII))
[email protected]e6e30ac2014-01-13 21:24:394717 RecordAction(base::UserMetricsAction("SSL.RanInsecureContentGoogle"));
estarkc2273502016-10-12 22:03:024718 controller_.ssl_manager()->DidRunMixedContent(security_origin);
[email protected]724159a2010-12-30 01:11:184719}
4720
carloskd9d97942017-02-16 08:58:094721void WebContentsImpl::PassiveInsecureContentFound(const GURL& resource_url) {
Sergey Kuznetsov3ebc01b2018-02-01 04:57:364722 if (delegate_) {
4723 delegate_->PassiveInsecureContentFound(resource_url);
4724 }
carloskd9d97942017-02-16 08:58:094725}
4726
4727bool WebContentsImpl::ShouldAllowRunningInsecureContent(
4728 WebContents* web_contents,
4729 bool allowed_per_prefs,
4730 const url::Origin& origin,
4731 const GURL& resource_url) {
Sergey Kuznetsov3ebc01b2018-02-01 04:57:364732 if (delegate_) {
4733 return delegate_->ShouldAllowRunningInsecureContent(
4734 web_contents, allowed_per_prefs, origin, resource_url);
4735 }
4736
4737 return allowed_per_prefs;
carloskd9d97942017-02-16 08:58:094738}
4739
Lukasz Anforowicze1b954d92017-10-30 21:28:064740void WebContentsImpl::ViewSource(RenderFrameHostImpl* frame) {
4741 DCHECK_EQ(this, WebContents::FromRenderFrameHost(frame));
4742
4743 // Don't do anything if there is no |delegate_| that could accept and show the
4744 // new WebContents containing the view-source.
4745 if (!delegate_)
4746 return;
4747
4748 // Use the last committed entry, since the pending entry hasn't loaded yet and
4749 // won't be copied into the cloned tab.
4750 NavigationEntryImpl* last_committed_entry =
4751 static_cast<NavigationEntryImpl*>(frame->frame_tree_node()
4752 ->navigator()
4753 ->GetController()
4754 ->GetLastCommittedEntry());
4755 if (!last_committed_entry)
4756 return;
4757
4758 FrameNavigationEntry* frame_entry =
4759 last_committed_entry->GetFrameEntry(frame->frame_tree_node());
4760 if (!frame_entry)
4761 return;
4762
4763 // Any new WebContents opened while this WebContents is in fullscreen can be
4764 // used to confuse the user, so drop fullscreen.
Avi Drissmand18c51972018-08-15 18:32:094765 ForSecurityDropFullscreen();
Lukasz Anforowicze1b954d92017-10-30 21:28:064766
4767 // We intentionally don't share the SiteInstance with the original frame so
4768 // that view source has a consistent process model and always ends up in a new
4769 // process (https://crbug.com/699493).
4770 scoped_refptr<SiteInstanceImpl> site_instance_for_view_source = nullptr;
Lukasz Anforowicz435bcb582019-07-12 20:50:064771 // Referrer and initiator are not important, because view-source should not
4772 // hit the network, but should be served from the cache instead.
Lukasz Anforowicze1b954d92017-10-30 21:28:064773 Referrer referrer_for_view_source;
Lukasz Anforowicz435bcb582019-07-12 20:50:064774 base::Optional<url::Origin> initiator_for_view_source = base::nullopt;
Lukasz Anforowicze1b954d92017-10-30 21:28:064775 // Do not restore title, derive it from the url.
4776 base::string16 title_for_view_source;
4777 auto navigation_entry = std::make_unique<NavigationEntryImpl>(
4778 site_instance_for_view_source, frame_entry->url(),
Lukasz Anforowicz435bcb582019-07-12 20:50:064779 referrer_for_view_source, initiator_for_view_source,
4780 title_for_view_source, ui::PAGE_TRANSITION_LINK,
Marijn Kruisselbrink7a0d5e182018-05-24 22:55:094781 /* is_renderer_initiated = */ false,
4782 /* blob_url_loader_factory = */ nullptr);
Lukasz Anforowicze1b954d92017-10-30 21:28:064783 navigation_entry->SetVirtualURL(GURL(content::kViewSourceScheme +
4784 std::string(":") +
4785 frame_entry->url().spec()));
4786
Yao Xiaof68f57d2019-10-03 04:20:054787 navigation_entry->set_network_isolation_key(
4788 net::NetworkIsolationKey(GetMainFrame()->GetLastCommittedOrigin(),
4789 frame->GetLastCommittedOrigin()));
4790
Lukasz Anforowicze1b954d92017-10-30 21:28:064791 // Do not restore scroller position.
4792 // TODO(creis, lukasza, arthursonzogni): Do not reuse the original PageState,
4793 // but start from a new one and only copy the needed data.
4794 const PageState& new_page_state =
4795 frame_entry->page_state().RemoveScrollOffset();
4796
4797 scoped_refptr<FrameNavigationEntry> new_frame_entry =
4798 navigation_entry->root_node()->frame_entry;
4799 new_frame_entry->set_method(frame_entry->method());
4800 new_frame_entry->SetPageState(new_page_state);
4801
4802 // Create a new WebContents, which is used to display the source code.
erikchenbee5c9622018-04-27 19:30:254803 std::unique_ptr<WebContents> view_source_contents =
Erik Chenbb8e738e2018-04-28 14:10:434804 Create(CreateParams(GetBrowserContext()));
Lukasz Anforowicze1b954d92017-10-30 21:28:064805
4806 // Restore the previously created NavigationEntry.
4807 std::vector<std::unique_ptr<NavigationEntry>> navigation_entries;
4808 navigation_entries.push_back(std::move(navigation_entry));
4809 view_source_contents->GetController().Restore(0, RestoreType::CURRENT_SESSION,
4810 &navigation_entries);
4811
4812 // Add |view_source_contents| as a new tab.
4813 gfx::Rect initial_rect;
4814 constexpr bool kUserGesture = true;
4815 bool ignored_was_blocked;
erikchenbee5c9622018-04-27 19:30:254816 delegate_->AddNewContents(this, std::move(view_source_contents),
Lukasz Anforowicze1b954d92017-10-30 21:28:064817 WindowOpenDisposition::NEW_FOREGROUND_TAB,
4818 initial_rect, kUserGesture, &ignored_was_blocked);
4819 // Note that the |delegate_| could have deleted |view_source_contents| during
4820 // AddNewContents method call.
4821}
4822
Jay Civellid5904f02018-03-23 19:43:574823void WebContentsImpl::SubresourceResponseStarted(const GURL& url,
4824 net::CertStatus cert_status) {
4825 controller_.ssl_manager()->DidStartResourceResponse(url, cert_status);
4826 SetNotWaitingForResponse();
4827}
4828
Jay Civelli116683f2018-03-27 19:56:234829void WebContentsImpl::ResourceLoadComplete(
Jay Civelli52a63302018-04-30 22:39:554830 RenderFrameHost* render_frame_host,
Clark DuVall36164bd2018-08-09 22:49:084831 const GlobalRequestID& request_id,
Jay Civelli116683f2018-03-27 19:56:234832 mojom::ResourceLoadInfoPtr resource_load_info) {
John Abd-El-Malek9b8f7fa2017-12-04 23:52:254833 for (auto& observer : observers_) {
Clark DuVall36164bd2018-08-09 22:49:084834 observer.ResourceLoadComplete(render_frame_host, request_id,
4835 *resource_load_info);
John Abd-El-Malek9b8f7fa2017-12-04 23:52:254836 }
John Abd-El-Malekd4882642017-12-04 21:45:194837}
4838
Wei Li5bb659742018-02-14 03:07:584839void WebContentsImpl::PrintCrossProcessSubframe(
4840 const gfx::Rect& rect,
4841 int document_cookie,
4842 RenderFrameHost* subframe_host) {
Wei Li5c0b4d12018-03-22 15:05:224843 auto* outer_contents = GetOuterWebContents();
4844 if (outer_contents) {
4845 // When an extension or app page is printed, the content should be
4846 // composited with outer content, so the outer contents should handle the
4847 // print request.
4848 outer_contents->PrintCrossProcessSubframe(rect, document_cookie,
4849 subframe_host);
4850 return;
4851 }
4852
Wei Li5bb659742018-02-14 03:07:584853 // If there is no delegate such as in tests or during deletion, do nothing.
4854 if (!delegate_)
4855 return;
4856
4857 delegate_->PrintCrossProcessSubframe(this, rect, document_cookie,
4858 subframe_host);
4859}
4860
rob.buis300b0872017-03-10 20:43:584861#if defined(OS_ANDROID)
4862base::android::ScopedJavaLocalRef<jobject>
4863WebContentsImpl::GetJavaRenderFrameHostDelegate() {
4864 return GetJavaWebContents();
4865}
4866#endif
4867
estark910b4572015-12-09 20:55:414868void WebContentsImpl::OnDidDisplayContentWithCertificateErrors(
Zhuoyu Qian4353f7f2018-01-08 05:33:004869 RenderFrameHostImpl* source) {
estarkc2273502016-10-12 22:03:024870 controller_.ssl_manager()->DidDisplayContentWithCertErrors();
estark910b4572015-12-09 20:55:414871}
4872
4873void WebContentsImpl::OnDidRunContentWithCertificateErrors(
Zhuoyu Qian4353f7f2018-01-08 05:33:004874 RenderFrameHostImpl* source) {
nicka0ac8382016-12-15 23:59:234875 // TODO(nick, estark): Do we need to consider |source| here somehow?
estarkcd2e30c2016-08-12 06:51:154876 NavigationEntry* entry = controller_.GetVisibleEntry();
4877 if (!entry)
estarkaeda1422016-05-10 02:31:124878 return;
4879
estarkaeda1422016-05-10 02:31:124880 // TODO(estark): check that this does something reasonable for
4881 // about:blank and sandboxed origins. https://crbug.com/609527
estarkcd2e30c2016-08-12 06:51:154882 controller_.ssl_manager()->DidRunContentWithCertErrors(
4883 entry->GetURL().GetOrigin());
estark910b4572015-12-09 20:55:414884}
4885
Kouhei Ueno97e0990d2019-09-25 02:57:274886void WebContentsImpl::DOMContentLoaded(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:094887 for (auto& observer : observers_)
Kouhei Uenof6e96242019-09-27 01:54:354888 observer.DOMContentLoaded(render_frame_host);
[email protected]724159a2010-12-30 01:11:184889}
4890
nicka0ac8382016-12-15 23:59:234891void WebContentsImpl::OnDidFinishLoad(RenderFrameHostImpl* source,
4892 const GURL& url) {
[email protected]8b3af1e2014-01-24 13:29:124893 GURL validated_url(url);
nicka0ac8382016-12-15 23:59:234894 source->GetProcess()->FilterURL(false, &validated_url);
[email protected]028053d42014-03-05 22:20:374895
ericwilligersde386342016-10-19 02:35:094896 for (auto& observer : observers_)
nicka0ac8382016-12-15 23:59:234897 observer.DidFinishLoad(source, validated_url);
yilkal172da772019-11-06 22:49:074898
4899 size_t tree_size = frame_tree_.root()->GetFrameTreeSize();
4900 if (max_loaded_frame_count_ < tree_size)
4901 max_loaded_frame_count_ = tree_size;
4902
4903 if (!source->GetParent())
4904 UMA_HISTOGRAM_COUNTS_1000("Navigation.MainFrame.FrameCount", tree_size);
[email protected]1a55c5be2011-11-29 11:36:314905}
4906
Dave Tapuska549baab2019-03-19 15:52:404907void WebContentsImpl::OnGoToEntryAtOffset(RenderFrameHostImpl* source,
Arthur Sonzognia7d715a2018-09-20 16:11:134908 int offset,
Dave Tapuska043b94a2019-09-10 14:14:354909 bool has_user_gesture) {
Arthur Sonzognia7d715a2018-09-20 16:11:134910 // Non-user initiated navigations coming from the renderer should be ignored
4911 // if there is an ongoing browser-initiated navigation.
4912 // See https://crbug.com/879965.
4913 // TODO(arthursonzogni): See if this should check for ongoing navigations in
4914 // the frame(s) affected by the session history navigation, rather than just
4915 // the main frame.
4916 if (!has_user_gesture) {
4917 NavigationRequest* ongoing_navigation_request =
4918 frame_tree_.root()->navigation_request();
4919 if (ongoing_navigation_request &&
4920 ongoing_navigation_request->browser_initiated()) {
4921 return;
4922 }
4923 }
4924
nicka0ac8382016-12-15 23:59:234925 // All frames are allowed to navigate the global history.
Dave Tapuska8bfd84c2019-03-26 20:47:164926 if (!delegate_ || delegate_->OnGoToEntryOffset(offset)) {
Dave Tapuska043b94a2019-09-10 14:14:354927 if (source->IsSandboxed(blink::WebSandboxFlags::kTopNavigation)) {
Dave Tapuska8bfd84c2019-03-26 20:47:164928 // Keep track of whether this is a session history from a sandboxed iframe
4929 // with top level navigation disallowed.
4930 controller_.GoToOffsetInSandboxedFrame(offset,
4931 source->GetFrameTreeNodeId());
4932 } else {
4933 controller_.GoToOffset(offset);
4934 }
4935 }
[email protected]216813952011-05-19 22:21:264936}
4937
nicka0ac8382016-12-15 23:59:234938void WebContentsImpl::OnPageScaleFactorChanged(RenderViewHostImpl* source,
4939 float page_scale_factor) {
mcnee336ea2c2017-05-23 22:50:594940#if !defined(OS_ANDROID)
4941 // While page scale factor is used on mobile, this PageScaleFactorIsOne logic
4942 // is only needed on desktop.
mcnee432e47d2015-11-09 19:37:464943 bool is_one = page_scale_factor == 1.f;
4944 if (is_one != page_scale_factor_is_one_) {
4945 page_scale_factor_is_one_ = is_one;
4946
4947 HostZoomMapImpl* host_zoom_map =
4948 static_cast<HostZoomMapImpl*>(HostZoomMap::GetForWebContents(this));
4949
nicka0ac8382016-12-15 23:59:234950 if (host_zoom_map) {
mcnee432e47d2015-11-09 19:37:464951 host_zoom_map->SetPageScaleFactorIsOneForView(
nicka0ac8382016-12-15 23:59:234952 source->GetProcess()->GetID(), source->GetRoutingID(),
mcnee432e47d2015-11-09 19:37:464953 page_scale_factor_is_one_);
4954 }
4955 }
mcnee336ea2c2017-05-23 22:50:594956#endif // !defined(OS_ANDROID)
mcnee432e47d2015-11-09 19:37:464957
ericwilligersde386342016-10-19 02:35:094958 for (auto& observer : observers_)
4959 observer.OnPageScaleFactorChanged(page_scale_factor);
mcnee432e47d2015-11-09 19:37:464960}
4961
W. James MacLean62198672019-06-04 16:46:104962void WebContentsImpl::OnTextAutosizerPageInfoChanged(
4963 RenderViewHostImpl* source,
4964 const blink::WebTextAutosizerPageInfo& page_info) {
4965 // Keep a copy of |page_info| in case we create a new RenderView before
4966 // the next update.
4967 text_autosizer_page_info_ = page_info;
4968 frame_tree_.root()->render_manager()->SendPageMessage(
4969 new PageMsg_UpdateTextAutosizerPageInfoForRemoteMainFrames(
4970 MSG_ROUTING_NONE, page_info),
4971 source->GetSiteInstance());
4972}
4973
Kent Tamura8c9e0562018-11-06 07:02:194974void WebContentsImpl::EnumerateDirectory(
4975 RenderFrameHost* render_frame_host,
4976 std::unique_ptr<FileSelectListener> listener,
4977 const base::FilePath& directory_path) {
4978 if (delegate_)
4979 delegate_->EnumerateDirectory(this, std::move(listener), directory_path);
4980 else
4981 listener->FileSelectionCanceled();
[email protected]3a29a6e2011-08-24 18:26:214982}
4983
Dave Tapuskaf9fc3122019-10-18 19:42:554984void WebContentsImpl::RegisterProtocolHandler(RenderFrameHostImpl* source,
4985 const std::string& protocol,
4986 const GURL& url,
4987 const base::string16& title,
4988 bool user_gesture) {
nicka0ac8382016-12-15 23:59:234989 // TODO(nick): Should we consider |source| here or pass it to the delegate?
4990 // TODO(nick): Do we need to apply FilterURL to |url|?
[email protected]e5f2de02012-07-20 22:15:434991 if (!delegate_)
4992 return;
4993
Raymes Khoury58373df2019-08-06 06:29:204994 if (!AreValidRegisterProtocolHandlerArguments(
4995 protocol, url, source->GetLastCommittedOrigin())) {
4996 ReceivedBadMessage(source->GetProcess(),
4997 bad_message::REGISTER_PROTOCOL_HANDLER_INVALID_URL);
[email protected]b9535422012-02-09 01:47:594998 return;
Raymes Khoury58373df2019-08-06 06:29:204999 }
[email protected]8f810632013-06-06 22:33:325000
[email protected]c125e532014-05-10 20:39:065001 delegate_->RegisterProtocolHandler(this, protocol, url, user_gesture);
[email protected]7d189022011-08-25 22:54:205002}
5003
Dave Tapuskaf9fc3122019-10-18 19:42:555004void WebContentsImpl::UnregisterProtocolHandler(RenderFrameHostImpl* source,
5005 const std::string& protocol,
5006 const GURL& url,
5007 bool user_gesture) {
nicka0ac8382016-12-15 23:59:235008 // TODO(nick): Should we consider |source| here or pass it to the delegate?
5009 // TODO(nick): Do we need to apply FilterURL to |url|?
[email protected]f5273e52014-07-14 16:30:205010 if (!delegate_)
5011 return;
5012
Raymes Khoury58373df2019-08-06 06:29:205013 if (!AreValidRegisterProtocolHandlerArguments(
5014 protocol, url, source->GetLastCommittedOrigin())) {
5015 ReceivedBadMessage(source->GetProcess(),
5016 bad_message::REGISTER_PROTOCOL_HANDLER_INVALID_URL);
[email protected]f5273e52014-07-14 16:30:205017 return;
Raymes Khoury58373df2019-08-06 06:29:205018 }
[email protected]f5273e52014-07-14 16:30:205019
5020 delegate_->UnregisterProtocolHandler(this, protocol, url, user_gesture);
5021}
5022
kouhei40f03cb2015-09-24 07:47:015023void WebContentsImpl::OnUpdatePageImportanceSignals(
nicka0ac8382016-12-15 23:59:235024 RenderFrameHostImpl* source,
kouhei40f03cb2015-09-24 07:47:015025 const PageImportanceSignals& signals) {
nicka0ac8382016-12-15 23:59:235026 // TODO(nick, kouhei): Fix this for oopifs; currently all frames' state gets
5027 // written to this one field.
kouhei40f03cb2015-09-24 07:47:015028 page_importance_signals_ = signals;
5029}
5030
nicka0ac8382016-12-15 23:59:235031void WebContentsImpl::OnDomOperationResponse(RenderFrameHostImpl* source,
5032 const std::string& json_string) {
5033 // TODO(nick, lukasza): The notification below should probably be updated to
5034 // include |source|.
avi60bd4902015-09-23 20:39:245035 std::string json = json_string;
5036 NotificationService::current()->Notify(NOTIFICATION_DOM_OPERATION_RESPONSE,
5037 Source<WebContents>(this),
5038 Details<std::string>(&json));
[email protected]cfa856d62014-02-22 07:58:405039}
5040
Marijn Kruisselbrink7f519672019-02-05 19:12:505041void WebContentsImpl::OnAppCacheAccessed(const GURL& manifest_url,
[email protected]b172aee2012-04-10 17:05:265042 bool blocked_by_policy) {
nicka0ac8382016-12-15 23:59:235043 // TODO(nick): Should we consider |source| here? Should we call FilterURL on
5044 // |manifest_url|?
5045
[email protected]7fc4bbb2011-09-08 21:23:105046 // Notify observers about navigation.
ericwilligersde386342016-10-19 02:35:095047 for (auto& observer : observers_)
5048 observer.AppCacheAccessed(manifest_url, blocked_by_policy);
[email protected]7fc4bbb2011-09-08 21:23:105049}
5050
Miyoung Shincb6475a2019-11-09 10:49:455051void WebContentsImpl::OnColorChooserFactoryReceiver(
Julie Jeongeun Kim8e2879e2019-08-06 23:55:205052 mojo::PendingReceiver<blink::mojom::ColorChooserFactory> receiver) {
5053 color_chooser_factory_receivers_.Add(this, std::move(receiver));
Joel Hockey85b379d2017-12-11 10:42:135054}
5055
5056void WebContentsImpl::OpenColorChooser(
Julie Jeongeun Kim8e2879e2019-08-06 23:55:205057 mojo::PendingReceiver<blink::mojom::ColorChooser> chooser_receiver,
5058 mojo::PendingRemote<blink::mojom::ColorChooserClient> client,
[email protected]8ed16472014-04-11 19:02:485059 SkColor color,
Joel Hockey163835a2017-12-20 11:51:575060 std::vector<blink::mojom::ColorSuggestionPtr> suggestions) {
Joel Hockey85b379d2017-12-11 10:42:135061 content::ColorChooser* new_color_chooser =
Ivan Kotenkov2c0d2bb32017-11-01 15:41:285062 delegate_ ? delegate_->OpenColorChooser(this, color, suggestions)
5063 : nullptr;
[email protected]820957a2014-01-14 14:56:305064 if (!new_color_chooser)
[email protected]cb805452013-05-22 15:16:215065 return;
[email protected]8ed16472014-04-11 19:02:485066
Joel Hockey85b379d2017-12-11 10:42:135067 color_chooser_.reset();
5068 color_chooser_ = std::make_unique<ColorChooser>(
Julie Jeongeun Kim8e2879e2019-08-06 23:55:205069 new_color_chooser, std::move(chooser_receiver), std::move(client));
[email protected]da8543762012-03-20 08:52:205070}
5071
brettw4b461082016-11-19 18:55:165072#if BUILDFLAG(ENABLE_PLUGINS)
nicka0ac8382016-12-15 23:59:235073void WebContentsImpl::OnPepperInstanceCreated(RenderFrameHostImpl* source,
5074 int32_t pp_instance) {
ericwilligersde386342016-10-19 02:35:095075 for (auto& observer : observers_)
5076 observer.PepperInstanceCreated();
nicka0ac8382016-12-15 23:59:235077 pepper_playback_observer_->PepperInstanceCreated(source, pp_instance);
emaxxe70f5e12015-05-29 11:26:005078}
5079
nicka0ac8382016-12-15 23:59:235080void WebContentsImpl::OnPepperInstanceDeleted(RenderFrameHostImpl* source,
5081 int32_t pp_instance) {
ericwilligersde386342016-10-19 02:35:095082 for (auto& observer : observers_)
5083 observer.PepperInstanceDeleted();
nicka0ac8382016-12-15 23:59:235084 pepper_playback_observer_->PepperInstanceDeleted(source, pp_instance);
emaxxe70f5e12015-05-29 11:26:005085}
5086
nicka0ac8382016-12-15 23:59:235087void WebContentsImpl::OnPepperPluginHung(RenderFrameHostImpl* source,
5088 int plugin_child_id,
tommyclie6633ca72014-10-31 00:40:425089 const base::FilePath& path,
5090 bool is_hung) {
Steven Holte95922222018-09-14 20:06:235091 UMA_HISTOGRAM_COUNTS_1M("Pepper.PluginHung", 1);
tommyclie6633ca72014-10-31 00:40:425092
ericwilligersde386342016-10-19 02:35:095093 for (auto& observer : observers_)
5094 observer.PluginHungStatusChanged(plugin_child_id, path, is_hung);
tommyclie6633ca72014-10-31 00:40:425095}
5096
nicka0ac8382016-12-15 23:59:235097void WebContentsImpl::OnPepperStartsPlayback(RenderFrameHostImpl* source,
5098 int32_t pp_instance) {
5099 pepper_playback_observer_->PepperStartsPlayback(source, pp_instance);
zqzhang181047e62016-07-01 13:37:175100}
5101
nicka0ac8382016-12-15 23:59:235102void WebContentsImpl::OnPepperStopsPlayback(RenderFrameHostImpl* source,
5103 int32_t pp_instance) {
5104 pepper_playback_observer_->PepperStopsPlayback(source, pp_instance);
zqzhang181047e62016-07-01 13:37:175105}
5106
nicka0ac8382016-12-15 23:59:235107void WebContentsImpl::OnPluginCrashed(RenderFrameHostImpl* source,
5108 const base::FilePath& plugin_path,
tommyclie6633ca72014-10-31 00:40:425109 base::ProcessId plugin_pid) {
nicka0ac8382016-12-15 23:59:235110 // TODO(nick): Eliminate the |plugin_pid| parameter, which can't be trusted,
5111 // and is only used by BlinkTestController.
ericwilligersde386342016-10-19 02:35:095112 for (auto& observer : observers_)
5113 observer.PluginCrashed(plugin_path, plugin_pid);
tommyclie6633ca72014-10-31 00:40:425114}
5115
[email protected]d8415ad92012-08-23 14:40:505116void WebContentsImpl::OnRequestPpapiBrokerPermission(
nicka0ac8382016-12-15 23:59:235117 RenderViewHostImpl* source,
5118 int ppb_broker_route_id,
[email protected]d8415ad92012-08-23 14:40:505119 const GURL& url,
[email protected]2dec8ec2013-02-07 19:20:345120 const base::FilePath& plugin_path) {
Avi Drissman0a2a967d2019-04-01 19:33:525121 base::OnceCallback<void(bool)> permission_result_callback = base::BindOnce(
nicka0ac8382016-12-15 23:59:235122 &WebContentsImpl::SendPpapiBrokerPermissionResult, base::Unretained(this),
5123 source->GetProcess()->GetID(), ppb_broker_route_id);
[email protected]8c8fc292012-11-23 18:57:165124 if (!delegate_) {
Tommy Nyquist4b749d02018-03-20 21:46:295125 std::move(permission_result_callback).Run(false);
[email protected]8c8fc292012-11-23 18:57:165126 return;
[email protected]d8415ad92012-08-23 14:40:505127 }
5128
Avi Drissman0a2a967d2019-04-01 19:33:525129 delegate_->RequestPpapiBrokerPermission(
5130 this, url, plugin_path, std::move(permission_result_callback));
[email protected]d8415ad92012-08-23 14:40:505131}
5132
nicka0ac8382016-12-15 23:59:235133void WebContentsImpl::SendPpapiBrokerPermissionResult(int process_id,
5134 int ppb_broker_route_id,
5135 bool result) {
5136 RenderProcessHost* rph = RenderProcessHost::FromID(process_id);
5137 if (rph) {
5138 // TODO(nick): Convert this from ViewMsg_ to a Ppapi msg, since it
5139 // is not routed to a RenderView.
5140 rph->Send(
5141 new ViewMsg_PpapiBrokerPermissionResult(ppb_broker_route_id, result));
5142 }
[email protected]d8415ad92012-08-23 14:40:505143}
5144
fsamuel833ee7c2015-02-13 23:40:405145void WebContentsImpl::OnBrowserPluginMessage(RenderFrameHost* render_frame_host,
5146 const IPC::Message& message) {
Lei Zhang6410ec1a2019-01-31 21:38:585147 CHECK(!browser_plugin_embedder_);
fsamuel60b42282015-03-10 03:29:145148 CreateBrowserPluginEmbedderIfNecessary();
fsamuel833ee7c2015-02-13 23:40:405149 browser_plugin_embedder_->OnMessageReceived(message, render_frame_host);
[email protected]19be7a62012-10-01 23:03:375150}
brettw4b461082016-11-19 18:55:165151#endif // BUILDFLAG(ENABLE_PLUGINS)
[email protected]19be7a62012-10-01 23:03:375152
[email protected]795c28972012-12-06 06:13:395153void WebContentsImpl::OnUpdateFaviconURL(
lukasza178ff092017-06-07 23:39:505154 RenderFrameHostImpl* source,
[email protected]795c28972012-12-06 06:13:395155 const std::vector<FaviconURL>& candidates) {
lukasza178ff092017-06-07 23:39:505156 // Ignore favicons for non-main frame.
5157 if (source->GetParent()) {
5158 NOTREACHED();
5159 return;
5160 }
5161
pkotwiczf9bc20592015-04-21 18:57:065162 // We get updated favicon URLs after the page stops loading. If a cross-site
5163 // navigation occurs while a page is still loading, the initial page
5164 // may stop loading and send us updated favicon URLs after the navigation
5165 // for the new page has committed.
lukasza178ff092017-06-07 23:39:505166 if (!source->IsCurrent())
pkotwiczf9bc20592015-04-21 18:57:065167 return;
5168
ericwilligersde386342016-10-19 02:35:095169 for (auto& observer : observers_)
5170 observer.DidUpdateFaviconURL(candidates);
[email protected]795c28972012-12-06 06:13:395171}
5172
qinmin72e8bd02016-10-21 19:35:375173void WebContentsImpl::SetIsOverlayContent(bool is_overlay_content) {
5174 is_overlay_content_ = is_overlay_content;
5175}
5176
Albert J. Wongfb64e142018-10-16 01:10:455177void WebContentsImpl::DidFirstVisuallyNonEmptyPaint(
5178 RenderViewHostImpl* source) {
nicka0ac8382016-12-15 23:59:235179 // TODO(nick): When this is ported to FrameHostMsg_, we should only listen if
5180 // |source| is the main frame.
ericwilligersde386342016-10-19 02:35:095181 for (auto& observer : observers_)
5182 observer.DidFirstVisuallyNonEmptyPaint();
yusufod41c5f92015-03-06 00:14:285183
Carlos Caballero1215f882019-10-29 15:58:435184 if (source->theme_color() != last_sent_theme_color_) {
yusufod41c5f92015-03-06 00:14:285185 // Theme color should have updated by now if there was one.
ericwilligersde386342016-10-19 02:35:095186 for (auto& observer : observers_)
Carlos Caballero1215f882019-10-29 15:58:435187 observer.DidChangeThemeColor(source->theme_color());
5188 last_sent_theme_color_ = source->theme_color();
yusufod41c5f92015-03-06 00:14:285189 }
[email protected]9f268072013-11-07 00:02:155190}
[email protected]d9030b82013-07-19 08:26:065191
Adithya Srinivasan46b8a792019-02-01 14:47:235192bool WebContentsImpl::IsPortal() const {
5193 return portal();
5194}
5195
[email protected]17e286e2013-03-01 23:29:395196void WebContentsImpl::NotifyBeforeFormRepostWarningShow() {
ericwilligersde386342016-10-19 02:35:095197 for (auto& observer : observers_)
5198 observer.BeforeFormRepostWarningShow();
[email protected]17e286e2013-03-01 23:29:395199}
5200
[email protected]ec6c05f2013-10-23 18:41:575201void WebContentsImpl::ActivateAndShowRepostFormWarningDialog() {
5202 Activate();
5203 if (delegate_)
5204 delegate_->ShowRepostFormWarningDialog(this);
5205}
5206
[email protected]b4c84012014-04-28 19:51:105207bool WebContentsImpl::HasAccessedInitialDocument() {
5208 return has_accessed_initial_document_;
5209}
5210
afakhry6f0c1ec22016-07-14 13:55:135211void WebContentsImpl::UpdateTitleForEntry(NavigationEntry* entry,
[email protected]fcf75d42013-12-03 20:11:265212 const base::string16& title) {
[email protected]fcf75d42013-12-03 20:11:265213 base::string16 final_title;
Avi Drissman93002212017-09-27 03:20:525214 base::TrimWhitespace(title, base::TRIM_ALL, &final_title);
[email protected]420ae012009-04-24 05:16:325215
[email protected]987fc3a2011-05-26 14:18:095216 // If a page is created via window.open and never navigated,
5217 // there will be no navigation entry. In this situation,
[email protected]73eb2602012-02-09 19:50:555218 // |page_title_when_no_navigation_entry_| will be used for page title.
[email protected]987fc3a2011-05-26 14:18:095219 if (entry) {
[email protected]36fc0392011-12-25 03:59:515220 if (final_title == entry->GetTitle())
afakhry6f0c1ec22016-07-14 13:55:135221 return; // Nothing changed, don't bother.
[email protected]420ae012009-04-24 05:16:325222
[email protected]36fc0392011-12-25 03:59:515223 entry->SetTitle(final_title);
Avi Drissman93002212017-09-27 03:20:525224
5225 // The title for display may differ from the title just set; grab it.
5226 final_title = entry->GetTitleForDisplay();
[email protected]987fc3a2011-05-26 14:18:095227 } else {
5228 if (page_title_when_no_navigation_entry_ == final_title)
afakhry6f0c1ec22016-07-14 13:55:135229 return; // Nothing changed, don't bother.
[email protected]987fc3a2011-05-26 14:18:095230
5231 page_title_when_no_navigation_entry_ = final_title;
5232 }
[email protected]420ae012009-04-24 05:16:325233
[email protected]420ae012009-04-24 05:16:325234 // Lastly, set the title for the view.
[email protected]790e2fd2011-09-21 20:28:235235 view_->SetPageTitle(final_title);
[email protected]420ae012009-04-24 05:16:325236
ericwilligersde386342016-10-19 02:35:095237 for (auto& observer : observers_)
Avi Drissman93002212017-09-27 03:20:525238 observer.TitleWasSet(entry);
[email protected]66798902013-10-01 18:40:165239
afakhry6f0c1ec22016-07-14 13:55:135240 // Broadcast notifications when the UI should be updated.
5241 if (entry == controller_.GetEntryAtOffset(0))
5242 NotifyNavigationStateChanged(INVALIDATE_TYPE_TITLE);
[email protected]420ae012009-04-24 05:16:325243}
5244
fdegansa696e5112015-04-17 01:57:595245void WebContentsImpl::SendChangeLoadProgress() {
[email protected]960b0372014-05-19 18:01:005246 loading_last_progress_update_ = base::TimeTicks::Now();
Evan Stade9f328112019-10-23 20:49:255247 for (auto& observer : observers_)
5248 observer.LoadProgressChanged(frame_tree_.load_progress());
[email protected]960b0372014-05-19 18:01:005249}
5250
5251void WebContentsImpl::ResetLoadProgressState() {
fdegans1d16355162015-03-26 11:58:345252 frame_tree_.ResetLoadProgress();
[email protected]960b0372014-05-19 18:01:005253 loading_weak_factory_.InvalidateWeakPtrs();
5254 loading_last_progress_update_ = base::TimeTicks();
5255}
5256
clamy44e84ce2016-02-22 15:38:255257// Notifies the RenderWidgetHost instance about the fact that the page is
5258// loading, or done loading.
5259void WebContentsImpl::LoadingStateChanged(bool to_different_document,
5260 bool due_to_interstitial,
5261 LoadNotificationDetails* details) {
Nate Chapin22ea6592019-03-05 22:29:025262 if (is_being_destroyed_)
5263 return;
clamy44e84ce2016-02-22 15:38:255264 // Do not send notifications about loading changes in the FrameTree while the
5265 // interstitial page is pausing the throbber.
creisadca9862017-06-16 19:12:115266 if (ShowingInterstitialPage() && interstitial_page_->pause_throbber() &&
clamy44e84ce2016-02-22 15:38:255267 !due_to_interstitial) {
5268 return;
5269 }
5270
5271 bool is_loading = IsLoading();
5272
5273 if (!is_loading) {
5274 load_state_ = net::LoadStateWithParam(net::LOAD_STATE_IDLE,
5275 base::string16());
5276 load_state_host_.clear();
5277 upload_size_ = 0;
5278 upload_position_ = 0;
5279 }
5280
5281 GetRenderManager()->SetIsLoading(is_loading);
5282
5283 waiting_for_response_ = is_loading;
5284 is_load_to_different_document_ = to_different_document;
5285
5286 if (delegate_)
5287 delegate_->LoadingStateChanged(this, to_different_document);
5288 NotifyNavigationStateChanged(INVALIDATE_TYPE_LOAD);
5289
5290 std::string url = (details ? details->url.possibly_invalid_spec() : "NULL");
5291 if (is_loading) {
5292 TRACE_EVENT_ASYNC_BEGIN2("browser,navigation", "WebContentsImpl Loading",
5293 this, "URL", url, "Main FrameTreeNode id",
5294 GetFrameTree()->root()->frame_tree_node_id());
ericwilligersde386342016-10-19 02:35:095295 for (auto& observer : observers_)
5296 observer.DidStartLoading();
clamy44e84ce2016-02-22 15:38:255297 } else {
5298 TRACE_EVENT_ASYNC_END1("browser,navigation", "WebContentsImpl Loading",
5299 this, "URL", url);
ericwilligersde386342016-10-19 02:35:095300 for (auto& observer : observers_)
5301 observer.DidStopLoading();
clamy44e84ce2016-02-22 15:38:255302 }
5303
5304 // TODO(avi): Remove. http://crbug.com/170921
5305 int type = is_loading ? NOTIFICATION_LOAD_START : NOTIFICATION_LOAD_STOP;
5306 NotificationDetails det = NotificationService::NoDetails();
5307 if (details)
5308 det = Details<LoadNotificationDetails>(details);
5309 NotificationService::current()->Notify(
5310 type, Source<NavigationController>(&controller_), det);
5311}
5312
[email protected]02d7b6e2014-06-24 21:01:505313void WebContentsImpl::NotifyViewSwapped(RenderViewHost* old_host,
5314 RenderViewHost* new_host) {
[email protected]420ae012009-04-24 05:16:325315 // After sending out a swap notification, we need to send a disconnect
5316 // notification so that clients that pick up a pointer to |this| can NULL the
5317 // pointer. See Bug 1230284.
5318 notify_disconnection_ = true;
ericwilligersde386342016-10-19 02:35:095319 for (auto& observer : observers_)
5320 observer.RenderViewHostChanged(old_host, new_host);
[email protected]da7a7182013-09-06 08:11:115321
Jinsuk Kimdc5284c22018-07-11 02:22:065322 view_->RenderViewHostChanged(old_host, new_host);
5323
Lucas Furukawa Gadanif9ea4fc2018-08-03 23:57:135324 // If this is an inner WebContents that has swapped views, we need to reattach
5325 // it to its outer WebContents.
5326 if (node_.outer_web_contents())
5327 ReattachToOuterWebContentsFrame();
5328
[email protected]7a846df2012-09-20 19:17:395329 // Ensure that the associated embedder gets cleared after a RenderViewHost
5330 // gets swapped, so we don't reuse the same embedder next time a
5331 // RenderViewHost is attached to this WebContents.
5332 RemoveBrowserPluginEmbedder();
[email protected]420ae012009-04-24 05:16:325333}
5334
[email protected]02d7b6e2014-06-24 21:01:505335void WebContentsImpl::NotifyFrameSwapped(RenderFrameHost* old_host,
Jinsuk Kim895b2c52018-07-03 06:49:165336 RenderFrameHost* new_host,
5337 bool is_main_frame) {
Bo Liu168c8642017-08-28 18:26:025338#if defined(OS_ANDROID)
Bo Liu16dd7b8322018-05-02 21:19:505339 // Copy importance from |old_host| if |new_host| is a main frame.
5340 if (old_host && !new_host->GetParent()) {
Bo Liu7c6779e92017-08-16 02:02:285341 static_cast<RenderFrameHostImpl*>(new_host)
5342 ->GetRenderWidgetHost()
Bo Liu16dd7b8322018-05-02 21:19:505343 ->SetImportance(static_cast<RenderFrameHostImpl*>(old_host)
5344 ->GetRenderWidgetHost()
5345 ->importance());
Bo Liu7c6779e92017-08-16 02:02:285346 }
Bo Liu168c8642017-08-28 18:26:025347#endif
ericwilligersde386342016-10-19 02:35:095348 for (auto& observer : observers_)
5349 observer.RenderFrameHostChanged(old_host, new_host);
[email protected]02d7b6e2014-06-24 21:01:505350}
5351
[email protected]da7a7182013-09-06 08:11:115352// TODO(avi): Remove this entire function because this notification is already
5353// covered by two observer functions. http://crbug.com/170921
[email protected]b172aee2012-04-10 17:05:265354void WebContentsImpl::NotifyDisconnected() {
[email protected]420ae012009-04-24 05:16:325355 if (!notify_disconnection_)
5356 return;
5357
5358 notify_disconnection_ = false;
[email protected]8ff00d72012-10-23 19:12:215359 NotificationService::current()->Notify(
5360 NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
5361 Source<WebContents>(this),
5362 NotificationService::NoDetails());
[email protected]420ae012009-04-24 05:16:325363}
5364
[email protected]cbb1ef592013-06-05 19:49:465365void WebContentsImpl::NotifyNavigationEntryCommitted(
5366 const LoadCommittedDetails& load_details) {
ericwilligersde386342016-10-19 02:35:095367 for (auto& observer : observers_)
5368 observer.NavigationEntryCommitted(load_details);
[email protected]cbb1ef592013-06-05 19:49:465369}
5370
Sam McNally5c087a32017-08-25 01:46:145371void WebContentsImpl::NotifyNavigationEntryChanged(
5372 const EntryChangedDetails& change_details) {
5373 for (auto& observer : observers_)
5374 observer.NavigationEntryChanged(change_details);
5375}
5376
5377void WebContentsImpl::NotifyNavigationListPruned(
5378 const PrunedDetails& pruned_details) {
5379 for (auto& observer : observers_)
5380 observer.NavigationListPruned(pruned_details);
5381}
5382
Christian Dullweber1af31e62018-02-22 11:49:485383void WebContentsImpl::NotifyNavigationEntriesDeleted() {
5384 for (auto& observer : observers_)
5385 observer.NavigationEntriesDeleted();
5386}
5387
rockotf62002a2016-09-15 00:08:595388void WebContentsImpl::OnAssociatedInterfaceRequest(
5389 RenderFrameHost* render_frame_host,
5390 const std::string& interface_name,
5391 mojo::ScopedInterfaceEndpointHandle handle) {
5392 auto it = binding_sets_.find(interface_name);
5393 if (it != binding_sets_.end())
5394 it->second->OnRequestForFrame(render_frame_host, std::move(handle));
5395}
5396
Ben Goodger9e24929e2017-07-21 03:13:405397void WebContentsImpl::OnInterfaceRequest(
5398 RenderFrameHost* render_frame_host,
5399 const std::string& interface_name,
5400 mojo::ScopedMessagePipeHandle* interface_pipe) {
5401 for (auto& observer : observers_) {
5402 observer.OnInterfaceRequestFromFrame(render_frame_host, interface_name,
5403 interface_pipe);
5404 if (!interface_pipe->is_valid())
5405 break;
5406 }
5407}
5408
Varun Khaneja5da94302019-06-25 04:48:105409void WebContentsImpl::OnDidBlockNavigation(
5410 const GURL& blocked_url,
5411 const GURL& initiator_url,
5412 blink::NavigationBlockedReason reason) {
Nicolas Dossou-gbetebcab2472017-09-09 12:28:405413 if (delegate_)
Varun Khaneja5da94302019-06-25 04:48:105414 delegate_->OnDidBlockNavigation(this, blocked_url, initiator_url, reason);
Nicolas Dossou-gbetebcab2472017-09-09 12:28:405415}
5416
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415417const GURL& WebContentsImpl::GetMainFrameLastCommittedURL() {
[email protected]c31a84802014-04-03 15:55:495418 return GetLastCommittedURL();
5419}
5420
[email protected]b849847b2013-12-10 21:57:585421void WebContentsImpl::RenderFrameCreated(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:095422 for (auto& observer : observers_)
5423 observer.RenderFrameCreated(render_frame_host);
dmazzonif8a31042016-12-03 00:52:135424 UpdateAccessibilityModeOnFrame(render_frame_host);
clamy91b7abf2016-03-24 15:17:455425
Becca Hughesd11d6502018-07-31 17:01:285426 if (display_cutout_host_impl_)
5427 display_cutout_host_impl_->RenderFrameCreated(render_frame_host);
5428
clamy91b7abf2016-03-24 15:17:455429 if (!render_frame_host->IsRenderFrameLive() || render_frame_host->GetParent())
5430 return;
5431
5432 NavigationEntry* entry = controller_.GetPendingEntry();
5433 if (entry && entry->IsViewSourceMode()) {
5434 // Put the renderer in view source mode.
5435 render_frame_host->Send(
5436 new FrameMsg_EnableViewSourceMode(render_frame_host->GetRoutingID()));
5437 }
[email protected]b849847b2013-12-10 21:57:585438}
5439
5440void WebContentsImpl::RenderFrameDeleted(RenderFrameHost* render_frame_host) {
yilkal172da772019-11-06 22:49:075441 if (IsBeingDestroyed() && !render_frame_host->GetParent() &&
5442 first_navigation_completed_ &&
Rakina Zata Amni74627df2019-10-15 02:03:175443 !static_cast<RenderFrameHostImpl*>(render_frame_host)
5444 ->is_in_back_forward_cache()) {
yilkal796e89e2019-10-02 23:58:285445 // Main frame has been deleted because WebContents is being destroyed.
Rakina Zata Amni74627df2019-10-15 02:03:175446 // Note that we aren't recording this here when the main frame is in the
5447 // back-forward cache because that means we've actually already navigated
5448 // away from it (and we got to this point because the WebContents is
yilkal172da772019-11-06 22:49:075449 // deleted), which means |max_loaded_frame_count_| is already overwritten.
5450 // The |max_loaded_frame_count_| value will instead be recorded from within
5451 // |WebContentsImpl::DidFinishNavigation()|.
5452 RecordMaxFrameCountUMA(max_loaded_frame_count_);
yilkal796e89e2019-10-02 23:58:285453 }
5454
creis3638897452017-05-09 22:07:505455 is_notifying_observers_ = true;
ericwilligersde386342016-10-19 02:35:095456 for (auto& observer : observers_)
5457 observer.RenderFrameDeleted(render_frame_host);
creis3638897452017-05-09 22:07:505458 is_notifying_observers_ = false;
zqzhang7b6f4f02016-12-07 22:10:225459#if BUILDFLAG(ENABLE_PLUGINS)
5460 pepper_playback_observer_->RenderFrameDeleted(render_frame_host);
5461#endif
Becca Hughesfd5d8f892018-06-14 18:23:365462
Becca Hughesd11d6502018-07-31 17:01:285463 if (display_cutout_host_impl_)
5464 display_cutout_host_impl_->RenderFrameDeleted(render_frame_host);
5465
Becca Hughesfd5d8f892018-06-14 18:23:365466 // Remove any fullscreen state that the frame has stored.
5467 FullscreenStateChanged(render_frame_host, false /* is_fullscreen */);
[email protected]b849847b2013-12-10 21:57:585468}
5469
[email protected]a09d53ce2014-01-31 00:46:425470void WebContentsImpl::ShowContextMenu(RenderFrameHost* render_frame_host,
5471 const ContextMenuParams& params) {
avie9fd8722017-04-10 16:17:585472 // If a renderer fires off a second command to show a context menu before the
5473 // first context menu is closed, just ignore it. https://crbug.com/707534
ekaramadf6750aa2017-06-06 18:29:425474 if (showing_context_menu_)
avie9fd8722017-04-10 16:17:585475 return;
5476
[email protected]077e704b2014-05-23 19:24:105477 ContextMenuParams context_menu_params(params);
[email protected]a09d53ce2014-01-31 00:46:425478 // Allow WebContentsDelegates to handle the context menu operation first.
Joel Klinghed0ea22ea2019-02-20 22:04:225479 if (delegate_ &&
5480 delegate_->HandleContextMenu(render_frame_host, context_menu_params))
[email protected]a09d53ce2014-01-31 00:46:425481 return;
5482
[email protected]077e704b2014-05-23 19:24:105483 render_view_host_delegate_view_->ShowContextMenu(render_frame_host,
5484 context_menu_params);
[email protected]a09d53ce2014-01-31 00:46:425485}
5486
Avi Drissman4891b852018-09-25 18:12:585487namespace {
5488// Normalizes the line endings: \r\n -> \n, lone \r -> \n.
5489base::string16 NormalizeLineBreaks(const base::string16& source) {
5490 static const base::NoDestructor<base::string16> kReturnNewline(
5491 base::ASCIIToUTF16("\r\n"));
5492 static const base::NoDestructor<base::string16> kReturn(
5493 base::ASCIIToUTF16("\r"));
5494 static const base::NoDestructor<base::string16> kNewline(
5495 base::ASCIIToUTF16("\n"));
5496
5497 std::vector<base::StringPiece16> pieces;
5498
5499 for (const auto& rn_line : base::SplitStringPieceUsingSubstr(
5500 source, *kReturnNewline, base::KEEP_WHITESPACE,
5501 base::SPLIT_WANT_ALL)) {
5502 auto r_lines = base::SplitStringPieceUsingSubstr(
5503 rn_line, *kReturn, base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
5504 std::move(std::begin(r_lines), std::end(r_lines),
5505 std::back_inserter(pieces));
5506 }
5507
5508 return base::JoinString(pieces, *kNewline);
5509}
5510} // namespace
5511
avi777ff452017-02-09 19:04:485512void WebContentsImpl::RunJavaScriptDialog(RenderFrameHost* render_frame_host,
5513 const base::string16& message,
5514 const base::string16& default_prompt,
avi777ff452017-02-09 19:04:485515 JavaScriptDialogType dialog_type,
5516 IPC::Message* reply_msg) {
Avi Drissman2ccbb402018-03-20 21:11:365517 // Ensure that if showing a dialog is the first thing that a page does, that
5518 // the contents of the previous page aren't shown behind it. This is required
5519 // because showing a dialog freezes the renderer, so no frames will be coming
5520 // from it. https://crbug.com/823353
5521 auto* render_widget_host_impl =
5522 static_cast<RenderFrameHostImpl*>(render_frame_host)
5523 ->GetRenderWidgetHost();
5524 if (render_widget_host_impl)
5525 render_widget_host_impl->ForceFirstFrameAfterNavigationTimeout();
5526
avi0720b02e2017-06-13 03:22:135527 // Running a dialog causes an exit to webpage-initiated fullscreen.
5528 // http://crbug.com/728276
Avi Drissmand18c51972018-08-15 18:32:095529 ForSecurityDropFullscreen();
avi0720b02e2017-06-13 03:22:135530
Avi Drissmane04d3992017-10-05 15:11:365531 auto callback =
5532 base::BindOnce(&WebContentsImpl::OnDialogClosed, base::Unretained(this),
5533 render_frame_host->GetProcess()->GetID(),
5534 render_frame_host->GetRoutingID(), reply_msg);
Pavel Feldman3c1842b2017-08-02 05:00:165535
Pavel Feldman3c1842b2017-08-02 05:00:165536 std::vector<protocol::PageHandler*> page_handlers =
5537 protocol::PageHandler::EnabledForWebContents(this);
5538
Pavel Feldmanfab3cb62017-10-05 01:02:015539 if (delegate_)
5540 dialog_manager_ = delegate_->GetJavaScriptDialogManager(this);
5541
Charlie Reis96077362019-07-04 00:34:045542 // While a JS message dialog is showing, defer commits in this WebContents.
5543 javascript_dialog_navigation_deferrer_ =
5544 std::make_unique<JavaScriptDialogNavigationDeferrer>();
5545
Pavel Feldmanfab3cb62017-10-05 01:02:015546 // Suppress JavaScript dialogs when requested. Also suppress messages when
5547 // showing an interstitial as it's shown over the previous page and we don't
5548 // want the hidden page's dialogs to interfere with the interstitial.
5549 bool should_suppress = ShowingInterstitialPage() ||
5550 (delegate_ && delegate_->ShouldSuppressDialogs(this));
Pavel Feldman1c587bc52018-04-04 21:16:055551 bool has_non_devtools_handlers = delegate_ && dialog_manager_;
5552 bool has_handlers = page_handlers.size() || has_non_devtools_handlers;
Pavel Feldmanfab3cb62017-10-05 01:02:015553 bool suppress_this_message = should_suppress || !has_handlers;
5554
5555 if (suppress_this_message) {
Avi Drissmane04d3992017-10-05 15:11:365556 std::move(callback).Run(true, false, base::string16());
Pavel Feldman3c1842b2017-08-02 05:00:165557 return;
5558 }
5559
5560 scoped_refptr<CloseDialogCallbackWrapper> wrapper =
Avi Drissmane04d3992017-10-05 15:11:365561 new CloseDialogCallbackWrapper(std::move(callback));
Pavel Feldman3c1842b2017-08-02 05:00:165562
5563 is_showing_javascript_dialog_ = true;
5564
Avi Drissman4891b852018-09-25 18:12:585565 base::string16 normalized_message = NormalizeLineBreaks(message);
5566
Pavel Feldman3c1842b2017-08-02 05:00:165567 for (auto* handler : page_handlers) {
Avi Drissmane04d3992017-10-05 15:11:365568 handler->DidRunJavaScriptDialog(
Avi Drissman4891b852018-09-25 18:12:585569 render_frame_host->GetLastCommittedURL(), normalized_message,
5570 default_prompt, dialog_type, has_non_devtools_handlers,
Avi Drissmane04d3992017-10-05 15:11:365571 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:165572 }
5573
5574 if (dialog_manager_) {
[email protected]87de04b02014-04-08 22:14:495575 dialog_manager_->RunJavaScriptDialog(
Avi Drissman4891b852018-09-25 18:12:585576 this, render_frame_host, dialog_type, normalized_message,
5577 default_prompt,
Avi Drissmane04d3992017-10-05 15:11:365578 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false),
5579 &suppress_this_message);
[email protected]87de04b02014-04-08 22:14:495580 }
5581
5582 if (suppress_this_message) {
5583 // If we are suppressing messages, just reply as if the user immediately
5584 // pressed "Cancel", passing true to |dialog_was_suppressed|.
Avi Drissmane04d3992017-10-05 15:11:365585 wrapper->Run(true, false, base::string16());
[email protected]87de04b02014-04-08 22:14:495586 }
[email protected]87de04b02014-04-08 22:14:495587}
5588
5589void WebContentsImpl::RunBeforeUnloadConfirm(
[email protected]39f2f9252014-05-03 00:54:015590 RenderFrameHost* render_frame_host,
[email protected]87de04b02014-04-08 22:14:495591 bool is_reload,
5592 IPC::Message* reply_msg) {
Avi Drissman2ccbb402018-03-20 21:11:365593 // Ensure that if showing a dialog is the first thing that a page does, that
5594 // the contents of the previous page aren't shown behind it. This is required
5595 // because showing a dialog freezes the renderer, so no frames will be coming
5596 // from it. https://crbug.com/823353
5597 auto* render_widget_host_impl =
5598 static_cast<RenderFrameHostImpl*>(render_frame_host)
5599 ->GetRenderWidgetHost();
5600 if (render_widget_host_impl)
5601 render_widget_host_impl->ForceFirstFrameAfterNavigationTimeout();
5602
avi0720b02e2017-06-13 03:22:135603 // Running a dialog causes an exit to webpage-initiated fullscreen.
5604 // http://crbug.com/728276
Avi Drissmand18c51972018-08-15 18:32:095605 ForSecurityDropFullscreen();
avi0720b02e2017-06-13 03:22:135606
[email protected]39f2f9252014-05-03 00:54:015607 RenderFrameHostImpl* rfhi =
5608 static_cast<RenderFrameHostImpl*>(render_frame_host);
[email protected]87de04b02014-04-08 22:14:495609 if (delegate_)
5610 delegate_->WillRunBeforeUnloadConfirm();
5611
Avi Drissmane04d3992017-10-05 15:11:365612 auto callback =
5613 base::BindOnce(&WebContentsImpl::OnDialogClosed, base::Unretained(this),
5614 render_frame_host->GetProcess()->GetID(),
5615 render_frame_host->GetRoutingID(), reply_msg);
Pavel Feldman3c1842b2017-08-02 05:00:165616
Pavel Feldman3c1842b2017-08-02 05:00:165617 std::vector<protocol::PageHandler*> page_handlers =
5618 protocol::PageHandler::EnabledForWebContents(this);
5619
Pavel Feldmanfab3cb62017-10-05 01:02:015620 if (delegate_)
5621 dialog_manager_ = delegate_->GetJavaScriptDialogManager(this);
5622
Charlie Reis96077362019-07-04 00:34:045623 // While a JS beforeunload dialog is showing, defer commits in this
5624 // WebContents.
5625 javascript_dialog_navigation_deferrer_ =
5626 std::make_unique<JavaScriptDialogNavigationDeferrer>();
5627
Pavel Feldmanfab3cb62017-10-05 01:02:015628 bool should_suppress = ShowingInterstitialPage() || !rfhi->is_active() ||
5629 (delegate_ && delegate_->ShouldSuppressDialogs(this));
Pavel Feldman1c587bc52018-04-04 21:16:055630 bool has_non_devtools_handlers = delegate_ && dialog_manager_;
5631 bool has_handlers = page_handlers.size() || has_non_devtools_handlers;
Pavel Feldmanfab3cb62017-10-05 01:02:015632 if (should_suppress || !has_handlers) {
Avi Drissmane04d3992017-10-05 15:11:365633 std::move(callback).Run(false, true, base::string16());
[email protected]87de04b02014-04-08 22:14:495634 return;
5635 }
5636
5637 is_showing_before_unload_dialog_ = true;
Pavel Feldman3c1842b2017-08-02 05:00:165638
5639 scoped_refptr<CloseDialogCallbackWrapper> wrapper =
Avi Drissmane04d3992017-10-05 15:11:365640 new CloseDialogCallbackWrapper(std::move(callback));
Pavel Feldman3c1842b2017-08-02 05:00:165641
5642 GURL frame_url = rfhi->GetLastCommittedURL();
5643 for (auto* handler : page_handlers) {
Avi Drissmane04d3992017-10-05 15:11:365644 handler->DidRunBeforeUnloadConfirm(
Pavel Feldman1c587bc52018-04-04 21:16:055645 frame_url, has_non_devtools_handlers,
Avi Drissmane04d3992017-10-05 15:11:365646 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:165647 }
5648
5649 if (dialog_manager_) {
Avi Drissmane04d3992017-10-05 15:11:365650 dialog_manager_->RunBeforeUnloadDialog(
Avi Drissmanff9ed752017-11-28 21:18:125651 this, render_frame_host, is_reload,
Avi Drissmane04d3992017-10-05 15:11:365652 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:165653 }
[email protected]87de04b02014-04-08 22:14:495654}
5655
Kent Tamurac260c9a2018-09-14 09:10:565656void WebContentsImpl::RunFileChooser(
5657 RenderFrameHost* render_frame_host,
Kent Tamura512a27e2018-10-04 00:49:325658 std::unique_ptr<content::FileSelectListener> listener,
Kent Tamurac260c9a2018-09-14 09:10:565659 const blink::mojom::FileChooserParams& params) {
Avi Drissman3d41e7712018-08-27 21:18:085660 // Any explicit focusing of another window while this WebContents is in
5661 // fullscreen can be used to confuse the user, so drop fullscreen.
5662 ForSecurityDropFullscreen();
5663
Andrey Lushnikov81b992e2019-06-27 23:27:215664 RenderFrameHostImpl* rfhi =
5665 static_cast<RenderFrameHostImpl*>(render_frame_host);
5666 if (devtools_instrumentation::InterceptFileChooser(rfhi, &listener, params))
5667 return;
5668
naskoada75b22016-06-11 16:09:465669 if (delegate_)
Kent Tamura512a27e2018-10-04 00:49:325670 delegate_->RunFileChooser(render_frame_host, std::move(listener), params);
5671 else
5672 listener->FileSelectionCanceled();
naskoada75b22016-06-11 16:09:465673}
5674
[email protected]a86c0e962013-12-17 17:10:395675WebContents* WebContentsImpl::GetAsWebContents() {
5676 return this;
5677}
5678
mcnee336ea2c2017-05-23 22:50:595679#if !defined(OS_ANDROID)
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415680double WebContentsImpl::GetPendingPageZoomLevel() {
wjmaclean64951902016-04-29 20:59:125681 NavigationEntry* pending_entry = GetController().GetPendingEntry();
5682 if (!pending_entry)
5683 return HostZoomMap::GetZoomLevel(this);
5684
5685 GURL url = pending_entry->GetURL();
5686 return HostZoomMap::GetForWebContents(this)->GetZoomLevelForHostAndScheme(
5687 url.scheme(), net::GetHostOrSpecFromURL(url));
5688}
mcnee336ea2c2017-05-23 22:50:595689#endif // !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:125690
qinmin72e8bd02016-10-21 19:35:375691bool WebContentsImpl::HideDownloadUI() const {
5692 return is_overlay_content_;
5693}
5694
mlamouri5cd9ae82017-02-18 11:05:095695bool WebContentsImpl::HasPersistentVideo() const {
5696 return has_persistent_video_;
5697}
5698
Ian Vollick5d5c37f2019-06-19 22:50:575699bool WebContentsImpl::IsSpatialNavigationDisabled() const {
5700 return is_spatial_navigation_disabled_;
5701}
5702
Albert J. Wong65fe64d2019-09-20 02:48:145703RenderFrameHostImpl* WebContentsImpl::GetPendingMainFrame() {
clamy610c63b32017-12-22 15:05:185704 return GetRenderManager()->speculative_frame_host();
Alex Moshchuk27caae82017-09-11 23:11:185705}
5706
mlamourie52c1b542017-02-23 14:57:505707bool WebContentsImpl::HasActiveEffectivelyFullscreenVideo() const {
5708 return media_web_contents_observer_->HasActiveEffectivelyFullscreenVideo();
5709}
5710
François Beaufortad6c5232018-02-26 11:00:445711bool WebContentsImpl::IsPictureInPictureAllowedForFullscreenVideo() const {
5712 return media_web_contents_observer_
5713 ->IsPictureInPictureAllowedForFullscreenVideo();
5714}
5715
ekaramada110f642016-12-21 19:47:285716bool WebContentsImpl::IsFocusedElementEditable() {
5717 RenderFrameHostImpl* frame = GetFocusedFrame();
5718 return frame && frame->has_focused_editable_element();
5719}
5720
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415721bool WebContentsImpl::IsShowingContextMenu() {
ekaramadf6750aa2017-06-06 18:29:425722 return showing_context_menu_;
5723}
5724
5725void WebContentsImpl::SetShowingContextMenu(bool showing) {
5726 DCHECK_NE(showing_context_menu_, showing);
5727 showing_context_menu_ = showing;
5728
5729 if (auto* view = GetRenderWidgetHostView()) {
5730 // Notify the main frame's RWHV to run the platform-specific code, if any.
5731 static_cast<RenderWidgetHostViewBase*>(view)->SetShowingContextMenu(
5732 showing);
5733 }
5734}
5735
ekaramada110f642016-12-21 19:47:285736void WebContentsImpl::ClearFocusedElement() {
5737 if (auto* frame = GetFocusedFrame())
5738 frame->ClearFocusedElement();
5739}
5740
[email protected]7912e822014-04-16 02:37:035741bool WebContentsImpl::IsNeverVisible() {
5742 if (!delegate_)
5743 return false;
5744 return delegate_->IsNeverVisible(this);
5745}
5746
[email protected]5a3bdf52012-05-24 15:12:575747RenderViewHostDelegateView* WebContentsImpl::GetDelegateView() {
5748 return render_view_host_delegate_view_;
[email protected]420ae012009-04-24 05:16:325749}
5750
Leon Hanc819dc62019-01-28 04:30:195751blink::mojom::RendererPreferences WebContentsImpl::GetRendererPrefs(
[email protected]8ff00d72012-10-23 19:12:215752 BrowserContext* browser_context) const {
[email protected]840b1512009-07-21 16:53:465753 return renderer_preferences_;
[email protected]80d96fa2009-06-10 22:34:515754}
5755
[email protected]7a846df2012-09-20 19:17:395756void WebContentsImpl::RemoveBrowserPluginEmbedder() {
Lei Zhang6410ec1a2019-01-31 21:38:585757 browser_plugin_embedder_.reset();
[email protected]7a846df2012-09-20 19:17:395758}
5759
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165760RenderFrameHostImpl* WebContentsImpl::GetOuterWebContentsFrame() {
5761 if (GetOuterDelegateFrameTreeNodeId() ==
5762 FrameTreeNode::kFrameTreeNodeInvalidId) {
5763 return nullptr;
5764 }
5765
5766 FrameTreeNode* outer_node =
5767 FrameTreeNode::GloballyFindByID(GetOuterDelegateFrameTreeNodeId());
5768 // The outer node should be in the outer WebContents.
5769 DCHECK_EQ(outer_node->frame_tree(), GetOuterWebContents()->GetFrameTree());
5770 return outer_node->parent()->current_frame_host();
5771}
5772
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415773WebContentsImpl* WebContentsImpl::GetOuterWebContents() {
lfg601233692017-03-06 22:45:445774 if (GuestMode::IsCrossProcessFrameGuest(this))
5775 return node_.outer_web_contents();
ekaramad1beabecc2016-09-23 20:18:175776
5777 if (browser_plugin_guest_)
5778 return browser_plugin_guest_->embedder_web_contents();
5779
Lucas Furukawa Gadani105de1e812018-05-31 19:38:395780 return node_.outer_web_contents();
avallee0206f782016-07-28 18:55:335781}
5782
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165783std::vector<WebContents*> WebContentsImpl::GetInnerWebContents() {
5784 std::vector<WebContents*> all_inner_contents;
5785 if (browser_plugin_embedder_) {
Sean Topping7df73952019-05-16 17:21:165786 BrowserPluginGuestManager* guest_manager =
5787 GetBrowserContext()->GetGuestManager();
5788 if (guest_manager) {
5789 guest_manager->ForEachGuest(
5790 this,
5791 base::BindRepeating(&GetInnerWebContentsHelper, &all_inner_contents));
5792 }
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165793 }
5794 const auto& inner_contents = node_.GetInnerWebContents();
5795 all_inner_contents.insert(all_inner_contents.end(), inner_contents.begin(),
5796 inner_contents.end());
5797 return all_inner_contents;
5798}
5799
avallee0206f782016-07-28 18:55:335800WebContentsImpl* WebContentsImpl::GetFocusedWebContents() {
lfg601233692017-03-06 22:45:445801 return GetOutermostWebContents()->node_.focused_web_contents();
avallee0206f782016-07-28 18:55:335802}
5803
avallee9993fca2016-11-17 06:16:505804bool WebContentsImpl::ContainsOrIsFocusedWebContents() {
5805 for (WebContentsImpl* focused_contents = GetFocusedWebContents();
5806 focused_contents;
5807 focused_contents = focused_contents->GetOuterWebContents()) {
5808 if (focused_contents == this)
5809 return true;
5810 }
5811
5812 return false;
5813}
5814
avallee0206f782016-07-28 18:55:335815WebContentsImpl* WebContentsImpl::GetOutermostWebContents() {
5816 WebContentsImpl* root = this;
5817 while (root->GetOuterWebContents())
5818 root = root->GetOuterWebContents();
5819 return root;
5820}
5821
avalleed68cdd12017-06-21 22:07:275822void WebContentsImpl::FocusOuterAttachmentFrameChain() {
5823 WebContentsImpl* outer_contents = GetOuterWebContents();
5824 if (!outer_contents)
5825 return;
5826
5827 FrameTreeNode* outer_node =
5828 FrameTreeNode::GloballyFindByID(GetOuterDelegateFrameTreeNodeId());
5829 outer_contents->frame_tree_.SetFocusedFrame(outer_node, nullptr);
5830
5831 // For a browser initiated focus change, let embedding renderer know of the
5832 // change. Otherwise, if the currently focused element is just across a
5833 // process boundary in focus order, it will not be possible to move across
5834 // that boundary. This is because the target element will already be focused
5835 // (that renderer was not notified) and drop the event.
5836 if (GetRenderManager()->GetProxyToOuterDelegate())
5837 GetRenderManager()->GetProxyToOuterDelegate()->SetFocusedFrame();
5838
5839 outer_contents->FocusOuterAttachmentFrameChain();
5840}
5841
Sean Toppingbbc4a2bd2019-01-30 02:16:145842void WebContentsImpl::InnerWebContentsCreated(WebContents* inner_web_contents) {
Shivani Sharma985474f2019-05-23 21:36:475843 had_inner_webcontents_ = true;
Sean Toppingbbc4a2bd2019-01-30 02:16:145844 for (auto& observer : observers_)
5845 observer.InnerWebContentsCreated(inner_web_contents);
5846}
5847
[email protected]b172aee2012-04-10 17:05:265848void WebContentsImpl::RenderViewCreated(RenderViewHost* render_view_host) {
[email protected]86f98a22013-03-20 14:35:005849 if (delegate_)
[email protected]e85165c642014-06-10 14:34:315850 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]a6b73c62013-02-11 23:05:085851
[email protected]8ff00d72012-10-23 19:12:215852 NotificationService::current()->Notify(
5853 NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED,
5854 Source<WebContents>(this),
5855 Details<RenderViewHost>(render_view_host));
[email protected]420ae012009-04-24 05:16:325856
[email protected]60780f412013-02-25 16:34:105857 view_->RenderViewCreated(render_view_host);
[email protected]11f764bb2011-05-25 19:45:265858
ericwilligersde386342016-10-19 02:35:095859 for (auto& observer : observers_)
5860 observer.RenderViewCreated(render_view_host);
Joel Einbinder848001c2017-09-19 21:39:315861 if (delegate_)
5862 RenderFrameDevToolsAgentHost::WebContentsCreated(this);
[email protected]420ae012009-04-24 05:16:325863}
5864
[email protected]b172aee2012-04-10 17:05:265865void WebContentsImpl::RenderViewReady(RenderViewHost* rvh) {
[email protected]151a63d2011-12-20 22:32:525866 if (rvh != GetRenderViewHost()) {
[email protected]420ae012009-04-24 05:16:325867 // Don't notify the world, since this came from a renderer in the
5868 // background.
5869 return;
5870 }
5871
dmazzoni62111452017-04-28 23:46:555872 RenderWidgetHostViewBase* rwhv =
5873 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
5874 if (rwhv)
5875 rwhv->SetMainFrameAXTreeID(GetMainFrame()->GetAXTreeID());
5876
[email protected]da7a7182013-09-06 08:11:115877 notify_disconnection_ = true;
[email protected]da7a7182013-09-06 08:11:115878
[email protected]be1f56ab2011-12-22 06:55:315879 bool was_crashed = IsCrashed();
[email protected]443b80e2010-12-14 00:42:235880 SetIsCrashed(base::TERMINATION_STATUS_STILL_RUNNING, 0);
[email protected]9d8a4642009-07-29 17:25:305881
5882 // Restore the focus to the tab (otherwise the focus will be on the top
5883 // window).
[email protected]484ae5912010-09-29 19:16:145884 if (was_crashed && !FocusLocationBarByDefault() &&
5885 (!delegate_ || delegate_->ShouldFocusPageAfterCrash())) {
[email protected]f3615f02013-02-26 06:09:065886 view_->Focus();
[email protected]484ae5912010-09-29 19:16:145887 }
[email protected]32ded2212011-11-10 18:51:435888
ericwilligersde386342016-10-19 02:35:095889 for (auto& observer : observers_)
5890 observer.RenderViewReady();
Jinsuk Kim895b2c52018-07-03 06:49:165891
5892 view_->RenderViewReady();
[email protected]420ae012009-04-24 05:16:325893}
5894
[email protected]ec6a7eb2013-04-22 17:34:225895void WebContentsImpl::RenderViewTerminated(RenderViewHost* rvh,
5896 base::TerminationStatus status,
5897 int error_code) {
[email protected]151a63d2011-12-20 22:32:525898 if (rvh != GetRenderViewHost()) {
[email protected]420ae012009-04-24 05:16:325899 // The pending page's RenderViewHost is gone.
5900 return;
5901 }
5902
[email protected]2fcdcc32014-03-05 02:14:075903 // Ensure fullscreen mode is exited in the |delegate_| since a crashed
5904 // renderer may not have made a clean exit.
alexmos5dd617d2016-06-07 04:21:155905 if (IsFullscreenForCurrentTab())
bokanece34a82016-01-28 19:49:465906 ExitFullscreenMode(false);
[email protected]2fcdcc32014-03-05 02:14:075907
Jennifer Apacibleb4b972a2018-06-07 04:41:025908 // Ensure any video in Picture-in-Picture is exited in the |delegate_| since
5909 // a crashed renderer may not have made a clean exit.
5910 if (HasPictureInPictureVideo())
5911 ExitPictureInPicture();
5912
[email protected]698191dc2014-02-25 01:06:135913 // Cancel any visible dialogs so they are not left dangling over the sad tab.
creis89a0f782015-05-27 16:13:175914 CancelActiveAndPendingDialogs();
[email protected]698191dc2014-02-25 01:06:135915
dalecurtis3d1e1302017-02-20 22:33:255916 audio_stream_monitor_.RenderProcessGone(rvh->GetProcess()->GetID());
5917
[email protected]960b0372014-05-19 18:01:005918 // Reset the loading progress. TODO(avi): What does it mean to have a
5919 // "renderer crash" when there is more than one renderer process serving a
5920 // webpage? Once this function is called at a more granular frame level, we
5921 // probably will need to more granularly reset the state here.
5922 ResetLoadProgressState();
clamy44e84ce2016-02-22 15:38:255923 NotifyDisconnected();
5924 SetIsCrashed(status, error_code);
[email protected]960b0372014-05-19 18:01:005925
ericwilligersde386342016-10-19 02:35:095926 for (auto& observer : observers_)
5927 observer.RenderProcessGone(GetCrashedStatus());
[email protected]420ae012009-04-24 05:16:325928}
5929
[email protected]b172aee2012-04-10 17:05:265930void WebContentsImpl::RenderViewDeleted(RenderViewHost* rvh) {
ericwilligersde386342016-10-19 02:35:095931 for (auto& observer : observers_)
5932 observer.RenderViewDeleted(rvh);
[email protected]2e4633c2009-07-09 16:58:065933}
5934
sky8b00392d2015-01-10 00:30:285935void WebContentsImpl::UpdateTargetURL(RenderViewHost* render_view_host,
5936 const GURL& url) {
5937 if (fullscreen_widget_routing_id_ != MSG_ROUTING_NONE) {
Lukasz Anforowiczfd707142018-02-07 19:46:135938 // If we're in flash fullscreen (i.e. Pepper plugin fullscreen) only update
5939 // the url if it's from the fullscreen renderer.
sky8b00392d2015-01-10 00:30:285940 RenderWidgetHostView* fs = GetFullscreenRenderWidgetHostView();
avif9ab5d942015-10-15 14:05:445941 if (fs && fs->GetRenderWidgetHost() != render_view_host->GetWidget())
sky8b00392d2015-01-10 00:30:285942 return;
5943 }
Lukasz Anforowiczfd707142018-02-07 19:46:135944
5945 // In case of racey updates from multiple RenderViewHosts, the last URL should
5946 // be shown - see also some discussion in https://crbug.com/807776.
5947 if (!url.is_valid() && render_view_host != view_that_set_last_target_url_)
5948 return;
5949 view_that_set_last_target_url_ = url.is_valid() ? render_view_host : nullptr;
5950
[email protected]6934a702011-12-20 00:04:515951 if (delegate_)
avi450ce00e2014-09-24 01:58:525952 delegate_->UpdateTargetURL(this, url);
[email protected]420ae012009-04-24 05:16:325953}
5954
Lukasz Anforowiczfd707142018-02-07 19:46:135955void WebContentsImpl::ClearTargetURL() {
5956 view_that_set_last_target_url_ = nullptr;
5957 if (delegate_)
5958 delegate_->UpdateTargetURL(this, GURL());
5959}
5960
[email protected]b172aee2012-04-10 17:05:265961void WebContentsImpl::Close(RenderViewHost* rvh) {
[email protected]60780f412013-02-25 16:34:105962#if defined(OS_MACOSX)
[email protected]07707302009-11-06 00:50:295963 // The UI may be in an event-tracking loop, such as between the
5964 // mouse-down and mouse-up in text selection or a button click.
5965 // Defer the close until after tracking is complete, so that we
5966 // don't free objects out from under the UI.
[email protected]07707302009-11-06 00:50:295967 // TODO(shess): This could get more fine-grained. For instance,
5968 // closing a tab in another window while selecting text in the
5969 // current window's Omnibox should be just fine.
Christopher Cameron9ae31e0d2019-03-01 20:01:195970 if (view_->CloseTabAfterEventTrackingIfNeeded())
[email protected]07707302009-11-06 00:50:295971 return;
[email protected]60780f412013-02-25 16:34:105972#endif
[email protected]07707302009-11-06 00:50:295973
[email protected]420ae012009-04-24 05:16:325974 // Ignore this if it comes from a RenderViewHost that we aren't showing.
[email protected]151a63d2011-12-20 22:32:525975 if (delegate_ && rvh == GetRenderViewHost())
[email protected]6934a702011-12-20 00:04:515976 delegate_->CloseContents(this);
[email protected]420ae012009-04-24 05:16:325977}
5978
Avi Drissman014dec72018-06-07 02:34:015979void WebContentsImpl::RequestSetBounds(const gfx::Rect& new_bounds) {
5980 if (delegate_)
5981 delegate_->SetContentsBounds(this, new_bounds);
[email protected]420ae012009-04-24 05:16:325982}
5983
fdegansa696e5112015-04-17 01:57:595984void WebContentsImpl::DidStartLoading(FrameTreeNode* frame_tree_node,
[email protected]e3b10d12014-03-28 16:06:095985 bool to_different_document) {
Evan Stadec3b26022017-07-14 19:50:245986 LoadingStateChanged(frame_tree_node->IsMainFrame() && to_different_document,
5987 false, nullptr);
dmazzonibf8cec42015-02-08 08:28:085988
Xiyuan Xia2a66b112018-12-06 15:52:165989 // Reset the focus state from DidStartNavigation to false if a new load starts
5990 // afterward, in case loading logic triggers a FocusLocationBarByDefault call.
5991 should_focus_location_bar_by_default_ = false;
5992
dmazzonibf8cec42015-02-08 08:28:085993 // Notify accessibility that the user is navigating away from the
5994 // current document.
Dominic Farolinof87ec2a2019-07-04 09:18:095995 // TODO(domfarolino, dmazzoni): Do this using WebContentsObserver. See
5996 // https://crbug.com/981271.
dmazzonibf8cec42015-02-08 08:28:085997 BrowserAccessibilityManager* manager =
fdegansa696e5112015-04-17 01:57:595998 frame_tree_node->current_frame_host()->browser_accessibility_manager();
dmazzonibf8cec42015-02-08 08:28:085999 if (manager)
6000 manager->UserIsNavigatingAway();
[email protected]420ae012009-04-24 05:16:326001}
6002
fdegansc73eec22015-03-19 14:47:546003void WebContentsImpl::DidStopLoading() {
dcheng59716272016-04-09 05:19:086004 std::unique_ptr<LoadNotificationDetails> details;
[email protected]420ae012009-04-24 05:16:326005
[email protected]9595fd82013-04-19 21:28:496006 // Use the last committed entry rather than the active one, in case a
6007 // pending entry has been created.
6008 NavigationEntry* entry = controller_.GetLastCommittedEntry();
[email protected]3691e5cf2014-01-22 10:16:206009 Navigator* navigator = frame_tree_.root()->navigator();
[email protected]9595fd82013-04-19 21:28:496010
[email protected]420ae012009-04-24 05:16:326011 // An entry may not exist for a stop when loading an initial blank page or
6012 // if an iframe injected by script into a blank page finishes loading.
6013 if (entry) {
[email protected]3691e5cf2014-01-22 10:16:206014 base::TimeDelta elapsed =
6015 base::TimeTicks::Now() - navigator->GetCurrentLoadStart();
[email protected]420ae012009-04-24 05:16:326016
6017 details.reset(new LoadNotificationDetails(
[email protected]36fc0392011-12-25 03:59:516018 entry->GetVirtualURL(),
[email protected]420ae012009-04-24 05:16:326019 elapsed,
6020 &controller_,
6021 controller_.GetCurrentEntryIndex()));
6022 }
6023
clamy44e84ce2016-02-22 15:38:256024 LoadingStateChanged(true, false, details.get());
[email protected]420ae012009-04-24 05:16:326025}
6026
fdegansa696e5112015-04-17 01:57:596027void WebContentsImpl::DidChangeLoadProgress() {
Nate Chapin22ea6592019-03-05 22:29:026028 if (is_being_destroyed_)
6029 return;
fdegansa696e5112015-04-17 01:57:596030 double load_progress = frame_tree_.load_progress();
6031
6032 // The delegate is notified immediately for the first and last updates. Also,
6033 // since the message loop may be pretty busy when a page is loaded, it might
6034 // not execute a posted task in a timely manner so the progress report is sent
6035 // immediately if enough time has passed.
6036 base::TimeDelta min_delay =
6037 base::TimeDelta::FromMilliseconds(kMinimumDelayBetweenLoadingUpdatesMS);
6038 bool delay_elapsed = loading_last_progress_update_.is_null() ||
6039 base::TimeTicks::Now() - loading_last_progress_update_ > min_delay;
6040
6041 if (load_progress == 0.0 || load_progress == 1.0 || delay_elapsed) {
6042 // If there is a pending task to send progress, it is now obsolete.
6043 loading_weak_factory_.InvalidateWeakPtrs();
6044
6045 // Notify the load progress change.
6046 SendChangeLoadProgress();
6047
6048 // Clean-up the states if needed.
6049 if (load_progress == 1.0)
6050 ResetLoadProgressState();
6051 return;
6052 }
6053
6054 if (loading_weak_factory_.HasWeakPtrs())
6055 return;
6056
skyostil95082a62015-06-05 19:53:076057 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
tzike2aca992017-09-05 08:50:546058 FROM_HERE,
6059 base::BindOnce(&WebContentsImpl::SendChangeLoadProgress,
6060 loading_weak_factory_.GetWeakPtr()),
fdegansa696e5112015-04-17 01:57:596061 min_delay);
6062}
6063
avid6d88b912017-01-13 00:16:006064std::vector<std::unique_ptr<NavigationThrottle>>
6065WebContentsImpl::CreateThrottlesForNavigation(
clamycbf524d42016-09-27 12:48:356066 NavigationHandle* navigation_handle) {
Charlie Reis96077362019-07-04 00:34:046067 auto throttles = GetContentClient()->browser()->CreateThrottlesForNavigation(
clamycbf524d42016-09-27 12:48:356068 navigation_handle);
Charlie Reis96077362019-07-04 00:34:046069
6070 // This is not a normal place to be adding a throttle. However, in the case
6071 // javascript dialogs, related logic is present in the web_contents/ layer,
6072 // and the purpose of the throttle is to ensure that navigation commits are
6073 // deferred for the entire WebContents. Most throttles are either added by
6074 // the embederrer outside of content/, or are per-frame and added by
6075 // NavigationThrottleRunner.
6076 std::unique_ptr<content::NavigationThrottle> dialog_throttle =
6077 JavaScriptDialogNavigationThrottle::MaybeCreateThrottleFor(
6078 navigation_handle);
6079 if (dialog_throttle)
6080 throttles.push_back(std::move(dialog_throttle));
6081
6082 return throttles;
clamycbf524d42016-09-27 12:48:356083}
6084
clamy1e5574e2016-09-29 16:48:446085std::unique_ptr<NavigationUIData> WebContentsImpl::GetNavigationUIData(
6086 NavigationHandle* navigation_handle) {
clamy1e5574e2016-09-29 16:48:446087 return GetContentClient()->browser()->GetNavigationUIData(navigation_handle);
6088}
6089
pdr15f5b5b2017-06-20 00:58:006090void WebContentsImpl::DidCancelLoading() {
6091 controller_.DiscardNonCommittedEntries();
6092
6093 // Update the URL display.
6094 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
6095}
6096
[email protected]59167c22013-06-03 18:07:326097void WebContentsImpl::DidAccessInitialDocument() {
[email protected]b4c84012014-04-28 19:51:106098 has_accessed_initial_document_ = true;
6099
[email protected]d1371bf8e2014-04-19 03:26:246100 // We may have left a failed browser-initiated navigation in the address bar
6101 // to let the user edit it and try again. Clear it now that content might
6102 // show up underneath it.
6103 if (!IsLoading() && controller_.GetPendingEntry())
avi45a72532015-04-07 21:01:456104 controller_.DiscardPendingEntry(false);
[email protected]d1371bf8e2014-04-19 03:26:246105
[email protected]59167c22013-06-03 18:07:326106 // Update the URL display.
thestigc4cac8f2014-09-04 21:17:506107 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
[email protected]59167c22013-06-03 18:07:326108}
6109
alexmosbe2f4c32015-03-10 02:30:236110void WebContentsImpl::DidChangeName(RenderFrameHost* render_frame_host,
6111 const std::string& name) {
ericwilligersde386342016-10-19 02:35:096112 for (auto& observer : observers_)
6113 observer.FrameNameChanged(render_frame_host, name);
alexmosbe2f4c32015-03-10 02:30:236114}
6115
John Delaneyedd8d6c2019-01-25 00:23:576116void WebContentsImpl::DidReceiveFirstUserActivation(
6117 RenderFrameHost* render_frame_host) {
6118 for (auto& observer : observers_)
6119 observer.FrameReceivedFirstUserActivation(render_frame_host);
6120}
6121
John Delaney0146a742019-01-25 19:25:286122void WebContentsImpl::DidChangeDisplayState(RenderFrameHost* render_frame_host,
6123 bool is_display_none) {
6124 for (auto& observer : observers_)
6125 observer.FrameDisplayStateChanged(render_frame_host, is_display_none);
6126}
6127
6128void WebContentsImpl::FrameSizeChanged(RenderFrameHost* render_frame_host,
6129 const gfx::Size& frame_size) {
6130 for (auto& observer : observers_)
6131 observer.FrameSizeChanged(render_frame_host, frame_size);
6132}
6133
[email protected]39f2f9252014-05-03 00:54:016134void WebContentsImpl::DocumentOnLoadCompleted(
[email protected]50279492014-05-05 23:24:296135 RenderFrameHost* render_frame_host) {
falken52a56e32016-12-08 05:02:406136 ShowInsecureLocalhostWarningIfNeeded();
6137
Alexander Timindd0fa0c52019-11-06 13:03:376138 GetRenderViewHost()->DocumentOnLoadCompletedInMainFrame();
6139
creis97867aa2017-02-17 18:39:456140 is_notifying_observers_ = true;
ericwilligersde386342016-10-19 02:35:096141 for (auto& observer : observers_)
6142 observer.DocumentOnLoadCompletedInMainFrame();
creis97867aa2017-02-17 18:39:456143 is_notifying_observers_ = false;
[email protected]6578fef2013-10-14 02:35:096144
6145 // TODO(avi): Remove. http://crbug.com/170921
[email protected]8ff00d72012-10-23 19:12:216146 NotificationService::current()->Notify(
6147 NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
6148 Source<WebContents>(this),
[email protected]50279492014-05-05 23:24:296149 NotificationService::NoDetails());
[email protected]25497492010-09-11 15:15:086150}
6151
creis8eb8ef22015-11-04 22:51:386152void WebContentsImpl::UpdateStateForFrame(RenderFrameHost* render_frame_host,
6153 const PageState& page_state) {
creis8eb8ef22015-11-04 22:51:386154 // The state update affects the last NavigationEntry associated with the given
6155 // |render_frame_host|. This may not be the last committed NavigationEntry (as
6156 // in the case of an UpdateState from a frame being swapped out). We track
6157 // which entry this is in the RenderFrameHost's nav_entry_id.
6158 RenderFrameHostImpl* rfhi =
6159 static_cast<RenderFrameHostImpl*>(render_frame_host);
6160 NavigationEntryImpl* entry =
6161 controller_.GetEntryWithUniqueID(rfhi->nav_entry_id());
6162 if (!entry)
6163 return;
6164
6165 FrameNavigationEntry* frame_entry =
6166 entry->GetFrameEntry(rfhi->frame_tree_node());
6167 if (!frame_entry)
6168 return;
6169
creisd06a9422015-11-11 03:08:456170 // The SiteInstance might not match if we do a cross-process navigation with
6171 // replacement (e.g., auto-subframe), in which case the swap out of the old
6172 // RenderFrameHost runs in the background after the old FrameNavigationEntry
6173 // has already been replaced and destroyed.
6174 if (frame_entry->site_instance() != rfhi->GetSiteInstance())
6175 return;
6176
creis8eb8ef22015-11-04 22:51:386177 if (page_state == frame_entry->page_state())
6178 return; // Nothing to update.
6179
creis0cade2e2017-02-28 06:37:476180 DCHECK(page_state.IsValid()) << "Shouldn't set an empty PageState.";
nasko34634672016-07-29 18:46:066181
6182 // The document_sequence_number and item_sequence_number recorded in the
6183 // FrameNavigationEntry should not differ from the one coming with the update,
6184 // since it must come from the same document. Do not update it if a difference
6185 // is detected, as this indicates that |frame_entry| is not the correct one.
6186 ExplodedPageState exploded_state;
6187 if (!DecodePageState(page_state.ToEncodedData(), &exploded_state))
6188 return;
6189
6190 if (exploded_state.top.document_sequence_number !=
6191 frame_entry->document_sequence_number() ||
6192 exploded_state.top.item_sequence_number !=
6193 frame_entry->item_sequence_number()) {
6194 return;
6195 }
6196
nasko04a322f25a2016-09-01 00:00:346197 frame_entry->SetPageState(page_state);
creis8eb8ef22015-11-04 22:51:386198 controller_.NotifyEntryChanged(entry);
6199}
6200
[email protected]ef3adfc2014-05-11 00:04:546201void WebContentsImpl::UpdateTitle(RenderFrameHost* render_frame_host,
[email protected]ef3adfc2014-05-11 00:04:546202 const base::string16& title,
6203 base::i18n::TextDirection title_direction) {
[email protected]ef3adfc2014-05-11 00:04:546204 // Try to find the navigation entry, which might not be the current one.
avi286019ce2015-07-29 01:26:586205 // For example, it might be from a recently swapped out RFH.
avi1edc8552016-10-13 21:37:166206 NavigationEntryImpl* entry = controller_.GetEntryWithUniqueID(
creisad8c31a2016-05-24 17:07:046207 static_cast<RenderFrameHostImpl*>(render_frame_host)->nav_entry_id());
[email protected]ef3adfc2014-05-11 00:04:546208
6209 // We can handle title updates when we don't have an entry in
6210 // UpdateTitleForEntry, but only if the update is from the current RVH.
6211 // TODO(avi): Change to make decisions based on the RenderFrameHost.
avi286019ce2015-07-29 01:26:586212 if (!entry && render_frame_host != GetMainFrame())
[email protected]ef3adfc2014-05-11 00:04:546213 return;
6214
6215 // TODO(evan): make use of title_direction.
6216 // http://code.google.com/p/chromium/issues/detail?id=27094
afakhry6f0c1ec22016-07-14 13:55:136217 UpdateTitleForEntry(entry, title);
[email protected]ef3adfc2014-05-11 00:04:546218}
6219
[email protected]39f2f9252014-05-03 00:54:016220void WebContentsImpl::DocumentAvailableInMainFrame(
6221 RenderViewHost* render_view_host) {
ericwilligersde386342016-10-19 02:35:096222 for (auto& observer : observers_)
6223 observer.DocumentAvailableInMainFrame();
[email protected]39f2f9252014-05-03 00:54:016224}
naskoc0fceff2015-04-30 15:53:526225
[email protected]e1c3a552012-05-04 20:51:326226void WebContentsImpl::RouteCloseEvent(RenderViewHost* rvh) {
6227 // Tell the active RenderViewHost to run unload handlers and close, as long
6228 // as the request came from a RenderViewHost in the same BrowsingInstance.
6229 // In most cases, we receive this from a swapped out RenderViewHost.
6230 // It is possible to receive it from one that has just been swapped in,
6231 // in which case we might as well deliver the message anyway.
6232 if (rvh->GetSiteInstance()->IsRelatedSiteInstance(GetSiteInstance()))
naskoc0fceff2015-04-30 15:53:526233 ClosePage();
[email protected]e1c3a552012-05-04 20:51:326234}
6235
alexmose7da5a12015-04-09 02:22:166236bool WebContentsImpl::ShouldRouteMessageEvent(
6237 RenderFrameHost* target_rfh,
6238 SiteInstance* source_site_instance) const {
6239 // Allow the message if this WebContents is dedicated to a browser plugin
6240 // guest.
[email protected]0eba810b2012-10-18 03:19:366241 // Note: This check means that an embedder could theoretically receive a
6242 // postMessage from anyone (not just its own guests). However, this is
6243 // probably not a risk for apps since other pages won't have references
6244 // to App windows.
alexmose7da5a12015-04-09 02:22:166245 return GetBrowserPluginGuest() || GetBrowserPluginEmbedder();
6246}
[email protected]f546640b2012-05-15 00:03:496247
alexmos58729042015-06-18 23:20:006248void WebContentsImpl::EnsureOpenerProxiesExist(RenderFrameHost* source_rfh) {
alexmose7da5a12015-04-09 02:22:166249 WebContentsImpl* source_web_contents = static_cast<WebContentsImpl*>(
6250 WebContents::FromRenderFrameHost(source_rfh));
[email protected]f546640b2012-05-15 00:03:496251
alexmose7da5a12015-04-09 02:22:166252 if (source_web_contents) {
lazyboy6ec48b2a2015-06-29 15:18:146253 // If this message is going to outer WebContents from inner WebContents,
6254 // then we should not create a RenderView. AttachToOuterWebContentsFrame()
6255 // already created a RenderFrameProxyHost for that purpose.
6256 if (GetBrowserPluginEmbedder() &&
ekaramad1beabecc2016-09-23 20:18:176257 GuestMode::IsCrossProcessFrameGuest(source_web_contents)) {
lazyboy6ec48b2a2015-06-29 15:18:146258 return;
6259 }
6260
lfg812874d2016-02-09 22:26:136261 if (this != source_web_contents && GetBrowserPluginGuest()) {
naskob3041b98a42016-03-12 04:43:066262 // We create a RenderFrameProxyHost for the embedder in the guest's render
6263 // process but we intentionally do not expose the embedder's opener chain
6264 // to it.
6265 source_web_contents->GetRenderManager()->CreateRenderFrameProxy(
6266 GetSiteInstance());
[email protected]f546640b2012-05-15 00:03:496267 } else {
alexmos58729042015-06-18 23:20:006268 RenderFrameHostImpl* source_rfhi =
6269 static_cast<RenderFrameHostImpl*>(source_rfh);
6270 source_rfhi->frame_tree_node()->render_manager()->CreateOpenerProxies(
alexmos90325cf2015-09-02 17:18:396271 GetSiteInstance(), nullptr);
[email protected]f546640b2012-05-15 00:03:496272 }
6273 }
[email protected]f546640b2012-05-15 00:03:496274}
6275
avallee9993fca2016-11-17 06:16:506276void WebContentsImpl::SetAsFocusedWebContentsIfNecessary() {
6277 // Only change focus if we are not currently focused.
6278 WebContentsImpl* old_contents = GetFocusedWebContents();
6279 if (old_contents == this)
6280 return;
6281
paulmeyerfeafc2d2017-04-25 21:46:406282 GetOutermostWebContents()->node_.SetFocusedWebContents(this);
6283
Greg Thompsonfb957602017-09-04 10:25:526284 if (!GuestMode::IsCrossProcessFrameGuest(this) && browser_plugin_guest_)
paulmeyerfeafc2d2017-04-25 21:46:406285 return;
6286
avallee9993fca2016-11-17 06:16:506287 // Send a page level blur to the old contents so that it displays inactive UI
6288 // and focus this contents to activate it.
6289 if (old_contents)
6290 old_contents->GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(false);
avalleec2ff1ef2017-01-21 00:12:306291
6292 // Make sure the outer web contents knows our frame is focused. Otherwise, the
6293 // outer renderer could have the element before or after the frame element
6294 // focused which would return early without actually advancing focus.
avalleed68cdd12017-06-21 22:07:276295 FocusOuterAttachmentFrameChain();
avalleec2ff1ef2017-01-21 00:12:306296
lfg1453e412017-04-11 00:48:506297 if (ShowingInterstitialPage()) {
creisadca9862017-06-16 19:12:116298 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:506299 ->GetRenderWidgetHost()
6300 ->SetPageFocus(true);
6301 } else {
6302 GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(true);
6303 }
avallee9993fca2016-11-17 06:16:506304}
6305
avallee0206f782016-07-28 18:55:336306void WebContentsImpl::SetFocusedFrame(FrameTreeNode* node,
6307 SiteInstance* source) {
avallee0206f782016-07-28 18:55:336308 frame_tree_.SetFocusedFrame(node, source);
avalleed68cdd12017-06-21 22:07:276309
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576310 if (auto* inner_contents = node_.GetInnerWebContentsInFrame(node)) {
6311 // |this| is an outer WebContents and |node| represents an inner
6312 // WebContents. Transfer the focus to the inner contents if |this| is
6313 // focused.
6314 if (GetFocusedWebContents() == this)
6315 inner_contents->SetAsFocusedWebContentsIfNecessary();
6316 } else if (node_.OuterContentsFrameTreeNode() &&
6317 node_.OuterContentsFrameTreeNode()
6318 ->current_frame_host()
6319 ->GetSiteInstance() == source) {
6320 // |this| is an inner WebContents, |node| is its main FrameTreeNode and
6321 // the outer WebContents FrameTreeNode is at |source|'s SiteInstance.
6322 // Transfer the focus to the inner WebContents if the outer WebContents is
6323 // focused. This branch is used when an inner WebContents is focused through
Lowell Mannersa9530382019-08-01 09:46:576324 // its RenderFrameProxyHost (via FrameFocused mojo call, used to
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576325 // implement the window.focus() API).
6326 if (GetFocusedWebContents() == GetOuterWebContents())
6327 SetAsFocusedWebContentsIfNecessary();
6328 } else if (!GetOuterWebContents()) {
6329 // This is an outermost WebContents.
6330 SetAsFocusedWebContentsIfNecessary();
6331 } else if (!GuestMode::IsCrossProcessFrameGuest(this) &&
6332 GetOuterWebContents()) {
6333 // TODO(lfg, paulmeyer): Allows BrowserPlugins to set themselves as the
6334 // focused WebContents. This works around a bug in FindRequestManager that
6335 // doesn't support properly traversing BrowserPlugins.
6336 SetAsFocusedWebContentsIfNecessary();
6337 }
avalleed68cdd12017-06-21 22:07:276338}
6339
Avi Drissman36f801f2018-02-01 20:06:046340void WebContentsImpl::DidCallFocus() {
6341 // Any explicit focusing of another window while this WebContents is in
6342 // fullscreen can be used to confuse the user, so drop fullscreen.
Avi Drissmand18c51972018-08-15 18:32:096343 ForSecurityDropFullscreen();
Avi Drissman36f801f2018-02-01 20:06:046344}
6345
avalleed68cdd12017-06-21 22:07:276346RenderFrameHost* WebContentsImpl::GetFocusedFrameIncludingInnerWebContents() {
6347 WebContentsImpl* contents = this;
6348 FrameTreeNode* focused_node = contents->frame_tree_.GetFocusedFrame();
6349
6350 // If there is no focused frame in the outer WebContents, we need to return
6351 // null.
6352 if (!focused_node)
6353 return nullptr;
6354
6355 // If the focused frame is embedding an inner WebContents, we must descend
6356 // into that contents. If the current WebContents does not have a focused
6357 // frame, return the main frame of this contents instead of the focused empty
6358 // frame embedding this contents.
6359 while (true) {
6360 contents = contents->node_.GetInnerWebContentsInFrame(focused_node);
6361 if (!contents)
6362 return focused_node->current_frame_host();
6363
6364 focused_node = contents->frame_tree_.GetFocusedFrame();
6365 if (!focused_node)
6366 return contents->GetMainFrame();
6367 }
avallee0206f782016-07-28 18:55:336368}
6369
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576370void WebContentsImpl::OnAdvanceFocus(RenderFrameHostImpl* source_rfh) {
6371 // When a RenderFrame needs to advance focus to a RenderFrameProxy (by hitting
6372 // TAB), the RenderFrameProxy sends an IPC to RenderFrameProxyHost. When this
6373 // RenderFrameProxyHost represents an inner WebContents, the outer WebContents
6374 // needs to focus the inner WebContents.
6375 if (GetOuterWebContents() &&
6376 GetOuterWebContents() == source_rfh->delegate()->GetAsWebContents() &&
6377 GetFocusedWebContents() == GetOuterWebContents()) {
6378 SetAsFocusedWebContentsIfNecessary();
6379 }
6380}
6381
ekaramada110f642016-12-21 19:47:286382void WebContentsImpl::OnFocusedElementChangedInFrame(
6383 RenderFrameHostImpl* frame,
6384 const gfx::Rect& bounds_in_root_view) {
6385 RenderWidgetHostViewBase* root_view =
6386 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
6387 if (!root_view || !frame->GetView())
6388 return;
6389
6390 // Converting to screen coordinates.
6391 gfx::Point origin = bounds_in_root_view.origin();
6392 origin += root_view->GetViewBounds().OffsetFromOrigin();
6393 gfx::Rect bounds_in_screen(origin, bounds_in_root_view.size());
6394
6395 root_view->FocusedNodeChanged(frame->has_focused_editable_element(),
6396 bounds_in_screen);
6397
6398 FocusedNodeDetails details = {frame->has_focused_editable_element(),
6399 bounds_in_screen};
6400
6401 // TODO(ekaramad): We should replace this with an observer notification
6402 // (https://crbug.com/675975).
6403 NotificationService::current()->Notify(
6404 NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
6405 Source<RenderViewHost>(GetRenderViewHost()),
6406 Details<FocusedNodeDetails>(&details));
Jeff Fisher709b4c52019-07-29 20:07:346407
6408 for (auto& observer : observers_)
6409 observer.OnFocusChangedInPage(&details);
ekaramada110f642016-12-21 19:47:286410}
6411
Lowell Manners1de5242e2019-04-25 10:18:466412bool WebContentsImpl::DidAddMessageToConsole(
6413 blink::mojom::ConsoleMessageLevel log_level,
6414 const base::string16& message,
6415 int32_t line_no,
6416 const base::string16& source_id) {
[email protected]a796f202012-05-30 14:14:256417 if (!delegate_)
6418 return false;
Lowell Manners1de5242e2019-04-25 10:18:466419 return delegate_->DidAddMessageToConsole(this, log_level, message, line_no,
avia90ae4e2016-11-11 20:49:336420 source_id);
[email protected]a796f202012-05-30 14:14:256421}
6422
Daniel Cheng90196c82018-04-25 21:49:146423void WebContentsImpl::DidReceiveInputEvent(
dominickn9c7ceaa32016-02-27 01:52:536424 RenderWidgetHostImpl* render_widget_host,
6425 const blink::WebInputEvent::Type type) {
Dominick Ng37a15052018-07-17 23:56:356426 if (!IsUserInteractionInputType(type))
Daniel Cheng90196c82018-04-25 21:49:146427 return;
6428
kenrb19221852016-04-29 17:21:406429 // Ignore unless the widget is currently in the frame tree.
6430 if (!HasMatchingWidgetHost(&frame_tree_, render_widget_host))
avic3aa8422015-11-09 20:57:226431 return;
6432
Daniel Cheng90196c82018-04-25 21:49:146433 if (type != blink::WebInputEvent::kGestureScrollBegin)
6434 last_interactive_input_event_time_ = ui::EventTimeForNow();
dominickn9c7ceaa32016-02-27 01:52:536435
Dominick Ng37a15052018-07-17 23:56:356436 for (auto& observer : observers_)
6437 observer.DidGetUserInteraction(type);
dominickn2dd142dd2015-10-29 05:30:506438}
6439
Avi Drissman738ea192018-08-29 20:24:166440bool WebContentsImpl::ShouldIgnoreInputEvents() {
6441 WebContentsImpl* web_contents = this;
6442 while (web_contents) {
6443 if (web_contents->ignore_input_events_)
6444 return true;
6445 web_contents = web_contents->GetOuterWebContents();
6446 }
6447
6448 return false;
6449}
6450
avallee9993fca2016-11-17 06:16:506451void WebContentsImpl::FocusOwningWebContents(
6452 RenderWidgetHostImpl* render_widget_host) {
6453 // The PDF plugin still runs as a BrowserPlugin and must go through the
6454 // input redirection mechanism. It must not become focused direcly.
6455 if (!GuestMode::IsCrossProcessFrameGuest(this) && browser_plugin_guest_)
6456 return;
6457
6458 RenderWidgetHostImpl* focused_widget =
6459 GetFocusedRenderWidgetHost(render_widget_host);
6460
6461 if (focused_widget != render_widget_host &&
avallee8e881592016-11-19 00:39:306462 (!focused_widget ||
6463 focused_widget->delegate() != render_widget_host->delegate())) {
avallee9993fca2016-11-17 06:16:506464 SetAsFocusedWebContentsIfNecessary();
6465 }
6466}
6467
[email protected]b172aee2012-04-10 17:05:266468void WebContentsImpl::OnIgnoredUIEvent() {
[email protected]31145092011-09-30 01:49:446469 // Notify observers.
ericwilligersde386342016-10-19 02:35:096470 for (auto& observer : observers_)
6471 observer.DidGetIgnoredUIEvent();
[email protected]fa1cf0b82010-01-15 21:49:446472}
6473
avic3aa8422015-11-09 20:57:226474void WebContentsImpl::RendererUnresponsive(
Lukasz Anforowicz52b93722018-06-20 16:11:396475 RenderWidgetHostImpl* render_widget_host,
6476 base::RepeatingClosure hang_monitor_restarter) {
avic031d392017-03-03 03:09:426477 if (ShouldIgnoreUnresponsiveRenderer())
[email protected]e5fc1632011-08-08 07:51:536478 return;
6479
Lukasz Anforowicz4f0593d2018-09-21 18:33:546480 // Do not report hangs (to task manager, to hang renderer dialog, etc.) for
6481 // invisible tabs (like extension background page, background tabs). See
6482 // https://crbug.com/881812 for rationale and for choosing the visibility
6483 // (rather than process priority) as the signal here.
6484 if (GetVisibility() != Visibility::VISIBLE)
6485 return;
6486
Avi Drissman8920def2018-01-31 19:53:366487 if (!render_widget_host->renderer_initialized())
[email protected]55452902011-06-01 21:57:476488 return;
6489
Lukasz Anforowicz4f0593d2018-09-21 18:33:546490 for (auto& observer : observers_)
6491 observer.OnRendererUnresponsive(render_widget_host->GetProcess());
6492
Dave Tapuskac6146c52017-12-20 22:48:156493 if (delegate_)
Lukasz Anforowicz52b93722018-06-20 16:11:396494 delegate_->RendererUnresponsive(this, render_widget_host,
6495 std::move(hang_monitor_restarter));
[email protected]420ae012009-04-24 05:16:326496}
6497
avic3aa8422015-11-09 20:57:226498void WebContentsImpl::RendererResponsive(
6499 RenderWidgetHostImpl* render_widget_host) {
[email protected]6934a702011-12-20 00:04:516500 if (delegate_)
Avi Drissman1572e8c3c2018-02-02 19:06:366501 delegate_->RendererResponsive(this, render_widget_host);
[email protected]420ae012009-04-24 05:16:326502}
6503
Alex Moshchuk7b4f0652019-05-30 18:54:416504void WebContentsImpl::SubframeCrashed(
6505 blink::mojom::FrameVisibility visibility) {
6506 // If a subframe crashed on a hidden tab, mark the tab for reload to avoid
6507 // showing a sad frame to the user if they ever switch back to that tab. Do
6508 // this for subframes that are either visible in viewport or visible but
6509 // scrolled out of view, but skip subframes that are not rendered (e.g., via
6510 // "display:none"), since in that case the user wouldn't see a sad frame
6511 // anyway.
6512 bool did_mark_for_reload = false;
6513 if (IsHidden() && visibility != blink::mojom::FrameVisibility::kNotRendered &&
6514 base::FeatureList::IsEnabled(
6515 features::kReloadHiddenTabsWithCrashedSubframes)) {
6516 controller_.SetNeedsReload(
6517 NavigationControllerImpl::NeedsReloadType::kCrashedSubframe);
6518 did_mark_for_reload = true;
6519 UMA_HISTOGRAM_ENUMERATION(
6520 "Stability.ChildFrameCrash.TabMarkedForReload.Visibility", visibility);
6521 }
6522
6523 UMA_HISTOGRAM_BOOLEAN("Stability.ChildFrameCrash.TabMarkedForReload",
6524 did_mark_for_reload);
6525}
6526
[email protected]b172aee2012-04-10 17:05:266527void WebContentsImpl::BeforeUnloadFiredFromRenderManager(
[email protected]feaded02012-09-25 19:12:556528 bool proceed, const base::TimeTicks& proceed_time,
[email protected]420ae012009-04-24 05:16:326529 bool* proceed_to_fire_unload) {
ericwilligersde386342016-10-19 02:35:096530 for (auto& observer : observers_)
Chris Hamilton3b3e315d2018-09-19 13:16:216531 observer.BeforeUnloadFired(proceed, proceed_time);
[email protected]6934a702011-12-20 00:04:516532 if (delegate_)
6533 delegate_->BeforeUnloadFired(this, proceed, proceed_to_fire_unload);
[email protected]e80af492013-06-24 21:52:096534 // Note: |this| might be deleted at this point.
[email protected]420ae012009-04-24 05:16:326535}
6536
[email protected]58d5cfe2013-07-10 02:40:526537void WebContentsImpl::RenderProcessGoneFromRenderManager(
[email protected]3a3d47472010-07-15 21:03:546538 RenderViewHost* render_view_host) {
[email protected]443b80e2010-12-14 00:42:236539 DCHECK(crashed_status_ != base::TERMINATION_STATUS_STILL_RUNNING);
[email protected]ec6a7eb2013-04-22 17:34:226540 RenderViewTerminated(render_view_host, crashed_status_, crashed_error_code_);
[email protected]3a3d47472010-07-15 21:03:546541}
6542
Jianzhou Fengd8720c72018-01-18 03:06:306543void WebContentsImpl::UpdateRenderViewSizeForRenderManager(bool is_main_frame) {
[email protected]8643e6d2012-01-18 20:26:106544 // TODO(brettw) this is a hack. See WebContentsView::SizeContents.
Jianzhou Fengd8720c72018-01-18 03:06:306545 gfx::Size size = GetSizeForNewRenderView(is_main_frame);
[email protected]0323ee42010-02-17 22:03:266546 // 0x0 isn't a valid window size (minimal window size is 1x1) but it may be
6547 // here during container initialization and normal window size will be set
6548 // later. In case of tab duplication this resizing to 0x0 prevents setting
6549 // normal size later so just ignore it.
6550 if (!size.IsEmpty())
6551 view_->SizeContents(size);
[email protected]420ae012009-04-24 05:16:326552}
6553
[email protected]af905902013-10-01 21:38:516554void WebContentsImpl::CancelModalDialogsForRenderManager() {
6555 // We need to cancel modal dialogs when doing a process swap, since the load
avi2460c762015-04-17 15:21:546556 // deferrer would prevent us from swapping out. We also clear the state
6557 // because this is a cross-process navigation, which means that it's a new
6558 // site that should not have to pay for the sins of its predecessor.
creis89a0f782015-05-27 16:13:176559 //
Lei Zhang6410ec1a2019-01-31 21:38:586560 // Note that we don't bother telling |browser_plugin_embedder_| because the
creis89a0f782015-05-27 16:13:176561 // cross-process navigation will either destroy the browser plugins or not
6562 // require their dialogs to close.
avi5d3b8692016-10-12 22:00:466563 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:536564 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:466565 }
[email protected]af905902013-10-01 21:38:516566}
6567
[email protected]02d7b6e2014-06-24 21:01:506568void WebContentsImpl::NotifySwappedFromRenderManager(RenderFrameHost* old_host,
6569 RenderFrameHost* new_host,
6570 bool is_main_frame) {
6571 if (is_main_frame) {
arthursonzognif97bca512019-10-10 11:32:586572 NotifyViewSwapped(old_host ? old_host->GetRenderViewHost() : nullptr,
6573 new_host->GetRenderViewHost());
[email protected]a6b73c62013-02-11 23:05:086574
[email protected]02d7b6e2014-06-24 21:01:506575 // Make sure the visible RVH reflects the new delegate's preferences.
6576 if (delegate_)
6577 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]d56a49e2013-02-23 00:47:396578
dmazzoni62111452017-04-28 23:46:556579 RenderWidgetHostViewBase* rwhv =
6580 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
6581 if (rwhv)
6582 rwhv->SetMainFrameAXTreeID(GetMainFrame()->GetAXTreeID());
[email protected]02d7b6e2014-06-24 21:01:506583 }
6584
Jinsuk Kim895b2c52018-07-03 06:49:166585 NotifyFrameSwapped(old_host, new_host, is_main_frame);
[email protected]3a3d47472010-07-15 21:03:546586}
6587
naskof5940b9f2015-03-02 23:04:056588void WebContentsImpl::NotifyMainFrameSwappedFromRenderManager(
Jinsuk Kim895b2c52018-07-03 06:49:166589 RenderFrameHost* old_host,
6590 RenderFrameHost* new_host) {
6591 NotifyViewSwapped(old_host ? old_host->GetRenderViewHost() : nullptr,
6592 new_host->GetRenderViewHost());
naskof5940b9f2015-03-02 23:04:056593}
6594
[email protected]b172aee2012-04-10 17:05:266595NavigationControllerImpl& WebContentsImpl::GetControllerForRenderManager() {
[email protected]d1198fd2012-08-13 22:50:196596 return GetController();
[email protected]3a3d47472010-07-15 21:03:546597}
6598
dcheng59716272016-04-09 05:19:086599std::unique_ptr<WebUIImpl> WebContentsImpl::CreateWebUIForRenderFrameHost(
carlosk37f793792014-11-27 15:08:296600 const GURL& url) {
Dan Beam055fe8f2017-10-04 23:23:366601 return CreateWebUI(url);
[email protected]420ae012009-04-24 05:16:326602}
6603
creisadca9862017-06-16 19:12:116604InterstitialPageImpl* WebContentsImpl::GetInterstitialForRenderManager() {
6605 return interstitial_page_;
6606}
6607
lfgbede6392015-09-11 21:54:066608void WebContentsImpl::CreateRenderWidgetHostViewForRenderManager(
6609 RenderViewHost* render_view_host) {
lfgc740d4b22016-04-15 16:45:336610 RenderWidgetHostViewBase* rwh_view =
6611 view_->CreateViewForWidget(render_view_host->GetWidget(), false);
danakjf616f2252019-09-18 21:44:096612 rwh_view->SetSize(GetSizeForNewRenderView(true));
lfgbede6392015-09-11 21:54:066613}
6614
6615bool WebContentsImpl::CreateRenderViewForRenderManager(
6616 RenderViewHost* render_view_host,
6617 int opener_frame_routing_id,
6618 int proxy_routing_id,
Pavel Feldman25234722017-10-11 02:49:066619 const base::UnguessableToken& devtools_frame_token,
lfgbede6392015-09-11 21:54:066620 const FrameReplicationState& replicated_frame_state) {
6621 TRACE_EVENT0("browser,navigation",
6622 "WebContentsImpl::CreateRenderViewForRenderManager");
6623
piman00cf9402017-04-03 17:09:206624 if (proxy_routing_id == MSG_ROUTING_NONE)
lfg9431efd2016-12-14 14:45:266625 CreateRenderWidgetHostViewForRenderManager(render_view_host);
lfg9431efd2016-12-14 14:45:266626
piman00cf9402017-04-03 17:09:206627 if (!static_cast<RenderViewHostImpl*>(render_view_host)
6628 ->CreateRenderView(opener_frame_routing_id, proxy_routing_id,
Pavel Feldman25234722017-10-11 02:49:066629 devtools_frame_token, replicated_frame_state,
6630 created_with_opener_)) {
[email protected]a4127722011-04-27 23:13:526631 return false;
[email protected]14392a52012-05-02 20:28:446632 }
W. James MacLean62198672019-06-04 16:46:106633 // Set the TextAutosizer state from the main frame's renderer on the new view,
6634 // but only if it's not for the main frame. Main frame renderers should create
6635 // this state themselves from up-to-date values, so we shouldn't override it
6636 // with the cached values.
6637 if (!render_view_host->GetMainFrame()) {
6638 render_view_host->Send(
6639 new PageMsg_UpdateTextAutosizerPageInfoForRemoteMainFrames(
6640 render_view_host->GetRoutingID(), text_autosizer_page_info_));
6641 }
[email protected]a4127722011-04-27 23:13:526642
Lucas Furukawa Gadaniaed1fed2017-10-13 17:34:146643 if (proxy_routing_id == MSG_ROUTING_NONE && node_.outer_web_contents())
6644 ReattachToOuterWebContentsFrame();
6645
avi2b177592014-12-10 02:08:026646 SetHistoryOffsetAndLengthForView(render_view_host,
6647 controller_.GetLastCommittedEntryIndex(),
6648 controller_.GetEntryCount());
6649
[email protected]a220b5932013-09-21 03:47:446650#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
[email protected]f8233cc2011-05-31 20:24:506651 // Force a ViewMsg_Resize to be sent, needed to make plugins show up on
6652 // linux. See crbug.com/83941.
avif9ab5d942015-10-15 14:05:446653 RenderWidgetHostView* rwh_view = render_view_host->GetWidget()->GetView();
[email protected]245f7d52011-11-28 15:36:446654 if (rwh_view) {
6655 if (RenderWidgetHost* render_widget_host = rwh_view->GetRenderWidgetHost())
Fady Samuel0b911822018-04-25 13:22:166656 render_widget_host->SynchronizeVisualProperties();
[email protected]245f7d52011-11-28 15:36:446657 }
[email protected]f8233cc2011-05-31 20:24:506658#endif
6659
[email protected]420ae012009-04-24 05:16:326660 return true;
6661}
6662
[email protected]82307f6b2014-08-07 03:30:126663bool WebContentsImpl::CreateRenderFrameForRenderManager(
6664 RenderFrameHost* render_frame_host,
arthursonzogni1efc7b962019-03-14 09:36:336665 int previous_routing_id,
alexmosa181efc2015-09-03 00:39:046666 int opener_routing_id,
japhete6adf142014-10-31 00:01:496667 int parent_routing_id,
alexmosa181efc2015-09-03 00:39:046668 int previous_sibling_routing_id) {
naskob8744d22014-08-28 17:07:436669 TRACE_EVENT0("browser,navigation",
6670 "WebContentsImpl::CreateRenderFrameForRenderManager");
[email protected]82307f6b2014-08-07 03:30:126671
6672 RenderFrameHostImpl* rfh =
6673 static_cast<RenderFrameHostImpl*>(render_frame_host);
arthursonzogni1efc7b962019-03-14 09:36:336674 if (!rfh->CreateRenderFrame(previous_routing_id, opener_routing_id,
alexmosa181efc2015-09-03 00:39:046675 parent_routing_id, previous_sibling_routing_id))
[email protected]82307f6b2014-08-07 03:30:126676 return false;
6677
6678 // TODO(nasko): When RenderWidgetHost is owned by RenderFrameHost, the passed
6679 // RenderFrameHost will have to be associated with the appropriate
6680 // RenderWidgetHostView or a new one should be created here.
6681
6682 return true;
6683}
6684
mfomitchev2b8b066a2016-01-28 19:23:156685#if defined(OS_ANDROID)
[email protected]fc2b46b2014-05-03 16:33:456686
[email protected]155c7f22013-12-09 17:07:186687base::android::ScopedJavaLocalRef<jobject>
6688WebContentsImpl::GetJavaWebContents() {
mostynb042582e2015-03-16 22:13:406689 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]0e813a52014-08-13 10:34:566690 return GetWebContentsAndroid()->GetJavaObject();
6691}
[email protected]155c7f22013-12-09 17:07:186692
[email protected]0e813a52014-08-13 10:34:566693WebContentsAndroid* WebContentsImpl::GetWebContentsAndroid() {
Kevin McNee576bb5d82019-05-29 16:47:516694 if (!web_contents_android_) {
6695 web_contents_android_ = std::make_unique<WebContentsAndroid>(this);
[email protected]155c7f22013-12-09 17:07:186696 }
Kevin McNee576bb5d82019-05-29 16:47:516697 return web_contents_android_.get();
6698}
6699
6700void WebContentsImpl::ClearWebContentsAndroid() {
6701 DCHECK_CURRENTLY_ON(BrowserThread::UI);
6702 web_contents_android_.reset();
[email protected]155c7f22013-12-09 17:07:186703}
6704
paulmeyerc0b762b2016-04-13 11:55:176705void WebContentsImpl::ActivateNearestFindResult(float x,
6706 float y) {
6707 GetOrCreateFindRequestManager()->ActivateNearestFindResult(x, y);
6708}
6709
6710void WebContentsImpl::RequestFindMatchRects(int current_version) {
6711 GetOrCreateFindRequestManager()->RequestFindMatchRects(current_version);
6712}
6713
[email protected]7d244f12013-08-22 21:41:516714bool WebContentsImpl::CreateRenderViewForInitialEmptyDocument() {
nasko4c0feb62015-06-05 18:37:066715 return CreateRenderViewForRenderManager(
6716 GetRenderViewHost(), MSG_ROUTING_NONE, MSG_ROUTING_NONE,
Pavel Feldman25234722017-10-11 02:49:066717 frame_tree_.root()->devtools_frame_token(),
lfgbede6392015-09-11 21:54:066718 frame_tree_.root()->current_replication_state());
[email protected]7d244f12013-08-22 21:41:516719}
[email protected]fc2b46b2014-05-03 16:33:456720
rockot400ea35b2016-10-15 19:15:326721service_manager::InterfaceProvider* WebContentsImpl::GetJavaInterfaces() {
sammcf5f1b0f2016-09-20 23:05:116722 if (!java_interfaces_) {
rockot400ea35b2016-10-15 19:15:326723 service_manager::mojom::InterfaceProviderPtr provider;
blundelle0a9f1582016-12-20 11:23:326724 BindInterfaceRegistryForWebContents(mojo::MakeRequest(&provider), this);
rockot400ea35b2016-10-15 19:15:326725 java_interfaces_.reset(new service_manager::InterfaceProvider);
sammcf5f1b0f2016-09-20 23:05:116726 java_interfaces_->Bind(std::move(provider));
6727 }
6728 return java_interfaces_.get();
6729}
6730
Francois Doray6c26f3342018-08-24 17:17:226731#endif
6732
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:416733bool WebContentsImpl::CompletedFirstVisuallyNonEmptyPaint() {
Carlos Caballero91fffb22019-10-29 15:24:306734 return GetRenderViewHost()->did_first_visually_non_empty_paint();
spqchane72c3cb2017-06-30 23:02:106735}
6736
pkotwicz75ca8ffd2016-02-16 23:10:196737void WebContentsImpl::OnDidDownloadImage(
Avi Drissmana5a52dd2018-03-27 03:39:026738 ImageDownloadCallback callback,
pkotwicz75ca8ffd2016-02-16 23:10:196739 int id,
6740 const GURL& image_url,
leon.hancbc4bc3c2016-02-26 07:08:526741 int32_t http_status_code,
leon.hanc2228532016-08-16 05:59:186742 const std::vector<SkBitmap>& images,
6743 const std::vector<gfx::Size>& original_image_sizes) {
Avi Drissmana5a52dd2018-03-27 03:39:026744 std::move(callback).Run(id, http_status_code, image_url, images,
6745 original_image_sizes);
pkotwicz75ca8ffd2016-02-16 23:10:196746}
6747
[email protected]6fba26d2014-04-29 09:38:286748void WebContentsImpl::OnDialogClosed(int render_process_id,
6749 int render_frame_id,
[email protected]b172aee2012-04-10 17:05:266750 IPC::Message* reply_msg,
[email protected]87de04b02014-04-08 22:14:496751 bool dialog_was_suppressed,
[email protected]b172aee2012-04-10 17:05:266752 bool success,
[email protected]fcf75d42013-12-03 20:11:266753 const base::string16& user_input) {
[email protected]6fba26d2014-04-29 09:38:286754 RenderFrameHostImpl* rfh = RenderFrameHostImpl::FromID(render_process_id,
6755 render_frame_id);
[email protected]87de04b02014-04-08 22:14:496756 last_dialog_suppressed_ = dialog_was_suppressed;
6757
Charlie Reis96077362019-07-04 00:34:046758 javascript_dialog_navigation_deferrer_.reset();
6759
[email protected]beb440c2009-11-06 04:08:546760 if (is_showing_before_unload_dialog_ && !success) {
clamybc6f4152016-04-01 20:14:236761 // It is possible for the current RenderFrameHost to have changed in the
6762 // meantime. Do not reset the navigation state in that case.
6763 if (rfh && rfh == rfh->frame_tree_node()->current_frame_host()) {
clamy44e84ce2016-02-22 15:38:256764 rfh->frame_tree_node()->BeforeUnloadCanceled();
clamybc6f4152016-04-01 20:14:236765 controller_.DiscardNonCommittedEntries();
6766 }
[email protected]ec8e8b02013-06-19 04:57:106767
Charles Reis15d60b132017-11-03 17:43:476768 // Update the URL display either way, to avoid showing a stale URL.
6769 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
6770
ericwilligersde386342016-10-19 02:35:096771 for (auto& observer : observers_)
6772 observer.BeforeUnloadDialogCancelled();
[email protected]beb440c2009-11-06 04:08:546773 }
[email protected]87de04b02014-04-08 22:14:496774
[email protected]6fba26d2014-04-29 09:38:286775 if (rfh) {
avi44acfaa82017-05-03 22:55:356776 rfh->JavaScriptDialogClosed(reply_msg, success, user_input);
Pavel Feldman3c1842b2017-08-02 05:00:166777
6778 std::vector<protocol::PageHandler*> page_handlers =
6779 protocol::PageHandler::EnabledForWebContents(this);
6780 for (auto* handler : page_handlers)
6781 handler->DidCloseJavaScriptDialog(success, user_input);
6782
[email protected]6fba26d2014-04-29 09:38:286783 } else {
6784 // Don't leak the sync IPC reply if the RFH or process is gone.
6785 delete reply_msg;
6786 }
avi1c51fb62017-02-27 20:43:036787
6788 is_showing_javascript_dialog_ = false;
6789 is_showing_before_unload_dialog_ = false;
[email protected]beb440c2009-11-06 04:08:546790}
6791
[email protected]1ac10dca2013-08-20 20:47:046792bool WebContentsImpl::IsHidden() {
Francois Doraye6161152018-03-27 22:05:376793 return !IsBeingCaptured() && visibility_ != Visibility::VISIBLE;
[email protected]1ac10dca2013-08-20 20:47:046794}
6795
rob97250742015-12-10 17:45:156796int WebContentsImpl::GetOuterDelegateFrameTreeNodeId() {
lfg601233692017-03-06 22:45:446797 return node_.outer_contents_frame_tree_node_id();
lazyboy6ec48b2a2015-06-29 15:18:146798}
6799
ekaramadaeb3c5c2016-11-09 03:22:356800RenderWidgetHostImpl* WebContentsImpl::GetFullscreenRenderWidgetHost() const {
6801 return RenderWidgetHostImpl::FromID(fullscreen_widget_process_id_,
6802 fullscreen_widget_routing_id_);
6803}
6804
[email protected]b0936d22013-11-28 06:47:366805RenderFrameHostManager* WebContentsImpl::GetRenderManager() const {
[email protected]fa944cb82013-11-15 17:51:216806 return frame_tree_.root()->render_manager();
6807}
6808
[email protected]f8497342013-02-05 22:15:026809BrowserPluginGuest* WebContentsImpl::GetBrowserPluginGuest() const {
[email protected]7a846df2012-09-20 19:17:396810 return browser_plugin_guest_.get();
6811}
6812
Albert J. Wongc55cc64d2018-10-12 02:50:046813void WebContentsImpl::SetBrowserPluginGuest(
6814 std::unique_ptr<BrowserPluginGuest> guest) {
6815 DCHECK(!browser_plugin_guest_);
6816 DCHECK(guest);
6817 browser_plugin_guest_ = std::move(guest);
[email protected]738f57a2013-06-29 21:06:546818}
6819
Aidan Wolter52bcc12a2018-11-14 03:27:296820base::UnguessableToken WebContentsImpl::GetAudioGroupId() {
6821 if (!base::FeatureList::IsEnabled(features::kAudioServiceAudioStreams))
6822 return base::UnguessableToken::Null();
6823
6824 return GetAudioStreamFactory()->group_id();
6825}
6826
Sofiya Semenova5e9d9122019-07-11 02:46:416827ukm::SourceId WebContentsImpl::GetLastCommittedSourceId() {
6828 return last_committed_source_id_;
6829}
6830
[email protected]f8497342013-02-05 22:15:026831BrowserPluginEmbedder* WebContentsImpl::GetBrowserPluginEmbedder() const {
[email protected]7a846df2012-09-20 19:17:396832 return browser_plugin_embedder_.get();
6833}
[email protected]8ff00d72012-10-23 19:12:216834
fsamuel60b42282015-03-10 03:29:146835void WebContentsImpl::CreateBrowserPluginEmbedderIfNecessary() {
6836 if (browser_plugin_embedder_)
6837 return;
6838 browser_plugin_embedder_.reset(BrowserPluginEmbedder::Create(this));
6839}
6840
Jianzhou Fengd8720c72018-01-18 03:06:306841gfx::Size WebContentsImpl::GetSizeForNewRenderView(bool is_main_frame) {
[email protected]dc0fd432013-08-27 15:29:216842 gfx::Size size;
Jianzhou Fengd8720c72018-01-18 03:06:306843 if (is_main_frame)
6844 size = device_emulation_size_;
6845 if (size.IsEmpty() && delegate_)
[email protected]dc0fd432013-08-27 15:29:216846 size = delegate_->GetSizeForNewRenderView(this);
6847 if (size.IsEmpty())
[email protected]fc2b46b2014-05-03 16:33:456848 size = GetContainerBounds().size();
[email protected]dc0fd432013-08-27 15:29:216849 return size;
6850}
6851
[email protected]ae7eeda2014-07-04 01:53:266852void WebContentsImpl::OnFrameRemoved(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:096853 for (auto& observer : observers_)
6854 observer.FrameDeleted(render_frame_host);
[email protected]9b159a52013-10-03 17:24:556855}
6856
[email protected]222f5822014-02-05 23:40:496857void WebContentsImpl::OnPreferredSizeChanged(const gfx::Size& old_size) {
6858 if (!delegate_)
6859 return;
6860 const gfx::Size new_size = GetPreferredSize();
6861 if (new_size != old_size)
6862 delegate_->UpdatePreferredSize(this, new_size);
6863}
6864
Dan Beam055fe8f2017-10-04 23:23:366865std::unique_ptr<WebUIImpl> WebContentsImpl::CreateWebUI(const GURL& url) {
Jeremy Roman04f27c372017-10-27 15:20:556866 std::unique_ptr<WebUIImpl> web_ui = std::make_unique<WebUIImpl>(this);
Lei Zhangee3b63ad2018-06-06 23:25:316867 std::unique_ptr<WebUIController> controller(
avie865b1d2016-10-24 19:42:596868 WebUIControllerFactoryRegistry::GetInstance()
Lei Zhangee3b63ad2018-06-06 23:25:316869 ->CreateWebUIControllerForURL(web_ui.get(), url));
dbeama1b926a2015-08-31 23:17:516870 if (controller) {
Lei Zhangee3b63ad2018-06-06 23:25:316871 web_ui->SetController(std::move(controller));
dbeama1b926a2015-08-31 23:17:516872 return web_ui;
6873 }
6874
avie865b1d2016-10-24 19:42:596875 return nullptr;
dbeama1b926a2015-08-31 23:17:516876}
6877
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:416878FindRequestManager* WebContentsImpl::GetFindRequestManager() {
6879 for (auto* contents = this; contents;
paulmeyerfeafc2d2017-04-25 21:46:406880 contents = contents->GetOuterWebContents()) {
6881 if (contents->find_request_manager_)
6882 return contents->find_request_manager_.get();
6883 }
6884
6885 return nullptr;
6886}
6887
paulmeyerc0b762b2016-04-13 11:55:176888FindRequestManager* WebContentsImpl::GetOrCreateFindRequestManager() {
paulmeyerfeafc2d2017-04-25 21:46:406889 if (FindRequestManager* manager = GetFindRequestManager())
6890 return manager;
6891
Ehsan Karamad6beb2ea2018-11-25 18:15:136892 DCHECK(!browser_plugin_guest_ || GetOuterWebContents());
6893
paulmeyerfeafc2d2017-04-25 21:46:406894 // No existing FindRequestManager found, so one must be created.
6895 find_request_manager_.reset(new FindRequestManager(this));
6896
6897 // Concurrent find sessions must not overlap, so destroy any existing
6898 // FindRequestManagers in any inner WebContentses.
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:166899 for (WebContents* contents : GetWebContentsAndAllInner()) {
6900 auto* web_contents_impl = static_cast<WebContentsImpl*>(contents);
6901 if (web_contents_impl == this)
paulmeyerfeafc2d2017-04-25 21:46:406902 continue;
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:166903 if (web_contents_impl->find_request_manager_) {
6904 web_contents_impl->find_request_manager_->StopFinding(
6905 STOP_FIND_ACTION_CLEAR_SELECTION);
6906 web_contents_impl->find_request_manager_.release();
paulmeyerfeafc2d2017-04-25 21:46:406907 }
6908 }
paulmeyerc0b762b2016-04-13 11:55:176909
6910 return find_request_manager_.get();
6911}
6912
6913void WebContentsImpl::NotifyFindReply(int request_id,
6914 int number_of_matches,
6915 const gfx::Rect& selection_rect,
6916 int active_match_ordinal,
6917 bool final_update) {
Sebastien Marchandcf97ed52017-07-24 23:50:346918 if (delegate_ && !is_being_destroyed_ &&
Lukasz Anforowicze9ae3722017-09-29 17:37:386919 !GetMainFrame()->GetProcess()->FastShutdownStarted()) {
paulmeyerc0b762b2016-04-13 11:55:176920 delegate_->FindReply(this, request_id, number_of_matches, selection_rect,
6921 active_match_ordinal, final_update);
6922 }
6923}
6924
ortuno467e5792016-06-10 04:32:396925void WebContentsImpl::IncrementBluetoothConnectedDeviceCount() {
6926 // Trying to invalidate the tab state while being destroyed could result in a
6927 // use after free.
6928 if (IsBeingDestroyed()) {
6929 return;
6930 }
6931 // Notify for UI updates if the state changes.
6932 bluetooth_connected_device_count_++;
6933 if (bluetooth_connected_device_count_ == 1) {
6934 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6935 }
6936}
6937
6938void WebContentsImpl::DecrementBluetoothConnectedDeviceCount() {
6939 // Trying to invalidate the tab state while being destroyed could result in a
6940 // use after free.
6941 if (IsBeingDestroyed()) {
6942 return;
6943 }
6944 // Notify for UI updates if the state changes.
Lukasz Anforowicze9ae3722017-09-29 17:37:386945 DCHECK_NE(bluetooth_connected_device_count_, 0u);
ortuno467e5792016-06-10 04:32:396946 bluetooth_connected_device_count_--;
6947 if (bluetooth_connected_device_count_ == 0) {
6948 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6949 }
6950}
6951
Reilly Grant5e7c79b22019-04-09 17:26:206952void WebContentsImpl::IncrementSerialActiveFrameCount() {
6953 // Trying to invalidate the tab state while being destroyed could result in a
6954 // use after free.
6955 if (IsBeingDestroyed())
6956 return;
6957
6958 // Notify for UI updates if the state changes.
6959 serial_active_frame_count_++;
6960 if (serial_active_frame_count_ == 1)
6961 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6962}
6963
6964void WebContentsImpl::DecrementSerialActiveFrameCount() {
6965 // Trying to invalidate the tab state while being destroyed could result in a
6966 // use after free.
6967 if (IsBeingDestroyed())
6968 return;
6969
6970 // Notify for UI updates if the state changes.
6971 DCHECK_NE(0u, serial_active_frame_count_);
6972 serial_active_frame_count_--;
6973 if (serial_active_frame_count_ == 0)
6974 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6975}
6976
Matt Reynoldse8c6c1f2019-11-02 09:53:536977void WebContentsImpl::IncrementHidActiveFrameCount() {
6978 // Trying to invalidate the tab state while being destroyed could result in a
6979 // use after free.
6980 if (IsBeingDestroyed())
6981 return;
6982
6983 // Notify for UI updates if the active frame count transitions from zero to
6984 // non-zero.
6985 hid_active_frame_count_++;
6986 if (hid_active_frame_count_ == 1)
6987 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6988}
6989
6990void WebContentsImpl::DecrementHidActiveFrameCount() {
6991 // Trying to invalidate the tab state while being destroyed could result in a
6992 // use after free.
6993 if (IsBeingDestroyed())
6994 return;
6995
6996 // Notify for UI updates if the active frame count transitions from non-zero
6997 // to zero.
6998 DCHECK_NE(0u, hid_active_frame_count_);
6999 hid_active_frame_count_--;
7000 if (hid_active_frame_count_ == 0)
7001 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
7002}
7003
Marijn Kruisselbrink29051042019-08-06 22:56:557004void WebContentsImpl::IncrementNativeFileSystemHandleCount() {
7005 // Trying to invalidate the tab state while being destroyed could result in a
7006 // use after free.
7007 if (IsBeingDestroyed())
7008 return;
7009
7010 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7011 // to update both the tab-level usage indicator and the usage indicator in the
7012 // omnibox.
7013 native_file_system_handle_count_++;
7014 if (native_file_system_handle_count_ == 1) {
7015 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7016 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7017 }
7018}
7019
7020void WebContentsImpl::DecrementNativeFileSystemHandleCount() {
7021 // Trying to invalidate the tab state while being destroyed could result in a
7022 // use after free.
7023 if (IsBeingDestroyed())
7024 return;
7025
7026 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7027 // to update both the tab-level usage indicator and the usage indicator in the
7028 // omnibox.
7029 DCHECK_NE(0u, native_file_system_handle_count_);
7030 native_file_system_handle_count_--;
7031 if (native_file_system_handle_count_ == 0) {
7032 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7033 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7034 }
7035}
7036
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:477037void WebContentsImpl::AddNativeFileSystemDirectoryHandle(
7038 const base::FilePath& path) {
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:337039 // Trying to invalidate the tab state while being destroyed could result in a
7040 // use after free.
7041 if (IsBeingDestroyed())
7042 return;
7043
7044 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7045 // to update both the tab-level usage indicator and the usage indicator in the
7046 // omnibox.
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:477047 const bool was_empty = native_file_system_directory_handles_.empty();
7048 native_file_system_directory_handles_[path]++;
7049 if (was_empty) {
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:337050 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7051 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7052 }
7053}
7054
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:477055void WebContentsImpl::RemoveNativeFileSystemDirectoryHandle(
7056 const base::FilePath& path) {
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:337057 // Trying to invalidate the tab state while being destroyed could result in a
7058 // use after free.
7059 if (IsBeingDestroyed())
7060 return;
7061
7062 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7063 // to update both the tab-level usage indicator and the usage indicator in the
7064 // omnibox.
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:477065 auto it = native_file_system_directory_handles_.find(path);
7066 DCHECK(it != native_file_system_directory_handles_.end());
7067 DCHECK_NE(0u, it->second);
7068 it->second--;
7069 if (it->second == 0)
7070 native_file_system_directory_handles_.erase(it);
7071 if (native_file_system_directory_handles_.empty()) {
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:337072 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7073 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7074 }
7075}
7076
7077void WebContentsImpl::IncrementWritableNativeFileSystemHandleCount() {
7078 // Trying to invalidate the tab state while being destroyed could result in a
7079 // use after free.
7080 if (IsBeingDestroyed())
7081 return;
7082
7083 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7084 // to update both the tab-level usage indicator and the usage indicator in the
7085 // omnibox.
7086 native_file_system_writable_handle_count_++;
7087 if (native_file_system_writable_handle_count_ == 1) {
7088 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7089 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7090 }
7091}
7092
7093void WebContentsImpl::DecrementWritableNativeFileSystemHandleCount() {
7094 // Trying to invalidate the tab state while being destroyed could result in a
7095 // use after free.
7096 if (IsBeingDestroyed())
7097 return;
7098
7099 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7100 // to update both the tab-level usage indicator and the usage indicator in the
7101 // omnibox.
7102 DCHECK_NE(0u, native_file_system_writable_handle_count_);
7103 native_file_system_writable_handle_count_--;
7104 if (native_file_system_writable_handle_count_ == 0) {
7105 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7106 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7107 }
7108}
7109
zqzhang8ac49002017-03-16 21:51:357110void WebContentsImpl::SetHasPersistentVideo(bool has_persistent_video) {
7111 if (has_persistent_video_ == has_persistent_video)
mlamouri5cd9ae82017-02-18 11:05:097112 return;
7113
zqzhang8ac49002017-03-16 21:51:357114 has_persistent_video_ = has_persistent_video;
mlamouri5cd9ae82017-02-18 11:05:097115 NotifyPreferencesChanged();
zqzhang8ac49002017-03-16 21:51:357116 media_web_contents_observer()->RequestPersistentVideo(has_persistent_video);
mlamouri5cd9ae82017-02-18 11:05:097117}
7118
Ian Vollick5d5c37f2019-06-19 22:50:577119void WebContentsImpl::SetSpatialNavigationDisabled(bool disabled) {
7120 if (is_spatial_navigation_disabled_ == disabled)
7121 return;
7122
7123 is_spatial_navigation_disabled_ = disabled;
7124 NotifyPreferencesChanged();
7125}
7126
paulmeyerfeafc2d2017-04-25 21:46:407127void WebContentsImpl::BrowserPluginGuestWillDetach() {
7128 WebContentsImpl* outermost = GetOutermostWebContents();
7129 if (this != outermost && ContainsOrIsFocusedWebContents())
7130 outermost->SetAsFocusedWebContentsIfNecessary();
7131}
7132
Becca Hughes112832e2019-06-11 17:19:027133PictureInPictureResult WebContentsImpl::EnterPictureInPicture(
Mounir Lamouri11e9ef42018-05-22 03:10:167134 const viz::SurfaceId& surface_id,
7135 const gfx::Size& natural_size) {
François Beaufortf09e4462019-01-18 14:34:517136 return delegate_
7137 ? delegate_->EnterPictureInPicture(this, surface_id, natural_size)
Becca Hughes112832e2019-06-11 17:19:027138 : PictureInPictureResult::kNotSupported;
Mounir Lamouri11e9ef42018-05-22 03:10:167139}
7140
Mounir Lamouri6d759e12018-05-16 20:01:307141void WebContentsImpl::ExitPictureInPicture() {
7142 if (delegate_)
7143 delegate_->ExitPictureInPicture();
7144}
7145
paulmeyerc0b762b2016-04-13 11:55:177146#if defined(OS_ANDROID)
7147void WebContentsImpl::NotifyFindMatchRectsReply(
7148 int version,
7149 const std::vector<gfx::RectF>& rects,
7150 const gfx::RectF& active_rect) {
7151 if (delegate_)
7152 delegate_->FindMatchRectsReply(this, version, rects, active_rect);
7153}
7154#endif
7155
[email protected]34ff1cfc2014-08-20 06:16:057156void WebContentsImpl::SetForceDisableOverscrollContent(bool force_disable) {
7157 force_disable_overscroll_content_ = force_disable;
7158 if (view_)
7159 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
7160}
7161
Jianzhou Fengd8720c72018-01-18 03:06:307162bool WebContentsImpl::SetDeviceEmulationSize(const gfx::Size& new_size) {
7163 device_emulation_size_ = new_size;
7164 RenderWidgetHostView* rwhv = GetMainFrame()->GetView();
7165
7166 const gfx::Size current_size = rwhv->GetViewBounds().size();
7167 if (view_size_before_emulation_.IsEmpty())
7168 view_size_before_emulation_ = current_size;
7169
7170 if (current_size != new_size)
7171 rwhv->SetSize(new_size);
7172
7173 return current_size != new_size;
7174}
7175
7176void WebContentsImpl::ClearDeviceEmulationSize() {
7177 RenderWidgetHostView* rwhv = GetMainFrame()->GetView();
7178 // WebContentsView could get resized during emulation, which also resizes
7179 // RWHV. If it happens, assume user would like to keep using the size after
7180 // emulation.
7181 // TODO(jzfeng): Prohibit resizing RWHV through any other means (at least when
7182 // WebContentsView size changes).
Dmitry Gozmanc63707182018-03-06 00:09:397183 if (!view_size_before_emulation_.IsEmpty() && rwhv &&
7184 rwhv->GetViewBounds().size() == device_emulation_size_) {
Jianzhou Fengd8720c72018-01-18 03:06:307185 rwhv->SetSize(view_size_before_emulation_);
Dmitry Gozmanc63707182018-03-06 00:09:397186 }
Jianzhou Fengd8720c72018-01-18 03:06:307187 device_emulation_size_ = gfx::Size();
7188 view_size_before_emulation_ = gfx::Size();
7189}
7190
Max Morin5bc74f52018-05-09 07:00:217191ForwardingAudioStreamFactory* WebContentsImpl::GetAudioStreamFactory() {
7192 if (!audio_stream_factory_) {
7193 audio_stream_factory_.emplace(
7194 this,
Max Morinddebb972018-09-20 10:04:147195 // BrowserMainLoop::GetInstance() may be null in unit tests.
7196 BrowserMainLoop::GetInstance()
7197 ? static_cast<media::UserInputMonitorBase*>(
7198 BrowserMainLoop::GetInstance()->user_input_monitor())
7199 : nullptr,
Ken Rockotfd03e682019-06-20 21:13:547200 GetSystemConnector()->Clone(), AudioStreamBrokerFactory::CreateImpl());
Max Morin5bc74f52018-05-09 07:00:217201 }
7202
7203 return &*audio_stream_factory_;
7204}
7205
dalecurtis88c240072015-12-09 02:11:187206void WebContentsImpl::MediaStartedPlaying(
billorr21c005d2016-11-17 03:57:047207 const WebContentsObserver::MediaPlayerInfo& media_info,
Mounir Lamouri0f5bdf52019-04-04 16:32:357208 const MediaPlayerId& id) {
billorr21c005d2016-11-17 03:57:047209 if (media_info.has_video)
7210 currently_playing_video_count_++;
7211
ericwilligersde386342016-10-19 02:35:097212 for (auto& observer : observers_)
billorr21c005d2016-11-17 03:57:047213 observer.MediaStartedPlaying(media_info, id);
dalecurtis88c240072015-12-09 02:11:187214}
7215
7216void WebContentsImpl::MediaStoppedPlaying(
billorr21c005d2016-11-17 03:57:047217 const WebContentsObserver::MediaPlayerInfo& media_info,
Mounir Lamouri0f5bdf52019-04-04 16:32:357218 const MediaPlayerId& id,
Becca Hughes220bfc102017-11-14 18:24:077219 WebContentsObserver::MediaStoppedReason reason) {
billorr21c005d2016-11-17 03:57:047220 if (media_info.has_video)
7221 currently_playing_video_count_--;
7222
ericwilligersde386342016-10-19 02:35:097223 for (auto& observer : observers_)
Becca Hughes220bfc102017-11-14 18:24:077224 observer.MediaStoppedPlaying(media_info, id, reason);
billorr21c005d2016-11-17 03:57:047225}
7226
Mounir Lamouri0f5bdf52019-04-04 16:32:357227void WebContentsImpl::MediaResized(const gfx::Size& size,
7228 const MediaPlayerId& id) {
peconn257951522017-06-09 18:24:597229 cached_video_sizes_[id] = size;
7230
7231 for (auto& observer : observers_)
7232 observer.MediaResized(size, id);
7233}
7234
Peter E Conneccb34c22017-09-08 09:37:587235void WebContentsImpl::MediaEffectivelyFullscreenChanged(bool is_fullscreen) {
7236 for (auto& observer : observers_)
7237 observer.MediaEffectivelyFullscreenChanged(is_fullscreen);
7238}
7239
Peter Conn31c726a2017-08-17 11:07:347240base::Optional<gfx::Size> WebContentsImpl::GetFullscreenVideoSize() {
Mounir Lamouri0f5bdf52019-04-04 16:32:357241 base::Optional<MediaPlayerId> id =
Peter Conn31c726a2017-08-17 11:07:347242 media_web_contents_observer_->GetFullscreenVideoMediaPlayerId();
Jan Wilken Dörrie531be7ca2019-06-07 10:05:577243 if (id && base::Contains(cached_video_sizes_, id.value()))
Peter Conn31c726a2017-08-17 11:07:347244 return base::Optional<gfx::Size>(cached_video_sizes_[id.value()]);
Lei Zhang6410ec1a2019-01-31 21:38:587245 return base::nullopt;
peconn257951522017-06-09 18:24:597246}
7247
billorr21c005d2016-11-17 03:57:047248int WebContentsImpl::GetCurrentlyPlayingVideoCount() {
7249 return currently_playing_video_count_;
dalecurtis88c240072015-12-09 02:11:187250}
7251
Raymond Toye413650c2018-08-31 00:12:477252void WebContentsImpl::AudioContextPlaybackStarted(RenderFrameHost* host,
7253 int context_id) {
7254 WebContentsObserver::AudioContextId audio_context_id(host, context_id);
7255 for (auto& observer : observers_)
7256 observer.AudioContextPlaybackStarted(audio_context_id);
7257}
7258
7259void WebContentsImpl::AudioContextPlaybackStopped(RenderFrameHost* host,
7260 int context_id) {
7261 WebContentsObserver::AudioContextId audio_context_id(host, context_id);
7262 for (auto& observer : observers_)
7263 observer.AudioContextPlaybackStopped(audio_context_id);
7264}
7265
evliufc233aa2019-10-31 19:53:037266void WebContentsImpl::MediaWatchTimeChanged(
7267 const content::MediaPlayerWatchTime& watch_time) {
7268 for (auto& observer : observers_)
7269 observer.MediaWatchTimeChanged(watch_time);
7270}
7271
evliu7f736f02019-11-07 17:43:507272media::MediaMetricsProvider::RecordAggregateWatchTimeCallback
7273WebContentsImpl::GetRecordAggregateWatchTimeCallback() {
7274 return base::BindRepeating(
7275 [](base::WeakPtr<RenderFrameHostDelegate> delegate,
7276 GURL last_committed_url, base::TimeDelta total_watch_time,
evliua283c9e2019-11-08 22:57:227277 base::TimeDelta time_stamp, bool has_video, bool has_audio) {
7278 content::MediaPlayerWatchTime watch_time(
7279 last_committed_url, last_committed_url.GetOrigin(),
7280 total_watch_time, time_stamp, has_video, has_audio);
evliu7f736f02019-11-07 17:43:507281
7282 // Save the watch time if the delegate is still alive.
7283 if (delegate)
7284 delegate->MediaWatchTimeChanged(watch_time);
7285 },
7286 weak_factory_.GetWeakPtr(), GetMainFrameLastCommittedURL());
7287}
7288
Ehsan Karamad1c631762019-05-13 23:04:017289RenderFrameHostImpl* WebContentsImpl::GetMainFrameForInnerDelegate(
7290 FrameTreeNode* frame_tree_node) {
7291 if (auto* web_contents = node_.GetInnerWebContentsInFrame(frame_tree_node))
7292 return web_contents->GetMainFrame();
7293 return nullptr;
7294}
7295
John Budorickee1c9512019-10-17 15:32:197296bool WebContentsImpl::IsFrameLowPriority(
7297 const RenderFrameHost* render_frame_host) {
7298 if (!delegate_)
7299 return false;
7300 return delegate_->IsFrameLowPriority(this, render_frame_host);
7301}
7302
Francois Doraye6161152018-03-27 22:05:377303void WebContentsImpl::UpdateWebContentsVisibility(Visibility visibility) {
Francois Doray3f2afbd2018-04-06 19:18:187304 // Occlusion is disabled when |features::kWebContentsOcclusion| is disabled
7305 // (for power and speed impact assessment) or when
7306 // |switches::kDisableBackgroundingOccludedWindowsForTesting| is specified on
7307 // the command line (to avoid flakiness in browser tests).
7308 const bool occlusion_is_disabled =
7309 !base::FeatureList::IsEnabled(features::kWebContentsOcclusion) ||
Francois Doraye6161152018-03-27 22:05:377310 base::CommandLine::ForCurrentProcess()->HasSwitch(
7311 switches::kDisableBackgroundingOccludedWindowsForTesting);
7312 if (occlusion_is_disabled && visibility == Visibility::OCCLUDED)
7313 visibility = Visibility::VISIBLE;
7314
tapted65ff2ea72016-03-01 23:39:007315 if (!did_first_set_visible_) {
Francois Doraye6161152018-03-27 22:05:377316 if (visibility == Visibility::VISIBLE) {
7317 // A WebContents created with CreateParams::initially_hidden = false
7318 // starts with GetVisibility() == Visibility::VISIBLE even though it is
7319 // not really visible. Call WasShown() when it becomes visible for real as
7320 // the page load mechanism and some WebContentsObserver rely on that.
tapted65ff2ea72016-03-01 23:39:007321 WasShown();
Francois Dorayfe4a1772018-02-17 04:17:097322 did_first_set_visible_ = true;
tapted65ff2ea72016-03-01 23:39:007323 }
Francois Doraye6161152018-03-27 22:05:377324
7325 // Trust the initial visibility of the WebContents and do not switch it to
7326 // HIDDEN or OCCLUDED before it becomes VISIBLE for real. Doing so would
7327 // result in destroying resources that would immediately be recreated (e.g.
7328 // UpdateWebContents(HIDDEN) can be called when a WebContents is added to a
7329 // hidden window that is about to be shown).
7330
tapted65ff2ea72016-03-01 23:39:007331 return;
7332 }
Francois Doraye6161152018-03-27 22:05:377333
7334 if (visibility == visibility_)
tapted65ff2ea72016-03-01 23:39:007335 return;
7336
Collin Baker989e0882019-11-01 01:27:177337 UpdateVisibilityAndNotifyPageAndView(visibility);
tapted65ff2ea72016-03-01 23:39:007338}
7339
aelias5252baa2016-04-10 01:18:027340void WebContentsImpl::UpdateOverridingUserAgent() {
mlamouri5cd9ae82017-02-18 11:05:097341 NotifyPreferencesChanged();
aelias5252baa2016-04-10 01:18:027342}
7343
avid53461d2016-02-25 17:15:047344void WebContentsImpl::SetJavaScriptDialogManagerForTesting(
7345 JavaScriptDialogManager* dialog_manager) {
7346 dialog_manager_ = dialog_manager;
7347}
7348
rockotf62002a2016-09-15 00:08:597349void WebContentsImpl::RemoveBindingSet(const std::string& interface_name) {
7350 auto it = binding_sets_.find(interface_name);
7351 if (it != binding_sets_.end())
7352 binding_sets_.erase(it);
7353}
7354
nzolghadrd87a308d2016-12-07 15:45:567355bool WebContentsImpl::AddDomainInfoToRapporSample(rappor::Sample* sample) {
nzolghadrbbffc6c2017-05-25 17:56:397356 // Here we associate this metric to the main frame URL regardless of what
7357 // caused it.
nzolghadrd87a308d2016-12-07 15:45:567358 sample->SetStringField("Domain", ::rappor::GetDomainAndRegistrySampleFromGURL(
7359 GetLastCommittedURL()));
nzolghadrd87a308d2016-12-07 15:45:567360 return true;
7361}
7362
falken52a56e32016-12-08 05:02:407363void WebContentsImpl::ShowInsecureLocalhostWarningIfNeeded() {
7364 bool allow_localhost = base::CommandLine::ForCurrentProcess()->HasSwitch(
7365 switches::kAllowInsecureLocalhost);
7366 if (!allow_localhost)
7367 return;
7368
7369 content::NavigationEntry* entry = GetController().GetLastCommittedEntry();
Rob Wuf79b3ba2018-01-14 01:54:317370 if (!entry || !net::IsLocalhost(entry->GetURL()))
falken52a56e32016-12-08 05:02:407371 return;
7372
7373 content::SSLStatus ssl_status = entry->GetSSL();
Matt Mueller936511442019-09-03 18:15:127374 if (!net::IsCertStatusError(ssl_status.cert_status))
falken52a56e32016-12-08 05:02:407375 return;
7376
7377 GetMainFrame()->AddMessageToConsole(
Abhijeet Kandalkara5928a0a2019-03-13 05:04:427378 blink::mojom::ConsoleMessageLevel::kWarning,
falken52a56e32016-12-08 05:02:407379 base::StringPrintf("This site does not have a valid SSL "
7380 "certificate! Without SSL, your site's and "
7381 "visitors' data is vulnerable to theft and "
7382 "tampering. Get a valid SSL certificate before"
7383 " releasing your website to the public."));
7384}
7385
ekaramadf6750aa2017-06-06 18:29:427386bool WebContentsImpl::IsShowingContextMenuOnPage() const {
7387 return showing_context_menu_;
7388}
7389
Min Qina904f3302018-02-13 23:33:347390download::DownloadUrlParameters::RequestHeadersType
7391WebContentsImpl::ParseDownloadHeaders(const std::string& headers) {
7392 download::DownloadUrlParameters::RequestHeadersType request_headers;
Megan Jablonski2f6a4c52017-07-10 23:01:257393 for (const base::StringPiece& key_value : base::SplitStringPiece(
7394 headers, "\r\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
7395 std::vector<std::string> pair = base::SplitString(
7396 key_value, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
7397 if (2ul == pair.size())
7398 request_headers.push_back(make_pair(pair[0], pair[1]));
7399 }
7400 return request_headers;
7401}
7402
lukasza6f8ac622017-06-06 03:10:207403void WebContentsImpl::SetOpenerForNewContents(FrameTreeNode* opener,
7404 bool opener_suppressed) {
7405 if (opener) {
7406 FrameTreeNode* new_root = GetFrameTree()->root();
7407
7408 // For the "original opener", track the opener's main frame instead, because
7409 // if the opener is a subframe, the opener tracking could be easily bypassed
7410 // by spawning from a subframe and deleting the subframe.
7411 // https://crbug.com/705316
7412 new_root->SetOriginalOpener(opener->frame_tree()->root());
7413
7414 if (!opener_suppressed) {
7415 new_root->SetOpener(opener);
7416 created_with_opener_ = true;
7417 }
7418 }
7419}
7420
Mounir Lamouri0f5bdf52019-04-04 16:32:357421void WebContentsImpl::MediaMutedStatusChanged(const MediaPlayerId& id,
7422 bool muted) {
Becca Hughes9f6fd4b82017-06-15 10:01:407423 for (auto& observer : observers_)
7424 observer.MediaMutedStatusChanged(id, muted);
7425}
7426
EhsanK2075c7e2017-08-21 02:42:397427void WebContentsImpl::SetVisibilityForChildViews(bool visible) {
7428 GetMainFrame()->SetVisibilityForChildViews(visible);
7429}
7430
Dave Tapuskae782bea2019-07-09 16:21:517431mojom::FrameInputHandler* WebContentsImpl::GetFocusedFrameInputHandler() {
7432 auto* focused_frame = GetFocusedFrame();
7433 if (!focused_frame)
7434 return nullptr;
7435 return focused_frame->GetFrameInputHandler();
7436}
7437
[email protected]8ff00d72012-10-23 19:12:217438} // namespace content