blob: 08fdd03784a0ff2da2b95ee6404a7c1188254e47 [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
Avi Drissman33972942020-06-19 14:16:019#include <algorithm>
w.shackleton49bcd392016-01-06 17:38:2210#include <cmath>
[email protected]2bb171882012-03-07 02:09:4611#include <utility>
rkaplowe56a52032017-02-07 00:14:5412#include <vector>
[email protected]b75b8292010-10-01 07:28:2513
Sebastien Marchandf8cbfab2019-01-25 16:02:3014#include "base/bind.h"
[email protected]36fb2c7c2011-04-04 15:49:0815#include "base/command_line.h"
Avi Drissman33972942020-06-19 14:16:0116#include "base/containers/flat_set.h"
creisfafed882016-07-29 00:03:0917#include "base/debug/dump_without_crashing.h"
zqzhang181047e62016-07-01 13:37:1718#include "base/feature_list.h"
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:4719#include "base/files/file_path.h"
[email protected]cbb1ef592013-06-05 19:49:4620#include "base/lazy_instance.h"
skyostil95082a62015-06-05 19:53:0721#include "base/location.h"
[email protected]6d636e62013-07-31 03:15:5622#include "base/logging.h"
avib7348942015-12-25 20:57:1023#include "base/macros.h"
fdorayba121422016-12-23 19:51:4824#include "base/memory/ptr_util.h"
dmazzonid95ae842016-04-12 21:17:3925#include "base/memory/ref_counted.h"
asvitkine8d51e9d2016-09-02 23:55:4326#include "base/metrics/histogram_macros.h"
bratell0a7406f2017-03-28 07:46:3727#include "base/metrics/user_metrics.h"
Avi Drissman4891b852018-09-25 18:12:5828#include "base/no_destructor.h"
Carlos Caballero1215f882019-10-29 15:58:4329#include "base/optional.h"
[email protected]04cbd3d2013-12-04 04:58:2030#include "base/process/process.h"
skyostil95082a62015-06-05 19:53:0731#include "base/single_thread_task_runner.h"
Arthur Sonzogni929d29f2018-09-17 14:19:4432#include "base/stl_util.h"
[email protected]348fbaac2013-06-11 06:31:5133#include "base/strings/string16.h"
34#include "base/strings/string_number_conversions.h"
Avi Drissman4891b852018-09-25 18:12:5835#include "base/strings/string_split.h"
[email protected]348fbaac2013-06-11 06:31:5136#include "base/strings/string_util.h"
[email protected]74ebfb12013-06-07 20:48:0037#include "base/strings/utf_string_conversions.h"
gab30f26df2016-05-11 19:37:5538#include "base/threading/thread_task_runner_handle.h"
[email protected]a43858f2013-06-28 15:18:3739#include "base/time/time.h"
ssid3e765612015-01-28 04:03:4240#include "base/trace_event/trace_event.h"
avib7348942015-12-25 20:57:1041#include "build/build_config.h"
Min Qinda0ed2062018-02-23 22:00:5342#include "components/download/public/common/download_stats.h"
nzolghadrd87a308d2016-12-07 15:45:5643#include "components/rappor/public/rappor_utils.h"
rsleevi24f64dc22015-08-07 21:39:2144#include "components/url_formatter/url_formatter.h"
Abigail Kleinaa898742019-11-01 02:31:2545#include "content/browser/accessibility/accessibility_event_recorder.h"
James Wallace-Leeeafc94cb92018-07-23 21:35:0946#include "content/browser/accessibility/accessibility_tree_formatter_blink.h"
jamescookda2505812015-03-20 18:01:1847#include "content/browser/bad_message.h"
Max Morinddebb972018-09-20 10:04:1448#include "content/browser/browser_main_loop.h"
[email protected]7a846df2012-09-20 19:17:3949#include "content/browser/browser_plugin/browser_plugin_embedder.h"
50#include "content/browser/browser_plugin/browser_plugin_guest.h"
[email protected]b9535422012-02-09 01:47:5951#include "content/browser/child_process_security_policy_impl.h"
John Delaney732721e92020-02-07 23:11:2752#include "content/browser/conversions/conversion_host.h"
Pavel Feldman3c1842b2017-08-02 05:00:1653#include "content/browser/devtools/protocol/page_handler.h"
dgozmanf00c4f72016-10-19 17:45:1554#include "content/browser/devtools/render_frame_devtools_agent_host.h"
Becca Hughes3b5a43482018-07-17 22:31:5555#include "content/browser/display_cutout/display_cutout_host_impl.h"
[email protected]5f2aa722013-08-07 16:59:4156#include "content/browser/dom_storage/dom_storage_context_wrapper.h"
[email protected]1ea3c792012-04-17 01:25:0457#include "content/browser/dom_storage/session_storage_namespace_impl.h"
[email protected]aa4f3972012-03-01 18:12:1258#include "content/browser/download/mhtml_generation_manager.h"
[email protected]a53209b2012-01-20 16:48:1659#include "content/browser/download/save_package.h"
paulmeyerc0b762b2016-04-13 11:55:1760#include "content/browser/find_request_manager.h"
[email protected]bffc8302014-01-23 20:52:1661#include "content/browser/frame_host/cross_process_frame_connector.h"
ananta4b7467a52016-09-23 01:42:3862#include "content/browser/frame_host/frame_tree_node.h"
[email protected]d4a8ca482013-10-30 21:06:4063#include "content/browser/frame_host/navigation_entry_impl.h"
Arthur Hemeryc3380172018-01-22 14:00:1764#include "content/browser/frame_host/navigation_request.h"
Hiroki Nakagawa080f86c2020-05-13 10:56:4265#include "content/browser/frame_host/navigator.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"
Yuzu Saijoa11069a2020-04-22 10:56:5575#include "content/browser/plugin_content_origin_allowlist.h"
Kevin McNee94ea52f52020-06-23 17:42:0676#include "content/browser/portal/portal.h"
David Black9cca3592019-11-06 23:02:2277#include "content/browser/renderer_host/frame_token_message_queue.h"
[email protected]f3b1a082011-11-18 00:34:3078#include "content/browser/renderer_host/render_process_host_impl.h"
[email protected]21161032014-05-05 16:56:5079#include "content/browser/renderer_host/render_view_host_delegate_view.h"
[email protected]b3c41c0b2012-03-06 15:48:3280#include "content/browser/renderer_host/render_view_host_impl.h"
[email protected]bafe6cd2012-05-23 23:09:5081#include "content/browser/renderer_host/render_widget_host_impl.h"
kenrb2a565f82015-09-02 20:24:5982#include "content/browser/renderer_host/render_widget_host_input_event_router.h"
[email protected]cfd80b02014-05-01 17:46:4883#include "content/browser/renderer_host/render_widget_host_view_base.h"
Ken Buchanandaef006b2017-08-17 18:32:1584#include "content/browser/renderer_host/render_widget_host_view_child_frame.h"
ekaramadadd882292016-06-08 15:22:5685#include "content/browser/renderer_host/text_input_manager.h"
Mike Wassermanb213b9352020-04-16 00:32:3486#include "content/browser/screen_enumeration/screen_change_monitor.h"
leon.han552e9de2017-02-09 14:37:3087#include "content/browser/screen_orientation/screen_orientation_provider.h"
[email protected]b6583592012-01-25 19:52:3388#include "content/browser/site_instance_impl.h"
Charlie Reis96077362019-07-04 00:34:0489#include "content/browser/web_contents/javascript_dialog_navigation_deferrer.h"
lfgc740d4b22016-04-15 16:45:3390#include "content/browser/web_contents/web_contents_view_child_frame.h"
Tsuyoshi Horob0d8d902020-03-12 00:09:3991#include "content/browser/web_package/save_as_web_bundle_job.h"
[email protected]86a0a6e2013-01-28 06:33:0392#include "content/browser/webui/web_ui_controller_factory_registry.h"
[email protected]d2353452012-01-19 19:53:5693#include "content/browser/webui/web_ui_impl.h"
[email protected]8eb04562013-03-06 03:41:1494#include "content/common/browser_plugin/browser_plugin_constants.h"
Paul Meyer0c58c3712016-11-17 22:59:5195#include "content/common/drag_messages.h"
[email protected]f114fa42013-12-06 17:06:4496#include "content/common/frame_messages.h"
[email protected]1f3fc1d2014-04-03 14:50:1797#include "content/common/input_messages.h"
lfgdb5c4ed2016-03-04 23:09:0798#include "content/common/page_messages.h"
nasko34634672016-07-29 18:46:0699#include "content/common/page_state_serialization.h"
rockot5c478a72016-09-28 23:14:18100#include "content/common/render_message_filter.mojom.h"
[email protected]2c5569662011-03-22 20:45:02101#include "content/common/view_messages.h"
Albert J. Wong3c93c182018-09-27 17:29:43102#include "content/common/widget_messages.h"
Abigail Kleinabb428332019-09-13 18:26:21103#include "content/public/browser/accessibility_tree_formatter.h"
[email protected]31a71eaf2014-03-13 01:47:36104#include "content/public/browser/ax_event_notification_details.h"
[email protected]ccb797302011-12-15 16:55:11105#include "content/public/browser/browser_context.h"
[email protected]139355f2014-05-11 14:21:28106#include "content/public/browser/browser_plugin_guest_manager.h"
Eric Seckler8652dcd52018-09-20 10:42:28107#include "content/public/browser/browser_task_traits.h"
Gabriel Charette790754c2018-03-16 21:32:59108#include "content/public/browser/browser_thread.h"
[email protected]87f3c082011-10-19 18:07:44109#include "content/public/browser/content_browser_client.h"
Lukasz Anforowicz8c4446dc2020-03-11 22:16:42110#include "content/public/browser/context_menu_params.h"
Ken Rockotce010f02019-12-12 23:32:32111#include "content/public/browser/device_service.h"
[email protected]e582fdd2011-12-20 16:48:17112#include "content/public/browser/download_manager.h"
Kent Tamura512a27e2018-10-04 00:49:32113#include "content/public/browser/file_select_listener.h"
ekaramada110f642016-12-21 19:47:28114#include "content/public/browser/focused_node_details.h"
Danyao Wanga78f3dd22020-03-05 05:31:27115#include "content/public/browser/global_routing_id.h"
[email protected]d9083482012-01-06 00:38:46116#include "content/public/browser/invalidate_type.h"
[email protected]71a88bb2013-02-01 22:05:15117#include "content/public/browser/javascript_dialog_manager.h"
skyf65d9bb2017-03-24 02:26:39118#include "content/public/browser/keyboard_event_processing_result.h"
[email protected]09d31d52012-03-11 22:30:27119#include "content/public/browser/load_notification_details.h"
[email protected]5b96836f2011-12-22 07:39:00120#include "content/public/browser/navigation_details.h"
[email protected]375fa1b2012-05-22 22:05:37121#include "content/public/browser/notification_details.h"
[email protected]be2510c02012-05-28 14:52:14122#include "content/public/browser/notification_service.h"
scottmg011d96e32016-06-29 19:15:08123#include "content/public/browser/notification_types.h"
[email protected]95640212014-07-26 18:14:30124#include "content/public/browser/render_widget_host_iterator.h"
Lukasz Anforowicze1b954d92017-10-30 21:28:06125#include "content/public/browser/restore_type.h"
estark5ea80e52015-06-19 18:43:12126#include "content/public/browser/security_style_explanations.h"
falken52a56e32016-12-08 05:02:40127#include "content/public/browser/ssl_status.h"
[email protected]4c3a23582012-08-18 08:54:34128#include "content/public/browser/storage_partition.h"
[email protected]674bc592011-12-20 23:00:42129#include "content/public/browser/web_contents_delegate.h"
Julie Jeongeun Kim7d0986172019-12-04 03:17:25130#include "content/public/browser/web_contents_receiver_set.h"
Lei Zhangee3b63ad2018-06-06 23:25:31131#include "content/public/browser/web_ui_controller.h"
[email protected]e091df82011-10-11 18:13:21132#include "content/public/common/bindings_policy.h"
alexmosc9e76ec2016-05-16 22:59:37133#include "content/public/common/child_process_host.h"
Hans Wennborg5ffd1392019-10-16 11:00:02134#include "content/public/common/content_client.h"
[email protected]54087fe2011-10-28 22:02:48135#include "content/public/common/content_constants.h"
Francois Doray3f2afbd2018-04-06 19:18:18136#include "content/public/common/content_features.h"
[email protected]64d69de42012-02-06 00:19:54137#include "content/public/common/content_switches.h"
Lukasz Anforowicze1b954d92017-10-30 21:28:06138#include "content/public/common/page_state.h"
Leon Han963dc182018-11-06 05:41:48139#include "content/public/common/referrer_type_converters.h"
[email protected]04cbd3d2013-12-04 04:58:20140#include "content/public/common/result_codes.h"
[email protected]f16cc6782013-12-16 23:42:57141#include "content/public/common/url_utils.h"
danakjffc8baf2019-10-10 23:49:42142#include "content/public/common/use_zoom_for_dsf_policy.h"
[email protected]b3a97b52014-07-09 06:25:05143#include "content/public/common/web_preferences.h"
Max Morinddebb972018-09-20 10:04:14144#include "media/base/user_input_monitor.h"
wjmaclean64951902016-04-29 20:59:12145#include "net/base/url_util.h"
[email protected]8bfc8272013-09-09 20:10:53146#include "net/http/http_cache.h"
147#include "net/http/http_transaction_factory.h"
rhalavati0fbaeef32017-06-01 15:56:30148#include "net/traffic_annotation/network_traffic_annotation.h"
[email protected]8bfc8272013-09-09 20:10:53149#include "net/url_request/url_request_context.h"
[email protected]abe2c032011-03-31 18:49:34150#include "net/url_request/url_request_context_getter.h"
Scott Violet02e38b92018-03-27 23:42:14151#include "ppapi/buildflags/buildflags.h"
Mounir Lamourifd9dcefa2017-07-06 10:26:55152#include "services/metrics/public/cpp/ukm_recorder.h"
John Abd-El-Malekb175a612018-12-03 20:11:58153#include "services/network/public/cpp/features.h"
arthursonzognib93a4472020-04-10 07:38:00154#include "services/network/public/cpp/web_sandbox_flags.h"
155#include "services/network/public/mojom/web_sandbox_flags.mojom.h"
rockot734fb662016-10-15 16:41:30156#include "services/service_manager/public/cpp/interface_provider.h"
Becca Hughes6daf5662018-06-27 16:50:54157#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
Blink Reformata30d4232018-04-07 15:31:06158#include "third_party/blink/public/common/mime_util/mime_util.h"
danakj938b37a62019-09-24 18:35:54159#include "third_party/blink/public/common/page/page_zoom.h"
Sergio Villar Senin9d9d4f52019-10-15 10:57:57160#include "third_party/blink/public/common/security/security_style.h"
Abhijeet Kandalkarde7348e2020-01-13 06:06:54161#include "third_party/blink/public/mojom/frame/frame.mojom.h"
Dave Tapuskaa4189512019-10-15 20:27:34162#include "third_party/blink/public/mojom/frame/fullscreen.mojom.h"
Takuto Ikutaaa3b796c2019-02-06 02:54:56163#include "third_party/blink/public/mojom/loader/pause_subresource_loading_handle.mojom.h"
Antonio Gomes0d42960a2019-06-05 12:35:51164#include "third_party/blink/public/mojom/mediastream/media_stream.mojom-shared.h"
halton.huoca2eabd2015-07-06 08:17:40165#include "third_party/skia/include/core/SkBitmap.h"
dmazzonid95ae842016-04-12 21:17:39166#include "ui/accessibility/ax_tree_combiner.h"
[email protected]a08412b62012-05-29 21:28:56167#include "ui/base/layout.h"
Daniel Cheng90196c82018-04-25 21:49:14168#include "ui/events/base_event_utils.h"
chongz4a9751942016-08-17 17:49:39169#include "ui/events/blink/web_input_event_traits.h"
[email protected]66bd5512012-08-01 02:02:52170#include "ui/gl/gl_switches.h"
[email protected]3c733bde2010-12-21 19:56:31171
ekaramada110f642016-12-21 19:47:28172#if defined(OS_WIN)
173#include "content/browser/renderer_host/dip_util.h"
174#include "ui/gfx/geometry/dip_util.h"
175#endif
176
[email protected]583418cc2013-01-17 14:01:10177#if defined(OS_ANDROID)
mfomitchev2b8b066a2016-01-28 19:23:15178#include "content/browser/android/date_time_chooser_android.h"
sammcf5f1b0f2016-09-20 23:05:11179#include "content/browser/android/java_interfaces_impl.h"
Leon Hanccb985f2019-08-26 02:43:24180#include "content/browser/android/nfc_host.h"
[email protected]155c7f22013-12-09 17:07:18181#include "content/browser/web_contents/web_contents_android.h"
Ke He31d0bb02018-02-24 07:16:24182#include "services/device/public/mojom/nfc.mojom.h"
mcnee336ea2c2017-05-23 22:50:59183#else // !OS_ANDROID
184#include "content/browser/host_zoom_map_impl.h"
mfomitchev2b8b066a2016-01-28 19:23:15185#endif // OS_ANDROID
[email protected]583418cc2013-01-17 14:01:10186
brettw4b461082016-11-19 18:55:16187#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17188#include "content/browser/media/session/pepper_playback_observer.h"
Lei Zhangebcc6302018-01-12 19:46:45189#endif
zqzhang181047e62016-07-01 13:37:17190
[email protected]8ff00d72012-10-23 19:12:21191namespace content {
Abigail Kleinaa898742019-11-01 02:31:25192
193using AccessibilityEventCallback =
194 base::RepeatingCallback<void(const std::string&)>;
195
[email protected]420ae012009-04-24 05:16:32196namespace {
197
[email protected]960b0372014-05-19 18:01:00198const int kMinimumDelayBetweenLoadingUpdatesMS = 100;
[email protected]82114f52012-03-20 22:53:41199const char kDotGoogleDotCom[] = ".google.com";
[email protected]ca406032011-07-19 21:53:05200
Sreeja Kamishettybe0ccd6b2020-06-09 11:52:50201using LifecycleState = RenderFrameHostImpl::LifecycleState;
202
Alexander Timin33bd754c02020-03-10 22:50:18203// TODO(crbug.com/1059903): Clean up after the initial investigation.
204constexpr base::Feature kCheckWebContentsAccessFromNonCurrentFrame{
205 "CheckWebContentsAccessFromNonCurrentFrame",
206 base::FEATURE_DISABLED_BY_DEFAULT};
207
Avi Drissmana9114822018-03-23 18:25:55208base::LazyInstance<std::vector<
209 WebContentsImpl::FriendWrapper::CreatedCallback>>::DestructorAtExit
210 g_created_callbacks = LAZY_INSTANCE_INITIALIZER;
[email protected]cbb1ef592013-06-05 19:49:46211
dcheng57e39e22016-01-21 00:25:38212bool HasMatchingProcess(FrameTree* tree, int render_process_id) {
213 for (FrameTreeNode* node : tree->Nodes()) {
214 if (node->current_frame_host()->GetProcess()->GetID() == render_process_id)
215 return true;
alexmos4cf2aa32015-07-15 23:40:43216 }
dcheng57e39e22016-01-21 00:25:38217 return false;
[email protected]95640212014-07-26 18:14:30218}
219
kenrb19221852016-04-29 17:21:40220bool HasMatchingWidgetHost(FrameTree* tree, RenderWidgetHost* host) {
221 // This method scans the frame tree rather than checking whether
222 // host->delegate() == this, which allows it to return false when the host
223 // for a frame that is pending or pending deletion.
224 if (!host)
225 return false;
226
227 for (FrameTreeNode* node : tree->Nodes()) {
228 if (node->current_frame_host()->GetRenderWidgetHost() == host)
229 return true;
230 }
231 return false;
232}
233
dmazzonif8a31042016-12-03 00:52:13234void UpdateAccessibilityModeOnFrame(RenderFrameHost* frame_host) {
235 static_cast<RenderFrameHostImpl*>(frame_host)->UpdateAccessibilityMode();
[email protected]95640212014-07-26 18:14:30236}
237
dtseng0dd3fa12015-07-22 19:00:52238void ResetAccessibility(RenderFrameHost* rfh) {
239 static_cast<RenderFrameHostImpl*>(rfh)->AccessibilityReset();
240}
241
Ian Clelland5cbaaf82017-11-27 22:00:03242RenderFrameHostImpl* FindOpenerRFH(const WebContents::CreateParams& params) {
243 RenderFrameHostImpl* opener_rfh = nullptr;
alexmose201c7cd2015-06-10 17:14:21244 if (params.opener_render_frame_id != MSG_ROUTING_NONE) {
Ian Clelland5cbaaf82017-11-27 22:00:03245 opener_rfh = RenderFrameHostImpl::FromID(params.opener_render_process_id,
246 params.opener_render_frame_id);
alexmose201c7cd2015-06-10 17:14:21247 }
Ian Clelland5cbaaf82017-11-27 22:00:03248 return opener_rfh;
lukasza6f8ac622017-06-06 03:10:20249}
250
Dominick Ng37a15052018-07-17 23:56:35251// Returns |true| if |type| is the kind of user input that should trigger the
252// user interaction observers.
253bool IsUserInteractionInputType(blink::WebInputEvent::Type type) {
254 // Ideally, this list would be based more off of
255 // https://whatwg.org/C/interaction.html#triggered-by-user-activation.
Dave Tapuska347d60a2020-04-21 23:55:47256 return type == blink::WebInputEvent::Type::kMouseDown ||
257 type == blink::WebInputEvent::Type::kGestureScrollBegin ||
258 type == blink::WebInputEvent::Type::kTouchStart ||
259 type == blink::WebInputEvent::Type::kRawKeyDown;
Dominick Ng37a15052018-07-17 23:56:35260}
261
Pavel Feldman3c1842b2017-08-02 05:00:16262// Ensures that OnDialogClosed is only called once.
263class CloseDialogCallbackWrapper
264 : public base::RefCountedThreadSafe<CloseDialogCallbackWrapper> {
265 public:
Avi Drissmane04d3992017-10-05 15:11:36266 using CloseCallback =
267 base::OnceCallback<void(bool, bool, const base::string16&)>;
268
269 explicit CloseDialogCallbackWrapper(CloseCallback callback)
270 : callback_(std::move(callback)) {}
Pavel Feldman3c1842b2017-08-02 05:00:16271
272 void Run(bool dialog_was_suppressed,
273 bool success,
274 const base::string16& user_input) {
Avi Drissmane04d3992017-10-05 15:11:36275 if (callback_.is_null())
Pavel Feldman3c1842b2017-08-02 05:00:16276 return;
Avi Drissmane04d3992017-10-05 15:11:36277 std::move(callback_).Run(dialog_was_suppressed, success, user_input);
Pavel Feldman3c1842b2017-08-02 05:00:16278 }
279
280 private:
281 friend class base::RefCountedThreadSafe<CloseDialogCallbackWrapper>;
282 ~CloseDialogCallbackWrapper() {}
Avi Drissmane04d3992017-10-05 15:11:36283
284 CloseCallback callback_;
Pavel Feldman3c1842b2017-08-02 05:00:16285};
286
Arthur Sonzogni929d29f2018-09-17 14:19:44287bool FrameCompareDepth(RenderFrameHostImpl* a, RenderFrameHostImpl* b) {
288 return a->frame_tree_node()->depth() < b->frame_tree_node()->depth();
289}
290
Raymes Khoury58373df2019-08-06 06:29:20291bool AreValidRegisterProtocolHandlerArguments(const std::string& protocol,
292 const GURL& url,
293 const url::Origin& origin) {
294 ChildProcessSecurityPolicyImpl* policy =
295 ChildProcessSecurityPolicyImpl::GetInstance();
296 if (policy->IsPseudoScheme(protocol))
297 return false;
298
299 url::Origin url_origin = url::Origin::Create(url);
300 if (url_origin.opaque())
301 return false;
302
303 if (!url_origin.IsSameOriginWith(origin))
304 return false;
305
306 return true;
307}
308
yilkal796e89e2019-10-02 23:58:28309void RecordMaxFrameCountUMA(size_t max_frame_count) {
310 UMA_HISTOGRAM_COUNTS_10000("Navigation.MainFrame.MaxFrameCount",
311 max_frame_count);
312}
313
Jeremy Roman03ce13ce2020-05-29 22:16:57314// Returns whether the condition provided applies to any inner contents.
315// This check is not recursive (however, the predicate provided may itself
316// recurse each contents' own inner contents).
317//
318// For example, if this is used to aggregate state from inner contents to outer
319// contents, then that propagation will gather transitive descendants without
320// need for this helper to do so. In fact, in such cases recursing on inner
321// contents here would make that operation quadratic rather than linear.
322template <typename Functor>
323bool AnyInnerWebContents(WebContents* web_contents, const Functor& f) {
324 const auto& inner_contents = web_contents->GetInnerWebContents();
325 return std::any_of(inner_contents.begin(), inner_contents.end(), f);
326}
327
Xuehui Xieb2300ae42020-06-09 20:25:05328std::vector<RenderFrameHost*> GetAllFramesImpl(FrameTree& frame_tree,
329 bool include_pending) {
330 std::vector<RenderFrameHost*> frame_hosts;
331 for (FrameTreeNode* node : frame_tree.Nodes()) {
332 frame_hosts.push_back(node->current_frame_host());
333 if (include_pending) {
334 RenderFrameHostImpl* pending_frame_host =
335 node->render_manager()->speculative_frame_host();
336 if (pending_frame_host)
337 frame_hosts.push_back(pending_frame_host);
338 }
339 }
340 return frame_hosts;
341}
342
343int SendToAllFramesImpl(FrameTree& frame_tree,
344 bool include_pending,
345 IPC::Message* message) {
346 int number_of_messages = 0;
347 std::vector<RenderFrameHost*> frame_hosts =
348 GetAllFramesImpl(frame_tree, include_pending);
349 for (RenderFrameHost* rfh : frame_hosts) {
350 if (!rfh->IsRenderFrameLive())
351 continue;
352
353 ++number_of_messages;
354 IPC::Message* message_copy = new IPC::Message(*message);
355 message_copy->set_routing_id(rfh->GetRoutingID());
356 rfh->Send(message_copy);
357 }
358 delete message;
359 return number_of_messages;
360}
361
Avi Drissman33972942020-06-19 14:16:01362// Returns the set of all WebContentses that are reachable from |web_contents|
363// by applying some combination of WebContents::GetOriginalOpener() and
364// WebContents::GetOuterWebContents(). The |web_contents| parameter will be
365// included in the returned set.
366base::flat_set<WebContentsImpl*> GetAllOpeningWebContents(
367 WebContentsImpl* web_contents) {
368 base::flat_set<WebContentsImpl*> result;
369 base::flat_set<WebContentsImpl*> current;
370
371 current.insert(web_contents);
372
373 while (!current.empty()) {
374 WebContentsImpl* current_contents = *current.begin();
375 current.erase(current.begin());
376 auto insert_result = result.insert(current_contents);
377
378 if (insert_result.second) {
379 RenderFrameHostImpl* opener_rfh = current_contents->GetOriginalOpener();
380 if (opener_rfh) {
381 current.insert(static_cast<WebContentsImpl*>(
382 WebContents::FromRenderFrameHost(opener_rfh)));
383 }
384
385 WebContentsImpl* outer_contents = current_contents->GetOuterWebContents();
386 if (outer_contents)
387 current.insert(outer_contents);
388 }
389 }
390
391 return result;
392}
393
394// Used to attach the "set of fullscreen contents" to a browser context. Storing
395// sets of WebContents on their browser context is done for two reasons. One,
396// related WebContentses must necessarily share a browser context, so this saves
397// lookup time by restricting to one specific browser context. Two, separating
398// by browser context is preemptive paranoia about keeping things separate.
399class FullscreenContentsHolder : public base::SupportsUserData::Data {
400 public:
401 FullscreenContentsHolder() = default;
402 ~FullscreenContentsHolder() override = default;
403
404 FullscreenContentsHolder(const FullscreenContentsHolder&) = delete;
405 FullscreenContentsHolder& operator=(const FullscreenContentsHolder&) = delete;
406
407 base::flat_set<WebContentsImpl*>* set() { return &set_; }
408
409 private:
410 base::flat_set<WebContentsImpl*> set_;
411};
412
413const char kFullscreenContentsSet[] = "fullscreen-contents";
414
415base::flat_set<WebContentsImpl*>* FullscreenContentsSet(
416 BrowserContext* browser_context) {
417 auto* set_holder = static_cast<FullscreenContentsHolder*>(
418 browser_context->GetUserData(kFullscreenContentsSet));
419 if (!set_holder) {
420 auto new_holder = std::make_unique<FullscreenContentsHolder>();
421 set_holder = new_holder.get();
422 browser_context->SetUserData(kFullscreenContentsSet, std::move(new_holder));
423 }
424
425 return set_holder->set();
426}
427
lukasza6f8ac622017-06-06 03:10:20428} // namespace
429
Joel Hockey8c2011b22020-04-30 05:07:19430CreatedWindow::CreatedWindow() = default;
431CreatedWindow::CreatedWindow(std::unique_ptr<WebContentsImpl> contents,
432 GURL target_url)
433 : contents(std::move(contents)), target_url(std::move(target_url)) {}
434CreatedWindow::~CreatedWindow() = default;
435CreatedWindow::CreatedWindow(CreatedWindow&&) = default;
436CreatedWindow& CreatedWindow::operator=(CreatedWindow&&) = default;
437
Erik Chenbb8e738e2018-04-28 14:10:43438std::unique_ptr<WebContents> WebContents::Create(
439 const WebContents::CreateParams& params) {
Albert J. Wong65fe64d2019-09-20 02:48:14440 return WebContentsImpl::Create(params);
441}
442
443std::unique_ptr<WebContentsImpl> WebContentsImpl::Create(
444 const CreateParams& params) {
445 return CreateWithOpener(params, FindOpenerRFH(params));
[email protected]d1198fd2012-08-13 22:50:19446}
447
erikchenade1fef2018-05-02 22:07:57448std::unique_ptr<WebContents> WebContents::CreateWithSessionStorage(
[email protected]54944cde2012-12-09 09:24:59449 const WebContents::CreateParams& params,
[email protected]fdac6ade2013-07-20 01:06:30450 const SessionStorageNamespaceMap& session_storage_namespace_map) {
erikchenade1fef2018-05-02 22:07:57451 std::unique_ptr<WebContentsImpl> new_contents(
452 new WebContentsImpl(params.browser_context));
Ian Clelland5cbaaf82017-11-27 22:00:03453 RenderFrameHostImpl* opener_rfh = FindOpenerRFH(params);
454 FrameTreeNode* opener = nullptr;
455 if (opener_rfh)
456 opener = opener_rfh->frame_tree_node();
457 new_contents->SetOpenerForNewContents(opener, params.opener_suppressed);
[email protected]fdac6ade2013-07-20 01:06:30458
jdoerrie55ec69d2018-10-08 13:34:46459 for (auto it = session_storage_namespace_map.begin();
460 it != session_storage_namespace_map.end(); ++it) {
Fergal Daly09d6c762020-05-29 02:05:18461 new_contents->GetController().SetSessionStorageNamespace(it->first,
462 it->second.get());
[email protected]fdac6ade2013-07-20 01:06:30463 }
464
Sean Toppingbbc4a2bd2019-01-30 02:16:14465 WebContentsImpl* outer_web_contents = nullptr;
Sam McNally69a33772018-06-27 16:54:12466 if (params.guest_delegate) {
467 // This makes |new_contents| act as a guest.
468 // For more info, see comment above class BrowserPluginGuest.
Albert J. Wongc55cc64d2018-10-12 02:50:04469 BrowserPluginGuest::CreateInWebContents(new_contents.get(),
470 params.guest_delegate);
Sean Toppingbbc4a2bd2019-01-30 02:16:14471 outer_web_contents = static_cast<WebContentsImpl*>(
472 params.guest_delegate->GetOwnerWebContents());
Sam McNally69a33772018-06-27 16:54:12473 }
474
[email protected]54944cde2012-12-09 09:24:59475 new_contents->Init(params);
Sean Toppingbbc4a2bd2019-01-30 02:16:14476 if (outer_web_contents)
477 outer_web_contents->InnerWebContentsCreated(new_contents.get());
[email protected]d1198fd2012-08-13 22:50:19478 return new_contents;
[email protected]a81343d232011-12-27 07:39:20479}
[email protected]746d3052012-05-22 15:15:47480
benwells5e7260d2017-03-20 23:36:33481void WebContentsImpl::FriendWrapper::AddCreatedCallbackForTesting(
nickf9acfbe2014-12-23 19:12:37482 const CreatedCallback& callback) {
[email protected]cbb1ef592013-06-05 19:49:46483 g_created_callbacks.Get().push_back(callback);
484}
485
benwells5e7260d2017-03-20 23:36:33486void WebContentsImpl::FriendWrapper::RemoveCreatedCallbackForTesting(
nickf9acfbe2014-12-23 19:12:37487 const CreatedCallback& callback) {
[email protected]cbb1ef592013-06-05 19:49:46488 for (size_t i = 0; i < g_created_callbacks.Get().size(); ++i) {
Robert Liao1db5a352019-06-05 20:57:34489 if (g_created_callbacks.Get().at(i) == callback) {
[email protected]cbb1ef592013-06-05 19:49:46490 g_created_callbacks.Get().erase(g_created_callbacks.Get().begin() + i);
491 return;
492 }
493 }
494}
495
avidf38c952015-10-27 13:45:13496WebContents* WebContents::FromRenderViewHost(RenderViewHost* rvh) {
497 if (!rvh)
498 return nullptr;
[email protected]746d3052012-05-22 15:15:47499 return rvh->GetDelegate()->GetAsWebContents();
500}
501
[email protected]a86c0e962013-12-17 17:10:39502WebContents* WebContents::FromRenderFrameHost(RenderFrameHost* rfh) {
avidf38c952015-10-27 13:45:13503 if (!rfh)
504 return nullptr;
Alexander Timin33bd754c02020-03-10 22:50:18505 if (!rfh->IsCurrent() && base::FeatureList::IsEnabled(
506 kCheckWebContentsAccessFromNonCurrentFrame)) {
507 // TODO(crbug.com/1059903): return nullptr here eventually.
508 base::debug::DumpWithoutCrashing();
509 }
avidf38c952015-10-27 13:45:13510 return static_cast<RenderFrameHostImpl*>(rfh)->delegate()->GetAsWebContents();
[email protected]a86c0e962013-12-17 17:10:39511}
512
ananta4b7467a52016-09-23 01:42:38513WebContents* WebContents::FromFrameTreeNodeId(int frame_tree_node_id) {
514 FrameTreeNode* frame_tree_node =
515 FrameTreeNode::GloballyFindByID(frame_tree_node_id);
anantab8cfa3b2016-10-14 22:43:19516 if (!frame_tree_node)
517 return nullptr;
jam8c4edd02017-05-06 18:50:33518 return WebContentsImpl::FromFrameTreeNode(frame_tree_node);
ananta4b7467a52016-09-23 01:42:38519}
520
leon.han552e9de2017-02-09 14:37:30521void WebContents::SetScreenOrientationDelegate(
522 ScreenOrientationDelegate* delegate) {
523 ScreenOrientationProvider::SetDelegate(delegate);
524}
525
[email protected]7fff43e2013-05-21 20:21:10526// WebContentsImpl::DestructionObserver ----------------------------------------
527
528class WebContentsImpl::DestructionObserver : public WebContentsObserver {
529 public:
530 DestructionObserver(WebContentsImpl* owner, WebContents* watched_contents)
Fergal Daly09d6c762020-05-29 02:05:18531 : WebContentsObserver(watched_contents), owner_(owner) {}
[email protected]7fff43e2013-05-21 20:21:10532
533 // WebContentsObserver:
dchengc2282aa2014-10-21 12:07:58534 void WebContentsDestroyed() override {
[email protected]12a46832014-05-09 13:35:58535 owner_->OnWebContentsDestroyed(
536 static_cast<WebContentsImpl*>(web_contents()));
[email protected]7fff43e2013-05-21 20:21:10537 }
538
539 private:
540 WebContentsImpl* owner_;
541
542 DISALLOW_COPY_AND_ASSIGN(DestructionObserver);
543};
544
Sreeja Kamishettybe0ccd6b2020-06-09 11:52:50545// TODO(sreejakshetty): Make |WebContentsImpl::ColorChooser| per-frame instead
546// of WebContents-owned.
Joel Hockey85b379d2017-12-11 10:42:13547// WebContentsImpl::ColorChooser ----------------------------------------------
Joel Hockey163835a2017-12-20 11:51:57548class WebContentsImpl::ColorChooser : public blink::mojom::ColorChooser {
Joel Hockey85b379d2017-12-11 10:42:13549 public:
550 ColorChooser(content::ColorChooser* chooser,
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20551 mojo::PendingReceiver<blink::mojom::ColorChooser> receiver,
552 mojo::PendingRemote<blink::mojom::ColorChooserClient> client)
Joel Hockey85b379d2017-12-11 10:42:13553 : chooser_(chooser),
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20554 receiver_(this, std::move(receiver)),
Joel Hockey85b379d2017-12-11 10:42:13555 client_(std::move(client)) {
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20556 receiver_.set_disconnect_handler(
Joel Hockey85b379d2017-12-11 10:42:13557 base::BindOnce([](content::ColorChooser* chooser) { chooser->End(); },
558 base::Unretained(chooser)));
559 }
[email protected]8ed16472014-04-11 19:02:48560
Joel Hockey85b379d2017-12-11 10:42:13561 ~ColorChooser() override { chooser_->End(); }
[email protected]8ed16472014-04-11 19:02:48562
Joel Hockey85b379d2017-12-11 10:42:13563 void SetSelectedColor(SkColor color) override {
564 chooser_->SetSelectedColor(color);
565 }
566
567 void DidChooseColorInColorChooser(SkColor color) {
568 client_->DidChooseColor(color);
569 }
570
571 private:
572 // Color chooser that was opened by this tab.
573 std::unique_ptr<content::ColorChooser> chooser_;
574
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20575 // mojo receiver.
576 mojo::Receiver<blink::mojom::ColorChooser> receiver_;
Joel Hockey85b379d2017-12-11 10:42:13577
578 // mojo renderer client.
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20579 mojo::Remote<blink::mojom::ColorChooserClient> client_;
Joel Hockey85b379d2017-12-11 10:42:13580};
nicka0ac8382016-12-15 23:59:23581
lazyboy6ec48b2a2015-06-29 15:18:14582// WebContentsImpl::WebContentsTreeNode ----------------------------------------
lfg601233692017-03-06 22:45:44583WebContentsImpl::WebContentsTreeNode::WebContentsTreeNode(
584 WebContentsImpl* current_web_contents)
585 : current_web_contents_(current_web_contents),
586 outer_web_contents_(nullptr),
lazyboy6ec48b2a2015-06-29 15:18:14587 outer_contents_frame_tree_node_id_(
avallee0206f782016-07-28 18:55:33588 FrameTreeNode::kFrameTreeNodeInvalidId),
lfg601233692017-03-06 22:45:44589 focused_web_contents_(current_web_contents) {}
lazyboy6ec48b2a2015-06-29 15:18:14590
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18591WebContentsImpl::WebContentsTreeNode::~WebContentsTreeNode() {}
lazyboy6ec48b2a2015-06-29 15:18:14592
Lucas Furukawa Gadani99125822019-01-03 15:41:49593std::unique_ptr<WebContents>
594WebContentsImpl::WebContentsTreeNode::DisconnectFromOuterWebContents() {
595 std::unique_ptr<WebContents> inner_contents =
596 outer_web_contents_->node_.DetachInnerWebContents(current_web_contents_);
597 OuterContentsFrameTreeNode()->RemoveObserver(this);
598 outer_contents_frame_tree_node_id_ = FrameTreeNode::kFrameTreeNodeInvalidId;
599 outer_web_contents_ = nullptr;
600 return inner_contents;
601}
602
paulmeyerfeafc2d2017-04-25 21:46:40603void WebContentsImpl::WebContentsTreeNode::AttachInnerWebContents(
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:50604 std::unique_ptr<WebContents> inner_web_contents,
605 RenderFrameHostImpl* render_frame_host) {
606 WebContentsImpl* inner_web_contents_impl =
607 static_cast<WebContentsImpl*>(inner_web_contents.get());
608 WebContentsTreeNode& inner_web_contents_node = inner_web_contents_impl->node_;
609
610 inner_web_contents_node.focused_web_contents_ = nullptr;
611 inner_web_contents_node.outer_web_contents_ = current_web_contents_;
612 inner_web_contents_node.outer_contents_frame_tree_node_id_ =
613 render_frame_host->frame_tree_node()->frame_tree_node_id();
614
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18615 inner_web_contents_.push_back(std::move(inner_web_contents));
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:50616
617 render_frame_host->frame_tree_node()->AddObserver(&inner_web_contents_node);
Jeremy Roman03ce13ce2020-05-29 22:16:57618 current_web_contents_->InnerWebContentsAttached(inner_web_contents_impl);
paulmeyerfeafc2d2017-04-25 21:46:40619}
620
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18621std::unique_ptr<WebContents>
622WebContentsImpl::WebContentsTreeNode::DetachInnerWebContents(
paulmeyerfeafc2d2017-04-25 21:46:40623 WebContentsImpl* inner_web_contents) {
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18624 std::unique_ptr<WebContents> detached_contents;
625 for (std::unique_ptr<WebContents>& web_contents : inner_web_contents_) {
626 if (web_contents.get() == inner_web_contents) {
627 detached_contents = std::move(web_contents);
628 std::swap(web_contents, inner_web_contents_.back());
629 inner_web_contents_.pop_back();
Jeremy Roman03ce13ce2020-05-29 22:16:57630 current_web_contents_->InnerWebContentsDetached(inner_web_contents);
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18631 return detached_contents;
632 }
633 }
634
635 NOTREACHED();
636 return nullptr;
paulmeyerfeafc2d2017-04-25 21:46:40637}
638
lfga3e2bdc2017-03-07 20:44:01639FrameTreeNode*
640WebContentsImpl::WebContentsTreeNode::OuterContentsFrameTreeNode() const {
641 return FrameTreeNode::GloballyFindByID(outer_contents_frame_tree_node_id_);
lfg601233692017-03-06 22:45:44642}
643
lfga3e2bdc2017-03-07 20:44:01644void WebContentsImpl::WebContentsTreeNode::OnFrameTreeNodeDestroyed(
645 FrameTreeNode* node) {
646 DCHECK_EQ(outer_contents_frame_tree_node_id_, node->frame_tree_node_id())
647 << "WebContentsTreeNode should only receive notifications for the "
648 "FrameTreeNode in its outer WebContents that hosts it.";
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18649
650 // Deletes |this| too.
651 outer_web_contents_->node_.DetachInnerWebContents(current_web_contents_);
lazyboy6ec48b2a2015-06-29 15:18:14652}
653
avallee0206f782016-07-28 18:55:33654void WebContentsImpl::WebContentsTreeNode::SetFocusedWebContents(
655 WebContentsImpl* web_contents) {
656 DCHECK(!outer_web_contents())
657 << "Only the outermost WebContents tracks focus.";
658 focused_web_contents_ = web_contents;
659}
660
paulmeyerfeafc2d2017-04-25 21:46:40661WebContentsImpl*
662WebContentsImpl::WebContentsTreeNode::GetInnerWebContentsInFrame(
663 const FrameTreeNode* frame) {
664 auto ftn_id = frame->frame_tree_node_id();
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18665 for (auto& contents : inner_web_contents_) {
666 WebContentsImpl* impl = static_cast<WebContentsImpl*>(contents.get());
667 if (impl->node_.outer_contents_frame_tree_node_id() == ftn_id) {
668 return impl;
paulmeyerfeafc2d2017-04-25 21:46:40669 }
670 }
671 return nullptr;
672}
673
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18674std::vector<WebContentsImpl*>
675WebContentsImpl::WebContentsTreeNode::GetInnerWebContents() const {
676 std::vector<WebContentsImpl*> inner_web_contents;
677 for (auto& contents : inner_web_contents_)
678 inner_web_contents.push_back(static_cast<WebContentsImpl*>(contents.get()));
679
680 return inner_web_contents;
paulmeyerfeafc2d2017-04-25 21:46:40681}
682
[email protected]b172aee2012-04-10 17:05:26683// WebContentsImpl -------------------------------------------------------------
[email protected]420ae012009-04-24 05:16:32684
alexmose201c7cd2015-06-10 17:14:21685WebContentsImpl::WebContentsImpl(BrowserContext* browser_context)
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28686 : delegate_(nullptr),
[email protected]69e797f2013-04-30 01:10:22687 controller_(this, browser_context),
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28688 render_view_host_delegate_view_(nullptr),
alexmose201c7cd2015-06-10 17:14:21689 created_with_opener_(false),
Lucas Furukawa Gadani99125822019-01-03 15:41:49690 node_(this),
Fergal Daly09d6c762020-05-29 02:05:18691 frame_tree_(&controller_, this, this, this, this, this),
[email protected]6dfed692014-05-22 04:18:03692 is_load_to_different_document_(false),
[email protected]443b80e2010-12-14 00:42:23693 crashed_status_(base::TERMINATION_STATUS_STILL_RUNNING),
694 crashed_error_code_(0),
[email protected]d5f942ba2008-09-26 19:30:34695 waiting_for_response_(false),
[email protected]fcf75d42013-12-03 20:11:26696 load_state_(net::LOAD_STATE_IDLE, base::string16()),
[email protected]094e5b22009-09-25 04:23:56697 upload_size_(0),
698 upload_position_(0),
dfalcantarae6b7b46752015-07-10 18:14:16699 is_resume_pending_(false),
[email protected]b4c84012014-04-28 19:51:10700 has_accessed_initial_document_(false),
Collin Bakerc5259962019-11-14 17:51:58701 visible_capturer_count_(0),
702 hidden_capturer_count_(0),
[email protected]fdd61c62009-04-22 19:22:57703 is_being_destroyed_(false),
creis97867aa2017-02-17 18:39:45704 is_notifying_observers_(false),
[email protected]fdd61c62009-04-22 19:22:57705 notify_disconnection_(false),
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28706 dialog_manager_(nullptr),
[email protected]7ab1e7d62009-10-14 23:32:01707 is_showing_before_unload_dialog_(false),
gab0dccfef2015-05-20 18:43:39708 last_active_time_(base::TimeTicks::Now()),
[email protected]ebf40a72010-07-22 01:46:38709 closed_by_user_gesture_(false),
danakj938b37a62019-09-24 18:35:54710 minimum_zoom_percent_(
711 static_cast<int>(blink::kMinimumPageZoomFactor * 100)),
712 maximum_zoom_percent_(
713 static_cast<int>(blink::kMaximumPageZoomFactor * 100)),
w.shackleton49bcd392016-01-06 17:38:22714 zoom_scroll_remainder_(0),
alexmosc9e76ec2016-05-16 22:59:37715 fullscreen_widget_process_id_(ChildProcessHost::kInvalidUniqueID),
[email protected]5dcaf8e2013-12-28 01:31:42716 fullscreen_widget_routing_id_(MSG_ROUTING_NONE),
[email protected]0b431992014-06-24 00:08:03717 fullscreen_widget_had_focus_at_shutdown_(false),
[email protected]34ff1cfc2014-08-20 06:16:05718 force_disable_overscroll_content_(false),
[email protected]95640212014-07-26 18:14:30719 last_dialog_suppressed_(false),
waffles1c12bf402016-02-10 17:45:48720 accessibility_mode_(
Dominic Mazzoni21fb0282019-02-13 18:32:47721 GetContentClient()->browser()->GetAXModeForBrowserContext(
722 browser_context)),
avayvodcc85bbd2015-08-28 19:11:15723 audio_stream_monitor_(this),
Thomas Guilbert882c4cec2019-02-14 05:55:45724 media_web_contents_observer_(
725 std::make_unique<MediaWebContentsObserver>(this)),
mcnee336ea2c2017-05-23 22:50:59726#if !defined(OS_ANDROID)
mcnee432e47d2015-11-09 19:37:46727 page_scale_factor_is_one_(true),
mcnee336ea2c2017-05-23 22:50:59728#endif // !defined(OS_ANDROID)
qinmin72e8bd02016-10-21 19:35:37729 is_overlay_content_(false),
ekaramadf6750aa2017-06-06 18:29:42730 showing_context_menu_(false),
W. James MacLean62198672019-06-04 16:46:10731 text_autosizer_page_info_({0, 0, 1.f}),
shivanigithubcceeacf2020-03-06 20:00:27732 native_theme_observer_(this) {
danakjf4b9e942019-11-29 15:43:04733 frame_tree_.SetFrameRemoveListener(base::BindRepeating(
734 &WebContentsImpl::OnFrameRemoved, base::Unretained(this)));
brettw4b461082016-11-19 18:55:16735#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17736 pepper_playback_observer_.reset(new PepperPlaybackObserver(this));
737#endif
blundelle75a8f92017-03-27 08:11:17738
Becca Hughes86334622018-07-09 21:29:38739#if defined(OS_ANDROID)
Elly Fong-Jonescdd7ae82019-02-20 23:26:33740 display_cutout_host_impl_ = std::make_unique<DisplayCutoutHostImpl>(this);
Becca Hughes86334622018-07-09 21:29:38741#endif
John Delaney732721e92020-02-07 23:11:27742
Alison Maher7f366dc62020-03-03 19:46:00743 ui::NativeTheme* native_theme = ui::NativeTheme::GetInstanceForWeb();
744 native_theme_observer_.Add(native_theme);
745 using_dark_colors_ = native_theme->ShouldUseDarkColors();
746 preferred_color_scheme_ = native_theme->GetPreferredColorScheme();
747
Mike Wassermanb213b9352020-04-16 00:32:34748 screen_change_monitor_ =
749 std::make_unique<ScreenChangeMonitor>(base::BindRepeating(
750 &WebContentsImpl::OnScreensChange, base::Unretained(this)));
751
John Delaney732721e92020-02-07 23:11:27752 // ConversionHost takes a weak ref on |this|, so it must be created outside of
753 // the initializer list.
Charlie Harrison405f6212020-04-14 21:57:32754 if (base::FeatureList::IsEnabled(features::kConversionMeasurement)) {
755 conversion_host_ = std::make_unique<ConversionHost>(this);
756 }
[email protected]332af7732009-03-11 13:21:35757}
initial.commit09911bf2008-07-26 23:55:29758
[email protected]b172aee2012-04-10 17:05:26759WebContentsImpl::~WebContentsImpl() {
creisba91ba82017-05-12 22:56:19760 // Imperfect sanity check against double free, given some crashes unexpectedly
761 // observed in the wild.
762 CHECK(!is_being_destroyed_);
763
764 // We generally keep track of is_being_destroyed_ to let other features know
765 // to avoid certain actions during destruction.
[email protected]420ae012009-04-24 05:16:32766 is_being_destroyed_ = true;
767
creis97867aa2017-02-17 18:39:45768 // A WebContents should never be deleted while it is notifying observers,
creisba91ba82017-05-12 22:56:19769 // since this will lead to a use-after-free as it continues to notify later
creis97867aa2017-02-17 18:39:45770 // observers.
771 CHECK(!is_notifying_observers_);
772
Avi Drissman33972942020-06-19 14:16:01773 FullscreenContentsSet(GetBrowserContext())->erase(this);
774
kenrb2a565f82015-09-02 20:24:59775 rwh_input_event_router_.reset();
776
Julie Jeongeun Kim7d0986172019-12-04 03:17:25777 for (auto& entry : receiver_sets_)
778 entry.second->CloseAllReceivers();
rockotf62002a2016-09-15 00:08:59779
avallee0206f782016-07-28 18:55:33780 WebContentsImpl* outermost = GetOutermostWebContents();
avallee9993fca2016-11-17 06:16:50781 if (this != outermost && ContainsOrIsFocusedWebContents()) {
avallee0206f782016-07-28 18:55:33782 // If the current WebContents is in focus, unset it.
avallee9993fca2016-11-17 06:16:50783 outermost->SetAsFocusedWebContentsIfNecessary();
avallee0206f782016-07-28 18:55:33784 }
785
Nick Carterd73635b2018-03-13 18:31:41786 if (mouse_lock_widget_)
James Hollyerd5c9de462020-03-10 19:02:45787 mouse_lock_widget_->RejectMouseLockOrUnlockIfNecessary(
788 blink::mojom::PointerLockResult::kElementDestroyed);
Nick Carterd73635b2018-03-13 18:31:41789
dcheng72be33c2016-01-21 04:11:31790 for (FrameTreeNode* node : frame_tree_.Nodes()) {
791 // Delete all RFHs pending shutdown, which will lead the corresponding RVHs
792 // to be shutdown and be deleted as well.
dcheng57e39e22016-01-21 00:25:38793 node->render_manager()->ClearRFHsPendingShutdown();
dcheng57e39e22016-01-21 00:25:38794 node->render_manager()->ClearWebUIInstances();
dcheng72be33c2016-01-21 04:11:31795 }
carlosk35f35af2015-12-01 10:55:40796
dcheng57e39e22016-01-21 00:25:38797 for (RenderWidgetHostImpl* widget : created_widgets_)
798 widget->DetachDelegate();
[email protected]b24b68a2012-09-24 21:57:26799 created_widgets_.clear();
800
[email protected]3ab9cb82011-06-03 18:02:07801 // Clear out any JavaScript state.
avi5d3b8692016-10-12 22:00:46802 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:53803 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:46804 }
[email protected]3ab9cb82011-06-03 18:02:07805
Joel Hockey85b379d2017-12-11 10:42:13806 color_chooser_.reset();
Rakina Zata Amni16196122018-11-14 02:14:00807 find_request_manager_.reset();
[email protected]da8543762012-03-20 08:52:20808
[email protected]420ae012009-04-24 05:16:32809 NotifyDisconnected();
[email protected]420ae012009-04-24 05:16:32810
[email protected]ca13a442012-04-17 14:00:12811 // Notify any observer that have a reference on this WebContents.
[email protected]8ff00d72012-10-23 19:12:21812 NotificationService::current()->Notify(
813 NOTIFICATION_WEB_CONTENTS_DESTROYED,
814 Source<WebContents>(this),
815 NotificationService::NoDetails());
[email protected]420ae012009-04-24 05:16:32816
Arthur Sonzogni5a9a88c2018-10-18 13:16:00817 // Destroy all subframes now. This notifies observers.
818 GetMainFrame()->ResetChildren();
[email protected]df0c843f2014-05-23 20:37:23819 GetRenderManager()->ResetProxyHosts();
[email protected]c06c58c2014-03-12 20:31:59820
clamy0e119882015-07-31 16:12:33821 // Manually call the observer methods for the root frame tree node. It is
822 // necessary to manually delete all objects tracking navigations
823 // (NavigationHandle, NavigationRequest) for observers to be properly
824 // notified of these navigations stopping before the WebContents is
825 // destroyed.
[email protected]df0c843f2014-05-23 20:37:23826 RenderFrameHostManager* root = GetRenderManager();
naskob21fe4872015-02-24 14:15:56827
Lowell Manners20250112019-10-18 15:06:15828 GetController().GetBackForwardCache().Shutdown();
829
naskob21fe4872015-02-24 14:15:56830 root->current_frame_host()->SetRenderFrameCreated(false);
clamyfc3850d2018-02-23 14:35:28831 root->current_frame_host()->ResetNavigationRequests();
clamy0e119882015-07-31 16:12:33832
Arthur Hemeryc3380172018-01-22 14:00:17833 // Do not update state as the WebContents is being destroyed.
Arthur Hemery241b9392019-10-24 11:08:41834 frame_tree_.root()->ResetNavigationRequest(true);
Arthur Hemeryc3380172018-01-22 14:00:17835 if (root->speculative_frame_host()) {
danakjf2342432019-05-15 21:46:09836 root->speculative_frame_host()->DeleteRenderFrame(
837 FrameDeleteIntention::kSpeculativeMainFrameForShutdown);
Arthur Hemeryc3380172018-01-22 14:00:17838 root->speculative_frame_host()->SetRenderFrameCreated(false);
clamyfc3850d2018-02-23 14:35:28839 root->speculative_frame_host()->ResetNavigationRequests();
clamy0e119882015-07-31 16:12:33840 }
[email protected]f273ee52013-10-18 16:05:27841
brettw4b461082016-11-19 18:55:16842#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17843 // Call this before WebContentsDestroyed() is broadcasted since
844 // AudioFocusManager will be destroyed after that.
845 pepper_playback_observer_.reset();
846#endif // defined(ENABLED_PLUGINS)
847
Chris Hamiltondf0d72cd2018-05-29 16:23:53848 // If audio is playing then notify external observers of the audio stream
849 // disappearing.
850 if (is_currently_audible_) {
851 is_currently_audible_ = false;
852 for (auto& observer : observers_)
853 observer.OnAudioStateChanged(false);
854
855 if (GetOuterWebContents())
856 GetOuterWebContents()->OnAudioStateChanged();
857 }
858
ericwilligersde386342016-10-19 02:35:09859 for (auto& observer : observers_)
860 observer.FrameDeleted(root->current_frame_host());
naskoa83483fb2015-02-27 16:57:10861
ericwilligersde386342016-10-19 02:35:09862 for (auto& observer : observers_)
863 observer.RenderViewDeleted(root->current_host());
[email protected]f273ee52013-10-18 16:05:27864
Kevin McNee576bb5d82019-05-29 16:47:51865#if defined(OS_ANDROID)
866 // For simplicity, destroy the Java WebContents before we notify of the
867 // destruction of the WebContents.
868 ClearWebContentsAndroid();
869#endif
870
ericwilligersde386342016-10-19 02:35:09871 for (auto& observer : observers_)
872 observer.WebContentsDestroyed();
[email protected]12a46832014-05-09 13:35:58873
Becca Hughesd11d6502018-07-31 17:01:28874 if (display_cutout_host_impl_)
875 display_cutout_host_impl_->WebContentsDestroyed();
876
ericwilligersde386342016-10-19 02:35:09877 for (auto& observer : observers_)
878 observer.ResetWebContents();
[email protected]232a5812011-03-04 22:42:08879
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28880 SetDelegate(nullptr);
[email protected]b5a1d11c2011-02-17 03:09:42881}
882
erikchen50735fd2018-05-05 15:08:33883std::unique_ptr<WebContentsImpl> WebContentsImpl::CreateWithOpener(
[email protected]54944cde2012-12-09 09:24:59884 const WebContents::CreateParams& params,
Ian Clelland5cbaaf82017-11-27 22:00:03885 RenderFrameHostImpl* opener_rfh) {
[email protected]e11f0e92013-06-12 15:12:03886 TRACE_EVENT0("browser", "WebContentsImpl::CreateWithOpener");
Ian Clelland5cbaaf82017-11-27 22:00:03887 FrameTreeNode* opener = nullptr;
888 if (opener_rfh)
889 opener = opener_rfh->frame_tree_node();
erikchen50735fd2018-05-05 15:08:33890 std::unique_ptr<WebContentsImpl> new_contents(
891 new WebContentsImpl(params.browser_context));
lukasza6f8ac622017-06-06 03:10:20892 new_contents->SetOpenerForNewContents(opener, params.opener_suppressed);
alexmose201c7cd2015-06-10 17:14:21893
alexmosaedfc6f2016-01-21 23:57:38894 // If the opener is sandboxed, a new popup must inherit the opener's sandbox
895 // flags, and these flags take effect immediately. An exception is if the
896 // opener's sandbox flags lack the PropagatesToAuxiliaryBrowsingContexts
897 // bit (which is controlled by the "allow-popups-to-escape-sandbox" token).
898 // See https://html.spec.whatwg.org/#attr-iframe-sandbox.
lukasza6f8ac622017-06-06 03:10:20899 FrameTreeNode* new_root = new_contents->GetFrameTree()->root();
alexmosaedfc6f2016-01-21 23:57:38900 if (opener) {
arthursonzognib93a4472020-04-10 07:38:00901 network::mojom::WebSandboxFlags opener_flags =
Antonio Gomes7096ac02020-02-14 14:29:54902 opener_rfh->active_sandbox_flags();
arthursonzognib93a4472020-04-10 07:38:00903 const network::mojom::WebSandboxFlags inherit_flag =
904 network::mojom::WebSandboxFlags::kPropagatesToAuxiliaryBrowsingContexts;
Ehsan Karamad39407082019-02-19 23:38:19905 bool sandbox_propagates_to_auxilary_context =
906 (opener_flags & inherit_flag) == inherit_flag;
907 if (sandbox_propagates_to_auxilary_context)
Charlie Hue1b77ac2019-12-13 21:30:17908 new_root->SetPendingFramePolicy({opener_flags,
909 {} /* container_policy */,
910 {} /* required_document_policy */});
arthursonzognib93a4472020-04-10 07:38:00911 if (opener_flags == network::mojom::WebSandboxFlags::kNone ||
Ehsan Karamad39407082019-02-19 23:38:19912 sandbox_propagates_to_auxilary_context) {
913 // TODO(ekaramad, iclelland): Do not propagate feature policies from non-
914 // sandboxed disowned openers (rel=noopener).
915 // If the current page is not sandboxed, or if the sandbox is to propagate
916 // to the popups then opener's feature policy will apply to the new popup
917 // as well.
918 new_root->SetOpenerFeaturePolicyState(
Ehsan Karamad34d10682019-02-26 20:55:04919 opener_rfh->feature_policy()->GetFeatureState());
alexmosaedfc6f2016-01-21 23:57:38920 }
921 }
922
mark a. foltzef394fce2017-10-21 09:11:02923 // Apply starting sandbox flags.
Luna Luc3fdacdf2017-11-08 04:48:53924 blink::FramePolicy frame_policy(new_root->pending_frame_policy());
mark a. foltzef394fce2017-10-21 09:11:02925 frame_policy.sandbox_flags |= params.starting_sandbox_flags;
926 new_root->SetPendingFramePolicy(frame_policy);
Charlie Hu5ffc0152019-12-06 15:59:53927 new_root->CommitFramePolicy(frame_policy);
mark a. foltzef394fce2017-10-21 09:11:02928
alexmose201c7cd2015-06-10 17:14:21929 // This may be true even when opener is null, such as when opening blocked
930 // popups.
alexmos090fae8e2015-05-28 17:09:28931 if (params.created_with_opener)
932 new_contents->created_with_opener_ = true;
933
Sean Toppingbbc4a2bd2019-01-30 02:16:14934 WebContentsImpl* outer_web_contents = nullptr;
[email protected]4858e432014-06-23 18:14:17935 if (params.guest_delegate) {
[email protected]83100cd2014-05-10 11:50:06936 // This makes |new_contents| act as a guest.
937 // For more info, see comment above class BrowserPluginGuest.
Albert J. Wongc55cc64d2018-10-12 02:50:04938 BrowserPluginGuest::CreateInWebContents(new_contents.get(),
939 params.guest_delegate);
Sean Toppingbbc4a2bd2019-01-30 02:16:14940 outer_web_contents = static_cast<WebContentsImpl*>(
941 params.guest_delegate->GetOwnerWebContents());
[email protected]83100cd2014-05-10 11:50:06942 }
mark a. foltzef394fce2017-10-21 09:11:02943
[email protected]54944cde2012-12-09 09:24:59944 new_contents->Init(params);
Sean Toppingbbc4a2bd2019-01-30 02:16:14945 if (outer_web_contents)
946 outer_web_contents->InnerWebContentsCreated(new_contents.get());
[email protected]d1198fd2012-08-13 22:50:19947 return new_contents;
948}
949
[email protected]95640212014-07-26 18:14:30950// static
951std::vector<WebContentsImpl*> WebContentsImpl::GetAllWebContents() {
952 std::vector<WebContentsImpl*> result;
dcheng59716272016-04-09 05:19:08953 std::unique_ptr<RenderWidgetHostIterator> widgets(
[email protected]95640212014-07-26 18:14:30954 RenderWidgetHostImpl::GetRenderWidgetHosts());
[email protected]95640212014-07-26 18:14:30955 while (RenderWidgetHost* rwh = widgets->GetNextHost()) {
[email protected]95640212014-07-26 18:14:30956 RenderViewHost* rvh = RenderViewHost::From(rwh);
957 if (!rvh)
958 continue;
959 WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
960 if (!web_contents)
961 continue;
avidf38c952015-10-27 13:45:13962 if (web_contents->GetRenderViewHost() != rvh)
963 continue;
964 // Because a WebContents can only have one current RVH at a time, there will
965 // be no duplicate WebContents here.
966 result.push_back(static_cast<WebContentsImpl*>(web_contents));
[email protected]95640212014-07-26 18:14:30967 }
968 return result;
969}
970
clamya16aa8172015-05-26 13:07:25971// static
972WebContentsImpl* WebContentsImpl::FromFrameTreeNode(
paulmeyerfeafc2d2017-04-25 21:46:40973 const FrameTreeNode* frame_tree_node) {
clamya16aa8172015-05-26 13:07:25974 return static_cast<WebContentsImpl*>(
975 WebContents::FromRenderFrameHost(frame_tree_node->current_frame_host()));
976}
977
clamy0d32d6d2015-11-24 11:16:26978// static
Patrick Monette275a6f92b2020-01-09 21:05:04979WebContents* WebContentsImpl::FromRenderFrameHostID(
980 GlobalFrameRoutingId render_frame_host_id) {
981 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
982 !BrowserThread::IsThreadInitialized(BrowserThread::UI));
Patrick Monette7364e6972020-01-09 22:56:02983 RenderFrameHost* render_frame_host =
984 RenderFrameHost::FromID(render_frame_host_id);
985 if (!render_frame_host)
986 return nullptr;
987
988 return WebContents::FromRenderFrameHost(render_frame_host);
Patrick Monette275a6f92b2020-01-09 21:05:04989}
990
991// static
clamy0d32d6d2015-11-24 11:16:26992WebContents* WebContentsImpl::FromRenderFrameHostID(int render_process_host_id,
993 int render_frame_host_id) {
Patrick Monette7364e6972020-01-09 22:56:02994 return FromRenderFrameHostID(
995 GlobalFrameRoutingId(render_process_host_id, render_frame_host_id));
clamy0d32d6d2015-11-24 11:16:26996}
997
paulmeyerfeafc2d2017-04-25 21:46:40998// static
999WebContentsImpl* WebContentsImpl::FromOuterFrameTreeNode(
1000 const FrameTreeNode* frame_tree_node) {
1001 return WebContentsImpl::FromFrameTreeNode(frame_tree_node)
1002 ->node_.GetInnerWebContentsInFrame(frame_tree_node);
1003}
1004
[email protected]b0936d22013-11-28 06:47:361005RenderFrameHostManager* WebContentsImpl::GetRenderManagerForTesting() {
[email protected]fa944cb82013-11-15 17:51:211006 return GetRenderManager();
[email protected]765187182012-01-11 23:59:281007}
1008
nicka0ac8382016-12-15 23:59:231009bool WebContentsImpl::OnMessageReceived(RenderViewHostImpl* render_view_host,
[email protected]7bb761892012-07-20 09:32:471010 const IPC::Message& message) {
nicka0ac8382016-12-15 23:59:231011 for (auto& observer : observers_) {
Lukasz Anforowicz89f2c1b2017-08-30 21:36:461012 // TODO(nick, creis): https://crbug.com/758026: Replace all uses of this
1013 // variant of OnMessageReceived with the version that takes a
1014 // RenderFrameHost, and then delete it.
nicka0ac8382016-12-15 23:59:231015 if (observer.OnMessageReceived(message))
1016 return true;
[email protected]64ffefa2014-05-10 12:06:331017 }
[email protected]403415a2011-01-10 18:57:531018
Henrique Ferreiroba535472020-04-21 11:38:361019#if BUILDFLAG(ENABLE_PLUGINS)
[email protected]724159a2010-12-30 01:11:181020 bool handled = true;
nicka0ac8382016-12-15 23:59:231021 IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(WebContentsImpl, message, render_view_host)
nicka0ac8382016-12-15 23:59:231022 IPC_MESSAGE_HANDLER(ViewHostMsg_RequestPpapiBrokerPermission,
1023 OnRequestPpapiBrokerPermission)
nicka0ac8382016-12-15 23:59:231024 IPC_MESSAGE_UNHANDLED(handled = false)
1025 IPC_END_MESSAGE_MAP()
nicka0ac8382016-12-15 23:59:231026 return handled;
Henrique Ferreiroba535472020-04-21 11:38:361027#else
1028 return false;
1029#endif
nicka0ac8382016-12-15 23:59:231030}
1031
1032bool WebContentsImpl::OnMessageReceived(RenderFrameHostImpl* render_frame_host,
1033 const IPC::Message& message) {
Denis Kuznetsov [CET]2c6f0159f2020-05-18 14:18:161034 {
1035 WebUIImpl* web_ui = render_frame_host->web_ui();
1036 if (web_ui && web_ui->OnMessageReceived(message, render_frame_host))
1037 return true;
1038 }
1039
nicka0ac8382016-12-15 23:59:231040 for (auto& observer : observers_) {
1041 if (observer.OnMessageReceived(message, render_frame_host))
1042 return true;
1043 }
1044
1045 bool handled = true;
1046 IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(WebContentsImpl, message, render_frame_host)
avi3a3332622015-09-01 01:18:541047 IPC_MESSAGE_HANDLER(FrameHostMsg_DidRunInsecureContent,
[email protected]724159a2010-12-30 01:11:181048 OnDidRunInsecureContent)
estark910b4572015-12-09 20:55:411049 IPC_MESSAGE_HANDLER(FrameHostMsg_DidDisplayContentWithCertificateErrors,
1050 OnDidDisplayContentWithCertificateErrors)
1051 IPC_MESSAGE_HANDLER(FrameHostMsg_DidRunContentWithCertificateErrors,
1052 OnDidRunContentWithCertificateErrors)
brettw4b461082016-11-19 18:55:161053#if BUILDFLAG(ENABLE_PLUGINS)
emaxxe70f5e12015-05-29 11:26:001054 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperInstanceCreated,
1055 OnPepperInstanceCreated)
1056 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperInstanceDeleted,
1057 OnPepperInstanceDeleted)
tommyclie6633ca72014-10-31 00:40:421058 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperPluginHung, OnPepperPluginHung)
zqzhang181047e62016-07-01 13:37:171059 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperStartsPlayback,
1060 OnPepperStartsPlayback)
1061 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperStopsPlayback,
1062 OnPepperStopsPlayback)
tommyclie6633ca72014-10-31 00:40:421063 IPC_MESSAGE_HANDLER(FrameHostMsg_PluginCrashed, OnPluginCrashed)
thestigc4cac8f2014-09-04 21:17:501064#endif
[email protected]724159a2010-12-30 01:11:181065 IPC_MESSAGE_UNHANDLED(handled = false)
[email protected]e44d1342014-05-16 21:29:331066 IPC_END_MESSAGE_MAP()
[email protected]724159a2010-12-30 01:11:181067
[email protected]724159a2010-12-30 01:11:181068 return handled;
1069}
1070
[email protected]d1198fd2012-08-13 22:50:191071NavigationControllerImpl& WebContentsImpl::GetController() {
[email protected]f5fa20e2011-12-21 22:35:561072 return controller_;
1073}
1074
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411075BrowserContext* WebContentsImpl::GetBrowserContext() {
[email protected]a26023822011-12-29 00:23:551076 return controller_.GetBrowserContext();
[email protected]627e0512011-12-21 22:55:301077}
1078
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411079const GURL& WebContentsImpl::GetURL() {
Peter Boström101d7672018-12-15 00:43:591080 return GetVisibleURL();
[email protected]be1f56ab2011-12-22 06:55:311081}
1082
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411083const GURL& WebContentsImpl::GetVisibleURL() {
[email protected]c854a7e2013-05-21 16:42:241084 // We may not have a navigation entry yet.
[email protected]59167c22013-06-03 18:07:321085 NavigationEntry* entry = controller_.GetVisibleEntry();
[email protected]c854a7e2013-05-21 16:42:241086 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
1087}
1088
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411089const GURL& WebContentsImpl::GetLastCommittedURL() {
[email protected]c854a7e2013-05-21 16:42:241090 // We may not have a navigation entry yet.
1091 NavigationEntry* entry = controller_.GetLastCommittedEntry();
1092 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
1093}
1094
[email protected]8ff00d72012-10-23 19:12:211095WebContentsDelegate* WebContentsImpl::GetDelegate() {
[email protected]be1f56ab2011-12-22 06:55:311096 return delegate_;
1097}
1098
[email protected]8ff00d72012-10-23 19:12:211099void WebContentsImpl::SetDelegate(WebContentsDelegate* delegate) {
[email protected]be1f56ab2011-12-22 06:55:311100 // TODO(cbentzel): remove this debugging code?
1101 if (delegate == delegate_)
1102 return;
1103 if (delegate_)
1104 delegate_->Detach(this);
1105 delegate_ = delegate;
[email protected]a6b73c62013-02-11 23:05:081106 if (delegate_) {
[email protected]be1f56ab2011-12-22 06:55:311107 delegate_->Attach(this);
[email protected]a6b73c62013-02-11 23:05:081108 // Ensure the visible RVH reflects the new delegate's preferences.
[email protected]86f98a22013-03-20 14:35:001109 if (view_)
[email protected]e85165c642014-06-10 14:34:311110 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
Joel Einbinder848001c2017-09-19 21:39:311111 if (GetRenderViewHost())
1112 RenderFrameDevToolsAgentHost::WebContentsCreated(this);
[email protected]a6b73c62013-02-11 23:05:081113 }
[email protected]be1f56ab2011-12-22 06:55:311114}
1115
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411116RenderFrameHostImpl* WebContentsImpl::GetMainFrame() {
[email protected]94d0cc12013-12-18 00:07:411117 return frame_tree_.root()->current_frame_host();
[email protected]60eca4eb2013-12-06 00:02:161118}
1119
nick53d5cbf2015-04-23 22:50:141120RenderFrameHostImpl* WebContentsImpl::GetFocusedFrame() {
1121 FrameTreeNode* focused_node = frame_tree_.GetFocusedFrame();
1122 if (!focused_node)
1123 return nullptr;
1124 return focused_node->current_frame_host();
[email protected]9c9343b2014-03-08 02:56:071125}
1126
rob3e2a0732016-01-06 21:22:091127RenderFrameHostImpl* WebContentsImpl::FindFrameByFrameTreeNodeId(
creisf71a2632017-05-04 19:03:501128 int frame_tree_node_id,
1129 int process_id) {
1130 FrameTreeNode* frame = frame_tree_.FindByID(frame_tree_node_id);
1131
1132 // Sanity check that this is in the caller's expected process. Otherwise a
1133 // recent cross-process navigation may have led to a privilege change that the
1134 // caller is not expecting.
1135 if (!frame ||
1136 frame->current_frame_host()->GetProcess()->GetID() != process_id)
1137 return nullptr;
1138
1139 return frame->current_frame_host();
1140}
1141
1142RenderFrameHostImpl* WebContentsImpl::UnsafeFindFrameByFrameTreeNodeId(
rob3e2a0732016-01-06 21:22:091143 int frame_tree_node_id) {
creisf71a2632017-05-04 19:03:501144 // Beware using this! The RenderFrameHost may have changed since the caller
1145 // obtained frame_tree_node_id.
rob3e2a0732016-01-06 21:22:091146 FrameTreeNode* frame = frame_tree_.FindByID(frame_tree_node_id);
1147 return frame ? frame->current_frame_host() : nullptr;
1148}
1149
[email protected]a86c0e962013-12-17 17:10:391150void WebContentsImpl::ForEachFrame(
Lei Zhangebcc6302018-01-12 19:46:451151 const base::RepeatingCallback<void(RenderFrameHost*)>& on_frame) {
dcheng57e39e22016-01-21 00:25:381152 for (FrameTreeNode* node : frame_tree_.Nodes()) {
1153 on_frame.Run(node->current_frame_host());
1154 }
[email protected]a86c0e962013-12-17 17:10:391155}
1156
dchengafb53e22016-02-04 08:11:081157std::vector<RenderFrameHost*> WebContentsImpl::GetAllFrames() {
Xuehui Xieb2300ae42020-06-09 20:25:051158 return GetAllFramesImpl(frame_tree_, /*include_pending=*/false);
1159}
1160
1161std::vector<RenderFrameHost*> WebContentsImpl::GetAllFramesIncludingPending() {
1162 return GetAllFramesImpl(frame_tree_, /*include_pending=*/true);
dchengafb53e22016-02-04 08:11:081163}
1164
lukaszacbdf52e2016-01-15 21:19:511165int WebContentsImpl::SendToAllFrames(IPC::Message* message) {
Xuehui Xieb2300ae42020-06-09 20:25:051166 return SendToAllFramesImpl(frame_tree_, /*include_pending=*/false, message);
1167}
lukasza1a9ab2422016-03-02 18:47:251168
Xuehui Xieb2300ae42020-06-09 20:25:051169int WebContentsImpl::SendToAllFramesIncludingPending(IPC::Message* message) {
1170 return SendToAllFramesImpl(frame_tree_, /*include_pending=*/true, message);
[email protected]a86c0e962013-12-17 17:10:391171}
1172
lfgdb5c4ed2016-03-04 23:09:071173void WebContentsImpl::SendPageMessage(IPC::Message* msg) {
alexmos136fd6e62016-08-15 20:58:411174 frame_tree_.root()->render_manager()->SendPageMessage(msg, nullptr);
lfgdb5c4ed2016-03-04 23:09:071175}
1176
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411177RenderViewHostImpl* WebContentsImpl::GetRenderViewHost() {
[email protected]fa944cb82013-11-15 17:51:211178 return GetRenderManager()->current_host();
[email protected]be1f56ab2011-12-22 06:55:311179}
1180
creis89a0f782015-05-27 16:13:171181void WebContentsImpl::CancelActiveAndPendingDialogs() {
avi5d3b8692016-10-12 22:00:461182 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:531183 dialog_manager_->CancelDialogs(this, /*reset_state=*/false);
avi5d3b8692016-10-12 22:00:461184 }
creis89a0f782015-05-27 16:13:171185 if (browser_plugin_embedder_)
1186 browser_plugin_embedder_->CancelGuestDialogs();
1187}
1188
naskoc0fceff2015-04-30 15:53:521189void WebContentsImpl::ClosePage() {
1190 GetRenderViewHost()->ClosePage();
1191}
1192
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411193RenderWidgetHostView* WebContentsImpl::GetRenderWidgetHostView() {
[email protected]fa944cb82013-11-15 17:51:211194 return GetRenderManager()->GetRenderWidgetHostView();
[email protected]be1f56ab2011-12-22 06:55:311195}
1196
lfg265a2672016-04-23 03:11:021197RenderWidgetHostView* WebContentsImpl::GetTopLevelRenderWidgetHostView() {
1198 if (GetOuterWebContents())
1199 return GetOuterWebContents()->GetTopLevelRenderWidgetHostView();
1200 return GetRenderManager()->GetRenderWidgetHostView();
1201}
1202
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411203RenderWidgetHostView* WebContentsImpl::GetFullscreenRenderWidgetHostView() {
vmpstr6d9996c82017-02-23 00:43:251204 if (auto* widget_host = GetFullscreenRenderWidgetHost())
ekaramadaeb3c5c2016-11-09 03:22:351205 return widget_host->GetView();
1206 return nullptr;
[email protected]4aebbca2013-09-17 22:26:491207}
1208
[email protected]8ff00d72012-10-23 19:12:211209WebContentsView* WebContentsImpl::GetView() const {
[email protected]be1f56ab2011-12-22 06:55:311210 return view_.get();
1211}
1212
Mike Wassermanb213b9352020-04-16 00:32:341213void WebContentsImpl::OnScreensChange() {
1214 for (FrameTreeNode* node : frame_tree_.Nodes()) {
1215 RenderFrameHostImpl* rfh = node->current_frame_host();
1216 rfh->GetAssociatedLocalFrame()->OnScreensChange();
1217 }
1218}
1219
leon.han552e9de2017-02-09 14:37:301220void WebContentsImpl::OnScreenOrientationChange() {
1221 DCHECK(screen_orientation_provider_);
Lan Weif81c6e7c2020-02-12 16:46:091222 DidChangeScreenOrientation();
Becca Hughese9e27952018-06-25 17:08:271223 screen_orientation_provider_->OnOrientationChange();
leon.hane4db177a2017-02-07 14:19:161224}
1225
Alan Cutter92d59252019-03-29 02:32:331226base::Optional<SkColor> WebContentsImpl::GetThemeColor() {
Carlos Caballero1215f882019-10-29 15:58:431227 return GetRenderViewHost()->theme_color();
yusufod41c5f92015-03-06 00:14:281228}
1229
Doug Turner63f3c7b2017-07-29 05:10:011230void WebContentsImpl::SetAccessibilityMode(ui::AXMode mode) {
[email protected]95640212014-07-26 18:14:301231 if (mode == accessibility_mode_)
1232 return;
1233
dmazzonif8a31042016-12-03 00:52:131234 // Don't allow accessibility to be enabled for WebContents that are never
danakj77eb7e82020-01-09 19:38:461235 // user-visible, like background pages.
1236 if (IsNeverComposited())
dmazzonif8a31042016-12-03 00:52:131237 return;
1238
[email protected]95640212014-07-26 18:14:301239 accessibility_mode_ = mode;
dcheng57e39e22016-01-21 00:25:381240
1241 for (FrameTreeNode* node : frame_tree_.Nodes()) {
dmazzonif8a31042016-12-03 00:52:131242 UpdateAccessibilityModeOnFrame(node->current_frame_host());
clamy610c63b32017-12-22 15:05:181243 // Also update accessibility mode on the speculative RenderFrameHost for
1244 // this FrameTreeNode, if one exists.
Alex Moshchuk3d8a1f392017-10-24 19:01:261245 RenderFrameHost* speculative_frame_host =
1246 node->render_manager()->speculative_frame_host();
1247 if (speculative_frame_host)
1248 UpdateAccessibilityModeOnFrame(speculative_frame_host);
dcheng57e39e22016-01-21 00:25:381249 }
[email protected]95640212014-07-26 18:14:301250}
1251
Doug Turner63f3c7b2017-07-29 05:10:011252void WebContentsImpl::AddAccessibilityMode(ui::AXMode mode) {
1253 ui::AXMode new_mode(accessibility_mode_);
dougtcd3dad732017-03-14 03:26:231254 new_mode |= mode;
1255 SetAccessibilityMode(new_mode);
[email protected]95640212014-07-26 18:14:301256}
1257
Avi Drissman1e620f32018-03-16 13:57:291258// Helper class used by WebContentsImpl::RequestAXTreeSnapshot.
1259// Handles the callbacks from parallel snapshot requests to each frame,
1260// and feeds the results to an AXTreeCombiner, which converts them into a
1261// single combined accessibility tree.
1262class WebContentsImpl::AXTreeSnapshotCombiner
1263 : public base::RefCounted<AXTreeSnapshotCombiner> {
1264 public:
1265 explicit AXTreeSnapshotCombiner(AXTreeSnapshotCallback callback)
1266 : callback_(std::move(callback)) {}
1267
1268 AXTreeSnapshotCallback AddFrame(bool is_root) {
1269 // Adds a reference to |this|.
1270 return base::BindOnce(&AXTreeSnapshotCombiner::ReceiveSnapshot, this,
1271 is_root);
1272 }
1273
1274 void ReceiveSnapshot(bool is_root, const ui::AXTreeUpdate& snapshot) {
1275 combiner_.AddTree(snapshot, is_root);
1276 }
1277
1278 private:
1279 friend class base::RefCounted<AXTreeSnapshotCombiner>;
1280
1281 // This is called automatically after the last call to ReceiveSnapshot
1282 // when there are no more references to this object.
1283 ~AXTreeSnapshotCombiner() {
1284 combiner_.Combine();
1285 std::move(callback_).Run(combiner_.combined());
1286 }
1287
1288 ui::AXTreeCombiner combiner_;
1289 AXTreeSnapshotCallback callback_;
1290};
1291
1292void WebContentsImpl::RequestAXTreeSnapshot(AXTreeSnapshotCallback callback,
1293 ui::AXMode ax_mode) {
dmazzonid95ae842016-04-12 21:17:391294 // Send a request to each of the frames in parallel. Each one will return
1295 // an accessibility tree snapshot, and AXTreeSnapshotCombiner will combine
1296 // them into a single tree and call |callback| with that result, then
1297 // delete |combiner|.
Avi Drissman1e620f32018-03-16 13:57:291298 FrameTreeNode* root_node = frame_tree_.root();
tzik58faa742018-08-01 10:54:181299 auto combiner =
1300 base::MakeRefCounted<AXTreeSnapshotCombiner>(std::move(callback));
Avi Drissman1e620f32018-03-16 13:57:291301
tzik58faa742018-08-01 10:54:181302 RecursiveRequestAXTreeSnapshotOnFrame(root_node, combiner.get(), ax_mode);
Avi Drissman1e620f32018-03-16 13:57:291303}
1304
1305void WebContentsImpl::RecursiveRequestAXTreeSnapshotOnFrame(
1306 FrameTreeNode* root_node,
1307 AXTreeSnapshotCombiner* combiner,
1308 ui::AXMode ax_mode) {
dmazzonid95ae842016-04-12 21:17:391309 for (FrameTreeNode* frame_tree_node : frame_tree_.Nodes()) {
Avi Drissman1e620f32018-03-16 13:57:291310 WebContentsImpl* inner_contents =
1311 node_.GetInnerWebContentsInFrame(frame_tree_node);
1312 if (inner_contents) {
1313 inner_contents->RecursiveRequestAXTreeSnapshotOnFrame(root_node, combiner,
1314 ax_mode);
1315 } else {
1316 bool is_root = frame_tree_node == root_node;
1317 frame_tree_node->current_frame_host()->RequestAXTreeSnapshot(
1318 combiner->AddFrame(is_root), ax_mode);
1319 }
dmazzonid95ae842016-04-12 21:17:391320 }
dmazzoni83ba5c82015-04-14 07:11:511321}
1322
Becca Hughes3b5a43482018-07-17 22:31:551323void WebContentsImpl::NotifyViewportFitChanged(
1324 blink::mojom::ViewportFit value) {
1325 for (auto& observer : observers_)
1326 observer.ViewportFitChanged(value);
1327}
1328
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411329FindRequestManager* WebContentsImpl::GetFindRequestManagerForTesting() {
Ehsan Karamad6beb2ea2018-11-25 18:15:131330 return GetFindRequestManager();
1331}
1332
mcnee336ea2c2017-05-23 22:50:591333#if !defined(OS_ANDROID)
akabac6bd1212018-06-25 20:10:481334void WebContentsImpl::UpdateZoom() {
1335 RenderWidgetHostImpl* rwh = GetRenderViewHost()->GetWidget();
1336 if (rwh->GetView())
1337 rwh->SynchronizeVisualProperties();
wjmaclean64951902016-04-29 20:59:121338}
1339
wjmaclean64951902016-04-29 20:59:121340
1341void WebContentsImpl::UpdateZoomIfNecessary(const std::string& scheme,
akabac6bd1212018-06-25 20:10:481342 const std::string& host) {
wjmaclean64951902016-04-29 20:59:121343 NavigationEntry* entry = GetController().GetLastCommittedEntry();
1344 if (!entry)
1345 return;
1346
1347 GURL url = HostZoomMap::GetURLFromEntry(entry);
1348 if (host != net::GetHostOrSpecFromURL(url) ||
1349 (!scheme.empty() && !url.SchemeIs(scheme))) {
1350 return;
1351 }
1352
akabac6bd1212018-06-25 20:10:481353 UpdateZoom();
wjmaclean64951902016-04-29 20:59:121354}
mcnee336ea2c2017-05-23 22:50:591355#endif // !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:121356
Julie Jeongeun Kim7d0986172019-12-04 03:17:251357base::OnceClosure WebContentsImpl::AddReceiverSet(
rockotf62002a2016-09-15 00:08:591358 const std::string& interface_name,
Julie Jeongeun Kim7d0986172019-12-04 03:17:251359 WebContentsReceiverSet* receiver_set) {
rockotf62002a2016-09-15 00:08:591360 auto result =
Julie Jeongeun Kim7d0986172019-12-04 03:17:251361 receiver_sets_.insert(std::make_pair(interface_name, receiver_set));
rockotf62002a2016-09-15 00:08:591362 DCHECK(result.second);
Julie Jeongeun Kim7d0986172019-12-04 03:17:251363 return base::BindOnce(&WebContentsImpl::RemoveReceiverSet,
danakjf4b9e942019-11-29 15:43:041364 weak_factory_.GetWeakPtr(), interface_name);
rockotf62002a2016-09-15 00:08:591365}
1366
Julie Jeongeun Kim7d0986172019-12-04 03:17:251367WebContentsReceiverSet* WebContentsImpl::GetReceiverSet(
rockot8bbad222017-03-22 04:34:051368 const std::string& interface_name) {
Julie Jeongeun Kim7d0986172019-12-04 03:17:251369 auto it = receiver_sets_.find(interface_name);
1370 if (it == receiver_sets_.end())
rockot8bbad222017-03-22 04:34:051371 return nullptr;
1372 return it->second;
1373}
1374
John Delaney732721e92020-02-07 23:11:271375void WebContentsImpl::RemoveReceiverSetForTesting(
1376 const std::string& interface_name) {
1377 RemoveReceiverSet(interface_name);
1378}
1379
paulmeyerfeafc2d2017-04-25 21:46:401380std::vector<WebContentsImpl*> WebContentsImpl::GetWebContentsAndAllInner() {
1381 std::vector<WebContentsImpl*> all_contents(1, this);
1382
1383 for (size_t i = 0; i != all_contents.size(); ++i) {
1384 for (auto* inner_contents : all_contents[i]->GetInnerWebContents()) {
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:161385 all_contents.push_back(static_cast<WebContentsImpl*>(inner_contents));
paulmeyerfeafc2d2017-04-25 21:46:401386 }
1387 }
1388
1389 return all_contents;
1390}
1391
Sam McNally145fb172017-05-10 00:13:231392void WebContentsImpl::NotifyManifestUrlChanged(
Yuzu Saijo0c263c702020-06-08 03:41:241393 RenderFrameHost* rfh,
Sam McNally145fb172017-05-10 00:13:231394 const base::Optional<GURL>& manifest_url) {
1395 for (auto& observer : observers_)
Yuzu Saijo0c263c702020-06-08 03:41:241396 observer.DidUpdateWebManifestURL(rfh, manifest_url);
Sam McNally145fb172017-05-10 00:13:231397}
1398
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411399WebUI* WebContentsImpl::GetWebUI() {
Nasko Oskov2f7d2112019-10-29 03:26:571400 WebUI* committed_web_ui = GetCommittedWebUI();
1401 if (committed_web_ui)
1402 return committed_web_ui;
1403
1404 if (GetRenderManager()->speculative_frame_host())
1405 return GetRenderManager()->speculative_frame_host()->web_ui();
1406
1407 return nullptr;
[email protected]be1f56ab2011-12-22 06:55:311408}
1409
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411410WebUI* WebContentsImpl::GetCommittedWebUI() {
carlosk35f35af2015-12-01 10:55:401411 return frame_tree_.root()->current_frame_host()->web_ui();
[email protected]d5f942ba2008-09-26 19:30:341412}
1413
Maks Orlovich73f374d2020-04-02 12:46:131414void WebContentsImpl::SetUserAgentOverride(
1415 const blink::UserAgentOverride& ua_override,
1416 bool override_in_new_tabs) {
1417 DCHECK(!ua_override.ua_metadata_override.has_value() ||
1418 !ua_override.ua_string_override.empty());
1419
1420 if (GetUserAgentOverride() == ua_override)
[email protected]bf70edce2012-06-20 22:32:221421 return;
1422
Changwan Ryuc1134a82018-03-07 02:10:141423 should_override_user_agent_in_new_tabs_ = override_in_new_tabs;
1424
Maks Orlovich73f374d2020-04-02 12:46:131425 renderer_preferences_.user_agent_override = ua_override;
[email protected]bf70edce2012-06-20 22:32:221426
Bruce Long1e3e1f542019-10-16 17:56:281427 // Send the new override string to all renderers in the current page.
1428 SyncRendererPrefs();
[email protected]bf70edce2012-06-20 22:32:221429
1430 // Reload the page if a load is currently in progress to avoid having
1431 // different parts of the page loaded using different user agents.
Scott Violete1d58cc2020-04-28 23:07:171432 // No need to reload if the current entry matches that of the
1433 // NavigationRequest supplied to DidStartNavigation() as NavigationRequest
1434 // handles it.
[email protected]6286a372013-10-09 04:03:271435 NavigationEntry* entry = controller_.GetVisibleEntry();
Scott Violete1d58cc2020-04-28 23:07:171436 if (IsLoading() && entry != nullptr && entry->GetIsOverridingUserAgent() &&
1437 (!frame_tree_.root()->navigation_request() ||
1438 frame_tree_.root()->navigation_request()->ua_change_requires_reload())) {
toyoshim6142d96f2016-12-19 09:07:251439 controller_.Reload(ReloadType::BYPASSING_CACHE, true);
Scott Violete1d58cc2020-04-28 23:07:171440 }
[email protected]8d0f3312012-08-18 01:47:531441
ericwilligersde386342016-10-19 02:35:091442 for (auto& observer : observers_)
Maks Orlovich73f374d2020-04-02 12:46:131443 observer.UserAgentOverrideSet(ua_override);
[email protected]86ef6a392012-05-11 22:03:111444}
1445
Scott Violet2a6c5bff2020-04-29 23:59:061446void WebContentsImpl::SetRendererInitiatedUserAgentOverrideOption(
1447 NavigationController::UserAgentOverrideOption option) {
1448 renderer_initiated_user_agent_override_option_ = option;
1449}
1450
Maks Orlovich73f374d2020-04-02 12:46:131451const blink::UserAgentOverride& WebContentsImpl::GetUserAgentOverride() {
[email protected]bf70edce2012-06-20 22:32:221452 return renderer_preferences_.user_agent_override;
[email protected]86ef6a392012-05-11 22:03:111453}
1454
Scott Violet2a6c5bff2020-04-29 23:59:061455bool WebContentsImpl::ShouldOverrideUserAgentForRendererInitiatedNavigation() {
1456 NavigationEntryImpl* current_entry = controller_.GetLastCommittedEntry();
1457 if (!current_entry)
1458 return should_override_user_agent_in_new_tabs_;
1459
1460 switch (renderer_initiated_user_agent_override_option_) {
1461 case NavigationController::UA_OVERRIDE_INHERIT:
1462 return current_entry->GetIsOverridingUserAgent();
1463 case NavigationController::UA_OVERRIDE_TRUE:
1464 return true;
1465 case NavigationController::UA_OVERRIDE_FALSE:
1466 return false;
1467 default:
1468 break;
1469 }
1470 return false;
Changwan Ryuc1134a82018-03-07 02:10:141471}
1472
dmazzonidd3d51a72016-12-14 18:41:011473void WebContentsImpl::EnableWebContentsOnlyAccessibilityMode() {
Dominic Mazzonid9fda172019-03-07 17:12:071474 // If accessibility is already enabled, we'll need to force a reset
1475 // in order to ensure new observers of accessibility events get the
1476 // full accessibility tree from scratch.
1477 bool need_reset = GetAccessibilityMode().has_mode(ui::AXMode::kWebContents);
1478
1479 ui::AXMode desired_mode =
1480 GetContentClient()->browser()->GetAXModeForBrowserContext(
1481 GetBrowserContext());
1482 desired_mode |= ui::kAXModeWebContentsOnly;
1483 AddAccessibilityMode(desired_mode);
1484
1485 if (need_reset) {
dchengafb53e22016-02-04 08:11:081486 for (RenderFrameHost* rfh : GetAllFrames())
1487 ResetAccessibility(rfh);
dchengafb53e22016-02-04 08:11:081488 }
[email protected]95640212014-07-26 18:14:301489}
1490
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411491bool WebContentsImpl::IsWebContentsOnlyAccessibilityModeForTesting() {
Doug Turner63f3c7b2017-07-29 05:10:011492 return accessibility_mode_ == ui::kAXModeWebContentsOnly;
[email protected]95640212014-07-26 18:14:301493}
1494
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411495bool WebContentsImpl::IsFullAccessibilityModeForTesting() {
Doug Turner63f3c7b2017-07-29 05:10:011496 return accessibility_mode_ == ui::kAXModeComplete;
[email protected]95640212014-07-26 18:14:301497}
1498
Becca Hughes6daf5662018-06-27 16:50:541499#if defined(OS_ANDROID)
1500
1501void WebContentsImpl::SetDisplayCutoutSafeArea(gfx::Insets insets) {
Becca Hughes86334622018-07-09 21:29:381502 if (display_cutout_host_impl_)
1503 display_cutout_host_impl_->SetDisplayCutoutSafeArea(insets);
Becca Hughes6daf5662018-06-27 16:50:541504}
1505
1506#endif
1507
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411508const base::string16& WebContentsImpl::GetTitle() {
Nasko Oskov2f7d2112019-10-29 03:26:571509 WebUI* our_web_ui =
1510 GetRenderManager()->speculative_frame_host()
1511 ? GetRenderManager()->speculative_frame_host()->web_ui()
1512 : GetRenderManager()->current_frame_host()->web_ui();
[email protected]7ade2732011-02-10 00:13:581513 if (our_web_ui) {
[email protected]96d185d2009-04-24 03:28:541514 // Don't override the title in view source mode.
Carlos IL4dea8902020-05-26 15:14:291515 NavigationEntry* entry = controller_.GetVisibleEntry();
[email protected]96d185d2009-04-24 03:28:541516 if (!(entry && entry->IsViewSourceMode())) {
[email protected]e0112912011-02-02 22:54:351517 // Give the Web UI the chance to override our title.
[email protected]fcf75d42013-12-03 20:11:261518 const base::string16& title = our_web_ui->GetOverriddenTitle();
[email protected]96d185d2009-04-24 03:28:541519 if (!title.empty())
1520 return title;
1521 }
1522 }
1523
1524 // We use the title for the last committed entry rather than a pending
1525 // navigation entry. For example, when the user types in a URL, we want to
1526 // keep the old page's title until the new load has committed and we get a new
1527 // title.
Carlos IL4dea8902020-05-26 15:14:291528 NavigationEntry* entry = controller_.GetLastCommittedEntry();
[email protected]59167c22013-06-03 18:07:321529
creis072b61f2015-09-28 20:52:241530 // We make an exception for initial navigations. We only want to use the title
1531 // from the visible entry if:
1532 // 1. The pending entry has been explicitly assigned a title to display.
1533 // 2. The user is doing a history navigation in a new tab (e.g., Ctrl+Back),
1534 // which case there is a pending entry index other than -1.
1535 //
1536 // Otherwise, we want to stick with the last committed entry's title during
1537 // new navigations, which have pending entries at index -1 with no title.
1538 if (controller_.IsInitialNavigation() &&
1539 ((controller_.GetVisibleEntry() &&
1540 !controller_.GetVisibleEntry()->GetTitle().empty()) ||
1541 controller_.GetPendingEntryIndex() != -1)) {
1542 entry = controller_.GetVisibleEntry();
[email protected]9eeafc012013-11-25 23:49:471543 }
[email protected]59167c22013-06-03 18:07:321544
[email protected]45d0ef7f2011-01-05 13:46:231545 if (entry) {
jshin1fb76462016-04-05 22:13:031546 return entry->GetTitleForDisplay();
[email protected]45d0ef7f2011-01-05 13:46:231547 }
[email protected]987fc3a2011-05-26 14:18:091548
1549 // |page_title_when_no_navigation_entry_| is finally used
1550 // if no title cannot be retrieved.
1551 return page_title_when_no_navigation_entry_;
[email protected]96d185d2009-04-24 03:28:541552}
1553
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411554SiteInstanceImpl* WebContentsImpl::GetSiteInstance() {
[email protected]fa944cb82013-11-15 17:51:211555 return GetRenderManager()->current_host()->GetSiteInstance();
[email protected]96d185d2009-04-24 03:28:541556}
1557
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411558bool WebContentsImpl::IsLoading() {
Carlos ILd51e7702020-05-07 18:51:391559 return frame_tree_.IsLoading();
[email protected]3c9e1872010-11-18 16:17:491560}
1561
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411562double WebContentsImpl::GetLoadProgress() {
Peter Boström18a40fa2018-10-31 19:03:501563 return frame_tree_.load_progress();
1564}
1565
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411566bool WebContentsImpl::IsLoadingToDifferentDocument() {
clamy44e84ce2016-02-22 15:38:251567 return IsLoading() && is_load_to_different_document_;
[email protected]6dfed692014-05-22 04:18:031568}
1569
Alexander Timindd0fa0c52019-11-06 13:03:371570bool WebContentsImpl::IsDocumentOnLoadCompletedInMainFrame() {
1571 return GetRenderViewHost()->IsDocumentOnLoadCompletedInMainFrame();
1572}
1573
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411574bool WebContentsImpl::IsWaitingForResponse() {
Peter Boströma9a27f6e2018-11-21 13:12:191575 NavigationRequest* ongoing_navigation_request =
1576 frame_tree_.root()->navigation_request();
1577
1578 // An ongoing navigation request means we're waiting for a response.
1579 return ongoing_navigation_request != nullptr;
[email protected]be1f56ab2011-12-22 06:55:311580}
1581
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411582const net::LoadStateWithParam& WebContentsImpl::GetLoadState() {
[email protected]be1f56ab2011-12-22 06:55:311583 return load_state_;
1584}
1585
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411586const base::string16& WebContentsImpl::GetLoadStateHost() {
[email protected]be1f56ab2011-12-22 06:55:311587 return load_state_host_;
1588}
1589
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411590uint64_t WebContentsImpl::GetUploadSize() {
[email protected]be1f56ab2011-12-22 06:55:311591 return upload_size_;
1592}
1593
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411594uint64_t WebContentsImpl::GetUploadPosition() {
[email protected]be1f56ab2011-12-22 06:55:311595 return upload_position_;
1596}
1597
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411598const std::string& WebContentsImpl::GetEncoding() {
Alexander Timine5f20e22019-10-09 23:22:351599 return GetMainFrame()->GetEncoding();
[email protected]be1f56ab2011-12-22 06:55:311600}
1601
Charles Zhaod72f99d2018-09-17 14:18:271602bool WebContentsImpl::WasDiscarded() {
1603 return GetFrameTree()->root()->was_discarded();
1604}
1605
Shubhie Panickerddf2a4e2018-03-06 00:09:061606void WebContentsImpl::SetWasDiscarded(bool was_discarded) {
1607 GetFrameTree()->root()->set_was_discarded();
1608}
1609
Collin Bakerc5259962019-11-14 17:51:581610void WebContentsImpl::IncrementCapturerCount(const gfx::Size& capture_size,
1611 bool stay_hidden) {
[email protected]5a652232013-02-12 06:15:251612 DCHECK(!is_being_destroyed_);
Collin Bakerc5259962019-11-14 17:51:581613 if (stay_hidden)
1614 ++hidden_capturer_count_;
1615 else
1616 ++visible_capturer_count_;
[email protected]222f5822014-02-05 23:40:491617
1618 // Note: This provides a hint to upstream code to size the views optimally
1619 // for quality (e.g., to avoid scaling).
1620 if (!capture_size.IsEmpty() && preferred_size_for_capture_.IsEmpty()) {
1621 preferred_size_for_capture_ = capture_size;
1622 OnPreferredSizeChanged(preferred_size_);
1623 }
ccameron8807c38f2015-01-17 00:29:191624
Collin Bakerc5259962019-11-14 17:51:581625 UpdateVisibilityAndNotifyPageAndView(GetVisibility());
[email protected]54597982013-02-06 01:59:551626}
1627
Collin Bakerc5259962019-11-14 17:51:581628void WebContentsImpl::DecrementCapturerCount(bool stay_hidden) {
1629 if (stay_hidden)
1630 --hidden_capturer_count_;
1631 else
1632 --visible_capturer_count_;
1633 DCHECK_GE(hidden_capturer_count_, 0);
1634 DCHECK_GE(visible_capturer_count_, 0);
[email protected]54597982013-02-06 01:59:551635
[email protected]5a652232013-02-12 06:15:251636 if (is_being_destroyed_)
1637 return;
1638
Francois Doray24fc62c2017-12-11 17:27:331639 if (!IsBeingCaptured()) {
[email protected]222f5822014-02-05 23:40:491640 const gfx::Size old_size = preferred_size_for_capture_;
1641 preferred_size_for_capture_ = gfx::Size();
1642 OnPreferredSizeChanged(old_size);
[email protected]54597982013-02-06 01:59:551643 }
Collin Bakerc5259962019-11-14 17:51:581644
1645 UpdateVisibilityAndNotifyPageAndView(GetVisibility());
[email protected]be1f56ab2011-12-22 06:55:311646}
1647
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411648bool WebContentsImpl::IsBeingCaptured() {
Collin Bakerc5259962019-11-14 17:51:581649 return visible_capturer_count_ + hidden_capturer_count_ > 0;
[email protected]f2bd40812013-07-20 04:30:441650}
1651
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411652bool WebContentsImpl::IsAudioMuted() {
Guido Urdanetaf8372942019-11-15 09:47:211653 return audio_stream_factory_ && audio_stream_factory_->IsMuted();
miu50f97892014-09-22 22:49:521654}
1655
1656void WebContentsImpl::SetAudioMuted(bool mute) {
1657 DVLOG(1) << "SetAudioMuted(mute=" << mute << "), was " << IsAudioMuted()
1658 << " for WebContentsImpl@" << this;
1659
1660 if (mute == IsAudioMuted())
1661 return;
1662
Guido Urdanetaf8372942019-11-15 09:47:211663 GetAudioStreamFactory()->SetMuted(mute);
miu50f97892014-09-22 22:49:521664
ericwilligersde386342016-10-19 02:35:091665 for (auto& observer : observers_)
1666 observer.DidUpdateAudioMutingState(mute);
wjmaclean2f797c782016-01-07 14:52:031667
Jan Rucka442c83f2017-08-08 13:27:541668 // Notification for UI updates in response to the changed muting state.
Collin Bakeraf540cf2019-09-20 20:54:161669 NotifyNavigationStateChanged(INVALIDATE_TYPE_AUDIO);
Jan Rucka442c83f2017-08-08 13:27:541670}
1671
1672bool WebContentsImpl::IsCurrentlyAudible() {
Chris Hamiltondf0d72cd2018-05-29 16:23:531673 return is_currently_audible_;
miu50f97892014-09-22 22:49:521674}
1675
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411676bool WebContentsImpl::IsConnectedToBluetoothDevice() {
ortunodf4d7982016-04-08 02:33:351677 return bluetooth_connected_device_count_ > 0;
ortuno32e7db3c2016-03-29 16:14:201678}
1679
Lucas Furukawa Gadani4b4eed02019-06-04 23:12:041680bool WebContentsImpl::IsConnectedToSerialPort() {
Reilly Grant5e7c79b22019-04-09 17:26:201681 return serial_active_frame_count_ > 0;
1682}
1683
Matt Reynoldse8c6c1f2019-11-02 09:53:531684bool WebContentsImpl::IsConnectedToHidDevice() {
1685 return hid_active_frame_count_ > 0;
1686}
1687
Marijn Kruisselbrink29051042019-08-06 22:56:551688bool WebContentsImpl::HasNativeFileSystemHandles() {
1689 return native_file_system_handle_count_ > 0;
1690}
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:331691
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411692bool WebContentsImpl::HasPictureInPictureVideo() {
sawtellea7333a82018-05-31 02:36:361693 return has_picture_in_picture_video_;
1694}
1695
1696void WebContentsImpl::SetHasPictureInPictureVideo(
1697 bool has_picture_in_picture_video) {
1698 // If status of |this| is already accurate, there is no need to update.
1699 if (has_picture_in_picture_video == has_picture_in_picture_video_)
1700 return;
1701 has_picture_in_picture_video_ = has_picture_in_picture_video;
1702 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
François Beaufort058085d2018-08-30 15:29:141703 for (auto& observer : observers_)
1704 observer.MediaPictureInPictureChanged(has_picture_in_picture_video_);
sawtellea7333a82018-05-31 02:36:361705}
1706
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411707bool WebContentsImpl::IsCrashed() {
Dominic Mazzoni73a48322018-05-25 18:14:071708 switch (crashed_status_) {
1709 case base::TERMINATION_STATUS_PROCESS_CRASHED:
1710 case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
1711 case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
1712 case base::TERMINATION_STATUS_OOM:
1713 case base::TERMINATION_STATUS_LAUNCH_FAILED:
oshima620225722015-06-04 19:45:271714#if defined(OS_CHROMEOS)
Dominic Mazzoni73a48322018-05-25 18:14:071715 case base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM:
oshima620225722015-06-04 19:45:271716#endif
Dominic Mazzoni73a48322018-05-25 18:14:071717#if defined(OS_ANDROID)
1718 case base::TERMINATION_STATUS_OOM_PROTECTED:
1719#endif
Will Harris07925d12019-10-31 03:03:051720#if defined(OS_WIN)
1721 case base::TERMINATION_STATUS_INTEGRITY_FAILURE:
1722#endif
Dominic Mazzoni73a48322018-05-25 18:14:071723 return true;
1724 case base::TERMINATION_STATUS_NORMAL_TERMINATION:
1725 case base::TERMINATION_STATUS_STILL_RUNNING:
1726 return false;
1727 case base::TERMINATION_STATUS_MAX_ENUM:
1728 NOTREACHED();
1729 return false;
1730 }
1731
1732 NOTREACHED();
1733 return false;
[email protected]3c9e1872010-11-18 16:17:491734}
1735
[email protected]b172aee2012-04-10 17:05:261736void WebContentsImpl::SetIsCrashed(base::TerminationStatus status,
1737 int error_code) {
[email protected]443b80e2010-12-14 00:42:231738 if (status == crashed_status_)
[email protected]d5f942ba2008-09-26 19:30:341739 return;
1740
[email protected]443b80e2010-12-14 00:42:231741 crashed_status_ = status;
1742 crashed_error_code_ = error_code;
[email protected]8ff00d72012-10-23 19:12:211743 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
[email protected]d5f942ba2008-09-26 19:30:341744}
1745
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411746base::TerminationStatus WebContentsImpl::GetCrashedStatus() {
[email protected]be1f56ab2011-12-22 06:55:311747 return crashed_status_;
1748}
1749
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411750int WebContentsImpl::GetCrashedErrorCode() {
afakhry98241832016-03-11 19:27:471751 return crashed_error_code_;
1752}
1753
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411754bool WebContentsImpl::IsBeingDestroyed() {
[email protected]be1f56ab2011-12-22 06:55:311755 return is_being_destroyed_;
1756}
1757
[email protected]7f924832014-08-09 05:57:221758void WebContentsImpl::NotifyNavigationStateChanged(
1759 InvalidateTypes changed_flags) {
dalecurtis88c240072015-12-09 02:11:181760 // Notify the media observer of potential audibility changes.
Collin Bakeraf540cf2019-09-20 20:54:161761 if (changed_flags & INVALIDATE_TYPE_AUDIO) {
mlamouri44e4ef42016-01-20 18:42:271762 media_web_contents_observer_->MaybeUpdateAudibleState();
dalecurtisbc6572e12014-09-12 19:22:301763 }
1764
[email protected]d5f942ba2008-09-26 19:30:341765 if (delegate_)
1766 delegate_->NavigationStateChanged(this, changed_flags);
wjmaclean1dabf3e32016-05-13 23:34:441767
1768 if (GetOuterWebContents())
1769 GetOuterWebContents()->NotifyNavigationStateChanged(changed_flags);
[email protected]d5f942ba2008-09-26 19:30:341770}
1771
W. James MacLean6f34b042019-07-12 19:25:301772RenderFrameHostImpl* WebContentsImpl::GetFocusedFrameFromFocusedDelegate() {
1773 FrameTreeNode* focused_node =
1774 GetFocusedWebContents()->frame_tree_.GetFocusedFrame();
1775 return focused_node ? focused_node->current_frame_host() : nullptr;
1776}
1777
David Black9cca3592019-11-06 23:02:221778void WebContentsImpl::OnVerticalScrollDirectionChanged(
1779 viz::VerticalScrollDirection scroll_direction) {
1780 for (auto& observer : observers_)
1781 observer.DidChangeVerticalScrollDirection(scroll_direction);
1782}
1783
Chris Hamiltondf0d72cd2018-05-29 16:23:531784void WebContentsImpl::OnAudioStateChanged() {
1785 // This notification can come from any embedded contents or from this
1786 // WebContents' stream monitor. Aggregate these signals to get the actual
1787 // state.
Jeremy Roman03ce13ce2020-05-29 22:16:571788 //
1789 // Note that guests may not be attached as inner contents, and so may need to
1790 // be checked separately.
Chris Hamiltondf0d72cd2018-05-29 16:23:531791 bool is_currently_audible =
1792 audio_stream_monitor_.IsCurrentlyAudible() ||
1793 (browser_plugin_embedder_ &&
Jeremy Roman03ce13ce2020-05-29 22:16:571794 browser_plugin_embedder_->AreAnyGuestsCurrentlyAudible()) ||
1795 AnyInnerWebContents(this, [](WebContents* inner_contents) {
1796 return inner_contents->IsCurrentlyAudible();
1797 });
Chris Hamiltondf0d72cd2018-05-29 16:23:531798 if (is_currently_audible == is_currently_audible_)
1799 return;
1800
1801 // Update internal state.
1802 is_currently_audible_ = is_currently_audible;
1803 was_ever_audible_ = was_ever_audible_ || is_currently_audible_;
1804
1805 SendPageMessage(
1806 new PageMsg_AudioStateChanged(MSG_ROUTING_NONE, is_currently_audible_));
altimind8bd26c2016-11-04 11:44:541807
altiminec87fd1f2016-11-17 20:22:491808 // Notification for UI updates in response to the changed audio state.
Collin Bakeraf540cf2019-09-20 20:54:161809 NotifyNavigationStateChanged(INVALIDATE_TYPE_AUDIO);
Jan Rucka442c83f2017-08-08 13:27:541810
Chris Hamiltondf0d72cd2018-05-29 16:23:531811 // Ensure that audio state changes propagate from innermost to outermost
1812 // WebContents.
1813 if (GetOuterWebContents())
1814 GetOuterWebContents()->OnAudioStateChanged();
Tommy Steimel18360512017-11-01 00:38:191815
Chris Hamiltoneb41198f2018-05-24 18:41:261816 for (auto& observer : observers_)
Chris Hamiltondf0d72cd2018-05-29 16:23:531817 observer.OnAudioStateChanged(is_currently_audible_);
altimind8bd26c2016-11-04 11:44:541818}
1819
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411820base::TimeTicks WebContentsImpl::GetLastActiveTime() {
[email protected]9a890452014-02-13 22:21:021821 return last_active_time_;
[email protected]3e324142012-06-25 18:26:331822}
1823
[email protected]9e2e4632012-07-27 16:38:411824void WebContentsImpl::WasShown() {
Collin Baker989e0882019-11-01 01:27:171825 UpdateVisibilityAndNotifyPageAndView(Visibility::VISIBLE);
[email protected]be1f56ab2011-12-22 06:55:311826}
1827
[email protected]b172aee2012-04-10 17:05:261828void WebContentsImpl::WasHidden() {
Collin Baker989e0882019-11-01 01:27:171829 UpdateVisibilityAndNotifyPageAndView(Visibility::HIDDEN);
[email protected]375fa1b2012-05-22 22:05:371830}
1831
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411832bool WebContentsImpl::HasRecentInteractiveInputEvent() {
Daniel Cheng90196c82018-04-25 21:49:141833 static constexpr base::TimeDelta kMaxInterval =
1834 base::TimeDelta::FromSeconds(5);
1835 base::TimeDelta delta =
1836 ui::EventTimeForNow() - last_interactive_input_event_time_;
1837 // Note: the expectation is that the caller is typically expecting an input
1838 // event, e.g. validating that a WebUI message that requires a gesture is
Daniel Chenge81030b32019-07-17 20:20:231839 // actually attached to a gesture.
Daniel Cheng90196c82018-04-25 21:49:141840 return delta <= kMaxInterval;
1841}
1842
Avi Drissman738ea192018-08-29 20:24:161843void WebContentsImpl::SetIgnoreInputEvents(bool ignore_input_events) {
1844 ignore_input_events_ = ignore_input_events;
1845}
1846
Bo Liu168c8642017-08-28 18:26:021847#if defined(OS_ANDROID)
Bo Liu16dd7b8322018-05-02 21:19:501848void WebContentsImpl::SetMainFrameImportance(
1849 ChildProcessImportance importance) {
1850 GetMainFrame()->GetRenderWidgetHost()->SetImportance(importance);
Bo Liu7c6779e92017-08-16 02:02:281851}
Bo Liu168c8642017-08-28 18:26:021852#endif
Bo Liu7c6779e92017-08-16 02:02:281853
ccameron8807c38f2015-01-17 00:29:191854void WebContentsImpl::WasOccluded() {
Collin Baker989e0882019-11-01 01:27:171855 UpdateVisibilityAndNotifyPageAndView(Visibility::OCCLUDED);
ccameron8807c38f2015-01-17 00:29:191856}
1857
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411858Visibility WebContentsImpl::GetVisibility() {
Francois Doraye6161152018-03-27 22:05:371859 return visibility_;
Francois Dorayfe4a1772018-02-17 04:17:091860}
1861
Alex Moshchuk5bcd7c12019-11-12 22:55:311862bool WebContentsImpl::NeedToFireBeforeUnloadOrUnload() {
Alexander Timinc7bee322020-05-19 17:54:341863 if (!notify_disconnection_)
Alex Moshchuk6fcaca752018-07-14 02:13:591864 return false;
1865
1866 // Don't fire if the main frame's RenderViewHost indicates that beforeunload
1867 // and unload have already executed (e.g., after receiving a ClosePage ACK)
1868 // or should be ignored.
1869 if (GetRenderViewHost()->SuddenTerminationAllowed())
1870 return false;
1871
Alex Moshchukc78dbc722019-10-31 20:00:501872 // Check whether any frame in the frame tree needs to run beforeunload or
1873 // unload handlers.
1874 for (FrameTreeNode* node : frame_tree_.Nodes()) {
1875 RenderFrameHostImpl* rfh = node->current_frame_host();
1876
1877 // No need to run beforeunload/unload if the RenderFrame isn't live.
1878 if (!rfh->IsRenderFrameLive())
1879 continue;
1880
Dave Tapuska97d22ab2019-12-03 17:56:361881 if (rfh->GetSuddenTerminationDisablerState(
1882 blink::mojom::SuddenTerminationDisablerType::
1883 kBeforeUnloadHandler) ||
1884 rfh->GetSuddenTerminationDisablerState(
1885 blink::mojom::SuddenTerminationDisablerType::kUnloadHandler)) {
Alex Moshchukc78dbc722019-10-31 20:00:501886 return true;
1887 }
Aditya Keerthi34f37e62019-03-08 15:54:531888 }
Alex Moshchuk6fcaca752018-07-14 02:13:591889
Alex Moshchukc78dbc722019-10-31 20:00:501890 return false;
[email protected]be1f56ab2011-12-22 06:55:311891}
1892
Chris Hamilton3b3e315d2018-09-19 13:16:211893void WebContentsImpl::DispatchBeforeUnload(bool auto_cancel) {
1894 auto before_unload_type =
1895 auto_cancel ? RenderFrameHostImpl::BeforeUnloadType::DISCARD
1896 : RenderFrameHostImpl::BeforeUnloadType::TAB_CLOSE;
1897 GetMainFrame()->DispatchBeforeUnload(before_unload_type, false);
[email protected]1c3f80bd2014-04-08 23:02:061898}
1899
W. James MacLean2539adb32019-12-13 00:40:441900bool WebContentsImpl::IsInnerWebContentsForGuest() {
1901 return !!browser_plugin_guest_;
1902}
1903
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501904void WebContentsImpl::AttachInnerWebContents(
1905 std::unique_ptr<WebContents> inner_web_contents,
W. James MacLean62883982019-11-12 20:39:001906 RenderFrameHost* render_frame_host,
1907 bool is_full_page) {
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501908 WebContentsImpl* inner_web_contents_impl =
1909 static_cast<WebContentsImpl*>(inner_web_contents.get());
1910 DCHECK(!inner_web_contents_impl->node_.outer_web_contents());
1911 auto* render_frame_host_impl =
1912 static_cast<RenderFrameHostImpl*>(render_frame_host);
Fergal Daly445af932020-06-02 06:37:231913 DCHECK_EQ(&frame_tree_, render_frame_host_impl->frame_tree());
Lucas Furukawa Gadani105de1e812018-05-31 19:38:391914
Yuzu Saijo3f86fb22020-06-11 03:51:101915 // Mark |render_frame_host_impl| as outer delegate frame.
1916 render_frame_host_impl->SetIsOuterDelegateFrame(true);
1917
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501918 RenderFrameHostManager* inner_render_manager =
1919 inner_web_contents_impl->GetRenderManager();
1920 RenderFrameHostImpl* inner_main_frame =
1921 inner_render_manager->current_frame_host();
1922 RenderViewHostImpl* inner_render_view_host =
1923 inner_render_manager->current_host();
1924 auto* outer_render_manager =
1925 render_frame_host_impl->frame_tree_node()->render_manager();
lfg91a79e12016-04-01 23:52:191926
Lucas Furukawa Gadani105de1e812018-05-31 19:38:391927 // When attaching a WebContents as an inner WebContents, we need to replace
1928 // the Webcontents' view with a WebContentsViewChildFrame.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501929 inner_web_contents_impl->view_.reset(new WebContentsViewChildFrame(
1930 inner_web_contents_impl,
1931 GetContentClient()->browser()->GetWebContentsViewDelegate(
1932 inner_web_contents_impl),
1933 &inner_web_contents_impl->render_view_host_delegate_view_));
Lucas Furukawa Gadani105de1e812018-05-31 19:38:391934
lfg91a79e12016-04-01 23:52:191935 // When the WebContents being initialized has an opener, the browser side
1936 // Render{View,Frame}Host must be initialized and the RenderWidgetHostView
1937 // created. This is needed because the usual initialization happens during
1938 // the first navigation, but when attaching a new window we don't navigate
1939 // before attaching. If the browser side is already initialized, the calls
1940 // below will just early return.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501941 inner_render_manager->InitRenderView(inner_render_view_host, nullptr);
1942 inner_main_frame->Init();
1943 if (!inner_render_manager->GetRenderWidgetHostView()) {
1944 inner_web_contents_impl->CreateRenderWidgetHostViewForRenderManager(
1945 inner_render_view_host);
1946 }
lfg91a79e12016-04-01 23:52:191947
Adithya Srinivasane6e7f842019-12-16 18:41:361948 inner_web_contents_impl->RecursivelyUnregisterFrameSinkIds();
1949
lazyboy6ec48b2a2015-06-29 15:18:141950 // Create a link to our outer WebContents.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501951 node_.AttachInnerWebContents(std::move(inner_web_contents),
1952 render_frame_host_impl);
lazyboy6ec48b2a2015-06-29 15:18:141953
lazyboy6ec48b2a2015-06-29 15:18:141954 // Create a proxy in top-level RenderFrameHostManager, pointing to the
1955 // SiteInstance of the outer WebContents. The proxy will be used to send
1956 // postMessage to the inner WebContents.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501957 auto* proxy = inner_render_manager->CreateOuterDelegateProxy(
1958 render_frame_host_impl->GetSiteInstance());
lazyboy6ec48b2a2015-06-29 15:18:141959
Lucas Furukawa Gadani99125822019-01-03 15:41:491960 // When attaching a GuestView as an inner WebContents, there should already be
1961 // a live RenderFrame, which has to be swapped. When attaching a portal, there
1962 // will not be a live RenderFrame before creating the proxy.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501963 if (render_frame_host_impl->IsRenderFrameLive()) {
1964 inner_render_manager->SwapOuterDelegateFrame(render_frame_host_impl, proxy);
Lucas Furukawa Gadani99125822019-01-03 15:41:491965
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501966 inner_web_contents_impl->ReattachToOuterWebContentsFrame();
Lucas Furukawa Gadani99125822019-01-03 15:41:491967 }
ekaramadadd882292016-06-08 15:22:561968
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501969 if (frame_tree_.GetFocusedFrame() ==
1970 render_frame_host_impl->frame_tree_node()) {
1971 inner_web_contents_impl->SetFocusedFrame(
1972 inner_web_contents_impl->frame_tree_.root(),
1973 render_frame_host_impl->GetSiteInstance());
avallee7529b2a2017-04-26 11:37:511974 }
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501975 outer_render_manager->set_attach_complete();
W. James MacLean62883982019-11-12 20:39:001976
1977 // If the inner WebContents is full frame, give it focus.
1978 if (is_full_page) {
1979 // There should only ever be one inner WebContents when |is_full_page| is
1980 // true, and it is the one we just attached.
1981 DCHECK_EQ(1u, node_.GetInnerWebContents().size());
1982 inner_web_contents_impl->SetAsFocusedWebContentsIfNecessary();
1983 }
Chris Hamilton16b5d1d2020-06-04 00:08:121984
1985 for (auto& observer : observers_) {
1986 observer.InnerWebContentsAttached(inner_web_contents_impl,
1987 render_frame_host, is_full_page);
1988 }
lazyboy6ec48b2a2015-06-29 15:18:141989}
1990
Lucas Furukawa Gadani99125822019-01-03 15:41:491991std::unique_ptr<WebContents> WebContentsImpl::DetachFromOuterWebContents() {
Chris Hamilton16b5d1d2020-06-04 00:08:121992 auto* outer_web_contents = GetOuterWebContents();
1993 DCHECK(outer_web_contents);
Yuzu Saijo3f86fb22020-06-11 03:51:101994 GetMainFrame()->ParentOrOuterDelegateFrame()->SetIsOuterDelegateFrame(false);
Chris Hamilton16b5d1d2020-06-04 00:08:121995
Adithya Srinivasane6e7f842019-12-16 18:41:361996 RecursivelyUnregisterFrameSinkIds();
Lucas Gadanid29952582020-06-09 21:24:001997
1998 // Each RenderViewHost has a RenderWidgetHost which can have a
1999 // RenderWidgetHostView, and it needs to be re-created with the appropriate
2000 // platform view. It is important to re-create all child views, not only the
2001 // current one, since the view can be swapped due to a cross-origin
2002 // navigation.
2003 std::set<RenderViewHostImpl*> render_view_hosts;
2004 for (auto& render_view_host : GetFrameTree()->render_view_hosts()) {
2005 if (render_view_host.second->GetWidget() &&
2006 render_view_host.second->GetWidget()->GetView()) {
2007 DCHECK(render_view_host.second->GetWidget()
2008 ->GetView()
2009 ->IsRenderWidgetHostViewChildFrame());
2010 render_view_hosts.insert(render_view_host.second);
Kevin McNee6471a702020-01-27 18:23:072011 }
2012 }
Lucas Gadanid29952582020-06-09 21:24:002013
2014 for (auto* render_view_host : render_view_hosts)
2015 render_view_host->GetWidget()->GetView()->Destroy();
2016
Lucas Furukawa Gadani99125822019-01-03 15:41:492017 GetRenderManager()->DeleteOuterDelegateProxy(
2018 node_.OuterContentsFrameTreeNode()
2019 ->current_frame_host()
2020 ->GetSiteInstance());
2021 view_.reset(CreateWebContentsView(
2022 this, GetContentClient()->browser()->GetWebContentsViewDelegate(this),
2023 &render_view_host_delegate_view_));
danakjfc5184932019-09-12 18:08:322024 view_->CreateView(nullptr);
Lucas Furukawa Gadani99125822019-01-03 15:41:492025 std::unique_ptr<WebContents> web_contents =
2026 node_.DisconnectFromOuterWebContents();
2027 DCHECK_EQ(web_contents.get(), this);
2028 node_.SetFocusedWebContents(this);
Lucas Gadanid29952582020-06-09 21:24:002029
2030 for (auto* render_view_host : render_view_hosts)
2031 CreateRenderWidgetHostViewForRenderManager(render_view_host);
2032
Adithya Srinivasane6e7f842019-12-16 18:41:362033 RecursivelyRegisterFrameSinkIds();
Adithya Srinivasan6f0f67b2019-12-19 01:26:462034 // TODO(adithyas): |browser_plugin_embedder_ax_tree_id| should either not be
2035 // used for portals, or it should get a different name.
2036 GetMainFrame()->set_browser_plugin_embedder_ax_tree_id(ui::AXTreeIDUnknown());
2037 GetMainFrame()->UpdateAXTreeData();
Chris Hamilton16b5d1d2020-06-04 00:08:122038
2039 // Invoke on the *outer* web contents observers for symmetry.
2040 for (auto& observer : outer_web_contents->observers_)
2041 observer.InnerWebContentsDetached(this);
2042
Lucas Furukawa Gadani99125822019-01-03 15:41:492043 return web_contents;
2044}
2045
W. James MacLean2dc75ed42019-03-06 14:31:092046void WebContentsImpl::RecursivelyRegisterFrameSinkIds() {
Adithya Srinivasane6e7f842019-12-16 18:41:362047 for (auto* view : GetRenderWidgetHostViewsInWebContentsTree()) {
2048 auto* rwhvb = static_cast<RenderWidgetHostViewBase*>(view);
2049 if (rwhvb->IsRenderWidgetHostViewChildFrame())
2050 static_cast<RenderWidgetHostViewChildFrame*>(view)->RegisterFrameSinkId();
2051 }
2052}
W. James MacLean2dc75ed42019-03-06 14:31:092053
Adithya Srinivasane6e7f842019-12-16 18:41:362054void WebContentsImpl::RecursivelyUnregisterFrameSinkIds() {
2055 for (auto* view : GetRenderWidgetHostViewsInWebContentsTree()) {
2056 auto* rwhvb = static_cast<RenderWidgetHostViewBase*>(view);
2057 if (rwhvb->IsRenderWidgetHostViewChildFrame()) {
2058 static_cast<RenderWidgetHostViewChildFrame*>(view)
2059 ->UnregisterFrameSinkId();
2060 }
W. James MacLean2dc75ed42019-03-06 14:31:092061 }
2062}
2063
Lucas Furukawa Gadaniaed1fed2017-10-13 17:34:142064void WebContentsImpl::ReattachToOuterWebContentsFrame() {
2065 DCHECK(node_.outer_web_contents());
2066 auto* render_manager = GetRenderManager();
2067 auto* parent_frame =
2068 node_.OuterContentsFrameTreeNode()->current_frame_host()->GetParent();
2069 render_manager->SetRWHViewForInnerContents(
2070 render_manager->GetRenderWidgetHostView());
2071
W. James MacLean2dc75ed42019-03-06 14:31:092072 RecursivelyRegisterFrameSinkIds();
Lucas Furukawa Gadaniaed1fed2017-10-13 17:34:142073
2074 // Set up the the guest's AX tree to point back at the embedder's AX tree.
2075 GetMainFrame()->set_browser_plugin_embedder_ax_tree_id(
2076 parent_frame->GetAXTreeID());
2077 GetMainFrame()->UpdateAXTreeData();
2078}
2079
Lucas Gadani972985622020-05-28 20:52:512080void WebContentsImpl::DidActivatePortal(
2081 WebContentsImpl* predecessor_web_contents,
2082 base::TimeTicks activation_time) {
2083 DCHECK(predecessor_web_contents);
Kevin McNeef8eb64c2020-04-21 21:36:062084 NotifyInsidePortal(false);
Kevin McNeef8eb64c2020-04-21 21:36:062085 for (auto& observer : observers_)
Lucas Gadani972985622020-05-28 20:52:512086 observer.DidActivatePortal(predecessor_web_contents, activation_time);
2087
Lucas Gadani972985622020-05-28 20:52:512088 GetDelegate()->WebContentsBecamePortal(predecessor_web_contents);
Kevin McNeef8eb64c2020-04-21 21:36:062089}
2090
Adithya Srinivasan11af2c52019-12-16 22:52:552091void WebContentsImpl::NotifyInsidePortal(bool inside_portal) {
2092 SendPageMessage(new PageMsg_SetInsidePortal(MSG_ROUTING_NONE, inside_portal));
2093}
2094
dalecurtis6c58ed02016-10-28 23:02:372095void WebContentsImpl::DidChangeVisibleSecurityState() {
Emily Starkc663b0242019-04-26 19:34:452096 if (delegate_)
dalecurtis6c58ed02016-10-28 23:02:372097 delegate_->VisibleSecurityStateChanged(this);
Emily Starkc663b0242019-04-26 19:34:452098 for (auto& observer : observers_)
2099 observer.DidChangeVisibleSecurityState();
dalecurtis6c58ed02016-10-28 23:02:372100}
2101
Ahmed Fakhryd70bf37b2018-04-04 17:07:242102void WebContentsImpl::NotifyPreferencesChanged() {
2103 std::set<RenderViewHost*> render_view_host_set;
2104 for (FrameTreeNode* node : frame_tree_.Nodes()) {
Giovanni Ortuño Urquidi17a5d7c2018-04-30 06:48:532105 render_view_host_set.insert(
2106 node->current_frame_host()->GetRenderViewHost());
Ahmed Fakhryd70bf37b2018-04-04 17:07:242107 }
Giovanni Ortuño Urquidi17a5d7c2018-04-30 06:48:532108
Ahmed Fakhryd70bf37b2018-04-04 17:07:242109 for (RenderViewHost* render_view_host : render_view_host_set)
2110 render_view_host->OnWebkitPreferencesChanged();
2111}
2112
Bruce Long1e3e1f542019-10-16 17:56:282113void WebContentsImpl::SyncRendererPrefs() {
2114 blink::mojom::RendererPreferences renderer_preferences =
2115 GetRendererPrefs(GetBrowserContext());
2116 RenderViewHostImpl::GetPlatformSpecificPrefs(&renderer_preferences);
2117 SendPageMessage(
2118 new PageMsg_SetRendererPrefs(MSG_ROUTING_NONE, renderer_preferences));
2119}
2120
Alexander Timin1cc31f42020-05-12 16:26:012121void WebContentsImpl::OnCookiesAccessed(NavigationHandle* navigation,
2122 const CookieAccessDetails& details) {
Josh Karlindaba39322019-07-17 23:24:332123 for (auto& observer : observers_) {
Alexander Timin1cc31f42020-05-12 16:26:012124 observer.OnCookiesAccessed(navigation, details);
2125 }
2126}
2127
2128void WebContentsImpl::OnCookiesAccessed(RenderFrameHostImpl* rfh,
2129 const CookieAccessDetails& details) {
2130 for (auto& observer : observers_) {
2131 observer.OnCookiesAccessed(rfh, details);
Josh Karlindaba39322019-07-17 23:24:332132 }
2133}
2134
[email protected]b172aee2012-04-10 17:05:262135void WebContentsImpl::Stop() {
dcheng57e39e22016-01-21 00:25:382136 for (FrameTreeNode* node : frame_tree_.Nodes())
2137 node->StopLoading();
ericwilligersde386342016-10-19 02:35:092138 for (auto& observer : observers_)
2139 observer.NavigationStopped();
[email protected]0bfbf882011-12-22 18:19:272140}
2141
Francois Doray47f759d2018-06-11 18:13:512142void WebContentsImpl::SetPageFrozen(bool frozen) {
2143 // A visible page is never frozen.
2144 DCHECK_NE(Visibility::VISIBLE, GetVisibility());
2145
Yuzu Saijo4fa1e9a2020-05-20 02:53:262146 for (auto& entry : frame_tree_.render_view_hosts()) {
2147 entry.second->SetIsFrozen(frozen);
2148 }
Fadi Meawada6573e02018-03-10 00:52:112149}
2150
erikchen6c7df7f7a2018-05-03 18:13:592151std::unique_ptr<WebContents> WebContentsImpl::Clone() {
[email protected]14392a52012-05-02 20:28:442152 // We use our current SiteInstance since the cloned entry will use it anyway.
alexmose201c7cd2015-06-10 17:14:212153 // We pass our own opener so that the cloned page can access it if it was set
[email protected]ed245db2012-12-18 08:00:452154 // before.
[email protected]54944cde2012-12-09 09:24:592155 CreateParams create_params(GetBrowserContext(), GetSiteInstance());
Ian Clelland5cbaaf82017-11-27 22:00:032156 FrameTreeNode* opener = frame_tree_.root()->opener();
2157 RenderFrameHostImpl* opener_rfh = nullptr;
2158 if (opener)
2159 opener_rfh = opener->current_frame_host();
erikchen6c7df7f7a2018-05-03 18:13:592160 std::unique_ptr<WebContentsImpl> tc =
erikchen50735fd2018-05-05 15:08:332161 CreateWithOpener(create_params, opener_rfh);
Lucas Furukawa Gadani5553a152019-01-08 18:55:572162 tc->GetController().CopyStateFrom(&controller_, true);
ericwilligersde386342016-10-19 02:35:092163 for (auto& observer : observers_)
erikchen6c7df7f7a2018-05-03 18:13:592164 observer.DidCloneToNewWebContents(this, tc.get());
[email protected]0bfbf882011-12-22 18:19:272165 return tc;
2166}
2167
[email protected]14392a52012-05-02 20:28:442168void WebContentsImpl::Observe(int type,
[email protected]8ff00d72012-10-23 19:12:212169 const NotificationSource& source,
2170 const NotificationDetails& details) {
[email protected]14392a52012-05-02 20:28:442171 switch (type) {
[email protected]8ff00d72012-10-23 19:12:212172 case NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: {
2173 RenderWidgetHost* host = Source<RenderWidgetHost>(source).ptr();
[email protected]0b431992014-06-24 00:08:032174 RenderWidgetHostView* view = host->GetView();
2175 if (view == GetFullscreenRenderWidgetHostView()) {
2176 // We cannot just call view_->RestoreFocus() here. On some platforms,
2177 // attempting to focus the currently-invisible WebContentsView will be
2178 // flat-out ignored. Therefore, this boolean is used to track whether
2179 // we will request focus after the fullscreen widget has been
2180 // destroyed.
2181 fullscreen_widget_had_focus_at_shutdown_ = (view && view->HasFocus());
2182 } else {
alexmosc2a8cec2016-05-23 22:19:532183 for (auto i = pending_widget_views_.begin();
[email protected]0b431992014-06-24 00:08:032184 i != pending_widget_views_.end(); ++i) {
2185 if (host->GetView() == i->second) {
2186 pending_widget_views_.erase(i);
2187 break;
2188 }
[email protected]bafe6cd2012-05-23 23:09:502189 }
2190 }
2191 break;
2192 }
[email protected]14392a52012-05-02 20:28:442193 default:
2194 NOTREACHED();
2195 }
2196}
2197
[email protected]ec6c05f2013-10-23 18:41:572198WebContents* WebContentsImpl::GetWebContents() {
2199 return this;
2200}
2201
[email protected]54944cde2012-12-09 09:24:592202void WebContentsImpl::Init(const WebContents::CreateParams& params) {
[email protected]fa944cb82013-11-15 17:51:212203 // This is set before initializing the render manager since
[email protected]b0936d22013-11-28 06:47:362204 // RenderFrameHostManager::Init calls back into us via its delegate to ask if
[email protected]fa944cb82013-11-15 17:51:212205 // it should be hidden.
Francois Doraye6161152018-03-27 22:05:372206 visibility_ =
2207 params.initially_hidden ? Visibility::HIDDEN : Visibility::VISIBLE;
[email protected]d6fa88f2013-10-18 16:00:432208
Sebastien Marchand28cf23182018-06-20 02:39:352209 if (!params.last_active_time.is_null())
2210 last_active_time_ = params.last_active_time;
2211
dcheng3ce04b62015-10-26 23:30:552212 scoped_refptr<SiteInstance> site_instance = params.site_instance;
2213 if (!site_instance)
2214 site_instance = SiteInstance::Create(params.browser_context);
Lukasz Anforowicz3caa8372018-06-05 17:22:072215 if (params.desired_renderer_state == CreateParams::kNoRendererProcess) {
2216 static_cast<SiteInstanceImpl*>(site_instance.get())
2217 ->PreventAssociationWithSpareProcess();
2218 }
dcheng3ce04b62015-10-26 23:30:552219
Fergal Dalycb0c1fdf2020-03-16 07:13:492220 GetRenderManager()->InitRoot(site_instance.get(),
2221 params.renderer_initiated_creation);
lukasza464d8692016-02-22 19:26:322222
lukasza5140a412016-09-15 21:12:302223 // blink::FrameTree::setName always keeps |unique_name| empty in case of a
2224 // main frame - let's do the same thing here.
2225 std::string unique_name;
lukasza464d8692016-02-22 19:26:322226 frame_tree_.root()->SetFrameName(params.main_frame_name, unique_name);
[email protected]d1198fd2012-08-13 22:50:192227
[email protected]fc2b46b2014-05-03 16:33:452228 WebContentsViewDelegate* delegate =
2229 GetContentClient()->browser()->GetWebContentsViewDelegate(this);
2230
W. James MacLean2539adb32019-12-13 00:40:442231 if (browser_plugin_guest_) {
sky52a39e342016-12-17 17:23:222232 view_.reset(new WebContentsViewChildFrame(
2233 this, delegate, &render_view_host_delegate_view_));
2234 } else {
2235 view_.reset(CreateWebContentsView(this, delegate,
2236 &render_view_host_delegate_view_));
[email protected]d1198fd2012-08-13 22:50:192237 }
[email protected]fc2b46b2014-05-03 16:33:452238 CHECK(render_view_host_delegate_view_);
[email protected]d1198fd2012-08-13 22:50:192239 CHECK(view_.get());
2240
danakjfc5184932019-09-12 18:08:322241 view_->CreateView(params.context);
[email protected]d1198fd2012-08-13 22:50:192242
brettw4b461082016-11-19 18:55:162243#if BUILDFLAG(ENABLE_PLUGINS)
Yuzu Saijoa11069a2020-04-22 10:56:552244 plugin_content_origin_allowlist_.reset(
2245 new PluginContentOriginAllowlist(this));
tommyclieb25b2a2014-11-03 19:45:092246#endif
2247
[email protected]d1198fd2012-08-13 22:50:192248 registrar_.Add(this,
[email protected]8ff00d72012-10-23 19:12:212249 NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
2250 NotificationService::AllBrowserContextsAndSources());
[email protected]f28ef9a32014-05-12 16:36:102251
leon.hane4db177a2017-02-07 14:19:162252 screen_orientation_provider_.reset(new ScreenOrientationProvider(this));
[email protected]01f83f92014-06-17 14:41:542253
mfomitchev2b8b066a2016-01-28 19:23:152254#if defined(OS_ANDROID)
Oksana Zhuravlova0b634332019-10-28 23:04:222255 DateTimeChooserAndroid::CreateForWebContents(this);
[email protected]583418cc2013-01-17 14:01:102256#endif
fsamuel7310a4262014-12-05 05:06:442257
2258 // BrowserPluginGuest::Init needs to be called after this WebContents has
W. James MacLean6e78da342019-12-13 15:13:232259 // a RenderWidgetHostViewChildFrame. That is, |view_->CreateView| above.
fsamuel7310a4262014-12-05 05:06:442260 if (browser_plugin_guest_)
2261 browser_plugin_guest_->Init();
nickf9acfbe2014-12-23 19:12:372262
2263 for (size_t i = 0; i < g_created_callbacks.Get().size(); i++)
2264 g_created_callbacks.Get().at(i).Run(this);
naskob21fe4872015-02-24 14:15:562265
2266 // If the WebContents creation was renderer-initiated, it means that the
2267 // corresponding RenderView and main RenderFrame have already been created.
2268 // Ensure observers are notified about this.
2269 if (params.renderer_initiated_creation) {
Fergal Dalybb2d6592020-06-02 05:02:332270 GetRenderViewHost()->GetWidget()->set_renderer_initialized(true);
Alex Moshchuk27caae82017-09-11 23:11:182271 GetRenderViewHost()->DispatchRenderViewCreated();
naskob21fe4872015-02-24 14:15:562272 GetRenderManager()->current_frame_host()->SetRenderFrameCreated(true);
2273 }
naskof5940b9f2015-03-02 23:04:052274
lof84501da082016-05-23 21:22:542275 // Create the renderer process in advance if requested.
Lukasz Anforowicz3caa8372018-06-05 17:22:072276 if (params.desired_renderer_state ==
2277 CreateParams::kInitializeAndWarmupRendererProcess) {
lof84501da082016-05-23 21:22:542278 if (!GetRenderManager()->current_frame_host()->IsRenderFrameLive()) {
2279 GetRenderManager()->InitRenderView(GetRenderViewHost(), nullptr);
2280 }
2281 }
2282
naskof5940b9f2015-03-02 23:04:052283 // Ensure that observers are notified of the creation of this WebContents's
2284 // main RenderFrameHost. It must be done here for main frames, since the
2285 // NotifySwappedFromRenderManager expects view_ to already be created and that
2286 // happens after RenderFrameHostManager::Init.
2287 NotifySwappedFromRenderManager(
2288 nullptr, GetRenderManager()->current_frame_host(), true);
Albert J. Wonge76bf0b82019-09-27 07:47:062289
2290 // For WebContents that are never shown, do critical initialization here which
2291 // would normally only happen when the WebContents is shown.
2292 if (params.is_never_visible) {
2293 // This has just been created so there can only be one frame. Thus it is
2294 // safe to initialize the root.
2295 GetMainFrame()->Init();
2296 }
[email protected]d1198fd2012-08-13 22:50:192297}
2298
[email protected]7fff43e2013-05-21 20:21:102299void WebContentsImpl::OnWebContentsDestroyed(WebContentsImpl* web_contents) {
2300 RemoveDestructionObserver(web_contents);
2301
[email protected]ceee8cd2013-03-08 04:59:512302 // Clear a pending contents that has been closed before being shown.
alexmosc2a8cec2016-05-23 22:19:532303 for (auto iter = pending_contents_.begin(); iter != pending_contents_.end();
[email protected]ceee8cd2013-03-08 04:59:512304 ++iter) {
Joel Hockey8c2011b22020-04-30 05:07:192305 if (iter->second.contents.get() != web_contents)
[email protected]ceee8cd2013-03-08 04:59:512306 continue;
erikchenbee5c9622018-04-27 19:30:252307
2308 // Someone else has deleted the WebContents. That should never happen!
2309 // TODO(erikchen): Fix semantics here. https://crbug.com/832879.
Joel Hockey8c2011b22020-04-30 05:07:192310 iter->second.contents.release();
[email protected]ceee8cd2013-03-08 04:59:512311 pending_contents_.erase(iter);
[email protected]ceee8cd2013-03-08 04:59:512312 return;
2313 }
2314 NOTREACHED();
[email protected]14392a52012-05-02 20:28:442315}
2316
[email protected]7fff43e2013-05-21 20:21:102317void WebContentsImpl::AddDestructionObserver(WebContentsImpl* web_contents) {
Jan Wilken Dörrie73c901e2019-06-12 09:02:322318 if (!base::Contains(destruction_observers_, web_contents)) {
[email protected]7fff43e2013-05-21 20:21:102319 destruction_observers_[web_contents] =
Jeremy Roman04f27c372017-10-27 15:20:552320 std::make_unique<DestructionObserver>(this, web_contents);
[email protected]7fff43e2013-05-21 20:21:102321 }
2322}
2323
2324void WebContentsImpl::RemoveDestructionObserver(WebContentsImpl* web_contents) {
avia8cf81982016-08-12 20:28:462325 destruction_observers_.erase(web_contents);
[email protected]7fff43e2013-05-21 20:21:102326}
2327
[email protected]b172aee2012-04-10 17:05:262328void WebContentsImpl::AddObserver(WebContentsObserver* observer) {
[email protected]be1f56ab2011-12-22 06:55:312329 observers_.AddObserver(observer);
2330}
2331
[email protected]b172aee2012-04-10 17:05:262332void WebContentsImpl::RemoveObserver(WebContentsObserver* observer) {
[email protected]be1f56ab2011-12-22 06:55:312333 observers_.RemoveObserver(observer);
2334}
2335
[email protected]948481d2014-06-11 18:32:222336std::set<RenderWidgetHostView*>
2337WebContentsImpl::GetRenderWidgetHostViewsInTree() {
2338 std::set<RenderWidgetHostView*> set;
Carlos IL07f282f2020-05-15 22:58:292339 for (RenderFrameHost* rfh : GetAllFrames()) {
2340 if (RenderWidgetHostView* rwhv = static_cast<RenderFrameHostImpl*>(rfh)
2341 ->frame_tree_node()
2342 ->render_manager()
2343 ->GetRenderWidgetHostView()) {
lfgf949e0e2017-05-10 22:18:112344 set.insert(rwhv);
dchengafb53e22016-02-04 08:11:082345 }
[email protected]948481d2014-06-11 18:32:222346 }
[email protected]de3c5d82014-05-28 22:12:592347 return set;
2348}
2349
Adithya Srinivasane6e7f842019-12-16 18:41:362350std::set<RenderWidgetHostView*>
2351WebContentsImpl::GetRenderWidgetHostViewsInWebContentsTree() {
2352 std::set<RenderWidgetHostView*> result;
2353 GetRenderWidgetHostViewsInWebContentsTree(result);
2354 return result;
2355}
2356
2357void WebContentsImpl::GetRenderWidgetHostViewsInWebContentsTree(
2358 std::set<RenderWidgetHostView*>& result) {
2359 std::set<RenderWidgetHostView*> views = GetRenderWidgetHostViewsInTree();
2360 result.insert(views.begin(), views.end());
2361 for (auto* inner_web_contents : GetInnerWebContents()) {
2362 static_cast<WebContentsImpl*>(inner_web_contents)
2363 ->GetRenderWidgetHostViewsInWebContentsTree(result);
2364 }
2365}
2366
[email protected]b172aee2012-04-10 17:05:262367void WebContentsImpl::Activate() {
[email protected]d5f942ba2008-09-26 19:30:342368 if (delegate_)
2369 delegate_->ActivateContents(this);
2370}
2371
avi3e4b8512015-11-11 01:55:492372void WebContentsImpl::LostCapture(RenderWidgetHostImpl* render_widget_host) {
2373 if (!RenderViewHostImpl::From(render_widget_host))
2374 return;
2375
[email protected]63954792011-07-11 04:17:482376 if (delegate_)
2377 delegate_->LostCapture();
2378}
2379
Yue Ru Sun979c4b162019-11-06 16:11:042380ukm::SourceId
2381WebContentsImpl::GetUkmSourceIdForLastCommittedSourceIncludingSameDocument()
2382 const {
2383 return last_committed_source_id_including_same_document_;
2384}
2385
Ahmed Fakhryfaa32d22018-10-05 15:56:162386void WebContentsImpl::SetTopControlsShownRatio(
2387 RenderWidgetHostImpl* render_widget_host,
2388 float ratio) {
2389 if (!delegate_)
2390 return;
2391
2392 RenderFrameHostImpl* rfh = GetMainFrame();
2393 if (!rfh || render_widget_host != rfh->GetRenderWidgetHost())
2394 return;
2395
2396 delegate_->SetTopControlsShownRatio(this, ratio);
Ahmed Fakhry58e6ef542018-09-04 18:05:382397}
2398
Ahmed Fakhry58e6ef542018-09-04 18:05:382399void WebContentsImpl::SetTopControlsGestureScrollInProgress(bool in_progress) {
2400 if (delegate_)
2401 delegate_->SetTopControlsGestureScrollInProgress(in_progress);
2402}
2403
lazyboy63f5b312015-11-23 20:19:522404void WebContentsImpl::RenderWidgetCreated(
2405 RenderWidgetHostImpl* render_widget_host) {
2406 created_widgets_.insert(render_widget_host);
2407}
2408
[email protected]b24b68a2012-09-24 21:57:262409void WebContentsImpl::RenderWidgetDeleted(
2410 RenderWidgetHostImpl* render_widget_host) {
lazyboy63f5b312015-11-23 20:19:522411 // Note that |is_being_destroyed_| can be true at this point as
2412 // ~WebContentsImpl() calls RFHM::ClearRFHsPendingShutdown(), which might lead
2413 // us here.
2414 created_widgets_.erase(render_widget_host);
[email protected]b24b68a2012-09-24 21:57:262415
lazyboy63f5b312015-11-23 20:19:522416 if (is_being_destroyed_)
2417 return;
[email protected]44470a22013-01-24 01:21:542418
2419 if (render_widget_host &&
alexmosc9e76ec2016-05-16 22:59:372420 render_widget_host->GetRoutingID() == fullscreen_widget_routing_id_ &&
2421 render_widget_host->GetProcess()->GetID() ==
2422 fullscreen_widget_process_id_) {
[email protected]4aebbca2013-09-17 22:26:492423 if (delegate_ && delegate_->EmbedsFullscreenWidget())
mlamouri7a78d6fd2015-01-17 13:23:532424 delegate_->ExitFullscreenModeForTab(this);
ericwilligersde386342016-10-19 02:35:092425 for (auto& observer : observers_)
2426 observer.DidDestroyFullscreenWidget();
alexmosc9e76ec2016-05-16 22:59:372427 fullscreen_widget_process_id_ = ChildProcessHost::kInvalidUniqueID;
[email protected]44470a22013-01-24 01:21:542428 fullscreen_widget_routing_id_ = MSG_ROUTING_NONE;
[email protected]0b431992014-06-24 00:08:032429 if (fullscreen_widget_had_focus_at_shutdown_)
2430 view_->RestoreFocus();
[email protected]44470a22013-01-24 01:21:542431 }
lfgbee1e0a2016-06-08 21:24:212432
lfg7d4caad2017-03-22 09:01:452433 if (render_widget_host == mouse_lock_widget_)
lfgff8dfc8d2016-10-21 17:42:322434 LostMouseLock(mouse_lock_widget_);
Joe Downing192998b22018-03-22 15:51:362435
Joe Downingc1a57efe2018-05-09 18:23:542436 CancelKeyboardLock(render_widget_host);
[email protected]b24b68a2012-09-24 21:57:262437}
2438
miu9e14e492014-10-25 02:39:042439void WebContentsImpl::RenderWidgetGotFocus(
2440 RenderWidgetHostImpl* render_widget_host) {
calamity7fe55ce2015-04-10 03:59:372441 // Notify the observers if an embedded fullscreen widget was focused.
2442 if (delegate_ && render_widget_host && delegate_->EmbedsFullscreenWidget() &&
2443 render_widget_host->GetView() == GetFullscreenRenderWidgetHostView()) {
Michael Thiessen896405db2017-07-20 17:52:322444 NotifyWebContentsFocused(render_widget_host);
calamity7fe55ce2015-04-10 03:59:372445 }
miu9e14e492014-10-25 02:39:042446}
2447
zijiehe3bee08e22017-05-17 04:14:462448void WebContentsImpl::RenderWidgetLostFocus(
2449 RenderWidgetHostImpl* render_widget_host) {
Michael Thiessen896405db2017-07-20 17:52:322450 // Notify the observers if an embedded fullscreen widget lost focus.
2451 if (delegate_ && render_widget_host && delegate_->EmbedsFullscreenWidget() &&
2452 render_widget_host->GetView() == GetFullscreenRenderWidgetHostView()) {
2453 NotifyWebContentsLostFocus(render_widget_host);
2454 }
zijiehe3bee08e22017-05-17 04:14:462455}
2456
estaded0a0c992015-01-21 14:12:062457void WebContentsImpl::RenderWidgetWasResized(
rouslan2f5993f2015-01-29 00:18:312458 RenderWidgetHostImpl* render_widget_host,
2459 bool width_changed) {
creisc014b402015-04-23 16:41:452460 RenderFrameHostImpl* rfh = GetMainFrame();
estadece344ec2015-01-23 00:12:292461 if (!rfh || render_widget_host != rfh->GetRenderWidgetHost())
estaded0a0c992015-01-21 14:12:062462 return;
estaded0a0c992015-01-21 14:12:062463
ericwilligersde386342016-10-19 02:35:092464 for (auto& observer : observers_)
2465 observer.MainFrameWasResized(width_changed);
estaded0a0c992015-01-21 14:12:062466}
2467
skyf65d9bb2017-03-24 02:26:392468KeyboardEventProcessingResult WebContentsImpl::PreHandleKeyboardEvent(
2469 const NativeWebKeyboardEvent& event) {
W. James MacLeane1187272019-11-12 03:42:482470 auto* outermost_contents = GetOutermostWebContents();
2471 // TODO(wjmaclean): Generalize this to forward all key events to the outermost
2472 // delegate's handler.
Avi Drissman97aef042020-06-30 21:04:482473 if (outermost_contents != this && IsFullscreen() &&
W. James MacLeane1187272019-11-12 03:42:482474 event.windows_key_code == ui::VKEY_ESCAPE) {
2475 // When an inner WebContents has focus and is fullscreen, redirect <esc>
2476 // key events to the outermost WebContents so it can be handled by that
2477 // WebContents' delegate.
2478 if (outermost_contents->PreHandleKeyboardEvent(event) ==
2479 KeyboardEventProcessingResult::HANDLED) {
2480 return KeyboardEventProcessingResult::HANDLED;
2481 }
2482 }
skyf65d9bb2017-03-24 02:26:392483 return delegate_ ? delegate_->PreHandleKeyboardEvent(this, event)
2484 : KeyboardEventProcessingResult::NOT_HANDLED;
[email protected]63954792011-07-11 04:17:482485}
2486
Dave Tapuska344399e2019-09-09 15:18:262487bool WebContentsImpl::HandleMouseEvent(const blink::WebMouseEvent& event) {
2488 // Handle mouse button back/forward in the browser process after the render
2489 // process is done with the event. This ensures all renderer-initiated history
2490 // navigations can be treated consistently.
2491 if (event.GetType() == blink::WebInputEvent::Type::kMouseUp) {
2492 WebContentsImpl* outermost = GetOutermostWebContents();
2493 if (event.button == blink::WebPointerProperties::Button::kBack &&
2494 outermost->controller_.CanGoBack()) {
2495 outermost->controller_.GoBack();
2496 return true;
2497 } else if (event.button == blink::WebPointerProperties::Button::kForward &&
2498 outermost->controller_.CanGoForward()) {
2499 outermost->controller_.GoForward();
2500 return true;
2501 }
2502 }
2503 return false;
2504}
2505
Scott Violetd5caa872018-10-16 22:00:512506bool WebContentsImpl::HandleKeyboardEvent(const NativeWebKeyboardEvent& event) {
[email protected]0b094002014-08-20 18:28:102507 if (browser_plugin_embedder_ &&
2508 browser_plugin_embedder_->HandleKeyboardEvent(event)) {
Scott Violetd5caa872018-10-16 22:00:512509 return true;
[email protected]0b094002014-08-20 18:28:102510 }
Scott Violetd5caa872018-10-16 22:00:512511 return delegate_ && delegate_->HandleKeyboardEvent(this, event);
[email protected]63954792011-07-11 04:17:482512}
2513
[email protected]d92026ef2014-03-03 21:04:132514bool WebContentsImpl::HandleWheelEvent(
[email protected]180ef242013-11-07 06:50:462515 const blink::WebMouseWheelEvent& event) {
[email protected]bccc4472013-04-18 16:37:192516#if !defined(OS_MACOSX)
lanweia93644f2015-01-21 22:00:332517 // On platforms other than Mac, control+mousewheel may change zoom. On Mac,
2518 // this isn't done for two reasons:
[email protected]bccc4472013-04-18 16:37:192519 // -the OS already has a gesture to do this through pinch-zoom
2520 // -if a user starts an inertial scroll, let's go, and presses control
2521 // (i.e. control+tab) then the OS's buffered scroll events will come in
2522 // with control key set which isn't what the user wants
Blink Reformat1c4d759e2017-04-09 16:34:542523 if (delegate_ && event.wheel_ticks_y &&
Ehsan Karamad0f83cb112018-09-06 22:07:362524 event.event_action == blink::WebMouseWheelEvent::EventAction::kPageZoom) {
w.shackleton49bcd392016-01-06 17:38:222525 // Count only integer cumulative scrolls as zoom events; this handles
2526 // smooth scroll and regular scroll device behavior.
Blink Reformat1c4d759e2017-04-09 16:34:542527 zoom_scroll_remainder_ += event.wheel_ticks_y;
w.shackleton49bcd392016-01-06 17:38:222528 int whole_zoom_scroll_remainder_ = std::lround(zoom_scroll_remainder_);
2529 zoom_scroll_remainder_ -= whole_zoom_scroll_remainder_;
2530 if (whole_zoom_scroll_remainder_ != 0) {
2531 delegate_->ContentsZoomChange(whole_zoom_scroll_remainder_ > 0);
2532 }
[email protected]fb3f066e2013-02-12 19:12:522533 return true;
2534 }
[email protected]bccc4472013-04-18 16:37:192535#endif
[email protected]fb3f066e2013-02-12 19:12:522536 return false;
2537}
2538
[email protected]04bce562014-01-30 05:34:542539bool WebContentsImpl::PreHandleGestureEvent(
2540 const blink::WebGestureEvent& event) {
[email protected]28042d32014-02-03 14:10:032541 return delegate_ && delegate_->PreHandleGestureEvent(this, event);
[email protected]04bce562014-01-30 05:34:542542}
2543
kenrb2a565f82015-09-02 20:24:592544RenderWidgetHostInputEventRouter* WebContentsImpl::GetInputEventRouter() {
wjmacleane31234f2015-12-14 17:20:452545 if (!is_being_destroyed_ && GetOuterWebContents())
2546 return GetOuterWebContents()->GetInputEventRouter();
2547
2548 if (!rwh_input_event_router_.get() && !is_being_destroyed_)
kenrb2a565f82015-09-02 20:24:592549 rwh_input_event_router_.reset(new RenderWidgetHostInputEventRouter);
2550 return rwh_input_event_router_.get();
2551}
2552
alexmos3fcd0ca2015-10-23 18:18:332553void WebContentsImpl::ReplicatePageFocus(bool is_focused) {
2554 // Focus loss may occur while this WebContents is being destroyed. Don't
2555 // send the message in this case, as the main frame's RenderFrameHost and
2556 // other state has already been cleared.
2557 if (is_being_destroyed_)
2558 return;
2559
2560 frame_tree_.ReplicatePageFocus(is_focused);
2561}
2562
alexmosc4cbacb2015-11-21 01:29:222563RenderWidgetHostImpl* WebContentsImpl::GetFocusedRenderWidgetHost(
2564 RenderWidgetHostImpl* receiving_widget) {
alexmosc4cbacb2015-11-21 01:29:222565 // Events for widgets other than the main frame (e.g., popup menus) should be
2566 // forwarded directly to the widget they arrived on.
2567 if (receiving_widget != GetMainFrame()->GetRenderWidgetHost())
2568 return receiving_widget;
alexmosc4d183e2015-11-06 00:46:522569
paulmeyerfeafc2d2017-04-25 21:46:402570 // If the focused WebContents is a guest WebContents, then get the focused
2571 // frame in the embedder WebContents instead.
W. James MacLean13d834d2019-12-04 16:06:452572 FrameTreeNode* focused_frame =
2573 GetFocusedWebContents()->frame_tree_.GetFocusedFrame();
lfg1453e412017-04-11 00:48:502574
alexmosc4d183e2015-11-06 00:46:522575 if (!focused_frame)
alexmosc4cbacb2015-11-21 01:29:222576 return receiving_widget;
alexmosc4d183e2015-11-06 00:46:522577
alexmos732ca3a2015-12-08 02:01:022578 // The view may be null if a subframe's renderer process has crashed while
2579 // the subframe has focus. Drop the event in that case. Do not give
2580 // it to the main frame, so that the user doesn't unexpectedly type into the
2581 // wrong frame if a focused subframe renderer crashes while they type.
2582 RenderWidgetHostView* view = focused_frame->current_frame_host()->GetView();
2583 if (!view)
2584 return nullptr;
2585
2586 return RenderWidgetHostImpl::From(view->GetRenderWidgetHost());
alexmosc4d183e2015-11-06 00:46:522587}
2588
avallee9993fca2016-11-17 06:16:502589RenderWidgetHostImpl* WebContentsImpl::GetRenderWidgetHostWithPageFocus() {
lfg1453e412017-04-11 00:48:502590 WebContentsImpl* focused_web_contents = GetFocusedWebContents();
2591
lfg1453e412017-04-11 00:48:502592 return focused_web_contents->GetMainFrame()->GetRenderWidgetHost();
avallee9993fca2016-11-17 06:16:502593}
2594
Avi Drissmand1d25652020-03-06 21:28:582595bool WebContentsImpl::CanEnterFullscreenMode() {
Avi Drissman33972942020-06-19 14:16:012596 // It's possible that this WebContents was spawned while blocking UI was on
2597 // the screen, or that it was downstream from a WebContents when UI was
2598 // blocked. Therefore, disqualify it from fullscreen if it or any upstream
2599 // WebContents has an active blocker.
2600 auto openers = GetAllOpeningWebContents(this);
2601 return std::all_of(openers.begin(), openers.end(), [](auto* opener) {
2602 return opener->fullscreen_blocker_count_ == 0;
2603 });
Avi Drissmand1d25652020-03-06 21:28:582604}
2605
Dave Tapuska3ed44192018-05-01 18:53:302606void WebContentsImpl::EnterFullscreenMode(
Mike Wasserman4ca09792020-05-29 17:44:432607 RenderFrameHost* requesting_frame,
Dave Tapuskaa4189512019-10-15 20:27:342608 const blink::mojom::FullscreenOptions& options) {
Avi Drissmand1d25652020-03-06 21:28:582609 DCHECK(CanEnterFullscreenMode());
2610
mlamouri7a78d6fd2015-01-17 13:23:532611 // This method is being called to enter renderer-initiated fullscreen mode.
2612 // Make sure any existing fullscreen widget is shut down first.
[email protected]4aebbca2013-09-17 22:26:492613 RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
avi85a4cef2015-12-18 20:13:372614 if (widget_view) {
2615 RenderWidgetHostImpl::From(widget_view->GetRenderWidgetHost())
2616 ->ShutdownAndDestroyWidget(true);
2617 }
[email protected]4aebbca2013-09-17 22:26:492618
Joe Downing13dd76b2018-04-09 18:32:152619 if (delegate_) {
Mike Wasserman4ca09792020-05-29 17:44:432620 delegate_->EnterFullscreenModeForTab(requesting_frame, options);
mlamouri7a78d6fd2015-01-17 13:23:532621
Joe Downing13dd76b2018-04-09 18:32:152622 if (keyboard_lock_widget_)
2623 delegate_->RequestKeyboardLock(this, esc_key_locked_);
2624 }
2625
ericwilligersde386342016-10-19 02:35:092626 for (auto& observer : observers_)
Avi Drissman97aef042020-06-30 21:04:482627 observer.DidToggleFullscreenModeForTab(IsFullscreen(), false);
Avi Drissman33972942020-06-19 14:16:012628
2629 FullscreenContentsSet(GetBrowserContext())->insert(this);
mlamouri7a78d6fd2015-01-17 13:23:532630}
2631
bokanece34a82016-01-28 19:49:462632void WebContentsImpl::ExitFullscreenMode(bool will_cause_resize) {
mlamouri7a78d6fd2015-01-17 13:23:532633 // This method is being called to leave renderer-initiated fullscreen mode.
2634 // Make sure any existing fullscreen widget is shut down first.
2635 RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
avi85a4cef2015-12-18 20:13:372636 if (widget_view) {
2637 RenderWidgetHostImpl::From(widget_view->GetRenderWidgetHost())
2638 ->ShutdownAndDestroyWidget(true);
2639 }
mlamouri7a78d6fd2015-01-17 13:23:532640
Joe Downing13dd76b2018-04-09 18:32:152641 if (delegate_) {
mlamouri7a78d6fd2015-01-17 13:23:532642 delegate_->ExitFullscreenModeForTab(this);
[email protected]657c8e02014-03-19 19:18:372643
Joe Downing13dd76b2018-04-09 18:32:152644 if (keyboard_lock_widget_)
2645 delegate_->CancelKeyboardLockRequest(this);
2646 }
2647
bokanece34a82016-01-28 19:49:462648 // The fullscreen state is communicated to the renderer through a resize
2649 // message. If the change in fullscreen state doesn't cause a view resize
2650 // then we must ensure web contents exit the fullscreen state by explicitly
2651 // sending a resize message. This is required for the situation of the browser
2652 // moving the view into a "browser fullscreen" state and then the contents
2653 // entering "tab fullscreen". Exiting the contents "tab fullscreen" then won't
2654 // have the side effect of the view resizing, hence the explicit call here is
2655 // required.
2656 if (!will_cause_resize) {
2657 if (RenderWidgetHostView* rwhv = GetRenderWidgetHostView()) {
2658 if (RenderWidgetHost* render_widget_host = rwhv->GetRenderWidgetHost())
Fady Samuel0b911822018-04-25 13:22:162659 render_widget_host->SynchronizeVisualProperties();
bokanece34a82016-01-28 19:49:462660 }
scheib3dcb6c932015-02-23 10:55:582661 }
2662
Arthur Sonzogni929d29f2018-09-17 14:19:442663 current_fullscreen_frame_ = nullptr;
Becca Hughese9e27952018-06-25 17:08:272664
ericwilligersde386342016-10-19 02:35:092665 for (auto& observer : observers_) {
Avi Drissman97aef042020-06-30 21:04:482666 observer.DidToggleFullscreenModeForTab(IsFullscreen(), will_cause_resize);
ericwilligersde386342016-10-19 02:35:092667 }
Becca Hughesd11d6502018-07-31 17:01:282668
2669 if (display_cutout_host_impl_)
2670 display_cutout_host_impl_->DidExitFullscreen();
Avi Drissman33972942020-06-19 14:16:012671
2672 FullscreenContentsSet(GetBrowserContext())->erase(this);
[email protected]8a5e0ca2011-08-25 06:30:472673}
2674
Becca Hughesfd5d8f892018-06-14 18:23:362675void WebContentsImpl::FullscreenStateChanged(RenderFrameHost* rfh,
2676 bool is_fullscreen) {
Arthur Sonzogni929d29f2018-09-17 14:19:442677 RenderFrameHostImpl* frame = static_cast<RenderFrameHostImpl*>(rfh);
Becca Hughesfd5d8f892018-06-14 18:23:362678
2679 if (is_fullscreen) {
Jan Wilken Dörrie531be7ca2019-06-07 10:05:572680 if (!base::Contains(fullscreen_frames_, frame)) {
Arthur Sonzogni929d29f2018-09-17 14:19:442681 fullscreen_frames_.insert(frame);
2682 FullscreenFrameSetUpdated();
Becca Hughesfd5d8f892018-06-14 18:23:362683 }
Arthur Sonzogni929d29f2018-09-17 14:19:442684 return;
2685 }
Becca Hughesfd5d8f892018-06-14 18:23:362686
Arthur Sonzogni929d29f2018-09-17 14:19:442687 // If |frame| is no longer in fullscreen, remove it and any descendants.
2688 // See https://fullscreen.spec.whatwg.org.
Arthur Sonzogni969a794e2018-10-11 08:56:092689 size_t size_before_deletion = fullscreen_frames_.size();
2690 base::EraseIf(fullscreen_frames_, [&](RenderFrameHostImpl* current) {
2691 return (current == frame || current->IsDescendantOf(frame));
Arthur Sonzogni929d29f2018-09-17 14:19:442692 });
2693
Arthur Sonzogni969a794e2018-10-11 08:56:092694 if (size_before_deletion != fullscreen_frames_.size())
Arthur Sonzogni929d29f2018-09-17 14:19:442695 FullscreenFrameSetUpdated();
2696}
2697
2698void WebContentsImpl::FullscreenFrameSetUpdated() {
2699 if (fullscreen_frames_.empty()) {
2700 current_fullscreen_frame_ = nullptr;
2701 return;
Becca Hughesfd5d8f892018-06-14 18:23:362702 }
2703
Arthur Sonzogni929d29f2018-09-17 14:19:442704 // Find the current fullscreen frame and call the observers.
2705 // If frame A is fullscreen, then frame B goes into inner fullscreen, then B
2706 // exits fullscreen - that will result in A being fullscreen.
2707 RenderFrameHostImpl* new_fullscreen_frame = *std::max_element(
2708 fullscreen_frames_.begin(), fullscreen_frames_.end(), FrameCompareDepth);
Becca Hughesfd5d8f892018-06-14 18:23:362709
Arthur Sonzogni929d29f2018-09-17 14:19:442710 // If we have already notified observers about this frame then we should not
2711 // fire the observers again.
2712 if (new_fullscreen_frame == current_fullscreen_frame_)
2713 return;
2714 current_fullscreen_frame_ = new_fullscreen_frame;
Becca Hughesfd5d8f892018-06-14 18:23:362715
Arthur Sonzogni929d29f2018-09-17 14:19:442716 for (auto& observer : observers_)
2717 observer.DidAcquireFullscreen(new_fullscreen_frame);
Becca Hughesfd5d8f892018-06-14 18:23:362718
Arthur Sonzogni929d29f2018-09-17 14:19:442719 if (display_cutout_host_impl_)
2720 display_cutout_host_impl_->DidAcquireFullscreen(new_fullscreen_frame);
Becca Hughesfd5d8f892018-06-14 18:23:362721}
2722
Collin Baker989e0882019-11-01 01:27:172723void WebContentsImpl::UpdateVisibilityAndNotifyPageAndView(
2724 Visibility new_visibility) {
Collin Baker989e0882019-11-01 01:27:172725 // Only hide the page if there are no entities capturing screenshots
Collin Bakerc5259962019-11-14 17:51:582726 // or video (e.g. mirroring). If there are, apply the correct state of
2727 // kHidden or kHiddenButPainting.
2728 PageVisibilityState page_visibility;
2729 if (new_visibility == Visibility::VISIBLE || visible_capturer_count_ > 0)
2730 page_visibility = PageVisibilityState::kVisible;
2731 else if (hidden_capturer_count_ > 0)
2732 page_visibility = PageVisibilityState::kHiddenButPainting;
2733 else
2734 page_visibility = PageVisibilityState::kHidden;
Collin Baker989e0882019-11-01 01:27:172735 // If there are entities in Picture-in-Picture mode, don't activate
2736 // the "disable rendering" optimization.
Collin Bakerc5259962019-11-14 17:51:582737 const bool view_is_visible =
2738 page_visibility != PageVisibilityState::kHidden ||
2739 HasPictureInPictureVideo();
Collin Baker989e0882019-11-01 01:27:172740
Collin Bakerc5259962019-11-14 17:51:582741 if (page_visibility != PageVisibilityState::kHidden) {
Dana Friedcf3bc8e2019-11-13 20:00:242742 // We cannot show a page or capture video unless there is a valid renderer
2743 // associated with this web contents. The navigation controller for this
2744 // page must be set to active (allowing navigation to complete, a renderer
2745 // and its associated views to be created, etc.) if any of these conditions
2746 // holds.
2747 //
2748 // Previously, it was possible for browser-side code to try to capture video
2749 // from a restored tab (for a variety of reasons, including the browser
2750 // creating preview thumbnails) and the tab would never actually load. By
Collin Bakerc5259962019-11-14 17:51:582751 // keying this behavior off of |page_visibility| instead of just
Dana Friedcf3bc8e2019-11-13 20:00:242752 // |new_visibility| we avoid this case. See crbug.com/1020782 for more
2753 // context.
2754 controller_.SetActive(true);
2755
2756 // This shows the Page before showing the individual RenderWidgets, as
2757 // RenderWidgets will work to produce compositor frames and handle input
2758 // as soon as they are shown. But the Page and other classes do not expect
2759 // to be producing frames when the Page is hidden. So we make sure the Page
2760 // is shown first.
Yuzu Saijo232076f2020-05-29 07:14:022761 for (auto* rvh : GetRenderViewHostsIncludingBackForwardCached()) {
2762 rvh->SetVisibility(page_visibility);
Yuzu Saijobe024af02020-05-11 07:35:562763 }
Collin Baker98457b52019-11-06 21:34:292764 }
Collin Baker989e0882019-11-01 01:27:172765
2766 // |GetRenderWidgetHostView()| can be null if the user middle clicks a link to
2767 // open a tab in the background, then closes the tab before selecting it.
2768 // This is because closing the tab calls WebContentsImpl::Destroy(), which
2769 // removes the |GetRenderViewHost()|; then when we actually destroy the
2770 // window, OnWindowPosChanged() notices and calls WasHidden() (which
2771 // calls us).
2772 if (auto* view = GetRenderWidgetHostView()) {
2773 if (view_is_visible) {
2774 view->Show();
Collin Baker989e0882019-11-01 01:27:172775 } else if (new_visibility == Visibility::HIDDEN) {
2776 view->Hide();
2777 } else {
2778 view->WasOccluded();
2779 }
2780 }
2781
Carlos IL07f282f2020-05-15 22:58:292782 SetVisibilityForChildViews(view_is_visible);
Collin Baker989e0882019-11-01 01:27:172783
2784 // Make sure to call SetVisibilityAndNotifyObservers(VISIBLE) before notifying
2785 // the CrossProcessFrameConnector.
2786 if (new_visibility == Visibility::VISIBLE) {
2787 last_active_time_ = base::TimeTicks::Now();
2788 SetVisibilityAndNotifyObservers(new_visibility);
2789 }
2790
Collin Bakerc5259962019-11-14 17:51:582791 if (page_visibility == PageVisibilityState::kHidden) {
Collin Baker989e0882019-11-01 01:27:172792 // Similar to when showing the page, we only hide the page after
2793 // hiding the individual RenderWidgets.
Yuzu Saijo232076f2020-05-29 07:14:022794 for (auto* rvh : GetRenderViewHostsIncludingBackForwardCached()) {
2795 rvh->SetVisibility(page_visibility);
Yuzu Saijobe024af02020-05-11 07:35:562796 }
2797
Collin Baker989e0882019-11-01 01:27:172798 } else {
2799 for (FrameTreeNode* node : frame_tree_.Nodes()) {
2800 RenderFrameProxyHost* parent = node->render_manager()->GetProxyToParent();
2801 if (!parent)
2802 continue;
2803
2804 parent->cross_process_frame_connector()->DelegateWasShown();
2805 }
2806 }
2807
2808 if (new_visibility != Visibility::VISIBLE)
2809 SetVisibilityAndNotifyObservers(new_visibility);
2810}
2811
Clark DuValla0e42992018-09-17 17:00:112812#if defined(OS_ANDROID)
2813void WebContentsImpl::UpdateUserGestureCarryoverInfo() {
2814 if (delegate_)
2815 delegate_->UpdateUserGestureCarryoverInfo(this);
2816}
2817#endif
2818
Avi Drissman97aef042020-06-30 21:04:482819bool WebContentsImpl::IsFullscreen() {
[email protected]199bba6e2012-04-04 16:19:382820 return delegate_ ? delegate_->IsFullscreenForTabOrPending(this) : false;
[email protected]5d5f7af2011-10-01 01:38:122821}
2822
Malay Keshav87c42c02019-01-15 08:37:472823bool WebContentsImpl::ShouldShowStaleContentOnEviction() {
2824 return GetDelegate() && GetDelegate()->ShouldShowStaleContentOnEviction(this);
2825}
2826
danakj45d42452020-04-08 17:24:182827blink::mojom::DisplayMode WebContentsImpl::GetDisplayMode() const {
mikhail.pozdnyakovc0e251b2015-04-15 06:51:122828 return delegate_ ? delegate_->GetDisplayMode(this)
Eric Willigers052f0432019-10-04 04:06:572829 : blink::mojom::DisplayMode::kBrowser;
mikhail.pozdnyakovc0e251b2015-04-15 06:51:122830}
2831
avic3aa8422015-11-09 20:57:222832void WebContentsImpl::RequestToLockMouse(
2833 RenderWidgetHostImpl* render_widget_host,
2834 bool user_gesture,
lfgad8244352016-07-13 16:55:512835 bool last_unlocked_by_target,
2836 bool privileged) {
lfgf0cd46e2017-01-04 00:05:232837 for (WebContentsImpl* current = this; current;
2838 current = current->GetOuterWebContents()) {
2839 if (current->mouse_lock_widget_) {
James Hollyerd5c9de462020-03-10 19:02:452840 render_widget_host->GotResponseToLockMouseRequest(
2841 blink::mojom::PointerLockResult::kAlreadyLocked);
lfgf0cd46e2017-01-04 00:05:232842 return;
2843 }
[email protected]e9621112011-10-17 05:38:372844 }
avic3aa8422015-11-09 20:57:222845
lfgad8244352016-07-13 16:55:512846 if (privileged) {
lfgf0cd46e2017-01-04 00:05:232847 DCHECK(!GetOuterWebContents());
lfgad8244352016-07-13 16:55:512848 mouse_lock_widget_ = render_widget_host;
James Hollyerd5c9de462020-03-10 19:02:452849 render_widget_host->GotResponseToLockMouseRequest(
2850 blink::mojom::PointerLockResult::kSuccess);
lfgad8244352016-07-13 16:55:512851 return;
2852 }
2853
lfgbee1e0a2016-06-08 21:24:212854 bool widget_in_frame_tree = false;
2855 for (FrameTreeNode* node : frame_tree_.Nodes()) {
2856 if (node->current_frame_host()->GetRenderWidgetHost() ==
2857 render_widget_host) {
2858 widget_in_frame_tree = true;
2859 break;
2860 }
2861 }
2862
2863 if (widget_in_frame_tree && delegate_) {
lfgf0cd46e2017-01-04 00:05:232864 for (WebContentsImpl* current = this; current;
2865 current = current->GetOuterWebContents()) {
2866 current->mouse_lock_widget_ = render_widget_host;
2867 }
2868
avic3aa8422015-11-09 20:57:222869 delegate_->RequestToLockMouse(this, user_gesture, last_unlocked_by_target);
lfgbee1e0a2016-06-08 21:24:212870 } else {
James Hollyerd5c9de462020-03-10 19:02:452871 render_widget_host->GotResponseToLockMouseRequest(
2872 blink::mojom::PointerLockResult::kWrongDocument);
lfgbee1e0a2016-06-08 21:24:212873 }
[email protected]e9621112011-10-17 05:38:372874}
2875
avi3e4b8512015-11-11 01:55:492876void WebContentsImpl::LostMouseLock(RenderWidgetHostImpl* render_widget_host) {
lfgbee1e0a2016-06-08 21:24:212877 CHECK(mouse_lock_widget_);
lfgf0cd46e2017-01-04 00:05:232878
2879 if (mouse_lock_widget_->delegate()->GetAsWebContents() != this)
2880 return mouse_lock_widget_->delegate()->LostMouseLock(render_widget_host);
2881
lfgbee1e0a2016-06-08 21:24:212882 mouse_lock_widget_->SendMouseLockLost();
lfgf0cd46e2017-01-04 00:05:232883 for (WebContentsImpl* current = this; current;
2884 current = current->GetOuterWebContents()) {
2885 current->mouse_lock_widget_ = nullptr;
2886 }
avi3e4b8512015-11-11 01:55:492887
[email protected]e9621112011-10-17 05:38:372888 if (delegate_)
2889 delegate_->LostMouseLock();
2890}
2891
lfgad8244352016-07-13 16:55:512892bool WebContentsImpl::HasMouseLock(RenderWidgetHostImpl* render_widget_host) {
2893 // To verify if the mouse is locked, the mouse_lock_widget_ needs to be
2894 // assigned to the widget that requested the mouse lock, and the top-level
2895 // platform RenderWidgetHostView needs to hold the mouse lock from the OS.
Lucas Gadania0ea0172018-09-20 18:31:372896 auto* widget_host = GetTopLevelRenderWidgetHostView();
2897 return mouse_lock_widget_ == render_widget_host && widget_host &&
2898 widget_host->IsMouseLocked();
lfgad8244352016-07-13 16:55:512899}
2900
lfg84763c92017-02-16 18:55:152901RenderWidgetHostImpl* WebContentsImpl::GetMouseLockWidget() {
Lucas Gadania0ea0172018-09-20 18:31:372902 auto* widget_host = GetTopLevelRenderWidgetHostView();
2903 if ((widget_host && widget_host->IsMouseLocked()) ||
lfge2176fb2017-03-26 00:45:472904 (GetFullscreenRenderWidgetHostView() &&
Lucas Gadania0ea0172018-09-20 18:31:372905 GetFullscreenRenderWidgetHostView()->IsMouseLocked())) {
lfg84763c92017-02-16 18:55:152906 return mouse_lock_widget_;
Lucas Gadania0ea0172018-09-20 18:31:372907 }
lfg84763c92017-02-16 18:55:152908
2909 return nullptr;
2910}
2911
Joe Downing192998b22018-03-22 15:51:362912bool WebContentsImpl::RequestKeyboardLock(
Joe Downing13dd76b2018-04-09 18:32:152913 RenderWidgetHostImpl* render_widget_host,
2914 bool esc_key_locked) {
Joe Downing192998b22018-03-22 15:51:362915 DCHECK(render_widget_host);
Joe Downing192998b22018-03-22 15:51:362916 if (render_widget_host->delegate()->GetAsWebContents() != this) {
2917 NOTREACHED();
2918 return false;
2919 }
2920
2921 // KeyboardLock is only supported when called by the top-level browsing
2922 // context and is not supported in embedded content scenarios.
2923 if (GetOuterWebContents())
2924 return false;
2925
Joe Downing13dd76b2018-04-09 18:32:152926 esc_key_locked_ = esc_key_locked;
Joe Downing192998b22018-03-22 15:51:362927 keyboard_lock_widget_ = render_widget_host;
2928
Joe Downing13dd76b2018-04-09 18:32:152929 if (delegate_)
2930 delegate_->RequestKeyboardLock(this, esc_key_locked_);
Joe Downing192998b22018-03-22 15:51:362931 return true;
2932}
2933
2934void WebContentsImpl::CancelKeyboardLock(
2935 RenderWidgetHostImpl* render_widget_host) {
2936 if (!keyboard_lock_widget_ || render_widget_host != keyboard_lock_widget_)
2937 return;
2938
2939 RenderWidgetHostImpl* old_keyboard_lock_widget = keyboard_lock_widget_;
2940 keyboard_lock_widget_ = nullptr;
2941
Joe Downing13dd76b2018-04-09 18:32:152942 if (delegate_)
2943 delegate_->CancelKeyboardLockRequest(this);
2944
Joe Downing192998b22018-03-22 15:51:362945 old_keyboard_lock_widget->CancelKeyboardLock();
2946}
2947
2948RenderWidgetHostImpl* WebContentsImpl::GetKeyboardLockWidget() {
2949 return keyboard_lock_widget_;
2950}
2951
Dave Tapuskac3344362019-02-20 17:54:282952void WebContentsImpl::OnRenderFrameProxyVisibilityChanged(
2953 blink::mojom::FrameVisibility visibility) {
2954 switch (visibility) {
2955 case blink::mojom::FrameVisibility::kRenderedInViewport:
2956 WasShown();
2957 break;
2958 case blink::mojom::FrameVisibility::kNotRendered:
2959 WasHidden();
2960 break;
2961 case blink::mojom::FrameVisibility::kRenderedOutOfViewport:
2962 WasOccluded();
2963 break;
2964 }
ekaramada4f42692016-02-11 19:48:372965}
2966
Albert J. Wong65fe64d2019-09-20 02:48:142967RenderFrameHostDelegate* WebContentsImpl::CreateNewWindow(
csharrison95f01e922017-04-24 18:52:352968 RenderFrameHost* opener,
rockot5c478a72016-09-28 23:14:182969 const mojom::CreateNewWindowParams& params,
Albert J. Wong65fe64d2019-09-20 02:48:142970 bool is_new_browsing_instance,
Sergey Kuznetsov32257a22019-02-11 20:26:502971 bool has_user_gesture,
[email protected]97714c82012-06-06 10:15:132972 SessionStorageNamespace* session_storage_namespace) {
csharrison95f01e922017-04-24 18:52:352973 DCHECK(opener);
nick5ae4d2d2017-01-06 01:18:352974
csharrison95f01e922017-04-24 18:52:352975 int render_process_id = opener->GetProcess()->GetID();
csharrison95f01e922017-04-24 18:52:352976
Albert J. Wong65fe64d2019-09-20 02:48:142977 SiteInstance* source_site_instance = opener->GetSiteInstance();
nick5ae4d2d2017-01-06 01:18:352978
Aaron Colwelleb219982020-01-16 02:17:272979 const GURL source_site_url = source_site_instance->GetSiteURL();
[email protected]fdac6ade2013-07-20 01:06:302980 const std::string& partition_id =
Aaron Colwelleb219982020-01-16 02:17:272981 GetContentClient()->browser()->GetStoragePartitionIdForSite(
2982 GetBrowserContext(), source_site_url);
2983 {
2984 StoragePartition* partition = BrowserContext::GetStoragePartitionForSite(
2985 GetBrowserContext(), source_site_url);
2986 DOMStorageContextWrapper* dom_storage_context =
2987 static_cast<DOMStorageContextWrapper*>(
2988 partition->GetDOMStorageContext());
2989 SessionStorageNamespaceImpl* session_storage_namespace_impl =
2990 static_cast<SessionStorageNamespaceImpl*>(session_storage_namespace);
2991 CHECK(session_storage_namespace_impl->IsFromContext(dom_storage_context));
2992 }
[email protected]dd6730412013-08-14 15:03:372993
Albert J. Wong1ceccef92019-10-08 08:25:202994 if (delegate_ && delegate_->IsWebContentsCreationOverridden(
2995 source_site_instance, params.window_container_type,
2996 opener->GetLastCommittedURL(), params.frame_name,
2997 params.target_url)) {
2998 return static_cast<WebContentsImpl*>(delegate_->CreateCustomWebContents(
2999 opener, source_site_instance, is_new_browsing_instance,
3000 opener->GetLastCommittedURL(), params.frame_name, params.target_url,
3001 partition_id, session_storage_namespace));
[email protected]dd6730412013-08-14 15:03:373002 }
3003
danakj22b4e8b2019-08-01 23:14:393004 bool renderer_started_hidden =
3005 params.disposition == WindowOpenDisposition::NEW_BACKGROUND_TAB;
3006
Aaron Colwelleb219982020-01-16 02:17:273007 // We usually create the new window in the same BrowsingInstance (group of
3008 // script-related windows), by passing in the current SiteInstance. However,
3009 // if the opener is being suppressed (in a non-guest), we do not provide
3010 // a SiteInstance which causes a new one to get created in its own
3011 // BrowsingInstance.
3012 bool is_guest = BrowserPluginGuest::IsGuest(this);
3013 scoped_refptr<SiteInstance> site_instance =
3014 params.opener_suppressed && !is_guest ? nullptr : source_site_instance;
3015
[email protected]dd6730412013-08-14 15:03:373016 // Create the new web contents. This will automatically create the new
3017 // WebContentsView. In the future, we may want to create the view separately.
[email protected]fc72bb12013-06-02 21:13:463018 CreateParams create_params(GetBrowserContext(), site_instance.get());
nasko48321ca32015-07-02 20:44:123019 create_params.main_frame_name = params.frame_name;
alexmos4cf2aa32015-07-15 23:40:433020 create_params.opener_render_process_id = render_process_id;
csharrison95f01e922017-04-24 18:52:353021 create_params.opener_render_frame_id = opener->GetRoutingID();
[email protected]50d326e2014-05-20 17:59:063022 create_params.opener_suppressed = params.opener_suppressed;
danakj22b4e8b2019-08-01 23:14:393023 create_params.initially_hidden = renderer_started_hidden;
[email protected]50d326e2014-05-20 17:59:063024
Albert J. Wong65fe64d2019-09-20 02:48:143025 // Even though all codepaths leading here are in response to a renderer
3026 // tryng to open a new window, if the new window ends up in a different
3027 // browsing instance, then the RenderViewHost, RenderWidgetHost,
3028 // RenderFrameHost constellation is effectively browser initiated
3029 // the opener's process will not given the routing IDs for the new
3030 // objects.
3031 create_params.renderer_initiated_creation = !is_new_browsing_instance;
Albert J. Wong1ceccef92019-10-08 08:25:203032
Albert J. Wong65fe64d2019-09-20 02:48:143033 std::unique_ptr<WebContentsImpl> new_contents;
[email protected]c4538072013-03-18 02:17:553034 if (!is_guest) {
3035 create_params.context = view_->GetNativeView();
Albert J. Wong65fe64d2019-09-20 02:48:143036 new_contents = WebContentsImpl::Create(create_params);
3037 } else {
3038 new_contents = base::WrapUnique(static_cast<WebContentsImpl*>(
3039 GetBrowserPluginGuest()->CreateNewGuestWindow(create_params)));
[email protected]c4538072013-03-18 02:17:553040 }
Albert J. Wong65fe64d2019-09-20 02:48:143041 auto* new_contents_impl = new_contents.get();
danakje6c01622018-10-05 19:39:263042
3043 new_contents_impl->GetController().SetSessionStorageNamespace(
erikchenbee5c9622018-04-27 19:30:253044 partition_id, session_storage_namespace);
[email protected]d1198fd2012-08-13 22:50:193045
alexmos646fec02015-07-25 00:11:493046 // If the new frame has a name, make sure any SiteInstances that can find
3047 // this named frame have proxies for it. Must be called after
3048 // SetSessionStorageNamespace, since this calls CreateRenderView, which uses
3049 // GetSessionStorageNamespace.
3050 if (!params.frame_name.empty())
danakje6c01622018-10-05 19:39:263051 new_contents_impl->GetRenderManager()->CreateProxiesForNewNamedFrame();
alexmos646fec02015-07-25 00:11:493052
[email protected]c4538072013-03-18 02:17:553053 // Save the window for later if we're not suppressing the opener (since it
[email protected]d70bea92013-04-05 04:23:343054 // will be shown immediately).
3055 if (!params.opener_suppressed) {
3056 if (!is_guest) {
danakje6c01622018-10-05 19:39:263057 WebContentsView* new_view = new_contents_impl->view_.get();
[email protected]bafe6cd2012-05-23 23:09:503058
[email protected]d70bea92013-04-05 04:23:343059 // TODO(brettw): It seems bogus that we have to call this function on the
3060 // newly created object and give it one of its own member variables.
danakj22b4e8b2019-08-01 23:14:393061 RenderWidgetHostView* widget_view = new_view->CreateViewForWidget(
W. James MacLean13d834d2019-12-04 16:06:453062 new_contents_impl->GetRenderViewHost()->GetWidget());
danakj22b4e8b2019-08-01 23:14:393063 if (!renderer_started_hidden) {
3064 // RenderWidgets for frames always initialize as hidden. If the renderer
3065 // created this window as visible, then we show it here.
3066 widget_view->Show();
3067 }
[email protected]d70bea92013-04-05 04:23:343068 }
[email protected]bafe6cd2012-05-23 23:09:503069 // Save the created window associated with the route so we can show it
3070 // later.
Albert J. Wongcb004632018-07-10 22:58:253071 //
3072 // TODO(ajwong): This should be keyed off the RenderFrame routing id or the
3073 // FrameTreeNode id instead of the routing id of the Widget for the main
3074 // frame. https://crbug.com/545684
Fergal Daly052873a82020-03-11 14:45:493075 int32_t main_frame_routing_id = new_contents_impl->GetMainFrame()
3076 ->GetRenderWidgetHost()
3077 ->GetRoutingID();
3078 GlobalRoutingID id(render_process_id, main_frame_routing_id);
Joel Hockey8c2011b22020-04-30 05:07:193079 pending_contents_[id] =
3080 CreatedWindow(std::move(new_contents), params.target_url);
danakje6c01622018-10-05 19:39:263081 AddDestructionObserver(new_contents_impl);
[email protected]bafe6cd2012-05-23 23:09:503082 }
3083
3084 if (delegate_) {
Bryan McQuaded2b93c02017-07-14 22:26:313085 delegate_->WebContentsCreated(this, render_process_id,
3086 opener->GetRoutingID(), params.frame_name,
danakje6c01622018-10-05 19:39:263087 params.target_url, new_contents_impl);
[email protected]bafe6cd2012-05-23 23:09:503088 }
3089
Charlie Harrisonf60dd1c2018-08-15 21:15:413090 for (auto& observer : observers_) {
danakje6c01622018-10-05 19:39:263091 observer.DidOpenRequestedURL(new_contents_impl, opener, params.target_url,
Leon Han963dc182018-11-06 05:41:483092 params.referrer.To<Referrer>(),
3093 params.disposition, ui::PAGE_TRANSITION_LINK,
Charlie Harrisonf60dd1c2018-08-15 21:15:413094 false, // started_from_context_menu
3095 true); // renderer_initiated
pnolandaae574e2017-03-06 21:04:213096 }
3097
Avi Drissmanba3b1b342017-08-29 18:16:133098 // Any new WebContents opened while this WebContents is in fullscreen can be
3099 // used to confuse the user, so drop fullscreen.
Avi Drissman1a55a9d62020-03-10 18:56:453100 base::ScopedClosureRunner fullscreen_block = ForSecurityDropFullscreen();
3101 // The new contents will be independent of this contents, so release the
3102 // fullscreen block.
3103 fullscreen_block.RunAndReset();
Avi Drissmanba3b1b342017-08-29 18:16:133104
[email protected]bafe6cd2012-05-23 23:09:503105 if (params.opener_suppressed) {
3106 // When the opener is suppressed, the original renderer cannot access the
3107 // new window. As a result, we need to show and navigate the window here.
[email protected]eda238a12012-09-07 23:44:003108 bool was_blocked = false;
erikchenbee5c9622018-04-27 19:30:253109
[email protected]eda238a12012-09-07 23:44:003110 if (delegate_) {
danakje6c01622018-10-05 19:39:263111 base::WeakPtr<WebContentsImpl> weak_new_contents =
3112 new_contents_impl->weak_factory_.GetWeakPtr();
nick0d558482017-02-13 22:27:223113
danakje6c01622018-10-05 19:39:263114 gfx::Rect initial_rect; // Report an empty initial rect.
Albert J. Wong65fe64d2019-09-20 02:48:143115 delegate_->AddNewContents(this, std::move(new_contents),
Joel Hockey891e88062020-04-30 05:38:443116 params.target_url, params.disposition,
3117 initial_rect, has_user_gesture, &was_blocked);
danakje6c01622018-10-05 19:39:263118 // The delegate may delete |new_contents_impl| during AddNewContents().
nick0d558482017-02-13 22:27:223119 if (!weak_new_contents)
Albert J. Wong65fe64d2019-09-20 02:48:143120 return nullptr;
[email protected]eda238a12012-09-07 23:44:003121 }
erikchenbee5c9622018-04-27 19:30:253122
[email protected]eda238a12012-09-07 23:44:003123 if (!was_blocked) {
Nasko Oskov83a8cf92018-10-19 14:58:563124 std::unique_ptr<NavigationController::LoadURLParams> load_params =
3125 std::make_unique<NavigationController::LoadURLParams>(
3126 params.target_url);
Nasko Oskov93e7c55c2018-12-19 01:59:293127 load_params->initiator_origin = opener->GetLastCommittedOrigin();
Aaron Colwell9dab1652019-12-09 18:29:493128 load_params->source_site_instance = source_site_instance;
Leon Han963dc182018-11-06 05:41:483129 load_params->referrer = params.referrer.To<Referrer>();
Nasko Oskov83a8cf92018-10-19 14:58:563130 load_params->transition_type = ui::PAGE_TRANSITION_LINK;
3131 load_params->is_renderer_initiated = true;
Sergey Kuznetsov32257a22019-02-11 20:26:503132 load_params->has_user_gesture = has_user_gesture;
mariakhomenkoa4971c12015-07-21 19:04:373133
3134 if (delegate_ && !is_guest &&
3135 !delegate_->ShouldResumeRequestsForCreatedWindow()) {
Nasko Oskov83a8cf92018-10-19 14:58:563136 // We are in asynchronous add new contents path, delay navigation.
3137 DCHECK(!new_contents_impl->delayed_open_url_params_);
3138 new_contents_impl->delayed_load_url_params_ = std::move(load_params);
mariakhomenkoa4971c12015-07-21 19:04:373139 } else {
Nasko Oskov83a8cf92018-10-19 14:58:563140 new_contents_impl->controller_.LoadURLWithParams(*load_params.get());
Nasko Oskov28ebd5b2018-12-07 22:29:333141 if (!is_guest)
3142 new_contents_impl->Focus();
mariakhomenkoa4971c12015-07-21 19:04:373143 }
[email protected]eda238a12012-09-07 23:44:003144 }
[email protected]bafe6cd2012-05-23 23:09:503145 }
Albert J. Wong65fe64d2019-09-20 02:48:143146 return new_contents_impl;
[email protected]bafe6cd2012-05-23 23:09:503147}
3148
Dave Tapuskad9835622020-03-10 17:32:313149void WebContentsImpl::CreateNewWidget(
3150 int32_t render_process_id,
3151 int32_t widget_route_id,
Dave Tapuska8499eec2020-03-16 17:54:303152 mojo::PendingAssociatedReceiver<blink::mojom::WidgetHost> blink_widget_host,
3153 mojo::PendingAssociatedRemote<blink::mojom::Widget> blink_widget) {
Albert J. Wongf6e13ed2018-09-18 15:25:473154 CreateNewWidget(render_process_id, widget_route_id, /*is_fullscreen=*/false,
Dave Tapuskab686c1b2020-06-09 00:40:233155 std::move(blink_widget_host), std::move(blink_widget));
[email protected]bafe6cd2012-05-23 23:09:503156}
3157
Julie Jeongeun Kimcaacf9102019-09-12 02:13:053158void WebContentsImpl::CreateNewFullscreenWidget(
3159 int32_t render_process_id,
3160 int32_t widget_route_id,
Dave Tapuska8499eec2020-03-16 17:54:303161 mojo::PendingAssociatedReceiver<blink::mojom::WidgetHost> blink_widget_host,
3162 mojo::PendingAssociatedRemote<blink::mojom::Widget> blink_widget) {
Albert J. Wongf6e13ed2018-09-18 15:25:473163 CreateNewWidget(render_process_id, widget_route_id, /*is_fullscreen=*/true,
Dave Tapuskab686c1b2020-06-09 00:40:233164 std::move(blink_widget_host), std::move(blink_widget));
[email protected]bafe6cd2012-05-23 23:09:503165}
3166
Dave Tapuskad9835622020-03-10 17:32:313167void WebContentsImpl::CreateNewWidget(
3168 int32_t render_process_id,
3169 int32_t route_id,
3170 bool is_fullscreen,
Dave Tapuska8499eec2020-03-16 17:54:303171 mojo::PendingAssociatedReceiver<blink::mojom::WidgetHost> blink_widget_host,
3172 mojo::PendingAssociatedRemote<blink::mojom::Widget> blink_widget) {
kenrba26d15092016-02-10 22:00:253173 RenderProcessHost* process = RenderProcessHost::FromID(render_process_id);
kenrbb46f86a2015-12-07 07:53:233174 // A message to create a new widget can only come from an active process for
[email protected]a8504022013-12-04 20:23:513175 // this WebContentsImpl instance. If any other process sends the request,
3176 // it is invalid and the process must be terminated.
dcheng57e39e22016-01-21 00:25:383177 if (!HasMatchingProcess(&frame_tree_, render_process_id)) {
Lukasz Anforowicz6f746282018-01-04 23:24:513178 ReceivedBadMessage(process, bad_message::WCI_NEW_WIDGET_PROCESS_MISMATCH);
[email protected]a8504022013-12-04 20:23:513179 return;
3180 }
3181
Dave Tapuskab686c1b2020-06-09 00:40:233182 RenderWidgetHostImpl* widget_host =
3183 new RenderWidgetHostImpl(this, process, route_id, IsHidden(),
3184 std::make_unique<FrameTokenMessageQueue>());
Dave Tapuska8499eec2020-03-16 17:54:303185
3186 widget_host->BindWidgetInterfaces(std::move(blink_widget_host),
3187 std::move(blink_widget));
[email protected]cfd80b02014-05-01 17:46:483188 RenderWidgetHostViewBase* widget_view =
3189 static_cast<RenderWidgetHostViewBase*>(
danakj0b246942018-09-17 21:30:273190 view_->CreateViewForChildWidget(widget_host));
[email protected]83918ec2013-01-10 15:37:193191 if (!widget_view)
3192 return;
danakj0b246942018-09-17 21:30:273193 // Fullscreen child widgets are frames, other child widgets are popups, and
3194 // popups should not get activated.
3195 if (!is_fullscreen)
3196 widget_view->SetWidgetType(WidgetType::kPopup);
[email protected]bafe6cd2012-05-23 23:09:503197 // Save the created widget associated with the route so we can show it later.
Lukasz Anforowicz09060bdf72018-08-23 15:53:173198 pending_widget_views_[GlobalRoutingID(render_process_id, route_id)] =
alexmosc2a8cec2016-05-23 22:19:533199 widget_view;
[email protected]bafe6cd2012-05-23 23:09:503200}
3201
alexmosc2a8cec2016-05-23 22:19:533202void WebContentsImpl::ShowCreatedWindow(int process_id,
nick5ae4d2d2017-01-06 01:18:353203 int main_frame_widget_route_id,
[email protected]bafe6cd2012-05-23 23:09:503204 WindowOpenDisposition disposition,
bokan107a47f2015-02-03 23:23:393205 const gfx::Rect& initial_rect,
[email protected]bafe6cd2012-05-23 23:09:503206 bool user_gesture) {
danakje6c01622018-10-05 19:39:263207 // This method is the renderer requesting an existing top level window to
3208 // show a new top level window that the renderer created. Each top level
3209 // window is associated with a WebContents. In this case it was created
3210 // earlier but showing it was deferred until the renderer requested for it
3211 // to be shown. We find that previously created WebContents here.
3212 // TODO(danakj): Why do we defer this show step until the renderer asks for it
3213 // when it will always do so. What needs to happen in the renderer before we
3214 // reach here?
Joel Hockey8c2011b22020-04-30 05:07:193215 base::Optional<CreatedWindow> owned_created =
nick5ae4d2d2017-01-06 01:18:353216 GetCreatedWindow(process_id, main_frame_widget_route_id);
Joel Hockey8c2011b22020-04-30 05:07:193217
danakje6c01622018-10-05 19:39:263218 // The browser may have rejected the request to make a new window, or the
3219 // renderer could be sending an invalid route id. Ignore the request then.
Joel Hockey8c2011b22020-04-30 05:07:193220 if (!owned_created || !owned_created->contents)
danakje6c01622018-10-05 19:39:263221 return;
mariakhomenko44bdc4732015-04-29 01:55:383222
Joel Hockey8c2011b22020-04-30 05:07:193223 WebContentsImpl* created = owned_created->contents.get();
3224
danakje6c01622018-10-05 19:39:263225 // This uses the delegate for the WebContents where the window was created
3226 // from, to control how to show the newly created window.
3227 WebContentsDelegate* delegate = GetDelegate();
nick5ae4d2d2017-01-06 01:18:353228
danakje6c01622018-10-05 19:39:263229 // The delegate can be null in tests, so we must check for it :(.
3230 if (delegate) {
3231 // Mark the web contents as pending resume, then immediately do
3232 // the resume if the delegate wants it.
3233 created->is_resume_pending_ = true;
3234 if (delegate->ShouldResumeRequestsForCreatedWindow())
3235 created->ResumeLoadingCreatedWebContents();
3236
3237 base::WeakPtr<WebContentsImpl> weak_created =
3238 created->weak_factory_.GetWeakPtr();
Joel Hockey8c2011b22020-04-30 05:07:193239 delegate->AddNewContents(this, std::move(owned_created->contents),
Joel Hockey891e88062020-04-30 05:38:443240 std::move(owned_created->target_url), disposition,
3241 initial_rect, user_gesture, nullptr);
danakje6c01622018-10-05 19:39:263242 // The delegate may delete |created| during AddNewContents().
3243 if (!weak_created)
3244 return;
[email protected]eda238a12012-09-07 23:44:003245 }
danakje6c01622018-10-05 19:39:263246
3247 RenderWidgetHostImpl* rwh = created->GetMainFrame()->GetRenderWidgetHost();
3248 DCHECK_EQ(main_frame_widget_route_id, rwh->GetRoutingID());
3249 rwh->Send(new WidgetMsg_SetBounds_ACK(rwh->GetRoutingID()));
[email protected]bafe6cd2012-05-23 23:09:503250}
3251
alexmosc2a8cec2016-05-23 22:19:533252void WebContentsImpl::ShowCreatedWidget(int process_id,
Albert J. Wongf6e13ed2018-09-18 15:25:473253 int widget_route_id,
bokan107a47f2015-02-03 23:23:393254 const gfx::Rect& initial_rect) {
Albert J. Wongf6e13ed2018-09-18 15:25:473255 ShowCreatedWidget(process_id, widget_route_id, false, initial_rect);
[email protected]bafe6cd2012-05-23 23:09:503256}
3257
alexmosc2a8cec2016-05-23 22:19:533258void WebContentsImpl::ShowCreatedFullscreenWidget(int process_id,
Albert J. Wongf6e13ed2018-09-18 15:25:473259 int widget_route_id) {
3260 ShowCreatedWidget(process_id, widget_route_id, true, gfx::Rect());
[email protected]bafe6cd2012-05-23 23:09:503261}
3262
alexmosc2a8cec2016-05-23 22:19:533263void WebContentsImpl::ShowCreatedWidget(int process_id,
3264 int route_id,
[email protected]bafe6cd2012-05-23 23:09:503265 bool is_fullscreen,
bokan107a47f2015-02-03 23:23:393266 const gfx::Rect& initial_rect) {
[email protected]cfd80b02014-05-01 17:46:483267 RenderWidgetHostViewBase* widget_host_view =
alexmosc2a8cec2016-05-23 22:19:533268 static_cast<RenderWidgetHostViewBase*>(
3269 GetCreatedWidget(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:503270 if (!widget_host_view)
3271 return;
[email protected]cfd80b02014-05-01 17:46:483272
W. James MacLeanec4125c2019-09-27 18:56:003273 // GetOutermostWebContents() returns |this| if there are no outer WebContents.
W. James MacLean3c5f50462019-10-28 16:24:213274 auto* outer_web_contents = GetOuterWebContents();
3275 auto* outermost_web_contents = GetOutermostWebContents();
W. James MacLeanec4125c2019-09-27 18:56:003276 RenderWidgetHostView* view =
W. James MacLean3c5f50462019-10-28 16:24:213277 outermost_web_contents->GetRenderWidgetHostView();
3278 // It's not entirely obvious why we need the transform only in the case where
3279 // the outer webcontents is not the same as the outermost webcontents. It may
3280 // be due to the fact that oopifs that are children of the mainframe get
3281 // correct values for their screenrects, but deeper cross-process frames do
3282 // not. Hopefully this can be resolved with https://crbug.com/928825.
3283 // Handling these cases separately is needed for http://crbug.com/1015298.
3284 bool needs_transform = this != outermost_web_contents &&
3285 outermost_web_contents != outer_web_contents;
W. James MacLeanec4125c2019-09-27 18:56:003286
3287 gfx::Rect transformed_rect(initial_rect);
3288 RenderWidgetHostView* this_view = GetRenderWidgetHostView();
W. James MacLean3c5f50462019-10-28 16:24:213289 if (needs_transform) {
W. James MacLeanec4125c2019-09-27 18:56:003290 // We need to transform the coordinates of initial_rect.
3291 gfx::Point origin =
3292 this_view->TransformPointToRootCoordSpace(initial_rect.origin());
3293 gfx::Point bottom_right =
3294 this_view->TransformPointToRootCoordSpace(initial_rect.bottom_right());
3295 transformed_rect =
3296 gfx::Rect(origin.x(), origin.y(), bottom_right.x() - origin.x(),
3297 bottom_right.y() - origin.y());
[email protected]cfd80b02014-05-01 17:46:483298 }
3299
danakj0b246942018-09-17 21:30:273300 // Fullscreen child widgets are frames, other child widgets are popups.
[email protected]4aebbca2013-09-17 22:26:493301 if (is_fullscreen) {
[email protected]d7f80ba2013-10-12 07:42:313302 DCHECK_EQ(MSG_ROUTING_NONE, fullscreen_widget_routing_id_);
[email protected]0b431992014-06-24 00:08:033303 view_->StoreFocus();
alexmosc9e76ec2016-05-16 22:59:373304 fullscreen_widget_process_id_ =
3305 widget_host_view->GetRenderWidgetHost()->GetProcess()->GetID();
[email protected]d7f80ba2013-10-12 07:42:313306 fullscreen_widget_routing_id_ = route_id;
[email protected]4aebbca2013-09-17 22:26:493307 if (delegate_ && delegate_->EmbedsFullscreenWidget()) {
3308 widget_host_view->InitAsChild(GetRenderWidgetHostView()->GetNativeView());
Mike Wasserman4ca09792020-05-29 17:44:433309 delegate_->EnterFullscreenModeForTab(GetMainFrame(),
Dave Tapuskaa4189512019-10-15 20:27:343310 blink::mojom::FullscreenOptions());
[email protected]4aebbca2013-09-17 22:26:493311 } else {
[email protected]cfd80b02014-05-01 17:46:483312 widget_host_view->InitAsFullscreen(view);
[email protected]4aebbca2013-09-17 22:26:493313 }
ericwilligersde386342016-10-19 02:35:093314 for (auto& observer : observers_)
3315 observer.DidShowFullscreenWidget();
[email protected]4aebbca2013-09-17 22:26:493316 if (!widget_host_view->HasFocus())
3317 widget_host_view->Focus();
3318 } else {
W. James MacLeanec4125c2019-09-27 18:56:003319 widget_host_view->InitAsPopup(view, transformed_rect);
[email protected]4aebbca2013-09-17 22:26:493320 }
[email protected]89054502012-06-03 10:29:243321
yiyixcb1fbc4f2018-03-16 19:54:083322 RenderWidgetHostImpl* render_widget_host_impl = widget_host_view->host();
[email protected]89054502012-06-03 10:29:243323 render_widget_host_impl->Init();
[email protected]d7f80ba2013-10-12 07:42:313324 // Only allow privileged mouse lock for fullscreen render widget, which is
3325 // used to implement Pepper Flash fullscreen.
3326 render_widget_host_impl->set_allow_privileged_mouse_lock(is_fullscreen);
[email protected]bafe6cd2012-05-23 23:09:503327}
3328
Joel Hockey8c2011b22020-04-30 05:07:193329base::Optional<CreatedWindow> WebContentsImpl::GetCreatedWindow(
nick5ae4d2d2017-01-06 01:18:353330 int process_id,
3331 int main_frame_widget_route_id) {
Lukasz Anforowicz09060bdf72018-08-23 15:53:173332 auto key = GlobalRoutingID(process_id, main_frame_widget_route_id);
nick5ae4d2d2017-01-06 01:18:353333 auto iter = pending_contents_.find(key);
[email protected]bafe6cd2012-05-23 23:09:503334
3335 // Certain systems can block the creation of new windows. If we didn't succeed
3336 // in creating one, just return NULL.
alexmosc2a8cec2016-05-23 22:19:533337 if (iter == pending_contents_.end())
Joel Hockey8c2011b22020-04-30 05:07:193338 return base::nullopt;
[email protected]bafe6cd2012-05-23 23:09:503339
Joel Hockey8c2011b22020-04-30 05:07:193340 CreatedWindow result = std::move(iter->second);
3341 WebContentsImpl* new_contents = result.contents.get();
nick5ae4d2d2017-01-06 01:18:353342 pending_contents_.erase(key);
Joel Hockey8c2011b22020-04-30 05:07:193343 RemoveDestructionObserver(new_contents);
[email protected]bafe6cd2012-05-23 23:09:503344
[email protected]d70bea92013-04-05 04:23:343345 // Don't initialize the guest WebContents immediately.
Joel Hockey8c2011b22020-04-30 05:07:193346 if (BrowserPluginGuest::IsGuest(new_contents))
3347 return result;
[email protected]d70bea92013-04-05 04:23:343348
Lukasz Anforowicz5510ed652018-06-06 16:16:193349 if (!new_contents->GetMainFrame()->GetProcess()->IsInitializedAndNotDead() ||
nick5ae4d2d2017-01-06 01:18:353350 !new_contents->GetMainFrame()->GetView()) {
Joel Hockey8c2011b22020-04-30 05:07:193351 return base::nullopt;
nick5ae4d2d2017-01-06 01:18:353352 }
[email protected]bafe6cd2012-05-23 23:09:503353
Joel Hockey8c2011b22020-04-30 05:07:193354 return result;
[email protected]bafe6cd2012-05-23 23:09:503355}
3356
alexmosc2a8cec2016-05-23 22:19:533357RenderWidgetHostView* WebContentsImpl::GetCreatedWidget(int process_id,
3358 int route_id) {
Lukasz Anforowicz09060bdf72018-08-23 15:53:173359 auto iter = pending_widget_views_.find(GlobalRoutingID(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:503360 if (iter == pending_widget_views_.end()) {
3361 DCHECK(false);
alexmosc2a8cec2016-05-23 22:19:533362 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:503363 }
3364
3365 RenderWidgetHostView* widget_host_view = iter->second;
Lukasz Anforowicz09060bdf72018-08-23 15:53:173366 pending_widget_views_.erase(GlobalRoutingID(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:503367
3368 RenderWidgetHost* widget_host = widget_host_view->GetRenderWidgetHost();
Lukasz Anforowicz5510ed652018-06-06 16:16:193369 if (!widget_host->GetProcess()->IsInitializedAndNotDead()) {
[email protected]bafe6cd2012-05-23 23:09:503370 // The view has gone away or the renderer crashed. Nothing to do.
alexmosc2a8cec2016-05-23 22:19:533371 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:503372 }
3373
3374 return widget_host_view;
3375}
3376
[email protected]f13b4202012-06-12 23:53:233377void WebContentsImpl::RequestMediaAccessPermission(
[email protected]33662e52013-01-07 21:31:093378 const MediaStreamRequest& request,
Mark Pilgrim57499082018-06-12 12:38:303379 MediaResponseCallback callback) {
[email protected]d19b84b2014-03-14 11:52:373380 if (delegate_) {
Mark Pilgrim57499082018-06-12 12:38:303381 delegate_->RequestMediaAccessPermission(this, request, std::move(callback));
[email protected]d19b84b2014-03-14 11:52:373382 } else {
Antonio Gomes0d42960a2019-06-05 12:35:513383 std::move(callback).Run(
3384 blink::MediaStreamDevices(),
3385 blink::mojom::MediaStreamRequestResult::FAILED_DUE_TO_SHUTDOWN,
3386 std::unique_ptr<MediaStreamUI>());
[email protected]d19b84b2014-03-14 11:52:373387 }
[email protected]f13b4202012-06-12 23:53:233388}
3389
Chandan Padhia4b8bcb72017-09-12 16:41:043390bool WebContentsImpl::CheckMediaAccessPermission(
Raymes Khouryad7c24a12018-03-05 23:22:583391 RenderFrameHost* render_frame_host,
Chandan Padhia4b8bcb72017-09-12 16:41:043392 const url::Origin& security_origin,
Antonio Gomesc8b734b2019-06-05 18:22:163393 blink::mojom::MediaStreamType type) {
3394 DCHECK(type == blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE ||
3395 type == blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE);
Chandan Padhia4b8bcb72017-09-12 16:41:043396 return delegate_ && delegate_->CheckMediaAccessPermission(
Raymes Khouryad7c24a12018-03-05 23:22:583397 render_frame_host, security_origin.GetURL(), type);
grunell657d4d82014-09-18 00:09:433398}
3399
Guido Urdaneta73fa6632019-01-14 18:46:263400std::string WebContentsImpl::GetDefaultMediaDeviceID(
Antonio Gomesc8b734b2019-06-05 18:22:163401 blink::mojom::MediaStreamType type) {
guidou8a440b842017-01-30 13:58:433402 if (!delegate_)
3403 return std::string();
3404 return delegate_->GetDefaultMediaDeviceID(this, type);
3405}
3406
[email protected]cc9200432013-07-23 23:02:403407SessionStorageNamespace* WebContentsImpl::GetSessionStorageNamespace(
3408 SiteInstance* instance) {
3409 return controller_.GetSessionStorageNamespace(instance);
3410}
3411
[email protected]6de7fc482014-06-06 10:46:443412SessionStorageNamespaceMap WebContentsImpl::GetSessionStorageNamespaceMap() {
3413 return controller_.GetSessionStorageNamespaceMap();
3414}
3415
[email protected]9b159a52013-10-03 17:24:553416FrameTree* WebContentsImpl::GetFrameTree() {
3417 return &frame_tree_;
3418}
3419
aelias5252baa2016-04-10 01:18:023420bool WebContentsImpl::IsOverridingUserAgent() {
3421 return GetController().GetVisibleEntry() &&
3422 GetController().GetVisibleEntry()->GetIsOverridingUserAgent();
3423}
3424
avi85ee8362016-10-08 02:09:083425bool WebContentsImpl::IsJavaScriptDialogShowing() const {
3426 return is_showing_javascript_dialog_;
3427}
3428
avic031d392017-03-03 03:09:423429bool WebContentsImpl::ShouldIgnoreUnresponsiveRenderer() {
3430 // Ignore unresponsive renderers if the debugger is attached to them since the
3431 // unresponsiveness might be a result of the renderer sitting on a breakpoint.
3432 //
David Bienvenu525f8a02019-02-15 02:02:423433#ifdef OS_WIN
3434 // Check if a windows debugger is attached to the renderer process.
3435 base::ProcessHandle process_handle =
3436 GetMainFrame()->GetProcess()->GetProcess().Handle();
3437 BOOL debugger_present = FALSE;
3438 if (CheckRemoteDebuggerPresent(process_handle, &debugger_present) &&
3439 debugger_present)
3440 return true;
3441#endif // OS_WIN
3442
avic031d392017-03-03 03:09:423443 // TODO(pfeldman): Fix this to only return true if the renderer is *actually*
3444 // sitting on a breakpoint. https://crbug.com/684202
3445 return DevToolsAgentHost::IsDebuggerAttached(this);
3446}
3447
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:413448ui::AXMode WebContentsImpl::GetAccessibilityMode() {
[email protected]95640212014-07-26 18:14:303449 return accessibility_mode_;
3450}
3451
Dominic Mazzonia7b0edb22017-08-09 16:32:513452void WebContentsImpl::AccessibilityEventReceived(
Dominic Mazzoniccbaa9b2018-06-06 07:44:233453 const AXEventNotificationDetails& details) {
ericwilligersde386342016-10-19 02:35:093454 for (auto& observer : observers_)
Dominic Mazzonia7b0edb22017-08-09 16:32:513455 observer.AccessibilityEventReceived(details);
[email protected]31a71eaf2014-03-13 01:47:363456}
3457
dmazzoni2400c462016-08-23 15:07:133458void WebContentsImpl::AccessibilityLocationChangesReceived(
3459 const std::vector<AXLocationChangeNotificationDetails>& details) {
ericwilligersde386342016-10-19 02:35:093460 for (auto& observer : observers_)
Dominic Mazzonia7b0edb22017-08-09 16:32:513461 observer.AccessibilityLocationChangesReceived(details);
dmazzoni2400c462016-08-23 15:07:133462}
3463
Abigail Kleinabb428332019-09-13 18:26:213464base::string16 WebContentsImpl::DumpAccessibilityTree(
3465 bool internal,
3466 std::vector<AccessibilityTreeFormatter::PropertyFilter> property_filters) {
James Wallace-Leeeafc94cb92018-07-23 21:35:093467 auto* ax_mgr = GetOrCreateRootBrowserAccessibilityManager();
3468 DCHECK(ax_mgr);
Lei Zhangc98caa3822019-11-07 19:17:273469 return AccessibilityTreeFormatterBase::DumpAccessibilityTreeFromManager(
Abigail Kleinabb428332019-09-13 18:26:213470 ax_mgr, internal, property_filters);
James Wallace-Leeeafc94cb92018-07-23 21:35:093471}
3472
Abigail Kleinaa898742019-11-01 02:31:253473void WebContentsImpl::RecordAccessibilityEvents(
Abigail Kleinbb8304bd2020-05-18 21:44:183474 bool start_recording,
3475 base::Optional<AccessibilityEventCallback> callback) {
3476 // Only pass a callback to RecordAccessibilityEvents when starting to record.
3477 DCHECK_EQ(start_recording, callback.has_value());
3478 if (start_recording) {
Abigail Kleinaa898742019-11-01 02:31:253479 SetAccessibilityMode(ui::AXMode::kWebContents);
3480 auto* ax_mgr = GetOrCreateRootBrowserAccessibilityManager();
3481 DCHECK(ax_mgr);
3482 base::ProcessId pid = base::Process::Current().Pid();
3483 event_recorder_ = content::AccessibilityEventRecorder::Create(
3484 ax_mgr, pid, base::StringPiece{});
Abigail Kleinbb8304bd2020-05-18 21:44:183485 event_recorder_->ListenToEvents(*callback);
Abigail Kleinaa898742019-11-01 02:31:253486 } else {
Abigail Kleinbb8304bd2020-05-18 21:44:183487 if (event_recorder_) {
3488 event_recorder_->FlushAsyncEvents();
3489 event_recorder_.reset(nullptr);
3490 }
Abigail Kleinaa898742019-11-01 02:31:253491 }
3492}
3493
dmazzonia656928e2014-09-15 20:28:543494RenderFrameHost* WebContentsImpl::GetGuestByInstanceID(
fsamuel833ee7c2015-02-13 23:40:403495 RenderFrameHost* render_frame_host,
dmazzonia656928e2014-09-15 20:28:543496 int browser_plugin_instance_id) {
3497 BrowserPluginGuestManager* guest_manager =
3498 GetBrowserContext()->GetGuestManager();
fsamuel9cbc00a2015-04-17 20:30:203499 if (!guest_manager)
3500 return nullptr;
3501
dmazzonia656928e2014-09-15 20:28:543502 WebContents* guest = guest_manager->GetGuestByInstanceID(
fsamuel2e9413d2015-02-25 01:25:443503 render_frame_host->GetProcess()->GetID(), browser_plugin_instance_id);
dmazzonia656928e2014-09-15 20:28:543504 if (!guest)
fsamuel9cbc00a2015-04-17 20:30:203505 return nullptr;
3506
dmazzonia656928e2014-09-15 20:28:543507 return guest->GetMainFrame();
3508}
3509
Ke He7319dbe2017-11-09 05:54:443510device::mojom::GeolocationContext* WebContentsImpl::GetGeolocationContext() {
Ella Ge3e375b702020-06-05 15:57:163511 if (delegate_) {
3512 auto* installed_webapp_context =
3513 delegate_->GetInstalledWebappGeolocationContext();
3514 if (installed_webapp_context)
3515 return installed_webapp_context;
3516 }
3517
Ken Rockotce010f02019-12-12 23:32:323518 if (!geolocation_context_) {
3519 GetDeviceService().BindGeolocationContext(
3520 geolocation_context_.BindNewPipeAndPassReceiver());
3521 }
Conley Owens6894c4f2017-07-10 19:29:133522 return geolocation_context_.get();
blundellc57b93f2014-10-29 13:19:573523}
3524
ke.he98b761e2017-05-09 05:59:173525device::mojom::WakeLockContext* WebContentsImpl::GetWakeLockContext() {
blundelld8cd72b2017-03-28 07:18:383526 if (!wake_lock_context_host_)
3527 wake_lock_context_host_.reset(new WakeLockContextHost(this));
blundelle75a8f92017-03-27 08:11:173528 return wake_lock_context_host_->GetWakeLockContext();
alogvinovf50445a2015-10-30 13:00:123529}
3530
blundellf5316fc2017-05-15 11:49:033531#if defined(OS_ANDROID)
Miyoung Shin59f39ff2019-09-17 07:23:203532void WebContentsImpl::GetNFC(
Reilly Grantafbe2242020-02-20 21:14:553533 RenderFrameHost* render_frame_host,
Miyoung Shin59f39ff2019-09-17 07:23:203534 mojo::PendingReceiver<device::mojom::NFC> receiver) {
Reilly Grantafbe2242020-02-20 21:14:553535 if (!nfc_host_)
3536 nfc_host_ = std::make_unique<NFCHost>(this);
3537 nfc_host_->GetNFC(render_frame_host, std::move(receiver));
blundellf5316fc2017-05-15 11:49:033538}
3539#endif
3540
Evan Stade5e750ad02017-08-07 21:59:273541void WebContentsImpl::SetNotWaitingForResponse() {
3542 if (waiting_for_response_ == false)
3543 return;
3544
3545 waiting_for_response_ = false;
3546 if (delegate_)
3547 delegate_->LoadingStateChanged(this, is_load_to_different_document_);
Chris Hamiltonf82f2a702018-02-15 19:37:293548 for (auto& observer : observers_)
3549 observer.DidReceiveResponse();
Evan Stade5e750ad02017-08-07 21:59:273550}
3551
lfgbb9c28a2016-03-01 03:19:493552void WebContentsImpl::SendScreenRects() {
kenrbc52e1b4e2016-03-20 01:03:373553 for (FrameTreeNode* node : frame_tree_.Nodes()) {
kenrb0e8dc202016-05-30 19:51:403554 if (node->current_frame_host()->is_local_root())
kenrbc52e1b4e2016-03-20 01:03:373555 node->current_frame_host()->GetRenderWidgetHost()->SendScreenRects();
3556 }
[email protected]32deec62013-05-15 23:55:043557}
3558
ekaramadadd882292016-06-08 15:22:563559TextInputManager* WebContentsImpl::GetTextInputManager() {
3560 if (GetOuterWebContents())
3561 return GetOuterWebContents()->GetTextInputManager();
3562
Ehsan Karamadc179dc02018-12-15 03:09:293563 if (!text_input_manager_ && !browser_plugin_guest_) {
Darren Shenca53d5f2018-05-15 04:56:013564 text_input_manager_.reset(new TextInputManager(
3565 GetBrowserContext() &&
3566 !GetBrowserContext()->IsOffTheRecord()) /* should_do_learning */);
3567 }
ekaramadadd882292016-06-08 15:22:563568
3569 return text_input_manager_.get();
3570}
3571
paulmeyer7f6f1d4f2016-11-15 00:00:273572bool WebContentsImpl::OnUpdateDragCursor() {
Lei Zhang6410ec1a2019-01-31 21:38:583573 return browser_plugin_embedder_ &&
3574 browser_plugin_embedder_->OnUpdateDragCursor();
paulmeyer7f6f1d4f2016-11-15 00:00:273575}
3576
kenrb11f213a2017-03-24 18:12:063577bool WebContentsImpl::IsWidgetForMainFrame(
3578 RenderWidgetHostImpl* render_widget_host) {
3579 return render_widget_host == GetMainFrame()->GetRenderWidgetHost();
3580}
3581
[email protected]95640212014-07-26 18:14:303582BrowserAccessibilityManager*
3583 WebContentsImpl::GetRootBrowserAccessibilityManager() {
Carlos ILd51e7702020-05-07 18:51:393584 RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(GetMainFrame());
creisc014b402015-04-23 16:41:453585 return rfh ? rfh->browser_accessibility_manager() : nullptr;
[email protected]95640212014-07-26 18:14:303586}
3587
3588BrowserAccessibilityManager*
3589 WebContentsImpl::GetOrCreateRootBrowserAccessibilityManager() {
Carlos ILd51e7702020-05-07 18:51:393590 RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(GetMainFrame());
creisc014b402015-04-23 16:41:453591 return rfh ? rfh->GetOrCreateBrowserAccessibilityManager() : nullptr;
[email protected]95640212014-07-26 18:14:303592}
3593
Dave Tapuskab336b922017-07-06 19:24:053594void WebContentsImpl::ExecuteEditCommand(
3595 const std::string& command,
3596 const base::Optional<base::string16>& value) {
Dave Tapuska58a099e2020-06-08 21:48:403597 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513598 if (!input_handler)
Dave Tapuskab336b922017-07-06 19:24:053599 return;
3600
Dave Tapuskae782bea2019-07-09 16:21:513601 input_handler->ExecuteEditCommand(command, value);
Dave Tapuskab336b922017-07-06 19:24:053602}
3603
mohsen7ab1ec16ec2015-07-02 18:26:233604void WebContentsImpl::MoveRangeSelectionExtent(const gfx::Point& extent) {
Dave Tapuska58a099e2020-06-08 21:48:403605 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513606 if (!input_handler)
mohsen7ab1ec16ec2015-07-02 18:26:233607 return;
3608
Dave Tapuskae782bea2019-07-09 16:21:513609 input_handler->MoveRangeSelectionExtent(extent);
mohsen7ab1ec16ec2015-07-02 18:26:233610}
3611
3612void WebContentsImpl::SelectRange(const gfx::Point& base,
3613 const gfx::Point& extent) {
Dave Tapuska58a099e2020-06-08 21:48:403614 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513615 if (!input_handler)
mohsen7ab1ec16ec2015-07-02 18:26:233616 return;
3617
Dave Tapuskae782bea2019-07-09 16:21:513618 input_handler->SelectRange(base, extent);
mohsen7ab1ec16ec2015-07-02 18:26:233619}
3620
Dave Tapuskab336b922017-07-06 19:24:053621void WebContentsImpl::MoveCaret(const gfx::Point& extent) {
Dave Tapuska58a099e2020-06-08 21:48:403622 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513623 if (!input_handler)
Dave Tapuskab336b922017-07-06 19:24:053624 return;
3625
Dave Tapuskae782bea2019-07-09 16:21:513626 input_handler->MoveCaret(extent);
Dave Tapuskab336b922017-07-06 19:24:053627}
3628
Shimi Zhang37deeb22017-09-28 00:59:013629void WebContentsImpl::AdjustSelectionByCharacterOffset(
3630 int start_adjust,
3631 int end_adjust,
3632 bool show_selection_menu) {
Dave Tapuska58a099e2020-06-08 21:48:403633 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513634 if (!input_handler)
aurimasab0319022015-07-10 21:57:383635 return;
3636
Shimi Zhang37deeb22017-09-28 00:59:013637 using blink::mojom::SelectionMenuBehavior;
Dave Tapuskae782bea2019-07-09 16:21:513638 input_handler->AdjustSelectionByCharacterOffset(
Shimi Zhang37deeb22017-09-28 00:59:013639 start_adjust, end_adjust,
3640 show_selection_menu ? SelectionMenuBehavior::kShow
3641 : SelectionMenuBehavior::kHide);
aurimasab0319022015-07-10 21:57:383642}
3643
[email protected]b172aee2012-04-10 17:05:263644void WebContentsImpl::UpdatePreferredSize(const gfx::Size& pref_size) {
[email protected]222f5822014-02-05 23:40:493645 const gfx::Size old_size = GetPreferredSize();
[email protected]bcd2815602012-01-14 18:17:233646 preferred_size_ = pref_size;
[email protected]222f5822014-02-05 23:40:493647 OnPreferredSizeChanged(old_size);
[email protected]0548c5352011-09-07 00:33:333648}
3649
avic3aa8422015-11-09 20:57:223650void WebContentsImpl::ResizeDueToAutoResize(
3651 RenderWidgetHostImpl* render_widget_host,
Fady Samuel97947112018-05-05 16:24:543652 const gfx::Size& new_size) {
avic3aa8422015-11-09 20:57:223653 if (render_widget_host != GetRenderViewHost()->GetWidget())
3654 return;
3655
[email protected]61e2b3cc2012-03-02 16:13:343656 if (delegate_)
3657 delegate_->ResizeDueToAutoResize(this, new_size);
3658}
3659
[email protected]b172aee2012-04-10 17:05:263660WebContents* WebContentsImpl::OpenURL(const OpenURLParams& params) {
Aaron Colwell9dab1652019-12-09 18:29:493661#if DCHECK_IS_ON()
3662 DCHECK(params.Valid());
3663#endif
3664
Bo Liu300c6052018-06-12 04:46:073665 if (!delegate_) {
3666 // Embedder can delay setting a delegate on new WebContents with
3667 // WebContentsDelegate::ShouldResumeRequestsForCreatedWindow. In the mean
3668 // time, navigations, including the initial one, that goes through OpenURL
3669 // should be delayed until embedder is ready to resume loading.
3670 delayed_open_url_params_ = std::make_unique<OpenURLParams>(params);
Nasko Oskov83a8cf92018-10-19 14:58:563671
3672 // If there was a navigation deferred when creating the window through
3673 // CreateNewWindow, drop it in favor of this navigation.
3674 delayed_load_url_params_.reset();
3675
Ivan Kotenkov2c0d2bb32017-11-01 15:41:283676 return nullptr;
Bo Liu300c6052018-06-12 04:46:073677 }
[email protected]00c37fc2011-08-02 00:22:503678
[email protected]e5d549d2011-12-28 01:29:203679 WebContents* new_contents = delegate_->OpenURLFromTab(this, params);
pnoland488944652017-02-22 18:58:543680
3681 RenderFrameHost* source_render_frame_host = RenderFrameHost::FromID(
3682 params.source_render_process_id, params.source_render_frame_id);
3683
3684 if (source_render_frame_host && params.source_site_instance) {
3685 CHECK_EQ(source_render_frame_host->GetSiteInstance(),
3686 params.source_site_instance.get());
3687 }
3688
3689 if (new_contents && source_render_frame_host && new_contents != this) {
3690 for (auto& observer : observers_) {
Lukasz Anforowicz48c9f872018-08-01 00:58:413691 observer.DidOpenRequestedURL(
3692 new_contents, source_render_frame_host, params.url, params.referrer,
3693 params.disposition, params.transition,
3694 params.started_from_context_menu, params.is_renderer_initiated);
pnoland488944652017-02-22 18:58:543695 }
3696 }
3697
[email protected]e5d549d2011-12-28 01:29:203698 return new_contents;
[email protected]d5f942ba2008-09-26 19:30:343699}
3700
avi2b177592014-12-10 02:08:023701void WebContentsImpl::SetHistoryOffsetAndLength(int history_offset,
3702 int history_length) {
alexmos136fd6e62016-08-15 20:58:413703 SendPageMessage(new PageMsg_SetHistoryOffsetAndLength(
3704 MSG_ROUTING_NONE, history_offset, history_length));
avi2b177592014-12-10 02:08:023705}
3706
3707void WebContentsImpl::SetHistoryOffsetAndLengthForView(
3708 RenderViewHost* render_view_host,
3709 int history_offset,
3710 int history_length) {
alexmos136fd6e62016-08-15 20:58:413711 render_view_host->Send(new PageMsg_SetHistoryOffsetAndLength(
avi2b177592014-12-10 02:08:023712 render_view_host->GetRoutingID(), history_offset, history_length));
[email protected]796931a92011-08-10 01:32:143713}
3714
arthursonzogni818c2642019-09-27 12:18:103715void WebContentsImpl::ReloadFocusedFrame() {
[email protected]1f3fc1d2014-04-03 14:50:173716 RenderFrameHost* focused_frame = GetFocusedFrame();
3717 if (!focused_frame)
3718 return;
3719
yilkal921048bd2019-10-09 23:51:043720 focused_frame->Reload();
[email protected]959be4c2014-04-08 15:01:333721}
3722
[email protected]959be4c2014-04-08 15:01:333723void WebContentsImpl::Undo() {
Dave Tapuska58a099e2020-06-08 21:48:403724 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513725 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333726 return;
3727
Dave Tapuskae782bea2019-07-09 16:21:513728 input_handler->Undo();
[email protected]959be4c2014-04-08 15:01:333729 RecordAction(base::UserMetricsAction("Undo"));
3730}
3731
3732void WebContentsImpl::Redo() {
Dave Tapuska58a099e2020-06-08 21:48:403733 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513734 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333735 return;
Dave Tapuskae782bea2019-07-09 16:21:513736
3737 input_handler->Redo();
[email protected]959be4c2014-04-08 15:01:333738 RecordAction(base::UserMetricsAction("Redo"));
3739}
3740
3741void WebContentsImpl::Cut() {
Dave Tapuska58a099e2020-06-08 21:48:403742 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513743 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333744 return;
3745
Dave Tapuskae782bea2019-07-09 16:21:513746 input_handler->Cut();
[email protected]959be4c2014-04-08 15:01:333747 RecordAction(base::UserMetricsAction("Cut"));
3748}
3749
3750void WebContentsImpl::Copy() {
Dave Tapuska58a099e2020-06-08 21:48:403751 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513752 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333753 return;
3754
Dave Tapuskae782bea2019-07-09 16:21:513755 input_handler->Copy();
[email protected]959be4c2014-04-08 15:01:333756 RecordAction(base::UserMetricsAction("Copy"));
3757}
3758
3759void WebContentsImpl::CopyToFindPboard() {
3760#if defined(OS_MACOSX)
Dave Tapuska58a099e2020-06-08 21:48:403761 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513762 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333763 return;
3764
3765 // Windows/Linux don't have the concept of a find pasteboard.
Dave Tapuskae782bea2019-07-09 16:21:513766 input_handler->CopyToFindPboard();
[email protected]959be4c2014-04-08 15:01:333767 RecordAction(base::UserMetricsAction("CopyToFindPboard"));
3768#endif
3769}
3770
3771void WebContentsImpl::Paste() {
Dave Tapuska58a099e2020-06-08 21:48:403772 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513773 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333774 return;
3775
Dave Tapuskae782bea2019-07-09 16:21:513776 input_handler->Paste();
Archana Simhaf67090c2019-05-06 23:43:233777 for (auto& observer : observers_)
3778 observer.OnPaste();
[email protected]959be4c2014-04-08 15:01:333779 RecordAction(base::UserMetricsAction("Paste"));
3780}
3781
3782void WebContentsImpl::PasteAndMatchStyle() {
Dave Tapuska58a099e2020-06-08 21:48:403783 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513784 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333785 return;
3786
Dave Tapuskae782bea2019-07-09 16:21:513787 input_handler->PasteAndMatchStyle();
Archana Simhaf67090c2019-05-06 23:43:233788 for (auto& observer : observers_)
3789 observer.OnPaste();
[email protected]959be4c2014-04-08 15:01:333790 RecordAction(base::UserMetricsAction("PasteAndMatchStyle"));
3791}
3792
3793void WebContentsImpl::Delete() {
Dave Tapuska58a099e2020-06-08 21:48:403794 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513795 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333796 return;
3797
Dave Tapuskae782bea2019-07-09 16:21:513798 input_handler->Delete();
[email protected]959be4c2014-04-08 15:01:333799 RecordAction(base::UserMetricsAction("DeleteSelection"));
3800}
3801
3802void WebContentsImpl::SelectAll() {
Dave Tapuska58a099e2020-06-08 21:48:403803 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513804 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333805 return;
3806
Dave Tapuskae782bea2019-07-09 16:21:513807 input_handler->SelectAll();
[email protected]959be4c2014-04-08 15:01:333808 RecordAction(base::UserMetricsAction("SelectAll"));
3809}
3810
yabinh351e7ec2017-03-10 02:43:243811void WebContentsImpl::CollapseSelection() {
Dave Tapuska58a099e2020-06-08 21:48:403812 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513813 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333814 return;
3815
Dave Tapuskae782bea2019-07-09 16:21:513816 input_handler->CollapseSelection();
[email protected]1f3fc1d2014-04-03 14:50:173817}
3818
3819void WebContentsImpl::Replace(const base::string16& word) {
Dave Tapuska58a099e2020-06-08 21:48:403820 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513821 if (!input_handler)
[email protected]1f3fc1d2014-04-03 14:50:173822 return;
3823
Dave Tapuskae782bea2019-07-09 16:21:513824 input_handler->Replace(word);
[email protected]1f3fc1d2014-04-03 14:50:173825}
3826
3827void WebContentsImpl::ReplaceMisspelling(const base::string16& word) {
Dave Tapuska58a099e2020-06-08 21:48:403828 auto* input_handler = GetFocusedFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:513829 if (!input_handler)
[email protected]1f3fc1d2014-04-03 14:50:173830 return;
3831
Dave Tapuskae782bea2019-07-09 16:21:513832 input_handler->ReplaceMisspelling(word);
[email protected]959be4c2014-04-08 15:01:333833}
3834
3835void WebContentsImpl::NotifyContextMenuClosed(
3836 const CustomContextMenuContext& context) {
3837 RenderFrameHost* focused_frame = GetFocusedFrame();
3838 if (!focused_frame)
3839 return;
3840
3841 focused_frame->Send(new FrameMsg_ContextMenuClosed(
3842 focused_frame->GetRoutingID(), context));
3843}
3844
3845void WebContentsImpl::ExecuteCustomContextMenuCommand(
3846 int action, const CustomContextMenuContext& context) {
3847 RenderFrameHost* focused_frame = GetFocusedFrame();
3848 if (!focused_frame)
3849 return;
3850
3851 focused_frame->Send(new FrameMsg_CustomContextMenuAction(
3852 focused_frame->GetRoutingID(), context, action));
[email protected]4fed3702014-04-01 09:08:003853}
3854
[email protected]fc2b46b2014-05-03 16:33:453855gfx::NativeView WebContentsImpl::GetNativeView() {
3856 return view_->GetNativeView();
3857}
3858
3859gfx::NativeView WebContentsImpl::GetContentNativeView() {
3860 return view_->GetContentNativeView();
3861}
3862
3863gfx::NativeWindow WebContentsImpl::GetTopLevelNativeWindow() {
3864 return view_->GetTopLevelNativeWindow();
3865}
3866
3867gfx::Rect WebContentsImpl::GetViewBounds() {
3868 return view_->GetViewBounds();
3869}
3870
3871gfx::Rect WebContentsImpl::GetContainerBounds() {
Jeremy Roman352239c2020-05-21 16:31:323872 return view_->GetContainerBounds();
[email protected]fc2b46b2014-05-03 16:33:453873}
3874
3875DropData* WebContentsImpl::GetDropData() {
3876 return view_->GetDropData();
3877}
3878
3879void WebContentsImpl::Focus() {
miu9e14e492014-10-25 02:39:043880 view_->Focus();
[email protected]fc2b46b2014-05-03 16:33:453881}
3882
3883void WebContentsImpl::SetInitialFocus() {
miu9e14e492014-10-25 02:39:043884 view_->SetInitialFocus();
[email protected]fc2b46b2014-05-03 16:33:453885}
3886
3887void WebContentsImpl::StoreFocus() {
miu9e14e492014-10-25 02:39:043888 view_->StoreFocus();
[email protected]fc2b46b2014-05-03 16:33:453889}
3890
3891void WebContentsImpl::RestoreFocus() {
miu9e14e492014-10-25 02:39:043892 view_->RestoreFocus();
[email protected]fc2b46b2014-05-03 16:33:453893}
3894
[email protected]b172aee2012-04-10 17:05:263895void WebContentsImpl::FocusThroughTabTraversal(bool reverse) {
Maxim Podgorodskiya926c4ff2017-11-20 02:06:393896 view_->FocusThroughTabTraversal(reverse);
[email protected]96d185d2009-04-24 03:28:543897}
3898
[email protected]b172aee2012-04-10 17:05:263899bool WebContentsImpl::IsSavable() {
[email protected]a53209b2012-01-20 16:48:163900 // WebKit creates Document object when MIME type is application/xhtml+xml,
3901 // so we also support this MIME type.
Yuzu Saijoc23e9b72020-06-25 07:21:273902 std::string mime_type = GetContentsMimeType();
3903 return mime_type == "text/html" || mime_type == "text/xml" ||
3904 mime_type == "application/xhtml+xml" || mime_type == "text/plain" ||
3905 mime_type == "text/css" ||
3906 blink::IsSupportedJavascriptMimeType(mime_type);
[email protected]a53209b2012-01-20 16:48:163907}
3908
[email protected]b172aee2012-04-10 17:05:263909void WebContentsImpl::OnSavePage() {
[email protected]c7dd2f62011-07-18 15:57:593910 // If we can not save the page, try to download it.
[email protected]a53209b2012-01-20 16:48:163911 if (!IsSavable()) {
Min Qinda0ed2062018-02-23 22:00:533912 download::RecordSavePackageEvent(
3913 download::SAVE_PACKAGE_DOWNLOAD_ON_NON_HTML);
nasko89ad7742015-03-05 22:14:193914 SaveFrame(GetLastCommittedURL(), Referrer());
[email protected]27678b2a2012-02-04 22:09:143915 return;
[email protected]c7dd2f62011-07-18 15:57:593916 }
3917
3918 Stop();
3919
3920 // Create the save package and possibly prompt the user for the name to save
3921 // the page as. The user prompt is an asynchronous operation that runs on
3922 // another thread.
3923 save_package_ = new SavePackage(this);
3924 save_package_->GetSaveInfo();
3925}
3926
3927// Used in automated testing to bypass prompting the user for file names.
3928// Instead, the names and paths are hard coded rather than running them through
3929// file name sanitation and extension / mime checking.
[email protected]2dec8ec2013-02-07 19:20:343930bool WebContentsImpl::SavePage(const base::FilePath& main_file,
3931 const base::FilePath& dir_path,
[email protected]8ff00d72012-10-23 19:12:213932 SavePageType save_type) {
[email protected]c7dd2f62011-07-18 15:57:593933 // Stop the page from navigating.
3934 Stop();
3935
3936 save_package_ = new SavePackage(this, save_type, main_file, dir_path);
[email protected]8ff00d72012-10-23 19:12:213937 return save_package_->Init(SavePackageDownloadCreatedCallback());
[email protected]c7dd2f62011-07-18 15:57:593938}
3939
[email protected]3c71576ce2013-07-23 02:00:013940void WebContentsImpl::SaveFrame(const GURL& url,
3941 const Referrer& referrer) {
Xing Liu10329bf2018-03-20 19:22:143942 SaveFrameWithHeaders(url, referrer, std::string(), base::string16());
kundaji6c7f9692015-03-09 18:00:373943}
3944
Xing Liu10329bf2018-03-20 19:22:143945void WebContentsImpl::SaveFrameWithHeaders(
3946 const GURL& url,
3947 const Referrer& referrer,
3948 const std::string& headers,
3949 const base::string16& suggested_filename) {
Lei Zhang13a42e42019-02-19 23:28:113950 // Check and see if the guest can handle this.
3951 if (delegate_) {
3952 WebContents* guest_web_contents = nullptr;
3953 if (browser_plugin_embedder_) {
3954 BrowserPluginGuest* guest = browser_plugin_embedder_->GetFullPageGuest();
3955 if (guest)
3956 guest_web_contents = guest->GetWebContents();
3957 } else if (browser_plugin_guest_) {
3958 guest_web_contents = this;
3959 }
3960
3961 if (guest_web_contents && delegate_->GuestSaveFrame(guest_web_contents))
3962 return;
3963 }
3964
nasko89ad7742015-03-05 22:14:193965 if (!GetLastCommittedURL().is_valid())
[email protected]3c71576ce2013-07-23 02:00:013966 return;
sammc92af61552014-11-19 23:27:403967 if (delegate_ && delegate_->SaveFrame(url, referrer))
3968 return;
3969
nasko89ad7742015-03-05 22:14:193970 // TODO(nasko): This check for main frame is incorrect and should be fixed
brettw760f7442016-05-23 21:19:223971 // by explicitly passing in which frame this method should target. This would
3972 // indicate whether it's the main frame, and also tell us the frame pointer
3973 // to use for routing.
nasko89ad7742015-03-05 22:14:193974 bool is_main_frame = (url == GetLastCommittedURL());
brettw760f7442016-05-23 21:19:223975 RenderFrameHost* frame_host = GetMainFrame();
[email protected]3c71576ce2013-07-23 02:00:013976
avib7348942015-12-25 20:57:103977 int64_t post_id = -1;
[email protected]3c71576ce2013-07-23 02:00:013978 if (is_main_frame) {
Lucas Furukawa Gadani5553a152019-01-08 18:55:573979 NavigationEntry* entry = controller_.GetLastCommittedEntry();
[email protected]3c71576ce2013-07-23 02:00:013980 if (entry)
3981 post_id = entry->GetPostID();
3982 }
Ramin Halavati24e21012017-07-10 12:56:063983 net::NetworkTrafficAnnotationTag traffic_annotation =
3984 net::DefineNetworkTrafficAnnotation("download_web_contents_frame", R"(
3985 semantics {
3986 sender: "Save Page Action"
3987 description:
3988 "Saves the given frame's URL to the local file system."
3989 trigger:
3990 "The user has triggered a save operation on the frame through a "
3991 "context menu or other mechanism."
3992 data: "None."
3993 destination: WEBSITE
3994 }
3995 policy {
Ramin Halavati3b979782017-07-21 11:40:263996 cookies_allowed: YES
Ramin Halavati24e21012017-07-10 12:56:063997 cookies_store: "user"
3998 setting:
3999 "This feature cannot be disabled by settings, but it's is only "
4000 "triggered by user request."
4001 policy_exception_justification: "Not implemented."
4002 })");
Min Qina904f3302018-02-13 23:33:344003 auto params = std::make_unique<download::DownloadUrlParameters>(
brettw760f7442016-05-23 21:19:224004 url, frame_host->GetProcess()->GetID(),
4005 frame_host->GetRenderViewHost()->GetRoutingID(),
Matt Menke0dcaebc32020-03-06 17:00:104006 frame_host->GetRoutingID(), traffic_annotation);
Min Qina904f3302018-02-13 23:33:344007 params->set_referrer(referrer.url);
4008 params->set_referrer_policy(
4009 Referrer::ReferrerPolicyForUrlRequest(referrer.policy));
[email protected]3c71576ce2013-07-23 02:00:014010 params->set_post_id(post_id);
[email protected]3c71576ce2013-07-23 02:00:014011 if (post_id >= 0)
4012 params->set_method("POST");
4013 params->set_prompt(true);
kundaji6c7f9692015-03-09 18:00:374014
4015 if (headers.empty()) {
4016 params->set_prefer_cache(true);
4017 } else {
Min Qina904f3302018-02-13 23:33:344018 for (download::DownloadUrlParameters::RequestHeadersNameValuePair
4019 key_value : ParseDownloadHeaders(headers)) {
Megan Jablonski2f6a4c52017-07-10 23:01:254020 params->add_request_header(key_value.first, key_value.second);
kundaji6c7f9692015-03-09 18:00:374021 }
4022 }
Xing Liu10329bf2018-03-20 19:22:144023 params->set_suggested_name(suggested_filename);
Min Qin0ca8e1ee2018-01-31 00:49:354024 params->set_download_source(download::DownloadSource::WEB_CONTENTS_API);
thestig859c78892017-05-15 21:17:064025 BrowserContext::GetDownloadManager(GetBrowserContext())
Ramin Halavati03efa732017-06-12 09:28:204026 ->DownloadUrl(std::move(params));
[email protected]3c71576ce2013-07-23 02:00:014027}
4028
[email protected]b172aee2012-04-10 17:05:264029void WebContentsImpl::GenerateMHTML(
dewittj6dc5747a2016-05-17 01:48:474030 const MHTMLGenerationParams& params,
Avi Drissman149b7832018-03-23 14:31:494031 base::OnceCallback<void(int64_t)> callback) {
Angel Alvarez902496682019-08-27 22:58:424032 base::OnceCallback<void(const MHTMLGenerationResult&)> wrapper_callback =
4033 base::BindOnce(
4034 [](base::OnceCallback<void(int64_t)> size_callback,
4035 const MHTMLGenerationResult& result) {
4036 std::move(size_callback).Run(result.file_size);
4037 },
4038 std::move(callback));
4039 MHTMLGenerationManager::GetInstance()->SaveMHTML(this, params,
4040 std::move(wrapper_callback));
4041}
4042
4043void WebContentsImpl::GenerateMHTMLWithResult(
4044 const MHTMLGenerationParams& params,
4045 MHTMLGenerationResult::GenerateMHTMLCallback callback) {
Avi Drissman149b7832018-03-23 14:31:494046 MHTMLGenerationManager::GetInstance()->SaveMHTML(this, params,
4047 std::move(callback));
[email protected]aa4f3972012-03-01 18:12:124048}
4049
Tsuyoshi Horob0d8d902020-03-12 00:09:394050void WebContentsImpl::GenerateWebBundle(
4051 const base::FilePath& file_path,
4052 base::OnceCallback<void(uint64_t /* file_size */,
4053 data_decoder::mojom::WebBundlerError)> callback) {
4054 SaveAsWebBundleJob::Start(this, file_path, std::move(callback));
4055}
4056
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414057const std::string& WebContentsImpl::GetContentsMimeType() {
Yuzu Saijoc23e9b72020-06-25 07:21:274058 return GetRenderViewHost()->contents_mime_type();
[email protected]0bfbf882011-12-22 18:19:274059}
4060
Leon Hanc819dc62019-01-28 04:30:194061blink::mojom::RendererPreferences* WebContentsImpl::GetMutableRendererPrefs() {
[email protected]0bfbf882011-12-22 18:19:274062 return &renderer_preferences_;
4063}
4064
[email protected]e35ccd52012-05-23 16:22:474065void WebContentsImpl::Close() {
4066 Close(GetRenderViewHost());
4067}
4068
Ella Ge80a52dce2017-11-15 18:01:524069void WebContentsImpl::DragSourceEndedAt(float client_x,
4070 float client_y,
4071 float screen_x,
4072 float screen_y,
Paul Meyer0c58c3712016-11-17 22:59:514073 blink::WebDragOperation operation,
4074 RenderWidgetHost* source_rwh) {
Lei Zhang6410ec1a2019-01-31 21:38:584075 if (browser_plugin_embedder_) {
W. James MacLean9437b5bf2019-12-06 17:33:444076 browser_plugin_embedder_->DragSourceEndedAt(client_x, client_y, screen_x,
4077 screen_y, operation);
Lei Zhang6410ec1a2019-01-31 21:38:584078 }
Paul Meyer0c58c3712016-11-17 22:59:514079 if (source_rwh) {
Ella Ge80a52dce2017-11-15 18:01:524080 source_rwh->DragSourceEndedAt(gfx::PointF(client_x, client_y),
4081 gfx::PointF(screen_x, screen_y), operation);
Paul Meyer0c58c3712016-11-17 22:59:514082 }
[email protected]cf200a562013-05-03 16:24:294083}
4084
jam73f892642016-09-11 06:04:064085void WebContentsImpl::LoadStateChanged(
Charles Harrison911fa062018-03-06 21:01:464086 const std::string& host,
jam73f892642016-09-11 06:04:064087 const net::LoadStateWithParam& load_state,
4088 uint64_t upload_position,
4089 uint64_t upload_size) {
Charles Harrison911fa062018-03-06 21:01:464090 base::string16 host16 = url_formatter::IDNToUnicode(host);
Elly Fong-Jonescad9c3d12018-01-31 17:26:104091 // Drop no-op updates.
4092 if (load_state_.state == load_state.state &&
4093 load_state_.param == load_state.param &&
4094 upload_position_ == upload_position && upload_size_ == upload_size &&
Charles Harrison911fa062018-03-06 21:01:464095 load_state_host_ == host16) {
Elly Fong-Jonescad9c3d12018-01-31 17:26:104096 return;
4097 }
jam73f892642016-09-11 06:04:064098 load_state_ = load_state;
4099 upload_position_ = upload_position;
4100 upload_size_ = upload_size;
Charles Harrison911fa062018-03-06 21:01:464101 load_state_host_ = host16;
jam73f892642016-09-11 06:04:064102 if (load_state_.state == net::LOAD_STATE_READING_RESPONSE)
4103 SetNotWaitingForResponse();
4104 if (IsLoading()) {
4105 NotifyNavigationStateChanged(static_cast<InvalidateTypes>(
4106 INVALIDATE_TYPE_LOAD | INVALIDATE_TYPE_TAB));
4107 }
4108}
4109
Collin Baker989e0882019-11-01 01:27:174110void WebContentsImpl::SetVisibilityAndNotifyObservers(Visibility visibility) {
Francois Doraye6161152018-03-27 22:05:374111 const Visibility previous_visibility = visibility_;
4112 visibility_ = visibility;
4113
Francois Dorayfe4a1772018-02-17 04:17:094114 // Notify observers if the visibility changed or if WasShown() is being called
4115 // for the first time.
Francois Dorayfe4a1772018-02-17 04:17:094116 if (visibility != previous_visibility ||
4117 (visibility == Visibility::VISIBLE && !did_first_set_visible_)) {
4118 for (auto& observer : observers_)
4119 observer.OnVisibilityChanged(visibility);
4120 }
4121}
4122
Michael Thiessen896405db2017-07-20 17:52:324123void WebContentsImpl::NotifyWebContentsFocused(
4124 RenderWidgetHost* render_widget_host) {
ericwilligersde386342016-10-19 02:35:094125 for (auto& observer : observers_)
Michael Thiessen896405db2017-07-20 17:52:324126 observer.OnWebContentsFocused(render_widget_host);
calamity7fe55ce2015-04-10 03:59:374127}
4128
Michael Thiessen896405db2017-07-20 17:52:324129void WebContentsImpl::NotifyWebContentsLostFocus(
4130 RenderWidgetHost* render_widget_host) {
zijiehe3bee08e22017-05-17 04:14:464131 for (auto& observer : observers_)
Michael Thiessen896405db2017-07-20 17:52:324132 observer.OnWebContentsLostFocus(render_widget_host);
zijiehe3bee08e22017-05-17 04:14:464133}
4134
Paul Meyer0c58c3712016-11-17 22:59:514135void WebContentsImpl::SystemDragEnded(RenderWidgetHost* source_rwh) {
4136 if (source_rwh)
4137 source_rwh->DragSourceSystemDragEnded();
Lei Zhang6410ec1a2019-01-31 21:38:584138 if (browser_plugin_embedder_)
[email protected]cf200a562013-05-03 16:24:294139 browser_plugin_embedder_->SystemDragEnded();
[email protected]7813bd72011-02-05 02:19:344140}
4141
[email protected]b172aee2012-04-10 17:05:264142void WebContentsImpl::SetClosedByUserGesture(bool value) {
[email protected]0bfbf882011-12-22 18:19:274143 closed_by_user_gesture_ = value;
4144}
4145
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414146bool WebContentsImpl::GetClosedByUserGesture() {
[email protected]0bfbf882011-12-22 18:19:274147 return closed_by_user_gesture_;
4148}
4149
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414150int WebContentsImpl::GetMinimumZoomPercent() {
[email protected]0bfbf882011-12-22 18:19:274151 return minimum_zoom_percent_;
4152}
4153
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414154int WebContentsImpl::GetMaximumZoomPercent() {
[email protected]0bfbf882011-12-22 18:19:274155 return maximum_zoom_percent_;
4156}
4157
Dave Tapuska8f7c3872020-02-07 01:16:384158void WebContentsImpl::SetPageScale(float scale_factor) {
4159 GetMainFrame()->GetAssociatedLocalMainFrame()->SetScaleFactor(scale_factor);
ccameronb7c1d6c2015-03-09 17:08:244160}
4161
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414162gfx::Size WebContentsImpl::GetPreferredSize() {
Francois Doray24fc62c2017-12-11 17:27:334163 return IsBeingCaptured() ? preferred_size_for_capture_ : preferred_size_;
[email protected]bcd2815602012-01-14 18:17:234164}
4165
James Hollyerd5c9de462020-03-10 19:02:454166bool WebContentsImpl::GotResponseToLockMouseRequest(
4167 blink::mojom::PointerLockResult result) {
lfgf0cd46e2017-01-04 00:05:234168 if (mouse_lock_widget_) {
4169 if (mouse_lock_widget_->delegate()->GetAsWebContents() != this) {
4170 return mouse_lock_widget_->delegate()
4171 ->GetAsWebContents()
James Hollyerd5c9de462020-03-10 19:02:454172 ->GotResponseToLockMouseRequest(result);
lfgf0cd46e2017-01-04 00:05:234173 }
lfgad8244352016-07-13 16:55:514174
James Hollyerd5c9de462020-03-10 19:02:454175 if (mouse_lock_widget_->GotResponseToLockMouseRequest(result))
lfgf0cd46e2017-01-04 00:05:234176 return true;
4177 }
4178
4179 for (WebContentsImpl* current = this; current;
4180 current = current->GetOuterWebContents()) {
4181 current->mouse_lock_widget_ = nullptr;
4182 }
4183
lfgbee1e0a2016-06-08 21:24:214184 return false;
[email protected]0bfbf882011-12-22 18:19:274185}
4186
James Hollyerd5c9de462020-03-10 19:02:454187void WebContentsImpl::GotLockMousePermissionResponse(bool allowed) {
4188 GotResponseToLockMouseRequest(
4189 allowed ? blink::mojom::PointerLockResult::kSuccess
4190 : blink::mojom::PointerLockResult::kPermissionDenied);
4191}
4192
Joe Downing13dd76b2018-04-09 18:32:154193bool WebContentsImpl::GotResponseToKeyboardLockRequest(bool allowed) {
4194 if (!keyboard_lock_widget_)
4195 return false;
4196
4197 if (keyboard_lock_widget_->delegate()->GetAsWebContents() != this) {
4198 NOTREACHED();
4199 return false;
4200 }
4201
4202 // KeyboardLock is only supported when called by the top-level browsing
4203 // context and is not supported in embedded content scenarios.
4204 if (GetOuterWebContents())
4205 return false;
4206
4207 keyboard_lock_widget_->GotResponseToKeyboardLockRequest(allowed);
4208 return true;
4209}
4210
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414211bool WebContentsImpl::HasOpener() {
Ivan Kotenkov2c0d2bb32017-11-01 15:41:284212 return GetOpener() != nullptr;
[email protected]a0358d72012-03-09 14:06:504213}
4214
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414215RenderFrameHostImpl* WebContentsImpl::GetOpener() {
alexmose201c7cd2015-06-10 17:14:214216 FrameTreeNode* opener_ftn = frame_tree_.root()->opener();
lukasza6f8ac622017-06-06 03:10:204217 return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
jochen55ff3502014-12-18 20:52:574218}
4219
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414220bool WebContentsImpl::HasOriginalOpener() {
Ivan Kotenkov2c0d2bb32017-11-01 15:41:284221 return GetOriginalOpener() != nullptr;
jochen6004a362017-02-04 00:11:404222}
4223
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414224RenderFrameHostImpl* WebContentsImpl::GetOriginalOpener() {
jochen6004a362017-02-04 00:11:404225 FrameTreeNode* opener_ftn = frame_tree_.root()->original_opener();
lukasza6f8ac622017-06-06 03:10:204226 return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
jochen6004a362017-02-04 00:11:404227}
4228
[email protected]cb805452013-05-22 15:16:214229void WebContentsImpl::DidChooseColorInColorChooser(SkColor color) {
Joel Hockey85b379d2017-12-11 10:42:134230 color_chooser_->DidChooseColorInColorChooser(color);
[email protected]da8543762012-03-20 08:52:204231}
4232
[email protected]cb805452013-05-22 15:16:214233void WebContentsImpl::DidEndColorChooser() {
Joel Hockey85b379d2017-12-11 10:42:134234 color_chooser_.reset();
[email protected]da8543762012-03-20 08:52:204235}
4236
halton.huoca2eabd2015-07-06 08:17:404237int WebContentsImpl::DownloadImage(
4238 const GURL& url,
4239 bool is_favicon,
Fredrik Söderquistb2b39eb92019-11-18 16:16:504240 uint32_t preferred_size,
halton.huoca2eabd2015-07-06 08:17:404241 uint32_t max_bitmap_size,
4242 bool bypass_cache,
Avi Drissmana5a52dd2018-03-27 03:39:024243 WebContents::ImageDownloadCallback callback) {
Danyao Wanga78f3dd22020-03-05 05:31:274244 return DownloadImageInFrame(GlobalFrameRoutingId(), url, is_favicon,
4245 preferred_size, max_bitmap_size, bypass_cache,
4246 std::move(callback));
4247}
4248
4249int WebContentsImpl::DownloadImageInFrame(
4250 const GlobalFrameRoutingId& initiator_frame_routing_id,
4251 const GURL& url,
4252 bool is_favicon,
4253 uint32_t preferred_size,
4254 uint32_t max_bitmap_size,
4255 bool bypass_cache,
4256 WebContents::ImageDownloadCallback callback) {
amistry9f01b772015-07-29 01:54:554257 DCHECK_CURRENTLY_ON(BrowserThread::UI);
halton.huoca2eabd2015-07-06 08:17:404258 static int next_image_download_id = 0;
Danyao Wanga78f3dd22020-03-05 05:31:274259
4260 RenderFrameHostImpl* initiator_frame =
4261 initiator_frame_routing_id.child_id
4262 ? RenderFrameHostImpl::FromID(initiator_frame_routing_id)
4263 : GetMainFrame();
Julie Jeongeun Kimb1473572019-08-15 05:59:134264 const mojo::Remote<blink::mojom::ImageDownloader>& mojo_image_downloader =
Danyao Wanga78f3dd22020-03-05 05:31:274265 initiator_frame->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.
Gabriel Charettee7cdc5cd2020-05-27 23:35:054272 GetUIThreadTaskRunner({})->PostTask(
4273 FROM_HERE,
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(
Fredrik Söderquistb2b39eb92019-11-18 16:16:504282 url, is_favicon, preferred_size, 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) {
Yuzu Saijofce18322020-05-14 05:02:094312 // TODO(yuzus, 1061899): Move this function to RenderFrameHostImpl.
4313 ManifestManagerHost* manifest_manager_host =
4314 ManifestManagerHost::GetOrCreateForCurrentDocument(GetMainFrame());
4315 manifest_manager_host->GetManifest(std::move(callback));
mlamouriefdca9d2014-09-16 16:55:404316}
4317
bokanece34a82016-01-28 19:49:464318void WebContentsImpl::ExitFullscreen(bool will_cause_resize) {
mlamouri7a78d6fd2015-01-17 13:23:534319 // Clean up related state and initiate the fullscreen exit.
James Hollyerd5c9de462020-03-10 19:02:454320 GetRenderViewHost()->GetWidget()->RejectMouseLockOrUnlockIfNecessary(
4321 blink::mojom::PointerLockResult::kUserRejected);
bokanece34a82016-01-28 19:49:464322 ExitFullscreenMode(will_cause_resize);
mlamouri7a78d6fd2015-01-17 13:23:534323}
4324
Avi Drissman1a55a9d62020-03-10 18:56:454325base::ScopedClosureRunner WebContentsImpl::ForSecurityDropFullscreen() {
Avi Drissman33972942020-06-19 14:16:014326 // Kick WebContentses that are "related" to this WebContents out of
4327 // fullscreen. This needs to be done with two passes, because it is simple to
4328 // walk _up_ the chain of openers and outer contents, but it not simple to
4329 // walk _down_ the chain.
4330
4331 // First, determine if any WebContents that is in fullscreen has this
4332 // WebContents as an upstream contents. Drop that WebContents out of
4333 // fullscreen if it does. This is theoretically quadratic-ish (fullscreen
4334 // contentses x each one's opener length) but neither of those is expected to
4335 // ever be a large number.
4336
4337 auto fullscreen_set_copy = *FullscreenContentsSet(GetBrowserContext());
4338 for (auto* fullscreen_contents : fullscreen_set_copy) {
Avi Drissman97aef042020-06-30 21:04:484339 // Checking IsFullscreen() for tabs in the fullscreen set may seem
4340 // redundant, but teeeeechnically fullscreen is run by the delegate, and
4341 // it's possible that the delegate's notion of fullscreen may have changed
4342 // outside of WebContents's notice.
4343 if (fullscreen_contents->IsFullscreen()) {
Avi Drissman33972942020-06-19 14:16:014344 auto opener_contentses = GetAllOpeningWebContents(fullscreen_contents);
4345 if (opener_contentses.count(this))
4346 fullscreen_contents->ExitFullscreen(true);
4347 }
4348 }
4349
4350 // Second, walk upstream from this WebContents, and drop the fullscreen of
4351 // all WebContentses that are in fullscreen. Block all the WebContentses in
4352 // the chain from entering fullscreen while the returned closure runner is
4353 // alive. It's OK that this set doesn't contain downstream WebContentses, as
4354 // any request to enter fullscreen will have the upstream of the WebContents
4355 // checked. (See CanEnterFullscreenMode().)
Avi Drissmanced52b62019-08-14 21:25:464356
Avi Drissman1a55a9d62020-03-10 18:56:454357 std::vector<base::WeakPtr<WebContentsImpl>> blocked_contentses;
4358
Avi Drissman33972942020-06-19 14:16:014359 for (auto* opener : GetAllOpeningWebContents(this)) {
Avi Drissman1a55a9d62020-03-10 18:56:454360 // Drop fullscreen if the WebContents is in it, and...
Avi Drissman97aef042020-06-30 21:04:484361 if (opener->IsFullscreen())
Avi Drissman33972942020-06-19 14:16:014362 opener->ExitFullscreen(true);
Avi Drissmanced52b62019-08-14 21:25:464363
Avi Drissman1a55a9d62020-03-10 18:56:454364 // ...block the WebContents from entering fullscreen until further notice.
Avi Drissman33972942020-06-19 14:16:014365 ++opener->fullscreen_blocker_count_;
4366 blocked_contentses.push_back(opener->weak_factory_.GetWeakPtr());
Avi Drissmanced52b62019-08-14 21:25:464367 }
Avi Drissman1a55a9d62020-03-10 18:56:454368
4369 return base::ScopedClosureRunner(base::BindOnce(
4370 [](std::vector<base::WeakPtr<WebContentsImpl>> blocked_contentses) {
4371 for (base::WeakPtr<WebContentsImpl>& web_contents :
4372 blocked_contentses) {
4373 if (web_contents) {
4374 DCHECK_GT(web_contents->fullscreen_blocker_count_, 0);
4375 --web_contents->fullscreen_blocker_count_;
4376 }
4377 }
4378 },
4379 std::move(blocked_contentses)));
Avi Drissmanced52b62019-08-14 21:25:464380}
4381
mariakhomenko44bdc4732015-04-29 01:55:384382void WebContentsImpl::ResumeLoadingCreatedWebContents() {
Nasko Oskov83a8cf92018-10-19 14:58:564383 if (delayed_load_url_params_.get()) {
4384 DCHECK(!delayed_open_url_params_);
4385 controller_.LoadURLWithParams(*delayed_load_url_params_.get());
4386 delayed_load_url_params_.reset(nullptr);
4387 return;
4388 }
4389
mariakhomenkoa4971c12015-07-21 19:04:374390 if (delayed_open_url_params_.get()) {
4391 OpenURL(*delayed_open_url_params_.get());
4392 delayed_open_url_params_.reset(nullptr);
4393 return;
4394 }
4395
mariakhomenko44bdc4732015-04-29 01:55:384396 // Resume blocked requests for both the RenderViewHost and RenderFrameHost.
4397 // TODO(brettw): It seems bogus to reach into here and initialize the host.
dfalcantarae6b7b46752015-07-10 18:14:164398 if (is_resume_pending_) {
4399 is_resume_pending_ = false;
avi0f1bbc9712015-11-17 02:58:134400 GetRenderViewHost()->GetWidget()->Init();
dfalcantarae6b7b46752015-07-10 18:14:164401 GetMainFrame()->Init();
4402 }
mariakhomenko44bdc4732015-04-29 01:55:384403}
4404
[email protected]b172aee2012-04-10 17:05:264405bool WebContentsImpl::FocusLocationBarByDefault() {
Xiyuan Xia2a66b112018-12-06 15:52:164406 if (should_focus_location_bar_by_default_)
[email protected]0c9406632013-02-08 01:13:334407 return true;
Xiyuan Xia2a66b112018-12-06 15:52:164408
[email protected]0c9406632013-02-08 01:13:334409 return delegate_ && delegate_->ShouldFocusLocationBarByDefault(this);
[email protected]0bfbf882011-12-22 18:19:274410}
4411
Tommy C. Li8bb5bf42019-01-18 18:45:514412void WebContentsImpl::SetFocusToLocationBar() {
[email protected]0bfbf882011-12-22 18:19:274413 if (delegate_)
Tommy C. Li8bb5bf42019-01-18 18:45:514414 delegate_->SetFocusToLocationBar();
[email protected]c40d6232011-03-25 00:16:214415}
4416
clamy0e119882015-07-31 16:12:334417void WebContentsImpl::DidStartNavigation(NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484418 TRACE_EVENT1("navigation", "WebContentsImpl::DidStartNavigation",
4419 "navigation_handle", navigation_handle);
Alan Cutterab48fc02020-02-24 12:26:424420 if (navigation_handle->IsInMainFrame())
4421 favicon_urls_.clear();
Mounir Lamouri7b4a1f232019-12-23 16:32:104422
ericwilligersde386342016-10-19 02:35:094423 for (auto& observer : observers_)
4424 observer.DidStartNavigation(navigation_handle);
Becca Hughesd11d6502018-07-31 17:01:284425
Xiyuan Xia2a66b112018-12-06 15:52:164426 if (navigation_handle->IsInMainFrame()) {
4427 // When the browser is started with about:blank as the startup URL, focus
4428 // the location bar (which will also select its contents) so people can
4429 // simply begin typing to navigate elsewhere.
4430 //
4431 // We need to be careful not to trigger this for anything other than the
4432 // startup navigation. In particular, if we allow an attacker to open a
4433 // popup to about:blank, then navigate, focusing the Omnibox will cause the
4434 // end of the new URL to be scrolled into view instead of the start,
4435 // allowing the attacker to spoof other URLs. The conditions checked here
4436 // are all aimed at ensuring no such attacker-controlled navigation can
4437 // trigger this.
4438 should_focus_location_bar_by_default_ =
4439 controller_.IsInitialNavigation() &&
4440 !navigation_handle->IsRendererInitiated() &&
4441 navigation_handle->GetURL() == url::kAboutBlankURL;
4442 }
clamy0e119882015-07-31 16:12:334443}
4444
4445void WebContentsImpl::DidRedirectNavigation(
4446 NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484447 TRACE_EVENT1("navigation", "WebContentsImpl::DidRedirectNavigation",
4448 "navigation_handle", navigation_handle);
ericwilligersde386342016-10-19 02:35:094449 for (auto& observer : observers_)
4450 observer.DidRedirectNavigation(navigation_handle);
jam5f358e52017-02-13 16:37:034451
4452 // Notify accessibility if this is a reload. This has to called on the
4453 // BrowserAccessibilityManager associated with the old RFHI.
4454 if (navigation_handle->GetReloadType() != ReloadType::NONE) {
Mohamed Abdelhalim95794962019-09-20 11:16:494455 NavigationRequest* request = NavigationRequest::From(navigation_handle);
jam5f358e52017-02-13 16:37:034456 BrowserAccessibilityManager* manager =
Mohamed Abdelhalim95794962019-09-20 11:16:494457 request->frame_tree_node()
jam5f358e52017-02-13 16:37:034458 ->current_frame_host()
4459 ->browser_accessibility_manager();
4460 if (manager)
4461 manager->UserIsReloading();
4462 }
clamy0e119882015-07-31 16:12:334463}
4464
clamyefca29e2015-09-17 00:22:114465void WebContentsImpl::ReadyToCommitNavigation(
4466 NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484467 TRACE_EVENT1("navigation", "WebContentsImpl::ReadyToCommitNavigation",
4468 "navigation_handle", navigation_handle);
ericwilligersde386342016-10-19 02:35:094469 for (auto& observer : observers_)
4470 observer.ReadyToCommitNavigation(navigation_handle);
John Abd-El-Malekd4882642017-12-04 21:45:194471
Kenneth Russell954ed9ce2018-04-12 23:07:014472 // If any domains are blocked from accessing 3D APIs because they may
4473 // have caused the GPU to reset recently, unblock them here if the user
4474 // initiated this navigation. This implies that the user was involved in
4475 // the decision to navigate, so there's no concern about
4476 // denial-of-service issues. Want to do this as early as
4477 // possible to avoid race conditions with pages attempting to access
4478 // WebGL early on.
4479 //
4480 // TODO(crbug.com/617904): currently navigations initiated by the browser
4481 // (reload button, reload menu option, pressing return in the Omnibox)
4482 // return false from HasUserGesture(). If or when that is addressed,
4483 // remove the check for IsRendererInitiated() below.
4484 //
4485 // TODO(crbug.com/832180): HasUserGesture comes from the renderer
4486 // process and isn't validated. Until it is, don't trust it.
4487 if (!navigation_handle->IsRendererInitiated()) {
4488 GpuDataManagerImpl::GetInstance()->UnblockDomainFrom3DAPIs(
4489 navigation_handle->GetURL());
4490 }
4491
John Abd-El-Malekfde08e6da2017-12-05 04:06:244492 if (navigation_handle->IsSameDocument())
4493 return;
4494
Livvie Lin139bf442018-08-10 00:18:544495 // SSLInfo is not needed on subframe navigations since the main-frame
4496 // certificate is the only one that can be inspected (using the info
4497 // bubble) without refreshing the page with DevTools open.
Carlos ILaed1e7b2019-03-12 19:27:214498 // We don't call DidStartResourceResponse on net errors, since that results on
4499 // existing cert exceptions being revoked, which leads to weird behavior with
4500 // committed interstitials or while offline. We only need the error check for
4501 // the main frame case because unlike this method, SubresourceResponseStarted
4502 // does not get called on network errors.
4503 if (navigation_handle->IsInMainFrame() &&
4504 navigation_handle->GetNetErrorCode() == net::OK) {
Livvie Lin139bf442018-08-10 00:18:544505 controller_.ssl_manager()->DidStartResourceResponse(
Lukasz Anforowiczd334bba2020-02-10 23:32:554506 navigation_handle->GetURL(),
Camille Lamy62b826012019-02-26 09:15:474507 navigation_handle->GetSSLInfo().has_value()
4508 ? net::IsCertStatusError(
4509 navigation_handle->GetSSLInfo()->cert_status)
4510 : false);
4511 }
John Abd-El-Malekfde08e6da2017-12-05 04:06:244512
4513 SetNotWaitingForResponse();
clamyefca29e2015-09-17 00:22:114514}
4515
clamy0e119882015-07-31 16:12:334516void WebContentsImpl::DidFinishNavigation(NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484517 TRACE_EVENT1("navigation", "WebContentsImpl::DidFinishNavigation",
4518 "navigation_handle", navigation_handle);
Steven Holte38041342018-06-22 22:00:574519
ericwilligersde386342016-10-19 02:35:094520 for (auto& observer : observers_)
4521 observer.DidFinishNavigation(navigation_handle);
clamy0e119882015-07-31 16:12:334522
Becca Hughesd11d6502018-07-31 17:01:284523 if (display_cutout_host_impl_)
4524 display_cutout_host_impl_->DidFinishNavigation(navigation_handle);
4525
jam5f358e52017-02-13 16:37:034526 if (navigation_handle->HasCommitted()) {
Ian Prestcdd843d2020-01-28 18:59:584527 // TODO(domfarolino, dmazzoni): Do this using WebContentsObserver. See
4528 // https://crbug.com/981271.
4529 BrowserAccessibilityManager* manager =
4530 static_cast<RenderFrameHostImpl*>(
4531 navigation_handle->GetRenderFrameHost())
4532 ->browser_accessibility_manager();
4533 if (manager) {
4534 if (navigation_handle->IsErrorPage()) {
4535 manager->NavigationFailed();
4536 } else {
4537 manager->NavigationSucceeded();
4538 }
4539 }
4540
Yue Ru Sun979c4b162019-11-06 16:11:044541 if (navigation_handle->IsInMainFrame()) {
4542 last_committed_source_id_including_same_document_ =
Steven Holte38041342018-06-22 22:00:574543 ukm::ConvertToSourceId(navigation_handle->GetNavigationId(),
4544 ukm::SourceIdType::NAVIGATION_ID);
Yue Ru Sun979c4b162019-11-06 16:11:044545
4546 if (!navigation_handle->IsSameDocument()) {
4547 was_ever_audible_ = false;
Yue Ru Sun979c4b162019-11-06 16:11:044548 }
Tommy Steimel18360512017-11-01 00:38:194549 }
Lan Weif81c6e7c2020-02-12 16:46:094550
4551 if (!navigation_handle->IsSameDocument())
4552 last_screen_orientation_change_time_ = base::TimeTicks();
dmazzonibf8cec42015-02-08 08:28:084553 }
Xiyuan Xia2a66b112018-12-06 15:52:164554
4555 // If we didn't end up on about:blank after setting this in DidStartNavigation
4556 // then don't focus the location bar.
4557 if (should_focus_location_bar_by_default_ &&
4558 navigation_handle->GetURL() != url::kAboutBlankURL) {
4559 should_focus_location_bar_by_default_ = false;
4560 }
yilkal796e89e2019-10-02 23:58:284561
yilkal172da772019-11-06 22:49:074562 if (navigation_handle->IsInMainFrame() && first_navigation_completed_)
4563 RecordMaxFrameCountUMA(max_loaded_frame_count_);
yilkal796e89e2019-10-02 23:58:284564
yilkal172da772019-11-06 22:49:074565 // If navigation has successfully finished in the main frame, set
4566 // |first_navigation_completed_| to true so that we will record
4567 // |max_loaded_frame_count_| above when future main frame navigations finish.
4568 if (navigation_handle->IsInMainFrame() && !navigation_handle->IsErrorPage()) {
4569 first_navigation_completed_ = true;
4570
4571 // Navigation has completed in main frame. Reset |max_loaded_frame_count_|.
4572 // |max_loaded_frame_count_| is not necessarily 1 if the navigation was
4573 // served from BackForwardCache.
4574 max_loaded_frame_count_ =
4575 GetMainFrame()->frame_tree_node()->GetFrameTreeSize();
yilkal796e89e2019-10-02 23:58:284576 }
[email protected]400992b2012-06-14 00:03:544577}
4578
[email protected]b80624c2014-02-09 02:46:554579void WebContentsImpl::DidFailLoadWithError(
4580 RenderFrameHostImpl* render_frame_host,
[email protected]b80624c2014-02-09 02:46:554581 const GURL& url,
Dave Tapuska924ef3c2020-01-22 18:20:594582 int error_code) {
ericwilligersde386342016-10-19 02:35:094583 for (auto& observer : observers_) {
Dave Tapuska924ef3c2020-01-22 18:20:594584 observer.DidFailLoad(render_frame_host, url, error_code);
ericwilligersde386342016-10-19 02:35:094585 }
[email protected]b80624c2014-02-09 02:46:554586}
4587
[email protected]52913802013-12-10 05:52:184588void WebContentsImpl::NotifyChangedNavigationState(
4589 InvalidateTypes changed_flags) {
4590 NotifyNavigationStateChanged(changed_flags);
4591}
4592
lukasza1d025732016-09-28 21:36:084593bool WebContentsImpl::ShouldTransferNavigation(bool is_main_frame_navigation) {
creis29460272015-12-16 04:38:224594 if (!delegate_)
4595 return true;
lukasza1d025732016-09-28 21:36:084596 return delegate_->ShouldTransferNavigation(is_main_frame_navigation);
creis29460272015-12-16 04:38:224597}
4598
[email protected]aa62afd2014-04-22 19:22:464599bool WebContentsImpl::ShouldPreserveAbortedURLs() {
4600 if (!delegate_)
4601 return false;
4602 return delegate_->ShouldPreserveAbortedURLs(this);
4603}
4604
[email protected]0d0f4c492014-04-02 06:42:574605void WebContentsImpl::DidNavigateMainFramePreCommit(
[email protected]5cfbddc2014-06-23 23:52:234606 bool navigation_is_within_page) {
[email protected]0d0f4c492014-04-02 06:42:574607 // Ensure fullscreen mode is exited before committing the navigation to a
4608 // different page. The next page will not start out assuming it is in
4609 // fullscreen mode.
[email protected]5cfbddc2014-06-23 23:52:234610 if (navigation_is_within_page) {
[email protected]dfc39cb2014-04-09 22:58:194611 // No page change? Then, the renderer and browser can remain in fullscreen.
[email protected]0d0f4c492014-04-02 06:42:574612 return;
4613 }
Avi Drissman97aef042020-06-30 21:04:484614 if (IsFullscreen())
bokanece34a82016-01-28 19:49:464615 ExitFullscreen(false);
Avi Drissman97aef042020-06-30 21:04:484616 DCHECK(!IsFullscreen());
Joe Downingc1a57efe2018-05-09 18:23:544617
4618 // Clean up keyboard lock state when navigating.
4619 CancelKeyboardLock(keyboard_lock_widget_);
[email protected]0d0f4c492014-04-02 06:42:574620}
4621
[email protected]37567b432014-02-12 01:12:224622void WebContentsImpl::DidNavigateMainFramePostCommit(
sky8b00392d2015-01-10 00:30:284623 RenderFrameHostImpl* render_frame_host,
[email protected]37567b432014-02-12 01:12:224624 const LoadCommittedDetails& details,
4625 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
4626 if (details.is_navigation_to_different_page()) {
4627 // Clear the status bubble. This is a workaround for a bug where WebKit
4628 // doesn't let us know that the cursor left an element during a
4629 // transition (this is also why the mouse cursor remains as a hand after
4630 // clicking on a link); see bugs 1184641 and 980803. We don't want to
4631 // clear the bubble when a user navigates to a named anchor in the same
4632 // page.
Lukasz Anforowiczfd707142018-02-07 19:46:134633 ClearTargetURL();
lanwei9d343ad22015-02-11 01:46:004634
4635 RenderWidgetHostViewBase* rwhvb =
4636 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
4637 if (rwhvb)
4638 rwhvb->OnDidNavigateMainFrameToNewPage();
[email protected]37567b432014-02-12 01:12:224639 }
4640
[email protected]e85165c642014-06-10 14:34:314641 if (delegate_)
[email protected]37567b432014-02-12 01:12:224642 delegate_->DidNavigateMainFramePostCommit(this);
[email protected]e85165c642014-06-10 14:34:314643 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
Shivani Sharma985474f2019-05-23 21:36:474644
Carlos Caballero91fffb22019-10-29 15:24:304645 if (details.is_navigation_to_different_page() &&
4646 GetRenderViewHost()->did_first_visually_non_empty_paint()) {
4647 // This event will not fire again if the page is restored from the
4648 // BackForwardCache. So fire it ourselves if needed.
4649 DidFirstVisuallyNonEmptyPaint(GetRenderViewHost());
4650 }
Carlos Caballero1215f882019-10-29 15:58:434651
4652 if (GetRenderViewHost()->theme_color() != last_sent_theme_color_) {
4653 // This event will not fire again if the page is restored from the
4654 // BackForwardCache. So fire it ourselves if needed.
4655 OnThemeColorChanged(GetRenderViewHost());
4656 }
[email protected]37567b432014-02-12 01:12:224657}
4658
4659void WebContentsImpl::DidNavigateAnyFramePostCommit(
4660 RenderFrameHostImpl* render_frame_host,
4661 const LoadCommittedDetails& details,
4662 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
[email protected]b4c84012014-04-28 19:51:104663 // Now that something has committed, we don't need to track whether the
4664 // initial page has been accessed.
4665 has_accessed_initial_document_ = false;
4666
[email protected]37567b432014-02-12 01:12:224667 // If we navigate off the page, close all JavaScript dialogs.
eugenebutee08663a2017-04-27 17:43:124668 if (!details.is_same_document)
creis89a0f782015-05-27 16:13:174669 CancelActiveAndPendingDialogs();
[email protected]37567b432014-02-12 01:12:224670
avid53461d2016-02-25 17:15:044671 // If this is a user-initiated navigation, start allowing JavaScript dialogs
4672 // again.
avi5d3b8692016-10-12 22:00:464673 if (params.gesture == NavigationGestureUser && dialog_manager_) {
avi6879fcf2017-01-21 05:27:534674 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:464675 }
[email protected]37567b432014-02-12 01:12:224676}
4677
[email protected]277857a2014-06-03 10:38:014678bool WebContentsImpl::CanOverscrollContent() const {
[email protected]e85165c642014-06-10 14:34:314679 // Disable overscroll when touch emulation is on. See crbug.com/369938.
[email protected]34ff1cfc2014-08-20 06:16:054680 if (force_disable_overscroll_content_)
[email protected]e85165c642014-06-10 14:34:314681 return false;
4682
[email protected]37567b432014-02-12 01:12:224683 if (delegate_)
4684 return delegate_->CanOverscrollContent();
4685
4686 return false;
4687}
4688
Carlos Caballero1215f882019-10-29 15:58:434689void WebContentsImpl::OnThemeColorChanged(RenderViewHostImpl* source) {
4690 if (source->did_first_visually_non_empty_paint() &&
4691 last_sent_theme_color_ != source->theme_color()) {
ericwilligersde386342016-10-19 02:35:094692 for (auto& observer : observers_)
Peter Kastingb14e5782020-01-06 23:55:044693 observer.DidChangeThemeColor();
Carlos Caballero1215f882019-10-29 15:58:434694 last_sent_theme_color_ = source->theme_color();
peter90afaba2015-06-01 12:05:294695 }
[email protected]e7104762014-06-20 19:17:254696}
4697
Gyuyoung Kim1905f7c2020-05-02 00:00:244698void WebContentsImpl::DidLoadResourceFromMemoryCache(
nicka0ac8382016-12-15 23:59:234699 RenderFrameHostImpl* source,
[email protected]724159a2010-12-30 01:11:184700 const GURL& url,
[email protected]70435962011-08-02 20:13:284701 const std::string& http_method,
[email protected]6d6cfb3a2012-05-23 22:53:184702 const std::string& mime_type,
Kinuko Yasuda433f710a2020-02-14 02:11:584703 network::mojom::RequestDestination request_destination) {
ericwilligersde386342016-10-19 02:35:094704 for (auto& observer : observers_)
Kinuko Yasuda433f710a2020-02-14 02:11:584705 observer.DidLoadResourceFromMemoryCache(url, mime_type,
4706 request_destination);
[email protected]b0f724c2013-09-05 04:21:134707
Steven Bingler674fb0822018-12-12 18:04:524708 if (url.is_valid() && url.SchemeIsHTTPOrHTTPS()) {
nicka0ac8382016-12-15 23:59:234709 StoragePartition* partition = source->GetProcess()->GetStoragePartition();
John Abd-El-Malekf4fe9d82019-07-31 04:05:594710 partition->GetNetworkContext()->NotifyExternalCacheHit(
Matt Menke2a33dee2019-12-02 17:01:544711 url, http_method, source->GetNetworkIsolationKey());
[email protected]8bfc8272013-09-09 20:10:534712 }
[email protected]724159a2010-12-30 01:11:184713}
4714
carloskd9d97942017-02-16 08:58:094715void WebContentsImpl::DidDisplayInsecureContent() {
estarkc2273502016-10-12 22:03:024716 controller_.ssl_manager()->DidDisplayMixedContent();
[email protected]724159a2010-12-30 01:11:184717}
4718
Dave Tapuskaa657d872019-10-21 20:23:214719void WebContentsImpl::DidContainInsecureFormAction() {
elawrenceb2ac2a232017-03-27 21:46:254720 controller_.ssl_manager()->DidContainInsecureFormAction();
4721}
4722
Julie Jeongeun Kim0b103492020-01-29 05:30:514723void WebContentsImpl::DocumentAvailableInMainFrame() {
4724 for (auto& observer : observers_)
4725 observer.DocumentAvailableInMainFrame();
4726}
4727
nicka0ac8382016-12-15 23:59:234728void WebContentsImpl::OnDidRunInsecureContent(RenderFrameHostImpl* source,
4729 const GURL& security_origin,
estark910b4572015-12-09 20:55:414730 const GURL& target_url) {
nicka0ac8382016-12-15 23:59:234731 // TODO(nick, estark): Should we call FilterURL using |source|'s process on
4732 // these parameters? |target_url| seems unused, except for a log message. And
4733 // |security_origin| might be replaceable with the origin of the main frame.
carloskd9d97942017-02-16 08:58:094734 DidRunInsecureContent(security_origin, target_url);
4735}
4736
4737void WebContentsImpl::DidRunInsecureContent(const GURL& security_origin,
4738 const GURL& target_url) {
[email protected]9450c462013-11-23 01:22:584739 LOG(WARNING) << security_origin << " ran insecure content from "
4740 << target_url.possibly_invalid_spec();
[email protected]e6e30ac2014-01-13 21:24:394741 RecordAction(base::UserMetricsAction("SSL.RanInsecureContent"));
estark910b4572015-12-09 20:55:414742 if (base::EndsWith(security_origin.spec(), kDotGoogleDotCom,
brettwa7ff1b292015-07-16 17:49:294743 base::CompareCase::INSENSITIVE_ASCII))
[email protected]e6e30ac2014-01-13 21:24:394744 RecordAction(base::UserMetricsAction("SSL.RanInsecureContentGoogle"));
estarkc2273502016-10-12 22:03:024745 controller_.ssl_manager()->DidRunMixedContent(security_origin);
[email protected]724159a2010-12-30 01:11:184746}
4747
carloskd9d97942017-02-16 08:58:094748void WebContentsImpl::PassiveInsecureContentFound(const GURL& resource_url) {
Sergey Kuznetsov3ebc01b2018-02-01 04:57:364749 if (delegate_) {
4750 delegate_->PassiveInsecureContentFound(resource_url);
4751 }
carloskd9d97942017-02-16 08:58:094752}
4753
4754bool WebContentsImpl::ShouldAllowRunningInsecureContent(
carloskd9d97942017-02-16 08:58:094755 bool allowed_per_prefs,
4756 const url::Origin& origin,
4757 const GURL& resource_url) {
Sergey Kuznetsov3ebc01b2018-02-01 04:57:364758 if (delegate_) {
Carlos IL29294a62020-05-15 00:21:164759 return delegate_->ShouldAllowRunningInsecureContent(this, allowed_per_prefs,
4760 origin, resource_url);
Sergey Kuznetsov3ebc01b2018-02-01 04:57:364761 }
4762
4763 return allowed_per_prefs;
carloskd9d97942017-02-16 08:58:094764}
4765
Lukasz Anforowicze1b954d92017-10-30 21:28:064766void WebContentsImpl::ViewSource(RenderFrameHostImpl* frame) {
4767 DCHECK_EQ(this, WebContents::FromRenderFrameHost(frame));
4768
4769 // Don't do anything if there is no |delegate_| that could accept and show the
4770 // new WebContents containing the view-source.
4771 if (!delegate_)
4772 return;
4773
4774 // Use the last committed entry, since the pending entry hasn't loaded yet and
4775 // won't be copied into the cloned tab.
4776 NavigationEntryImpl* last_committed_entry =
Fergal Daly09d6c762020-05-29 02:05:184777 GetController().GetLastCommittedEntry();
Lukasz Anforowicze1b954d92017-10-30 21:28:064778 if (!last_committed_entry)
4779 return;
4780
4781 FrameNavigationEntry* frame_entry =
4782 last_committed_entry->GetFrameEntry(frame->frame_tree_node());
4783 if (!frame_entry)
4784 return;
4785
4786 // Any new WebContents opened while this WebContents is in fullscreen can be
4787 // used to confuse the user, so drop fullscreen.
Avi Drissman1a55a9d62020-03-10 18:56:454788 base::ScopedClosureRunner fullscreen_block = ForSecurityDropFullscreen();
4789 // The new view source contents will be independent of this contents, so
4790 // release the fullscreen block.
4791 fullscreen_block.RunAndReset();
Lukasz Anforowicze1b954d92017-10-30 21:28:064792
4793 // We intentionally don't share the SiteInstance with the original frame so
4794 // that view source has a consistent process model and always ends up in a new
4795 // process (https://crbug.com/699493).
4796 scoped_refptr<SiteInstanceImpl> site_instance_for_view_source = nullptr;
Lukasz Anforowicz435bcb582019-07-12 20:50:064797 // Referrer and initiator are not important, because view-source should not
4798 // hit the network, but should be served from the cache instead.
Lukasz Anforowicze1b954d92017-10-30 21:28:064799 Referrer referrer_for_view_source;
Lukasz Anforowicz435bcb582019-07-12 20:50:064800 base::Optional<url::Origin> initiator_for_view_source = base::nullopt;
Lukasz Anforowicze1b954d92017-10-30 21:28:064801 // Do not restore title, derive it from the url.
4802 base::string16 title_for_view_source;
4803 auto navigation_entry = std::make_unique<NavigationEntryImpl>(
4804 site_instance_for_view_source, frame_entry->url(),
Lukasz Anforowicz435bcb582019-07-12 20:50:064805 referrer_for_view_source, initiator_for_view_source,
4806 title_for_view_source, ui::PAGE_TRANSITION_LINK,
Marijn Kruisselbrink7a0d5e182018-05-24 22:55:094807 /* is_renderer_initiated = */ false,
4808 /* blob_url_loader_factory = */ nullptr);
Joel Hockey891e88062020-04-30 05:38:444809 const GURL url(content::kViewSourceScheme + std::string(":") +
4810 frame_entry->url().spec());
4811 navigation_entry->SetVirtualURL(url);
Matt Menkea56c5992020-04-10 20:53:564812 navigation_entry->set_isolation_info(
4813 frame->GetIsolationInfoForSubresources());
Yao Xiaof68f57d2019-10-03 04:20:054814
Lukasz Anforowicze1b954d92017-10-30 21:28:064815 // Do not restore scroller position.
4816 // TODO(creis, lukasza, arthursonzogni): Do not reuse the original PageState,
4817 // but start from a new one and only copy the needed data.
4818 const PageState& new_page_state =
4819 frame_entry->page_state().RemoveScrollOffset();
4820
4821 scoped_refptr<FrameNavigationEntry> new_frame_entry =
4822 navigation_entry->root_node()->frame_entry;
4823 new_frame_entry->set_method(frame_entry->method());
4824 new_frame_entry->SetPageState(new_page_state);
4825
4826 // Create a new WebContents, which is used to display the source code.
erikchenbee5c9622018-04-27 19:30:254827 std::unique_ptr<WebContents> view_source_contents =
Erik Chenbb8e738e2018-04-28 14:10:434828 Create(CreateParams(GetBrowserContext()));
Lukasz Anforowicze1b954d92017-10-30 21:28:064829
4830 // Restore the previously created NavigationEntry.
4831 std::vector<std::unique_ptr<NavigationEntry>> navigation_entries;
4832 navigation_entries.push_back(std::move(navigation_entry));
4833 view_source_contents->GetController().Restore(0, RestoreType::CURRENT_SESSION,
4834 &navigation_entries);
4835
4836 // Add |view_source_contents| as a new tab.
4837 gfx::Rect initial_rect;
4838 constexpr bool kUserGesture = true;
4839 bool ignored_was_blocked;
Joel Hockey891e88062020-04-30 05:38:444840 delegate_->AddNewContents(this, std::move(view_source_contents), url,
Lukasz Anforowicze1b954d92017-10-30 21:28:064841 WindowOpenDisposition::NEW_FOREGROUND_TAB,
4842 initial_rect, kUserGesture, &ignored_was_blocked);
4843 // Note that the |delegate_| could have deleted |view_source_contents| during
4844 // AddNewContents method call.
4845}
4846
Lukasz Anforowiczd334bba2020-02-10 23:32:554847void WebContentsImpl::SubresourceResponseStarted(const GURL& url,
4848 net::CertStatus cert_status) {
4849 controller_.ssl_manager()->DidStartResourceResponse(url, cert_status);
Jay Civellid5904f02018-03-23 19:43:574850 SetNotWaitingForResponse();
4851}
4852
Jay Civelli116683f2018-03-27 19:56:234853void WebContentsImpl::ResourceLoadComplete(
Jay Civelli52a63302018-04-30 22:39:554854 RenderFrameHost* render_frame_host,
Clark DuVall36164bd2018-08-09 22:49:084855 const GlobalRequestID& request_id,
Minggang Wangee5af392020-02-05 02:55:284856 blink::mojom::ResourceLoadInfoPtr resource_load_info) {
John Abd-El-Malek9b8f7fa2017-12-04 23:52:254857 for (auto& observer : observers_) {
Clark DuVall36164bd2018-08-09 22:49:084858 observer.ResourceLoadComplete(render_frame_host, request_id,
4859 *resource_load_info);
John Abd-El-Malek9b8f7fa2017-12-04 23:52:254860 }
John Abd-El-Malekd4882642017-12-04 21:45:194861}
4862
Wei Li5bb659742018-02-14 03:07:584863void WebContentsImpl::PrintCrossProcessSubframe(
4864 const gfx::Rect& rect,
4865 int document_cookie,
4866 RenderFrameHost* subframe_host) {
Wei Li5c0b4d12018-03-22 15:05:224867 auto* outer_contents = GetOuterWebContents();
4868 if (outer_contents) {
4869 // When an extension or app page is printed, the content should be
4870 // composited with outer content, so the outer contents should handle the
4871 // print request.
4872 outer_contents->PrintCrossProcessSubframe(rect, document_cookie,
4873 subframe_host);
4874 return;
4875 }
4876
Wei Li5bb659742018-02-14 03:07:584877 // If there is no delegate such as in tests or during deletion, do nothing.
4878 if (!delegate_)
4879 return;
4880
4881 delegate_->PrintCrossProcessSubframe(this, rect, document_cookie,
4882 subframe_host);
4883}
4884
ckitagawa8695799b2020-02-05 16:08:494885void WebContentsImpl::CapturePaintPreviewOfCrossProcessSubframe(
4886 const gfx::Rect& rect,
4887 const base::UnguessableToken& guid,
4888 RenderFrameHost* render_frame_host) {
4889 if (!delegate_)
4890 return;
ckitagawac43ac982020-07-07 17:41:174891 delegate_->CapturePaintPreviewOfSubframe(this, rect, guid, render_frame_host);
ckitagawa8695799b2020-02-05 16:08:494892}
4893
rob.buis300b0872017-03-10 20:43:584894#if defined(OS_ANDROID)
4895base::android::ScopedJavaLocalRef<jobject>
4896WebContentsImpl::GetJavaRenderFrameHostDelegate() {
4897 return GetJavaWebContents();
4898}
4899#endif
4900
estark910b4572015-12-09 20:55:414901void WebContentsImpl::OnDidDisplayContentWithCertificateErrors(
Zhuoyu Qian4353f7f2018-01-08 05:33:004902 RenderFrameHostImpl* source) {
estarkc2273502016-10-12 22:03:024903 controller_.ssl_manager()->DidDisplayContentWithCertErrors();
estark910b4572015-12-09 20:55:414904}
4905
4906void WebContentsImpl::OnDidRunContentWithCertificateErrors(
Zhuoyu Qian4353f7f2018-01-08 05:33:004907 RenderFrameHostImpl* source) {
Emily Starkabbdd662020-06-05 02:40:134908 // For RenderFrameHosts that are inactive and going to be discarded, we can
4909 // disregard this message; there's no need to update the UI if the UI will
4910 // never be shown again.
4911 //
4912 // We still process this message for speculative RenderFrameHosts. This can
4913 // happen when a subframe's main resource has a certificate error. The
4914 // currently committed navigation entry will get marked as having run insecure
4915 // content and that will carry over to the navigation entry for the
4916 // speculative RFH when it commits.
4917 if (source->lifecycle_state() !=
4918 RenderFrameHostImpl::LifecycleState::kSpeculative &&
4919 source->IsInactiveAndDisallowReactivation()) {
estarkaeda1422016-05-10 02:31:124920 return;
Emily Starkabbdd662020-06-05 02:40:134921 }
estarkcd2e30c2016-08-12 06:51:154922 controller_.ssl_manager()->DidRunContentWithCertErrors(
Emily Starkabbdd662020-06-05 02:40:134923 source->GetMainFrame()->GetLastCommittedOrigin().GetURL());
estark910b4572015-12-09 20:55:414924}
4925
Kouhei Ueno97e0990d2019-09-25 02:57:274926void WebContentsImpl::DOMContentLoaded(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:094927 for (auto& observer : observers_)
Kouhei Uenof6e96242019-09-27 01:54:354928 observer.DOMContentLoaded(render_frame_host);
[email protected]724159a2010-12-30 01:11:184929}
4930
Gyuyoung Kim525e0c5d2020-03-09 15:04:194931void WebContentsImpl::OnDidFinishLoad(RenderFrameHost* render_frame_host,
nicka0ac8382016-12-15 23:59:234932 const GURL& url) {
[email protected]8b3af1e2014-01-24 13:29:124933 GURL validated_url(url);
Gyuyoung Kim525e0c5d2020-03-09 15:04:194934 render_frame_host->GetProcess()->FilterURL(false, &validated_url);
[email protected]028053d42014-03-05 22:20:374935
ericwilligersde386342016-10-19 02:35:094936 for (auto& observer : observers_)
Gyuyoung Kim525e0c5d2020-03-09 15:04:194937 observer.DidFinishLoad(render_frame_host, validated_url);
yilkal172da772019-11-06 22:49:074938
4939 size_t tree_size = frame_tree_.root()->GetFrameTreeSize();
4940 if (max_loaded_frame_count_ < tree_size)
4941 max_loaded_frame_count_ = tree_size;
4942
Gyuyoung Kim525e0c5d2020-03-09 15:04:194943 if (!render_frame_host->GetParent())
yilkal172da772019-11-06 22:49:074944 UMA_HISTOGRAM_COUNTS_1000("Navigation.MainFrame.FrameCount", tree_size);
[email protected]1a55c5be2011-11-29 11:36:314945}
4946
Dave Tapuska549baab2019-03-19 15:52:404947void WebContentsImpl::OnGoToEntryAtOffset(RenderFrameHostImpl* source,
Julie Jeongeun Kim144f8192020-01-18 06:59:034948 int32_t offset,
Dave Tapuska043b94a2019-09-10 14:14:354949 bool has_user_gesture) {
Arthur Sonzognia7d715a2018-09-20 16:11:134950 // Non-user initiated navigations coming from the renderer should be ignored
4951 // if there is an ongoing browser-initiated navigation.
4952 // See https://crbug.com/879965.
4953 // TODO(arthursonzogni): See if this should check for ongoing navigations in
4954 // the frame(s) affected by the session history navigation, rather than just
4955 // the main frame.
4956 if (!has_user_gesture) {
4957 NavigationRequest* ongoing_navigation_request =
4958 frame_tree_.root()->navigation_request();
4959 if (ongoing_navigation_request &&
4960 ongoing_navigation_request->browser_initiated()) {
4961 return;
4962 }
4963 }
4964
nicka0ac8382016-12-15 23:59:234965 // All frames are allowed to navigate the global history.
Dave Tapuska8bfd84c2019-03-26 20:47:164966 if (!delegate_ || delegate_->OnGoToEntryOffset(offset)) {
arthursonzognib93a4472020-04-10 07:38:004967 if (source->IsSandboxed(network::mojom::WebSandboxFlags::kTopNavigation)) {
Dave Tapuska8bfd84c2019-03-26 20:47:164968 // Keep track of whether this is a session history from a sandboxed iframe
4969 // with top level navigation disallowed.
4970 controller_.GoToOffsetInSandboxedFrame(offset,
4971 source->GetFrameTreeNodeId());
4972 } else {
4973 controller_.GoToOffset(offset);
4974 }
4975 }
[email protected]216813952011-05-19 22:21:264976}
4977
Dave Tapuska4c02911b2020-02-14 22:52:074978void WebContentsImpl::OnPageScaleFactorChanged(RenderFrameHostImpl* source,
nicka0ac8382016-12-15 23:59:234979 float page_scale_factor) {
mcnee336ea2c2017-05-23 22:50:594980#if !defined(OS_ANDROID)
4981 // While page scale factor is used on mobile, this PageScaleFactorIsOne logic
4982 // is only needed on desktop.
mcnee432e47d2015-11-09 19:37:464983 bool is_one = page_scale_factor == 1.f;
4984 if (is_one != page_scale_factor_is_one_) {
4985 page_scale_factor_is_one_ = is_one;
4986
4987 HostZoomMapImpl* host_zoom_map =
4988 static_cast<HostZoomMapImpl*>(HostZoomMap::GetForWebContents(this));
4989
nicka0ac8382016-12-15 23:59:234990 if (host_zoom_map) {
mcnee432e47d2015-11-09 19:37:464991 host_zoom_map->SetPageScaleFactorIsOneForView(
Dave Tapuska4c02911b2020-02-14 22:52:074992 source->GetProcess()->GetID(),
4993 source->GetRenderViewHost()->GetRoutingID(),
mcnee432e47d2015-11-09 19:37:464994 page_scale_factor_is_one_);
4995 }
4996 }
mcnee336ea2c2017-05-23 22:50:594997#endif // !defined(OS_ANDROID)
mcnee432e47d2015-11-09 19:37:464998
ericwilligersde386342016-10-19 02:35:094999 for (auto& observer : observers_)
5000 observer.OnPageScaleFactorChanged(page_scale_factor);
mcnee432e47d2015-11-09 19:37:465001}
5002
W. James MacLean62198672019-06-04 16:46:105003void WebContentsImpl::OnTextAutosizerPageInfoChanged(
Henrique Ferreiroba535472020-04-21 11:38:365004 RenderFrameHostImpl* source,
5005 blink::mojom::TextAutosizerPageInfoPtr page_info) {
W. James MacLean62198672019-06-04 16:46:105006 // Keep a copy of |page_info| in case we create a new RenderView before
5007 // the next update.
Henrique Ferreiroba535472020-04-21 11:38:365008 text_autosizer_page_info_.main_frame_width = page_info->main_frame_width;
5009 text_autosizer_page_info_.main_frame_layout_width =
5010 page_info->main_frame_layout_width;
5011 text_autosizer_page_info_.device_scale_adjustment =
5012 page_info->device_scale_adjustment;
W. James MacLean62198672019-06-04 16:46:105013 frame_tree_.root()->render_manager()->SendPageMessage(
5014 new PageMsg_UpdateTextAutosizerPageInfoForRemoteMainFrames(
Henrique Ferreiroba535472020-04-21 11:38:365015 MSG_ROUTING_NONE, text_autosizer_page_info_),
W. James MacLean62198672019-06-04 16:46:105016 source->GetSiteInstance());
5017}
5018
Kent Tamura8c9e0562018-11-06 07:02:195019void WebContentsImpl::EnumerateDirectory(
5020 RenderFrameHost* render_frame_host,
Kent Tamura3abb32d2020-07-02 00:23:015021 scoped_refptr<FileChooserImpl::FileSelectListenerImpl> listener,
Kent Tamura8c9e0562018-11-06 07:02:195022 const base::FilePath& directory_path) {
Avi Drissman1a55a9d62020-03-10 18:56:455023 // Any explicit focusing of another window while this WebContents is in
5024 // fullscreen can be used to confuse the user, so drop fullscreen.
5025 base::ScopedClosureRunner fullscreen_block = ForSecurityDropFullscreen();
5026 listener->SetFullscreenBlock(std::move(fullscreen_block));
5027
Kent Tamura8c9e0562018-11-06 07:02:195028 if (delegate_)
5029 delegate_->EnumerateDirectory(this, std::move(listener), directory_path);
5030 else
5031 listener->FileSelectionCanceled();
[email protected]3a29a6e2011-08-24 18:26:215032}
5033
Dave Tapuskaf9fc3122019-10-18 19:42:555034void WebContentsImpl::RegisterProtocolHandler(RenderFrameHostImpl* source,
5035 const std::string& protocol,
5036 const GURL& url,
5037 const base::string16& title,
5038 bool user_gesture) {
nicka0ac8382016-12-15 23:59:235039 // TODO(nick): Should we consider |source| here or pass it to the delegate?
5040 // TODO(nick): Do we need to apply FilterURL to |url|?
[email protected]e5f2de02012-07-20 22:15:435041 if (!delegate_)
5042 return;
5043
Raymes Khoury58373df2019-08-06 06:29:205044 if (!AreValidRegisterProtocolHandlerArguments(
5045 protocol, url, source->GetLastCommittedOrigin())) {
5046 ReceivedBadMessage(source->GetProcess(),
5047 bad_message::REGISTER_PROTOCOL_HANDLER_INVALID_URL);
[email protected]b9535422012-02-09 01:47:595048 return;
Raymes Khoury58373df2019-08-06 06:29:205049 }
[email protected]8f810632013-06-06 22:33:325050
[email protected]c125e532014-05-10 20:39:065051 delegate_->RegisterProtocolHandler(this, protocol, url, user_gesture);
[email protected]7d189022011-08-25 22:54:205052}
5053
Dave Tapuskaf9fc3122019-10-18 19:42:555054void WebContentsImpl::UnregisterProtocolHandler(RenderFrameHostImpl* source,
5055 const std::string& protocol,
5056 const GURL& url,
5057 bool user_gesture) {
nicka0ac8382016-12-15 23:59:235058 // TODO(nick): Should we consider |source| here or pass it to the delegate?
5059 // TODO(nick): Do we need to apply FilterURL to |url|?
[email protected]f5273e52014-07-14 16:30:205060 if (!delegate_)
5061 return;
5062
Raymes Khoury58373df2019-08-06 06:29:205063 if (!AreValidRegisterProtocolHandlerArguments(
5064 protocol, url, source->GetLastCommittedOrigin())) {
5065 ReceivedBadMessage(source->GetProcess(),
5066 bad_message::REGISTER_PROTOCOL_HANDLER_INVALID_URL);
[email protected]f5273e52014-07-14 16:30:205067 return;
Raymes Khoury58373df2019-08-06 06:29:205068 }
[email protected]f5273e52014-07-14 16:30:205069
5070 delegate_->UnregisterProtocolHandler(this, protocol, url, user_gesture);
5071}
5072
Marijn Kruisselbrink7f519672019-02-05 19:12:505073void WebContentsImpl::OnAppCacheAccessed(const GURL& manifest_url,
[email protected]b172aee2012-04-10 17:05:265074 bool blocked_by_policy) {
nicka0ac8382016-12-15 23:59:235075 // TODO(nick): Should we consider |source| here? Should we call FilterURL on
5076 // |manifest_url|?
5077
[email protected]7fc4bbb2011-09-08 21:23:105078 // Notify observers about navigation.
ericwilligersde386342016-10-19 02:35:095079 for (auto& observer : observers_)
5080 observer.AppCacheAccessed(manifest_url, blocked_by_policy);
[email protected]7fc4bbb2011-09-08 21:23:105081}
5082
Gyuyoung Kimc5f4ac12020-05-08 10:59:395083void WebContentsImpl::DomOperationResponse(const std::string& json_string) {
5084 // TODO(lukasza): The notification below should probably indicate which
5085 // RenderFrameHostImpl the message is coming from. This can enable tests to
5086 // talk to 2 frames at the same time, without being confused which frame a
5087 // given response comes from. See also a corresponding TODO in the
5088 // ExecuteScriptHelper in //content/public/test/browser_test_utils.cc
5089 NotificationService::current()->Notify(
5090 NOTIFICATION_DOM_OPERATION_RESPONSE, Source<WebContents>(this),
5091 Details<const std::string>(&json_string));
5092}
5093
Gyuyoung Kim4c50517842020-06-04 17:50:445094void WebContentsImpl::SavableResourceLinksResponse(
5095 RenderFrameHostImpl* source,
5096 const std::vector<GURL>& resources_list,
5097 blink::mojom::ReferrerPtr referrer,
5098 const std::vector<blink::mojom::SavableSubframePtr>& subframes) {
5099 save_package_->SavableResourceLinksResponse(source, resources_list,
5100 std::move(referrer), subframes);
5101}
5102
5103void WebContentsImpl::SavableResourceLinksError(RenderFrameHostImpl* source) {
5104 save_package_->SavableResourceLinksError(source);
5105}
5106
Alexander Timin17edc742020-04-23 18:22:185107void WebContentsImpl::OnServiceWorkerAccessed(
5108 RenderFrameHost* render_frame_host,
5109 const GURL& scope,
5110 AllowServiceWorkerResult allowed) {
5111 for (auto& observer : observers_) {
5112 observer.OnServiceWorkerAccessed(render_frame_host, scope, allowed);
5113 }
5114}
5115
5116void WebContentsImpl::OnServiceWorkerAccessed(
5117 NavigationHandle* navigation,
5118 const GURL& scope,
5119 AllowServiceWorkerResult allowed) {
5120 for (auto& observer : observers_) {
5121 observer.OnServiceWorkerAccessed(navigation, scope, allowed);
5122 }
5123}
5124
Miyoung Shincb6475a2019-11-09 10:49:455125void WebContentsImpl::OnColorChooserFactoryReceiver(
Julie Jeongeun Kim8e2879e2019-08-06 23:55:205126 mojo::PendingReceiver<blink::mojom::ColorChooserFactory> receiver) {
5127 color_chooser_factory_receivers_.Add(this, std::move(receiver));
Joel Hockey85b379d2017-12-11 10:42:135128}
5129
5130void WebContentsImpl::OpenColorChooser(
Julie Jeongeun Kim8e2879e2019-08-06 23:55:205131 mojo::PendingReceiver<blink::mojom::ColorChooser> chooser_receiver,
5132 mojo::PendingRemote<blink::mojom::ColorChooserClient> client,
[email protected]8ed16472014-04-11 19:02:485133 SkColor color,
Joel Hockey163835a2017-12-20 11:51:575134 std::vector<blink::mojom::ColorSuggestionPtr> suggestions) {
Joel Hockey85b379d2017-12-11 10:42:135135 content::ColorChooser* new_color_chooser =
Ivan Kotenkov2c0d2bb32017-11-01 15:41:285136 delegate_ ? delegate_->OpenColorChooser(this, color, suggestions)
5137 : nullptr;
[email protected]820957a2014-01-14 14:56:305138 if (!new_color_chooser)
[email protected]cb805452013-05-22 15:16:215139 return;
[email protected]8ed16472014-04-11 19:02:485140
Joel Hockey85b379d2017-12-11 10:42:135141 color_chooser_.reset();
5142 color_chooser_ = std::make_unique<ColorChooser>(
Julie Jeongeun Kim8e2879e2019-08-06 23:55:205143 new_color_chooser, std::move(chooser_receiver), std::move(client));
[email protected]da8543762012-03-20 08:52:205144}
5145
brettw4b461082016-11-19 18:55:165146#if BUILDFLAG(ENABLE_PLUGINS)
nicka0ac8382016-12-15 23:59:235147void WebContentsImpl::OnPepperInstanceCreated(RenderFrameHostImpl* source,
5148 int32_t pp_instance) {
ericwilligersde386342016-10-19 02:35:095149 for (auto& observer : observers_)
5150 observer.PepperInstanceCreated();
nicka0ac8382016-12-15 23:59:235151 pepper_playback_observer_->PepperInstanceCreated(source, pp_instance);
emaxxe70f5e12015-05-29 11:26:005152}
5153
nicka0ac8382016-12-15 23:59:235154void WebContentsImpl::OnPepperInstanceDeleted(RenderFrameHostImpl* source,
5155 int32_t pp_instance) {
ericwilligersde386342016-10-19 02:35:095156 for (auto& observer : observers_)
5157 observer.PepperInstanceDeleted();
nicka0ac8382016-12-15 23:59:235158 pepper_playback_observer_->PepperInstanceDeleted(source, pp_instance);
emaxxe70f5e12015-05-29 11:26:005159}
5160
nicka0ac8382016-12-15 23:59:235161void WebContentsImpl::OnPepperPluginHung(RenderFrameHostImpl* source,
5162 int plugin_child_id,
tommyclie6633ca72014-10-31 00:40:425163 const base::FilePath& path,
5164 bool is_hung) {
Steven Holte95922222018-09-14 20:06:235165 UMA_HISTOGRAM_COUNTS_1M("Pepper.PluginHung", 1);
tommyclie6633ca72014-10-31 00:40:425166
ericwilligersde386342016-10-19 02:35:095167 for (auto& observer : observers_)
5168 observer.PluginHungStatusChanged(plugin_child_id, path, is_hung);
tommyclie6633ca72014-10-31 00:40:425169}
5170
nicka0ac8382016-12-15 23:59:235171void WebContentsImpl::OnPepperStartsPlayback(RenderFrameHostImpl* source,
5172 int32_t pp_instance) {
5173 pepper_playback_observer_->PepperStartsPlayback(source, pp_instance);
zqzhang181047e62016-07-01 13:37:175174}
5175
nicka0ac8382016-12-15 23:59:235176void WebContentsImpl::OnPepperStopsPlayback(RenderFrameHostImpl* source,
5177 int32_t pp_instance) {
5178 pepper_playback_observer_->PepperStopsPlayback(source, pp_instance);
zqzhang181047e62016-07-01 13:37:175179}
5180
nicka0ac8382016-12-15 23:59:235181void WebContentsImpl::OnPluginCrashed(RenderFrameHostImpl* source,
5182 const base::FilePath& plugin_path,
tommyclie6633ca72014-10-31 00:40:425183 base::ProcessId plugin_pid) {
nicka0ac8382016-12-15 23:59:235184 // TODO(nick): Eliminate the |plugin_pid| parameter, which can't be trusted,
Gyuyoung Kim26c7bc92020-04-29 00:53:005185 // and is only used by WebTestControlHost.
ericwilligersde386342016-10-19 02:35:095186 for (auto& observer : observers_)
5187 observer.PluginCrashed(plugin_path, plugin_pid);
tommyclie6633ca72014-10-31 00:40:425188}
5189
[email protected]d8415ad92012-08-23 14:40:505190void WebContentsImpl::OnRequestPpapiBrokerPermission(
nicka0ac8382016-12-15 23:59:235191 RenderViewHostImpl* source,
5192 int ppb_broker_route_id,
[email protected]d8415ad92012-08-23 14:40:505193 const GURL& url,
[email protected]2dec8ec2013-02-07 19:20:345194 const base::FilePath& plugin_path) {
Avi Drissman0a2a967d2019-04-01 19:33:525195 base::OnceCallback<void(bool)> permission_result_callback = base::BindOnce(
nicka0ac8382016-12-15 23:59:235196 &WebContentsImpl::SendPpapiBrokerPermissionResult, base::Unretained(this),
5197 source->GetProcess()->GetID(), ppb_broker_route_id);
[email protected]8c8fc292012-11-23 18:57:165198 if (!delegate_) {
Tommy Nyquist4b749d02018-03-20 21:46:295199 std::move(permission_result_callback).Run(false);
[email protected]8c8fc292012-11-23 18:57:165200 return;
[email protected]d8415ad92012-08-23 14:40:505201 }
5202
Avi Drissman0a2a967d2019-04-01 19:33:525203 delegate_->RequestPpapiBrokerPermission(
5204 this, url, plugin_path, std::move(permission_result_callback));
[email protected]d8415ad92012-08-23 14:40:505205}
5206
nicka0ac8382016-12-15 23:59:235207void WebContentsImpl::SendPpapiBrokerPermissionResult(int process_id,
5208 int ppb_broker_route_id,
5209 bool result) {
5210 RenderProcessHost* rph = RenderProcessHost::FromID(process_id);
5211 if (rph) {
5212 // TODO(nick): Convert this from ViewMsg_ to a Ppapi msg, since it
5213 // is not routed to a RenderView.
5214 rph->Send(
5215 new ViewMsg_PpapiBrokerPermissionResult(ppb_broker_route_id, result));
5216 }
[email protected]d8415ad92012-08-23 14:40:505217}
brettw4b461082016-11-19 18:55:165218#endif // BUILDFLAG(ENABLE_PLUGINS)
[email protected]19be7a62012-10-01 23:03:375219
Miyoung Shin5709ab02020-02-19 06:50:415220void WebContentsImpl::UpdateFaviconURL(
5221 RenderFrameHost* source,
5222 std::vector<blink::mojom::FaviconURLPtr> candidates) {
lukasza178ff092017-06-07 23:39:505223 // Ignore favicons for non-main frame.
5224 if (source->GetParent()) {
5225 NOTREACHED();
5226 return;
5227 }
5228
pkotwiczf9bc20592015-04-21 18:57:065229 // We get updated favicon URLs after the page stops loading. If a cross-site
5230 // navigation occurs while a page is still loading, the initial page
5231 // may stop loading and send us updated favicon URLs after the navigation
5232 // for the new page has committed.
lukasza178ff092017-06-07 23:39:505233 if (!source->IsCurrent())
pkotwiczf9bc20592015-04-21 18:57:065234 return;
5235
Miyoung Shin5709ab02020-02-19 06:50:415236 favicon_urls_ = std::move(candidates);
Mounir Lamouri7b4a1f232019-12-23 16:32:105237
ericwilligersde386342016-10-19 02:35:095238 for (auto& observer : observers_)
Yuzu Saijo0c263c702020-06-08 03:41:245239 observer.DidUpdateFaviconURL(source, favicon_urls_);
[email protected]795c28972012-12-06 06:13:395240}
5241
qinmin72e8bd02016-10-21 19:35:375242void WebContentsImpl::SetIsOverlayContent(bool is_overlay_content) {
5243 is_overlay_content_ = is_overlay_content;
5244}
5245
Albert J. Wongfb64e142018-10-16 01:10:455246void WebContentsImpl::DidFirstVisuallyNonEmptyPaint(
5247 RenderViewHostImpl* source) {
nicka0ac8382016-12-15 23:59:235248 // TODO(nick): When this is ported to FrameHostMsg_, we should only listen if
5249 // |source| is the main frame.
ericwilligersde386342016-10-19 02:35:095250 for (auto& observer : observers_)
5251 observer.DidFirstVisuallyNonEmptyPaint();
yusufod41c5f92015-03-06 00:14:285252
Carlos Caballero1215f882019-10-29 15:58:435253 if (source->theme_color() != last_sent_theme_color_) {
yusufod41c5f92015-03-06 00:14:285254 // Theme color should have updated by now if there was one.
ericwilligersde386342016-10-19 02:35:095255 for (auto& observer : observers_)
Peter Kastingb14e5782020-01-06 23:55:045256 observer.DidChangeThemeColor();
Carlos Caballero1215f882019-10-29 15:58:435257 last_sent_theme_color_ = source->theme_color();
yusufod41c5f92015-03-06 00:14:285258 }
[email protected]9f268072013-11-07 00:02:155259}
[email protected]d9030b82013-07-19 08:26:065260
Kevin McNee068c3eb2020-04-03 18:24:195261bool WebContentsImpl::IsPortal() {
Adithya Srinivasan46b8a792019-02-01 14:47:235262 return portal();
5263}
5264
Kevin McNee94ea52f52020-06-23 17:42:065265WebContentsImpl* WebContentsImpl::GetPortalHostWebContents() {
5266 return portal() ? portal()->GetPortalHostContents() : nullptr;
5267}
5268
[email protected]17e286e2013-03-01 23:29:395269void WebContentsImpl::NotifyBeforeFormRepostWarningShow() {
ericwilligersde386342016-10-19 02:35:095270 for (auto& observer : observers_)
5271 observer.BeforeFormRepostWarningShow();
[email protected]17e286e2013-03-01 23:29:395272}
5273
[email protected]ec6c05f2013-10-23 18:41:575274void WebContentsImpl::ActivateAndShowRepostFormWarningDialog() {
5275 Activate();
5276 if (delegate_)
5277 delegate_->ShowRepostFormWarningDialog(this);
5278}
5279
[email protected]b4c84012014-04-28 19:51:105280bool WebContentsImpl::HasAccessedInitialDocument() {
5281 return has_accessed_initial_document_;
5282}
5283
afakhry6f0c1ec22016-07-14 13:55:135284void WebContentsImpl::UpdateTitleForEntry(NavigationEntry* entry,
[email protected]fcf75d42013-12-03 20:11:265285 const base::string16& title) {
[email protected]fcf75d42013-12-03 20:11:265286 base::string16 final_title;
Avi Drissman93002212017-09-27 03:20:525287 base::TrimWhitespace(title, base::TRIM_ALL, &final_title);
[email protected]420ae012009-04-24 05:16:325288
[email protected]987fc3a2011-05-26 14:18:095289 // If a page is created via window.open and never navigated,
5290 // there will be no navigation entry. In this situation,
[email protected]73eb2602012-02-09 19:50:555291 // |page_title_when_no_navigation_entry_| will be used for page title.
[email protected]987fc3a2011-05-26 14:18:095292 if (entry) {
[email protected]36fc0392011-12-25 03:59:515293 if (final_title == entry->GetTitle())
afakhry6f0c1ec22016-07-14 13:55:135294 return; // Nothing changed, don't bother.
[email protected]420ae012009-04-24 05:16:325295
[email protected]36fc0392011-12-25 03:59:515296 entry->SetTitle(final_title);
Avi Drissman93002212017-09-27 03:20:525297
5298 // The title for display may differ from the title just set; grab it.
5299 final_title = entry->GetTitleForDisplay();
[email protected]987fc3a2011-05-26 14:18:095300 } else {
5301 if (page_title_when_no_navigation_entry_ == final_title)
afakhry6f0c1ec22016-07-14 13:55:135302 return; // Nothing changed, don't bother.
[email protected]987fc3a2011-05-26 14:18:095303
5304 page_title_when_no_navigation_entry_ = final_title;
5305 }
[email protected]420ae012009-04-24 05:16:325306
[email protected]420ae012009-04-24 05:16:325307 // Lastly, set the title for the view.
[email protected]790e2fd2011-09-21 20:28:235308 view_->SetPageTitle(final_title);
[email protected]420ae012009-04-24 05:16:325309
ericwilligersde386342016-10-19 02:35:095310 for (auto& observer : observers_)
Avi Drissman93002212017-09-27 03:20:525311 observer.TitleWasSet(entry);
[email protected]66798902013-10-01 18:40:165312
afakhry6f0c1ec22016-07-14 13:55:135313 // Broadcast notifications when the UI should be updated.
5314 if (entry == controller_.GetEntryAtOffset(0))
5315 NotifyNavigationStateChanged(INVALIDATE_TYPE_TITLE);
[email protected]420ae012009-04-24 05:16:325316}
5317
fdegansa696e5112015-04-17 01:57:595318void WebContentsImpl::SendChangeLoadProgress() {
[email protected]960b0372014-05-19 18:01:005319 loading_last_progress_update_ = base::TimeTicks::Now();
Evan Stade9f328112019-10-23 20:49:255320 for (auto& observer : observers_)
5321 observer.LoadProgressChanged(frame_tree_.load_progress());
[email protected]960b0372014-05-19 18:01:005322}
5323
5324void WebContentsImpl::ResetLoadProgressState() {
fdegans1d16355162015-03-26 11:58:345325 frame_tree_.ResetLoadProgress();
[email protected]960b0372014-05-19 18:01:005326 loading_weak_factory_.InvalidateWeakPtrs();
5327 loading_last_progress_update_ = base::TimeTicks();
5328}
5329
clamy44e84ce2016-02-22 15:38:255330// Notifies the RenderWidgetHost instance about the fact that the page is
5331// loading, or done loading.
5332void WebContentsImpl::LoadingStateChanged(bool to_different_document,
clamy44e84ce2016-02-22 15:38:255333 LoadNotificationDetails* details) {
Nate Chapin22ea6592019-03-05 22:29:025334 if (is_being_destroyed_)
5335 return;
clamy44e84ce2016-02-22 15:38:255336
5337 bool is_loading = IsLoading();
5338
5339 if (!is_loading) {
5340 load_state_ = net::LoadStateWithParam(net::LOAD_STATE_IDLE,
5341 base::string16());
5342 load_state_host_.clear();
5343 upload_size_ = 0;
5344 upload_position_ = 0;
5345 }
5346
5347 GetRenderManager()->SetIsLoading(is_loading);
5348
5349 waiting_for_response_ = is_loading;
5350 is_load_to_different_document_ = to_different_document;
5351
5352 if (delegate_)
5353 delegate_->LoadingStateChanged(this, to_different_document);
5354 NotifyNavigationStateChanged(INVALIDATE_TYPE_LOAD);
5355
5356 std::string url = (details ? details->url.possibly_invalid_spec() : "NULL");
5357 if (is_loading) {
5358 TRACE_EVENT_ASYNC_BEGIN2("browser,navigation", "WebContentsImpl Loading",
5359 this, "URL", url, "Main FrameTreeNode id",
5360 GetFrameTree()->root()->frame_tree_node_id());
ericwilligersde386342016-10-19 02:35:095361 for (auto& observer : observers_)
5362 observer.DidStartLoading();
clamy44e84ce2016-02-22 15:38:255363 } else {
5364 TRACE_EVENT_ASYNC_END1("browser,navigation", "WebContentsImpl Loading",
5365 this, "URL", url);
ericwilligersde386342016-10-19 02:35:095366 for (auto& observer : observers_)
5367 observer.DidStopLoading();
clamy44e84ce2016-02-22 15:38:255368 }
5369
5370 // TODO(avi): Remove. http://crbug.com/170921
5371 int type = is_loading ? NOTIFICATION_LOAD_START : NOTIFICATION_LOAD_STOP;
5372 NotificationDetails det = NotificationService::NoDetails();
5373 if (details)
5374 det = Details<LoadNotificationDetails>(details);
5375 NotificationService::current()->Notify(
5376 type, Source<NavigationController>(&controller_), det);
5377}
5378
danakja0bce4c952020-05-12 20:40:285379void WebContentsImpl::NotifyViewSwapped(RenderViewHost* old_view,
5380 RenderViewHost* new_view) {
5381 DCHECK_NE(old_view, new_view);
[email protected]420ae012009-04-24 05:16:325382 // After sending out a swap notification, we need to send a disconnect
5383 // notification so that clients that pick up a pointer to |this| can NULL the
5384 // pointer. See Bug 1230284.
5385 notify_disconnection_ = true;
ericwilligersde386342016-10-19 02:35:095386 for (auto& observer : observers_)
danakja0bce4c952020-05-12 20:40:285387 observer.RenderViewHostChanged(old_view, new_view);
[email protected]da7a7182013-09-06 08:11:115388
danakja0bce4c952020-05-12 20:40:285389 view_->RenderViewHostChanged(old_view, new_view);
Jinsuk Kimdc5284c22018-07-11 02:22:065390
Lucas Furukawa Gadanif9ea4fc2018-08-03 23:57:135391 // If this is an inner WebContents that has swapped views, we need to reattach
5392 // it to its outer WebContents.
5393 if (node_.outer_web_contents())
5394 ReattachToOuterWebContentsFrame();
5395
[email protected]7a846df2012-09-20 19:17:395396 // Ensure that the associated embedder gets cleared after a RenderViewHost
5397 // gets swapped, so we don't reuse the same embedder next time a
5398 // RenderViewHost is attached to this WebContents.
5399 RemoveBrowserPluginEmbedder();
[email protected]420ae012009-04-24 05:16:325400}
5401
danakja0bce4c952020-05-12 20:40:285402void WebContentsImpl::NotifyFrameSwapped(RenderFrameHost* old_frame,
5403 RenderFrameHost* new_frame,
Jinsuk Kim895b2c52018-07-03 06:49:165404 bool is_main_frame) {
Bo Liu168c8642017-08-28 18:26:025405#if defined(OS_ANDROID)
danakja0bce4c952020-05-12 20:40:285406 // Copy importance from |old_frame| if |new_frame| is a main frame.
5407 if (old_frame && !new_frame->GetParent()) {
5408 RenderWidgetHostImpl* old_widget =
5409 static_cast<RenderFrameHostImpl*>(old_frame)->GetRenderWidgetHost();
5410 RenderWidgetHostImpl* new_widget =
5411 static_cast<RenderFrameHostImpl*>(new_frame)->GetRenderWidgetHost();
5412 new_widget->SetImportance(old_widget->importance());
Bo Liu7c6779e92017-08-16 02:02:285413 }
Bo Liu168c8642017-08-28 18:26:025414#endif
ericwilligersde386342016-10-19 02:35:095415 for (auto& observer : observers_)
danakja0bce4c952020-05-12 20:40:285416 observer.RenderFrameHostChanged(old_frame, new_frame);
[email protected]02d7b6e2014-06-24 21:01:505417}
5418
[email protected]da7a7182013-09-06 08:11:115419// TODO(avi): Remove this entire function because this notification is already
5420// covered by two observer functions. http://crbug.com/170921
[email protected]b172aee2012-04-10 17:05:265421void WebContentsImpl::NotifyDisconnected() {
[email protected]420ae012009-04-24 05:16:325422 if (!notify_disconnection_)
5423 return;
5424
5425 notify_disconnection_ = false;
[email protected]8ff00d72012-10-23 19:12:215426 NotificationService::current()->Notify(
5427 NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
5428 Source<WebContents>(this),
5429 NotificationService::NoDetails());
[email protected]420ae012009-04-24 05:16:325430}
5431
[email protected]cbb1ef592013-06-05 19:49:465432void WebContentsImpl::NotifyNavigationEntryCommitted(
5433 const LoadCommittedDetails& load_details) {
ericwilligersde386342016-10-19 02:35:095434 for (auto& observer : observers_)
5435 observer.NavigationEntryCommitted(load_details);
[email protected]cbb1ef592013-06-05 19:49:465436}
5437
Sam McNally5c087a32017-08-25 01:46:145438void WebContentsImpl::NotifyNavigationEntryChanged(
5439 const EntryChangedDetails& change_details) {
5440 for (auto& observer : observers_)
5441 observer.NavigationEntryChanged(change_details);
5442}
5443
5444void WebContentsImpl::NotifyNavigationListPruned(
5445 const PrunedDetails& pruned_details) {
5446 for (auto& observer : observers_)
5447 observer.NavigationListPruned(pruned_details);
5448}
5449
Christian Dullweber1af31e62018-02-22 11:49:485450void WebContentsImpl::NotifyNavigationEntriesDeleted() {
5451 for (auto& observer : observers_)
5452 observer.NavigationEntriesDeleted();
5453}
5454
rockotf62002a2016-09-15 00:08:595455void WebContentsImpl::OnAssociatedInterfaceRequest(
5456 RenderFrameHost* render_frame_host,
5457 const std::string& interface_name,
5458 mojo::ScopedInterfaceEndpointHandle handle) {
Julie Jeongeun Kim7d0986172019-12-04 03:17:255459 auto it = receiver_sets_.find(interface_name);
5460 if (it != receiver_sets_.end())
5461 it->second->OnReceiverForFrame(render_frame_host, std::move(handle));
rockotf62002a2016-09-15 00:08:595462}
5463
Ben Goodger9e24929e2017-07-21 03:13:405464void WebContentsImpl::OnInterfaceRequest(
5465 RenderFrameHost* render_frame_host,
5466 const std::string& interface_name,
5467 mojo::ScopedMessagePipeHandle* interface_pipe) {
5468 for (auto& observer : observers_) {
5469 observer.OnInterfaceRequestFromFrame(render_frame_host, interface_name,
5470 interface_pipe);
5471 if (!interface_pipe->is_valid())
5472 break;
5473 }
5474}
5475
Varun Khaneja5da94302019-06-25 04:48:105476void WebContentsImpl::OnDidBlockNavigation(
5477 const GURL& blocked_url,
5478 const GURL& initiator_url,
Abhijeet Kandalkarde7348e2020-01-13 06:06:545479 blink::mojom::NavigationBlockedReason reason) {
Nicolas Dossou-gbetebcab2472017-09-09 12:28:405480 if (delegate_)
Varun Khaneja5da94302019-06-25 04:48:105481 delegate_->OnDidBlockNavigation(this, blocked_url, initiator_url, reason);
Nicolas Dossou-gbetebcab2472017-09-09 12:28:405482}
5483
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415484const GURL& WebContentsImpl::GetMainFrameLastCommittedURL() {
[email protected]c31a84802014-04-03 15:55:495485 return GetLastCommittedURL();
5486}
5487
[email protected]b849847b2013-12-10 21:57:585488void WebContentsImpl::RenderFrameCreated(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:095489 for (auto& observer : observers_)
5490 observer.RenderFrameCreated(render_frame_host);
dmazzonif8a31042016-12-03 00:52:135491 UpdateAccessibilityModeOnFrame(render_frame_host);
clamy91b7abf2016-03-24 15:17:455492
Becca Hughesd11d6502018-07-31 17:01:285493 if (display_cutout_host_impl_)
5494 display_cutout_host_impl_->RenderFrameCreated(render_frame_host);
5495
clamy91b7abf2016-03-24 15:17:455496 if (!render_frame_host->IsRenderFrameLive() || render_frame_host->GetParent())
5497 return;
5498
5499 NavigationEntry* entry = controller_.GetPendingEntry();
5500 if (entry && entry->IsViewSourceMode()) {
5501 // Put the renderer in view source mode.
Dave Tapuska3c05e1c2019-11-27 18:34:185502 static_cast<RenderFrameHostImpl*>(render_frame_host)
5503 ->GetAssociatedLocalFrame()
5504 ->EnableViewSourceMode();
clamy91b7abf2016-03-24 15:17:455505 }
[email protected]b849847b2013-12-10 21:57:585506}
5507
5508void WebContentsImpl::RenderFrameDeleted(RenderFrameHost* render_frame_host) {
yilkal172da772019-11-06 22:49:075509 if (IsBeingDestroyed() && !render_frame_host->GetParent() &&
5510 first_navigation_completed_ &&
Hajime Hoshibbc509c2020-04-06 08:55:085511 !render_frame_host->IsInBackForwardCache()) {
yilkal796e89e2019-10-02 23:58:285512 // Main frame has been deleted because WebContents is being destroyed.
Rakina Zata Amni74627df2019-10-15 02:03:175513 // Note that we aren't recording this here when the main frame is in the
5514 // back-forward cache because that means we've actually already navigated
5515 // away from it (and we got to this point because the WebContents is
yilkal172da772019-11-06 22:49:075516 // deleted), which means |max_loaded_frame_count_| is already overwritten.
5517 // The |max_loaded_frame_count_| value will instead be recorded from within
5518 // |WebContentsImpl::DidFinishNavigation()|.
5519 RecordMaxFrameCountUMA(max_loaded_frame_count_);
yilkal796e89e2019-10-02 23:58:285520 }
5521
creis3638897452017-05-09 22:07:505522 is_notifying_observers_ = true;
ericwilligersde386342016-10-19 02:35:095523 for (auto& observer : observers_)
5524 observer.RenderFrameDeleted(render_frame_host);
creis3638897452017-05-09 22:07:505525 is_notifying_observers_ = false;
zqzhang7b6f4f02016-12-07 22:10:225526#if BUILDFLAG(ENABLE_PLUGINS)
5527 pepper_playback_observer_->RenderFrameDeleted(render_frame_host);
5528#endif
Becca Hughesfd5d8f892018-06-14 18:23:365529
Becca Hughesd11d6502018-07-31 17:01:285530 if (display_cutout_host_impl_)
5531 display_cutout_host_impl_->RenderFrameDeleted(render_frame_host);
5532
Becca Hughesfd5d8f892018-06-14 18:23:365533 // Remove any fullscreen state that the frame has stored.
5534 FullscreenStateChanged(render_frame_host, false /* is_fullscreen */);
[email protected]b849847b2013-12-10 21:57:585535}
5536
[email protected]a09d53ce2014-01-31 00:46:425537void WebContentsImpl::ShowContextMenu(RenderFrameHost* render_frame_host,
5538 const ContextMenuParams& params) {
avie9fd8722017-04-10 16:17:585539 // If a renderer fires off a second command to show a context menu before the
5540 // first context menu is closed, just ignore it. https://crbug.com/707534
ekaramadf6750aa2017-06-06 18:29:425541 if (showing_context_menu_)
avie9fd8722017-04-10 16:17:585542 return;
5543
[email protected]077e704b2014-05-23 19:24:105544 ContextMenuParams context_menu_params(params);
[email protected]a09d53ce2014-01-31 00:46:425545 // Allow WebContentsDelegates to handle the context menu operation first.
Joel Klinghed0ea22ea2019-02-20 22:04:225546 if (delegate_ &&
5547 delegate_->HandleContextMenu(render_frame_host, context_menu_params))
[email protected]a09d53ce2014-01-31 00:46:425548 return;
5549
[email protected]077e704b2014-05-23 19:24:105550 render_view_host_delegate_view_->ShowContextMenu(render_frame_host,
5551 context_menu_params);
[email protected]a09d53ce2014-01-31 00:46:425552}
5553
Avi Drissman4891b852018-09-25 18:12:585554namespace {
5555// Normalizes the line endings: \r\n -> \n, lone \r -> \n.
5556base::string16 NormalizeLineBreaks(const base::string16& source) {
5557 static const base::NoDestructor<base::string16> kReturnNewline(
5558 base::ASCIIToUTF16("\r\n"));
5559 static const base::NoDestructor<base::string16> kReturn(
5560 base::ASCIIToUTF16("\r"));
5561 static const base::NoDestructor<base::string16> kNewline(
5562 base::ASCIIToUTF16("\n"));
5563
5564 std::vector<base::StringPiece16> pieces;
5565
5566 for (const auto& rn_line : base::SplitStringPieceUsingSubstr(
5567 source, *kReturnNewline, base::KEEP_WHITESPACE,
5568 base::SPLIT_WANT_ALL)) {
5569 auto r_lines = base::SplitStringPieceUsingSubstr(
5570 rn_line, *kReturn, base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
5571 std::move(std::begin(r_lines), std::end(r_lines),
5572 std::back_inserter(pieces));
5573 }
5574
5575 return base::JoinString(pieces, *kNewline);
5576}
5577} // namespace
5578
Dave Tapuskacdf545cc2020-01-23 18:38:525579void WebContentsImpl::RunJavaScriptDialog(
5580 RenderFrameHost* render_frame_host,
5581 const base::string16& message,
5582 const base::string16& default_prompt,
5583 JavaScriptDialogType dialog_type,
5584 JavaScriptDialogCallback response_callback) {
Avi Drissman2ccbb402018-03-20 21:11:365585 // Ensure that if showing a dialog is the first thing that a page does, that
5586 // the contents of the previous page aren't shown behind it. This is required
5587 // because showing a dialog freezes the renderer, so no frames will be coming
5588 // from it. https://crbug.com/823353
5589 auto* render_widget_host_impl =
5590 static_cast<RenderFrameHostImpl*>(render_frame_host)
5591 ->GetRenderWidgetHost();
5592 if (render_widget_host_impl)
5593 render_widget_host_impl->ForceFirstFrameAfterNavigationTimeout();
5594
avi0720b02e2017-06-13 03:22:135595 // Running a dialog causes an exit to webpage-initiated fullscreen.
5596 // http://crbug.com/728276
Avi Drissman1a55a9d62020-03-10 18:56:455597 base::ScopedClosureRunner fullscreen_block = ForSecurityDropFullscreen();
avi0720b02e2017-06-13 03:22:135598
Avi Drissman1a55a9d62020-03-10 18:56:455599 auto callback =
5600 base::BindOnce(&WebContentsImpl::OnDialogClosed, base::Unretained(this),
5601 render_frame_host->GetProcess()->GetID(),
5602 render_frame_host->GetRoutingID(),
5603 std::move(response_callback), std::move(fullscreen_block));
Pavel Feldman3c1842b2017-08-02 05:00:165604
Pavel Feldman3c1842b2017-08-02 05:00:165605 std::vector<protocol::PageHandler*> page_handlers =
5606 protocol::PageHandler::EnabledForWebContents(this);
5607
Pavel Feldmanfab3cb62017-10-05 01:02:015608 if (delegate_)
5609 dialog_manager_ = delegate_->GetJavaScriptDialogManager(this);
5610
Charlie Reis96077362019-07-04 00:34:045611 // While a JS message dialog is showing, defer commits in this WebContents.
5612 javascript_dialog_navigation_deferrer_ =
5613 std::make_unique<JavaScriptDialogNavigationDeferrer>();
5614
Carlos IL07f282f2020-05-15 22:58:295615 // Suppress JavaScript dialogs when requested.
5616 bool should_suppress = delegate_ && delegate_->ShouldSuppressDialogs(this);
Pavel Feldman1c587bc52018-04-04 21:16:055617 bool has_non_devtools_handlers = delegate_ && dialog_manager_;
5618 bool has_handlers = page_handlers.size() || has_non_devtools_handlers;
Pavel Feldmanfab3cb62017-10-05 01:02:015619 bool suppress_this_message = should_suppress || !has_handlers;
5620
5621 if (suppress_this_message) {
Avi Drissmane04d3992017-10-05 15:11:365622 std::move(callback).Run(true, false, base::string16());
Pavel Feldman3c1842b2017-08-02 05:00:165623 return;
5624 }
5625
5626 scoped_refptr<CloseDialogCallbackWrapper> wrapper =
Avi Drissmane04d3992017-10-05 15:11:365627 new CloseDialogCallbackWrapper(std::move(callback));
Pavel Feldman3c1842b2017-08-02 05:00:165628
5629 is_showing_javascript_dialog_ = true;
5630
Avi Drissman4891b852018-09-25 18:12:585631 base::string16 normalized_message = NormalizeLineBreaks(message);
5632
Pavel Feldman3c1842b2017-08-02 05:00:165633 for (auto* handler : page_handlers) {
Avi Drissmane04d3992017-10-05 15:11:365634 handler->DidRunJavaScriptDialog(
Avi Drissman4891b852018-09-25 18:12:585635 render_frame_host->GetLastCommittedURL(), normalized_message,
5636 default_prompt, dialog_type, has_non_devtools_handlers,
Avi Drissmane04d3992017-10-05 15:11:365637 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:165638 }
5639
5640 if (dialog_manager_) {
[email protected]87de04b02014-04-08 22:14:495641 dialog_manager_->RunJavaScriptDialog(
Avi Drissman4891b852018-09-25 18:12:585642 this, render_frame_host, dialog_type, normalized_message,
5643 default_prompt,
Avi Drissmane04d3992017-10-05 15:11:365644 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false),
5645 &suppress_this_message);
[email protected]87de04b02014-04-08 22:14:495646 }
5647
5648 if (suppress_this_message) {
5649 // If we are suppressing messages, just reply as if the user immediately
5650 // pressed "Cancel", passing true to |dialog_was_suppressed|.
Avi Drissmane04d3992017-10-05 15:11:365651 wrapper->Run(true, false, base::string16());
[email protected]87de04b02014-04-08 22:14:495652 }
[email protected]87de04b02014-04-08 22:14:495653}
5654
5655void WebContentsImpl::RunBeforeUnloadConfirm(
[email protected]39f2f9252014-05-03 00:54:015656 RenderFrameHost* render_frame_host,
[email protected]87de04b02014-04-08 22:14:495657 bool is_reload,
Dave Tapuskacdf545cc2020-01-23 18:38:525658 JavaScriptDialogCallback response_callback) {
Avi Drissman2ccbb402018-03-20 21:11:365659 // Ensure that if showing a dialog is the first thing that a page does, that
5660 // the contents of the previous page aren't shown behind it. This is required
5661 // because showing a dialog freezes the renderer, so no frames will be coming
5662 // from it. https://crbug.com/823353
5663 auto* render_widget_host_impl =
5664 static_cast<RenderFrameHostImpl*>(render_frame_host)
5665 ->GetRenderWidgetHost();
5666 if (render_widget_host_impl)
5667 render_widget_host_impl->ForceFirstFrameAfterNavigationTimeout();
5668
avi0720b02e2017-06-13 03:22:135669 // Running a dialog causes an exit to webpage-initiated fullscreen.
5670 // http://crbug.com/728276
Avi Drissman1a55a9d62020-03-10 18:56:455671 base::ScopedClosureRunner fullscreen_block = ForSecurityDropFullscreen();
avi0720b02e2017-06-13 03:22:135672
[email protected]39f2f9252014-05-03 00:54:015673 RenderFrameHostImpl* rfhi =
5674 static_cast<RenderFrameHostImpl*>(render_frame_host);
[email protected]87de04b02014-04-08 22:14:495675 if (delegate_)
5676 delegate_->WillRunBeforeUnloadConfirm();
5677
Avi Drissman1a55a9d62020-03-10 18:56:455678 auto callback =
5679 base::BindOnce(&WebContentsImpl::OnDialogClosed, base::Unretained(this),
5680 render_frame_host->GetProcess()->GetID(),
5681 render_frame_host->GetRoutingID(),
5682 std::move(response_callback), std::move(fullscreen_block));
Pavel Feldman3c1842b2017-08-02 05:00:165683
Pavel Feldman3c1842b2017-08-02 05:00:165684 std::vector<protocol::PageHandler*> page_handlers =
5685 protocol::PageHandler::EnabledForWebContents(this);
5686
Pavel Feldmanfab3cb62017-10-05 01:02:015687 if (delegate_)
5688 dialog_manager_ = delegate_->GetJavaScriptDialogManager(this);
5689
Charlie Reis96077362019-07-04 00:34:045690 // While a JS beforeunload dialog is showing, defer commits in this
5691 // WebContents.
5692 javascript_dialog_navigation_deferrer_ =
5693 std::make_unique<JavaScriptDialogNavigationDeferrer>();
5694
Sreeja Kamishettyf352e302020-06-10 13:21:245695 bool should_suppress = !rfhi->IsCurrent() ||
Tarun Bansalc209b742019-12-24 06:53:255696 (delegate_ && delegate_->ShouldSuppressDialogs(this));
Pavel Feldman1c587bc52018-04-04 21:16:055697 bool has_non_devtools_handlers = delegate_ && dialog_manager_;
5698 bool has_handlers = page_handlers.size() || has_non_devtools_handlers;
Pavel Feldmanfab3cb62017-10-05 01:02:015699 if (should_suppress || !has_handlers) {
Avi Drissmane04d3992017-10-05 15:11:365700 std::move(callback).Run(false, true, base::string16());
[email protected]87de04b02014-04-08 22:14:495701 return;
5702 }
5703
5704 is_showing_before_unload_dialog_ = true;
Pavel Feldman3c1842b2017-08-02 05:00:165705
5706 scoped_refptr<CloseDialogCallbackWrapper> wrapper =
Avi Drissmane04d3992017-10-05 15:11:365707 new CloseDialogCallbackWrapper(std::move(callback));
Pavel Feldman3c1842b2017-08-02 05:00:165708
5709 GURL frame_url = rfhi->GetLastCommittedURL();
5710 for (auto* handler : page_handlers) {
Avi Drissmane04d3992017-10-05 15:11:365711 handler->DidRunBeforeUnloadConfirm(
Pavel Feldman1c587bc52018-04-04 21:16:055712 frame_url, has_non_devtools_handlers,
Avi Drissmane04d3992017-10-05 15:11:365713 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:165714 }
5715
5716 if (dialog_manager_) {
Avi Drissmane04d3992017-10-05 15:11:365717 dialog_manager_->RunBeforeUnloadDialog(
Avi Drissmanff9ed752017-11-28 21:18:125718 this, render_frame_host, is_reload,
Avi Drissmane04d3992017-10-05 15:11:365719 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:165720 }
[email protected]87de04b02014-04-08 22:14:495721}
5722
Kent Tamurac260c9a2018-09-14 09:10:565723void WebContentsImpl::RunFileChooser(
5724 RenderFrameHost* render_frame_host,
Kent Tamura3abb32d2020-07-02 00:23:015725 scoped_refptr<FileChooserImpl::FileSelectListenerImpl> listener,
Kent Tamurac260c9a2018-09-14 09:10:565726 const blink::mojom::FileChooserParams& params) {
Avi Drissman3d41e7712018-08-27 21:18:085727 // Any explicit focusing of another window while this WebContents is in
5728 // fullscreen can be used to confuse the user, so drop fullscreen.
Avi Drissman1a55a9d62020-03-10 18:56:455729 base::ScopedClosureRunner fullscreen_block = ForSecurityDropFullscreen();
5730 listener->SetFullscreenBlock(std::move(fullscreen_block));
Avi Drissman3d41e7712018-08-27 21:18:085731
naskoada75b22016-06-11 16:09:465732 if (delegate_)
Kent Tamura512a27e2018-10-04 00:49:325733 delegate_->RunFileChooser(render_frame_host, std::move(listener), params);
5734 else
5735 listener->FileSelectionCanceled();
naskoada75b22016-06-11 16:09:465736}
5737
[email protected]a86c0e962013-12-17 17:10:395738WebContents* WebContentsImpl::GetAsWebContents() {
5739 return this;
5740}
5741
mcnee336ea2c2017-05-23 22:50:595742#if !defined(OS_ANDROID)
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415743double WebContentsImpl::GetPendingPageZoomLevel() {
wjmaclean64951902016-04-29 20:59:125744 NavigationEntry* pending_entry = GetController().GetPendingEntry();
5745 if (!pending_entry)
5746 return HostZoomMap::GetZoomLevel(this);
5747
5748 GURL url = pending_entry->GetURL();
5749 return HostZoomMap::GetForWebContents(this)->GetZoomLevelForHostAndScheme(
5750 url.scheme(), net::GetHostOrSpecFromURL(url));
5751}
mcnee336ea2c2017-05-23 22:50:595752#endif // !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:125753
qinmin72e8bd02016-10-21 19:35:375754bool WebContentsImpl::HideDownloadUI() const {
5755 return is_overlay_content_;
5756}
5757
mlamouri5cd9ae82017-02-18 11:05:095758bool WebContentsImpl::HasPersistentVideo() const {
5759 return has_persistent_video_;
5760}
5761
Ian Vollick5d5c37f2019-06-19 22:50:575762bool WebContentsImpl::IsSpatialNavigationDisabled() const {
5763 return is_spatial_navigation_disabled_;
5764}
5765
Albert J. Wong65fe64d2019-09-20 02:48:145766RenderFrameHostImpl* WebContentsImpl::GetPendingMainFrame() {
clamy610c63b32017-12-22 15:05:185767 return GetRenderManager()->speculative_frame_host();
Alex Moshchuk27caae82017-09-11 23:11:185768}
5769
mlamourie52c1b542017-02-23 14:57:505770bool WebContentsImpl::HasActiveEffectivelyFullscreenVideo() const {
5771 return media_web_contents_observer_->HasActiveEffectivelyFullscreenVideo();
5772}
5773
François Beaufortad6c5232018-02-26 11:00:445774bool WebContentsImpl::IsPictureInPictureAllowedForFullscreenVideo() const {
5775 return media_web_contents_observer_
5776 ->IsPictureInPictureAllowedForFullscreenVideo();
5777}
5778
ekaramada110f642016-12-21 19:47:285779bool WebContentsImpl::IsFocusedElementEditable() {
5780 RenderFrameHostImpl* frame = GetFocusedFrame();
5781 return frame && frame->has_focused_editable_element();
5782}
5783
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415784bool WebContentsImpl::IsShowingContextMenu() {
ekaramadf6750aa2017-06-06 18:29:425785 return showing_context_menu_;
5786}
5787
5788void WebContentsImpl::SetShowingContextMenu(bool showing) {
5789 DCHECK_NE(showing_context_menu_, showing);
5790 showing_context_menu_ = showing;
5791
5792 if (auto* view = GetRenderWidgetHostView()) {
5793 // Notify the main frame's RWHV to run the platform-specific code, if any.
5794 static_cast<RenderWidgetHostViewBase*>(view)->SetShowingContextMenu(
5795 showing);
5796 }
5797}
5798
ekaramada110f642016-12-21 19:47:285799void WebContentsImpl::ClearFocusedElement() {
5800 if (auto* frame = GetFocusedFrame())
5801 frame->ClearFocusedElement();
5802}
5803
danakj77eb7e82020-01-09 19:38:465804bool WebContentsImpl::IsNeverComposited() {
[email protected]7912e822014-04-16 02:37:035805 if (!delegate_)
5806 return false;
danakj77eb7e82020-01-09 19:38:465807 return delegate_->IsNeverComposited(this);
[email protected]7912e822014-04-16 02:37:035808}
5809
[email protected]5a3bdf52012-05-24 15:12:575810RenderViewHostDelegateView* WebContentsImpl::GetDelegateView() {
5811 return render_view_host_delegate_view_;
[email protected]420ae012009-04-24 05:16:325812}
5813
Leon Hanc819dc62019-01-28 04:30:195814blink::mojom::RendererPreferences WebContentsImpl::GetRendererPrefs(
[email protected]8ff00d72012-10-23 19:12:215815 BrowserContext* browser_context) const {
[email protected]840b1512009-07-21 16:53:465816 return renderer_preferences_;
[email protected]80d96fa2009-06-10 22:34:515817}
5818
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165819RenderFrameHostImpl* WebContentsImpl::GetOuterWebContentsFrame() {
5820 if (GetOuterDelegateFrameTreeNodeId() ==
5821 FrameTreeNode::kFrameTreeNodeInvalidId) {
5822 return nullptr;
5823 }
5824
5825 FrameTreeNode* outer_node =
5826 FrameTreeNode::GloballyFindByID(GetOuterDelegateFrameTreeNodeId());
5827 // The outer node should be in the outer WebContents.
5828 DCHECK_EQ(outer_node->frame_tree(), GetOuterWebContents()->GetFrameTree());
Alexander Timin381e7e182020-04-28 19:04:035829 return outer_node->parent();
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165830}
5831
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415832WebContentsImpl* WebContentsImpl::GetOuterWebContents() {
Lucas Furukawa Gadani105de1e812018-05-31 19:38:395833 return node_.outer_web_contents();
avallee0206f782016-07-28 18:55:335834}
5835
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165836std::vector<WebContents*> WebContentsImpl::GetInnerWebContents() {
5837 std::vector<WebContents*> all_inner_contents;
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165838 const auto& inner_contents = node_.GetInnerWebContents();
5839 all_inner_contents.insert(all_inner_contents.end(), inner_contents.begin(),
5840 inner_contents.end());
5841 return all_inner_contents;
5842}
5843
Jeremy Roman7e70bf92020-01-07 23:23:585844WebContentsImpl* WebContentsImpl::GetResponsibleWebContents() {
5845 // Iteratively ask delegates which other contents is responsible until a fixed
5846 // point is found.
5847 WebContentsImpl* contents = this;
5848 while (WebContentsDelegate* delegate = contents->GetDelegate()) {
5849 auto* responsible_contents = static_cast<WebContentsImpl*>(
5850 delegate->GetResponsibleWebContents(contents));
5851 if (responsible_contents == contents)
5852 break;
5853 contents = responsible_contents;
5854 }
5855 return contents;
5856}
5857
avallee0206f782016-07-28 18:55:335858WebContentsImpl* WebContentsImpl::GetFocusedWebContents() {
lfg601233692017-03-06 22:45:445859 return GetOutermostWebContents()->node_.focused_web_contents();
avallee0206f782016-07-28 18:55:335860}
5861
avallee9993fca2016-11-17 06:16:505862bool WebContentsImpl::ContainsOrIsFocusedWebContents() {
5863 for (WebContentsImpl* focused_contents = GetFocusedWebContents();
5864 focused_contents;
5865 focused_contents = focused_contents->GetOuterWebContents()) {
5866 if (focused_contents == this)
5867 return true;
5868 }
5869
5870 return false;
5871}
5872
W. James MacLean9437b5bf2019-12-06 17:33:445873void WebContentsImpl::RemoveBrowserPluginEmbedder() {
5874 browser_plugin_embedder_.reset();
5875}
5876
avallee0206f782016-07-28 18:55:335877WebContentsImpl* WebContentsImpl::GetOutermostWebContents() {
5878 WebContentsImpl* root = this;
5879 while (root->GetOuterWebContents())
5880 root = root->GetOuterWebContents();
5881 return root;
5882}
5883
avalleed68cdd12017-06-21 22:07:275884void WebContentsImpl::FocusOuterAttachmentFrameChain() {
5885 WebContentsImpl* outer_contents = GetOuterWebContents();
5886 if (!outer_contents)
5887 return;
5888
5889 FrameTreeNode* outer_node =
5890 FrameTreeNode::GloballyFindByID(GetOuterDelegateFrameTreeNodeId());
5891 outer_contents->frame_tree_.SetFocusedFrame(outer_node, nullptr);
5892
5893 // For a browser initiated focus change, let embedding renderer know of the
5894 // change. Otherwise, if the currently focused element is just across a
5895 // process boundary in focus order, it will not be possible to move across
5896 // that boundary. This is because the target element will already be focused
5897 // (that renderer was not notified) and drop the event.
5898 if (GetRenderManager()->GetProxyToOuterDelegate())
5899 GetRenderManager()->GetProxyToOuterDelegate()->SetFocusedFrame();
5900
5901 outer_contents->FocusOuterAttachmentFrameChain();
5902}
5903
Sean Toppingbbc4a2bd2019-01-30 02:16:145904void WebContentsImpl::InnerWebContentsCreated(WebContents* inner_web_contents) {
5905 for (auto& observer : observers_)
5906 observer.InnerWebContentsCreated(inner_web_contents);
5907}
5908
Jeremy Roman03ce13ce2020-05-29 22:16:575909void WebContentsImpl::InnerWebContentsAttached(
5910 WebContents* inner_web_contents) {
5911 if (inner_web_contents->IsCurrentlyAudible())
5912 OnAudioStateChanged();
5913}
5914
5915void WebContentsImpl::InnerWebContentsDetached(
5916 WebContents* inner_web_contents) {
5917 if (!is_being_destroyed_)
5918 OnAudioStateChanged();
5919}
5920
[email protected]b172aee2012-04-10 17:05:265921void WebContentsImpl::RenderViewCreated(RenderViewHost* render_view_host) {
[email protected]86f98a22013-03-20 14:35:005922 if (delegate_)
[email protected]e85165c642014-06-10 14:34:315923 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]a6b73c62013-02-11 23:05:085924
[email protected]8ff00d72012-10-23 19:12:215925 NotificationService::current()->Notify(
5926 NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED,
5927 Source<WebContents>(this),
5928 Details<RenderViewHost>(render_view_host));
[email protected]420ae012009-04-24 05:16:325929
ericwilligersde386342016-10-19 02:35:095930 for (auto& observer : observers_)
5931 observer.RenderViewCreated(render_view_host);
Joel Einbinder848001c2017-09-19 21:39:315932 if (delegate_)
5933 RenderFrameDevToolsAgentHost::WebContentsCreated(this);
[email protected]420ae012009-04-24 05:16:325934}
5935
[email protected]b172aee2012-04-10 17:05:265936void WebContentsImpl::RenderViewReady(RenderViewHost* rvh) {
[email protected]151a63d2011-12-20 22:32:525937 if (rvh != GetRenderViewHost()) {
[email protected]420ae012009-04-24 05:16:325938 // Don't notify the world, since this came from a renderer in the
5939 // background.
5940 return;
5941 }
5942
dmazzoni62111452017-04-28 23:46:555943 RenderWidgetHostViewBase* rwhv =
5944 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
5945 if (rwhv)
5946 rwhv->SetMainFrameAXTreeID(GetMainFrame()->GetAXTreeID());
5947
[email protected]da7a7182013-09-06 08:11:115948 notify_disconnection_ = true;
[email protected]da7a7182013-09-06 08:11:115949
[email protected]be1f56ab2011-12-22 06:55:315950 bool was_crashed = IsCrashed();
[email protected]443b80e2010-12-14 00:42:235951 SetIsCrashed(base::TERMINATION_STATUS_STILL_RUNNING, 0);
[email protected]9d8a4642009-07-29 17:25:305952
5953 // Restore the focus to the tab (otherwise the focus will be on the top
5954 // window).
[email protected]484ae5912010-09-29 19:16:145955 if (was_crashed && !FocusLocationBarByDefault() &&
5956 (!delegate_ || delegate_->ShouldFocusPageAfterCrash())) {
[email protected]f3615f02013-02-26 06:09:065957 view_->Focus();
[email protected]484ae5912010-09-29 19:16:145958 }
[email protected]32ded2212011-11-10 18:51:435959
ericwilligersde386342016-10-19 02:35:095960 for (auto& observer : observers_)
5961 observer.RenderViewReady();
Jinsuk Kim895b2c52018-07-03 06:49:165962
5963 view_->RenderViewReady();
[email protected]420ae012009-04-24 05:16:325964}
5965
[email protected]ec6a7eb2013-04-22 17:34:225966void WebContentsImpl::RenderViewTerminated(RenderViewHost* rvh,
5967 base::TerminationStatus status,
5968 int error_code) {
[email protected]151a63d2011-12-20 22:32:525969 if (rvh != GetRenderViewHost()) {
[email protected]420ae012009-04-24 05:16:325970 // The pending page's RenderViewHost is gone.
5971 return;
5972 }
5973
[email protected]2fcdcc32014-03-05 02:14:075974 // Ensure fullscreen mode is exited in the |delegate_| since a crashed
5975 // renderer may not have made a clean exit.
Avi Drissman97aef042020-06-30 21:04:485976 if (IsFullscreen())
bokanece34a82016-01-28 19:49:465977 ExitFullscreenMode(false);
[email protected]2fcdcc32014-03-05 02:14:075978
Jennifer Apacibleb4b972a2018-06-07 04:41:025979 // Ensure any video in Picture-in-Picture is exited in the |delegate_| since
5980 // a crashed renderer may not have made a clean exit.
5981 if (HasPictureInPictureVideo())
5982 ExitPictureInPicture();
5983
[email protected]698191dc2014-02-25 01:06:135984 // Cancel any visible dialogs so they are not left dangling over the sad tab.
creis89a0f782015-05-27 16:13:175985 CancelActiveAndPendingDialogs();
[email protected]698191dc2014-02-25 01:06:135986
dalecurtis3d1e1302017-02-20 22:33:255987 audio_stream_monitor_.RenderProcessGone(rvh->GetProcess()->GetID());
5988
[email protected]960b0372014-05-19 18:01:005989 // Reset the loading progress. TODO(avi): What does it mean to have a
5990 // "renderer crash" when there is more than one renderer process serving a
5991 // webpage? Once this function is called at a more granular frame level, we
5992 // probably will need to more granularly reset the state here.
5993 ResetLoadProgressState();
clamy44e84ce2016-02-22 15:38:255994 NotifyDisconnected();
5995 SetIsCrashed(status, error_code);
[email protected]960b0372014-05-19 18:01:005996
ericwilligersde386342016-10-19 02:35:095997 for (auto& observer : observers_)
5998 observer.RenderProcessGone(GetCrashedStatus());
[email protected]420ae012009-04-24 05:16:325999}
6000
[email protected]b172aee2012-04-10 17:05:266001void WebContentsImpl::RenderViewDeleted(RenderViewHost* rvh) {
ericwilligersde386342016-10-19 02:35:096002 for (auto& observer : observers_)
6003 observer.RenderViewDeleted(rvh);
[email protected]2e4633c2009-07-09 16:58:066004}
6005
sky8b00392d2015-01-10 00:30:286006void WebContentsImpl::UpdateTargetURL(RenderViewHost* render_view_host,
6007 const GURL& url) {
6008 if (fullscreen_widget_routing_id_ != MSG_ROUTING_NONE) {
Lukasz Anforowiczfd707142018-02-07 19:46:136009 // If we're in flash fullscreen (i.e. Pepper plugin fullscreen) only update
6010 // the url if it's from the fullscreen renderer.
sky8b00392d2015-01-10 00:30:286011 RenderWidgetHostView* fs = GetFullscreenRenderWidgetHostView();
avif9ab5d942015-10-15 14:05:446012 if (fs && fs->GetRenderWidgetHost() != render_view_host->GetWidget())
sky8b00392d2015-01-10 00:30:286013 return;
6014 }
Lukasz Anforowiczfd707142018-02-07 19:46:136015
6016 // In case of racey updates from multiple RenderViewHosts, the last URL should
6017 // be shown - see also some discussion in https://crbug.com/807776.
6018 if (!url.is_valid() && render_view_host != view_that_set_last_target_url_)
6019 return;
6020 view_that_set_last_target_url_ = url.is_valid() ? render_view_host : nullptr;
6021
[email protected]6934a702011-12-20 00:04:516022 if (delegate_)
avi450ce00e2014-09-24 01:58:526023 delegate_->UpdateTargetURL(this, url);
[email protected]420ae012009-04-24 05:16:326024}
6025
Lukasz Anforowiczfd707142018-02-07 19:46:136026void WebContentsImpl::ClearTargetURL() {
6027 view_that_set_last_target_url_ = nullptr;
6028 if (delegate_)
6029 delegate_->UpdateTargetURL(this, GURL());
6030}
6031
[email protected]b172aee2012-04-10 17:05:266032void WebContentsImpl::Close(RenderViewHost* rvh) {
[email protected]60780f412013-02-25 16:34:106033#if defined(OS_MACOSX)
[email protected]07707302009-11-06 00:50:296034 // The UI may be in an event-tracking loop, such as between the
6035 // mouse-down and mouse-up in text selection or a button click.
6036 // Defer the close until after tracking is complete, so that we
6037 // don't free objects out from under the UI.
[email protected]07707302009-11-06 00:50:296038 // TODO(shess): This could get more fine-grained. For instance,
6039 // closing a tab in another window while selecting text in the
6040 // current window's Omnibox should be just fine.
Christopher Cameron9ae31e0d2019-03-01 20:01:196041 if (view_->CloseTabAfterEventTrackingIfNeeded())
[email protected]07707302009-11-06 00:50:296042 return;
[email protected]60780f412013-02-25 16:34:106043#endif
[email protected]07707302009-11-06 00:50:296044
[email protected]420ae012009-04-24 05:16:326045 // Ignore this if it comes from a RenderViewHost that we aren't showing.
[email protected]151a63d2011-12-20 22:32:526046 if (delegate_ && rvh == GetRenderViewHost())
[email protected]6934a702011-12-20 00:04:516047 delegate_->CloseContents(this);
[email protected]420ae012009-04-24 05:16:326048}
6049
Avi Drissman014dec72018-06-07 02:34:016050void WebContentsImpl::RequestSetBounds(const gfx::Rect& new_bounds) {
6051 if (delegate_)
6052 delegate_->SetContentsBounds(this, new_bounds);
[email protected]420ae012009-04-24 05:16:326053}
6054
fdegansa696e5112015-04-17 01:57:596055void WebContentsImpl::DidStartLoading(FrameTreeNode* frame_tree_node,
[email protected]e3b10d12014-03-28 16:06:096056 bool to_different_document) {
Evan Stadec3b26022017-07-14 19:50:246057 LoadingStateChanged(frame_tree_node->IsMainFrame() && to_different_document,
Carlos IL07f282f2020-05-15 22:58:296058 nullptr);
dmazzonibf8cec42015-02-08 08:28:086059
Xiyuan Xia2a66b112018-12-06 15:52:166060 // Reset the focus state from DidStartNavigation to false if a new load starts
6061 // afterward, in case loading logic triggers a FocusLocationBarByDefault call.
6062 should_focus_location_bar_by_default_ = false;
Ian Prestcdd843d2020-01-28 18:59:586063
6064 // Notify accessibility that the user is navigating away from the
6065 // current document.
6066 // TODO(domfarolino, dmazzoni): Do this using WebContentsObserver. See
6067 // https://crbug.com/981271.
6068 BrowserAccessibilityManager* manager =
6069 frame_tree_node->current_frame_host()->browser_accessibility_manager();
6070 if (manager)
6071 manager->UserIsNavigatingAway();
[email protected]420ae012009-04-24 05:16:326072}
6073
fdegansc73eec22015-03-19 14:47:546074void WebContentsImpl::DidStopLoading() {
dcheng59716272016-04-09 05:19:086075 std::unique_ptr<LoadNotificationDetails> details;
[email protected]420ae012009-04-24 05:16:326076
[email protected]9595fd82013-04-19 21:28:496077 // Use the last committed entry rather than the active one, in case a
6078 // pending entry has been created.
6079 NavigationEntry* entry = controller_.GetLastCommittedEntry();
6080
[email protected]420ae012009-04-24 05:16:326081 // An entry may not exist for a stop when loading an initial blank page or
6082 // if an iframe injected by script into a blank page finishes loading.
6083 if (entry) {
[email protected]420ae012009-04-24 05:16:326084 details.reset(new LoadNotificationDetails(
[email protected]36fc0392011-12-25 03:59:516085 entry->GetVirtualURL(),
[email protected]420ae012009-04-24 05:16:326086 &controller_,
6087 controller_.GetCurrentEntryIndex()));
6088 }
6089
Carlos IL07f282f2020-05-15 22:58:296090 LoadingStateChanged(true, details.get());
[email protected]420ae012009-04-24 05:16:326091}
6092
fdegansa696e5112015-04-17 01:57:596093void WebContentsImpl::DidChangeLoadProgress() {
Nate Chapin22ea6592019-03-05 22:29:026094 if (is_being_destroyed_)
6095 return;
fdegansa696e5112015-04-17 01:57:596096 double load_progress = frame_tree_.load_progress();
6097
6098 // The delegate is notified immediately for the first and last updates. Also,
6099 // since the message loop may be pretty busy when a page is loaded, it might
6100 // not execute a posted task in a timely manner so the progress report is sent
6101 // immediately if enough time has passed.
6102 base::TimeDelta min_delay =
6103 base::TimeDelta::FromMilliseconds(kMinimumDelayBetweenLoadingUpdatesMS);
6104 bool delay_elapsed = loading_last_progress_update_.is_null() ||
6105 base::TimeTicks::Now() - loading_last_progress_update_ > min_delay;
6106
6107 if (load_progress == 0.0 || load_progress == 1.0 || delay_elapsed) {
6108 // If there is a pending task to send progress, it is now obsolete.
6109 loading_weak_factory_.InvalidateWeakPtrs();
6110
6111 // Notify the load progress change.
6112 SendChangeLoadProgress();
6113
6114 // Clean-up the states if needed.
6115 if (load_progress == 1.0)
6116 ResetLoadProgressState();
6117 return;
6118 }
6119
6120 if (loading_weak_factory_.HasWeakPtrs())
6121 return;
6122
skyostil95082a62015-06-05 19:53:076123 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
tzike2aca992017-09-05 08:50:546124 FROM_HERE,
6125 base::BindOnce(&WebContentsImpl::SendChangeLoadProgress,
6126 loading_weak_factory_.GetWeakPtr()),
fdegansa696e5112015-04-17 01:57:596127 min_delay);
6128}
6129
avid6d88b912017-01-13 00:16:006130std::vector<std::unique_ptr<NavigationThrottle>>
6131WebContentsImpl::CreateThrottlesForNavigation(
clamycbf524d42016-09-27 12:48:356132 NavigationHandle* navigation_handle) {
Charlie Reis96077362019-07-04 00:34:046133 auto throttles = GetContentClient()->browser()->CreateThrottlesForNavigation(
clamycbf524d42016-09-27 12:48:356134 navigation_handle);
Charlie Reis96077362019-07-04 00:34:046135
6136 // This is not a normal place to be adding a throttle. However, in the case
6137 // javascript dialogs, related logic is present in the web_contents/ layer,
6138 // and the purpose of the throttle is to ensure that navigation commits are
6139 // deferred for the entire WebContents. Most throttles are either added by
6140 // the embederrer outside of content/, or are per-frame and added by
6141 // NavigationThrottleRunner.
6142 std::unique_ptr<content::NavigationThrottle> dialog_throttle =
6143 JavaScriptDialogNavigationThrottle::MaybeCreateThrottleFor(
6144 navigation_handle);
6145 if (dialog_throttle)
6146 throttles.push_back(std::move(dialog_throttle));
6147
6148 return throttles;
clamycbf524d42016-09-27 12:48:356149}
6150
clamy1e5574e2016-09-29 16:48:446151std::unique_ptr<NavigationUIData> WebContentsImpl::GetNavigationUIData(
6152 NavigationHandle* navigation_handle) {
clamy1e5574e2016-09-29 16:48:446153 return GetContentClient()->browser()->GetNavigationUIData(navigation_handle);
6154}
6155
W. James MacLean1c40862c2020-04-27 21:05:576156void WebContentsImpl::RegisterExistingOriginToPreventOptInIsolation(
W. James MacLeanb70fab82020-05-01 18:51:146157 const url::Origin& origin,
6158 NavigationRequest* navigation_request_to_exclude) {
W. James MacLean1c40862c2020-04-27 21:05:576159 // Note: This function can be made static if we ever need call it without
6160 // a WebContentsImpl instance, in which case we can use a wrapper to
6161 // implement the override from NavigatorDelegate.
6162 for (WebContentsImpl* web_contents : GetAllWebContents()) {
6163 web_contents->controller_.RegisterExistingOriginToPreventOptInIsolation(
6164 origin);
W. James MacLeanb70fab82020-05-01 18:51:146165 // Walk the frame tree to pick up any frames without FrameNavigationEntries.
6166 // * Some frames won't have FrameNavigationEntries (Issues 524208, 608402).
6167 // * Some pending navigations won't have NavigationEntries.
6168 web_contents->GetFrameTree()->RegisterExistingOriginToPreventOptInIsolation(
6169 origin, navigation_request_to_exclude);
W. James MacLean1c40862c2020-04-27 21:05:576170 }
6171}
6172
pdr15f5b5b2017-06-20 00:58:006173void WebContentsImpl::DidCancelLoading() {
6174 controller_.DiscardNonCommittedEntries();
6175
6176 // Update the URL display.
6177 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
6178}
6179
[email protected]59167c22013-06-03 18:07:326180void WebContentsImpl::DidAccessInitialDocument() {
[email protected]b4c84012014-04-28 19:51:106181 has_accessed_initial_document_ = true;
6182
[email protected]d1371bf8e2014-04-19 03:26:246183 // We may have left a failed browser-initiated navigation in the address bar
6184 // to let the user edit it and try again. Clear it now that content might
6185 // show up underneath it.
6186 if (!IsLoading() && controller_.GetPendingEntry())
avi45a72532015-04-07 21:01:456187 controller_.DiscardPendingEntry(false);
[email protected]d1371bf8e2014-04-19 03:26:246188
[email protected]59167c22013-06-03 18:07:326189 // Update the URL display.
thestigc4cac8f2014-09-04 21:17:506190 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
[email protected]59167c22013-06-03 18:07:326191}
6192
alexmosbe2f4c32015-03-10 02:30:236193void WebContentsImpl::DidChangeName(RenderFrameHost* render_frame_host,
6194 const std::string& name) {
ericwilligersde386342016-10-19 02:35:096195 for (auto& observer : observers_)
6196 observer.FrameNameChanged(render_frame_host, name);
alexmosbe2f4c32015-03-10 02:30:236197}
6198
John Delaneyedd8d6c2019-01-25 00:23:576199void WebContentsImpl::DidReceiveFirstUserActivation(
6200 RenderFrameHost* render_frame_host) {
6201 for (auto& observer : observers_)
6202 observer.FrameReceivedFirstUserActivation(render_frame_host);
6203}
6204
John Delaney0146a742019-01-25 19:25:286205void WebContentsImpl::DidChangeDisplayState(RenderFrameHost* render_frame_host,
6206 bool is_display_none) {
6207 for (auto& observer : observers_)
6208 observer.FrameDisplayStateChanged(render_frame_host, is_display_none);
6209}
6210
6211void WebContentsImpl::FrameSizeChanged(RenderFrameHost* render_frame_host,
6212 const gfx::Size& frame_size) {
6213 for (auto& observer : observers_)
6214 observer.FrameSizeChanged(render_frame_host, frame_size);
6215}
6216
[email protected]39f2f9252014-05-03 00:54:016217void WebContentsImpl::DocumentOnLoadCompleted(
[email protected]50279492014-05-05 23:24:296218 RenderFrameHost* render_frame_host) {
falken52a56e32016-12-08 05:02:406219 ShowInsecureLocalhostWarningIfNeeded();
6220
Alexander Timindd0fa0c52019-11-06 13:03:376221 GetRenderViewHost()->DocumentOnLoadCompletedInMainFrame();
6222
creis97867aa2017-02-17 18:39:456223 is_notifying_observers_ = true;
ericwilligersde386342016-10-19 02:35:096224 for (auto& observer : observers_)
6225 observer.DocumentOnLoadCompletedInMainFrame();
creis97867aa2017-02-17 18:39:456226 is_notifying_observers_ = false;
[email protected]6578fef2013-10-14 02:35:096227
6228 // TODO(avi): Remove. http://crbug.com/170921
[email protected]8ff00d72012-10-23 19:12:216229 NotificationService::current()->Notify(
6230 NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
6231 Source<WebContents>(this),
[email protected]50279492014-05-05 23:24:296232 NotificationService::NoDetails());
[email protected]25497492010-09-11 15:15:086233}
6234
creis8eb8ef22015-11-04 22:51:386235void WebContentsImpl::UpdateStateForFrame(RenderFrameHost* render_frame_host,
6236 const PageState& page_state) {
creis8eb8ef22015-11-04 22:51:386237 // The state update affects the last NavigationEntry associated with the given
6238 // |render_frame_host|. This may not be the last committed NavigationEntry (as
6239 // in the case of an UpdateState from a frame being swapped out). We track
6240 // which entry this is in the RenderFrameHost's nav_entry_id.
6241 RenderFrameHostImpl* rfhi =
6242 static_cast<RenderFrameHostImpl*>(render_frame_host);
6243 NavigationEntryImpl* entry =
6244 controller_.GetEntryWithUniqueID(rfhi->nav_entry_id());
6245 if (!entry)
6246 return;
6247
6248 FrameNavigationEntry* frame_entry =
6249 entry->GetFrameEntry(rfhi->frame_tree_node());
6250 if (!frame_entry)
6251 return;
6252
creisd06a9422015-11-11 03:08:456253 // The SiteInstance might not match if we do a cross-process navigation with
6254 // replacement (e.g., auto-subframe), in which case the swap out of the old
6255 // RenderFrameHost runs in the background after the old FrameNavigationEntry
6256 // has already been replaced and destroyed.
6257 if (frame_entry->site_instance() != rfhi->GetSiteInstance())
6258 return;
6259
creis8eb8ef22015-11-04 22:51:386260 if (page_state == frame_entry->page_state())
6261 return; // Nothing to update.
6262
creis0cade2e2017-02-28 06:37:476263 DCHECK(page_state.IsValid()) << "Shouldn't set an empty PageState.";
nasko34634672016-07-29 18:46:066264
6265 // The document_sequence_number and item_sequence_number recorded in the
6266 // FrameNavigationEntry should not differ from the one coming with the update,
6267 // since it must come from the same document. Do not update it if a difference
6268 // is detected, as this indicates that |frame_entry| is not the correct one.
6269 ExplodedPageState exploded_state;
6270 if (!DecodePageState(page_state.ToEncodedData(), &exploded_state))
6271 return;
6272
6273 if (exploded_state.top.document_sequence_number !=
6274 frame_entry->document_sequence_number() ||
6275 exploded_state.top.item_sequence_number !=
6276 frame_entry->item_sequence_number()) {
6277 return;
6278 }
6279
nasko04a322f25a2016-09-01 00:00:346280 frame_entry->SetPageState(page_state);
creis8eb8ef22015-11-04 22:51:386281 controller_.NotifyEntryChanged(entry);
6282}
6283
[email protected]ef3adfc2014-05-11 00:04:546284void WebContentsImpl::UpdateTitle(RenderFrameHost* render_frame_host,
[email protected]ef3adfc2014-05-11 00:04:546285 const base::string16& title,
6286 base::i18n::TextDirection title_direction) {
[email protected]ef3adfc2014-05-11 00:04:546287 // Try to find the navigation entry, which might not be the current one.
avi286019ce2015-07-29 01:26:586288 // For example, it might be from a recently swapped out RFH.
avi1edc8552016-10-13 21:37:166289 NavigationEntryImpl* entry = controller_.GetEntryWithUniqueID(
creisad8c31a2016-05-24 17:07:046290 static_cast<RenderFrameHostImpl*>(render_frame_host)->nav_entry_id());
[email protected]ef3adfc2014-05-11 00:04:546291
6292 // We can handle title updates when we don't have an entry in
6293 // UpdateTitleForEntry, but only if the update is from the current RVH.
6294 // TODO(avi): Change to make decisions based on the RenderFrameHost.
avi286019ce2015-07-29 01:26:586295 if (!entry && render_frame_host != GetMainFrame())
[email protected]ef3adfc2014-05-11 00:04:546296 return;
6297
6298 // TODO(evan): make use of title_direction.
6299 // http://code.google.com/p/chromium/issues/detail?id=27094
afakhry6f0c1ec22016-07-14 13:55:136300 UpdateTitleForEntry(entry, title);
[email protected]ef3adfc2014-05-11 00:04:546301}
6302
[email protected]e1c3a552012-05-04 20:51:326303void WebContentsImpl::RouteCloseEvent(RenderViewHost* rvh) {
6304 // Tell the active RenderViewHost to run unload handlers and close, as long
6305 // as the request came from a RenderViewHost in the same BrowsingInstance.
6306 // In most cases, we receive this from a swapped out RenderViewHost.
6307 // It is possible to receive it from one that has just been swapped in,
6308 // in which case we might as well deliver the message anyway.
6309 if (rvh->GetSiteInstance()->IsRelatedSiteInstance(GetSiteInstance()))
naskoc0fceff2015-04-30 15:53:526310 ClosePage();
[email protected]e1c3a552012-05-04 20:51:326311}
6312
alexmose7da5a12015-04-09 02:22:166313bool WebContentsImpl::ShouldRouteMessageEvent(
6314 RenderFrameHost* target_rfh,
6315 SiteInstance* source_site_instance) const {
6316 // Allow the message if this WebContents is dedicated to a browser plugin
6317 // guest.
[email protected]0eba810b2012-10-18 03:19:366318 // Note: This check means that an embedder could theoretically receive a
6319 // postMessage from anyone (not just its own guests). However, this is
6320 // probably not a risk for apps since other pages won't have references
6321 // to App windows.
alexmose7da5a12015-04-09 02:22:166322 return GetBrowserPluginGuest() || GetBrowserPluginEmbedder();
6323}
[email protected]f546640b2012-05-15 00:03:496324
alexmos58729042015-06-18 23:20:006325void WebContentsImpl::EnsureOpenerProxiesExist(RenderFrameHost* source_rfh) {
alexmose7da5a12015-04-09 02:22:166326 WebContentsImpl* source_web_contents = static_cast<WebContentsImpl*>(
6327 WebContents::FromRenderFrameHost(source_rfh));
[email protected]f546640b2012-05-15 00:03:496328
alexmose7da5a12015-04-09 02:22:166329 if (source_web_contents) {
lazyboy6ec48b2a2015-06-29 15:18:146330 // If this message is going to outer WebContents from inner WebContents,
6331 // then we should not create a RenderView. AttachToOuterWebContentsFrame()
6332 // already created a RenderFrameProxyHost for that purpose.
6333 if (GetBrowserPluginEmbedder() &&
W. James MacLean2539adb32019-12-13 00:40:446334 source_web_contents->browser_plugin_guest_) {
lazyboy6ec48b2a2015-06-29 15:18:146335 return;
W. James MacLean2539adb32019-12-13 00:40:446336 }
lazyboy6ec48b2a2015-06-29 15:18:146337
lfg812874d2016-02-09 22:26:136338 if (this != source_web_contents && GetBrowserPluginGuest()) {
naskob3041b98a42016-03-12 04:43:066339 // We create a RenderFrameProxyHost for the embedder in the guest's render
6340 // process but we intentionally do not expose the embedder's opener chain
6341 // to it.
6342 source_web_contents->GetRenderManager()->CreateRenderFrameProxy(
6343 GetSiteInstance());
[email protected]f546640b2012-05-15 00:03:496344 } else {
alexmos58729042015-06-18 23:20:006345 RenderFrameHostImpl* source_rfhi =
6346 static_cast<RenderFrameHostImpl*>(source_rfh);
6347 source_rfhi->frame_tree_node()->render_manager()->CreateOpenerProxies(
alexmos90325cf2015-09-02 17:18:396348 GetSiteInstance(), nullptr);
[email protected]f546640b2012-05-15 00:03:496349 }
6350 }
[email protected]f546640b2012-05-15 00:03:496351}
6352
avallee9993fca2016-11-17 06:16:506353void WebContentsImpl::SetAsFocusedWebContentsIfNecessary() {
Adithya Srinivasan11af2c52019-12-16 22:52:556354 DCHECK(!portal());
avallee9993fca2016-11-17 06:16:506355 // Only change focus if we are not currently focused.
6356 WebContentsImpl* old_contents = GetFocusedWebContents();
6357 if (old_contents == this)
6358 return;
6359
paulmeyerfeafc2d2017-04-25 21:46:406360 GetOutermostWebContents()->node_.SetFocusedWebContents(this);
6361
avallee9993fca2016-11-17 06:16:506362 // Send a page level blur to the old contents so that it displays inactive UI
6363 // and focus this contents to activate it.
6364 if (old_contents)
6365 old_contents->GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(false);
avalleec2ff1ef2017-01-21 00:12:306366
6367 // Make sure the outer web contents knows our frame is focused. Otherwise, the
6368 // outer renderer could have the element before or after the frame element
6369 // focused which would return early without actually advancing focus.
avalleed68cdd12017-06-21 22:07:276370 FocusOuterAttachmentFrameChain();
avalleec2ff1ef2017-01-21 00:12:306371
Carlos ILd51e7702020-05-07 18:51:396372 GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(true);
avallee9993fca2016-11-17 06:16:506373}
6374
avallee0206f782016-07-28 18:55:336375void WebContentsImpl::SetFocusedFrame(FrameTreeNode* node,
6376 SiteInstance* source) {
Adithya Srinivasan11af2c52019-12-16 22:52:556377 DCHECK(!portal());
avallee0206f782016-07-28 18:55:336378 frame_tree_.SetFocusedFrame(node, source);
avalleed68cdd12017-06-21 22:07:276379
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576380 if (auto* inner_contents = node_.GetInnerWebContentsInFrame(node)) {
6381 // |this| is an outer WebContents and |node| represents an inner
6382 // WebContents. Transfer the focus to the inner contents if |this| is
6383 // focused.
6384 if (GetFocusedWebContents() == this)
6385 inner_contents->SetAsFocusedWebContentsIfNecessary();
6386 } else if (node_.OuterContentsFrameTreeNode() &&
6387 node_.OuterContentsFrameTreeNode()
6388 ->current_frame_host()
6389 ->GetSiteInstance() == source) {
6390 // |this| is an inner WebContents, |node| is its main FrameTreeNode and
6391 // the outer WebContents FrameTreeNode is at |source|'s SiteInstance.
6392 // Transfer the focus to the inner WebContents if the outer WebContents is
6393 // focused. This branch is used when an inner WebContents is focused through
Lowell Mannersa9530382019-08-01 09:46:576394 // its RenderFrameProxyHost (via FrameFocused mojo call, used to
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576395 // implement the window.focus() API).
6396 if (GetFocusedWebContents() == GetOuterWebContents())
6397 SetAsFocusedWebContentsIfNecessary();
6398 } else if (!GetOuterWebContents()) {
6399 // This is an outermost WebContents.
6400 SetAsFocusedWebContentsIfNecessary();
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576401 }
avalleed68cdd12017-06-21 22:07:276402}
6403
Avi Drissman36f801f2018-02-01 20:06:046404void WebContentsImpl::DidCallFocus() {
6405 // Any explicit focusing of another window while this WebContents is in
6406 // fullscreen can be used to confuse the user, so drop fullscreen.
Avi Drissman1a55a9d62020-03-10 18:56:456407 base::ScopedClosureRunner fullscreen_block = ForSecurityDropFullscreen();
6408 // The other contents is independent of this contents, so release the
6409 // fullscreen block.
6410 fullscreen_block.RunAndReset();
Avi Drissman36f801f2018-02-01 20:06:046411}
6412
avalleed68cdd12017-06-21 22:07:276413RenderFrameHost* WebContentsImpl::GetFocusedFrameIncludingInnerWebContents() {
6414 WebContentsImpl* contents = this;
6415 FrameTreeNode* focused_node = contents->frame_tree_.GetFocusedFrame();
6416
6417 // If there is no focused frame in the outer WebContents, we need to return
6418 // null.
6419 if (!focused_node)
6420 return nullptr;
6421
6422 // If the focused frame is embedding an inner WebContents, we must descend
6423 // into that contents. If the current WebContents does not have a focused
6424 // frame, return the main frame of this contents instead of the focused empty
6425 // frame embedding this contents.
6426 while (true) {
6427 contents = contents->node_.GetInnerWebContentsInFrame(focused_node);
6428 if (!contents)
6429 return focused_node->current_frame_host();
6430
6431 focused_node = contents->frame_tree_.GetFocusedFrame();
6432 if (!focused_node)
6433 return contents->GetMainFrame();
6434 }
avallee0206f782016-07-28 18:55:336435}
6436
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576437void WebContentsImpl::OnAdvanceFocus(RenderFrameHostImpl* source_rfh) {
6438 // When a RenderFrame needs to advance focus to a RenderFrameProxy (by hitting
6439 // TAB), the RenderFrameProxy sends an IPC to RenderFrameProxyHost. When this
6440 // RenderFrameProxyHost represents an inner WebContents, the outer WebContents
6441 // needs to focus the inner WebContents.
6442 if (GetOuterWebContents() &&
6443 GetOuterWebContents() == source_rfh->delegate()->GetAsWebContents() &&
6444 GetFocusedWebContents() == GetOuterWebContents()) {
6445 SetAsFocusedWebContentsIfNecessary();
6446 }
6447}
6448
ekaramada110f642016-12-21 19:47:286449void WebContentsImpl::OnFocusedElementChangedInFrame(
6450 RenderFrameHostImpl* frame,
6451 const gfx::Rect& bounds_in_root_view) {
6452 RenderWidgetHostViewBase* root_view =
6453 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
6454 if (!root_view || !frame->GetView())
6455 return;
6456
6457 // Converting to screen coordinates.
6458 gfx::Point origin = bounds_in_root_view.origin();
6459 origin += root_view->GetViewBounds().OffsetFromOrigin();
6460 gfx::Rect bounds_in_screen(origin, bounds_in_root_view.size());
6461
6462 root_view->FocusedNodeChanged(frame->has_focused_editable_element(),
6463 bounds_in_screen);
6464
6465 FocusedNodeDetails details = {frame->has_focused_editable_element(),
6466 bounds_in_screen};
6467
6468 // TODO(ekaramad): We should replace this with an observer notification
6469 // (https://crbug.com/675975).
6470 NotificationService::current()->Notify(
6471 NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
6472 Source<RenderViewHost>(GetRenderViewHost()),
6473 Details<FocusedNodeDetails>(&details));
Jeff Fisher709b4c52019-07-29 20:07:346474
6475 for (auto& observer : observers_)
6476 observer.OnFocusChangedInPage(&details);
ekaramada110f642016-12-21 19:47:286477}
6478
Lowell Manners1de5242e2019-04-25 10:18:466479bool WebContentsImpl::DidAddMessageToConsole(
6480 blink::mojom::ConsoleMessageLevel log_level,
6481 const base::string16& message,
6482 int32_t line_no,
6483 const base::string16& source_id) {
Devlin Cronin5ea668f32019-12-18 21:57:586484 for (auto& observer : observers_)
6485 observer.OnDidAddMessageToConsole(log_level, message, line_no, source_id);
6486
[email protected]a796f202012-05-30 14:14:256487 if (!delegate_)
6488 return false;
Lowell Manners1de5242e2019-04-25 10:18:466489 return delegate_->DidAddMessageToConsole(this, log_level, message, line_no,
avia90ae4e2016-11-11 20:49:336490 source_id);
[email protected]a796f202012-05-30 14:14:256491}
6492
Daniel Cheng90196c82018-04-25 21:49:146493void WebContentsImpl::DidReceiveInputEvent(
dominickn9c7ceaa32016-02-27 01:52:536494 RenderWidgetHostImpl* render_widget_host,
6495 const blink::WebInputEvent::Type type) {
Dominick Ng37a15052018-07-17 23:56:356496 if (!IsUserInteractionInputType(type))
Daniel Cheng90196c82018-04-25 21:49:146497 return;
6498
kenrb19221852016-04-29 17:21:406499 // Ignore unless the widget is currently in the frame tree.
6500 if (!HasMatchingWidgetHost(&frame_tree_, render_widget_host))
avic3aa8422015-11-09 20:57:226501 return;
6502
Dave Tapuska347d60a2020-04-21 23:55:476503 if (type != blink::WebInputEvent::Type::kGestureScrollBegin)
Daniel Cheng90196c82018-04-25 21:49:146504 last_interactive_input_event_time_ = ui::EventTimeForNow();
dominickn9c7ceaa32016-02-27 01:52:536505
Dominick Ng37a15052018-07-17 23:56:356506 for (auto& observer : observers_)
6507 observer.DidGetUserInteraction(type);
dominickn2dd142dd2015-10-29 05:30:506508}
6509
Avi Drissman738ea192018-08-29 20:24:166510bool WebContentsImpl::ShouldIgnoreInputEvents() {
6511 WebContentsImpl* web_contents = this;
6512 while (web_contents) {
6513 if (web_contents->ignore_input_events_)
6514 return true;
6515 web_contents = web_contents->GetOuterWebContents();
6516 }
6517
6518 return false;
6519}
6520
avallee9993fca2016-11-17 06:16:506521void WebContentsImpl::FocusOwningWebContents(
6522 RenderWidgetHostImpl* render_widget_host) {
Alex Moshchukc4f0a722019-11-19 22:41:286523 RenderWidgetHostImpl* main_frame_widget_host =
6524 GetMainFrame()->GetRenderWidgetHost();
avallee9993fca2016-11-17 06:16:506525 RenderWidgetHostImpl* focused_widget =
Alex Moshchukc4f0a722019-11-19 22:41:286526 GetFocusedRenderWidgetHost(main_frame_widget_host);
avallee9993fca2016-11-17 06:16:506527
6528 if (focused_widget != render_widget_host &&
avallee8e881592016-11-19 00:39:306529 (!focused_widget ||
6530 focused_widget->delegate() != render_widget_host->delegate())) {
avallee9993fca2016-11-17 06:16:506531 SetAsFocusedWebContentsIfNecessary();
6532 }
6533}
6534
[email protected]b172aee2012-04-10 17:05:266535void WebContentsImpl::OnIgnoredUIEvent() {
[email protected]31145092011-09-30 01:49:446536 // Notify observers.
ericwilligersde386342016-10-19 02:35:096537 for (auto& observer : observers_)
6538 observer.DidGetIgnoredUIEvent();
[email protected]fa1cf0b82010-01-15 21:49:446539}
6540
avic3aa8422015-11-09 20:57:226541void WebContentsImpl::RendererUnresponsive(
Lukasz Anforowicz52b93722018-06-20 16:11:396542 RenderWidgetHostImpl* render_widget_host,
6543 base::RepeatingClosure hang_monitor_restarter) {
avic031d392017-03-03 03:09:426544 if (ShouldIgnoreUnresponsiveRenderer())
[email protected]e5fc1632011-08-08 07:51:536545 return;
6546
Lukasz Anforowicz4f0593d2018-09-21 18:33:546547 // Do not report hangs (to task manager, to hang renderer dialog, etc.) for
6548 // invisible tabs (like extension background page, background tabs). See
6549 // https://crbug.com/881812 for rationale and for choosing the visibility
6550 // (rather than process priority) as the signal here.
6551 if (GetVisibility() != Visibility::VISIBLE)
6552 return;
6553
Avi Drissman8920def2018-01-31 19:53:366554 if (!render_widget_host->renderer_initialized())
[email protected]55452902011-06-01 21:57:476555 return;
6556
Lukasz Anforowicz4f0593d2018-09-21 18:33:546557 for (auto& observer : observers_)
6558 observer.OnRendererUnresponsive(render_widget_host->GetProcess());
6559
Dave Tapuskac6146c52017-12-20 22:48:156560 if (delegate_)
Lukasz Anforowicz52b93722018-06-20 16:11:396561 delegate_->RendererUnresponsive(this, render_widget_host,
6562 std::move(hang_monitor_restarter));
[email protected]420ae012009-04-24 05:16:326563}
6564
avic3aa8422015-11-09 20:57:226565void WebContentsImpl::RendererResponsive(
6566 RenderWidgetHostImpl* render_widget_host) {
Scott Violet48202e62020-05-26 17:19:336567 for (auto& observer : observers_)
6568 observer.OnRendererResponsive(render_widget_host->GetProcess());
6569
[email protected]6934a702011-12-20 00:04:516570 if (delegate_)
Avi Drissman1572e8c3c2018-02-02 19:06:366571 delegate_->RendererResponsive(this, render_widget_host);
[email protected]420ae012009-04-24 05:16:326572}
6573
Alex Moshchuk7b4f0652019-05-30 18:54:416574void WebContentsImpl::SubframeCrashed(
6575 blink::mojom::FrameVisibility visibility) {
6576 // If a subframe crashed on a hidden tab, mark the tab for reload to avoid
6577 // showing a sad frame to the user if they ever switch back to that tab. Do
6578 // this for subframes that are either visible in viewport or visible but
6579 // scrolled out of view, but skip subframes that are not rendered (e.g., via
6580 // "display:none"), since in that case the user wouldn't see a sad frame
6581 // anyway.
6582 bool did_mark_for_reload = false;
6583 if (IsHidden() && visibility != blink::mojom::FrameVisibility::kNotRendered &&
6584 base::FeatureList::IsEnabled(
6585 features::kReloadHiddenTabsWithCrashedSubframes)) {
6586 controller_.SetNeedsReload(
6587 NavigationControllerImpl::NeedsReloadType::kCrashedSubframe);
6588 did_mark_for_reload = true;
6589 UMA_HISTOGRAM_ENUMERATION(
6590 "Stability.ChildFrameCrash.TabMarkedForReload.Visibility", visibility);
6591 }
6592
6593 UMA_HISTOGRAM_BOOLEAN("Stability.ChildFrameCrash.TabMarkedForReload",
6594 did_mark_for_reload);
6595}
6596
[email protected]b172aee2012-04-10 17:05:266597void WebContentsImpl::BeforeUnloadFiredFromRenderManager(
[email protected]feaded02012-09-25 19:12:556598 bool proceed, const base::TimeTicks& proceed_time,
[email protected]420ae012009-04-24 05:16:326599 bool* proceed_to_fire_unload) {
ericwilligersde386342016-10-19 02:35:096600 for (auto& observer : observers_)
Chris Hamilton3b3e315d2018-09-19 13:16:216601 observer.BeforeUnloadFired(proceed, proceed_time);
[email protected]6934a702011-12-20 00:04:516602 if (delegate_)
6603 delegate_->BeforeUnloadFired(this, proceed, proceed_to_fire_unload);
[email protected]e80af492013-06-24 21:52:096604 // Note: |this| might be deleted at this point.
[email protected]420ae012009-04-24 05:16:326605}
6606
[email protected]58d5cfe2013-07-10 02:40:526607void WebContentsImpl::RenderProcessGoneFromRenderManager(
[email protected]3a3d47472010-07-15 21:03:546608 RenderViewHost* render_view_host) {
[email protected]443b80e2010-12-14 00:42:236609 DCHECK(crashed_status_ != base::TERMINATION_STATUS_STILL_RUNNING);
[email protected]ec6a7eb2013-04-22 17:34:226610 RenderViewTerminated(render_view_host, crashed_status_, crashed_error_code_);
[email protected]3a3d47472010-07-15 21:03:546611}
6612
[email protected]af905902013-10-01 21:38:516613void WebContentsImpl::CancelModalDialogsForRenderManager() {
6614 // We need to cancel modal dialogs when doing a process swap, since the load
avi2460c762015-04-17 15:21:546615 // deferrer would prevent us from swapping out. We also clear the state
6616 // because this is a cross-process navigation, which means that it's a new
6617 // site that should not have to pay for the sins of its predecessor.
creis89a0f782015-05-27 16:13:176618 //
Lei Zhang6410ec1a2019-01-31 21:38:586619 // Note that we don't bother telling |browser_plugin_embedder_| because the
creis89a0f782015-05-27 16:13:176620 // cross-process navigation will either destroy the browser plugins or not
6621 // require their dialogs to close.
avi5d3b8692016-10-12 22:00:466622 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:536623 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:466624 }
[email protected]af905902013-10-01 21:38:516625}
6626
danakja0bce4c952020-05-12 20:40:286627void WebContentsImpl::NotifySwappedFromRenderManager(RenderFrameHost* old_frame,
6628 RenderFrameHost* new_frame,
[email protected]02d7b6e2014-06-24 21:01:506629 bool is_main_frame) {
6630 if (is_main_frame) {
danakja0bce4c952020-05-12 20:40:286631 // The |new_frame| and its various compadres are already swapped into place
6632 // for the WebContentsImpl when this method is called.
6633 DCHECK(GetMainFrame() == new_frame);
6634 DCHECK(GetRenderViewHost() == new_frame->GetRenderViewHost());
6635 DCHECK(GetRenderWidgetHostView() == new_frame->GetView());
6636
Fergal Daly6767b2e2020-02-04 03:15:166637 RenderViewHost* old_rvh =
danakja0bce4c952020-05-12 20:40:286638 old_frame ? old_frame->GetRenderViewHost() : nullptr;
6639 RenderViewHost* new_rvh = new_frame->GetRenderViewHost();
Fergal Daly6767b2e2020-02-04 03:15:166640 // |old_rvh| and |new_rvh| might be equal when navigating from a crashed
6641 // RenderFrameHost to a new same-site one. With RenderDocument, this will
6642 // happen for every same-site navigation.
6643 if (old_rvh != new_rvh)
6644 NotifyViewSwapped(old_rvh, new_rvh);
[email protected]a6b73c62013-02-11 23:05:086645
[email protected]02d7b6e2014-06-24 21:01:506646 // Make sure the visible RVH reflects the new delegate's preferences.
6647 if (delegate_)
6648 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]d56a49e2013-02-23 00:47:396649
danakja0bce4c952020-05-12 20:40:286650 auto* rwhv = static_cast<RenderWidgetHostViewBase*>(new_frame->GetView());
6651 if (rwhv) {
6652 rwhv->SetMainFrameAXTreeID(new_frame->GetAXTreeID());
6653
6654 // The RenderWidgetHostView for the speculative RenderFrameHost is not
6655 // resized with the current RenderFrameHost while a navigation is
6656 // pending. So when we swap in the main frame, we need to update the
6657 // RenderWidgetHostView's size.
6658 //
6659 // Historically, this was done to fix b/1079768 for interstitials.
6660 rwhv->SetSize(GetSizeForMainFrame());
6661 }
[email protected]02d7b6e2014-06-24 21:01:506662 }
6663
danakja0bce4c952020-05-12 20:40:286664 NotifyFrameSwapped(old_frame, new_frame, is_main_frame);
[email protected]3a3d47472010-07-15 21:03:546665}
6666
naskof5940b9f2015-03-02 23:04:056667void WebContentsImpl::NotifyMainFrameSwappedFromRenderManager(
danakja0bce4c952020-05-12 20:40:286668 RenderFrameHost* old_frame,
6669 RenderFrameHost* new_frame) {
6670 NotifyViewSwapped(old_frame ? old_frame->GetRenderViewHost() : nullptr,
6671 new_frame->GetRenderViewHost());
naskof5940b9f2015-03-02 23:04:056672}
6673
[email protected]b172aee2012-04-10 17:05:266674NavigationControllerImpl& WebContentsImpl::GetControllerForRenderManager() {
[email protected]d1198fd2012-08-13 22:50:196675 return GetController();
[email protected]3a3d47472010-07-15 21:03:546676}
6677
dcheng59716272016-04-09 05:19:086678std::unique_ptr<WebUIImpl> WebContentsImpl::CreateWebUIForRenderFrameHost(
Denis Kuznetsov [CET]2c6f0159f2020-05-18 14:18:166679 const GURL& url) {
6680 return CreateWebUI(url);
[email protected]420ae012009-04-24 05:16:326681}
6682
lfgbede6392015-09-11 21:54:066683void WebContentsImpl::CreateRenderWidgetHostViewForRenderManager(
6684 RenderViewHost* render_view_host) {
lfgc740d4b22016-04-15 16:45:336685 RenderWidgetHostViewBase* rwh_view =
W. James MacLean13d834d2019-12-04 16:06:456686 view_->CreateViewForWidget(render_view_host->GetWidget());
danakja0bce4c952020-05-12 20:40:286687 rwh_view->SetSize(GetSizeForMainFrame());
lfgbede6392015-09-11 21:54:066688}
6689
6690bool WebContentsImpl::CreateRenderViewForRenderManager(
6691 RenderViewHost* render_view_host,
Antonio Gomesb3dd5fc2020-05-25 22:53:276692 const base::Optional<base::UnguessableToken>& opener_frame_token,
Daniel Chengabfdb002020-06-04 06:02:306693 int proxy_routing_id) {
lfgbede6392015-09-11 21:54:066694 TRACE_EVENT0("browser,navigation",
6695 "WebContentsImpl::CreateRenderViewForRenderManager");
6696
piman00cf9402017-04-03 17:09:206697 if (proxy_routing_id == MSG_ROUTING_NONE)
lfg9431efd2016-12-14 14:45:266698 CreateRenderWidgetHostViewForRenderManager(render_view_host);
lfg9431efd2016-12-14 14:45:266699
piman00cf9402017-04-03 17:09:206700 if (!static_cast<RenderViewHostImpl*>(render_view_host)
Daniel Chengabfdb002020-06-04 06:02:306701 ->CreateRenderView(opener_frame_token, proxy_routing_id,
Antonio Gomesb3dd5fc2020-05-25 22:53:276702 created_with_opener_)) {
[email protected]a4127722011-04-27 23:13:526703 return false;
[email protected]14392a52012-05-02 20:28:446704 }
W. James MacLean62198672019-06-04 16:46:106705 // Set the TextAutosizer state from the main frame's renderer on the new view,
6706 // but only if it's not for the main frame. Main frame renderers should create
6707 // this state themselves from up-to-date values, so we shouldn't override it
6708 // with the cached values.
6709 if (!render_view_host->GetMainFrame()) {
6710 render_view_host->Send(
6711 new PageMsg_UpdateTextAutosizerPageInfoForRemoteMainFrames(
6712 render_view_host->GetRoutingID(), text_autosizer_page_info_));
6713 }
[email protected]a4127722011-04-27 23:13:526714
Lucas Furukawa Gadaniaed1fed2017-10-13 17:34:146715 if (proxy_routing_id == MSG_ROUTING_NONE && node_.outer_web_contents())
6716 ReattachToOuterWebContentsFrame();
6717
avi2b177592014-12-10 02:08:026718 SetHistoryOffsetAndLengthForView(render_view_host,
6719 controller_.GetLastCommittedEntryIndex(),
6720 controller_.GetEntryCount());
6721
[email protected]a220b5932013-09-21 03:47:446722#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
[email protected]f8233cc2011-05-31 20:24:506723 // Force a ViewMsg_Resize to be sent, needed to make plugins show up on
6724 // linux. See crbug.com/83941.
avif9ab5d942015-10-15 14:05:446725 RenderWidgetHostView* rwh_view = render_view_host->GetWidget()->GetView();
[email protected]245f7d52011-11-28 15:36:446726 if (rwh_view) {
6727 if (RenderWidgetHost* render_widget_host = rwh_view->GetRenderWidgetHost())
Fady Samuel0b911822018-04-25 13:22:166728 render_widget_host->SynchronizeVisualProperties();
[email protected]245f7d52011-11-28 15:36:446729 }
[email protected]f8233cc2011-05-31 20:24:506730#endif
6731
[email protected]420ae012009-04-24 05:16:326732 return true;
6733}
6734
[email protected]82307f6b2014-08-07 03:30:126735bool WebContentsImpl::CreateRenderFrameForRenderManager(
6736 RenderFrameHost* render_frame_host,
arthursonzogni1efc7b962019-03-14 09:36:336737 int previous_routing_id,
Antonio Gomes9d150542020-05-25 18:32:116738 const base::Optional<base::UnguessableToken>& opener_frame_token,
japhete6adf142014-10-31 00:01:496739 int parent_routing_id,
alexmosa181efc2015-09-03 00:39:046740 int previous_sibling_routing_id) {
naskob8744d22014-08-28 17:07:436741 TRACE_EVENT0("browser,navigation",
6742 "WebContentsImpl::CreateRenderFrameForRenderManager");
[email protected]82307f6b2014-08-07 03:30:126743
6744 RenderFrameHostImpl* rfh =
6745 static_cast<RenderFrameHostImpl*>(render_frame_host);
Antonio Gomes9d150542020-05-25 18:32:116746 if (!rfh->CreateRenderFrame(previous_routing_id, opener_frame_token,
6747 parent_routing_id, previous_sibling_routing_id)) {
[email protected]82307f6b2014-08-07 03:30:126748 return false;
Antonio Gomes9d150542020-05-25 18:32:116749 }
[email protected]82307f6b2014-08-07 03:30:126750
6751 // TODO(nasko): When RenderWidgetHost is owned by RenderFrameHost, the passed
6752 // RenderFrameHost will have to be associated with the appropriate
6753 // RenderWidgetHostView or a new one should be created here.
6754
6755 return true;
6756}
6757
mfomitchev2b8b066a2016-01-28 19:23:156758#if defined(OS_ANDROID)
[email protected]fc2b46b2014-05-03 16:33:456759
[email protected]155c7f22013-12-09 17:07:186760base::android::ScopedJavaLocalRef<jobject>
6761WebContentsImpl::GetJavaWebContents() {
mostynb042582e2015-03-16 22:13:406762 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]0e813a52014-08-13 10:34:566763 return GetWebContentsAndroid()->GetJavaObject();
6764}
[email protected]155c7f22013-12-09 17:07:186765
[email protected]0e813a52014-08-13 10:34:566766WebContentsAndroid* WebContentsImpl::GetWebContentsAndroid() {
Kevin McNee576bb5d82019-05-29 16:47:516767 if (!web_contents_android_) {
6768 web_contents_android_ = std::make_unique<WebContentsAndroid>(this);
[email protected]155c7f22013-12-09 17:07:186769 }
Kevin McNee576bb5d82019-05-29 16:47:516770 return web_contents_android_.get();
6771}
6772
6773void WebContentsImpl::ClearWebContentsAndroid() {
6774 DCHECK_CURRENTLY_ON(BrowserThread::UI);
6775 web_contents_android_.reset();
[email protected]155c7f22013-12-09 17:07:186776}
6777
paulmeyerc0b762b2016-04-13 11:55:176778void WebContentsImpl::ActivateNearestFindResult(float x,
6779 float y) {
6780 GetOrCreateFindRequestManager()->ActivateNearestFindResult(x, y);
6781}
6782
6783void WebContentsImpl::RequestFindMatchRects(int current_version) {
6784 GetOrCreateFindRequestManager()->RequestFindMatchRects(current_version);
6785}
6786
rockot400ea35b2016-10-15 19:15:326787service_manager::InterfaceProvider* WebContentsImpl::GetJavaInterfaces() {
sammcf5f1b0f2016-09-20 23:05:116788 if (!java_interfaces_) {
Gyuyoung Kim6c9ce9022019-11-26 05:40:086789 mojo::PendingRemote<service_manager::mojom::InterfaceProvider> provider;
6790 BindInterfaceRegistryForWebContents(
6791 provider.InitWithNewPipeAndPassReceiver(), this);
rockot400ea35b2016-10-15 19:15:326792 java_interfaces_.reset(new service_manager::InterfaceProvider);
sammcf5f1b0f2016-09-20 23:05:116793 java_interfaces_->Bind(std::move(provider));
6794 }
6795 return java_interfaces_.get();
6796}
6797
Francois Doray6c26f3342018-08-24 17:17:226798#endif
6799
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:416800bool WebContentsImpl::CompletedFirstVisuallyNonEmptyPaint() {
Carlos Caballero91fffb22019-10-29 15:24:306801 return GetRenderViewHost()->did_first_visually_non_empty_paint();
spqchane72c3cb2017-06-30 23:02:106802}
6803
pkotwicz75ca8ffd2016-02-16 23:10:196804void WebContentsImpl::OnDidDownloadImage(
Avi Drissmana5a52dd2018-03-27 03:39:026805 ImageDownloadCallback callback,
pkotwicz75ca8ffd2016-02-16 23:10:196806 int id,
6807 const GURL& image_url,
leon.hancbc4bc3c2016-02-26 07:08:526808 int32_t http_status_code,
leon.hanc2228532016-08-16 05:59:186809 const std::vector<SkBitmap>& images,
6810 const std::vector<gfx::Size>& original_image_sizes) {
Avi Drissmana5a52dd2018-03-27 03:39:026811 std::move(callback).Run(id, http_status_code, image_url, images,
6812 original_image_sizes);
pkotwicz75ca8ffd2016-02-16 23:10:196813}
6814
[email protected]6fba26d2014-04-29 09:38:286815void WebContentsImpl::OnDialogClosed(int render_process_id,
6816 int render_frame_id,
Dave Tapuskacdf545cc2020-01-23 18:38:526817 JavaScriptDialogCallback response_callback,
Avi Drissman1a55a9d62020-03-10 18:56:456818 base::ScopedClosureRunner fullscreen_block,
[email protected]87de04b02014-04-08 22:14:496819 bool dialog_was_suppressed,
[email protected]b172aee2012-04-10 17:05:266820 bool success,
[email protected]fcf75d42013-12-03 20:11:266821 const base::string16& user_input) {
[email protected]6fba26d2014-04-29 09:38:286822 RenderFrameHostImpl* rfh = RenderFrameHostImpl::FromID(render_process_id,
6823 render_frame_id);
[email protected]87de04b02014-04-08 22:14:496824 last_dialog_suppressed_ = dialog_was_suppressed;
Avi Drissman1a55a9d62020-03-10 18:56:456825 fullscreen_block.RunAndReset();
[email protected]87de04b02014-04-08 22:14:496826
Charlie Reis96077362019-07-04 00:34:046827 javascript_dialog_navigation_deferrer_.reset();
6828
[email protected]beb440c2009-11-06 04:08:546829 if (is_showing_before_unload_dialog_ && !success) {
clamybc6f4152016-04-01 20:14:236830 // It is possible for the current RenderFrameHost to have changed in the
6831 // meantime. Do not reset the navigation state in that case.
6832 if (rfh && rfh == rfh->frame_tree_node()->current_frame_host()) {
clamy44e84ce2016-02-22 15:38:256833 rfh->frame_tree_node()->BeforeUnloadCanceled();
clamybc6f4152016-04-01 20:14:236834 controller_.DiscardNonCommittedEntries();
6835 }
[email protected]ec8e8b02013-06-19 04:57:106836
Charles Reis15d60b132017-11-03 17:43:476837 // Update the URL display either way, to avoid showing a stale URL.
6838 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
6839
ericwilligersde386342016-10-19 02:35:096840 for (auto& observer : observers_)
6841 observer.BeforeUnloadDialogCancelled();
[email protected]beb440c2009-11-06 04:08:546842 }
[email protected]87de04b02014-04-08 22:14:496843
Dave Tapuskacdf545cc2020-01-23 18:38:526844 std::move(response_callback).Run(success, user_input);
Pavel Feldman3c1842b2017-08-02 05:00:166845
Dave Tapuskacdf545cc2020-01-23 18:38:526846 std::vector<protocol::PageHandler*> page_handlers =
6847 protocol::PageHandler::EnabledForWebContents(this);
6848 for (auto* handler : page_handlers)
6849 handler->DidCloseJavaScriptDialog(success, user_input);
avi1c51fb62017-02-27 20:43:036850
6851 is_showing_javascript_dialog_ = false;
6852 is_showing_before_unload_dialog_ = false;
[email protected]beb440c2009-11-06 04:08:546853}
6854
[email protected]1ac10dca2013-08-20 20:47:046855bool WebContentsImpl::IsHidden() {
Francois Doraye6161152018-03-27 22:05:376856 return !IsBeingCaptured() && visibility_ != Visibility::VISIBLE;
[email protected]1ac10dca2013-08-20 20:47:046857}
6858
rob97250742015-12-10 17:45:156859int WebContentsImpl::GetOuterDelegateFrameTreeNodeId() {
lfg601233692017-03-06 22:45:446860 return node_.outer_contents_frame_tree_node_id();
lazyboy6ec48b2a2015-06-29 15:18:146861}
6862
ekaramadaeb3c5c2016-11-09 03:22:356863RenderWidgetHostImpl* WebContentsImpl::GetFullscreenRenderWidgetHost() const {
6864 return RenderWidgetHostImpl::FromID(fullscreen_widget_process_id_,
6865 fullscreen_widget_routing_id_);
6866}
6867
[email protected]b0936d22013-11-28 06:47:366868RenderFrameHostManager* WebContentsImpl::GetRenderManager() const {
[email protected]fa944cb82013-11-15 17:51:216869 return frame_tree_.root()->render_manager();
6870}
6871
[email protected]f8497342013-02-05 22:15:026872BrowserPluginGuest* WebContentsImpl::GetBrowserPluginGuest() const {
[email protected]7a846df2012-09-20 19:17:396873 return browser_plugin_guest_.get();
6874}
6875
Albert J. Wongc55cc64d2018-10-12 02:50:046876void WebContentsImpl::SetBrowserPluginGuest(
6877 std::unique_ptr<BrowserPluginGuest> guest) {
6878 DCHECK(!browser_plugin_guest_);
6879 DCHECK(guest);
6880 browser_plugin_guest_ = std::move(guest);
[email protected]738f57a2013-06-29 21:06:546881}
6882
Aidan Wolter52bcc12a2018-11-14 03:27:296883base::UnguessableToken WebContentsImpl::GetAudioGroupId() {
Aidan Wolter52bcc12a2018-11-14 03:27:296884 return GetAudioStreamFactory()->group_id();
6885}
6886
Miyoung Shin5709ab02020-02-19 06:50:416887const std::vector<blink::mojom::FaviconURLPtr>&
6888WebContentsImpl::GetFaviconURLs() {
Mounir Lamouri7b4a1f232019-12-23 16:32:106889 return favicon_urls_;
6890}
6891
[email protected]f8497342013-02-05 22:15:026892BrowserPluginEmbedder* WebContentsImpl::GetBrowserPluginEmbedder() const {
[email protected]7a846df2012-09-20 19:17:396893 return browser_plugin_embedder_.get();
6894}
[email protected]8ff00d72012-10-23 19:12:216895
fsamuel60b42282015-03-10 03:29:146896void WebContentsImpl::CreateBrowserPluginEmbedderIfNecessary() {
6897 if (browser_plugin_embedder_)
6898 return;
6899 browser_plugin_embedder_.reset(BrowserPluginEmbedder::Create(this));
6900}
6901
danakja0bce4c952020-05-12 20:40:286902gfx::Size WebContentsImpl::GetSizeForMainFrame() {
6903 if (delegate_) {
6904 // The delegate has a chance to specify a size independent of the UI.
6905 gfx::Size delegate_size = delegate_->GetSizeForNewRenderView(this);
6906 if (!delegate_size.IsEmpty())
6907 return delegate_size;
6908 }
6909
6910 // Device emulation, when enabled, can specify a size independent of the UI.
6911 if (!device_emulation_size_.IsEmpty())
6912 return device_emulation_size_;
6913
6914 return GetContainerBounds().size();
[email protected]dc0fd432013-08-27 15:29:216915}
6916
[email protected]ae7eeda2014-07-04 01:53:266917void WebContentsImpl::OnFrameRemoved(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:096918 for (auto& observer : observers_)
6919 observer.FrameDeleted(render_frame_host);
[email protected]9b159a52013-10-03 17:24:556920}
6921
[email protected]222f5822014-02-05 23:40:496922void WebContentsImpl::OnPreferredSizeChanged(const gfx::Size& old_size) {
6923 if (!delegate_)
6924 return;
6925 const gfx::Size new_size = GetPreferredSize();
6926 if (new_size != old_size)
6927 delegate_->UpdatePreferredSize(this, new_size);
6928}
6929
Denis Kuznetsov [CET]2c6f0159f2020-05-18 14:18:166930std::unique_ptr<WebUIImpl> WebContentsImpl::CreateWebUI(const GURL& url) {
6931 std::unique_ptr<WebUIImpl> web_ui = std::make_unique<WebUIImpl>(this);
Lei Zhangee3b63ad2018-06-06 23:25:316932 std::unique_ptr<WebUIController> controller(
avie865b1d2016-10-24 19:42:596933 WebUIControllerFactoryRegistry::GetInstance()
Lei Zhangee3b63ad2018-06-06 23:25:316934 ->CreateWebUIControllerForURL(web_ui.get(), url));
dbeama1b926a2015-08-31 23:17:516935 if (controller) {
Lei Zhangee3b63ad2018-06-06 23:25:316936 web_ui->SetController(std::move(controller));
dbeama1b926a2015-08-31 23:17:516937 return web_ui;
6938 }
6939
avie865b1d2016-10-24 19:42:596940 return nullptr;
dbeama1b926a2015-08-31 23:17:516941}
6942
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:416943FindRequestManager* WebContentsImpl::GetFindRequestManager() {
6944 for (auto* contents = this; contents;
paulmeyerfeafc2d2017-04-25 21:46:406945 contents = contents->GetOuterWebContents()) {
6946 if (contents->find_request_manager_)
6947 return contents->find_request_manager_.get();
6948 }
6949
6950 return nullptr;
6951}
6952
paulmeyerc0b762b2016-04-13 11:55:176953FindRequestManager* WebContentsImpl::GetOrCreateFindRequestManager() {
paulmeyerfeafc2d2017-04-25 21:46:406954 if (FindRequestManager* manager = GetFindRequestManager())
6955 return manager;
6956
Ehsan Karamad6beb2ea2018-11-25 18:15:136957 DCHECK(!browser_plugin_guest_ || GetOuterWebContents());
6958
paulmeyerfeafc2d2017-04-25 21:46:406959 // No existing FindRequestManager found, so one must be created.
6960 find_request_manager_.reset(new FindRequestManager(this));
6961
6962 // Concurrent find sessions must not overlap, so destroy any existing
6963 // FindRequestManagers in any inner WebContentses.
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:166964 for (WebContents* contents : GetWebContentsAndAllInner()) {
6965 auto* web_contents_impl = static_cast<WebContentsImpl*>(contents);
6966 if (web_contents_impl == this)
paulmeyerfeafc2d2017-04-25 21:46:406967 continue;
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:166968 if (web_contents_impl->find_request_manager_) {
6969 web_contents_impl->find_request_manager_->StopFinding(
6970 STOP_FIND_ACTION_CLEAR_SELECTION);
6971 web_contents_impl->find_request_manager_.release();
paulmeyerfeafc2d2017-04-25 21:46:406972 }
6973 }
paulmeyerc0b762b2016-04-13 11:55:176974
6975 return find_request_manager_.get();
6976}
6977
6978void WebContentsImpl::NotifyFindReply(int request_id,
6979 int number_of_matches,
6980 const gfx::Rect& selection_rect,
6981 int active_match_ordinal,
6982 bool final_update) {
Sebastien Marchandcf97ed52017-07-24 23:50:346983 if (delegate_ && !is_being_destroyed_ &&
Lukasz Anforowicze9ae3722017-09-29 17:37:386984 !GetMainFrame()->GetProcess()->FastShutdownStarted()) {
paulmeyerc0b762b2016-04-13 11:55:176985 delegate_->FindReply(this, request_id, number_of_matches, selection_rect,
6986 active_match_ordinal, final_update);
6987 }
6988}
6989
ortuno467e5792016-06-10 04:32:396990void WebContentsImpl::IncrementBluetoothConnectedDeviceCount() {
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 state changes.
6997 bluetooth_connected_device_count_++;
6998 if (bluetooth_connected_device_count_ == 1) {
Francois Doray66766a572019-12-17 20:56:496999 OnIsConnectedToBluetoothDeviceChanged(true);
ortuno467e5792016-06-10 04:32:397000 }
7001}
7002
7003void WebContentsImpl::DecrementBluetoothConnectedDeviceCount() {
7004 // Trying to invalidate the tab state while being destroyed could result in a
7005 // use after free.
7006 if (IsBeingDestroyed()) {
7007 return;
7008 }
7009 // Notify for UI updates if the state changes.
Lukasz Anforowicze9ae3722017-09-29 17:37:387010 DCHECK_NE(bluetooth_connected_device_count_, 0u);
ortuno467e5792016-06-10 04:32:397011 bluetooth_connected_device_count_--;
7012 if (bluetooth_connected_device_count_ == 0) {
Francois Doray66766a572019-12-17 20:56:497013 OnIsConnectedToBluetoothDeviceChanged(false);
7014 }
7015}
7016
7017void WebContentsImpl::OnIsConnectedToBluetoothDeviceChanged(
7018 bool is_connected_to_bluetooth_device) {
7019 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
7020 for (auto& observer : observers_) {
7021 observer.OnIsConnectedToBluetoothDeviceChanged(
7022 is_connected_to_bluetooth_device);
ortuno467e5792016-06-10 04:32:397023 }
7024}
7025
Reilly Grant5e7c79b22019-04-09 17:26:207026void WebContentsImpl::IncrementSerialActiveFrameCount() {
7027 // Trying to invalidate the tab state while being destroyed could result in a
7028 // use after free.
7029 if (IsBeingDestroyed())
7030 return;
7031
7032 // Notify for UI updates if the state changes.
7033 serial_active_frame_count_++;
7034 if (serial_active_frame_count_ == 1)
7035 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
7036}
7037
7038void WebContentsImpl::DecrementSerialActiveFrameCount() {
7039 // 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.
7045 DCHECK_NE(0u, serial_active_frame_count_);
7046 serial_active_frame_count_--;
7047 if (serial_active_frame_count_ == 0)
7048 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
7049}
7050
Matt Reynoldse8c6c1f2019-11-02 09:53:537051void WebContentsImpl::IncrementHidActiveFrameCount() {
7052 // Trying to invalidate the tab state while being destroyed could result in a
7053 // use after free.
7054 if (IsBeingDestroyed())
7055 return;
7056
7057 // Notify for UI updates if the active frame count transitions from zero to
7058 // non-zero.
7059 hid_active_frame_count_++;
7060 if (hid_active_frame_count_ == 1)
7061 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
7062}
7063
7064void WebContentsImpl::DecrementHidActiveFrameCount() {
7065 // Trying to invalidate the tab state while being destroyed could result in a
7066 // use after free.
7067 if (IsBeingDestroyed())
7068 return;
7069
7070 // Notify for UI updates if the active frame count transitions from non-zero
7071 // to zero.
7072 DCHECK_NE(0u, hid_active_frame_count_);
7073 hid_active_frame_count_--;
7074 if (hid_active_frame_count_ == 0)
7075 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
7076}
7077
Marijn Kruisselbrink29051042019-08-06 22:56:557078void WebContentsImpl::IncrementNativeFileSystemHandleCount() {
7079 // Trying to invalidate the tab state while being destroyed could result in a
7080 // use after free.
7081 if (IsBeingDestroyed())
7082 return;
7083
7084 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7085 // to update both the tab-level usage indicator and the usage indicator in the
7086 // omnibox.
7087 native_file_system_handle_count_++;
7088 if (native_file_system_handle_count_ == 1) {
7089 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7090 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7091 }
7092}
7093
7094void WebContentsImpl::DecrementNativeFileSystemHandleCount() {
7095 // Trying to invalidate the tab state while being destroyed could result in a
7096 // use after free.
7097 if (IsBeingDestroyed())
7098 return;
7099
7100 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7101 // to update both the tab-level usage indicator and the usage indicator in the
7102 // omnibox.
7103 DCHECK_NE(0u, native_file_system_handle_count_);
7104 native_file_system_handle_count_--;
7105 if (native_file_system_handle_count_ == 0) {
7106 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7107 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7108 }
7109}
7110
zqzhang8ac49002017-03-16 21:51:357111void WebContentsImpl::SetHasPersistentVideo(bool has_persistent_video) {
7112 if (has_persistent_video_ == has_persistent_video)
mlamouri5cd9ae82017-02-18 11:05:097113 return;
7114
zqzhang8ac49002017-03-16 21:51:357115 has_persistent_video_ = has_persistent_video;
mlamouri5cd9ae82017-02-18 11:05:097116 NotifyPreferencesChanged();
zqzhang8ac49002017-03-16 21:51:357117 media_web_contents_observer()->RequestPersistentVideo(has_persistent_video);
mlamouri5cd9ae82017-02-18 11:05:097118}
7119
Ian Vollick5d5c37f2019-06-19 22:50:577120void WebContentsImpl::SetSpatialNavigationDisabled(bool disabled) {
7121 if (is_spatial_navigation_disabled_ == disabled)
7122 return;
7123
7124 is_spatial_navigation_disabled_ = disabled;
7125 NotifyPreferencesChanged();
7126}
7127
paulmeyerfeafc2d2017-04-25 21:46:407128void WebContentsImpl::BrowserPluginGuestWillDetach() {
7129 WebContentsImpl* outermost = GetOutermostWebContents();
7130 if (this != outermost && ContainsOrIsFocusedWebContents())
7131 outermost->SetAsFocusedWebContentsIfNecessary();
7132}
7133
Becca Hughes112832e2019-06-11 17:19:027134PictureInPictureResult WebContentsImpl::EnterPictureInPicture(
Mounir Lamouri11e9ef42018-05-22 03:10:167135 const viz::SurfaceId& surface_id,
7136 const gfx::Size& natural_size) {
François Beaufortf09e4462019-01-18 14:34:517137 return delegate_
7138 ? delegate_->EnterPictureInPicture(this, surface_id, natural_size)
Becca Hughes112832e2019-06-11 17:19:027139 : PictureInPictureResult::kNotSupported;
Mounir Lamouri11e9ef42018-05-22 03:10:167140}
7141
Mounir Lamouri6d759e12018-05-16 20:01:307142void WebContentsImpl::ExitPictureInPicture() {
7143 if (delegate_)
7144 delegate_->ExitPictureInPicture();
7145}
7146
paulmeyerc0b762b2016-04-13 11:55:177147#if defined(OS_ANDROID)
7148void WebContentsImpl::NotifyFindMatchRectsReply(
7149 int version,
7150 const std::vector<gfx::RectF>& rects,
7151 const gfx::RectF& active_rect) {
7152 if (delegate_)
7153 delegate_->FindMatchRectsReply(this, version, rects, active_rect);
7154}
7155#endif
7156
[email protected]34ff1cfc2014-08-20 06:16:057157void WebContentsImpl::SetForceDisableOverscrollContent(bool force_disable) {
7158 force_disable_overscroll_content_ = force_disable;
7159 if (view_)
7160 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
7161}
7162
Jianzhou Fengd8720c72018-01-18 03:06:307163bool WebContentsImpl::SetDeviceEmulationSize(const gfx::Size& new_size) {
7164 device_emulation_size_ = new_size;
7165 RenderWidgetHostView* rwhv = GetMainFrame()->GetView();
7166
7167 const gfx::Size current_size = rwhv->GetViewBounds().size();
7168 if (view_size_before_emulation_.IsEmpty())
7169 view_size_before_emulation_ = current_size;
7170
7171 if (current_size != new_size)
7172 rwhv->SetSize(new_size);
7173
7174 return current_size != new_size;
7175}
7176
7177void WebContentsImpl::ClearDeviceEmulationSize() {
7178 RenderWidgetHostView* rwhv = GetMainFrame()->GetView();
7179 // WebContentsView could get resized during emulation, which also resizes
7180 // RWHV. If it happens, assume user would like to keep using the size after
7181 // emulation.
7182 // TODO(jzfeng): Prohibit resizing RWHV through any other means (at least when
7183 // WebContentsView size changes).
Dmitry Gozmanc63707182018-03-06 00:09:397184 if (!view_size_before_emulation_.IsEmpty() && rwhv &&
7185 rwhv->GetViewBounds().size() == device_emulation_size_) {
Jianzhou Fengd8720c72018-01-18 03:06:307186 rwhv->SetSize(view_size_before_emulation_);
Dmitry Gozmanc63707182018-03-06 00:09:397187 }
Jianzhou Fengd8720c72018-01-18 03:06:307188 device_emulation_size_ = gfx::Size();
7189 view_size_before_emulation_ = gfx::Size();
7190}
7191
Max Morin5bc74f52018-05-09 07:00:217192ForwardingAudioStreamFactory* WebContentsImpl::GetAudioStreamFactory() {
7193 if (!audio_stream_factory_) {
7194 audio_stream_factory_.emplace(
7195 this,
Max Morinddebb972018-09-20 10:04:147196 // BrowserMainLoop::GetInstance() may be null in unit tests.
7197 BrowserMainLoop::GetInstance()
7198 ? static_cast<media::UserInputMonitorBase*>(
7199 BrowserMainLoop::GetInstance()->user_input_monitor())
7200 : nullptr,
Ken Rockot72964402019-12-06 10:40:517201 AudioStreamBrokerFactory::CreateImpl());
Max Morin5bc74f52018-05-09 07:00:217202 }
7203
7204 return &*audio_stream_factory_;
7205}
7206
dalecurtis88c240072015-12-09 02:11:187207void WebContentsImpl::MediaStartedPlaying(
billorr21c005d2016-11-17 03:57:047208 const WebContentsObserver::MediaPlayerInfo& media_info,
Mounir Lamouri0f5bdf52019-04-04 16:32:357209 const MediaPlayerId& id) {
billorr21c005d2016-11-17 03:57:047210 if (media_info.has_video)
7211 currently_playing_video_count_++;
7212
ericwilligersde386342016-10-19 02:35:097213 for (auto& observer : observers_)
billorr21c005d2016-11-17 03:57:047214 observer.MediaStartedPlaying(media_info, id);
dalecurtis88c240072015-12-09 02:11:187215}
7216
7217void WebContentsImpl::MediaStoppedPlaying(
billorr21c005d2016-11-17 03:57:047218 const WebContentsObserver::MediaPlayerInfo& media_info,
Mounir Lamouri0f5bdf52019-04-04 16:32:357219 const MediaPlayerId& id,
Becca Hughes220bfc102017-11-14 18:24:077220 WebContentsObserver::MediaStoppedReason reason) {
billorr21c005d2016-11-17 03:57:047221 if (media_info.has_video)
7222 currently_playing_video_count_--;
7223
ericwilligersde386342016-10-19 02:35:097224 for (auto& observer : observers_)
Becca Hughes220bfc102017-11-14 18:24:077225 observer.MediaStoppedPlaying(media_info, id, reason);
billorr21c005d2016-11-17 03:57:047226}
7227
Mounir Lamouri0f5bdf52019-04-04 16:32:357228void WebContentsImpl::MediaResized(const gfx::Size& size,
7229 const MediaPlayerId& id) {
peconn257951522017-06-09 18:24:597230 cached_video_sizes_[id] = size;
7231
7232 for (auto& observer : observers_)
7233 observer.MediaResized(size, id);
7234}
7235
Peter E Conneccb34c22017-09-08 09:37:587236void WebContentsImpl::MediaEffectivelyFullscreenChanged(bool is_fullscreen) {
7237 for (auto& observer : observers_)
7238 observer.MediaEffectivelyFullscreenChanged(is_fullscreen);
7239}
7240
Peter Conn31c726a2017-08-17 11:07:347241base::Optional<gfx::Size> WebContentsImpl::GetFullscreenVideoSize() {
Mounir Lamouri0f5bdf52019-04-04 16:32:357242 base::Optional<MediaPlayerId> id =
Peter Conn31c726a2017-08-17 11:07:347243 media_web_contents_observer_->GetFullscreenVideoMediaPlayerId();
Jan Wilken Dörrie531be7ca2019-06-07 10:05:577244 if (id && base::Contains(cached_video_sizes_, id.value()))
Peter Conn31c726a2017-08-17 11:07:347245 return base::Optional<gfx::Size>(cached_video_sizes_[id.value()]);
Lei Zhang6410ec1a2019-01-31 21:38:587246 return base::nullopt;
peconn257951522017-06-09 18:24:597247}
7248
billorr21c005d2016-11-17 03:57:047249int WebContentsImpl::GetCurrentlyPlayingVideoCount() {
7250 return currently_playing_video_count_;
dalecurtis88c240072015-12-09 02:11:187251}
7252
Raymond Toye413650c2018-08-31 00:12:477253void WebContentsImpl::AudioContextPlaybackStarted(RenderFrameHost* host,
7254 int context_id) {
7255 WebContentsObserver::AudioContextId audio_context_id(host, context_id);
7256 for (auto& observer : observers_)
7257 observer.AudioContextPlaybackStarted(audio_context_id);
7258}
7259
7260void WebContentsImpl::AudioContextPlaybackStopped(RenderFrameHost* host,
7261 int context_id) {
7262 WebContentsObserver::AudioContextId audio_context_id(host, context_id);
7263 for (auto& observer : observers_)
7264 observer.AudioContextPlaybackStopped(audio_context_id);
7265}
7266
Chris Hamilton16ca64a2020-05-14 23:13:177267void WebContentsImpl::OnFrameAudioStateChanged(RenderFrameHost* host,
7268 bool is_audible) {
7269 for (auto& observer : observers_)
7270 observer.OnFrameAudioStateChanged(host, is_audible);
7271}
7272
evliu7f736f02019-11-07 17:43:507273media::MediaMetricsProvider::RecordAggregateWatchTimeCallback
7274WebContentsImpl::GetRecordAggregateWatchTimeCallback() {
Becca Hughes53652442020-03-17 15:35:427275 if (!delegate_ || !delegate_->GetDelegateWeakPtr())
7276 return base::DoNothing();
7277
evliu7f736f02019-11-07 17:43:507278 return base::BindRepeating(
Becca Hughes53652442020-03-17 15:35:427279 [](base::WeakPtr<WebContentsDelegate> delegate, GURL last_committed_url,
7280 base::TimeDelta total_watch_time, base::TimeDelta time_stamp,
7281 bool has_video, bool has_audio) {
evliua283c9e2019-11-08 22:57:227282 content::MediaPlayerWatchTime watch_time(
7283 last_committed_url, last_committed_url.GetOrigin(),
7284 total_watch_time, time_stamp, has_video, has_audio);
evliu7f736f02019-11-07 17:43:507285
7286 // Save the watch time if the delegate is still alive.
7287 if (delegate)
7288 delegate->MediaWatchTimeChanged(watch_time);
7289 },
Becca Hughes53652442020-03-17 15:35:427290 delegate_->GetDelegateWeakPtr(), GetMainFrameLastCommittedURL());
evliu7f736f02019-11-07 17:43:507291}
7292
Ehsan Karamad1c631762019-05-13 23:04:017293RenderFrameHostImpl* WebContentsImpl::GetMainFrameForInnerDelegate(
7294 FrameTreeNode* frame_tree_node) {
7295 if (auto* web_contents = node_.GetInnerWebContentsInFrame(frame_tree_node))
7296 return web_contents->GetMainFrame();
7297 return nullptr;
7298}
7299
John Budorickee1c9512019-10-17 15:32:197300bool WebContentsImpl::IsFrameLowPriority(
7301 const RenderFrameHost* render_frame_host) {
7302 if (!delegate_)
7303 return false;
7304 return delegate_->IsFrameLowPriority(this, render_frame_host);
7305}
7306
Roger Tawa03ffdbd2020-01-16 18:12:547307void WebContentsImpl::IsClipboardPasteAllowed(
7308 const GURL& url,
7309 const ui::ClipboardFormatType& data_type,
7310 const std::string& data,
7311 IsClipboardPasteAllowedCallback callback) {
7312 GetContentClient()->browser()->IsClipboardPasteAllowed(
7313 this, url, data_type, data, std::move(callback));
7314}
7315
Lan Weif81c6e7c2020-02-12 16:46:097316bool WebContentsImpl::HasSeenRecentScreenOrientationChange() {
7317 static constexpr base::TimeDelta kMaxInterval =
7318 base::TimeDelta::FromSeconds(1);
7319 base::TimeDelta delta =
7320 ui::EventTimeForNow() - last_screen_orientation_change_time_;
7321 // Return whether there is a screen orientation change happened in the recent
7322 // 1 second.
7323 return delta <= kMaxInterval;
7324}
7325
7326void WebContentsImpl::DidChangeScreenOrientation() {
7327 last_screen_orientation_change_time_ = ui::EventTimeForNow();
7328}
7329
Miyoung Shin8f2e1832020-04-27 09:00:027330bool WebContentsImpl::ShowPopupMenu(
Miyoung Shin4d947d22020-04-24 04:48:337331 RenderFrameHostImpl* render_frame_host,
Miyoung Shin8f2e1832020-04-27 09:00:027332 mojo::PendingRemote<blink::mojom::PopupMenuClient>* popup_client,
Miyoung Shin4d947d22020-04-24 04:48:337333 const gfx::Rect& bounds,
7334 int32_t item_height,
7335 double font_size,
7336 int32_t selected_item,
7337 std::vector<blink::mojom::MenuItemPtr>* menu_items,
7338 bool right_aligned,
7339 bool allow_multiple_selection) {
7340 for (auto& observer : observers_) {
Miyoung Shin8f2e1832020-04-27 09:00:027341 if (observer.ShowPopupMenu(render_frame_host, popup_client, bounds,
7342 item_height, font_size, selected_item,
7343 menu_items, right_aligned,
7344 allow_multiple_selection)) {
Miyoung Shin4d947d22020-04-24 04:48:337345 return true;
7346 }
7347 }
7348 return false;
7349}
7350
Francois Doraye6161152018-03-27 22:05:377351void WebContentsImpl::UpdateWebContentsVisibility(Visibility visibility) {
Francois Doray3f2afbd2018-04-06 19:18:187352 // Occlusion is disabled when |features::kWebContentsOcclusion| is disabled
7353 // (for power and speed impact assessment) or when
7354 // |switches::kDisableBackgroundingOccludedWindowsForTesting| is specified on
7355 // the command line (to avoid flakiness in browser tests).
7356 const bool occlusion_is_disabled =
7357 !base::FeatureList::IsEnabled(features::kWebContentsOcclusion) ||
Francois Doraye6161152018-03-27 22:05:377358 base::CommandLine::ForCurrentProcess()->HasSwitch(
7359 switches::kDisableBackgroundingOccludedWindowsForTesting);
7360 if (occlusion_is_disabled && visibility == Visibility::OCCLUDED)
7361 visibility = Visibility::VISIBLE;
7362
tapted65ff2ea72016-03-01 23:39:007363 if (!did_first_set_visible_) {
Francois Doraye6161152018-03-27 22:05:377364 if (visibility == Visibility::VISIBLE) {
7365 // A WebContents created with CreateParams::initially_hidden = false
7366 // starts with GetVisibility() == Visibility::VISIBLE even though it is
7367 // not really visible. Call WasShown() when it becomes visible for real as
7368 // the page load mechanism and some WebContentsObserver rely on that.
tapted65ff2ea72016-03-01 23:39:007369 WasShown();
Francois Dorayfe4a1772018-02-17 04:17:097370 did_first_set_visible_ = true;
tapted65ff2ea72016-03-01 23:39:007371 }
Francois Doraye6161152018-03-27 22:05:377372
7373 // Trust the initial visibility of the WebContents and do not switch it to
7374 // HIDDEN or OCCLUDED before it becomes VISIBLE for real. Doing so would
7375 // result in destroying resources that would immediately be recreated (e.g.
7376 // UpdateWebContents(HIDDEN) can be called when a WebContents is added to a
7377 // hidden window that is about to be shown).
7378
tapted65ff2ea72016-03-01 23:39:007379 return;
7380 }
Francois Doraye6161152018-03-27 22:05:377381
7382 if (visibility == visibility_)
tapted65ff2ea72016-03-01 23:39:007383 return;
7384
Collin Baker989e0882019-11-01 01:27:177385 UpdateVisibilityAndNotifyPageAndView(visibility);
tapted65ff2ea72016-03-01 23:39:007386}
7387
aelias5252baa2016-04-10 01:18:027388void WebContentsImpl::UpdateOverridingUserAgent() {
mlamouri5cd9ae82017-02-18 11:05:097389 NotifyPreferencesChanged();
aelias5252baa2016-04-10 01:18:027390}
7391
avid53461d2016-02-25 17:15:047392void WebContentsImpl::SetJavaScriptDialogManagerForTesting(
7393 JavaScriptDialogManager* dialog_manager) {
7394 dialog_manager_ = dialog_manager;
7395}
7396
Julie Jeongeun Kim7d0986172019-12-04 03:17:257397void WebContentsImpl::RemoveReceiverSet(const std::string& interface_name) {
7398 auto it = receiver_sets_.find(interface_name);
7399 if (it != receiver_sets_.end())
7400 receiver_sets_.erase(it);
rockotf62002a2016-09-15 00:08:597401}
7402
nzolghadrd87a308d2016-12-07 15:45:567403bool WebContentsImpl::AddDomainInfoToRapporSample(rappor::Sample* sample) {
nzolghadrbbffc6c2017-05-25 17:56:397404 // Here we associate this metric to the main frame URL regardless of what
7405 // caused it.
nzolghadrd87a308d2016-12-07 15:45:567406 sample->SetStringField("Domain", ::rappor::GetDomainAndRegistrySampleFromGURL(
7407 GetLastCommittedURL()));
nzolghadrd87a308d2016-12-07 15:45:567408 return true;
7409}
7410
falken52a56e32016-12-08 05:02:407411void WebContentsImpl::ShowInsecureLocalhostWarningIfNeeded() {
7412 bool allow_localhost = base::CommandLine::ForCurrentProcess()->HasSwitch(
7413 switches::kAllowInsecureLocalhost);
7414 if (!allow_localhost)
7415 return;
7416
7417 content::NavigationEntry* entry = GetController().GetLastCommittedEntry();
Rob Wuf79b3ba2018-01-14 01:54:317418 if (!entry || !net::IsLocalhost(entry->GetURL()))
falken52a56e32016-12-08 05:02:407419 return;
7420
7421 content::SSLStatus ssl_status = entry->GetSSL();
Matt Mueller936511442019-09-03 18:15:127422 if (!net::IsCertStatusError(ssl_status.cert_status))
falken52a56e32016-12-08 05:02:407423 return;
7424
7425 GetMainFrame()->AddMessageToConsole(
Abhijeet Kandalkara5928a0a2019-03-13 05:04:427426 blink::mojom::ConsoleMessageLevel::kWarning,
falken52a56e32016-12-08 05:02:407427 base::StringPrintf("This site does not have a valid SSL "
7428 "certificate! Without SSL, your site's and "
7429 "visitors' data is vulnerable to theft and "
7430 "tampering. Get a valid SSL certificate before"
7431 " releasing your website to the public."));
7432}
7433
ekaramadf6750aa2017-06-06 18:29:427434bool WebContentsImpl::IsShowingContextMenuOnPage() const {
7435 return showing_context_menu_;
7436}
7437
Min Qina904f3302018-02-13 23:33:347438download::DownloadUrlParameters::RequestHeadersType
7439WebContentsImpl::ParseDownloadHeaders(const std::string& headers) {
7440 download::DownloadUrlParameters::RequestHeadersType request_headers;
Megan Jablonski2f6a4c52017-07-10 23:01:257441 for (const base::StringPiece& key_value : base::SplitStringPiece(
7442 headers, "\r\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
7443 std::vector<std::string> pair = base::SplitString(
7444 key_value, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
7445 if (2ul == pair.size())
7446 request_headers.push_back(make_pair(pair[0], pair[1]));
7447 }
7448 return request_headers;
7449}
7450
lukasza6f8ac622017-06-06 03:10:207451void WebContentsImpl::SetOpenerForNewContents(FrameTreeNode* opener,
7452 bool opener_suppressed) {
7453 if (opener) {
7454 FrameTreeNode* new_root = GetFrameTree()->root();
7455
7456 // For the "original opener", track the opener's main frame instead, because
7457 // if the opener is a subframe, the opener tracking could be easily bypassed
7458 // by spawning from a subframe and deleting the subframe.
7459 // https://crbug.com/705316
7460 new_root->SetOriginalOpener(opener->frame_tree()->root());
7461
7462 if (!opener_suppressed) {
7463 new_root->SetOpener(opener);
7464 created_with_opener_ = true;
7465 }
7466 }
7467}
7468
Mounir Lamouri0f5bdf52019-04-04 16:32:357469void WebContentsImpl::MediaMutedStatusChanged(const MediaPlayerId& id,
7470 bool muted) {
Becca Hughes9f6fd4b82017-06-15 10:01:407471 for (auto& observer : observers_)
7472 observer.MediaMutedStatusChanged(id, muted);
7473}
7474
EhsanK2075c7e2017-08-21 02:42:397475void WebContentsImpl::SetVisibilityForChildViews(bool visible) {
7476 GetMainFrame()->SetVisibilityForChildViews(visible);
7477}
7478
Alison Maher7f366dc62020-03-03 19:46:007479void WebContentsImpl::OnNativeThemeUpdated(ui::NativeTheme* observed_theme) {
7480 DCHECK(native_theme_observer_.IsObserving(observed_theme));
7481
7482 bool using_dark_colors = observed_theme->ShouldUseDarkColors();
7483 ui::NativeTheme::PreferredColorScheme preferred_color_scheme =
7484 observed_theme->GetPreferredColorScheme();
7485 bool preferences_changed = false;
7486
7487 if (using_dark_colors_ != using_dark_colors) {
7488 using_dark_colors_ = using_dark_colors;
7489 preferences_changed = true;
7490 }
7491 if (preferred_color_scheme_ != preferred_color_scheme) {
7492 preferred_color_scheme_ = preferred_color_scheme;
7493 preferences_changed = true;
7494 }
7495
7496 if (preferences_changed)
7497 NotifyPreferencesChanged();
7498}
7499
Dave Tapuska58a099e2020-06-08 21:48:407500blink::mojom::FrameWidgetInputHandler*
7501WebContentsImpl::GetFocusedFrameWidgetInputHandler() {
7502 auto* focused_render_widget_host =
7503 GetFocusedRenderWidgetHost(GetMainFrame()->GetRenderWidgetHost());
7504 if (!focused_render_widget_host)
Dave Tapuskae782bea2019-07-09 16:21:517505 return nullptr;
Dave Tapuska58a099e2020-06-08 21:48:407506 return focused_render_widget_host->GetFrameWidgetInputHandler();
Dave Tapuskae782bea2019-07-09 16:21:517507}
7508
Alexander Timine3ec4192020-04-20 16:39:407509ukm::SourceId WebContentsImpl::GetCurrentPageUkmSourceId() {
7510 return GetMainFrame()->GetPageUkmSourceId();
7511}
7512
Yuzu Saijo232076f2020-05-29 07:14:027513std::set<RenderViewHostImpl*>
7514WebContentsImpl::GetRenderViewHostsIncludingBackForwardCached() {
7515 std::set<RenderViewHostImpl*> render_view_hosts;
7516
7517 // Add RenderViewHostImpls outside of BackForwardCache.
7518 for (auto& render_view_host : frame_tree_.render_view_hosts()) {
7519 render_view_hosts.insert(render_view_host.second);
7520 }
7521
7522 // Add RenderViewHostImpls in BackForwardCache.
7523 const auto& entries = GetController().GetBackForwardCache().GetEntries();
7524 for (const auto& entry : entries) {
7525 std::set<RenderViewHostImpl*> bfcached_hosts = entry->render_view_hosts;
7526 render_view_hosts.insert(bfcached_hosts.begin(), bfcached_hosts.end());
7527 }
7528
7529 return render_view_hosts;
7530}
7531
Sreeja Kamishettybe0ccd6b2020-06-09 11:52:507532void WebContentsImpl::RenderFrameHostStateChanged(
7533 RenderFrameHost* render_frame_host,
7534 LifecycleState old_state,
7535 LifecycleState new_state) {
7536 if (render_frame_host->GetParent())
7537 return;
7538
7539 if (old_state == LifecycleState::kActive &&
7540 new_state != LifecycleState::kActive) {
7541 // TODO(sreejakshetty): Remove this reset when ColorChooser becomes
7542 // per-frame.
7543 // Close the color chooser popup when RenderFrameHost changes state from
7544 // kActive.
7545 color_chooser_.reset();
7546 }
7547}
7548
[email protected]8ff00d72012-10-23 19:12:217549} // namespace content