blob: 6f1679f15e953b40e18d6af6ad0ed6b8e996f964 [file] [log] [blame]
[email protected]91854cd2012-01-10 19:43:571// Copyright (c) 2012 The Chromium Authors. All rights reserved.
license.botbf09a502008-08-24 00:55:552// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commit09911bf2008-07-26 23:55:294
[email protected]93ddb3c2012-04-11 21:44:295#include "content/browser/web_contents/web_contents_impl.h"
[email protected]39526562011-02-05 03:41:516
avib7348942015-12-25 20:57:107#include <stddef.h>
8
w.shackleton49bcd392016-01-06 17:38:229#include <cmath>
[email protected]2bb171882012-03-07 02:09:4610#include <utility>
rkaplowe56a52032017-02-07 00:14:5411#include <vector>
[email protected]b75b8292010-10-01 07:28:2512
Sebastien Marchandf8cbfab2019-01-25 16:02:3013#include "base/bind.h"
[email protected]36fb2c7c2011-04-04 15:49:0814#include "base/command_line.h"
creisfafed882016-07-29 00:03:0915#include "base/debug/dump_without_crashing.h"
zqzhang181047e62016-07-01 13:37:1716#include "base/feature_list.h"
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:4717#include "base/files/file_path.h"
[email protected]cbb1ef592013-06-05 19:49:4618#include "base/lazy_instance.h"
skyostil95082a62015-06-05 19:53:0719#include "base/location.h"
[email protected]6d636e62013-07-31 03:15:5620#include "base/logging.h"
avib7348942015-12-25 20:57:1021#include "base/macros.h"
fdorayba121422016-12-23 19:51:4822#include "base/memory/ptr_util.h"
dmazzonid95ae842016-04-12 21:17:3923#include "base/memory/ref_counted.h"
asvitkine8d51e9d2016-09-02 23:55:4324#include "base/metrics/histogram_macros.h"
bratell0a7406f2017-03-28 07:46:3725#include "base/metrics/user_metrics.h"
Avi Drissman4891b852018-09-25 18:12:5826#include "base/no_destructor.h"
Carlos Caballero1215f882019-10-29 15:58:4327#include "base/optional.h"
[email protected]04cbd3d2013-12-04 04:58:2028#include "base/process/process.h"
skyostil95082a62015-06-05 19:53:0729#include "base/single_thread_task_runner.h"
Arthur Sonzogni929d29f2018-09-17 14:19:4430#include "base/stl_util.h"
[email protected]348fbaac2013-06-11 06:31:5131#include "base/strings/string16.h"
32#include "base/strings/string_number_conversions.h"
Avi Drissman4891b852018-09-25 18:12:5833#include "base/strings/string_split.h"
[email protected]348fbaac2013-06-11 06:31:5134#include "base/strings/string_util.h"
[email protected]74ebfb12013-06-07 20:48:0035#include "base/strings/utf_string_conversions.h"
Eric Seckler8652dcd52018-09-20 10:42:2836#include "base/task/post_task.h"
gab30f26df2016-05-11 19:37:5537#include "base/threading/thread_task_runner_handle.h"
[email protected]a43858f2013-06-28 15:18:3738#include "base/time/time.h"
ssid3e765612015-01-28 04:03:4239#include "base/trace_event/trace_event.h"
avib7348942015-12-25 20:57:1040#include "build/build_config.h"
Min Qinda0ed2062018-02-23 22:00:5341#include "components/download/public/common/download_stats.h"
nzolghadrd87a308d2016-12-07 15:45:5642#include "components/rappor/public/rappor_utils.h"
rsleevi24f64dc22015-08-07 21:39:2143#include "components/url_formatter/url_formatter.h"
Abigail Kleinaa898742019-11-01 02:31:2544#include "content/browser/accessibility/accessibility_event_recorder.h"
James Wallace-Leeeafc94cb92018-07-23 21:35:0945#include "content/browser/accessibility/accessibility_tree_formatter_blink.h"
jamescookda2505812015-03-20 18:01:1846#include "content/browser/bad_message.h"
Max Morinddebb972018-09-20 10:04:1447#include "content/browser/browser_main_loop.h"
[email protected]7a846df2012-09-20 19:17:3948#include "content/browser/browser_plugin/browser_plugin_embedder.h"
49#include "content/browser/browser_plugin/browser_plugin_guest.h"
[email protected]b9535422012-02-09 01:47:5950#include "content/browser/child_process_security_policy_impl.h"
John Delaney732721e92020-02-07 23:11:2751#include "content/browser/conversions/conversion_host.h"
Pavel Feldman3c1842b2017-08-02 05:00:1652#include "content/browser/devtools/protocol/page_handler.h"
dgozmanf00c4f72016-10-19 17:45:1553#include "content/browser/devtools/render_frame_devtools_agent_host.h"
Becca Hughes3b5a43482018-07-17 22:31:5554#include "content/browser/display_cutout/display_cutout_host_impl.h"
[email protected]5f2aa722013-08-07 16:59:4155#include "content/browser/dom_storage/dom_storage_context_wrapper.h"
[email protected]1ea3c792012-04-17 01:25:0456#include "content/browser/dom_storage/session_storage_namespace_impl.h"
[email protected]aa4f3972012-03-01 18:12:1257#include "content/browser/download/mhtml_generation_manager.h"
[email protected]a53209b2012-01-20 16:48:1658#include "content/browser/download/save_package.h"
paulmeyerc0b762b2016-04-13 11:55:1759#include "content/browser/find_request_manager.h"
[email protected]bffc8302014-01-23 20:52:1660#include "content/browser/frame_host/cross_process_frame_connector.h"
ananta4b7467a52016-09-23 01:42:3861#include "content/browser/frame_host/frame_tree_node.h"
[email protected]d4a8ca482013-10-30 21:06:4062#include "content/browser/frame_host/interstitial_page_impl.h"
63#include "content/browser/frame_host/navigation_entry_impl.h"
Arthur Hemeryc3380172018-01-22 14:00:1764#include "content/browser/frame_host/navigation_request.h"
[email protected]6ea6bdf2013-12-06 13:35:0165#include "content/browser/frame_host/navigator_impl.h"
[email protected]52913802013-12-10 05:52:1866#include "content/browser/frame_host/render_frame_host_impl.h"
lfgdb5c4ed2016-03-04 23:09:0767#include "content/browser/frame_host/render_frame_proxy_host.h"
Kenneth Russell954ed9ce2018-04-12 23:07:0168#include "content/browser/gpu/gpu_data_manager_impl.h"
mlamouriefdca9d2014-09-16 16:55:4069#include "content/browser/manifest/manifest_manager_host.h"
Max Morin5bc74f52018-05-09 07:00:2170#include "content/browser/media/audio_stream_broker.h"
dalecurtisbc6572e12014-09-12 19:22:3071#include "content/browser/media/audio_stream_monitor.h"
miu50f97892014-09-22 22:49:5272#include "content/browser/media/capture/web_contents_audio_muter.h"
dalecurtis88c240072015-12-09 02:11:1873#include "content/browser/media/media_web_contents_observer.h"
zqzhang1adf3cb2016-11-01 11:26:4574#include "content/browser/media/session/media_session_impl.h"
tommyclieb25b2a2014-11-03 19:45:0975#include "content/browser/plugin_content_origin_whitelist.h"
David Black9cca3592019-11-06 23:02:2276#include "content/browser/renderer_host/frame_token_message_queue.h"
[email protected]f3b1a082011-11-18 00:34:3077#include "content/browser/renderer_host/render_process_host_impl.h"
[email protected]21161032014-05-05 16:56:5078#include "content/browser/renderer_host/render_view_host_delegate_view.h"
[email protected]b3c41c0b2012-03-06 15:48:3279#include "content/browser/renderer_host/render_view_host_impl.h"
[email protected]bafe6cd2012-05-23 23:09:5080#include "content/browser/renderer_host/render_widget_host_impl.h"
kenrb2a565f82015-09-02 20:24:5981#include "content/browser/renderer_host/render_widget_host_input_event_router.h"
[email protected]cfd80b02014-05-01 17:46:4882#include "content/browser/renderer_host/render_widget_host_view_base.h"
Ken Buchanandaef006b2017-08-17 18:32:1583#include "content/browser/renderer_host/render_widget_host_view_child_frame.h"
ekaramadadd882292016-06-08 15:22:5684#include "content/browser/renderer_host/text_input_manager.h"
leon.han552e9de2017-02-09 14:37:3085#include "content/browser/screen_orientation/screen_orientation_provider.h"
[email protected]b6583592012-01-25 19:52:3386#include "content/browser/site_instance_impl.h"
Charlie Reis96077362019-07-04 00:34:0487#include "content/browser/web_contents/javascript_dialog_navigation_deferrer.h"
lfgc740d4b22016-04-15 16:45:3388#include "content/browser/web_contents/web_contents_view_child_frame.h"
[email protected]86a0a6e2013-01-28 06:33:0389#include "content/browser/webui/web_ui_controller_factory_registry.h"
[email protected]d2353452012-01-19 19:53:5690#include "content/browser/webui/web_ui_impl.h"
[email protected]8eb04562013-03-06 03:41:1491#include "content/common/browser_plugin/browser_plugin_constants.h"
Paul Meyer0c58c3712016-11-17 22:59:5192#include "content/common/drag_messages.h"
[email protected]f114fa42013-12-06 17:06:4493#include "content/common/frame_messages.h"
[email protected]1f3fc1d2014-04-03 14:50:1794#include "content/common/input_messages.h"
lfgdb5c4ed2016-03-04 23:09:0795#include "content/common/page_messages.h"
nasko34634672016-07-29 18:46:0696#include "content/common/page_state_serialization.h"
rockot5c478a72016-09-28 23:14:1897#include "content/common/render_message_filter.mojom.h"
[email protected]2c5569662011-03-22 20:45:0298#include "content/common/view_messages.h"
Albert J. Wong3c93c182018-09-27 17:29:4399#include "content/common/widget_messages.h"
Abigail Kleinabb428332019-09-13 18:26:21100#include "content/public/browser/accessibility_tree_formatter.h"
[email protected]31a71eaf2014-03-13 01:47:36101#include "content/public/browser/ax_event_notification_details.h"
[email protected]ccb797302011-12-15 16:55:11102#include "content/public/browser/browser_context.h"
[email protected]139355f2014-05-11 14:21:28103#include "content/public/browser/browser_plugin_guest_manager.h"
Eric Seckler8652dcd52018-09-20 10:42:28104#include "content/public/browser/browser_task_traits.h"
Gabriel Charette790754c2018-03-16 21:32:59105#include "content/public/browser/browser_thread.h"
[email protected]87f3c082011-10-19 18:07:44106#include "content/public/browser/content_browser_client.h"
Ken Rockotce010f02019-12-12 23:32:32107#include "content/public/browser/device_service.h"
[email protected]e582fdd2011-12-20 16:48:17108#include "content/public/browser/download_manager.h"
Kent Tamura512a27e2018-10-04 00:49:32109#include "content/public/browser/file_select_listener.h"
ekaramada110f642016-12-21 19:47:28110#include "content/public/browser/focused_node_details.h"
Danyao Wanga78f3dd22020-03-05 05:31:27111#include "content/public/browser/global_routing_id.h"
[email protected]d9083482012-01-06 00:38:46112#include "content/public/browser/invalidate_type.h"
[email protected]71a88bb2013-02-01 22:05:15113#include "content/public/browser/javascript_dialog_manager.h"
skyf65d9bb2017-03-24 02:26:39114#include "content/public/browser/keyboard_event_processing_result.h"
[email protected]09d31d52012-03-11 22:30:27115#include "content/public/browser/load_notification_details.h"
[email protected]5b96836f2011-12-22 07:39:00116#include "content/public/browser/navigation_details.h"
[email protected]375fa1b2012-05-22 22:05:37117#include "content/public/browser/notification_details.h"
[email protected]be2510c02012-05-28 14:52:14118#include "content/public/browser/notification_service.h"
scottmg011d96e32016-06-29 19:15:08119#include "content/public/browser/notification_types.h"
[email protected]95640212014-07-26 18:14:30120#include "content/public/browser/render_widget_host_iterator.h"
Lukasz Anforowicze1b954d92017-10-30 21:28:06121#include "content/public/browser/restore_type.h"
estark5ea80e52015-06-19 18:43:12122#include "content/public/browser/security_style_explanations.h"
falken52a56e32016-12-08 05:02:40123#include "content/public/browser/ssl_status.h"
[email protected]4c3a23582012-08-18 08:54:34124#include "content/public/browser/storage_partition.h"
[email protected]674bc592011-12-20 23:00:42125#include "content/public/browser/web_contents_delegate.h"
Julie Jeongeun Kim7d0986172019-12-04 03:17:25126#include "content/public/browser/web_contents_receiver_set.h"
Lei Zhangee3b63ad2018-06-06 23:25:31127#include "content/public/browser/web_ui_controller.h"
[email protected]e091df82011-10-11 18:13:21128#include "content/public/common/bindings_policy.h"
alexmosc9e76ec2016-05-16 22:59:37129#include "content/public/common/child_process_host.h"
Hans Wennborg5ffd1392019-10-16 11:00:02130#include "content/public/common/content_client.h"
[email protected]54087fe2011-10-28 22:02:48131#include "content/public/common/content_constants.h"
Francois Doray3f2afbd2018-04-06 19:18:18132#include "content/public/common/content_features.h"
[email protected]64d69de42012-02-06 00:19:54133#include "content/public/common/content_switches.h"
Lukasz Anforowicze1b954d92017-10-30 21:28:06134#include "content/public/common/page_state.h"
Leon Han963dc182018-11-06 05:41:48135#include "content/public/common/referrer_type_converters.h"
[email protected]04cbd3d2013-12-04 04:58:20136#include "content/public/common/result_codes.h"
[email protected]f16cc6782013-12-16 23:42:57137#include "content/public/common/url_utils.h"
danakjffc8baf2019-10-10 23:49:42138#include "content/public/common/use_zoom_for_dsf_policy.h"
[email protected]b3a97b52014-07-09 06:25:05139#include "content/public/common/web_preferences.h"
Max Morinddebb972018-09-20 10:04:14140#include "media/base/user_input_monitor.h"
wjmaclean64951902016-04-29 20:59:12141#include "net/base/url_util.h"
[email protected]8bfc8272013-09-09 20:10:53142#include "net/http/http_cache.h"
143#include "net/http/http_transaction_factory.h"
rhalavati0fbaeef32017-06-01 15:56:30144#include "net/traffic_annotation/network_traffic_annotation.h"
[email protected]8bfc8272013-09-09 20:10:53145#include "net/url_request/url_request_context.h"
[email protected]abe2c032011-03-31 18:49:34146#include "net/url_request/url_request_context_getter.h"
Scott Violet02e38b92018-03-27 23:42:14147#include "ppapi/buildflags/buildflags.h"
Mounir Lamourifd9dcefa2017-07-06 10:26:55148#include "services/metrics/public/cpp/ukm_recorder.h"
John Abd-El-Malekb175a612018-12-03 20:11:58149#include "services/network/public/cpp/features.h"
rockot734fb662016-10-15 16:41:30150#include "services/service_manager/public/cpp/interface_provider.h"
Becca Hughes6daf5662018-06-27 16:50:54151#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
Blink Reformata30d4232018-04-07 15:31:06152#include "third_party/blink/public/common/frame/sandbox_flags.h"
153#include "third_party/blink/public/common/mime_util/mime_util.h"
danakj938b37a62019-09-24 18:35:54154#include "third_party/blink/public/common/page/page_zoom.h"
Sergio Villar Senin9d9d4f52019-10-15 10:57:57155#include "third_party/blink/public/common/security/security_style.h"
Abhijeet Kandalkarde7348e2020-01-13 06:06:54156#include "third_party/blink/public/mojom/frame/frame.mojom.h"
Dave Tapuskaa4189512019-10-15 20:27:34157#include "third_party/blink/public/mojom/frame/fullscreen.mojom.h"
Takuto Ikutaaa3b796c2019-02-06 02:54:56158#include "third_party/blink/public/mojom/loader/pause_subresource_loading_handle.mojom.h"
Antonio Gomes0d42960a2019-06-05 12:35:51159#include "third_party/blink/public/mojom/mediastream/media_stream.mojom-shared.h"
halton.huoca2eabd2015-07-06 08:17:40160#include "third_party/skia/include/core/SkBitmap.h"
dmazzonid95ae842016-04-12 21:17:39161#include "ui/accessibility/ax_tree_combiner.h"
[email protected]a08412b62012-05-29 21:28:56162#include "ui/base/layout.h"
Daniel Cheng90196c82018-04-25 21:49:14163#include "ui/events/base_event_utils.h"
chongz4a9751942016-08-17 17:49:39164#include "ui/events/blink/web_input_event_traits.h"
[email protected]66bd5512012-08-01 02:02:52165#include "ui/gl/gl_switches.h"
[email protected]3c733bde2010-12-21 19:56:31166
ekaramada110f642016-12-21 19:47:28167#if defined(OS_WIN)
168#include "content/browser/renderer_host/dip_util.h"
169#include "ui/gfx/geometry/dip_util.h"
170#endif
171
[email protected]583418cc2013-01-17 14:01:10172#if defined(OS_ANDROID)
mfomitchev2b8b066a2016-01-28 19:23:15173#include "content/browser/android/date_time_chooser_android.h"
sammcf5f1b0f2016-09-20 23:05:11174#include "content/browser/android/java_interfaces_impl.h"
Leon Hanccb985f2019-08-26 02:43:24175#include "content/browser/android/nfc_host.h"
[email protected]155c7f22013-12-09 17:07:18176#include "content/browser/web_contents/web_contents_android.h"
Ke He31d0bb02018-02-24 07:16:24177#include "services/device/public/mojom/nfc.mojom.h"
mcnee336ea2c2017-05-23 22:50:59178#else // !OS_ANDROID
179#include "content/browser/host_zoom_map_impl.h"
mfomitchev2b8b066a2016-01-28 19:23:15180#endif // OS_ANDROID
[email protected]583418cc2013-01-17 14:01:10181
brettw4b461082016-11-19 18:55:16182#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17183#include "content/browser/media/session/pepper_playback_observer.h"
Lei Zhangebcc6302018-01-12 19:46:45184#endif
zqzhang181047e62016-07-01 13:37:17185
[email protected]8ff00d72012-10-23 19:12:21186namespace content {
Abigail Kleinaa898742019-11-01 02:31:25187
188using AccessibilityEventCallback =
189 base::RepeatingCallback<void(const std::string&)>;
190
[email protected]420ae012009-04-24 05:16:32191namespace {
192
[email protected]960b0372014-05-19 18:01:00193const int kMinimumDelayBetweenLoadingUpdatesMS = 100;
[email protected]82114f52012-03-20 22:53:41194const char kDotGoogleDotCom[] = ".google.com";
[email protected]ca406032011-07-19 21:53:05195
Alexander Timin33bd754c02020-03-10 22:50:18196// TODO(crbug.com/1059903): Clean up after the initial investigation.
197constexpr base::Feature kCheckWebContentsAccessFromNonCurrentFrame{
198 "CheckWebContentsAccessFromNonCurrentFrame",
199 base::FEATURE_DISABLED_BY_DEFAULT};
200
Avi Drissmana9114822018-03-23 18:25:55201base::LazyInstance<std::vector<
202 WebContentsImpl::FriendWrapper::CreatedCallback>>::DestructorAtExit
203 g_created_callbacks = LAZY_INSTANCE_INITIALIZER;
[email protected]cbb1ef592013-06-05 19:49:46204
dcheng57e39e22016-01-21 00:25:38205bool HasMatchingProcess(FrameTree* tree, int render_process_id) {
206 for (FrameTreeNode* node : tree->Nodes()) {
207 if (node->current_frame_host()->GetProcess()->GetID() == render_process_id)
208 return true;
alexmos4cf2aa32015-07-15 23:40:43209 }
dcheng57e39e22016-01-21 00:25:38210 return false;
[email protected]95640212014-07-26 18:14:30211}
212
kenrb19221852016-04-29 17:21:40213bool HasMatchingWidgetHost(FrameTree* tree, RenderWidgetHost* host) {
214 // This method scans the frame tree rather than checking whether
215 // host->delegate() == this, which allows it to return false when the host
216 // for a frame that is pending or pending deletion.
217 if (!host)
218 return false;
219
220 for (FrameTreeNode* node : tree->Nodes()) {
221 if (node->current_frame_host()->GetRenderWidgetHost() == host)
222 return true;
223 }
224 return false;
225}
226
dmazzonif8a31042016-12-03 00:52:13227void UpdateAccessibilityModeOnFrame(RenderFrameHost* frame_host) {
228 static_cast<RenderFrameHostImpl*>(frame_host)->UpdateAccessibilityMode();
[email protected]95640212014-07-26 18:14:30229}
230
dtseng0dd3fa12015-07-22 19:00:52231void ResetAccessibility(RenderFrameHost* rfh) {
232 static_cast<RenderFrameHostImpl*>(rfh)->AccessibilityReset();
233}
234
Ian Clelland5cbaaf82017-11-27 22:00:03235RenderFrameHostImpl* FindOpenerRFH(const WebContents::CreateParams& params) {
236 RenderFrameHostImpl* opener_rfh = nullptr;
alexmose201c7cd2015-06-10 17:14:21237 if (params.opener_render_frame_id != MSG_ROUTING_NONE) {
Ian Clelland5cbaaf82017-11-27 22:00:03238 opener_rfh = RenderFrameHostImpl::FromID(params.opener_render_process_id,
239 params.opener_render_frame_id);
alexmose201c7cd2015-06-10 17:14:21240 }
Ian Clelland5cbaaf82017-11-27 22:00:03241 return opener_rfh;
lukasza6f8ac622017-06-06 03:10:20242}
243
Dominick Ng37a15052018-07-17 23:56:35244// Returns |true| if |type| is the kind of user input that should trigger the
245// user interaction observers.
246bool IsUserInteractionInputType(blink::WebInputEvent::Type type) {
247 // Ideally, this list would be based more off of
248 // https://whatwg.org/C/interaction.html#triggered-by-user-activation.
249 return type == blink::WebInputEvent::kMouseDown ||
250 type == blink::WebInputEvent::kGestureScrollBegin ||
251 type == blink::WebInputEvent::kTouchStart ||
252 type == blink::WebInputEvent::kRawKeyDown;
253}
254
Pavel Feldman3c1842b2017-08-02 05:00:16255// Ensures that OnDialogClosed is only called once.
256class CloseDialogCallbackWrapper
257 : public base::RefCountedThreadSafe<CloseDialogCallbackWrapper> {
258 public:
Avi Drissmane04d3992017-10-05 15:11:36259 using CloseCallback =
260 base::OnceCallback<void(bool, bool, const base::string16&)>;
261
262 explicit CloseDialogCallbackWrapper(CloseCallback callback)
263 : callback_(std::move(callback)) {}
Pavel Feldman3c1842b2017-08-02 05:00:16264
265 void Run(bool dialog_was_suppressed,
266 bool success,
267 const base::string16& user_input) {
Avi Drissmane04d3992017-10-05 15:11:36268 if (callback_.is_null())
Pavel Feldman3c1842b2017-08-02 05:00:16269 return;
Avi Drissmane04d3992017-10-05 15:11:36270 std::move(callback_).Run(dialog_was_suppressed, success, user_input);
Pavel Feldman3c1842b2017-08-02 05:00:16271 }
272
273 private:
274 friend class base::RefCountedThreadSafe<CloseDialogCallbackWrapper>;
275 ~CloseDialogCallbackWrapper() {}
Avi Drissmane04d3992017-10-05 15:11:36276
277 CloseCallback callback_;
Pavel Feldman3c1842b2017-08-02 05:00:16278};
279
Arthur Sonzogni929d29f2018-09-17 14:19:44280bool FrameCompareDepth(RenderFrameHostImpl* a, RenderFrameHostImpl* b) {
281 return a->frame_tree_node()->depth() < b->frame_tree_node()->depth();
282}
283
Raymes Khoury58373df2019-08-06 06:29:20284bool AreValidRegisterProtocolHandlerArguments(const std::string& protocol,
285 const GURL& url,
286 const url::Origin& origin) {
287 ChildProcessSecurityPolicyImpl* policy =
288 ChildProcessSecurityPolicyImpl::GetInstance();
289 if (policy->IsPseudoScheme(protocol))
290 return false;
291
292 url::Origin url_origin = url::Origin::Create(url);
293 if (url_origin.opaque())
294 return false;
295
296 if (!url_origin.IsSameOriginWith(origin))
297 return false;
298
299 return true;
300}
301
yilkal796e89e2019-10-02 23:58:28302void RecordMaxFrameCountUMA(size_t max_frame_count) {
303 UMA_HISTOGRAM_COUNTS_10000("Navigation.MainFrame.MaxFrameCount",
304 max_frame_count);
305}
306
lukasza6f8ac622017-06-06 03:10:20307} // namespace
308
Erik Chenbb8e738e2018-04-28 14:10:43309std::unique_ptr<WebContents> WebContents::Create(
310 const WebContents::CreateParams& params) {
Albert J. Wong65fe64d2019-09-20 02:48:14311 return WebContentsImpl::Create(params);
312}
313
314std::unique_ptr<WebContentsImpl> WebContentsImpl::Create(
315 const CreateParams& params) {
316 return CreateWithOpener(params, FindOpenerRFH(params));
[email protected]d1198fd2012-08-13 22:50:19317}
318
erikchenade1fef2018-05-02 22:07:57319std::unique_ptr<WebContents> WebContents::CreateWithSessionStorage(
[email protected]54944cde2012-12-09 09:24:59320 const WebContents::CreateParams& params,
[email protected]fdac6ade2013-07-20 01:06:30321 const SessionStorageNamespaceMap& session_storage_namespace_map) {
erikchenade1fef2018-05-02 22:07:57322 std::unique_ptr<WebContentsImpl> new_contents(
323 new WebContentsImpl(params.browser_context));
Ian Clelland5cbaaf82017-11-27 22:00:03324 RenderFrameHostImpl* opener_rfh = FindOpenerRFH(params);
325 FrameTreeNode* opener = nullptr;
326 if (opener_rfh)
327 opener = opener_rfh->frame_tree_node();
328 new_contents->SetOpenerForNewContents(opener, params.opener_suppressed);
[email protected]fdac6ade2013-07-20 01:06:30329
jdoerrie55ec69d2018-10-08 13:34:46330 for (auto it = session_storage_namespace_map.begin();
331 it != session_storage_namespace_map.end(); ++it) {
[email protected]fdac6ade2013-07-20 01:06:30332 new_contents->GetController()
333 .SetSessionStorageNamespace(it->first, it->second.get());
334 }
335
Sean Toppingbbc4a2bd2019-01-30 02:16:14336 WebContentsImpl* outer_web_contents = nullptr;
Sam McNally69a33772018-06-27 16:54:12337 if (params.guest_delegate) {
338 // This makes |new_contents| act as a guest.
339 // For more info, see comment above class BrowserPluginGuest.
Albert J. Wongc55cc64d2018-10-12 02:50:04340 BrowserPluginGuest::CreateInWebContents(new_contents.get(),
341 params.guest_delegate);
Sean Toppingbbc4a2bd2019-01-30 02:16:14342 outer_web_contents = static_cast<WebContentsImpl*>(
343 params.guest_delegate->GetOwnerWebContents());
Sam McNally69a33772018-06-27 16:54:12344 }
345
[email protected]54944cde2012-12-09 09:24:59346 new_contents->Init(params);
Sean Toppingbbc4a2bd2019-01-30 02:16:14347 if (outer_web_contents)
348 outer_web_contents->InnerWebContentsCreated(new_contents.get());
[email protected]d1198fd2012-08-13 22:50:19349 return new_contents;
[email protected]a81343d232011-12-27 07:39:20350}
[email protected]746d3052012-05-22 15:15:47351
benwells5e7260d2017-03-20 23:36:33352void WebContentsImpl::FriendWrapper::AddCreatedCallbackForTesting(
nickf9acfbe2014-12-23 19:12:37353 const CreatedCallback& callback) {
[email protected]cbb1ef592013-06-05 19:49:46354 g_created_callbacks.Get().push_back(callback);
355}
356
benwells5e7260d2017-03-20 23:36:33357void WebContentsImpl::FriendWrapper::RemoveCreatedCallbackForTesting(
nickf9acfbe2014-12-23 19:12:37358 const CreatedCallback& callback) {
[email protected]cbb1ef592013-06-05 19:49:46359 for (size_t i = 0; i < g_created_callbacks.Get().size(); ++i) {
Robert Liao1db5a352019-06-05 20:57:34360 if (g_created_callbacks.Get().at(i) == callback) {
[email protected]cbb1ef592013-06-05 19:49:46361 g_created_callbacks.Get().erase(g_created_callbacks.Get().begin() + i);
362 return;
363 }
364 }
365}
366
avidf38c952015-10-27 13:45:13367WebContents* WebContents::FromRenderViewHost(RenderViewHost* rvh) {
368 if (!rvh)
369 return nullptr;
[email protected]746d3052012-05-22 15:15:47370 return rvh->GetDelegate()->GetAsWebContents();
371}
372
[email protected]a86c0e962013-12-17 17:10:39373WebContents* WebContents::FromRenderFrameHost(RenderFrameHost* rfh) {
avidf38c952015-10-27 13:45:13374 if (!rfh)
375 return nullptr;
Alexander Timin33bd754c02020-03-10 22:50:18376 if (!rfh->IsCurrent() && base::FeatureList::IsEnabled(
377 kCheckWebContentsAccessFromNonCurrentFrame)) {
378 // TODO(crbug.com/1059903): return nullptr here eventually.
379 base::debug::DumpWithoutCrashing();
380 }
avidf38c952015-10-27 13:45:13381 return static_cast<RenderFrameHostImpl*>(rfh)->delegate()->GetAsWebContents();
[email protected]a86c0e962013-12-17 17:10:39382}
383
ananta4b7467a52016-09-23 01:42:38384WebContents* WebContents::FromFrameTreeNodeId(int frame_tree_node_id) {
385 FrameTreeNode* frame_tree_node =
386 FrameTreeNode::GloballyFindByID(frame_tree_node_id);
anantab8cfa3b2016-10-14 22:43:19387 if (!frame_tree_node)
388 return nullptr;
jam8c4edd02017-05-06 18:50:33389 return WebContentsImpl::FromFrameTreeNode(frame_tree_node);
ananta4b7467a52016-09-23 01:42:38390}
391
leon.han552e9de2017-02-09 14:37:30392void WebContents::SetScreenOrientationDelegate(
393 ScreenOrientationDelegate* delegate) {
394 ScreenOrientationProvider::SetDelegate(delegate);
395}
396
[email protected]7fff43e2013-05-21 20:21:10397// WebContentsImpl::DestructionObserver ----------------------------------------
398
399class WebContentsImpl::DestructionObserver : public WebContentsObserver {
400 public:
401 DestructionObserver(WebContentsImpl* owner, WebContents* watched_contents)
402 : WebContentsObserver(watched_contents),
403 owner_(owner) {
404 }
405
406 // WebContentsObserver:
dchengc2282aa2014-10-21 12:07:58407 void WebContentsDestroyed() override {
[email protected]12a46832014-05-09 13:35:58408 owner_->OnWebContentsDestroyed(
409 static_cast<WebContentsImpl*>(web_contents()));
[email protected]7fff43e2013-05-21 20:21:10410 }
411
412 private:
413 WebContentsImpl* owner_;
414
415 DISALLOW_COPY_AND_ASSIGN(DestructionObserver);
416};
417
Joel Hockey85b379d2017-12-11 10:42:13418// WebContentsImpl::ColorChooser ----------------------------------------------
Joel Hockey163835a2017-12-20 11:51:57419class WebContentsImpl::ColorChooser : public blink::mojom::ColorChooser {
Joel Hockey85b379d2017-12-11 10:42:13420 public:
421 ColorChooser(content::ColorChooser* chooser,
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20422 mojo::PendingReceiver<blink::mojom::ColorChooser> receiver,
423 mojo::PendingRemote<blink::mojom::ColorChooserClient> client)
Joel Hockey85b379d2017-12-11 10:42:13424 : chooser_(chooser),
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20425 receiver_(this, std::move(receiver)),
Joel Hockey85b379d2017-12-11 10:42:13426 client_(std::move(client)) {
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20427 receiver_.set_disconnect_handler(
Joel Hockey85b379d2017-12-11 10:42:13428 base::BindOnce([](content::ColorChooser* chooser) { chooser->End(); },
429 base::Unretained(chooser)));
430 }
[email protected]8ed16472014-04-11 19:02:48431
Joel Hockey85b379d2017-12-11 10:42:13432 ~ColorChooser() override { chooser_->End(); }
[email protected]8ed16472014-04-11 19:02:48433
Joel Hockey85b379d2017-12-11 10:42:13434 void SetSelectedColor(SkColor color) override {
435 chooser_->SetSelectedColor(color);
436 }
437
438 void DidChooseColorInColorChooser(SkColor color) {
439 client_->DidChooseColor(color);
440 }
441
442 private:
443 // Color chooser that was opened by this tab.
444 std::unique_ptr<content::ColorChooser> chooser_;
445
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20446 // mojo receiver.
447 mojo::Receiver<blink::mojom::ColorChooser> receiver_;
Joel Hockey85b379d2017-12-11 10:42:13448
449 // mojo renderer client.
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20450 mojo::Remote<blink::mojom::ColorChooserClient> client_;
Joel Hockey85b379d2017-12-11 10:42:13451};
nicka0ac8382016-12-15 23:59:23452
lazyboy6ec48b2a2015-06-29 15:18:14453// WebContentsImpl::WebContentsTreeNode ----------------------------------------
lfg601233692017-03-06 22:45:44454WebContentsImpl::WebContentsTreeNode::WebContentsTreeNode(
455 WebContentsImpl* current_web_contents)
456 : current_web_contents_(current_web_contents),
457 outer_web_contents_(nullptr),
lazyboy6ec48b2a2015-06-29 15:18:14458 outer_contents_frame_tree_node_id_(
avallee0206f782016-07-28 18:55:33459 FrameTreeNode::kFrameTreeNodeInvalidId),
lfg601233692017-03-06 22:45:44460 focused_web_contents_(current_web_contents) {}
lazyboy6ec48b2a2015-06-29 15:18:14461
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18462WebContentsImpl::WebContentsTreeNode::~WebContentsTreeNode() {}
lazyboy6ec48b2a2015-06-29 15:18:14463
Lucas Furukawa Gadani99125822019-01-03 15:41:49464std::unique_ptr<WebContents>
465WebContentsImpl::WebContentsTreeNode::DisconnectFromOuterWebContents() {
466 std::unique_ptr<WebContents> inner_contents =
467 outer_web_contents_->node_.DetachInnerWebContents(current_web_contents_);
468 OuterContentsFrameTreeNode()->RemoveObserver(this);
469 outer_contents_frame_tree_node_id_ = FrameTreeNode::kFrameTreeNodeInvalidId;
470 outer_web_contents_ = nullptr;
471 return inner_contents;
472}
473
paulmeyerfeafc2d2017-04-25 21:46:40474void WebContentsImpl::WebContentsTreeNode::AttachInnerWebContents(
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:50475 std::unique_ptr<WebContents> inner_web_contents,
476 RenderFrameHostImpl* render_frame_host) {
477 WebContentsImpl* inner_web_contents_impl =
478 static_cast<WebContentsImpl*>(inner_web_contents.get());
479 WebContentsTreeNode& inner_web_contents_node = inner_web_contents_impl->node_;
480
481 inner_web_contents_node.focused_web_contents_ = nullptr;
482 inner_web_contents_node.outer_web_contents_ = current_web_contents_;
483 inner_web_contents_node.outer_contents_frame_tree_node_id_ =
484 render_frame_host->frame_tree_node()->frame_tree_node_id();
485
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18486 inner_web_contents_.push_back(std::move(inner_web_contents));
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:50487
488 render_frame_host->frame_tree_node()->AddObserver(&inner_web_contents_node);
paulmeyerfeafc2d2017-04-25 21:46:40489}
490
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18491std::unique_ptr<WebContents>
492WebContentsImpl::WebContentsTreeNode::DetachInnerWebContents(
paulmeyerfeafc2d2017-04-25 21:46:40493 WebContentsImpl* inner_web_contents) {
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18494 std::unique_ptr<WebContents> detached_contents;
495 for (std::unique_ptr<WebContents>& web_contents : inner_web_contents_) {
496 if (web_contents.get() == inner_web_contents) {
497 detached_contents = std::move(web_contents);
498 std::swap(web_contents, inner_web_contents_.back());
499 inner_web_contents_.pop_back();
500 return detached_contents;
501 }
502 }
503
504 NOTREACHED();
505 return nullptr;
paulmeyerfeafc2d2017-04-25 21:46:40506}
507
lfga3e2bdc2017-03-07 20:44:01508FrameTreeNode*
509WebContentsImpl::WebContentsTreeNode::OuterContentsFrameTreeNode() const {
510 return FrameTreeNode::GloballyFindByID(outer_contents_frame_tree_node_id_);
lfg601233692017-03-06 22:45:44511}
512
lfga3e2bdc2017-03-07 20:44:01513void WebContentsImpl::WebContentsTreeNode::OnFrameTreeNodeDestroyed(
514 FrameTreeNode* node) {
515 DCHECK_EQ(outer_contents_frame_tree_node_id_, node->frame_tree_node_id())
516 << "WebContentsTreeNode should only receive notifications for the "
517 "FrameTreeNode in its outer WebContents that hosts it.";
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18518
519 // Deletes |this| too.
520 outer_web_contents_->node_.DetachInnerWebContents(current_web_contents_);
lazyboy6ec48b2a2015-06-29 15:18:14521}
522
avallee0206f782016-07-28 18:55:33523void WebContentsImpl::WebContentsTreeNode::SetFocusedWebContents(
524 WebContentsImpl* web_contents) {
525 DCHECK(!outer_web_contents())
526 << "Only the outermost WebContents tracks focus.";
527 focused_web_contents_ = web_contents;
528}
529
paulmeyerfeafc2d2017-04-25 21:46:40530WebContentsImpl*
531WebContentsImpl::WebContentsTreeNode::GetInnerWebContentsInFrame(
532 const FrameTreeNode* frame) {
533 auto ftn_id = frame->frame_tree_node_id();
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18534 for (auto& contents : inner_web_contents_) {
535 WebContentsImpl* impl = static_cast<WebContentsImpl*>(contents.get());
536 if (impl->node_.outer_contents_frame_tree_node_id() == ftn_id) {
537 return impl;
paulmeyerfeafc2d2017-04-25 21:46:40538 }
539 }
540 return nullptr;
541}
542
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18543std::vector<WebContentsImpl*>
544WebContentsImpl::WebContentsTreeNode::GetInnerWebContents() const {
545 std::vector<WebContentsImpl*> inner_web_contents;
546 for (auto& contents : inner_web_contents_)
547 inner_web_contents.push_back(static_cast<WebContentsImpl*>(contents.get()));
548
549 return inner_web_contents;
paulmeyerfeafc2d2017-04-25 21:46:40550}
551
[email protected]b172aee2012-04-10 17:05:26552// WebContentsImpl -------------------------------------------------------------
[email protected]420ae012009-04-24 05:16:32553
alexmose201c7cd2015-06-10 17:14:21554WebContentsImpl::WebContentsImpl(BrowserContext* browser_context)
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28555 : delegate_(nullptr),
[email protected]69e797f2013-04-30 01:10:22556 controller_(this, browser_context),
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28557 render_view_host_delegate_view_(nullptr),
alexmose201c7cd2015-06-10 17:14:21558 created_with_opener_(false),
Lucas Furukawa Gadani99125822019-01-03 15:41:49559 node_(this),
[email protected]6ea6bdf2013-12-06 13:35:01560 frame_tree_(new NavigatorImpl(&controller_, this),
blundellc57b93f2014-10-29 13:19:57561 this,
562 this,
563 this,
564 this),
[email protected]6dfed692014-05-22 04:18:03565 is_load_to_different_document_(false),
[email protected]443b80e2010-12-14 00:42:23566 crashed_status_(base::TERMINATION_STATUS_STILL_RUNNING),
567 crashed_error_code_(0),
[email protected]d5f942ba2008-09-26 19:30:34568 waiting_for_response_(false),
[email protected]fcf75d42013-12-03 20:11:26569 load_state_(net::LOAD_STATE_IDLE, base::string16()),
[email protected]094e5b22009-09-25 04:23:56570 upload_size_(0),
571 upload_position_(0),
dfalcantarae6b7b46752015-07-10 18:14:16572 is_resume_pending_(false),
creisadca9862017-06-16 19:12:11573 interstitial_page_(nullptr),
[email protected]b4c84012014-04-28 19:51:10574 has_accessed_initial_document_(false),
Collin Bakerc5259962019-11-14 17:51:58575 visible_capturer_count_(0),
576 hidden_capturer_count_(0),
[email protected]fdd61c62009-04-22 19:22:57577 is_being_destroyed_(false),
creis97867aa2017-02-17 18:39:45578 is_notifying_observers_(false),
[email protected]fdd61c62009-04-22 19:22:57579 notify_disconnection_(false),
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28580 dialog_manager_(nullptr),
[email protected]7ab1e7d62009-10-14 23:32:01581 is_showing_before_unload_dialog_(false),
gab0dccfef2015-05-20 18:43:39582 last_active_time_(base::TimeTicks::Now()),
[email protected]ebf40a72010-07-22 01:46:38583 closed_by_user_gesture_(false),
danakj938b37a62019-09-24 18:35:54584 minimum_zoom_percent_(
585 static_cast<int>(blink::kMinimumPageZoomFactor * 100)),
586 maximum_zoom_percent_(
587 static_cast<int>(blink::kMaximumPageZoomFactor * 100)),
w.shackleton49bcd392016-01-06 17:38:22588 zoom_scroll_remainder_(0),
alexmosc9e76ec2016-05-16 22:59:37589 fullscreen_widget_process_id_(ChildProcessHost::kInvalidUniqueID),
[email protected]5dcaf8e2013-12-28 01:31:42590 fullscreen_widget_routing_id_(MSG_ROUTING_NONE),
[email protected]0b431992014-06-24 00:08:03591 fullscreen_widget_had_focus_at_shutdown_(false),
[email protected]34ff1cfc2014-08-20 06:16:05592 force_disable_overscroll_content_(false),
[email protected]95640212014-07-26 18:14:30593 last_dialog_suppressed_(false),
waffles1c12bf402016-02-10 17:45:48594 accessibility_mode_(
Dominic Mazzoni21fb0282019-02-13 18:32:47595 GetContentClient()->browser()->GetAXModeForBrowserContext(
596 browser_context)),
avayvodcc85bbd2015-08-28 19:11:15597 audio_stream_monitor_(this),
Thomas Guilbert882c4cec2019-02-14 05:55:45598 media_web_contents_observer_(
599 std::make_unique<MediaWebContentsObserver>(this)),
mcnee336ea2c2017-05-23 22:50:59600#if !defined(OS_ANDROID)
mcnee432e47d2015-11-09 19:37:46601 page_scale_factor_is_one_(true),
mcnee336ea2c2017-05-23 22:50:59602#endif // !defined(OS_ANDROID)
qinmin72e8bd02016-10-21 19:35:37603 is_overlay_content_(false),
ekaramadf6750aa2017-06-06 18:29:42604 showing_context_menu_(false),
W. James MacLean62198672019-06-04 16:46:10605 text_autosizer_page_info_({0, 0, 1.f}),
shivanigithubcceeacf2020-03-06 20:00:27606 native_theme_observer_(this) {
danakjf4b9e942019-11-29 15:43:04607 frame_tree_.SetFrameRemoveListener(base::BindRepeating(
608 &WebContentsImpl::OnFrameRemoved, base::Unretained(this)));
brettw4b461082016-11-19 18:55:16609#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17610 pepper_playback_observer_.reset(new PepperPlaybackObserver(this));
611#endif
blundelle75a8f92017-03-27 08:11:17612
Becca Hughes86334622018-07-09 21:29:38613#if defined(OS_ANDROID)
Elly Fong-Jonescdd7ae82019-02-20 23:26:33614 display_cutout_host_impl_ = std::make_unique<DisplayCutoutHostImpl>(this);
Becca Hughes86334622018-07-09 21:29:38615#endif
John Delaney732721e92020-02-07 23:11:27616
Alison Maher7f366dc62020-03-03 19:46:00617 ui::NativeTheme* native_theme = ui::NativeTheme::GetInstanceForWeb();
618 native_theme_observer_.Add(native_theme);
619 using_dark_colors_ = native_theme->ShouldUseDarkColors();
620 preferred_color_scheme_ = native_theme->GetPreferredColorScheme();
621
John Delaney732721e92020-02-07 23:11:27622 // ConversionHost takes a weak ref on |this|, so it must be created outside of
623 // the initializer list.
624 conversion_host_ = std::make_unique<ConversionHost>(this);
[email protected]332af7732009-03-11 13:21:35625}
initial.commit09911bf2008-07-26 23:55:29626
[email protected]b172aee2012-04-10 17:05:26627WebContentsImpl::~WebContentsImpl() {
creisba91ba82017-05-12 22:56:19628 // Imperfect sanity check against double free, given some crashes unexpectedly
629 // observed in the wild.
630 CHECK(!is_being_destroyed_);
631
632 // We generally keep track of is_being_destroyed_ to let other features know
633 // to avoid certain actions during destruction.
[email protected]420ae012009-04-24 05:16:32634 is_being_destroyed_ = true;
635
creis97867aa2017-02-17 18:39:45636 // A WebContents should never be deleted while it is notifying observers,
creisba91ba82017-05-12 22:56:19637 // since this will lead to a use-after-free as it continues to notify later
creis97867aa2017-02-17 18:39:45638 // observers.
639 CHECK(!is_notifying_observers_);
640
kenrb2a565f82015-09-02 20:24:59641 rwh_input_event_router_.reset();
642
Julie Jeongeun Kim7d0986172019-12-04 03:17:25643 for (auto& entry : receiver_sets_)
644 entry.second->CloseAllReceivers();
rockotf62002a2016-09-15 00:08:59645
avallee0206f782016-07-28 18:55:33646 WebContentsImpl* outermost = GetOutermostWebContents();
avallee9993fca2016-11-17 06:16:50647 if (this != outermost && ContainsOrIsFocusedWebContents()) {
avallee0206f782016-07-28 18:55:33648 // If the current WebContents is in focus, unset it.
avallee9993fca2016-11-17 06:16:50649 outermost->SetAsFocusedWebContentsIfNecessary();
avallee0206f782016-07-28 18:55:33650 }
651
Nick Carterd73635b2018-03-13 18:31:41652 if (mouse_lock_widget_)
James Hollyerd5c9de462020-03-10 19:02:45653 mouse_lock_widget_->RejectMouseLockOrUnlockIfNecessary(
654 blink::mojom::PointerLockResult::kElementDestroyed);
Nick Carterd73635b2018-03-13 18:31:41655
dcheng72be33c2016-01-21 04:11:31656 for (FrameTreeNode* node : frame_tree_.Nodes()) {
657 // Delete all RFHs pending shutdown, which will lead the corresponding RVHs
658 // to be shutdown and be deleted as well.
dcheng57e39e22016-01-21 00:25:38659 node->render_manager()->ClearRFHsPendingShutdown();
dcheng57e39e22016-01-21 00:25:38660 node->render_manager()->ClearWebUIInstances();
dcheng72be33c2016-01-21 04:11:31661 }
carlosk35f35af2015-12-01 10:55:40662
dcheng57e39e22016-01-21 00:25:38663 for (RenderWidgetHostImpl* widget : created_widgets_)
664 widget->DetachDelegate();
[email protected]b24b68a2012-09-24 21:57:26665 created_widgets_.clear();
666
[email protected]3ab9cb82011-06-03 18:02:07667 // Clear out any JavaScript state.
avi5d3b8692016-10-12 22:00:46668 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:53669 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:46670 }
[email protected]3ab9cb82011-06-03 18:02:07671
Joel Hockey85b379d2017-12-11 10:42:13672 color_chooser_.reset();
Rakina Zata Amni16196122018-11-14 02:14:00673 find_request_manager_.reset();
[email protected]da8543762012-03-20 08:52:20674
[email protected]420ae012009-04-24 05:16:32675 NotifyDisconnected();
[email protected]420ae012009-04-24 05:16:32676
[email protected]ca13a442012-04-17 14:00:12677 // Notify any observer that have a reference on this WebContents.
[email protected]8ff00d72012-10-23 19:12:21678 NotificationService::current()->Notify(
679 NOTIFICATION_WEB_CONTENTS_DESTROYED,
680 Source<WebContents>(this),
681 NotificationService::NoDetails());
[email protected]420ae012009-04-24 05:16:32682
Arthur Sonzogni5a9a88c2018-10-18 13:16:00683 // Destroy all subframes now. This notifies observers.
684 GetMainFrame()->ResetChildren();
[email protected]df0c843f2014-05-23 20:37:23685 GetRenderManager()->ResetProxyHosts();
[email protected]c06c58c2014-03-12 20:31:59686
clamy0e119882015-07-31 16:12:33687 // Manually call the observer methods for the root frame tree node. It is
688 // necessary to manually delete all objects tracking navigations
689 // (NavigationHandle, NavigationRequest) for observers to be properly
690 // notified of these navigations stopping before the WebContents is
691 // destroyed.
[email protected]df0c843f2014-05-23 20:37:23692 RenderFrameHostManager* root = GetRenderManager();
naskob21fe4872015-02-24 14:15:56693
Lowell Manners20250112019-10-18 15:06:15694 GetController().GetBackForwardCache().Shutdown();
695
naskob21fe4872015-02-24 14:15:56696 root->current_frame_host()->SetRenderFrameCreated(false);
clamyfc3850d2018-02-23 14:35:28697 root->current_frame_host()->ResetNavigationRequests();
clamy0e119882015-07-31 16:12:33698
Arthur Hemeryc3380172018-01-22 14:00:17699 // Do not update state as the WebContents is being destroyed.
Arthur Hemery241b9392019-10-24 11:08:41700 frame_tree_.root()->ResetNavigationRequest(true);
Arthur Hemeryc3380172018-01-22 14:00:17701 if (root->speculative_frame_host()) {
danakjf2342432019-05-15 21:46:09702 root->speculative_frame_host()->DeleteRenderFrame(
703 FrameDeleteIntention::kSpeculativeMainFrameForShutdown);
Arthur Hemeryc3380172018-01-22 14:00:17704 root->speculative_frame_host()->SetRenderFrameCreated(false);
clamyfc3850d2018-02-23 14:35:28705 root->speculative_frame_host()->ResetNavigationRequests();
clamy0e119882015-07-31 16:12:33706 }
[email protected]f273ee52013-10-18 16:05:27707
brettw4b461082016-11-19 18:55:16708#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17709 // Call this before WebContentsDestroyed() is broadcasted since
710 // AudioFocusManager will be destroyed after that.
711 pepper_playback_observer_.reset();
712#endif // defined(ENABLED_PLUGINS)
713
Chris Hamiltondf0d72cd2018-05-29 16:23:53714 // If audio is playing then notify external observers of the audio stream
715 // disappearing.
716 if (is_currently_audible_) {
717 is_currently_audible_ = false;
718 for (auto& observer : observers_)
719 observer.OnAudioStateChanged(false);
720
721 if (GetOuterWebContents())
722 GetOuterWebContents()->OnAudioStateChanged();
723 }
724
ericwilligersde386342016-10-19 02:35:09725 for (auto& observer : observers_)
726 observer.FrameDeleted(root->current_frame_host());
naskoa83483fb2015-02-27 16:57:10727
ericwilligersde386342016-10-19 02:35:09728 for (auto& observer : observers_)
729 observer.RenderViewDeleted(root->current_host());
[email protected]f273ee52013-10-18 16:05:27730
Kevin McNee576bb5d82019-05-29 16:47:51731#if defined(OS_ANDROID)
732 // For simplicity, destroy the Java WebContents before we notify of the
733 // destruction of the WebContents.
734 ClearWebContentsAndroid();
735#endif
736
ericwilligersde386342016-10-19 02:35:09737 for (auto& observer : observers_)
738 observer.WebContentsDestroyed();
[email protected]12a46832014-05-09 13:35:58739
Becca Hughesd11d6502018-07-31 17:01:28740 if (display_cutout_host_impl_)
741 display_cutout_host_impl_->WebContentsDestroyed();
742
ericwilligersde386342016-10-19 02:35:09743 for (auto& observer : observers_)
744 observer.ResetWebContents();
[email protected]232a5812011-03-04 22:42:08745
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28746 SetDelegate(nullptr);
[email protected]b5a1d11c2011-02-17 03:09:42747}
748
erikchen50735fd2018-05-05 15:08:33749std::unique_ptr<WebContentsImpl> WebContentsImpl::CreateWithOpener(
[email protected]54944cde2012-12-09 09:24:59750 const WebContents::CreateParams& params,
Ian Clelland5cbaaf82017-11-27 22:00:03751 RenderFrameHostImpl* opener_rfh) {
[email protected]e11f0e92013-06-12 15:12:03752 TRACE_EVENT0("browser", "WebContentsImpl::CreateWithOpener");
Ian Clelland5cbaaf82017-11-27 22:00:03753 FrameTreeNode* opener = nullptr;
754 if (opener_rfh)
755 opener = opener_rfh->frame_tree_node();
erikchen50735fd2018-05-05 15:08:33756 std::unique_ptr<WebContentsImpl> new_contents(
757 new WebContentsImpl(params.browser_context));
lukasza6f8ac622017-06-06 03:10:20758 new_contents->SetOpenerForNewContents(opener, params.opener_suppressed);
alexmose201c7cd2015-06-10 17:14:21759
alexmosaedfc6f2016-01-21 23:57:38760 // If the opener is sandboxed, a new popup must inherit the opener's sandbox
761 // flags, and these flags take effect immediately. An exception is if the
762 // opener's sandbox flags lack the PropagatesToAuxiliaryBrowsingContexts
763 // bit (which is controlled by the "allow-popups-to-escape-sandbox" token).
764 // See https://html.spec.whatwg.org/#attr-iframe-sandbox.
lukasza6f8ac622017-06-06 03:10:20765 FrameTreeNode* new_root = new_contents->GetFrameTree()->root();
alexmosaedfc6f2016-01-21 23:57:38766 if (opener) {
Antonio Gomes7096ac02020-02-14 14:29:54767 blink::mojom::WebSandboxFlags opener_flags =
768 opener_rfh->active_sandbox_flags();
769 const blink::mojom::WebSandboxFlags inherit_flag =
770 blink::mojom::WebSandboxFlags::kPropagatesToAuxiliaryBrowsingContexts;
Ehsan Karamad39407082019-02-19 23:38:19771 bool sandbox_propagates_to_auxilary_context =
772 (opener_flags & inherit_flag) == inherit_flag;
773 if (sandbox_propagates_to_auxilary_context)
Charlie Hue1b77ac2019-12-13 21:30:17774 new_root->SetPendingFramePolicy({opener_flags,
775 {} /* container_policy */,
776 {} /* required_document_policy */});
Antonio Gomes7096ac02020-02-14 14:29:54777 if (opener_flags == blink::mojom::WebSandboxFlags::kNone ||
Ehsan Karamad39407082019-02-19 23:38:19778 sandbox_propagates_to_auxilary_context) {
779 // TODO(ekaramad, iclelland): Do not propagate feature policies from non-
780 // sandboxed disowned openers (rel=noopener).
781 // If the current page is not sandboxed, or if the sandbox is to propagate
782 // to the popups then opener's feature policy will apply to the new popup
783 // as well.
784 new_root->SetOpenerFeaturePolicyState(
Ehsan Karamad34d10682019-02-26 20:55:04785 opener_rfh->feature_policy()->GetFeatureState());
alexmosaedfc6f2016-01-21 23:57:38786 }
787 }
788
mark a. foltzef394fce2017-10-21 09:11:02789 // Apply starting sandbox flags.
Luna Luc3fdacdf2017-11-08 04:48:53790 blink::FramePolicy frame_policy(new_root->pending_frame_policy());
mark a. foltzef394fce2017-10-21 09:11:02791 frame_policy.sandbox_flags |= params.starting_sandbox_flags;
792 new_root->SetPendingFramePolicy(frame_policy);
Charlie Hu5ffc0152019-12-06 15:59:53793 new_root->CommitFramePolicy(frame_policy);
mark a. foltzef394fce2017-10-21 09:11:02794
alexmose201c7cd2015-06-10 17:14:21795 // This may be true even when opener is null, such as when opening blocked
796 // popups.
alexmos090fae8e2015-05-28 17:09:28797 if (params.created_with_opener)
798 new_contents->created_with_opener_ = true;
799
Sean Toppingbbc4a2bd2019-01-30 02:16:14800 WebContentsImpl* outer_web_contents = nullptr;
[email protected]4858e432014-06-23 18:14:17801 if (params.guest_delegate) {
[email protected]83100cd2014-05-10 11:50:06802 // This makes |new_contents| act as a guest.
803 // For more info, see comment above class BrowserPluginGuest.
Albert J. Wongc55cc64d2018-10-12 02:50:04804 BrowserPluginGuest::CreateInWebContents(new_contents.get(),
805 params.guest_delegate);
Sean Toppingbbc4a2bd2019-01-30 02:16:14806 outer_web_contents = static_cast<WebContentsImpl*>(
807 params.guest_delegate->GetOwnerWebContents());
[email protected]83100cd2014-05-10 11:50:06808 }
mark a. foltzef394fce2017-10-21 09:11:02809
[email protected]54944cde2012-12-09 09:24:59810 new_contents->Init(params);
Sean Toppingbbc4a2bd2019-01-30 02:16:14811 if (outer_web_contents)
812 outer_web_contents->InnerWebContentsCreated(new_contents.get());
[email protected]d1198fd2012-08-13 22:50:19813 return new_contents;
814}
815
[email protected]95640212014-07-26 18:14:30816// static
817std::vector<WebContentsImpl*> WebContentsImpl::GetAllWebContents() {
818 std::vector<WebContentsImpl*> result;
dcheng59716272016-04-09 05:19:08819 std::unique_ptr<RenderWidgetHostIterator> widgets(
[email protected]95640212014-07-26 18:14:30820 RenderWidgetHostImpl::GetRenderWidgetHosts());
[email protected]95640212014-07-26 18:14:30821 while (RenderWidgetHost* rwh = widgets->GetNextHost()) {
[email protected]95640212014-07-26 18:14:30822 RenderViewHost* rvh = RenderViewHost::From(rwh);
823 if (!rvh)
824 continue;
825 WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
826 if (!web_contents)
827 continue;
avidf38c952015-10-27 13:45:13828 if (web_contents->GetRenderViewHost() != rvh)
829 continue;
830 // Because a WebContents can only have one current RVH at a time, there will
831 // be no duplicate WebContents here.
832 result.push_back(static_cast<WebContentsImpl*>(web_contents));
[email protected]95640212014-07-26 18:14:30833 }
834 return result;
835}
836
clamya16aa8172015-05-26 13:07:25837// static
838WebContentsImpl* WebContentsImpl::FromFrameTreeNode(
paulmeyerfeafc2d2017-04-25 21:46:40839 const FrameTreeNode* frame_tree_node) {
clamya16aa8172015-05-26 13:07:25840 return static_cast<WebContentsImpl*>(
841 WebContents::FromRenderFrameHost(frame_tree_node->current_frame_host()));
842}
843
clamy0d32d6d2015-11-24 11:16:26844// static
Patrick Monette275a6f92b2020-01-09 21:05:04845WebContents* WebContentsImpl::FromRenderFrameHostID(
846 GlobalFrameRoutingId render_frame_host_id) {
847 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
848 !BrowserThread::IsThreadInitialized(BrowserThread::UI));
Patrick Monette7364e6972020-01-09 22:56:02849 RenderFrameHost* render_frame_host =
850 RenderFrameHost::FromID(render_frame_host_id);
851 if (!render_frame_host)
852 return nullptr;
853
854 return WebContents::FromRenderFrameHost(render_frame_host);
Patrick Monette275a6f92b2020-01-09 21:05:04855}
856
857// static
clamy0d32d6d2015-11-24 11:16:26858WebContents* WebContentsImpl::FromRenderFrameHostID(int render_process_host_id,
859 int render_frame_host_id) {
Patrick Monette7364e6972020-01-09 22:56:02860 return FromRenderFrameHostID(
861 GlobalFrameRoutingId(render_process_host_id, render_frame_host_id));
clamy0d32d6d2015-11-24 11:16:26862}
863
paulmeyerfeafc2d2017-04-25 21:46:40864// static
865WebContentsImpl* WebContentsImpl::FromOuterFrameTreeNode(
866 const FrameTreeNode* frame_tree_node) {
867 return WebContentsImpl::FromFrameTreeNode(frame_tree_node)
868 ->node_.GetInnerWebContentsInFrame(frame_tree_node);
869}
870
[email protected]b0936d22013-11-28 06:47:36871RenderFrameHostManager* WebContentsImpl::GetRenderManagerForTesting() {
[email protected]fa944cb82013-11-15 17:51:21872 return GetRenderManager();
[email protected]765187182012-01-11 23:59:28873}
874
nicka0ac8382016-12-15 23:59:23875bool WebContentsImpl::OnMessageReceived(RenderViewHostImpl* render_view_host,
[email protected]7bb761892012-07-20 09:32:47876 const IPC::Message& message) {
nicka0ac8382016-12-15 23:59:23877 for (auto& observer : observers_) {
Lukasz Anforowicz89f2c1b2017-08-30 21:36:46878 // TODO(nick, creis): https://crbug.com/758026: Replace all uses of this
879 // variant of OnMessageReceived with the version that takes a
880 // RenderFrameHost, and then delete it.
nicka0ac8382016-12-15 23:59:23881 if (observer.OnMessageReceived(message))
882 return true;
[email protected]64ffefa2014-05-10 12:06:33883 }
[email protected]403415a2011-01-10 18:57:53884
[email protected]724159a2010-12-30 01:11:18885 bool handled = true;
nicka0ac8382016-12-15 23:59:23886 IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(WebContentsImpl, message, render_view_host)
W. James MacLean62198672019-06-04 16:46:10887 IPC_MESSAGE_HANDLER(
888 ViewHostMsg_NotifyTextAutosizerPageInfoChangedInLocalMainFrame,
889 OnTextAutosizerPageInfoChanged)
nicka0ac8382016-12-15 23:59:23890#if BUILDFLAG(ENABLE_PLUGINS)
891 IPC_MESSAGE_HANDLER(ViewHostMsg_RequestPpapiBrokerPermission,
892 OnRequestPpapiBrokerPermission)
893#endif
nicka0ac8382016-12-15 23:59:23894 IPC_MESSAGE_UNHANDLED(handled = false)
895 IPC_END_MESSAGE_MAP()
896
897 return handled;
898}
899
900bool WebContentsImpl::OnMessageReceived(RenderFrameHostImpl* render_frame_host,
901 const IPC::Message& message) {
Lukasz Anforowicz02923102017-10-09 18:11:37902 {
903 WebUIImpl* web_ui = render_frame_host->web_ui();
904 if (web_ui && web_ui->OnMessageReceived(message, render_frame_host))
905 return true;
906 }
907
nicka0ac8382016-12-15 23:59:23908 for (auto& observer : observers_) {
909 if (observer.OnMessageReceived(message, render_frame_host))
910 return true;
911 }
912
913 bool handled = true;
914 IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(WebContentsImpl, message, render_frame_host)
[email protected]cfa856d62014-02-22 07:58:40915 IPC_MESSAGE_HANDLER(FrameHostMsg_DomOperationResponse,
916 OnDomOperationResponse)
avi7830c852015-08-31 23:46:25917 IPC_MESSAGE_HANDLER(FrameHostMsg_DidLoadResourceFromMemoryCache,
[email protected]724159a2010-12-30 01:11:18918 OnDidLoadResourceFromMemoryCache)
avi3a3332622015-09-01 01:18:54919 IPC_MESSAGE_HANDLER(FrameHostMsg_DidRunInsecureContent,
[email protected]724159a2010-12-30 01:11:18920 OnDidRunInsecureContent)
estark910b4572015-12-09 20:55:41921 IPC_MESSAGE_HANDLER(FrameHostMsg_DidDisplayContentWithCertificateErrors,
922 OnDidDisplayContentWithCertificateErrors)
923 IPC_MESSAGE_HANDLER(FrameHostMsg_DidRunContentWithCertificateErrors,
924 OnDidRunContentWithCertificateErrors)
brettw4b461082016-11-19 18:55:16925#if BUILDFLAG(ENABLE_PLUGINS)
emaxxe70f5e12015-05-29 11:26:00926 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperInstanceCreated,
927 OnPepperInstanceCreated)
928 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperInstanceDeleted,
929 OnPepperInstanceDeleted)
tommyclie6633ca72014-10-31 00:40:42930 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperPluginHung, OnPepperPluginHung)
zqzhang181047e62016-07-01 13:37:17931 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperStartsPlayback,
932 OnPepperStartsPlayback)
933 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperStopsPlayback,
934 OnPepperStopsPlayback)
tommyclie6633ca72014-10-31 00:40:42935 IPC_MESSAGE_HANDLER(FrameHostMsg_PluginCrashed, OnPluginCrashed)
thestigc4cac8f2014-09-04 21:17:50936#endif
[email protected]724159a2010-12-30 01:11:18937 IPC_MESSAGE_UNHANDLED(handled = false)
[email protected]e44d1342014-05-16 21:29:33938 IPC_END_MESSAGE_MAP()
[email protected]724159a2010-12-30 01:11:18939
[email protected]724159a2010-12-30 01:11:18940 return handled;
941}
942
[email protected]d1198fd2012-08-13 22:50:19943NavigationControllerImpl& WebContentsImpl::GetController() {
[email protected]f5fa20e2011-12-21 22:35:56944 return controller_;
945}
946
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41947BrowserContext* WebContentsImpl::GetBrowserContext() {
[email protected]a26023822011-12-29 00:23:55948 return controller_.GetBrowserContext();
[email protected]627e0512011-12-21 22:55:30949}
950
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41951const GURL& WebContentsImpl::GetURL() {
Peter Boström101d7672018-12-15 00:43:59952 return GetVisibleURL();
[email protected]be1f56ab2011-12-22 06:55:31953}
954
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41955const GURL& WebContentsImpl::GetVisibleURL() {
[email protected]c854a7e2013-05-21 16:42:24956 // We may not have a navigation entry yet.
[email protected]59167c22013-06-03 18:07:32957 NavigationEntry* entry = controller_.GetVisibleEntry();
[email protected]c854a7e2013-05-21 16:42:24958 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
959}
960
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41961const GURL& WebContentsImpl::GetLastCommittedURL() {
[email protected]c854a7e2013-05-21 16:42:24962 // We may not have a navigation entry yet.
963 NavigationEntry* entry = controller_.GetLastCommittedEntry();
964 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
965}
966
[email protected]8ff00d72012-10-23 19:12:21967WebContentsDelegate* WebContentsImpl::GetDelegate() {
[email protected]be1f56ab2011-12-22 06:55:31968 return delegate_;
969}
970
[email protected]8ff00d72012-10-23 19:12:21971void WebContentsImpl::SetDelegate(WebContentsDelegate* delegate) {
[email protected]be1f56ab2011-12-22 06:55:31972 // TODO(cbentzel): remove this debugging code?
973 if (delegate == delegate_)
974 return;
975 if (delegate_)
976 delegate_->Detach(this);
977 delegate_ = delegate;
[email protected]a6b73c62013-02-11 23:05:08978 if (delegate_) {
[email protected]be1f56ab2011-12-22 06:55:31979 delegate_->Attach(this);
[email protected]a6b73c62013-02-11 23:05:08980 // Ensure the visible RVH reflects the new delegate's preferences.
[email protected]86f98a22013-03-20 14:35:00981 if (view_)
[email protected]e85165c642014-06-10 14:34:31982 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
Joel Einbinder848001c2017-09-19 21:39:31983 if (GetRenderViewHost())
984 RenderFrameDevToolsAgentHost::WebContentsCreated(this);
[email protected]a6b73c62013-02-11 23:05:08985 }
[email protected]be1f56ab2011-12-22 06:55:31986}
987
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41988RenderFrameHostImpl* WebContentsImpl::GetMainFrame() {
[email protected]94d0cc12013-12-18 00:07:41989 return frame_tree_.root()->current_frame_host();
[email protected]60eca4eb2013-12-06 00:02:16990}
991
nick53d5cbf2015-04-23 22:50:14992RenderFrameHostImpl* WebContentsImpl::GetFocusedFrame() {
993 FrameTreeNode* focused_node = frame_tree_.GetFocusedFrame();
994 if (!focused_node)
995 return nullptr;
996 return focused_node->current_frame_host();
[email protected]9c9343b2014-03-08 02:56:07997}
998
rob3e2a0732016-01-06 21:22:09999RenderFrameHostImpl* WebContentsImpl::FindFrameByFrameTreeNodeId(
creisf71a2632017-05-04 19:03:501000 int frame_tree_node_id,
1001 int process_id) {
1002 FrameTreeNode* frame = frame_tree_.FindByID(frame_tree_node_id);
1003
1004 // Sanity check that this is in the caller's expected process. Otherwise a
1005 // recent cross-process navigation may have led to a privilege change that the
1006 // caller is not expecting.
1007 if (!frame ||
1008 frame->current_frame_host()->GetProcess()->GetID() != process_id)
1009 return nullptr;
1010
1011 return frame->current_frame_host();
1012}
1013
1014RenderFrameHostImpl* WebContentsImpl::UnsafeFindFrameByFrameTreeNodeId(
rob3e2a0732016-01-06 21:22:091015 int frame_tree_node_id) {
creisf71a2632017-05-04 19:03:501016 // Beware using this! The RenderFrameHost may have changed since the caller
1017 // obtained frame_tree_node_id.
rob3e2a0732016-01-06 21:22:091018 FrameTreeNode* frame = frame_tree_.FindByID(frame_tree_node_id);
1019 return frame ? frame->current_frame_host() : nullptr;
1020}
1021
[email protected]a86c0e962013-12-17 17:10:391022void WebContentsImpl::ForEachFrame(
Lei Zhangebcc6302018-01-12 19:46:451023 const base::RepeatingCallback<void(RenderFrameHost*)>& on_frame) {
dcheng57e39e22016-01-21 00:25:381024 for (FrameTreeNode* node : frame_tree_.Nodes()) {
1025 on_frame.Run(node->current_frame_host());
1026 }
[email protected]a86c0e962013-12-17 17:10:391027}
1028
dchengafb53e22016-02-04 08:11:081029std::vector<RenderFrameHost*> WebContentsImpl::GetAllFrames() {
1030 std::vector<RenderFrameHost*> frame_hosts;
1031 for (FrameTreeNode* node : frame_tree_.Nodes())
1032 frame_hosts.push_back(node->current_frame_host());
1033 return frame_hosts;
1034}
1035
lukaszacbdf52e2016-01-15 21:19:511036int WebContentsImpl::SendToAllFrames(IPC::Message* message) {
1037 int number_of_messages = 0;
dchengafb53e22016-02-04 08:11:081038 for (RenderFrameHost* rfh : GetAllFrames()) {
lukasza1a9ab2422016-03-02 18:47:251039 if (!rfh->IsRenderFrameLive())
1040 continue;
1041
dchengafb53e22016-02-04 08:11:081042 ++number_of_messages;
1043 IPC::Message* message_copy = new IPC::Message(*message);
1044 message_copy->set_routing_id(rfh->GetRoutingID());
1045 rfh->Send(message_copy);
1046 }
[email protected]a86c0e962013-12-17 17:10:391047 delete message;
lukaszacbdf52e2016-01-15 21:19:511048 return number_of_messages;
[email protected]a86c0e962013-12-17 17:10:391049}
1050
lfgdb5c4ed2016-03-04 23:09:071051void WebContentsImpl::SendPageMessage(IPC::Message* msg) {
alexmos136fd6e62016-08-15 20:58:411052 frame_tree_.root()->render_manager()->SendPageMessage(msg, nullptr);
lfgdb5c4ed2016-03-04 23:09:071053}
1054
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411055RenderViewHostImpl* WebContentsImpl::GetRenderViewHost() {
[email protected]fa944cb82013-11-15 17:51:211056 return GetRenderManager()->current_host();
[email protected]be1f56ab2011-12-22 06:55:311057}
1058
creis89a0f782015-05-27 16:13:171059void WebContentsImpl::CancelActiveAndPendingDialogs() {
avi5d3b8692016-10-12 22:00:461060 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:531061 dialog_manager_->CancelDialogs(this, /*reset_state=*/false);
avi5d3b8692016-10-12 22:00:461062 }
creis89a0f782015-05-27 16:13:171063 if (browser_plugin_embedder_)
1064 browser_plugin_embedder_->CancelGuestDialogs();
1065}
1066
naskoc0fceff2015-04-30 15:53:521067void WebContentsImpl::ClosePage() {
1068 GetRenderViewHost()->ClosePage();
1069}
1070
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411071RenderWidgetHostView* WebContentsImpl::GetRenderWidgetHostView() {
[email protected]fa944cb82013-11-15 17:51:211072 return GetRenderManager()->GetRenderWidgetHostView();
[email protected]be1f56ab2011-12-22 06:55:311073}
1074
lfg265a2672016-04-23 03:11:021075RenderWidgetHostView* WebContentsImpl::GetTopLevelRenderWidgetHostView() {
1076 if (GetOuterWebContents())
1077 return GetOuterWebContents()->GetTopLevelRenderWidgetHostView();
1078 return GetRenderManager()->GetRenderWidgetHostView();
1079}
1080
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411081RenderWidgetHostView* WebContentsImpl::GetFullscreenRenderWidgetHostView() {
vmpstr6d9996c82017-02-23 00:43:251082 if (auto* widget_host = GetFullscreenRenderWidgetHost())
ekaramadaeb3c5c2016-11-09 03:22:351083 return widget_host->GetView();
1084 return nullptr;
[email protected]4aebbca2013-09-17 22:26:491085}
1086
[email protected]8ff00d72012-10-23 19:12:211087WebContentsView* WebContentsImpl::GetView() const {
[email protected]be1f56ab2011-12-22 06:55:311088 return view_.get();
1089}
1090
leon.han552e9de2017-02-09 14:37:301091void WebContentsImpl::OnScreenOrientationChange() {
1092 DCHECK(screen_orientation_provider_);
Lan Weif81c6e7c2020-02-12 16:46:091093 DidChangeScreenOrientation();
Becca Hughese9e27952018-06-25 17:08:271094 screen_orientation_provider_->OnOrientationChange();
leon.hane4db177a2017-02-07 14:19:161095}
1096
Alan Cutter92d59252019-03-29 02:32:331097base::Optional<SkColor> WebContentsImpl::GetThemeColor() {
Carlos Caballero1215f882019-10-29 15:58:431098 return GetRenderViewHost()->theme_color();
yusufod41c5f92015-03-06 00:14:281099}
1100
Doug Turner63f3c7b2017-07-29 05:10:011101void WebContentsImpl::SetAccessibilityMode(ui::AXMode mode) {
[email protected]95640212014-07-26 18:14:301102 if (mode == accessibility_mode_)
1103 return;
1104
dmazzonif8a31042016-12-03 00:52:131105 // Don't allow accessibility to be enabled for WebContents that are never
danakj77eb7e82020-01-09 19:38:461106 // user-visible, like background pages.
1107 if (IsNeverComposited())
dmazzonif8a31042016-12-03 00:52:131108 return;
1109
[email protected]95640212014-07-26 18:14:301110 accessibility_mode_ = mode;
dcheng57e39e22016-01-21 00:25:381111
1112 for (FrameTreeNode* node : frame_tree_.Nodes()) {
dmazzonif8a31042016-12-03 00:52:131113 UpdateAccessibilityModeOnFrame(node->current_frame_host());
clamy610c63b32017-12-22 15:05:181114 // Also update accessibility mode on the speculative RenderFrameHost for
1115 // this FrameTreeNode, if one exists.
Alex Moshchuk3d8a1f392017-10-24 19:01:261116 RenderFrameHost* speculative_frame_host =
1117 node->render_manager()->speculative_frame_host();
1118 if (speculative_frame_host)
1119 UpdateAccessibilityModeOnFrame(speculative_frame_host);
dcheng57e39e22016-01-21 00:25:381120 }
[email protected]95640212014-07-26 18:14:301121}
1122
Doug Turner63f3c7b2017-07-29 05:10:011123void WebContentsImpl::AddAccessibilityMode(ui::AXMode mode) {
1124 ui::AXMode new_mode(accessibility_mode_);
dougtcd3dad732017-03-14 03:26:231125 new_mode |= mode;
1126 SetAccessibilityMode(new_mode);
[email protected]95640212014-07-26 18:14:301127}
1128
Avi Drissman1e620f32018-03-16 13:57:291129// Helper class used by WebContentsImpl::RequestAXTreeSnapshot.
1130// Handles the callbacks from parallel snapshot requests to each frame,
1131// and feeds the results to an AXTreeCombiner, which converts them into a
1132// single combined accessibility tree.
1133class WebContentsImpl::AXTreeSnapshotCombiner
1134 : public base::RefCounted<AXTreeSnapshotCombiner> {
1135 public:
1136 explicit AXTreeSnapshotCombiner(AXTreeSnapshotCallback callback)
1137 : callback_(std::move(callback)) {}
1138
1139 AXTreeSnapshotCallback AddFrame(bool is_root) {
1140 // Adds a reference to |this|.
1141 return base::BindOnce(&AXTreeSnapshotCombiner::ReceiveSnapshot, this,
1142 is_root);
1143 }
1144
1145 void ReceiveSnapshot(bool is_root, const ui::AXTreeUpdate& snapshot) {
1146 combiner_.AddTree(snapshot, is_root);
1147 }
1148
1149 private:
1150 friend class base::RefCounted<AXTreeSnapshotCombiner>;
1151
1152 // This is called automatically after the last call to ReceiveSnapshot
1153 // when there are no more references to this object.
1154 ~AXTreeSnapshotCombiner() {
1155 combiner_.Combine();
1156 std::move(callback_).Run(combiner_.combined());
1157 }
1158
1159 ui::AXTreeCombiner combiner_;
1160 AXTreeSnapshotCallback callback_;
1161};
1162
1163void WebContentsImpl::RequestAXTreeSnapshot(AXTreeSnapshotCallback callback,
1164 ui::AXMode ax_mode) {
dmazzonid95ae842016-04-12 21:17:391165 // Send a request to each of the frames in parallel. Each one will return
1166 // an accessibility tree snapshot, and AXTreeSnapshotCombiner will combine
1167 // them into a single tree and call |callback| with that result, then
1168 // delete |combiner|.
Avi Drissman1e620f32018-03-16 13:57:291169 FrameTreeNode* root_node = frame_tree_.root();
tzik58faa742018-08-01 10:54:181170 auto combiner =
1171 base::MakeRefCounted<AXTreeSnapshotCombiner>(std::move(callback));
Avi Drissman1e620f32018-03-16 13:57:291172
tzik58faa742018-08-01 10:54:181173 RecursiveRequestAXTreeSnapshotOnFrame(root_node, combiner.get(), ax_mode);
Avi Drissman1e620f32018-03-16 13:57:291174}
1175
1176void WebContentsImpl::RecursiveRequestAXTreeSnapshotOnFrame(
1177 FrameTreeNode* root_node,
1178 AXTreeSnapshotCombiner* combiner,
1179 ui::AXMode ax_mode) {
dmazzonid95ae842016-04-12 21:17:391180 for (FrameTreeNode* frame_tree_node : frame_tree_.Nodes()) {
Avi Drissman1e620f32018-03-16 13:57:291181 WebContentsImpl* inner_contents =
1182 node_.GetInnerWebContentsInFrame(frame_tree_node);
1183 if (inner_contents) {
1184 inner_contents->RecursiveRequestAXTreeSnapshotOnFrame(root_node, combiner,
1185 ax_mode);
1186 } else {
1187 bool is_root = frame_tree_node == root_node;
1188 frame_tree_node->current_frame_host()->RequestAXTreeSnapshot(
1189 combiner->AddFrame(is_root), ax_mode);
1190 }
dmazzonid95ae842016-04-12 21:17:391191 }
dmazzoni83ba5c82015-04-14 07:11:511192}
1193
Becca Hughes3b5a43482018-07-17 22:31:551194void WebContentsImpl::NotifyViewportFitChanged(
1195 blink::mojom::ViewportFit value) {
1196 for (auto& observer : observers_)
1197 observer.ViewportFitChanged(value);
1198}
1199
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411200FindRequestManager* WebContentsImpl::GetFindRequestManagerForTesting() {
Ehsan Karamad6beb2ea2018-11-25 18:15:131201 return GetFindRequestManager();
1202}
1203
mcnee336ea2c2017-05-23 22:50:591204#if !defined(OS_ANDROID)
akabac6bd1212018-06-25 20:10:481205void WebContentsImpl::UpdateZoom() {
1206 RenderWidgetHostImpl* rwh = GetRenderViewHost()->GetWidget();
1207 if (rwh->GetView())
1208 rwh->SynchronizeVisualProperties();
wjmaclean64951902016-04-29 20:59:121209}
1210
wjmaclean64951902016-04-29 20:59:121211
1212void WebContentsImpl::UpdateZoomIfNecessary(const std::string& scheme,
akabac6bd1212018-06-25 20:10:481213 const std::string& host) {
wjmaclean64951902016-04-29 20:59:121214 NavigationEntry* entry = GetController().GetLastCommittedEntry();
1215 if (!entry)
1216 return;
1217
1218 GURL url = HostZoomMap::GetURLFromEntry(entry);
1219 if (host != net::GetHostOrSpecFromURL(url) ||
1220 (!scheme.empty() && !url.SchemeIs(scheme))) {
1221 return;
1222 }
1223
akabac6bd1212018-06-25 20:10:481224 UpdateZoom();
wjmaclean64951902016-04-29 20:59:121225}
mcnee336ea2c2017-05-23 22:50:591226#endif // !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:121227
Julie Jeongeun Kim7d0986172019-12-04 03:17:251228base::OnceClosure WebContentsImpl::AddReceiverSet(
rockotf62002a2016-09-15 00:08:591229 const std::string& interface_name,
Julie Jeongeun Kim7d0986172019-12-04 03:17:251230 WebContentsReceiverSet* receiver_set) {
rockotf62002a2016-09-15 00:08:591231 auto result =
Julie Jeongeun Kim7d0986172019-12-04 03:17:251232 receiver_sets_.insert(std::make_pair(interface_name, receiver_set));
rockotf62002a2016-09-15 00:08:591233 DCHECK(result.second);
Julie Jeongeun Kim7d0986172019-12-04 03:17:251234 return base::BindOnce(&WebContentsImpl::RemoveReceiverSet,
danakjf4b9e942019-11-29 15:43:041235 weak_factory_.GetWeakPtr(), interface_name);
rockotf62002a2016-09-15 00:08:591236}
1237
Julie Jeongeun Kim7d0986172019-12-04 03:17:251238WebContentsReceiverSet* WebContentsImpl::GetReceiverSet(
rockot8bbad222017-03-22 04:34:051239 const std::string& interface_name) {
Julie Jeongeun Kim7d0986172019-12-04 03:17:251240 auto it = receiver_sets_.find(interface_name);
1241 if (it == receiver_sets_.end())
rockot8bbad222017-03-22 04:34:051242 return nullptr;
1243 return it->second;
1244}
1245
John Delaney732721e92020-02-07 23:11:271246void WebContentsImpl::RemoveReceiverSetForTesting(
1247 const std::string& interface_name) {
1248 RemoveReceiverSet(interface_name);
1249}
1250
paulmeyerfeafc2d2017-04-25 21:46:401251std::vector<WebContentsImpl*> WebContentsImpl::GetWebContentsAndAllInner() {
1252 std::vector<WebContentsImpl*> all_contents(1, this);
1253
1254 for (size_t i = 0; i != all_contents.size(); ++i) {
1255 for (auto* inner_contents : all_contents[i]->GetInnerWebContents()) {
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:161256 all_contents.push_back(static_cast<WebContentsImpl*>(inner_contents));
paulmeyerfeafc2d2017-04-25 21:46:401257 }
1258 }
1259
1260 return all_contents;
1261}
1262
Sam McNally145fb172017-05-10 00:13:231263void WebContentsImpl::NotifyManifestUrlChanged(
1264 const base::Optional<GURL>& manifest_url) {
1265 for (auto& observer : observers_)
1266 observer.DidUpdateWebManifestURL(manifest_url);
1267}
1268
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411269WebUI* WebContentsImpl::GetWebUI() {
Nasko Oskov2f7d2112019-10-29 03:26:571270 WebUI* committed_web_ui = GetCommittedWebUI();
1271 if (committed_web_ui)
1272 return committed_web_ui;
1273
1274 if (GetRenderManager()->speculative_frame_host())
1275 return GetRenderManager()->speculative_frame_host()->web_ui();
1276
1277 return nullptr;
[email protected]be1f56ab2011-12-22 06:55:311278}
1279
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411280WebUI* WebContentsImpl::GetCommittedWebUI() {
carlosk35f35af2015-12-01 10:55:401281 return frame_tree_.root()->current_frame_host()->web_ui();
[email protected]d5f942ba2008-09-26 19:30:341282}
1283
Changwan Ryuc1134a82018-03-07 02:10:141284void WebContentsImpl::SetUserAgentOverride(const std::string& override,
1285 bool override_in_new_tabs) {
[email protected]bf70edce2012-06-20 22:32:221286 if (GetUserAgentOverride() == override)
1287 return;
1288
Changwan Ryuc1134a82018-03-07 02:10:141289 should_override_user_agent_in_new_tabs_ = override_in_new_tabs;
1290
[email protected]bf70edce2012-06-20 22:32:221291 renderer_preferences_.user_agent_override = override;
1292
Bruce Long1e3e1f542019-10-16 17:56:281293 // Send the new override string to all renderers in the current page.
1294 SyncRendererPrefs();
[email protected]bf70edce2012-06-20 22:32:221295
1296 // Reload the page if a load is currently in progress to avoid having
1297 // different parts of the page loaded using different user agents.
[email protected]6286a372013-10-09 04:03:271298 NavigationEntry* entry = controller_.GetVisibleEntry();
Ivan Kotenkov2c0d2bb32017-11-01 15:41:281299 if (IsLoading() && entry != nullptr && entry->GetIsOverridingUserAgent())
toyoshim6142d96f2016-12-19 09:07:251300 controller_.Reload(ReloadType::BYPASSING_CACHE, true);
[email protected]8d0f3312012-08-18 01:47:531301
ericwilligersde386342016-10-19 02:35:091302 for (auto& observer : observers_)
1303 observer.UserAgentOverrideSet(override);
[email protected]86ef6a392012-05-11 22:03:111304}
1305
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411306const std::string& WebContentsImpl::GetUserAgentOverride() {
[email protected]bf70edce2012-06-20 22:32:221307 return renderer_preferences_.user_agent_override;
[email protected]86ef6a392012-05-11 22:03:111308}
1309
Changwan Ryuc1134a82018-03-07 02:10:141310bool WebContentsImpl::ShouldOverrideUserAgentInNewTabs() {
1311 return should_override_user_agent_in_new_tabs_;
1312}
1313
dmazzonidd3d51a72016-12-14 18:41:011314void WebContentsImpl::EnableWebContentsOnlyAccessibilityMode() {
Dominic Mazzonid9fda172019-03-07 17:12:071315 // If accessibility is already enabled, we'll need to force a reset
1316 // in order to ensure new observers of accessibility events get the
1317 // full accessibility tree from scratch.
1318 bool need_reset = GetAccessibilityMode().has_mode(ui::AXMode::kWebContents);
1319
1320 ui::AXMode desired_mode =
1321 GetContentClient()->browser()->GetAXModeForBrowserContext(
1322 GetBrowserContext());
1323 desired_mode |= ui::kAXModeWebContentsOnly;
1324 AddAccessibilityMode(desired_mode);
1325
1326 if (need_reset) {
dchengafb53e22016-02-04 08:11:081327 for (RenderFrameHost* rfh : GetAllFrames())
1328 ResetAccessibility(rfh);
dchengafb53e22016-02-04 08:11:081329 }
[email protected]95640212014-07-26 18:14:301330}
1331
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411332bool WebContentsImpl::IsWebContentsOnlyAccessibilityModeForTesting() {
Doug Turner63f3c7b2017-07-29 05:10:011333 return accessibility_mode_ == ui::kAXModeWebContentsOnly;
[email protected]95640212014-07-26 18:14:301334}
1335
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411336bool WebContentsImpl::IsFullAccessibilityModeForTesting() {
Doug Turner63f3c7b2017-07-29 05:10:011337 return accessibility_mode_ == ui::kAXModeComplete;
[email protected]95640212014-07-26 18:14:301338}
1339
Becca Hughes6daf5662018-06-27 16:50:541340#if defined(OS_ANDROID)
1341
1342void WebContentsImpl::SetDisplayCutoutSafeArea(gfx::Insets insets) {
Becca Hughes86334622018-07-09 21:29:381343 if (display_cutout_host_impl_)
1344 display_cutout_host_impl_->SetDisplayCutoutSafeArea(insets);
Becca Hughes6daf5662018-06-27 16:50:541345}
1346
1347#endif
1348
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411349const base::string16& WebContentsImpl::GetTitle() {
[email protected]4c6092c5b2009-06-06 00:23:551350 // Transient entries take precedence. They are used for interstitial pages
1351 // that are shown on top of existing pages.
[email protected]10f417c52011-12-28 21:04:231352 NavigationEntry* entry = controller_.GetTransientEntry();
[email protected]45d0ef7f2011-01-05 13:46:231353 if (entry) {
jshin1fb76462016-04-05 22:13:031354 return entry->GetTitleForDisplay();
[email protected]45d0ef7f2011-01-05 13:46:231355 }
carlosk35f35af2015-12-01 10:55:401356
Nasko Oskov2f7d2112019-10-29 03:26:571357 WebUI* our_web_ui =
1358 GetRenderManager()->speculative_frame_host()
1359 ? GetRenderManager()->speculative_frame_host()->web_ui()
1360 : GetRenderManager()->current_frame_host()->web_ui();
[email protected]7ade2732011-02-10 00:13:581361 if (our_web_ui) {
[email protected]96d185d2009-04-24 03:28:541362 // Don't override the title in view source mode.
[email protected]59167c22013-06-03 18:07:321363 entry = controller_.GetVisibleEntry();
[email protected]96d185d2009-04-24 03:28:541364 if (!(entry && entry->IsViewSourceMode())) {
[email protected]e0112912011-02-02 22:54:351365 // Give the Web UI the chance to override our title.
[email protected]fcf75d42013-12-03 20:11:261366 const base::string16& title = our_web_ui->GetOverriddenTitle();
[email protected]96d185d2009-04-24 03:28:541367 if (!title.empty())
1368 return title;
1369 }
1370 }
1371
1372 // We use the title for the last committed entry rather than a pending
1373 // navigation entry. For example, when the user types in a URL, we want to
1374 // keep the old page's title until the new load has committed and we get a new
1375 // title.
[email protected]96d185d2009-04-24 03:28:541376 entry = controller_.GetLastCommittedEntry();
[email protected]59167c22013-06-03 18:07:321377
creis072b61f2015-09-28 20:52:241378 // We make an exception for initial navigations. We only want to use the title
1379 // from the visible entry if:
1380 // 1. The pending entry has been explicitly assigned a title to display.
1381 // 2. The user is doing a history navigation in a new tab (e.g., Ctrl+Back),
1382 // which case there is a pending entry index other than -1.
1383 //
1384 // Otherwise, we want to stick with the last committed entry's title during
1385 // new navigations, which have pending entries at index -1 with no title.
1386 if (controller_.IsInitialNavigation() &&
1387 ((controller_.GetVisibleEntry() &&
1388 !controller_.GetVisibleEntry()->GetTitle().empty()) ||
1389 controller_.GetPendingEntryIndex() != -1)) {
1390 entry = controller_.GetVisibleEntry();
[email protected]9eeafc012013-11-25 23:49:471391 }
[email protected]59167c22013-06-03 18:07:321392
[email protected]45d0ef7f2011-01-05 13:46:231393 if (entry) {
jshin1fb76462016-04-05 22:13:031394 return entry->GetTitleForDisplay();
[email protected]45d0ef7f2011-01-05 13:46:231395 }
[email protected]987fc3a2011-05-26 14:18:091396
1397 // |page_title_when_no_navigation_entry_| is finally used
1398 // if no title cannot be retrieved.
1399 return page_title_when_no_navigation_entry_;
[email protected]96d185d2009-04-24 03:28:541400}
1401
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411402SiteInstanceImpl* WebContentsImpl::GetSiteInstance() {
[email protected]fa944cb82013-11-15 17:51:211403 return GetRenderManager()->current_host()->GetSiteInstance();
[email protected]96d185d2009-04-24 03:28:541404}
1405
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411406bool WebContentsImpl::IsLoading() {
clamy44e84ce2016-02-22 15:38:251407 return frame_tree_.IsLoading() &&
creisadca9862017-06-16 19:12:111408 !(ShowingInterstitialPage() && interstitial_page_->pause_throbber());
[email protected]3c9e1872010-11-18 16:17:491409}
1410
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411411double WebContentsImpl::GetLoadProgress() {
Peter Boström18a40fa2018-10-31 19:03:501412 return frame_tree_.load_progress();
1413}
1414
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411415bool WebContentsImpl::IsLoadingToDifferentDocument() {
clamy44e84ce2016-02-22 15:38:251416 return IsLoading() && is_load_to_different_document_;
[email protected]6dfed692014-05-22 04:18:031417}
1418
Alexander Timindd0fa0c52019-11-06 13:03:371419bool WebContentsImpl::IsDocumentOnLoadCompletedInMainFrame() {
1420 return GetRenderViewHost()->IsDocumentOnLoadCompletedInMainFrame();
1421}
1422
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411423bool WebContentsImpl::IsWaitingForResponse() {
Peter Boströma9a27f6e2018-11-21 13:12:191424 NavigationRequest* ongoing_navigation_request =
1425 frame_tree_.root()->navigation_request();
1426
1427 // An ongoing navigation request means we're waiting for a response.
1428 return ongoing_navigation_request != nullptr;
[email protected]be1f56ab2011-12-22 06:55:311429}
1430
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411431const net::LoadStateWithParam& WebContentsImpl::GetLoadState() {
[email protected]be1f56ab2011-12-22 06:55:311432 return load_state_;
1433}
1434
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411435const base::string16& WebContentsImpl::GetLoadStateHost() {
[email protected]be1f56ab2011-12-22 06:55:311436 return load_state_host_;
1437}
1438
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411439uint64_t WebContentsImpl::GetUploadSize() {
[email protected]be1f56ab2011-12-22 06:55:311440 return upload_size_;
1441}
1442
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411443uint64_t WebContentsImpl::GetUploadPosition() {
[email protected]be1f56ab2011-12-22 06:55:311444 return upload_position_;
1445}
1446
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411447const std::string& WebContentsImpl::GetEncoding() {
Alexander Timine5f20e22019-10-09 23:22:351448 return GetMainFrame()->GetEncoding();
[email protected]be1f56ab2011-12-22 06:55:311449}
1450
Charles Zhaod72f99d2018-09-17 14:18:271451bool WebContentsImpl::WasDiscarded() {
1452 return GetFrameTree()->root()->was_discarded();
1453}
1454
Shubhie Panickerddf2a4e2018-03-06 00:09:061455void WebContentsImpl::SetWasDiscarded(bool was_discarded) {
1456 GetFrameTree()->root()->set_was_discarded();
1457}
1458
Collin Bakerc5259962019-11-14 17:51:581459void WebContentsImpl::IncrementCapturerCount(const gfx::Size& capture_size,
1460 bool stay_hidden) {
[email protected]5a652232013-02-12 06:15:251461 DCHECK(!is_being_destroyed_);
Collin Bakerc5259962019-11-14 17:51:581462 if (stay_hidden)
1463 ++hidden_capturer_count_;
1464 else
1465 ++visible_capturer_count_;
[email protected]222f5822014-02-05 23:40:491466
1467 // Note: This provides a hint to upstream code to size the views optimally
1468 // for quality (e.g., to avoid scaling).
1469 if (!capture_size.IsEmpty() && preferred_size_for_capture_.IsEmpty()) {
1470 preferred_size_for_capture_ = capture_size;
1471 OnPreferredSizeChanged(preferred_size_);
1472 }
ccameron8807c38f2015-01-17 00:29:191473
Collin Bakerc5259962019-11-14 17:51:581474 UpdateVisibilityAndNotifyPageAndView(GetVisibility());
[email protected]54597982013-02-06 01:59:551475}
1476
Collin Bakerc5259962019-11-14 17:51:581477void WebContentsImpl::DecrementCapturerCount(bool stay_hidden) {
1478 if (stay_hidden)
1479 --hidden_capturer_count_;
1480 else
1481 --visible_capturer_count_;
1482 DCHECK_GE(hidden_capturer_count_, 0);
1483 DCHECK_GE(visible_capturer_count_, 0);
[email protected]54597982013-02-06 01:59:551484
[email protected]5a652232013-02-12 06:15:251485 if (is_being_destroyed_)
1486 return;
1487
Francois Doray24fc62c2017-12-11 17:27:331488 if (!IsBeingCaptured()) {
[email protected]222f5822014-02-05 23:40:491489 const gfx::Size old_size = preferred_size_for_capture_;
1490 preferred_size_for_capture_ = gfx::Size();
1491 OnPreferredSizeChanged(old_size);
[email protected]54597982013-02-06 01:59:551492 }
Collin Bakerc5259962019-11-14 17:51:581493
1494 UpdateVisibilityAndNotifyPageAndView(GetVisibility());
[email protected]be1f56ab2011-12-22 06:55:311495}
1496
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411497bool WebContentsImpl::IsBeingCaptured() {
Collin Bakerc5259962019-11-14 17:51:581498 return visible_capturer_count_ + hidden_capturer_count_ > 0;
[email protected]f2bd40812013-07-20 04:30:441499}
1500
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411501bool WebContentsImpl::IsAudioMuted() {
Guido Urdanetaf8372942019-11-15 09:47:211502 return audio_stream_factory_ && audio_stream_factory_->IsMuted();
miu50f97892014-09-22 22:49:521503}
1504
1505void WebContentsImpl::SetAudioMuted(bool mute) {
1506 DVLOG(1) << "SetAudioMuted(mute=" << mute << "), was " << IsAudioMuted()
1507 << " for WebContentsImpl@" << this;
1508
1509 if (mute == IsAudioMuted())
1510 return;
1511
Guido Urdanetaf8372942019-11-15 09:47:211512 GetAudioStreamFactory()->SetMuted(mute);
miu50f97892014-09-22 22:49:521513
ericwilligersde386342016-10-19 02:35:091514 for (auto& observer : observers_)
1515 observer.DidUpdateAudioMutingState(mute);
wjmaclean2f797c782016-01-07 14:52:031516
Jan Rucka442c83f2017-08-08 13:27:541517 // Notification for UI updates in response to the changed muting state.
Collin Bakeraf540cf2019-09-20 20:54:161518 NotifyNavigationStateChanged(INVALIDATE_TYPE_AUDIO);
Jan Rucka442c83f2017-08-08 13:27:541519}
1520
1521bool WebContentsImpl::IsCurrentlyAudible() {
Chris Hamiltondf0d72cd2018-05-29 16:23:531522 return is_currently_audible_;
miu50f97892014-09-22 22:49:521523}
1524
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411525bool WebContentsImpl::IsConnectedToBluetoothDevice() {
ortunodf4d7982016-04-08 02:33:351526 return bluetooth_connected_device_count_ > 0;
ortuno32e7db3c2016-03-29 16:14:201527}
1528
Lucas Furukawa Gadani4b4eed02019-06-04 23:12:041529bool WebContentsImpl::IsConnectedToSerialPort() {
Reilly Grant5e7c79b22019-04-09 17:26:201530 return serial_active_frame_count_ > 0;
1531}
1532
Matt Reynoldse8c6c1f2019-11-02 09:53:531533bool WebContentsImpl::IsConnectedToHidDevice() {
1534 return hid_active_frame_count_ > 0;
1535}
1536
Marijn Kruisselbrink29051042019-08-06 22:56:551537bool WebContentsImpl::HasNativeFileSystemHandles() {
1538 return native_file_system_handle_count_ > 0;
1539}
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:331540bool WebContentsImpl::HasNativeFileSystemDirectoryHandles() {
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:471541 return !native_file_system_directory_handles_.empty();
1542}
1543
1544std::vector<base::FilePath>
1545WebContentsImpl::GetNativeFileSystemDirectoryHandles() {
1546 std::vector<base::FilePath> result;
1547 result.reserve(native_file_system_directory_handles_.size());
1548 for (auto const& entry : native_file_system_directory_handles_)
1549 result.push_back(entry.first);
1550 return result;
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:331551}
1552
1553bool WebContentsImpl::HasWritableNativeFileSystemHandles() {
1554 return native_file_system_writable_handle_count_ > 0;
1555}
1556
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411557bool WebContentsImpl::HasPictureInPictureVideo() {
sawtellea7333a82018-05-31 02:36:361558 return has_picture_in_picture_video_;
1559}
1560
1561void WebContentsImpl::SetHasPictureInPictureVideo(
1562 bool has_picture_in_picture_video) {
1563 // If status of |this| is already accurate, there is no need to update.
1564 if (has_picture_in_picture_video == has_picture_in_picture_video_)
1565 return;
1566 has_picture_in_picture_video_ = has_picture_in_picture_video;
1567 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
François Beaufort058085d2018-08-30 15:29:141568 for (auto& observer : observers_)
1569 observer.MediaPictureInPictureChanged(has_picture_in_picture_video_);
sawtellea7333a82018-05-31 02:36:361570}
1571
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411572bool WebContentsImpl::IsCrashed() {
Dominic Mazzoni73a48322018-05-25 18:14:071573 switch (crashed_status_) {
1574 case base::TERMINATION_STATUS_PROCESS_CRASHED:
1575 case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
1576 case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
1577 case base::TERMINATION_STATUS_OOM:
1578 case base::TERMINATION_STATUS_LAUNCH_FAILED:
oshima620225722015-06-04 19:45:271579#if defined(OS_CHROMEOS)
Dominic Mazzoni73a48322018-05-25 18:14:071580 case base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM:
oshima620225722015-06-04 19:45:271581#endif
Dominic Mazzoni73a48322018-05-25 18:14:071582#if defined(OS_ANDROID)
1583 case base::TERMINATION_STATUS_OOM_PROTECTED:
1584#endif
Will Harris07925d12019-10-31 03:03:051585#if defined(OS_WIN)
1586 case base::TERMINATION_STATUS_INTEGRITY_FAILURE:
1587#endif
Dominic Mazzoni73a48322018-05-25 18:14:071588 return true;
1589 case base::TERMINATION_STATUS_NORMAL_TERMINATION:
1590 case base::TERMINATION_STATUS_STILL_RUNNING:
1591 return false;
1592 case base::TERMINATION_STATUS_MAX_ENUM:
1593 NOTREACHED();
1594 return false;
1595 }
1596
1597 NOTREACHED();
1598 return false;
[email protected]3c9e1872010-11-18 16:17:491599}
1600
[email protected]b172aee2012-04-10 17:05:261601void WebContentsImpl::SetIsCrashed(base::TerminationStatus status,
1602 int error_code) {
[email protected]443b80e2010-12-14 00:42:231603 if (status == crashed_status_)
[email protected]d5f942ba2008-09-26 19:30:341604 return;
1605
[email protected]443b80e2010-12-14 00:42:231606 crashed_status_ = status;
1607 crashed_error_code_ = error_code;
[email protected]8ff00d72012-10-23 19:12:211608 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
[email protected]d5f942ba2008-09-26 19:30:341609}
1610
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411611base::TerminationStatus WebContentsImpl::GetCrashedStatus() {
[email protected]be1f56ab2011-12-22 06:55:311612 return crashed_status_;
1613}
1614
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411615int WebContentsImpl::GetCrashedErrorCode() {
afakhry98241832016-03-11 19:27:471616 return crashed_error_code_;
1617}
1618
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411619bool WebContentsImpl::IsBeingDestroyed() {
[email protected]be1f56ab2011-12-22 06:55:311620 return is_being_destroyed_;
1621}
1622
[email protected]7f924832014-08-09 05:57:221623void WebContentsImpl::NotifyNavigationStateChanged(
1624 InvalidateTypes changed_flags) {
dalecurtis88c240072015-12-09 02:11:181625 // Notify the media observer of potential audibility changes.
Collin Bakeraf540cf2019-09-20 20:54:161626 if (changed_flags & INVALIDATE_TYPE_AUDIO) {
mlamouri44e4ef42016-01-20 18:42:271627 media_web_contents_observer_->MaybeUpdateAudibleState();
dalecurtisbc6572e12014-09-12 19:22:301628 }
1629
[email protected]d5f942ba2008-09-26 19:30:341630 if (delegate_)
1631 delegate_->NavigationStateChanged(this, changed_flags);
wjmaclean1dabf3e32016-05-13 23:34:441632
1633 if (GetOuterWebContents())
1634 GetOuterWebContents()->NotifyNavigationStateChanged(changed_flags);
[email protected]d5f942ba2008-09-26 19:30:341635}
1636
W. James MacLean6f34b042019-07-12 19:25:301637RenderFrameHostImpl* WebContentsImpl::GetFocusedFrameFromFocusedDelegate() {
1638 FrameTreeNode* focused_node =
1639 GetFocusedWebContents()->frame_tree_.GetFocusedFrame();
1640 return focused_node ? focused_node->current_frame_host() : nullptr;
1641}
1642
David Black9cca3592019-11-06 23:02:221643void WebContentsImpl::OnVerticalScrollDirectionChanged(
1644 viz::VerticalScrollDirection scroll_direction) {
1645 for (auto& observer : observers_)
1646 observer.DidChangeVerticalScrollDirection(scroll_direction);
1647}
1648
Chris Hamiltondf0d72cd2018-05-29 16:23:531649void WebContentsImpl::OnAudioStateChanged() {
1650 // This notification can come from any embedded contents or from this
1651 // WebContents' stream monitor. Aggregate these signals to get the actual
1652 // state.
1653 bool is_currently_audible =
1654 audio_stream_monitor_.IsCurrentlyAudible() ||
1655 (browser_plugin_embedder_ &&
1656 browser_plugin_embedder_->AreAnyGuestsCurrentlyAudible());
1657 if (is_currently_audible == is_currently_audible_)
1658 return;
1659
1660 // Update internal state.
1661 is_currently_audible_ = is_currently_audible;
1662 was_ever_audible_ = was_ever_audible_ || is_currently_audible_;
1663
1664 SendPageMessage(
1665 new PageMsg_AudioStateChanged(MSG_ROUTING_NONE, is_currently_audible_));
altimind8bd26c2016-11-04 11:44:541666
altiminec87fd1f2016-11-17 20:22:491667 // Notification for UI updates in response to the changed audio state.
Collin Bakeraf540cf2019-09-20 20:54:161668 NotifyNavigationStateChanged(INVALIDATE_TYPE_AUDIO);
Jan Rucka442c83f2017-08-08 13:27:541669
Chris Hamiltondf0d72cd2018-05-29 16:23:531670 // Ensure that audio state changes propagate from innermost to outermost
1671 // WebContents.
1672 if (GetOuterWebContents())
1673 GetOuterWebContents()->OnAudioStateChanged();
Tommy Steimel18360512017-11-01 00:38:191674
Chris Hamiltoneb41198f2018-05-24 18:41:261675 for (auto& observer : observers_)
Chris Hamiltondf0d72cd2018-05-29 16:23:531676 observer.OnAudioStateChanged(is_currently_audible_);
altimind8bd26c2016-11-04 11:44:541677}
1678
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411679base::TimeTicks WebContentsImpl::GetLastActiveTime() {
[email protected]9a890452014-02-13 22:21:021680 return last_active_time_;
[email protected]3e324142012-06-25 18:26:331681}
1682
[email protected]9e2e4632012-07-27 16:38:411683void WebContentsImpl::WasShown() {
Collin Baker989e0882019-11-01 01:27:171684 UpdateVisibilityAndNotifyPageAndView(Visibility::VISIBLE);
[email protected]be1f56ab2011-12-22 06:55:311685}
1686
[email protected]b172aee2012-04-10 17:05:261687void WebContentsImpl::WasHidden() {
Collin Baker989e0882019-11-01 01:27:171688 UpdateVisibilityAndNotifyPageAndView(Visibility::HIDDEN);
[email protected]375fa1b2012-05-22 22:05:371689}
1690
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411691bool WebContentsImpl::HasRecentInteractiveInputEvent() {
Daniel Cheng90196c82018-04-25 21:49:141692 static constexpr base::TimeDelta kMaxInterval =
1693 base::TimeDelta::FromSeconds(5);
1694 base::TimeDelta delta =
1695 ui::EventTimeForNow() - last_interactive_input_event_time_;
1696 // Note: the expectation is that the caller is typically expecting an input
1697 // event, e.g. validating that a WebUI message that requires a gesture is
Daniel Chenge81030b32019-07-17 20:20:231698 // actually attached to a gesture.
Daniel Cheng90196c82018-04-25 21:49:141699 return delta <= kMaxInterval;
1700}
1701
Avi Drissman738ea192018-08-29 20:24:161702void WebContentsImpl::SetIgnoreInputEvents(bool ignore_input_events) {
1703 ignore_input_events_ = ignore_input_events;
1704}
1705
Bo Liu168c8642017-08-28 18:26:021706#if defined(OS_ANDROID)
Bo Liu16dd7b8322018-05-02 21:19:501707void WebContentsImpl::SetMainFrameImportance(
1708 ChildProcessImportance importance) {
1709 GetMainFrame()->GetRenderWidgetHost()->SetImportance(importance);
Bo Liu7c6779e92017-08-16 02:02:281710 if (ShowingInterstitialPage()) {
Bo Liu16dd7b8322018-05-02 21:19:501711 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
1712 ->GetRenderWidgetHost()
1713 ->SetImportance(importance);
Bo Liu7c6779e92017-08-16 02:02:281714 }
Bo Liu7c6779e92017-08-16 02:02:281715}
Bo Liu168c8642017-08-28 18:26:021716#endif
Bo Liu7c6779e92017-08-16 02:02:281717
ccameron8807c38f2015-01-17 00:29:191718void WebContentsImpl::WasOccluded() {
Collin Baker989e0882019-11-01 01:27:171719 UpdateVisibilityAndNotifyPageAndView(Visibility::OCCLUDED);
ccameron8807c38f2015-01-17 00:29:191720}
1721
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411722Visibility WebContentsImpl::GetVisibility() {
Francois Doraye6161152018-03-27 22:05:371723 return visibility_;
Francois Dorayfe4a1772018-02-17 04:17:091724}
1725
Alex Moshchuk5bcd7c12019-11-12 22:55:311726bool WebContentsImpl::NeedToFireBeforeUnloadOrUnload() {
[email protected]be1f56ab2011-12-22 06:55:311727 // TODO(creis): Should we fire even for interstitial pages?
Alex Moshchuk6fcaca752018-07-14 02:13:591728 if (ShowingInterstitialPage())
1729 return false;
1730
1731 if (!WillNotifyDisconnection())
1732 return false;
1733
1734 // Don't fire if the main frame's RenderViewHost indicates that beforeunload
1735 // and unload have already executed (e.g., after receiving a ClosePage ACK)
1736 // or should be ignored.
1737 if (GetRenderViewHost()->SuddenTerminationAllowed())
1738 return false;
1739
Alex Moshchukc78dbc722019-10-31 20:00:501740 // Check whether any frame in the frame tree needs to run beforeunload or
1741 // unload handlers.
1742 for (FrameTreeNode* node : frame_tree_.Nodes()) {
1743 RenderFrameHostImpl* rfh = node->current_frame_host();
1744
1745 // No need to run beforeunload/unload if the RenderFrame isn't live.
1746 if (!rfh->IsRenderFrameLive())
1747 continue;
1748
Dave Tapuska97d22ab2019-12-03 17:56:361749 if (rfh->GetSuddenTerminationDisablerState(
1750 blink::mojom::SuddenTerminationDisablerType::
1751 kBeforeUnloadHandler) ||
1752 rfh->GetSuddenTerminationDisablerState(
1753 blink::mojom::SuddenTerminationDisablerType::kUnloadHandler)) {
Alex Moshchukc78dbc722019-10-31 20:00:501754 return true;
1755 }
Aditya Keerthi34f37e62019-03-08 15:54:531756 }
Alex Moshchuk6fcaca752018-07-14 02:13:591757
Alex Moshchukc78dbc722019-10-31 20:00:501758 return false;
[email protected]be1f56ab2011-12-22 06:55:311759}
1760
Chris Hamilton3b3e315d2018-09-19 13:16:211761void WebContentsImpl::DispatchBeforeUnload(bool auto_cancel) {
1762 auto before_unload_type =
1763 auto_cancel ? RenderFrameHostImpl::BeforeUnloadType::DISCARD
1764 : RenderFrameHostImpl::BeforeUnloadType::TAB_CLOSE;
1765 GetMainFrame()->DispatchBeforeUnload(before_unload_type, false);
[email protected]1c3f80bd2014-04-08 23:02:061766}
1767
W. James MacLean2539adb32019-12-13 00:40:441768bool WebContentsImpl::IsInnerWebContentsForGuest() {
1769 return !!browser_plugin_guest_;
1770}
1771
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501772void WebContentsImpl::AttachInnerWebContents(
1773 std::unique_ptr<WebContents> inner_web_contents,
W. James MacLean62883982019-11-12 20:39:001774 RenderFrameHost* render_frame_host,
1775 bool is_full_page) {
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501776 WebContentsImpl* inner_web_contents_impl =
1777 static_cast<WebContentsImpl*>(inner_web_contents.get());
1778 DCHECK(!inner_web_contents_impl->node_.outer_web_contents());
1779 auto* render_frame_host_impl =
1780 static_cast<RenderFrameHostImpl*>(render_frame_host);
1781 DCHECK_EQ(&frame_tree_,
1782 render_frame_host_impl->frame_tree_node()->frame_tree());
Lucas Furukawa Gadani105de1e812018-05-31 19:38:391783
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501784 RenderFrameHostManager* inner_render_manager =
1785 inner_web_contents_impl->GetRenderManager();
1786 RenderFrameHostImpl* inner_main_frame =
1787 inner_render_manager->current_frame_host();
1788 RenderViewHostImpl* inner_render_view_host =
1789 inner_render_manager->current_host();
1790 auto* outer_render_manager =
1791 render_frame_host_impl->frame_tree_node()->render_manager();
lfg91a79e12016-04-01 23:52:191792
Lucas Furukawa Gadani105de1e812018-05-31 19:38:391793 // When attaching a WebContents as an inner WebContents, we need to replace
1794 // the Webcontents' view with a WebContentsViewChildFrame.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501795 inner_web_contents_impl->view_.reset(new WebContentsViewChildFrame(
1796 inner_web_contents_impl,
1797 GetContentClient()->browser()->GetWebContentsViewDelegate(
1798 inner_web_contents_impl),
1799 &inner_web_contents_impl->render_view_host_delegate_view_));
Lucas Furukawa Gadani105de1e812018-05-31 19:38:391800
lfg91a79e12016-04-01 23:52:191801 // When the WebContents being initialized has an opener, the browser side
1802 // Render{View,Frame}Host must be initialized and the RenderWidgetHostView
1803 // created. This is needed because the usual initialization happens during
1804 // the first navigation, but when attaching a new window we don't navigate
1805 // before attaching. If the browser side is already initialized, the calls
1806 // below will just early return.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501807 inner_render_manager->InitRenderView(inner_render_view_host, nullptr);
1808 inner_main_frame->Init();
1809 if (!inner_render_manager->GetRenderWidgetHostView()) {
1810 inner_web_contents_impl->CreateRenderWidgetHostViewForRenderManager(
1811 inner_render_view_host);
1812 }
lfg91a79e12016-04-01 23:52:191813
Adithya Srinivasane6e7f842019-12-16 18:41:361814 inner_web_contents_impl->RecursivelyUnregisterFrameSinkIds();
1815
lazyboy6ec48b2a2015-06-29 15:18:141816 // Create a link to our outer WebContents.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501817 node_.AttachInnerWebContents(std::move(inner_web_contents),
1818 render_frame_host_impl);
lazyboy6ec48b2a2015-06-29 15:18:141819
lazyboy6ec48b2a2015-06-29 15:18:141820 // Create a proxy in top-level RenderFrameHostManager, pointing to the
1821 // SiteInstance of the outer WebContents. The proxy will be used to send
1822 // postMessage to the inner WebContents.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501823 auto* proxy = inner_render_manager->CreateOuterDelegateProxy(
1824 render_frame_host_impl->GetSiteInstance());
lazyboy6ec48b2a2015-06-29 15:18:141825
Lucas Furukawa Gadani99125822019-01-03 15:41:491826 // When attaching a GuestView as an inner WebContents, there should already be
1827 // a live RenderFrame, which has to be swapped. When attaching a portal, there
1828 // will not be a live RenderFrame before creating the proxy.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501829 if (render_frame_host_impl->IsRenderFrameLive()) {
1830 inner_render_manager->SwapOuterDelegateFrame(render_frame_host_impl, proxy);
Lucas Furukawa Gadani99125822019-01-03 15:41:491831
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501832 inner_web_contents_impl->ReattachToOuterWebContentsFrame();
Lucas Furukawa Gadani99125822019-01-03 15:41:491833 }
ekaramadadd882292016-06-08 15:22:561834
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501835 if (frame_tree_.GetFocusedFrame() ==
1836 render_frame_host_impl->frame_tree_node()) {
1837 inner_web_contents_impl->SetFocusedFrame(
1838 inner_web_contents_impl->frame_tree_.root(),
1839 render_frame_host_impl->GetSiteInstance());
avallee7529b2a2017-04-26 11:37:511840 }
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501841 outer_render_manager->set_attach_complete();
W. James MacLean62883982019-11-12 20:39:001842
1843 // If the inner WebContents is full frame, give it focus.
1844 if (is_full_page) {
1845 // There should only ever be one inner WebContents when |is_full_page| is
1846 // true, and it is the one we just attached.
1847 DCHECK_EQ(1u, node_.GetInnerWebContents().size());
1848 inner_web_contents_impl->SetAsFocusedWebContentsIfNecessary();
1849 }
lazyboy6ec48b2a2015-06-29 15:18:141850}
1851
Lucas Furukawa Gadani99125822019-01-03 15:41:491852std::unique_ptr<WebContents> WebContentsImpl::DetachFromOuterWebContents() {
1853 DCHECK(node_.outer_web_contents());
Adithya Srinivasane6e7f842019-12-16 18:41:361854 RecursivelyUnregisterFrameSinkIds();
Lucas Furukawa Gadani99125822019-01-03 15:41:491855 if (RenderWidgetHostViewBase* view =
1856 static_cast<RenderWidgetHostViewBase*>(GetMainFrame()->GetView())) {
Kevin McNee6471a702020-01-27 18:23:071857 DCHECK(view->IsRenderWidgetHostViewChildFrame());
Lucas Furukawa Gadani99125822019-01-03 15:41:491858 view->Destroy();
1859 }
Kevin McNee6471a702020-01-27 18:23:071860 if (GetPendingMainFrame()) {
1861 if (RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
1862 GetPendingMainFrame()->GetView())) {
1863 DCHECK(view->IsRenderWidgetHostViewChildFrame());
1864 view->Destroy();
1865 }
1866 }
Lucas Furukawa Gadani99125822019-01-03 15:41:491867 GetRenderManager()->DeleteOuterDelegateProxy(
1868 node_.OuterContentsFrameTreeNode()
1869 ->current_frame_host()
1870 ->GetSiteInstance());
1871 view_.reset(CreateWebContentsView(
1872 this, GetContentClient()->browser()->GetWebContentsViewDelegate(this),
1873 &render_view_host_delegate_view_));
danakjfc5184932019-09-12 18:08:321874 view_->CreateView(nullptr);
Lucas Furukawa Gadani99125822019-01-03 15:41:491875 std::unique_ptr<WebContents> web_contents =
1876 node_.DisconnectFromOuterWebContents();
1877 DCHECK_EQ(web_contents.get(), this);
1878 node_.SetFocusedWebContents(this);
1879 CreateRenderWidgetHostViewForRenderManager(GetRenderViewHost());
Kevin McNee6471a702020-01-27 18:23:071880 if (GetPendingMainFrame()) {
1881 CreateRenderWidgetHostViewForRenderManager(
1882 GetPendingMainFrame()->render_view_host());
1883 }
Adithya Srinivasane6e7f842019-12-16 18:41:361884 RecursivelyRegisterFrameSinkIds();
Adithya Srinivasan6f0f67b2019-12-19 01:26:461885 // TODO(adithyas): |browser_plugin_embedder_ax_tree_id| should either not be
1886 // used for portals, or it should get a different name.
1887 GetMainFrame()->set_browser_plugin_embedder_ax_tree_id(ui::AXTreeIDUnknown());
1888 GetMainFrame()->UpdateAXTreeData();
Lucas Furukawa Gadani99125822019-01-03 15:41:491889 return web_contents;
1890}
1891
W. James MacLean2dc75ed42019-03-06 14:31:091892void WebContentsImpl::RecursivelyRegisterFrameSinkIds() {
Adithya Srinivasane6e7f842019-12-16 18:41:361893 for (auto* view : GetRenderWidgetHostViewsInWebContentsTree()) {
1894 auto* rwhvb = static_cast<RenderWidgetHostViewBase*>(view);
1895 if (rwhvb->IsRenderWidgetHostViewChildFrame())
1896 static_cast<RenderWidgetHostViewChildFrame*>(view)->RegisterFrameSinkId();
1897 }
1898}
W. James MacLean2dc75ed42019-03-06 14:31:091899
Adithya Srinivasane6e7f842019-12-16 18:41:361900void WebContentsImpl::RecursivelyUnregisterFrameSinkIds() {
1901 for (auto* view : GetRenderWidgetHostViewsInWebContentsTree()) {
1902 auto* rwhvb = static_cast<RenderWidgetHostViewBase*>(view);
1903 if (rwhvb->IsRenderWidgetHostViewChildFrame()) {
1904 static_cast<RenderWidgetHostViewChildFrame*>(view)
1905 ->UnregisterFrameSinkId();
1906 }
W. James MacLean2dc75ed42019-03-06 14:31:091907 }
1908}
1909
Lucas Furukawa Gadaniaed1fed2017-10-13 17:34:141910void WebContentsImpl::ReattachToOuterWebContentsFrame() {
1911 DCHECK(node_.outer_web_contents());
1912 auto* render_manager = GetRenderManager();
1913 auto* parent_frame =
1914 node_.OuterContentsFrameTreeNode()->current_frame_host()->GetParent();
1915 render_manager->SetRWHViewForInnerContents(
1916 render_manager->GetRenderWidgetHostView());
1917
W. James MacLean2dc75ed42019-03-06 14:31:091918 RecursivelyRegisterFrameSinkIds();
Lucas Furukawa Gadaniaed1fed2017-10-13 17:34:141919
1920 // Set up the the guest's AX tree to point back at the embedder's AX tree.
1921 GetMainFrame()->set_browser_plugin_embedder_ax_tree_id(
1922 parent_frame->GetAXTreeID());
1923 GetMainFrame()->UpdateAXTreeData();
1924}
1925
Adithya Srinivasan11af2c52019-12-16 22:52:551926void WebContentsImpl::NotifyInsidePortal(bool inside_portal) {
1927 SendPageMessage(new PageMsg_SetInsidePortal(MSG_ROUTING_NONE, inside_portal));
1928}
1929
dalecurtis6c58ed02016-10-28 23:02:371930void WebContentsImpl::DidChangeVisibleSecurityState() {
Emily Starkc663b0242019-04-26 19:34:451931 if (delegate_)
dalecurtis6c58ed02016-10-28 23:02:371932 delegate_->VisibleSecurityStateChanged(this);
Emily Starkc663b0242019-04-26 19:34:451933 for (auto& observer : observers_)
1934 observer.DidChangeVisibleSecurityState();
dalecurtis6c58ed02016-10-28 23:02:371935}
1936
Ahmed Fakhryd70bf37b2018-04-04 17:07:241937void WebContentsImpl::NotifyPreferencesChanged() {
1938 std::set<RenderViewHost*> render_view_host_set;
1939 for (FrameTreeNode* node : frame_tree_.Nodes()) {
Giovanni Ortuño Urquidi17a5d7c2018-04-30 06:48:531940 render_view_host_set.insert(
1941 node->current_frame_host()->GetRenderViewHost());
Ahmed Fakhryd70bf37b2018-04-04 17:07:241942 }
Giovanni Ortuño Urquidi17a5d7c2018-04-30 06:48:531943
Ahmed Fakhryd70bf37b2018-04-04 17:07:241944 for (RenderViewHost* render_view_host : render_view_host_set)
1945 render_view_host->OnWebkitPreferencesChanged();
1946}
1947
Bruce Long1e3e1f542019-10-16 17:56:281948void WebContentsImpl::SyncRendererPrefs() {
1949 blink::mojom::RendererPreferences renderer_preferences =
1950 GetRendererPrefs(GetBrowserContext());
1951 RenderViewHostImpl::GetPlatformSpecificPrefs(&renderer_preferences);
1952 SendPageMessage(
1953 new PageMsg_SetRendererPrefs(MSG_ROUTING_NONE, renderer_preferences));
1954}
1955
Josh Karlindaba39322019-07-17 23:24:331956void WebContentsImpl::OnCookiesRead(const GURL& url,
1957 const GURL& first_party_url,
1958 const net::CookieList& cookie_list,
1959 bool blocked_by_policy) {
1960 for (auto& observer : observers_) {
1961 observer.OnCookiesRead(url, first_party_url, cookie_list,
1962 blocked_by_policy);
1963 }
1964}
1965
1966void WebContentsImpl::OnCookieChange(const GURL& url,
1967 const GURL& first_party_url,
1968 const net::CanonicalCookie& cookie,
1969 bool blocked_by_policy) {
1970 for (auto& observer : observers_) {
1971 observer.OnCookieChange(url, first_party_url, cookie, blocked_by_policy);
1972 }
1973}
1974
[email protected]b172aee2012-04-10 17:05:261975void WebContentsImpl::Stop() {
dcheng57e39e22016-01-21 00:25:381976 for (FrameTreeNode* node : frame_tree_.Nodes())
1977 node->StopLoading();
ericwilligersde386342016-10-19 02:35:091978 for (auto& observer : observers_)
1979 observer.NavigationStopped();
[email protected]0bfbf882011-12-22 18:19:271980}
1981
Francois Doray47f759d2018-06-11 18:13:511982void WebContentsImpl::SetPageFrozen(bool frozen) {
1983 // A visible page is never frozen.
1984 DCHECK_NE(Visibility::VISIBLE, GetVisibility());
1985
1986 SendPageMessage(new PageMsg_SetPageFrozen(MSG_ROUTING_NONE, frozen));
Fadi Meawada6573e02018-03-10 00:52:111987}
1988
erikchen6c7df7f7a2018-05-03 18:13:591989std::unique_ptr<WebContents> WebContentsImpl::Clone() {
[email protected]14392a52012-05-02 20:28:441990 // We use our current SiteInstance since the cloned entry will use it anyway.
alexmose201c7cd2015-06-10 17:14:211991 // We pass our own opener so that the cloned page can access it if it was set
[email protected]ed245db2012-12-18 08:00:451992 // before.
[email protected]54944cde2012-12-09 09:24:591993 CreateParams create_params(GetBrowserContext(), GetSiteInstance());
Ian Clelland5cbaaf82017-11-27 22:00:031994 FrameTreeNode* opener = frame_tree_.root()->opener();
1995 RenderFrameHostImpl* opener_rfh = nullptr;
1996 if (opener)
1997 opener_rfh = opener->current_frame_host();
erikchen6c7df7f7a2018-05-03 18:13:591998 std::unique_ptr<WebContentsImpl> tc =
erikchen50735fd2018-05-05 15:08:331999 CreateWithOpener(create_params, opener_rfh);
Lucas Furukawa Gadani5553a152019-01-08 18:55:572000 tc->GetController().CopyStateFrom(&controller_, true);
ericwilligersde386342016-10-19 02:35:092001 for (auto& observer : observers_)
erikchen6c7df7f7a2018-05-03 18:13:592002 observer.DidCloneToNewWebContents(this, tc.get());
[email protected]0bfbf882011-12-22 18:19:272003 return tc;
2004}
2005
[email protected]14392a52012-05-02 20:28:442006void WebContentsImpl::Observe(int type,
[email protected]8ff00d72012-10-23 19:12:212007 const NotificationSource& source,
2008 const NotificationDetails& details) {
[email protected]14392a52012-05-02 20:28:442009 switch (type) {
[email protected]8ff00d72012-10-23 19:12:212010 case NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: {
2011 RenderWidgetHost* host = Source<RenderWidgetHost>(source).ptr();
[email protected]0b431992014-06-24 00:08:032012 RenderWidgetHostView* view = host->GetView();
2013 if (view == GetFullscreenRenderWidgetHostView()) {
2014 // We cannot just call view_->RestoreFocus() here. On some platforms,
2015 // attempting to focus the currently-invisible WebContentsView will be
2016 // flat-out ignored. Therefore, this boolean is used to track whether
2017 // we will request focus after the fullscreen widget has been
2018 // destroyed.
2019 fullscreen_widget_had_focus_at_shutdown_ = (view && view->HasFocus());
2020 } else {
alexmosc2a8cec2016-05-23 22:19:532021 for (auto i = pending_widget_views_.begin();
[email protected]0b431992014-06-24 00:08:032022 i != pending_widget_views_.end(); ++i) {
2023 if (host->GetView() == i->second) {
2024 pending_widget_views_.erase(i);
2025 break;
2026 }
[email protected]bafe6cd2012-05-23 23:09:502027 }
2028 }
2029 break;
2030 }
[email protected]14392a52012-05-02 20:28:442031 default:
2032 NOTREACHED();
2033 }
2034}
2035
[email protected]ec6c05f2013-10-23 18:41:572036WebContents* WebContentsImpl::GetWebContents() {
2037 return this;
2038}
2039
[email protected]54944cde2012-12-09 09:24:592040void WebContentsImpl::Init(const WebContents::CreateParams& params) {
[email protected]fa944cb82013-11-15 17:51:212041 // This is set before initializing the render manager since
[email protected]b0936d22013-11-28 06:47:362042 // RenderFrameHostManager::Init calls back into us via its delegate to ask if
[email protected]fa944cb82013-11-15 17:51:212043 // it should be hidden.
Francois Doraye6161152018-03-27 22:05:372044 visibility_ =
2045 params.initially_hidden ? Visibility::HIDDEN : Visibility::VISIBLE;
[email protected]d6fa88f2013-10-18 16:00:432046
Sebastien Marchand28cf23182018-06-20 02:39:352047 if (!params.last_active_time.is_null())
2048 last_active_time_ = params.last_active_time;
2049
dcheng3ce04b62015-10-26 23:30:552050 scoped_refptr<SiteInstance> site_instance = params.site_instance;
2051 if (!site_instance)
2052 site_instance = SiteInstance::Create(params.browser_context);
Lukasz Anforowicz3caa8372018-06-05 17:22:072053 if (params.desired_renderer_state == CreateParams::kNoRendererProcess) {
2054 static_cast<SiteInstanceImpl*>(site_instance.get())
2055 ->PreventAssociationWithSpareProcess();
2056 }
dcheng3ce04b62015-10-26 23:30:552057
2058 // A main RenderFrameHost always has a RenderWidgetHost, since it is always a
2059 // local root by definition.
2060 // TODO(avi): Once RenderViewHostImpl has-a RenderWidgetHostImpl, it will no
2061 // longer be necessary to eagerly grab a routing ID for the view.
2062 // https://crbug.com/545684
Fergal Daly052873a82020-03-11 14:45:492063 int32_t view_routing_id = site_instance->GetProcess()->GetNextRoutingID();
2064 int32_t main_frame_widget_routing_id =
2065 site_instance->GetProcess()->GetNextRoutingID();
dcheng3ce04b62015-10-26 23:30:552066
Albert J. Wongcb004632018-07-10 22:58:252067 DCHECK_NE(view_routing_id, main_frame_widget_routing_id);
2068
Fergal Daly052873a82020-03-11 14:45:492069 GetRenderManager()->Init(site_instance.get(), view_routing_id,
2070 /*frame_routing_id=*/MSG_ROUTING_NONE,
2071 main_frame_widget_routing_id,
2072 params.renderer_initiated_creation);
lukasza464d8692016-02-22 19:26:322073
lukasza5140a412016-09-15 21:12:302074 // blink::FrameTree::setName always keeps |unique_name| empty in case of a
2075 // main frame - let's do the same thing here.
2076 std::string unique_name;
lukasza464d8692016-02-22 19:26:322077 frame_tree_.root()->SetFrameName(params.main_frame_name, unique_name);
[email protected]d1198fd2012-08-13 22:50:192078
[email protected]fc2b46b2014-05-03 16:33:452079 WebContentsViewDelegate* delegate =
2080 GetContentClient()->browser()->GetWebContentsViewDelegate(this);
2081
W. James MacLean2539adb32019-12-13 00:40:442082 if (browser_plugin_guest_) {
sky52a39e342016-12-17 17:23:222083 view_.reset(new WebContentsViewChildFrame(
2084 this, delegate, &render_view_host_delegate_view_));
2085 } else {
2086 view_.reset(CreateWebContentsView(this, delegate,
2087 &render_view_host_delegate_view_));
[email protected]d1198fd2012-08-13 22:50:192088 }
[email protected]fc2b46b2014-05-03 16:33:452089 CHECK(render_view_host_delegate_view_);
[email protected]d1198fd2012-08-13 22:50:192090 CHECK(view_.get());
2091
danakjfc5184932019-09-12 18:08:322092 view_->CreateView(params.context);
[email protected]d1198fd2012-08-13 22:50:192093
brettw4b461082016-11-19 18:55:162094#if BUILDFLAG(ENABLE_PLUGINS)
tommyclieb25b2a2014-11-03 19:45:092095 plugin_content_origin_whitelist_.reset(
2096 new PluginContentOriginWhitelist(this));
2097#endif
2098
[email protected]d1198fd2012-08-13 22:50:192099 registrar_.Add(this,
[email protected]8ff00d72012-10-23 19:12:212100 NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
2101 NotificationService::AllBrowserContextsAndSources());
[email protected]f28ef9a32014-05-12 16:36:102102
leon.hane4db177a2017-02-07 14:19:162103 screen_orientation_provider_.reset(new ScreenOrientationProvider(this));
[email protected]01f83f92014-06-17 14:41:542104
mlamouriefdca9d2014-09-16 16:55:402105 manifest_manager_host_.reset(new ManifestManagerHost(this));
2106
mfomitchev2b8b066a2016-01-28 19:23:152107#if defined(OS_ANDROID)
Oksana Zhuravlova0b634332019-10-28 23:04:222108 DateTimeChooserAndroid::CreateForWebContents(this);
[email protected]583418cc2013-01-17 14:01:102109#endif
fsamuel7310a4262014-12-05 05:06:442110
2111 // BrowserPluginGuest::Init needs to be called after this WebContents has
W. James MacLean6e78da342019-12-13 15:13:232112 // a RenderWidgetHostViewChildFrame. That is, |view_->CreateView| above.
fsamuel7310a4262014-12-05 05:06:442113 if (browser_plugin_guest_)
2114 browser_plugin_guest_->Init();
nickf9acfbe2014-12-23 19:12:372115
2116 for (size_t i = 0; i < g_created_callbacks.Get().size(); i++)
2117 g_created_callbacks.Get().at(i).Run(this);
naskob21fe4872015-02-24 14:15:562118
2119 // If the WebContents creation was renderer-initiated, it means that the
2120 // corresponding RenderView and main RenderFrame have already been created.
2121 // Ensure observers are notified about this.
2122 if (params.renderer_initiated_creation) {
avi3627ecac2015-10-16 17:40:432123 GetRenderViewHost()->GetWidget()->set_renderer_initialized(true);
Alex Moshchuk27caae82017-09-11 23:11:182124 GetRenderViewHost()->DispatchRenderViewCreated();
naskob21fe4872015-02-24 14:15:562125 GetRenderManager()->current_frame_host()->SetRenderFrameCreated(true);
2126 }
naskof5940b9f2015-03-02 23:04:052127
lof84501da082016-05-23 21:22:542128 // Create the renderer process in advance if requested.
Lukasz Anforowicz3caa8372018-06-05 17:22:072129 if (params.desired_renderer_state ==
2130 CreateParams::kInitializeAndWarmupRendererProcess) {
lof84501da082016-05-23 21:22:542131 if (!GetRenderManager()->current_frame_host()->IsRenderFrameLive()) {
2132 GetRenderManager()->InitRenderView(GetRenderViewHost(), nullptr);
2133 }
2134 }
2135
naskof5940b9f2015-03-02 23:04:052136 // Ensure that observers are notified of the creation of this WebContents's
2137 // main RenderFrameHost. It must be done here for main frames, since the
2138 // NotifySwappedFromRenderManager expects view_ to already be created and that
2139 // happens after RenderFrameHostManager::Init.
2140 NotifySwappedFromRenderManager(
2141 nullptr, GetRenderManager()->current_frame_host(), true);
Albert J. Wonge76bf0b82019-09-27 07:47:062142
2143 // For WebContents that are never shown, do critical initialization here which
2144 // would normally only happen when the WebContents is shown.
2145 if (params.is_never_visible) {
2146 // This has just been created so there can only be one frame. Thus it is
2147 // safe to initialize the root.
2148 GetMainFrame()->Init();
2149 }
[email protected]d1198fd2012-08-13 22:50:192150}
2151
[email protected]7fff43e2013-05-21 20:21:102152void WebContentsImpl::OnWebContentsDestroyed(WebContentsImpl* web_contents) {
2153 RemoveDestructionObserver(web_contents);
2154
[email protected]ceee8cd2013-03-08 04:59:512155 // Clear a pending contents that has been closed before being shown.
alexmosc2a8cec2016-05-23 22:19:532156 for (auto iter = pending_contents_.begin(); iter != pending_contents_.end();
[email protected]ceee8cd2013-03-08 04:59:512157 ++iter) {
erikchenbee5c9622018-04-27 19:30:252158 if (iter->second.get() != web_contents)
[email protected]ceee8cd2013-03-08 04:59:512159 continue;
erikchenbee5c9622018-04-27 19:30:252160
2161 // Someone else has deleted the WebContents. That should never happen!
2162 // TODO(erikchen): Fix semantics here. https://crbug.com/832879.
2163 iter->second.release();
[email protected]ceee8cd2013-03-08 04:59:512164 pending_contents_.erase(iter);
[email protected]ceee8cd2013-03-08 04:59:512165 return;
2166 }
2167 NOTREACHED();
[email protected]14392a52012-05-02 20:28:442168}
2169
[email protected]7fff43e2013-05-21 20:21:102170void WebContentsImpl::AddDestructionObserver(WebContentsImpl* web_contents) {
Jan Wilken Dörrie73c901e2019-06-12 09:02:322171 if (!base::Contains(destruction_observers_, web_contents)) {
[email protected]7fff43e2013-05-21 20:21:102172 destruction_observers_[web_contents] =
Jeremy Roman04f27c372017-10-27 15:20:552173 std::make_unique<DestructionObserver>(this, web_contents);
[email protected]7fff43e2013-05-21 20:21:102174 }
2175}
2176
2177void WebContentsImpl::RemoveDestructionObserver(WebContentsImpl* web_contents) {
avia8cf81982016-08-12 20:28:462178 destruction_observers_.erase(web_contents);
[email protected]7fff43e2013-05-21 20:21:102179}
2180
[email protected]b172aee2012-04-10 17:05:262181void WebContentsImpl::AddObserver(WebContentsObserver* observer) {
[email protected]be1f56ab2011-12-22 06:55:312182 observers_.AddObserver(observer);
2183}
2184
[email protected]b172aee2012-04-10 17:05:262185void WebContentsImpl::RemoveObserver(WebContentsObserver* observer) {
[email protected]be1f56ab2011-12-22 06:55:312186 observers_.RemoveObserver(observer);
2187}
2188
[email protected]948481d2014-06-11 18:32:222189std::set<RenderWidgetHostView*>
2190WebContentsImpl::GetRenderWidgetHostViewsInTree() {
2191 std::set<RenderWidgetHostView*> set;
2192 if (ShowingInterstitialPage()) {
lfgf949e0e2017-05-10 22:18:112193 if (RenderWidgetHostView* rwhv = GetRenderWidgetHostView())
2194 set.insert(rwhv);
[email protected]948481d2014-06-11 18:32:222195 } else {
dchengafb53e22016-02-04 08:11:082196 for (RenderFrameHost* rfh : GetAllFrames()) {
lfgf949e0e2017-05-10 22:18:112197 if (RenderWidgetHostView* rwhv = static_cast<RenderFrameHostImpl*>(rfh)
2198 ->frame_tree_node()
2199 ->render_manager()
2200 ->GetRenderWidgetHostView()) {
2201 set.insert(rwhv);
2202 }
dchengafb53e22016-02-04 08:11:082203 }
[email protected]948481d2014-06-11 18:32:222204 }
[email protected]de3c5d82014-05-28 22:12:592205 return set;
2206}
2207
Adithya Srinivasane6e7f842019-12-16 18:41:362208std::set<RenderWidgetHostView*>
2209WebContentsImpl::GetRenderWidgetHostViewsInWebContentsTree() {
2210 std::set<RenderWidgetHostView*> result;
2211 GetRenderWidgetHostViewsInWebContentsTree(result);
2212 return result;
2213}
2214
2215void WebContentsImpl::GetRenderWidgetHostViewsInWebContentsTree(
2216 std::set<RenderWidgetHostView*>& result) {
2217 std::set<RenderWidgetHostView*> views = GetRenderWidgetHostViewsInTree();
2218 result.insert(views.begin(), views.end());
2219 for (auto* inner_web_contents : GetInnerWebContents()) {
2220 static_cast<WebContentsImpl*>(inner_web_contents)
2221 ->GetRenderWidgetHostViewsInWebContentsTree(result);
2222 }
2223}
2224
[email protected]b172aee2012-04-10 17:05:262225void WebContentsImpl::Activate() {
[email protected]d5f942ba2008-09-26 19:30:342226 if (delegate_)
2227 delegate_->ActivateContents(this);
2228}
2229
avi3e4b8512015-11-11 01:55:492230void WebContentsImpl::LostCapture(RenderWidgetHostImpl* render_widget_host) {
2231 if (!RenderViewHostImpl::From(render_widget_host))
2232 return;
2233
[email protected]63954792011-07-11 04:17:482234 if (delegate_)
2235 delegate_->LostCapture();
2236}
2237
Steven Holte38041342018-06-22 22:00:572238ukm::SourceId WebContentsImpl::GetUkmSourceIdForLastCommittedSource() const {
2239 return last_committed_source_id_;
2240}
2241
Yue Ru Sun979c4b162019-11-06 16:11:042242ukm::SourceId
2243WebContentsImpl::GetUkmSourceIdForLastCommittedSourceIncludingSameDocument()
2244 const {
2245 return last_committed_source_id_including_same_document_;
2246}
2247
Ahmed Fakhryfaa32d22018-10-05 15:56:162248void WebContentsImpl::SetTopControlsShownRatio(
2249 RenderWidgetHostImpl* render_widget_host,
2250 float ratio) {
2251 if (!delegate_)
2252 return;
2253
2254 RenderFrameHostImpl* rfh = GetMainFrame();
2255 if (!rfh || render_widget_host != rfh->GetRenderWidgetHost())
2256 return;
2257
2258 delegate_->SetTopControlsShownRatio(this, ratio);
Ahmed Fakhry58e6ef542018-09-04 18:05:382259}
2260
Ahmed Fakhry58e6ef542018-09-04 18:05:382261void WebContentsImpl::SetTopControlsGestureScrollInProgress(bool in_progress) {
2262 if (delegate_)
2263 delegate_->SetTopControlsGestureScrollInProgress(in_progress);
2264}
2265
lazyboy63f5b312015-11-23 20:19:522266void WebContentsImpl::RenderWidgetCreated(
2267 RenderWidgetHostImpl* render_widget_host) {
2268 created_widgets_.insert(render_widget_host);
2269}
2270
[email protected]b24b68a2012-09-24 21:57:262271void WebContentsImpl::RenderWidgetDeleted(
2272 RenderWidgetHostImpl* render_widget_host) {
lazyboy63f5b312015-11-23 20:19:522273 // Note that |is_being_destroyed_| can be true at this point as
2274 // ~WebContentsImpl() calls RFHM::ClearRFHsPendingShutdown(), which might lead
2275 // us here.
2276 created_widgets_.erase(render_widget_host);
[email protected]b24b68a2012-09-24 21:57:262277
lazyboy63f5b312015-11-23 20:19:522278 if (is_being_destroyed_)
2279 return;
[email protected]44470a22013-01-24 01:21:542280
2281 if (render_widget_host &&
alexmosc9e76ec2016-05-16 22:59:372282 render_widget_host->GetRoutingID() == fullscreen_widget_routing_id_ &&
2283 render_widget_host->GetProcess()->GetID() ==
2284 fullscreen_widget_process_id_) {
[email protected]4aebbca2013-09-17 22:26:492285 if (delegate_ && delegate_->EmbedsFullscreenWidget())
mlamouri7a78d6fd2015-01-17 13:23:532286 delegate_->ExitFullscreenModeForTab(this);
ericwilligersde386342016-10-19 02:35:092287 for (auto& observer : observers_)
2288 observer.DidDestroyFullscreenWidget();
alexmosc9e76ec2016-05-16 22:59:372289 fullscreen_widget_process_id_ = ChildProcessHost::kInvalidUniqueID;
[email protected]44470a22013-01-24 01:21:542290 fullscreen_widget_routing_id_ = MSG_ROUTING_NONE;
[email protected]0b431992014-06-24 00:08:032291 if (fullscreen_widget_had_focus_at_shutdown_)
2292 view_->RestoreFocus();
[email protected]44470a22013-01-24 01:21:542293 }
lfgbee1e0a2016-06-08 21:24:212294
lfg7d4caad2017-03-22 09:01:452295 if (render_widget_host == mouse_lock_widget_)
lfgff8dfc8d2016-10-21 17:42:322296 LostMouseLock(mouse_lock_widget_);
Joe Downing192998b22018-03-22 15:51:362297
Joe Downingc1a57efe2018-05-09 18:23:542298 CancelKeyboardLock(render_widget_host);
[email protected]b24b68a2012-09-24 21:57:262299}
2300
miu9e14e492014-10-25 02:39:042301void WebContentsImpl::RenderWidgetGotFocus(
2302 RenderWidgetHostImpl* render_widget_host) {
calamity7fe55ce2015-04-10 03:59:372303 // Notify the observers if an embedded fullscreen widget was focused.
2304 if (delegate_ && render_widget_host && delegate_->EmbedsFullscreenWidget() &&
2305 render_widget_host->GetView() == GetFullscreenRenderWidgetHostView()) {
Michael Thiessen896405db2017-07-20 17:52:322306 NotifyWebContentsFocused(render_widget_host);
calamity7fe55ce2015-04-10 03:59:372307 }
miu9e14e492014-10-25 02:39:042308}
2309
zijiehe3bee08e22017-05-17 04:14:462310void WebContentsImpl::RenderWidgetLostFocus(
2311 RenderWidgetHostImpl* render_widget_host) {
Michael Thiessen896405db2017-07-20 17:52:322312 // Notify the observers if an embedded fullscreen widget lost focus.
2313 if (delegate_ && render_widget_host && delegate_->EmbedsFullscreenWidget() &&
2314 render_widget_host->GetView() == GetFullscreenRenderWidgetHostView()) {
2315 NotifyWebContentsLostFocus(render_widget_host);
2316 }
zijiehe3bee08e22017-05-17 04:14:462317}
2318
estaded0a0c992015-01-21 14:12:062319void WebContentsImpl::RenderWidgetWasResized(
rouslan2f5993f2015-01-29 00:18:312320 RenderWidgetHostImpl* render_widget_host,
2321 bool width_changed) {
creisc014b402015-04-23 16:41:452322 RenderFrameHostImpl* rfh = GetMainFrame();
estadece344ec2015-01-23 00:12:292323 if (!rfh || render_widget_host != rfh->GetRenderWidgetHost())
estaded0a0c992015-01-21 14:12:062324 return;
estaded0a0c992015-01-21 14:12:062325
ericwilligersde386342016-10-19 02:35:092326 for (auto& observer : observers_)
2327 observer.MainFrameWasResized(width_changed);
estaded0a0c992015-01-21 14:12:062328}
2329
skyf65d9bb2017-03-24 02:26:392330KeyboardEventProcessingResult WebContentsImpl::PreHandleKeyboardEvent(
2331 const NativeWebKeyboardEvent& event) {
W. James MacLeane1187272019-11-12 03:42:482332 auto* outermost_contents = GetOutermostWebContents();
2333 // TODO(wjmaclean): Generalize this to forward all key events to the outermost
2334 // delegate's handler.
2335 if (outermost_contents != this && IsFullscreenForCurrentTab() &&
2336 event.windows_key_code == ui::VKEY_ESCAPE) {
2337 // When an inner WebContents has focus and is fullscreen, redirect <esc>
2338 // key events to the outermost WebContents so it can be handled by that
2339 // WebContents' delegate.
2340 if (outermost_contents->PreHandleKeyboardEvent(event) ==
2341 KeyboardEventProcessingResult::HANDLED) {
2342 return KeyboardEventProcessingResult::HANDLED;
2343 }
2344 }
skyf65d9bb2017-03-24 02:26:392345 return delegate_ ? delegate_->PreHandleKeyboardEvent(this, event)
2346 : KeyboardEventProcessingResult::NOT_HANDLED;
[email protected]63954792011-07-11 04:17:482347}
2348
Dave Tapuska344399e2019-09-09 15:18:262349bool WebContentsImpl::HandleMouseEvent(const blink::WebMouseEvent& event) {
2350 // Handle mouse button back/forward in the browser process after the render
2351 // process is done with the event. This ensures all renderer-initiated history
2352 // navigations can be treated consistently.
2353 if (event.GetType() == blink::WebInputEvent::Type::kMouseUp) {
2354 WebContentsImpl* outermost = GetOutermostWebContents();
2355 if (event.button == blink::WebPointerProperties::Button::kBack &&
2356 outermost->controller_.CanGoBack()) {
2357 outermost->controller_.GoBack();
2358 return true;
2359 } else if (event.button == blink::WebPointerProperties::Button::kForward &&
2360 outermost->controller_.CanGoForward()) {
2361 outermost->controller_.GoForward();
2362 return true;
2363 }
2364 }
2365 return false;
2366}
2367
Scott Violetd5caa872018-10-16 22:00:512368bool WebContentsImpl::HandleKeyboardEvent(const NativeWebKeyboardEvent& event) {
[email protected]0b094002014-08-20 18:28:102369 if (browser_plugin_embedder_ &&
2370 browser_plugin_embedder_->HandleKeyboardEvent(event)) {
Scott Violetd5caa872018-10-16 22:00:512371 return true;
[email protected]0b094002014-08-20 18:28:102372 }
Scott Violetd5caa872018-10-16 22:00:512373 return delegate_ && delegate_->HandleKeyboardEvent(this, event);
[email protected]63954792011-07-11 04:17:482374}
2375
[email protected]d92026ef2014-03-03 21:04:132376bool WebContentsImpl::HandleWheelEvent(
[email protected]180ef242013-11-07 06:50:462377 const blink::WebMouseWheelEvent& event) {
[email protected]bccc4472013-04-18 16:37:192378#if !defined(OS_MACOSX)
lanweia93644f2015-01-21 22:00:332379 // On platforms other than Mac, control+mousewheel may change zoom. On Mac,
2380 // this isn't done for two reasons:
[email protected]bccc4472013-04-18 16:37:192381 // -the OS already has a gesture to do this through pinch-zoom
2382 // -if a user starts an inertial scroll, let's go, and presses control
2383 // (i.e. control+tab) then the OS's buffered scroll events will come in
2384 // with control key set which isn't what the user wants
Blink Reformat1c4d759e2017-04-09 16:34:542385 if (delegate_ && event.wheel_ticks_y &&
Ehsan Karamad0f83cb112018-09-06 22:07:362386 event.event_action == blink::WebMouseWheelEvent::EventAction::kPageZoom) {
w.shackleton49bcd392016-01-06 17:38:222387 // Count only integer cumulative scrolls as zoom events; this handles
2388 // smooth scroll and regular scroll device behavior.
Blink Reformat1c4d759e2017-04-09 16:34:542389 zoom_scroll_remainder_ += event.wheel_ticks_y;
w.shackleton49bcd392016-01-06 17:38:222390 int whole_zoom_scroll_remainder_ = std::lround(zoom_scroll_remainder_);
2391 zoom_scroll_remainder_ -= whole_zoom_scroll_remainder_;
2392 if (whole_zoom_scroll_remainder_ != 0) {
2393 delegate_->ContentsZoomChange(whole_zoom_scroll_remainder_ > 0);
2394 }
[email protected]fb3f066e2013-02-12 19:12:522395 return true;
2396 }
[email protected]bccc4472013-04-18 16:37:192397#endif
[email protected]fb3f066e2013-02-12 19:12:522398 return false;
2399}
2400
[email protected]04bce562014-01-30 05:34:542401bool WebContentsImpl::PreHandleGestureEvent(
2402 const blink::WebGestureEvent& event) {
[email protected]28042d32014-02-03 14:10:032403 return delegate_ && delegate_->PreHandleGestureEvent(this, event);
[email protected]04bce562014-01-30 05:34:542404}
2405
kenrb2a565f82015-09-02 20:24:592406RenderWidgetHostInputEventRouter* WebContentsImpl::GetInputEventRouter() {
wjmacleane31234f2015-12-14 17:20:452407 if (!is_being_destroyed_ && GetOuterWebContents())
2408 return GetOuterWebContents()->GetInputEventRouter();
2409
2410 if (!rwh_input_event_router_.get() && !is_being_destroyed_)
kenrb2a565f82015-09-02 20:24:592411 rwh_input_event_router_.reset(new RenderWidgetHostInputEventRouter);
2412 return rwh_input_event_router_.get();
2413}
2414
alexmos3fcd0ca2015-10-23 18:18:332415void WebContentsImpl::ReplicatePageFocus(bool is_focused) {
2416 // Focus loss may occur while this WebContents is being destroyed. Don't
2417 // send the message in this case, as the main frame's RenderFrameHost and
2418 // other state has already been cleared.
2419 if (is_being_destroyed_)
2420 return;
2421
2422 frame_tree_.ReplicatePageFocus(is_focused);
2423}
2424
alexmosc4cbacb2015-11-21 01:29:222425RenderWidgetHostImpl* WebContentsImpl::GetFocusedRenderWidgetHost(
2426 RenderWidgetHostImpl* receiving_widget) {
alexmosc4cbacb2015-11-21 01:29:222427 // Events for widgets other than the main frame (e.g., popup menus) should be
2428 // forwarded directly to the widget they arrived on.
2429 if (receiving_widget != GetMainFrame()->GetRenderWidgetHost())
2430 return receiving_widget;
alexmosc4d183e2015-11-06 00:46:522431
lfg1453e412017-04-11 00:48:502432 WebContentsImpl* focused_contents = GetFocusedWebContents();
2433
2434 // If the focused WebContents is showing an interstitial, return the
2435 // interstitial's widget.
2436 if (focused_contents->ShowingInterstitialPage()) {
2437 return static_cast<RenderFrameHostImpl*>(
creisadca9862017-06-16 19:12:112438 focused_contents->interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:502439 ->GetRenderWidgetHost();
2440 }
2441
paulmeyerfeafc2d2017-04-25 21:46:402442 // If the focused WebContents is a guest WebContents, then get the focused
2443 // frame in the embedder WebContents instead.
W. James MacLean13d834d2019-12-04 16:06:452444 FrameTreeNode* focused_frame =
2445 GetFocusedWebContents()->frame_tree_.GetFocusedFrame();
lfg1453e412017-04-11 00:48:502446
alexmosc4d183e2015-11-06 00:46:522447 if (!focused_frame)
alexmosc4cbacb2015-11-21 01:29:222448 return receiving_widget;
alexmosc4d183e2015-11-06 00:46:522449
alexmos732ca3a2015-12-08 02:01:022450 // The view may be null if a subframe's renderer process has crashed while
2451 // the subframe has focus. Drop the event in that case. Do not give
2452 // it to the main frame, so that the user doesn't unexpectedly type into the
2453 // wrong frame if a focused subframe renderer crashes while they type.
2454 RenderWidgetHostView* view = focused_frame->current_frame_host()->GetView();
2455 if (!view)
2456 return nullptr;
2457
2458 return RenderWidgetHostImpl::From(view->GetRenderWidgetHost());
alexmosc4d183e2015-11-06 00:46:522459}
2460
avallee9993fca2016-11-17 06:16:502461RenderWidgetHostImpl* WebContentsImpl::GetRenderWidgetHostWithPageFocus() {
lfg1453e412017-04-11 00:48:502462 WebContentsImpl* focused_web_contents = GetFocusedWebContents();
2463
2464 if (focused_web_contents->ShowingInterstitialPage()) {
2465 return static_cast<RenderFrameHostImpl*>(
creisadca9862017-06-16 19:12:112466 focused_web_contents->interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:502467 ->GetRenderWidgetHost();
2468 }
2469
2470 return focused_web_contents->GetMainFrame()->GetRenderWidgetHost();
avallee9993fca2016-11-17 06:16:502471}
2472
Avi Drissmand1d25652020-03-06 21:28:582473bool WebContentsImpl::CanEnterFullscreenMode() {
Avi Drissman1a55a9d62020-03-10 18:56:452474 return fullscreen_blocker_count_ == 0;
Avi Drissmand1d25652020-03-06 21:28:582475}
2476
Dave Tapuska3ed44192018-05-01 18:53:302477void WebContentsImpl::EnterFullscreenMode(
2478 const GURL& origin,
Dave Tapuskaa4189512019-10-15 20:27:342479 const blink::mojom::FullscreenOptions& options) {
Avi Drissmand1d25652020-03-06 21:28:582480 DCHECK(CanEnterFullscreenMode());
2481
mlamouri7a78d6fd2015-01-17 13:23:532482 // This method is being called to enter renderer-initiated fullscreen mode.
2483 // Make sure any existing fullscreen widget is shut down first.
[email protected]4aebbca2013-09-17 22:26:492484 RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
avi85a4cef2015-12-18 20:13:372485 if (widget_view) {
2486 RenderWidgetHostImpl::From(widget_view->GetRenderWidgetHost())
2487 ->ShutdownAndDestroyWidget(true);
2488 }
[email protected]4aebbca2013-09-17 22:26:492489
Joe Downing13dd76b2018-04-09 18:32:152490 if (delegate_) {
Dave Tapuska3ed44192018-05-01 18:53:302491 delegate_->EnterFullscreenModeForTab(this, origin, options);
mlamouri7a78d6fd2015-01-17 13:23:532492
Joe Downing13dd76b2018-04-09 18:32:152493 if (keyboard_lock_widget_)
2494 delegate_->RequestKeyboardLock(this, esc_key_locked_);
2495 }
2496
ericwilligersde386342016-10-19 02:35:092497 for (auto& observer : observers_)
2498 observer.DidToggleFullscreenModeForTab(IsFullscreenForCurrentTab(), false);
mlamouri7a78d6fd2015-01-17 13:23:532499}
2500
bokanece34a82016-01-28 19:49:462501void WebContentsImpl::ExitFullscreenMode(bool will_cause_resize) {
mlamouri7a78d6fd2015-01-17 13:23:532502 // This method is being called to leave renderer-initiated fullscreen mode.
2503 // Make sure any existing fullscreen widget is shut down first.
2504 RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
avi85a4cef2015-12-18 20:13:372505 if (widget_view) {
2506 RenderWidgetHostImpl::From(widget_view->GetRenderWidgetHost())
2507 ->ShutdownAndDestroyWidget(true);
2508 }
mlamouri7a78d6fd2015-01-17 13:23:532509
Joe Downing13dd76b2018-04-09 18:32:152510 if (delegate_) {
mlamouri7a78d6fd2015-01-17 13:23:532511 delegate_->ExitFullscreenModeForTab(this);
[email protected]657c8e02014-03-19 19:18:372512
Joe Downing13dd76b2018-04-09 18:32:152513 if (keyboard_lock_widget_)
2514 delegate_->CancelKeyboardLockRequest(this);
2515 }
2516
bokanece34a82016-01-28 19:49:462517 // The fullscreen state is communicated to the renderer through a resize
2518 // message. If the change in fullscreen state doesn't cause a view resize
2519 // then we must ensure web contents exit the fullscreen state by explicitly
2520 // sending a resize message. This is required for the situation of the browser
2521 // moving the view into a "browser fullscreen" state and then the contents
2522 // entering "tab fullscreen". Exiting the contents "tab fullscreen" then won't
2523 // have the side effect of the view resizing, hence the explicit call here is
2524 // required.
2525 if (!will_cause_resize) {
2526 if (RenderWidgetHostView* rwhv = GetRenderWidgetHostView()) {
2527 if (RenderWidgetHost* render_widget_host = rwhv->GetRenderWidgetHost())
Fady Samuel0b911822018-04-25 13:22:162528 render_widget_host->SynchronizeVisualProperties();
bokanece34a82016-01-28 19:49:462529 }
scheib3dcb6c932015-02-23 10:55:582530 }
2531
Arthur Sonzogni929d29f2018-09-17 14:19:442532 current_fullscreen_frame_ = nullptr;
Becca Hughese9e27952018-06-25 17:08:272533
ericwilligersde386342016-10-19 02:35:092534 for (auto& observer : observers_) {
2535 observer.DidToggleFullscreenModeForTab(IsFullscreenForCurrentTab(),
2536 will_cause_resize);
2537 }
Becca Hughesd11d6502018-07-31 17:01:282538
2539 if (display_cutout_host_impl_)
2540 display_cutout_host_impl_->DidExitFullscreen();
[email protected]8a5e0ca2011-08-25 06:30:472541}
2542
Becca Hughesfd5d8f892018-06-14 18:23:362543void WebContentsImpl::FullscreenStateChanged(RenderFrameHost* rfh,
2544 bool is_fullscreen) {
Arthur Sonzogni929d29f2018-09-17 14:19:442545 RenderFrameHostImpl* frame = static_cast<RenderFrameHostImpl*>(rfh);
Becca Hughesfd5d8f892018-06-14 18:23:362546
2547 if (is_fullscreen) {
Jan Wilken Dörrie531be7ca2019-06-07 10:05:572548 if (!base::Contains(fullscreen_frames_, frame)) {
Arthur Sonzogni929d29f2018-09-17 14:19:442549 fullscreen_frames_.insert(frame);
2550 FullscreenFrameSetUpdated();
Becca Hughesfd5d8f892018-06-14 18:23:362551 }
Arthur Sonzogni929d29f2018-09-17 14:19:442552 return;
2553 }
Becca Hughesfd5d8f892018-06-14 18:23:362554
Arthur Sonzogni929d29f2018-09-17 14:19:442555 // If |frame| is no longer in fullscreen, remove it and any descendants.
2556 // See https://fullscreen.spec.whatwg.org.
Arthur Sonzogni969a794e2018-10-11 08:56:092557 size_t size_before_deletion = fullscreen_frames_.size();
2558 base::EraseIf(fullscreen_frames_, [&](RenderFrameHostImpl* current) {
2559 return (current == frame || current->IsDescendantOf(frame));
Arthur Sonzogni929d29f2018-09-17 14:19:442560 });
2561
Arthur Sonzogni969a794e2018-10-11 08:56:092562 if (size_before_deletion != fullscreen_frames_.size())
Arthur Sonzogni929d29f2018-09-17 14:19:442563 FullscreenFrameSetUpdated();
2564}
2565
2566void WebContentsImpl::FullscreenFrameSetUpdated() {
2567 if (fullscreen_frames_.empty()) {
2568 current_fullscreen_frame_ = nullptr;
2569 return;
Becca Hughesfd5d8f892018-06-14 18:23:362570 }
2571
Arthur Sonzogni929d29f2018-09-17 14:19:442572 // Find the current fullscreen frame and call the observers.
2573 // If frame A is fullscreen, then frame B goes into inner fullscreen, then B
2574 // exits fullscreen - that will result in A being fullscreen.
2575 RenderFrameHostImpl* new_fullscreen_frame = *std::max_element(
2576 fullscreen_frames_.begin(), fullscreen_frames_.end(), FrameCompareDepth);
Becca Hughesfd5d8f892018-06-14 18:23:362577
Arthur Sonzogni929d29f2018-09-17 14:19:442578 // If we have already notified observers about this frame then we should not
2579 // fire the observers again.
2580 if (new_fullscreen_frame == current_fullscreen_frame_)
2581 return;
2582 current_fullscreen_frame_ = new_fullscreen_frame;
Becca Hughesfd5d8f892018-06-14 18:23:362583
Arthur Sonzogni929d29f2018-09-17 14:19:442584 for (auto& observer : observers_)
2585 observer.DidAcquireFullscreen(new_fullscreen_frame);
Becca Hughesfd5d8f892018-06-14 18:23:362586
Arthur Sonzogni929d29f2018-09-17 14:19:442587 if (display_cutout_host_impl_)
2588 display_cutout_host_impl_->DidAcquireFullscreen(new_fullscreen_frame);
Becca Hughesfd5d8f892018-06-14 18:23:362589}
2590
Collin Baker989e0882019-11-01 01:27:172591void WebContentsImpl::UpdateVisibilityAndNotifyPageAndView(
2592 Visibility new_visibility) {
Collin Baker989e0882019-11-01 01:27:172593 // Only hide the page if there are no entities capturing screenshots
Collin Bakerc5259962019-11-14 17:51:582594 // or video (e.g. mirroring). If there are, apply the correct state of
2595 // kHidden or kHiddenButPainting.
2596 PageVisibilityState page_visibility;
2597 if (new_visibility == Visibility::VISIBLE || visible_capturer_count_ > 0)
2598 page_visibility = PageVisibilityState::kVisible;
2599 else if (hidden_capturer_count_ > 0)
2600 page_visibility = PageVisibilityState::kHiddenButPainting;
2601 else
2602 page_visibility = PageVisibilityState::kHidden;
Collin Baker989e0882019-11-01 01:27:172603 // If there are entities in Picture-in-Picture mode, don't activate
2604 // the "disable rendering" optimization.
Collin Bakerc5259962019-11-14 17:51:582605 const bool view_is_visible =
2606 page_visibility != PageVisibilityState::kHidden ||
2607 HasPictureInPictureVideo();
Collin Baker989e0882019-11-01 01:27:172608
Collin Bakerc5259962019-11-14 17:51:582609 if (page_visibility != PageVisibilityState::kHidden) {
Dana Friedcf3bc8e2019-11-13 20:00:242610 // We cannot show a page or capture video unless there is a valid renderer
2611 // associated with this web contents. The navigation controller for this
2612 // page must be set to active (allowing navigation to complete, a renderer
2613 // and its associated views to be created, etc.) if any of these conditions
2614 // holds.
2615 //
2616 // Previously, it was possible for browser-side code to try to capture video
2617 // from a restored tab (for a variety of reasons, including the browser
2618 // creating preview thumbnails) and the tab would never actually load. By
Collin Bakerc5259962019-11-14 17:51:582619 // keying this behavior off of |page_visibility| instead of just
Dana Friedcf3bc8e2019-11-13 20:00:242620 // |new_visibility| we avoid this case. See crbug.com/1020782 for more
2621 // context.
2622 controller_.SetActive(true);
2623
2624 // This shows the Page before showing the individual RenderWidgets, as
2625 // RenderWidgets will work to produce compositor frames and handle input
2626 // as soon as they are shown. But the Page and other classes do not expect
2627 // to be producing frames when the Page is hidden. So we make sure the Page
2628 // is shown first.
Collin Bakerc5259962019-11-14 17:51:582629 SendPageMessage(
2630 new PageMsg_VisibilityChanged(MSG_ROUTING_NONE, page_visibility));
Collin Baker98457b52019-11-06 21:34:292631 }
Collin Baker989e0882019-11-01 01:27:172632
2633 // |GetRenderWidgetHostView()| can be null if the user middle clicks a link to
2634 // open a tab in the background, then closes the tab before selecting it.
2635 // This is because closing the tab calls WebContentsImpl::Destroy(), which
2636 // removes the |GetRenderViewHost()|; then when we actually destroy the
2637 // window, OnWindowPosChanged() notices and calls WasHidden() (which
2638 // calls us).
2639 if (auto* view = GetRenderWidgetHostView()) {
2640 if (view_is_visible) {
2641 view->Show();
Collin Baker989e0882019-11-01 01:27:172642 } else if (new_visibility == Visibility::HIDDEN) {
2643 view->Hide();
2644 } else {
2645 view->WasOccluded();
2646 }
2647 }
2648
2649 if (!ShowingInterstitialPage())
2650 SetVisibilityForChildViews(view_is_visible);
2651
2652 // Make sure to call SetVisibilityAndNotifyObservers(VISIBLE) before notifying
2653 // the CrossProcessFrameConnector.
2654 if (new_visibility == Visibility::VISIBLE) {
2655 last_active_time_ = base::TimeTicks::Now();
2656 SetVisibilityAndNotifyObservers(new_visibility);
2657 }
2658
Collin Bakerc5259962019-11-14 17:51:582659 if (page_visibility == PageVisibilityState::kHidden) {
Collin Baker989e0882019-11-01 01:27:172660 // Similar to when showing the page, we only hide the page after
2661 // hiding the individual RenderWidgets.
Collin Baker98457b52019-11-06 21:34:292662 SendPageMessage(new PageMsg_VisibilityChanged(
2663 MSG_ROUTING_NONE, PageVisibilityState::kHidden));
Collin Baker989e0882019-11-01 01:27:172664 } else {
2665 for (FrameTreeNode* node : frame_tree_.Nodes()) {
2666 RenderFrameProxyHost* parent = node->render_manager()->GetProxyToParent();
2667 if (!parent)
2668 continue;
2669
2670 parent->cross_process_frame_connector()->DelegateWasShown();
2671 }
2672 }
2673
2674 if (new_visibility != Visibility::VISIBLE)
2675 SetVisibilityAndNotifyObservers(new_visibility);
2676}
2677
Clark DuValla0e42992018-09-17 17:00:112678#if defined(OS_ANDROID)
2679void WebContentsImpl::UpdateUserGestureCarryoverInfo() {
2680 if (delegate_)
2681 delegate_->UpdateUserGestureCarryoverInfo(this);
2682}
2683#endif
2684
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:412685bool WebContentsImpl::IsFullscreenForCurrentTab() {
[email protected]199bba6e2012-04-04 16:19:382686 return delegate_ ? delegate_->IsFullscreenForTabOrPending(this) : false;
[email protected]5d5f7af2011-10-01 01:38:122687}
2688
Malay Keshav87c42c02019-01-15 08:37:472689bool WebContentsImpl::ShouldShowStaleContentOnEviction() {
2690 return GetDelegate() && GetDelegate()->ShouldShowStaleContentOnEviction(this);
2691}
2692
billorr21c005d2016-11-17 03:57:042693bool WebContentsImpl::IsFullscreen() {
2694 return IsFullscreenForCurrentTab();
2695}
2696
Eric Willigers052f0432019-10-04 04:06:572697blink::mojom::DisplayMode WebContentsImpl::GetDisplayMode(
avibf58fa0c2015-11-11 01:45:522698 RenderWidgetHostImpl* render_widget_host) const {
2699 if (!RenderViewHostImpl::From(render_widget_host))
Eric Willigers052f0432019-10-04 04:06:572700 return blink::mojom::DisplayMode::kBrowser;
avibf58fa0c2015-11-11 01:45:522701
mikhail.pozdnyakovc0e251b2015-04-15 06:51:122702 return delegate_ ? delegate_->GetDisplayMode(this)
Eric Willigers052f0432019-10-04 04:06:572703 : blink::mojom::DisplayMode::kBrowser;
mikhail.pozdnyakovc0e251b2015-04-15 06:51:122704}
2705
avic3aa8422015-11-09 20:57:222706void WebContentsImpl::RequestToLockMouse(
2707 RenderWidgetHostImpl* render_widget_host,
2708 bool user_gesture,
lfgad8244352016-07-13 16:55:512709 bool last_unlocked_by_target,
2710 bool privileged) {
lfgf0cd46e2017-01-04 00:05:232711 for (WebContentsImpl* current = this; current;
2712 current = current->GetOuterWebContents()) {
2713 if (current->mouse_lock_widget_) {
James Hollyerd5c9de462020-03-10 19:02:452714 render_widget_host->GotResponseToLockMouseRequest(
2715 blink::mojom::PointerLockResult::kAlreadyLocked);
lfgf0cd46e2017-01-04 00:05:232716 return;
2717 }
[email protected]e9621112011-10-17 05:38:372718 }
avic3aa8422015-11-09 20:57:222719
lfgad8244352016-07-13 16:55:512720 if (privileged) {
lfgf0cd46e2017-01-04 00:05:232721 DCHECK(!GetOuterWebContents());
lfgad8244352016-07-13 16:55:512722 mouse_lock_widget_ = render_widget_host;
James Hollyerd5c9de462020-03-10 19:02:452723 render_widget_host->GotResponseToLockMouseRequest(
2724 blink::mojom::PointerLockResult::kSuccess);
lfgad8244352016-07-13 16:55:512725 return;
2726 }
2727
lfgbee1e0a2016-06-08 21:24:212728 bool widget_in_frame_tree = false;
2729 for (FrameTreeNode* node : frame_tree_.Nodes()) {
2730 if (node->current_frame_host()->GetRenderWidgetHost() ==
2731 render_widget_host) {
2732 widget_in_frame_tree = true;
2733 break;
2734 }
2735 }
2736
2737 if (widget_in_frame_tree && delegate_) {
lfgf0cd46e2017-01-04 00:05:232738 for (WebContentsImpl* current = this; current;
2739 current = current->GetOuterWebContents()) {
2740 current->mouse_lock_widget_ = render_widget_host;
2741 }
2742
avic3aa8422015-11-09 20:57:222743 delegate_->RequestToLockMouse(this, user_gesture, last_unlocked_by_target);
lfgbee1e0a2016-06-08 21:24:212744 } else {
James Hollyerd5c9de462020-03-10 19:02:452745 render_widget_host->GotResponseToLockMouseRequest(
2746 blink::mojom::PointerLockResult::kWrongDocument);
lfgbee1e0a2016-06-08 21:24:212747 }
[email protected]e9621112011-10-17 05:38:372748}
2749
avi3e4b8512015-11-11 01:55:492750void WebContentsImpl::LostMouseLock(RenderWidgetHostImpl* render_widget_host) {
lfgbee1e0a2016-06-08 21:24:212751 CHECK(mouse_lock_widget_);
lfgf0cd46e2017-01-04 00:05:232752
2753 if (mouse_lock_widget_->delegate()->GetAsWebContents() != this)
2754 return mouse_lock_widget_->delegate()->LostMouseLock(render_widget_host);
2755
lfgbee1e0a2016-06-08 21:24:212756 mouse_lock_widget_->SendMouseLockLost();
lfgf0cd46e2017-01-04 00:05:232757 for (WebContentsImpl* current = this; current;
2758 current = current->GetOuterWebContents()) {
2759 current->mouse_lock_widget_ = nullptr;
2760 }
avi3e4b8512015-11-11 01:55:492761
[email protected]e9621112011-10-17 05:38:372762 if (delegate_)
2763 delegate_->LostMouseLock();
2764}
2765
lfgad8244352016-07-13 16:55:512766bool WebContentsImpl::HasMouseLock(RenderWidgetHostImpl* render_widget_host) {
2767 // To verify if the mouse is locked, the mouse_lock_widget_ needs to be
2768 // assigned to the widget that requested the mouse lock, and the top-level
2769 // platform RenderWidgetHostView needs to hold the mouse lock from the OS.
Lucas Gadania0ea0172018-09-20 18:31:372770 auto* widget_host = GetTopLevelRenderWidgetHostView();
2771 return mouse_lock_widget_ == render_widget_host && widget_host &&
2772 widget_host->IsMouseLocked();
lfgad8244352016-07-13 16:55:512773}
2774
lfg84763c92017-02-16 18:55:152775RenderWidgetHostImpl* WebContentsImpl::GetMouseLockWidget() {
Lucas Gadania0ea0172018-09-20 18:31:372776 auto* widget_host = GetTopLevelRenderWidgetHostView();
2777 if ((widget_host && widget_host->IsMouseLocked()) ||
lfge2176fb2017-03-26 00:45:472778 (GetFullscreenRenderWidgetHostView() &&
Lucas Gadania0ea0172018-09-20 18:31:372779 GetFullscreenRenderWidgetHostView()->IsMouseLocked())) {
lfg84763c92017-02-16 18:55:152780 return mouse_lock_widget_;
Lucas Gadania0ea0172018-09-20 18:31:372781 }
lfg84763c92017-02-16 18:55:152782
2783 return nullptr;
2784}
2785
Joe Downing192998b22018-03-22 15:51:362786bool WebContentsImpl::RequestKeyboardLock(
Joe Downing13dd76b2018-04-09 18:32:152787 RenderWidgetHostImpl* render_widget_host,
2788 bool esc_key_locked) {
Joe Downing192998b22018-03-22 15:51:362789 DCHECK(render_widget_host);
Joe Downing192998b22018-03-22 15:51:362790 if (render_widget_host->delegate()->GetAsWebContents() != this) {
2791 NOTREACHED();
2792 return false;
2793 }
2794
2795 // KeyboardLock is only supported when called by the top-level browsing
2796 // context and is not supported in embedded content scenarios.
2797 if (GetOuterWebContents())
2798 return false;
2799
Joe Downing13dd76b2018-04-09 18:32:152800 esc_key_locked_ = esc_key_locked;
Joe Downing192998b22018-03-22 15:51:362801 keyboard_lock_widget_ = render_widget_host;
2802
Joe Downing13dd76b2018-04-09 18:32:152803 if (delegate_)
2804 delegate_->RequestKeyboardLock(this, esc_key_locked_);
Joe Downing192998b22018-03-22 15:51:362805 return true;
2806}
2807
2808void WebContentsImpl::CancelKeyboardLock(
2809 RenderWidgetHostImpl* render_widget_host) {
2810 if (!keyboard_lock_widget_ || render_widget_host != keyboard_lock_widget_)
2811 return;
2812
2813 RenderWidgetHostImpl* old_keyboard_lock_widget = keyboard_lock_widget_;
2814 keyboard_lock_widget_ = nullptr;
2815
Joe Downing13dd76b2018-04-09 18:32:152816 if (delegate_)
2817 delegate_->CancelKeyboardLockRequest(this);
2818
Joe Downing192998b22018-03-22 15:51:362819 old_keyboard_lock_widget->CancelKeyboardLock();
2820}
2821
2822RenderWidgetHostImpl* WebContentsImpl::GetKeyboardLockWidget() {
2823 return keyboard_lock_widget_;
2824}
2825
Dave Tapuskac3344362019-02-20 17:54:282826void WebContentsImpl::OnRenderFrameProxyVisibilityChanged(
2827 blink::mojom::FrameVisibility visibility) {
2828 switch (visibility) {
2829 case blink::mojom::FrameVisibility::kRenderedInViewport:
2830 WasShown();
2831 break;
2832 case blink::mojom::FrameVisibility::kNotRendered:
2833 WasHidden();
2834 break;
2835 case blink::mojom::FrameVisibility::kRenderedOutOfViewport:
2836 WasOccluded();
2837 break;
2838 }
ekaramada4f42692016-02-11 19:48:372839}
2840
Albert J. Wong65fe64d2019-09-20 02:48:142841RenderFrameHostDelegate* WebContentsImpl::CreateNewWindow(
csharrison95f01e922017-04-24 18:52:352842 RenderFrameHost* opener,
rockot5c478a72016-09-28 23:14:182843 const mojom::CreateNewWindowParams& params,
Albert J. Wong65fe64d2019-09-20 02:48:142844 bool is_new_browsing_instance,
Sergey Kuznetsov32257a22019-02-11 20:26:502845 bool has_user_gesture,
[email protected]97714c82012-06-06 10:15:132846 SessionStorageNamespace* session_storage_namespace) {
csharrison95f01e922017-04-24 18:52:352847 DCHECK(opener);
nick5ae4d2d2017-01-06 01:18:352848
csharrison95f01e922017-04-24 18:52:352849 int render_process_id = opener->GetProcess()->GetID();
csharrison95f01e922017-04-24 18:52:352850
Albert J. Wong65fe64d2019-09-20 02:48:142851 SiteInstance* source_site_instance = opener->GetSiteInstance();
nick5ae4d2d2017-01-06 01:18:352852
Aaron Colwelleb219982020-01-16 02:17:272853 const GURL source_site_url = source_site_instance->GetSiteURL();
[email protected]fdac6ade2013-07-20 01:06:302854 const std::string& partition_id =
Aaron Colwelleb219982020-01-16 02:17:272855 GetContentClient()->browser()->GetStoragePartitionIdForSite(
2856 GetBrowserContext(), source_site_url);
2857 {
2858 StoragePartition* partition = BrowserContext::GetStoragePartitionForSite(
2859 GetBrowserContext(), source_site_url);
2860 DOMStorageContextWrapper* dom_storage_context =
2861 static_cast<DOMStorageContextWrapper*>(
2862 partition->GetDOMStorageContext());
2863 SessionStorageNamespaceImpl* session_storage_namespace_impl =
2864 static_cast<SessionStorageNamespaceImpl*>(session_storage_namespace);
2865 CHECK(session_storage_namespace_impl->IsFromContext(dom_storage_context));
2866 }
[email protected]dd6730412013-08-14 15:03:372867
Albert J. Wong1ceccef92019-10-08 08:25:202868 if (delegate_ && delegate_->IsWebContentsCreationOverridden(
2869 source_site_instance, params.window_container_type,
2870 opener->GetLastCommittedURL(), params.frame_name,
2871 params.target_url)) {
2872 return static_cast<WebContentsImpl*>(delegate_->CreateCustomWebContents(
2873 opener, source_site_instance, is_new_browsing_instance,
2874 opener->GetLastCommittedURL(), params.frame_name, params.target_url,
2875 partition_id, session_storage_namespace));
[email protected]dd6730412013-08-14 15:03:372876 }
2877
danakj22b4e8b2019-08-01 23:14:392878 bool renderer_started_hidden =
2879 params.disposition == WindowOpenDisposition::NEW_BACKGROUND_TAB;
2880
Aaron Colwelleb219982020-01-16 02:17:272881 // We usually create the new window in the same BrowsingInstance (group of
2882 // script-related windows), by passing in the current SiteInstance. However,
2883 // if the opener is being suppressed (in a non-guest), we do not provide
2884 // a SiteInstance which causes a new one to get created in its own
2885 // BrowsingInstance.
2886 bool is_guest = BrowserPluginGuest::IsGuest(this);
2887 scoped_refptr<SiteInstance> site_instance =
2888 params.opener_suppressed && !is_guest ? nullptr : source_site_instance;
2889
[email protected]dd6730412013-08-14 15:03:372890 // Create the new web contents. This will automatically create the new
2891 // WebContentsView. In the future, we may want to create the view separately.
[email protected]fc72bb12013-06-02 21:13:462892 CreateParams create_params(GetBrowserContext(), site_instance.get());
nasko48321ca32015-07-02 20:44:122893 create_params.main_frame_name = params.frame_name;
alexmos4cf2aa32015-07-15 23:40:432894 create_params.opener_render_process_id = render_process_id;
csharrison95f01e922017-04-24 18:52:352895 create_params.opener_render_frame_id = opener->GetRoutingID();
[email protected]50d326e2014-05-20 17:59:062896 create_params.opener_suppressed = params.opener_suppressed;
danakj22b4e8b2019-08-01 23:14:392897 create_params.initially_hidden = renderer_started_hidden;
[email protected]50d326e2014-05-20 17:59:062898
Albert J. Wong65fe64d2019-09-20 02:48:142899 // Even though all codepaths leading here are in response to a renderer
2900 // tryng to open a new window, if the new window ends up in a different
2901 // browsing instance, then the RenderViewHost, RenderWidgetHost,
2902 // RenderFrameHost constellation is effectively browser initiated
2903 // the opener's process will not given the routing IDs for the new
2904 // objects.
2905 create_params.renderer_initiated_creation = !is_new_browsing_instance;
Albert J. Wong1ceccef92019-10-08 08:25:202906
Albert J. Wong65fe64d2019-09-20 02:48:142907 std::unique_ptr<WebContentsImpl> new_contents;
[email protected]c4538072013-03-18 02:17:552908 if (!is_guest) {
2909 create_params.context = view_->GetNativeView();
Albert J. Wong65fe64d2019-09-20 02:48:142910 new_contents = WebContentsImpl::Create(create_params);
2911 } else {
2912 new_contents = base::WrapUnique(static_cast<WebContentsImpl*>(
2913 GetBrowserPluginGuest()->CreateNewGuestWindow(create_params)));
[email protected]c4538072013-03-18 02:17:552914 }
Albert J. Wong65fe64d2019-09-20 02:48:142915 auto* new_contents_impl = new_contents.get();
danakje6c01622018-10-05 19:39:262916
2917 new_contents_impl->GetController().SetSessionStorageNamespace(
erikchenbee5c9622018-04-27 19:30:252918 partition_id, session_storage_namespace);
[email protected]d1198fd2012-08-13 22:50:192919
alexmos646fec02015-07-25 00:11:492920 // If the new frame has a name, make sure any SiteInstances that can find
2921 // this named frame have proxies for it. Must be called after
2922 // SetSessionStorageNamespace, since this calls CreateRenderView, which uses
2923 // GetSessionStorageNamespace.
2924 if (!params.frame_name.empty())
danakje6c01622018-10-05 19:39:262925 new_contents_impl->GetRenderManager()->CreateProxiesForNewNamedFrame();
alexmos646fec02015-07-25 00:11:492926
[email protected]c4538072013-03-18 02:17:552927 // Save the window for later if we're not suppressing the opener (since it
[email protected]d70bea92013-04-05 04:23:342928 // will be shown immediately).
2929 if (!params.opener_suppressed) {
2930 if (!is_guest) {
danakje6c01622018-10-05 19:39:262931 WebContentsView* new_view = new_contents_impl->view_.get();
[email protected]bafe6cd2012-05-23 23:09:502932
[email protected]d70bea92013-04-05 04:23:342933 // TODO(brettw): It seems bogus that we have to call this function on the
2934 // newly created object and give it one of its own member variables.
danakj22b4e8b2019-08-01 23:14:392935 RenderWidgetHostView* widget_view = new_view->CreateViewForWidget(
W. James MacLean13d834d2019-12-04 16:06:452936 new_contents_impl->GetRenderViewHost()->GetWidget());
danakj22b4e8b2019-08-01 23:14:392937 if (!renderer_started_hidden) {
2938 // RenderWidgets for frames always initialize as hidden. If the renderer
2939 // created this window as visible, then we show it here.
2940 widget_view->Show();
2941 }
[email protected]d70bea92013-04-05 04:23:342942 }
[email protected]bafe6cd2012-05-23 23:09:502943 // Save the created window associated with the route so we can show it
2944 // later.
Albert J. Wongcb004632018-07-10 22:58:252945 //
2946 // TODO(ajwong): This should be keyed off the RenderFrame routing id or the
2947 // FrameTreeNode id instead of the routing id of the Widget for the main
2948 // frame. https://crbug.com/545684
Fergal Daly052873a82020-03-11 14:45:492949 int32_t main_frame_routing_id = new_contents_impl->GetMainFrame()
2950 ->GetRenderWidgetHost()
2951 ->GetRoutingID();
2952 GlobalRoutingID id(render_process_id, main_frame_routing_id);
Albert J. Wong65fe64d2019-09-20 02:48:142953 pending_contents_[id] = std::move(new_contents);
danakje6c01622018-10-05 19:39:262954 AddDestructionObserver(new_contents_impl);
[email protected]bafe6cd2012-05-23 23:09:502955 }
2956
2957 if (delegate_) {
Bryan McQuaded2b93c02017-07-14 22:26:312958 delegate_->WebContentsCreated(this, render_process_id,
2959 opener->GetRoutingID(), params.frame_name,
danakje6c01622018-10-05 19:39:262960 params.target_url, new_contents_impl);
[email protected]bafe6cd2012-05-23 23:09:502961 }
2962
Charlie Harrisonf60dd1c2018-08-15 21:15:412963 for (auto& observer : observers_) {
danakje6c01622018-10-05 19:39:262964 observer.DidOpenRequestedURL(new_contents_impl, opener, params.target_url,
Leon Han963dc182018-11-06 05:41:482965 params.referrer.To<Referrer>(),
2966 params.disposition, ui::PAGE_TRANSITION_LINK,
Charlie Harrisonf60dd1c2018-08-15 21:15:412967 false, // started_from_context_menu
2968 true); // renderer_initiated
pnolandaae574e2017-03-06 21:04:212969 }
2970
Avi Drissmanba3b1b342017-08-29 18:16:132971 // Any new WebContents opened while this WebContents is in fullscreen can be
2972 // used to confuse the user, so drop fullscreen.
Avi Drissman1a55a9d62020-03-10 18:56:452973 base::ScopedClosureRunner fullscreen_block = ForSecurityDropFullscreen();
2974 // The new contents will be independent of this contents, so release the
2975 // fullscreen block.
2976 fullscreen_block.RunAndReset();
Avi Drissmanba3b1b342017-08-29 18:16:132977
[email protected]bafe6cd2012-05-23 23:09:502978 if (params.opener_suppressed) {
2979 // When the opener is suppressed, the original renderer cannot access the
2980 // new window. As a result, we need to show and navigate the window here.
[email protected]eda238a12012-09-07 23:44:002981 bool was_blocked = false;
erikchenbee5c9622018-04-27 19:30:252982
[email protected]eda238a12012-09-07 23:44:002983 if (delegate_) {
danakje6c01622018-10-05 19:39:262984 base::WeakPtr<WebContentsImpl> weak_new_contents =
2985 new_contents_impl->weak_factory_.GetWeakPtr();
nick0d558482017-02-13 22:27:222986
danakje6c01622018-10-05 19:39:262987 gfx::Rect initial_rect; // Report an empty initial rect.
Albert J. Wong65fe64d2019-09-20 02:48:142988 delegate_->AddNewContents(this, std::move(new_contents),
erikchenbee5c9622018-04-27 19:30:252989 params.disposition, initial_rect,
Sergey Kuznetsov32257a22019-02-11 20:26:502990 has_user_gesture, &was_blocked);
danakje6c01622018-10-05 19:39:262991 // The delegate may delete |new_contents_impl| during AddNewContents().
nick0d558482017-02-13 22:27:222992 if (!weak_new_contents)
Albert J. Wong65fe64d2019-09-20 02:48:142993 return nullptr;
[email protected]eda238a12012-09-07 23:44:002994 }
erikchenbee5c9622018-04-27 19:30:252995
[email protected]eda238a12012-09-07 23:44:002996 if (!was_blocked) {
Nasko Oskov83a8cf92018-10-19 14:58:562997 std::unique_ptr<NavigationController::LoadURLParams> load_params =
2998 std::make_unique<NavigationController::LoadURLParams>(
2999 params.target_url);
Nasko Oskov93e7c55c2018-12-19 01:59:293000 load_params->initiator_origin = opener->GetLastCommittedOrigin();
Aaron Colwell9dab1652019-12-09 18:29:493001 load_params->source_site_instance = source_site_instance;
Leon Han963dc182018-11-06 05:41:483002 load_params->referrer = params.referrer.To<Referrer>();
Nasko Oskov83a8cf92018-10-19 14:58:563003 load_params->transition_type = ui::PAGE_TRANSITION_LINK;
3004 load_params->is_renderer_initiated = true;
Sergey Kuznetsov32257a22019-02-11 20:26:503005 load_params->has_user_gesture = has_user_gesture;
mariakhomenkoa4971c12015-07-21 19:04:373006
3007 if (delegate_ && !is_guest &&
3008 !delegate_->ShouldResumeRequestsForCreatedWindow()) {
Nasko Oskov83a8cf92018-10-19 14:58:563009 // We are in asynchronous add new contents path, delay navigation.
3010 DCHECK(!new_contents_impl->delayed_open_url_params_);
3011 new_contents_impl->delayed_load_url_params_ = std::move(load_params);
mariakhomenkoa4971c12015-07-21 19:04:373012 } else {
Nasko Oskov83a8cf92018-10-19 14:58:563013 new_contents_impl->controller_.LoadURLWithParams(*load_params.get());
Nasko Oskov28ebd5b2018-12-07 22:29:333014 if (!is_guest)
3015 new_contents_impl->Focus();
mariakhomenkoa4971c12015-07-21 19:04:373016 }
[email protected]eda238a12012-09-07 23:44:003017 }
[email protected]bafe6cd2012-05-23 23:09:503018 }
Albert J. Wong65fe64d2019-09-20 02:48:143019 return new_contents_impl;
[email protected]bafe6cd2012-05-23 23:09:503020}
3021
Dave Tapuskad9835622020-03-10 17:32:313022void WebContentsImpl::CreateNewWidget(
3023 int32_t render_process_id,
3024 int32_t widget_route_id,
3025 mojo::PendingRemote<mojom::Widget> widget) {
Albert J. Wongf6e13ed2018-09-18 15:25:473026 CreateNewWidget(render_process_id, widget_route_id, /*is_fullscreen=*/false,
Dave Tapuskad9835622020-03-10 17:32:313027 std::move(widget));
[email protected]bafe6cd2012-05-23 23:09:503028}
3029
Julie Jeongeun Kimcaacf9102019-09-12 02:13:053030void WebContentsImpl::CreateNewFullscreenWidget(
3031 int32_t render_process_id,
3032 int32_t widget_route_id,
Dave Tapuskad9835622020-03-10 17:32:313033 mojo::PendingRemote<mojom::Widget> widget) {
Albert J. Wongf6e13ed2018-09-18 15:25:473034 CreateNewWidget(render_process_id, widget_route_id, /*is_fullscreen=*/true,
Dave Tapuskad9835622020-03-10 17:32:313035 std::move(widget));
[email protected]bafe6cd2012-05-23 23:09:503036}
3037
Dave Tapuskad9835622020-03-10 17:32:313038void WebContentsImpl::CreateNewWidget(
3039 int32_t render_process_id,
3040 int32_t route_id,
3041 bool is_fullscreen,
3042 mojo::PendingRemote<mojom::Widget> widget) {
kenrba26d15092016-02-10 22:00:253043 RenderProcessHost* process = RenderProcessHost::FromID(render_process_id);
kenrbb46f86a2015-12-07 07:53:233044 // A message to create a new widget can only come from an active process for
[email protected]a8504022013-12-04 20:23:513045 // this WebContentsImpl instance. If any other process sends the request,
3046 // it is invalid and the process must be terminated.
dcheng57e39e22016-01-21 00:25:383047 if (!HasMatchingProcess(&frame_tree_, render_process_id)) {
Lukasz Anforowicz6f746282018-01-04 23:24:513048 ReceivedBadMessage(process, bad_message::WCI_NEW_WIDGET_PROCESS_MISMATCH);
[email protected]a8504022013-12-04 20:23:513049 return;
3050 }
3051
Dave Tapuska485aca92017-08-08 00:47:583052 RenderWidgetHostImpl* widget_host = new RenderWidgetHostImpl(
David Black9cca3592019-11-06 23:02:223053 this, process, route_id, std::move(widget), IsHidden(),
3054 std::make_unique<FrameTokenMessageQueue>());
[email protected]cfd80b02014-05-01 17:46:483055 RenderWidgetHostViewBase* widget_view =
3056 static_cast<RenderWidgetHostViewBase*>(
danakj0b246942018-09-17 21:30:273057 view_->CreateViewForChildWidget(widget_host));
[email protected]83918ec2013-01-10 15:37:193058 if (!widget_view)
3059 return;
danakj0b246942018-09-17 21:30:273060 // Fullscreen child widgets are frames, other child widgets are popups, and
3061 // popups should not get activated.
3062 if (!is_fullscreen)
3063 widget_view->SetWidgetType(WidgetType::kPopup);
[email protected]bafe6cd2012-05-23 23:09:503064 // Save the created widget associated with the route so we can show it later.
Lukasz Anforowicz09060bdf72018-08-23 15:53:173065 pending_widget_views_[GlobalRoutingID(render_process_id, route_id)] =
alexmosc2a8cec2016-05-23 22:19:533066 widget_view;
[email protected]bafe6cd2012-05-23 23:09:503067}
3068
alexmosc2a8cec2016-05-23 22:19:533069void WebContentsImpl::ShowCreatedWindow(int process_id,
nick5ae4d2d2017-01-06 01:18:353070 int main_frame_widget_route_id,
[email protected]bafe6cd2012-05-23 23:09:503071 WindowOpenDisposition disposition,
bokan107a47f2015-02-03 23:23:393072 const gfx::Rect& initial_rect,
[email protected]bafe6cd2012-05-23 23:09:503073 bool user_gesture) {
danakje6c01622018-10-05 19:39:263074 // This method is the renderer requesting an existing top level window to
3075 // show a new top level window that the renderer created. Each top level
3076 // window is associated with a WebContents. In this case it was created
3077 // earlier but showing it was deferred until the renderer requested for it
3078 // to be shown. We find that previously created WebContents here.
3079 // TODO(danakj): Why do we defer this show step until the renderer asks for it
3080 // when it will always do so. What needs to happen in the renderer before we
3081 // reach here?
3082 std::unique_ptr<WebContentsImpl> owned_created =
nick5ae4d2d2017-01-06 01:18:353083 GetCreatedWindow(process_id, main_frame_widget_route_id);
danakje6c01622018-10-05 19:39:263084 WebContentsImpl* created = owned_created.get();
3085 // The browser may have rejected the request to make a new window, or the
3086 // renderer could be sending an invalid route id. Ignore the request then.
3087 if (!created)
3088 return;
mariakhomenko44bdc4732015-04-29 01:55:383089
danakje6c01622018-10-05 19:39:263090 // This uses the delegate for the WebContents where the window was created
3091 // from, to control how to show the newly created window.
3092 WebContentsDelegate* delegate = GetDelegate();
nick5ae4d2d2017-01-06 01:18:353093
danakje6c01622018-10-05 19:39:263094 // The delegate can be null in tests, so we must check for it :(.
3095 if (delegate) {
3096 // Mark the web contents as pending resume, then immediately do
3097 // the resume if the delegate wants it.
3098 created->is_resume_pending_ = true;
3099 if (delegate->ShouldResumeRequestsForCreatedWindow())
3100 created->ResumeLoadingCreatedWebContents();
3101
3102 base::WeakPtr<WebContentsImpl> weak_created =
3103 created->weak_factory_.GetWeakPtr();
3104 delegate->AddNewContents(this, std::move(owned_created), disposition,
3105 initial_rect, user_gesture, nullptr);
3106 // The delegate may delete |created| during AddNewContents().
3107 if (!weak_created)
3108 return;
[email protected]eda238a12012-09-07 23:44:003109 }
danakje6c01622018-10-05 19:39:263110
3111 RenderWidgetHostImpl* rwh = created->GetMainFrame()->GetRenderWidgetHost();
3112 DCHECK_EQ(main_frame_widget_route_id, rwh->GetRoutingID());
3113 rwh->Send(new WidgetMsg_SetBounds_ACK(rwh->GetRoutingID()));
[email protected]bafe6cd2012-05-23 23:09:503114}
3115
alexmosc2a8cec2016-05-23 22:19:533116void WebContentsImpl::ShowCreatedWidget(int process_id,
Albert J. Wongf6e13ed2018-09-18 15:25:473117 int widget_route_id,
bokan107a47f2015-02-03 23:23:393118 const gfx::Rect& initial_rect) {
Albert J. Wongf6e13ed2018-09-18 15:25:473119 ShowCreatedWidget(process_id, widget_route_id, false, initial_rect);
[email protected]bafe6cd2012-05-23 23:09:503120}
3121
alexmosc2a8cec2016-05-23 22:19:533122void WebContentsImpl::ShowCreatedFullscreenWidget(int process_id,
Albert J. Wongf6e13ed2018-09-18 15:25:473123 int widget_route_id) {
3124 ShowCreatedWidget(process_id, widget_route_id, true, gfx::Rect());
[email protected]bafe6cd2012-05-23 23:09:503125}
3126
alexmosc2a8cec2016-05-23 22:19:533127void WebContentsImpl::ShowCreatedWidget(int process_id,
3128 int route_id,
[email protected]bafe6cd2012-05-23 23:09:503129 bool is_fullscreen,
bokan107a47f2015-02-03 23:23:393130 const gfx::Rect& initial_rect) {
[email protected]cfd80b02014-05-01 17:46:483131 RenderWidgetHostViewBase* widget_host_view =
alexmosc2a8cec2016-05-23 22:19:533132 static_cast<RenderWidgetHostViewBase*>(
3133 GetCreatedWidget(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:503134 if (!widget_host_view)
3135 return;
[email protected]cfd80b02014-05-01 17:46:483136
W. James MacLeanec4125c2019-09-27 18:56:003137 // GetOutermostWebContents() returns |this| if there are no outer WebContents.
W. James MacLean3c5f50462019-10-28 16:24:213138 auto* outer_web_contents = GetOuterWebContents();
3139 auto* outermost_web_contents = GetOutermostWebContents();
W. James MacLeanec4125c2019-09-27 18:56:003140 RenderWidgetHostView* view =
W. James MacLean3c5f50462019-10-28 16:24:213141 outermost_web_contents->GetRenderWidgetHostView();
3142 // It's not entirely obvious why we need the transform only in the case where
3143 // the outer webcontents is not the same as the outermost webcontents. It may
3144 // be due to the fact that oopifs that are children of the mainframe get
3145 // correct values for their screenrects, but deeper cross-process frames do
3146 // not. Hopefully this can be resolved with https://crbug.com/928825.
3147 // Handling these cases separately is needed for http://crbug.com/1015298.
3148 bool needs_transform = this != outermost_web_contents &&
3149 outermost_web_contents != outer_web_contents;
W. James MacLeanec4125c2019-09-27 18:56:003150
3151 gfx::Rect transformed_rect(initial_rect);
3152 RenderWidgetHostView* this_view = GetRenderWidgetHostView();
W. James MacLean3c5f50462019-10-28 16:24:213153 if (needs_transform) {
W. James MacLeanec4125c2019-09-27 18:56:003154 // We need to transform the coordinates of initial_rect.
3155 gfx::Point origin =
3156 this_view->TransformPointToRootCoordSpace(initial_rect.origin());
3157 gfx::Point bottom_right =
3158 this_view->TransformPointToRootCoordSpace(initial_rect.bottom_right());
3159 transformed_rect =
3160 gfx::Rect(origin.x(), origin.y(), bottom_right.x() - origin.x(),
3161 bottom_right.y() - origin.y());
[email protected]cfd80b02014-05-01 17:46:483162 }
3163
danakj0b246942018-09-17 21:30:273164 // Fullscreen child widgets are frames, other child widgets are popups.
[email protected]4aebbca2013-09-17 22:26:493165 if (is_fullscreen) {
[email protected]d7f80ba2013-10-12 07:42:313166 DCHECK_EQ(MSG_ROUTING_NONE, fullscreen_widget_routing_id_);
[email protected]0b431992014-06-24 00:08:033167 view_->StoreFocus();
alexmosc9e76ec2016-05-16 22:59:373168 fullscreen_widget_process_id_ =
3169 widget_host_view->GetRenderWidgetHost()->GetProcess()->GetID();
[email protected]d7f80ba2013-10-12 07:42:313170 fullscreen_widget_routing_id_ = route_id;
[email protected]4aebbca2013-09-17 22:26:493171 if (delegate_ && delegate_->EmbedsFullscreenWidget()) {
3172 widget_host_view->InitAsChild(GetRenderWidgetHostView()->GetNativeView());
Dave Tapuska3ed44192018-05-01 18:53:303173 delegate_->EnterFullscreenModeForTab(this, GURL(),
Dave Tapuskaa4189512019-10-15 20:27:343174 blink::mojom::FullscreenOptions());
[email protected]4aebbca2013-09-17 22:26:493175 } else {
[email protected]cfd80b02014-05-01 17:46:483176 widget_host_view->InitAsFullscreen(view);
[email protected]4aebbca2013-09-17 22:26:493177 }
ericwilligersde386342016-10-19 02:35:093178 for (auto& observer : observers_)
3179 observer.DidShowFullscreenWidget();
[email protected]4aebbca2013-09-17 22:26:493180 if (!widget_host_view->HasFocus())
3181 widget_host_view->Focus();
3182 } else {
W. James MacLeanec4125c2019-09-27 18:56:003183 widget_host_view->InitAsPopup(view, transformed_rect);
[email protected]4aebbca2013-09-17 22:26:493184 }
[email protected]89054502012-06-03 10:29:243185
yiyixcb1fbc4f2018-03-16 19:54:083186 RenderWidgetHostImpl* render_widget_host_impl = widget_host_view->host();
[email protected]89054502012-06-03 10:29:243187 render_widget_host_impl->Init();
[email protected]d7f80ba2013-10-12 07:42:313188 // Only allow privileged mouse lock for fullscreen render widget, which is
3189 // used to implement Pepper Flash fullscreen.
3190 render_widget_host_impl->set_allow_privileged_mouse_lock(is_fullscreen);
[email protected]bafe6cd2012-05-23 23:09:503191}
3192
danakje6c01622018-10-05 19:39:263193std::unique_ptr<WebContentsImpl> WebContentsImpl::GetCreatedWindow(
nick5ae4d2d2017-01-06 01:18:353194 int process_id,
3195 int main_frame_widget_route_id) {
Lukasz Anforowicz09060bdf72018-08-23 15:53:173196 auto key = GlobalRoutingID(process_id, main_frame_widget_route_id);
nick5ae4d2d2017-01-06 01:18:353197 auto iter = pending_contents_.find(key);
[email protected]bafe6cd2012-05-23 23:09:503198
3199 // Certain systems can block the creation of new windows. If we didn't succeed
3200 // in creating one, just return NULL.
alexmosc2a8cec2016-05-23 22:19:533201 if (iter == pending_contents_.end())
3202 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:503203
danakje6c01622018-10-05 19:39:263204 std::unique_ptr<WebContentsImpl> new_contents = std::move(iter->second);
nick5ae4d2d2017-01-06 01:18:353205 pending_contents_.erase(key);
danakje6c01622018-10-05 19:39:263206 RemoveDestructionObserver(new_contents.get());
[email protected]bafe6cd2012-05-23 23:09:503207
[email protected]d70bea92013-04-05 04:23:343208 // Don't initialize the guest WebContents immediately.
danakje6c01622018-10-05 19:39:263209 if (BrowserPluginGuest::IsGuest(new_contents.get()))
[email protected]d70bea92013-04-05 04:23:343210 return new_contents;
3211
Lukasz Anforowicz5510ed652018-06-06 16:16:193212 if (!new_contents->GetMainFrame()->GetProcess()->IsInitializedAndNotDead() ||
nick5ae4d2d2017-01-06 01:18:353213 !new_contents->GetMainFrame()->GetView()) {
alexmosc2a8cec2016-05-23 22:19:533214 return nullptr;
nick5ae4d2d2017-01-06 01:18:353215 }
[email protected]bafe6cd2012-05-23 23:09:503216
[email protected]bafe6cd2012-05-23 23:09:503217 return new_contents;
3218}
3219
alexmosc2a8cec2016-05-23 22:19:533220RenderWidgetHostView* WebContentsImpl::GetCreatedWidget(int process_id,
3221 int route_id) {
Lukasz Anforowicz09060bdf72018-08-23 15:53:173222 auto iter = pending_widget_views_.find(GlobalRoutingID(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:503223 if (iter == pending_widget_views_.end()) {
3224 DCHECK(false);
alexmosc2a8cec2016-05-23 22:19:533225 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:503226 }
3227
3228 RenderWidgetHostView* widget_host_view = iter->second;
Lukasz Anforowicz09060bdf72018-08-23 15:53:173229 pending_widget_views_.erase(GlobalRoutingID(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:503230
3231 RenderWidgetHost* widget_host = widget_host_view->GetRenderWidgetHost();
Lukasz Anforowicz5510ed652018-06-06 16:16:193232 if (!widget_host->GetProcess()->IsInitializedAndNotDead()) {
[email protected]bafe6cd2012-05-23 23:09:503233 // The view has gone away or the renderer crashed. Nothing to do.
alexmosc2a8cec2016-05-23 22:19:533234 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:503235 }
3236
3237 return widget_host_view;
3238}
3239
[email protected]f13b4202012-06-12 23:53:233240void WebContentsImpl::RequestMediaAccessPermission(
[email protected]33662e52013-01-07 21:31:093241 const MediaStreamRequest& request,
Mark Pilgrim57499082018-06-12 12:38:303242 MediaResponseCallback callback) {
[email protected]d19b84b2014-03-14 11:52:373243 if (delegate_) {
Mark Pilgrim57499082018-06-12 12:38:303244 delegate_->RequestMediaAccessPermission(this, request, std::move(callback));
[email protected]d19b84b2014-03-14 11:52:373245 } else {
Antonio Gomes0d42960a2019-06-05 12:35:513246 std::move(callback).Run(
3247 blink::MediaStreamDevices(),
3248 blink::mojom::MediaStreamRequestResult::FAILED_DUE_TO_SHUTDOWN,
3249 std::unique_ptr<MediaStreamUI>());
[email protected]d19b84b2014-03-14 11:52:373250 }
[email protected]f13b4202012-06-12 23:53:233251}
3252
Chandan Padhia4b8bcb72017-09-12 16:41:043253bool WebContentsImpl::CheckMediaAccessPermission(
Raymes Khouryad7c24a12018-03-05 23:22:583254 RenderFrameHost* render_frame_host,
Chandan Padhia4b8bcb72017-09-12 16:41:043255 const url::Origin& security_origin,
Antonio Gomesc8b734b2019-06-05 18:22:163256 blink::mojom::MediaStreamType type) {
3257 DCHECK(type == blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE ||
3258 type == blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE);
Chandan Padhia4b8bcb72017-09-12 16:41:043259 return delegate_ && delegate_->CheckMediaAccessPermission(
Raymes Khouryad7c24a12018-03-05 23:22:583260 render_frame_host, security_origin.GetURL(), type);
grunell657d4d82014-09-18 00:09:433261}
3262
Guido Urdaneta73fa6632019-01-14 18:46:263263std::string WebContentsImpl::GetDefaultMediaDeviceID(
Antonio Gomesc8b734b2019-06-05 18:22:163264 blink::mojom::MediaStreamType type) {
guidou8a440b842017-01-30 13:58:433265 if (!delegate_)
3266 return std::string();
3267 return delegate_->GetDefaultMediaDeviceID(this, type);
3268}
3269
[email protected]cc9200432013-07-23 23:02:403270SessionStorageNamespace* WebContentsImpl::GetSessionStorageNamespace(
3271 SiteInstance* instance) {
3272 return controller_.GetSessionStorageNamespace(instance);
3273}
3274
[email protected]6de7fc482014-06-06 10:46:443275SessionStorageNamespaceMap WebContentsImpl::GetSessionStorageNamespaceMap() {
3276 return controller_.GetSessionStorageNamespaceMap();
3277}
3278
[email protected]9b159a52013-10-03 17:24:553279FrameTree* WebContentsImpl::GetFrameTree() {
3280 return &frame_tree_;
3281}
3282
aelias5252baa2016-04-10 01:18:023283bool WebContentsImpl::IsOverridingUserAgent() {
3284 return GetController().GetVisibleEntry() &&
3285 GetController().GetVisibleEntry()->GetIsOverridingUserAgent();
3286}
3287
avi85ee8362016-10-08 02:09:083288bool WebContentsImpl::IsJavaScriptDialogShowing() const {
3289 return is_showing_javascript_dialog_;
3290}
3291
avic031d392017-03-03 03:09:423292bool WebContentsImpl::ShouldIgnoreUnresponsiveRenderer() {
3293 // Ignore unresponsive renderers if the debugger is attached to them since the
3294 // unresponsiveness might be a result of the renderer sitting on a breakpoint.
3295 //
David Bienvenu525f8a02019-02-15 02:02:423296#ifdef OS_WIN
3297 // Check if a windows debugger is attached to the renderer process.
3298 base::ProcessHandle process_handle =
3299 GetMainFrame()->GetProcess()->GetProcess().Handle();
3300 BOOL debugger_present = FALSE;
3301 if (CheckRemoteDebuggerPresent(process_handle, &debugger_present) &&
3302 debugger_present)
3303 return true;
3304#endif // OS_WIN
3305
avic031d392017-03-03 03:09:423306 // TODO(pfeldman): Fix this to only return true if the renderer is *actually*
3307 // sitting on a breakpoint. https://crbug.com/684202
3308 return DevToolsAgentHost::IsDebuggerAttached(this);
3309}
3310
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:413311ui::AXMode WebContentsImpl::GetAccessibilityMode() {
[email protected]95640212014-07-26 18:14:303312 return accessibility_mode_;
3313}
3314
Dominic Mazzonia7b0edb22017-08-09 16:32:513315void WebContentsImpl::AccessibilityEventReceived(
Dominic Mazzoniccbaa9b2018-06-06 07:44:233316 const AXEventNotificationDetails& details) {
ericwilligersde386342016-10-19 02:35:093317 for (auto& observer : observers_)
Dominic Mazzonia7b0edb22017-08-09 16:32:513318 observer.AccessibilityEventReceived(details);
[email protected]31a71eaf2014-03-13 01:47:363319}
3320
dmazzoni2400c462016-08-23 15:07:133321void WebContentsImpl::AccessibilityLocationChangesReceived(
3322 const std::vector<AXLocationChangeNotificationDetails>& details) {
ericwilligersde386342016-10-19 02:35:093323 for (auto& observer : observers_)
Dominic Mazzonia7b0edb22017-08-09 16:32:513324 observer.AccessibilityLocationChangesReceived(details);
dmazzoni2400c462016-08-23 15:07:133325}
3326
Abigail Kleinabb428332019-09-13 18:26:213327base::string16 WebContentsImpl::DumpAccessibilityTree(
3328 bool internal,
3329 std::vector<AccessibilityTreeFormatter::PropertyFilter> property_filters) {
James Wallace-Leeeafc94cb92018-07-23 21:35:093330 auto* ax_mgr = GetOrCreateRootBrowserAccessibilityManager();
3331 DCHECK(ax_mgr);
Lei Zhangc98caa3822019-11-07 19:17:273332 return AccessibilityTreeFormatterBase::DumpAccessibilityTreeFromManager(
Abigail Kleinabb428332019-09-13 18:26:213333 ax_mgr, internal, property_filters);
James Wallace-Leeeafc94cb92018-07-23 21:35:093334}
3335
Abigail Kleinaa898742019-11-01 02:31:253336void WebContentsImpl::RecordAccessibilityEvents(
3337 AccessibilityEventCallback callback,
3338 bool start) {
3339 if (start) {
3340 SetAccessibilityMode(ui::AXMode::kWebContents);
3341 auto* ax_mgr = GetOrCreateRootBrowserAccessibilityManager();
3342 DCHECK(ax_mgr);
3343 base::ProcessId pid = base::Process::Current().Pid();
3344 event_recorder_ = content::AccessibilityEventRecorder::Create(
3345 ax_mgr, pid, base::StringPiece{});
3346 event_recorder_->ListenToEvents(callback);
3347 } else {
3348 DCHECK(event_recorder_);
3349 event_recorder_->FlushAsyncEvents();
3350 event_recorder_ = nullptr;
3351 }
3352}
3353
dmazzonia656928e2014-09-15 20:28:543354RenderFrameHost* WebContentsImpl::GetGuestByInstanceID(
fsamuel833ee7c2015-02-13 23:40:403355 RenderFrameHost* render_frame_host,
dmazzonia656928e2014-09-15 20:28:543356 int browser_plugin_instance_id) {
3357 BrowserPluginGuestManager* guest_manager =
3358 GetBrowserContext()->GetGuestManager();
fsamuel9cbc00a2015-04-17 20:30:203359 if (!guest_manager)
3360 return nullptr;
3361
dmazzonia656928e2014-09-15 20:28:543362 WebContents* guest = guest_manager->GetGuestByInstanceID(
fsamuel2e9413d2015-02-25 01:25:443363 render_frame_host->GetProcess()->GetID(), browser_plugin_instance_id);
dmazzonia656928e2014-09-15 20:28:543364 if (!guest)
fsamuel9cbc00a2015-04-17 20:30:203365 return nullptr;
3366
dmazzonia656928e2014-09-15 20:28:543367 return guest->GetMainFrame();
3368}
3369
Ke He7319dbe2017-11-09 05:54:443370device::mojom::GeolocationContext* WebContentsImpl::GetGeolocationContext() {
Ken Rockotce010f02019-12-12 23:32:323371 if (!geolocation_context_) {
3372 GetDeviceService().BindGeolocationContext(
3373 geolocation_context_.BindNewPipeAndPassReceiver());
3374 }
Conley Owens6894c4f2017-07-10 19:29:133375 return geolocation_context_.get();
blundellc57b93f2014-10-29 13:19:573376}
3377
ke.he98b761e2017-05-09 05:59:173378device::mojom::WakeLockContext* WebContentsImpl::GetWakeLockContext() {
blundelld8cd72b2017-03-28 07:18:383379 if (!wake_lock_context_host_)
3380 wake_lock_context_host_.reset(new WakeLockContextHost(this));
blundelle75a8f92017-03-27 08:11:173381 return wake_lock_context_host_->GetWakeLockContext();
alogvinovf50445a2015-10-30 13:00:123382}
3383
blundellf5316fc2017-05-15 11:49:033384#if defined(OS_ANDROID)
Miyoung Shin59f39ff2019-09-17 07:23:203385void WebContentsImpl::GetNFC(
Reilly Grantafbe2242020-02-20 21:14:553386 RenderFrameHost* render_frame_host,
Miyoung Shin59f39ff2019-09-17 07:23:203387 mojo::PendingReceiver<device::mojom::NFC> receiver) {
Reilly Grantafbe2242020-02-20 21:14:553388 if (!nfc_host_)
3389 nfc_host_ = std::make_unique<NFCHost>(this);
3390 nfc_host_->GetNFC(render_frame_host, std::move(receiver));
blundellf5316fc2017-05-15 11:49:033391}
3392#endif
3393
Evan Stade5e750ad02017-08-07 21:59:273394void WebContentsImpl::SetNotWaitingForResponse() {
3395 if (waiting_for_response_ == false)
3396 return;
3397
3398 waiting_for_response_ = false;
3399 if (delegate_)
3400 delegate_->LoadingStateChanged(this, is_load_to_different_document_);
Chris Hamiltonf82f2a702018-02-15 19:37:293401 for (auto& observer : observers_)
3402 observer.DidReceiveResponse();
Evan Stade5e750ad02017-08-07 21:59:273403}
3404
lfgbb9c28a2016-03-01 03:19:493405void WebContentsImpl::SendScreenRects() {
kenrbc52e1b4e2016-03-20 01:03:373406 for (FrameTreeNode* node : frame_tree_.Nodes()) {
kenrb0e8dc202016-05-30 19:51:403407 if (node->current_frame_host()->is_local_root())
kenrbc52e1b4e2016-03-20 01:03:373408 node->current_frame_host()->GetRenderWidgetHost()->SendScreenRects();
3409 }
lfgbb9c28a2016-03-01 03:19:493410
danakj4df8a9d02019-02-05 20:36:593411 // Interstitials have their own |frame_tree_|.
3412 if (interstitial_page_) {
3413 FrameTree* interstitial_frame_tree = interstitial_page_->GetFrameTree();
3414 for (FrameTreeNode* node : interstitial_frame_tree->Nodes()) {
3415 if (node->current_frame_host()->is_local_root())
3416 node->current_frame_host()->GetRenderWidgetHost()->SendScreenRects();
3417 }
lfgdb5c4ed2016-03-04 23:09:073418 }
[email protected]32deec62013-05-15 23:55:043419}
3420
ekaramadadd882292016-06-08 15:22:563421TextInputManager* WebContentsImpl::GetTextInputManager() {
3422 if (GetOuterWebContents())
3423 return GetOuterWebContents()->GetTextInputManager();
3424
Ehsan Karamadc179dc02018-12-15 03:09:293425 if (!text_input_manager_ && !browser_plugin_guest_) {
Darren Shenca53d5f2018-05-15 04:56:013426 text_input_manager_.reset(new TextInputManager(
3427 GetBrowserContext() &&
3428 !GetBrowserContext()->IsOffTheRecord()) /* should_do_learning */);
3429 }
ekaramadadd882292016-06-08 15:22:563430
3431 return text_input_manager_.get();
3432}
3433
paulmeyer7f6f1d4f2016-11-15 00:00:273434bool WebContentsImpl::OnUpdateDragCursor() {
Lei Zhang6410ec1a2019-01-31 21:38:583435 return browser_plugin_embedder_ &&
3436 browser_plugin_embedder_->OnUpdateDragCursor();
paulmeyer7f6f1d4f2016-11-15 00:00:273437}
3438
kenrb11f213a2017-03-24 18:12:063439bool WebContentsImpl::IsWidgetForMainFrame(
3440 RenderWidgetHostImpl* render_widget_host) {
3441 return render_widget_host == GetMainFrame()->GetRenderWidgetHost();
3442}
3443
[email protected]95640212014-07-26 18:14:303444BrowserAccessibilityManager*
3445 WebContentsImpl::GetRootBrowserAccessibilityManager() {
Dominic Mazzoniefb5f9e32017-12-21 01:08:223446 RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(
3447 ShowingInterstitialPage() ? GetInterstitialPage()->GetMainFrame()
3448 : GetMainFrame());
creisc014b402015-04-23 16:41:453449 return rfh ? rfh->browser_accessibility_manager() : nullptr;
[email protected]95640212014-07-26 18:14:303450}
3451
3452BrowserAccessibilityManager*
3453 WebContentsImpl::GetOrCreateRootBrowserAccessibilityManager() {
Dominic Mazzoniefb5f9e32017-12-21 01:08:223454 RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(
3455 ShowingInterstitialPage() ? GetInterstitialPage()->GetMainFrame()
3456 : GetMainFrame());
creisc014b402015-04-23 16:41:453457 return rfh ? rfh->GetOrCreateBrowserAccessibilityManager() : nullptr;
[email protected]95640212014-07-26 18:14:303458}
3459
Dave Tapuskab336b922017-07-06 19:24:053460void WebContentsImpl::ExecuteEditCommand(
3461 const std::string& command,
3462 const base::Optional<base::string16>& value) {
Dave Tapuskae782bea2019-07-09 16:21:513463 auto* input_handler = GetFocusedFrameInputHandler();
3464 if (!input_handler)
Dave Tapuskab336b922017-07-06 19:24:053465 return;
3466
Dave Tapuskae782bea2019-07-09 16:21:513467 input_handler->ExecuteEditCommand(command, value);
Dave Tapuskab336b922017-07-06 19:24:053468}
3469
mohsen7ab1ec16ec2015-07-02 18:26:233470void WebContentsImpl::MoveRangeSelectionExtent(const gfx::Point& extent) {
Dave Tapuskae782bea2019-07-09 16:21:513471 auto* input_handler = GetFocusedFrameInputHandler();
3472 if (!input_handler)
mohsen7ab1ec16ec2015-07-02 18:26:233473 return;
3474
Dave Tapuskae782bea2019-07-09 16:21:513475 input_handler->MoveRangeSelectionExtent(extent);
mohsen7ab1ec16ec2015-07-02 18:26:233476}
3477
3478void WebContentsImpl::SelectRange(const gfx::Point& base,
3479 const gfx::Point& extent) {
Dave Tapuskae782bea2019-07-09 16:21:513480 auto* input_handler = GetFocusedFrameInputHandler();
3481 if (!input_handler)
mohsen7ab1ec16ec2015-07-02 18:26:233482 return;
3483
Dave Tapuskae782bea2019-07-09 16:21:513484 input_handler->SelectRange(base, extent);
mohsen7ab1ec16ec2015-07-02 18:26:233485}
3486
Dave Tapuskab336b922017-07-06 19:24:053487void WebContentsImpl::MoveCaret(const gfx::Point& extent) {
Dave Tapuskae782bea2019-07-09 16:21:513488 auto* input_handler = GetFocusedFrameInputHandler();
3489 if (!input_handler)
Dave Tapuskab336b922017-07-06 19:24:053490 return;
3491
Dave Tapuskae782bea2019-07-09 16:21:513492 input_handler->MoveCaret(extent);
Dave Tapuskab336b922017-07-06 19:24:053493}
3494
Shimi Zhang37deeb22017-09-28 00:59:013495void WebContentsImpl::AdjustSelectionByCharacterOffset(
3496 int start_adjust,
3497 int end_adjust,
3498 bool show_selection_menu) {
Dave Tapuskae782bea2019-07-09 16:21:513499 auto* input_handler = GetFocusedFrameInputHandler();
3500 if (!input_handler)
aurimasab0319022015-07-10 21:57:383501 return;
3502
Shimi Zhang37deeb22017-09-28 00:59:013503 using blink::mojom::SelectionMenuBehavior;
Dave Tapuskae782bea2019-07-09 16:21:513504 input_handler->AdjustSelectionByCharacterOffset(
Shimi Zhang37deeb22017-09-28 00:59:013505 start_adjust, end_adjust,
3506 show_selection_menu ? SelectionMenuBehavior::kShow
3507 : SelectionMenuBehavior::kHide);
aurimasab0319022015-07-10 21:57:383508}
3509
[email protected]b172aee2012-04-10 17:05:263510void WebContentsImpl::UpdatePreferredSize(const gfx::Size& pref_size) {
[email protected]222f5822014-02-05 23:40:493511 const gfx::Size old_size = GetPreferredSize();
[email protected]bcd2815602012-01-14 18:17:233512 preferred_size_ = pref_size;
[email protected]222f5822014-02-05 23:40:493513 OnPreferredSizeChanged(old_size);
[email protected]0548c5352011-09-07 00:33:333514}
3515
avic3aa8422015-11-09 20:57:223516void WebContentsImpl::ResizeDueToAutoResize(
3517 RenderWidgetHostImpl* render_widget_host,
Fady Samuel97947112018-05-05 16:24:543518 const gfx::Size& new_size) {
avic3aa8422015-11-09 20:57:223519 if (render_widget_host != GetRenderViewHost()->GetWidget())
3520 return;
3521
[email protected]61e2b3cc2012-03-02 16:13:343522 if (delegate_)
3523 delegate_->ResizeDueToAutoResize(this, new_size);
3524}
3525
[email protected]b172aee2012-04-10 17:05:263526WebContents* WebContentsImpl::OpenURL(const OpenURLParams& params) {
Aaron Colwell9dab1652019-12-09 18:29:493527#if DCHECK_IS_ON()
3528 DCHECK(params.Valid());
3529#endif
3530
Bo Liu300c6052018-06-12 04:46:073531 if (!delegate_) {
3532 // Embedder can delay setting a delegate on new WebContents with
3533 // WebContentsDelegate::ShouldResumeRequestsForCreatedWindow. In the mean
3534 // time, navigations, including the initial one, that goes through OpenURL
3535 // should be delayed until embedder is ready to resume loading.
3536 delayed_open_url_params_ = std::make_unique<OpenURLParams>(params);
Nasko Oskov83a8cf92018-10-19 14:58:563537
3538 // If there was a navigation deferred when creating the window through
3539 // CreateNewWindow, drop it in favor of this navigation.
3540 delayed_load_url_params_.reset();
3541
Ivan Kotenkov2c0d2bb32017-11-01 15:41:283542 return nullptr;
Bo Liu300c6052018-06-12 04:46:073543 }
[email protected]00c37fc2011-08-02 00:22:503544
[email protected]e5d549d2011-12-28 01:29:203545 WebContents* new_contents = delegate_->OpenURLFromTab(this, params);
pnoland488944652017-02-22 18:58:543546
3547 RenderFrameHost* source_render_frame_host = RenderFrameHost::FromID(
3548 params.source_render_process_id, params.source_render_frame_id);
3549
3550 if (source_render_frame_host && params.source_site_instance) {
3551 CHECK_EQ(source_render_frame_host->GetSiteInstance(),
3552 params.source_site_instance.get());
3553 }
3554
3555 if (new_contents && source_render_frame_host && new_contents != this) {
3556 for (auto& observer : observers_) {
Lukasz Anforowicz48c9f872018-08-01 00:58:413557 observer.DidOpenRequestedURL(
3558 new_contents, source_render_frame_host, params.url, params.referrer,
3559 params.disposition, params.transition,
3560 params.started_from_context_menu, params.is_renderer_initiated);
pnoland488944652017-02-22 18:58:543561 }
3562 }
3563
[email protected]e5d549d2011-12-28 01:29:203564 return new_contents;
[email protected]d5f942ba2008-09-26 19:30:343565}
3566
[email protected]a86c0e962013-12-17 17:10:393567void WebContentsImpl::RenderFrameForInterstitialPageCreated(
3568 RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:093569 for (auto& observer : observers_)
3570 observer.RenderFrameForInterstitialPageCreated(render_frame_host);
[email protected]ba45bfd2012-05-22 21:51:443571}
3572
[email protected]20ca0382013-02-28 19:50:073573void WebContentsImpl::AttachInterstitialPage(
3574 InterstitialPageImpl* interstitial_page) {
creisadca9862017-06-16 19:12:113575 DCHECK(!interstitial_page_ && interstitial_page);
3576 interstitial_page_ = interstitial_page;
[email protected]90fb08ed2013-09-24 17:43:293577
3578 // Cancel any visible dialogs so that they don't interfere with the
3579 // interstitial.
creis89a0f782015-05-27 16:13:173580 CancelActiveAndPendingDialogs();
[email protected]90fb08ed2013-09-24 17:43:293581
ericwilligersde386342016-10-19 02:35:093582 for (auto& observer : observers_)
3583 observer.DidAttachInterstitialPage();
clamy44e84ce2016-02-22 15:38:253584
3585 // Stop the throbber if needed while the interstitial page is shown.
3586 if (frame_tree_.IsLoading())
3587 LoadingStateChanged(true, true, nullptr);
lfg1453e412017-04-11 00:48:503588
3589 // Connect to outer WebContents if necessary.
3590 if (node_.OuterContentsFrameTreeNode()) {
3591 if (GetRenderManager()->GetProxyToOuterDelegate()) {
3592 DCHECK(
3593 static_cast<RenderWidgetHostViewBase*>(interstitial_page->GetView())
3594 ->IsRenderWidgetHostViewChildFrame());
3595 RenderWidgetHostViewChildFrame* view =
3596 static_cast<RenderWidgetHostViewChildFrame*>(
3597 interstitial_page->GetView());
3598 GetRenderManager()->SetRWHViewForInnerContents(view);
3599 }
3600 }
Bo Liu7c6779e92017-08-16 02:02:283601
Bo Liu168c8642017-08-28 18:26:023602#if defined(OS_ANDROID)
Bo Liu7c6779e92017-08-16 02:02:283603 // Update importance of the interstitial.
3604 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
3605 ->GetRenderWidgetHost()
3606 ->SetImportance(GetMainFrame()->GetRenderWidgetHost()->importance());
Bo Liu168c8642017-08-28 18:26:023607#endif
Dominic Mazzoniefb5f9e32017-12-21 01:08:223608
3609 if (accessibility_mode_.has_mode(ui::AXMode::kNativeAPIs)) {
3610 // Make sure that the main page's accessibility tree is hidden and the
3611 // interstitial gets focus.
3612 RenderFrameHostImpl* rfh =
3613 static_cast<RenderFrameHostImpl*>(GetMainFrame());
3614 if (rfh) {
3615 BrowserAccessibilityManager* accessibility_manager =
3616 rfh->browser_accessibility_manager();
3617 if (accessibility_manager)
3618 accessibility_manager->set_hidden_by_interstitial_page(true);
3619 }
3620 rfh = static_cast<RenderFrameHostImpl*>(
3621 GetInterstitialPage()->GetMainFrame());
3622 if (rfh) {
3623 BrowserAccessibilityManager* accessibility_manager =
3624 rfh->GetOrCreateBrowserAccessibilityManager();
3625 if (accessibility_manager)
3626 accessibility_manager->OnWindowFocused();
3627 }
3628 }
clamy44e84ce2016-02-22 15:38:253629}
3630
3631void WebContentsImpl::DidProceedOnInterstitial() {
3632 // The interstitial page should no longer be pausing the throbber.
creisadca9862017-06-16 19:12:113633 DCHECK(!(ShowingInterstitialPage() && interstitial_page_->pause_throbber()));
clamy44e84ce2016-02-22 15:38:253634
3635 // Restart the throbber now that the interstitial page no longer pauses it.
3636 if (ShowingInterstitialPage() && frame_tree_.IsLoading())
3637 LoadingStateChanged(true, true, nullptr);
[email protected]20ca0382013-02-28 19:50:073638}
3639
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043640void WebContentsImpl::DetachInterstitialPage(bool has_focus) {
Lucas Furukawa Gadani69b609192017-07-10 17:08:343641 bool interstitial_pausing_throbber =
3642 ShowingInterstitialPage() && interstitial_page_->pause_throbber();
3643 if (ShowingInterstitialPage())
3644 interstitial_page_ = nullptr;
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043645
Dominic Mazzoniefb5f9e32017-12-21 01:08:223646 // Make sure that the main page's accessibility tree is no longer
3647 // suppressed.
3648 RenderFrameHostImpl* rfh = GetMainFrame();
3649 if (rfh) {
3650 BrowserAccessibilityManager* accessibility_manager =
3651 rfh->browser_accessibility_manager();
3652 if (accessibility_manager)
3653 accessibility_manager->set_hidden_by_interstitial_page(false);
3654 }
3655
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043656 // If the focus was on the interstitial, let's keep it to the page.
3657 // (Note that in unit-tests the RVH may not have a view).
3658 if (has_focus && GetRenderViewHost()->GetWidget()->GetView())
3659 GetRenderViewHost()->GetWidget()->GetView()->Focus();
3660
Lucas Furukawa Gadani69b609192017-07-10 17:08:343661 for (auto& observer : observers_)
3662 observer.DidDetachInterstitialPage();
3663
3664 // Disconnect from outer WebContents if necessary. This must happen after the
3665 // interstitial page is cleared above, since the call to
3666 // SetRWHViewForInnerContents below may loop over all the
3667 // RenderWidgetHostViews in the tree (otherwise, including the now-deleted
3668 // view for the interstitial).
lfg1453e412017-04-11 00:48:503669 if (node_.OuterContentsFrameTreeNode()) {
3670 if (GetRenderManager()->GetProxyToOuterDelegate()) {
3671 DCHECK(static_cast<RenderWidgetHostViewBase*>(
3672 GetRenderManager()->current_frame_host()->GetView())
3673 ->IsRenderWidgetHostViewChildFrame());
3674 RenderWidgetHostViewChildFrame* view =
3675 static_cast<RenderWidgetHostViewChildFrame*>(
3676 GetRenderManager()->current_frame_host()->GetView());
3677 GetRenderManager()->SetRWHViewForInnerContents(view);
3678 }
3679 }
3680
clamy44e84ce2016-02-22 15:38:253681 // Restart the throbber if needed now that the interstitial page is going
3682 // away.
3683 if (interstitial_pausing_throbber && frame_tree_.IsLoading())
3684 LoadingStateChanged(true, true, nullptr);
[email protected]20ca0382013-02-28 19:50:073685}
3686
avi2b177592014-12-10 02:08:023687void WebContentsImpl::SetHistoryOffsetAndLength(int history_offset,
3688 int history_length) {
alexmos136fd6e62016-08-15 20:58:413689 SendPageMessage(new PageMsg_SetHistoryOffsetAndLength(
3690 MSG_ROUTING_NONE, history_offset, history_length));
avi2b177592014-12-10 02:08:023691}
3692
3693void WebContentsImpl::SetHistoryOffsetAndLengthForView(
3694 RenderViewHost* render_view_host,
3695 int history_offset,
3696 int history_length) {
alexmos136fd6e62016-08-15 20:58:413697 render_view_host->Send(new PageMsg_SetHistoryOffsetAndLength(
avi2b177592014-12-10 02:08:023698 render_view_host->GetRoutingID(), history_offset, history_length));
[email protected]796931a92011-08-10 01:32:143699}
3700
arthursonzogni818c2642019-09-27 12:18:103701void WebContentsImpl::ReloadFocusedFrame() {
[email protected]1f3fc1d2014-04-03 14:50:173702 RenderFrameHost* focused_frame = GetFocusedFrame();
3703 if (!focused_frame)
3704 return;
3705
yilkal921048bd2019-10-09 23:51:043706 focused_frame->Reload();
[email protected]959be4c2014-04-08 15:01:333707}
3708
Miyoung Shin298d5ad2019-09-05 01:52:373709std::vector<mojo::Remote<blink::mojom::PauseSubresourceLoadingHandle>>
Ryan Sturmc65dbe42018-05-31 20:37:043710WebContentsImpl::PauseSubresourceLoading() {
Miyoung Shin298d5ad2019-09-05 01:52:373711 std::vector<mojo::Remote<blink::mojom::PauseSubresourceLoadingHandle>>
3712 handles;
Ryan Sturmc65dbe42018-05-31 20:37:043713 for (RenderFrameHost* rfh : GetAllFrames()) {
3714 if (!rfh->IsRenderFrameLive())
3715 continue;
3716 handles.push_back(rfh->PauseSubresourceLoading());
3717 }
3718 return handles;
3719}
3720
[email protected]959be4c2014-04-08 15:01:333721void WebContentsImpl::Undo() {
Dave Tapuskae782bea2019-07-09 16:21:513722 auto* input_handler = GetFocusedFrameInputHandler();
3723 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333724 return;
3725
Dave Tapuskae782bea2019-07-09 16:21:513726 input_handler->Undo();
[email protected]959be4c2014-04-08 15:01:333727 RecordAction(base::UserMetricsAction("Undo"));
3728}
3729
3730void WebContentsImpl::Redo() {
Dave Tapuskae782bea2019-07-09 16:21:513731 auto* input_handler = GetFocusedFrameInputHandler();
3732 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333733 return;
Dave Tapuskae782bea2019-07-09 16:21:513734
3735 input_handler->Redo();
[email protected]959be4c2014-04-08 15:01:333736 RecordAction(base::UserMetricsAction("Redo"));
3737}
3738
3739void WebContentsImpl::Cut() {
Dave Tapuskae782bea2019-07-09 16:21:513740 auto* input_handler = GetFocusedFrameInputHandler();
3741 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333742 return;
3743
Dave Tapuskae782bea2019-07-09 16:21:513744 input_handler->Cut();
[email protected]959be4c2014-04-08 15:01:333745 RecordAction(base::UserMetricsAction("Cut"));
3746}
3747
3748void WebContentsImpl::Copy() {
Dave Tapuskae782bea2019-07-09 16:21:513749 auto* input_handler = GetFocusedFrameInputHandler();
3750 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333751 return;
3752
Dave Tapuskae782bea2019-07-09 16:21:513753 input_handler->Copy();
[email protected]959be4c2014-04-08 15:01:333754 RecordAction(base::UserMetricsAction("Copy"));
3755}
3756
3757void WebContentsImpl::CopyToFindPboard() {
3758#if defined(OS_MACOSX)
Dave Tapuskae782bea2019-07-09 16:21:513759 auto* input_handler = GetFocusedFrameInputHandler();
3760 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333761 return;
3762
3763 // Windows/Linux don't have the concept of a find pasteboard.
Dave Tapuskae782bea2019-07-09 16:21:513764 input_handler->CopyToFindPboard();
[email protected]959be4c2014-04-08 15:01:333765 RecordAction(base::UserMetricsAction("CopyToFindPboard"));
3766#endif
3767}
3768
3769void WebContentsImpl::Paste() {
Dave Tapuskae782bea2019-07-09 16:21:513770 auto* input_handler = GetFocusedFrameInputHandler();
3771 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333772 return;
3773
Dave Tapuskae782bea2019-07-09 16:21:513774 input_handler->Paste();
Archana Simhaf67090c2019-05-06 23:43:233775 for (auto& observer : observers_)
3776 observer.OnPaste();
[email protected]959be4c2014-04-08 15:01:333777 RecordAction(base::UserMetricsAction("Paste"));
3778}
3779
3780void WebContentsImpl::PasteAndMatchStyle() {
Dave Tapuskae782bea2019-07-09 16:21:513781 auto* input_handler = GetFocusedFrameInputHandler();
3782 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333783 return;
3784
Dave Tapuskae782bea2019-07-09 16:21:513785 input_handler->PasteAndMatchStyle();
Archana Simhaf67090c2019-05-06 23:43:233786 for (auto& observer : observers_)
3787 observer.OnPaste();
[email protected]959be4c2014-04-08 15:01:333788 RecordAction(base::UserMetricsAction("PasteAndMatchStyle"));
3789}
3790
3791void WebContentsImpl::Delete() {
Dave Tapuskae782bea2019-07-09 16:21:513792 auto* input_handler = GetFocusedFrameInputHandler();
3793 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333794 return;
3795
Dave Tapuskae782bea2019-07-09 16:21:513796 input_handler->Delete();
[email protected]959be4c2014-04-08 15:01:333797 RecordAction(base::UserMetricsAction("DeleteSelection"));
3798}
3799
3800void WebContentsImpl::SelectAll() {
Dave Tapuskae782bea2019-07-09 16:21:513801 auto* input_handler = GetFocusedFrameInputHandler();
3802 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333803 return;
3804
Dave Tapuskae782bea2019-07-09 16:21:513805 input_handler->SelectAll();
[email protected]959be4c2014-04-08 15:01:333806 RecordAction(base::UserMetricsAction("SelectAll"));
3807}
3808
yabinh351e7ec2017-03-10 02:43:243809void WebContentsImpl::CollapseSelection() {
Dave Tapuskae782bea2019-07-09 16:21:513810 auto* input_handler = GetFocusedFrameInputHandler();
3811 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333812 return;
3813
Dave Tapuskae782bea2019-07-09 16:21:513814 input_handler->CollapseSelection();
[email protected]1f3fc1d2014-04-03 14:50:173815}
3816
3817void WebContentsImpl::Replace(const base::string16& word) {
Dave Tapuskae782bea2019-07-09 16:21:513818 auto* input_handler = GetFocusedFrameInputHandler();
3819 if (!input_handler)
[email protected]1f3fc1d2014-04-03 14:50:173820 return;
3821
Dave Tapuskae782bea2019-07-09 16:21:513822 input_handler->Replace(word);
[email protected]1f3fc1d2014-04-03 14:50:173823}
3824
3825void WebContentsImpl::ReplaceMisspelling(const base::string16& word) {
Dave Tapuskae782bea2019-07-09 16:21:513826 auto* input_handler = GetFocusedFrameInputHandler();
3827 if (!input_handler)
[email protected]1f3fc1d2014-04-03 14:50:173828 return;
3829
Dave Tapuskae782bea2019-07-09 16:21:513830 input_handler->ReplaceMisspelling(word);
[email protected]959be4c2014-04-08 15:01:333831}
3832
3833void WebContentsImpl::NotifyContextMenuClosed(
3834 const CustomContextMenuContext& context) {
3835 RenderFrameHost* focused_frame = GetFocusedFrame();
3836 if (!focused_frame)
3837 return;
3838
3839 focused_frame->Send(new FrameMsg_ContextMenuClosed(
3840 focused_frame->GetRoutingID(), context));
3841}
3842
3843void WebContentsImpl::ExecuteCustomContextMenuCommand(
3844 int action, const CustomContextMenuContext& context) {
3845 RenderFrameHost* focused_frame = GetFocusedFrame();
3846 if (!focused_frame)
3847 return;
3848
3849 focused_frame->Send(new FrameMsg_CustomContextMenuAction(
3850 focused_frame->GetRoutingID(), context, action));
[email protected]4fed3702014-04-01 09:08:003851}
3852
[email protected]fc2b46b2014-05-03 16:33:453853gfx::NativeView WebContentsImpl::GetNativeView() {
3854 return view_->GetNativeView();
3855}
3856
3857gfx::NativeView WebContentsImpl::GetContentNativeView() {
3858 return view_->GetContentNativeView();
3859}
3860
3861gfx::NativeWindow WebContentsImpl::GetTopLevelNativeWindow() {
3862 return view_->GetTopLevelNativeWindow();
3863}
3864
3865gfx::Rect WebContentsImpl::GetViewBounds() {
3866 return view_->GetViewBounds();
3867}
3868
3869gfx::Rect WebContentsImpl::GetContainerBounds() {
3870 gfx::Rect rv;
3871 view_->GetContainerBounds(&rv);
3872 return rv;
3873}
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
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:413899bool WebContentsImpl::ShowingInterstitialPage() {
creisadca9862017-06-16 19:12:113900 return interstitial_page_ != nullptr;
[email protected]96d185d2009-04-24 03:28:543901}
3902
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:413903InterstitialPageImpl* WebContentsImpl::GetInterstitialPage() {
creisadca9862017-06-16 19:12:113904 return interstitial_page_;
[email protected]686493142011-07-15 21:47:223905}
3906
[email protected]b172aee2012-04-10 17:05:263907bool WebContentsImpl::IsSavable() {
[email protected]a53209b2012-01-20 16:48:163908 // WebKit creates Document object when MIME type is application/xhtml+xml,
3909 // so we also support this MIME type.
3910 return contents_mime_type_ == "text/html" ||
3911 contents_mime_type_ == "text/xml" ||
3912 contents_mime_type_ == "application/xhtml+xml" ||
3913 contents_mime_type_ == "text/plain" ||
3914 contents_mime_type_ == "text/css" ||
Kinuko Yasuda74702f92017-07-31 03:27:533915 blink::IsSupportedJavascriptMimeType(contents_mime_type_);
[email protected]a53209b2012-01-20 16:48:163916}
3917
[email protected]b172aee2012-04-10 17:05:263918void WebContentsImpl::OnSavePage() {
[email protected]c7dd2f62011-07-18 15:57:593919 // If we can not save the page, try to download it.
[email protected]a53209b2012-01-20 16:48:163920 if (!IsSavable()) {
Min Qinda0ed2062018-02-23 22:00:533921 download::RecordSavePackageEvent(
3922 download::SAVE_PACKAGE_DOWNLOAD_ON_NON_HTML);
nasko89ad7742015-03-05 22:14:193923 SaveFrame(GetLastCommittedURL(), Referrer());
[email protected]27678b2a2012-02-04 22:09:143924 return;
[email protected]c7dd2f62011-07-18 15:57:593925 }
3926
3927 Stop();
3928
3929 // Create the save package and possibly prompt the user for the name to save
3930 // the page as. The user prompt is an asynchronous operation that runs on
3931 // another thread.
3932 save_package_ = new SavePackage(this);
3933 save_package_->GetSaveInfo();
3934}
3935
3936// Used in automated testing to bypass prompting the user for file names.
3937// Instead, the names and paths are hard coded rather than running them through
3938// file name sanitation and extension / mime checking.
[email protected]2dec8ec2013-02-07 19:20:343939bool WebContentsImpl::SavePage(const base::FilePath& main_file,
3940 const base::FilePath& dir_path,
[email protected]8ff00d72012-10-23 19:12:213941 SavePageType save_type) {
[email protected]c7dd2f62011-07-18 15:57:593942 // Stop the page from navigating.
3943 Stop();
3944
3945 save_package_ = new SavePackage(this, save_type, main_file, dir_path);
[email protected]8ff00d72012-10-23 19:12:213946 return save_package_->Init(SavePackageDownloadCreatedCallback());
[email protected]c7dd2f62011-07-18 15:57:593947}
3948
[email protected]3c71576ce2013-07-23 02:00:013949void WebContentsImpl::SaveFrame(const GURL& url,
3950 const Referrer& referrer) {
Xing Liu10329bf2018-03-20 19:22:143951 SaveFrameWithHeaders(url, referrer, std::string(), base::string16());
kundaji6c7f9692015-03-09 18:00:373952}
3953
Xing Liu10329bf2018-03-20 19:22:143954void WebContentsImpl::SaveFrameWithHeaders(
3955 const GURL& url,
3956 const Referrer& referrer,
3957 const std::string& headers,
3958 const base::string16& suggested_filename) {
Lei Zhang13a42e42019-02-19 23:28:113959 // Check and see if the guest can handle this.
3960 if (delegate_) {
3961 WebContents* guest_web_contents = nullptr;
3962 if (browser_plugin_embedder_) {
3963 BrowserPluginGuest* guest = browser_plugin_embedder_->GetFullPageGuest();
3964 if (guest)
3965 guest_web_contents = guest->GetWebContents();
3966 } else if (browser_plugin_guest_) {
3967 guest_web_contents = this;
3968 }
3969
3970 if (guest_web_contents && delegate_->GuestSaveFrame(guest_web_contents))
3971 return;
3972 }
3973
nasko89ad7742015-03-05 22:14:193974 if (!GetLastCommittedURL().is_valid())
[email protected]3c71576ce2013-07-23 02:00:013975 return;
sammc92af61552014-11-19 23:27:403976 if (delegate_ && delegate_->SaveFrame(url, referrer))
3977 return;
3978
nasko89ad7742015-03-05 22:14:193979 // TODO(nasko): This check for main frame is incorrect and should be fixed
brettw760f7442016-05-23 21:19:223980 // by explicitly passing in which frame this method should target. This would
3981 // indicate whether it's the main frame, and also tell us the frame pointer
3982 // to use for routing.
nasko89ad7742015-03-05 22:14:193983 bool is_main_frame = (url == GetLastCommittedURL());
brettw760f7442016-05-23 21:19:223984 RenderFrameHost* frame_host = GetMainFrame();
[email protected]3c71576ce2013-07-23 02:00:013985
avib7348942015-12-25 20:57:103986 int64_t post_id = -1;
[email protected]3c71576ce2013-07-23 02:00:013987 if (is_main_frame) {
Lucas Furukawa Gadani5553a152019-01-08 18:55:573988 NavigationEntry* entry = controller_.GetLastCommittedEntry();
[email protected]3c71576ce2013-07-23 02:00:013989 if (entry)
3990 post_id = entry->GetPostID();
3991 }
Ramin Halavati24e21012017-07-10 12:56:063992 net::NetworkTrafficAnnotationTag traffic_annotation =
3993 net::DefineNetworkTrafficAnnotation("download_web_contents_frame", R"(
3994 semantics {
3995 sender: "Save Page Action"
3996 description:
3997 "Saves the given frame's URL to the local file system."
3998 trigger:
3999 "The user has triggered a save operation on the frame through a "
4000 "context menu or other mechanism."
4001 data: "None."
4002 destination: WEBSITE
4003 }
4004 policy {
Ramin Halavati3b979782017-07-21 11:40:264005 cookies_allowed: YES
Ramin Halavati24e21012017-07-10 12:56:064006 cookies_store: "user"
4007 setting:
4008 "This feature cannot be disabled by settings, but it's is only "
4009 "triggered by user request."
4010 policy_exception_justification: "Not implemented."
4011 })");
Min Qina904f3302018-02-13 23:33:344012 auto params = std::make_unique<download::DownloadUrlParameters>(
brettw760f7442016-05-23 21:19:224013 url, frame_host->GetProcess()->GetID(),
4014 frame_host->GetRenderViewHost()->GetRoutingID(),
Matt Menke0dcaebc32020-03-06 17:00:104015 frame_host->GetRoutingID(), traffic_annotation);
Min Qina904f3302018-02-13 23:33:344016 params->set_referrer(referrer.url);
4017 params->set_referrer_policy(
4018 Referrer::ReferrerPolicyForUrlRequest(referrer.policy));
[email protected]3c71576ce2013-07-23 02:00:014019 params->set_post_id(post_id);
[email protected]3c71576ce2013-07-23 02:00:014020 if (post_id >= 0)
4021 params->set_method("POST");
4022 params->set_prompt(true);
kundaji6c7f9692015-03-09 18:00:374023
4024 if (headers.empty()) {
4025 params->set_prefer_cache(true);
4026 } else {
Min Qina904f3302018-02-13 23:33:344027 for (download::DownloadUrlParameters::RequestHeadersNameValuePair
4028 key_value : ParseDownloadHeaders(headers)) {
Megan Jablonski2f6a4c52017-07-10 23:01:254029 params->add_request_header(key_value.first, key_value.second);
kundaji6c7f9692015-03-09 18:00:374030 }
4031 }
Xing Liu10329bf2018-03-20 19:22:144032 params->set_suggested_name(suggested_filename);
Min Qin0ca8e1ee2018-01-31 00:49:354033 params->set_download_source(download::DownloadSource::WEB_CONTENTS_API);
thestig859c78892017-05-15 21:17:064034 BrowserContext::GetDownloadManager(GetBrowserContext())
Ramin Halavati03efa732017-06-12 09:28:204035 ->DownloadUrl(std::move(params));
[email protected]3c71576ce2013-07-23 02:00:014036}
4037
[email protected]b172aee2012-04-10 17:05:264038void WebContentsImpl::GenerateMHTML(
dewittj6dc5747a2016-05-17 01:48:474039 const MHTMLGenerationParams& params,
Avi Drissman149b7832018-03-23 14:31:494040 base::OnceCallback<void(int64_t)> callback) {
Angel Alvarez902496682019-08-27 22:58:424041 base::OnceCallback<void(const MHTMLGenerationResult&)> wrapper_callback =
4042 base::BindOnce(
4043 [](base::OnceCallback<void(int64_t)> size_callback,
4044 const MHTMLGenerationResult& result) {
4045 std::move(size_callback).Run(result.file_size);
4046 },
4047 std::move(callback));
4048 MHTMLGenerationManager::GetInstance()->SaveMHTML(this, params,
4049 std::move(wrapper_callback));
4050}
4051
4052void WebContentsImpl::GenerateMHTMLWithResult(
4053 const MHTMLGenerationParams& params,
4054 MHTMLGenerationResult::GenerateMHTMLCallback callback) {
Avi Drissman149b7832018-03-23 14:31:494055 MHTMLGenerationManager::GetInstance()->SaveMHTML(this, params,
4056 std::move(callback));
[email protected]aa4f3972012-03-01 18:12:124057}
4058
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414059const std::string& WebContentsImpl::GetContentsMimeType() {
[email protected]0bfbf882011-12-22 18:19:274060 return contents_mime_type_;
4061}
4062
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414063bool WebContentsImpl::WillNotifyDisconnection() {
[email protected]0bfbf882011-12-22 18:19:274064 return notify_disconnection_;
4065}
4066
Leon Hanc819dc62019-01-28 04:30:194067blink::mojom::RendererPreferences* WebContentsImpl::GetMutableRendererPrefs() {
[email protected]0bfbf882011-12-22 18:19:274068 return &renderer_preferences_;
4069}
4070
[email protected]e35ccd52012-05-23 16:22:474071void WebContentsImpl::Close() {
4072 Close(GetRenderViewHost());
4073}
4074
Ella Ge80a52dce2017-11-15 18:01:524075void WebContentsImpl::DragSourceEndedAt(float client_x,
4076 float client_y,
4077 float screen_x,
4078 float screen_y,
Paul Meyer0c58c3712016-11-17 22:59:514079 blink::WebDragOperation operation,
4080 RenderWidgetHost* source_rwh) {
Lei Zhang6410ec1a2019-01-31 21:38:584081 if (browser_plugin_embedder_) {
W. James MacLean9437b5bf2019-12-06 17:33:444082 browser_plugin_embedder_->DragSourceEndedAt(client_x, client_y, screen_x,
4083 screen_y, operation);
Lei Zhang6410ec1a2019-01-31 21:38:584084 }
Paul Meyer0c58c3712016-11-17 22:59:514085 if (source_rwh) {
Ella Ge80a52dce2017-11-15 18:01:524086 source_rwh->DragSourceEndedAt(gfx::PointF(client_x, client_y),
4087 gfx::PointF(screen_x, screen_y), operation);
Paul Meyer0c58c3712016-11-17 22:59:514088 }
[email protected]cf200a562013-05-03 16:24:294089}
4090
jam73f892642016-09-11 06:04:064091void WebContentsImpl::LoadStateChanged(
Charles Harrison911fa062018-03-06 21:01:464092 const std::string& host,
jam73f892642016-09-11 06:04:064093 const net::LoadStateWithParam& load_state,
4094 uint64_t upload_position,
4095 uint64_t upload_size) {
Charles Harrison911fa062018-03-06 21:01:464096 base::string16 host16 = url_formatter::IDNToUnicode(host);
Elly Fong-Jonescad9c3d12018-01-31 17:26:104097 // Drop no-op updates.
4098 if (load_state_.state == load_state.state &&
4099 load_state_.param == load_state.param &&
4100 upload_position_ == upload_position && upload_size_ == upload_size &&
Charles Harrison911fa062018-03-06 21:01:464101 load_state_host_ == host16) {
Elly Fong-Jonescad9c3d12018-01-31 17:26:104102 return;
4103 }
jam73f892642016-09-11 06:04:064104 load_state_ = load_state;
4105 upload_position_ = upload_position;
4106 upload_size_ = upload_size;
Charles Harrison911fa062018-03-06 21:01:464107 load_state_host_ = host16;
jam73f892642016-09-11 06:04:064108 if (load_state_.state == net::LOAD_STATE_READING_RESPONSE)
4109 SetNotWaitingForResponse();
4110 if (IsLoading()) {
4111 NotifyNavigationStateChanged(static_cast<InvalidateTypes>(
4112 INVALIDATE_TYPE_LOAD | INVALIDATE_TYPE_TAB));
4113 }
4114}
4115
Collin Baker989e0882019-11-01 01:27:174116void WebContentsImpl::SetVisibilityAndNotifyObservers(Visibility visibility) {
Francois Doraye6161152018-03-27 22:05:374117 const Visibility previous_visibility = visibility_;
4118 visibility_ = visibility;
4119
Francois Dorayfe4a1772018-02-17 04:17:094120 // Notify observers if the visibility changed or if WasShown() is being called
4121 // for the first time.
Francois Dorayfe4a1772018-02-17 04:17:094122 if (visibility != previous_visibility ||
4123 (visibility == Visibility::VISIBLE && !did_first_set_visible_)) {
4124 for (auto& observer : observers_)
4125 observer.OnVisibilityChanged(visibility);
4126 }
4127}
4128
Michael Thiessen896405db2017-07-20 17:52:324129void WebContentsImpl::NotifyWebContentsFocused(
4130 RenderWidgetHost* render_widget_host) {
ericwilligersde386342016-10-19 02:35:094131 for (auto& observer : observers_)
Michael Thiessen896405db2017-07-20 17:52:324132 observer.OnWebContentsFocused(render_widget_host);
calamity7fe55ce2015-04-10 03:59:374133}
4134
Michael Thiessen896405db2017-07-20 17:52:324135void WebContentsImpl::NotifyWebContentsLostFocus(
4136 RenderWidgetHost* render_widget_host) {
zijiehe3bee08e22017-05-17 04:14:464137 for (auto& observer : observers_)
Michael Thiessen896405db2017-07-20 17:52:324138 observer.OnWebContentsLostFocus(render_widget_host);
zijiehe3bee08e22017-05-17 04:14:464139}
4140
Paul Meyer0c58c3712016-11-17 22:59:514141void WebContentsImpl::SystemDragEnded(RenderWidgetHost* source_rwh) {
4142 if (source_rwh)
4143 source_rwh->DragSourceSystemDragEnded();
Lei Zhang6410ec1a2019-01-31 21:38:584144 if (browser_plugin_embedder_)
[email protected]cf200a562013-05-03 16:24:294145 browser_plugin_embedder_->SystemDragEnded();
[email protected]7813bd72011-02-05 02:19:344146}
4147
[email protected]b172aee2012-04-10 17:05:264148void WebContentsImpl::SetClosedByUserGesture(bool value) {
[email protected]0bfbf882011-12-22 18:19:274149 closed_by_user_gesture_ = value;
4150}
4151
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414152bool WebContentsImpl::GetClosedByUserGesture() {
[email protected]0bfbf882011-12-22 18:19:274153 return closed_by_user_gesture_;
4154}
4155
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414156int WebContentsImpl::GetMinimumZoomPercent() {
[email protected]0bfbf882011-12-22 18:19:274157 return minimum_zoom_percent_;
4158}
4159
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414160int WebContentsImpl::GetMaximumZoomPercent() {
[email protected]0bfbf882011-12-22 18:19:274161 return maximum_zoom_percent_;
4162}
4163
Dave Tapuska8f7c3872020-02-07 01:16:384164void WebContentsImpl::SetPageScale(float scale_factor) {
4165 GetMainFrame()->GetAssociatedLocalMainFrame()->SetScaleFactor(scale_factor);
ccameronb7c1d6c2015-03-09 17:08:244166}
4167
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414168gfx::Size WebContentsImpl::GetPreferredSize() {
Francois Doray24fc62c2017-12-11 17:27:334169 return IsBeingCaptured() ? preferred_size_for_capture_ : preferred_size_;
[email protected]bcd2815602012-01-14 18:17:234170}
4171
James Hollyerd5c9de462020-03-10 19:02:454172bool WebContentsImpl::GotResponseToLockMouseRequest(
4173 blink::mojom::PointerLockResult result) {
lfgf0cd46e2017-01-04 00:05:234174 if (mouse_lock_widget_) {
4175 if (mouse_lock_widget_->delegate()->GetAsWebContents() != this) {
4176 return mouse_lock_widget_->delegate()
4177 ->GetAsWebContents()
James Hollyerd5c9de462020-03-10 19:02:454178 ->GotResponseToLockMouseRequest(result);
lfgf0cd46e2017-01-04 00:05:234179 }
lfgad8244352016-07-13 16:55:514180
James Hollyerd5c9de462020-03-10 19:02:454181 if (mouse_lock_widget_->GotResponseToLockMouseRequest(result))
lfgf0cd46e2017-01-04 00:05:234182 return true;
4183 }
4184
4185 for (WebContentsImpl* current = this; current;
4186 current = current->GetOuterWebContents()) {
4187 current->mouse_lock_widget_ = nullptr;
4188 }
4189
lfgbee1e0a2016-06-08 21:24:214190 return false;
[email protected]0bfbf882011-12-22 18:19:274191}
4192
James Hollyerd5c9de462020-03-10 19:02:454193void WebContentsImpl::GotLockMousePermissionResponse(bool allowed) {
4194 GotResponseToLockMouseRequest(
4195 allowed ? blink::mojom::PointerLockResult::kSuccess
4196 : blink::mojom::PointerLockResult::kPermissionDenied);
4197}
4198
Joe Downing13dd76b2018-04-09 18:32:154199bool WebContentsImpl::GotResponseToKeyboardLockRequest(bool allowed) {
4200 if (!keyboard_lock_widget_)
4201 return false;
4202
4203 if (keyboard_lock_widget_->delegate()->GetAsWebContents() != this) {
4204 NOTREACHED();
4205 return false;
4206 }
4207
4208 // KeyboardLock is only supported when called by the top-level browsing
4209 // context and is not supported in embedded content scenarios.
4210 if (GetOuterWebContents())
4211 return false;
4212
4213 keyboard_lock_widget_->GotResponseToKeyboardLockRequest(allowed);
4214 return true;
4215}
4216
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414217bool WebContentsImpl::HasOpener() {
Ivan Kotenkov2c0d2bb32017-11-01 15:41:284218 return GetOpener() != nullptr;
[email protected]a0358d72012-03-09 14:06:504219}
4220
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414221RenderFrameHostImpl* WebContentsImpl::GetOpener() {
alexmose201c7cd2015-06-10 17:14:214222 FrameTreeNode* opener_ftn = frame_tree_.root()->opener();
lukasza6f8ac622017-06-06 03:10:204223 return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
jochen55ff3502014-12-18 20:52:574224}
4225
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414226bool WebContentsImpl::HasOriginalOpener() {
Ivan Kotenkov2c0d2bb32017-11-01 15:41:284227 return GetOriginalOpener() != nullptr;
jochen6004a362017-02-04 00:11:404228}
4229
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414230RenderFrameHostImpl* WebContentsImpl::GetOriginalOpener() {
jochen6004a362017-02-04 00:11:404231 FrameTreeNode* opener_ftn = frame_tree_.root()->original_opener();
lukasza6f8ac622017-06-06 03:10:204232 return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
jochen6004a362017-02-04 00:11:404233}
4234
[email protected]cb805452013-05-22 15:16:214235void WebContentsImpl::DidChooseColorInColorChooser(SkColor color) {
Joel Hockey85b379d2017-12-11 10:42:134236 color_chooser_->DidChooseColorInColorChooser(color);
[email protected]da8543762012-03-20 08:52:204237}
4238
[email protected]cb805452013-05-22 15:16:214239void WebContentsImpl::DidEndColorChooser() {
Joel Hockey85b379d2017-12-11 10:42:134240 color_chooser_.reset();
[email protected]da8543762012-03-20 08:52:204241}
4242
halton.huoca2eabd2015-07-06 08:17:404243int WebContentsImpl::DownloadImage(
4244 const GURL& url,
4245 bool is_favicon,
Fredrik Söderquistb2b39eb92019-11-18 16:16:504246 uint32_t preferred_size,
halton.huoca2eabd2015-07-06 08:17:404247 uint32_t max_bitmap_size,
4248 bool bypass_cache,
Avi Drissmana5a52dd2018-03-27 03:39:024249 WebContents::ImageDownloadCallback callback) {
Danyao Wanga78f3dd22020-03-05 05:31:274250 return DownloadImageInFrame(GlobalFrameRoutingId(), url, is_favicon,
4251 preferred_size, max_bitmap_size, bypass_cache,
4252 std::move(callback));
4253}
4254
4255int WebContentsImpl::DownloadImageInFrame(
4256 const GlobalFrameRoutingId& initiator_frame_routing_id,
4257 const GURL& url,
4258 bool is_favicon,
4259 uint32_t preferred_size,
4260 uint32_t max_bitmap_size,
4261 bool bypass_cache,
4262 WebContents::ImageDownloadCallback callback) {
amistry9f01b772015-07-29 01:54:554263 DCHECK_CURRENTLY_ON(BrowserThread::UI);
halton.huoca2eabd2015-07-06 08:17:404264 static int next_image_download_id = 0;
Danyao Wanga78f3dd22020-03-05 05:31:274265
4266 RenderFrameHostImpl* initiator_frame =
4267 initiator_frame_routing_id.child_id
4268 ? RenderFrameHostImpl::FromID(initiator_frame_routing_id)
4269 : GetMainFrame();
Julie Jeongeun Kimb1473572019-08-15 05:59:134270 const mojo::Remote<blink::mojom::ImageDownloader>& mojo_image_downloader =
Danyao Wanga78f3dd22020-03-05 05:31:274271 initiator_frame->GetMojoImageDownloader();
amistry9f01b772015-07-29 01:54:554272 const int download_id = ++next_image_download_id;
4273 if (!mojo_image_downloader) {
4274 // If the renderer process is dead (i.e. crash, or memory pressure on
4275 // Android), the downloader service will be invalid. Pre-Mojo, this would
Avi Drissmana5a52dd2018-03-27 03:39:024276 // hang the callback indefinitely since the IPC would be dropped. Now,
amistry9f01b772015-07-29 01:54:554277 // respond with a 400 HTTP error code to indicate that something went wrong.
Sami Kyostila8e4d5a92019-08-02 12:45:054278 base::PostTask(
Eric Seckler8652dcd52018-09-20 10:42:284279 FROM_HERE, {BrowserThread::UI},
tzike2aca992017-09-05 08:50:544280 base::BindOnce(&WebContentsImpl::OnDidDownloadImage,
Avi Drissmana5a52dd2018-03-27 03:39:024281 weak_factory_.GetWeakPtr(), std::move(callback),
4282 download_id, url, 400, std::vector<SkBitmap>(),
4283 std::vector<gfx::Size>()));
amistry9f01b772015-07-29 01:54:554284 return download_id;
4285 }
4286
halton.huoca2eabd2015-07-06 08:17:404287 mojo_image_downloader->DownloadImage(
Fredrik Söderquistb2b39eb92019-11-18 16:16:504288 url, is_favicon, preferred_size, max_bitmap_size, bypass_cache,
tzike2aca992017-09-05 08:50:544289 base::BindOnce(&WebContentsImpl::OnDidDownloadImage,
Avi Drissmana5a52dd2018-03-27 03:39:024290 weak_factory_.GetWeakPtr(), std::move(callback),
4291 download_id, url));
amistry9f01b772015-07-29 01:54:554292 return download_id;
[email protected]795c28972012-12-06 06:13:394293}
4294
[email protected]36ec24f2014-01-09 00:32:084295void WebContentsImpl::Find(int request_id,
4296 const base::string16& search_text,
Rakina Zata Amni3f77dff2018-09-08 16:19:434297 blink::mojom::FindOptionsPtr options) {
thestig6057a6b22015-11-12 23:01:334298 // Cowardly refuse to search for no text.
4299 if (search_text.empty()) {
4300 NOTREACHED();
4301 return;
4302 }
4303
Rakina Zata Amni3f77dff2018-09-08 16:19:434304 GetOrCreateFindRequestManager()->Find(request_id, search_text,
4305 std::move(options));
[email protected]36ec24f2014-01-09 00:32:084306}
4307
4308void WebContentsImpl::StopFinding(StopFindAction action) {
paulmeyerfeafc2d2017-04-25 21:46:404309 if (FindRequestManager* manager = GetFindRequestManager())
4310 manager->StopFinding(action);
[email protected]36ec24f2014-01-09 00:32:084311}
4312
Tommy Steimel18360512017-11-01 00:38:194313bool WebContentsImpl::WasEverAudible() {
4314 return was_ever_audible_;
4315}
4316
Avi Drissmana5a52dd2018-03-27 03:39:024317void WebContentsImpl::GetManifest(GetManifestCallback callback) {
4318 manifest_manager_host_->GetManifest(std::move(callback));
mlamouriefdca9d2014-09-16 16:55:404319}
4320
bokanece34a82016-01-28 19:49:464321void WebContentsImpl::ExitFullscreen(bool will_cause_resize) {
mlamouri7a78d6fd2015-01-17 13:23:534322 // Clean up related state and initiate the fullscreen exit.
James Hollyerd5c9de462020-03-10 19:02:454323 GetRenderViewHost()->GetWidget()->RejectMouseLockOrUnlockIfNecessary(
4324 blink::mojom::PointerLockResult::kUserRejected);
bokanece34a82016-01-28 19:49:464325 ExitFullscreenMode(will_cause_resize);
mlamouri7a78d6fd2015-01-17 13:23:534326}
4327
Avi Drissman1a55a9d62020-03-10 18:56:454328base::ScopedClosureRunner WebContentsImpl::ForSecurityDropFullscreen() {
Avi Drissmanced52b62019-08-14 21:25:464329 // There are two chains of WebContents to kick out of fullscreen.
4330 //
4331 // Chain 1, the inner/outer WebContents chain. If an inner WebContents has
4332 // done something that requires the browser to drop fullscreen, drop
4333 // fullscreen from it and any outer WebContents that may be in fullscreen.
4334 //
4335 // Chain 2, the opener WebContents chain. If a WebContents has done something
4336 // that requires the browser to drop fullscreen, drop fullscreen from any
4337 // WebContents that was involved in the chain of opening it.
4338 //
4339 // Note that these two chains don't interact, as only a top-level WebContents
4340 // can have an opener. This simplifies things.
4341
Avi Drissman1a55a9d62020-03-10 18:56:454342 std::vector<base::WeakPtr<WebContentsImpl>> blocked_contentses;
4343
4344 WebContentsImpl* web_contents = this;
Avi Drissmanced52b62019-08-14 21:25:464345 while (web_contents) {
Avi Drissman1a55a9d62020-03-10 18:56:454346 // Drop fullscreen if the WebContents is in it, and...
Avi Drissmanced52b62019-08-14 21:25:464347 if (web_contents->IsFullscreenForCurrentTab())
4348 web_contents->ExitFullscreen(true);
4349
Avi Drissman1a55a9d62020-03-10 18:56:454350 // ...block the WebContents from entering fullscreen until further notice.
4351 ++web_contents->fullscreen_blocker_count_;
4352 blocked_contentses.push_back(web_contents->weak_factory_.GetWeakPtr());
4353
4354 if (web_contents->HasOriginalOpener()) {
4355 web_contents = static_cast<WebContentsImpl*>(
4356 FromRenderFrameHost(web_contents->GetOriginalOpener()));
4357 } else {
Avi Drissmanced52b62019-08-14 21:25:464358 web_contents = web_contents->GetOuterWebContents();
Avi Drissman1a55a9d62020-03-10 18:56:454359 }
Avi Drissmanced52b62019-08-14 21:25:464360 }
Avi Drissman1a55a9d62020-03-10 18:56:454361
4362 return base::ScopedClosureRunner(base::BindOnce(
4363 [](std::vector<base::WeakPtr<WebContentsImpl>> blocked_contentses) {
4364 for (base::WeakPtr<WebContentsImpl>& web_contents :
4365 blocked_contentses) {
4366 if (web_contents) {
4367 DCHECK_GT(web_contents->fullscreen_blocker_count_, 0);
4368 --web_contents->fullscreen_blocker_count_;
4369 }
4370 }
4371 },
4372 std::move(blocked_contentses)));
Avi Drissmanced52b62019-08-14 21:25:464373}
4374
mariakhomenko44bdc4732015-04-29 01:55:384375void WebContentsImpl::ResumeLoadingCreatedWebContents() {
Nasko Oskov83a8cf92018-10-19 14:58:564376 if (delayed_load_url_params_.get()) {
4377 DCHECK(!delayed_open_url_params_);
4378 controller_.LoadURLWithParams(*delayed_load_url_params_.get());
4379 delayed_load_url_params_.reset(nullptr);
4380 return;
4381 }
4382
mariakhomenkoa4971c12015-07-21 19:04:374383 if (delayed_open_url_params_.get()) {
4384 OpenURL(*delayed_open_url_params_.get());
4385 delayed_open_url_params_.reset(nullptr);
4386 return;
4387 }
4388
mariakhomenko44bdc4732015-04-29 01:55:384389 // Resume blocked requests for both the RenderViewHost and RenderFrameHost.
4390 // TODO(brettw): It seems bogus to reach into here and initialize the host.
dfalcantarae6b7b46752015-07-10 18:14:164391 if (is_resume_pending_) {
4392 is_resume_pending_ = false;
avi0f1bbc9712015-11-17 02:58:134393 GetRenderViewHost()->GetWidget()->Init();
dfalcantarae6b7b46752015-07-10 18:14:164394 GetMainFrame()->Init();
4395 }
mariakhomenko44bdc4732015-04-29 01:55:384396}
4397
[email protected]b172aee2012-04-10 17:05:264398bool WebContentsImpl::FocusLocationBarByDefault() {
Xiyuan Xia2a66b112018-12-06 15:52:164399 if (should_focus_location_bar_by_default_)
[email protected]0c9406632013-02-08 01:13:334400 return true;
Xiyuan Xia2a66b112018-12-06 15:52:164401
[email protected]0c9406632013-02-08 01:13:334402 return delegate_ && delegate_->ShouldFocusLocationBarByDefault(this);
[email protected]0bfbf882011-12-22 18:19:274403}
4404
Tommy C. Li8bb5bf42019-01-18 18:45:514405void WebContentsImpl::SetFocusToLocationBar() {
[email protected]0bfbf882011-12-22 18:19:274406 if (delegate_)
Tommy C. Li8bb5bf42019-01-18 18:45:514407 delegate_->SetFocusToLocationBar();
[email protected]c40d6232011-03-25 00:16:214408}
4409
clamy0e119882015-07-31 16:12:334410void WebContentsImpl::DidStartNavigation(NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484411 TRACE_EVENT1("navigation", "WebContentsImpl::DidStartNavigation",
4412 "navigation_handle", navigation_handle);
Alan Cutterab48fc02020-02-24 12:26:424413 if (navigation_handle->IsInMainFrame())
4414 favicon_urls_.clear();
Mounir Lamouri7b4a1f232019-12-23 16:32:104415
ericwilligersde386342016-10-19 02:35:094416 for (auto& observer : observers_)
4417 observer.DidStartNavigation(navigation_handle);
Becca Hughesd11d6502018-07-31 17:01:284418
4419 if (display_cutout_host_impl_)
4420 display_cutout_host_impl_->DidStartNavigation(navigation_handle);
Xiyuan Xia2a66b112018-12-06 15:52:164421
4422 if (navigation_handle->IsInMainFrame()) {
4423 // When the browser is started with about:blank as the startup URL, focus
4424 // the location bar (which will also select its contents) so people can
4425 // simply begin typing to navigate elsewhere.
4426 //
4427 // We need to be careful not to trigger this for anything other than the
4428 // startup navigation. In particular, if we allow an attacker to open a
4429 // popup to about:blank, then navigate, focusing the Omnibox will cause the
4430 // end of the new URL to be scrolled into view instead of the start,
4431 // allowing the attacker to spoof other URLs. The conditions checked here
4432 // are all aimed at ensuring no such attacker-controlled navigation can
4433 // trigger this.
4434 should_focus_location_bar_by_default_ =
4435 controller_.IsInitialNavigation() &&
4436 !navigation_handle->IsRendererInitiated() &&
4437 navigation_handle->GetURL() == url::kAboutBlankURL;
4438 }
clamy0e119882015-07-31 16:12:334439}
4440
4441void WebContentsImpl::DidRedirectNavigation(
4442 NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484443 TRACE_EVENT1("navigation", "WebContentsImpl::DidRedirectNavigation",
4444 "navigation_handle", navigation_handle);
ericwilligersde386342016-10-19 02:35:094445 for (auto& observer : observers_)
4446 observer.DidRedirectNavigation(navigation_handle);
jam5f358e52017-02-13 16:37:034447
4448 // Notify accessibility if this is a reload. This has to called on the
4449 // BrowserAccessibilityManager associated with the old RFHI.
4450 if (navigation_handle->GetReloadType() != ReloadType::NONE) {
Mohamed Abdelhalim95794962019-09-20 11:16:494451 NavigationRequest* request = NavigationRequest::From(navigation_handle);
jam5f358e52017-02-13 16:37:034452 BrowserAccessibilityManager* manager =
Mohamed Abdelhalim95794962019-09-20 11:16:494453 request->frame_tree_node()
jam5f358e52017-02-13 16:37:034454 ->current_frame_host()
4455 ->browser_accessibility_manager();
4456 if (manager)
4457 manager->UserIsReloading();
4458 }
clamy0e119882015-07-31 16:12:334459}
4460
clamyefca29e2015-09-17 00:22:114461void WebContentsImpl::ReadyToCommitNavigation(
4462 NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484463 TRACE_EVENT1("navigation", "WebContentsImpl::ReadyToCommitNavigation",
4464 "navigation_handle", navigation_handle);
ericwilligersde386342016-10-19 02:35:094465 for (auto& observer : observers_)
4466 observer.ReadyToCommitNavigation(navigation_handle);
John Abd-El-Malekd4882642017-12-04 21:45:194467
Kenneth Russell954ed9ce2018-04-12 23:07:014468 // If any domains are blocked from accessing 3D APIs because they may
4469 // have caused the GPU to reset recently, unblock them here if the user
4470 // initiated this navigation. This implies that the user was involved in
4471 // the decision to navigate, so there's no concern about
4472 // denial-of-service issues. Want to do this as early as
4473 // possible to avoid race conditions with pages attempting to access
4474 // WebGL early on.
4475 //
4476 // TODO(crbug.com/617904): currently navigations initiated by the browser
4477 // (reload button, reload menu option, pressing return in the Omnibox)
4478 // return false from HasUserGesture(). If or when that is addressed,
4479 // remove the check for IsRendererInitiated() below.
4480 //
4481 // TODO(crbug.com/832180): HasUserGesture comes from the renderer
4482 // process and isn't validated. Until it is, don't trust it.
4483 if (!navigation_handle->IsRendererInitiated()) {
4484 GpuDataManagerImpl::GetInstance()->UnblockDomainFrom3DAPIs(
4485 navigation_handle->GetURL());
4486 }
4487
John Abd-El-Malekfde08e6da2017-12-05 04:06:244488 if (navigation_handle->IsSameDocument())
4489 return;
4490
Livvie Lin139bf442018-08-10 00:18:544491 // SSLInfo is not needed on subframe navigations since the main-frame
4492 // certificate is the only one that can be inspected (using the info
4493 // bubble) without refreshing the page with DevTools open.
Carlos ILaed1e7b2019-03-12 19:27:214494 // We don't call DidStartResourceResponse on net errors, since that results on
4495 // existing cert exceptions being revoked, which leads to weird behavior with
4496 // committed interstitials or while offline. We only need the error check for
4497 // the main frame case because unlike this method, SubresourceResponseStarted
4498 // does not get called on network errors.
4499 if (navigation_handle->IsInMainFrame() &&
4500 navigation_handle->GetNetErrorCode() == net::OK) {
Livvie Lin139bf442018-08-10 00:18:544501 controller_.ssl_manager()->DidStartResourceResponse(
Lukasz Anforowiczd334bba2020-02-10 23:32:554502 navigation_handle->GetURL(),
Camille Lamy62b826012019-02-26 09:15:474503 navigation_handle->GetSSLInfo().has_value()
4504 ? net::IsCertStatusError(
4505 navigation_handle->GetSSLInfo()->cert_status)
4506 : false);
4507 }
John Abd-El-Malekfde08e6da2017-12-05 04:06:244508
4509 SetNotWaitingForResponse();
clamyefca29e2015-09-17 00:22:114510}
4511
clamy0e119882015-07-31 16:12:334512void WebContentsImpl::DidFinishNavigation(NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484513 TRACE_EVENT1("navigation", "WebContentsImpl::DidFinishNavigation",
4514 "navigation_handle", navigation_handle);
Steven Holte38041342018-06-22 22:00:574515
ericwilligersde386342016-10-19 02:35:094516 for (auto& observer : observers_)
4517 observer.DidFinishNavigation(navigation_handle);
clamy0e119882015-07-31 16:12:334518
Becca Hughesd11d6502018-07-31 17:01:284519 if (display_cutout_host_impl_)
4520 display_cutout_host_impl_->DidFinishNavigation(navigation_handle);
4521
jam5f358e52017-02-13 16:37:034522 if (navigation_handle->HasCommitted()) {
Ian Prestcdd843d2020-01-28 18:59:584523 // TODO(domfarolino, dmazzoni): Do this using WebContentsObserver. See
4524 // https://crbug.com/981271.
4525 BrowserAccessibilityManager* manager =
4526 static_cast<RenderFrameHostImpl*>(
4527 navigation_handle->GetRenderFrameHost())
4528 ->browser_accessibility_manager();
4529 if (manager) {
4530 if (navigation_handle->IsErrorPage()) {
4531 manager->NavigationFailed();
4532 } else {
4533 manager->NavigationSucceeded();
4534 }
4535 }
4536
Yue Ru Sun979c4b162019-11-06 16:11:044537 if (navigation_handle->IsInMainFrame()) {
4538 last_committed_source_id_including_same_document_ =
Steven Holte38041342018-06-22 22:00:574539 ukm::ConvertToSourceId(navigation_handle->GetNavigationId(),
4540 ukm::SourceIdType::NAVIGATION_ID);
Yue Ru Sun979c4b162019-11-06 16:11:044541
4542 if (!navigation_handle->IsSameDocument()) {
4543 was_ever_audible_ = false;
4544 last_committed_source_id_ =
4545 last_committed_source_id_including_same_document_;
4546 }
Tommy Steimel18360512017-11-01 00:38:194547 }
Lan Weif81c6e7c2020-02-12 16:46:094548
4549 if (!navigation_handle->IsSameDocument())
4550 last_screen_orientation_change_time_ = base::TimeTicks();
dmazzonibf8cec42015-02-08 08:28:084551 }
Xiyuan Xia2a66b112018-12-06 15:52:164552
4553 // If we didn't end up on about:blank after setting this in DidStartNavigation
4554 // then don't focus the location bar.
4555 if (should_focus_location_bar_by_default_ &&
4556 navigation_handle->GetURL() != url::kAboutBlankURL) {
4557 should_focus_location_bar_by_default_ = false;
4558 }
yilkal796e89e2019-10-02 23:58:284559
yilkal172da772019-11-06 22:49:074560 if (navigation_handle->IsInMainFrame() && first_navigation_completed_)
4561 RecordMaxFrameCountUMA(max_loaded_frame_count_);
yilkal796e89e2019-10-02 23:58:284562
yilkal172da772019-11-06 22:49:074563 // If navigation has successfully finished in the main frame, set
4564 // |first_navigation_completed_| to true so that we will record
4565 // |max_loaded_frame_count_| above when future main frame navigations finish.
4566 if (navigation_handle->IsInMainFrame() && !navigation_handle->IsErrorPage()) {
4567 first_navigation_completed_ = true;
4568
4569 // Navigation has completed in main frame. Reset |max_loaded_frame_count_|.
4570 // |max_loaded_frame_count_| is not necessarily 1 if the navigation was
4571 // served from BackForwardCache.
4572 max_loaded_frame_count_ =
4573 GetMainFrame()->frame_tree_node()->GetFrameTreeSize();
yilkal796e89e2019-10-02 23:58:284574 }
[email protected]400992b2012-06-14 00:03:544575}
4576
[email protected]b80624c2014-02-09 02:46:554577void WebContentsImpl::DidFailLoadWithError(
4578 RenderFrameHostImpl* render_frame_host,
[email protected]b80624c2014-02-09 02:46:554579 const GURL& url,
Dave Tapuska924ef3c2020-01-22 18:20:594580 int error_code) {
ericwilligersde386342016-10-19 02:35:094581 for (auto& observer : observers_) {
Dave Tapuska924ef3c2020-01-22 18:20:594582 observer.DidFailLoad(render_frame_host, url, error_code);
ericwilligersde386342016-10-19 02:35:094583 }
[email protected]b80624c2014-02-09 02:46:554584}
4585
[email protected]52913802013-12-10 05:52:184586void WebContentsImpl::NotifyChangedNavigationState(
4587 InvalidateTypes changed_flags) {
4588 NotifyNavigationStateChanged(changed_flags);
4589}
4590
toyoshim0df1d3a2016-09-09 09:52:484591void WebContentsImpl::DidStartNavigationToPendingEntry(const GURL& url,
4592 ReloadType reload_type) {
[email protected]3691e5cf2014-01-22 10:16:204593 // Notify observers about navigation.
ericwilligersde386342016-10-19 02:35:094594 for (auto& observer : observers_)
4595 observer.DidStartNavigationToPendingEntry(url, reload_type);
[email protected]3691e5cf2014-01-22 10:16:204596}
4597
lukasza1d025732016-09-28 21:36:084598bool WebContentsImpl::ShouldTransferNavigation(bool is_main_frame_navigation) {
creis29460272015-12-16 04:38:224599 if (!delegate_)
4600 return true;
lukasza1d025732016-09-28 21:36:084601 return delegate_->ShouldTransferNavigation(is_main_frame_navigation);
creis29460272015-12-16 04:38:224602}
4603
[email protected]aa62afd2014-04-22 19:22:464604bool WebContentsImpl::ShouldPreserveAbortedURLs() {
4605 if (!delegate_)
4606 return false;
4607 return delegate_->ShouldPreserveAbortedURLs(this);
4608}
4609
[email protected]0d0f4c492014-04-02 06:42:574610void WebContentsImpl::DidNavigateMainFramePreCommit(
[email protected]5cfbddc2014-06-23 23:52:234611 bool navigation_is_within_page) {
[email protected]0d0f4c492014-04-02 06:42:574612 // Ensure fullscreen mode is exited before committing the navigation to a
4613 // different page. The next page will not start out assuming it is in
4614 // fullscreen mode.
[email protected]5cfbddc2014-06-23 23:52:234615 if (navigation_is_within_page) {
[email protected]dfc39cb2014-04-09 22:58:194616 // No page change? Then, the renderer and browser can remain in fullscreen.
[email protected]0d0f4c492014-04-02 06:42:574617 return;
4618 }
alexmos5dd617d2016-06-07 04:21:154619 if (IsFullscreenForCurrentTab())
bokanece34a82016-01-28 19:49:464620 ExitFullscreen(false);
alexmos5dd617d2016-06-07 04:21:154621 DCHECK(!IsFullscreenForCurrentTab());
Joe Downingc1a57efe2018-05-09 18:23:544622
4623 // Clean up keyboard lock state when navigating.
4624 CancelKeyboardLock(keyboard_lock_widget_);
[email protected]0d0f4c492014-04-02 06:42:574625}
4626
[email protected]37567b432014-02-12 01:12:224627void WebContentsImpl::DidNavigateMainFramePostCommit(
sky8b00392d2015-01-10 00:30:284628 RenderFrameHostImpl* render_frame_host,
[email protected]37567b432014-02-12 01:12:224629 const LoadCommittedDetails& details,
4630 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
4631 if (details.is_navigation_to_different_page()) {
4632 // Clear the status bubble. This is a workaround for a bug where WebKit
4633 // doesn't let us know that the cursor left an element during a
4634 // transition (this is also why the mouse cursor remains as a hand after
4635 // clicking on a link); see bugs 1184641 and 980803. We don't want to
4636 // clear the bubble when a user navigates to a named anchor in the same
4637 // page.
Lukasz Anforowiczfd707142018-02-07 19:46:134638 ClearTargetURL();
lanwei9d343ad22015-02-11 01:46:004639
4640 RenderWidgetHostViewBase* rwhvb =
4641 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
4642 if (rwhvb)
4643 rwhvb->OnDidNavigateMainFrameToNewPage();
[email protected]37567b432014-02-12 01:12:224644 }
4645
[email protected]e85165c642014-06-10 14:34:314646 if (delegate_)
[email protected]37567b432014-02-12 01:12:224647 delegate_->DidNavigateMainFramePostCommit(this);
[email protected]e85165c642014-06-10 14:34:314648 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
Shivani Sharma985474f2019-05-23 21:36:474649
Carlos Caballero91fffb22019-10-29 15:24:304650 if (details.is_navigation_to_different_page() &&
4651 GetRenderViewHost()->did_first_visually_non_empty_paint()) {
4652 // This event will not fire again if the page is restored from the
4653 // BackForwardCache. So fire it ourselves if needed.
4654 DidFirstVisuallyNonEmptyPaint(GetRenderViewHost());
4655 }
Carlos Caballero1215f882019-10-29 15:58:434656
4657 if (GetRenderViewHost()->theme_color() != last_sent_theme_color_) {
4658 // This event will not fire again if the page is restored from the
4659 // BackForwardCache. So fire it ourselves if needed.
4660 OnThemeColorChanged(GetRenderViewHost());
4661 }
[email protected]37567b432014-02-12 01:12:224662}
4663
4664void WebContentsImpl::DidNavigateAnyFramePostCommit(
4665 RenderFrameHostImpl* render_frame_host,
4666 const LoadCommittedDetails& details,
4667 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
[email protected]b4c84012014-04-28 19:51:104668 // Now that something has committed, we don't need to track whether the
4669 // initial page has been accessed.
4670 has_accessed_initial_document_ = false;
4671
[email protected]37567b432014-02-12 01:12:224672 // If we navigate off the page, close all JavaScript dialogs.
eugenebutee08663a2017-04-27 17:43:124673 if (!details.is_same_document)
creis89a0f782015-05-27 16:13:174674 CancelActiveAndPendingDialogs();
[email protected]37567b432014-02-12 01:12:224675
avid53461d2016-02-25 17:15:044676 // If this is a user-initiated navigation, start allowing JavaScript dialogs
4677 // again.
avi5d3b8692016-10-12 22:00:464678 if (params.gesture == NavigationGestureUser && dialog_manager_) {
avi6879fcf2017-01-21 05:27:534679 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:464680 }
[email protected]37567b432014-02-12 01:12:224681}
4682
4683void WebContentsImpl::SetMainFrameMimeType(const std::string& mime_type) {
4684 contents_mime_type_ = mime_type;
4685}
4686
[email protected]277857a2014-06-03 10:38:014687bool WebContentsImpl::CanOverscrollContent() const {
[email protected]e85165c642014-06-10 14:34:314688 // Disable overscroll when touch emulation is on. See crbug.com/369938.
[email protected]34ff1cfc2014-08-20 06:16:054689 if (force_disable_overscroll_content_)
[email protected]e85165c642014-06-10 14:34:314690 return false;
4691
[email protected]37567b432014-02-12 01:12:224692 if (delegate_)
4693 return delegate_->CanOverscrollContent();
4694
4695 return false;
4696}
4697
Carlos Caballero1215f882019-10-29 15:58:434698void WebContentsImpl::OnThemeColorChanged(RenderViewHostImpl* source) {
4699 if (source->did_first_visually_non_empty_paint() &&
4700 last_sent_theme_color_ != source->theme_color()) {
ericwilligersde386342016-10-19 02:35:094701 for (auto& observer : observers_)
Peter Kastingb14e5782020-01-06 23:55:044702 observer.DidChangeThemeColor();
Carlos Caballero1215f882019-10-29 15:58:434703 last_sent_theme_color_ = source->theme_color();
peter90afaba2015-06-01 12:05:294704 }
[email protected]e7104762014-06-20 19:17:254705}
4706
[email protected]b172aee2012-04-10 17:05:264707void WebContentsImpl::OnDidLoadResourceFromMemoryCache(
nicka0ac8382016-12-15 23:59:234708 RenderFrameHostImpl* source,
[email protected]724159a2010-12-30 01:11:184709 const GURL& url,
[email protected]70435962011-08-02 20:13:284710 const std::string& http_method,
[email protected]6d6cfb3a2012-05-23 22:53:184711 const std::string& mime_type,
Kinuko Yasuda433f710a2020-02-14 02:11:584712 network::mojom::RequestDestination request_destination) {
ericwilligersde386342016-10-19 02:35:094713 for (auto& observer : observers_)
Kinuko Yasuda433f710a2020-02-14 02:11:584714 observer.DidLoadResourceFromMemoryCache(url, mime_type,
4715 request_destination);
[email protected]b0f724c2013-09-05 04:21:134716
Steven Bingler674fb0822018-12-12 18:04:524717 if (url.is_valid() && url.SchemeIsHTTPOrHTTPS()) {
nicka0ac8382016-12-15 23:59:234718 StoragePartition* partition = source->GetProcess()->GetStoragePartition();
John Abd-El-Malekf4fe9d82019-07-31 04:05:594719 partition->GetNetworkContext()->NotifyExternalCacheHit(
Matt Menke2a33dee2019-12-02 17:01:544720 url, http_method, source->GetNetworkIsolationKey());
[email protected]8bfc8272013-09-09 20:10:534721 }
[email protected]724159a2010-12-30 01:11:184722}
4723
carloskd9d97942017-02-16 08:58:094724void WebContentsImpl::DidDisplayInsecureContent() {
estarkc2273502016-10-12 22:03:024725 controller_.ssl_manager()->DidDisplayMixedContent();
[email protected]724159a2010-12-30 01:11:184726}
4727
Dave Tapuskaa657d872019-10-21 20:23:214728void WebContentsImpl::DidContainInsecureFormAction() {
elawrenceb2ac2a232017-03-27 21:46:254729 controller_.ssl_manager()->DidContainInsecureFormAction();
4730}
4731
Julie Jeongeun Kim0b103492020-01-29 05:30:514732void WebContentsImpl::DocumentAvailableInMainFrame() {
4733 for (auto& observer : observers_)
4734 observer.DocumentAvailableInMainFrame();
4735}
4736
nicka0ac8382016-12-15 23:59:234737void WebContentsImpl::OnDidRunInsecureContent(RenderFrameHostImpl* source,
4738 const GURL& security_origin,
estark910b4572015-12-09 20:55:414739 const GURL& target_url) {
nicka0ac8382016-12-15 23:59:234740 // TODO(nick, estark): Should we call FilterURL using |source|'s process on
4741 // these parameters? |target_url| seems unused, except for a log message. And
4742 // |security_origin| might be replaceable with the origin of the main frame.
carloskd9d97942017-02-16 08:58:094743 DidRunInsecureContent(security_origin, target_url);
4744}
4745
4746void WebContentsImpl::DidRunInsecureContent(const GURL& security_origin,
4747 const GURL& target_url) {
[email protected]9450c462013-11-23 01:22:584748 LOG(WARNING) << security_origin << " ran insecure content from "
4749 << target_url.possibly_invalid_spec();
[email protected]e6e30ac2014-01-13 21:24:394750 RecordAction(base::UserMetricsAction("SSL.RanInsecureContent"));
estark910b4572015-12-09 20:55:414751 if (base::EndsWith(security_origin.spec(), kDotGoogleDotCom,
brettwa7ff1b292015-07-16 17:49:294752 base::CompareCase::INSENSITIVE_ASCII))
[email protected]e6e30ac2014-01-13 21:24:394753 RecordAction(base::UserMetricsAction("SSL.RanInsecureContentGoogle"));
estarkc2273502016-10-12 22:03:024754 controller_.ssl_manager()->DidRunMixedContent(security_origin);
[email protected]724159a2010-12-30 01:11:184755}
4756
carloskd9d97942017-02-16 08:58:094757void WebContentsImpl::PassiveInsecureContentFound(const GURL& resource_url) {
Sergey Kuznetsov3ebc01b2018-02-01 04:57:364758 if (delegate_) {
4759 delegate_->PassiveInsecureContentFound(resource_url);
4760 }
carloskd9d97942017-02-16 08:58:094761}
4762
4763bool WebContentsImpl::ShouldAllowRunningInsecureContent(
4764 WebContents* web_contents,
4765 bool allowed_per_prefs,
4766 const url::Origin& origin,
4767 const GURL& resource_url) {
Sergey Kuznetsov3ebc01b2018-02-01 04:57:364768 if (delegate_) {
4769 return delegate_->ShouldAllowRunningInsecureContent(
4770 web_contents, allowed_per_prefs, origin, resource_url);
4771 }
4772
4773 return allowed_per_prefs;
carloskd9d97942017-02-16 08:58:094774}
4775
Lukasz Anforowicze1b954d92017-10-30 21:28:064776void WebContentsImpl::ViewSource(RenderFrameHostImpl* frame) {
4777 DCHECK_EQ(this, WebContents::FromRenderFrameHost(frame));
4778
4779 // Don't do anything if there is no |delegate_| that could accept and show the
4780 // new WebContents containing the view-source.
4781 if (!delegate_)
4782 return;
4783
4784 // Use the last committed entry, since the pending entry hasn't loaded yet and
4785 // won't be copied into the cloned tab.
4786 NavigationEntryImpl* last_committed_entry =
4787 static_cast<NavigationEntryImpl*>(frame->frame_tree_node()
4788 ->navigator()
4789 ->GetController()
4790 ->GetLastCommittedEntry());
4791 if (!last_committed_entry)
4792 return;
4793
4794 FrameNavigationEntry* frame_entry =
4795 last_committed_entry->GetFrameEntry(frame->frame_tree_node());
4796 if (!frame_entry)
4797 return;
4798
4799 // Any new WebContents opened while this WebContents is in fullscreen can be
4800 // used to confuse the user, so drop fullscreen.
Avi Drissman1a55a9d62020-03-10 18:56:454801 base::ScopedClosureRunner fullscreen_block = ForSecurityDropFullscreen();
4802 // The new view source contents will be independent of this contents, so
4803 // release the fullscreen block.
4804 fullscreen_block.RunAndReset();
Lukasz Anforowicze1b954d92017-10-30 21:28:064805
4806 // We intentionally don't share the SiteInstance with the original frame so
4807 // that view source has a consistent process model and always ends up in a new
4808 // process (https://crbug.com/699493).
4809 scoped_refptr<SiteInstanceImpl> site_instance_for_view_source = nullptr;
Lukasz Anforowicz435bcb582019-07-12 20:50:064810 // Referrer and initiator are not important, because view-source should not
4811 // hit the network, but should be served from the cache instead.
Lukasz Anforowicze1b954d92017-10-30 21:28:064812 Referrer referrer_for_view_source;
Lukasz Anforowicz435bcb582019-07-12 20:50:064813 base::Optional<url::Origin> initiator_for_view_source = base::nullopt;
Lukasz Anforowicze1b954d92017-10-30 21:28:064814 // Do not restore title, derive it from the url.
4815 base::string16 title_for_view_source;
4816 auto navigation_entry = std::make_unique<NavigationEntryImpl>(
4817 site_instance_for_view_source, frame_entry->url(),
Lukasz Anforowicz435bcb582019-07-12 20:50:064818 referrer_for_view_source, initiator_for_view_source,
4819 title_for_view_source, ui::PAGE_TRANSITION_LINK,
Marijn Kruisselbrink7a0d5e182018-05-24 22:55:094820 /* is_renderer_initiated = */ false,
4821 /* blob_url_loader_factory = */ nullptr);
Lukasz Anforowicze1b954d92017-10-30 21:28:064822 navigation_entry->SetVirtualURL(GURL(content::kViewSourceScheme +
4823 std::string(":") +
4824 frame_entry->url().spec()));
4825
Matt Menke2a33dee2019-12-02 17:01:544826 navigation_entry->set_network_isolation_key(frame->GetNetworkIsolationKey());
Yao Xiaof68f57d2019-10-03 04:20:054827
Lukasz Anforowicze1b954d92017-10-30 21:28:064828 // Do not restore scroller position.
4829 // TODO(creis, lukasza, arthursonzogni): Do not reuse the original PageState,
4830 // but start from a new one and only copy the needed data.
4831 const PageState& new_page_state =
4832 frame_entry->page_state().RemoveScrollOffset();
4833
4834 scoped_refptr<FrameNavigationEntry> new_frame_entry =
4835 navigation_entry->root_node()->frame_entry;
4836 new_frame_entry->set_method(frame_entry->method());
4837 new_frame_entry->SetPageState(new_page_state);
4838
4839 // Create a new WebContents, which is used to display the source code.
erikchenbee5c9622018-04-27 19:30:254840 std::unique_ptr<WebContents> view_source_contents =
Erik Chenbb8e738e2018-04-28 14:10:434841 Create(CreateParams(GetBrowserContext()));
Lukasz Anforowicze1b954d92017-10-30 21:28:064842
4843 // Restore the previously created NavigationEntry.
4844 std::vector<std::unique_ptr<NavigationEntry>> navigation_entries;
4845 navigation_entries.push_back(std::move(navigation_entry));
4846 view_source_contents->GetController().Restore(0, RestoreType::CURRENT_SESSION,
4847 &navigation_entries);
4848
4849 // Add |view_source_contents| as a new tab.
4850 gfx::Rect initial_rect;
4851 constexpr bool kUserGesture = true;
4852 bool ignored_was_blocked;
erikchenbee5c9622018-04-27 19:30:254853 delegate_->AddNewContents(this, std::move(view_source_contents),
Lukasz Anforowicze1b954d92017-10-30 21:28:064854 WindowOpenDisposition::NEW_FOREGROUND_TAB,
4855 initial_rect, kUserGesture, &ignored_was_blocked);
4856 // Note that the |delegate_| could have deleted |view_source_contents| during
4857 // AddNewContents method call.
4858}
4859
Lukasz Anforowiczd334bba2020-02-10 23:32:554860void WebContentsImpl::SubresourceResponseStarted(const GURL& url,
4861 net::CertStatus cert_status) {
4862 controller_.ssl_manager()->DidStartResourceResponse(url, cert_status);
Jay Civellid5904f02018-03-23 19:43:574863 SetNotWaitingForResponse();
4864}
4865
Jay Civelli116683f2018-03-27 19:56:234866void WebContentsImpl::ResourceLoadComplete(
Jay Civelli52a63302018-04-30 22:39:554867 RenderFrameHost* render_frame_host,
Clark DuVall36164bd2018-08-09 22:49:084868 const GlobalRequestID& request_id,
Minggang Wangee5af392020-02-05 02:55:284869 blink::mojom::ResourceLoadInfoPtr resource_load_info) {
John Abd-El-Malek9b8f7fa2017-12-04 23:52:254870 for (auto& observer : observers_) {
Clark DuVall36164bd2018-08-09 22:49:084871 observer.ResourceLoadComplete(render_frame_host, request_id,
4872 *resource_load_info);
John Abd-El-Malek9b8f7fa2017-12-04 23:52:254873 }
John Abd-El-Malekd4882642017-12-04 21:45:194874}
4875
Wei Li5bb659742018-02-14 03:07:584876void WebContentsImpl::PrintCrossProcessSubframe(
4877 const gfx::Rect& rect,
4878 int document_cookie,
4879 RenderFrameHost* subframe_host) {
Wei Li5c0b4d12018-03-22 15:05:224880 auto* outer_contents = GetOuterWebContents();
4881 if (outer_contents) {
4882 // When an extension or app page is printed, the content should be
4883 // composited with outer content, so the outer contents should handle the
4884 // print request.
4885 outer_contents->PrintCrossProcessSubframe(rect, document_cookie,
4886 subframe_host);
4887 return;
4888 }
4889
Wei Li5bb659742018-02-14 03:07:584890 // If there is no delegate such as in tests or during deletion, do nothing.
4891 if (!delegate_)
4892 return;
4893
4894 delegate_->PrintCrossProcessSubframe(this, rect, document_cookie,
4895 subframe_host);
4896}
4897
ckitagawa8695799b2020-02-05 16:08:494898void WebContentsImpl::CapturePaintPreviewOfCrossProcessSubframe(
4899 const gfx::Rect& rect,
4900 const base::UnguessableToken& guid,
4901 RenderFrameHost* render_frame_host) {
4902 if (!delegate_)
4903 return;
4904 delegate_->CapturePaintPreviewOfCrossProcessSubframe(this, rect, guid,
4905 render_frame_host);
4906}
4907
rob.buis300b0872017-03-10 20:43:584908#if defined(OS_ANDROID)
4909base::android::ScopedJavaLocalRef<jobject>
4910WebContentsImpl::GetJavaRenderFrameHostDelegate() {
4911 return GetJavaWebContents();
4912}
4913#endif
4914
estark910b4572015-12-09 20:55:414915void WebContentsImpl::OnDidDisplayContentWithCertificateErrors(
Zhuoyu Qian4353f7f2018-01-08 05:33:004916 RenderFrameHostImpl* source) {
estarkc2273502016-10-12 22:03:024917 controller_.ssl_manager()->DidDisplayContentWithCertErrors();
estark910b4572015-12-09 20:55:414918}
4919
4920void WebContentsImpl::OnDidRunContentWithCertificateErrors(
Zhuoyu Qian4353f7f2018-01-08 05:33:004921 RenderFrameHostImpl* source) {
nicka0ac8382016-12-15 23:59:234922 // TODO(nick, estark): Do we need to consider |source| here somehow?
estarkcd2e30c2016-08-12 06:51:154923 NavigationEntry* entry = controller_.GetVisibleEntry();
4924 if (!entry)
estarkaeda1422016-05-10 02:31:124925 return;
4926
estarkaeda1422016-05-10 02:31:124927 // TODO(estark): check that this does something reasonable for
4928 // about:blank and sandboxed origins. https://crbug.com/609527
estarkcd2e30c2016-08-12 06:51:154929 controller_.ssl_manager()->DidRunContentWithCertErrors(
4930 entry->GetURL().GetOrigin());
estark910b4572015-12-09 20:55:414931}
4932
Kouhei Ueno97e0990d2019-09-25 02:57:274933void WebContentsImpl::DOMContentLoaded(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:094934 for (auto& observer : observers_)
Kouhei Uenof6e96242019-09-27 01:54:354935 observer.DOMContentLoaded(render_frame_host);
[email protected]724159a2010-12-30 01:11:184936}
4937
Gyuyoung Kim525e0c5d2020-03-09 15:04:194938void WebContentsImpl::OnDidFinishLoad(RenderFrameHost* render_frame_host,
nicka0ac8382016-12-15 23:59:234939 const GURL& url) {
[email protected]8b3af1e2014-01-24 13:29:124940 GURL validated_url(url);
Gyuyoung Kim525e0c5d2020-03-09 15:04:194941 render_frame_host->GetProcess()->FilterURL(false, &validated_url);
[email protected]028053d42014-03-05 22:20:374942
ericwilligersde386342016-10-19 02:35:094943 for (auto& observer : observers_)
Gyuyoung Kim525e0c5d2020-03-09 15:04:194944 observer.DidFinishLoad(render_frame_host, validated_url);
yilkal172da772019-11-06 22:49:074945
4946 size_t tree_size = frame_tree_.root()->GetFrameTreeSize();
4947 if (max_loaded_frame_count_ < tree_size)
4948 max_loaded_frame_count_ = tree_size;
4949
Gyuyoung Kim525e0c5d2020-03-09 15:04:194950 if (!render_frame_host->GetParent())
yilkal172da772019-11-06 22:49:074951 UMA_HISTOGRAM_COUNTS_1000("Navigation.MainFrame.FrameCount", tree_size);
[email protected]1a55c5be2011-11-29 11:36:314952}
4953
Dave Tapuska549baab2019-03-19 15:52:404954void WebContentsImpl::OnGoToEntryAtOffset(RenderFrameHostImpl* source,
Julie Jeongeun Kim144f8192020-01-18 06:59:034955 int32_t offset,
Dave Tapuska043b94a2019-09-10 14:14:354956 bool has_user_gesture) {
Arthur Sonzognia7d715a2018-09-20 16:11:134957 // Non-user initiated navigations coming from the renderer should be ignored
4958 // if there is an ongoing browser-initiated navigation.
4959 // See https://crbug.com/879965.
4960 // TODO(arthursonzogni): See if this should check for ongoing navigations in
4961 // the frame(s) affected by the session history navigation, rather than just
4962 // the main frame.
4963 if (!has_user_gesture) {
4964 NavigationRequest* ongoing_navigation_request =
4965 frame_tree_.root()->navigation_request();
4966 if (ongoing_navigation_request &&
4967 ongoing_navigation_request->browser_initiated()) {
4968 return;
4969 }
4970 }
4971
nicka0ac8382016-12-15 23:59:234972 // All frames are allowed to navigate the global history.
Dave Tapuska8bfd84c2019-03-26 20:47:164973 if (!delegate_ || delegate_->OnGoToEntryOffset(offset)) {
Antonio Gomes7096ac02020-02-14 14:29:544974 if (source->IsSandboxed(blink::mojom::WebSandboxFlags::kTopNavigation)) {
Dave Tapuska8bfd84c2019-03-26 20:47:164975 // Keep track of whether this is a session history from a sandboxed iframe
4976 // with top level navigation disallowed.
4977 controller_.GoToOffsetInSandboxedFrame(offset,
4978 source->GetFrameTreeNodeId());
4979 } else {
4980 controller_.GoToOffset(offset);
4981 }
4982 }
[email protected]216813952011-05-19 22:21:264983}
4984
Dave Tapuska4c02911b2020-02-14 22:52:074985void WebContentsImpl::OnPageScaleFactorChanged(RenderFrameHostImpl* source,
nicka0ac8382016-12-15 23:59:234986 float page_scale_factor) {
mcnee336ea2c2017-05-23 22:50:594987#if !defined(OS_ANDROID)
4988 // While page scale factor is used on mobile, this PageScaleFactorIsOne logic
4989 // is only needed on desktop.
mcnee432e47d2015-11-09 19:37:464990 bool is_one = page_scale_factor == 1.f;
4991 if (is_one != page_scale_factor_is_one_) {
4992 page_scale_factor_is_one_ = is_one;
4993
4994 HostZoomMapImpl* host_zoom_map =
4995 static_cast<HostZoomMapImpl*>(HostZoomMap::GetForWebContents(this));
4996
nicka0ac8382016-12-15 23:59:234997 if (host_zoom_map) {
mcnee432e47d2015-11-09 19:37:464998 host_zoom_map->SetPageScaleFactorIsOneForView(
Dave Tapuska4c02911b2020-02-14 22:52:074999 source->GetProcess()->GetID(),
5000 source->GetRenderViewHost()->GetRoutingID(),
mcnee432e47d2015-11-09 19:37:465001 page_scale_factor_is_one_);
5002 }
5003 }
mcnee336ea2c2017-05-23 22:50:595004#endif // !defined(OS_ANDROID)
mcnee432e47d2015-11-09 19:37:465005
ericwilligersde386342016-10-19 02:35:095006 for (auto& observer : observers_)
5007 observer.OnPageScaleFactorChanged(page_scale_factor);
mcnee432e47d2015-11-09 19:37:465008}
5009
W. James MacLean62198672019-06-04 16:46:105010void WebContentsImpl::OnTextAutosizerPageInfoChanged(
5011 RenderViewHostImpl* source,
5012 const blink::WebTextAutosizerPageInfo& page_info) {
5013 // Keep a copy of |page_info| in case we create a new RenderView before
5014 // the next update.
5015 text_autosizer_page_info_ = page_info;
5016 frame_tree_.root()->render_manager()->SendPageMessage(
5017 new PageMsg_UpdateTextAutosizerPageInfoForRemoteMainFrames(
5018 MSG_ROUTING_NONE, page_info),
5019 source->GetSiteInstance());
5020}
5021
Kent Tamura8c9e0562018-11-06 07:02:195022void WebContentsImpl::EnumerateDirectory(
5023 RenderFrameHost* render_frame_host,
Avi Drissman1a55a9d62020-03-10 18:56:455024 std::unique_ptr<FileChooserImpl::FileSelectListenerImpl> listener,
Kent Tamura8c9e0562018-11-06 07:02:195025 const base::FilePath& directory_path) {
Avi Drissman1a55a9d62020-03-10 18:56:455026 // Any explicit focusing of another window while this WebContents is in
5027 // fullscreen can be used to confuse the user, so drop fullscreen.
5028 base::ScopedClosureRunner fullscreen_block = ForSecurityDropFullscreen();
5029 listener->SetFullscreenBlock(std::move(fullscreen_block));
5030
Kent Tamura8c9e0562018-11-06 07:02:195031 if (delegate_)
5032 delegate_->EnumerateDirectory(this, std::move(listener), directory_path);
5033 else
5034 listener->FileSelectionCanceled();
[email protected]3a29a6e2011-08-24 18:26:215035}
5036
Dave Tapuskaf9fc3122019-10-18 19:42:555037void WebContentsImpl::RegisterProtocolHandler(RenderFrameHostImpl* source,
5038 const std::string& protocol,
5039 const GURL& url,
5040 const base::string16& title,
5041 bool user_gesture) {
nicka0ac8382016-12-15 23:59:235042 // TODO(nick): Should we consider |source| here or pass it to the delegate?
5043 // TODO(nick): Do we need to apply FilterURL to |url|?
[email protected]e5f2de02012-07-20 22:15:435044 if (!delegate_)
5045 return;
5046
Raymes Khoury58373df2019-08-06 06:29:205047 if (!AreValidRegisterProtocolHandlerArguments(
5048 protocol, url, source->GetLastCommittedOrigin())) {
5049 ReceivedBadMessage(source->GetProcess(),
5050 bad_message::REGISTER_PROTOCOL_HANDLER_INVALID_URL);
[email protected]b9535422012-02-09 01:47:595051 return;
Raymes Khoury58373df2019-08-06 06:29:205052 }
[email protected]8f810632013-06-06 22:33:325053
[email protected]c125e532014-05-10 20:39:065054 delegate_->RegisterProtocolHandler(this, protocol, url, user_gesture);
[email protected]7d189022011-08-25 22:54:205055}
5056
Dave Tapuskaf9fc3122019-10-18 19:42:555057void WebContentsImpl::UnregisterProtocolHandler(RenderFrameHostImpl* source,
5058 const std::string& protocol,
5059 const GURL& url,
5060 bool user_gesture) {
nicka0ac8382016-12-15 23:59:235061 // TODO(nick): Should we consider |source| here or pass it to the delegate?
5062 // TODO(nick): Do we need to apply FilterURL to |url|?
[email protected]f5273e52014-07-14 16:30:205063 if (!delegate_)
5064 return;
5065
Raymes Khoury58373df2019-08-06 06:29:205066 if (!AreValidRegisterProtocolHandlerArguments(
5067 protocol, url, source->GetLastCommittedOrigin())) {
5068 ReceivedBadMessage(source->GetProcess(),
5069 bad_message::REGISTER_PROTOCOL_HANDLER_INVALID_URL);
[email protected]f5273e52014-07-14 16:30:205070 return;
Raymes Khoury58373df2019-08-06 06:29:205071 }
[email protected]f5273e52014-07-14 16:30:205072
5073 delegate_->UnregisterProtocolHandler(this, protocol, url, user_gesture);
5074}
5075
nicka0ac8382016-12-15 23:59:235076void WebContentsImpl::OnDomOperationResponse(RenderFrameHostImpl* source,
5077 const std::string& json_string) {
5078 // TODO(nick, lukasza): The notification below should probably be updated to
5079 // include |source|.
avi60bd4902015-09-23 20:39:245080 std::string json = json_string;
5081 NotificationService::current()->Notify(NOTIFICATION_DOM_OPERATION_RESPONSE,
5082 Source<WebContents>(this),
5083 Details<std::string>(&json));
[email protected]cfa856d62014-02-22 07:58:405084}
5085
Marijn Kruisselbrink7f519672019-02-05 19:12:505086void WebContentsImpl::OnAppCacheAccessed(const GURL& manifest_url,
[email protected]b172aee2012-04-10 17:05:265087 bool blocked_by_policy) {
nicka0ac8382016-12-15 23:59:235088 // TODO(nick): Should we consider |source| here? Should we call FilterURL on
5089 // |manifest_url|?
5090
[email protected]7fc4bbb2011-09-08 21:23:105091 // Notify observers about navigation.
ericwilligersde386342016-10-19 02:35:095092 for (auto& observer : observers_)
5093 observer.AppCacheAccessed(manifest_url, blocked_by_policy);
[email protected]7fc4bbb2011-09-08 21:23:105094}
5095
Miyoung Shincb6475a2019-11-09 10:49:455096void WebContentsImpl::OnColorChooserFactoryReceiver(
Julie Jeongeun Kim8e2879e2019-08-06 23:55:205097 mojo::PendingReceiver<blink::mojom::ColorChooserFactory> receiver) {
5098 color_chooser_factory_receivers_.Add(this, std::move(receiver));
Joel Hockey85b379d2017-12-11 10:42:135099}
5100
5101void WebContentsImpl::OpenColorChooser(
Julie Jeongeun Kim8e2879e2019-08-06 23:55:205102 mojo::PendingReceiver<blink::mojom::ColorChooser> chooser_receiver,
5103 mojo::PendingRemote<blink::mojom::ColorChooserClient> client,
[email protected]8ed16472014-04-11 19:02:485104 SkColor color,
Joel Hockey163835a2017-12-20 11:51:575105 std::vector<blink::mojom::ColorSuggestionPtr> suggestions) {
Joel Hockey85b379d2017-12-11 10:42:135106 content::ColorChooser* new_color_chooser =
Ivan Kotenkov2c0d2bb32017-11-01 15:41:285107 delegate_ ? delegate_->OpenColorChooser(this, color, suggestions)
5108 : nullptr;
[email protected]820957a2014-01-14 14:56:305109 if (!new_color_chooser)
[email protected]cb805452013-05-22 15:16:215110 return;
[email protected]8ed16472014-04-11 19:02:485111
Joel Hockey85b379d2017-12-11 10:42:135112 color_chooser_.reset();
5113 color_chooser_ = std::make_unique<ColorChooser>(
Julie Jeongeun Kim8e2879e2019-08-06 23:55:205114 new_color_chooser, std::move(chooser_receiver), std::move(client));
[email protected]da8543762012-03-20 08:52:205115}
5116
brettw4b461082016-11-19 18:55:165117#if BUILDFLAG(ENABLE_PLUGINS)
nicka0ac8382016-12-15 23:59:235118void WebContentsImpl::OnPepperInstanceCreated(RenderFrameHostImpl* source,
5119 int32_t pp_instance) {
ericwilligersde386342016-10-19 02:35:095120 for (auto& observer : observers_)
5121 observer.PepperInstanceCreated();
nicka0ac8382016-12-15 23:59:235122 pepper_playback_observer_->PepperInstanceCreated(source, pp_instance);
emaxxe70f5e12015-05-29 11:26:005123}
5124
nicka0ac8382016-12-15 23:59:235125void WebContentsImpl::OnPepperInstanceDeleted(RenderFrameHostImpl* source,
5126 int32_t pp_instance) {
ericwilligersde386342016-10-19 02:35:095127 for (auto& observer : observers_)
5128 observer.PepperInstanceDeleted();
nicka0ac8382016-12-15 23:59:235129 pepper_playback_observer_->PepperInstanceDeleted(source, pp_instance);
emaxxe70f5e12015-05-29 11:26:005130}
5131
nicka0ac8382016-12-15 23:59:235132void WebContentsImpl::OnPepperPluginHung(RenderFrameHostImpl* source,
5133 int plugin_child_id,
tommyclie6633ca72014-10-31 00:40:425134 const base::FilePath& path,
5135 bool is_hung) {
Steven Holte95922222018-09-14 20:06:235136 UMA_HISTOGRAM_COUNTS_1M("Pepper.PluginHung", 1);
tommyclie6633ca72014-10-31 00:40:425137
ericwilligersde386342016-10-19 02:35:095138 for (auto& observer : observers_)
5139 observer.PluginHungStatusChanged(plugin_child_id, path, is_hung);
tommyclie6633ca72014-10-31 00:40:425140}
5141
nicka0ac8382016-12-15 23:59:235142void WebContentsImpl::OnPepperStartsPlayback(RenderFrameHostImpl* source,
5143 int32_t pp_instance) {
5144 pepper_playback_observer_->PepperStartsPlayback(source, pp_instance);
zqzhang181047e62016-07-01 13:37:175145}
5146
nicka0ac8382016-12-15 23:59:235147void WebContentsImpl::OnPepperStopsPlayback(RenderFrameHostImpl* source,
5148 int32_t pp_instance) {
5149 pepper_playback_observer_->PepperStopsPlayback(source, pp_instance);
zqzhang181047e62016-07-01 13:37:175150}
5151
nicka0ac8382016-12-15 23:59:235152void WebContentsImpl::OnPluginCrashed(RenderFrameHostImpl* source,
5153 const base::FilePath& plugin_path,
tommyclie6633ca72014-10-31 00:40:425154 base::ProcessId plugin_pid) {
nicka0ac8382016-12-15 23:59:235155 // TODO(nick): Eliminate the |plugin_pid| parameter, which can't be trusted,
5156 // and is only used by BlinkTestController.
ericwilligersde386342016-10-19 02:35:095157 for (auto& observer : observers_)
5158 observer.PluginCrashed(plugin_path, plugin_pid);
tommyclie6633ca72014-10-31 00:40:425159}
5160
[email protected]d8415ad92012-08-23 14:40:505161void WebContentsImpl::OnRequestPpapiBrokerPermission(
nicka0ac8382016-12-15 23:59:235162 RenderViewHostImpl* source,
5163 int ppb_broker_route_id,
[email protected]d8415ad92012-08-23 14:40:505164 const GURL& url,
[email protected]2dec8ec2013-02-07 19:20:345165 const base::FilePath& plugin_path) {
Avi Drissman0a2a967d2019-04-01 19:33:525166 base::OnceCallback<void(bool)> permission_result_callback = base::BindOnce(
nicka0ac8382016-12-15 23:59:235167 &WebContentsImpl::SendPpapiBrokerPermissionResult, base::Unretained(this),
5168 source->GetProcess()->GetID(), ppb_broker_route_id);
[email protected]8c8fc292012-11-23 18:57:165169 if (!delegate_) {
Tommy Nyquist4b749d02018-03-20 21:46:295170 std::move(permission_result_callback).Run(false);
[email protected]8c8fc292012-11-23 18:57:165171 return;
[email protected]d8415ad92012-08-23 14:40:505172 }
5173
Avi Drissman0a2a967d2019-04-01 19:33:525174 delegate_->RequestPpapiBrokerPermission(
5175 this, url, plugin_path, std::move(permission_result_callback));
[email protected]d8415ad92012-08-23 14:40:505176}
5177
nicka0ac8382016-12-15 23:59:235178void WebContentsImpl::SendPpapiBrokerPermissionResult(int process_id,
5179 int ppb_broker_route_id,
5180 bool result) {
5181 RenderProcessHost* rph = RenderProcessHost::FromID(process_id);
5182 if (rph) {
5183 // TODO(nick): Convert this from ViewMsg_ to a Ppapi msg, since it
5184 // is not routed to a RenderView.
5185 rph->Send(
5186 new ViewMsg_PpapiBrokerPermissionResult(ppb_broker_route_id, result));
5187 }
[email protected]d8415ad92012-08-23 14:40:505188}
brettw4b461082016-11-19 18:55:165189#endif // BUILDFLAG(ENABLE_PLUGINS)
[email protected]19be7a62012-10-01 23:03:375190
Miyoung Shin5709ab02020-02-19 06:50:415191void WebContentsImpl::UpdateFaviconURL(
5192 RenderFrameHost* source,
5193 std::vector<blink::mojom::FaviconURLPtr> candidates) {
lukasza178ff092017-06-07 23:39:505194 // Ignore favicons for non-main frame.
5195 if (source->GetParent()) {
5196 NOTREACHED();
5197 return;
5198 }
5199
pkotwiczf9bc20592015-04-21 18:57:065200 // We get updated favicon URLs after the page stops loading. If a cross-site
5201 // navigation occurs while a page is still loading, the initial page
5202 // may stop loading and send us updated favicon URLs after the navigation
5203 // for the new page has committed.
lukasza178ff092017-06-07 23:39:505204 if (!source->IsCurrent())
pkotwiczf9bc20592015-04-21 18:57:065205 return;
5206
Miyoung Shin5709ab02020-02-19 06:50:415207 favicon_urls_ = std::move(candidates);
Mounir Lamouri7b4a1f232019-12-23 16:32:105208
ericwilligersde386342016-10-19 02:35:095209 for (auto& observer : observers_)
Miyoung Shin5709ab02020-02-19 06:50:415210 observer.DidUpdateFaviconURL(favicon_urls_);
[email protected]795c28972012-12-06 06:13:395211}
5212
qinmin72e8bd02016-10-21 19:35:375213void WebContentsImpl::SetIsOverlayContent(bool is_overlay_content) {
5214 is_overlay_content_ = is_overlay_content;
5215}
5216
Albert J. Wongfb64e142018-10-16 01:10:455217void WebContentsImpl::DidFirstVisuallyNonEmptyPaint(
5218 RenderViewHostImpl* source) {
nicka0ac8382016-12-15 23:59:235219 // TODO(nick): When this is ported to FrameHostMsg_, we should only listen if
5220 // |source| is the main frame.
ericwilligersde386342016-10-19 02:35:095221 for (auto& observer : observers_)
5222 observer.DidFirstVisuallyNonEmptyPaint();
yusufod41c5f92015-03-06 00:14:285223
Carlos Caballero1215f882019-10-29 15:58:435224 if (source->theme_color() != last_sent_theme_color_) {
yusufod41c5f92015-03-06 00:14:285225 // Theme color should have updated by now if there was one.
ericwilligersde386342016-10-19 02:35:095226 for (auto& observer : observers_)
Peter Kastingb14e5782020-01-06 23:55:045227 observer.DidChangeThemeColor();
Carlos Caballero1215f882019-10-29 15:58:435228 last_sent_theme_color_ = source->theme_color();
yusufod41c5f92015-03-06 00:14:285229 }
[email protected]9f268072013-11-07 00:02:155230}
[email protected]d9030b82013-07-19 08:26:065231
Adithya Srinivasan46b8a792019-02-01 14:47:235232bool WebContentsImpl::IsPortal() const {
5233 return portal();
5234}
5235
[email protected]17e286e2013-03-01 23:29:395236void WebContentsImpl::NotifyBeforeFormRepostWarningShow() {
ericwilligersde386342016-10-19 02:35:095237 for (auto& observer : observers_)
5238 observer.BeforeFormRepostWarningShow();
[email protected]17e286e2013-03-01 23:29:395239}
5240
[email protected]ec6c05f2013-10-23 18:41:575241void WebContentsImpl::ActivateAndShowRepostFormWarningDialog() {
5242 Activate();
5243 if (delegate_)
5244 delegate_->ShowRepostFormWarningDialog(this);
5245}
5246
[email protected]b4c84012014-04-28 19:51:105247bool WebContentsImpl::HasAccessedInitialDocument() {
5248 return has_accessed_initial_document_;
5249}
5250
afakhry6f0c1ec22016-07-14 13:55:135251void WebContentsImpl::UpdateTitleForEntry(NavigationEntry* entry,
[email protected]fcf75d42013-12-03 20:11:265252 const base::string16& title) {
[email protected]fcf75d42013-12-03 20:11:265253 base::string16 final_title;
Avi Drissman93002212017-09-27 03:20:525254 base::TrimWhitespace(title, base::TRIM_ALL, &final_title);
[email protected]420ae012009-04-24 05:16:325255
[email protected]987fc3a2011-05-26 14:18:095256 // If a page is created via window.open and never navigated,
5257 // there will be no navigation entry. In this situation,
[email protected]73eb2602012-02-09 19:50:555258 // |page_title_when_no_navigation_entry_| will be used for page title.
[email protected]987fc3a2011-05-26 14:18:095259 if (entry) {
[email protected]36fc0392011-12-25 03:59:515260 if (final_title == entry->GetTitle())
afakhry6f0c1ec22016-07-14 13:55:135261 return; // Nothing changed, don't bother.
[email protected]420ae012009-04-24 05:16:325262
[email protected]36fc0392011-12-25 03:59:515263 entry->SetTitle(final_title);
Avi Drissman93002212017-09-27 03:20:525264
5265 // The title for display may differ from the title just set; grab it.
5266 final_title = entry->GetTitleForDisplay();
[email protected]987fc3a2011-05-26 14:18:095267 } else {
5268 if (page_title_when_no_navigation_entry_ == final_title)
afakhry6f0c1ec22016-07-14 13:55:135269 return; // Nothing changed, don't bother.
[email protected]987fc3a2011-05-26 14:18:095270
5271 page_title_when_no_navigation_entry_ = final_title;
5272 }
[email protected]420ae012009-04-24 05:16:325273
[email protected]420ae012009-04-24 05:16:325274 // Lastly, set the title for the view.
[email protected]790e2fd2011-09-21 20:28:235275 view_->SetPageTitle(final_title);
[email protected]420ae012009-04-24 05:16:325276
ericwilligersde386342016-10-19 02:35:095277 for (auto& observer : observers_)
Avi Drissman93002212017-09-27 03:20:525278 observer.TitleWasSet(entry);
[email protected]66798902013-10-01 18:40:165279
afakhry6f0c1ec22016-07-14 13:55:135280 // Broadcast notifications when the UI should be updated.
5281 if (entry == controller_.GetEntryAtOffset(0))
5282 NotifyNavigationStateChanged(INVALIDATE_TYPE_TITLE);
[email protected]420ae012009-04-24 05:16:325283}
5284
fdegansa696e5112015-04-17 01:57:595285void WebContentsImpl::SendChangeLoadProgress() {
[email protected]960b0372014-05-19 18:01:005286 loading_last_progress_update_ = base::TimeTicks::Now();
Evan Stade9f328112019-10-23 20:49:255287 for (auto& observer : observers_)
5288 observer.LoadProgressChanged(frame_tree_.load_progress());
[email protected]960b0372014-05-19 18:01:005289}
5290
5291void WebContentsImpl::ResetLoadProgressState() {
fdegans1d16355162015-03-26 11:58:345292 frame_tree_.ResetLoadProgress();
[email protected]960b0372014-05-19 18:01:005293 loading_weak_factory_.InvalidateWeakPtrs();
5294 loading_last_progress_update_ = base::TimeTicks();
5295}
5296
clamy44e84ce2016-02-22 15:38:255297// Notifies the RenderWidgetHost instance about the fact that the page is
5298// loading, or done loading.
5299void WebContentsImpl::LoadingStateChanged(bool to_different_document,
5300 bool due_to_interstitial,
5301 LoadNotificationDetails* details) {
Nate Chapin22ea6592019-03-05 22:29:025302 if (is_being_destroyed_)
5303 return;
clamy44e84ce2016-02-22 15:38:255304 // Do not send notifications about loading changes in the FrameTree while the
5305 // interstitial page is pausing the throbber.
creisadca9862017-06-16 19:12:115306 if (ShowingInterstitialPage() && interstitial_page_->pause_throbber() &&
clamy44e84ce2016-02-22 15:38:255307 !due_to_interstitial) {
5308 return;
5309 }
5310
5311 bool is_loading = IsLoading();
5312
5313 if (!is_loading) {
5314 load_state_ = net::LoadStateWithParam(net::LOAD_STATE_IDLE,
5315 base::string16());
5316 load_state_host_.clear();
5317 upload_size_ = 0;
5318 upload_position_ = 0;
5319 }
5320
5321 GetRenderManager()->SetIsLoading(is_loading);
5322
5323 waiting_for_response_ = is_loading;
5324 is_load_to_different_document_ = to_different_document;
5325
5326 if (delegate_)
5327 delegate_->LoadingStateChanged(this, to_different_document);
5328 NotifyNavigationStateChanged(INVALIDATE_TYPE_LOAD);
5329
5330 std::string url = (details ? details->url.possibly_invalid_spec() : "NULL");
5331 if (is_loading) {
5332 TRACE_EVENT_ASYNC_BEGIN2("browser,navigation", "WebContentsImpl Loading",
5333 this, "URL", url, "Main FrameTreeNode id",
5334 GetFrameTree()->root()->frame_tree_node_id());
ericwilligersde386342016-10-19 02:35:095335 for (auto& observer : observers_)
5336 observer.DidStartLoading();
clamy44e84ce2016-02-22 15:38:255337 } else {
5338 TRACE_EVENT_ASYNC_END1("browser,navigation", "WebContentsImpl Loading",
5339 this, "URL", url);
ericwilligersde386342016-10-19 02:35:095340 for (auto& observer : observers_)
5341 observer.DidStopLoading();
clamy44e84ce2016-02-22 15:38:255342 }
5343
5344 // TODO(avi): Remove. http://crbug.com/170921
5345 int type = is_loading ? NOTIFICATION_LOAD_START : NOTIFICATION_LOAD_STOP;
5346 NotificationDetails det = NotificationService::NoDetails();
5347 if (details)
5348 det = Details<LoadNotificationDetails>(details);
5349 NotificationService::current()->Notify(
5350 type, Source<NavigationController>(&controller_), det);
5351}
5352
[email protected]02d7b6e2014-06-24 21:01:505353void WebContentsImpl::NotifyViewSwapped(RenderViewHost* old_host,
5354 RenderViewHost* new_host) {
Fergal Daly6767b2e2020-02-04 03:15:165355 DCHECK_NE(old_host, new_host);
[email protected]420ae012009-04-24 05:16:325356 // After sending out a swap notification, we need to send a disconnect
5357 // notification so that clients that pick up a pointer to |this| can NULL the
5358 // pointer. See Bug 1230284.
5359 notify_disconnection_ = true;
ericwilligersde386342016-10-19 02:35:095360 for (auto& observer : observers_)
5361 observer.RenderViewHostChanged(old_host, new_host);
[email protected]da7a7182013-09-06 08:11:115362
Jinsuk Kimdc5284c22018-07-11 02:22:065363 view_->RenderViewHostChanged(old_host, new_host);
5364
Lucas Furukawa Gadanif9ea4fc2018-08-03 23:57:135365 // If this is an inner WebContents that has swapped views, we need to reattach
5366 // it to its outer WebContents.
5367 if (node_.outer_web_contents())
5368 ReattachToOuterWebContentsFrame();
5369
[email protected]7a846df2012-09-20 19:17:395370 // Ensure that the associated embedder gets cleared after a RenderViewHost
5371 // gets swapped, so we don't reuse the same embedder next time a
5372 // RenderViewHost is attached to this WebContents.
5373 RemoveBrowserPluginEmbedder();
[email protected]420ae012009-04-24 05:16:325374}
5375
[email protected]02d7b6e2014-06-24 21:01:505376void WebContentsImpl::NotifyFrameSwapped(RenderFrameHost* old_host,
Jinsuk Kim895b2c52018-07-03 06:49:165377 RenderFrameHost* new_host,
5378 bool is_main_frame) {
Bo Liu168c8642017-08-28 18:26:025379#if defined(OS_ANDROID)
Bo Liu16dd7b8322018-05-02 21:19:505380 // Copy importance from |old_host| if |new_host| is a main frame.
5381 if (old_host && !new_host->GetParent()) {
Bo Liu7c6779e92017-08-16 02:02:285382 static_cast<RenderFrameHostImpl*>(new_host)
5383 ->GetRenderWidgetHost()
Bo Liu16dd7b8322018-05-02 21:19:505384 ->SetImportance(static_cast<RenderFrameHostImpl*>(old_host)
5385 ->GetRenderWidgetHost()
5386 ->importance());
Bo Liu7c6779e92017-08-16 02:02:285387 }
Bo Liu168c8642017-08-28 18:26:025388#endif
ericwilligersde386342016-10-19 02:35:095389 for (auto& observer : observers_)
5390 observer.RenderFrameHostChanged(old_host, new_host);
[email protected]02d7b6e2014-06-24 21:01:505391}
5392
[email protected]da7a7182013-09-06 08:11:115393// TODO(avi): Remove this entire function because this notification is already
5394// covered by two observer functions. http://crbug.com/170921
[email protected]b172aee2012-04-10 17:05:265395void WebContentsImpl::NotifyDisconnected() {
[email protected]420ae012009-04-24 05:16:325396 if (!notify_disconnection_)
5397 return;
5398
5399 notify_disconnection_ = false;
[email protected]8ff00d72012-10-23 19:12:215400 NotificationService::current()->Notify(
5401 NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
5402 Source<WebContents>(this),
5403 NotificationService::NoDetails());
[email protected]420ae012009-04-24 05:16:325404}
5405
[email protected]cbb1ef592013-06-05 19:49:465406void WebContentsImpl::NotifyNavigationEntryCommitted(
5407 const LoadCommittedDetails& load_details) {
ericwilligersde386342016-10-19 02:35:095408 for (auto& observer : observers_)
5409 observer.NavigationEntryCommitted(load_details);
[email protected]cbb1ef592013-06-05 19:49:465410}
5411
Sam McNally5c087a32017-08-25 01:46:145412void WebContentsImpl::NotifyNavigationEntryChanged(
5413 const EntryChangedDetails& change_details) {
5414 for (auto& observer : observers_)
5415 observer.NavigationEntryChanged(change_details);
5416}
5417
5418void WebContentsImpl::NotifyNavigationListPruned(
5419 const PrunedDetails& pruned_details) {
5420 for (auto& observer : observers_)
5421 observer.NavigationListPruned(pruned_details);
5422}
5423
Christian Dullweber1af31e62018-02-22 11:49:485424void WebContentsImpl::NotifyNavigationEntriesDeleted() {
5425 for (auto& observer : observers_)
5426 observer.NavigationEntriesDeleted();
5427}
5428
rockotf62002a2016-09-15 00:08:595429void WebContentsImpl::OnAssociatedInterfaceRequest(
5430 RenderFrameHost* render_frame_host,
5431 const std::string& interface_name,
5432 mojo::ScopedInterfaceEndpointHandle handle) {
Julie Jeongeun Kim7d0986172019-12-04 03:17:255433 auto it = receiver_sets_.find(interface_name);
5434 if (it != receiver_sets_.end())
5435 it->second->OnReceiverForFrame(render_frame_host, std::move(handle));
rockotf62002a2016-09-15 00:08:595436}
5437
Ben Goodger9e24929e2017-07-21 03:13:405438void WebContentsImpl::OnInterfaceRequest(
5439 RenderFrameHost* render_frame_host,
5440 const std::string& interface_name,
5441 mojo::ScopedMessagePipeHandle* interface_pipe) {
5442 for (auto& observer : observers_) {
5443 observer.OnInterfaceRequestFromFrame(render_frame_host, interface_name,
5444 interface_pipe);
5445 if (!interface_pipe->is_valid())
5446 break;
5447 }
5448}
5449
Varun Khaneja5da94302019-06-25 04:48:105450void WebContentsImpl::OnDidBlockNavigation(
5451 const GURL& blocked_url,
5452 const GURL& initiator_url,
Abhijeet Kandalkarde7348e2020-01-13 06:06:545453 blink::mojom::NavigationBlockedReason reason) {
Nicolas Dossou-gbetebcab2472017-09-09 12:28:405454 if (delegate_)
Varun Khaneja5da94302019-06-25 04:48:105455 delegate_->OnDidBlockNavigation(this, blocked_url, initiator_url, reason);
Nicolas Dossou-gbetebcab2472017-09-09 12:28:405456}
5457
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415458const GURL& WebContentsImpl::GetMainFrameLastCommittedURL() {
[email protected]c31a84802014-04-03 15:55:495459 return GetLastCommittedURL();
5460}
5461
[email protected]b849847b2013-12-10 21:57:585462void WebContentsImpl::RenderFrameCreated(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:095463 for (auto& observer : observers_)
5464 observer.RenderFrameCreated(render_frame_host);
dmazzonif8a31042016-12-03 00:52:135465 UpdateAccessibilityModeOnFrame(render_frame_host);
clamy91b7abf2016-03-24 15:17:455466
Becca Hughesd11d6502018-07-31 17:01:285467 if (display_cutout_host_impl_)
5468 display_cutout_host_impl_->RenderFrameCreated(render_frame_host);
5469
clamy91b7abf2016-03-24 15:17:455470 if (!render_frame_host->IsRenderFrameLive() || render_frame_host->GetParent())
5471 return;
5472
5473 NavigationEntry* entry = controller_.GetPendingEntry();
5474 if (entry && entry->IsViewSourceMode()) {
5475 // Put the renderer in view source mode.
Dave Tapuska3c05e1c2019-11-27 18:34:185476 static_cast<RenderFrameHostImpl*>(render_frame_host)
5477 ->GetAssociatedLocalFrame()
5478 ->EnableViewSourceMode();
clamy91b7abf2016-03-24 15:17:455479 }
[email protected]b849847b2013-12-10 21:57:585480}
5481
5482void WebContentsImpl::RenderFrameDeleted(RenderFrameHost* render_frame_host) {
yilkal172da772019-11-06 22:49:075483 if (IsBeingDestroyed() && !render_frame_host->GetParent() &&
5484 first_navigation_completed_ &&
Rakina Zata Amni74627df2019-10-15 02:03:175485 !static_cast<RenderFrameHostImpl*>(render_frame_host)
5486 ->is_in_back_forward_cache()) {
yilkal796e89e2019-10-02 23:58:285487 // Main frame has been deleted because WebContents is being destroyed.
Rakina Zata Amni74627df2019-10-15 02:03:175488 // Note that we aren't recording this here when the main frame is in the
5489 // back-forward cache because that means we've actually already navigated
5490 // away from it (and we got to this point because the WebContents is
yilkal172da772019-11-06 22:49:075491 // deleted), which means |max_loaded_frame_count_| is already overwritten.
5492 // The |max_loaded_frame_count_| value will instead be recorded from within
5493 // |WebContentsImpl::DidFinishNavigation()|.
5494 RecordMaxFrameCountUMA(max_loaded_frame_count_);
yilkal796e89e2019-10-02 23:58:285495 }
5496
creis3638897452017-05-09 22:07:505497 is_notifying_observers_ = true;
ericwilligersde386342016-10-19 02:35:095498 for (auto& observer : observers_)
5499 observer.RenderFrameDeleted(render_frame_host);
creis3638897452017-05-09 22:07:505500 is_notifying_observers_ = false;
zqzhang7b6f4f02016-12-07 22:10:225501#if BUILDFLAG(ENABLE_PLUGINS)
5502 pepper_playback_observer_->RenderFrameDeleted(render_frame_host);
5503#endif
Becca Hughesfd5d8f892018-06-14 18:23:365504
Becca Hughesd11d6502018-07-31 17:01:285505 if (display_cutout_host_impl_)
5506 display_cutout_host_impl_->RenderFrameDeleted(render_frame_host);
5507
Becca Hughesfd5d8f892018-06-14 18:23:365508 // Remove any fullscreen state that the frame has stored.
5509 FullscreenStateChanged(render_frame_host, false /* is_fullscreen */);
[email protected]b849847b2013-12-10 21:57:585510}
5511
[email protected]a09d53ce2014-01-31 00:46:425512void WebContentsImpl::ShowContextMenu(RenderFrameHost* render_frame_host,
5513 const ContextMenuParams& params) {
avie9fd8722017-04-10 16:17:585514 // If a renderer fires off a second command to show a context menu before the
5515 // first context menu is closed, just ignore it. https://crbug.com/707534
ekaramadf6750aa2017-06-06 18:29:425516 if (showing_context_menu_)
avie9fd8722017-04-10 16:17:585517 return;
5518
[email protected]077e704b2014-05-23 19:24:105519 ContextMenuParams context_menu_params(params);
[email protected]a09d53ce2014-01-31 00:46:425520 // Allow WebContentsDelegates to handle the context menu operation first.
Joel Klinghed0ea22ea2019-02-20 22:04:225521 if (delegate_ &&
5522 delegate_->HandleContextMenu(render_frame_host, context_menu_params))
[email protected]a09d53ce2014-01-31 00:46:425523 return;
5524
[email protected]077e704b2014-05-23 19:24:105525 render_view_host_delegate_view_->ShowContextMenu(render_frame_host,
5526 context_menu_params);
[email protected]a09d53ce2014-01-31 00:46:425527}
5528
Avi Drissman4891b852018-09-25 18:12:585529namespace {
5530// Normalizes the line endings: \r\n -> \n, lone \r -> \n.
5531base::string16 NormalizeLineBreaks(const base::string16& source) {
5532 static const base::NoDestructor<base::string16> kReturnNewline(
5533 base::ASCIIToUTF16("\r\n"));
5534 static const base::NoDestructor<base::string16> kReturn(
5535 base::ASCIIToUTF16("\r"));
5536 static const base::NoDestructor<base::string16> kNewline(
5537 base::ASCIIToUTF16("\n"));
5538
5539 std::vector<base::StringPiece16> pieces;
5540
5541 for (const auto& rn_line : base::SplitStringPieceUsingSubstr(
5542 source, *kReturnNewline, base::KEEP_WHITESPACE,
5543 base::SPLIT_WANT_ALL)) {
5544 auto r_lines = base::SplitStringPieceUsingSubstr(
5545 rn_line, *kReturn, base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
5546 std::move(std::begin(r_lines), std::end(r_lines),
5547 std::back_inserter(pieces));
5548 }
5549
5550 return base::JoinString(pieces, *kNewline);
5551}
5552} // namespace
5553
Dave Tapuskacdf545cc2020-01-23 18:38:525554void WebContentsImpl::RunJavaScriptDialog(
5555 RenderFrameHost* render_frame_host,
5556 const base::string16& message,
5557 const base::string16& default_prompt,
5558 JavaScriptDialogType dialog_type,
5559 JavaScriptDialogCallback response_callback) {
Avi Drissman2ccbb402018-03-20 21:11:365560 // Ensure that if showing a dialog is the first thing that a page does, that
5561 // the contents of the previous page aren't shown behind it. This is required
5562 // because showing a dialog freezes the renderer, so no frames will be coming
5563 // from it. https://crbug.com/823353
5564 auto* render_widget_host_impl =
5565 static_cast<RenderFrameHostImpl*>(render_frame_host)
5566 ->GetRenderWidgetHost();
5567 if (render_widget_host_impl)
5568 render_widget_host_impl->ForceFirstFrameAfterNavigationTimeout();
5569
avi0720b02e2017-06-13 03:22:135570 // Running a dialog causes an exit to webpage-initiated fullscreen.
5571 // http://crbug.com/728276
Avi Drissman1a55a9d62020-03-10 18:56:455572 base::ScopedClosureRunner fullscreen_block = ForSecurityDropFullscreen();
avi0720b02e2017-06-13 03:22:135573
Avi Drissman1a55a9d62020-03-10 18:56:455574 auto callback =
5575 base::BindOnce(&WebContentsImpl::OnDialogClosed, base::Unretained(this),
5576 render_frame_host->GetProcess()->GetID(),
5577 render_frame_host->GetRoutingID(),
5578 std::move(response_callback), std::move(fullscreen_block));
Pavel Feldman3c1842b2017-08-02 05:00:165579
Pavel Feldman3c1842b2017-08-02 05:00:165580 std::vector<protocol::PageHandler*> page_handlers =
5581 protocol::PageHandler::EnabledForWebContents(this);
5582
Pavel Feldmanfab3cb62017-10-05 01:02:015583 if (delegate_)
5584 dialog_manager_ = delegate_->GetJavaScriptDialogManager(this);
5585
Charlie Reis96077362019-07-04 00:34:045586 // While a JS message dialog is showing, defer commits in this WebContents.
5587 javascript_dialog_navigation_deferrer_ =
5588 std::make_unique<JavaScriptDialogNavigationDeferrer>();
5589
Pavel Feldmanfab3cb62017-10-05 01:02:015590 // Suppress JavaScript dialogs when requested. Also suppress messages when
5591 // showing an interstitial as it's shown over the previous page and we don't
5592 // want the hidden page's dialogs to interfere with the interstitial.
Tarun Bansalc209b742019-12-24 06:53:255593 bool should_suppress = ShowingInterstitialPage() ||
5594 (delegate_ && delegate_->ShouldSuppressDialogs(this));
Pavel Feldman1c587bc52018-04-04 21:16:055595 bool has_non_devtools_handlers = delegate_ && dialog_manager_;
5596 bool has_handlers = page_handlers.size() || has_non_devtools_handlers;
Pavel Feldmanfab3cb62017-10-05 01:02:015597 bool suppress_this_message = should_suppress || !has_handlers;
5598
5599 if (suppress_this_message) {
Avi Drissmane04d3992017-10-05 15:11:365600 std::move(callback).Run(true, false, base::string16());
Pavel Feldman3c1842b2017-08-02 05:00:165601 return;
5602 }
5603
5604 scoped_refptr<CloseDialogCallbackWrapper> wrapper =
Avi Drissmane04d3992017-10-05 15:11:365605 new CloseDialogCallbackWrapper(std::move(callback));
Pavel Feldman3c1842b2017-08-02 05:00:165606
5607 is_showing_javascript_dialog_ = true;
5608
Avi Drissman4891b852018-09-25 18:12:585609 base::string16 normalized_message = NormalizeLineBreaks(message);
5610
Pavel Feldman3c1842b2017-08-02 05:00:165611 for (auto* handler : page_handlers) {
Avi Drissmane04d3992017-10-05 15:11:365612 handler->DidRunJavaScriptDialog(
Avi Drissman4891b852018-09-25 18:12:585613 render_frame_host->GetLastCommittedURL(), normalized_message,
5614 default_prompt, dialog_type, has_non_devtools_handlers,
Avi Drissmane04d3992017-10-05 15:11:365615 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:165616 }
5617
5618 if (dialog_manager_) {
[email protected]87de04b02014-04-08 22:14:495619 dialog_manager_->RunJavaScriptDialog(
Avi Drissman4891b852018-09-25 18:12:585620 this, render_frame_host, dialog_type, normalized_message,
5621 default_prompt,
Avi Drissmane04d3992017-10-05 15:11:365622 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false),
5623 &suppress_this_message);
[email protected]87de04b02014-04-08 22:14:495624 }
5625
5626 if (suppress_this_message) {
5627 // If we are suppressing messages, just reply as if the user immediately
5628 // pressed "Cancel", passing true to |dialog_was_suppressed|.
Avi Drissmane04d3992017-10-05 15:11:365629 wrapper->Run(true, false, base::string16());
[email protected]87de04b02014-04-08 22:14:495630 }
[email protected]87de04b02014-04-08 22:14:495631}
5632
5633void WebContentsImpl::RunBeforeUnloadConfirm(
[email protected]39f2f9252014-05-03 00:54:015634 RenderFrameHost* render_frame_host,
[email protected]87de04b02014-04-08 22:14:495635 bool is_reload,
Dave Tapuskacdf545cc2020-01-23 18:38:525636 JavaScriptDialogCallback response_callback) {
Avi Drissman2ccbb402018-03-20 21:11:365637 // Ensure that if showing a dialog is the first thing that a page does, that
5638 // the contents of the previous page aren't shown behind it. This is required
5639 // because showing a dialog freezes the renderer, so no frames will be coming
5640 // from it. https://crbug.com/823353
5641 auto* render_widget_host_impl =
5642 static_cast<RenderFrameHostImpl*>(render_frame_host)
5643 ->GetRenderWidgetHost();
5644 if (render_widget_host_impl)
5645 render_widget_host_impl->ForceFirstFrameAfterNavigationTimeout();
5646
avi0720b02e2017-06-13 03:22:135647 // Running a dialog causes an exit to webpage-initiated fullscreen.
5648 // http://crbug.com/728276
Avi Drissman1a55a9d62020-03-10 18:56:455649 base::ScopedClosureRunner fullscreen_block = ForSecurityDropFullscreen();
avi0720b02e2017-06-13 03:22:135650
[email protected]39f2f9252014-05-03 00:54:015651 RenderFrameHostImpl* rfhi =
5652 static_cast<RenderFrameHostImpl*>(render_frame_host);
[email protected]87de04b02014-04-08 22:14:495653 if (delegate_)
5654 delegate_->WillRunBeforeUnloadConfirm();
5655
Avi Drissman1a55a9d62020-03-10 18:56:455656 auto callback =
5657 base::BindOnce(&WebContentsImpl::OnDialogClosed, base::Unretained(this),
5658 render_frame_host->GetProcess()->GetID(),
5659 render_frame_host->GetRoutingID(),
5660 std::move(response_callback), std::move(fullscreen_block));
Pavel Feldman3c1842b2017-08-02 05:00:165661
Pavel Feldman3c1842b2017-08-02 05:00:165662 std::vector<protocol::PageHandler*> page_handlers =
5663 protocol::PageHandler::EnabledForWebContents(this);
5664
Pavel Feldmanfab3cb62017-10-05 01:02:015665 if (delegate_)
5666 dialog_manager_ = delegate_->GetJavaScriptDialogManager(this);
5667
Charlie Reis96077362019-07-04 00:34:045668 // While a JS beforeunload dialog is showing, defer commits in this
5669 // WebContents.
5670 javascript_dialog_navigation_deferrer_ =
5671 std::make_unique<JavaScriptDialogNavigationDeferrer>();
5672
Tarun Bansalc209b742019-12-24 06:53:255673 bool should_suppress = ShowingInterstitialPage() || !rfhi->is_active() ||
5674 (delegate_ && delegate_->ShouldSuppressDialogs(this));
Pavel Feldman1c587bc52018-04-04 21:16:055675 bool has_non_devtools_handlers = delegate_ && dialog_manager_;
5676 bool has_handlers = page_handlers.size() || has_non_devtools_handlers;
Pavel Feldmanfab3cb62017-10-05 01:02:015677 if (should_suppress || !has_handlers) {
Avi Drissmane04d3992017-10-05 15:11:365678 std::move(callback).Run(false, true, base::string16());
[email protected]87de04b02014-04-08 22:14:495679 return;
5680 }
5681
5682 is_showing_before_unload_dialog_ = true;
Pavel Feldman3c1842b2017-08-02 05:00:165683
5684 scoped_refptr<CloseDialogCallbackWrapper> wrapper =
Avi Drissmane04d3992017-10-05 15:11:365685 new CloseDialogCallbackWrapper(std::move(callback));
Pavel Feldman3c1842b2017-08-02 05:00:165686
5687 GURL frame_url = rfhi->GetLastCommittedURL();
5688 for (auto* handler : page_handlers) {
Avi Drissmane04d3992017-10-05 15:11:365689 handler->DidRunBeforeUnloadConfirm(
Pavel Feldman1c587bc52018-04-04 21:16:055690 frame_url, has_non_devtools_handlers,
Avi Drissmane04d3992017-10-05 15:11:365691 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:165692 }
5693
5694 if (dialog_manager_) {
Avi Drissmane04d3992017-10-05 15:11:365695 dialog_manager_->RunBeforeUnloadDialog(
Avi Drissmanff9ed752017-11-28 21:18:125696 this, render_frame_host, is_reload,
Avi Drissmane04d3992017-10-05 15:11:365697 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:165698 }
[email protected]87de04b02014-04-08 22:14:495699}
5700
Kent Tamurac260c9a2018-09-14 09:10:565701void WebContentsImpl::RunFileChooser(
5702 RenderFrameHost* render_frame_host,
Avi Drissman1a55a9d62020-03-10 18:56:455703 std::unique_ptr<FileChooserImpl::FileSelectListenerImpl> listener,
Kent Tamurac260c9a2018-09-14 09:10:565704 const blink::mojom::FileChooserParams& params) {
Avi Drissman3d41e7712018-08-27 21:18:085705 // Any explicit focusing of another window while this WebContents is in
5706 // fullscreen can be used to confuse the user, so drop fullscreen.
Avi Drissman1a55a9d62020-03-10 18:56:455707 base::ScopedClosureRunner fullscreen_block = ForSecurityDropFullscreen();
5708 listener->SetFullscreenBlock(std::move(fullscreen_block));
Avi Drissman3d41e7712018-08-27 21:18:085709
naskoada75b22016-06-11 16:09:465710 if (delegate_)
Kent Tamura512a27e2018-10-04 00:49:325711 delegate_->RunFileChooser(render_frame_host, std::move(listener), params);
5712 else
5713 listener->FileSelectionCanceled();
naskoada75b22016-06-11 16:09:465714}
5715
[email protected]a86c0e962013-12-17 17:10:395716WebContents* WebContentsImpl::GetAsWebContents() {
5717 return this;
5718}
5719
mcnee336ea2c2017-05-23 22:50:595720#if !defined(OS_ANDROID)
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415721double WebContentsImpl::GetPendingPageZoomLevel() {
wjmaclean64951902016-04-29 20:59:125722 NavigationEntry* pending_entry = GetController().GetPendingEntry();
5723 if (!pending_entry)
5724 return HostZoomMap::GetZoomLevel(this);
5725
5726 GURL url = pending_entry->GetURL();
5727 return HostZoomMap::GetForWebContents(this)->GetZoomLevelForHostAndScheme(
5728 url.scheme(), net::GetHostOrSpecFromURL(url));
5729}
mcnee336ea2c2017-05-23 22:50:595730#endif // !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:125731
qinmin72e8bd02016-10-21 19:35:375732bool WebContentsImpl::HideDownloadUI() const {
5733 return is_overlay_content_;
5734}
5735
mlamouri5cd9ae82017-02-18 11:05:095736bool WebContentsImpl::HasPersistentVideo() const {
5737 return has_persistent_video_;
5738}
5739
Ian Vollick5d5c37f2019-06-19 22:50:575740bool WebContentsImpl::IsSpatialNavigationDisabled() const {
5741 return is_spatial_navigation_disabled_;
5742}
5743
Albert J. Wong65fe64d2019-09-20 02:48:145744RenderFrameHostImpl* WebContentsImpl::GetPendingMainFrame() {
clamy610c63b32017-12-22 15:05:185745 return GetRenderManager()->speculative_frame_host();
Alex Moshchuk27caae82017-09-11 23:11:185746}
5747
mlamourie52c1b542017-02-23 14:57:505748bool WebContentsImpl::HasActiveEffectivelyFullscreenVideo() const {
5749 return media_web_contents_observer_->HasActiveEffectivelyFullscreenVideo();
5750}
5751
François Beaufortad6c5232018-02-26 11:00:445752bool WebContentsImpl::IsPictureInPictureAllowedForFullscreenVideo() const {
5753 return media_web_contents_observer_
5754 ->IsPictureInPictureAllowedForFullscreenVideo();
5755}
5756
ekaramada110f642016-12-21 19:47:285757bool WebContentsImpl::IsFocusedElementEditable() {
5758 RenderFrameHostImpl* frame = GetFocusedFrame();
5759 return frame && frame->has_focused_editable_element();
5760}
5761
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415762bool WebContentsImpl::IsShowingContextMenu() {
ekaramadf6750aa2017-06-06 18:29:425763 return showing_context_menu_;
5764}
5765
5766void WebContentsImpl::SetShowingContextMenu(bool showing) {
5767 DCHECK_NE(showing_context_menu_, showing);
5768 showing_context_menu_ = showing;
5769
5770 if (auto* view = GetRenderWidgetHostView()) {
5771 // Notify the main frame's RWHV to run the platform-specific code, if any.
5772 static_cast<RenderWidgetHostViewBase*>(view)->SetShowingContextMenu(
5773 showing);
5774 }
5775}
5776
ekaramada110f642016-12-21 19:47:285777void WebContentsImpl::ClearFocusedElement() {
5778 if (auto* frame = GetFocusedFrame())
5779 frame->ClearFocusedElement();
5780}
5781
danakj77eb7e82020-01-09 19:38:465782bool WebContentsImpl::IsNeverComposited() {
[email protected]7912e822014-04-16 02:37:035783 if (!delegate_)
5784 return false;
danakj77eb7e82020-01-09 19:38:465785 return delegate_->IsNeverComposited(this);
[email protected]7912e822014-04-16 02:37:035786}
5787
[email protected]5a3bdf52012-05-24 15:12:575788RenderViewHostDelegateView* WebContentsImpl::GetDelegateView() {
5789 return render_view_host_delegate_view_;
[email protected]420ae012009-04-24 05:16:325790}
5791
Leon Hanc819dc62019-01-28 04:30:195792blink::mojom::RendererPreferences WebContentsImpl::GetRendererPrefs(
[email protected]8ff00d72012-10-23 19:12:215793 BrowserContext* browser_context) const {
[email protected]840b1512009-07-21 16:53:465794 return renderer_preferences_;
[email protected]80d96fa2009-06-10 22:34:515795}
5796
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165797RenderFrameHostImpl* WebContentsImpl::GetOuterWebContentsFrame() {
5798 if (GetOuterDelegateFrameTreeNodeId() ==
5799 FrameTreeNode::kFrameTreeNodeInvalidId) {
5800 return nullptr;
5801 }
5802
5803 FrameTreeNode* outer_node =
5804 FrameTreeNode::GloballyFindByID(GetOuterDelegateFrameTreeNodeId());
5805 // The outer node should be in the outer WebContents.
5806 DCHECK_EQ(outer_node->frame_tree(), GetOuterWebContents()->GetFrameTree());
5807 return outer_node->parent()->current_frame_host();
5808}
5809
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415810WebContentsImpl* WebContentsImpl::GetOuterWebContents() {
Lucas Furukawa Gadani105de1e812018-05-31 19:38:395811 return node_.outer_web_contents();
avallee0206f782016-07-28 18:55:335812}
5813
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165814std::vector<WebContents*> WebContentsImpl::GetInnerWebContents() {
5815 std::vector<WebContents*> all_inner_contents;
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165816 const auto& inner_contents = node_.GetInnerWebContents();
5817 all_inner_contents.insert(all_inner_contents.end(), inner_contents.begin(),
5818 inner_contents.end());
5819 return all_inner_contents;
5820}
5821
Jeremy Roman7e70bf92020-01-07 23:23:585822WebContentsImpl* WebContentsImpl::GetResponsibleWebContents() {
5823 // Iteratively ask delegates which other contents is responsible until a fixed
5824 // point is found.
5825 WebContentsImpl* contents = this;
5826 while (WebContentsDelegate* delegate = contents->GetDelegate()) {
5827 auto* responsible_contents = static_cast<WebContentsImpl*>(
5828 delegate->GetResponsibleWebContents(contents));
5829 if (responsible_contents == contents)
5830 break;
5831 contents = responsible_contents;
5832 }
5833 return contents;
5834}
5835
avallee0206f782016-07-28 18:55:335836WebContentsImpl* WebContentsImpl::GetFocusedWebContents() {
lfg601233692017-03-06 22:45:445837 return GetOutermostWebContents()->node_.focused_web_contents();
avallee0206f782016-07-28 18:55:335838}
5839
avallee9993fca2016-11-17 06:16:505840bool WebContentsImpl::ContainsOrIsFocusedWebContents() {
5841 for (WebContentsImpl* focused_contents = GetFocusedWebContents();
5842 focused_contents;
5843 focused_contents = focused_contents->GetOuterWebContents()) {
5844 if (focused_contents == this)
5845 return true;
5846 }
5847
5848 return false;
5849}
5850
W. James MacLean9437b5bf2019-12-06 17:33:445851void WebContentsImpl::RemoveBrowserPluginEmbedder() {
5852 browser_plugin_embedder_.reset();
5853}
5854
avallee0206f782016-07-28 18:55:335855WebContentsImpl* WebContentsImpl::GetOutermostWebContents() {
5856 WebContentsImpl* root = this;
5857 while (root->GetOuterWebContents())
5858 root = root->GetOuterWebContents();
5859 return root;
5860}
5861
avalleed68cdd12017-06-21 22:07:275862void WebContentsImpl::FocusOuterAttachmentFrameChain() {
5863 WebContentsImpl* outer_contents = GetOuterWebContents();
5864 if (!outer_contents)
5865 return;
5866
5867 FrameTreeNode* outer_node =
5868 FrameTreeNode::GloballyFindByID(GetOuterDelegateFrameTreeNodeId());
5869 outer_contents->frame_tree_.SetFocusedFrame(outer_node, nullptr);
5870
5871 // For a browser initiated focus change, let embedding renderer know of the
5872 // change. Otherwise, if the currently focused element is just across a
5873 // process boundary in focus order, it will not be possible to move across
5874 // that boundary. This is because the target element will already be focused
5875 // (that renderer was not notified) and drop the event.
5876 if (GetRenderManager()->GetProxyToOuterDelegate())
5877 GetRenderManager()->GetProxyToOuterDelegate()->SetFocusedFrame();
5878
5879 outer_contents->FocusOuterAttachmentFrameChain();
5880}
5881
Sean Toppingbbc4a2bd2019-01-30 02:16:145882void WebContentsImpl::InnerWebContentsCreated(WebContents* inner_web_contents) {
Sean Toppingbbc4a2bd2019-01-30 02:16:145883 for (auto& observer : observers_)
5884 observer.InnerWebContentsCreated(inner_web_contents);
5885}
5886
[email protected]b172aee2012-04-10 17:05:265887void WebContentsImpl::RenderViewCreated(RenderViewHost* render_view_host) {
[email protected]86f98a22013-03-20 14:35:005888 if (delegate_)
[email protected]e85165c642014-06-10 14:34:315889 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]a6b73c62013-02-11 23:05:085890
[email protected]8ff00d72012-10-23 19:12:215891 NotificationService::current()->Notify(
5892 NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED,
5893 Source<WebContents>(this),
5894 Details<RenderViewHost>(render_view_host));
[email protected]420ae012009-04-24 05:16:325895
ericwilligersde386342016-10-19 02:35:095896 for (auto& observer : observers_)
5897 observer.RenderViewCreated(render_view_host);
Joel Einbinder848001c2017-09-19 21:39:315898 if (delegate_)
5899 RenderFrameDevToolsAgentHost::WebContentsCreated(this);
[email protected]420ae012009-04-24 05:16:325900}
5901
[email protected]b172aee2012-04-10 17:05:265902void WebContentsImpl::RenderViewReady(RenderViewHost* rvh) {
[email protected]151a63d2011-12-20 22:32:525903 if (rvh != GetRenderViewHost()) {
[email protected]420ae012009-04-24 05:16:325904 // Don't notify the world, since this came from a renderer in the
5905 // background.
5906 return;
5907 }
5908
dmazzoni62111452017-04-28 23:46:555909 RenderWidgetHostViewBase* rwhv =
5910 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
5911 if (rwhv)
5912 rwhv->SetMainFrameAXTreeID(GetMainFrame()->GetAXTreeID());
5913
[email protected]da7a7182013-09-06 08:11:115914 notify_disconnection_ = true;
[email protected]da7a7182013-09-06 08:11:115915
[email protected]be1f56ab2011-12-22 06:55:315916 bool was_crashed = IsCrashed();
[email protected]443b80e2010-12-14 00:42:235917 SetIsCrashed(base::TERMINATION_STATUS_STILL_RUNNING, 0);
[email protected]9d8a4642009-07-29 17:25:305918
5919 // Restore the focus to the tab (otherwise the focus will be on the top
5920 // window).
[email protected]484ae5912010-09-29 19:16:145921 if (was_crashed && !FocusLocationBarByDefault() &&
5922 (!delegate_ || delegate_->ShouldFocusPageAfterCrash())) {
[email protected]f3615f02013-02-26 06:09:065923 view_->Focus();
[email protected]484ae5912010-09-29 19:16:145924 }
[email protected]32ded2212011-11-10 18:51:435925
ericwilligersde386342016-10-19 02:35:095926 for (auto& observer : observers_)
5927 observer.RenderViewReady();
Jinsuk Kim895b2c52018-07-03 06:49:165928
5929 view_->RenderViewReady();
[email protected]420ae012009-04-24 05:16:325930}
5931
[email protected]ec6a7eb2013-04-22 17:34:225932void WebContentsImpl::RenderViewTerminated(RenderViewHost* rvh,
5933 base::TerminationStatus status,
5934 int error_code) {
[email protected]151a63d2011-12-20 22:32:525935 if (rvh != GetRenderViewHost()) {
[email protected]420ae012009-04-24 05:16:325936 // The pending page's RenderViewHost is gone.
5937 return;
5938 }
5939
[email protected]2fcdcc32014-03-05 02:14:075940 // Ensure fullscreen mode is exited in the |delegate_| since a crashed
5941 // renderer may not have made a clean exit.
alexmos5dd617d2016-06-07 04:21:155942 if (IsFullscreenForCurrentTab())
bokanece34a82016-01-28 19:49:465943 ExitFullscreenMode(false);
[email protected]2fcdcc32014-03-05 02:14:075944
Jennifer Apacibleb4b972a2018-06-07 04:41:025945 // Ensure any video in Picture-in-Picture is exited in the |delegate_| since
5946 // a crashed renderer may not have made a clean exit.
5947 if (HasPictureInPictureVideo())
5948 ExitPictureInPicture();
5949
[email protected]698191dc2014-02-25 01:06:135950 // Cancel any visible dialogs so they are not left dangling over the sad tab.
creis89a0f782015-05-27 16:13:175951 CancelActiveAndPendingDialogs();
[email protected]698191dc2014-02-25 01:06:135952
dalecurtis3d1e1302017-02-20 22:33:255953 audio_stream_monitor_.RenderProcessGone(rvh->GetProcess()->GetID());
5954
[email protected]960b0372014-05-19 18:01:005955 // Reset the loading progress. TODO(avi): What does it mean to have a
5956 // "renderer crash" when there is more than one renderer process serving a
5957 // webpage? Once this function is called at a more granular frame level, we
5958 // probably will need to more granularly reset the state here.
5959 ResetLoadProgressState();
clamy44e84ce2016-02-22 15:38:255960 NotifyDisconnected();
5961 SetIsCrashed(status, error_code);
[email protected]960b0372014-05-19 18:01:005962
ericwilligersde386342016-10-19 02:35:095963 for (auto& observer : observers_)
5964 observer.RenderProcessGone(GetCrashedStatus());
[email protected]420ae012009-04-24 05:16:325965}
5966
[email protected]b172aee2012-04-10 17:05:265967void WebContentsImpl::RenderViewDeleted(RenderViewHost* rvh) {
ericwilligersde386342016-10-19 02:35:095968 for (auto& observer : observers_)
5969 observer.RenderViewDeleted(rvh);
[email protected]2e4633c2009-07-09 16:58:065970}
5971
sky8b00392d2015-01-10 00:30:285972void WebContentsImpl::UpdateTargetURL(RenderViewHost* render_view_host,
5973 const GURL& url) {
5974 if (fullscreen_widget_routing_id_ != MSG_ROUTING_NONE) {
Lukasz Anforowiczfd707142018-02-07 19:46:135975 // If we're in flash fullscreen (i.e. Pepper plugin fullscreen) only update
5976 // the url if it's from the fullscreen renderer.
sky8b00392d2015-01-10 00:30:285977 RenderWidgetHostView* fs = GetFullscreenRenderWidgetHostView();
avif9ab5d942015-10-15 14:05:445978 if (fs && fs->GetRenderWidgetHost() != render_view_host->GetWidget())
sky8b00392d2015-01-10 00:30:285979 return;
5980 }
Lukasz Anforowiczfd707142018-02-07 19:46:135981
5982 // In case of racey updates from multiple RenderViewHosts, the last URL should
5983 // be shown - see also some discussion in https://crbug.com/807776.
5984 if (!url.is_valid() && render_view_host != view_that_set_last_target_url_)
5985 return;
5986 view_that_set_last_target_url_ = url.is_valid() ? render_view_host : nullptr;
5987
[email protected]6934a702011-12-20 00:04:515988 if (delegate_)
avi450ce00e2014-09-24 01:58:525989 delegate_->UpdateTargetURL(this, url);
[email protected]420ae012009-04-24 05:16:325990}
5991
Lukasz Anforowiczfd707142018-02-07 19:46:135992void WebContentsImpl::ClearTargetURL() {
5993 view_that_set_last_target_url_ = nullptr;
5994 if (delegate_)
5995 delegate_->UpdateTargetURL(this, GURL());
5996}
5997
[email protected]b172aee2012-04-10 17:05:265998void WebContentsImpl::Close(RenderViewHost* rvh) {
[email protected]60780f412013-02-25 16:34:105999#if defined(OS_MACOSX)
[email protected]07707302009-11-06 00:50:296000 // The UI may be in an event-tracking loop, such as between the
6001 // mouse-down and mouse-up in text selection or a button click.
6002 // Defer the close until after tracking is complete, so that we
6003 // don't free objects out from under the UI.
[email protected]07707302009-11-06 00:50:296004 // TODO(shess): This could get more fine-grained. For instance,
6005 // closing a tab in another window while selecting text in the
6006 // current window's Omnibox should be just fine.
Christopher Cameron9ae31e0d2019-03-01 20:01:196007 if (view_->CloseTabAfterEventTrackingIfNeeded())
[email protected]07707302009-11-06 00:50:296008 return;
[email protected]60780f412013-02-25 16:34:106009#endif
[email protected]07707302009-11-06 00:50:296010
[email protected]420ae012009-04-24 05:16:326011 // Ignore this if it comes from a RenderViewHost that we aren't showing.
[email protected]151a63d2011-12-20 22:32:526012 if (delegate_ && rvh == GetRenderViewHost())
[email protected]6934a702011-12-20 00:04:516013 delegate_->CloseContents(this);
[email protected]420ae012009-04-24 05:16:326014}
6015
Avi Drissman014dec72018-06-07 02:34:016016void WebContentsImpl::RequestSetBounds(const gfx::Rect& new_bounds) {
6017 if (delegate_)
6018 delegate_->SetContentsBounds(this, new_bounds);
[email protected]420ae012009-04-24 05:16:326019}
6020
fdegansa696e5112015-04-17 01:57:596021void WebContentsImpl::DidStartLoading(FrameTreeNode* frame_tree_node,
[email protected]e3b10d12014-03-28 16:06:096022 bool to_different_document) {
Evan Stadec3b26022017-07-14 19:50:246023 LoadingStateChanged(frame_tree_node->IsMainFrame() && to_different_document,
6024 false, nullptr);
dmazzonibf8cec42015-02-08 08:28:086025
Xiyuan Xia2a66b112018-12-06 15:52:166026 // Reset the focus state from DidStartNavigation to false if a new load starts
6027 // afterward, in case loading logic triggers a FocusLocationBarByDefault call.
6028 should_focus_location_bar_by_default_ = false;
Ian Prestcdd843d2020-01-28 18:59:586029
6030 // Notify accessibility that the user is navigating away from the
6031 // current document.
6032 // TODO(domfarolino, dmazzoni): Do this using WebContentsObserver. See
6033 // https://crbug.com/981271.
6034 BrowserAccessibilityManager* manager =
6035 frame_tree_node->current_frame_host()->browser_accessibility_manager();
6036 if (manager)
6037 manager->UserIsNavigatingAway();
[email protected]420ae012009-04-24 05:16:326038}
6039
fdegansc73eec22015-03-19 14:47:546040void WebContentsImpl::DidStopLoading() {
dcheng59716272016-04-09 05:19:086041 std::unique_ptr<LoadNotificationDetails> details;
[email protected]420ae012009-04-24 05:16:326042
[email protected]9595fd82013-04-19 21:28:496043 // Use the last committed entry rather than the active one, in case a
6044 // pending entry has been created.
6045 NavigationEntry* entry = controller_.GetLastCommittedEntry();
[email protected]3691e5cf2014-01-22 10:16:206046 Navigator* navigator = frame_tree_.root()->navigator();
[email protected]9595fd82013-04-19 21:28:496047
[email protected]420ae012009-04-24 05:16:326048 // An entry may not exist for a stop when loading an initial blank page or
6049 // if an iframe injected by script into a blank page finishes loading.
6050 if (entry) {
[email protected]3691e5cf2014-01-22 10:16:206051 base::TimeDelta elapsed =
6052 base::TimeTicks::Now() - navigator->GetCurrentLoadStart();
[email protected]420ae012009-04-24 05:16:326053
6054 details.reset(new LoadNotificationDetails(
[email protected]36fc0392011-12-25 03:59:516055 entry->GetVirtualURL(),
[email protected]420ae012009-04-24 05:16:326056 elapsed,
6057 &controller_,
6058 controller_.GetCurrentEntryIndex()));
6059 }
6060
clamy44e84ce2016-02-22 15:38:256061 LoadingStateChanged(true, false, details.get());
[email protected]420ae012009-04-24 05:16:326062}
6063
fdegansa696e5112015-04-17 01:57:596064void WebContentsImpl::DidChangeLoadProgress() {
Nate Chapin22ea6592019-03-05 22:29:026065 if (is_being_destroyed_)
6066 return;
fdegansa696e5112015-04-17 01:57:596067 double load_progress = frame_tree_.load_progress();
6068
6069 // The delegate is notified immediately for the first and last updates. Also,
6070 // since the message loop may be pretty busy when a page is loaded, it might
6071 // not execute a posted task in a timely manner so the progress report is sent
6072 // immediately if enough time has passed.
6073 base::TimeDelta min_delay =
6074 base::TimeDelta::FromMilliseconds(kMinimumDelayBetweenLoadingUpdatesMS);
6075 bool delay_elapsed = loading_last_progress_update_.is_null() ||
6076 base::TimeTicks::Now() - loading_last_progress_update_ > min_delay;
6077
6078 if (load_progress == 0.0 || load_progress == 1.0 || delay_elapsed) {
6079 // If there is a pending task to send progress, it is now obsolete.
6080 loading_weak_factory_.InvalidateWeakPtrs();
6081
6082 // Notify the load progress change.
6083 SendChangeLoadProgress();
6084
6085 // Clean-up the states if needed.
6086 if (load_progress == 1.0)
6087 ResetLoadProgressState();
6088 return;
6089 }
6090
6091 if (loading_weak_factory_.HasWeakPtrs())
6092 return;
6093
skyostil95082a62015-06-05 19:53:076094 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
tzike2aca992017-09-05 08:50:546095 FROM_HERE,
6096 base::BindOnce(&WebContentsImpl::SendChangeLoadProgress,
6097 loading_weak_factory_.GetWeakPtr()),
fdegansa696e5112015-04-17 01:57:596098 min_delay);
6099}
6100
avid6d88b912017-01-13 00:16:006101std::vector<std::unique_ptr<NavigationThrottle>>
6102WebContentsImpl::CreateThrottlesForNavigation(
clamycbf524d42016-09-27 12:48:356103 NavigationHandle* navigation_handle) {
Charlie Reis96077362019-07-04 00:34:046104 auto throttles = GetContentClient()->browser()->CreateThrottlesForNavigation(
clamycbf524d42016-09-27 12:48:356105 navigation_handle);
Charlie Reis96077362019-07-04 00:34:046106
6107 // This is not a normal place to be adding a throttle. However, in the case
6108 // javascript dialogs, related logic is present in the web_contents/ layer,
6109 // and the purpose of the throttle is to ensure that navigation commits are
6110 // deferred for the entire WebContents. Most throttles are either added by
6111 // the embederrer outside of content/, or are per-frame and added by
6112 // NavigationThrottleRunner.
6113 std::unique_ptr<content::NavigationThrottle> dialog_throttle =
6114 JavaScriptDialogNavigationThrottle::MaybeCreateThrottleFor(
6115 navigation_handle);
6116 if (dialog_throttle)
6117 throttles.push_back(std::move(dialog_throttle));
6118
6119 return throttles;
clamycbf524d42016-09-27 12:48:356120}
6121
clamy1e5574e2016-09-29 16:48:446122std::unique_ptr<NavigationUIData> WebContentsImpl::GetNavigationUIData(
6123 NavigationHandle* navigation_handle) {
clamy1e5574e2016-09-29 16:48:446124 return GetContentClient()->browser()->GetNavigationUIData(navigation_handle);
6125}
6126
pdr15f5b5b2017-06-20 00:58:006127void WebContentsImpl::DidCancelLoading() {
6128 controller_.DiscardNonCommittedEntries();
6129
6130 // Update the URL display.
6131 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
6132}
6133
[email protected]59167c22013-06-03 18:07:326134void WebContentsImpl::DidAccessInitialDocument() {
[email protected]b4c84012014-04-28 19:51:106135 has_accessed_initial_document_ = true;
6136
[email protected]d1371bf8e2014-04-19 03:26:246137 // We may have left a failed browser-initiated navigation in the address bar
6138 // to let the user edit it and try again. Clear it now that content might
6139 // show up underneath it.
6140 if (!IsLoading() && controller_.GetPendingEntry())
avi45a72532015-04-07 21:01:456141 controller_.DiscardPendingEntry(false);
[email protected]d1371bf8e2014-04-19 03:26:246142
[email protected]59167c22013-06-03 18:07:326143 // Update the URL display.
thestigc4cac8f2014-09-04 21:17:506144 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
[email protected]59167c22013-06-03 18:07:326145}
6146
alexmosbe2f4c32015-03-10 02:30:236147void WebContentsImpl::DidChangeName(RenderFrameHost* render_frame_host,
6148 const std::string& name) {
ericwilligersde386342016-10-19 02:35:096149 for (auto& observer : observers_)
6150 observer.FrameNameChanged(render_frame_host, name);
alexmosbe2f4c32015-03-10 02:30:236151}
6152
John Delaneyedd8d6c2019-01-25 00:23:576153void WebContentsImpl::DidReceiveFirstUserActivation(
6154 RenderFrameHost* render_frame_host) {
6155 for (auto& observer : observers_)
6156 observer.FrameReceivedFirstUserActivation(render_frame_host);
6157}
6158
John Delaney0146a742019-01-25 19:25:286159void WebContentsImpl::DidChangeDisplayState(RenderFrameHost* render_frame_host,
6160 bool is_display_none) {
6161 for (auto& observer : observers_)
6162 observer.FrameDisplayStateChanged(render_frame_host, is_display_none);
6163}
6164
6165void WebContentsImpl::FrameSizeChanged(RenderFrameHost* render_frame_host,
6166 const gfx::Size& frame_size) {
6167 for (auto& observer : observers_)
6168 observer.FrameSizeChanged(render_frame_host, frame_size);
6169}
6170
[email protected]39f2f9252014-05-03 00:54:016171void WebContentsImpl::DocumentOnLoadCompleted(
[email protected]50279492014-05-05 23:24:296172 RenderFrameHost* render_frame_host) {
falken52a56e32016-12-08 05:02:406173 ShowInsecureLocalhostWarningIfNeeded();
6174
Alexander Timindd0fa0c52019-11-06 13:03:376175 GetRenderViewHost()->DocumentOnLoadCompletedInMainFrame();
6176
creis97867aa2017-02-17 18:39:456177 is_notifying_observers_ = true;
ericwilligersde386342016-10-19 02:35:096178 for (auto& observer : observers_)
6179 observer.DocumentOnLoadCompletedInMainFrame();
creis97867aa2017-02-17 18:39:456180 is_notifying_observers_ = false;
[email protected]6578fef2013-10-14 02:35:096181
6182 // TODO(avi): Remove. http://crbug.com/170921
[email protected]8ff00d72012-10-23 19:12:216183 NotificationService::current()->Notify(
6184 NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
6185 Source<WebContents>(this),
[email protected]50279492014-05-05 23:24:296186 NotificationService::NoDetails());
[email protected]25497492010-09-11 15:15:086187}
6188
creis8eb8ef22015-11-04 22:51:386189void WebContentsImpl::UpdateStateForFrame(RenderFrameHost* render_frame_host,
6190 const PageState& page_state) {
creis8eb8ef22015-11-04 22:51:386191 // The state update affects the last NavigationEntry associated with the given
6192 // |render_frame_host|. This may not be the last committed NavigationEntry (as
6193 // in the case of an UpdateState from a frame being swapped out). We track
6194 // which entry this is in the RenderFrameHost's nav_entry_id.
6195 RenderFrameHostImpl* rfhi =
6196 static_cast<RenderFrameHostImpl*>(render_frame_host);
6197 NavigationEntryImpl* entry =
6198 controller_.GetEntryWithUniqueID(rfhi->nav_entry_id());
6199 if (!entry)
6200 return;
6201
6202 FrameNavigationEntry* frame_entry =
6203 entry->GetFrameEntry(rfhi->frame_tree_node());
6204 if (!frame_entry)
6205 return;
6206
creisd06a9422015-11-11 03:08:456207 // The SiteInstance might not match if we do a cross-process navigation with
6208 // replacement (e.g., auto-subframe), in which case the swap out of the old
6209 // RenderFrameHost runs in the background after the old FrameNavigationEntry
6210 // has already been replaced and destroyed.
6211 if (frame_entry->site_instance() != rfhi->GetSiteInstance())
6212 return;
6213
creis8eb8ef22015-11-04 22:51:386214 if (page_state == frame_entry->page_state())
6215 return; // Nothing to update.
6216
creis0cade2e2017-02-28 06:37:476217 DCHECK(page_state.IsValid()) << "Shouldn't set an empty PageState.";
nasko34634672016-07-29 18:46:066218
6219 // The document_sequence_number and item_sequence_number recorded in the
6220 // FrameNavigationEntry should not differ from the one coming with the update,
6221 // since it must come from the same document. Do not update it if a difference
6222 // is detected, as this indicates that |frame_entry| is not the correct one.
6223 ExplodedPageState exploded_state;
6224 if (!DecodePageState(page_state.ToEncodedData(), &exploded_state))
6225 return;
6226
6227 if (exploded_state.top.document_sequence_number !=
6228 frame_entry->document_sequence_number() ||
6229 exploded_state.top.item_sequence_number !=
6230 frame_entry->item_sequence_number()) {
6231 return;
6232 }
6233
nasko04a322f25a2016-09-01 00:00:346234 frame_entry->SetPageState(page_state);
creis8eb8ef22015-11-04 22:51:386235 controller_.NotifyEntryChanged(entry);
6236}
6237
[email protected]ef3adfc2014-05-11 00:04:546238void WebContentsImpl::UpdateTitle(RenderFrameHost* render_frame_host,
[email protected]ef3adfc2014-05-11 00:04:546239 const base::string16& title,
6240 base::i18n::TextDirection title_direction) {
[email protected]ef3adfc2014-05-11 00:04:546241 // Try to find the navigation entry, which might not be the current one.
avi286019ce2015-07-29 01:26:586242 // For example, it might be from a recently swapped out RFH.
avi1edc8552016-10-13 21:37:166243 NavigationEntryImpl* entry = controller_.GetEntryWithUniqueID(
creisad8c31a2016-05-24 17:07:046244 static_cast<RenderFrameHostImpl*>(render_frame_host)->nav_entry_id());
[email protected]ef3adfc2014-05-11 00:04:546245
6246 // We can handle title updates when we don't have an entry in
6247 // UpdateTitleForEntry, but only if the update is from the current RVH.
6248 // TODO(avi): Change to make decisions based on the RenderFrameHost.
avi286019ce2015-07-29 01:26:586249 if (!entry && render_frame_host != GetMainFrame())
[email protected]ef3adfc2014-05-11 00:04:546250 return;
6251
6252 // TODO(evan): make use of title_direction.
6253 // http://code.google.com/p/chromium/issues/detail?id=27094
afakhry6f0c1ec22016-07-14 13:55:136254 UpdateTitleForEntry(entry, title);
[email protected]ef3adfc2014-05-11 00:04:546255}
6256
[email protected]e1c3a552012-05-04 20:51:326257void WebContentsImpl::RouteCloseEvent(RenderViewHost* rvh) {
6258 // Tell the active RenderViewHost to run unload handlers and close, as long
6259 // as the request came from a RenderViewHost in the same BrowsingInstance.
6260 // In most cases, we receive this from a swapped out RenderViewHost.
6261 // It is possible to receive it from one that has just been swapped in,
6262 // in which case we might as well deliver the message anyway.
6263 if (rvh->GetSiteInstance()->IsRelatedSiteInstance(GetSiteInstance()))
naskoc0fceff2015-04-30 15:53:526264 ClosePage();
[email protected]e1c3a552012-05-04 20:51:326265}
6266
alexmose7da5a12015-04-09 02:22:166267bool WebContentsImpl::ShouldRouteMessageEvent(
6268 RenderFrameHost* target_rfh,
6269 SiteInstance* source_site_instance) const {
6270 // Allow the message if this WebContents is dedicated to a browser plugin
6271 // guest.
[email protected]0eba810b2012-10-18 03:19:366272 // Note: This check means that an embedder could theoretically receive a
6273 // postMessage from anyone (not just its own guests). However, this is
6274 // probably not a risk for apps since other pages won't have references
6275 // to App windows.
alexmose7da5a12015-04-09 02:22:166276 return GetBrowserPluginGuest() || GetBrowserPluginEmbedder();
6277}
[email protected]f546640b2012-05-15 00:03:496278
alexmos58729042015-06-18 23:20:006279void WebContentsImpl::EnsureOpenerProxiesExist(RenderFrameHost* source_rfh) {
alexmose7da5a12015-04-09 02:22:166280 WebContentsImpl* source_web_contents = static_cast<WebContentsImpl*>(
6281 WebContents::FromRenderFrameHost(source_rfh));
[email protected]f546640b2012-05-15 00:03:496282
alexmose7da5a12015-04-09 02:22:166283 if (source_web_contents) {
lazyboy6ec48b2a2015-06-29 15:18:146284 // If this message is going to outer WebContents from inner WebContents,
6285 // then we should not create a RenderView. AttachToOuterWebContentsFrame()
6286 // already created a RenderFrameProxyHost for that purpose.
6287 if (GetBrowserPluginEmbedder() &&
W. James MacLean2539adb32019-12-13 00:40:446288 source_web_contents->browser_plugin_guest_) {
lazyboy6ec48b2a2015-06-29 15:18:146289 return;
W. James MacLean2539adb32019-12-13 00:40:446290 }
lazyboy6ec48b2a2015-06-29 15:18:146291
lfg812874d2016-02-09 22:26:136292 if (this != source_web_contents && GetBrowserPluginGuest()) {
naskob3041b98a42016-03-12 04:43:066293 // We create a RenderFrameProxyHost for the embedder in the guest's render
6294 // process but we intentionally do not expose the embedder's opener chain
6295 // to it.
6296 source_web_contents->GetRenderManager()->CreateRenderFrameProxy(
6297 GetSiteInstance());
[email protected]f546640b2012-05-15 00:03:496298 } else {
alexmos58729042015-06-18 23:20:006299 RenderFrameHostImpl* source_rfhi =
6300 static_cast<RenderFrameHostImpl*>(source_rfh);
6301 source_rfhi->frame_tree_node()->render_manager()->CreateOpenerProxies(
alexmos90325cf2015-09-02 17:18:396302 GetSiteInstance(), nullptr);
[email protected]f546640b2012-05-15 00:03:496303 }
6304 }
[email protected]f546640b2012-05-15 00:03:496305}
6306
avallee9993fca2016-11-17 06:16:506307void WebContentsImpl::SetAsFocusedWebContentsIfNecessary() {
Adithya Srinivasan11af2c52019-12-16 22:52:556308 DCHECK(!portal());
avallee9993fca2016-11-17 06:16:506309 // Only change focus if we are not currently focused.
6310 WebContentsImpl* old_contents = GetFocusedWebContents();
6311 if (old_contents == this)
6312 return;
6313
paulmeyerfeafc2d2017-04-25 21:46:406314 GetOutermostWebContents()->node_.SetFocusedWebContents(this);
6315
avallee9993fca2016-11-17 06:16:506316 // Send a page level blur to the old contents so that it displays inactive UI
6317 // and focus this contents to activate it.
6318 if (old_contents)
6319 old_contents->GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(false);
avalleec2ff1ef2017-01-21 00:12:306320
6321 // Make sure the outer web contents knows our frame is focused. Otherwise, the
6322 // outer renderer could have the element before or after the frame element
6323 // focused which would return early without actually advancing focus.
avalleed68cdd12017-06-21 22:07:276324 FocusOuterAttachmentFrameChain();
avalleec2ff1ef2017-01-21 00:12:306325
lfg1453e412017-04-11 00:48:506326 if (ShowingInterstitialPage()) {
creisadca9862017-06-16 19:12:116327 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:506328 ->GetRenderWidgetHost()
6329 ->SetPageFocus(true);
6330 } else {
6331 GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(true);
6332 }
avallee9993fca2016-11-17 06:16:506333}
6334
avallee0206f782016-07-28 18:55:336335void WebContentsImpl::SetFocusedFrame(FrameTreeNode* node,
6336 SiteInstance* source) {
Adithya Srinivasan11af2c52019-12-16 22:52:556337 DCHECK(!portal());
avallee0206f782016-07-28 18:55:336338 frame_tree_.SetFocusedFrame(node, source);
avalleed68cdd12017-06-21 22:07:276339
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576340 if (auto* inner_contents = node_.GetInnerWebContentsInFrame(node)) {
6341 // |this| is an outer WebContents and |node| represents an inner
6342 // WebContents. Transfer the focus to the inner contents if |this| is
6343 // focused.
6344 if (GetFocusedWebContents() == this)
6345 inner_contents->SetAsFocusedWebContentsIfNecessary();
6346 } else if (node_.OuterContentsFrameTreeNode() &&
6347 node_.OuterContentsFrameTreeNode()
6348 ->current_frame_host()
6349 ->GetSiteInstance() == source) {
6350 // |this| is an inner WebContents, |node| is its main FrameTreeNode and
6351 // the outer WebContents FrameTreeNode is at |source|'s SiteInstance.
6352 // Transfer the focus to the inner WebContents if the outer WebContents is
6353 // focused. This branch is used when an inner WebContents is focused through
Lowell Mannersa9530382019-08-01 09:46:576354 // its RenderFrameProxyHost (via FrameFocused mojo call, used to
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576355 // implement the window.focus() API).
6356 if (GetFocusedWebContents() == GetOuterWebContents())
6357 SetAsFocusedWebContentsIfNecessary();
6358 } else if (!GetOuterWebContents()) {
6359 // This is an outermost WebContents.
6360 SetAsFocusedWebContentsIfNecessary();
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576361 }
avalleed68cdd12017-06-21 22:07:276362}
6363
Avi Drissman36f801f2018-02-01 20:06:046364void WebContentsImpl::DidCallFocus() {
6365 // Any explicit focusing of another window while this WebContents is in
6366 // fullscreen can be used to confuse the user, so drop fullscreen.
Avi Drissman1a55a9d62020-03-10 18:56:456367 base::ScopedClosureRunner fullscreen_block = ForSecurityDropFullscreen();
6368 // The other contents is independent of this contents, so release the
6369 // fullscreen block.
6370 fullscreen_block.RunAndReset();
Avi Drissman36f801f2018-02-01 20:06:046371}
6372
avalleed68cdd12017-06-21 22:07:276373RenderFrameHost* WebContentsImpl::GetFocusedFrameIncludingInnerWebContents() {
6374 WebContentsImpl* contents = this;
6375 FrameTreeNode* focused_node = contents->frame_tree_.GetFocusedFrame();
6376
6377 // If there is no focused frame in the outer WebContents, we need to return
6378 // null.
6379 if (!focused_node)
6380 return nullptr;
6381
6382 // If the focused frame is embedding an inner WebContents, we must descend
6383 // into that contents. If the current WebContents does not have a focused
6384 // frame, return the main frame of this contents instead of the focused empty
6385 // frame embedding this contents.
6386 while (true) {
6387 contents = contents->node_.GetInnerWebContentsInFrame(focused_node);
6388 if (!contents)
6389 return focused_node->current_frame_host();
6390
6391 focused_node = contents->frame_tree_.GetFocusedFrame();
6392 if (!focused_node)
6393 return contents->GetMainFrame();
6394 }
avallee0206f782016-07-28 18:55:336395}
6396
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576397void WebContentsImpl::OnAdvanceFocus(RenderFrameHostImpl* source_rfh) {
6398 // When a RenderFrame needs to advance focus to a RenderFrameProxy (by hitting
6399 // TAB), the RenderFrameProxy sends an IPC to RenderFrameProxyHost. When this
6400 // RenderFrameProxyHost represents an inner WebContents, the outer WebContents
6401 // needs to focus the inner WebContents.
6402 if (GetOuterWebContents() &&
6403 GetOuterWebContents() == source_rfh->delegate()->GetAsWebContents() &&
6404 GetFocusedWebContents() == GetOuterWebContents()) {
6405 SetAsFocusedWebContentsIfNecessary();
6406 }
6407}
6408
ekaramada110f642016-12-21 19:47:286409void WebContentsImpl::OnFocusedElementChangedInFrame(
6410 RenderFrameHostImpl* frame,
6411 const gfx::Rect& bounds_in_root_view) {
6412 RenderWidgetHostViewBase* root_view =
6413 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
6414 if (!root_view || !frame->GetView())
6415 return;
6416
6417 // Converting to screen coordinates.
6418 gfx::Point origin = bounds_in_root_view.origin();
6419 origin += root_view->GetViewBounds().OffsetFromOrigin();
6420 gfx::Rect bounds_in_screen(origin, bounds_in_root_view.size());
6421
6422 root_view->FocusedNodeChanged(frame->has_focused_editable_element(),
6423 bounds_in_screen);
6424
6425 FocusedNodeDetails details = {frame->has_focused_editable_element(),
6426 bounds_in_screen};
6427
6428 // TODO(ekaramad): We should replace this with an observer notification
6429 // (https://crbug.com/675975).
6430 NotificationService::current()->Notify(
6431 NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
6432 Source<RenderViewHost>(GetRenderViewHost()),
6433 Details<FocusedNodeDetails>(&details));
Jeff Fisher709b4c52019-07-29 20:07:346434
6435 for (auto& observer : observers_)
6436 observer.OnFocusChangedInPage(&details);
ekaramada110f642016-12-21 19:47:286437}
6438
Lowell Manners1de5242e2019-04-25 10:18:466439bool WebContentsImpl::DidAddMessageToConsole(
6440 blink::mojom::ConsoleMessageLevel log_level,
6441 const base::string16& message,
6442 int32_t line_no,
6443 const base::string16& source_id) {
Devlin Cronin5ea668f32019-12-18 21:57:586444 for (auto& observer : observers_)
6445 observer.OnDidAddMessageToConsole(log_level, message, line_no, source_id);
6446
[email protected]a796f202012-05-30 14:14:256447 if (!delegate_)
6448 return false;
Lowell Manners1de5242e2019-04-25 10:18:466449 return delegate_->DidAddMessageToConsole(this, log_level, message, line_no,
avia90ae4e2016-11-11 20:49:336450 source_id);
[email protected]a796f202012-05-30 14:14:256451}
6452
Daniel Cheng90196c82018-04-25 21:49:146453void WebContentsImpl::DidReceiveInputEvent(
dominickn9c7ceaa32016-02-27 01:52:536454 RenderWidgetHostImpl* render_widget_host,
6455 const blink::WebInputEvent::Type type) {
Dominick Ng37a15052018-07-17 23:56:356456 if (!IsUserInteractionInputType(type))
Daniel Cheng90196c82018-04-25 21:49:146457 return;
6458
kenrb19221852016-04-29 17:21:406459 // Ignore unless the widget is currently in the frame tree.
6460 if (!HasMatchingWidgetHost(&frame_tree_, render_widget_host))
avic3aa8422015-11-09 20:57:226461 return;
6462
Daniel Cheng90196c82018-04-25 21:49:146463 if (type != blink::WebInputEvent::kGestureScrollBegin)
6464 last_interactive_input_event_time_ = ui::EventTimeForNow();
dominickn9c7ceaa32016-02-27 01:52:536465
Dominick Ng37a15052018-07-17 23:56:356466 for (auto& observer : observers_)
6467 observer.DidGetUserInteraction(type);
dominickn2dd142dd2015-10-29 05:30:506468}
6469
Avi Drissman738ea192018-08-29 20:24:166470bool WebContentsImpl::ShouldIgnoreInputEvents() {
6471 WebContentsImpl* web_contents = this;
6472 while (web_contents) {
6473 if (web_contents->ignore_input_events_)
6474 return true;
6475 web_contents = web_contents->GetOuterWebContents();
6476 }
6477
6478 return false;
6479}
6480
avallee9993fca2016-11-17 06:16:506481void WebContentsImpl::FocusOwningWebContents(
6482 RenderWidgetHostImpl* render_widget_host) {
Alex Moshchukc4f0a722019-11-19 22:41:286483 RenderWidgetHostImpl* main_frame_widget_host =
6484 GetMainFrame()->GetRenderWidgetHost();
avallee9993fca2016-11-17 06:16:506485 RenderWidgetHostImpl* focused_widget =
Alex Moshchukc4f0a722019-11-19 22:41:286486 GetFocusedRenderWidgetHost(main_frame_widget_host);
avallee9993fca2016-11-17 06:16:506487
6488 if (focused_widget != render_widget_host &&
avallee8e881592016-11-19 00:39:306489 (!focused_widget ||
6490 focused_widget->delegate() != render_widget_host->delegate())) {
avallee9993fca2016-11-17 06:16:506491 SetAsFocusedWebContentsIfNecessary();
6492 }
6493}
6494
[email protected]b172aee2012-04-10 17:05:266495void WebContentsImpl::OnIgnoredUIEvent() {
[email protected]31145092011-09-30 01:49:446496 // Notify observers.
ericwilligersde386342016-10-19 02:35:096497 for (auto& observer : observers_)
6498 observer.DidGetIgnoredUIEvent();
[email protected]fa1cf0b82010-01-15 21:49:446499}
6500
avic3aa8422015-11-09 20:57:226501void WebContentsImpl::RendererUnresponsive(
Lukasz Anforowicz52b93722018-06-20 16:11:396502 RenderWidgetHostImpl* render_widget_host,
6503 base::RepeatingClosure hang_monitor_restarter) {
avic031d392017-03-03 03:09:426504 if (ShouldIgnoreUnresponsiveRenderer())
[email protected]e5fc1632011-08-08 07:51:536505 return;
6506
Lukasz Anforowicz4f0593d2018-09-21 18:33:546507 // Do not report hangs (to task manager, to hang renderer dialog, etc.) for
6508 // invisible tabs (like extension background page, background tabs). See
6509 // https://crbug.com/881812 for rationale and for choosing the visibility
6510 // (rather than process priority) as the signal here.
6511 if (GetVisibility() != Visibility::VISIBLE)
6512 return;
6513
Avi Drissman8920def2018-01-31 19:53:366514 if (!render_widget_host->renderer_initialized())
[email protected]55452902011-06-01 21:57:476515 return;
6516
Lukasz Anforowicz4f0593d2018-09-21 18:33:546517 for (auto& observer : observers_)
6518 observer.OnRendererUnresponsive(render_widget_host->GetProcess());
6519
Dave Tapuskac6146c52017-12-20 22:48:156520 if (delegate_)
Lukasz Anforowicz52b93722018-06-20 16:11:396521 delegate_->RendererUnresponsive(this, render_widget_host,
6522 std::move(hang_monitor_restarter));
[email protected]420ae012009-04-24 05:16:326523}
6524
avic3aa8422015-11-09 20:57:226525void WebContentsImpl::RendererResponsive(
6526 RenderWidgetHostImpl* render_widget_host) {
[email protected]6934a702011-12-20 00:04:516527 if (delegate_)
Avi Drissman1572e8c3c2018-02-02 19:06:366528 delegate_->RendererResponsive(this, render_widget_host);
[email protected]420ae012009-04-24 05:16:326529}
6530
Alex Moshchuk7b4f0652019-05-30 18:54:416531void WebContentsImpl::SubframeCrashed(
6532 blink::mojom::FrameVisibility visibility) {
6533 // If a subframe crashed on a hidden tab, mark the tab for reload to avoid
6534 // showing a sad frame to the user if they ever switch back to that tab. Do
6535 // this for subframes that are either visible in viewport or visible but
6536 // scrolled out of view, but skip subframes that are not rendered (e.g., via
6537 // "display:none"), since in that case the user wouldn't see a sad frame
6538 // anyway.
6539 bool did_mark_for_reload = false;
6540 if (IsHidden() && visibility != blink::mojom::FrameVisibility::kNotRendered &&
6541 base::FeatureList::IsEnabled(
6542 features::kReloadHiddenTabsWithCrashedSubframes)) {
6543 controller_.SetNeedsReload(
6544 NavigationControllerImpl::NeedsReloadType::kCrashedSubframe);
6545 did_mark_for_reload = true;
6546 UMA_HISTOGRAM_ENUMERATION(
6547 "Stability.ChildFrameCrash.TabMarkedForReload.Visibility", visibility);
6548 }
6549
6550 UMA_HISTOGRAM_BOOLEAN("Stability.ChildFrameCrash.TabMarkedForReload",
6551 did_mark_for_reload);
6552}
6553
[email protected]b172aee2012-04-10 17:05:266554void WebContentsImpl::BeforeUnloadFiredFromRenderManager(
[email protected]feaded02012-09-25 19:12:556555 bool proceed, const base::TimeTicks& proceed_time,
[email protected]420ae012009-04-24 05:16:326556 bool* proceed_to_fire_unload) {
ericwilligersde386342016-10-19 02:35:096557 for (auto& observer : observers_)
Chris Hamilton3b3e315d2018-09-19 13:16:216558 observer.BeforeUnloadFired(proceed, proceed_time);
[email protected]6934a702011-12-20 00:04:516559 if (delegate_)
6560 delegate_->BeforeUnloadFired(this, proceed, proceed_to_fire_unload);
[email protected]e80af492013-06-24 21:52:096561 // Note: |this| might be deleted at this point.
[email protected]420ae012009-04-24 05:16:326562}
6563
[email protected]58d5cfe2013-07-10 02:40:526564void WebContentsImpl::RenderProcessGoneFromRenderManager(
[email protected]3a3d47472010-07-15 21:03:546565 RenderViewHost* render_view_host) {
[email protected]443b80e2010-12-14 00:42:236566 DCHECK(crashed_status_ != base::TERMINATION_STATUS_STILL_RUNNING);
[email protected]ec6a7eb2013-04-22 17:34:226567 RenderViewTerminated(render_view_host, crashed_status_, crashed_error_code_);
[email protected]3a3d47472010-07-15 21:03:546568}
6569
Jianzhou Fengd8720c72018-01-18 03:06:306570void WebContentsImpl::UpdateRenderViewSizeForRenderManager(bool is_main_frame) {
[email protected]8643e6d2012-01-18 20:26:106571 // TODO(brettw) this is a hack. See WebContentsView::SizeContents.
Jianzhou Fengd8720c72018-01-18 03:06:306572 gfx::Size size = GetSizeForNewRenderView(is_main_frame);
[email protected]0323ee42010-02-17 22:03:266573 // 0x0 isn't a valid window size (minimal window size is 1x1) but it may be
6574 // here during container initialization and normal window size will be set
6575 // later. In case of tab duplication this resizing to 0x0 prevents setting
6576 // normal size later so just ignore it.
6577 if (!size.IsEmpty())
6578 view_->SizeContents(size);
[email protected]420ae012009-04-24 05:16:326579}
6580
[email protected]af905902013-10-01 21:38:516581void WebContentsImpl::CancelModalDialogsForRenderManager() {
6582 // We need to cancel modal dialogs when doing a process swap, since the load
avi2460c762015-04-17 15:21:546583 // deferrer would prevent us from swapping out. We also clear the state
6584 // because this is a cross-process navigation, which means that it's a new
6585 // site that should not have to pay for the sins of its predecessor.
creis89a0f782015-05-27 16:13:176586 //
Lei Zhang6410ec1a2019-01-31 21:38:586587 // Note that we don't bother telling |browser_plugin_embedder_| because the
creis89a0f782015-05-27 16:13:176588 // cross-process navigation will either destroy the browser plugins or not
6589 // require their dialogs to close.
avi5d3b8692016-10-12 22:00:466590 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:536591 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:466592 }
[email protected]af905902013-10-01 21:38:516593}
6594
[email protected]02d7b6e2014-06-24 21:01:506595void WebContentsImpl::NotifySwappedFromRenderManager(RenderFrameHost* old_host,
6596 RenderFrameHost* new_host,
6597 bool is_main_frame) {
6598 if (is_main_frame) {
Fergal Daly6767b2e2020-02-04 03:15:166599 RenderViewHost* old_rvh =
6600 old_host ? old_host->GetRenderViewHost() : nullptr;
6601 RenderViewHost* new_rvh = new_host->GetRenderViewHost();
6602 // |old_rvh| and |new_rvh| might be equal when navigating from a crashed
6603 // RenderFrameHost to a new same-site one. With RenderDocument, this will
6604 // happen for every same-site navigation.
6605 if (old_rvh != new_rvh)
6606 NotifyViewSwapped(old_rvh, new_rvh);
[email protected]a6b73c62013-02-11 23:05:086607
[email protected]02d7b6e2014-06-24 21:01:506608 // Make sure the visible RVH reflects the new delegate's preferences.
6609 if (delegate_)
6610 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]d56a49e2013-02-23 00:47:396611
dmazzoni62111452017-04-28 23:46:556612 RenderWidgetHostViewBase* rwhv =
6613 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
6614 if (rwhv)
6615 rwhv->SetMainFrameAXTreeID(GetMainFrame()->GetAXTreeID());
[email protected]02d7b6e2014-06-24 21:01:506616 }
6617
Jinsuk Kim895b2c52018-07-03 06:49:166618 NotifyFrameSwapped(old_host, new_host, is_main_frame);
[email protected]3a3d47472010-07-15 21:03:546619}
6620
naskof5940b9f2015-03-02 23:04:056621void WebContentsImpl::NotifyMainFrameSwappedFromRenderManager(
Jinsuk Kim895b2c52018-07-03 06:49:166622 RenderFrameHost* old_host,
6623 RenderFrameHost* new_host) {
6624 NotifyViewSwapped(old_host ? old_host->GetRenderViewHost() : nullptr,
6625 new_host->GetRenderViewHost());
naskof5940b9f2015-03-02 23:04:056626}
6627
[email protected]b172aee2012-04-10 17:05:266628NavigationControllerImpl& WebContentsImpl::GetControllerForRenderManager() {
[email protected]d1198fd2012-08-13 22:50:196629 return GetController();
[email protected]3a3d47472010-07-15 21:03:546630}
6631
dcheng59716272016-04-09 05:19:086632std::unique_ptr<WebUIImpl> WebContentsImpl::CreateWebUIForRenderFrameHost(
carlosk37f793792014-11-27 15:08:296633 const GURL& url) {
Dan Beam055fe8f2017-10-04 23:23:366634 return CreateWebUI(url);
[email protected]420ae012009-04-24 05:16:326635}
6636
creisadca9862017-06-16 19:12:116637InterstitialPageImpl* WebContentsImpl::GetInterstitialForRenderManager() {
6638 return interstitial_page_;
6639}
6640
lfgbede6392015-09-11 21:54:066641void WebContentsImpl::CreateRenderWidgetHostViewForRenderManager(
6642 RenderViewHost* render_view_host) {
lfgc740d4b22016-04-15 16:45:336643 RenderWidgetHostViewBase* rwh_view =
W. James MacLean13d834d2019-12-04 16:06:456644 view_->CreateViewForWidget(render_view_host->GetWidget());
danakjf616f2252019-09-18 21:44:096645 rwh_view->SetSize(GetSizeForNewRenderView(true));
lfgbede6392015-09-11 21:54:066646}
6647
6648bool WebContentsImpl::CreateRenderViewForRenderManager(
6649 RenderViewHost* render_view_host,
6650 int opener_frame_routing_id,
6651 int proxy_routing_id,
Pavel Feldman25234722017-10-11 02:49:066652 const base::UnguessableToken& devtools_frame_token,
lfgbede6392015-09-11 21:54:066653 const FrameReplicationState& replicated_frame_state) {
6654 TRACE_EVENT0("browser,navigation",
6655 "WebContentsImpl::CreateRenderViewForRenderManager");
6656
piman00cf9402017-04-03 17:09:206657 if (proxy_routing_id == MSG_ROUTING_NONE)
lfg9431efd2016-12-14 14:45:266658 CreateRenderWidgetHostViewForRenderManager(render_view_host);
lfg9431efd2016-12-14 14:45:266659
piman00cf9402017-04-03 17:09:206660 if (!static_cast<RenderViewHostImpl*>(render_view_host)
6661 ->CreateRenderView(opener_frame_routing_id, proxy_routing_id,
Pavel Feldman25234722017-10-11 02:49:066662 devtools_frame_token, replicated_frame_state,
6663 created_with_opener_)) {
[email protected]a4127722011-04-27 23:13:526664 return false;
[email protected]14392a52012-05-02 20:28:446665 }
W. James MacLean62198672019-06-04 16:46:106666 // Set the TextAutosizer state from the main frame's renderer on the new view,
6667 // but only if it's not for the main frame. Main frame renderers should create
6668 // this state themselves from up-to-date values, so we shouldn't override it
6669 // with the cached values.
6670 if (!render_view_host->GetMainFrame()) {
6671 render_view_host->Send(
6672 new PageMsg_UpdateTextAutosizerPageInfoForRemoteMainFrames(
6673 render_view_host->GetRoutingID(), text_autosizer_page_info_));
6674 }
[email protected]a4127722011-04-27 23:13:526675
Lucas Furukawa Gadaniaed1fed2017-10-13 17:34:146676 if (proxy_routing_id == MSG_ROUTING_NONE && node_.outer_web_contents())
6677 ReattachToOuterWebContentsFrame();
6678
avi2b177592014-12-10 02:08:026679 SetHistoryOffsetAndLengthForView(render_view_host,
6680 controller_.GetLastCommittedEntryIndex(),
6681 controller_.GetEntryCount());
6682
[email protected]a220b5932013-09-21 03:47:446683#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
[email protected]f8233cc2011-05-31 20:24:506684 // Force a ViewMsg_Resize to be sent, needed to make plugins show up on
6685 // linux. See crbug.com/83941.
avif9ab5d942015-10-15 14:05:446686 RenderWidgetHostView* rwh_view = render_view_host->GetWidget()->GetView();
[email protected]245f7d52011-11-28 15:36:446687 if (rwh_view) {
6688 if (RenderWidgetHost* render_widget_host = rwh_view->GetRenderWidgetHost())
Fady Samuel0b911822018-04-25 13:22:166689 render_widget_host->SynchronizeVisualProperties();
[email protected]245f7d52011-11-28 15:36:446690 }
[email protected]f8233cc2011-05-31 20:24:506691#endif
6692
[email protected]420ae012009-04-24 05:16:326693 return true;
6694}
6695
[email protected]82307f6b2014-08-07 03:30:126696bool WebContentsImpl::CreateRenderFrameForRenderManager(
6697 RenderFrameHost* render_frame_host,
arthursonzogni1efc7b962019-03-14 09:36:336698 int previous_routing_id,
alexmosa181efc2015-09-03 00:39:046699 int opener_routing_id,
japhete6adf142014-10-31 00:01:496700 int parent_routing_id,
alexmosa181efc2015-09-03 00:39:046701 int previous_sibling_routing_id) {
naskob8744d22014-08-28 17:07:436702 TRACE_EVENT0("browser,navigation",
6703 "WebContentsImpl::CreateRenderFrameForRenderManager");
[email protected]82307f6b2014-08-07 03:30:126704
6705 RenderFrameHostImpl* rfh =
6706 static_cast<RenderFrameHostImpl*>(render_frame_host);
arthursonzogni1efc7b962019-03-14 09:36:336707 if (!rfh->CreateRenderFrame(previous_routing_id, opener_routing_id,
alexmosa181efc2015-09-03 00:39:046708 parent_routing_id, previous_sibling_routing_id))
[email protected]82307f6b2014-08-07 03:30:126709 return false;
6710
6711 // TODO(nasko): When RenderWidgetHost is owned by RenderFrameHost, the passed
6712 // RenderFrameHost will have to be associated with the appropriate
6713 // RenderWidgetHostView or a new one should be created here.
6714
6715 return true;
6716}
6717
mfomitchev2b8b066a2016-01-28 19:23:156718#if defined(OS_ANDROID)
[email protected]fc2b46b2014-05-03 16:33:456719
[email protected]155c7f22013-12-09 17:07:186720base::android::ScopedJavaLocalRef<jobject>
6721WebContentsImpl::GetJavaWebContents() {
mostynb042582e2015-03-16 22:13:406722 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]0e813a52014-08-13 10:34:566723 return GetWebContentsAndroid()->GetJavaObject();
6724}
[email protected]155c7f22013-12-09 17:07:186725
[email protected]0e813a52014-08-13 10:34:566726WebContentsAndroid* WebContentsImpl::GetWebContentsAndroid() {
Kevin McNee576bb5d82019-05-29 16:47:516727 if (!web_contents_android_) {
6728 web_contents_android_ = std::make_unique<WebContentsAndroid>(this);
[email protected]155c7f22013-12-09 17:07:186729 }
Kevin McNee576bb5d82019-05-29 16:47:516730 return web_contents_android_.get();
6731}
6732
6733void WebContentsImpl::ClearWebContentsAndroid() {
6734 DCHECK_CURRENTLY_ON(BrowserThread::UI);
6735 web_contents_android_.reset();
[email protected]155c7f22013-12-09 17:07:186736}
6737
paulmeyerc0b762b2016-04-13 11:55:176738void WebContentsImpl::ActivateNearestFindResult(float x,
6739 float y) {
6740 GetOrCreateFindRequestManager()->ActivateNearestFindResult(x, y);
6741}
6742
6743void WebContentsImpl::RequestFindMatchRects(int current_version) {
6744 GetOrCreateFindRequestManager()->RequestFindMatchRects(current_version);
6745}
6746
[email protected]7d244f12013-08-22 21:41:516747bool WebContentsImpl::CreateRenderViewForInitialEmptyDocument() {
nasko4c0feb62015-06-05 18:37:066748 return CreateRenderViewForRenderManager(
6749 GetRenderViewHost(), MSG_ROUTING_NONE, MSG_ROUTING_NONE,
Pavel Feldman25234722017-10-11 02:49:066750 frame_tree_.root()->devtools_frame_token(),
lfgbede6392015-09-11 21:54:066751 frame_tree_.root()->current_replication_state());
[email protected]7d244f12013-08-22 21:41:516752}
[email protected]fc2b46b2014-05-03 16:33:456753
rockot400ea35b2016-10-15 19:15:326754service_manager::InterfaceProvider* WebContentsImpl::GetJavaInterfaces() {
sammcf5f1b0f2016-09-20 23:05:116755 if (!java_interfaces_) {
Gyuyoung Kim6c9ce9022019-11-26 05:40:086756 mojo::PendingRemote<service_manager::mojom::InterfaceProvider> provider;
6757 BindInterfaceRegistryForWebContents(
6758 provider.InitWithNewPipeAndPassReceiver(), this);
rockot400ea35b2016-10-15 19:15:326759 java_interfaces_.reset(new service_manager::InterfaceProvider);
sammcf5f1b0f2016-09-20 23:05:116760 java_interfaces_->Bind(std::move(provider));
6761 }
6762 return java_interfaces_.get();
6763}
6764
Francois Doray6c26f3342018-08-24 17:17:226765#endif
6766
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:416767bool WebContentsImpl::CompletedFirstVisuallyNonEmptyPaint() {
Carlos Caballero91fffb22019-10-29 15:24:306768 return GetRenderViewHost()->did_first_visually_non_empty_paint();
spqchane72c3cb2017-06-30 23:02:106769}
6770
pkotwicz75ca8ffd2016-02-16 23:10:196771void WebContentsImpl::OnDidDownloadImage(
Avi Drissmana5a52dd2018-03-27 03:39:026772 ImageDownloadCallback callback,
pkotwicz75ca8ffd2016-02-16 23:10:196773 int id,
6774 const GURL& image_url,
leon.hancbc4bc3c2016-02-26 07:08:526775 int32_t http_status_code,
leon.hanc2228532016-08-16 05:59:186776 const std::vector<SkBitmap>& images,
6777 const std::vector<gfx::Size>& original_image_sizes) {
Avi Drissmana5a52dd2018-03-27 03:39:026778 std::move(callback).Run(id, http_status_code, image_url, images,
6779 original_image_sizes);
pkotwicz75ca8ffd2016-02-16 23:10:196780}
6781
[email protected]6fba26d2014-04-29 09:38:286782void WebContentsImpl::OnDialogClosed(int render_process_id,
6783 int render_frame_id,
Dave Tapuskacdf545cc2020-01-23 18:38:526784 JavaScriptDialogCallback response_callback,
Avi Drissman1a55a9d62020-03-10 18:56:456785 base::ScopedClosureRunner fullscreen_block,
[email protected]87de04b02014-04-08 22:14:496786 bool dialog_was_suppressed,
[email protected]b172aee2012-04-10 17:05:266787 bool success,
[email protected]fcf75d42013-12-03 20:11:266788 const base::string16& user_input) {
[email protected]6fba26d2014-04-29 09:38:286789 RenderFrameHostImpl* rfh = RenderFrameHostImpl::FromID(render_process_id,
6790 render_frame_id);
[email protected]87de04b02014-04-08 22:14:496791 last_dialog_suppressed_ = dialog_was_suppressed;
Avi Drissman1a55a9d62020-03-10 18:56:456792 fullscreen_block.RunAndReset();
[email protected]87de04b02014-04-08 22:14:496793
Charlie Reis96077362019-07-04 00:34:046794 javascript_dialog_navigation_deferrer_.reset();
6795
[email protected]beb440c2009-11-06 04:08:546796 if (is_showing_before_unload_dialog_ && !success) {
clamybc6f4152016-04-01 20:14:236797 // It is possible for the current RenderFrameHost to have changed in the
6798 // meantime. Do not reset the navigation state in that case.
6799 if (rfh && rfh == rfh->frame_tree_node()->current_frame_host()) {
clamy44e84ce2016-02-22 15:38:256800 rfh->frame_tree_node()->BeforeUnloadCanceled();
clamybc6f4152016-04-01 20:14:236801 controller_.DiscardNonCommittedEntries();
6802 }
[email protected]ec8e8b02013-06-19 04:57:106803
Charles Reis15d60b132017-11-03 17:43:476804 // Update the URL display either way, to avoid showing a stale URL.
6805 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
6806
ericwilligersde386342016-10-19 02:35:096807 for (auto& observer : observers_)
6808 observer.BeforeUnloadDialogCancelled();
[email protected]beb440c2009-11-06 04:08:546809 }
[email protected]87de04b02014-04-08 22:14:496810
Dave Tapuskacdf545cc2020-01-23 18:38:526811 std::move(response_callback).Run(success, user_input);
Pavel Feldman3c1842b2017-08-02 05:00:166812
Dave Tapuskacdf545cc2020-01-23 18:38:526813 std::vector<protocol::PageHandler*> page_handlers =
6814 protocol::PageHandler::EnabledForWebContents(this);
6815 for (auto* handler : page_handlers)
6816 handler->DidCloseJavaScriptDialog(success, user_input);
avi1c51fb62017-02-27 20:43:036817
6818 is_showing_javascript_dialog_ = false;
6819 is_showing_before_unload_dialog_ = false;
[email protected]beb440c2009-11-06 04:08:546820}
6821
[email protected]1ac10dca2013-08-20 20:47:046822bool WebContentsImpl::IsHidden() {
Francois Doraye6161152018-03-27 22:05:376823 return !IsBeingCaptured() && visibility_ != Visibility::VISIBLE;
[email protected]1ac10dca2013-08-20 20:47:046824}
6825
rob97250742015-12-10 17:45:156826int WebContentsImpl::GetOuterDelegateFrameTreeNodeId() {
lfg601233692017-03-06 22:45:446827 return node_.outer_contents_frame_tree_node_id();
lazyboy6ec48b2a2015-06-29 15:18:146828}
6829
ekaramadaeb3c5c2016-11-09 03:22:356830RenderWidgetHostImpl* WebContentsImpl::GetFullscreenRenderWidgetHost() const {
6831 return RenderWidgetHostImpl::FromID(fullscreen_widget_process_id_,
6832 fullscreen_widget_routing_id_);
6833}
6834
[email protected]b0936d22013-11-28 06:47:366835RenderFrameHostManager* WebContentsImpl::GetRenderManager() const {
[email protected]fa944cb82013-11-15 17:51:216836 return frame_tree_.root()->render_manager();
6837}
6838
[email protected]f8497342013-02-05 22:15:026839BrowserPluginGuest* WebContentsImpl::GetBrowserPluginGuest() const {
[email protected]7a846df2012-09-20 19:17:396840 return browser_plugin_guest_.get();
6841}
6842
Albert J. Wongc55cc64d2018-10-12 02:50:046843void WebContentsImpl::SetBrowserPluginGuest(
6844 std::unique_ptr<BrowserPluginGuest> guest) {
6845 DCHECK(!browser_plugin_guest_);
6846 DCHECK(guest);
6847 browser_plugin_guest_ = std::move(guest);
[email protected]738f57a2013-06-29 21:06:546848}
6849
Aidan Wolter52bcc12a2018-11-14 03:27:296850base::UnguessableToken WebContentsImpl::GetAudioGroupId() {
Aidan Wolter52bcc12a2018-11-14 03:27:296851 return GetAudioStreamFactory()->group_id();
6852}
6853
Sofiya Semenova5e9d9122019-07-11 02:46:416854ukm::SourceId WebContentsImpl::GetLastCommittedSourceId() {
6855 return last_committed_source_id_;
6856}
6857
Miyoung Shin5709ab02020-02-19 06:50:416858const std::vector<blink::mojom::FaviconURLPtr>&
6859WebContentsImpl::GetFaviconURLs() {
Mounir Lamouri7b4a1f232019-12-23 16:32:106860 return favicon_urls_;
6861}
6862
[email protected]f8497342013-02-05 22:15:026863BrowserPluginEmbedder* WebContentsImpl::GetBrowserPluginEmbedder() const {
[email protected]7a846df2012-09-20 19:17:396864 return browser_plugin_embedder_.get();
6865}
[email protected]8ff00d72012-10-23 19:12:216866
fsamuel60b42282015-03-10 03:29:146867void WebContentsImpl::CreateBrowserPluginEmbedderIfNecessary() {
6868 if (browser_plugin_embedder_)
6869 return;
6870 browser_plugin_embedder_.reset(BrowserPluginEmbedder::Create(this));
6871}
6872
Jianzhou Fengd8720c72018-01-18 03:06:306873gfx::Size WebContentsImpl::GetSizeForNewRenderView(bool is_main_frame) {
[email protected]dc0fd432013-08-27 15:29:216874 gfx::Size size;
Jianzhou Fengd8720c72018-01-18 03:06:306875 if (is_main_frame)
6876 size = device_emulation_size_;
6877 if (size.IsEmpty() && delegate_)
[email protected]dc0fd432013-08-27 15:29:216878 size = delegate_->GetSizeForNewRenderView(this);
6879 if (size.IsEmpty())
[email protected]fc2b46b2014-05-03 16:33:456880 size = GetContainerBounds().size();
[email protected]dc0fd432013-08-27 15:29:216881 return size;
6882}
6883
[email protected]ae7eeda2014-07-04 01:53:266884void WebContentsImpl::OnFrameRemoved(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:096885 for (auto& observer : observers_)
6886 observer.FrameDeleted(render_frame_host);
[email protected]9b159a52013-10-03 17:24:556887}
6888
[email protected]222f5822014-02-05 23:40:496889void WebContentsImpl::OnPreferredSizeChanged(const gfx::Size& old_size) {
6890 if (!delegate_)
6891 return;
6892 const gfx::Size new_size = GetPreferredSize();
6893 if (new_size != old_size)
6894 delegate_->UpdatePreferredSize(this, new_size);
6895}
6896
Dan Beam055fe8f2017-10-04 23:23:366897std::unique_ptr<WebUIImpl> WebContentsImpl::CreateWebUI(const GURL& url) {
Jeremy Roman04f27c372017-10-27 15:20:556898 std::unique_ptr<WebUIImpl> web_ui = std::make_unique<WebUIImpl>(this);
Lei Zhangee3b63ad2018-06-06 23:25:316899 std::unique_ptr<WebUIController> controller(
avie865b1d2016-10-24 19:42:596900 WebUIControllerFactoryRegistry::GetInstance()
Lei Zhangee3b63ad2018-06-06 23:25:316901 ->CreateWebUIControllerForURL(web_ui.get(), url));
dbeama1b926a2015-08-31 23:17:516902 if (controller) {
Lei Zhangee3b63ad2018-06-06 23:25:316903 web_ui->SetController(std::move(controller));
dbeama1b926a2015-08-31 23:17:516904 return web_ui;
6905 }
6906
avie865b1d2016-10-24 19:42:596907 return nullptr;
dbeama1b926a2015-08-31 23:17:516908}
6909
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:416910FindRequestManager* WebContentsImpl::GetFindRequestManager() {
6911 for (auto* contents = this; contents;
paulmeyerfeafc2d2017-04-25 21:46:406912 contents = contents->GetOuterWebContents()) {
6913 if (contents->find_request_manager_)
6914 return contents->find_request_manager_.get();
6915 }
6916
6917 return nullptr;
6918}
6919
paulmeyerc0b762b2016-04-13 11:55:176920FindRequestManager* WebContentsImpl::GetOrCreateFindRequestManager() {
paulmeyerfeafc2d2017-04-25 21:46:406921 if (FindRequestManager* manager = GetFindRequestManager())
6922 return manager;
6923
Ehsan Karamad6beb2ea2018-11-25 18:15:136924 DCHECK(!browser_plugin_guest_ || GetOuterWebContents());
6925
paulmeyerfeafc2d2017-04-25 21:46:406926 // No existing FindRequestManager found, so one must be created.
6927 find_request_manager_.reset(new FindRequestManager(this));
6928
6929 // Concurrent find sessions must not overlap, so destroy any existing
6930 // FindRequestManagers in any inner WebContentses.
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:166931 for (WebContents* contents : GetWebContentsAndAllInner()) {
6932 auto* web_contents_impl = static_cast<WebContentsImpl*>(contents);
6933 if (web_contents_impl == this)
paulmeyerfeafc2d2017-04-25 21:46:406934 continue;
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:166935 if (web_contents_impl->find_request_manager_) {
6936 web_contents_impl->find_request_manager_->StopFinding(
6937 STOP_FIND_ACTION_CLEAR_SELECTION);
6938 web_contents_impl->find_request_manager_.release();
paulmeyerfeafc2d2017-04-25 21:46:406939 }
6940 }
paulmeyerc0b762b2016-04-13 11:55:176941
6942 return find_request_manager_.get();
6943}
6944
6945void WebContentsImpl::NotifyFindReply(int request_id,
6946 int number_of_matches,
6947 const gfx::Rect& selection_rect,
6948 int active_match_ordinal,
6949 bool final_update) {
Sebastien Marchandcf97ed52017-07-24 23:50:346950 if (delegate_ && !is_being_destroyed_ &&
Lukasz Anforowicze9ae3722017-09-29 17:37:386951 !GetMainFrame()->GetProcess()->FastShutdownStarted()) {
paulmeyerc0b762b2016-04-13 11:55:176952 delegate_->FindReply(this, request_id, number_of_matches, selection_rect,
6953 active_match_ordinal, final_update);
6954 }
6955}
6956
ortuno467e5792016-06-10 04:32:396957void WebContentsImpl::IncrementBluetoothConnectedDeviceCount() {
6958 // Trying to invalidate the tab state while being destroyed could result in a
6959 // use after free.
6960 if (IsBeingDestroyed()) {
6961 return;
6962 }
6963 // Notify for UI updates if the state changes.
6964 bluetooth_connected_device_count_++;
6965 if (bluetooth_connected_device_count_ == 1) {
Francois Doray66766a572019-12-17 20:56:496966 OnIsConnectedToBluetoothDeviceChanged(true);
ortuno467e5792016-06-10 04:32:396967 }
6968}
6969
6970void WebContentsImpl::DecrementBluetoothConnectedDeviceCount() {
6971 // Trying to invalidate the tab state while being destroyed could result in a
6972 // use after free.
6973 if (IsBeingDestroyed()) {
6974 return;
6975 }
6976 // Notify for UI updates if the state changes.
Lukasz Anforowicze9ae3722017-09-29 17:37:386977 DCHECK_NE(bluetooth_connected_device_count_, 0u);
ortuno467e5792016-06-10 04:32:396978 bluetooth_connected_device_count_--;
6979 if (bluetooth_connected_device_count_ == 0) {
Francois Doray66766a572019-12-17 20:56:496980 OnIsConnectedToBluetoothDeviceChanged(false);
6981 }
6982}
6983
6984void WebContentsImpl::OnIsConnectedToBluetoothDeviceChanged(
6985 bool is_connected_to_bluetooth_device) {
6986 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6987 for (auto& observer : observers_) {
6988 observer.OnIsConnectedToBluetoothDeviceChanged(
6989 is_connected_to_bluetooth_device);
ortuno467e5792016-06-10 04:32:396990 }
6991}
6992
Reilly Grant5e7c79b22019-04-09 17:26:206993void WebContentsImpl::IncrementSerialActiveFrameCount() {
6994 // Trying to invalidate the tab state while being destroyed could result in a
6995 // use after free.
6996 if (IsBeingDestroyed())
6997 return;
6998
6999 // Notify for UI updates if the state changes.
7000 serial_active_frame_count_++;
7001 if (serial_active_frame_count_ == 1)
7002 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
7003}
7004
7005void WebContentsImpl::DecrementSerialActiveFrameCount() {
7006 // Trying to invalidate the tab state while being destroyed could result in a
7007 // use after free.
7008 if (IsBeingDestroyed())
7009 return;
7010
7011 // Notify for UI updates if the state changes.
7012 DCHECK_NE(0u, serial_active_frame_count_);
7013 serial_active_frame_count_--;
7014 if (serial_active_frame_count_ == 0)
7015 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
7016}
7017
Matt Reynoldse8c6c1f2019-11-02 09:53:537018void WebContentsImpl::IncrementHidActiveFrameCount() {
7019 // Trying to invalidate the tab state while being destroyed could result in a
7020 // use after free.
7021 if (IsBeingDestroyed())
7022 return;
7023
7024 // Notify for UI updates if the active frame count transitions from zero to
7025 // non-zero.
7026 hid_active_frame_count_++;
7027 if (hid_active_frame_count_ == 1)
7028 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
7029}
7030
7031void WebContentsImpl::DecrementHidActiveFrameCount() {
7032 // Trying to invalidate the tab state while being destroyed could result in a
7033 // use after free.
7034 if (IsBeingDestroyed())
7035 return;
7036
7037 // Notify for UI updates if the active frame count transitions from non-zero
7038 // to zero.
7039 DCHECK_NE(0u, hid_active_frame_count_);
7040 hid_active_frame_count_--;
7041 if (hid_active_frame_count_ == 0)
7042 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
7043}
7044
Marijn Kruisselbrink29051042019-08-06 22:56:557045void WebContentsImpl::IncrementNativeFileSystemHandleCount() {
7046 // Trying to invalidate the tab state while being destroyed could result in a
7047 // use after free.
7048 if (IsBeingDestroyed())
7049 return;
7050
7051 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7052 // to update both the tab-level usage indicator and the usage indicator in the
7053 // omnibox.
7054 native_file_system_handle_count_++;
7055 if (native_file_system_handle_count_ == 1) {
7056 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7057 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7058 }
7059}
7060
7061void WebContentsImpl::DecrementNativeFileSystemHandleCount() {
7062 // Trying to invalidate the tab state while being destroyed could result in a
7063 // use after free.
7064 if (IsBeingDestroyed())
7065 return;
7066
7067 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7068 // to update both the tab-level usage indicator and the usage indicator in the
7069 // omnibox.
7070 DCHECK_NE(0u, native_file_system_handle_count_);
7071 native_file_system_handle_count_--;
7072 if (native_file_system_handle_count_ == 0) {
7073 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7074 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7075 }
7076}
7077
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:477078void WebContentsImpl::AddNativeFileSystemDirectoryHandle(
7079 const base::FilePath& path) {
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:337080 // Trying to invalidate the tab state while being destroyed could result in a
7081 // use after free.
7082 if (IsBeingDestroyed())
7083 return;
7084
7085 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7086 // to update both the tab-level usage indicator and the usage indicator in the
7087 // omnibox.
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:477088 const bool was_empty = native_file_system_directory_handles_.empty();
7089 native_file_system_directory_handles_[path]++;
7090 if (was_empty) {
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:337091 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7092 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7093 }
7094}
7095
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:477096void WebContentsImpl::RemoveNativeFileSystemDirectoryHandle(
7097 const base::FilePath& path) {
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:337098 // Trying to invalidate the tab state while being destroyed could result in a
7099 // use after free.
7100 if (IsBeingDestroyed())
7101 return;
7102
7103 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7104 // to update both the tab-level usage indicator and the usage indicator in the
7105 // omnibox.
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:477106 auto it = native_file_system_directory_handles_.find(path);
7107 DCHECK(it != native_file_system_directory_handles_.end());
7108 DCHECK_NE(0u, it->second);
7109 it->second--;
7110 if (it->second == 0)
7111 native_file_system_directory_handles_.erase(it);
7112 if (native_file_system_directory_handles_.empty()) {
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:337113 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7114 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7115 }
7116}
7117
7118void WebContentsImpl::IncrementWritableNativeFileSystemHandleCount() {
7119 // Trying to invalidate the tab state while being destroyed could result in a
7120 // use after free.
7121 if (IsBeingDestroyed())
7122 return;
7123
7124 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7125 // to update both the tab-level usage indicator and the usage indicator in the
7126 // omnibox.
7127 native_file_system_writable_handle_count_++;
7128 if (native_file_system_writable_handle_count_ == 1) {
7129 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7130 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7131 }
7132}
7133
7134void WebContentsImpl::DecrementWritableNativeFileSystemHandleCount() {
7135 // Trying to invalidate the tab state while being destroyed could result in a
7136 // use after free.
7137 if (IsBeingDestroyed())
7138 return;
7139
7140 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7141 // to update both the tab-level usage indicator and the usage indicator in the
7142 // omnibox.
7143 DCHECK_NE(0u, native_file_system_writable_handle_count_);
7144 native_file_system_writable_handle_count_--;
7145 if (native_file_system_writable_handle_count_ == 0) {
7146 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7147 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7148 }
7149}
7150
zqzhang8ac49002017-03-16 21:51:357151void WebContentsImpl::SetHasPersistentVideo(bool has_persistent_video) {
7152 if (has_persistent_video_ == has_persistent_video)
mlamouri5cd9ae82017-02-18 11:05:097153 return;
7154
zqzhang8ac49002017-03-16 21:51:357155 has_persistent_video_ = has_persistent_video;
mlamouri5cd9ae82017-02-18 11:05:097156 NotifyPreferencesChanged();
zqzhang8ac49002017-03-16 21:51:357157 media_web_contents_observer()->RequestPersistentVideo(has_persistent_video);
mlamouri5cd9ae82017-02-18 11:05:097158}
7159
Ian Vollick5d5c37f2019-06-19 22:50:577160void WebContentsImpl::SetSpatialNavigationDisabled(bool disabled) {
7161 if (is_spatial_navigation_disabled_ == disabled)
7162 return;
7163
7164 is_spatial_navigation_disabled_ = disabled;
7165 NotifyPreferencesChanged();
7166}
7167
paulmeyerfeafc2d2017-04-25 21:46:407168void WebContentsImpl::BrowserPluginGuestWillDetach() {
7169 WebContentsImpl* outermost = GetOutermostWebContents();
7170 if (this != outermost && ContainsOrIsFocusedWebContents())
7171 outermost->SetAsFocusedWebContentsIfNecessary();
7172}
7173
Becca Hughes112832e2019-06-11 17:19:027174PictureInPictureResult WebContentsImpl::EnterPictureInPicture(
Mounir Lamouri11e9ef42018-05-22 03:10:167175 const viz::SurfaceId& surface_id,
7176 const gfx::Size& natural_size) {
François Beaufortf09e4462019-01-18 14:34:517177 return delegate_
7178 ? delegate_->EnterPictureInPicture(this, surface_id, natural_size)
Becca Hughes112832e2019-06-11 17:19:027179 : PictureInPictureResult::kNotSupported;
Mounir Lamouri11e9ef42018-05-22 03:10:167180}
7181
Mounir Lamouri6d759e12018-05-16 20:01:307182void WebContentsImpl::ExitPictureInPicture() {
7183 if (delegate_)
7184 delegate_->ExitPictureInPicture();
7185}
7186
paulmeyerc0b762b2016-04-13 11:55:177187#if defined(OS_ANDROID)
7188void WebContentsImpl::NotifyFindMatchRectsReply(
7189 int version,
7190 const std::vector<gfx::RectF>& rects,
7191 const gfx::RectF& active_rect) {
7192 if (delegate_)
7193 delegate_->FindMatchRectsReply(this, version, rects, active_rect);
7194}
7195#endif
7196
[email protected]34ff1cfc2014-08-20 06:16:057197void WebContentsImpl::SetForceDisableOverscrollContent(bool force_disable) {
7198 force_disable_overscroll_content_ = force_disable;
7199 if (view_)
7200 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
7201}
7202
Jianzhou Fengd8720c72018-01-18 03:06:307203bool WebContentsImpl::SetDeviceEmulationSize(const gfx::Size& new_size) {
7204 device_emulation_size_ = new_size;
7205 RenderWidgetHostView* rwhv = GetMainFrame()->GetView();
7206
7207 const gfx::Size current_size = rwhv->GetViewBounds().size();
7208 if (view_size_before_emulation_.IsEmpty())
7209 view_size_before_emulation_ = current_size;
7210
7211 if (current_size != new_size)
7212 rwhv->SetSize(new_size);
7213
7214 return current_size != new_size;
7215}
7216
7217void WebContentsImpl::ClearDeviceEmulationSize() {
7218 RenderWidgetHostView* rwhv = GetMainFrame()->GetView();
7219 // WebContentsView could get resized during emulation, which also resizes
7220 // RWHV. If it happens, assume user would like to keep using the size after
7221 // emulation.
7222 // TODO(jzfeng): Prohibit resizing RWHV through any other means (at least when
7223 // WebContentsView size changes).
Dmitry Gozmanc63707182018-03-06 00:09:397224 if (!view_size_before_emulation_.IsEmpty() && rwhv &&
7225 rwhv->GetViewBounds().size() == device_emulation_size_) {
Jianzhou Fengd8720c72018-01-18 03:06:307226 rwhv->SetSize(view_size_before_emulation_);
Dmitry Gozmanc63707182018-03-06 00:09:397227 }
Jianzhou Fengd8720c72018-01-18 03:06:307228 device_emulation_size_ = gfx::Size();
7229 view_size_before_emulation_ = gfx::Size();
7230}
7231
Max Morin5bc74f52018-05-09 07:00:217232ForwardingAudioStreamFactory* WebContentsImpl::GetAudioStreamFactory() {
7233 if (!audio_stream_factory_) {
7234 audio_stream_factory_.emplace(
7235 this,
Max Morinddebb972018-09-20 10:04:147236 // BrowserMainLoop::GetInstance() may be null in unit tests.
7237 BrowserMainLoop::GetInstance()
7238 ? static_cast<media::UserInputMonitorBase*>(
7239 BrowserMainLoop::GetInstance()->user_input_monitor())
7240 : nullptr,
Ken Rockot72964402019-12-06 10:40:517241 AudioStreamBrokerFactory::CreateImpl());
Max Morin5bc74f52018-05-09 07:00:217242 }
7243
7244 return &*audio_stream_factory_;
7245}
7246
dalecurtis88c240072015-12-09 02:11:187247void WebContentsImpl::MediaStartedPlaying(
billorr21c005d2016-11-17 03:57:047248 const WebContentsObserver::MediaPlayerInfo& media_info,
Mounir Lamouri0f5bdf52019-04-04 16:32:357249 const MediaPlayerId& id) {
billorr21c005d2016-11-17 03:57:047250 if (media_info.has_video)
7251 currently_playing_video_count_++;
7252
ericwilligersde386342016-10-19 02:35:097253 for (auto& observer : observers_)
billorr21c005d2016-11-17 03:57:047254 observer.MediaStartedPlaying(media_info, id);
dalecurtis88c240072015-12-09 02:11:187255}
7256
7257void WebContentsImpl::MediaStoppedPlaying(
billorr21c005d2016-11-17 03:57:047258 const WebContentsObserver::MediaPlayerInfo& media_info,
Mounir Lamouri0f5bdf52019-04-04 16:32:357259 const MediaPlayerId& id,
Becca Hughes220bfc102017-11-14 18:24:077260 WebContentsObserver::MediaStoppedReason reason) {
billorr21c005d2016-11-17 03:57:047261 if (media_info.has_video)
7262 currently_playing_video_count_--;
7263
ericwilligersde386342016-10-19 02:35:097264 for (auto& observer : observers_)
Becca Hughes220bfc102017-11-14 18:24:077265 observer.MediaStoppedPlaying(media_info, id, reason);
billorr21c005d2016-11-17 03:57:047266}
7267
Mounir Lamouri0f5bdf52019-04-04 16:32:357268void WebContentsImpl::MediaResized(const gfx::Size& size,
7269 const MediaPlayerId& id) {
peconn257951522017-06-09 18:24:597270 cached_video_sizes_[id] = size;
7271
7272 for (auto& observer : observers_)
7273 observer.MediaResized(size, id);
7274}
7275
Peter E Conneccb34c22017-09-08 09:37:587276void WebContentsImpl::MediaEffectivelyFullscreenChanged(bool is_fullscreen) {
7277 for (auto& observer : observers_)
7278 observer.MediaEffectivelyFullscreenChanged(is_fullscreen);
7279}
7280
Peter Conn31c726a2017-08-17 11:07:347281base::Optional<gfx::Size> WebContentsImpl::GetFullscreenVideoSize() {
Mounir Lamouri0f5bdf52019-04-04 16:32:357282 base::Optional<MediaPlayerId> id =
Peter Conn31c726a2017-08-17 11:07:347283 media_web_contents_observer_->GetFullscreenVideoMediaPlayerId();
Jan Wilken Dörrie531be7ca2019-06-07 10:05:577284 if (id && base::Contains(cached_video_sizes_, id.value()))
Peter Conn31c726a2017-08-17 11:07:347285 return base::Optional<gfx::Size>(cached_video_sizes_[id.value()]);
Lei Zhang6410ec1a2019-01-31 21:38:587286 return base::nullopt;
peconn257951522017-06-09 18:24:597287}
7288
billorr21c005d2016-11-17 03:57:047289int WebContentsImpl::GetCurrentlyPlayingVideoCount() {
7290 return currently_playing_video_count_;
dalecurtis88c240072015-12-09 02:11:187291}
7292
Raymond Toye413650c2018-08-31 00:12:477293void WebContentsImpl::AudioContextPlaybackStarted(RenderFrameHost* host,
7294 int context_id) {
7295 WebContentsObserver::AudioContextId audio_context_id(host, context_id);
7296 for (auto& observer : observers_)
7297 observer.AudioContextPlaybackStarted(audio_context_id);
7298}
7299
7300void WebContentsImpl::AudioContextPlaybackStopped(RenderFrameHost* host,
7301 int context_id) {
7302 WebContentsObserver::AudioContextId audio_context_id(host, context_id);
7303 for (auto& observer : observers_)
7304 observer.AudioContextPlaybackStopped(audio_context_id);
7305}
7306
evliufc233aa2019-10-31 19:53:037307void WebContentsImpl::MediaWatchTimeChanged(
7308 const content::MediaPlayerWatchTime& watch_time) {
7309 for (auto& observer : observers_)
7310 observer.MediaWatchTimeChanged(watch_time);
7311}
7312
evliu7f736f02019-11-07 17:43:507313media::MediaMetricsProvider::RecordAggregateWatchTimeCallback
7314WebContentsImpl::GetRecordAggregateWatchTimeCallback() {
7315 return base::BindRepeating(
7316 [](base::WeakPtr<RenderFrameHostDelegate> delegate,
7317 GURL last_committed_url, base::TimeDelta total_watch_time,
evliua283c9e2019-11-08 22:57:227318 base::TimeDelta time_stamp, bool has_video, bool has_audio) {
7319 content::MediaPlayerWatchTime watch_time(
7320 last_committed_url, last_committed_url.GetOrigin(),
7321 total_watch_time, time_stamp, has_video, has_audio);
evliu7f736f02019-11-07 17:43:507322
7323 // Save the watch time if the delegate is still alive.
7324 if (delegate)
7325 delegate->MediaWatchTimeChanged(watch_time);
7326 },
7327 weak_factory_.GetWeakPtr(), GetMainFrameLastCommittedURL());
7328}
7329
Ehsan Karamad1c631762019-05-13 23:04:017330RenderFrameHostImpl* WebContentsImpl::GetMainFrameForInnerDelegate(
7331 FrameTreeNode* frame_tree_node) {
7332 if (auto* web_contents = node_.GetInnerWebContentsInFrame(frame_tree_node))
7333 return web_contents->GetMainFrame();
7334 return nullptr;
7335}
7336
John Budorickee1c9512019-10-17 15:32:197337bool WebContentsImpl::IsFrameLowPriority(
7338 const RenderFrameHost* render_frame_host) {
7339 if (!delegate_)
7340 return false;
7341 return delegate_->IsFrameLowPriority(this, render_frame_host);
7342}
7343
Roger Tawa03ffdbd2020-01-16 18:12:547344void WebContentsImpl::IsClipboardPasteAllowed(
7345 const GURL& url,
7346 const ui::ClipboardFormatType& data_type,
7347 const std::string& data,
7348 IsClipboardPasteAllowedCallback callback) {
7349 GetContentClient()->browser()->IsClipboardPasteAllowed(
7350 this, url, data_type, data, std::move(callback));
7351}
7352
Lan Weif81c6e7c2020-02-12 16:46:097353bool WebContentsImpl::HasSeenRecentScreenOrientationChange() {
7354 static constexpr base::TimeDelta kMaxInterval =
7355 base::TimeDelta::FromSeconds(1);
7356 base::TimeDelta delta =
7357 ui::EventTimeForNow() - last_screen_orientation_change_time_;
7358 // Return whether there is a screen orientation change happened in the recent
7359 // 1 second.
7360 return delta <= kMaxInterval;
7361}
7362
7363void WebContentsImpl::DidChangeScreenOrientation() {
7364 last_screen_orientation_change_time_ = ui::EventTimeForNow();
7365}
7366
Francois Doraye6161152018-03-27 22:05:377367void WebContentsImpl::UpdateWebContentsVisibility(Visibility visibility) {
Francois Doray3f2afbd2018-04-06 19:18:187368 // Occlusion is disabled when |features::kWebContentsOcclusion| is disabled
7369 // (for power and speed impact assessment) or when
7370 // |switches::kDisableBackgroundingOccludedWindowsForTesting| is specified on
7371 // the command line (to avoid flakiness in browser tests).
7372 const bool occlusion_is_disabled =
7373 !base::FeatureList::IsEnabled(features::kWebContentsOcclusion) ||
Francois Doraye6161152018-03-27 22:05:377374 base::CommandLine::ForCurrentProcess()->HasSwitch(
7375 switches::kDisableBackgroundingOccludedWindowsForTesting);
7376 if (occlusion_is_disabled && visibility == Visibility::OCCLUDED)
7377 visibility = Visibility::VISIBLE;
7378
tapted65ff2ea72016-03-01 23:39:007379 if (!did_first_set_visible_) {
Francois Doraye6161152018-03-27 22:05:377380 if (visibility == Visibility::VISIBLE) {
7381 // A WebContents created with CreateParams::initially_hidden = false
7382 // starts with GetVisibility() == Visibility::VISIBLE even though it is
7383 // not really visible. Call WasShown() when it becomes visible for real as
7384 // the page load mechanism and some WebContentsObserver rely on that.
tapted65ff2ea72016-03-01 23:39:007385 WasShown();
Francois Dorayfe4a1772018-02-17 04:17:097386 did_first_set_visible_ = true;
tapted65ff2ea72016-03-01 23:39:007387 }
Francois Doraye6161152018-03-27 22:05:377388
7389 // Trust the initial visibility of the WebContents and do not switch it to
7390 // HIDDEN or OCCLUDED before it becomes VISIBLE for real. Doing so would
7391 // result in destroying resources that would immediately be recreated (e.g.
7392 // UpdateWebContents(HIDDEN) can be called when a WebContents is added to a
7393 // hidden window that is about to be shown).
7394
tapted65ff2ea72016-03-01 23:39:007395 return;
7396 }
Francois Doraye6161152018-03-27 22:05:377397
7398 if (visibility == visibility_)
tapted65ff2ea72016-03-01 23:39:007399 return;
7400
Collin Baker989e0882019-11-01 01:27:177401 UpdateVisibilityAndNotifyPageAndView(visibility);
tapted65ff2ea72016-03-01 23:39:007402}
7403
aelias5252baa2016-04-10 01:18:027404void WebContentsImpl::UpdateOverridingUserAgent() {
mlamouri5cd9ae82017-02-18 11:05:097405 NotifyPreferencesChanged();
aelias5252baa2016-04-10 01:18:027406}
7407
avid53461d2016-02-25 17:15:047408void WebContentsImpl::SetJavaScriptDialogManagerForTesting(
7409 JavaScriptDialogManager* dialog_manager) {
7410 dialog_manager_ = dialog_manager;
7411}
7412
Julie Jeongeun Kim7d0986172019-12-04 03:17:257413void WebContentsImpl::RemoveReceiverSet(const std::string& interface_name) {
7414 auto it = receiver_sets_.find(interface_name);
7415 if (it != receiver_sets_.end())
7416 receiver_sets_.erase(it);
rockotf62002a2016-09-15 00:08:597417}
7418
nzolghadrd87a308d2016-12-07 15:45:567419bool WebContentsImpl::AddDomainInfoToRapporSample(rappor::Sample* sample) {
nzolghadrbbffc6c2017-05-25 17:56:397420 // Here we associate this metric to the main frame URL regardless of what
7421 // caused it.
nzolghadrd87a308d2016-12-07 15:45:567422 sample->SetStringField("Domain", ::rappor::GetDomainAndRegistrySampleFromGURL(
7423 GetLastCommittedURL()));
nzolghadrd87a308d2016-12-07 15:45:567424 return true;
7425}
7426
falken52a56e32016-12-08 05:02:407427void WebContentsImpl::ShowInsecureLocalhostWarningIfNeeded() {
7428 bool allow_localhost = base::CommandLine::ForCurrentProcess()->HasSwitch(
7429 switches::kAllowInsecureLocalhost);
7430 if (!allow_localhost)
7431 return;
7432
7433 content::NavigationEntry* entry = GetController().GetLastCommittedEntry();
Rob Wuf79b3ba2018-01-14 01:54:317434 if (!entry || !net::IsLocalhost(entry->GetURL()))
falken52a56e32016-12-08 05:02:407435 return;
7436
7437 content::SSLStatus ssl_status = entry->GetSSL();
Matt Mueller936511442019-09-03 18:15:127438 if (!net::IsCertStatusError(ssl_status.cert_status))
falken52a56e32016-12-08 05:02:407439 return;
7440
7441 GetMainFrame()->AddMessageToConsole(
Abhijeet Kandalkara5928a0a2019-03-13 05:04:427442 blink::mojom::ConsoleMessageLevel::kWarning,
falken52a56e32016-12-08 05:02:407443 base::StringPrintf("This site does not have a valid SSL "
7444 "certificate! Without SSL, your site's and "
7445 "visitors' data is vulnerable to theft and "
7446 "tampering. Get a valid SSL certificate before"
7447 " releasing your website to the public."));
7448}
7449
ekaramadf6750aa2017-06-06 18:29:427450bool WebContentsImpl::IsShowingContextMenuOnPage() const {
7451 return showing_context_menu_;
7452}
7453
Min Qina904f3302018-02-13 23:33:347454download::DownloadUrlParameters::RequestHeadersType
7455WebContentsImpl::ParseDownloadHeaders(const std::string& headers) {
7456 download::DownloadUrlParameters::RequestHeadersType request_headers;
Megan Jablonski2f6a4c52017-07-10 23:01:257457 for (const base::StringPiece& key_value : base::SplitStringPiece(
7458 headers, "\r\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
7459 std::vector<std::string> pair = base::SplitString(
7460 key_value, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
7461 if (2ul == pair.size())
7462 request_headers.push_back(make_pair(pair[0], pair[1]));
7463 }
7464 return request_headers;
7465}
7466
lukasza6f8ac622017-06-06 03:10:207467void WebContentsImpl::SetOpenerForNewContents(FrameTreeNode* opener,
7468 bool opener_suppressed) {
7469 if (opener) {
7470 FrameTreeNode* new_root = GetFrameTree()->root();
7471
7472 // For the "original opener", track the opener's main frame instead, because
7473 // if the opener is a subframe, the opener tracking could be easily bypassed
7474 // by spawning from a subframe and deleting the subframe.
7475 // https://crbug.com/705316
7476 new_root->SetOriginalOpener(opener->frame_tree()->root());
7477
7478 if (!opener_suppressed) {
7479 new_root->SetOpener(opener);
7480 created_with_opener_ = true;
7481 }
7482 }
7483}
7484
Mounir Lamouri0f5bdf52019-04-04 16:32:357485void WebContentsImpl::MediaMutedStatusChanged(const MediaPlayerId& id,
7486 bool muted) {
Becca Hughes9f6fd4b82017-06-15 10:01:407487 for (auto& observer : observers_)
7488 observer.MediaMutedStatusChanged(id, muted);
7489}
7490
EhsanK2075c7e2017-08-21 02:42:397491void WebContentsImpl::SetVisibilityForChildViews(bool visible) {
7492 GetMainFrame()->SetVisibilityForChildViews(visible);
7493}
7494
Alison Maher7f366dc62020-03-03 19:46:007495void WebContentsImpl::OnNativeThemeUpdated(ui::NativeTheme* observed_theme) {
7496 DCHECK(native_theme_observer_.IsObserving(observed_theme));
7497
7498 bool using_dark_colors = observed_theme->ShouldUseDarkColors();
7499 ui::NativeTheme::PreferredColorScheme preferred_color_scheme =
7500 observed_theme->GetPreferredColorScheme();
7501 bool preferences_changed = false;
7502
7503 if (using_dark_colors_ != using_dark_colors) {
7504 using_dark_colors_ = using_dark_colors;
7505 preferences_changed = true;
7506 }
7507 if (preferred_color_scheme_ != preferred_color_scheme) {
7508 preferred_color_scheme_ = preferred_color_scheme;
7509 preferences_changed = true;
7510 }
7511
7512 if (preferences_changed)
7513 NotifyPreferencesChanged();
7514}
7515
Dave Tapuskae782bea2019-07-09 16:21:517516mojom::FrameInputHandler* WebContentsImpl::GetFocusedFrameInputHandler() {
7517 auto* focused_frame = GetFocusedFrame();
7518 if (!focused_frame)
7519 return nullptr;
7520 return focused_frame->GetFrameInputHandler();
7521}
7522
[email protected]8ff00d72012-10-23 19:12:217523} // namespace content