blob: 8bb7713c017a0999a7035bfc8a689d85f085f0fc [file] [log] [blame]
[email protected]91854cd2012-01-10 19:43:571// Copyright (c) 2012 The Chromium Authors. All rights reserved.
license.botbf09a502008-08-24 00:55:552// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commit09911bf2008-07-26 23:55:294
[email protected]93ddb3c2012-04-11 21:44:295#include "content/browser/web_contents/web_contents_impl.h"
[email protected]39526562011-02-05 03:41:516
avib7348942015-12-25 20:57:107#include <stddef.h>
8
w.shackleton49bcd392016-01-06 17:38:229#include <cmath>
[email protected]2bb171882012-03-07 02:09:4610#include <utility>
rkaplowe56a52032017-02-07 00:14:5411#include <vector>
[email protected]b75b8292010-10-01 07:28:2512
Sebastien Marchandf8cbfab2019-01-25 16:02:3013#include "base/bind.h"
[email protected]36fb2c7c2011-04-04 15:49:0814#include "base/command_line.h"
creisfafed882016-07-29 00:03:0915#include "base/debug/dump_without_crashing.h"
zqzhang181047e62016-07-01 13:37:1716#include "base/feature_list.h"
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:4717#include "base/files/file_path.h"
[email protected]cbb1ef592013-06-05 19:49:4618#include "base/lazy_instance.h"
skyostil95082a62015-06-05 19:53:0719#include "base/location.h"
[email protected]6d636e62013-07-31 03:15:5620#include "base/logging.h"
avib7348942015-12-25 20:57:1021#include "base/macros.h"
fdorayba121422016-12-23 19:51:4822#include "base/memory/ptr_util.h"
dmazzonid95ae842016-04-12 21:17:3923#include "base/memory/ref_counted.h"
asvitkine8d51e9d2016-09-02 23:55:4324#include "base/metrics/histogram_macros.h"
bratell0a7406f2017-03-28 07:46:3725#include "base/metrics/user_metrics.h"
Avi Drissman4891b852018-09-25 18:12:5826#include "base/no_destructor.h"
Carlos Caballero1215f882019-10-29 15:58:4327#include "base/optional.h"
[email protected]04cbd3d2013-12-04 04:58:2028#include "base/process/process.h"
skyostil95082a62015-06-05 19:53:0729#include "base/single_thread_task_runner.h"
Arthur Sonzogni929d29f2018-09-17 14:19:4430#include "base/stl_util.h"
[email protected]348fbaac2013-06-11 06:31:5131#include "base/strings/string16.h"
32#include "base/strings/string_number_conversions.h"
Avi Drissman4891b852018-09-25 18:12:5833#include "base/strings/string_split.h"
[email protected]348fbaac2013-06-11 06:31:5134#include "base/strings/string_util.h"
[email protected]74ebfb12013-06-07 20:48:0035#include "base/strings/utf_string_conversions.h"
Eric Seckler8652dcd52018-09-20 10:42:2836#include "base/task/post_task.h"
gab30f26df2016-05-11 19:37:5537#include "base/threading/thread_task_runner_handle.h"
[email protected]a43858f2013-06-28 15:18:3738#include "base/time/time.h"
ssid3e765612015-01-28 04:03:4239#include "base/trace_event/trace_event.h"
avib7348942015-12-25 20:57:1040#include "build/build_config.h"
Min Qinda0ed2062018-02-23 22:00:5341#include "components/download/public/common/download_stats.h"
nzolghadrd87a308d2016-12-07 15:45:5642#include "components/rappor/public/rappor_utils.h"
rsleevi24f64dc22015-08-07 21:39:2143#include "components/url_formatter/url_formatter.h"
Abigail Kleinaa898742019-11-01 02:31:2544#include "content/browser/accessibility/accessibility_event_recorder.h"
James Wallace-Leeeafc94cb92018-07-23 21:35:0945#include "content/browser/accessibility/accessibility_tree_formatter_blink.h"
jamescookda2505812015-03-20 18:01:1846#include "content/browser/bad_message.h"
Max Morinddebb972018-09-20 10:04:1447#include "content/browser/browser_main_loop.h"
[email protected]7a846df2012-09-20 19:17:3948#include "content/browser/browser_plugin/browser_plugin_embedder.h"
49#include "content/browser/browser_plugin/browser_plugin_guest.h"
[email protected]b9535422012-02-09 01:47:5950#include "content/browser/child_process_security_policy_impl.h"
Andrey Lushnikov81b992e2019-06-27 23:27:2151#include "content/browser/devtools/devtools_instrumentation.h"
Pavel Feldman3c1842b2017-08-02 05:00:1652#include "content/browser/devtools/protocol/page_handler.h"
dgozmanf00c4f72016-10-19 17:45:1553#include "content/browser/devtools/render_frame_devtools_agent_host.h"
Becca Hughes3b5a43482018-07-17 22:31:5554#include "content/browser/display_cutout/display_cutout_host_impl.h"
[email protected]5f2aa722013-08-07 16:59:4155#include "content/browser/dom_storage/dom_storage_context_wrapper.h"
[email protected]1ea3c792012-04-17 01:25:0456#include "content/browser/dom_storage/session_storage_namespace_impl.h"
[email protected]aa4f3972012-03-01 18:12:1257#include "content/browser/download/mhtml_generation_manager.h"
[email protected]a53209b2012-01-20 16:48:1658#include "content/browser/download/save_package.h"
paulmeyerc0b762b2016-04-13 11:55:1759#include "content/browser/find_request_manager.h"
[email protected]bffc8302014-01-23 20:52:1660#include "content/browser/frame_host/cross_process_frame_connector.h"
ananta4b7467a52016-09-23 01:42:3861#include "content/browser/frame_host/frame_tree_node.h"
[email protected]d4a8ca482013-10-30 21:06:4062#include "content/browser/frame_host/interstitial_page_impl.h"
63#include "content/browser/frame_host/navigation_entry_impl.h"
Arthur Hemeryc3380172018-01-22 14:00:1764#include "content/browser/frame_host/navigation_request.h"
[email protected]6ea6bdf2013-12-06 13:35:0165#include "content/browser/frame_host/navigator_impl.h"
[email protected]52913802013-12-10 05:52:1866#include "content/browser/frame_host/render_frame_host_impl.h"
lfgdb5c4ed2016-03-04 23:09:0767#include "content/browser/frame_host/render_frame_proxy_host.h"
Kenneth Russell954ed9ce2018-04-12 23:07:0168#include "content/browser/gpu/gpu_data_manager_impl.h"
mlamouriefdca9d2014-09-16 16:55:4069#include "content/browser/manifest/manifest_manager_host.h"
Max Morin5bc74f52018-05-09 07:00:2170#include "content/browser/media/audio_stream_broker.h"
dalecurtisbc6572e12014-09-12 19:22:3071#include "content/browser/media/audio_stream_monitor.h"
miu50f97892014-09-22 22:49:5272#include "content/browser/media/capture/web_contents_audio_muter.h"
dalecurtis88c240072015-12-09 02:11:1873#include "content/browser/media/media_web_contents_observer.h"
zqzhang1adf3cb2016-11-01 11:26:4574#include "content/browser/media/session/media_session_impl.h"
tommyclieb25b2a2014-11-03 19:45:0975#include "content/browser/plugin_content_origin_whitelist.h"
David Black9cca3592019-11-06 23:02:2276#include "content/browser/renderer_host/frame_token_message_queue.h"
[email protected]f3b1a082011-11-18 00:34:3077#include "content/browser/renderer_host/render_process_host_impl.h"
[email protected]21161032014-05-05 16:56:5078#include "content/browser/renderer_host/render_view_host_delegate_view.h"
[email protected]b3c41c0b2012-03-06 15:48:3279#include "content/browser/renderer_host/render_view_host_impl.h"
[email protected]bafe6cd2012-05-23 23:09:5080#include "content/browser/renderer_host/render_widget_host_impl.h"
kenrb2a565f82015-09-02 20:24:5981#include "content/browser/renderer_host/render_widget_host_input_event_router.h"
[email protected]cfd80b02014-05-01 17:46:4882#include "content/browser/renderer_host/render_widget_host_view_base.h"
Ken Buchanandaef006b2017-08-17 18:32:1583#include "content/browser/renderer_host/render_widget_host_view_child_frame.h"
ekaramadadd882292016-06-08 15:22:5684#include "content/browser/renderer_host/text_input_manager.h"
leon.han552e9de2017-02-09 14:37:3085#include "content/browser/screen_orientation/screen_orientation_provider.h"
[email protected]b6583592012-01-25 19:52:3386#include "content/browser/site_instance_impl.h"
Charlie Reis96077362019-07-04 00:34:0487#include "content/browser/web_contents/javascript_dialog_navigation_deferrer.h"
lfgc740d4b22016-04-15 16:45:3388#include "content/browser/web_contents/web_contents_view_child_frame.h"
[email protected]b5a40842012-11-28 15:26:1189#include "content/browser/web_contents/web_contents_view_guest.h"
[email protected]86a0a6e2013-01-28 06:33:0390#include "content/browser/webui/web_ui_controller_factory_registry.h"
[email protected]d2353452012-01-19 19:53:5691#include "content/browser/webui/web_ui_impl.h"
[email protected]8eb04562013-03-06 03:41:1492#include "content/common/browser_plugin/browser_plugin_constants.h"
[email protected]703dd662013-03-05 07:37:4293#include "content/common/browser_plugin/browser_plugin_messages.h"
Paul Meyer0c58c3712016-11-17 22:59:5194#include "content/common/drag_messages.h"
[email protected]f114fa42013-12-06 17:06:4495#include "content/common/frame_messages.h"
[email protected]1f3fc1d2014-04-03 14:50:1796#include "content/common/input_messages.h"
lfgdb5c4ed2016-03-04 23:09:0797#include "content/common/page_messages.h"
nasko34634672016-07-29 18:46:0698#include "content/common/page_state_serialization.h"
rockot5c478a72016-09-28 23:14:1899#include "content/common/render_message_filter.mojom.h"
[email protected]2c5569662011-03-22 20:45:02100#include "content/common/view_messages.h"
Albert J. Wong3c93c182018-09-27 17:29:43101#include "content/common/widget_messages.h"
Abigail Kleinabb428332019-09-13 18:26:21102#include "content/public/browser/accessibility_tree_formatter.h"
[email protected]31a71eaf2014-03-13 01:47:36103#include "content/public/browser/ax_event_notification_details.h"
[email protected]ccb797302011-12-15 16:55:11104#include "content/public/browser/browser_context.h"
[email protected]139355f2014-05-11 14:21:28105#include "content/public/browser/browser_plugin_guest_manager.h"
Eric Seckler8652dcd52018-09-20 10:42:28106#include "content/public/browser/browser_task_traits.h"
Gabriel Charette790754c2018-03-16 21:32:59107#include "content/public/browser/browser_thread.h"
[email protected]87f3c082011-10-19 18:07:44108#include "content/public/browser/content_browser_client.h"
[email protected]e582fdd2011-12-20 16:48:17109#include "content/public/browser/download_manager.h"
Kent Tamura512a27e2018-10-04 00:49:32110#include "content/public/browser/file_select_listener.h"
ekaramada110f642016-12-21 19:47:28111#include "content/public/browser/focused_node_details.h"
ekaramad1beabecc2016-09-23 20:18:17112#include "content/public/browser/guest_mode.h"
[email protected]d9083482012-01-06 00:38:46113#include "content/public/browser/invalidate_type.h"
[email protected]71a88bb2013-02-01 22:05:15114#include "content/public/browser/javascript_dialog_manager.h"
skyf65d9bb2017-03-24 02:26:39115#include "content/public/browser/keyboard_event_processing_result.h"
[email protected]09d31d52012-03-11 22:30:27116#include "content/public/browser/load_notification_details.h"
[email protected]5b96836f2011-12-22 07:39:00117#include "content/public/browser/navigation_details.h"
[email protected]375fa1b2012-05-22 22:05:37118#include "content/public/browser/notification_details.h"
[email protected]be2510c02012-05-28 14:52:14119#include "content/public/browser/notification_service.h"
scottmg011d96e32016-06-29 19:15:08120#include "content/public/browser/notification_types.h"
[email protected]95640212014-07-26 18:14:30121#include "content/public/browser/render_widget_host_iterator.h"
Lukasz Anforowicze1b954d92017-10-30 21:28:06122#include "content/public/browser/restore_type.h"
estark5ea80e52015-06-19 18:43:12123#include "content/public/browser/security_style_explanations.h"
falken52a56e32016-12-08 05:02:40124#include "content/public/browser/ssl_status.h"
[email protected]4c3a23582012-08-18 08:54:34125#include "content/public/browser/storage_partition.h"
Ken Rockotfd03e682019-06-20 21:13:54126#include "content/public/browser/system_connector.h"
rockotf62002a2016-09-15 00:08:59127#include "content/public/browser/web_contents_binding_set.h"
[email protected]674bc592011-12-20 23:00:42128#include "content/public/browser/web_contents_delegate.h"
Lei Zhangee3b63ad2018-06-06 23:25:31129#include "content/public/browser/web_ui_controller.h"
[email protected]e091df82011-10-11 18:13:21130#include "content/public/common/bindings_policy.h"
alexmosc9e76ec2016-05-16 22:59:37131#include "content/public/common/child_process_host.h"
Hans Wennborg5ffd1392019-10-16 11:00:02132#include "content/public/common/content_client.h"
[email protected]54087fe2011-10-28 22:02:48133#include "content/public/common/content_constants.h"
Francois Doray3f2afbd2018-04-06 19:18:18134#include "content/public/common/content_features.h"
[email protected]64d69de42012-02-06 00:19:54135#include "content/public/common/content_switches.h"
Lukasz Anforowicze1b954d92017-10-30 21:28:06136#include "content/public/common/page_state.h"
Leon Han963dc182018-11-06 05:41:48137#include "content/public/common/referrer_type_converters.h"
[email protected]04cbd3d2013-12-04 04:58:20138#include "content/public/common/result_codes.h"
[email protected]f16cc6782013-12-16 23:42:57139#include "content/public/common/url_utils.h"
danakjffc8baf2019-10-10 23:49:42140#include "content/public/common/use_zoom_for_dsf_policy.h"
[email protected]b3a97b52014-07-09 06:25:05141#include "content/public/common/web_preferences.h"
Max Morinddebb972018-09-20 10:04:14142#include "media/base/user_input_monitor.h"
wjmaclean64951902016-04-29 20:59:12143#include "net/base/url_util.h"
[email protected]8bfc8272013-09-09 20:10:53144#include "net/http/http_cache.h"
145#include "net/http/http_transaction_factory.h"
rhalavati0fbaeef32017-06-01 15:56:30146#include "net/traffic_annotation/network_traffic_annotation.h"
[email protected]8bfc8272013-09-09 20:10:53147#include "net/url_request/url_request_context.h"
[email protected]abe2c032011-03-31 18:49:34148#include "net/url_request/url_request_context_getter.h"
Scott Violet02e38b92018-03-27 23:42:14149#include "ppapi/buildflags/buildflags.h"
Ke He31d0bb02018-02-24 07:16:24150#include "services/device/public/mojom/constants.mojom.h"
Mounir Lamourifd9dcefa2017-07-06 10:26:55151#include "services/metrics/public/cpp/ukm_recorder.h"
John Abd-El-Malekb175a612018-12-03 20:11:58152#include "services/network/public/cpp/features.h"
Ke He7319dbe2017-11-09 05:54:44153#include "services/service_manager/public/cpp/connector.h"
rockot734fb662016-10-15 16:41:30154#include "services/service_manager/public/cpp/interface_provider.h"
Becca Hughes6daf5662018-06-27 16:50:54155#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
Blink Reformata30d4232018-04-07 15:31:06156#include "third_party/blink/public/common/frame/sandbox_flags.h"
157#include "third_party/blink/public/common/mime_util/mime_util.h"
danakj938b37a62019-09-24 18:35:54158#include "third_party/blink/public/common/page/page_zoom.h"
Sergio Villar Senin9d9d4f52019-10-15 10:57:57159#include "third_party/blink/public/common/security/security_style.h"
Dave Tapuskaa4189512019-10-15 20:27:34160#include "third_party/blink/public/mojom/frame/fullscreen.mojom.h"
Takuto Ikutaaa3b796c2019-02-06 02:54:56161#include "third_party/blink/public/mojom/loader/pause_subresource_loading_handle.mojom.h"
Antonio Gomes0d42960a2019-06-05 12:35:51162#include "third_party/blink/public/mojom/mediastream/media_stream.mojom-shared.h"
halton.huoca2eabd2015-07-06 08:17:40163#include "third_party/skia/include/core/SkBitmap.h"
dmazzonid95ae842016-04-12 21:17:39164#include "ui/accessibility/ax_tree_combiner.h"
[email protected]a08412b62012-05-29 21:28:56165#include "ui/base/layout.h"
Daniel Cheng90196c82018-04-25 21:49:14166#include "ui/events/base_event_utils.h"
chongz4a9751942016-08-17 17:49:39167#include "ui/events/blink/web_input_event_traits.h"
[email protected]66bd5512012-08-01 02:02:52168#include "ui/gl/gl_switches.h"
[email protected]3c733bde2010-12-21 19:56:31169
ekaramada110f642016-12-21 19:47:28170#if defined(OS_WIN)
171#include "content/browser/renderer_host/dip_util.h"
172#include "ui/gfx/geometry/dip_util.h"
173#endif
174
[email protected]583418cc2013-01-17 14:01:10175#if defined(OS_ANDROID)
mfomitchev2b8b066a2016-01-28 19:23:15176#include "content/browser/android/date_time_chooser_android.h"
sammcf5f1b0f2016-09-20 23:05:11177#include "content/browser/android/java_interfaces_impl.h"
Leon Hanccb985f2019-08-26 02:43:24178#include "content/browser/android/nfc_host.h"
[email protected]155c7f22013-12-09 17:07:18179#include "content/browser/web_contents/web_contents_android.h"
Ke He31d0bb02018-02-24 07:16:24180#include "services/device/public/mojom/nfc.mojom.h"
mcnee336ea2c2017-05-23 22:50:59181#else // !OS_ANDROID
182#include "content/browser/host_zoom_map_impl.h"
mfomitchev2b8b066a2016-01-28 19:23:15183#endif // OS_ANDROID
[email protected]583418cc2013-01-17 14:01:10184
brettw4b461082016-11-19 18:55:16185#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17186#include "content/browser/media/session/pepper_playback_observer.h"
Lei Zhangebcc6302018-01-12 19:46:45187#endif
zqzhang181047e62016-07-01 13:37:17188
[email protected]8ff00d72012-10-23 19:12:21189namespace content {
Abigail Kleinaa898742019-11-01 02:31:25190
191using AccessibilityEventCallback =
192 base::RepeatingCallback<void(const std::string&)>;
193
[email protected]420ae012009-04-24 05:16:32194namespace {
195
[email protected]960b0372014-05-19 18:01:00196const int kMinimumDelayBetweenLoadingUpdatesMS = 100;
[email protected]82114f52012-03-20 22:53:41197const char kDotGoogleDotCom[] = ".google.com";
[email protected]ca406032011-07-19 21:53:05198
Avi Drissmana9114822018-03-23 18:25:55199base::LazyInstance<std::vector<
200 WebContentsImpl::FriendWrapper::CreatedCallback>>::DestructorAtExit
201 g_created_callbacks = LAZY_INSTANCE_INITIALIZER;
[email protected]cbb1ef592013-06-05 19:49:46202
dcheng57e39e22016-01-21 00:25:38203bool HasMatchingProcess(FrameTree* tree, int render_process_id) {
204 for (FrameTreeNode* node : tree->Nodes()) {
205 if (node->current_frame_host()->GetProcess()->GetID() == render_process_id)
206 return true;
alexmos4cf2aa32015-07-15 23:40:43207 }
dcheng57e39e22016-01-21 00:25:38208 return false;
[email protected]95640212014-07-26 18:14:30209}
210
kenrb19221852016-04-29 17:21:40211bool HasMatchingWidgetHost(FrameTree* tree, RenderWidgetHost* host) {
212 // This method scans the frame tree rather than checking whether
213 // host->delegate() == this, which allows it to return false when the host
214 // for a frame that is pending or pending deletion.
215 if (!host)
216 return false;
217
218 for (FrameTreeNode* node : tree->Nodes()) {
219 if (node->current_frame_host()->GetRenderWidgetHost() == host)
220 return true;
221 }
222 return false;
223}
224
dmazzonif8a31042016-12-03 00:52:13225void UpdateAccessibilityModeOnFrame(RenderFrameHost* frame_host) {
226 static_cast<RenderFrameHostImpl*>(frame_host)->UpdateAccessibilityMode();
[email protected]95640212014-07-26 18:14:30227}
228
dtseng0dd3fa12015-07-22 19:00:52229void ResetAccessibility(RenderFrameHost* rfh) {
230 static_cast<RenderFrameHostImpl*>(rfh)->AccessibilityReset();
231}
232
paulmeyerfeafc2d2017-04-25 21:46:40233// Helper for GetInnerWebContents().
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:16234bool GetInnerWebContentsHelper(std::vector<WebContents*>* all_guest_contents,
235 WebContents* guest_contents) {
Ehsan Karamad6beb2ea2018-11-25 18:15:13236 auto* web_contents_impl = static_cast<WebContentsImpl*>(guest_contents);
237 if (web_contents_impl->GetBrowserPluginGuest()->attached() &&
238 !GuestMode::IsCrossProcessFrameGuest(web_contents_impl)) {
239 all_guest_contents->push_back(web_contents_impl);
240 }
paulmeyerfeafc2d2017-04-25 21:46:40241 return false;
242}
243
Ian Clelland5cbaaf82017-11-27 22:00:03244RenderFrameHostImpl* FindOpenerRFH(const WebContents::CreateParams& params) {
245 RenderFrameHostImpl* opener_rfh = nullptr;
alexmose201c7cd2015-06-10 17:14:21246 if (params.opener_render_frame_id != MSG_ROUTING_NONE) {
Ian Clelland5cbaaf82017-11-27 22:00:03247 opener_rfh = RenderFrameHostImpl::FromID(params.opener_render_process_id,
248 params.opener_render_frame_id);
alexmose201c7cd2015-06-10 17:14:21249 }
Ian Clelland5cbaaf82017-11-27 22:00:03250 return opener_rfh;
lukasza6f8ac622017-06-06 03:10:20251}
252
Dominick Ng37a15052018-07-17 23:56:35253// Returns |true| if |type| is the kind of user input that should trigger the
254// user interaction observers.
255bool IsUserInteractionInputType(blink::WebInputEvent::Type type) {
256 // Ideally, this list would be based more off of
257 // https://whatwg.org/C/interaction.html#triggered-by-user-activation.
258 return type == blink::WebInputEvent::kMouseDown ||
259 type == blink::WebInputEvent::kGestureScrollBegin ||
260 type == blink::WebInputEvent::kTouchStart ||
261 type == blink::WebInputEvent::kRawKeyDown;
262}
263
Pavel Feldman3c1842b2017-08-02 05:00:16264// Ensures that OnDialogClosed is only called once.
265class CloseDialogCallbackWrapper
266 : public base::RefCountedThreadSafe<CloseDialogCallbackWrapper> {
267 public:
Avi Drissmane04d3992017-10-05 15:11:36268 using CloseCallback =
269 base::OnceCallback<void(bool, bool, const base::string16&)>;
270
271 explicit CloseDialogCallbackWrapper(CloseCallback callback)
272 : callback_(std::move(callback)) {}
Pavel Feldman3c1842b2017-08-02 05:00:16273
274 void Run(bool dialog_was_suppressed,
275 bool success,
276 const base::string16& user_input) {
Avi Drissmane04d3992017-10-05 15:11:36277 if (callback_.is_null())
Pavel Feldman3c1842b2017-08-02 05:00:16278 return;
Avi Drissmane04d3992017-10-05 15:11:36279 std::move(callback_).Run(dialog_was_suppressed, success, user_input);
Pavel Feldman3c1842b2017-08-02 05:00:16280 }
281
282 private:
283 friend class base::RefCountedThreadSafe<CloseDialogCallbackWrapper>;
284 ~CloseDialogCallbackWrapper() {}
Avi Drissmane04d3992017-10-05 15:11:36285
286 CloseCallback callback_;
Pavel Feldman3c1842b2017-08-02 05:00:16287};
288
Arthur Sonzogni929d29f2018-09-17 14:19:44289bool FrameCompareDepth(RenderFrameHostImpl* a, RenderFrameHostImpl* b) {
290 return a->frame_tree_node()->depth() < b->frame_tree_node()->depth();
291}
292
Raymes Khoury58373df2019-08-06 06:29:20293bool AreValidRegisterProtocolHandlerArguments(const std::string& protocol,
294 const GURL& url,
295 const url::Origin& origin) {
296 ChildProcessSecurityPolicyImpl* policy =
297 ChildProcessSecurityPolicyImpl::GetInstance();
298 if (policy->IsPseudoScheme(protocol))
299 return false;
300
301 url::Origin url_origin = url::Origin::Create(url);
302 if (url_origin.opaque())
303 return false;
304
305 if (!url_origin.IsSameOriginWith(origin))
306 return false;
307
308 return true;
309}
310
yilkal796e89e2019-10-02 23:58:28311void RecordMaxFrameCountUMA(size_t max_frame_count) {
312 UMA_HISTOGRAM_COUNTS_10000("Navigation.MainFrame.MaxFrameCount",
313 max_frame_count);
314}
315
lukasza6f8ac622017-06-06 03:10:20316} // namespace
317
Erik Chenbb8e738e2018-04-28 14:10:43318std::unique_ptr<WebContents> WebContents::Create(
319 const WebContents::CreateParams& params) {
Albert J. Wong65fe64d2019-09-20 02:48:14320 return WebContentsImpl::Create(params);
321}
322
323std::unique_ptr<WebContentsImpl> WebContentsImpl::Create(
324 const CreateParams& params) {
325 return CreateWithOpener(params, FindOpenerRFH(params));
[email protected]d1198fd2012-08-13 22:50:19326}
327
erikchenade1fef2018-05-02 22:07:57328std::unique_ptr<WebContents> WebContents::CreateWithSessionStorage(
[email protected]54944cde2012-12-09 09:24:59329 const WebContents::CreateParams& params,
[email protected]fdac6ade2013-07-20 01:06:30330 const SessionStorageNamespaceMap& session_storage_namespace_map) {
erikchenade1fef2018-05-02 22:07:57331 std::unique_ptr<WebContentsImpl> new_contents(
332 new WebContentsImpl(params.browser_context));
Ian Clelland5cbaaf82017-11-27 22:00:03333 RenderFrameHostImpl* opener_rfh = FindOpenerRFH(params);
334 FrameTreeNode* opener = nullptr;
335 if (opener_rfh)
336 opener = opener_rfh->frame_tree_node();
337 new_contents->SetOpenerForNewContents(opener, params.opener_suppressed);
[email protected]fdac6ade2013-07-20 01:06:30338
jdoerrie55ec69d2018-10-08 13:34:46339 for (auto it = session_storage_namespace_map.begin();
340 it != session_storage_namespace_map.end(); ++it) {
[email protected]fdac6ade2013-07-20 01:06:30341 new_contents->GetController()
342 .SetSessionStorageNamespace(it->first, it->second.get());
343 }
344
Sean Toppingbbc4a2bd2019-01-30 02:16:14345 WebContentsImpl* outer_web_contents = nullptr;
Sam McNally69a33772018-06-27 16:54:12346 if (params.guest_delegate) {
347 // This makes |new_contents| act as a guest.
348 // For more info, see comment above class BrowserPluginGuest.
Albert J. Wongc55cc64d2018-10-12 02:50:04349 BrowserPluginGuest::CreateInWebContents(new_contents.get(),
350 params.guest_delegate);
Sean Toppingbbc4a2bd2019-01-30 02:16:14351 outer_web_contents = static_cast<WebContentsImpl*>(
352 params.guest_delegate->GetOwnerWebContents());
Sam McNally69a33772018-06-27 16:54:12353 }
354
[email protected]54944cde2012-12-09 09:24:59355 new_contents->Init(params);
Sean Toppingbbc4a2bd2019-01-30 02:16:14356 if (outer_web_contents)
357 outer_web_contents->InnerWebContentsCreated(new_contents.get());
[email protected]d1198fd2012-08-13 22:50:19358 return new_contents;
[email protected]a81343d232011-12-27 07:39:20359}
[email protected]746d3052012-05-22 15:15:47360
benwells5e7260d2017-03-20 23:36:33361void WebContentsImpl::FriendWrapper::AddCreatedCallbackForTesting(
nickf9acfbe2014-12-23 19:12:37362 const CreatedCallback& callback) {
[email protected]cbb1ef592013-06-05 19:49:46363 g_created_callbacks.Get().push_back(callback);
364}
365
benwells5e7260d2017-03-20 23:36:33366void WebContentsImpl::FriendWrapper::RemoveCreatedCallbackForTesting(
nickf9acfbe2014-12-23 19:12:37367 const CreatedCallback& callback) {
[email protected]cbb1ef592013-06-05 19:49:46368 for (size_t i = 0; i < g_created_callbacks.Get().size(); ++i) {
Robert Liao1db5a352019-06-05 20:57:34369 if (g_created_callbacks.Get().at(i) == callback) {
[email protected]cbb1ef592013-06-05 19:49:46370 g_created_callbacks.Get().erase(g_created_callbacks.Get().begin() + i);
371 return;
372 }
373 }
374}
375
avidf38c952015-10-27 13:45:13376WebContents* WebContents::FromRenderViewHost(RenderViewHost* rvh) {
377 if (!rvh)
378 return nullptr;
[email protected]746d3052012-05-22 15:15:47379 return rvh->GetDelegate()->GetAsWebContents();
380}
381
[email protected]a86c0e962013-12-17 17:10:39382WebContents* WebContents::FromRenderFrameHost(RenderFrameHost* rfh) {
avidf38c952015-10-27 13:45:13383 if (!rfh)
384 return nullptr;
385 return static_cast<RenderFrameHostImpl*>(rfh)->delegate()->GetAsWebContents();
[email protected]a86c0e962013-12-17 17:10:39386}
387
ananta4b7467a52016-09-23 01:42:38388WebContents* WebContents::FromFrameTreeNodeId(int frame_tree_node_id) {
389 FrameTreeNode* frame_tree_node =
390 FrameTreeNode::GloballyFindByID(frame_tree_node_id);
anantab8cfa3b2016-10-14 22:43:19391 if (!frame_tree_node)
392 return nullptr;
jam8c4edd02017-05-06 18:50:33393 return WebContentsImpl::FromFrameTreeNode(frame_tree_node);
ananta4b7467a52016-09-23 01:42:38394}
395
leon.han552e9de2017-02-09 14:37:30396void WebContents::SetScreenOrientationDelegate(
397 ScreenOrientationDelegate* delegate) {
398 ScreenOrientationProvider::SetDelegate(delegate);
399}
400
[email protected]7fff43e2013-05-21 20:21:10401// WebContentsImpl::DestructionObserver ----------------------------------------
402
403class WebContentsImpl::DestructionObserver : public WebContentsObserver {
404 public:
405 DestructionObserver(WebContentsImpl* owner, WebContents* watched_contents)
406 : WebContentsObserver(watched_contents),
407 owner_(owner) {
408 }
409
410 // WebContentsObserver:
dchengc2282aa2014-10-21 12:07:58411 void WebContentsDestroyed() override {
[email protected]12a46832014-05-09 13:35:58412 owner_->OnWebContentsDestroyed(
413 static_cast<WebContentsImpl*>(web_contents()));
[email protected]7fff43e2013-05-21 20:21:10414 }
415
416 private:
417 WebContentsImpl* owner_;
418
419 DISALLOW_COPY_AND_ASSIGN(DestructionObserver);
420};
421
Joel Hockey85b379d2017-12-11 10:42:13422// WebContentsImpl::ColorChooser ----------------------------------------------
Joel Hockey163835a2017-12-20 11:51:57423class WebContentsImpl::ColorChooser : public blink::mojom::ColorChooser {
Joel Hockey85b379d2017-12-11 10:42:13424 public:
425 ColorChooser(content::ColorChooser* chooser,
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20426 mojo::PendingReceiver<blink::mojom::ColorChooser> receiver,
427 mojo::PendingRemote<blink::mojom::ColorChooserClient> client)
Joel Hockey85b379d2017-12-11 10:42:13428 : chooser_(chooser),
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20429 receiver_(this, std::move(receiver)),
Joel Hockey85b379d2017-12-11 10:42:13430 client_(std::move(client)) {
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20431 receiver_.set_disconnect_handler(
Joel Hockey85b379d2017-12-11 10:42:13432 base::BindOnce([](content::ColorChooser* chooser) { chooser->End(); },
433 base::Unretained(chooser)));
434 }
[email protected]8ed16472014-04-11 19:02:48435
Joel Hockey85b379d2017-12-11 10:42:13436 ~ColorChooser() override { chooser_->End(); }
[email protected]8ed16472014-04-11 19:02:48437
Joel Hockey85b379d2017-12-11 10:42:13438 void SetSelectedColor(SkColor color) override {
439 chooser_->SetSelectedColor(color);
440 }
441
442 void DidChooseColorInColorChooser(SkColor color) {
443 client_->DidChooseColor(color);
444 }
445
446 private:
447 // Color chooser that was opened by this tab.
448 std::unique_ptr<content::ColorChooser> chooser_;
449
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20450 // mojo receiver.
451 mojo::Receiver<blink::mojom::ColorChooser> receiver_;
Joel Hockey85b379d2017-12-11 10:42:13452
453 // mojo renderer client.
Julie Jeongeun Kim8e2879e2019-08-06 23:55:20454 mojo::Remote<blink::mojom::ColorChooserClient> client_;
Joel Hockey85b379d2017-12-11 10:42:13455};
nicka0ac8382016-12-15 23:59:23456
lazyboy6ec48b2a2015-06-29 15:18:14457// WebContentsImpl::WebContentsTreeNode ----------------------------------------
lfg601233692017-03-06 22:45:44458WebContentsImpl::WebContentsTreeNode::WebContentsTreeNode(
459 WebContentsImpl* current_web_contents)
460 : current_web_contents_(current_web_contents),
461 outer_web_contents_(nullptr),
lazyboy6ec48b2a2015-06-29 15:18:14462 outer_contents_frame_tree_node_id_(
avallee0206f782016-07-28 18:55:33463 FrameTreeNode::kFrameTreeNodeInvalidId),
lfg601233692017-03-06 22:45:44464 focused_web_contents_(current_web_contents) {}
lazyboy6ec48b2a2015-06-29 15:18:14465
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18466WebContentsImpl::WebContentsTreeNode::~WebContentsTreeNode() {}
lazyboy6ec48b2a2015-06-29 15:18:14467
Lucas Furukawa Gadani99125822019-01-03 15:41:49468std::unique_ptr<WebContents>
469WebContentsImpl::WebContentsTreeNode::DisconnectFromOuterWebContents() {
470 std::unique_ptr<WebContents> inner_contents =
471 outer_web_contents_->node_.DetachInnerWebContents(current_web_contents_);
472 OuterContentsFrameTreeNode()->RemoveObserver(this);
473 outer_contents_frame_tree_node_id_ = FrameTreeNode::kFrameTreeNodeInvalidId;
474 outer_web_contents_ = nullptr;
475 return inner_contents;
476}
477
paulmeyerfeafc2d2017-04-25 21:46:40478void WebContentsImpl::WebContentsTreeNode::AttachInnerWebContents(
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:50479 std::unique_ptr<WebContents> inner_web_contents,
480 RenderFrameHostImpl* render_frame_host) {
481 WebContentsImpl* inner_web_contents_impl =
482 static_cast<WebContentsImpl*>(inner_web_contents.get());
483 WebContentsTreeNode& inner_web_contents_node = inner_web_contents_impl->node_;
484
485 inner_web_contents_node.focused_web_contents_ = nullptr;
486 inner_web_contents_node.outer_web_contents_ = current_web_contents_;
487 inner_web_contents_node.outer_contents_frame_tree_node_id_ =
488 render_frame_host->frame_tree_node()->frame_tree_node_id();
489
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18490 inner_web_contents_.push_back(std::move(inner_web_contents));
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:50491
492 render_frame_host->frame_tree_node()->AddObserver(&inner_web_contents_node);
paulmeyerfeafc2d2017-04-25 21:46:40493}
494
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18495std::unique_ptr<WebContents>
496WebContentsImpl::WebContentsTreeNode::DetachInnerWebContents(
paulmeyerfeafc2d2017-04-25 21:46:40497 WebContentsImpl* inner_web_contents) {
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18498 std::unique_ptr<WebContents> detached_contents;
499 for (std::unique_ptr<WebContents>& web_contents : inner_web_contents_) {
500 if (web_contents.get() == inner_web_contents) {
501 detached_contents = std::move(web_contents);
502 std::swap(web_contents, inner_web_contents_.back());
503 inner_web_contents_.pop_back();
504 return detached_contents;
505 }
506 }
507
508 NOTREACHED();
509 return nullptr;
paulmeyerfeafc2d2017-04-25 21:46:40510}
511
lfga3e2bdc2017-03-07 20:44:01512FrameTreeNode*
513WebContentsImpl::WebContentsTreeNode::OuterContentsFrameTreeNode() const {
514 return FrameTreeNode::GloballyFindByID(outer_contents_frame_tree_node_id_);
lfg601233692017-03-06 22:45:44515}
516
lfga3e2bdc2017-03-07 20:44:01517void WebContentsImpl::WebContentsTreeNode::OnFrameTreeNodeDestroyed(
518 FrameTreeNode* node) {
519 DCHECK_EQ(outer_contents_frame_tree_node_id_, node->frame_tree_node_id())
520 << "WebContentsTreeNode should only receive notifications for the "
521 "FrameTreeNode in its outer WebContents that hosts it.";
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18522
523 // Deletes |this| too.
524 outer_web_contents_->node_.DetachInnerWebContents(current_web_contents_);
lazyboy6ec48b2a2015-06-29 15:18:14525}
526
avallee0206f782016-07-28 18:55:33527void WebContentsImpl::WebContentsTreeNode::SetFocusedWebContents(
528 WebContentsImpl* web_contents) {
529 DCHECK(!outer_web_contents())
530 << "Only the outermost WebContents tracks focus.";
531 focused_web_contents_ = web_contents;
532}
533
paulmeyerfeafc2d2017-04-25 21:46:40534WebContentsImpl*
535WebContentsImpl::WebContentsTreeNode::GetInnerWebContentsInFrame(
536 const FrameTreeNode* frame) {
537 auto ftn_id = frame->frame_tree_node_id();
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18538 for (auto& contents : inner_web_contents_) {
539 WebContentsImpl* impl = static_cast<WebContentsImpl*>(contents.get());
540 if (impl->node_.outer_contents_frame_tree_node_id() == ftn_id) {
541 return impl;
paulmeyerfeafc2d2017-04-25 21:46:40542 }
543 }
544 return nullptr;
545}
546
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18547std::vector<WebContentsImpl*>
548WebContentsImpl::WebContentsTreeNode::GetInnerWebContents() const {
549 std::vector<WebContentsImpl*> inner_web_contents;
550 for (auto& contents : inner_web_contents_)
551 inner_web_contents.push_back(static_cast<WebContentsImpl*>(contents.get()));
552
553 return inner_web_contents;
paulmeyerfeafc2d2017-04-25 21:46:40554}
555
[email protected]b172aee2012-04-10 17:05:26556// WebContentsImpl -------------------------------------------------------------
[email protected]420ae012009-04-24 05:16:32557
alexmose201c7cd2015-06-10 17:14:21558WebContentsImpl::WebContentsImpl(BrowserContext* browser_context)
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28559 : delegate_(nullptr),
[email protected]69e797f2013-04-30 01:10:22560 controller_(this, browser_context),
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28561 render_view_host_delegate_view_(nullptr),
alexmose201c7cd2015-06-10 17:14:21562 created_with_opener_(false),
Lucas Furukawa Gadani99125822019-01-03 15:41:49563 node_(this),
[email protected]6ea6bdf2013-12-06 13:35:01564 frame_tree_(new NavigatorImpl(&controller_, this),
blundellc57b93f2014-10-29 13:19:57565 this,
566 this,
567 this,
568 this),
[email protected]6dfed692014-05-22 04:18:03569 is_load_to_different_document_(false),
[email protected]443b80e2010-12-14 00:42:23570 crashed_status_(base::TERMINATION_STATUS_STILL_RUNNING),
571 crashed_error_code_(0),
[email protected]d5f942ba2008-09-26 19:30:34572 waiting_for_response_(false),
[email protected]fcf75d42013-12-03 20:11:26573 load_state_(net::LOAD_STATE_IDLE, base::string16()),
[email protected]094e5b22009-09-25 04:23:56574 upload_size_(0),
575 upload_position_(0),
dfalcantarae6b7b46752015-07-10 18:14:16576 is_resume_pending_(false),
creisadca9862017-06-16 19:12:11577 interstitial_page_(nullptr),
[email protected]b4c84012014-04-28 19:51:10578 has_accessed_initial_document_(false),
[email protected]54597982013-02-06 01:59:55579 capturer_count_(0),
[email protected]fdd61c62009-04-22 19:22:57580 is_being_destroyed_(false),
creis97867aa2017-02-17 18:39:45581 is_notifying_observers_(false),
[email protected]fdd61c62009-04-22 19:22:57582 notify_disconnection_(false),
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28583 dialog_manager_(nullptr),
[email protected]7ab1e7d62009-10-14 23:32:01584 is_showing_before_unload_dialog_(false),
gab0dccfef2015-05-20 18:43:39585 last_active_time_(base::TimeTicks::Now()),
[email protected]ebf40a72010-07-22 01:46:38586 closed_by_user_gesture_(false),
danakj938b37a62019-09-24 18:35:54587 minimum_zoom_percent_(
588 static_cast<int>(blink::kMinimumPageZoomFactor * 100)),
589 maximum_zoom_percent_(
590 static_cast<int>(blink::kMaximumPageZoomFactor * 100)),
w.shackleton49bcd392016-01-06 17:38:22591 zoom_scroll_remainder_(0),
alexmosc9e76ec2016-05-16 22:59:37592 fullscreen_widget_process_id_(ChildProcessHost::kInvalidUniqueID),
[email protected]5dcaf8e2013-12-28 01:31:42593 fullscreen_widget_routing_id_(MSG_ROUTING_NONE),
[email protected]0b431992014-06-24 00:08:03594 fullscreen_widget_had_focus_at_shutdown_(false),
[email protected]34ff1cfc2014-08-20 06:16:05595 force_disable_overscroll_content_(false),
[email protected]95640212014-07-26 18:14:30596 last_dialog_suppressed_(false),
waffles1c12bf402016-02-10 17:45:48597 accessibility_mode_(
Dominic Mazzoni21fb0282019-02-13 18:32:47598 GetContentClient()->browser()->GetAXModeForBrowserContext(
599 browser_context)),
avayvodcc85bbd2015-08-28 19:11:15600 audio_stream_monitor_(this),
Thomas Guilbert882c4cec2019-02-14 05:55:45601 media_web_contents_observer_(
602 std::make_unique<MediaWebContentsObserver>(this)),
mcnee336ea2c2017-05-23 22:50:59603#if !defined(OS_ANDROID)
mcnee432e47d2015-11-09 19:37:46604 page_scale_factor_is_one_(true),
mcnee336ea2c2017-05-23 22:50:59605#endif // !defined(OS_ANDROID)
qinmin72e8bd02016-10-21 19:35:37606 is_overlay_content_(false),
ekaramadf6750aa2017-06-06 18:29:42607 showing_context_menu_(false),
W. James MacLean62198672019-06-04 16:46:10608 text_autosizer_page_info_({0, 0, 1.f}),
Jeremy Roman3bca4bf2019-07-11 03:41:25609 had_inner_webcontents_(false) {
[email protected]9b159a52013-10-03 17:24:55610 frame_tree_.SetFrameRemoveListener(
611 base::Bind(&WebContentsImpl::OnFrameRemoved,
612 base::Unretained(this)));
brettw4b461082016-11-19 18:55:16613#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17614 pepper_playback_observer_.reset(new PepperPlaybackObserver(this));
615#endif
blundelle75a8f92017-03-27 08:11:17616
Becca Hughes86334622018-07-09 21:29:38617#if defined(OS_ANDROID)
Elly Fong-Jonescdd7ae82019-02-20 23:26:33618 display_cutout_host_impl_ = std::make_unique<DisplayCutoutHostImpl>(this);
Becca Hughes86334622018-07-09 21:29:38619#endif
[email protected]332af7732009-03-11 13:21:35620}
initial.commit09911bf2008-07-26 23:55:29621
[email protected]b172aee2012-04-10 17:05:26622WebContentsImpl::~WebContentsImpl() {
creisba91ba82017-05-12 22:56:19623 // Imperfect sanity check against double free, given some crashes unexpectedly
624 // observed in the wild.
625 CHECK(!is_being_destroyed_);
626
627 // We generally keep track of is_being_destroyed_ to let other features know
628 // to avoid certain actions during destruction.
[email protected]420ae012009-04-24 05:16:32629 is_being_destroyed_ = true;
630
creis97867aa2017-02-17 18:39:45631 // A WebContents should never be deleted while it is notifying observers,
creisba91ba82017-05-12 22:56:19632 // since this will lead to a use-after-free as it continues to notify later
creis97867aa2017-02-17 18:39:45633 // observers.
634 CHECK(!is_notifying_observers_);
635
kenrb2a565f82015-09-02 20:24:59636 rwh_input_event_router_.reset();
637
rockotf62002a2016-09-15 00:08:59638 for (auto& entry : binding_sets_)
639 entry.second->CloseAllBindings();
640
avallee0206f782016-07-28 18:55:33641 WebContentsImpl* outermost = GetOutermostWebContents();
avallee9993fca2016-11-17 06:16:50642 if (this != outermost && ContainsOrIsFocusedWebContents()) {
avallee0206f782016-07-28 18:55:33643 // If the current WebContents is in focus, unset it.
avallee9993fca2016-11-17 06:16:50644 outermost->SetAsFocusedWebContentsIfNecessary();
avallee0206f782016-07-28 18:55:33645 }
646
Nick Carterd73635b2018-03-13 18:31:41647 if (mouse_lock_widget_)
648 mouse_lock_widget_->RejectMouseLockOrUnlockIfNecessary();
649
dcheng72be33c2016-01-21 04:11:31650 for (FrameTreeNode* node : frame_tree_.Nodes()) {
651 // Delete all RFHs pending shutdown, which will lead the corresponding RVHs
652 // to be shutdown and be deleted as well.
dcheng57e39e22016-01-21 00:25:38653 node->render_manager()->ClearRFHsPendingShutdown();
dcheng57e39e22016-01-21 00:25:38654 node->render_manager()->ClearWebUIInstances();
dcheng72be33c2016-01-21 04:11:31655 }
carlosk35f35af2015-12-01 10:55:40656
dcheng57e39e22016-01-21 00:25:38657 for (RenderWidgetHostImpl* widget : created_widgets_)
658 widget->DetachDelegate();
[email protected]b24b68a2012-09-24 21:57:26659 created_widgets_.clear();
660
[email protected]3ab9cb82011-06-03 18:02:07661 // Clear out any JavaScript state.
avi5d3b8692016-10-12 22:00:46662 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:53663 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:46664 }
[email protected]3ab9cb82011-06-03 18:02:07665
Joel Hockey85b379d2017-12-11 10:42:13666 color_chooser_.reset();
Rakina Zata Amni16196122018-11-14 02:14:00667 find_request_manager_.reset();
[email protected]da8543762012-03-20 08:52:20668
[email protected]420ae012009-04-24 05:16:32669 NotifyDisconnected();
[email protected]420ae012009-04-24 05:16:32670
[email protected]ca13a442012-04-17 14:00:12671 // Notify any observer that have a reference on this WebContents.
[email protected]8ff00d72012-10-23 19:12:21672 NotificationService::current()->Notify(
673 NOTIFICATION_WEB_CONTENTS_DESTROYED,
674 Source<WebContents>(this),
675 NotificationService::NoDetails());
[email protected]420ae012009-04-24 05:16:32676
Arthur Sonzogni5a9a88c2018-10-18 13:16:00677 // Destroy all subframes now. This notifies observers.
678 GetMainFrame()->ResetChildren();
[email protected]df0c843f2014-05-23 20:37:23679 GetRenderManager()->ResetProxyHosts();
[email protected]c06c58c2014-03-12 20:31:59680
clamy0e119882015-07-31 16:12:33681 // Manually call the observer methods for the root frame tree node. It is
682 // necessary to manually delete all objects tracking navigations
683 // (NavigationHandle, NavigationRequest) for observers to be properly
684 // notified of these navigations stopping before the WebContents is
685 // destroyed.
[email protected]df0c843f2014-05-23 20:37:23686 RenderFrameHostManager* root = GetRenderManager();
naskob21fe4872015-02-24 14:15:56687
Lowell Manners20250112019-10-18 15:06:15688 GetController().GetBackForwardCache().Shutdown();
689
naskob21fe4872015-02-24 14:15:56690 root->current_frame_host()->SetRenderFrameCreated(false);
clamyfc3850d2018-02-23 14:35:28691 root->current_frame_host()->ResetNavigationRequests();
clamy0e119882015-07-31 16:12:33692
Arthur Hemeryc3380172018-01-22 14:00:17693 // Do not update state as the WebContents is being destroyed.
Arthur Hemery241b9392019-10-24 11:08:41694 frame_tree_.root()->ResetNavigationRequest(true);
Arthur Hemeryc3380172018-01-22 14:00:17695 if (root->speculative_frame_host()) {
danakjf2342432019-05-15 21:46:09696 root->speculative_frame_host()->DeleteRenderFrame(
697 FrameDeleteIntention::kSpeculativeMainFrameForShutdown);
Arthur Hemeryc3380172018-01-22 14:00:17698 root->speculative_frame_host()->SetRenderFrameCreated(false);
clamyfc3850d2018-02-23 14:35:28699 root->speculative_frame_host()->ResetNavigationRequests();
clamy0e119882015-07-31 16:12:33700 }
[email protected]f273ee52013-10-18 16:05:27701
brettw4b461082016-11-19 18:55:16702#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17703 // Call this before WebContentsDestroyed() is broadcasted since
704 // AudioFocusManager will be destroyed after that.
705 pepper_playback_observer_.reset();
706#endif // defined(ENABLED_PLUGINS)
707
Chris Hamiltondf0d72cd2018-05-29 16:23:53708 // If audio is playing then notify external observers of the audio stream
709 // disappearing.
710 if (is_currently_audible_) {
711 is_currently_audible_ = false;
712 for (auto& observer : observers_)
713 observer.OnAudioStateChanged(false);
714
715 if (GetOuterWebContents())
716 GetOuterWebContents()->OnAudioStateChanged();
717 }
718
ericwilligersde386342016-10-19 02:35:09719 for (auto& observer : observers_)
720 observer.FrameDeleted(root->current_frame_host());
naskoa83483fb2015-02-27 16:57:10721
ericwilligersde386342016-10-19 02:35:09722 for (auto& observer : observers_)
723 observer.RenderViewDeleted(root->current_host());
[email protected]f273ee52013-10-18 16:05:27724
Kevin McNee576bb5d82019-05-29 16:47:51725#if defined(OS_ANDROID)
726 // For simplicity, destroy the Java WebContents before we notify of the
727 // destruction of the WebContents.
728 ClearWebContentsAndroid();
729#endif
730
ericwilligersde386342016-10-19 02:35:09731 for (auto& observer : observers_)
732 observer.WebContentsDestroyed();
[email protected]12a46832014-05-09 13:35:58733
Becca Hughesd11d6502018-07-31 17:01:28734 if (display_cutout_host_impl_)
735 display_cutout_host_impl_->WebContentsDestroyed();
736
ericwilligersde386342016-10-19 02:35:09737 for (auto& observer : observers_)
738 observer.ResetWebContents();
[email protected]232a5812011-03-04 22:42:08739
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28740 SetDelegate(nullptr);
[email protected]b5a1d11c2011-02-17 03:09:42741}
742
erikchen50735fd2018-05-05 15:08:33743std::unique_ptr<WebContentsImpl> WebContentsImpl::CreateWithOpener(
[email protected]54944cde2012-12-09 09:24:59744 const WebContents::CreateParams& params,
Ian Clelland5cbaaf82017-11-27 22:00:03745 RenderFrameHostImpl* opener_rfh) {
[email protected]e11f0e92013-06-12 15:12:03746 TRACE_EVENT0("browser", "WebContentsImpl::CreateWithOpener");
Ian Clelland5cbaaf82017-11-27 22:00:03747 FrameTreeNode* opener = nullptr;
748 if (opener_rfh)
749 opener = opener_rfh->frame_tree_node();
erikchen50735fd2018-05-05 15:08:33750 std::unique_ptr<WebContentsImpl> new_contents(
751 new WebContentsImpl(params.browser_context));
lukasza6f8ac622017-06-06 03:10:20752 new_contents->SetOpenerForNewContents(opener, params.opener_suppressed);
alexmose201c7cd2015-06-10 17:14:21753
alexmosaedfc6f2016-01-21 23:57:38754 // If the opener is sandboxed, a new popup must inherit the opener's sandbox
755 // flags, and these flags take effect immediately. An exception is if the
756 // opener's sandbox flags lack the PropagatesToAuxiliaryBrowsingContexts
757 // bit (which is controlled by the "allow-popups-to-escape-sandbox" token).
758 // See https://html.spec.whatwg.org/#attr-iframe-sandbox.
lukasza6f8ac622017-06-06 03:10:20759 FrameTreeNode* new_root = new_contents->GetFrameTree()->root();
alexmosaedfc6f2016-01-21 23:57:38760 if (opener) {
Ian Clelland5cbaaf82017-11-27 22:00:03761 blink::WebSandboxFlags opener_flags = opener_rfh->active_sandbox_flags();
alexmosaedfc6f2016-01-21 23:57:38762 const blink::WebSandboxFlags inherit_flag =
Blink Reformat1c4d759e2017-04-09 16:34:54763 blink::WebSandboxFlags::kPropagatesToAuxiliaryBrowsingContexts;
Ehsan Karamad39407082019-02-19 23:38:19764 bool sandbox_propagates_to_auxilary_context =
765 (opener_flags & inherit_flag) == inherit_flag;
766 if (sandbox_propagates_to_auxilary_context)
Ian Clellandcdc4f312017-10-13 22:24:12767 new_root->SetPendingFramePolicy({opener_flags, {}});
Ehsan Karamad39407082019-02-19 23:38:19768 if (opener_flags == blink::WebSandboxFlags::kNone ||
769 sandbox_propagates_to_auxilary_context) {
770 // TODO(ekaramad, iclelland): Do not propagate feature policies from non-
771 // sandboxed disowned openers (rel=noopener).
772 // If the current page is not sandboxed, or if the sandbox is to propagate
773 // to the popups then opener's feature policy will apply to the new popup
774 // as well.
775 new_root->SetOpenerFeaturePolicyState(
Ehsan Karamad34d10682019-02-26 20:55:04776 opener_rfh->feature_policy()->GetFeatureState());
alexmosaedfc6f2016-01-21 23:57:38777 }
778 }
779
mark a. foltzef394fce2017-10-21 09:11:02780 // Apply starting sandbox flags.
Luna Luc3fdacdf2017-11-08 04:48:53781 blink::FramePolicy frame_policy(new_root->pending_frame_policy());
mark a. foltzef394fce2017-10-21 09:11:02782 frame_policy.sandbox_flags |= params.starting_sandbox_flags;
783 new_root->SetPendingFramePolicy(frame_policy);
784 new_root->CommitPendingFramePolicy();
785
alexmose201c7cd2015-06-10 17:14:21786 // This may be true even when opener is null, such as when opening blocked
787 // popups.
alexmos090fae8e2015-05-28 17:09:28788 if (params.created_with_opener)
789 new_contents->created_with_opener_ = true;
790
Sean Toppingbbc4a2bd2019-01-30 02:16:14791 WebContentsImpl* outer_web_contents = nullptr;
[email protected]4858e432014-06-23 18:14:17792 if (params.guest_delegate) {
[email protected]83100cd2014-05-10 11:50:06793 // This makes |new_contents| act as a guest.
794 // For more info, see comment above class BrowserPluginGuest.
Albert J. Wongc55cc64d2018-10-12 02:50:04795 BrowserPluginGuest::CreateInWebContents(new_contents.get(),
796 params.guest_delegate);
Sean Toppingbbc4a2bd2019-01-30 02:16:14797 outer_web_contents = static_cast<WebContentsImpl*>(
798 params.guest_delegate->GetOwnerWebContents());
[email protected]83100cd2014-05-10 11:50:06799 }
mark a. foltzef394fce2017-10-21 09:11:02800
[email protected]54944cde2012-12-09 09:24:59801 new_contents->Init(params);
Sean Toppingbbc4a2bd2019-01-30 02:16:14802 if (outer_web_contents)
803 outer_web_contents->InnerWebContentsCreated(new_contents.get());
[email protected]d1198fd2012-08-13 22:50:19804 return new_contents;
805}
806
[email protected]95640212014-07-26 18:14:30807// static
808std::vector<WebContentsImpl*> WebContentsImpl::GetAllWebContents() {
809 std::vector<WebContentsImpl*> result;
dcheng59716272016-04-09 05:19:08810 std::unique_ptr<RenderWidgetHostIterator> widgets(
[email protected]95640212014-07-26 18:14:30811 RenderWidgetHostImpl::GetRenderWidgetHosts());
[email protected]95640212014-07-26 18:14:30812 while (RenderWidgetHost* rwh = widgets->GetNextHost()) {
[email protected]95640212014-07-26 18:14:30813 RenderViewHost* rvh = RenderViewHost::From(rwh);
814 if (!rvh)
815 continue;
816 WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
817 if (!web_contents)
818 continue;
avidf38c952015-10-27 13:45:13819 if (web_contents->GetRenderViewHost() != rvh)
820 continue;
821 // Because a WebContents can only have one current RVH at a time, there will
822 // be no duplicate WebContents here.
823 result.push_back(static_cast<WebContentsImpl*>(web_contents));
[email protected]95640212014-07-26 18:14:30824 }
825 return result;
826}
827
clamya16aa8172015-05-26 13:07:25828// static
829WebContentsImpl* WebContentsImpl::FromFrameTreeNode(
paulmeyerfeafc2d2017-04-25 21:46:40830 const FrameTreeNode* frame_tree_node) {
clamya16aa8172015-05-26 13:07:25831 return static_cast<WebContentsImpl*>(
832 WebContents::FromRenderFrameHost(frame_tree_node->current_frame_host()));
833}
834
clamy0d32d6d2015-11-24 11:16:26835// static
836WebContents* WebContentsImpl::FromRenderFrameHostID(int render_process_host_id,
837 int render_frame_host_id) {
Min Qina1150112019-02-15 01:47:49838 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
839 !BrowserThread::IsThreadInitialized(BrowserThread::UI));
clamy0d32d6d2015-11-24 11:16:26840 RenderFrameHost* render_frame_host =
841 RenderFrameHost::FromID(render_process_host_id, render_frame_host_id);
842 if (!render_frame_host)
843 return nullptr;
844
845 return WebContents::FromRenderFrameHost(render_frame_host);
846}
847
paulmeyerfeafc2d2017-04-25 21:46:40848// static
849WebContentsImpl* WebContentsImpl::FromOuterFrameTreeNode(
850 const FrameTreeNode* frame_tree_node) {
851 return WebContentsImpl::FromFrameTreeNode(frame_tree_node)
852 ->node_.GetInnerWebContentsInFrame(frame_tree_node);
853}
854
[email protected]b0936d22013-11-28 06:47:36855RenderFrameHostManager* WebContentsImpl::GetRenderManagerForTesting() {
[email protected]fa944cb82013-11-15 17:51:21856 return GetRenderManager();
[email protected]765187182012-01-11 23:59:28857}
858
nicka0ac8382016-12-15 23:59:23859bool WebContentsImpl::OnMessageReceived(RenderViewHostImpl* render_view_host,
[email protected]7bb761892012-07-20 09:32:47860 const IPC::Message& message) {
nicka0ac8382016-12-15 23:59:23861 for (auto& observer : observers_) {
Lukasz Anforowicz89f2c1b2017-08-30 21:36:46862 // TODO(nick, creis): https://crbug.com/758026: Replace all uses of this
863 // variant of OnMessageReceived with the version that takes a
864 // RenderFrameHost, and then delete it.
nicka0ac8382016-12-15 23:59:23865 if (observer.OnMessageReceived(message))
866 return true;
[email protected]64ffefa2014-05-10 12:06:33867 }
[email protected]403415a2011-01-10 18:57:53868
[email protected]724159a2010-12-30 01:11:18869 bool handled = true;
nicka0ac8382016-12-15 23:59:23870 IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(WebContentsImpl, message, render_view_host)
nicka0ac8382016-12-15 23:59:23871 IPC_MESSAGE_HANDLER(ViewHostMsg_PageScaleFactorChanged,
872 OnPageScaleFactorChanged)
W. James MacLean62198672019-06-04 16:46:10873 IPC_MESSAGE_HANDLER(
874 ViewHostMsg_NotifyTextAutosizerPageInfoChangedInLocalMainFrame,
875 OnTextAutosizerPageInfoChanged)
nicka0ac8382016-12-15 23:59:23876#if BUILDFLAG(ENABLE_PLUGINS)
877 IPC_MESSAGE_HANDLER(ViewHostMsg_RequestPpapiBrokerPermission,
878 OnRequestPpapiBrokerPermission)
879#endif
nicka0ac8382016-12-15 23:59:23880 IPC_MESSAGE_UNHANDLED(handled = false)
881 IPC_END_MESSAGE_MAP()
882
883 return handled;
884}
885
886bool WebContentsImpl::OnMessageReceived(RenderFrameHostImpl* render_frame_host,
887 const IPC::Message& message) {
Lukasz Anforowicz02923102017-10-09 18:11:37888 {
889 WebUIImpl* web_ui = render_frame_host->web_ui();
890 if (web_ui && web_ui->OnMessageReceived(message, render_frame_host))
891 return true;
892 }
893
nicka0ac8382016-12-15 23:59:23894 for (auto& observer : observers_) {
895 if (observer.OnMessageReceived(message, render_frame_host))
896 return true;
897 }
898
899 bool handled = true;
900 IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(WebContentsImpl, message, render_frame_host)
[email protected]cfa856d62014-02-22 07:58:40901 IPC_MESSAGE_HANDLER(FrameHostMsg_DomOperationResponse,
902 OnDomOperationResponse)
[email protected]8ed16472014-04-11 19:02:48903 IPC_MESSAGE_HANDLER(FrameHostMsg_DidFinishLoad, OnDidFinishLoad)
avi7830c852015-08-31 23:46:25904 IPC_MESSAGE_HANDLER(FrameHostMsg_DidLoadResourceFromMemoryCache,
[email protected]724159a2010-12-30 01:11:18905 OnDidLoadResourceFromMemoryCache)
avi3a3332622015-09-01 01:18:54906 IPC_MESSAGE_HANDLER(FrameHostMsg_DidRunInsecureContent,
[email protected]724159a2010-12-30 01:11:18907 OnDidRunInsecureContent)
estark910b4572015-12-09 20:55:41908 IPC_MESSAGE_HANDLER(FrameHostMsg_DidDisplayContentWithCertificateErrors,
909 OnDidDisplayContentWithCertificateErrors)
910 IPC_MESSAGE_HANDLER(FrameHostMsg_DidRunContentWithCertificateErrors,
911 OnDidRunContentWithCertificateErrors)
Dave Tapuska549baab2019-03-19 15:52:40912 IPC_MESSAGE_HANDLER(FrameHostMsg_GoToEntryAtOffset, OnGoToEntryAtOffset)
kouhei40f03cb2015-09-24 07:47:01913 IPC_MESSAGE_HANDLER(FrameHostMsg_UpdatePageImportanceSignals,
914 OnUpdatePageImportanceSignals)
lukasza178ff092017-06-07 23:39:50915 IPC_MESSAGE_HANDLER(FrameHostMsg_UpdateFaviconURL, OnUpdateFaviconURL)
brettw4b461082016-11-19 18:55:16916#if BUILDFLAG(ENABLE_PLUGINS)
emaxxe70f5e12015-05-29 11:26:00917 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperInstanceCreated,
918 OnPepperInstanceCreated)
919 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperInstanceDeleted,
920 OnPepperInstanceDeleted)
tommyclie6633ca72014-10-31 00:40:42921 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperPluginHung, OnPepperPluginHung)
zqzhang181047e62016-07-01 13:37:17922 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperStartsPlayback,
923 OnPepperStartsPlayback)
924 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperStopsPlayback,
925 OnPepperStopsPlayback)
tommyclie6633ca72014-10-31 00:40:42926 IPC_MESSAGE_HANDLER(FrameHostMsg_PluginCrashed, OnPluginCrashed)
[email protected]c4538072013-03-18 02:17:55927 IPC_MESSAGE_HANDLER_GENERIC(BrowserPluginHostMsg_Attach,
fsamuel833ee7c2015-02-13 23:40:40928 OnBrowserPluginMessage(render_frame_host,
929 message))
thestigc4cac8f2014-09-04 21:17:50930#endif
[email protected]724159a2010-12-30 01:11:18931 IPC_MESSAGE_UNHANDLED(handled = false)
[email protected]e44d1342014-05-16 21:29:33932 IPC_END_MESSAGE_MAP()
[email protected]724159a2010-12-30 01:11:18933
[email protected]724159a2010-12-30 01:11:18934 return handled;
935}
936
[email protected]d1198fd2012-08-13 22:50:19937NavigationControllerImpl& WebContentsImpl::GetController() {
[email protected]f5fa20e2011-12-21 22:35:56938 return controller_;
939}
940
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41941BrowserContext* WebContentsImpl::GetBrowserContext() {
[email protected]a26023822011-12-29 00:23:55942 return controller_.GetBrowserContext();
[email protected]627e0512011-12-21 22:55:30943}
944
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41945const GURL& WebContentsImpl::GetURL() {
Peter Boström101d7672018-12-15 00:43:59946 return GetVisibleURL();
[email protected]be1f56ab2011-12-22 06:55:31947}
948
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41949const GURL& WebContentsImpl::GetVisibleURL() {
[email protected]c854a7e2013-05-21 16:42:24950 // We may not have a navigation entry yet.
[email protected]59167c22013-06-03 18:07:32951 NavigationEntry* entry = controller_.GetVisibleEntry();
[email protected]c854a7e2013-05-21 16:42:24952 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
953}
954
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41955const GURL& WebContentsImpl::GetLastCommittedURL() {
[email protected]c854a7e2013-05-21 16:42:24956 // We may not have a navigation entry yet.
957 NavigationEntry* entry = controller_.GetLastCommittedEntry();
958 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
959}
960
[email protected]8ff00d72012-10-23 19:12:21961WebContentsDelegate* WebContentsImpl::GetDelegate() {
[email protected]be1f56ab2011-12-22 06:55:31962 return delegate_;
963}
964
[email protected]8ff00d72012-10-23 19:12:21965void WebContentsImpl::SetDelegate(WebContentsDelegate* delegate) {
[email protected]be1f56ab2011-12-22 06:55:31966 // TODO(cbentzel): remove this debugging code?
967 if (delegate == delegate_)
968 return;
969 if (delegate_)
970 delegate_->Detach(this);
971 delegate_ = delegate;
[email protected]a6b73c62013-02-11 23:05:08972 if (delegate_) {
[email protected]be1f56ab2011-12-22 06:55:31973 delegate_->Attach(this);
[email protected]a6b73c62013-02-11 23:05:08974 // Ensure the visible RVH reflects the new delegate's preferences.
[email protected]86f98a22013-03-20 14:35:00975 if (view_)
[email protected]e85165c642014-06-10 14:34:31976 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
Joel Einbinder848001c2017-09-19 21:39:31977 if (GetRenderViewHost())
978 RenderFrameDevToolsAgentHost::WebContentsCreated(this);
[email protected]a6b73c62013-02-11 23:05:08979 }
[email protected]be1f56ab2011-12-22 06:55:31980}
981
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41982RenderFrameHostImpl* WebContentsImpl::GetMainFrame() {
[email protected]94d0cc12013-12-18 00:07:41983 return frame_tree_.root()->current_frame_host();
[email protected]60eca4eb2013-12-06 00:02:16984}
985
nick53d5cbf2015-04-23 22:50:14986RenderFrameHostImpl* WebContentsImpl::GetFocusedFrame() {
987 FrameTreeNode* focused_node = frame_tree_.GetFocusedFrame();
988 if (!focused_node)
989 return nullptr;
990 return focused_node->current_frame_host();
[email protected]9c9343b2014-03-08 02:56:07991}
992
rob3e2a0732016-01-06 21:22:09993RenderFrameHostImpl* WebContentsImpl::FindFrameByFrameTreeNodeId(
creisf71a2632017-05-04 19:03:50994 int frame_tree_node_id,
995 int process_id) {
996 FrameTreeNode* frame = frame_tree_.FindByID(frame_tree_node_id);
997
998 // Sanity check that this is in the caller's expected process. Otherwise a
999 // recent cross-process navigation may have led to a privilege change that the
1000 // caller is not expecting.
1001 if (!frame ||
1002 frame->current_frame_host()->GetProcess()->GetID() != process_id)
1003 return nullptr;
1004
1005 return frame->current_frame_host();
1006}
1007
1008RenderFrameHostImpl* WebContentsImpl::UnsafeFindFrameByFrameTreeNodeId(
rob3e2a0732016-01-06 21:22:091009 int frame_tree_node_id) {
creisf71a2632017-05-04 19:03:501010 // Beware using this! The RenderFrameHost may have changed since the caller
1011 // obtained frame_tree_node_id.
rob3e2a0732016-01-06 21:22:091012 FrameTreeNode* frame = frame_tree_.FindByID(frame_tree_node_id);
1013 return frame ? frame->current_frame_host() : nullptr;
1014}
1015
[email protected]a86c0e962013-12-17 17:10:391016void WebContentsImpl::ForEachFrame(
Lei Zhangebcc6302018-01-12 19:46:451017 const base::RepeatingCallback<void(RenderFrameHost*)>& on_frame) {
dcheng57e39e22016-01-21 00:25:381018 for (FrameTreeNode* node : frame_tree_.Nodes()) {
1019 on_frame.Run(node->current_frame_host());
1020 }
[email protected]a86c0e962013-12-17 17:10:391021}
1022
dchengafb53e22016-02-04 08:11:081023std::vector<RenderFrameHost*> WebContentsImpl::GetAllFrames() {
1024 std::vector<RenderFrameHost*> frame_hosts;
1025 for (FrameTreeNode* node : frame_tree_.Nodes())
1026 frame_hosts.push_back(node->current_frame_host());
1027 return frame_hosts;
1028}
1029
lukaszacbdf52e2016-01-15 21:19:511030int WebContentsImpl::SendToAllFrames(IPC::Message* message) {
1031 int number_of_messages = 0;
dchengafb53e22016-02-04 08:11:081032 for (RenderFrameHost* rfh : GetAllFrames()) {
lukasza1a9ab2422016-03-02 18:47:251033 if (!rfh->IsRenderFrameLive())
1034 continue;
1035
dchengafb53e22016-02-04 08:11:081036 ++number_of_messages;
1037 IPC::Message* message_copy = new IPC::Message(*message);
1038 message_copy->set_routing_id(rfh->GetRoutingID());
1039 rfh->Send(message_copy);
1040 }
[email protected]a86c0e962013-12-17 17:10:391041 delete message;
lukaszacbdf52e2016-01-15 21:19:511042 return number_of_messages;
[email protected]a86c0e962013-12-17 17:10:391043}
1044
lfgdb5c4ed2016-03-04 23:09:071045void WebContentsImpl::SendPageMessage(IPC::Message* msg) {
alexmos136fd6e62016-08-15 20:58:411046 frame_tree_.root()->render_manager()->SendPageMessage(msg, nullptr);
lfgdb5c4ed2016-03-04 23:09:071047}
1048
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411049RenderViewHostImpl* WebContentsImpl::GetRenderViewHost() {
[email protected]fa944cb82013-11-15 17:51:211050 return GetRenderManager()->current_host();
[email protected]be1f56ab2011-12-22 06:55:311051}
1052
creis89a0f782015-05-27 16:13:171053void WebContentsImpl::CancelActiveAndPendingDialogs() {
avi5d3b8692016-10-12 22:00:461054 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:531055 dialog_manager_->CancelDialogs(this, /*reset_state=*/false);
avi5d3b8692016-10-12 22:00:461056 }
creis89a0f782015-05-27 16:13:171057 if (browser_plugin_embedder_)
1058 browser_plugin_embedder_->CancelGuestDialogs();
1059}
1060
naskoc0fceff2015-04-30 15:53:521061void WebContentsImpl::ClosePage() {
1062 GetRenderViewHost()->ClosePage();
1063}
1064
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411065RenderWidgetHostView* WebContentsImpl::GetRenderWidgetHostView() {
[email protected]fa944cb82013-11-15 17:51:211066 return GetRenderManager()->GetRenderWidgetHostView();
[email protected]be1f56ab2011-12-22 06:55:311067}
1068
lfg265a2672016-04-23 03:11:021069RenderWidgetHostView* WebContentsImpl::GetTopLevelRenderWidgetHostView() {
1070 if (GetOuterWebContents())
1071 return GetOuterWebContents()->GetTopLevelRenderWidgetHostView();
1072 return GetRenderManager()->GetRenderWidgetHostView();
1073}
1074
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411075RenderWidgetHostView* WebContentsImpl::GetFullscreenRenderWidgetHostView() {
vmpstr6d9996c82017-02-23 00:43:251076 if (auto* widget_host = GetFullscreenRenderWidgetHost())
ekaramadaeb3c5c2016-11-09 03:22:351077 return widget_host->GetView();
1078 return nullptr;
[email protected]4aebbca2013-09-17 22:26:491079}
1080
[email protected]8ff00d72012-10-23 19:12:211081WebContentsView* WebContentsImpl::GetView() const {
[email protected]be1f56ab2011-12-22 06:55:311082 return view_.get();
1083}
1084
leon.han552e9de2017-02-09 14:37:301085void WebContentsImpl::OnScreenOrientationChange() {
1086 DCHECK(screen_orientation_provider_);
Becca Hughese9e27952018-06-25 17:08:271087 screen_orientation_provider_->OnOrientationChange();
leon.hane4db177a2017-02-07 14:19:161088}
1089
Alan Cutter92d59252019-03-29 02:32:331090base::Optional<SkColor> WebContentsImpl::GetThemeColor() {
Carlos Caballero1215f882019-10-29 15:58:431091 return GetRenderViewHost()->theme_color();
yusufod41c5f92015-03-06 00:14:281092}
1093
Doug Turner63f3c7b2017-07-29 05:10:011094void WebContentsImpl::SetAccessibilityMode(ui::AXMode mode) {
[email protected]95640212014-07-26 18:14:301095 if (mode == accessibility_mode_)
1096 return;
1097
dmazzonif8a31042016-12-03 00:52:131098 // Don't allow accessibility to be enabled for WebContents that are never
1099 // visible, like background pages.
1100 if (IsNeverVisible())
1101 return;
1102
[email protected]95640212014-07-26 18:14:301103 accessibility_mode_ = mode;
dcheng57e39e22016-01-21 00:25:381104
1105 for (FrameTreeNode* node : frame_tree_.Nodes()) {
dmazzonif8a31042016-12-03 00:52:131106 UpdateAccessibilityModeOnFrame(node->current_frame_host());
clamy610c63b32017-12-22 15:05:181107 // Also update accessibility mode on the speculative RenderFrameHost for
1108 // this FrameTreeNode, if one exists.
Alex Moshchuk3d8a1f392017-10-24 19:01:261109 RenderFrameHost* speculative_frame_host =
1110 node->render_manager()->speculative_frame_host();
1111 if (speculative_frame_host)
1112 UpdateAccessibilityModeOnFrame(speculative_frame_host);
dcheng57e39e22016-01-21 00:25:381113 }
[email protected]95640212014-07-26 18:14:301114}
1115
Doug Turner63f3c7b2017-07-29 05:10:011116void WebContentsImpl::AddAccessibilityMode(ui::AXMode mode) {
1117 ui::AXMode new_mode(accessibility_mode_);
dougtcd3dad732017-03-14 03:26:231118 new_mode |= mode;
1119 SetAccessibilityMode(new_mode);
[email protected]95640212014-07-26 18:14:301120}
1121
Avi Drissman1e620f32018-03-16 13:57:291122// Helper class used by WebContentsImpl::RequestAXTreeSnapshot.
1123// Handles the callbacks from parallel snapshot requests to each frame,
1124// and feeds the results to an AXTreeCombiner, which converts them into a
1125// single combined accessibility tree.
1126class WebContentsImpl::AXTreeSnapshotCombiner
1127 : public base::RefCounted<AXTreeSnapshotCombiner> {
1128 public:
1129 explicit AXTreeSnapshotCombiner(AXTreeSnapshotCallback callback)
1130 : callback_(std::move(callback)) {}
1131
1132 AXTreeSnapshotCallback AddFrame(bool is_root) {
1133 // Adds a reference to |this|.
1134 return base::BindOnce(&AXTreeSnapshotCombiner::ReceiveSnapshot, this,
1135 is_root);
1136 }
1137
1138 void ReceiveSnapshot(bool is_root, const ui::AXTreeUpdate& snapshot) {
1139 combiner_.AddTree(snapshot, is_root);
1140 }
1141
1142 private:
1143 friend class base::RefCounted<AXTreeSnapshotCombiner>;
1144
1145 // This is called automatically after the last call to ReceiveSnapshot
1146 // when there are no more references to this object.
1147 ~AXTreeSnapshotCombiner() {
1148 combiner_.Combine();
1149 std::move(callback_).Run(combiner_.combined());
1150 }
1151
1152 ui::AXTreeCombiner combiner_;
1153 AXTreeSnapshotCallback callback_;
1154};
1155
1156void WebContentsImpl::RequestAXTreeSnapshot(AXTreeSnapshotCallback callback,
1157 ui::AXMode ax_mode) {
dmazzonid95ae842016-04-12 21:17:391158 // Send a request to each of the frames in parallel. Each one will return
1159 // an accessibility tree snapshot, and AXTreeSnapshotCombiner will combine
1160 // them into a single tree and call |callback| with that result, then
1161 // delete |combiner|.
Avi Drissman1e620f32018-03-16 13:57:291162 FrameTreeNode* root_node = frame_tree_.root();
tzik58faa742018-08-01 10:54:181163 auto combiner =
1164 base::MakeRefCounted<AXTreeSnapshotCombiner>(std::move(callback));
Avi Drissman1e620f32018-03-16 13:57:291165
tzik58faa742018-08-01 10:54:181166 RecursiveRequestAXTreeSnapshotOnFrame(root_node, combiner.get(), ax_mode);
Avi Drissman1e620f32018-03-16 13:57:291167}
1168
1169void WebContentsImpl::RecursiveRequestAXTreeSnapshotOnFrame(
1170 FrameTreeNode* root_node,
1171 AXTreeSnapshotCombiner* combiner,
1172 ui::AXMode ax_mode) {
dmazzonid95ae842016-04-12 21:17:391173 for (FrameTreeNode* frame_tree_node : frame_tree_.Nodes()) {
Avi Drissman1e620f32018-03-16 13:57:291174 WebContentsImpl* inner_contents =
1175 node_.GetInnerWebContentsInFrame(frame_tree_node);
1176 if (inner_contents) {
1177 inner_contents->RecursiveRequestAXTreeSnapshotOnFrame(root_node, combiner,
1178 ax_mode);
1179 } else {
1180 bool is_root = frame_tree_node == root_node;
1181 frame_tree_node->current_frame_host()->RequestAXTreeSnapshot(
1182 combiner->AddFrame(is_root), ax_mode);
1183 }
dmazzonid95ae842016-04-12 21:17:391184 }
dmazzoni83ba5c82015-04-14 07:11:511185}
1186
Becca Hughes3b5a43482018-07-17 22:31:551187void WebContentsImpl::NotifyViewportFitChanged(
1188 blink::mojom::ViewportFit value) {
1189 for (auto& observer : observers_)
1190 observer.ViewportFitChanged(value);
1191}
1192
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411193FindRequestManager* WebContentsImpl::GetFindRequestManagerForTesting() {
Ehsan Karamad6beb2ea2018-11-25 18:15:131194 return GetFindRequestManager();
1195}
1196
mcnee336ea2c2017-05-23 22:50:591197#if !defined(OS_ANDROID)
akabac6bd1212018-06-25 20:10:481198void WebContentsImpl::UpdateZoom() {
1199 RenderWidgetHostImpl* rwh = GetRenderViewHost()->GetWidget();
1200 if (rwh->GetView())
1201 rwh->SynchronizeVisualProperties();
wjmaclean64951902016-04-29 20:59:121202}
1203
wjmaclean64951902016-04-29 20:59:121204
1205void WebContentsImpl::UpdateZoomIfNecessary(const std::string& scheme,
akabac6bd1212018-06-25 20:10:481206 const std::string& host) {
wjmaclean64951902016-04-29 20:59:121207 NavigationEntry* entry = GetController().GetLastCommittedEntry();
1208 if (!entry)
1209 return;
1210
1211 GURL url = HostZoomMap::GetURLFromEntry(entry);
1212 if (host != net::GetHostOrSpecFromURL(url) ||
1213 (!scheme.empty() && !url.SchemeIs(scheme))) {
1214 return;
1215 }
1216
akabac6bd1212018-06-25 20:10:481217 UpdateZoom();
wjmaclean64951902016-04-29 20:59:121218}
mcnee336ea2c2017-05-23 22:50:591219#endif // !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:121220
rockotf62002a2016-09-15 00:08:591221base::Closure WebContentsImpl::AddBindingSet(
1222 const std::string& interface_name,
1223 WebContentsBindingSet* binding_set) {
1224 auto result =
1225 binding_sets_.insert(std::make_pair(interface_name, binding_set));
1226 DCHECK(result.second);
1227 return base::Bind(&WebContentsImpl::RemoveBindingSet,
1228 weak_factory_.GetWeakPtr(), interface_name);
1229}
1230
rockot8bbad222017-03-22 04:34:051231WebContentsBindingSet* WebContentsImpl::GetBindingSet(
1232 const std::string& interface_name) {
1233 auto it = binding_sets_.find(interface_name);
1234 if (it == binding_sets_.end())
1235 return nullptr;
1236 return it->second;
1237}
1238
paulmeyerfeafc2d2017-04-25 21:46:401239std::vector<WebContentsImpl*> WebContentsImpl::GetWebContentsAndAllInner() {
1240 std::vector<WebContentsImpl*> all_contents(1, this);
1241
1242 for (size_t i = 0; i != all_contents.size(); ++i) {
1243 for (auto* inner_contents : all_contents[i]->GetInnerWebContents()) {
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:161244 all_contents.push_back(static_cast<WebContentsImpl*>(inner_contents));
paulmeyerfeafc2d2017-04-25 21:46:401245 }
1246 }
1247
1248 return all_contents;
1249}
1250
Sam McNally145fb172017-05-10 00:13:231251void WebContentsImpl::NotifyManifestUrlChanged(
1252 const base::Optional<GURL>& manifest_url) {
1253 for (auto& observer : observers_)
1254 observer.DidUpdateWebManifestURL(manifest_url);
1255}
1256
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411257WebUI* WebContentsImpl::GetWebUI() {
Nasko Oskov2f7d2112019-10-29 03:26:571258 WebUI* committed_web_ui = GetCommittedWebUI();
1259 if (committed_web_ui)
1260 return committed_web_ui;
1261
1262 if (GetRenderManager()->speculative_frame_host())
1263 return GetRenderManager()->speculative_frame_host()->web_ui();
1264
1265 return nullptr;
[email protected]be1f56ab2011-12-22 06:55:311266}
1267
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411268WebUI* WebContentsImpl::GetCommittedWebUI() {
carlosk35f35af2015-12-01 10:55:401269 return frame_tree_.root()->current_frame_host()->web_ui();
[email protected]d5f942ba2008-09-26 19:30:341270}
1271
Changwan Ryuc1134a82018-03-07 02:10:141272void WebContentsImpl::SetUserAgentOverride(const std::string& override,
1273 bool override_in_new_tabs) {
[email protected]bf70edce2012-06-20 22:32:221274 if (GetUserAgentOverride() == override)
1275 return;
1276
Changwan Ryuc1134a82018-03-07 02:10:141277 should_override_user_agent_in_new_tabs_ = override_in_new_tabs;
1278
[email protected]bf70edce2012-06-20 22:32:221279 renderer_preferences_.user_agent_override = override;
1280
Bruce Long1e3e1f542019-10-16 17:56:281281 // Send the new override string to all renderers in the current page.
1282 SyncRendererPrefs();
[email protected]bf70edce2012-06-20 22:32:221283
1284 // Reload the page if a load is currently in progress to avoid having
1285 // different parts of the page loaded using different user agents.
[email protected]6286a372013-10-09 04:03:271286 NavigationEntry* entry = controller_.GetVisibleEntry();
Ivan Kotenkov2c0d2bb32017-11-01 15:41:281287 if (IsLoading() && entry != nullptr && entry->GetIsOverridingUserAgent())
toyoshim6142d96f2016-12-19 09:07:251288 controller_.Reload(ReloadType::BYPASSING_CACHE, true);
[email protected]8d0f3312012-08-18 01:47:531289
ericwilligersde386342016-10-19 02:35:091290 for (auto& observer : observers_)
1291 observer.UserAgentOverrideSet(override);
[email protected]86ef6a392012-05-11 22:03:111292}
1293
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411294const std::string& WebContentsImpl::GetUserAgentOverride() {
[email protected]bf70edce2012-06-20 22:32:221295 return renderer_preferences_.user_agent_override;
[email protected]86ef6a392012-05-11 22:03:111296}
1297
Changwan Ryuc1134a82018-03-07 02:10:141298bool WebContentsImpl::ShouldOverrideUserAgentInNewTabs() {
1299 return should_override_user_agent_in_new_tabs_;
1300}
1301
dmazzonidd3d51a72016-12-14 18:41:011302void WebContentsImpl::EnableWebContentsOnlyAccessibilityMode() {
Dominic Mazzonid9fda172019-03-07 17:12:071303 // If accessibility is already enabled, we'll need to force a reset
1304 // in order to ensure new observers of accessibility events get the
1305 // full accessibility tree from scratch.
1306 bool need_reset = GetAccessibilityMode().has_mode(ui::AXMode::kWebContents);
1307
1308 ui::AXMode desired_mode =
1309 GetContentClient()->browser()->GetAXModeForBrowserContext(
1310 GetBrowserContext());
1311 desired_mode |= ui::kAXModeWebContentsOnly;
1312 AddAccessibilityMode(desired_mode);
1313
1314 if (need_reset) {
dchengafb53e22016-02-04 08:11:081315 for (RenderFrameHost* rfh : GetAllFrames())
1316 ResetAccessibility(rfh);
dchengafb53e22016-02-04 08:11:081317 }
[email protected]95640212014-07-26 18:14:301318}
1319
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411320bool WebContentsImpl::IsWebContentsOnlyAccessibilityModeForTesting() {
Doug Turner63f3c7b2017-07-29 05:10:011321 return accessibility_mode_ == ui::kAXModeWebContentsOnly;
[email protected]95640212014-07-26 18:14:301322}
1323
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411324bool WebContentsImpl::IsFullAccessibilityModeForTesting() {
Doug Turner63f3c7b2017-07-29 05:10:011325 return accessibility_mode_ == ui::kAXModeComplete;
[email protected]95640212014-07-26 18:14:301326}
1327
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411328const PageImportanceSignals& WebContentsImpl::GetPageImportanceSignals() {
kouhei40f03cb2015-09-24 07:47:011329 return page_importance_signals_;
1330}
1331
Becca Hughes6daf5662018-06-27 16:50:541332#if defined(OS_ANDROID)
1333
1334void WebContentsImpl::SetDisplayCutoutSafeArea(gfx::Insets insets) {
Becca Hughes86334622018-07-09 21:29:381335 if (display_cutout_host_impl_)
1336 display_cutout_host_impl_->SetDisplayCutoutSafeArea(insets);
Becca Hughes6daf5662018-06-27 16:50:541337}
1338
1339#endif
1340
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411341const base::string16& WebContentsImpl::GetTitle() {
[email protected]4c6092c5b2009-06-06 00:23:551342 // Transient entries take precedence. They are used for interstitial pages
1343 // that are shown on top of existing pages.
[email protected]10f417c52011-12-28 21:04:231344 NavigationEntry* entry = controller_.GetTransientEntry();
[email protected]45d0ef7f2011-01-05 13:46:231345 if (entry) {
jshin1fb76462016-04-05 22:13:031346 return entry->GetTitleForDisplay();
[email protected]45d0ef7f2011-01-05 13:46:231347 }
carlosk35f35af2015-12-01 10:55:401348
Nasko Oskov2f7d2112019-10-29 03:26:571349 WebUI* our_web_ui =
1350 GetRenderManager()->speculative_frame_host()
1351 ? GetRenderManager()->speculative_frame_host()->web_ui()
1352 : GetRenderManager()->current_frame_host()->web_ui();
[email protected]7ade2732011-02-10 00:13:581353 if (our_web_ui) {
[email protected]96d185d2009-04-24 03:28:541354 // Don't override the title in view source mode.
[email protected]59167c22013-06-03 18:07:321355 entry = controller_.GetVisibleEntry();
[email protected]96d185d2009-04-24 03:28:541356 if (!(entry && entry->IsViewSourceMode())) {
[email protected]e0112912011-02-02 22:54:351357 // Give the Web UI the chance to override our title.
[email protected]fcf75d42013-12-03 20:11:261358 const base::string16& title = our_web_ui->GetOverriddenTitle();
[email protected]96d185d2009-04-24 03:28:541359 if (!title.empty())
1360 return title;
1361 }
1362 }
1363
1364 // We use the title for the last committed entry rather than a pending
1365 // navigation entry. For example, when the user types in a URL, we want to
1366 // keep the old page's title until the new load has committed and we get a new
1367 // title.
[email protected]96d185d2009-04-24 03:28:541368 entry = controller_.GetLastCommittedEntry();
[email protected]59167c22013-06-03 18:07:321369
creis072b61f2015-09-28 20:52:241370 // We make an exception for initial navigations. We only want to use the title
1371 // from the visible entry if:
1372 // 1. The pending entry has been explicitly assigned a title to display.
1373 // 2. The user is doing a history navigation in a new tab (e.g., Ctrl+Back),
1374 // which case there is a pending entry index other than -1.
1375 //
1376 // Otherwise, we want to stick with the last committed entry's title during
1377 // new navigations, which have pending entries at index -1 with no title.
1378 if (controller_.IsInitialNavigation() &&
1379 ((controller_.GetVisibleEntry() &&
1380 !controller_.GetVisibleEntry()->GetTitle().empty()) ||
1381 controller_.GetPendingEntryIndex() != -1)) {
1382 entry = controller_.GetVisibleEntry();
[email protected]9eeafc012013-11-25 23:49:471383 }
[email protected]59167c22013-06-03 18:07:321384
[email protected]45d0ef7f2011-01-05 13:46:231385 if (entry) {
jshin1fb76462016-04-05 22:13:031386 return entry->GetTitleForDisplay();
[email protected]45d0ef7f2011-01-05 13:46:231387 }
[email protected]987fc3a2011-05-26 14:18:091388
1389 // |page_title_when_no_navigation_entry_| is finally used
1390 // if no title cannot be retrieved.
1391 return page_title_when_no_navigation_entry_;
[email protected]96d185d2009-04-24 03:28:541392}
1393
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411394SiteInstanceImpl* WebContentsImpl::GetSiteInstance() {
[email protected]fa944cb82013-11-15 17:51:211395 return GetRenderManager()->current_host()->GetSiteInstance();
[email protected]96d185d2009-04-24 03:28:541396}
1397
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411398bool WebContentsImpl::IsLoading() {
clamy44e84ce2016-02-22 15:38:251399 return frame_tree_.IsLoading() &&
creisadca9862017-06-16 19:12:111400 !(ShowingInterstitialPage() && interstitial_page_->pause_throbber());
[email protected]3c9e1872010-11-18 16:17:491401}
1402
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411403double WebContentsImpl::GetLoadProgress() {
Peter Boström18a40fa2018-10-31 19:03:501404 return frame_tree_.load_progress();
1405}
1406
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411407bool WebContentsImpl::IsLoadingToDifferentDocument() {
clamy44e84ce2016-02-22 15:38:251408 return IsLoading() && is_load_to_different_document_;
[email protected]6dfed692014-05-22 04:18:031409}
1410
Alexander Timindd0fa0c52019-11-06 13:03:371411bool WebContentsImpl::IsDocumentOnLoadCompletedInMainFrame() {
1412 return GetRenderViewHost()->IsDocumentOnLoadCompletedInMainFrame();
1413}
1414
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411415bool WebContentsImpl::IsWaitingForResponse() {
Peter Boströma9a27f6e2018-11-21 13:12:191416 NavigationRequest* ongoing_navigation_request =
1417 frame_tree_.root()->navigation_request();
1418
1419 // An ongoing navigation request means we're waiting for a response.
1420 return ongoing_navigation_request != nullptr;
[email protected]be1f56ab2011-12-22 06:55:311421}
1422
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411423const net::LoadStateWithParam& WebContentsImpl::GetLoadState() {
[email protected]be1f56ab2011-12-22 06:55:311424 return load_state_;
1425}
1426
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411427const base::string16& WebContentsImpl::GetLoadStateHost() {
[email protected]be1f56ab2011-12-22 06:55:311428 return load_state_host_;
1429}
1430
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411431uint64_t WebContentsImpl::GetUploadSize() {
[email protected]be1f56ab2011-12-22 06:55:311432 return upload_size_;
1433}
1434
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411435uint64_t WebContentsImpl::GetUploadPosition() {
[email protected]be1f56ab2011-12-22 06:55:311436 return upload_position_;
1437}
1438
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411439const std::string& WebContentsImpl::GetEncoding() {
Alexander Timine5f20e22019-10-09 23:22:351440 return GetMainFrame()->GetEncoding();
[email protected]be1f56ab2011-12-22 06:55:311441}
1442
Charles Zhaod72f99d2018-09-17 14:18:271443bool WebContentsImpl::WasDiscarded() {
1444 return GetFrameTree()->root()->was_discarded();
1445}
1446
Shubhie Panickerddf2a4e2018-03-06 00:09:061447void WebContentsImpl::SetWasDiscarded(bool was_discarded) {
1448 GetFrameTree()->root()->set_was_discarded();
1449}
1450
[email protected]222f5822014-02-05 23:40:491451void WebContentsImpl::IncrementCapturerCount(const gfx::Size& capture_size) {
[email protected]5a652232013-02-12 06:15:251452 DCHECK(!is_being_destroyed_);
Francois Doraye6161152018-03-27 22:05:371453 const bool was_captured = IsBeingCaptured();
[email protected]54597982013-02-06 01:59:551454 ++capturer_count_;
1455 DVLOG(1) << "There are now " << capturer_count_
1456 << " capturing(s) of WebContentsImpl@" << this;
[email protected]222f5822014-02-05 23:40:491457
1458 // Note: This provides a hint to upstream code to size the views optimally
1459 // for quality (e.g., to avoid scaling).
1460 if (!capture_size.IsEmpty() && preferred_size_for_capture_.IsEmpty()) {
1461 preferred_size_for_capture_ = capture_size;
1462 OnPreferredSizeChanged(preferred_size_);
1463 }
ccameron8807c38f2015-01-17 00:29:191464
Collin Baker989e0882019-11-01 01:27:171465 if (!was_captured)
1466 UpdateVisibilityAndNotifyPageAndView(GetVisibility());
[email protected]54597982013-02-06 01:59:551467}
1468
1469void WebContentsImpl::DecrementCapturerCount() {
1470 --capturer_count_;
1471 DVLOG(1) << "There are now " << capturer_count_
1472 << " capturing(s) of WebContentsImpl@" << this;
1473 DCHECK_LE(0, capturer_count_);
1474
[email protected]5a652232013-02-12 06:15:251475 if (is_being_destroyed_)
1476 return;
1477
Francois Doray24fc62c2017-12-11 17:27:331478 if (!IsBeingCaptured()) {
[email protected]222f5822014-02-05 23:40:491479 const gfx::Size old_size = preferred_size_for_capture_;
1480 preferred_size_for_capture_ = gfx::Size();
1481 OnPreferredSizeChanged(old_size);
Collin Baker989e0882019-11-01 01:27:171482 UpdateVisibilityAndNotifyPageAndView(GetVisibility());
[email protected]54597982013-02-06 01:59:551483 }
[email protected]be1f56ab2011-12-22 06:55:311484}
1485
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411486bool WebContentsImpl::IsBeingCaptured() {
Francois Doray24fc62c2017-12-11 17:27:331487 return capturer_count_ > 0;
[email protected]f2bd40812013-07-20 04:30:441488}
1489
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411490bool WebContentsImpl::IsAudioMuted() {
Max Morinb5506f72018-05-16 07:33:101491 if (base::FeatureList::IsEnabled(features::kAudioServiceAudioStreams)) {
1492 return audio_stream_factory_ && audio_stream_factory_->IsMuted();
1493 }
miu50f97892014-09-22 22:49:521494 return audio_muter_.get() && audio_muter_->is_muting();
1495}
1496
1497void WebContentsImpl::SetAudioMuted(bool mute) {
1498 DVLOG(1) << "SetAudioMuted(mute=" << mute << "), was " << IsAudioMuted()
1499 << " for WebContentsImpl@" << this;
1500
1501 if (mute == IsAudioMuted())
1502 return;
1503
Max Morinb5506f72018-05-16 07:33:101504 if (base::FeatureList::IsEnabled(features::kAudioServiceAudioStreams)) {
1505 GetAudioStreamFactory()->SetMuted(mute);
miu50f97892014-09-22 22:49:521506 } else {
Max Morinb5506f72018-05-16 07:33:101507 if (mute) {
1508 if (!audio_muter_)
1509 audio_muter_.reset(new WebContentsAudioMuter(this));
1510 audio_muter_->StartMuting();
1511 } else {
1512 DCHECK(audio_muter_);
1513 audio_muter_->StopMuting();
1514 }
miu50f97892014-09-22 22:49:521515 }
1516
ericwilligersde386342016-10-19 02:35:091517 for (auto& observer : observers_)
1518 observer.DidUpdateAudioMutingState(mute);
wjmaclean2f797c782016-01-07 14:52:031519
Jan Rucka442c83f2017-08-08 13:27:541520 // Notification for UI updates in response to the changed muting state.
Collin Bakeraf540cf2019-09-20 20:54:161521 NotifyNavigationStateChanged(INVALIDATE_TYPE_AUDIO);
Jan Rucka442c83f2017-08-08 13:27:541522}
1523
1524bool WebContentsImpl::IsCurrentlyAudible() {
Chris Hamiltondf0d72cd2018-05-29 16:23:531525 return is_currently_audible_;
miu50f97892014-09-22 22:49:521526}
1527
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411528bool WebContentsImpl::IsConnectedToBluetoothDevice() {
ortunodf4d7982016-04-08 02:33:351529 return bluetooth_connected_device_count_ > 0;
ortuno32e7db3c2016-03-29 16:14:201530}
1531
Lucas Furukawa Gadani4b4eed02019-06-04 23:12:041532bool WebContentsImpl::IsConnectedToSerialPort() {
Reilly Grant5e7c79b22019-04-09 17:26:201533 return serial_active_frame_count_ > 0;
1534}
1535
Matt Reynoldse8c6c1f2019-11-02 09:53:531536bool WebContentsImpl::IsConnectedToHidDevice() {
1537 return hid_active_frame_count_ > 0;
1538}
1539
Marijn Kruisselbrink29051042019-08-06 22:56:551540bool WebContentsImpl::HasNativeFileSystemHandles() {
1541 return native_file_system_handle_count_ > 0;
1542}
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:331543bool WebContentsImpl::HasNativeFileSystemDirectoryHandles() {
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:471544 return !native_file_system_directory_handles_.empty();
1545}
1546
1547std::vector<base::FilePath>
1548WebContentsImpl::GetNativeFileSystemDirectoryHandles() {
1549 std::vector<base::FilePath> result;
1550 result.reserve(native_file_system_directory_handles_.size());
1551 for (auto const& entry : native_file_system_directory_handles_)
1552 result.push_back(entry.first);
1553 return result;
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:331554}
1555
1556bool WebContentsImpl::HasWritableNativeFileSystemHandles() {
1557 return native_file_system_writable_handle_count_ > 0;
1558}
1559
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411560bool WebContentsImpl::HasPictureInPictureVideo() {
sawtellea7333a82018-05-31 02:36:361561 return has_picture_in_picture_video_;
1562}
1563
1564void WebContentsImpl::SetHasPictureInPictureVideo(
1565 bool has_picture_in_picture_video) {
1566 // If status of |this| is already accurate, there is no need to update.
1567 if (has_picture_in_picture_video == has_picture_in_picture_video_)
1568 return;
1569 has_picture_in_picture_video_ = has_picture_in_picture_video;
1570 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
François Beaufort058085d2018-08-30 15:29:141571 for (auto& observer : observers_)
1572 observer.MediaPictureInPictureChanged(has_picture_in_picture_video_);
sawtellea7333a82018-05-31 02:36:361573}
1574
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411575bool WebContentsImpl::IsCrashed() {
Dominic Mazzoni73a48322018-05-25 18:14:071576 switch (crashed_status_) {
1577 case base::TERMINATION_STATUS_PROCESS_CRASHED:
1578 case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
1579 case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
1580 case base::TERMINATION_STATUS_OOM:
1581 case base::TERMINATION_STATUS_LAUNCH_FAILED:
oshima620225722015-06-04 19:45:271582#if defined(OS_CHROMEOS)
Dominic Mazzoni73a48322018-05-25 18:14:071583 case base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM:
oshima620225722015-06-04 19:45:271584#endif
Dominic Mazzoni73a48322018-05-25 18:14:071585#if defined(OS_ANDROID)
1586 case base::TERMINATION_STATUS_OOM_PROTECTED:
1587#endif
Will Harris07925d12019-10-31 03:03:051588#if defined(OS_WIN)
1589 case base::TERMINATION_STATUS_INTEGRITY_FAILURE:
1590#endif
Dominic Mazzoni73a48322018-05-25 18:14:071591 return true;
1592 case base::TERMINATION_STATUS_NORMAL_TERMINATION:
1593 case base::TERMINATION_STATUS_STILL_RUNNING:
1594 return false;
1595 case base::TERMINATION_STATUS_MAX_ENUM:
1596 NOTREACHED();
1597 return false;
1598 }
1599
1600 NOTREACHED();
1601 return false;
[email protected]3c9e1872010-11-18 16:17:491602}
1603
[email protected]b172aee2012-04-10 17:05:261604void WebContentsImpl::SetIsCrashed(base::TerminationStatus status,
1605 int error_code) {
[email protected]443b80e2010-12-14 00:42:231606 if (status == crashed_status_)
[email protected]d5f942ba2008-09-26 19:30:341607 return;
1608
[email protected]443b80e2010-12-14 00:42:231609 crashed_status_ = status;
1610 crashed_error_code_ = error_code;
[email protected]8ff00d72012-10-23 19:12:211611 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
[email protected]d5f942ba2008-09-26 19:30:341612}
1613
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411614base::TerminationStatus WebContentsImpl::GetCrashedStatus() {
[email protected]be1f56ab2011-12-22 06:55:311615 return crashed_status_;
1616}
1617
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411618int WebContentsImpl::GetCrashedErrorCode() {
afakhry98241832016-03-11 19:27:471619 return crashed_error_code_;
1620}
1621
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411622bool WebContentsImpl::IsBeingDestroyed() {
[email protected]be1f56ab2011-12-22 06:55:311623 return is_being_destroyed_;
1624}
1625
[email protected]7f924832014-08-09 05:57:221626void WebContentsImpl::NotifyNavigationStateChanged(
1627 InvalidateTypes changed_flags) {
dalecurtis88c240072015-12-09 02:11:181628 // Notify the media observer of potential audibility changes.
Collin Bakeraf540cf2019-09-20 20:54:161629 if (changed_flags & INVALIDATE_TYPE_AUDIO) {
mlamouri44e4ef42016-01-20 18:42:271630 media_web_contents_observer_->MaybeUpdateAudibleState();
dalecurtisbc6572e12014-09-12 19:22:301631 }
1632
[email protected]d5f942ba2008-09-26 19:30:341633 if (delegate_)
1634 delegate_->NavigationStateChanged(this, changed_flags);
wjmaclean1dabf3e32016-05-13 23:34:441635
1636 if (GetOuterWebContents())
1637 GetOuterWebContents()->NotifyNavigationStateChanged(changed_flags);
[email protected]d5f942ba2008-09-26 19:30:341638}
1639
W. James MacLean6f34b042019-07-12 19:25:301640RenderFrameHostImpl* WebContentsImpl::GetFocusedFrameFromFocusedDelegate() {
1641 FrameTreeNode* focused_node =
1642 GetFocusedWebContents()->frame_tree_.GetFocusedFrame();
1643 return focused_node ? focused_node->current_frame_host() : nullptr;
1644}
1645
David Black9cca3592019-11-06 23:02:221646void WebContentsImpl::OnVerticalScrollDirectionChanged(
1647 viz::VerticalScrollDirection scroll_direction) {
1648 for (auto& observer : observers_)
1649 observer.DidChangeVerticalScrollDirection(scroll_direction);
1650}
1651
Chris Hamiltondf0d72cd2018-05-29 16:23:531652void WebContentsImpl::OnAudioStateChanged() {
1653 // This notification can come from any embedded contents or from this
1654 // WebContents' stream monitor. Aggregate these signals to get the actual
1655 // state.
1656 bool is_currently_audible =
1657 audio_stream_monitor_.IsCurrentlyAudible() ||
1658 (browser_plugin_embedder_ &&
1659 browser_plugin_embedder_->AreAnyGuestsCurrentlyAudible());
1660 if (is_currently_audible == is_currently_audible_)
1661 return;
1662
1663 // Update internal state.
1664 is_currently_audible_ = is_currently_audible;
1665 was_ever_audible_ = was_ever_audible_ || is_currently_audible_;
1666
1667 SendPageMessage(
1668 new PageMsg_AudioStateChanged(MSG_ROUTING_NONE, is_currently_audible_));
altimind8bd26c2016-11-04 11:44:541669
altiminec87fd1f2016-11-17 20:22:491670 // Notification for UI updates in response to the changed audio state.
Collin Bakeraf540cf2019-09-20 20:54:161671 NotifyNavigationStateChanged(INVALIDATE_TYPE_AUDIO);
Jan Rucka442c83f2017-08-08 13:27:541672
Chris Hamiltondf0d72cd2018-05-29 16:23:531673 // Ensure that audio state changes propagate from innermost to outermost
1674 // WebContents.
1675 if (GetOuterWebContents())
1676 GetOuterWebContents()->OnAudioStateChanged();
Tommy Steimel18360512017-11-01 00:38:191677
Chris Hamiltoneb41198f2018-05-24 18:41:261678 for (auto& observer : observers_)
Chris Hamiltondf0d72cd2018-05-29 16:23:531679 observer.OnAudioStateChanged(is_currently_audible_);
altimind8bd26c2016-11-04 11:44:541680}
1681
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411682base::TimeTicks WebContentsImpl::GetLastActiveTime() {
[email protected]9a890452014-02-13 22:21:021683 return last_active_time_;
[email protected]3e324142012-06-25 18:26:331684}
1685
[email protected]9e2e4632012-07-27 16:38:411686void WebContentsImpl::WasShown() {
Collin Baker989e0882019-11-01 01:27:171687 UpdateVisibilityAndNotifyPageAndView(Visibility::VISIBLE);
[email protected]be1f56ab2011-12-22 06:55:311688}
1689
[email protected]b172aee2012-04-10 17:05:261690void WebContentsImpl::WasHidden() {
Collin Baker989e0882019-11-01 01:27:171691 UpdateVisibilityAndNotifyPageAndView(Visibility::HIDDEN);
[email protected]375fa1b2012-05-22 22:05:371692}
1693
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411694bool WebContentsImpl::HasRecentInteractiveInputEvent() {
Daniel Cheng90196c82018-04-25 21:49:141695 static constexpr base::TimeDelta kMaxInterval =
1696 base::TimeDelta::FromSeconds(5);
1697 base::TimeDelta delta =
1698 ui::EventTimeForNow() - last_interactive_input_event_time_;
1699 // Note: the expectation is that the caller is typically expecting an input
1700 // event, e.g. validating that a WebUI message that requires a gesture is
Daniel Chenge81030b32019-07-17 20:20:231701 // actually attached to a gesture.
Daniel Cheng90196c82018-04-25 21:49:141702 return delta <= kMaxInterval;
1703}
1704
Avi Drissman738ea192018-08-29 20:24:161705void WebContentsImpl::SetIgnoreInputEvents(bool ignore_input_events) {
1706 ignore_input_events_ = ignore_input_events;
1707}
1708
Bo Liu168c8642017-08-28 18:26:021709#if defined(OS_ANDROID)
Bo Liu16dd7b8322018-05-02 21:19:501710void WebContentsImpl::SetMainFrameImportance(
1711 ChildProcessImportance importance) {
1712 GetMainFrame()->GetRenderWidgetHost()->SetImportance(importance);
Bo Liu7c6779e92017-08-16 02:02:281713 if (ShowingInterstitialPage()) {
Bo Liu16dd7b8322018-05-02 21:19:501714 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
1715 ->GetRenderWidgetHost()
1716 ->SetImportance(importance);
Bo Liu7c6779e92017-08-16 02:02:281717 }
Bo Liu7c6779e92017-08-16 02:02:281718}
Bo Liu168c8642017-08-28 18:26:021719#endif
Bo Liu7c6779e92017-08-16 02:02:281720
ccameron8807c38f2015-01-17 00:29:191721void WebContentsImpl::WasOccluded() {
Collin Baker989e0882019-11-01 01:27:171722 UpdateVisibilityAndNotifyPageAndView(Visibility::OCCLUDED);
ccameron8807c38f2015-01-17 00:29:191723}
1724
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411725Visibility WebContentsImpl::GetVisibility() {
Francois Doraye6161152018-03-27 22:05:371726 return visibility_;
Francois Dorayfe4a1772018-02-17 04:17:091727}
1728
Alex Moshchuk6fcaca752018-07-14 02:13:591729// TODO(alexmos): rename to NeedToFireBeforeUnloadOrUnload().
[email protected]b172aee2012-04-10 17:05:261730bool WebContentsImpl::NeedToFireBeforeUnload() {
[email protected]be1f56ab2011-12-22 06:55:311731 // TODO(creis): Should we fire even for interstitial pages?
Alex Moshchuk6fcaca752018-07-14 02:13:591732 if (ShowingInterstitialPage())
1733 return false;
1734
1735 if (!WillNotifyDisconnection())
1736 return false;
1737
1738 // Don't fire if the main frame's RenderViewHost indicates that beforeunload
1739 // and unload have already executed (e.g., after receiving a ClosePage ACK)
1740 // or should be ignored.
1741 if (GetRenderViewHost()->SuddenTerminationAllowed())
1742 return false;
1743
Alex Moshchukc78dbc722019-10-31 20:00:501744 // Check whether any frame in the frame tree needs to run beforeunload or
1745 // unload handlers.
1746 for (FrameTreeNode* node : frame_tree_.Nodes()) {
1747 RenderFrameHostImpl* rfh = node->current_frame_host();
1748
1749 // No need to run beforeunload/unload if the RenderFrame isn't live.
1750 if (!rfh->IsRenderFrameLive())
1751 continue;
1752
1753 if (rfh->GetSuddenTerminationDisablerState(blink::kBeforeUnloadHandler |
1754 blink::kUnloadHandler)) {
1755 return true;
1756 }
Aditya Keerthi34f37e62019-03-08 15:54:531757 }
Alex Moshchuk6fcaca752018-07-14 02:13:591758
Alex Moshchukc78dbc722019-10-31 20:00:501759 return false;
[email protected]be1f56ab2011-12-22 06:55:311760}
1761
Chris Hamilton3b3e315d2018-09-19 13:16:211762void WebContentsImpl::DispatchBeforeUnload(bool auto_cancel) {
1763 auto before_unload_type =
1764 auto_cancel ? RenderFrameHostImpl::BeforeUnloadType::DISCARD
1765 : RenderFrameHostImpl::BeforeUnloadType::TAB_CLOSE;
1766 GetMainFrame()->DispatchBeforeUnload(before_unload_type, false);
[email protected]1c3f80bd2014-04-08 23:02:061767}
1768
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501769void WebContentsImpl::AttachInnerWebContents(
1770 std::unique_ptr<WebContents> inner_web_contents,
1771 RenderFrameHost* render_frame_host) {
1772 WebContentsImpl* inner_web_contents_impl =
1773 static_cast<WebContentsImpl*>(inner_web_contents.get());
1774 DCHECK(!inner_web_contents_impl->node_.outer_web_contents());
1775 auto* render_frame_host_impl =
1776 static_cast<RenderFrameHostImpl*>(render_frame_host);
1777 DCHECK_EQ(&frame_tree_,
1778 render_frame_host_impl->frame_tree_node()->frame_tree());
Lucas Furukawa Gadani105de1e812018-05-31 19:38:391779
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501780 RenderFrameHostManager* inner_render_manager =
1781 inner_web_contents_impl->GetRenderManager();
1782 RenderFrameHostImpl* inner_main_frame =
1783 inner_render_manager->current_frame_host();
1784 RenderViewHostImpl* inner_render_view_host =
1785 inner_render_manager->current_host();
1786 auto* outer_render_manager =
1787 render_frame_host_impl->frame_tree_node()->render_manager();
lfg91a79e12016-04-01 23:52:191788
Lucas Furukawa Gadani105de1e812018-05-31 19:38:391789 // When attaching a WebContents as an inner WebContents, we need to replace
1790 // the Webcontents' view with a WebContentsViewChildFrame.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501791 inner_web_contents_impl->view_.reset(new WebContentsViewChildFrame(
1792 inner_web_contents_impl,
1793 GetContentClient()->browser()->GetWebContentsViewDelegate(
1794 inner_web_contents_impl),
1795 &inner_web_contents_impl->render_view_host_delegate_view_));
Lucas Furukawa Gadani105de1e812018-05-31 19:38:391796
lfg91a79e12016-04-01 23:52:191797 // When the WebContents being initialized has an opener, the browser side
1798 // Render{View,Frame}Host must be initialized and the RenderWidgetHostView
1799 // created. This is needed because the usual initialization happens during
1800 // the first navigation, but when attaching a new window we don't navigate
1801 // before attaching. If the browser side is already initialized, the calls
1802 // below will just early return.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501803 inner_render_manager->InitRenderView(inner_render_view_host, nullptr);
1804 inner_main_frame->Init();
1805 if (!inner_render_manager->GetRenderWidgetHostView()) {
1806 inner_web_contents_impl->CreateRenderWidgetHostViewForRenderManager(
1807 inner_render_view_host);
1808 }
lfg91a79e12016-04-01 23:52:191809
lazyboy6ec48b2a2015-06-29 15:18:141810 // Create a link to our outer WebContents.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501811 node_.AttachInnerWebContents(std::move(inner_web_contents),
1812 render_frame_host_impl);
lazyboy6ec48b2a2015-06-29 15:18:141813
lazyboy6ec48b2a2015-06-29 15:18:141814 // Create a proxy in top-level RenderFrameHostManager, pointing to the
1815 // SiteInstance of the outer WebContents. The proxy will be used to send
1816 // postMessage to the inner WebContents.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501817 auto* proxy = inner_render_manager->CreateOuterDelegateProxy(
1818 render_frame_host_impl->GetSiteInstance());
lazyboy6ec48b2a2015-06-29 15:18:141819
Lucas Furukawa Gadani99125822019-01-03 15:41:491820 // When attaching a GuestView as an inner WebContents, there should already be
1821 // a live RenderFrame, which has to be swapped. When attaching a portal, there
1822 // will not be a live RenderFrame before creating the proxy.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501823 if (render_frame_host_impl->IsRenderFrameLive()) {
1824 inner_render_manager->SwapOuterDelegateFrame(render_frame_host_impl, proxy);
Lucas Furukawa Gadani99125822019-01-03 15:41:491825
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501826 inner_web_contents_impl->ReattachToOuterWebContentsFrame();
Lucas Furukawa Gadani99125822019-01-03 15:41:491827 }
ekaramadadd882292016-06-08 15:22:561828
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501829 if (frame_tree_.GetFocusedFrame() ==
1830 render_frame_host_impl->frame_tree_node()) {
1831 inner_web_contents_impl->SetFocusedFrame(
1832 inner_web_contents_impl->frame_tree_.root(),
1833 render_frame_host_impl->GetSiteInstance());
avallee7529b2a2017-04-26 11:37:511834 }
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501835 outer_render_manager->set_attach_complete();
lazyboy6ec48b2a2015-06-29 15:18:141836}
1837
Lucas Furukawa Gadani99125822019-01-03 15:41:491838std::unique_ptr<WebContents> WebContentsImpl::DetachFromOuterWebContents() {
1839 DCHECK(node_.outer_web_contents());
1840 if (RenderWidgetHostViewBase* view =
1841 static_cast<RenderWidgetHostViewBase*>(GetMainFrame()->GetView())) {
1842 view->Destroy();
1843 }
1844 GetRenderManager()->DeleteOuterDelegateProxy(
1845 node_.OuterContentsFrameTreeNode()
1846 ->current_frame_host()
1847 ->GetSiteInstance());
1848 view_.reset(CreateWebContentsView(
1849 this, GetContentClient()->browser()->GetWebContentsViewDelegate(this),
1850 &render_view_host_delegate_view_));
danakjfc5184932019-09-12 18:08:321851 view_->CreateView(nullptr);
Lucas Furukawa Gadani99125822019-01-03 15:41:491852 std::unique_ptr<WebContents> web_contents =
1853 node_.DisconnectFromOuterWebContents();
1854 DCHECK_EQ(web_contents.get(), this);
1855 node_.SetFocusedWebContents(this);
1856 CreateRenderWidgetHostViewForRenderManager(GetRenderViewHost());
1857 return web_contents;
1858}
1859
W. James MacLean2dc75ed42019-03-06 14:31:091860void WebContentsImpl::RecursivelyRegisterFrameSinkIds() {
1861 auto* view = static_cast<RenderWidgetHostViewBase*>(
1862 GetRenderManager()->GetRenderWidgetHostView());
1863 DCHECK(view);
1864 if (!view->IsRenderWidgetHostViewChildFrame())
1865 return;
1866 static_cast<RenderWidgetHostViewChildFrame*>(view)->RegisterFrameSinkId();
1867
1868 for (auto* inner_web_contents : node_.GetInnerWebContents()) {
1869 static_cast<WebContentsImpl*>(inner_web_contents)
1870 ->RecursivelyRegisterFrameSinkIds();
1871 }
1872}
1873
Lucas Furukawa Gadaniaed1fed2017-10-13 17:34:141874void WebContentsImpl::ReattachToOuterWebContentsFrame() {
1875 DCHECK(node_.outer_web_contents());
1876 auto* render_manager = GetRenderManager();
1877 auto* parent_frame =
1878 node_.OuterContentsFrameTreeNode()->current_frame_host()->GetParent();
1879 render_manager->SetRWHViewForInnerContents(
1880 render_manager->GetRenderWidgetHostView());
1881
W. James MacLean2dc75ed42019-03-06 14:31:091882 RecursivelyRegisterFrameSinkIds();
Lucas Furukawa Gadaniaed1fed2017-10-13 17:34:141883
1884 // Set up the the guest's AX tree to point back at the embedder's AX tree.
1885 GetMainFrame()->set_browser_plugin_embedder_ax_tree_id(
1886 parent_frame->GetAXTreeID());
1887 GetMainFrame()->UpdateAXTreeData();
1888}
1889
dalecurtis6c58ed02016-10-28 23:02:371890void WebContentsImpl::DidChangeVisibleSecurityState() {
Emily Starkc663b0242019-04-26 19:34:451891 if (delegate_)
dalecurtis6c58ed02016-10-28 23:02:371892 delegate_->VisibleSecurityStateChanged(this);
Emily Starkc663b0242019-04-26 19:34:451893 for (auto& observer : observers_)
1894 observer.DidChangeVisibleSecurityState();
dalecurtis6c58ed02016-10-28 23:02:371895}
1896
Ahmed Fakhryd70bf37b2018-04-04 17:07:241897void WebContentsImpl::NotifyPreferencesChanged() {
1898 std::set<RenderViewHost*> render_view_host_set;
1899 for (FrameTreeNode* node : frame_tree_.Nodes()) {
Giovanni Ortuño Urquidi17a5d7c2018-04-30 06:48:531900 render_view_host_set.insert(
1901 node->current_frame_host()->GetRenderViewHost());
Ahmed Fakhryd70bf37b2018-04-04 17:07:241902 }
Giovanni Ortuño Urquidi17a5d7c2018-04-30 06:48:531903
Ahmed Fakhryd70bf37b2018-04-04 17:07:241904 for (RenderViewHost* render_view_host : render_view_host_set)
1905 render_view_host->OnWebkitPreferencesChanged();
1906}
1907
Bruce Long1e3e1f542019-10-16 17:56:281908void WebContentsImpl::SyncRendererPrefs() {
1909 blink::mojom::RendererPreferences renderer_preferences =
1910 GetRendererPrefs(GetBrowserContext());
1911 RenderViewHostImpl::GetPlatformSpecificPrefs(&renderer_preferences);
1912 SendPageMessage(
1913 new PageMsg_SetRendererPrefs(MSG_ROUTING_NONE, renderer_preferences));
1914}
1915
Josh Karlindaba39322019-07-17 23:24:331916void WebContentsImpl::OnCookiesRead(const GURL& url,
1917 const GURL& first_party_url,
1918 const net::CookieList& cookie_list,
1919 bool blocked_by_policy) {
1920 for (auto& observer : observers_) {
1921 observer.OnCookiesRead(url, first_party_url, cookie_list,
1922 blocked_by_policy);
1923 }
1924}
1925
1926void WebContentsImpl::OnCookieChange(const GURL& url,
1927 const GURL& first_party_url,
1928 const net::CanonicalCookie& cookie,
1929 bool blocked_by_policy) {
1930 for (auto& observer : observers_) {
1931 observer.OnCookieChange(url, first_party_url, cookie, blocked_by_policy);
1932 }
1933}
1934
[email protected]b172aee2012-04-10 17:05:261935void WebContentsImpl::Stop() {
dcheng57e39e22016-01-21 00:25:381936 for (FrameTreeNode* node : frame_tree_.Nodes())
1937 node->StopLoading();
ericwilligersde386342016-10-19 02:35:091938 for (auto& observer : observers_)
1939 observer.NavigationStopped();
[email protected]0bfbf882011-12-22 18:19:271940}
1941
Francois Doray47f759d2018-06-11 18:13:511942void WebContentsImpl::SetPageFrozen(bool frozen) {
1943 // A visible page is never frozen.
1944 DCHECK_NE(Visibility::VISIBLE, GetVisibility());
1945
1946 SendPageMessage(new PageMsg_SetPageFrozen(MSG_ROUTING_NONE, frozen));
Fadi Meawada6573e02018-03-10 00:52:111947}
1948
erikchen6c7df7f7a2018-05-03 18:13:591949std::unique_ptr<WebContents> WebContentsImpl::Clone() {
[email protected]14392a52012-05-02 20:28:441950 // We use our current SiteInstance since the cloned entry will use it anyway.
alexmose201c7cd2015-06-10 17:14:211951 // We pass our own opener so that the cloned page can access it if it was set
[email protected]ed245db2012-12-18 08:00:451952 // before.
[email protected]54944cde2012-12-09 09:24:591953 CreateParams create_params(GetBrowserContext(), GetSiteInstance());
Ian Clelland5cbaaf82017-11-27 22:00:031954 FrameTreeNode* opener = frame_tree_.root()->opener();
1955 RenderFrameHostImpl* opener_rfh = nullptr;
1956 if (opener)
1957 opener_rfh = opener->current_frame_host();
erikchen6c7df7f7a2018-05-03 18:13:591958 std::unique_ptr<WebContentsImpl> tc =
erikchen50735fd2018-05-05 15:08:331959 CreateWithOpener(create_params, opener_rfh);
Lucas Furukawa Gadani5553a152019-01-08 18:55:571960 tc->GetController().CopyStateFrom(&controller_, true);
ericwilligersde386342016-10-19 02:35:091961 for (auto& observer : observers_)
erikchen6c7df7f7a2018-05-03 18:13:591962 observer.DidCloneToNewWebContents(this, tc.get());
[email protected]0bfbf882011-12-22 18:19:271963 return tc;
1964}
1965
[email protected]14392a52012-05-02 20:28:441966void WebContentsImpl::Observe(int type,
[email protected]8ff00d72012-10-23 19:12:211967 const NotificationSource& source,
1968 const NotificationDetails& details) {
[email protected]14392a52012-05-02 20:28:441969 switch (type) {
[email protected]8ff00d72012-10-23 19:12:211970 case NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: {
1971 RenderWidgetHost* host = Source<RenderWidgetHost>(source).ptr();
[email protected]0b431992014-06-24 00:08:031972 RenderWidgetHostView* view = host->GetView();
1973 if (view == GetFullscreenRenderWidgetHostView()) {
1974 // We cannot just call view_->RestoreFocus() here. On some platforms,
1975 // attempting to focus the currently-invisible WebContentsView will be
1976 // flat-out ignored. Therefore, this boolean is used to track whether
1977 // we will request focus after the fullscreen widget has been
1978 // destroyed.
1979 fullscreen_widget_had_focus_at_shutdown_ = (view && view->HasFocus());
1980 } else {
alexmosc2a8cec2016-05-23 22:19:531981 for (auto i = pending_widget_views_.begin();
[email protected]0b431992014-06-24 00:08:031982 i != pending_widget_views_.end(); ++i) {
1983 if (host->GetView() == i->second) {
1984 pending_widget_views_.erase(i);
1985 break;
1986 }
[email protected]bafe6cd2012-05-23 23:09:501987 }
1988 }
1989 break;
1990 }
[email protected]14392a52012-05-02 20:28:441991 default:
1992 NOTREACHED();
1993 }
1994}
1995
[email protected]ec6c05f2013-10-23 18:41:571996WebContents* WebContentsImpl::GetWebContents() {
1997 return this;
1998}
1999
[email protected]54944cde2012-12-09 09:24:592000void WebContentsImpl::Init(const WebContents::CreateParams& params) {
[email protected]fa944cb82013-11-15 17:51:212001 // This is set before initializing the render manager since
[email protected]b0936d22013-11-28 06:47:362002 // RenderFrameHostManager::Init calls back into us via its delegate to ask if
[email protected]fa944cb82013-11-15 17:51:212003 // it should be hidden.
Francois Doraye6161152018-03-27 22:05:372004 visibility_ =
2005 params.initially_hidden ? Visibility::HIDDEN : Visibility::VISIBLE;
[email protected]d6fa88f2013-10-18 16:00:432006
Sebastien Marchand28cf23182018-06-20 02:39:352007 if (!params.last_active_time.is_null())
2008 last_active_time_ = params.last_active_time;
2009
dcheng3ce04b62015-10-26 23:30:552010 // The routing ids must either all be set or all be unset.
avic2c29d782014-12-12 00:23:542011 DCHECK((params.routing_id == MSG_ROUTING_NONE &&
dcheng3ce04b62015-10-26 23:30:552012 params.main_frame_routing_id == MSG_ROUTING_NONE &&
2013 params.main_frame_widget_routing_id == MSG_ROUTING_NONE) ||
avic2c29d782014-12-12 00:23:542014 (params.routing_id != MSG_ROUTING_NONE &&
dcheng3ce04b62015-10-26 23:30:552015 params.main_frame_routing_id != MSG_ROUTING_NONE &&
2016 params.main_frame_widget_routing_id != MSG_ROUTING_NONE));
2017
2018 scoped_refptr<SiteInstance> site_instance = params.site_instance;
2019 if (!site_instance)
2020 site_instance = SiteInstance::Create(params.browser_context);
Lukasz Anforowicz3caa8372018-06-05 17:22:072021 if (params.desired_renderer_state == CreateParams::kNoRendererProcess) {
2022 static_cast<SiteInstanceImpl*>(site_instance.get())
2023 ->PreventAssociationWithSpareProcess();
2024 }
dcheng3ce04b62015-10-26 23:30:552025
2026 // A main RenderFrameHost always has a RenderWidgetHost, since it is always a
2027 // local root by definition.
2028 // TODO(avi): Once RenderViewHostImpl has-a RenderWidgetHostImpl, it will no
2029 // longer be necessary to eagerly grab a routing ID for the view.
2030 // https://crbug.com/545684
2031 int32_t view_routing_id = params.routing_id;
2032 int32_t main_frame_widget_routing_id = params.main_frame_widget_routing_id;
2033 if (main_frame_widget_routing_id == MSG_ROUTING_NONE) {
Albert J. Wongcb004632018-07-10 22:58:252034 view_routing_id = site_instance->GetProcess()->GetNextRoutingID();
2035 main_frame_widget_routing_id =
dcheng3ce04b62015-10-26 23:30:552036 site_instance->GetProcess()->GetNextRoutingID();
2037 }
2038
Albert J. Wongcb004632018-07-10 22:58:252039 DCHECK_NE(view_routing_id, main_frame_widget_routing_id);
2040
Dave Tapuska485aca92017-08-08 00:47:582041 GetRenderManager()->Init(
2042 site_instance.get(), view_routing_id, params.main_frame_routing_id,
2043 main_frame_widget_routing_id, params.renderer_initiated_creation);
lukasza464d8692016-02-22 19:26:322044
lukasza5140a412016-09-15 21:12:302045 // blink::FrameTree::setName always keeps |unique_name| empty in case of a
2046 // main frame - let's do the same thing here.
2047 std::string unique_name;
lukasza464d8692016-02-22 19:26:322048 frame_tree_.root()->SetFrameName(params.main_frame_name, unique_name);
[email protected]d1198fd2012-08-13 22:50:192049
[email protected]fc2b46b2014-05-03 16:33:452050 WebContentsViewDelegate* delegate =
2051 GetContentClient()->browser()->GetWebContentsViewDelegate(this);
2052
sky52a39e342016-12-17 17:23:222053 if (GuestMode::IsCrossProcessFrameGuest(this)) {
2054 view_.reset(new WebContentsViewChildFrame(
2055 this, delegate, &render_view_host_delegate_view_));
2056 } else {
2057 view_.reset(CreateWebContentsView(this, delegate,
2058 &render_view_host_delegate_view_));
Scott Violetc884c7fd2017-11-03 23:51:012059 if (browser_plugin_guest_) {
2060 view_ = std::make_unique<WebContentsViewGuest>(
2061 this, browser_plugin_guest_.get(), std::move(view_),
2062 &render_view_host_delegate_view_);
2063 }
[email protected]d1198fd2012-08-13 22:50:192064 }
[email protected]fc2b46b2014-05-03 16:33:452065 CHECK(render_view_host_delegate_view_);
[email protected]d1198fd2012-08-13 22:50:192066 CHECK(view_.get());
2067
danakjfc5184932019-09-12 18:08:322068 view_->CreateView(params.context);
[email protected]d1198fd2012-08-13 22:50:192069
brettw4b461082016-11-19 18:55:162070#if BUILDFLAG(ENABLE_PLUGINS)
tommyclieb25b2a2014-11-03 19:45:092071 plugin_content_origin_whitelist_.reset(
2072 new PluginContentOriginWhitelist(this));
2073#endif
2074
[email protected]d1198fd2012-08-13 22:50:192075 registrar_.Add(this,
[email protected]8ff00d72012-10-23 19:12:212076 NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
2077 NotificationService::AllBrowserContextsAndSources());
[email protected]f28ef9a32014-05-12 16:36:102078
leon.hane4db177a2017-02-07 14:19:162079 screen_orientation_provider_.reset(new ScreenOrientationProvider(this));
[email protected]01f83f92014-06-17 14:41:542080
mlamouriefdca9d2014-09-16 16:55:402081 manifest_manager_host_.reset(new ManifestManagerHost(this));
2082
mfomitchev2b8b066a2016-01-28 19:23:152083#if defined(OS_ANDROID)
Oksana Zhuravlova0b634332019-10-28 23:04:222084 DateTimeChooserAndroid::CreateForWebContents(this);
[email protected]583418cc2013-01-17 14:01:102085#endif
fsamuel7310a4262014-12-05 05:06:442086
2087 // BrowserPluginGuest::Init needs to be called after this WebContents has
2088 // a RenderWidgetHostViewGuest. That is, |view_->CreateView| above.
2089 if (browser_plugin_guest_)
2090 browser_plugin_guest_->Init();
nickf9acfbe2014-12-23 19:12:372091
2092 for (size_t i = 0; i < g_created_callbacks.Get().size(); i++)
2093 g_created_callbacks.Get().at(i).Run(this);
naskob21fe4872015-02-24 14:15:562094
2095 // If the WebContents creation was renderer-initiated, it means that the
2096 // corresponding RenderView and main RenderFrame have already been created.
2097 // Ensure observers are notified about this.
2098 if (params.renderer_initiated_creation) {
avi3627ecac2015-10-16 17:40:432099 GetRenderViewHost()->GetWidget()->set_renderer_initialized(true);
Alex Moshchuk27caae82017-09-11 23:11:182100 GetRenderViewHost()->DispatchRenderViewCreated();
naskob21fe4872015-02-24 14:15:562101 GetRenderManager()->current_frame_host()->SetRenderFrameCreated(true);
2102 }
naskof5940b9f2015-03-02 23:04:052103
lof84501da082016-05-23 21:22:542104 // Create the renderer process in advance if requested.
Lukasz Anforowicz3caa8372018-06-05 17:22:072105 if (params.desired_renderer_state ==
2106 CreateParams::kInitializeAndWarmupRendererProcess) {
lof84501da082016-05-23 21:22:542107 if (!GetRenderManager()->current_frame_host()->IsRenderFrameLive()) {
2108 GetRenderManager()->InitRenderView(GetRenderViewHost(), nullptr);
2109 }
2110 }
2111
naskof5940b9f2015-03-02 23:04:052112 // Ensure that observers are notified of the creation of this WebContents's
2113 // main RenderFrameHost. It must be done here for main frames, since the
2114 // NotifySwappedFromRenderManager expects view_ to already be created and that
2115 // happens after RenderFrameHostManager::Init.
2116 NotifySwappedFromRenderManager(
2117 nullptr, GetRenderManager()->current_frame_host(), true);
Albert J. Wonge76bf0b82019-09-27 07:47:062118
2119 // For WebContents that are never shown, do critical initialization here which
2120 // would normally only happen when the WebContents is shown.
2121 if (params.is_never_visible) {
2122 // This has just been created so there can only be one frame. Thus it is
2123 // safe to initialize the root.
2124 GetMainFrame()->Init();
2125 }
[email protected]d1198fd2012-08-13 22:50:192126}
2127
[email protected]7fff43e2013-05-21 20:21:102128void WebContentsImpl::OnWebContentsDestroyed(WebContentsImpl* web_contents) {
2129 RemoveDestructionObserver(web_contents);
2130
[email protected]ceee8cd2013-03-08 04:59:512131 // Clear a pending contents that has been closed before being shown.
alexmosc2a8cec2016-05-23 22:19:532132 for (auto iter = pending_contents_.begin(); iter != pending_contents_.end();
[email protected]ceee8cd2013-03-08 04:59:512133 ++iter) {
erikchenbee5c9622018-04-27 19:30:252134 if (iter->second.get() != web_contents)
[email protected]ceee8cd2013-03-08 04:59:512135 continue;
erikchenbee5c9622018-04-27 19:30:252136
2137 // Someone else has deleted the WebContents. That should never happen!
2138 // TODO(erikchen): Fix semantics here. https://crbug.com/832879.
2139 iter->second.release();
[email protected]ceee8cd2013-03-08 04:59:512140 pending_contents_.erase(iter);
[email protected]ceee8cd2013-03-08 04:59:512141 return;
2142 }
2143 NOTREACHED();
[email protected]14392a52012-05-02 20:28:442144}
2145
[email protected]7fff43e2013-05-21 20:21:102146void WebContentsImpl::AddDestructionObserver(WebContentsImpl* web_contents) {
Jan Wilken Dörrie73c901e2019-06-12 09:02:322147 if (!base::Contains(destruction_observers_, web_contents)) {
[email protected]7fff43e2013-05-21 20:21:102148 destruction_observers_[web_contents] =
Jeremy Roman04f27c372017-10-27 15:20:552149 std::make_unique<DestructionObserver>(this, web_contents);
[email protected]7fff43e2013-05-21 20:21:102150 }
2151}
2152
2153void WebContentsImpl::RemoveDestructionObserver(WebContentsImpl* web_contents) {
avia8cf81982016-08-12 20:28:462154 destruction_observers_.erase(web_contents);
[email protected]7fff43e2013-05-21 20:21:102155}
2156
[email protected]b172aee2012-04-10 17:05:262157void WebContentsImpl::AddObserver(WebContentsObserver* observer) {
[email protected]be1f56ab2011-12-22 06:55:312158 observers_.AddObserver(observer);
2159}
2160
[email protected]b172aee2012-04-10 17:05:262161void WebContentsImpl::RemoveObserver(WebContentsObserver* observer) {
[email protected]be1f56ab2011-12-22 06:55:312162 observers_.RemoveObserver(observer);
2163}
2164
[email protected]948481d2014-06-11 18:32:222165std::set<RenderWidgetHostView*>
2166WebContentsImpl::GetRenderWidgetHostViewsInTree() {
2167 std::set<RenderWidgetHostView*> set;
2168 if (ShowingInterstitialPage()) {
lfgf949e0e2017-05-10 22:18:112169 if (RenderWidgetHostView* rwhv = GetRenderWidgetHostView())
2170 set.insert(rwhv);
[email protected]948481d2014-06-11 18:32:222171 } else {
dchengafb53e22016-02-04 08:11:082172 for (RenderFrameHost* rfh : GetAllFrames()) {
lfgf949e0e2017-05-10 22:18:112173 if (RenderWidgetHostView* rwhv = static_cast<RenderFrameHostImpl*>(rfh)
2174 ->frame_tree_node()
2175 ->render_manager()
2176 ->GetRenderWidgetHostView()) {
2177 set.insert(rwhv);
2178 }
dchengafb53e22016-02-04 08:11:082179 }
[email protected]948481d2014-06-11 18:32:222180 }
[email protected]de3c5d82014-05-28 22:12:592181 return set;
2182}
2183
[email protected]b172aee2012-04-10 17:05:262184void WebContentsImpl::Activate() {
[email protected]d5f942ba2008-09-26 19:30:342185 if (delegate_)
2186 delegate_->ActivateContents(this);
2187}
2188
avi3e4b8512015-11-11 01:55:492189void WebContentsImpl::LostCapture(RenderWidgetHostImpl* render_widget_host) {
2190 if (!RenderViewHostImpl::From(render_widget_host))
2191 return;
2192
[email protected]63954792011-07-11 04:17:482193 if (delegate_)
2194 delegate_->LostCapture();
2195}
2196
Steven Holte38041342018-06-22 22:00:572197ukm::SourceId WebContentsImpl::GetUkmSourceIdForLastCommittedSource() const {
2198 return last_committed_source_id_;
2199}
2200
Yue Ru Sun979c4b162019-11-06 16:11:042201ukm::SourceId
2202WebContentsImpl::GetUkmSourceIdForLastCommittedSourceIncludingSameDocument()
2203 const {
2204 return last_committed_source_id_including_same_document_;
2205}
2206
Ahmed Fakhryfaa32d22018-10-05 15:56:162207void WebContentsImpl::SetTopControlsShownRatio(
2208 RenderWidgetHostImpl* render_widget_host,
2209 float ratio) {
2210 if (!delegate_)
2211 return;
2212
2213 RenderFrameHostImpl* rfh = GetMainFrame();
2214 if (!rfh || render_widget_host != rfh->GetRenderWidgetHost())
2215 return;
2216
2217 delegate_->SetTopControlsShownRatio(this, ratio);
Ahmed Fakhry58e6ef542018-09-04 18:05:382218}
2219
Ahmed Fakhry58e6ef542018-09-04 18:05:382220void WebContentsImpl::SetTopControlsGestureScrollInProgress(bool in_progress) {
2221 if (delegate_)
2222 delegate_->SetTopControlsGestureScrollInProgress(in_progress);
2223}
2224
lazyboy63f5b312015-11-23 20:19:522225void WebContentsImpl::RenderWidgetCreated(
2226 RenderWidgetHostImpl* render_widget_host) {
2227 created_widgets_.insert(render_widget_host);
2228}
2229
[email protected]b24b68a2012-09-24 21:57:262230void WebContentsImpl::RenderWidgetDeleted(
2231 RenderWidgetHostImpl* render_widget_host) {
lazyboy63f5b312015-11-23 20:19:522232 // Note that |is_being_destroyed_| can be true at this point as
2233 // ~WebContentsImpl() calls RFHM::ClearRFHsPendingShutdown(), which might lead
2234 // us here.
2235 created_widgets_.erase(render_widget_host);
[email protected]b24b68a2012-09-24 21:57:262236
lazyboy63f5b312015-11-23 20:19:522237 if (is_being_destroyed_)
2238 return;
[email protected]44470a22013-01-24 01:21:542239
2240 if (render_widget_host &&
alexmosc9e76ec2016-05-16 22:59:372241 render_widget_host->GetRoutingID() == fullscreen_widget_routing_id_ &&
2242 render_widget_host->GetProcess()->GetID() ==
2243 fullscreen_widget_process_id_) {
[email protected]4aebbca2013-09-17 22:26:492244 if (delegate_ && delegate_->EmbedsFullscreenWidget())
mlamouri7a78d6fd2015-01-17 13:23:532245 delegate_->ExitFullscreenModeForTab(this);
ericwilligersde386342016-10-19 02:35:092246 for (auto& observer : observers_)
2247 observer.DidDestroyFullscreenWidget();
alexmosc9e76ec2016-05-16 22:59:372248 fullscreen_widget_process_id_ = ChildProcessHost::kInvalidUniqueID;
[email protected]44470a22013-01-24 01:21:542249 fullscreen_widget_routing_id_ = MSG_ROUTING_NONE;
[email protected]0b431992014-06-24 00:08:032250 if (fullscreen_widget_had_focus_at_shutdown_)
2251 view_->RestoreFocus();
[email protected]44470a22013-01-24 01:21:542252 }
lfgbee1e0a2016-06-08 21:24:212253
lfg7d4caad2017-03-22 09:01:452254 if (render_widget_host == mouse_lock_widget_)
lfgff8dfc8d2016-10-21 17:42:322255 LostMouseLock(mouse_lock_widget_);
Joe Downing192998b22018-03-22 15:51:362256
Joe Downingc1a57efe2018-05-09 18:23:542257 CancelKeyboardLock(render_widget_host);
[email protected]b24b68a2012-09-24 21:57:262258}
2259
miu9e14e492014-10-25 02:39:042260void WebContentsImpl::RenderWidgetGotFocus(
2261 RenderWidgetHostImpl* render_widget_host) {
calamity7fe55ce2015-04-10 03:59:372262 // Notify the observers if an embedded fullscreen widget was focused.
2263 if (delegate_ && render_widget_host && delegate_->EmbedsFullscreenWidget() &&
2264 render_widget_host->GetView() == GetFullscreenRenderWidgetHostView()) {
Michael Thiessen896405db2017-07-20 17:52:322265 NotifyWebContentsFocused(render_widget_host);
calamity7fe55ce2015-04-10 03:59:372266 }
miu9e14e492014-10-25 02:39:042267}
2268
zijiehe3bee08e22017-05-17 04:14:462269void WebContentsImpl::RenderWidgetLostFocus(
2270 RenderWidgetHostImpl* render_widget_host) {
Michael Thiessen896405db2017-07-20 17:52:322271 // Notify the observers if an embedded fullscreen widget lost focus.
2272 if (delegate_ && render_widget_host && delegate_->EmbedsFullscreenWidget() &&
2273 render_widget_host->GetView() == GetFullscreenRenderWidgetHostView()) {
2274 NotifyWebContentsLostFocus(render_widget_host);
2275 }
zijiehe3bee08e22017-05-17 04:14:462276}
2277
estaded0a0c992015-01-21 14:12:062278void WebContentsImpl::RenderWidgetWasResized(
rouslan2f5993f2015-01-29 00:18:312279 RenderWidgetHostImpl* render_widget_host,
2280 bool width_changed) {
creisc014b402015-04-23 16:41:452281 RenderFrameHostImpl* rfh = GetMainFrame();
estadece344ec2015-01-23 00:12:292282 if (!rfh || render_widget_host != rfh->GetRenderWidgetHost())
estaded0a0c992015-01-21 14:12:062283 return;
estaded0a0c992015-01-21 14:12:062284
ericwilligersde386342016-10-19 02:35:092285 for (auto& observer : observers_)
2286 observer.MainFrameWasResized(width_changed);
estaded0a0c992015-01-21 14:12:062287}
2288
skyf65d9bb2017-03-24 02:26:392289KeyboardEventProcessingResult WebContentsImpl::PreHandleKeyboardEvent(
2290 const NativeWebKeyboardEvent& event) {
2291 return delegate_ ? delegate_->PreHandleKeyboardEvent(this, event)
2292 : KeyboardEventProcessingResult::NOT_HANDLED;
[email protected]63954792011-07-11 04:17:482293}
2294
Dave Tapuska344399e2019-09-09 15:18:262295bool WebContentsImpl::HandleMouseEvent(const blink::WebMouseEvent& event) {
2296 // Handle mouse button back/forward in the browser process after the render
2297 // process is done with the event. This ensures all renderer-initiated history
2298 // navigations can be treated consistently.
2299 if (event.GetType() == blink::WebInputEvent::Type::kMouseUp) {
2300 WebContentsImpl* outermost = GetOutermostWebContents();
2301 if (event.button == blink::WebPointerProperties::Button::kBack &&
2302 outermost->controller_.CanGoBack()) {
2303 outermost->controller_.GoBack();
2304 return true;
2305 } else if (event.button == blink::WebPointerProperties::Button::kForward &&
2306 outermost->controller_.CanGoForward()) {
2307 outermost->controller_.GoForward();
2308 return true;
2309 }
2310 }
2311 return false;
2312}
2313
Scott Violetd5caa872018-10-16 22:00:512314bool WebContentsImpl::HandleKeyboardEvent(const NativeWebKeyboardEvent& event) {
[email protected]0b094002014-08-20 18:28:102315 if (browser_plugin_embedder_ &&
2316 browser_plugin_embedder_->HandleKeyboardEvent(event)) {
Scott Violetd5caa872018-10-16 22:00:512317 return true;
[email protected]0b094002014-08-20 18:28:102318 }
Scott Violetd5caa872018-10-16 22:00:512319 return delegate_ && delegate_->HandleKeyboardEvent(this, event);
[email protected]63954792011-07-11 04:17:482320}
2321
[email protected]d92026ef2014-03-03 21:04:132322bool WebContentsImpl::HandleWheelEvent(
[email protected]180ef242013-11-07 06:50:462323 const blink::WebMouseWheelEvent& event) {
[email protected]bccc4472013-04-18 16:37:192324#if !defined(OS_MACOSX)
lanweia93644f2015-01-21 22:00:332325 // On platforms other than Mac, control+mousewheel may change zoom. On Mac,
2326 // this isn't done for two reasons:
[email protected]bccc4472013-04-18 16:37:192327 // -the OS already has a gesture to do this through pinch-zoom
2328 // -if a user starts an inertial scroll, let's go, and presses control
2329 // (i.e. control+tab) then the OS's buffered scroll events will come in
2330 // with control key set which isn't what the user wants
Blink Reformat1c4d759e2017-04-09 16:34:542331 if (delegate_ && event.wheel_ticks_y &&
Ehsan Karamad0f83cb112018-09-06 22:07:362332 event.event_action == blink::WebMouseWheelEvent::EventAction::kPageZoom) {
w.shackleton49bcd392016-01-06 17:38:222333 // Count only integer cumulative scrolls as zoom events; this handles
2334 // smooth scroll and regular scroll device behavior.
Blink Reformat1c4d759e2017-04-09 16:34:542335 zoom_scroll_remainder_ += event.wheel_ticks_y;
w.shackleton49bcd392016-01-06 17:38:222336 int whole_zoom_scroll_remainder_ = std::lround(zoom_scroll_remainder_);
2337 zoom_scroll_remainder_ -= whole_zoom_scroll_remainder_;
2338 if (whole_zoom_scroll_remainder_ != 0) {
2339 delegate_->ContentsZoomChange(whole_zoom_scroll_remainder_ > 0);
2340 }
[email protected]fb3f066e2013-02-12 19:12:522341 return true;
2342 }
[email protected]bccc4472013-04-18 16:37:192343#endif
[email protected]fb3f066e2013-02-12 19:12:522344 return false;
2345}
2346
[email protected]04bce562014-01-30 05:34:542347bool WebContentsImpl::PreHandleGestureEvent(
2348 const blink::WebGestureEvent& event) {
[email protected]28042d32014-02-03 14:10:032349 return delegate_ && delegate_->PreHandleGestureEvent(this, event);
[email protected]04bce562014-01-30 05:34:542350}
2351
kenrb2a565f82015-09-02 20:24:592352RenderWidgetHostInputEventRouter* WebContentsImpl::GetInputEventRouter() {
wjmacleane31234f2015-12-14 17:20:452353 if (!is_being_destroyed_ && GetOuterWebContents())
2354 return GetOuterWebContents()->GetInputEventRouter();
2355
2356 if (!rwh_input_event_router_.get() && !is_being_destroyed_)
kenrb2a565f82015-09-02 20:24:592357 rwh_input_event_router_.reset(new RenderWidgetHostInputEventRouter);
2358 return rwh_input_event_router_.get();
2359}
2360
alexmos3fcd0ca2015-10-23 18:18:332361void WebContentsImpl::ReplicatePageFocus(bool is_focused) {
2362 // Focus loss may occur while this WebContents is being destroyed. Don't
2363 // send the message in this case, as the main frame's RenderFrameHost and
2364 // other state has already been cleared.
2365 if (is_being_destroyed_)
2366 return;
2367
2368 frame_tree_.ReplicatePageFocus(is_focused);
2369}
2370
alexmosc4cbacb2015-11-21 01:29:222371RenderWidgetHostImpl* WebContentsImpl::GetFocusedRenderWidgetHost(
2372 RenderWidgetHostImpl* receiving_widget) {
alexmosc4cbacb2015-11-21 01:29:222373 // Events for widgets other than the main frame (e.g., popup menus) should be
2374 // forwarded directly to the widget they arrived on.
2375 if (receiving_widget != GetMainFrame()->GetRenderWidgetHost())
2376 return receiving_widget;
alexmosc4d183e2015-11-06 00:46:522377
lfg1453e412017-04-11 00:48:502378 WebContentsImpl* focused_contents = GetFocusedWebContents();
2379
2380 // If the focused WebContents is showing an interstitial, return the
2381 // interstitial's widget.
2382 if (focused_contents->ShowingInterstitialPage()) {
2383 return static_cast<RenderFrameHostImpl*>(
creisadca9862017-06-16 19:12:112384 focused_contents->interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:502385 ->GetRenderWidgetHost();
2386 }
2387
paulmeyerfeafc2d2017-04-25 21:46:402388 // If the focused WebContents is a guest WebContents, then get the focused
2389 // frame in the embedder WebContents instead.
2390 FrameTreeNode* focused_frame = nullptr;
2391 if (focused_contents->browser_plugin_guest_ &&
2392 !GuestMode::IsCrossProcessFrameGuest(focused_contents)) {
2393 focused_frame = frame_tree_.GetFocusedFrame();
2394 } else {
2395 focused_frame = GetFocusedWebContents()->frame_tree_.GetFocusedFrame();
2396 }
lfg1453e412017-04-11 00:48:502397
alexmosc4d183e2015-11-06 00:46:522398 if (!focused_frame)
alexmosc4cbacb2015-11-21 01:29:222399 return receiving_widget;
alexmosc4d183e2015-11-06 00:46:522400
alexmos732ca3a2015-12-08 02:01:022401 // The view may be null if a subframe's renderer process has crashed while
2402 // the subframe has focus. Drop the event in that case. Do not give
2403 // it to the main frame, so that the user doesn't unexpectedly type into the
2404 // wrong frame if a focused subframe renderer crashes while they type.
2405 RenderWidgetHostView* view = focused_frame->current_frame_host()->GetView();
2406 if (!view)
2407 return nullptr;
2408
2409 return RenderWidgetHostImpl::From(view->GetRenderWidgetHost());
alexmosc4d183e2015-11-06 00:46:522410}
2411
avallee9993fca2016-11-17 06:16:502412RenderWidgetHostImpl* WebContentsImpl::GetRenderWidgetHostWithPageFocus() {
lfg1453e412017-04-11 00:48:502413 WebContentsImpl* focused_web_contents = GetFocusedWebContents();
2414
2415 if (focused_web_contents->ShowingInterstitialPage()) {
2416 return static_cast<RenderFrameHostImpl*>(
creisadca9862017-06-16 19:12:112417 focused_web_contents->interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:502418 ->GetRenderWidgetHost();
2419 }
Alex Valléedc80ae2ed2017-09-06 21:55:442420 if (!GuestMode::IsCrossProcessFrameGuest(focused_web_contents) &&
2421 focused_web_contents->browser_plugin_guest_) {
2422 // If this is a guest, we need to be controlled by our embedder.
2423 return focused_web_contents->GetOuterWebContents()
2424 ->GetMainFrame()
2425 ->GetRenderWidgetHost();
2426 }
lfg1453e412017-04-11 00:48:502427
2428 return focused_web_contents->GetMainFrame()->GetRenderWidgetHost();
avallee9993fca2016-11-17 06:16:502429}
2430
Dave Tapuska3ed44192018-05-01 18:53:302431void WebContentsImpl::EnterFullscreenMode(
2432 const GURL& origin,
Dave Tapuskaa4189512019-10-15 20:27:342433 const blink::mojom::FullscreenOptions& options) {
mlamouri7a78d6fd2015-01-17 13:23:532434 // This method is being called to enter renderer-initiated fullscreen mode.
2435 // Make sure any existing fullscreen widget is shut down first.
[email protected]4aebbca2013-09-17 22:26:492436 RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
avi85a4cef2015-12-18 20:13:372437 if (widget_view) {
2438 RenderWidgetHostImpl::From(widget_view->GetRenderWidgetHost())
2439 ->ShutdownAndDestroyWidget(true);
2440 }
[email protected]4aebbca2013-09-17 22:26:492441
Joe Downing13dd76b2018-04-09 18:32:152442 if (delegate_) {
Dave Tapuska3ed44192018-05-01 18:53:302443 delegate_->EnterFullscreenModeForTab(this, origin, options);
mlamouri7a78d6fd2015-01-17 13:23:532444
Joe Downing13dd76b2018-04-09 18:32:152445 if (keyboard_lock_widget_)
2446 delegate_->RequestKeyboardLock(this, esc_key_locked_);
2447 }
2448
ericwilligersde386342016-10-19 02:35:092449 for (auto& observer : observers_)
2450 observer.DidToggleFullscreenModeForTab(IsFullscreenForCurrentTab(), false);
mlamouri7a78d6fd2015-01-17 13:23:532451}
2452
bokanece34a82016-01-28 19:49:462453void WebContentsImpl::ExitFullscreenMode(bool will_cause_resize) {
mlamouri7a78d6fd2015-01-17 13:23:532454 // This method is being called to leave renderer-initiated fullscreen mode.
2455 // Make sure any existing fullscreen widget is shut down first.
2456 RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
avi85a4cef2015-12-18 20:13:372457 if (widget_view) {
2458 RenderWidgetHostImpl::From(widget_view->GetRenderWidgetHost())
2459 ->ShutdownAndDestroyWidget(true);
2460 }
mlamouri7a78d6fd2015-01-17 13:23:532461
Joe Downing13dd76b2018-04-09 18:32:152462 if (delegate_) {
mlamouri7a78d6fd2015-01-17 13:23:532463 delegate_->ExitFullscreenModeForTab(this);
[email protected]657c8e02014-03-19 19:18:372464
Joe Downing13dd76b2018-04-09 18:32:152465 if (keyboard_lock_widget_)
2466 delegate_->CancelKeyboardLockRequest(this);
2467 }
2468
bokanece34a82016-01-28 19:49:462469 // The fullscreen state is communicated to the renderer through a resize
2470 // message. If the change in fullscreen state doesn't cause a view resize
2471 // then we must ensure web contents exit the fullscreen state by explicitly
2472 // sending a resize message. This is required for the situation of the browser
2473 // moving the view into a "browser fullscreen" state and then the contents
2474 // entering "tab fullscreen". Exiting the contents "tab fullscreen" then won't
2475 // have the side effect of the view resizing, hence the explicit call here is
2476 // required.
2477 if (!will_cause_resize) {
2478 if (RenderWidgetHostView* rwhv = GetRenderWidgetHostView()) {
2479 if (RenderWidgetHost* render_widget_host = rwhv->GetRenderWidgetHost())
Fady Samuel0b911822018-04-25 13:22:162480 render_widget_host->SynchronizeVisualProperties();
bokanece34a82016-01-28 19:49:462481 }
scheib3dcb6c932015-02-23 10:55:582482 }
2483
Arthur Sonzogni929d29f2018-09-17 14:19:442484 current_fullscreen_frame_ = nullptr;
Becca Hughese9e27952018-06-25 17:08:272485
ericwilligersde386342016-10-19 02:35:092486 for (auto& observer : observers_) {
2487 observer.DidToggleFullscreenModeForTab(IsFullscreenForCurrentTab(),
2488 will_cause_resize);
2489 }
Becca Hughesd11d6502018-07-31 17:01:282490
2491 if (display_cutout_host_impl_)
2492 display_cutout_host_impl_->DidExitFullscreen();
[email protected]8a5e0ca2011-08-25 06:30:472493}
2494
Becca Hughesfd5d8f892018-06-14 18:23:362495void WebContentsImpl::FullscreenStateChanged(RenderFrameHost* rfh,
2496 bool is_fullscreen) {
Arthur Sonzogni929d29f2018-09-17 14:19:442497 RenderFrameHostImpl* frame = static_cast<RenderFrameHostImpl*>(rfh);
Becca Hughesfd5d8f892018-06-14 18:23:362498
2499 if (is_fullscreen) {
Jan Wilken Dörrie531be7ca2019-06-07 10:05:572500 if (!base::Contains(fullscreen_frames_, frame)) {
Arthur Sonzogni929d29f2018-09-17 14:19:442501 fullscreen_frames_.insert(frame);
2502 FullscreenFrameSetUpdated();
Becca Hughesfd5d8f892018-06-14 18:23:362503 }
Arthur Sonzogni929d29f2018-09-17 14:19:442504 return;
2505 }
Becca Hughesfd5d8f892018-06-14 18:23:362506
Arthur Sonzogni929d29f2018-09-17 14:19:442507 // If |frame| is no longer in fullscreen, remove it and any descendants.
2508 // See https://fullscreen.spec.whatwg.org.
Arthur Sonzogni969a794e2018-10-11 08:56:092509 size_t size_before_deletion = fullscreen_frames_.size();
2510 base::EraseIf(fullscreen_frames_, [&](RenderFrameHostImpl* current) {
2511 return (current == frame || current->IsDescendantOf(frame));
Arthur Sonzogni929d29f2018-09-17 14:19:442512 });
2513
Arthur Sonzogni969a794e2018-10-11 08:56:092514 if (size_before_deletion != fullscreen_frames_.size())
Arthur Sonzogni929d29f2018-09-17 14:19:442515 FullscreenFrameSetUpdated();
2516}
2517
2518void WebContentsImpl::FullscreenFrameSetUpdated() {
2519 if (fullscreen_frames_.empty()) {
2520 current_fullscreen_frame_ = nullptr;
2521 return;
Becca Hughesfd5d8f892018-06-14 18:23:362522 }
2523
Arthur Sonzogni929d29f2018-09-17 14:19:442524 // Find the current fullscreen frame and call the observers.
2525 // If frame A is fullscreen, then frame B goes into inner fullscreen, then B
2526 // exits fullscreen - that will result in A being fullscreen.
2527 RenderFrameHostImpl* new_fullscreen_frame = *std::max_element(
2528 fullscreen_frames_.begin(), fullscreen_frames_.end(), FrameCompareDepth);
Becca Hughesfd5d8f892018-06-14 18:23:362529
Arthur Sonzogni929d29f2018-09-17 14:19:442530 // If we have already notified observers about this frame then we should not
2531 // fire the observers again.
2532 if (new_fullscreen_frame == current_fullscreen_frame_)
2533 return;
2534 current_fullscreen_frame_ = new_fullscreen_frame;
Becca Hughesfd5d8f892018-06-14 18:23:362535
Arthur Sonzogni929d29f2018-09-17 14:19:442536 for (auto& observer : observers_)
2537 observer.DidAcquireFullscreen(new_fullscreen_frame);
Becca Hughesfd5d8f892018-06-14 18:23:362538
Arthur Sonzogni929d29f2018-09-17 14:19:442539 if (display_cutout_host_impl_)
2540 display_cutout_host_impl_->DidAcquireFullscreen(new_fullscreen_frame);
Becca Hughesfd5d8f892018-06-14 18:23:362541}
2542
Collin Baker989e0882019-11-01 01:27:172543void WebContentsImpl::UpdateVisibilityAndNotifyPageAndView(
2544 Visibility new_visibility) {
2545 if (new_visibility == Visibility::VISIBLE)
2546 controller_.SetActive(true);
2547
2548 // Only hide the page if there are no entities capturing screenshots
2549 // or video (e.g. mirroring).
2550 const bool page_is_visible =
2551 new_visibility == Visibility::VISIBLE || IsBeingCaptured();
2552 // If there are entities in Picture-in-Picture mode, don't activate
2553 // the "disable rendering" optimization.
2554 const bool view_is_visible = page_is_visible || HasPictureInPictureVideo();
2555
2556 // This shows the Page before showing the individual RenderWidgets, as
2557 // RenderWidgets will work to produce compositor frames and handle input
2558 // as soon as they are shown. But the Page and other classes do not expect to
2559 // be producing frames when the Page is hidden. So we make sure the Page is
2560 // shown first.
Collin Baker98457b52019-11-06 21:34:292561 if (page_is_visible) {
2562 SendPageMessage(new PageMsg_VisibilityChanged(
2563 MSG_ROUTING_NONE, PageVisibilityState::kVisible));
2564 }
Collin Baker989e0882019-11-01 01:27:172565
2566 // |GetRenderWidgetHostView()| can be null if the user middle clicks a link to
2567 // open a tab in the background, then closes the tab before selecting it.
2568 // This is because closing the tab calls WebContentsImpl::Destroy(), which
2569 // removes the |GetRenderViewHost()|; then when we actually destroy the
2570 // window, OnWindowPosChanged() notices and calls WasHidden() (which
2571 // calls us).
2572 if (auto* view = GetRenderWidgetHostView()) {
2573 if (view_is_visible) {
2574 view->Show();
2575#if defined(OS_MACOSX)
2576 view->SetActive(true);
2577#endif
2578 } else if (new_visibility == Visibility::HIDDEN) {
2579 view->Hide();
2580 } else {
2581 view->WasOccluded();
2582 }
2583 }
2584
2585 if (!ShowingInterstitialPage())
2586 SetVisibilityForChildViews(view_is_visible);
2587
2588 // Make sure to call SetVisibilityAndNotifyObservers(VISIBLE) before notifying
2589 // the CrossProcessFrameConnector.
2590 if (new_visibility == Visibility::VISIBLE) {
2591 last_active_time_ = base::TimeTicks::Now();
2592 SetVisibilityAndNotifyObservers(new_visibility);
2593 }
2594
2595 if (!page_is_visible) {
2596 // Similar to when showing the page, we only hide the page after
2597 // hiding the individual RenderWidgets.
Collin Baker98457b52019-11-06 21:34:292598 SendPageMessage(new PageMsg_VisibilityChanged(
2599 MSG_ROUTING_NONE, PageVisibilityState::kHidden));
Collin Baker989e0882019-11-01 01:27:172600 } else {
2601 for (FrameTreeNode* node : frame_tree_.Nodes()) {
2602 RenderFrameProxyHost* parent = node->render_manager()->GetProxyToParent();
2603 if (!parent)
2604 continue;
2605
2606 parent->cross_process_frame_connector()->DelegateWasShown();
2607 }
2608 }
2609
2610 if (new_visibility != Visibility::VISIBLE)
2611 SetVisibilityAndNotifyObservers(new_visibility);
2612}
2613
Clark DuValla0e42992018-09-17 17:00:112614#if defined(OS_ANDROID)
2615void WebContentsImpl::UpdateUserGestureCarryoverInfo() {
2616 if (delegate_)
2617 delegate_->UpdateUserGestureCarryoverInfo(this);
2618}
2619#endif
2620
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:412621bool WebContentsImpl::IsFullscreenForCurrentTab() {
[email protected]199bba6e2012-04-04 16:19:382622 return delegate_ ? delegate_->IsFullscreenForTabOrPending(this) : false;
[email protected]5d5f7af2011-10-01 01:38:122623}
2624
Malay Keshav87c42c02019-01-15 08:37:472625bool WebContentsImpl::ShouldShowStaleContentOnEviction() {
2626 return GetDelegate() && GetDelegate()->ShouldShowStaleContentOnEviction(this);
2627}
2628
billorr21c005d2016-11-17 03:57:042629bool WebContentsImpl::IsFullscreen() {
2630 return IsFullscreenForCurrentTab();
2631}
2632
Eric Willigers052f0432019-10-04 04:06:572633blink::mojom::DisplayMode WebContentsImpl::GetDisplayMode(
avibf58fa0c2015-11-11 01:45:522634 RenderWidgetHostImpl* render_widget_host) const {
2635 if (!RenderViewHostImpl::From(render_widget_host))
Eric Willigers052f0432019-10-04 04:06:572636 return blink::mojom::DisplayMode::kBrowser;
avibf58fa0c2015-11-11 01:45:522637
mikhail.pozdnyakovc0e251b2015-04-15 06:51:122638 return delegate_ ? delegate_->GetDisplayMode(this)
Eric Willigers052f0432019-10-04 04:06:572639 : blink::mojom::DisplayMode::kBrowser;
mikhail.pozdnyakovc0e251b2015-04-15 06:51:122640}
2641
avic3aa8422015-11-09 20:57:222642void WebContentsImpl::RequestToLockMouse(
2643 RenderWidgetHostImpl* render_widget_host,
2644 bool user_gesture,
lfgad8244352016-07-13 16:55:512645 bool last_unlocked_by_target,
2646 bool privileged) {
lfgf0cd46e2017-01-04 00:05:232647 for (WebContentsImpl* current = this; current;
2648 current = current->GetOuterWebContents()) {
2649 if (current->mouse_lock_widget_) {
2650 render_widget_host->GotResponseToLockMouseRequest(false);
2651 return;
2652 }
[email protected]e9621112011-10-17 05:38:372653 }
avic3aa8422015-11-09 20:57:222654
lfgad8244352016-07-13 16:55:512655 if (privileged) {
lfgf0cd46e2017-01-04 00:05:232656 DCHECK(!GetOuterWebContents());
lfgad8244352016-07-13 16:55:512657 mouse_lock_widget_ = render_widget_host;
2658 render_widget_host->GotResponseToLockMouseRequest(true);
2659 return;
2660 }
2661
lfgbee1e0a2016-06-08 21:24:212662 bool widget_in_frame_tree = false;
2663 for (FrameTreeNode* node : frame_tree_.Nodes()) {
2664 if (node->current_frame_host()->GetRenderWidgetHost() ==
2665 render_widget_host) {
2666 widget_in_frame_tree = true;
2667 break;
2668 }
2669 }
2670
2671 if (widget_in_frame_tree && delegate_) {
lfgf0cd46e2017-01-04 00:05:232672 for (WebContentsImpl* current = this; current;
2673 current = current->GetOuterWebContents()) {
2674 current->mouse_lock_widget_ = render_widget_host;
2675 }
2676
avic3aa8422015-11-09 20:57:222677 delegate_->RequestToLockMouse(this, user_gesture, last_unlocked_by_target);
lfgbee1e0a2016-06-08 21:24:212678 } else {
2679 render_widget_host->GotResponseToLockMouseRequest(false);
2680 }
[email protected]e9621112011-10-17 05:38:372681}
2682
avi3e4b8512015-11-11 01:55:492683void WebContentsImpl::LostMouseLock(RenderWidgetHostImpl* render_widget_host) {
lfgbee1e0a2016-06-08 21:24:212684 CHECK(mouse_lock_widget_);
lfgf0cd46e2017-01-04 00:05:232685
2686 if (mouse_lock_widget_->delegate()->GetAsWebContents() != this)
2687 return mouse_lock_widget_->delegate()->LostMouseLock(render_widget_host);
2688
lfgbee1e0a2016-06-08 21:24:212689 mouse_lock_widget_->SendMouseLockLost();
lfgf0cd46e2017-01-04 00:05:232690 for (WebContentsImpl* current = this; current;
2691 current = current->GetOuterWebContents()) {
2692 current->mouse_lock_widget_ = nullptr;
2693 }
avi3e4b8512015-11-11 01:55:492694
[email protected]e9621112011-10-17 05:38:372695 if (delegate_)
2696 delegate_->LostMouseLock();
2697}
2698
lfgad8244352016-07-13 16:55:512699bool WebContentsImpl::HasMouseLock(RenderWidgetHostImpl* render_widget_host) {
2700 // To verify if the mouse is locked, the mouse_lock_widget_ needs to be
2701 // assigned to the widget that requested the mouse lock, and the top-level
2702 // platform RenderWidgetHostView needs to hold the mouse lock from the OS.
Lucas Gadania0ea0172018-09-20 18:31:372703 auto* widget_host = GetTopLevelRenderWidgetHostView();
2704 return mouse_lock_widget_ == render_widget_host && widget_host &&
2705 widget_host->IsMouseLocked();
lfgad8244352016-07-13 16:55:512706}
2707
lfg84763c92017-02-16 18:55:152708RenderWidgetHostImpl* WebContentsImpl::GetMouseLockWidget() {
Lucas Gadania0ea0172018-09-20 18:31:372709 auto* widget_host = GetTopLevelRenderWidgetHostView();
2710 if ((widget_host && widget_host->IsMouseLocked()) ||
lfge2176fb2017-03-26 00:45:472711 (GetFullscreenRenderWidgetHostView() &&
Lucas Gadania0ea0172018-09-20 18:31:372712 GetFullscreenRenderWidgetHostView()->IsMouseLocked())) {
lfg84763c92017-02-16 18:55:152713 return mouse_lock_widget_;
Lucas Gadania0ea0172018-09-20 18:31:372714 }
lfg84763c92017-02-16 18:55:152715
2716 return nullptr;
2717}
2718
Joe Downing192998b22018-03-22 15:51:362719bool WebContentsImpl::RequestKeyboardLock(
Joe Downing13dd76b2018-04-09 18:32:152720 RenderWidgetHostImpl* render_widget_host,
2721 bool esc_key_locked) {
Joe Downing192998b22018-03-22 15:51:362722 DCHECK(render_widget_host);
Joe Downing192998b22018-03-22 15:51:362723 if (render_widget_host->delegate()->GetAsWebContents() != this) {
2724 NOTREACHED();
2725 return false;
2726 }
2727
2728 // KeyboardLock is only supported when called by the top-level browsing
2729 // context and is not supported in embedded content scenarios.
2730 if (GetOuterWebContents())
2731 return false;
2732
Joe Downing13dd76b2018-04-09 18:32:152733 esc_key_locked_ = esc_key_locked;
Joe Downing192998b22018-03-22 15:51:362734 keyboard_lock_widget_ = render_widget_host;
2735
Joe Downing13dd76b2018-04-09 18:32:152736 if (delegate_)
2737 delegate_->RequestKeyboardLock(this, esc_key_locked_);
Joe Downing192998b22018-03-22 15:51:362738 return true;
2739}
2740
2741void WebContentsImpl::CancelKeyboardLock(
2742 RenderWidgetHostImpl* render_widget_host) {
2743 if (!keyboard_lock_widget_ || render_widget_host != keyboard_lock_widget_)
2744 return;
2745
2746 RenderWidgetHostImpl* old_keyboard_lock_widget = keyboard_lock_widget_;
2747 keyboard_lock_widget_ = nullptr;
2748
Joe Downing13dd76b2018-04-09 18:32:152749 if (delegate_)
2750 delegate_->CancelKeyboardLockRequest(this);
2751
Joe Downing192998b22018-03-22 15:51:362752 old_keyboard_lock_widget->CancelKeyboardLock();
2753}
2754
2755RenderWidgetHostImpl* WebContentsImpl::GetKeyboardLockWidget() {
2756 return keyboard_lock_widget_;
2757}
2758
Dave Tapuskac3344362019-02-20 17:54:282759void WebContentsImpl::OnRenderFrameProxyVisibilityChanged(
2760 blink::mojom::FrameVisibility visibility) {
2761 switch (visibility) {
2762 case blink::mojom::FrameVisibility::kRenderedInViewport:
2763 WasShown();
2764 break;
2765 case blink::mojom::FrameVisibility::kNotRendered:
2766 WasHidden();
2767 break;
2768 case blink::mojom::FrameVisibility::kRenderedOutOfViewport:
2769 WasOccluded();
2770 break;
2771 }
ekaramada4f42692016-02-11 19:48:372772}
2773
Albert J. Wong65fe64d2019-09-20 02:48:142774RenderFrameHostDelegate* WebContentsImpl::CreateNewWindow(
csharrison95f01e922017-04-24 18:52:352775 RenderFrameHost* opener,
rockot5c478a72016-09-28 23:14:182776 const mojom::CreateNewWindowParams& params,
Albert J. Wong65fe64d2019-09-20 02:48:142777 bool is_new_browsing_instance,
Sergey Kuznetsov32257a22019-02-11 20:26:502778 bool has_user_gesture,
[email protected]97714c82012-06-06 10:15:132779 SessionStorageNamespace* session_storage_namespace) {
csharrison95f01e922017-04-24 18:52:352780 DCHECK(opener);
nick5ae4d2d2017-01-06 01:18:352781
csharrison95f01e922017-04-24 18:52:352782 int render_process_id = opener->GetProcess()->GetID();
csharrison95f01e922017-04-24 18:52:352783
Albert J. Wong65fe64d2019-09-20 02:48:142784 SiteInstance* source_site_instance = opener->GetSiteInstance();
nick5ae4d2d2017-01-06 01:18:352785
[email protected]bafe6cd2012-05-23 23:09:502786 // We usually create the new window in the same BrowsingInstance (group of
2787 // script-related windows), by passing in the current SiteInstance. However,
[email protected]c4538072013-03-18 02:17:552788 // if the opener is being suppressed (in a non-guest), we create a new
2789 // SiteInstance in its own BrowsingInstance.
[email protected]a24efc22014-05-26 15:50:252790 bool is_guest = BrowserPluginGuest::IsGuest(this);
[email protected]c4538072013-03-18 02:17:552791
[email protected]bafe6cd2012-05-23 23:09:502792 scoped_refptr<SiteInstance> site_instance =
alexmos4cf2aa32015-07-15 23:40:432793 params.opener_suppressed && !is_guest
2794 ? SiteInstance::CreateForURL(GetBrowserContext(), params.target_url)
2795 : source_site_instance;
[email protected]bafe6cd2012-05-23 23:09:502796
[email protected]d1198fd2012-08-13 22:50:192797 // We must assign the SessionStorageNamespace before calling Init().
[email protected]4c3a23582012-08-18 08:54:342798 //
2799 // http://crbug.com/142685
[email protected]fdac6ade2013-07-20 01:06:302800 const std::string& partition_id =
2801 GetContentClient()->browser()->
2802 GetStoragePartitionIdForSite(GetBrowserContext(),
2803 site_instance->GetSiteURL());
[email protected]fc72bb12013-06-02 21:13:462804 StoragePartition* partition = BrowserContext::GetStoragePartition(
2805 GetBrowserContext(), site_instance.get());
[email protected]5f2aa722013-08-07 16:59:412806 DOMStorageContextWrapper* dom_storage_context =
2807 static_cast<DOMStorageContextWrapper*>(partition->GetDOMStorageContext());
[email protected]d1198fd2012-08-13 22:50:192808 SessionStorageNamespaceImpl* session_storage_namespace_impl =
2809 static_cast<SessionStorageNamespaceImpl*>(session_storage_namespace);
2810 CHECK(session_storage_namespace_impl->IsFromContext(dom_storage_context));
[email protected]dd6730412013-08-14 15:03:372811
Albert J. Wong1ceccef92019-10-08 08:25:202812 if (delegate_ && delegate_->IsWebContentsCreationOverridden(
2813 source_site_instance, params.window_container_type,
2814 opener->GetLastCommittedURL(), params.frame_name,
2815 params.target_url)) {
2816 return static_cast<WebContentsImpl*>(delegate_->CreateCustomWebContents(
2817 opener, source_site_instance, is_new_browsing_instance,
2818 opener->GetLastCommittedURL(), params.frame_name, params.target_url,
2819 partition_id, session_storage_namespace));
[email protected]dd6730412013-08-14 15:03:372820 }
2821
danakj22b4e8b2019-08-01 23:14:392822 bool renderer_started_hidden =
2823 params.disposition == WindowOpenDisposition::NEW_BACKGROUND_TAB;
2824
[email protected]dd6730412013-08-14 15:03:372825 // Create the new web contents. This will automatically create the new
2826 // WebContentsView. In the future, we may want to create the view separately.
[email protected]fc72bb12013-06-02 21:13:462827 CreateParams create_params(GetBrowserContext(), site_instance.get());
nasko48321ca32015-07-02 20:44:122828 create_params.main_frame_name = params.frame_name;
alexmos4cf2aa32015-07-15 23:40:432829 create_params.opener_render_process_id = render_process_id;
csharrison95f01e922017-04-24 18:52:352830 create_params.opener_render_frame_id = opener->GetRoutingID();
[email protected]50d326e2014-05-20 17:59:062831 create_params.opener_suppressed = params.opener_suppressed;
danakj22b4e8b2019-08-01 23:14:392832 create_params.initially_hidden = renderer_started_hidden;
[email protected]50d326e2014-05-20 17:59:062833
Albert J. Wong65fe64d2019-09-20 02:48:142834 // Even though all codepaths leading here are in response to a renderer
2835 // tryng to open a new window, if the new window ends up in a different
2836 // browsing instance, then the RenderViewHost, RenderWidgetHost,
2837 // RenderFrameHost constellation is effectively browser initiated
2838 // the opener's process will not given the routing IDs for the new
2839 // objects.
2840 create_params.renderer_initiated_creation = !is_new_browsing_instance;
Albert J. Wong1ceccef92019-10-08 08:25:202841
2842 // If |is_new_browsing_instance| is true, defer routing_id allocation
2843 // to the WebContentsImpl::Create() call. This is required because with
2844 // a new browsing instance, WebContentsImpl::Create() may elect a different
2845 // SiteInstance from |site_instance| (which happens if |site_instance| is
2846 // nullptr for example).
2847 //
2848 // TODO(ajwong): This routing id allocation should be pushed down further
2849 // into WebContentsImpl::Create().
2850 if (!is_new_browsing_instance) {
2851 create_params.routing_id = opener->GetProcess()->GetNextRoutingID();
2852 create_params.main_frame_routing_id =
2853 opener->GetProcess()->GetNextRoutingID();
2854 create_params.main_frame_widget_routing_id =
2855 opener->GetProcess()->GetNextRoutingID();
2856 }
Albert J. Wong65fe64d2019-09-20 02:48:142857
2858 std::unique_ptr<WebContentsImpl> new_contents;
[email protected]c4538072013-03-18 02:17:552859 if (!is_guest) {
2860 create_params.context = view_->GetNativeView();
Albert J. Wong65fe64d2019-09-20 02:48:142861 new_contents = WebContentsImpl::Create(create_params);
2862 } else {
2863 new_contents = base::WrapUnique(static_cast<WebContentsImpl*>(
2864 GetBrowserPluginGuest()->CreateNewGuestWindow(create_params)));
[email protected]c4538072013-03-18 02:17:552865 }
Albert J. Wong65fe64d2019-09-20 02:48:142866 auto* new_contents_impl = new_contents.get();
danakje6c01622018-10-05 19:39:262867
2868 new_contents_impl->GetController().SetSessionStorageNamespace(
erikchenbee5c9622018-04-27 19:30:252869 partition_id, session_storage_namespace);
[email protected]d1198fd2012-08-13 22:50:192870
alexmos646fec02015-07-25 00:11:492871 // If the new frame has a name, make sure any SiteInstances that can find
2872 // this named frame have proxies for it. Must be called after
2873 // SetSessionStorageNamespace, since this calls CreateRenderView, which uses
2874 // GetSessionStorageNamespace.
2875 if (!params.frame_name.empty())
danakje6c01622018-10-05 19:39:262876 new_contents_impl->GetRenderManager()->CreateProxiesForNewNamedFrame();
alexmos646fec02015-07-25 00:11:492877
[email protected]c4538072013-03-18 02:17:552878 // Save the window for later if we're not suppressing the opener (since it
[email protected]d70bea92013-04-05 04:23:342879 // will be shown immediately).
2880 if (!params.opener_suppressed) {
2881 if (!is_guest) {
danakje6c01622018-10-05 19:39:262882 WebContentsView* new_view = new_contents_impl->view_.get();
[email protected]bafe6cd2012-05-23 23:09:502883
[email protected]d70bea92013-04-05 04:23:342884 // TODO(brettw): It seems bogus that we have to call this function on the
2885 // newly created object and give it one of its own member variables.
danakj22b4e8b2019-08-01 23:14:392886 RenderWidgetHostView* widget_view = new_view->CreateViewForWidget(
danakje6c01622018-10-05 19:39:262887 new_contents_impl->GetRenderViewHost()->GetWidget(), false);
danakj22b4e8b2019-08-01 23:14:392888 if (!renderer_started_hidden) {
2889 // RenderWidgets for frames always initialize as hidden. If the renderer
2890 // created this window as visible, then we show it here.
2891 widget_view->Show();
2892 }
[email protected]d70bea92013-04-05 04:23:342893 }
[email protected]bafe6cd2012-05-23 23:09:502894 // Save the created window associated with the route so we can show it
2895 // later.
Albert J. Wongcb004632018-07-10 22:58:252896 //
2897 // TODO(ajwong): This should be keyed off the RenderFrame routing id or the
2898 // FrameTreeNode id instead of the routing id of the Widget for the main
2899 // frame. https://crbug.com/545684
Albert J. Wong1ceccef92019-10-08 08:25:202900 DCHECK_NE(MSG_ROUTING_NONE, create_params.main_frame_routing_id);
2901 GlobalRoutingID id(render_process_id,
2902 create_params.main_frame_widget_routing_id);
Albert J. Wong65fe64d2019-09-20 02:48:142903 pending_contents_[id] = std::move(new_contents);
danakje6c01622018-10-05 19:39:262904 AddDestructionObserver(new_contents_impl);
[email protected]bafe6cd2012-05-23 23:09:502905 }
2906
2907 if (delegate_) {
Bryan McQuaded2b93c02017-07-14 22:26:312908 delegate_->WebContentsCreated(this, render_process_id,
2909 opener->GetRoutingID(), params.frame_name,
danakje6c01622018-10-05 19:39:262910 params.target_url, new_contents_impl);
[email protected]bafe6cd2012-05-23 23:09:502911 }
2912
Charlie Harrisonf60dd1c2018-08-15 21:15:412913 for (auto& observer : observers_) {
danakje6c01622018-10-05 19:39:262914 observer.DidOpenRequestedURL(new_contents_impl, opener, params.target_url,
Leon Han963dc182018-11-06 05:41:482915 params.referrer.To<Referrer>(),
2916 params.disposition, ui::PAGE_TRANSITION_LINK,
Charlie Harrisonf60dd1c2018-08-15 21:15:412917 false, // started_from_context_menu
2918 true); // renderer_initiated
pnolandaae574e2017-03-06 21:04:212919 }
2920
Avi Drissmanba3b1b342017-08-29 18:16:132921 // Any new WebContents opened while this WebContents is in fullscreen can be
2922 // used to confuse the user, so drop fullscreen.
Avi Drissmand18c51972018-08-15 18:32:092923 ForSecurityDropFullscreen();
Avi Drissmanba3b1b342017-08-29 18:16:132924
[email protected]bafe6cd2012-05-23 23:09:502925 if (params.opener_suppressed) {
2926 // When the opener is suppressed, the original renderer cannot access the
2927 // new window. As a result, we need to show and navigate the window here.
[email protected]eda238a12012-09-07 23:44:002928 bool was_blocked = false;
erikchenbee5c9622018-04-27 19:30:252929
[email protected]eda238a12012-09-07 23:44:002930 if (delegate_) {
danakje6c01622018-10-05 19:39:262931 base::WeakPtr<WebContentsImpl> weak_new_contents =
2932 new_contents_impl->weak_factory_.GetWeakPtr();
nick0d558482017-02-13 22:27:222933
danakje6c01622018-10-05 19:39:262934 gfx::Rect initial_rect; // Report an empty initial rect.
Albert J. Wong65fe64d2019-09-20 02:48:142935 delegate_->AddNewContents(this, std::move(new_contents),
erikchenbee5c9622018-04-27 19:30:252936 params.disposition, initial_rect,
Sergey Kuznetsov32257a22019-02-11 20:26:502937 has_user_gesture, &was_blocked);
danakje6c01622018-10-05 19:39:262938 // The delegate may delete |new_contents_impl| during AddNewContents().
nick0d558482017-02-13 22:27:222939 if (!weak_new_contents)
Albert J. Wong65fe64d2019-09-20 02:48:142940 return nullptr;
[email protected]eda238a12012-09-07 23:44:002941 }
erikchenbee5c9622018-04-27 19:30:252942
[email protected]eda238a12012-09-07 23:44:002943 if (!was_blocked) {
Nasko Oskov83a8cf92018-10-19 14:58:562944 std::unique_ptr<NavigationController::LoadURLParams> load_params =
2945 std::make_unique<NavigationController::LoadURLParams>(
2946 params.target_url);
Nasko Oskov93e7c55c2018-12-19 01:59:292947 load_params->initiator_origin = opener->GetLastCommittedOrigin();
Leon Han963dc182018-11-06 05:41:482948 load_params->referrer = params.referrer.To<Referrer>();
Nasko Oskov83a8cf92018-10-19 14:58:562949 load_params->transition_type = ui::PAGE_TRANSITION_LINK;
2950 load_params->is_renderer_initiated = true;
Sergey Kuznetsov32257a22019-02-11 20:26:502951 load_params->has_user_gesture = has_user_gesture;
mariakhomenkoa4971c12015-07-21 19:04:372952
2953 if (delegate_ && !is_guest &&
2954 !delegate_->ShouldResumeRequestsForCreatedWindow()) {
Nasko Oskov83a8cf92018-10-19 14:58:562955 // We are in asynchronous add new contents path, delay navigation.
2956 DCHECK(!new_contents_impl->delayed_open_url_params_);
2957 new_contents_impl->delayed_load_url_params_ = std::move(load_params);
mariakhomenkoa4971c12015-07-21 19:04:372958 } else {
Nasko Oskov83a8cf92018-10-19 14:58:562959 new_contents_impl->controller_.LoadURLWithParams(*load_params.get());
Nasko Oskov28ebd5b2018-12-07 22:29:332960 if (!is_guest)
2961 new_contents_impl->Focus();
mariakhomenkoa4971c12015-07-21 19:04:372962 }
[email protected]eda238a12012-09-07 23:44:002963 }
[email protected]bafe6cd2012-05-23 23:09:502964 }
Albert J. Wong65fe64d2019-09-20 02:48:142965 return new_contents_impl;
[email protected]bafe6cd2012-05-23 23:09:502966}
2967
Erik Chenc71b51fe2019-09-19 21:34:272968void WebContentsImpl::CreateNewWidget(int32_t render_process_id,
2969 int32_t widget_route_id,
2970 mojo::PendingRemote<mojom::Widget> widget,
2971 RenderViewHostImpl* render_view_host) {
Albert J. Wongf6e13ed2018-09-18 15:25:472972 CreateNewWidget(render_process_id, widget_route_id, /*is_fullscreen=*/false,
Erik Chenc71b51fe2019-09-19 21:34:272973 std::move(widget), render_view_host);
[email protected]bafe6cd2012-05-23 23:09:502974}
2975
Julie Jeongeun Kimcaacf9102019-09-12 02:13:052976void WebContentsImpl::CreateNewFullscreenWidget(
2977 int32_t render_process_id,
2978 int32_t widget_route_id,
Erik Chenc71b51fe2019-09-19 21:34:272979 mojo::PendingRemote<mojom::Widget> widget,
2980 RenderViewHostImpl* render_view_host) {
Albert J. Wongf6e13ed2018-09-18 15:25:472981 CreateNewWidget(render_process_id, widget_route_id, /*is_fullscreen=*/true,
Erik Chenc71b51fe2019-09-19 21:34:272982 std::move(widget), render_view_host);
[email protected]bafe6cd2012-05-23 23:09:502983}
2984
Erik Chenc71b51fe2019-09-19 21:34:272985void WebContentsImpl::CreateNewWidget(int32_t render_process_id,
2986 int32_t route_id,
2987 bool is_fullscreen,
2988 mojo::PendingRemote<mojom::Widget> widget,
2989 RenderViewHostImpl* render_view_host) {
kenrba26d15092016-02-10 22:00:252990 RenderProcessHost* process = RenderProcessHost::FromID(render_process_id);
kenrbb46f86a2015-12-07 07:53:232991 // A message to create a new widget can only come from an active process for
[email protected]a8504022013-12-04 20:23:512992 // this WebContentsImpl instance. If any other process sends the request,
2993 // it is invalid and the process must be terminated.
dcheng57e39e22016-01-21 00:25:382994 if (!HasMatchingProcess(&frame_tree_, render_process_id)) {
Lukasz Anforowicz6f746282018-01-04 23:24:512995 ReceivedBadMessage(process, bad_message::WCI_NEW_WIDGET_PROCESS_MISMATCH);
[email protected]a8504022013-12-04 20:23:512996 return;
2997 }
2998
Dave Tapuska485aca92017-08-08 00:47:582999 RenderWidgetHostImpl* widget_host = new RenderWidgetHostImpl(
David Black9cca3592019-11-06 23:02:223000 this, process, route_id, std::move(widget), IsHidden(),
3001 std::make_unique<FrameTokenMessageQueue>());
[email protected]cfd80b02014-05-01 17:46:483002 RenderWidgetHostViewBase* widget_view =
3003 static_cast<RenderWidgetHostViewBase*>(
danakj0b246942018-09-17 21:30:273004 view_->CreateViewForChildWidget(widget_host));
[email protected]83918ec2013-01-10 15:37:193005 if (!widget_view)
3006 return;
danakj0b246942018-09-17 21:30:273007 // Fullscreen child widgets are frames, other child widgets are popups, and
3008 // popups should not get activated.
3009 if (!is_fullscreen)
3010 widget_view->SetWidgetType(WidgetType::kPopup);
[email protected]bafe6cd2012-05-23 23:09:503011 // Save the created widget associated with the route so we can show it later.
Lukasz Anforowicz09060bdf72018-08-23 15:53:173012 pending_widget_views_[GlobalRoutingID(render_process_id, route_id)] =
alexmosc2a8cec2016-05-23 22:19:533013 widget_view;
[email protected]bafe6cd2012-05-23 23:09:503014}
3015
alexmosc2a8cec2016-05-23 22:19:533016void WebContentsImpl::ShowCreatedWindow(int process_id,
nick5ae4d2d2017-01-06 01:18:353017 int main_frame_widget_route_id,
[email protected]bafe6cd2012-05-23 23:09:503018 WindowOpenDisposition disposition,
bokan107a47f2015-02-03 23:23:393019 const gfx::Rect& initial_rect,
[email protected]bafe6cd2012-05-23 23:09:503020 bool user_gesture) {
danakje6c01622018-10-05 19:39:263021 // This method is the renderer requesting an existing top level window to
3022 // show a new top level window that the renderer created. Each top level
3023 // window is associated with a WebContents. In this case it was created
3024 // earlier but showing it was deferred until the renderer requested for it
3025 // to be shown. We find that previously created WebContents here.
3026 // TODO(danakj): Why do we defer this show step until the renderer asks for it
3027 // when it will always do so. What needs to happen in the renderer before we
3028 // reach here?
3029 std::unique_ptr<WebContentsImpl> owned_created =
nick5ae4d2d2017-01-06 01:18:353030 GetCreatedWindow(process_id, main_frame_widget_route_id);
danakje6c01622018-10-05 19:39:263031 WebContentsImpl* created = owned_created.get();
3032 // The browser may have rejected the request to make a new window, or the
3033 // renderer could be sending an invalid route id. Ignore the request then.
3034 if (!created)
3035 return;
mariakhomenko44bdc4732015-04-29 01:55:383036
danakje6c01622018-10-05 19:39:263037 // This uses the delegate for the WebContents where the window was created
3038 // from, to control how to show the newly created window.
3039 WebContentsDelegate* delegate = GetDelegate();
nick5ae4d2d2017-01-06 01:18:353040
danakje6c01622018-10-05 19:39:263041 // The delegate can be null in tests, so we must check for it :(.
3042 if (delegate) {
3043 // Mark the web contents as pending resume, then immediately do
3044 // the resume if the delegate wants it.
3045 created->is_resume_pending_ = true;
3046 if (delegate->ShouldResumeRequestsForCreatedWindow())
3047 created->ResumeLoadingCreatedWebContents();
3048
3049 base::WeakPtr<WebContentsImpl> weak_created =
3050 created->weak_factory_.GetWeakPtr();
3051 delegate->AddNewContents(this, std::move(owned_created), disposition,
3052 initial_rect, user_gesture, nullptr);
3053 // The delegate may delete |created| during AddNewContents().
3054 if (!weak_created)
3055 return;
[email protected]eda238a12012-09-07 23:44:003056 }
danakje6c01622018-10-05 19:39:263057
3058 RenderWidgetHostImpl* rwh = created->GetMainFrame()->GetRenderWidgetHost();
3059 DCHECK_EQ(main_frame_widget_route_id, rwh->GetRoutingID());
3060 rwh->Send(new WidgetMsg_SetBounds_ACK(rwh->GetRoutingID()));
[email protected]bafe6cd2012-05-23 23:09:503061}
3062
alexmosc2a8cec2016-05-23 22:19:533063void WebContentsImpl::ShowCreatedWidget(int process_id,
Albert J. Wongf6e13ed2018-09-18 15:25:473064 int widget_route_id,
bokan107a47f2015-02-03 23:23:393065 const gfx::Rect& initial_rect) {
Albert J. Wongf6e13ed2018-09-18 15:25:473066 ShowCreatedWidget(process_id, widget_route_id, false, initial_rect);
[email protected]bafe6cd2012-05-23 23:09:503067}
3068
alexmosc2a8cec2016-05-23 22:19:533069void WebContentsImpl::ShowCreatedFullscreenWidget(int process_id,
Albert J. Wongf6e13ed2018-09-18 15:25:473070 int widget_route_id) {
3071 ShowCreatedWidget(process_id, widget_route_id, true, gfx::Rect());
[email protected]bafe6cd2012-05-23 23:09:503072}
3073
alexmosc2a8cec2016-05-23 22:19:533074void WebContentsImpl::ShowCreatedWidget(int process_id,
3075 int route_id,
[email protected]bafe6cd2012-05-23 23:09:503076 bool is_fullscreen,
bokan107a47f2015-02-03 23:23:393077 const gfx::Rect& initial_rect) {
[email protected]cfd80b02014-05-01 17:46:483078 RenderWidgetHostViewBase* widget_host_view =
alexmosc2a8cec2016-05-23 22:19:533079 static_cast<RenderWidgetHostViewBase*>(
3080 GetCreatedWidget(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:503081 if (!widget_host_view)
3082 return;
[email protected]cfd80b02014-05-01 17:46:483083
W. James MacLeanec4125c2019-09-27 18:56:003084 // GetOutermostWebContents() returns |this| if there are no outer WebContents.
W. James MacLean3c5f50462019-10-28 16:24:213085 auto* outer_web_contents = GetOuterWebContents();
3086 auto* outermost_web_contents = GetOutermostWebContents();
W. James MacLeanec4125c2019-09-27 18:56:003087 RenderWidgetHostView* view =
W. James MacLean3c5f50462019-10-28 16:24:213088 outermost_web_contents->GetRenderWidgetHostView();
3089 // It's not entirely obvious why we need the transform only in the case where
3090 // the outer webcontents is not the same as the outermost webcontents. It may
3091 // be due to the fact that oopifs that are children of the mainframe get
3092 // correct values for their screenrects, but deeper cross-process frames do
3093 // not. Hopefully this can be resolved with https://crbug.com/928825.
3094 // Handling these cases separately is needed for http://crbug.com/1015298.
3095 bool needs_transform = this != outermost_web_contents &&
3096 outermost_web_contents != outer_web_contents;
W. James MacLeanec4125c2019-09-27 18:56:003097
3098 gfx::Rect transformed_rect(initial_rect);
3099 RenderWidgetHostView* this_view = GetRenderWidgetHostView();
W. James MacLean3c5f50462019-10-28 16:24:213100 if (needs_transform) {
W. James MacLeanec4125c2019-09-27 18:56:003101 // We need to transform the coordinates of initial_rect.
3102 gfx::Point origin =
3103 this_view->TransformPointToRootCoordSpace(initial_rect.origin());
3104 gfx::Point bottom_right =
3105 this_view->TransformPointToRootCoordSpace(initial_rect.bottom_right());
3106 transformed_rect =
3107 gfx::Rect(origin.x(), origin.y(), bottom_right.x() - origin.x(),
3108 bottom_right.y() - origin.y());
[email protected]cfd80b02014-05-01 17:46:483109 }
3110
danakj0b246942018-09-17 21:30:273111 // Fullscreen child widgets are frames, other child widgets are popups.
[email protected]4aebbca2013-09-17 22:26:493112 if (is_fullscreen) {
[email protected]d7f80ba2013-10-12 07:42:313113 DCHECK_EQ(MSG_ROUTING_NONE, fullscreen_widget_routing_id_);
[email protected]0b431992014-06-24 00:08:033114 view_->StoreFocus();
alexmosc9e76ec2016-05-16 22:59:373115 fullscreen_widget_process_id_ =
3116 widget_host_view->GetRenderWidgetHost()->GetProcess()->GetID();
[email protected]d7f80ba2013-10-12 07:42:313117 fullscreen_widget_routing_id_ = route_id;
[email protected]4aebbca2013-09-17 22:26:493118 if (delegate_ && delegate_->EmbedsFullscreenWidget()) {
3119 widget_host_view->InitAsChild(GetRenderWidgetHostView()->GetNativeView());
Dave Tapuska3ed44192018-05-01 18:53:303120 delegate_->EnterFullscreenModeForTab(this, GURL(),
Dave Tapuskaa4189512019-10-15 20:27:343121 blink::mojom::FullscreenOptions());
[email protected]4aebbca2013-09-17 22:26:493122 } else {
[email protected]cfd80b02014-05-01 17:46:483123 widget_host_view->InitAsFullscreen(view);
[email protected]4aebbca2013-09-17 22:26:493124 }
ericwilligersde386342016-10-19 02:35:093125 for (auto& observer : observers_)
3126 observer.DidShowFullscreenWidget();
[email protected]4aebbca2013-09-17 22:26:493127 if (!widget_host_view->HasFocus())
3128 widget_host_view->Focus();
3129 } else {
W. James MacLeanec4125c2019-09-27 18:56:003130 widget_host_view->InitAsPopup(view, transformed_rect);
[email protected]4aebbca2013-09-17 22:26:493131 }
[email protected]89054502012-06-03 10:29:243132
yiyixcb1fbc4f2018-03-16 19:54:083133 RenderWidgetHostImpl* render_widget_host_impl = widget_host_view->host();
[email protected]89054502012-06-03 10:29:243134 render_widget_host_impl->Init();
[email protected]d7f80ba2013-10-12 07:42:313135 // Only allow privileged mouse lock for fullscreen render widget, which is
3136 // used to implement Pepper Flash fullscreen.
3137 render_widget_host_impl->set_allow_privileged_mouse_lock(is_fullscreen);
[email protected]bafe6cd2012-05-23 23:09:503138}
3139
danakje6c01622018-10-05 19:39:263140std::unique_ptr<WebContentsImpl> WebContentsImpl::GetCreatedWindow(
nick5ae4d2d2017-01-06 01:18:353141 int process_id,
3142 int main_frame_widget_route_id) {
Lukasz Anforowicz09060bdf72018-08-23 15:53:173143 auto key = GlobalRoutingID(process_id, main_frame_widget_route_id);
nick5ae4d2d2017-01-06 01:18:353144 auto iter = pending_contents_.find(key);
[email protected]bafe6cd2012-05-23 23:09:503145
3146 // Certain systems can block the creation of new windows. If we didn't succeed
3147 // in creating one, just return NULL.
alexmosc2a8cec2016-05-23 22:19:533148 if (iter == pending_contents_.end())
3149 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:503150
danakje6c01622018-10-05 19:39:263151 std::unique_ptr<WebContentsImpl> new_contents = std::move(iter->second);
nick5ae4d2d2017-01-06 01:18:353152 pending_contents_.erase(key);
danakje6c01622018-10-05 19:39:263153 RemoveDestructionObserver(new_contents.get());
[email protected]bafe6cd2012-05-23 23:09:503154
[email protected]d70bea92013-04-05 04:23:343155 // Don't initialize the guest WebContents immediately.
danakje6c01622018-10-05 19:39:263156 if (BrowserPluginGuest::IsGuest(new_contents.get()))
[email protected]d70bea92013-04-05 04:23:343157 return new_contents;
3158
Lukasz Anforowicz5510ed652018-06-06 16:16:193159 if (!new_contents->GetMainFrame()->GetProcess()->IsInitializedAndNotDead() ||
nick5ae4d2d2017-01-06 01:18:353160 !new_contents->GetMainFrame()->GetView()) {
alexmosc2a8cec2016-05-23 22:19:533161 return nullptr;
nick5ae4d2d2017-01-06 01:18:353162 }
[email protected]bafe6cd2012-05-23 23:09:503163
[email protected]bafe6cd2012-05-23 23:09:503164 return new_contents;
3165}
3166
alexmosc2a8cec2016-05-23 22:19:533167RenderWidgetHostView* WebContentsImpl::GetCreatedWidget(int process_id,
3168 int route_id) {
Lukasz Anforowicz09060bdf72018-08-23 15:53:173169 auto iter = pending_widget_views_.find(GlobalRoutingID(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:503170 if (iter == pending_widget_views_.end()) {
3171 DCHECK(false);
alexmosc2a8cec2016-05-23 22:19:533172 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:503173 }
3174
3175 RenderWidgetHostView* widget_host_view = iter->second;
Lukasz Anforowicz09060bdf72018-08-23 15:53:173176 pending_widget_views_.erase(GlobalRoutingID(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:503177
3178 RenderWidgetHost* widget_host = widget_host_view->GetRenderWidgetHost();
Lukasz Anforowicz5510ed652018-06-06 16:16:193179 if (!widget_host->GetProcess()->IsInitializedAndNotDead()) {
[email protected]bafe6cd2012-05-23 23:09:503180 // The view has gone away or the renderer crashed. Nothing to do.
alexmosc2a8cec2016-05-23 22:19:533181 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:503182 }
3183
3184 return widget_host_view;
3185}
3186
[email protected]f13b4202012-06-12 23:53:233187void WebContentsImpl::RequestMediaAccessPermission(
[email protected]33662e52013-01-07 21:31:093188 const MediaStreamRequest& request,
Mark Pilgrim57499082018-06-12 12:38:303189 MediaResponseCallback callback) {
[email protected]d19b84b2014-03-14 11:52:373190 if (delegate_) {
Mark Pilgrim57499082018-06-12 12:38:303191 delegate_->RequestMediaAccessPermission(this, request, std::move(callback));
[email protected]d19b84b2014-03-14 11:52:373192 } else {
Antonio Gomes0d42960a2019-06-05 12:35:513193 std::move(callback).Run(
3194 blink::MediaStreamDevices(),
3195 blink::mojom::MediaStreamRequestResult::FAILED_DUE_TO_SHUTDOWN,
3196 std::unique_ptr<MediaStreamUI>());
[email protected]d19b84b2014-03-14 11:52:373197 }
[email protected]f13b4202012-06-12 23:53:233198}
3199
Chandan Padhia4b8bcb72017-09-12 16:41:043200bool WebContentsImpl::CheckMediaAccessPermission(
Raymes Khouryad7c24a12018-03-05 23:22:583201 RenderFrameHost* render_frame_host,
Chandan Padhia4b8bcb72017-09-12 16:41:043202 const url::Origin& security_origin,
Antonio Gomesc8b734b2019-06-05 18:22:163203 blink::mojom::MediaStreamType type) {
3204 DCHECK(type == blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE ||
3205 type == blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE);
Chandan Padhia4b8bcb72017-09-12 16:41:043206 return delegate_ && delegate_->CheckMediaAccessPermission(
Raymes Khouryad7c24a12018-03-05 23:22:583207 render_frame_host, security_origin.GetURL(), type);
grunell657d4d82014-09-18 00:09:433208}
3209
Guido Urdaneta73fa6632019-01-14 18:46:263210std::string WebContentsImpl::GetDefaultMediaDeviceID(
Antonio Gomesc8b734b2019-06-05 18:22:163211 blink::mojom::MediaStreamType type) {
guidou8a440b842017-01-30 13:58:433212 if (!delegate_)
3213 return std::string();
3214 return delegate_->GetDefaultMediaDeviceID(this, type);
3215}
3216
[email protected]cc9200432013-07-23 23:02:403217SessionStorageNamespace* WebContentsImpl::GetSessionStorageNamespace(
3218 SiteInstance* instance) {
3219 return controller_.GetSessionStorageNamespace(instance);
3220}
3221
[email protected]6de7fc482014-06-06 10:46:443222SessionStorageNamespaceMap WebContentsImpl::GetSessionStorageNamespaceMap() {
3223 return controller_.GetSessionStorageNamespaceMap();
3224}
3225
[email protected]9b159a52013-10-03 17:24:553226FrameTree* WebContentsImpl::GetFrameTree() {
3227 return &frame_tree_;
3228}
3229
aelias5252baa2016-04-10 01:18:023230bool WebContentsImpl::IsOverridingUserAgent() {
3231 return GetController().GetVisibleEntry() &&
3232 GetController().GetVisibleEntry()->GetIsOverridingUserAgent();
3233}
3234
avi85ee8362016-10-08 02:09:083235bool WebContentsImpl::IsJavaScriptDialogShowing() const {
3236 return is_showing_javascript_dialog_;
3237}
3238
avic031d392017-03-03 03:09:423239bool WebContentsImpl::ShouldIgnoreUnresponsiveRenderer() {
3240 // Ignore unresponsive renderers if the debugger is attached to them since the
3241 // unresponsiveness might be a result of the renderer sitting on a breakpoint.
3242 //
David Bienvenu525f8a02019-02-15 02:02:423243#ifdef OS_WIN
3244 // Check if a windows debugger is attached to the renderer process.
3245 base::ProcessHandle process_handle =
3246 GetMainFrame()->GetProcess()->GetProcess().Handle();
3247 BOOL debugger_present = FALSE;
3248 if (CheckRemoteDebuggerPresent(process_handle, &debugger_present) &&
3249 debugger_present)
3250 return true;
3251#endif // OS_WIN
3252
avic031d392017-03-03 03:09:423253 // TODO(pfeldman): Fix this to only return true if the renderer is *actually*
3254 // sitting on a breakpoint. https://crbug.com/684202
3255 return DevToolsAgentHost::IsDebuggerAttached(this);
3256}
3257
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:413258ui::AXMode WebContentsImpl::GetAccessibilityMode() {
[email protected]95640212014-07-26 18:14:303259 return accessibility_mode_;
3260}
3261
Dominic Mazzonia7b0edb22017-08-09 16:32:513262void WebContentsImpl::AccessibilityEventReceived(
Dominic Mazzoniccbaa9b2018-06-06 07:44:233263 const AXEventNotificationDetails& details) {
ericwilligersde386342016-10-19 02:35:093264 for (auto& observer : observers_)
Dominic Mazzonia7b0edb22017-08-09 16:32:513265 observer.AccessibilityEventReceived(details);
[email protected]31a71eaf2014-03-13 01:47:363266}
3267
dmazzoni2400c462016-08-23 15:07:133268void WebContentsImpl::AccessibilityLocationChangesReceived(
3269 const std::vector<AXLocationChangeNotificationDetails>& details) {
ericwilligersde386342016-10-19 02:35:093270 for (auto& observer : observers_)
Dominic Mazzonia7b0edb22017-08-09 16:32:513271 observer.AccessibilityLocationChangesReceived(details);
dmazzoni2400c462016-08-23 15:07:133272}
3273
Abigail Kleinabb428332019-09-13 18:26:213274base::string16 WebContentsImpl::DumpAccessibilityTree(
3275 bool internal,
3276 std::vector<AccessibilityTreeFormatter::PropertyFilter> property_filters) {
James Wallace-Leeeafc94cb92018-07-23 21:35:093277 auto* ax_mgr = GetOrCreateRootBrowserAccessibilityManager();
3278 DCHECK(ax_mgr);
Lei Zhangc98caa3822019-11-07 19:17:273279 return AccessibilityTreeFormatterBase::DumpAccessibilityTreeFromManager(
Abigail Kleinabb428332019-09-13 18:26:213280 ax_mgr, internal, property_filters);
James Wallace-Leeeafc94cb92018-07-23 21:35:093281}
3282
Abigail Kleinaa898742019-11-01 02:31:253283void WebContentsImpl::RecordAccessibilityEvents(
3284 AccessibilityEventCallback callback,
3285 bool start) {
3286 if (start) {
3287 SetAccessibilityMode(ui::AXMode::kWebContents);
3288 auto* ax_mgr = GetOrCreateRootBrowserAccessibilityManager();
3289 DCHECK(ax_mgr);
3290 base::ProcessId pid = base::Process::Current().Pid();
3291 event_recorder_ = content::AccessibilityEventRecorder::Create(
3292 ax_mgr, pid, base::StringPiece{});
3293 event_recorder_->ListenToEvents(callback);
3294 } else {
3295 DCHECK(event_recorder_);
3296 event_recorder_->FlushAsyncEvents();
3297 event_recorder_ = nullptr;
3298 }
3299}
3300
dmazzonia656928e2014-09-15 20:28:543301RenderFrameHost* WebContentsImpl::GetGuestByInstanceID(
fsamuel833ee7c2015-02-13 23:40:403302 RenderFrameHost* render_frame_host,
dmazzonia656928e2014-09-15 20:28:543303 int browser_plugin_instance_id) {
3304 BrowserPluginGuestManager* guest_manager =
3305 GetBrowserContext()->GetGuestManager();
fsamuel9cbc00a2015-04-17 20:30:203306 if (!guest_manager)
3307 return nullptr;
3308
dmazzonia656928e2014-09-15 20:28:543309 WebContents* guest = guest_manager->GetGuestByInstanceID(
fsamuel2e9413d2015-02-25 01:25:443310 render_frame_host->GetProcess()->GetID(), browser_plugin_instance_id);
dmazzonia656928e2014-09-15 20:28:543311 if (!guest)
fsamuel9cbc00a2015-04-17 20:30:203312 return nullptr;
3313
dmazzonia656928e2014-09-15 20:28:543314 return guest->GetMainFrame();
3315}
3316
Ke He7319dbe2017-11-09 05:54:443317device::mojom::GeolocationContext* WebContentsImpl::GetGeolocationContext() {
3318 if (geolocation_context_)
3319 return geolocation_context_.get();
3320
Ken Rockotfd03e682019-06-20 21:13:543321 service_manager::Connector* connector = GetSystemConnector();
Miyoung Shin0f4480d2019-09-12 01:15:263322 auto receiver = geolocation_context_.BindNewPipeAndPassReceiver();
Ken Rockotfd03e682019-06-20 21:13:543323 if (connector)
Miyoung Shin0f4480d2019-09-12 01:15:263324 connector->Connect(device::mojom::kServiceName, std::move(receiver));
Conley Owens6894c4f2017-07-10 19:29:133325 return geolocation_context_.get();
blundellc57b93f2014-10-29 13:19:573326}
3327
ke.he98b761e2017-05-09 05:59:173328device::mojom::WakeLockContext* WebContentsImpl::GetWakeLockContext() {
blundelld8cd72b2017-03-28 07:18:383329 if (!wake_lock_context_host_)
3330 wake_lock_context_host_.reset(new WakeLockContextHost(this));
blundelle75a8f92017-03-27 08:11:173331 return wake_lock_context_host_->GetWakeLockContext();
alogvinovf50445a2015-10-30 13:00:123332}
3333
blundellf5316fc2017-05-15 11:49:033334#if defined(OS_ANDROID)
Miyoung Shin59f39ff2019-09-17 07:23:203335void WebContentsImpl::GetNFC(
3336 mojo::PendingReceiver<device::mojom::NFC> receiver) {
Leon Hanccb985f2019-08-26 02:43:243337 NFCHost nfc_host(this);
Miyoung Shin59f39ff2019-09-17 07:23:203338 nfc_host.GetNFC(std::move(receiver));
blundellf5316fc2017-05-15 11:49:033339}
3340#endif
3341
Evan Stade5e750ad02017-08-07 21:59:273342void WebContentsImpl::SetNotWaitingForResponse() {
3343 if (waiting_for_response_ == false)
3344 return;
3345
3346 waiting_for_response_ = false;
3347 if (delegate_)
3348 delegate_->LoadingStateChanged(this, is_load_to_different_document_);
Chris Hamiltonf82f2a702018-02-15 19:37:293349 for (auto& observer : observers_)
3350 observer.DidReceiveResponse();
Evan Stade5e750ad02017-08-07 21:59:273351}
3352
lfgbb9c28a2016-03-01 03:19:493353void WebContentsImpl::SendScreenRects() {
kenrbc52e1b4e2016-03-20 01:03:373354 for (FrameTreeNode* node : frame_tree_.Nodes()) {
kenrb0e8dc202016-05-30 19:51:403355 if (node->current_frame_host()->is_local_root())
kenrbc52e1b4e2016-03-20 01:03:373356 node->current_frame_host()->GetRenderWidgetHost()->SendScreenRects();
3357 }
lfgbb9c28a2016-03-01 03:19:493358
danakj4df8a9d02019-02-05 20:36:593359 // Interstitials have their own |frame_tree_|.
3360 if (interstitial_page_) {
3361 FrameTree* interstitial_frame_tree = interstitial_page_->GetFrameTree();
3362 for (FrameTreeNode* node : interstitial_frame_tree->Nodes()) {
3363 if (node->current_frame_host()->is_local_root())
3364 node->current_frame_host()->GetRenderWidgetHost()->SendScreenRects();
3365 }
lfgdb5c4ed2016-03-04 23:09:073366 }
3367
avallee9f43b012016-11-26 07:02:103368 if (browser_plugin_embedder_ && !is_being_destroyed_)
[email protected]a7568e62013-06-14 07:50:443369 browser_plugin_embedder_->DidSendScreenRects();
[email protected]32deec62013-05-15 23:55:043370}
3371
ekaramadadd882292016-06-08 15:22:563372TextInputManager* WebContentsImpl::GetTextInputManager() {
3373 if (GetOuterWebContents())
3374 return GetOuterWebContents()->GetTextInputManager();
3375
Ehsan Karamadc179dc02018-12-15 03:09:293376 if (!text_input_manager_ && !browser_plugin_guest_) {
Darren Shenca53d5f2018-05-15 04:56:013377 text_input_manager_.reset(new TextInputManager(
3378 GetBrowserContext() &&
3379 !GetBrowserContext()->IsOffTheRecord()) /* should_do_learning */);
3380 }
ekaramadadd882292016-06-08 15:22:563381
3382 return text_input_manager_.get();
3383}
3384
paulmeyer7f6f1d4f2016-11-15 00:00:273385bool WebContentsImpl::OnUpdateDragCursor() {
Lei Zhang6410ec1a2019-01-31 21:38:583386 return browser_plugin_embedder_ &&
3387 browser_plugin_embedder_->OnUpdateDragCursor();
paulmeyer7f6f1d4f2016-11-15 00:00:273388}
3389
kenrb11f213a2017-03-24 18:12:063390bool WebContentsImpl::IsWidgetForMainFrame(
3391 RenderWidgetHostImpl* render_widget_host) {
3392 return render_widget_host == GetMainFrame()->GetRenderWidgetHost();
3393}
3394
[email protected]95640212014-07-26 18:14:303395BrowserAccessibilityManager*
3396 WebContentsImpl::GetRootBrowserAccessibilityManager() {
Dominic Mazzoniefb5f9e32017-12-21 01:08:223397 RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(
3398 ShowingInterstitialPage() ? GetInterstitialPage()->GetMainFrame()
3399 : GetMainFrame());
creisc014b402015-04-23 16:41:453400 return rfh ? rfh->browser_accessibility_manager() : nullptr;
[email protected]95640212014-07-26 18:14:303401}
3402
3403BrowserAccessibilityManager*
3404 WebContentsImpl::GetOrCreateRootBrowserAccessibilityManager() {
Dominic Mazzoniefb5f9e32017-12-21 01:08:223405 RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(
3406 ShowingInterstitialPage() ? GetInterstitialPage()->GetMainFrame()
3407 : GetMainFrame());
creisc014b402015-04-23 16:41:453408 return rfh ? rfh->GetOrCreateBrowserAccessibilityManager() : nullptr;
[email protected]95640212014-07-26 18:14:303409}
3410
Dave Tapuskab336b922017-07-06 19:24:053411void WebContentsImpl::ExecuteEditCommand(
3412 const std::string& command,
3413 const base::Optional<base::string16>& value) {
Dave Tapuskae782bea2019-07-09 16:21:513414 auto* input_handler = GetFocusedFrameInputHandler();
3415 if (!input_handler)
Dave Tapuskab336b922017-07-06 19:24:053416 return;
3417
Dave Tapuskae782bea2019-07-09 16:21:513418 input_handler->ExecuteEditCommand(command, value);
Dave Tapuskab336b922017-07-06 19:24:053419}
3420
mohsen7ab1ec16ec2015-07-02 18:26:233421void WebContentsImpl::MoveRangeSelectionExtent(const gfx::Point& extent) {
Dave Tapuskae782bea2019-07-09 16:21:513422 auto* input_handler = GetFocusedFrameInputHandler();
3423 if (!input_handler)
mohsen7ab1ec16ec2015-07-02 18:26:233424 return;
3425
Dave Tapuskae782bea2019-07-09 16:21:513426 input_handler->MoveRangeSelectionExtent(extent);
mohsen7ab1ec16ec2015-07-02 18:26:233427}
3428
3429void WebContentsImpl::SelectRange(const gfx::Point& base,
3430 const gfx::Point& extent) {
Dave Tapuskae782bea2019-07-09 16:21:513431 auto* input_handler = GetFocusedFrameInputHandler();
3432 if (!input_handler)
mohsen7ab1ec16ec2015-07-02 18:26:233433 return;
3434
Dave Tapuskae782bea2019-07-09 16:21:513435 input_handler->SelectRange(base, extent);
mohsen7ab1ec16ec2015-07-02 18:26:233436}
3437
Dave Tapuskab336b922017-07-06 19:24:053438void WebContentsImpl::MoveCaret(const gfx::Point& extent) {
Dave Tapuskae782bea2019-07-09 16:21:513439 auto* input_handler = GetFocusedFrameInputHandler();
3440 if (!input_handler)
Dave Tapuskab336b922017-07-06 19:24:053441 return;
3442
Dave Tapuskae782bea2019-07-09 16:21:513443 input_handler->MoveCaret(extent);
Dave Tapuskab336b922017-07-06 19:24:053444}
3445
Shimi Zhang37deeb22017-09-28 00:59:013446void WebContentsImpl::AdjustSelectionByCharacterOffset(
3447 int start_adjust,
3448 int end_adjust,
3449 bool show_selection_menu) {
Dave Tapuskae782bea2019-07-09 16:21:513450 auto* input_handler = GetFocusedFrameInputHandler();
3451 if (!input_handler)
aurimasab0319022015-07-10 21:57:383452 return;
3453
Shimi Zhang37deeb22017-09-28 00:59:013454 using blink::mojom::SelectionMenuBehavior;
Dave Tapuskae782bea2019-07-09 16:21:513455 input_handler->AdjustSelectionByCharacterOffset(
Shimi Zhang37deeb22017-09-28 00:59:013456 start_adjust, end_adjust,
3457 show_selection_menu ? SelectionMenuBehavior::kShow
3458 : SelectionMenuBehavior::kHide);
aurimasab0319022015-07-10 21:57:383459}
3460
[email protected]b172aee2012-04-10 17:05:263461void WebContentsImpl::UpdatePreferredSize(const gfx::Size& pref_size) {
[email protected]222f5822014-02-05 23:40:493462 const gfx::Size old_size = GetPreferredSize();
[email protected]bcd2815602012-01-14 18:17:233463 preferred_size_ = pref_size;
[email protected]222f5822014-02-05 23:40:493464 OnPreferredSizeChanged(old_size);
[email protected]0548c5352011-09-07 00:33:333465}
3466
avic3aa8422015-11-09 20:57:223467void WebContentsImpl::ResizeDueToAutoResize(
3468 RenderWidgetHostImpl* render_widget_host,
Fady Samuel97947112018-05-05 16:24:543469 const gfx::Size& new_size) {
avic3aa8422015-11-09 20:57:223470 if (render_widget_host != GetRenderViewHost()->GetWidget())
3471 return;
3472
kenrbe4f91082017-06-02 20:32:083473 auto_resize_size_ = new_size;
3474
3475 // Out-of-process iframe visible viewport sizes usually come from the
3476 // top-level RenderWidgetHostView, but when auto-resize is enabled on the
3477 // top frame then that size is used instead.
3478 for (FrameTreeNode* node : frame_tree_.Nodes()) {
3479 if (node->current_frame_host()->is_local_root()) {
3480 RenderWidgetHostImpl* host =
3481 node->current_frame_host()->GetRenderWidgetHost();
3482 if (host != render_widget_host)
Fady Samuel0b911822018-04-25 13:22:163483 host->SynchronizeVisualProperties();
kenrbe4f91082017-06-02 20:32:083484 }
3485 }
3486
[email protected]61e2b3cc2012-03-02 16:13:343487 if (delegate_)
3488 delegate_->ResizeDueToAutoResize(this, new_size);
3489}
3490
kenrbe4f91082017-06-02 20:32:083491gfx::Size WebContentsImpl::GetAutoResizeSize() {
3492 return auto_resize_size_;
3493}
3494
3495void WebContentsImpl::ResetAutoResizeSize() {
3496 auto_resize_size_ = gfx::Size();
3497}
3498
Albert J. Wongeb28e7e2018-10-12 00:57:433499InputEventShim* WebContentsImpl::GetInputEventShim() const {
3500 // The only thing that intercepts text input and mouse lock is the
3501 // BrowserPluginGuest. Delegate to the BrowserPluginGuest logic for
3502 // whether or not it needs to shim these events.
3503 if (browser_plugin_guest_) {
3504 return browser_plugin_guest_->GetInputEventShim();
3505 }
3506 return nullptr;
3507}
3508
[email protected]b172aee2012-04-10 17:05:263509WebContents* WebContentsImpl::OpenURL(const OpenURLParams& params) {
Bo Liu300c6052018-06-12 04:46:073510 if (!delegate_) {
3511 // Embedder can delay setting a delegate on new WebContents with
3512 // WebContentsDelegate::ShouldResumeRequestsForCreatedWindow. In the mean
3513 // time, navigations, including the initial one, that goes through OpenURL
3514 // should be delayed until embedder is ready to resume loading.
3515 delayed_open_url_params_ = std::make_unique<OpenURLParams>(params);
Nasko Oskov83a8cf92018-10-19 14:58:563516
3517 // If there was a navigation deferred when creating the window through
3518 // CreateNewWindow, drop it in favor of this navigation.
3519 delayed_load_url_params_.reset();
3520
Ivan Kotenkov2c0d2bb32017-11-01 15:41:283521 return nullptr;
Bo Liu300c6052018-06-12 04:46:073522 }
[email protected]00c37fc2011-08-02 00:22:503523
[email protected]e5d549d2011-12-28 01:29:203524 WebContents* new_contents = delegate_->OpenURLFromTab(this, params);
pnoland488944652017-02-22 18:58:543525
3526 RenderFrameHost* source_render_frame_host = RenderFrameHost::FromID(
3527 params.source_render_process_id, params.source_render_frame_id);
3528
3529 if (source_render_frame_host && params.source_site_instance) {
3530 CHECK_EQ(source_render_frame_host->GetSiteInstance(),
3531 params.source_site_instance.get());
3532 }
3533
3534 if (new_contents && source_render_frame_host && new_contents != this) {
3535 for (auto& observer : observers_) {
Lukasz Anforowicz48c9f872018-08-01 00:58:413536 observer.DidOpenRequestedURL(
3537 new_contents, source_render_frame_host, params.url, params.referrer,
3538 params.disposition, params.transition,
3539 params.started_from_context_menu, params.is_renderer_initiated);
pnoland488944652017-02-22 18:58:543540 }
3541 }
3542
[email protected]e5d549d2011-12-28 01:29:203543 return new_contents;
[email protected]d5f942ba2008-09-26 19:30:343544}
3545
[email protected]a86c0e962013-12-17 17:10:393546void WebContentsImpl::RenderFrameForInterstitialPageCreated(
3547 RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:093548 for (auto& observer : observers_)
3549 observer.RenderFrameForInterstitialPageCreated(render_frame_host);
[email protected]ba45bfd2012-05-22 21:51:443550}
3551
[email protected]20ca0382013-02-28 19:50:073552void WebContentsImpl::AttachInterstitialPage(
3553 InterstitialPageImpl* interstitial_page) {
creisadca9862017-06-16 19:12:113554 DCHECK(!interstitial_page_ && interstitial_page);
3555 interstitial_page_ = interstitial_page;
[email protected]90fb08ed2013-09-24 17:43:293556
3557 // Cancel any visible dialogs so that they don't interfere with the
3558 // interstitial.
creis89a0f782015-05-27 16:13:173559 CancelActiveAndPendingDialogs();
[email protected]90fb08ed2013-09-24 17:43:293560
ericwilligersde386342016-10-19 02:35:093561 for (auto& observer : observers_)
3562 observer.DidAttachInterstitialPage();
clamy44e84ce2016-02-22 15:38:253563
3564 // Stop the throbber if needed while the interstitial page is shown.
3565 if (frame_tree_.IsLoading())
3566 LoadingStateChanged(true, true, nullptr);
lfg1453e412017-04-11 00:48:503567
3568 // Connect to outer WebContents if necessary.
3569 if (node_.OuterContentsFrameTreeNode()) {
3570 if (GetRenderManager()->GetProxyToOuterDelegate()) {
3571 DCHECK(
3572 static_cast<RenderWidgetHostViewBase*>(interstitial_page->GetView())
3573 ->IsRenderWidgetHostViewChildFrame());
3574 RenderWidgetHostViewChildFrame* view =
3575 static_cast<RenderWidgetHostViewChildFrame*>(
3576 interstitial_page->GetView());
3577 GetRenderManager()->SetRWHViewForInnerContents(view);
3578 }
3579 }
Bo Liu7c6779e92017-08-16 02:02:283580
Bo Liu168c8642017-08-28 18:26:023581#if defined(OS_ANDROID)
Bo Liu7c6779e92017-08-16 02:02:283582 // Update importance of the interstitial.
3583 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
3584 ->GetRenderWidgetHost()
3585 ->SetImportance(GetMainFrame()->GetRenderWidgetHost()->importance());
Bo Liu168c8642017-08-28 18:26:023586#endif
Dominic Mazzoniefb5f9e32017-12-21 01:08:223587
3588 if (accessibility_mode_.has_mode(ui::AXMode::kNativeAPIs)) {
3589 // Make sure that the main page's accessibility tree is hidden and the
3590 // interstitial gets focus.
3591 RenderFrameHostImpl* rfh =
3592 static_cast<RenderFrameHostImpl*>(GetMainFrame());
3593 if (rfh) {
3594 BrowserAccessibilityManager* accessibility_manager =
3595 rfh->browser_accessibility_manager();
3596 if (accessibility_manager)
3597 accessibility_manager->set_hidden_by_interstitial_page(true);
3598 }
3599 rfh = static_cast<RenderFrameHostImpl*>(
3600 GetInterstitialPage()->GetMainFrame());
3601 if (rfh) {
3602 BrowserAccessibilityManager* accessibility_manager =
3603 rfh->GetOrCreateBrowserAccessibilityManager();
3604 if (accessibility_manager)
3605 accessibility_manager->OnWindowFocused();
3606 }
3607 }
clamy44e84ce2016-02-22 15:38:253608}
3609
3610void WebContentsImpl::DidProceedOnInterstitial() {
3611 // The interstitial page should no longer be pausing the throbber.
creisadca9862017-06-16 19:12:113612 DCHECK(!(ShowingInterstitialPage() && interstitial_page_->pause_throbber()));
clamy44e84ce2016-02-22 15:38:253613
3614 // Restart the throbber now that the interstitial page no longer pauses it.
3615 if (ShowingInterstitialPage() && frame_tree_.IsLoading())
3616 LoadingStateChanged(true, true, nullptr);
[email protected]20ca0382013-02-28 19:50:073617}
3618
Shivani Sharma985474f2019-05-23 21:36:473619bool WebContentsImpl::HadInnerWebContents() {
3620 return had_inner_webcontents_;
3621}
3622
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043623void WebContentsImpl::DetachInterstitialPage(bool has_focus) {
Lucas Furukawa Gadani69b609192017-07-10 17:08:343624 bool interstitial_pausing_throbber =
3625 ShowingInterstitialPage() && interstitial_page_->pause_throbber();
3626 if (ShowingInterstitialPage())
3627 interstitial_page_ = nullptr;
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043628
Dominic Mazzoniefb5f9e32017-12-21 01:08:223629 // Make sure that the main page's accessibility tree is no longer
3630 // suppressed.
3631 RenderFrameHostImpl* rfh = GetMainFrame();
3632 if (rfh) {
3633 BrowserAccessibilityManager* accessibility_manager =
3634 rfh->browser_accessibility_manager();
3635 if (accessibility_manager)
3636 accessibility_manager->set_hidden_by_interstitial_page(false);
3637 }
3638
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043639 // If the focus was on the interstitial, let's keep it to the page.
3640 // (Note that in unit-tests the RVH may not have a view).
3641 if (has_focus && GetRenderViewHost()->GetWidget()->GetView())
3642 GetRenderViewHost()->GetWidget()->GetView()->Focus();
3643
Lucas Furukawa Gadani69b609192017-07-10 17:08:343644 for (auto& observer : observers_)
3645 observer.DidDetachInterstitialPage();
3646
3647 // Disconnect from outer WebContents if necessary. This must happen after the
3648 // interstitial page is cleared above, since the call to
3649 // SetRWHViewForInnerContents below may loop over all the
3650 // RenderWidgetHostViews in the tree (otherwise, including the now-deleted
3651 // view for the interstitial).
lfg1453e412017-04-11 00:48:503652 if (node_.OuterContentsFrameTreeNode()) {
3653 if (GetRenderManager()->GetProxyToOuterDelegate()) {
3654 DCHECK(static_cast<RenderWidgetHostViewBase*>(
3655 GetRenderManager()->current_frame_host()->GetView())
3656 ->IsRenderWidgetHostViewChildFrame());
3657 RenderWidgetHostViewChildFrame* view =
3658 static_cast<RenderWidgetHostViewChildFrame*>(
3659 GetRenderManager()->current_frame_host()->GetView());
3660 GetRenderManager()->SetRWHViewForInnerContents(view);
3661 }
3662 }
3663
clamy44e84ce2016-02-22 15:38:253664 // Restart the throbber if needed now that the interstitial page is going
3665 // away.
3666 if (interstitial_pausing_throbber && frame_tree_.IsLoading())
3667 LoadingStateChanged(true, true, nullptr);
[email protected]20ca0382013-02-28 19:50:073668}
3669
avi2b177592014-12-10 02:08:023670void WebContentsImpl::SetHistoryOffsetAndLength(int history_offset,
3671 int history_length) {
alexmos136fd6e62016-08-15 20:58:413672 SendPageMessage(new PageMsg_SetHistoryOffsetAndLength(
3673 MSG_ROUTING_NONE, history_offset, history_length));
avi2b177592014-12-10 02:08:023674}
3675
3676void WebContentsImpl::SetHistoryOffsetAndLengthForView(
3677 RenderViewHost* render_view_host,
3678 int history_offset,
3679 int history_length) {
alexmos136fd6e62016-08-15 20:58:413680 render_view_host->Send(new PageMsg_SetHistoryOffsetAndLength(
avi2b177592014-12-10 02:08:023681 render_view_host->GetRoutingID(), history_offset, history_length));
[email protected]796931a92011-08-10 01:32:143682}
3683
arthursonzogni818c2642019-09-27 12:18:103684void WebContentsImpl::ReloadFocusedFrame() {
[email protected]1f3fc1d2014-04-03 14:50:173685 RenderFrameHost* focused_frame = GetFocusedFrame();
3686 if (!focused_frame)
3687 return;
3688
yilkal921048bd2019-10-09 23:51:043689 focused_frame->Reload();
[email protected]959be4c2014-04-08 15:01:333690}
3691
Miyoung Shin298d5ad2019-09-05 01:52:373692std::vector<mojo::Remote<blink::mojom::PauseSubresourceLoadingHandle>>
Ryan Sturmc65dbe42018-05-31 20:37:043693WebContentsImpl::PauseSubresourceLoading() {
Miyoung Shin298d5ad2019-09-05 01:52:373694 std::vector<mojo::Remote<blink::mojom::PauseSubresourceLoadingHandle>>
3695 handles;
Ryan Sturmc65dbe42018-05-31 20:37:043696 for (RenderFrameHost* rfh : GetAllFrames()) {
3697 if (!rfh->IsRenderFrameLive())
3698 continue;
3699 handles.push_back(rfh->PauseSubresourceLoading());
3700 }
3701 return handles;
3702}
3703
[email protected]959be4c2014-04-08 15:01:333704void WebContentsImpl::Undo() {
Dave Tapuskae782bea2019-07-09 16:21:513705 auto* input_handler = GetFocusedFrameInputHandler();
3706 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333707 return;
3708
Dave Tapuskae782bea2019-07-09 16:21:513709 input_handler->Undo();
[email protected]959be4c2014-04-08 15:01:333710 RecordAction(base::UserMetricsAction("Undo"));
3711}
3712
3713void WebContentsImpl::Redo() {
Dave Tapuskae782bea2019-07-09 16:21:513714 auto* input_handler = GetFocusedFrameInputHandler();
3715 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333716 return;
Dave Tapuskae782bea2019-07-09 16:21:513717
3718 input_handler->Redo();
[email protected]959be4c2014-04-08 15:01:333719 RecordAction(base::UserMetricsAction("Redo"));
3720}
3721
3722void WebContentsImpl::Cut() {
Dave Tapuskae782bea2019-07-09 16:21:513723 auto* input_handler = GetFocusedFrameInputHandler();
3724 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333725 return;
3726
Dave Tapuskae782bea2019-07-09 16:21:513727 input_handler->Cut();
[email protected]959be4c2014-04-08 15:01:333728 RecordAction(base::UserMetricsAction("Cut"));
3729}
3730
3731void WebContentsImpl::Copy() {
Dave Tapuskae782bea2019-07-09 16:21:513732 auto* input_handler = GetFocusedFrameInputHandler();
3733 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333734 return;
3735
Dave Tapuskae782bea2019-07-09 16:21:513736 input_handler->Copy();
[email protected]959be4c2014-04-08 15:01:333737 RecordAction(base::UserMetricsAction("Copy"));
3738}
3739
3740void WebContentsImpl::CopyToFindPboard() {
3741#if defined(OS_MACOSX)
Dave Tapuskae782bea2019-07-09 16:21:513742 auto* input_handler = GetFocusedFrameInputHandler();
3743 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333744 return;
3745
3746 // Windows/Linux don't have the concept of a find pasteboard.
Dave Tapuskae782bea2019-07-09 16:21:513747 input_handler->CopyToFindPboard();
[email protected]959be4c2014-04-08 15:01:333748 RecordAction(base::UserMetricsAction("CopyToFindPboard"));
3749#endif
3750}
3751
3752void WebContentsImpl::Paste() {
Dave Tapuskae782bea2019-07-09 16:21:513753 auto* input_handler = GetFocusedFrameInputHandler();
3754 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333755 return;
3756
Dave Tapuskae782bea2019-07-09 16:21:513757 input_handler->Paste();
Archana Simhaf67090c2019-05-06 23:43:233758 for (auto& observer : observers_)
3759 observer.OnPaste();
[email protected]959be4c2014-04-08 15:01:333760 RecordAction(base::UserMetricsAction("Paste"));
3761}
3762
3763void WebContentsImpl::PasteAndMatchStyle() {
Dave Tapuskae782bea2019-07-09 16:21:513764 auto* input_handler = GetFocusedFrameInputHandler();
3765 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333766 return;
3767
Dave Tapuskae782bea2019-07-09 16:21:513768 input_handler->PasteAndMatchStyle();
Archana Simhaf67090c2019-05-06 23:43:233769 for (auto& observer : observers_)
3770 observer.OnPaste();
[email protected]959be4c2014-04-08 15:01:333771 RecordAction(base::UserMetricsAction("PasteAndMatchStyle"));
3772}
3773
3774void WebContentsImpl::Delete() {
Dave Tapuskae782bea2019-07-09 16:21:513775 auto* input_handler = GetFocusedFrameInputHandler();
3776 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333777 return;
3778
Dave Tapuskae782bea2019-07-09 16:21:513779 input_handler->Delete();
[email protected]959be4c2014-04-08 15:01:333780 RecordAction(base::UserMetricsAction("DeleteSelection"));
3781}
3782
3783void WebContentsImpl::SelectAll() {
Dave Tapuskae782bea2019-07-09 16:21:513784 auto* input_handler = GetFocusedFrameInputHandler();
3785 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333786 return;
3787
Dave Tapuskae782bea2019-07-09 16:21:513788 input_handler->SelectAll();
[email protected]959be4c2014-04-08 15:01:333789 RecordAction(base::UserMetricsAction("SelectAll"));
3790}
3791
yabinh351e7ec2017-03-10 02:43:243792void WebContentsImpl::CollapseSelection() {
Dave Tapuskae782bea2019-07-09 16:21:513793 auto* input_handler = GetFocusedFrameInputHandler();
3794 if (!input_handler)
[email protected]959be4c2014-04-08 15:01:333795 return;
3796
Dave Tapuskae782bea2019-07-09 16:21:513797 input_handler->CollapseSelection();
[email protected]1f3fc1d2014-04-03 14:50:173798}
3799
3800void WebContentsImpl::Replace(const base::string16& word) {
Dave Tapuskae782bea2019-07-09 16:21:513801 auto* input_handler = GetFocusedFrameInputHandler();
3802 if (!input_handler)
[email protected]1f3fc1d2014-04-03 14:50:173803 return;
3804
Dave Tapuskae782bea2019-07-09 16:21:513805 input_handler->Replace(word);
[email protected]1f3fc1d2014-04-03 14:50:173806}
3807
3808void WebContentsImpl::ReplaceMisspelling(const base::string16& word) {
Dave Tapuskae782bea2019-07-09 16:21:513809 auto* input_handler = GetFocusedFrameInputHandler();
3810 if (!input_handler)
[email protected]1f3fc1d2014-04-03 14:50:173811 return;
3812
Dave Tapuskae782bea2019-07-09 16:21:513813 input_handler->ReplaceMisspelling(word);
[email protected]959be4c2014-04-08 15:01:333814}
3815
3816void WebContentsImpl::NotifyContextMenuClosed(
3817 const CustomContextMenuContext& context) {
3818 RenderFrameHost* focused_frame = GetFocusedFrame();
3819 if (!focused_frame)
3820 return;
3821
3822 focused_frame->Send(new FrameMsg_ContextMenuClosed(
3823 focused_frame->GetRoutingID(), context));
3824}
3825
3826void WebContentsImpl::ExecuteCustomContextMenuCommand(
3827 int action, const CustomContextMenuContext& context) {
3828 RenderFrameHost* focused_frame = GetFocusedFrame();
3829 if (!focused_frame)
3830 return;
3831
3832 focused_frame->Send(new FrameMsg_CustomContextMenuAction(
3833 focused_frame->GetRoutingID(), context, action));
[email protected]4fed3702014-04-01 09:08:003834}
3835
[email protected]fc2b46b2014-05-03 16:33:453836gfx::NativeView WebContentsImpl::GetNativeView() {
3837 return view_->GetNativeView();
3838}
3839
3840gfx::NativeView WebContentsImpl::GetContentNativeView() {
3841 return view_->GetContentNativeView();
3842}
3843
3844gfx::NativeWindow WebContentsImpl::GetTopLevelNativeWindow() {
3845 return view_->GetTopLevelNativeWindow();
3846}
3847
3848gfx::Rect WebContentsImpl::GetViewBounds() {
3849 return view_->GetViewBounds();
3850}
3851
3852gfx::Rect WebContentsImpl::GetContainerBounds() {
3853 gfx::Rect rv;
3854 view_->GetContainerBounds(&rv);
3855 return rv;
3856}
3857
3858DropData* WebContentsImpl::GetDropData() {
3859 return view_->GetDropData();
3860}
3861
3862void WebContentsImpl::Focus() {
miu9e14e492014-10-25 02:39:043863 view_->Focus();
[email protected]fc2b46b2014-05-03 16:33:453864}
3865
3866void WebContentsImpl::SetInitialFocus() {
miu9e14e492014-10-25 02:39:043867 view_->SetInitialFocus();
[email protected]fc2b46b2014-05-03 16:33:453868}
3869
3870void WebContentsImpl::StoreFocus() {
miu9e14e492014-10-25 02:39:043871 view_->StoreFocus();
[email protected]fc2b46b2014-05-03 16:33:453872}
3873
3874void WebContentsImpl::RestoreFocus() {
miu9e14e492014-10-25 02:39:043875 view_->RestoreFocus();
[email protected]fc2b46b2014-05-03 16:33:453876}
3877
[email protected]b172aee2012-04-10 17:05:263878void WebContentsImpl::FocusThroughTabTraversal(bool reverse) {
Maxim Podgorodskiya926c4ff2017-11-20 02:06:393879 view_->FocusThroughTabTraversal(reverse);
[email protected]96d185d2009-04-24 03:28:543880}
3881
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:413882bool WebContentsImpl::ShowingInterstitialPage() {
creisadca9862017-06-16 19:12:113883 return interstitial_page_ != nullptr;
[email protected]96d185d2009-04-24 03:28:543884}
3885
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:413886InterstitialPageImpl* WebContentsImpl::GetInterstitialPage() {
creisadca9862017-06-16 19:12:113887 return interstitial_page_;
[email protected]686493142011-07-15 21:47:223888}
3889
[email protected]b172aee2012-04-10 17:05:263890bool WebContentsImpl::IsSavable() {
[email protected]a53209b2012-01-20 16:48:163891 // WebKit creates Document object when MIME type is application/xhtml+xml,
3892 // so we also support this MIME type.
3893 return contents_mime_type_ == "text/html" ||
3894 contents_mime_type_ == "text/xml" ||
3895 contents_mime_type_ == "application/xhtml+xml" ||
3896 contents_mime_type_ == "text/plain" ||
3897 contents_mime_type_ == "text/css" ||
Kinuko Yasuda74702f92017-07-31 03:27:533898 blink::IsSupportedJavascriptMimeType(contents_mime_type_);
[email protected]a53209b2012-01-20 16:48:163899}
3900
[email protected]b172aee2012-04-10 17:05:263901void WebContentsImpl::OnSavePage() {
[email protected]c7dd2f62011-07-18 15:57:593902 // If we can not save the page, try to download it.
[email protected]a53209b2012-01-20 16:48:163903 if (!IsSavable()) {
Min Qinda0ed2062018-02-23 22:00:533904 download::RecordSavePackageEvent(
3905 download::SAVE_PACKAGE_DOWNLOAD_ON_NON_HTML);
nasko89ad7742015-03-05 22:14:193906 SaveFrame(GetLastCommittedURL(), Referrer());
[email protected]27678b2a2012-02-04 22:09:143907 return;
[email protected]c7dd2f62011-07-18 15:57:593908 }
3909
3910 Stop();
3911
3912 // Create the save package and possibly prompt the user for the name to save
3913 // the page as. The user prompt is an asynchronous operation that runs on
3914 // another thread.
3915 save_package_ = new SavePackage(this);
3916 save_package_->GetSaveInfo();
3917}
3918
3919// Used in automated testing to bypass prompting the user for file names.
3920// Instead, the names and paths are hard coded rather than running them through
3921// file name sanitation and extension / mime checking.
[email protected]2dec8ec2013-02-07 19:20:343922bool WebContentsImpl::SavePage(const base::FilePath& main_file,
3923 const base::FilePath& dir_path,
[email protected]8ff00d72012-10-23 19:12:213924 SavePageType save_type) {
[email protected]c7dd2f62011-07-18 15:57:593925 // Stop the page from navigating.
3926 Stop();
3927
3928 save_package_ = new SavePackage(this, save_type, main_file, dir_path);
[email protected]8ff00d72012-10-23 19:12:213929 return save_package_->Init(SavePackageDownloadCreatedCallback());
[email protected]c7dd2f62011-07-18 15:57:593930}
3931
[email protected]3c71576ce2013-07-23 02:00:013932void WebContentsImpl::SaveFrame(const GURL& url,
3933 const Referrer& referrer) {
Xing Liu10329bf2018-03-20 19:22:143934 SaveFrameWithHeaders(url, referrer, std::string(), base::string16());
kundaji6c7f9692015-03-09 18:00:373935}
3936
Xing Liu10329bf2018-03-20 19:22:143937void WebContentsImpl::SaveFrameWithHeaders(
3938 const GURL& url,
3939 const Referrer& referrer,
3940 const std::string& headers,
3941 const base::string16& suggested_filename) {
Lei Zhang13a42e42019-02-19 23:28:113942 // Check and see if the guest can handle this.
3943 if (delegate_) {
3944 WebContents* guest_web_contents = nullptr;
3945 if (browser_plugin_embedder_) {
3946 BrowserPluginGuest* guest = browser_plugin_embedder_->GetFullPageGuest();
3947 if (guest)
3948 guest_web_contents = guest->GetWebContents();
3949 } else if (browser_plugin_guest_) {
3950 guest_web_contents = this;
3951 }
3952
3953 if (guest_web_contents && delegate_->GuestSaveFrame(guest_web_contents))
3954 return;
3955 }
3956
nasko89ad7742015-03-05 22:14:193957 if (!GetLastCommittedURL().is_valid())
[email protected]3c71576ce2013-07-23 02:00:013958 return;
sammc92af61552014-11-19 23:27:403959 if (delegate_ && delegate_->SaveFrame(url, referrer))
3960 return;
3961
nasko89ad7742015-03-05 22:14:193962 // TODO(nasko): This check for main frame is incorrect and should be fixed
brettw760f7442016-05-23 21:19:223963 // by explicitly passing in which frame this method should target. This would
3964 // indicate whether it's the main frame, and also tell us the frame pointer
3965 // to use for routing.
nasko89ad7742015-03-05 22:14:193966 bool is_main_frame = (url == GetLastCommittedURL());
brettw760f7442016-05-23 21:19:223967 RenderFrameHost* frame_host = GetMainFrame();
[email protected]3c71576ce2013-07-23 02:00:013968
avib7348942015-12-25 20:57:103969 int64_t post_id = -1;
[email protected]3c71576ce2013-07-23 02:00:013970 if (is_main_frame) {
Lucas Furukawa Gadani5553a152019-01-08 18:55:573971 NavigationEntry* entry = controller_.GetLastCommittedEntry();
[email protected]3c71576ce2013-07-23 02:00:013972 if (entry)
3973 post_id = entry->GetPostID();
3974 }
Ramin Halavati24e21012017-07-10 12:56:063975 net::NetworkTrafficAnnotationTag traffic_annotation =
3976 net::DefineNetworkTrafficAnnotation("download_web_contents_frame", R"(
3977 semantics {
3978 sender: "Save Page Action"
3979 description:
3980 "Saves the given frame's URL to the local file system."
3981 trigger:
3982 "The user has triggered a save operation on the frame through a "
3983 "context menu or other mechanism."
3984 data: "None."
3985 destination: WEBSITE
3986 }
3987 policy {
Ramin Halavati3b979782017-07-21 11:40:263988 cookies_allowed: YES
Ramin Halavati24e21012017-07-10 12:56:063989 cookies_store: "user"
3990 setting:
3991 "This feature cannot be disabled by settings, but it's is only "
3992 "triggered by user request."
3993 policy_exception_justification: "Not implemented."
3994 })");
Min Qina904f3302018-02-13 23:33:343995 auto params = std::make_unique<download::DownloadUrlParameters>(
brettw760f7442016-05-23 21:19:223996 url, frame_host->GetProcess()->GetID(),
3997 frame_host->GetRenderViewHost()->GetRoutingID(),
Matt Menke6d93c3c2018-10-10 15:21:503998 frame_host->GetRoutingID(), traffic_annotation);
Min Qina904f3302018-02-13 23:33:343999 params->set_referrer(referrer.url);
4000 params->set_referrer_policy(
4001 Referrer::ReferrerPolicyForUrlRequest(referrer.policy));
[email protected]3c71576ce2013-07-23 02:00:014002 params->set_post_id(post_id);
[email protected]3c71576ce2013-07-23 02:00:014003 if (post_id >= 0)
4004 params->set_method("POST");
4005 params->set_prompt(true);
kundaji6c7f9692015-03-09 18:00:374006
4007 if (headers.empty()) {
4008 params->set_prefer_cache(true);
4009 } else {
Min Qina904f3302018-02-13 23:33:344010 for (download::DownloadUrlParameters::RequestHeadersNameValuePair
4011 key_value : ParseDownloadHeaders(headers)) {
Megan Jablonski2f6a4c52017-07-10 23:01:254012 params->add_request_header(key_value.first, key_value.second);
kundaji6c7f9692015-03-09 18:00:374013 }
4014 }
Xing Liu10329bf2018-03-20 19:22:144015 params->set_suggested_name(suggested_filename);
Min Qin0ca8e1ee2018-01-31 00:49:354016 params->set_download_source(download::DownloadSource::WEB_CONTENTS_API);
thestig859c78892017-05-15 21:17:064017 BrowserContext::GetDownloadManager(GetBrowserContext())
Ramin Halavati03efa732017-06-12 09:28:204018 ->DownloadUrl(std::move(params));
[email protected]3c71576ce2013-07-23 02:00:014019}
4020
[email protected]b172aee2012-04-10 17:05:264021void WebContentsImpl::GenerateMHTML(
dewittj6dc5747a2016-05-17 01:48:474022 const MHTMLGenerationParams& params,
Avi Drissman149b7832018-03-23 14:31:494023 base::OnceCallback<void(int64_t)> callback) {
Angel Alvarez902496682019-08-27 22:58:424024 base::OnceCallback<void(const MHTMLGenerationResult&)> wrapper_callback =
4025 base::BindOnce(
4026 [](base::OnceCallback<void(int64_t)> size_callback,
4027 const MHTMLGenerationResult& result) {
4028 std::move(size_callback).Run(result.file_size);
4029 },
4030 std::move(callback));
4031 MHTMLGenerationManager::GetInstance()->SaveMHTML(this, params,
4032 std::move(wrapper_callback));
4033}
4034
4035void WebContentsImpl::GenerateMHTMLWithResult(
4036 const MHTMLGenerationParams& params,
4037 MHTMLGenerationResult::GenerateMHTMLCallback callback) {
Avi Drissman149b7832018-03-23 14:31:494038 MHTMLGenerationManager::GetInstance()->SaveMHTML(this, params,
4039 std::move(callback));
[email protected]aa4f3972012-03-01 18:12:124040}
4041
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414042const std::string& WebContentsImpl::GetContentsMimeType() {
[email protected]0bfbf882011-12-22 18:19:274043 return contents_mime_type_;
4044}
4045
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414046bool WebContentsImpl::WillNotifyDisconnection() {
[email protected]0bfbf882011-12-22 18:19:274047 return notify_disconnection_;
4048}
4049
Leon Hanc819dc62019-01-28 04:30:194050blink::mojom::RendererPreferences* WebContentsImpl::GetMutableRendererPrefs() {
[email protected]0bfbf882011-12-22 18:19:274051 return &renderer_preferences_;
4052}
4053
[email protected]e35ccd52012-05-23 16:22:474054void WebContentsImpl::Close() {
4055 Close(GetRenderViewHost());
4056}
4057
Ella Ge80a52dce2017-11-15 18:01:524058void WebContentsImpl::DragSourceEndedAt(float client_x,
4059 float client_y,
4060 float screen_x,
4061 float screen_y,
Paul Meyer0c58c3712016-11-17 22:59:514062 blink::WebDragOperation operation,
4063 RenderWidgetHost* source_rwh) {
Lei Zhang6410ec1a2019-01-31 21:38:584064 if (browser_plugin_embedder_) {
paulmeyer8fc8ea92016-11-15 05:12:214065 browser_plugin_embedder_->DragSourceEndedAt(
4066 client_x, client_y, screen_x, screen_y, operation);
Lei Zhang6410ec1a2019-01-31 21:38:584067 }
Paul Meyer0c58c3712016-11-17 22:59:514068 if (source_rwh) {
Ella Ge80a52dce2017-11-15 18:01:524069 source_rwh->DragSourceEndedAt(gfx::PointF(client_x, client_y),
4070 gfx::PointF(screen_x, screen_y), operation);
Paul Meyer0c58c3712016-11-17 22:59:514071 }
[email protected]cf200a562013-05-03 16:24:294072}
4073
jam73f892642016-09-11 06:04:064074void WebContentsImpl::LoadStateChanged(
Charles Harrison911fa062018-03-06 21:01:464075 const std::string& host,
jam73f892642016-09-11 06:04:064076 const net::LoadStateWithParam& load_state,
4077 uint64_t upload_position,
4078 uint64_t upload_size) {
Charles Harrison911fa062018-03-06 21:01:464079 base::string16 host16 = url_formatter::IDNToUnicode(host);
Elly Fong-Jonescad9c3d12018-01-31 17:26:104080 // Drop no-op updates.
4081 if (load_state_.state == load_state.state &&
4082 load_state_.param == load_state.param &&
4083 upload_position_ == upload_position && upload_size_ == upload_size &&
Charles Harrison911fa062018-03-06 21:01:464084 load_state_host_ == host16) {
Elly Fong-Jonescad9c3d12018-01-31 17:26:104085 return;
4086 }
jam73f892642016-09-11 06:04:064087 load_state_ = load_state;
4088 upload_position_ = upload_position;
4089 upload_size_ = upload_size;
Charles Harrison911fa062018-03-06 21:01:464090 load_state_host_ = host16;
jam73f892642016-09-11 06:04:064091 if (load_state_.state == net::LOAD_STATE_READING_RESPONSE)
4092 SetNotWaitingForResponse();
4093 if (IsLoading()) {
4094 NotifyNavigationStateChanged(static_cast<InvalidateTypes>(
4095 INVALIDATE_TYPE_LOAD | INVALIDATE_TYPE_TAB));
4096 }
4097}
4098
Collin Baker989e0882019-11-01 01:27:174099void WebContentsImpl::SetVisibilityAndNotifyObservers(Visibility visibility) {
Francois Doraye6161152018-03-27 22:05:374100 const Visibility previous_visibility = visibility_;
4101 visibility_ = visibility;
4102
Francois Dorayfe4a1772018-02-17 04:17:094103 // Notify observers if the visibility changed or if WasShown() is being called
4104 // for the first time.
Francois Dorayfe4a1772018-02-17 04:17:094105 if (visibility != previous_visibility ||
4106 (visibility == Visibility::VISIBLE && !did_first_set_visible_)) {
4107 for (auto& observer : observers_)
4108 observer.OnVisibilityChanged(visibility);
4109 }
4110}
4111
Michael Thiessen896405db2017-07-20 17:52:324112void WebContentsImpl::NotifyWebContentsFocused(
4113 RenderWidgetHost* render_widget_host) {
ericwilligersde386342016-10-19 02:35:094114 for (auto& observer : observers_)
Michael Thiessen896405db2017-07-20 17:52:324115 observer.OnWebContentsFocused(render_widget_host);
calamity7fe55ce2015-04-10 03:59:374116}
4117
Michael Thiessen896405db2017-07-20 17:52:324118void WebContentsImpl::NotifyWebContentsLostFocus(
4119 RenderWidgetHost* render_widget_host) {
zijiehe3bee08e22017-05-17 04:14:464120 for (auto& observer : observers_)
Michael Thiessen896405db2017-07-20 17:52:324121 observer.OnWebContentsLostFocus(render_widget_host);
zijiehe3bee08e22017-05-17 04:14:464122}
4123
Paul Meyer0c58c3712016-11-17 22:59:514124void WebContentsImpl::SystemDragEnded(RenderWidgetHost* source_rwh) {
4125 if (source_rwh)
4126 source_rwh->DragSourceSystemDragEnded();
Lei Zhang6410ec1a2019-01-31 21:38:584127 if (browser_plugin_embedder_)
[email protected]cf200a562013-05-03 16:24:294128 browser_plugin_embedder_->SystemDragEnded();
[email protected]7813bd72011-02-05 02:19:344129}
4130
[email protected]b172aee2012-04-10 17:05:264131void WebContentsImpl::SetClosedByUserGesture(bool value) {
[email protected]0bfbf882011-12-22 18:19:274132 closed_by_user_gesture_ = value;
4133}
4134
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414135bool WebContentsImpl::GetClosedByUserGesture() {
[email protected]0bfbf882011-12-22 18:19:274136 return closed_by_user_gesture_;
4137}
4138
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414139int WebContentsImpl::GetMinimumZoomPercent() {
[email protected]0bfbf882011-12-22 18:19:274140 return minimum_zoom_percent_;
4141}
4142
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414143int WebContentsImpl::GetMaximumZoomPercent() {
[email protected]0bfbf882011-12-22 18:19:274144 return maximum_zoom_percent_;
4145}
4146
mcnee432e47d2015-11-09 19:37:464147void WebContentsImpl::SetPageScale(float page_scale_factor) {
Lukasz Anforowiczf4357ca2017-09-07 01:43:324148 GetRenderViewHost()->Send(new ViewMsg_SetPageScale(
4149 GetRenderViewHost()->GetRoutingID(), page_scale_factor));
ccameronb7c1d6c2015-03-09 17:08:244150}
4151
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414152gfx::Size WebContentsImpl::GetPreferredSize() {
Francois Doray24fc62c2017-12-11 17:27:334153 return IsBeingCaptured() ? preferred_size_for_capture_ : preferred_size_;
[email protected]bcd2815602012-01-14 18:17:234154}
4155
[email protected]b172aee2012-04-10 17:05:264156bool WebContentsImpl::GotResponseToLockMouseRequest(bool allowed) {
lfgf0cd46e2017-01-04 00:05:234157 if (!GuestMode::IsCrossProcessFrameGuest(GetWebContents()) &&
4158 GetBrowserPluginGuest())
[email protected]660f18e2014-05-15 20:53:054159 return GetBrowserPluginGuest()->LockMouse(allowed);
4160
lfgf0cd46e2017-01-04 00:05:234161 if (mouse_lock_widget_) {
4162 if (mouse_lock_widget_->delegate()->GetAsWebContents() != this) {
4163 return mouse_lock_widget_->delegate()
4164 ->GetAsWebContents()
4165 ->GotResponseToLockMouseRequest(allowed);
4166 }
lfgad8244352016-07-13 16:55:514167
lfgf0cd46e2017-01-04 00:05:234168 if (mouse_lock_widget_->GotResponseToLockMouseRequest(allowed))
4169 return true;
4170 }
4171
4172 for (WebContentsImpl* current = this; current;
4173 current = current->GetOuterWebContents()) {
4174 current->mouse_lock_widget_ = nullptr;
4175 }
4176
lfgbee1e0a2016-06-08 21:24:214177 return false;
[email protected]0bfbf882011-12-22 18:19:274178}
4179
Joe Downing13dd76b2018-04-09 18:32:154180bool WebContentsImpl::GotResponseToKeyboardLockRequest(bool allowed) {
4181 if (!keyboard_lock_widget_)
4182 return false;
4183
4184 if (keyboard_lock_widget_->delegate()->GetAsWebContents() != this) {
4185 NOTREACHED();
4186 return false;
4187 }
4188
4189 // KeyboardLock is only supported when called by the top-level browsing
4190 // context and is not supported in embedded content scenarios.
4191 if (GetOuterWebContents())
4192 return false;
4193
4194 keyboard_lock_widget_->GotResponseToKeyboardLockRequest(allowed);
4195 return true;
4196}
4197
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414198bool WebContentsImpl::HasOpener() {
Ivan Kotenkov2c0d2bb32017-11-01 15:41:284199 return GetOpener() != nullptr;
[email protected]a0358d72012-03-09 14:06:504200}
4201
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414202RenderFrameHostImpl* WebContentsImpl::GetOpener() {
alexmose201c7cd2015-06-10 17:14:214203 FrameTreeNode* opener_ftn = frame_tree_.root()->opener();
lukasza6f8ac622017-06-06 03:10:204204 return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
jochen55ff3502014-12-18 20:52:574205}
4206
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414207bool WebContentsImpl::HasOriginalOpener() {
Ivan Kotenkov2c0d2bb32017-11-01 15:41:284208 return GetOriginalOpener() != nullptr;
jochen6004a362017-02-04 00:11:404209}
4210
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414211RenderFrameHostImpl* WebContentsImpl::GetOriginalOpener() {
jochen6004a362017-02-04 00:11:404212 FrameTreeNode* opener_ftn = frame_tree_.root()->original_opener();
lukasza6f8ac622017-06-06 03:10:204213 return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
jochen6004a362017-02-04 00:11:404214}
4215
[email protected]cb805452013-05-22 15:16:214216void WebContentsImpl::DidChooseColorInColorChooser(SkColor color) {
Joel Hockey85b379d2017-12-11 10:42:134217 color_chooser_->DidChooseColorInColorChooser(color);
[email protected]da8543762012-03-20 08:52:204218}
4219
[email protected]cb805452013-05-22 15:16:214220void WebContentsImpl::DidEndColorChooser() {
Joel Hockey85b379d2017-12-11 10:42:134221 color_chooser_.reset();
[email protected]da8543762012-03-20 08:52:204222}
4223
halton.huoca2eabd2015-07-06 08:17:404224int WebContentsImpl::DownloadImage(
4225 const GURL& url,
4226 bool is_favicon,
4227 uint32_t max_bitmap_size,
4228 bool bypass_cache,
Avi Drissmana5a52dd2018-03-27 03:39:024229 WebContents::ImageDownloadCallback callback) {
amistry9f01b772015-07-29 01:54:554230 DCHECK_CURRENTLY_ON(BrowserThread::UI);
halton.huoca2eabd2015-07-06 08:17:404231 static int next_image_download_id = 0;
Julie Jeongeun Kimb1473572019-08-15 05:59:134232 const mojo::Remote<blink::mojom::ImageDownloader>& mojo_image_downloader =
halton.huoca2eabd2015-07-06 08:17:404233 GetMainFrame()->GetMojoImageDownloader();
amistry9f01b772015-07-29 01:54:554234 const int download_id = ++next_image_download_id;
4235 if (!mojo_image_downloader) {
4236 // If the renderer process is dead (i.e. crash, or memory pressure on
4237 // Android), the downloader service will be invalid. Pre-Mojo, this would
Avi Drissmana5a52dd2018-03-27 03:39:024238 // hang the callback indefinitely since the IPC would be dropped. Now,
amistry9f01b772015-07-29 01:54:554239 // respond with a 400 HTTP error code to indicate that something went wrong.
Sami Kyostila8e4d5a92019-08-02 12:45:054240 base::PostTask(
Eric Seckler8652dcd52018-09-20 10:42:284241 FROM_HERE, {BrowserThread::UI},
tzike2aca992017-09-05 08:50:544242 base::BindOnce(&WebContentsImpl::OnDidDownloadImage,
Avi Drissmana5a52dd2018-03-27 03:39:024243 weak_factory_.GetWeakPtr(), std::move(callback),
4244 download_id, url, 400, std::vector<SkBitmap>(),
4245 std::vector<gfx::Size>()));
amistry9f01b772015-07-29 01:54:554246 return download_id;
4247 }
4248
halton.huoca2eabd2015-07-06 08:17:404249 mojo_image_downloader->DownloadImage(
sammcf6f4fcf2016-06-21 05:39:394250 url, is_favicon, max_bitmap_size, bypass_cache,
tzike2aca992017-09-05 08:50:544251 base::BindOnce(&WebContentsImpl::OnDidDownloadImage,
Avi Drissmana5a52dd2018-03-27 03:39:024252 weak_factory_.GetWeakPtr(), std::move(callback),
4253 download_id, url));
amistry9f01b772015-07-29 01:54:554254 return download_id;
[email protected]795c28972012-12-06 06:13:394255}
4256
[email protected]36ec24f2014-01-09 00:32:084257void WebContentsImpl::Find(int request_id,
4258 const base::string16& search_text,
Rakina Zata Amni3f77dff2018-09-08 16:19:434259 blink::mojom::FindOptionsPtr options) {
thestig6057a6b22015-11-12 23:01:334260 // Cowardly refuse to search for no text.
4261 if (search_text.empty()) {
4262 NOTREACHED();
4263 return;
4264 }
4265
Rakina Zata Amni3f77dff2018-09-08 16:19:434266 GetOrCreateFindRequestManager()->Find(request_id, search_text,
4267 std::move(options));
[email protected]36ec24f2014-01-09 00:32:084268}
4269
4270void WebContentsImpl::StopFinding(StopFindAction action) {
paulmeyerfeafc2d2017-04-25 21:46:404271 if (FindRequestManager* manager = GetFindRequestManager())
4272 manager->StopFinding(action);
[email protected]36ec24f2014-01-09 00:32:084273}
4274
Tommy Steimel18360512017-11-01 00:38:194275bool WebContentsImpl::WasEverAudible() {
4276 return was_ever_audible_;
4277}
4278
Avi Drissmana5a52dd2018-03-27 03:39:024279void WebContentsImpl::GetManifest(GetManifestCallback callback) {
4280 manifest_manager_host_->GetManifest(std::move(callback));
mlamouriefdca9d2014-09-16 16:55:404281}
4282
bokanece34a82016-01-28 19:49:464283void WebContentsImpl::ExitFullscreen(bool will_cause_resize) {
mlamouri7a78d6fd2015-01-17 13:23:534284 // Clean up related state and initiate the fullscreen exit.
avi3627ecac2015-10-16 17:40:434285 GetRenderViewHost()->GetWidget()->RejectMouseLockOrUnlockIfNecessary();
bokanece34a82016-01-28 19:49:464286 ExitFullscreenMode(will_cause_resize);
mlamouri7a78d6fd2015-01-17 13:23:534287}
4288
Avi Drissmanced52b62019-08-14 21:25:464289void WebContentsImpl::ForSecurityDropFullscreen() {
4290 // There are two chains of WebContents to kick out of fullscreen.
4291 //
4292 // Chain 1, the inner/outer WebContents chain. If an inner WebContents has
4293 // done something that requires the browser to drop fullscreen, drop
4294 // fullscreen from it and any outer WebContents that may be in fullscreen.
4295 //
4296 // Chain 2, the opener WebContents chain. If a WebContents has done something
4297 // that requires the browser to drop fullscreen, drop fullscreen from any
4298 // WebContents that was involved in the chain of opening it.
4299 //
4300 // Note that these two chains don't interact, as only a top-level WebContents
4301 // can have an opener. This simplifies things.
4302
4303 WebContents* web_contents = this;
4304 while (web_contents) {
4305 if (web_contents->IsFullscreenForCurrentTab())
4306 web_contents->ExitFullscreen(true);
4307
4308 if (web_contents->HasOriginalOpener())
4309 web_contents = FromRenderFrameHost(web_contents->GetOriginalOpener());
4310 else
4311 web_contents = web_contents->GetOuterWebContents();
4312 }
4313}
4314
mariakhomenko44bdc4732015-04-29 01:55:384315void WebContentsImpl::ResumeLoadingCreatedWebContents() {
Nasko Oskov83a8cf92018-10-19 14:58:564316 if (delayed_load_url_params_.get()) {
4317 DCHECK(!delayed_open_url_params_);
4318 controller_.LoadURLWithParams(*delayed_load_url_params_.get());
4319 delayed_load_url_params_.reset(nullptr);
4320 return;
4321 }
4322
mariakhomenkoa4971c12015-07-21 19:04:374323 if (delayed_open_url_params_.get()) {
4324 OpenURL(*delayed_open_url_params_.get());
4325 delayed_open_url_params_.reset(nullptr);
4326 return;
4327 }
4328
mariakhomenko44bdc4732015-04-29 01:55:384329 // Resume blocked requests for both the RenderViewHost and RenderFrameHost.
4330 // TODO(brettw): It seems bogus to reach into here and initialize the host.
dfalcantarae6b7b46752015-07-10 18:14:164331 if (is_resume_pending_) {
4332 is_resume_pending_ = false;
avi0f1bbc9712015-11-17 02:58:134333 GetRenderViewHost()->GetWidget()->Init();
dfalcantarae6b7b46752015-07-10 18:14:164334 GetMainFrame()->Init();
4335 }
mariakhomenko44bdc4732015-04-29 01:55:384336}
4337
[email protected]b172aee2012-04-10 17:05:264338bool WebContentsImpl::FocusLocationBarByDefault() {
Xiyuan Xia2a66b112018-12-06 15:52:164339 if (should_focus_location_bar_by_default_)
[email protected]0c9406632013-02-08 01:13:334340 return true;
Xiyuan Xia2a66b112018-12-06 15:52:164341
[email protected]0c9406632013-02-08 01:13:334342 return delegate_ && delegate_->ShouldFocusLocationBarByDefault(this);
[email protected]0bfbf882011-12-22 18:19:274343}
4344
Tommy C. Li8bb5bf42019-01-18 18:45:514345void WebContentsImpl::SetFocusToLocationBar() {
[email protected]0bfbf882011-12-22 18:19:274346 if (delegate_)
Tommy C. Li8bb5bf42019-01-18 18:45:514347 delegate_->SetFocusToLocationBar();
[email protected]c40d6232011-03-25 00:16:214348}
4349
clamy0e119882015-07-31 16:12:334350void WebContentsImpl::DidStartNavigation(NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484351 TRACE_EVENT1("navigation", "WebContentsImpl::DidStartNavigation",
4352 "navigation_handle", navigation_handle);
ericwilligersde386342016-10-19 02:35:094353 for (auto& observer : observers_)
4354 observer.DidStartNavigation(navigation_handle);
Becca Hughesd11d6502018-07-31 17:01:284355
4356 if (display_cutout_host_impl_)
4357 display_cutout_host_impl_->DidStartNavigation(navigation_handle);
Xiyuan Xia2a66b112018-12-06 15:52:164358
4359 if (navigation_handle->IsInMainFrame()) {
4360 // When the browser is started with about:blank as the startup URL, focus
4361 // the location bar (which will also select its contents) so people can
4362 // simply begin typing to navigate elsewhere.
4363 //
4364 // We need to be careful not to trigger this for anything other than the
4365 // startup navigation. In particular, if we allow an attacker to open a
4366 // popup to about:blank, then navigate, focusing the Omnibox will cause the
4367 // end of the new URL to be scrolled into view instead of the start,
4368 // allowing the attacker to spoof other URLs. The conditions checked here
4369 // are all aimed at ensuring no such attacker-controlled navigation can
4370 // trigger this.
4371 should_focus_location_bar_by_default_ =
4372 controller_.IsInitialNavigation() &&
4373 !navigation_handle->IsRendererInitiated() &&
4374 navigation_handle->GetURL() == url::kAboutBlankURL;
4375 }
clamy0e119882015-07-31 16:12:334376}
4377
4378void WebContentsImpl::DidRedirectNavigation(
4379 NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484380 TRACE_EVENT1("navigation", "WebContentsImpl::DidRedirectNavigation",
4381 "navigation_handle", navigation_handle);
ericwilligersde386342016-10-19 02:35:094382 for (auto& observer : observers_)
4383 observer.DidRedirectNavigation(navigation_handle);
jam5f358e52017-02-13 16:37:034384
4385 // Notify accessibility if this is a reload. This has to called on the
4386 // BrowserAccessibilityManager associated with the old RFHI.
4387 if (navigation_handle->GetReloadType() != ReloadType::NONE) {
Mohamed Abdelhalim95794962019-09-20 11:16:494388 NavigationRequest* request = NavigationRequest::From(navigation_handle);
jam5f358e52017-02-13 16:37:034389 BrowserAccessibilityManager* manager =
Mohamed Abdelhalim95794962019-09-20 11:16:494390 request->frame_tree_node()
jam5f358e52017-02-13 16:37:034391 ->current_frame_host()
4392 ->browser_accessibility_manager();
4393 if (manager)
4394 manager->UserIsReloading();
4395 }
clamy0e119882015-07-31 16:12:334396}
4397
clamyefca29e2015-09-17 00:22:114398void WebContentsImpl::ReadyToCommitNavigation(
4399 NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484400 TRACE_EVENT1("navigation", "WebContentsImpl::ReadyToCommitNavigation",
4401 "navigation_handle", navigation_handle);
ericwilligersde386342016-10-19 02:35:094402 for (auto& observer : observers_)
4403 observer.ReadyToCommitNavigation(navigation_handle);
John Abd-El-Malekd4882642017-12-04 21:45:194404
Kenneth Russell954ed9ce2018-04-12 23:07:014405 // If any domains are blocked from accessing 3D APIs because they may
4406 // have caused the GPU to reset recently, unblock them here if the user
4407 // initiated this navigation. This implies that the user was involved in
4408 // the decision to navigate, so there's no concern about
4409 // denial-of-service issues. Want to do this as early as
4410 // possible to avoid race conditions with pages attempting to access
4411 // WebGL early on.
4412 //
4413 // TODO(crbug.com/617904): currently navigations initiated by the browser
4414 // (reload button, reload menu option, pressing return in the Omnibox)
4415 // return false from HasUserGesture(). If or when that is addressed,
4416 // remove the check for IsRendererInitiated() below.
4417 //
4418 // TODO(crbug.com/832180): HasUserGesture comes from the renderer
4419 // process and isn't validated. Until it is, don't trust it.
4420 if (!navigation_handle->IsRendererInitiated()) {
4421 GpuDataManagerImpl::GetInstance()->UnblockDomainFrom3DAPIs(
4422 navigation_handle->GetURL());
4423 }
4424
John Abd-El-Malekfde08e6da2017-12-05 04:06:244425 if (navigation_handle->IsSameDocument())
4426 return;
4427
Livvie Lin139bf442018-08-10 00:18:544428 // SSLInfo is not needed on subframe navigations since the main-frame
4429 // certificate is the only one that can be inspected (using the info
4430 // bubble) without refreshing the page with DevTools open.
Carlos ILaed1e7b2019-03-12 19:27:214431 // We don't call DidStartResourceResponse on net errors, since that results on
4432 // existing cert exceptions being revoked, which leads to weird behavior with
4433 // committed interstitials or while offline. We only need the error check for
4434 // the main frame case because unlike this method, SubresourceResponseStarted
4435 // does not get called on network errors.
4436 if (navigation_handle->IsInMainFrame() &&
4437 navigation_handle->GetNetErrorCode() == net::OK) {
Livvie Lin139bf442018-08-10 00:18:544438 controller_.ssl_manager()->DidStartResourceResponse(
4439 navigation_handle->GetURL(),
Camille Lamy62b826012019-02-26 09:15:474440 navigation_handle->GetSSLInfo().has_value()
4441 ? net::IsCertStatusError(
4442 navigation_handle->GetSSLInfo()->cert_status)
4443 : false);
4444 }
John Abd-El-Malekfde08e6da2017-12-05 04:06:244445
4446 SetNotWaitingForResponse();
clamyefca29e2015-09-17 00:22:114447}
4448
clamy0e119882015-07-31 16:12:334449void WebContentsImpl::DidFinishNavigation(NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484450 TRACE_EVENT1("navigation", "WebContentsImpl::DidFinishNavigation",
4451 "navigation_handle", navigation_handle);
Steven Holte38041342018-06-22 22:00:574452
ericwilligersde386342016-10-19 02:35:094453 for (auto& observer : observers_)
4454 observer.DidFinishNavigation(navigation_handle);
clamy0e119882015-07-31 16:12:334455
Becca Hughesd11d6502018-07-31 17:01:284456 if (display_cutout_host_impl_)
4457 display_cutout_host_impl_->DidFinishNavigation(navigation_handle);
4458
jam5f358e52017-02-13 16:37:034459 if (navigation_handle->HasCommitted()) {
Dominic Farolinof87ec2a2019-07-04 09:18:094460 // TODO(domfarolino, dmazzoni): Do this using WebContentsObserver. See
4461 // https://crbug.com/981271.
dmazzonibf8cec42015-02-08 08:28:084462 BrowserAccessibilityManager* manager =
jam5f358e52017-02-13 16:37:034463 static_cast<RenderFrameHostImpl*>(
4464 navigation_handle->GetRenderFrameHost())
4465 ->browser_accessibility_manager();
4466 if (manager) {
4467 if (navigation_handle->IsErrorPage()) {
4468 manager->NavigationFailed();
4469 } else {
4470 manager->NavigationSucceeded();
4471 }
4472 }
Tommy Steimel18360512017-11-01 00:38:194473
Yue Ru Sun979c4b162019-11-06 16:11:044474 if (navigation_handle->IsInMainFrame()) {
4475 last_committed_source_id_including_same_document_ =
Steven Holte38041342018-06-22 22:00:574476 ukm::ConvertToSourceId(navigation_handle->GetNavigationId(),
4477 ukm::SourceIdType::NAVIGATION_ID);
Yue Ru Sun979c4b162019-11-06 16:11:044478
4479 if (!navigation_handle->IsSameDocument()) {
4480 was_ever_audible_ = false;
4481 last_committed_source_id_ =
4482 last_committed_source_id_including_same_document_;
4483 }
Tommy Steimel18360512017-11-01 00:38:194484 }
dmazzonibf8cec42015-02-08 08:28:084485 }
Xiyuan Xia2a66b112018-12-06 15:52:164486
4487 // If we didn't end up on about:blank after setting this in DidStartNavigation
4488 // then don't focus the location bar.
4489 if (should_focus_location_bar_by_default_ &&
4490 navigation_handle->GetURL() != url::kAboutBlankURL) {
4491 should_focus_location_bar_by_default_ = false;
4492 }
yilkal796e89e2019-10-02 23:58:284493
yilkal172da772019-11-06 22:49:074494 if (navigation_handle->IsInMainFrame() && first_navigation_completed_)
4495 RecordMaxFrameCountUMA(max_loaded_frame_count_);
yilkal796e89e2019-10-02 23:58:284496
yilkal172da772019-11-06 22:49:074497 // If navigation has successfully finished in the main frame, set
4498 // |first_navigation_completed_| to true so that we will record
4499 // |max_loaded_frame_count_| above when future main frame navigations finish.
4500 if (navigation_handle->IsInMainFrame() && !navigation_handle->IsErrorPage()) {
4501 first_navigation_completed_ = true;
4502
4503 // Navigation has completed in main frame. Reset |max_loaded_frame_count_|.
4504 // |max_loaded_frame_count_| is not necessarily 1 if the navigation was
4505 // served from BackForwardCache.
4506 max_loaded_frame_count_ =
4507 GetMainFrame()->frame_tree_node()->GetFrameTreeSize();
yilkal796e89e2019-10-02 23:58:284508 }
[email protected]400992b2012-06-14 00:03:544509}
4510
[email protected]b80624c2014-02-09 02:46:554511void WebContentsImpl::DidFailLoadWithError(
4512 RenderFrameHostImpl* render_frame_host,
[email protected]b80624c2014-02-09 02:46:554513 const GURL& url,
[email protected]b80624c2014-02-09 02:46:554514 int error_code,
Yutaka Hirano16d3c5d2017-07-31 06:17:304515 const base::string16& error_description) {
ericwilligersde386342016-10-19 02:35:094516 for (auto& observer : observers_) {
Yutaka Hirano16d3c5d2017-07-31 06:17:304517 observer.DidFailLoad(render_frame_host, url, error_code, error_description);
ericwilligersde386342016-10-19 02:35:094518 }
[email protected]b80624c2014-02-09 02:46:554519}
4520
[email protected]52913802013-12-10 05:52:184521void WebContentsImpl::NotifyChangedNavigationState(
4522 InvalidateTypes changed_flags) {
4523 NotifyNavigationStateChanged(changed_flags);
4524}
4525
toyoshim0df1d3a2016-09-09 09:52:484526void WebContentsImpl::DidStartNavigationToPendingEntry(const GURL& url,
4527 ReloadType reload_type) {
[email protected]3691e5cf2014-01-22 10:16:204528 // Notify observers about navigation.
ericwilligersde386342016-10-19 02:35:094529 for (auto& observer : observers_)
4530 observer.DidStartNavigationToPendingEntry(url, reload_type);
[email protected]3691e5cf2014-01-22 10:16:204531}
4532
lukasza1d025732016-09-28 21:36:084533bool WebContentsImpl::ShouldTransferNavigation(bool is_main_frame_navigation) {
creis29460272015-12-16 04:38:224534 if (!delegate_)
4535 return true;
lukasza1d025732016-09-28 21:36:084536 return delegate_->ShouldTransferNavigation(is_main_frame_navigation);
creis29460272015-12-16 04:38:224537}
4538
[email protected]aa62afd2014-04-22 19:22:464539bool WebContentsImpl::ShouldPreserveAbortedURLs() {
4540 if (!delegate_)
4541 return false;
4542 return delegate_->ShouldPreserveAbortedURLs(this);
4543}
4544
[email protected]0d0f4c492014-04-02 06:42:574545void WebContentsImpl::DidNavigateMainFramePreCommit(
[email protected]5cfbddc2014-06-23 23:52:234546 bool navigation_is_within_page) {
[email protected]0d0f4c492014-04-02 06:42:574547 // Ensure fullscreen mode is exited before committing the navigation to a
4548 // different page. The next page will not start out assuming it is in
4549 // fullscreen mode.
[email protected]5cfbddc2014-06-23 23:52:234550 if (navigation_is_within_page) {
[email protected]dfc39cb2014-04-09 22:58:194551 // No page change? Then, the renderer and browser can remain in fullscreen.
[email protected]0d0f4c492014-04-02 06:42:574552 return;
4553 }
alexmos5dd617d2016-06-07 04:21:154554 if (IsFullscreenForCurrentTab())
bokanece34a82016-01-28 19:49:464555 ExitFullscreen(false);
alexmos5dd617d2016-06-07 04:21:154556 DCHECK(!IsFullscreenForCurrentTab());
Joe Downingc1a57efe2018-05-09 18:23:544557
4558 // Clean up keyboard lock state when navigating.
4559 CancelKeyboardLock(keyboard_lock_widget_);
[email protected]0d0f4c492014-04-02 06:42:574560}
4561
[email protected]37567b432014-02-12 01:12:224562void WebContentsImpl::DidNavigateMainFramePostCommit(
sky8b00392d2015-01-10 00:30:284563 RenderFrameHostImpl* render_frame_host,
[email protected]37567b432014-02-12 01:12:224564 const LoadCommittedDetails& details,
4565 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
4566 if (details.is_navigation_to_different_page()) {
4567 // Clear the status bubble. This is a workaround for a bug where WebKit
4568 // doesn't let us know that the cursor left an element during a
4569 // transition (this is also why the mouse cursor remains as a hand after
4570 // clicking on a link); see bugs 1184641 and 980803. We don't want to
4571 // clear the bubble when a user navigates to a named anchor in the same
4572 // page.
Lukasz Anforowiczfd707142018-02-07 19:46:134573 ClearTargetURL();
lanwei9d343ad22015-02-11 01:46:004574
4575 RenderWidgetHostViewBase* rwhvb =
4576 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
4577 if (rwhvb)
4578 rwhvb->OnDidNavigateMainFrameToNewPage();
[email protected]37567b432014-02-12 01:12:224579 }
4580
[email protected]e85165c642014-06-10 14:34:314581 if (delegate_)
[email protected]37567b432014-02-12 01:12:224582 delegate_->DidNavigateMainFramePostCommit(this);
[email protected]e85165c642014-06-10 14:34:314583 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
Shivani Sharma985474f2019-05-23 21:36:474584
4585 if (!details.is_same_document && GetInnerWebContents().empty())
4586 had_inner_webcontents_ = false;
Carlos Caballero91fffb22019-10-29 15:24:304587
4588 if (details.is_navigation_to_different_page() &&
4589 GetRenderViewHost()->did_first_visually_non_empty_paint()) {
4590 // This event will not fire again if the page is restored from the
4591 // BackForwardCache. So fire it ourselves if needed.
4592 DidFirstVisuallyNonEmptyPaint(GetRenderViewHost());
4593 }
Carlos Caballero1215f882019-10-29 15:58:434594
4595 if (GetRenderViewHost()->theme_color() != last_sent_theme_color_) {
4596 // This event will not fire again if the page is restored from the
4597 // BackForwardCache. So fire it ourselves if needed.
4598 OnThemeColorChanged(GetRenderViewHost());
4599 }
[email protected]37567b432014-02-12 01:12:224600}
4601
4602void WebContentsImpl::DidNavigateAnyFramePostCommit(
4603 RenderFrameHostImpl* render_frame_host,
4604 const LoadCommittedDetails& details,
4605 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
[email protected]b4c84012014-04-28 19:51:104606 // Now that something has committed, we don't need to track whether the
4607 // initial page has been accessed.
4608 has_accessed_initial_document_ = false;
4609
[email protected]37567b432014-02-12 01:12:224610 // If we navigate off the page, close all JavaScript dialogs.
eugenebutee08663a2017-04-27 17:43:124611 if (!details.is_same_document)
creis89a0f782015-05-27 16:13:174612 CancelActiveAndPendingDialogs();
[email protected]37567b432014-02-12 01:12:224613
avid53461d2016-02-25 17:15:044614 // If this is a user-initiated navigation, start allowing JavaScript dialogs
4615 // again.
avi5d3b8692016-10-12 22:00:464616 if (params.gesture == NavigationGestureUser && dialog_manager_) {
avi6879fcf2017-01-21 05:27:534617 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:464618 }
[email protected]37567b432014-02-12 01:12:224619}
4620
4621void WebContentsImpl::SetMainFrameMimeType(const std::string& mime_type) {
4622 contents_mime_type_ = mime_type;
4623}
4624
[email protected]277857a2014-06-03 10:38:014625bool WebContentsImpl::CanOverscrollContent() const {
[email protected]e85165c642014-06-10 14:34:314626 // Disable overscroll when touch emulation is on. See crbug.com/369938.
[email protected]34ff1cfc2014-08-20 06:16:054627 if (force_disable_overscroll_content_)
[email protected]e85165c642014-06-10 14:34:314628 return false;
4629
[email protected]37567b432014-02-12 01:12:224630 if (delegate_)
4631 return delegate_->CanOverscrollContent();
4632
4633 return false;
4634}
4635
Carlos Caballero1215f882019-10-29 15:58:434636void WebContentsImpl::OnThemeColorChanged(RenderViewHostImpl* source) {
4637 if (source->did_first_visually_non_empty_paint() &&
4638 last_sent_theme_color_ != source->theme_color()) {
ericwilligersde386342016-10-19 02:35:094639 for (auto& observer : observers_)
Carlos Caballero1215f882019-10-29 15:58:434640 observer.DidChangeThemeColor(source->theme_color());
4641 last_sent_theme_color_ = source->theme_color();
peter90afaba2015-06-01 12:05:294642 }
[email protected]e7104762014-06-20 19:17:254643}
4644
[email protected]b172aee2012-04-10 17:05:264645void WebContentsImpl::OnDidLoadResourceFromMemoryCache(
nicka0ac8382016-12-15 23:59:234646 RenderFrameHostImpl* source,
[email protected]724159a2010-12-30 01:11:184647 const GURL& url,
[email protected]70435962011-08-02 20:13:284648 const std::string& http_method,
[email protected]6d6cfb3a2012-05-23 22:53:184649 const std::string& mime_type,
[email protected]6c1e05212014-07-31 00:59:404650 ResourceType resource_type) {
ericwilligersde386342016-10-19 02:35:094651 for (auto& observer : observers_)
4652 observer.DidLoadResourceFromMemoryCache(url, mime_type, resource_type);
[email protected]b0f724c2013-09-05 04:21:134653
Steven Bingler674fb0822018-12-12 18:04:524654 if (url.is_valid() && url.SchemeIsHTTPOrHTTPS()) {
nicka0ac8382016-12-15 23:59:234655 StoragePartition* partition = source->GetProcess()->GetStoragePartition();
John Abd-El-Malekf4fe9d82019-07-31 04:05:594656 partition->GetNetworkContext()->NotifyExternalCacheHit(
Alex Turner48442b542019-08-21 14:01:144657 url, http_method, source->network_isolation_key());
[email protected]8bfc8272013-09-09 20:10:534658 }
[email protected]724159a2010-12-30 01:11:184659}
4660
carloskd9d97942017-02-16 08:58:094661void WebContentsImpl::DidDisplayInsecureContent() {
estarkc2273502016-10-12 22:03:024662 controller_.ssl_manager()->DidDisplayMixedContent();
[email protected]724159a2010-12-30 01:11:184663}
4664
Dave Tapuskaa657d872019-10-21 20:23:214665void WebContentsImpl::DidContainInsecureFormAction() {
elawrenceb2ac2a232017-03-27 21:46:254666 controller_.ssl_manager()->DidContainInsecureFormAction();
4667}
4668
nicka0ac8382016-12-15 23:59:234669void WebContentsImpl::OnDidRunInsecureContent(RenderFrameHostImpl* source,
4670 const GURL& security_origin,
estark910b4572015-12-09 20:55:414671 const GURL& target_url) {
nicka0ac8382016-12-15 23:59:234672 // TODO(nick, estark): Should we call FilterURL using |source|'s process on
4673 // these parameters? |target_url| seems unused, except for a log message. And
4674 // |security_origin| might be replaceable with the origin of the main frame.
carloskd9d97942017-02-16 08:58:094675 DidRunInsecureContent(security_origin, target_url);
4676}
4677
4678void WebContentsImpl::DidRunInsecureContent(const GURL& security_origin,
4679 const GURL& target_url) {
[email protected]9450c462013-11-23 01:22:584680 LOG(WARNING) << security_origin << " ran insecure content from "
4681 << target_url.possibly_invalid_spec();
[email protected]e6e30ac2014-01-13 21:24:394682 RecordAction(base::UserMetricsAction("SSL.RanInsecureContent"));
estark910b4572015-12-09 20:55:414683 if (base::EndsWith(security_origin.spec(), kDotGoogleDotCom,
brettwa7ff1b292015-07-16 17:49:294684 base::CompareCase::INSENSITIVE_ASCII))
[email protected]e6e30ac2014-01-13 21:24:394685 RecordAction(base::UserMetricsAction("SSL.RanInsecureContentGoogle"));
estarkc2273502016-10-12 22:03:024686 controller_.ssl_manager()->DidRunMixedContent(security_origin);
[email protected]724159a2010-12-30 01:11:184687}
4688
carloskd9d97942017-02-16 08:58:094689void WebContentsImpl::PassiveInsecureContentFound(const GURL& resource_url) {
Sergey Kuznetsov3ebc01b2018-02-01 04:57:364690 if (delegate_) {
4691 delegate_->PassiveInsecureContentFound(resource_url);
4692 }
carloskd9d97942017-02-16 08:58:094693}
4694
4695bool WebContentsImpl::ShouldAllowRunningInsecureContent(
4696 WebContents* web_contents,
4697 bool allowed_per_prefs,
4698 const url::Origin& origin,
4699 const GURL& resource_url) {
Sergey Kuznetsov3ebc01b2018-02-01 04:57:364700 if (delegate_) {
4701 return delegate_->ShouldAllowRunningInsecureContent(
4702 web_contents, allowed_per_prefs, origin, resource_url);
4703 }
4704
4705 return allowed_per_prefs;
carloskd9d97942017-02-16 08:58:094706}
4707
Lukasz Anforowicze1b954d92017-10-30 21:28:064708void WebContentsImpl::ViewSource(RenderFrameHostImpl* frame) {
4709 DCHECK_EQ(this, WebContents::FromRenderFrameHost(frame));
4710
4711 // Don't do anything if there is no |delegate_| that could accept and show the
4712 // new WebContents containing the view-source.
4713 if (!delegate_)
4714 return;
4715
4716 // Use the last committed entry, since the pending entry hasn't loaded yet and
4717 // won't be copied into the cloned tab.
4718 NavigationEntryImpl* last_committed_entry =
4719 static_cast<NavigationEntryImpl*>(frame->frame_tree_node()
4720 ->navigator()
4721 ->GetController()
4722 ->GetLastCommittedEntry());
4723 if (!last_committed_entry)
4724 return;
4725
4726 FrameNavigationEntry* frame_entry =
4727 last_committed_entry->GetFrameEntry(frame->frame_tree_node());
4728 if (!frame_entry)
4729 return;
4730
4731 // Any new WebContents opened while this WebContents is in fullscreen can be
4732 // used to confuse the user, so drop fullscreen.
Avi Drissmand18c51972018-08-15 18:32:094733 ForSecurityDropFullscreen();
Lukasz Anforowicze1b954d92017-10-30 21:28:064734
4735 // We intentionally don't share the SiteInstance with the original frame so
4736 // that view source has a consistent process model and always ends up in a new
4737 // process (https://crbug.com/699493).
4738 scoped_refptr<SiteInstanceImpl> site_instance_for_view_source = nullptr;
Lukasz Anforowicz435bcb582019-07-12 20:50:064739 // Referrer and initiator are not important, because view-source should not
4740 // hit the network, but should be served from the cache instead.
Lukasz Anforowicze1b954d92017-10-30 21:28:064741 Referrer referrer_for_view_source;
Lukasz Anforowicz435bcb582019-07-12 20:50:064742 base::Optional<url::Origin> initiator_for_view_source = base::nullopt;
Lukasz Anforowicze1b954d92017-10-30 21:28:064743 // Do not restore title, derive it from the url.
4744 base::string16 title_for_view_source;
4745 auto navigation_entry = std::make_unique<NavigationEntryImpl>(
4746 site_instance_for_view_source, frame_entry->url(),
Lukasz Anforowicz435bcb582019-07-12 20:50:064747 referrer_for_view_source, initiator_for_view_source,
4748 title_for_view_source, ui::PAGE_TRANSITION_LINK,
Marijn Kruisselbrink7a0d5e182018-05-24 22:55:094749 /* is_renderer_initiated = */ false,
4750 /* blob_url_loader_factory = */ nullptr);
Lukasz Anforowicze1b954d92017-10-30 21:28:064751 navigation_entry->SetVirtualURL(GURL(content::kViewSourceScheme +
4752 std::string(":") +
4753 frame_entry->url().spec()));
4754
Yao Xiaof68f57d2019-10-03 04:20:054755 navigation_entry->set_network_isolation_key(
4756 net::NetworkIsolationKey(GetMainFrame()->GetLastCommittedOrigin(),
4757 frame->GetLastCommittedOrigin()));
4758
Lukasz Anforowicze1b954d92017-10-30 21:28:064759 // Do not restore scroller position.
4760 // TODO(creis, lukasza, arthursonzogni): Do not reuse the original PageState,
4761 // but start from a new one and only copy the needed data.
4762 const PageState& new_page_state =
4763 frame_entry->page_state().RemoveScrollOffset();
4764
4765 scoped_refptr<FrameNavigationEntry> new_frame_entry =
4766 navigation_entry->root_node()->frame_entry;
4767 new_frame_entry->set_method(frame_entry->method());
4768 new_frame_entry->SetPageState(new_page_state);
4769
4770 // Create a new WebContents, which is used to display the source code.
erikchenbee5c9622018-04-27 19:30:254771 std::unique_ptr<WebContents> view_source_contents =
Erik Chenbb8e738e2018-04-28 14:10:434772 Create(CreateParams(GetBrowserContext()));
Lukasz Anforowicze1b954d92017-10-30 21:28:064773
4774 // Restore the previously created NavigationEntry.
4775 std::vector<std::unique_ptr<NavigationEntry>> navigation_entries;
4776 navigation_entries.push_back(std::move(navigation_entry));
4777 view_source_contents->GetController().Restore(0, RestoreType::CURRENT_SESSION,
4778 &navigation_entries);
4779
4780 // Add |view_source_contents| as a new tab.
4781 gfx::Rect initial_rect;
4782 constexpr bool kUserGesture = true;
4783 bool ignored_was_blocked;
erikchenbee5c9622018-04-27 19:30:254784 delegate_->AddNewContents(this, std::move(view_source_contents),
Lukasz Anforowicze1b954d92017-10-30 21:28:064785 WindowOpenDisposition::NEW_FOREGROUND_TAB,
4786 initial_rect, kUserGesture, &ignored_was_blocked);
4787 // Note that the |delegate_| could have deleted |view_source_contents| during
4788 // AddNewContents method call.
4789}
4790
Jay Civellid5904f02018-03-23 19:43:574791void WebContentsImpl::SubresourceResponseStarted(const GURL& url,
4792 net::CertStatus cert_status) {
4793 controller_.ssl_manager()->DidStartResourceResponse(url, cert_status);
4794 SetNotWaitingForResponse();
4795}
4796
Jay Civelli116683f2018-03-27 19:56:234797void WebContentsImpl::ResourceLoadComplete(
Jay Civelli52a63302018-04-30 22:39:554798 RenderFrameHost* render_frame_host,
Clark DuVall36164bd2018-08-09 22:49:084799 const GlobalRequestID& request_id,
Jay Civelli116683f2018-03-27 19:56:234800 mojom::ResourceLoadInfoPtr resource_load_info) {
John Abd-El-Malek9b8f7fa2017-12-04 23:52:254801 for (auto& observer : observers_) {
Clark DuVall36164bd2018-08-09 22:49:084802 observer.ResourceLoadComplete(render_frame_host, request_id,
4803 *resource_load_info);
John Abd-El-Malek9b8f7fa2017-12-04 23:52:254804 }
John Abd-El-Malekd4882642017-12-04 21:45:194805}
4806
Wei Li5bb659742018-02-14 03:07:584807void WebContentsImpl::PrintCrossProcessSubframe(
4808 const gfx::Rect& rect,
4809 int document_cookie,
4810 RenderFrameHost* subframe_host) {
Wei Li5c0b4d12018-03-22 15:05:224811 auto* outer_contents = GetOuterWebContents();
4812 if (outer_contents) {
4813 // When an extension or app page is printed, the content should be
4814 // composited with outer content, so the outer contents should handle the
4815 // print request.
4816 outer_contents->PrintCrossProcessSubframe(rect, document_cookie,
4817 subframe_host);
4818 return;
4819 }
4820
Wei Li5bb659742018-02-14 03:07:584821 // If there is no delegate such as in tests or during deletion, do nothing.
4822 if (!delegate_)
4823 return;
4824
4825 delegate_->PrintCrossProcessSubframe(this, rect, document_cookie,
4826 subframe_host);
4827}
4828
rob.buis300b0872017-03-10 20:43:584829#if defined(OS_ANDROID)
4830base::android::ScopedJavaLocalRef<jobject>
4831WebContentsImpl::GetJavaRenderFrameHostDelegate() {
4832 return GetJavaWebContents();
4833}
4834#endif
4835
estark910b4572015-12-09 20:55:414836void WebContentsImpl::OnDidDisplayContentWithCertificateErrors(
Zhuoyu Qian4353f7f2018-01-08 05:33:004837 RenderFrameHostImpl* source) {
estarkc2273502016-10-12 22:03:024838 controller_.ssl_manager()->DidDisplayContentWithCertErrors();
estark910b4572015-12-09 20:55:414839}
4840
4841void WebContentsImpl::OnDidRunContentWithCertificateErrors(
Zhuoyu Qian4353f7f2018-01-08 05:33:004842 RenderFrameHostImpl* source) {
nicka0ac8382016-12-15 23:59:234843 // TODO(nick, estark): Do we need to consider |source| here somehow?
estarkcd2e30c2016-08-12 06:51:154844 NavigationEntry* entry = controller_.GetVisibleEntry();
4845 if (!entry)
estarkaeda1422016-05-10 02:31:124846 return;
4847
estarkaeda1422016-05-10 02:31:124848 // TODO(estark): check that this does something reasonable for
4849 // about:blank and sandboxed origins. https://crbug.com/609527
estarkcd2e30c2016-08-12 06:51:154850 controller_.ssl_manager()->DidRunContentWithCertErrors(
4851 entry->GetURL().GetOrigin());
estark910b4572015-12-09 20:55:414852}
4853
Kouhei Ueno97e0990d2019-09-25 02:57:274854void WebContentsImpl::DOMContentLoaded(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:094855 for (auto& observer : observers_)
Kouhei Uenof6e96242019-09-27 01:54:354856 observer.DOMContentLoaded(render_frame_host);
[email protected]724159a2010-12-30 01:11:184857}
4858
nicka0ac8382016-12-15 23:59:234859void WebContentsImpl::OnDidFinishLoad(RenderFrameHostImpl* source,
4860 const GURL& url) {
[email protected]8b3af1e2014-01-24 13:29:124861 GURL validated_url(url);
nicka0ac8382016-12-15 23:59:234862 source->GetProcess()->FilterURL(false, &validated_url);
[email protected]028053d42014-03-05 22:20:374863
ericwilligersde386342016-10-19 02:35:094864 for (auto& observer : observers_)
nicka0ac8382016-12-15 23:59:234865 observer.DidFinishLoad(source, validated_url);
yilkal172da772019-11-06 22:49:074866
4867 size_t tree_size = frame_tree_.root()->GetFrameTreeSize();
4868 if (max_loaded_frame_count_ < tree_size)
4869 max_loaded_frame_count_ = tree_size;
4870
4871 if (!source->GetParent())
4872 UMA_HISTOGRAM_COUNTS_1000("Navigation.MainFrame.FrameCount", tree_size);
[email protected]1a55c5be2011-11-29 11:36:314873}
4874
Dave Tapuska549baab2019-03-19 15:52:404875void WebContentsImpl::OnGoToEntryAtOffset(RenderFrameHostImpl* source,
Arthur Sonzognia7d715a2018-09-20 16:11:134876 int offset,
Dave Tapuska043b94a2019-09-10 14:14:354877 bool has_user_gesture) {
Arthur Sonzognia7d715a2018-09-20 16:11:134878 // Non-user initiated navigations coming from the renderer should be ignored
4879 // if there is an ongoing browser-initiated navigation.
4880 // See https://crbug.com/879965.
4881 // TODO(arthursonzogni): See if this should check for ongoing navigations in
4882 // the frame(s) affected by the session history navigation, rather than just
4883 // the main frame.
4884 if (!has_user_gesture) {
4885 NavigationRequest* ongoing_navigation_request =
4886 frame_tree_.root()->navigation_request();
4887 if (ongoing_navigation_request &&
4888 ongoing_navigation_request->browser_initiated()) {
4889 return;
4890 }
4891 }
4892
nicka0ac8382016-12-15 23:59:234893 // All frames are allowed to navigate the global history.
Dave Tapuska8bfd84c2019-03-26 20:47:164894 if (!delegate_ || delegate_->OnGoToEntryOffset(offset)) {
Dave Tapuska043b94a2019-09-10 14:14:354895 if (source->IsSandboxed(blink::WebSandboxFlags::kTopNavigation)) {
Dave Tapuska8bfd84c2019-03-26 20:47:164896 // Keep track of whether this is a session history from a sandboxed iframe
4897 // with top level navigation disallowed.
4898 controller_.GoToOffsetInSandboxedFrame(offset,
4899 source->GetFrameTreeNodeId());
4900 } else {
4901 controller_.GoToOffset(offset);
4902 }
4903 }
[email protected]216813952011-05-19 22:21:264904}
4905
nicka0ac8382016-12-15 23:59:234906void WebContentsImpl::OnPageScaleFactorChanged(RenderViewHostImpl* source,
4907 float page_scale_factor) {
mcnee336ea2c2017-05-23 22:50:594908#if !defined(OS_ANDROID)
4909 // While page scale factor is used on mobile, this PageScaleFactorIsOne logic
4910 // is only needed on desktop.
mcnee432e47d2015-11-09 19:37:464911 bool is_one = page_scale_factor == 1.f;
4912 if (is_one != page_scale_factor_is_one_) {
4913 page_scale_factor_is_one_ = is_one;
4914
4915 HostZoomMapImpl* host_zoom_map =
4916 static_cast<HostZoomMapImpl*>(HostZoomMap::GetForWebContents(this));
4917
nicka0ac8382016-12-15 23:59:234918 if (host_zoom_map) {
mcnee432e47d2015-11-09 19:37:464919 host_zoom_map->SetPageScaleFactorIsOneForView(
nicka0ac8382016-12-15 23:59:234920 source->GetProcess()->GetID(), source->GetRoutingID(),
mcnee432e47d2015-11-09 19:37:464921 page_scale_factor_is_one_);
4922 }
4923 }
mcnee336ea2c2017-05-23 22:50:594924#endif // !defined(OS_ANDROID)
mcnee432e47d2015-11-09 19:37:464925
ericwilligersde386342016-10-19 02:35:094926 for (auto& observer : observers_)
4927 observer.OnPageScaleFactorChanged(page_scale_factor);
mcnee432e47d2015-11-09 19:37:464928}
4929
W. James MacLean62198672019-06-04 16:46:104930void WebContentsImpl::OnTextAutosizerPageInfoChanged(
4931 RenderViewHostImpl* source,
4932 const blink::WebTextAutosizerPageInfo& page_info) {
4933 // Keep a copy of |page_info| in case we create a new RenderView before
4934 // the next update.
4935 text_autosizer_page_info_ = page_info;
4936 frame_tree_.root()->render_manager()->SendPageMessage(
4937 new PageMsg_UpdateTextAutosizerPageInfoForRemoteMainFrames(
4938 MSG_ROUTING_NONE, page_info),
4939 source->GetSiteInstance());
4940}
4941
Kent Tamura8c9e0562018-11-06 07:02:194942void WebContentsImpl::EnumerateDirectory(
4943 RenderFrameHost* render_frame_host,
4944 std::unique_ptr<FileSelectListener> listener,
4945 const base::FilePath& directory_path) {
4946 if (delegate_)
4947 delegate_->EnumerateDirectory(this, std::move(listener), directory_path);
4948 else
4949 listener->FileSelectionCanceled();
[email protected]3a29a6e2011-08-24 18:26:214950}
4951
Dave Tapuskaf9fc3122019-10-18 19:42:554952void WebContentsImpl::RegisterProtocolHandler(RenderFrameHostImpl* source,
4953 const std::string& protocol,
4954 const GURL& url,
4955 const base::string16& title,
4956 bool user_gesture) {
nicka0ac8382016-12-15 23:59:234957 // TODO(nick): Should we consider |source| here or pass it to the delegate?
4958 // TODO(nick): Do we need to apply FilterURL to |url|?
[email protected]e5f2de02012-07-20 22:15:434959 if (!delegate_)
4960 return;
4961
Raymes Khoury58373df2019-08-06 06:29:204962 if (!AreValidRegisterProtocolHandlerArguments(
4963 protocol, url, source->GetLastCommittedOrigin())) {
4964 ReceivedBadMessage(source->GetProcess(),
4965 bad_message::REGISTER_PROTOCOL_HANDLER_INVALID_URL);
[email protected]b9535422012-02-09 01:47:594966 return;
Raymes Khoury58373df2019-08-06 06:29:204967 }
[email protected]8f810632013-06-06 22:33:324968
[email protected]c125e532014-05-10 20:39:064969 delegate_->RegisterProtocolHandler(this, protocol, url, user_gesture);
[email protected]7d189022011-08-25 22:54:204970}
4971
Dave Tapuskaf9fc3122019-10-18 19:42:554972void WebContentsImpl::UnregisterProtocolHandler(RenderFrameHostImpl* source,
4973 const std::string& protocol,
4974 const GURL& url,
4975 bool user_gesture) {
nicka0ac8382016-12-15 23:59:234976 // TODO(nick): Should we consider |source| here or pass it to the delegate?
4977 // TODO(nick): Do we need to apply FilterURL to |url|?
[email protected]f5273e52014-07-14 16:30:204978 if (!delegate_)
4979 return;
4980
Raymes Khoury58373df2019-08-06 06:29:204981 if (!AreValidRegisterProtocolHandlerArguments(
4982 protocol, url, source->GetLastCommittedOrigin())) {
4983 ReceivedBadMessage(source->GetProcess(),
4984 bad_message::REGISTER_PROTOCOL_HANDLER_INVALID_URL);
[email protected]f5273e52014-07-14 16:30:204985 return;
Raymes Khoury58373df2019-08-06 06:29:204986 }
[email protected]f5273e52014-07-14 16:30:204987
4988 delegate_->UnregisterProtocolHandler(this, protocol, url, user_gesture);
4989}
4990
kouhei40f03cb2015-09-24 07:47:014991void WebContentsImpl::OnUpdatePageImportanceSignals(
nicka0ac8382016-12-15 23:59:234992 RenderFrameHostImpl* source,
kouhei40f03cb2015-09-24 07:47:014993 const PageImportanceSignals& signals) {
nicka0ac8382016-12-15 23:59:234994 // TODO(nick, kouhei): Fix this for oopifs; currently all frames' state gets
4995 // written to this one field.
kouhei40f03cb2015-09-24 07:47:014996 page_importance_signals_ = signals;
4997}
4998
nicka0ac8382016-12-15 23:59:234999void WebContentsImpl::OnDomOperationResponse(RenderFrameHostImpl* source,
5000 const std::string& json_string) {
5001 // TODO(nick, lukasza): The notification below should probably be updated to
5002 // include |source|.
avi60bd4902015-09-23 20:39:245003 std::string json = json_string;
5004 NotificationService::current()->Notify(NOTIFICATION_DOM_OPERATION_RESPONSE,
5005 Source<WebContents>(this),
5006 Details<std::string>(&json));
[email protected]cfa856d62014-02-22 07:58:405007}
5008
Marijn Kruisselbrink7f519672019-02-05 19:12:505009void WebContentsImpl::OnAppCacheAccessed(const GURL& manifest_url,
[email protected]b172aee2012-04-10 17:05:265010 bool blocked_by_policy) {
nicka0ac8382016-12-15 23:59:235011 // TODO(nick): Should we consider |source| here? Should we call FilterURL on
5012 // |manifest_url|?
5013
[email protected]7fc4bbb2011-09-08 21:23:105014 // Notify observers about navigation.
ericwilligersde386342016-10-19 02:35:095015 for (auto& observer : observers_)
5016 observer.AppCacheAccessed(manifest_url, blocked_by_policy);
[email protected]7fc4bbb2011-09-08 21:23:105017}
5018
Miyoung Shincb6475a2019-11-09 10:49:455019void WebContentsImpl::OnColorChooserFactoryReceiver(
Julie Jeongeun Kim8e2879e2019-08-06 23:55:205020 mojo::PendingReceiver<blink::mojom::ColorChooserFactory> receiver) {
5021 color_chooser_factory_receivers_.Add(this, std::move(receiver));
Joel Hockey85b379d2017-12-11 10:42:135022}
5023
5024void WebContentsImpl::OpenColorChooser(
Julie Jeongeun Kim8e2879e2019-08-06 23:55:205025 mojo::PendingReceiver<blink::mojom::ColorChooser> chooser_receiver,
5026 mojo::PendingRemote<blink::mojom::ColorChooserClient> client,
[email protected]8ed16472014-04-11 19:02:485027 SkColor color,
Joel Hockey163835a2017-12-20 11:51:575028 std::vector<blink::mojom::ColorSuggestionPtr> suggestions) {
Joel Hockey85b379d2017-12-11 10:42:135029 content::ColorChooser* new_color_chooser =
Ivan Kotenkov2c0d2bb32017-11-01 15:41:285030 delegate_ ? delegate_->OpenColorChooser(this, color, suggestions)
5031 : nullptr;
[email protected]820957a2014-01-14 14:56:305032 if (!new_color_chooser)
[email protected]cb805452013-05-22 15:16:215033 return;
[email protected]8ed16472014-04-11 19:02:485034
Joel Hockey85b379d2017-12-11 10:42:135035 color_chooser_.reset();
5036 color_chooser_ = std::make_unique<ColorChooser>(
Julie Jeongeun Kim8e2879e2019-08-06 23:55:205037 new_color_chooser, std::move(chooser_receiver), std::move(client));
[email protected]da8543762012-03-20 08:52:205038}
5039
brettw4b461082016-11-19 18:55:165040#if BUILDFLAG(ENABLE_PLUGINS)
nicka0ac8382016-12-15 23:59:235041void WebContentsImpl::OnPepperInstanceCreated(RenderFrameHostImpl* source,
5042 int32_t pp_instance) {
ericwilligersde386342016-10-19 02:35:095043 for (auto& observer : observers_)
5044 observer.PepperInstanceCreated();
nicka0ac8382016-12-15 23:59:235045 pepper_playback_observer_->PepperInstanceCreated(source, pp_instance);
emaxxe70f5e12015-05-29 11:26:005046}
5047
nicka0ac8382016-12-15 23:59:235048void WebContentsImpl::OnPepperInstanceDeleted(RenderFrameHostImpl* source,
5049 int32_t pp_instance) {
ericwilligersde386342016-10-19 02:35:095050 for (auto& observer : observers_)
5051 observer.PepperInstanceDeleted();
nicka0ac8382016-12-15 23:59:235052 pepper_playback_observer_->PepperInstanceDeleted(source, pp_instance);
emaxxe70f5e12015-05-29 11:26:005053}
5054
nicka0ac8382016-12-15 23:59:235055void WebContentsImpl::OnPepperPluginHung(RenderFrameHostImpl* source,
5056 int plugin_child_id,
tommyclie6633ca72014-10-31 00:40:425057 const base::FilePath& path,
5058 bool is_hung) {
Steven Holte95922222018-09-14 20:06:235059 UMA_HISTOGRAM_COUNTS_1M("Pepper.PluginHung", 1);
tommyclie6633ca72014-10-31 00:40:425060
ericwilligersde386342016-10-19 02:35:095061 for (auto& observer : observers_)
5062 observer.PluginHungStatusChanged(plugin_child_id, path, is_hung);
tommyclie6633ca72014-10-31 00:40:425063}
5064
nicka0ac8382016-12-15 23:59:235065void WebContentsImpl::OnPepperStartsPlayback(RenderFrameHostImpl* source,
5066 int32_t pp_instance) {
5067 pepper_playback_observer_->PepperStartsPlayback(source, pp_instance);
zqzhang181047e62016-07-01 13:37:175068}
5069
nicka0ac8382016-12-15 23:59:235070void WebContentsImpl::OnPepperStopsPlayback(RenderFrameHostImpl* source,
5071 int32_t pp_instance) {
5072 pepper_playback_observer_->PepperStopsPlayback(source, pp_instance);
zqzhang181047e62016-07-01 13:37:175073}
5074
nicka0ac8382016-12-15 23:59:235075void WebContentsImpl::OnPluginCrashed(RenderFrameHostImpl* source,
5076 const base::FilePath& plugin_path,
tommyclie6633ca72014-10-31 00:40:425077 base::ProcessId plugin_pid) {
nicka0ac8382016-12-15 23:59:235078 // TODO(nick): Eliminate the |plugin_pid| parameter, which can't be trusted,
5079 // and is only used by BlinkTestController.
ericwilligersde386342016-10-19 02:35:095080 for (auto& observer : observers_)
5081 observer.PluginCrashed(plugin_path, plugin_pid);
tommyclie6633ca72014-10-31 00:40:425082}
5083
[email protected]d8415ad92012-08-23 14:40:505084void WebContentsImpl::OnRequestPpapiBrokerPermission(
nicka0ac8382016-12-15 23:59:235085 RenderViewHostImpl* source,
5086 int ppb_broker_route_id,
[email protected]d8415ad92012-08-23 14:40:505087 const GURL& url,
[email protected]2dec8ec2013-02-07 19:20:345088 const base::FilePath& plugin_path) {
Avi Drissman0a2a967d2019-04-01 19:33:525089 base::OnceCallback<void(bool)> permission_result_callback = base::BindOnce(
nicka0ac8382016-12-15 23:59:235090 &WebContentsImpl::SendPpapiBrokerPermissionResult, base::Unretained(this),
5091 source->GetProcess()->GetID(), ppb_broker_route_id);
[email protected]8c8fc292012-11-23 18:57:165092 if (!delegate_) {
Tommy Nyquist4b749d02018-03-20 21:46:295093 std::move(permission_result_callback).Run(false);
[email protected]8c8fc292012-11-23 18:57:165094 return;
[email protected]d8415ad92012-08-23 14:40:505095 }
5096
Avi Drissman0a2a967d2019-04-01 19:33:525097 delegate_->RequestPpapiBrokerPermission(
5098 this, url, plugin_path, std::move(permission_result_callback));
[email protected]d8415ad92012-08-23 14:40:505099}
5100
nicka0ac8382016-12-15 23:59:235101void WebContentsImpl::SendPpapiBrokerPermissionResult(int process_id,
5102 int ppb_broker_route_id,
5103 bool result) {
5104 RenderProcessHost* rph = RenderProcessHost::FromID(process_id);
5105 if (rph) {
5106 // TODO(nick): Convert this from ViewMsg_ to a Ppapi msg, since it
5107 // is not routed to a RenderView.
5108 rph->Send(
5109 new ViewMsg_PpapiBrokerPermissionResult(ppb_broker_route_id, result));
5110 }
[email protected]d8415ad92012-08-23 14:40:505111}
5112
fsamuel833ee7c2015-02-13 23:40:405113void WebContentsImpl::OnBrowserPluginMessage(RenderFrameHost* render_frame_host,
5114 const IPC::Message& message) {
Lei Zhang6410ec1a2019-01-31 21:38:585115 CHECK(!browser_plugin_embedder_);
fsamuel60b42282015-03-10 03:29:145116 CreateBrowserPluginEmbedderIfNecessary();
fsamuel833ee7c2015-02-13 23:40:405117 browser_plugin_embedder_->OnMessageReceived(message, render_frame_host);
[email protected]19be7a62012-10-01 23:03:375118}
brettw4b461082016-11-19 18:55:165119#endif // BUILDFLAG(ENABLE_PLUGINS)
[email protected]19be7a62012-10-01 23:03:375120
[email protected]795c28972012-12-06 06:13:395121void WebContentsImpl::OnUpdateFaviconURL(
lukasza178ff092017-06-07 23:39:505122 RenderFrameHostImpl* source,
[email protected]795c28972012-12-06 06:13:395123 const std::vector<FaviconURL>& candidates) {
lukasza178ff092017-06-07 23:39:505124 // Ignore favicons for non-main frame.
5125 if (source->GetParent()) {
5126 NOTREACHED();
5127 return;
5128 }
5129
pkotwiczf9bc20592015-04-21 18:57:065130 // We get updated favicon URLs after the page stops loading. If a cross-site
5131 // navigation occurs while a page is still loading, the initial page
5132 // may stop loading and send us updated favicon URLs after the navigation
5133 // for the new page has committed.
lukasza178ff092017-06-07 23:39:505134 if (!source->IsCurrent())
pkotwiczf9bc20592015-04-21 18:57:065135 return;
5136
ericwilligersde386342016-10-19 02:35:095137 for (auto& observer : observers_)
5138 observer.DidUpdateFaviconURL(candidates);
[email protected]795c28972012-12-06 06:13:395139}
5140
qinmin72e8bd02016-10-21 19:35:375141void WebContentsImpl::SetIsOverlayContent(bool is_overlay_content) {
5142 is_overlay_content_ = is_overlay_content;
5143}
5144
Albert J. Wongfb64e142018-10-16 01:10:455145void WebContentsImpl::DidFirstVisuallyNonEmptyPaint(
5146 RenderViewHostImpl* source) {
nicka0ac8382016-12-15 23:59:235147 // TODO(nick): When this is ported to FrameHostMsg_, we should only listen if
5148 // |source| is the main frame.
ericwilligersde386342016-10-19 02:35:095149 for (auto& observer : observers_)
5150 observer.DidFirstVisuallyNonEmptyPaint();
yusufod41c5f92015-03-06 00:14:285151
Carlos Caballero1215f882019-10-29 15:58:435152 if (source->theme_color() != last_sent_theme_color_) {
yusufod41c5f92015-03-06 00:14:285153 // Theme color should have updated by now if there was one.
ericwilligersde386342016-10-19 02:35:095154 for (auto& observer : observers_)
Carlos Caballero1215f882019-10-29 15:58:435155 observer.DidChangeThemeColor(source->theme_color());
5156 last_sent_theme_color_ = source->theme_color();
yusufod41c5f92015-03-06 00:14:285157 }
[email protected]9f268072013-11-07 00:02:155158}
[email protected]d9030b82013-07-19 08:26:065159
Adithya Srinivasan46b8a792019-02-01 14:47:235160bool WebContentsImpl::IsPortal() const {
5161 return portal();
5162}
5163
[email protected]17e286e2013-03-01 23:29:395164void WebContentsImpl::NotifyBeforeFormRepostWarningShow() {
ericwilligersde386342016-10-19 02:35:095165 for (auto& observer : observers_)
5166 observer.BeforeFormRepostWarningShow();
[email protected]17e286e2013-03-01 23:29:395167}
5168
[email protected]ec6c05f2013-10-23 18:41:575169void WebContentsImpl::ActivateAndShowRepostFormWarningDialog() {
5170 Activate();
5171 if (delegate_)
5172 delegate_->ShowRepostFormWarningDialog(this);
5173}
5174
[email protected]b4c84012014-04-28 19:51:105175bool WebContentsImpl::HasAccessedInitialDocument() {
5176 return has_accessed_initial_document_;
5177}
5178
afakhry6f0c1ec22016-07-14 13:55:135179void WebContentsImpl::UpdateTitleForEntry(NavigationEntry* entry,
[email protected]fcf75d42013-12-03 20:11:265180 const base::string16& title) {
[email protected]fcf75d42013-12-03 20:11:265181 base::string16 final_title;
Avi Drissman93002212017-09-27 03:20:525182 base::TrimWhitespace(title, base::TRIM_ALL, &final_title);
[email protected]420ae012009-04-24 05:16:325183
[email protected]987fc3a2011-05-26 14:18:095184 // If a page is created via window.open and never navigated,
5185 // there will be no navigation entry. In this situation,
[email protected]73eb2602012-02-09 19:50:555186 // |page_title_when_no_navigation_entry_| will be used for page title.
[email protected]987fc3a2011-05-26 14:18:095187 if (entry) {
[email protected]36fc0392011-12-25 03:59:515188 if (final_title == entry->GetTitle())
afakhry6f0c1ec22016-07-14 13:55:135189 return; // Nothing changed, don't bother.
[email protected]420ae012009-04-24 05:16:325190
[email protected]36fc0392011-12-25 03:59:515191 entry->SetTitle(final_title);
Avi Drissman93002212017-09-27 03:20:525192
5193 // The title for display may differ from the title just set; grab it.
5194 final_title = entry->GetTitleForDisplay();
[email protected]987fc3a2011-05-26 14:18:095195 } else {
5196 if (page_title_when_no_navigation_entry_ == final_title)
afakhry6f0c1ec22016-07-14 13:55:135197 return; // Nothing changed, don't bother.
[email protected]987fc3a2011-05-26 14:18:095198
5199 page_title_when_no_navigation_entry_ = final_title;
5200 }
[email protected]420ae012009-04-24 05:16:325201
[email protected]420ae012009-04-24 05:16:325202 // Lastly, set the title for the view.
[email protected]790e2fd2011-09-21 20:28:235203 view_->SetPageTitle(final_title);
[email protected]420ae012009-04-24 05:16:325204
ericwilligersde386342016-10-19 02:35:095205 for (auto& observer : observers_)
Avi Drissman93002212017-09-27 03:20:525206 observer.TitleWasSet(entry);
[email protected]66798902013-10-01 18:40:165207
afakhry6f0c1ec22016-07-14 13:55:135208 // Broadcast notifications when the UI should be updated.
5209 if (entry == controller_.GetEntryAtOffset(0))
5210 NotifyNavigationStateChanged(INVALIDATE_TYPE_TITLE);
[email protected]420ae012009-04-24 05:16:325211}
5212
fdegansa696e5112015-04-17 01:57:595213void WebContentsImpl::SendChangeLoadProgress() {
[email protected]960b0372014-05-19 18:01:005214 loading_last_progress_update_ = base::TimeTicks::Now();
Evan Stade9f328112019-10-23 20:49:255215 for (auto& observer : observers_)
5216 observer.LoadProgressChanged(frame_tree_.load_progress());
[email protected]960b0372014-05-19 18:01:005217}
5218
5219void WebContentsImpl::ResetLoadProgressState() {
fdegans1d16355162015-03-26 11:58:345220 frame_tree_.ResetLoadProgress();
[email protected]960b0372014-05-19 18:01:005221 loading_weak_factory_.InvalidateWeakPtrs();
5222 loading_last_progress_update_ = base::TimeTicks();
5223}
5224
clamy44e84ce2016-02-22 15:38:255225// Notifies the RenderWidgetHost instance about the fact that the page is
5226// loading, or done loading.
5227void WebContentsImpl::LoadingStateChanged(bool to_different_document,
5228 bool due_to_interstitial,
5229 LoadNotificationDetails* details) {
Nate Chapin22ea6592019-03-05 22:29:025230 if (is_being_destroyed_)
5231 return;
clamy44e84ce2016-02-22 15:38:255232 // Do not send notifications about loading changes in the FrameTree while the
5233 // interstitial page is pausing the throbber.
creisadca9862017-06-16 19:12:115234 if (ShowingInterstitialPage() && interstitial_page_->pause_throbber() &&
clamy44e84ce2016-02-22 15:38:255235 !due_to_interstitial) {
5236 return;
5237 }
5238
5239 bool is_loading = IsLoading();
5240
5241 if (!is_loading) {
5242 load_state_ = net::LoadStateWithParam(net::LOAD_STATE_IDLE,
5243 base::string16());
5244 load_state_host_.clear();
5245 upload_size_ = 0;
5246 upload_position_ = 0;
5247 }
5248
5249 GetRenderManager()->SetIsLoading(is_loading);
5250
5251 waiting_for_response_ = is_loading;
5252 is_load_to_different_document_ = to_different_document;
5253
5254 if (delegate_)
5255 delegate_->LoadingStateChanged(this, to_different_document);
5256 NotifyNavigationStateChanged(INVALIDATE_TYPE_LOAD);
5257
5258 std::string url = (details ? details->url.possibly_invalid_spec() : "NULL");
5259 if (is_loading) {
5260 TRACE_EVENT_ASYNC_BEGIN2("browser,navigation", "WebContentsImpl Loading",
5261 this, "URL", url, "Main FrameTreeNode id",
5262 GetFrameTree()->root()->frame_tree_node_id());
ericwilligersde386342016-10-19 02:35:095263 for (auto& observer : observers_)
5264 observer.DidStartLoading();
clamy44e84ce2016-02-22 15:38:255265 } else {
5266 TRACE_EVENT_ASYNC_END1("browser,navigation", "WebContentsImpl Loading",
5267 this, "URL", url);
ericwilligersde386342016-10-19 02:35:095268 for (auto& observer : observers_)
5269 observer.DidStopLoading();
clamy44e84ce2016-02-22 15:38:255270 }
5271
5272 // TODO(avi): Remove. http://crbug.com/170921
5273 int type = is_loading ? NOTIFICATION_LOAD_START : NOTIFICATION_LOAD_STOP;
5274 NotificationDetails det = NotificationService::NoDetails();
5275 if (details)
5276 det = Details<LoadNotificationDetails>(details);
5277 NotificationService::current()->Notify(
5278 type, Source<NavigationController>(&controller_), det);
5279}
5280
[email protected]02d7b6e2014-06-24 21:01:505281void WebContentsImpl::NotifyViewSwapped(RenderViewHost* old_host,
5282 RenderViewHost* new_host) {
[email protected]420ae012009-04-24 05:16:325283 // After sending out a swap notification, we need to send a disconnect
5284 // notification so that clients that pick up a pointer to |this| can NULL the
5285 // pointer. See Bug 1230284.
5286 notify_disconnection_ = true;
ericwilligersde386342016-10-19 02:35:095287 for (auto& observer : observers_)
5288 observer.RenderViewHostChanged(old_host, new_host);
[email protected]da7a7182013-09-06 08:11:115289
Jinsuk Kimdc5284c22018-07-11 02:22:065290 view_->RenderViewHostChanged(old_host, new_host);
5291
Lucas Furukawa Gadanif9ea4fc2018-08-03 23:57:135292 // If this is an inner WebContents that has swapped views, we need to reattach
5293 // it to its outer WebContents.
5294 if (node_.outer_web_contents())
5295 ReattachToOuterWebContentsFrame();
5296
[email protected]7a846df2012-09-20 19:17:395297 // Ensure that the associated embedder gets cleared after a RenderViewHost
5298 // gets swapped, so we don't reuse the same embedder next time a
5299 // RenderViewHost is attached to this WebContents.
5300 RemoveBrowserPluginEmbedder();
[email protected]420ae012009-04-24 05:16:325301}
5302
[email protected]02d7b6e2014-06-24 21:01:505303void WebContentsImpl::NotifyFrameSwapped(RenderFrameHost* old_host,
Jinsuk Kim895b2c52018-07-03 06:49:165304 RenderFrameHost* new_host,
5305 bool is_main_frame) {
Bo Liu168c8642017-08-28 18:26:025306#if defined(OS_ANDROID)
Bo Liu16dd7b8322018-05-02 21:19:505307 // Copy importance from |old_host| if |new_host| is a main frame.
5308 if (old_host && !new_host->GetParent()) {
Bo Liu7c6779e92017-08-16 02:02:285309 static_cast<RenderFrameHostImpl*>(new_host)
5310 ->GetRenderWidgetHost()
Bo Liu16dd7b8322018-05-02 21:19:505311 ->SetImportance(static_cast<RenderFrameHostImpl*>(old_host)
5312 ->GetRenderWidgetHost()
5313 ->importance());
Bo Liu7c6779e92017-08-16 02:02:285314 }
Bo Liu168c8642017-08-28 18:26:025315#endif
ericwilligersde386342016-10-19 02:35:095316 for (auto& observer : observers_)
5317 observer.RenderFrameHostChanged(old_host, new_host);
[email protected]02d7b6e2014-06-24 21:01:505318}
5319
[email protected]da7a7182013-09-06 08:11:115320// TODO(avi): Remove this entire function because this notification is already
5321// covered by two observer functions. http://crbug.com/170921
[email protected]b172aee2012-04-10 17:05:265322void WebContentsImpl::NotifyDisconnected() {
[email protected]420ae012009-04-24 05:16:325323 if (!notify_disconnection_)
5324 return;
5325
5326 notify_disconnection_ = false;
[email protected]8ff00d72012-10-23 19:12:215327 NotificationService::current()->Notify(
5328 NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
5329 Source<WebContents>(this),
5330 NotificationService::NoDetails());
[email protected]420ae012009-04-24 05:16:325331}
5332
[email protected]cbb1ef592013-06-05 19:49:465333void WebContentsImpl::NotifyNavigationEntryCommitted(
5334 const LoadCommittedDetails& load_details) {
ericwilligersde386342016-10-19 02:35:095335 for (auto& observer : observers_)
5336 observer.NavigationEntryCommitted(load_details);
[email protected]cbb1ef592013-06-05 19:49:465337}
5338
Sam McNally5c087a32017-08-25 01:46:145339void WebContentsImpl::NotifyNavigationEntryChanged(
5340 const EntryChangedDetails& change_details) {
5341 for (auto& observer : observers_)
5342 observer.NavigationEntryChanged(change_details);
5343}
5344
5345void WebContentsImpl::NotifyNavigationListPruned(
5346 const PrunedDetails& pruned_details) {
5347 for (auto& observer : observers_)
5348 observer.NavigationListPruned(pruned_details);
5349}
5350
Christian Dullweber1af31e62018-02-22 11:49:485351void WebContentsImpl::NotifyNavigationEntriesDeleted() {
5352 for (auto& observer : observers_)
5353 observer.NavigationEntriesDeleted();
5354}
5355
rockotf62002a2016-09-15 00:08:595356void WebContentsImpl::OnAssociatedInterfaceRequest(
5357 RenderFrameHost* render_frame_host,
5358 const std::string& interface_name,
5359 mojo::ScopedInterfaceEndpointHandle handle) {
5360 auto it = binding_sets_.find(interface_name);
5361 if (it != binding_sets_.end())
5362 it->second->OnRequestForFrame(render_frame_host, std::move(handle));
5363}
5364
Ben Goodger9e24929e2017-07-21 03:13:405365void WebContentsImpl::OnInterfaceRequest(
5366 RenderFrameHost* render_frame_host,
5367 const std::string& interface_name,
5368 mojo::ScopedMessagePipeHandle* interface_pipe) {
5369 for (auto& observer : observers_) {
5370 observer.OnInterfaceRequestFromFrame(render_frame_host, interface_name,
5371 interface_pipe);
5372 if (!interface_pipe->is_valid())
5373 break;
5374 }
5375}
5376
Varun Khaneja5da94302019-06-25 04:48:105377void WebContentsImpl::OnDidBlockNavigation(
5378 const GURL& blocked_url,
5379 const GURL& initiator_url,
5380 blink::NavigationBlockedReason reason) {
Nicolas Dossou-gbetebcab2472017-09-09 12:28:405381 if (delegate_)
Varun Khaneja5da94302019-06-25 04:48:105382 delegate_->OnDidBlockNavigation(this, blocked_url, initiator_url, reason);
Nicolas Dossou-gbetebcab2472017-09-09 12:28:405383}
5384
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415385const GURL& WebContentsImpl::GetMainFrameLastCommittedURL() {
[email protected]c31a84802014-04-03 15:55:495386 return GetLastCommittedURL();
5387}
5388
[email protected]b849847b2013-12-10 21:57:585389void WebContentsImpl::RenderFrameCreated(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:095390 for (auto& observer : observers_)
5391 observer.RenderFrameCreated(render_frame_host);
dmazzonif8a31042016-12-03 00:52:135392 UpdateAccessibilityModeOnFrame(render_frame_host);
clamy91b7abf2016-03-24 15:17:455393
Becca Hughesd11d6502018-07-31 17:01:285394 if (display_cutout_host_impl_)
5395 display_cutout_host_impl_->RenderFrameCreated(render_frame_host);
5396
clamy91b7abf2016-03-24 15:17:455397 if (!render_frame_host->IsRenderFrameLive() || render_frame_host->GetParent())
5398 return;
5399
5400 NavigationEntry* entry = controller_.GetPendingEntry();
5401 if (entry && entry->IsViewSourceMode()) {
5402 // Put the renderer in view source mode.
5403 render_frame_host->Send(
5404 new FrameMsg_EnableViewSourceMode(render_frame_host->GetRoutingID()));
5405 }
[email protected]b849847b2013-12-10 21:57:585406}
5407
5408void WebContentsImpl::RenderFrameDeleted(RenderFrameHost* render_frame_host) {
yilkal172da772019-11-06 22:49:075409 if (IsBeingDestroyed() && !render_frame_host->GetParent() &&
5410 first_navigation_completed_ &&
Rakina Zata Amni74627df2019-10-15 02:03:175411 !static_cast<RenderFrameHostImpl*>(render_frame_host)
5412 ->is_in_back_forward_cache()) {
yilkal796e89e2019-10-02 23:58:285413 // Main frame has been deleted because WebContents is being destroyed.
Rakina Zata Amni74627df2019-10-15 02:03:175414 // Note that we aren't recording this here when the main frame is in the
5415 // back-forward cache because that means we've actually already navigated
5416 // away from it (and we got to this point because the WebContents is
yilkal172da772019-11-06 22:49:075417 // deleted), which means |max_loaded_frame_count_| is already overwritten.
5418 // The |max_loaded_frame_count_| value will instead be recorded from within
5419 // |WebContentsImpl::DidFinishNavigation()|.
5420 RecordMaxFrameCountUMA(max_loaded_frame_count_);
yilkal796e89e2019-10-02 23:58:285421 }
5422
creis3638897452017-05-09 22:07:505423 is_notifying_observers_ = true;
ericwilligersde386342016-10-19 02:35:095424 for (auto& observer : observers_)
5425 observer.RenderFrameDeleted(render_frame_host);
creis3638897452017-05-09 22:07:505426 is_notifying_observers_ = false;
zqzhang7b6f4f02016-12-07 22:10:225427#if BUILDFLAG(ENABLE_PLUGINS)
5428 pepper_playback_observer_->RenderFrameDeleted(render_frame_host);
5429#endif
Becca Hughesfd5d8f892018-06-14 18:23:365430
Becca Hughesd11d6502018-07-31 17:01:285431 if (display_cutout_host_impl_)
5432 display_cutout_host_impl_->RenderFrameDeleted(render_frame_host);
5433
Becca Hughesfd5d8f892018-06-14 18:23:365434 // Remove any fullscreen state that the frame has stored.
5435 FullscreenStateChanged(render_frame_host, false /* is_fullscreen */);
[email protected]b849847b2013-12-10 21:57:585436}
5437
[email protected]a09d53ce2014-01-31 00:46:425438void WebContentsImpl::ShowContextMenu(RenderFrameHost* render_frame_host,
5439 const ContextMenuParams& params) {
avie9fd8722017-04-10 16:17:585440 // If a renderer fires off a second command to show a context menu before the
5441 // first context menu is closed, just ignore it. https://crbug.com/707534
ekaramadf6750aa2017-06-06 18:29:425442 if (showing_context_menu_)
avie9fd8722017-04-10 16:17:585443 return;
5444
[email protected]077e704b2014-05-23 19:24:105445 ContextMenuParams context_menu_params(params);
[email protected]a09d53ce2014-01-31 00:46:425446 // Allow WebContentsDelegates to handle the context menu operation first.
Joel Klinghed0ea22ea2019-02-20 22:04:225447 if (delegate_ &&
5448 delegate_->HandleContextMenu(render_frame_host, context_menu_params))
[email protected]a09d53ce2014-01-31 00:46:425449 return;
5450
[email protected]077e704b2014-05-23 19:24:105451 render_view_host_delegate_view_->ShowContextMenu(render_frame_host,
5452 context_menu_params);
[email protected]a09d53ce2014-01-31 00:46:425453}
5454
Avi Drissman4891b852018-09-25 18:12:585455namespace {
5456// Normalizes the line endings: \r\n -> \n, lone \r -> \n.
5457base::string16 NormalizeLineBreaks(const base::string16& source) {
5458 static const base::NoDestructor<base::string16> kReturnNewline(
5459 base::ASCIIToUTF16("\r\n"));
5460 static const base::NoDestructor<base::string16> kReturn(
5461 base::ASCIIToUTF16("\r"));
5462 static const base::NoDestructor<base::string16> kNewline(
5463 base::ASCIIToUTF16("\n"));
5464
5465 std::vector<base::StringPiece16> pieces;
5466
5467 for (const auto& rn_line : base::SplitStringPieceUsingSubstr(
5468 source, *kReturnNewline, base::KEEP_WHITESPACE,
5469 base::SPLIT_WANT_ALL)) {
5470 auto r_lines = base::SplitStringPieceUsingSubstr(
5471 rn_line, *kReturn, base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
5472 std::move(std::begin(r_lines), std::end(r_lines),
5473 std::back_inserter(pieces));
5474 }
5475
5476 return base::JoinString(pieces, *kNewline);
5477}
5478} // namespace
5479
avi777ff452017-02-09 19:04:485480void WebContentsImpl::RunJavaScriptDialog(RenderFrameHost* render_frame_host,
5481 const base::string16& message,
5482 const base::string16& default_prompt,
avi777ff452017-02-09 19:04:485483 JavaScriptDialogType dialog_type,
5484 IPC::Message* reply_msg) {
Avi Drissman2ccbb402018-03-20 21:11:365485 // Ensure that if showing a dialog is the first thing that a page does, that
5486 // the contents of the previous page aren't shown behind it. This is required
5487 // because showing a dialog freezes the renderer, so no frames will be coming
5488 // from it. https://crbug.com/823353
5489 auto* render_widget_host_impl =
5490 static_cast<RenderFrameHostImpl*>(render_frame_host)
5491 ->GetRenderWidgetHost();
5492 if (render_widget_host_impl)
5493 render_widget_host_impl->ForceFirstFrameAfterNavigationTimeout();
5494
avi0720b02e2017-06-13 03:22:135495 // Running a dialog causes an exit to webpage-initiated fullscreen.
5496 // http://crbug.com/728276
Avi Drissmand18c51972018-08-15 18:32:095497 ForSecurityDropFullscreen();
avi0720b02e2017-06-13 03:22:135498
Avi Drissmane04d3992017-10-05 15:11:365499 auto callback =
5500 base::BindOnce(&WebContentsImpl::OnDialogClosed, base::Unretained(this),
5501 render_frame_host->GetProcess()->GetID(),
5502 render_frame_host->GetRoutingID(), reply_msg);
Pavel Feldman3c1842b2017-08-02 05:00:165503
Pavel Feldman3c1842b2017-08-02 05:00:165504 std::vector<protocol::PageHandler*> page_handlers =
5505 protocol::PageHandler::EnabledForWebContents(this);
5506
Pavel Feldmanfab3cb62017-10-05 01:02:015507 if (delegate_)
5508 dialog_manager_ = delegate_->GetJavaScriptDialogManager(this);
5509
Charlie Reis96077362019-07-04 00:34:045510 // While a JS message dialog is showing, defer commits in this WebContents.
5511 javascript_dialog_navigation_deferrer_ =
5512 std::make_unique<JavaScriptDialogNavigationDeferrer>();
5513
Pavel Feldmanfab3cb62017-10-05 01:02:015514 // Suppress JavaScript dialogs when requested. Also suppress messages when
5515 // showing an interstitial as it's shown over the previous page and we don't
5516 // want the hidden page's dialogs to interfere with the interstitial.
5517 bool should_suppress = ShowingInterstitialPage() ||
5518 (delegate_ && delegate_->ShouldSuppressDialogs(this));
Pavel Feldman1c587bc52018-04-04 21:16:055519 bool has_non_devtools_handlers = delegate_ && dialog_manager_;
5520 bool has_handlers = page_handlers.size() || has_non_devtools_handlers;
Pavel Feldmanfab3cb62017-10-05 01:02:015521 bool suppress_this_message = should_suppress || !has_handlers;
5522
5523 if (suppress_this_message) {
Avi Drissmane04d3992017-10-05 15:11:365524 std::move(callback).Run(true, false, base::string16());
Pavel Feldman3c1842b2017-08-02 05:00:165525 return;
5526 }
5527
5528 scoped_refptr<CloseDialogCallbackWrapper> wrapper =
Avi Drissmane04d3992017-10-05 15:11:365529 new CloseDialogCallbackWrapper(std::move(callback));
Pavel Feldman3c1842b2017-08-02 05:00:165530
5531 is_showing_javascript_dialog_ = true;
5532
Avi Drissman4891b852018-09-25 18:12:585533 base::string16 normalized_message = NormalizeLineBreaks(message);
5534
Pavel Feldman3c1842b2017-08-02 05:00:165535 for (auto* handler : page_handlers) {
Avi Drissmane04d3992017-10-05 15:11:365536 handler->DidRunJavaScriptDialog(
Avi Drissman4891b852018-09-25 18:12:585537 render_frame_host->GetLastCommittedURL(), normalized_message,
5538 default_prompt, dialog_type, has_non_devtools_handlers,
Avi Drissmane04d3992017-10-05 15:11:365539 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:165540 }
5541
5542 if (dialog_manager_) {
[email protected]87de04b02014-04-08 22:14:495543 dialog_manager_->RunJavaScriptDialog(
Avi Drissman4891b852018-09-25 18:12:585544 this, render_frame_host, dialog_type, normalized_message,
5545 default_prompt,
Avi Drissmane04d3992017-10-05 15:11:365546 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false),
5547 &suppress_this_message);
[email protected]87de04b02014-04-08 22:14:495548 }
5549
5550 if (suppress_this_message) {
5551 // If we are suppressing messages, just reply as if the user immediately
5552 // pressed "Cancel", passing true to |dialog_was_suppressed|.
Avi Drissmane04d3992017-10-05 15:11:365553 wrapper->Run(true, false, base::string16());
[email protected]87de04b02014-04-08 22:14:495554 }
[email protected]87de04b02014-04-08 22:14:495555}
5556
5557void WebContentsImpl::RunBeforeUnloadConfirm(
[email protected]39f2f9252014-05-03 00:54:015558 RenderFrameHost* render_frame_host,
[email protected]87de04b02014-04-08 22:14:495559 bool is_reload,
5560 IPC::Message* reply_msg) {
Avi Drissman2ccbb402018-03-20 21:11:365561 // Ensure that if showing a dialog is the first thing that a page does, that
5562 // the contents of the previous page aren't shown behind it. This is required
5563 // because showing a dialog freezes the renderer, so no frames will be coming
5564 // from it. https://crbug.com/823353
5565 auto* render_widget_host_impl =
5566 static_cast<RenderFrameHostImpl*>(render_frame_host)
5567 ->GetRenderWidgetHost();
5568 if (render_widget_host_impl)
5569 render_widget_host_impl->ForceFirstFrameAfterNavigationTimeout();
5570
avi0720b02e2017-06-13 03:22:135571 // Running a dialog causes an exit to webpage-initiated fullscreen.
5572 // http://crbug.com/728276
Avi Drissmand18c51972018-08-15 18:32:095573 ForSecurityDropFullscreen();
avi0720b02e2017-06-13 03:22:135574
[email protected]39f2f9252014-05-03 00:54:015575 RenderFrameHostImpl* rfhi =
5576 static_cast<RenderFrameHostImpl*>(render_frame_host);
[email protected]87de04b02014-04-08 22:14:495577 if (delegate_)
5578 delegate_->WillRunBeforeUnloadConfirm();
5579
Avi Drissmane04d3992017-10-05 15:11:365580 auto callback =
5581 base::BindOnce(&WebContentsImpl::OnDialogClosed, base::Unretained(this),
5582 render_frame_host->GetProcess()->GetID(),
5583 render_frame_host->GetRoutingID(), reply_msg);
Pavel Feldman3c1842b2017-08-02 05:00:165584
Pavel Feldman3c1842b2017-08-02 05:00:165585 std::vector<protocol::PageHandler*> page_handlers =
5586 protocol::PageHandler::EnabledForWebContents(this);
5587
Pavel Feldmanfab3cb62017-10-05 01:02:015588 if (delegate_)
5589 dialog_manager_ = delegate_->GetJavaScriptDialogManager(this);
5590
Charlie Reis96077362019-07-04 00:34:045591 // While a JS beforeunload dialog is showing, defer commits in this
5592 // WebContents.
5593 javascript_dialog_navigation_deferrer_ =
5594 std::make_unique<JavaScriptDialogNavigationDeferrer>();
5595
Pavel Feldmanfab3cb62017-10-05 01:02:015596 bool should_suppress = ShowingInterstitialPage() || !rfhi->is_active() ||
5597 (delegate_ && delegate_->ShouldSuppressDialogs(this));
Pavel Feldman1c587bc52018-04-04 21:16:055598 bool has_non_devtools_handlers = delegate_ && dialog_manager_;
5599 bool has_handlers = page_handlers.size() || has_non_devtools_handlers;
Pavel Feldmanfab3cb62017-10-05 01:02:015600 if (should_suppress || !has_handlers) {
Avi Drissmane04d3992017-10-05 15:11:365601 std::move(callback).Run(false, true, base::string16());
[email protected]87de04b02014-04-08 22:14:495602 return;
5603 }
5604
5605 is_showing_before_unload_dialog_ = true;
Pavel Feldman3c1842b2017-08-02 05:00:165606
5607 scoped_refptr<CloseDialogCallbackWrapper> wrapper =
Avi Drissmane04d3992017-10-05 15:11:365608 new CloseDialogCallbackWrapper(std::move(callback));
Pavel Feldman3c1842b2017-08-02 05:00:165609
5610 GURL frame_url = rfhi->GetLastCommittedURL();
5611 for (auto* handler : page_handlers) {
Avi Drissmane04d3992017-10-05 15:11:365612 handler->DidRunBeforeUnloadConfirm(
Pavel Feldman1c587bc52018-04-04 21:16:055613 frame_url, has_non_devtools_handlers,
Avi Drissmane04d3992017-10-05 15:11:365614 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:165615 }
5616
5617 if (dialog_manager_) {
Avi Drissmane04d3992017-10-05 15:11:365618 dialog_manager_->RunBeforeUnloadDialog(
Avi Drissmanff9ed752017-11-28 21:18:125619 this, render_frame_host, is_reload,
Avi Drissmane04d3992017-10-05 15:11:365620 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:165621 }
[email protected]87de04b02014-04-08 22:14:495622}
5623
Kent Tamurac260c9a2018-09-14 09:10:565624void WebContentsImpl::RunFileChooser(
5625 RenderFrameHost* render_frame_host,
Kent Tamura512a27e2018-10-04 00:49:325626 std::unique_ptr<content::FileSelectListener> listener,
Kent Tamurac260c9a2018-09-14 09:10:565627 const blink::mojom::FileChooserParams& params) {
Avi Drissman3d41e7712018-08-27 21:18:085628 // Any explicit focusing of another window while this WebContents is in
5629 // fullscreen can be used to confuse the user, so drop fullscreen.
5630 ForSecurityDropFullscreen();
5631
Andrey Lushnikov81b992e2019-06-27 23:27:215632 RenderFrameHostImpl* rfhi =
5633 static_cast<RenderFrameHostImpl*>(render_frame_host);
5634 if (devtools_instrumentation::InterceptFileChooser(rfhi, &listener, params))
5635 return;
5636
naskoada75b22016-06-11 16:09:465637 if (delegate_)
Kent Tamura512a27e2018-10-04 00:49:325638 delegate_->RunFileChooser(render_frame_host, std::move(listener), params);
5639 else
5640 listener->FileSelectionCanceled();
naskoada75b22016-06-11 16:09:465641}
5642
[email protected]a86c0e962013-12-17 17:10:395643WebContents* WebContentsImpl::GetAsWebContents() {
5644 return this;
5645}
5646
mcnee336ea2c2017-05-23 22:50:595647#if !defined(OS_ANDROID)
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415648double WebContentsImpl::GetPendingPageZoomLevel() {
wjmaclean64951902016-04-29 20:59:125649 NavigationEntry* pending_entry = GetController().GetPendingEntry();
5650 if (!pending_entry)
5651 return HostZoomMap::GetZoomLevel(this);
5652
5653 GURL url = pending_entry->GetURL();
5654 return HostZoomMap::GetForWebContents(this)->GetZoomLevelForHostAndScheme(
5655 url.scheme(), net::GetHostOrSpecFromURL(url));
5656}
mcnee336ea2c2017-05-23 22:50:595657#endif // !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:125658
qinmin72e8bd02016-10-21 19:35:375659bool WebContentsImpl::HideDownloadUI() const {
5660 return is_overlay_content_;
5661}
5662
mlamouri5cd9ae82017-02-18 11:05:095663bool WebContentsImpl::HasPersistentVideo() const {
5664 return has_persistent_video_;
5665}
5666
Ian Vollick5d5c37f2019-06-19 22:50:575667bool WebContentsImpl::IsSpatialNavigationDisabled() const {
5668 return is_spatial_navigation_disabled_;
5669}
5670
Albert J. Wong65fe64d2019-09-20 02:48:145671RenderFrameHostImpl* WebContentsImpl::GetPendingMainFrame() {
clamy610c63b32017-12-22 15:05:185672 return GetRenderManager()->speculative_frame_host();
Alex Moshchuk27caae82017-09-11 23:11:185673}
5674
mlamourie52c1b542017-02-23 14:57:505675bool WebContentsImpl::HasActiveEffectivelyFullscreenVideo() const {
5676 return media_web_contents_observer_->HasActiveEffectivelyFullscreenVideo();
5677}
5678
François Beaufortad6c5232018-02-26 11:00:445679bool WebContentsImpl::IsPictureInPictureAllowedForFullscreenVideo() const {
5680 return media_web_contents_observer_
5681 ->IsPictureInPictureAllowedForFullscreenVideo();
5682}
5683
ekaramada110f642016-12-21 19:47:285684bool WebContentsImpl::IsFocusedElementEditable() {
5685 RenderFrameHostImpl* frame = GetFocusedFrame();
5686 return frame && frame->has_focused_editable_element();
5687}
5688
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415689bool WebContentsImpl::IsShowingContextMenu() {
ekaramadf6750aa2017-06-06 18:29:425690 return showing_context_menu_;
5691}
5692
5693void WebContentsImpl::SetShowingContextMenu(bool showing) {
5694 DCHECK_NE(showing_context_menu_, showing);
5695 showing_context_menu_ = showing;
5696
5697 if (auto* view = GetRenderWidgetHostView()) {
5698 // Notify the main frame's RWHV to run the platform-specific code, if any.
5699 static_cast<RenderWidgetHostViewBase*>(view)->SetShowingContextMenu(
5700 showing);
5701 }
5702}
5703
ekaramada110f642016-12-21 19:47:285704void WebContentsImpl::ClearFocusedElement() {
5705 if (auto* frame = GetFocusedFrame())
5706 frame->ClearFocusedElement();
5707}
5708
[email protected]7912e822014-04-16 02:37:035709bool WebContentsImpl::IsNeverVisible() {
5710 if (!delegate_)
5711 return false;
5712 return delegate_->IsNeverVisible(this);
5713}
5714
[email protected]5a3bdf52012-05-24 15:12:575715RenderViewHostDelegateView* WebContentsImpl::GetDelegateView() {
5716 return render_view_host_delegate_view_;
[email protected]420ae012009-04-24 05:16:325717}
5718
Leon Hanc819dc62019-01-28 04:30:195719blink::mojom::RendererPreferences WebContentsImpl::GetRendererPrefs(
[email protected]8ff00d72012-10-23 19:12:215720 BrowserContext* browser_context) const {
[email protected]840b1512009-07-21 16:53:465721 return renderer_preferences_;
[email protected]80d96fa2009-06-10 22:34:515722}
5723
[email protected]7a846df2012-09-20 19:17:395724void WebContentsImpl::RemoveBrowserPluginEmbedder() {
Lei Zhang6410ec1a2019-01-31 21:38:585725 browser_plugin_embedder_.reset();
[email protected]7a846df2012-09-20 19:17:395726}
5727
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165728RenderFrameHostImpl* WebContentsImpl::GetOuterWebContentsFrame() {
5729 if (GetOuterDelegateFrameTreeNodeId() ==
5730 FrameTreeNode::kFrameTreeNodeInvalidId) {
5731 return nullptr;
5732 }
5733
5734 FrameTreeNode* outer_node =
5735 FrameTreeNode::GloballyFindByID(GetOuterDelegateFrameTreeNodeId());
5736 // The outer node should be in the outer WebContents.
5737 DCHECK_EQ(outer_node->frame_tree(), GetOuterWebContents()->GetFrameTree());
5738 return outer_node->parent()->current_frame_host();
5739}
5740
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415741WebContentsImpl* WebContentsImpl::GetOuterWebContents() {
lfg601233692017-03-06 22:45:445742 if (GuestMode::IsCrossProcessFrameGuest(this))
5743 return node_.outer_web_contents();
ekaramad1beabecc2016-09-23 20:18:175744
5745 if (browser_plugin_guest_)
5746 return browser_plugin_guest_->embedder_web_contents();
5747
Lucas Furukawa Gadani105de1e812018-05-31 19:38:395748 return node_.outer_web_contents();
avallee0206f782016-07-28 18:55:335749}
5750
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165751std::vector<WebContents*> WebContentsImpl::GetInnerWebContents() {
5752 std::vector<WebContents*> all_inner_contents;
5753 if (browser_plugin_embedder_) {
Sean Topping7df73952019-05-16 17:21:165754 BrowserPluginGuestManager* guest_manager =
5755 GetBrowserContext()->GetGuestManager();
5756 if (guest_manager) {
5757 guest_manager->ForEachGuest(
5758 this,
5759 base::BindRepeating(&GetInnerWebContentsHelper, &all_inner_contents));
5760 }
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165761 }
5762 const auto& inner_contents = node_.GetInnerWebContents();
5763 all_inner_contents.insert(all_inner_contents.end(), inner_contents.begin(),
5764 inner_contents.end());
5765 return all_inner_contents;
5766}
5767
avallee0206f782016-07-28 18:55:335768WebContentsImpl* WebContentsImpl::GetFocusedWebContents() {
lfg601233692017-03-06 22:45:445769 return GetOutermostWebContents()->node_.focused_web_contents();
avallee0206f782016-07-28 18:55:335770}
5771
avallee9993fca2016-11-17 06:16:505772bool WebContentsImpl::ContainsOrIsFocusedWebContents() {
5773 for (WebContentsImpl* focused_contents = GetFocusedWebContents();
5774 focused_contents;
5775 focused_contents = focused_contents->GetOuterWebContents()) {
5776 if (focused_contents == this)
5777 return true;
5778 }
5779
5780 return false;
5781}
5782
avallee0206f782016-07-28 18:55:335783WebContentsImpl* WebContentsImpl::GetOutermostWebContents() {
5784 WebContentsImpl* root = this;
5785 while (root->GetOuterWebContents())
5786 root = root->GetOuterWebContents();
5787 return root;
5788}
5789
avalleed68cdd12017-06-21 22:07:275790void WebContentsImpl::FocusOuterAttachmentFrameChain() {
5791 WebContentsImpl* outer_contents = GetOuterWebContents();
5792 if (!outer_contents)
5793 return;
5794
5795 FrameTreeNode* outer_node =
5796 FrameTreeNode::GloballyFindByID(GetOuterDelegateFrameTreeNodeId());
5797 outer_contents->frame_tree_.SetFocusedFrame(outer_node, nullptr);
5798
5799 // For a browser initiated focus change, let embedding renderer know of the
5800 // change. Otherwise, if the currently focused element is just across a
5801 // process boundary in focus order, it will not be possible to move across
5802 // that boundary. This is because the target element will already be focused
5803 // (that renderer was not notified) and drop the event.
5804 if (GetRenderManager()->GetProxyToOuterDelegate())
5805 GetRenderManager()->GetProxyToOuterDelegate()->SetFocusedFrame();
5806
5807 outer_contents->FocusOuterAttachmentFrameChain();
5808}
5809
Sean Toppingbbc4a2bd2019-01-30 02:16:145810void WebContentsImpl::InnerWebContentsCreated(WebContents* inner_web_contents) {
Shivani Sharma985474f2019-05-23 21:36:475811 had_inner_webcontents_ = true;
Sean Toppingbbc4a2bd2019-01-30 02:16:145812 for (auto& observer : observers_)
5813 observer.InnerWebContentsCreated(inner_web_contents);
5814}
5815
[email protected]b172aee2012-04-10 17:05:265816void WebContentsImpl::RenderViewCreated(RenderViewHost* render_view_host) {
[email protected]86f98a22013-03-20 14:35:005817 if (delegate_)
[email protected]e85165c642014-06-10 14:34:315818 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]a6b73c62013-02-11 23:05:085819
[email protected]8ff00d72012-10-23 19:12:215820 NotificationService::current()->Notify(
5821 NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED,
5822 Source<WebContents>(this),
5823 Details<RenderViewHost>(render_view_host));
[email protected]420ae012009-04-24 05:16:325824
[email protected]60780f412013-02-25 16:34:105825 view_->RenderViewCreated(render_view_host);
[email protected]11f764bb2011-05-25 19:45:265826
ericwilligersde386342016-10-19 02:35:095827 for (auto& observer : observers_)
5828 observer.RenderViewCreated(render_view_host);
Joel Einbinder848001c2017-09-19 21:39:315829 if (delegate_)
5830 RenderFrameDevToolsAgentHost::WebContentsCreated(this);
[email protected]420ae012009-04-24 05:16:325831}
5832
[email protected]b172aee2012-04-10 17:05:265833void WebContentsImpl::RenderViewReady(RenderViewHost* rvh) {
[email protected]151a63d2011-12-20 22:32:525834 if (rvh != GetRenderViewHost()) {
[email protected]420ae012009-04-24 05:16:325835 // Don't notify the world, since this came from a renderer in the
5836 // background.
5837 return;
5838 }
5839
dmazzoni62111452017-04-28 23:46:555840 RenderWidgetHostViewBase* rwhv =
5841 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
5842 if (rwhv)
5843 rwhv->SetMainFrameAXTreeID(GetMainFrame()->GetAXTreeID());
5844
[email protected]da7a7182013-09-06 08:11:115845 notify_disconnection_ = true;
[email protected]da7a7182013-09-06 08:11:115846
[email protected]be1f56ab2011-12-22 06:55:315847 bool was_crashed = IsCrashed();
[email protected]443b80e2010-12-14 00:42:235848 SetIsCrashed(base::TERMINATION_STATUS_STILL_RUNNING, 0);
[email protected]9d8a4642009-07-29 17:25:305849
5850 // Restore the focus to the tab (otherwise the focus will be on the top
5851 // window).
[email protected]484ae5912010-09-29 19:16:145852 if (was_crashed && !FocusLocationBarByDefault() &&
5853 (!delegate_ || delegate_->ShouldFocusPageAfterCrash())) {
[email protected]f3615f02013-02-26 06:09:065854 view_->Focus();
[email protected]484ae5912010-09-29 19:16:145855 }
[email protected]32ded2212011-11-10 18:51:435856
ericwilligersde386342016-10-19 02:35:095857 for (auto& observer : observers_)
5858 observer.RenderViewReady();
Jinsuk Kim895b2c52018-07-03 06:49:165859
5860 view_->RenderViewReady();
[email protected]420ae012009-04-24 05:16:325861}
5862
[email protected]ec6a7eb2013-04-22 17:34:225863void WebContentsImpl::RenderViewTerminated(RenderViewHost* rvh,
5864 base::TerminationStatus status,
5865 int error_code) {
[email protected]151a63d2011-12-20 22:32:525866 if (rvh != GetRenderViewHost()) {
[email protected]420ae012009-04-24 05:16:325867 // The pending page's RenderViewHost is gone.
5868 return;
5869 }
5870
[email protected]2fcdcc32014-03-05 02:14:075871 // Ensure fullscreen mode is exited in the |delegate_| since a crashed
5872 // renderer may not have made a clean exit.
alexmos5dd617d2016-06-07 04:21:155873 if (IsFullscreenForCurrentTab())
bokanece34a82016-01-28 19:49:465874 ExitFullscreenMode(false);
[email protected]2fcdcc32014-03-05 02:14:075875
Jennifer Apacibleb4b972a2018-06-07 04:41:025876 // Ensure any video in Picture-in-Picture is exited in the |delegate_| since
5877 // a crashed renderer may not have made a clean exit.
5878 if (HasPictureInPictureVideo())
5879 ExitPictureInPicture();
5880
[email protected]698191dc2014-02-25 01:06:135881 // Cancel any visible dialogs so they are not left dangling over the sad tab.
creis89a0f782015-05-27 16:13:175882 CancelActiveAndPendingDialogs();
[email protected]698191dc2014-02-25 01:06:135883
dalecurtis3d1e1302017-02-20 22:33:255884 audio_stream_monitor_.RenderProcessGone(rvh->GetProcess()->GetID());
5885
[email protected]960b0372014-05-19 18:01:005886 // Reset the loading progress. TODO(avi): What does it mean to have a
5887 // "renderer crash" when there is more than one renderer process serving a
5888 // webpage? Once this function is called at a more granular frame level, we
5889 // probably will need to more granularly reset the state here.
5890 ResetLoadProgressState();
clamy44e84ce2016-02-22 15:38:255891 NotifyDisconnected();
5892 SetIsCrashed(status, error_code);
[email protected]960b0372014-05-19 18:01:005893
ericwilligersde386342016-10-19 02:35:095894 for (auto& observer : observers_)
5895 observer.RenderProcessGone(GetCrashedStatus());
[email protected]420ae012009-04-24 05:16:325896}
5897
[email protected]b172aee2012-04-10 17:05:265898void WebContentsImpl::RenderViewDeleted(RenderViewHost* rvh) {
ericwilligersde386342016-10-19 02:35:095899 for (auto& observer : observers_)
5900 observer.RenderViewDeleted(rvh);
[email protected]2e4633c2009-07-09 16:58:065901}
5902
sky8b00392d2015-01-10 00:30:285903void WebContentsImpl::UpdateTargetURL(RenderViewHost* render_view_host,
5904 const GURL& url) {
5905 if (fullscreen_widget_routing_id_ != MSG_ROUTING_NONE) {
Lukasz Anforowiczfd707142018-02-07 19:46:135906 // If we're in flash fullscreen (i.e. Pepper plugin fullscreen) only update
5907 // the url if it's from the fullscreen renderer.
sky8b00392d2015-01-10 00:30:285908 RenderWidgetHostView* fs = GetFullscreenRenderWidgetHostView();
avif9ab5d942015-10-15 14:05:445909 if (fs && fs->GetRenderWidgetHost() != render_view_host->GetWidget())
sky8b00392d2015-01-10 00:30:285910 return;
5911 }
Lukasz Anforowiczfd707142018-02-07 19:46:135912
5913 // In case of racey updates from multiple RenderViewHosts, the last URL should
5914 // be shown - see also some discussion in https://crbug.com/807776.
5915 if (!url.is_valid() && render_view_host != view_that_set_last_target_url_)
5916 return;
5917 view_that_set_last_target_url_ = url.is_valid() ? render_view_host : nullptr;
5918
[email protected]6934a702011-12-20 00:04:515919 if (delegate_)
avi450ce00e2014-09-24 01:58:525920 delegate_->UpdateTargetURL(this, url);
[email protected]420ae012009-04-24 05:16:325921}
5922
Lukasz Anforowiczfd707142018-02-07 19:46:135923void WebContentsImpl::ClearTargetURL() {
5924 view_that_set_last_target_url_ = nullptr;
5925 if (delegate_)
5926 delegate_->UpdateTargetURL(this, GURL());
5927}
5928
[email protected]b172aee2012-04-10 17:05:265929void WebContentsImpl::Close(RenderViewHost* rvh) {
[email protected]60780f412013-02-25 16:34:105930#if defined(OS_MACOSX)
[email protected]07707302009-11-06 00:50:295931 // The UI may be in an event-tracking loop, such as between the
5932 // mouse-down and mouse-up in text selection or a button click.
5933 // Defer the close until after tracking is complete, so that we
5934 // don't free objects out from under the UI.
[email protected]07707302009-11-06 00:50:295935 // TODO(shess): This could get more fine-grained. For instance,
5936 // closing a tab in another window while selecting text in the
5937 // current window's Omnibox should be just fine.
Christopher Cameron9ae31e0d2019-03-01 20:01:195938 if (view_->CloseTabAfterEventTrackingIfNeeded())
[email protected]07707302009-11-06 00:50:295939 return;
[email protected]60780f412013-02-25 16:34:105940#endif
[email protected]07707302009-11-06 00:50:295941
[email protected]420ae012009-04-24 05:16:325942 // Ignore this if it comes from a RenderViewHost that we aren't showing.
[email protected]151a63d2011-12-20 22:32:525943 if (delegate_ && rvh == GetRenderViewHost())
[email protected]6934a702011-12-20 00:04:515944 delegate_->CloseContents(this);
[email protected]420ae012009-04-24 05:16:325945}
5946
Avi Drissman014dec72018-06-07 02:34:015947void WebContentsImpl::RequestSetBounds(const gfx::Rect& new_bounds) {
5948 if (delegate_)
5949 delegate_->SetContentsBounds(this, new_bounds);
[email protected]420ae012009-04-24 05:16:325950}
5951
fdegansa696e5112015-04-17 01:57:595952void WebContentsImpl::DidStartLoading(FrameTreeNode* frame_tree_node,
[email protected]e3b10d12014-03-28 16:06:095953 bool to_different_document) {
Evan Stadec3b26022017-07-14 19:50:245954 LoadingStateChanged(frame_tree_node->IsMainFrame() && to_different_document,
5955 false, nullptr);
dmazzonibf8cec42015-02-08 08:28:085956
Xiyuan Xia2a66b112018-12-06 15:52:165957 // Reset the focus state from DidStartNavigation to false if a new load starts
5958 // afterward, in case loading logic triggers a FocusLocationBarByDefault call.
5959 should_focus_location_bar_by_default_ = false;
5960
dmazzonibf8cec42015-02-08 08:28:085961 // Notify accessibility that the user is navigating away from the
5962 // current document.
Dominic Farolinof87ec2a2019-07-04 09:18:095963 // TODO(domfarolino, dmazzoni): Do this using WebContentsObserver. See
5964 // https://crbug.com/981271.
dmazzonibf8cec42015-02-08 08:28:085965 BrowserAccessibilityManager* manager =
fdegansa696e5112015-04-17 01:57:595966 frame_tree_node->current_frame_host()->browser_accessibility_manager();
dmazzonibf8cec42015-02-08 08:28:085967 if (manager)
5968 manager->UserIsNavigatingAway();
[email protected]420ae012009-04-24 05:16:325969}
5970
fdegansc73eec22015-03-19 14:47:545971void WebContentsImpl::DidStopLoading() {
dcheng59716272016-04-09 05:19:085972 std::unique_ptr<LoadNotificationDetails> details;
[email protected]420ae012009-04-24 05:16:325973
[email protected]9595fd82013-04-19 21:28:495974 // Use the last committed entry rather than the active one, in case a
5975 // pending entry has been created.
5976 NavigationEntry* entry = controller_.GetLastCommittedEntry();
[email protected]3691e5cf2014-01-22 10:16:205977 Navigator* navigator = frame_tree_.root()->navigator();
[email protected]9595fd82013-04-19 21:28:495978
[email protected]420ae012009-04-24 05:16:325979 // An entry may not exist for a stop when loading an initial blank page or
5980 // if an iframe injected by script into a blank page finishes loading.
5981 if (entry) {
[email protected]3691e5cf2014-01-22 10:16:205982 base::TimeDelta elapsed =
5983 base::TimeTicks::Now() - navigator->GetCurrentLoadStart();
[email protected]420ae012009-04-24 05:16:325984
5985 details.reset(new LoadNotificationDetails(
[email protected]36fc0392011-12-25 03:59:515986 entry->GetVirtualURL(),
[email protected]420ae012009-04-24 05:16:325987 elapsed,
5988 &controller_,
5989 controller_.GetCurrentEntryIndex()));
5990 }
5991
clamy44e84ce2016-02-22 15:38:255992 LoadingStateChanged(true, false, details.get());
[email protected]420ae012009-04-24 05:16:325993}
5994
fdegansa696e5112015-04-17 01:57:595995void WebContentsImpl::DidChangeLoadProgress() {
Nate Chapin22ea6592019-03-05 22:29:025996 if (is_being_destroyed_)
5997 return;
fdegansa696e5112015-04-17 01:57:595998 double load_progress = frame_tree_.load_progress();
5999
6000 // The delegate is notified immediately for the first and last updates. Also,
6001 // since the message loop may be pretty busy when a page is loaded, it might
6002 // not execute a posted task in a timely manner so the progress report is sent
6003 // immediately if enough time has passed.
6004 base::TimeDelta min_delay =
6005 base::TimeDelta::FromMilliseconds(kMinimumDelayBetweenLoadingUpdatesMS);
6006 bool delay_elapsed = loading_last_progress_update_.is_null() ||
6007 base::TimeTicks::Now() - loading_last_progress_update_ > min_delay;
6008
6009 if (load_progress == 0.0 || load_progress == 1.0 || delay_elapsed) {
6010 // If there is a pending task to send progress, it is now obsolete.
6011 loading_weak_factory_.InvalidateWeakPtrs();
6012
6013 // Notify the load progress change.
6014 SendChangeLoadProgress();
6015
6016 // Clean-up the states if needed.
6017 if (load_progress == 1.0)
6018 ResetLoadProgressState();
6019 return;
6020 }
6021
6022 if (loading_weak_factory_.HasWeakPtrs())
6023 return;
6024
skyostil95082a62015-06-05 19:53:076025 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
tzike2aca992017-09-05 08:50:546026 FROM_HERE,
6027 base::BindOnce(&WebContentsImpl::SendChangeLoadProgress,
6028 loading_weak_factory_.GetWeakPtr()),
fdegansa696e5112015-04-17 01:57:596029 min_delay);
6030}
6031
avid6d88b912017-01-13 00:16:006032std::vector<std::unique_ptr<NavigationThrottle>>
6033WebContentsImpl::CreateThrottlesForNavigation(
clamycbf524d42016-09-27 12:48:356034 NavigationHandle* navigation_handle) {
Charlie Reis96077362019-07-04 00:34:046035 auto throttles = GetContentClient()->browser()->CreateThrottlesForNavigation(
clamycbf524d42016-09-27 12:48:356036 navigation_handle);
Charlie Reis96077362019-07-04 00:34:046037
6038 // This is not a normal place to be adding a throttle. However, in the case
6039 // javascript dialogs, related logic is present in the web_contents/ layer,
6040 // and the purpose of the throttle is to ensure that navigation commits are
6041 // deferred for the entire WebContents. Most throttles are either added by
6042 // the embederrer outside of content/, or are per-frame and added by
6043 // NavigationThrottleRunner.
6044 std::unique_ptr<content::NavigationThrottle> dialog_throttle =
6045 JavaScriptDialogNavigationThrottle::MaybeCreateThrottleFor(
6046 navigation_handle);
6047 if (dialog_throttle)
6048 throttles.push_back(std::move(dialog_throttle));
6049
6050 return throttles;
clamycbf524d42016-09-27 12:48:356051}
6052
clamy1e5574e2016-09-29 16:48:446053std::unique_ptr<NavigationUIData> WebContentsImpl::GetNavigationUIData(
6054 NavigationHandle* navigation_handle) {
clamy1e5574e2016-09-29 16:48:446055 return GetContentClient()->browser()->GetNavigationUIData(navigation_handle);
6056}
6057
pdr15f5b5b2017-06-20 00:58:006058void WebContentsImpl::DidCancelLoading() {
6059 controller_.DiscardNonCommittedEntries();
6060
6061 // Update the URL display.
6062 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
6063}
6064
[email protected]59167c22013-06-03 18:07:326065void WebContentsImpl::DidAccessInitialDocument() {
[email protected]b4c84012014-04-28 19:51:106066 has_accessed_initial_document_ = true;
6067
[email protected]d1371bf8e2014-04-19 03:26:246068 // We may have left a failed browser-initiated navigation in the address bar
6069 // to let the user edit it and try again. Clear it now that content might
6070 // show up underneath it.
6071 if (!IsLoading() && controller_.GetPendingEntry())
avi45a72532015-04-07 21:01:456072 controller_.DiscardPendingEntry(false);
[email protected]d1371bf8e2014-04-19 03:26:246073
[email protected]59167c22013-06-03 18:07:326074 // Update the URL display.
thestigc4cac8f2014-09-04 21:17:506075 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
[email protected]59167c22013-06-03 18:07:326076}
6077
alexmosbe2f4c32015-03-10 02:30:236078void WebContentsImpl::DidChangeName(RenderFrameHost* render_frame_host,
6079 const std::string& name) {
ericwilligersde386342016-10-19 02:35:096080 for (auto& observer : observers_)
6081 observer.FrameNameChanged(render_frame_host, name);
alexmosbe2f4c32015-03-10 02:30:236082}
6083
John Delaneyedd8d6c2019-01-25 00:23:576084void WebContentsImpl::DidReceiveFirstUserActivation(
6085 RenderFrameHost* render_frame_host) {
6086 for (auto& observer : observers_)
6087 observer.FrameReceivedFirstUserActivation(render_frame_host);
6088}
6089
John Delaney0146a742019-01-25 19:25:286090void WebContentsImpl::DidChangeDisplayState(RenderFrameHost* render_frame_host,
6091 bool is_display_none) {
6092 for (auto& observer : observers_)
6093 observer.FrameDisplayStateChanged(render_frame_host, is_display_none);
6094}
6095
6096void WebContentsImpl::FrameSizeChanged(RenderFrameHost* render_frame_host,
6097 const gfx::Size& frame_size) {
6098 for (auto& observer : observers_)
6099 observer.FrameSizeChanged(render_frame_host, frame_size);
6100}
6101
[email protected]39f2f9252014-05-03 00:54:016102void WebContentsImpl::DocumentOnLoadCompleted(
[email protected]50279492014-05-05 23:24:296103 RenderFrameHost* render_frame_host) {
falken52a56e32016-12-08 05:02:406104 ShowInsecureLocalhostWarningIfNeeded();
6105
Alexander Timindd0fa0c52019-11-06 13:03:376106 GetRenderViewHost()->DocumentOnLoadCompletedInMainFrame();
6107
creis97867aa2017-02-17 18:39:456108 is_notifying_observers_ = true;
ericwilligersde386342016-10-19 02:35:096109 for (auto& observer : observers_)
6110 observer.DocumentOnLoadCompletedInMainFrame();
creis97867aa2017-02-17 18:39:456111 is_notifying_observers_ = false;
[email protected]6578fef2013-10-14 02:35:096112
6113 // TODO(avi): Remove. http://crbug.com/170921
[email protected]8ff00d72012-10-23 19:12:216114 NotificationService::current()->Notify(
6115 NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
6116 Source<WebContents>(this),
[email protected]50279492014-05-05 23:24:296117 NotificationService::NoDetails());
[email protected]25497492010-09-11 15:15:086118}
6119
creis8eb8ef22015-11-04 22:51:386120void WebContentsImpl::UpdateStateForFrame(RenderFrameHost* render_frame_host,
6121 const PageState& page_state) {
creis8eb8ef22015-11-04 22:51:386122 // The state update affects the last NavigationEntry associated with the given
6123 // |render_frame_host|. This may not be the last committed NavigationEntry (as
6124 // in the case of an UpdateState from a frame being swapped out). We track
6125 // which entry this is in the RenderFrameHost's nav_entry_id.
6126 RenderFrameHostImpl* rfhi =
6127 static_cast<RenderFrameHostImpl*>(render_frame_host);
6128 NavigationEntryImpl* entry =
6129 controller_.GetEntryWithUniqueID(rfhi->nav_entry_id());
6130 if (!entry)
6131 return;
6132
6133 FrameNavigationEntry* frame_entry =
6134 entry->GetFrameEntry(rfhi->frame_tree_node());
6135 if (!frame_entry)
6136 return;
6137
creisd06a9422015-11-11 03:08:456138 // The SiteInstance might not match if we do a cross-process navigation with
6139 // replacement (e.g., auto-subframe), in which case the swap out of the old
6140 // RenderFrameHost runs in the background after the old FrameNavigationEntry
6141 // has already been replaced and destroyed.
6142 if (frame_entry->site_instance() != rfhi->GetSiteInstance())
6143 return;
6144
creis8eb8ef22015-11-04 22:51:386145 if (page_state == frame_entry->page_state())
6146 return; // Nothing to update.
6147
creis0cade2e2017-02-28 06:37:476148 DCHECK(page_state.IsValid()) << "Shouldn't set an empty PageState.";
nasko34634672016-07-29 18:46:066149
6150 // The document_sequence_number and item_sequence_number recorded in the
6151 // FrameNavigationEntry should not differ from the one coming with the update,
6152 // since it must come from the same document. Do not update it if a difference
6153 // is detected, as this indicates that |frame_entry| is not the correct one.
6154 ExplodedPageState exploded_state;
6155 if (!DecodePageState(page_state.ToEncodedData(), &exploded_state))
6156 return;
6157
6158 if (exploded_state.top.document_sequence_number !=
6159 frame_entry->document_sequence_number() ||
6160 exploded_state.top.item_sequence_number !=
6161 frame_entry->item_sequence_number()) {
6162 return;
6163 }
6164
nasko04a322f25a2016-09-01 00:00:346165 frame_entry->SetPageState(page_state);
creis8eb8ef22015-11-04 22:51:386166 controller_.NotifyEntryChanged(entry);
6167}
6168
[email protected]ef3adfc2014-05-11 00:04:546169void WebContentsImpl::UpdateTitle(RenderFrameHost* render_frame_host,
[email protected]ef3adfc2014-05-11 00:04:546170 const base::string16& title,
6171 base::i18n::TextDirection title_direction) {
[email protected]ef3adfc2014-05-11 00:04:546172 // Try to find the navigation entry, which might not be the current one.
avi286019ce2015-07-29 01:26:586173 // For example, it might be from a recently swapped out RFH.
avi1edc8552016-10-13 21:37:166174 NavigationEntryImpl* entry = controller_.GetEntryWithUniqueID(
creisad8c31a2016-05-24 17:07:046175 static_cast<RenderFrameHostImpl*>(render_frame_host)->nav_entry_id());
[email protected]ef3adfc2014-05-11 00:04:546176
6177 // We can handle title updates when we don't have an entry in
6178 // UpdateTitleForEntry, but only if the update is from the current RVH.
6179 // TODO(avi): Change to make decisions based on the RenderFrameHost.
avi286019ce2015-07-29 01:26:586180 if (!entry && render_frame_host != GetMainFrame())
[email protected]ef3adfc2014-05-11 00:04:546181 return;
6182
6183 // TODO(evan): make use of title_direction.
6184 // http://code.google.com/p/chromium/issues/detail?id=27094
afakhry6f0c1ec22016-07-14 13:55:136185 UpdateTitleForEntry(entry, title);
[email protected]ef3adfc2014-05-11 00:04:546186}
6187
[email protected]39f2f9252014-05-03 00:54:016188void WebContentsImpl::DocumentAvailableInMainFrame(
6189 RenderViewHost* render_view_host) {
ericwilligersde386342016-10-19 02:35:096190 for (auto& observer : observers_)
6191 observer.DocumentAvailableInMainFrame();
[email protected]39f2f9252014-05-03 00:54:016192}
naskoc0fceff2015-04-30 15:53:526193
[email protected]e1c3a552012-05-04 20:51:326194void WebContentsImpl::RouteCloseEvent(RenderViewHost* rvh) {
6195 // Tell the active RenderViewHost to run unload handlers and close, as long
6196 // as the request came from a RenderViewHost in the same BrowsingInstance.
6197 // In most cases, we receive this from a swapped out RenderViewHost.
6198 // It is possible to receive it from one that has just been swapped in,
6199 // in which case we might as well deliver the message anyway.
6200 if (rvh->GetSiteInstance()->IsRelatedSiteInstance(GetSiteInstance()))
naskoc0fceff2015-04-30 15:53:526201 ClosePage();
[email protected]e1c3a552012-05-04 20:51:326202}
6203
alexmose7da5a12015-04-09 02:22:166204bool WebContentsImpl::ShouldRouteMessageEvent(
6205 RenderFrameHost* target_rfh,
6206 SiteInstance* source_site_instance) const {
6207 // Allow the message if this WebContents is dedicated to a browser plugin
6208 // guest.
[email protected]0eba810b2012-10-18 03:19:366209 // Note: This check means that an embedder could theoretically receive a
6210 // postMessage from anyone (not just its own guests). However, this is
6211 // probably not a risk for apps since other pages won't have references
6212 // to App windows.
alexmose7da5a12015-04-09 02:22:166213 return GetBrowserPluginGuest() || GetBrowserPluginEmbedder();
6214}
[email protected]f546640b2012-05-15 00:03:496215
alexmos58729042015-06-18 23:20:006216void WebContentsImpl::EnsureOpenerProxiesExist(RenderFrameHost* source_rfh) {
alexmose7da5a12015-04-09 02:22:166217 WebContentsImpl* source_web_contents = static_cast<WebContentsImpl*>(
6218 WebContents::FromRenderFrameHost(source_rfh));
[email protected]f546640b2012-05-15 00:03:496219
alexmose7da5a12015-04-09 02:22:166220 if (source_web_contents) {
lazyboy6ec48b2a2015-06-29 15:18:146221 // If this message is going to outer WebContents from inner WebContents,
6222 // then we should not create a RenderView. AttachToOuterWebContentsFrame()
6223 // already created a RenderFrameProxyHost for that purpose.
6224 if (GetBrowserPluginEmbedder() &&
ekaramad1beabecc2016-09-23 20:18:176225 GuestMode::IsCrossProcessFrameGuest(source_web_contents)) {
lazyboy6ec48b2a2015-06-29 15:18:146226 return;
6227 }
6228
lfg812874d2016-02-09 22:26:136229 if (this != source_web_contents && GetBrowserPluginGuest()) {
naskob3041b98a42016-03-12 04:43:066230 // We create a RenderFrameProxyHost for the embedder in the guest's render
6231 // process but we intentionally do not expose the embedder's opener chain
6232 // to it.
6233 source_web_contents->GetRenderManager()->CreateRenderFrameProxy(
6234 GetSiteInstance());
[email protected]f546640b2012-05-15 00:03:496235 } else {
alexmos58729042015-06-18 23:20:006236 RenderFrameHostImpl* source_rfhi =
6237 static_cast<RenderFrameHostImpl*>(source_rfh);
6238 source_rfhi->frame_tree_node()->render_manager()->CreateOpenerProxies(
alexmos90325cf2015-09-02 17:18:396239 GetSiteInstance(), nullptr);
[email protected]f546640b2012-05-15 00:03:496240 }
6241 }
[email protected]f546640b2012-05-15 00:03:496242}
6243
avallee9993fca2016-11-17 06:16:506244void WebContentsImpl::SetAsFocusedWebContentsIfNecessary() {
6245 // Only change focus if we are not currently focused.
6246 WebContentsImpl* old_contents = GetFocusedWebContents();
6247 if (old_contents == this)
6248 return;
6249
paulmeyerfeafc2d2017-04-25 21:46:406250 GetOutermostWebContents()->node_.SetFocusedWebContents(this);
6251
Greg Thompsonfb957602017-09-04 10:25:526252 if (!GuestMode::IsCrossProcessFrameGuest(this) && browser_plugin_guest_)
paulmeyerfeafc2d2017-04-25 21:46:406253 return;
6254
avallee9993fca2016-11-17 06:16:506255 // Send a page level blur to the old contents so that it displays inactive UI
6256 // and focus this contents to activate it.
6257 if (old_contents)
6258 old_contents->GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(false);
avalleec2ff1ef2017-01-21 00:12:306259
6260 // Make sure the outer web contents knows our frame is focused. Otherwise, the
6261 // outer renderer could have the element before or after the frame element
6262 // focused which would return early without actually advancing focus.
avalleed68cdd12017-06-21 22:07:276263 FocusOuterAttachmentFrameChain();
avalleec2ff1ef2017-01-21 00:12:306264
lfg1453e412017-04-11 00:48:506265 if (ShowingInterstitialPage()) {
creisadca9862017-06-16 19:12:116266 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:506267 ->GetRenderWidgetHost()
6268 ->SetPageFocus(true);
6269 } else {
6270 GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(true);
6271 }
avallee9993fca2016-11-17 06:16:506272}
6273
avallee0206f782016-07-28 18:55:336274void WebContentsImpl::SetFocusedFrame(FrameTreeNode* node,
6275 SiteInstance* source) {
avallee0206f782016-07-28 18:55:336276 frame_tree_.SetFocusedFrame(node, source);
avalleed68cdd12017-06-21 22:07:276277
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576278 if (auto* inner_contents = node_.GetInnerWebContentsInFrame(node)) {
6279 // |this| is an outer WebContents and |node| represents an inner
6280 // WebContents. Transfer the focus to the inner contents if |this| is
6281 // focused.
6282 if (GetFocusedWebContents() == this)
6283 inner_contents->SetAsFocusedWebContentsIfNecessary();
6284 } else if (node_.OuterContentsFrameTreeNode() &&
6285 node_.OuterContentsFrameTreeNode()
6286 ->current_frame_host()
6287 ->GetSiteInstance() == source) {
6288 // |this| is an inner WebContents, |node| is its main FrameTreeNode and
6289 // the outer WebContents FrameTreeNode is at |source|'s SiteInstance.
6290 // Transfer the focus to the inner WebContents if the outer WebContents is
6291 // focused. This branch is used when an inner WebContents is focused through
Lowell Mannersa9530382019-08-01 09:46:576292 // its RenderFrameProxyHost (via FrameFocused mojo call, used to
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576293 // implement the window.focus() API).
6294 if (GetFocusedWebContents() == GetOuterWebContents())
6295 SetAsFocusedWebContentsIfNecessary();
6296 } else if (!GetOuterWebContents()) {
6297 // This is an outermost WebContents.
6298 SetAsFocusedWebContentsIfNecessary();
6299 } else if (!GuestMode::IsCrossProcessFrameGuest(this) &&
6300 GetOuterWebContents()) {
6301 // TODO(lfg, paulmeyer): Allows BrowserPlugins to set themselves as the
6302 // focused WebContents. This works around a bug in FindRequestManager that
6303 // doesn't support properly traversing BrowserPlugins.
6304 SetAsFocusedWebContentsIfNecessary();
6305 }
avalleed68cdd12017-06-21 22:07:276306}
6307
Avi Drissman36f801f2018-02-01 20:06:046308void WebContentsImpl::DidCallFocus() {
6309 // Any explicit focusing of another window while this WebContents is in
6310 // fullscreen can be used to confuse the user, so drop fullscreen.
Avi Drissmand18c51972018-08-15 18:32:096311 ForSecurityDropFullscreen();
Avi Drissman36f801f2018-02-01 20:06:046312}
6313
avalleed68cdd12017-06-21 22:07:276314RenderFrameHost* WebContentsImpl::GetFocusedFrameIncludingInnerWebContents() {
6315 WebContentsImpl* contents = this;
6316 FrameTreeNode* focused_node = contents->frame_tree_.GetFocusedFrame();
6317
6318 // If there is no focused frame in the outer WebContents, we need to return
6319 // null.
6320 if (!focused_node)
6321 return nullptr;
6322
6323 // If the focused frame is embedding an inner WebContents, we must descend
6324 // into that contents. If the current WebContents does not have a focused
6325 // frame, return the main frame of this contents instead of the focused empty
6326 // frame embedding this contents.
6327 while (true) {
6328 contents = contents->node_.GetInnerWebContentsInFrame(focused_node);
6329 if (!contents)
6330 return focused_node->current_frame_host();
6331
6332 focused_node = contents->frame_tree_.GetFocusedFrame();
6333 if (!focused_node)
6334 return contents->GetMainFrame();
6335 }
avallee0206f782016-07-28 18:55:336336}
6337
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576338void WebContentsImpl::OnAdvanceFocus(RenderFrameHostImpl* source_rfh) {
6339 // When a RenderFrame needs to advance focus to a RenderFrameProxy (by hitting
6340 // TAB), the RenderFrameProxy sends an IPC to RenderFrameProxyHost. When this
6341 // RenderFrameProxyHost represents an inner WebContents, the outer WebContents
6342 // needs to focus the inner WebContents.
6343 if (GetOuterWebContents() &&
6344 GetOuterWebContents() == source_rfh->delegate()->GetAsWebContents() &&
6345 GetFocusedWebContents() == GetOuterWebContents()) {
6346 SetAsFocusedWebContentsIfNecessary();
6347 }
6348}
6349
ekaramada110f642016-12-21 19:47:286350void WebContentsImpl::OnFocusedElementChangedInFrame(
6351 RenderFrameHostImpl* frame,
6352 const gfx::Rect& bounds_in_root_view) {
6353 RenderWidgetHostViewBase* root_view =
6354 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
6355 if (!root_view || !frame->GetView())
6356 return;
6357
6358 // Converting to screen coordinates.
6359 gfx::Point origin = bounds_in_root_view.origin();
6360 origin += root_view->GetViewBounds().OffsetFromOrigin();
6361 gfx::Rect bounds_in_screen(origin, bounds_in_root_view.size());
6362
6363 root_view->FocusedNodeChanged(frame->has_focused_editable_element(),
6364 bounds_in_screen);
6365
6366 FocusedNodeDetails details = {frame->has_focused_editable_element(),
6367 bounds_in_screen};
6368
6369 // TODO(ekaramad): We should replace this with an observer notification
6370 // (https://crbug.com/675975).
6371 NotificationService::current()->Notify(
6372 NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
6373 Source<RenderViewHost>(GetRenderViewHost()),
6374 Details<FocusedNodeDetails>(&details));
Jeff Fisher709b4c52019-07-29 20:07:346375
6376 for (auto& observer : observers_)
6377 observer.OnFocusChangedInPage(&details);
ekaramada110f642016-12-21 19:47:286378}
6379
Lowell Manners1de5242e2019-04-25 10:18:466380bool WebContentsImpl::DidAddMessageToConsole(
6381 blink::mojom::ConsoleMessageLevel log_level,
6382 const base::string16& message,
6383 int32_t line_no,
6384 const base::string16& source_id) {
[email protected]a796f202012-05-30 14:14:256385 if (!delegate_)
6386 return false;
Lowell Manners1de5242e2019-04-25 10:18:466387 return delegate_->DidAddMessageToConsole(this, log_level, message, line_no,
avia90ae4e2016-11-11 20:49:336388 source_id);
[email protected]a796f202012-05-30 14:14:256389}
6390
Daniel Cheng90196c82018-04-25 21:49:146391void WebContentsImpl::DidReceiveInputEvent(
dominickn9c7ceaa32016-02-27 01:52:536392 RenderWidgetHostImpl* render_widget_host,
6393 const blink::WebInputEvent::Type type) {
Dominick Ng37a15052018-07-17 23:56:356394 if (!IsUserInteractionInputType(type))
Daniel Cheng90196c82018-04-25 21:49:146395 return;
6396
kenrb19221852016-04-29 17:21:406397 // Ignore unless the widget is currently in the frame tree.
6398 if (!HasMatchingWidgetHost(&frame_tree_, render_widget_host))
avic3aa8422015-11-09 20:57:226399 return;
6400
Daniel Cheng90196c82018-04-25 21:49:146401 if (type != blink::WebInputEvent::kGestureScrollBegin)
6402 last_interactive_input_event_time_ = ui::EventTimeForNow();
dominickn9c7ceaa32016-02-27 01:52:536403
Dominick Ng37a15052018-07-17 23:56:356404 for (auto& observer : observers_)
6405 observer.DidGetUserInteraction(type);
dominickn2dd142dd2015-10-29 05:30:506406}
6407
Avi Drissman738ea192018-08-29 20:24:166408bool WebContentsImpl::ShouldIgnoreInputEvents() {
6409 WebContentsImpl* web_contents = this;
6410 while (web_contents) {
6411 if (web_contents->ignore_input_events_)
6412 return true;
6413 web_contents = web_contents->GetOuterWebContents();
6414 }
6415
6416 return false;
6417}
6418
avallee9993fca2016-11-17 06:16:506419void WebContentsImpl::FocusOwningWebContents(
6420 RenderWidgetHostImpl* render_widget_host) {
6421 // The PDF plugin still runs as a BrowserPlugin and must go through the
6422 // input redirection mechanism. It must not become focused direcly.
6423 if (!GuestMode::IsCrossProcessFrameGuest(this) && browser_plugin_guest_)
6424 return;
6425
6426 RenderWidgetHostImpl* focused_widget =
6427 GetFocusedRenderWidgetHost(render_widget_host);
6428
6429 if (focused_widget != render_widget_host &&
avallee8e881592016-11-19 00:39:306430 (!focused_widget ||
6431 focused_widget->delegate() != render_widget_host->delegate())) {
avallee9993fca2016-11-17 06:16:506432 SetAsFocusedWebContentsIfNecessary();
6433 }
6434}
6435
[email protected]b172aee2012-04-10 17:05:266436void WebContentsImpl::OnIgnoredUIEvent() {
[email protected]31145092011-09-30 01:49:446437 // Notify observers.
ericwilligersde386342016-10-19 02:35:096438 for (auto& observer : observers_)
6439 observer.DidGetIgnoredUIEvent();
[email protected]fa1cf0b82010-01-15 21:49:446440}
6441
avic3aa8422015-11-09 20:57:226442void WebContentsImpl::RendererUnresponsive(
Lukasz Anforowicz52b93722018-06-20 16:11:396443 RenderWidgetHostImpl* render_widget_host,
6444 base::RepeatingClosure hang_monitor_restarter) {
avic031d392017-03-03 03:09:426445 if (ShouldIgnoreUnresponsiveRenderer())
[email protected]e5fc1632011-08-08 07:51:536446 return;
6447
Lukasz Anforowicz4f0593d2018-09-21 18:33:546448 // Do not report hangs (to task manager, to hang renderer dialog, etc.) for
6449 // invisible tabs (like extension background page, background tabs). See
6450 // https://crbug.com/881812 for rationale and for choosing the visibility
6451 // (rather than process priority) as the signal here.
6452 if (GetVisibility() != Visibility::VISIBLE)
6453 return;
6454
Avi Drissman8920def2018-01-31 19:53:366455 if (!render_widget_host->renderer_initialized())
[email protected]55452902011-06-01 21:57:476456 return;
6457
Lukasz Anforowicz4f0593d2018-09-21 18:33:546458 for (auto& observer : observers_)
6459 observer.OnRendererUnresponsive(render_widget_host->GetProcess());
6460
Dave Tapuskac6146c52017-12-20 22:48:156461 if (delegate_)
Lukasz Anforowicz52b93722018-06-20 16:11:396462 delegate_->RendererUnresponsive(this, render_widget_host,
6463 std::move(hang_monitor_restarter));
[email protected]420ae012009-04-24 05:16:326464}
6465
avic3aa8422015-11-09 20:57:226466void WebContentsImpl::RendererResponsive(
6467 RenderWidgetHostImpl* render_widget_host) {
[email protected]6934a702011-12-20 00:04:516468 if (delegate_)
Avi Drissman1572e8c3c2018-02-02 19:06:366469 delegate_->RendererResponsive(this, render_widget_host);
[email protected]420ae012009-04-24 05:16:326470}
6471
Alex Moshchuk7b4f0652019-05-30 18:54:416472void WebContentsImpl::SubframeCrashed(
6473 blink::mojom::FrameVisibility visibility) {
6474 // If a subframe crashed on a hidden tab, mark the tab for reload to avoid
6475 // showing a sad frame to the user if they ever switch back to that tab. Do
6476 // this for subframes that are either visible in viewport or visible but
6477 // scrolled out of view, but skip subframes that are not rendered (e.g., via
6478 // "display:none"), since in that case the user wouldn't see a sad frame
6479 // anyway.
6480 bool did_mark_for_reload = false;
6481 if (IsHidden() && visibility != blink::mojom::FrameVisibility::kNotRendered &&
6482 base::FeatureList::IsEnabled(
6483 features::kReloadHiddenTabsWithCrashedSubframes)) {
6484 controller_.SetNeedsReload(
6485 NavigationControllerImpl::NeedsReloadType::kCrashedSubframe);
6486 did_mark_for_reload = true;
6487 UMA_HISTOGRAM_ENUMERATION(
6488 "Stability.ChildFrameCrash.TabMarkedForReload.Visibility", visibility);
6489 }
6490
6491 UMA_HISTOGRAM_BOOLEAN("Stability.ChildFrameCrash.TabMarkedForReload",
6492 did_mark_for_reload);
6493}
6494
[email protected]b172aee2012-04-10 17:05:266495void WebContentsImpl::BeforeUnloadFiredFromRenderManager(
[email protected]feaded02012-09-25 19:12:556496 bool proceed, const base::TimeTicks& proceed_time,
[email protected]420ae012009-04-24 05:16:326497 bool* proceed_to_fire_unload) {
ericwilligersde386342016-10-19 02:35:096498 for (auto& observer : observers_)
Chris Hamilton3b3e315d2018-09-19 13:16:216499 observer.BeforeUnloadFired(proceed, proceed_time);
[email protected]6934a702011-12-20 00:04:516500 if (delegate_)
6501 delegate_->BeforeUnloadFired(this, proceed, proceed_to_fire_unload);
[email protected]e80af492013-06-24 21:52:096502 // Note: |this| might be deleted at this point.
[email protected]420ae012009-04-24 05:16:326503}
6504
[email protected]58d5cfe2013-07-10 02:40:526505void WebContentsImpl::RenderProcessGoneFromRenderManager(
[email protected]3a3d47472010-07-15 21:03:546506 RenderViewHost* render_view_host) {
[email protected]443b80e2010-12-14 00:42:236507 DCHECK(crashed_status_ != base::TERMINATION_STATUS_STILL_RUNNING);
[email protected]ec6a7eb2013-04-22 17:34:226508 RenderViewTerminated(render_view_host, crashed_status_, crashed_error_code_);
[email protected]3a3d47472010-07-15 21:03:546509}
6510
Jianzhou Fengd8720c72018-01-18 03:06:306511void WebContentsImpl::UpdateRenderViewSizeForRenderManager(bool is_main_frame) {
[email protected]8643e6d2012-01-18 20:26:106512 // TODO(brettw) this is a hack. See WebContentsView::SizeContents.
Jianzhou Fengd8720c72018-01-18 03:06:306513 gfx::Size size = GetSizeForNewRenderView(is_main_frame);
[email protected]0323ee42010-02-17 22:03:266514 // 0x0 isn't a valid window size (minimal window size is 1x1) but it may be
6515 // here during container initialization and normal window size will be set
6516 // later. In case of tab duplication this resizing to 0x0 prevents setting
6517 // normal size later so just ignore it.
6518 if (!size.IsEmpty())
6519 view_->SizeContents(size);
[email protected]420ae012009-04-24 05:16:326520}
6521
[email protected]af905902013-10-01 21:38:516522void WebContentsImpl::CancelModalDialogsForRenderManager() {
6523 // We need to cancel modal dialogs when doing a process swap, since the load
avi2460c762015-04-17 15:21:546524 // deferrer would prevent us from swapping out. We also clear the state
6525 // because this is a cross-process navigation, which means that it's a new
6526 // site that should not have to pay for the sins of its predecessor.
creis89a0f782015-05-27 16:13:176527 //
Lei Zhang6410ec1a2019-01-31 21:38:586528 // Note that we don't bother telling |browser_plugin_embedder_| because the
creis89a0f782015-05-27 16:13:176529 // cross-process navigation will either destroy the browser plugins or not
6530 // require their dialogs to close.
avi5d3b8692016-10-12 22:00:466531 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:536532 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:466533 }
[email protected]af905902013-10-01 21:38:516534}
6535
[email protected]02d7b6e2014-06-24 21:01:506536void WebContentsImpl::NotifySwappedFromRenderManager(RenderFrameHost* old_host,
6537 RenderFrameHost* new_host,
6538 bool is_main_frame) {
6539 if (is_main_frame) {
arthursonzognif97bca512019-10-10 11:32:586540 NotifyViewSwapped(old_host ? old_host->GetRenderViewHost() : nullptr,
6541 new_host->GetRenderViewHost());
[email protected]a6b73c62013-02-11 23:05:086542
[email protected]02d7b6e2014-06-24 21:01:506543 // Make sure the visible RVH reflects the new delegate's preferences.
6544 if (delegate_)
6545 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]d56a49e2013-02-23 00:47:396546
dmazzoni62111452017-04-28 23:46:556547 RenderWidgetHostViewBase* rwhv =
6548 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
6549 if (rwhv)
6550 rwhv->SetMainFrameAXTreeID(GetMainFrame()->GetAXTreeID());
[email protected]02d7b6e2014-06-24 21:01:506551 }
6552
Jinsuk Kim895b2c52018-07-03 06:49:166553 NotifyFrameSwapped(old_host, new_host, is_main_frame);
[email protected]3a3d47472010-07-15 21:03:546554}
6555
naskof5940b9f2015-03-02 23:04:056556void WebContentsImpl::NotifyMainFrameSwappedFromRenderManager(
Jinsuk Kim895b2c52018-07-03 06:49:166557 RenderFrameHost* old_host,
6558 RenderFrameHost* new_host) {
6559 NotifyViewSwapped(old_host ? old_host->GetRenderViewHost() : nullptr,
6560 new_host->GetRenderViewHost());
naskof5940b9f2015-03-02 23:04:056561}
6562
[email protected]b172aee2012-04-10 17:05:266563NavigationControllerImpl& WebContentsImpl::GetControllerForRenderManager() {
[email protected]d1198fd2012-08-13 22:50:196564 return GetController();
[email protected]3a3d47472010-07-15 21:03:546565}
6566
dcheng59716272016-04-09 05:19:086567std::unique_ptr<WebUIImpl> WebContentsImpl::CreateWebUIForRenderFrameHost(
carlosk37f793792014-11-27 15:08:296568 const GURL& url) {
Dan Beam055fe8f2017-10-04 23:23:366569 return CreateWebUI(url);
[email protected]420ae012009-04-24 05:16:326570}
6571
creisadca9862017-06-16 19:12:116572InterstitialPageImpl* WebContentsImpl::GetInterstitialForRenderManager() {
6573 return interstitial_page_;
6574}
6575
lfgbede6392015-09-11 21:54:066576void WebContentsImpl::CreateRenderWidgetHostViewForRenderManager(
6577 RenderViewHost* render_view_host) {
lfgc740d4b22016-04-15 16:45:336578 RenderWidgetHostViewBase* rwh_view =
6579 view_->CreateViewForWidget(render_view_host->GetWidget(), false);
danakjf616f2252019-09-18 21:44:096580 rwh_view->SetSize(GetSizeForNewRenderView(true));
lfgbede6392015-09-11 21:54:066581}
6582
6583bool WebContentsImpl::CreateRenderViewForRenderManager(
6584 RenderViewHost* render_view_host,
6585 int opener_frame_routing_id,
6586 int proxy_routing_id,
Pavel Feldman25234722017-10-11 02:49:066587 const base::UnguessableToken& devtools_frame_token,
lfgbede6392015-09-11 21:54:066588 const FrameReplicationState& replicated_frame_state) {
6589 TRACE_EVENT0("browser,navigation",
6590 "WebContentsImpl::CreateRenderViewForRenderManager");
6591
piman00cf9402017-04-03 17:09:206592 if (proxy_routing_id == MSG_ROUTING_NONE)
lfg9431efd2016-12-14 14:45:266593 CreateRenderWidgetHostViewForRenderManager(render_view_host);
lfg9431efd2016-12-14 14:45:266594
piman00cf9402017-04-03 17:09:206595 if (!static_cast<RenderViewHostImpl*>(render_view_host)
6596 ->CreateRenderView(opener_frame_routing_id, proxy_routing_id,
Pavel Feldman25234722017-10-11 02:49:066597 devtools_frame_token, replicated_frame_state,
6598 created_with_opener_)) {
[email protected]a4127722011-04-27 23:13:526599 return false;
[email protected]14392a52012-05-02 20:28:446600 }
W. James MacLean62198672019-06-04 16:46:106601 // Set the TextAutosizer state from the main frame's renderer on the new view,
6602 // but only if it's not for the main frame. Main frame renderers should create
6603 // this state themselves from up-to-date values, so we shouldn't override it
6604 // with the cached values.
6605 if (!render_view_host->GetMainFrame()) {
6606 render_view_host->Send(
6607 new PageMsg_UpdateTextAutosizerPageInfoForRemoteMainFrames(
6608 render_view_host->GetRoutingID(), text_autosizer_page_info_));
6609 }
[email protected]a4127722011-04-27 23:13:526610
Lucas Furukawa Gadaniaed1fed2017-10-13 17:34:146611 if (proxy_routing_id == MSG_ROUTING_NONE && node_.outer_web_contents())
6612 ReattachToOuterWebContentsFrame();
6613
avi2b177592014-12-10 02:08:026614 SetHistoryOffsetAndLengthForView(render_view_host,
6615 controller_.GetLastCommittedEntryIndex(),
6616 controller_.GetEntryCount());
6617
[email protected]a220b5932013-09-21 03:47:446618#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
[email protected]f8233cc2011-05-31 20:24:506619 // Force a ViewMsg_Resize to be sent, needed to make plugins show up on
6620 // linux. See crbug.com/83941.
avif9ab5d942015-10-15 14:05:446621 RenderWidgetHostView* rwh_view = render_view_host->GetWidget()->GetView();
[email protected]245f7d52011-11-28 15:36:446622 if (rwh_view) {
6623 if (RenderWidgetHost* render_widget_host = rwh_view->GetRenderWidgetHost())
Fady Samuel0b911822018-04-25 13:22:166624 render_widget_host->SynchronizeVisualProperties();
[email protected]245f7d52011-11-28 15:36:446625 }
[email protected]f8233cc2011-05-31 20:24:506626#endif
6627
[email protected]420ae012009-04-24 05:16:326628 return true;
6629}
6630
[email protected]82307f6b2014-08-07 03:30:126631bool WebContentsImpl::CreateRenderFrameForRenderManager(
6632 RenderFrameHost* render_frame_host,
arthursonzogni1efc7b962019-03-14 09:36:336633 int previous_routing_id,
alexmosa181efc2015-09-03 00:39:046634 int opener_routing_id,
japhete6adf142014-10-31 00:01:496635 int parent_routing_id,
alexmosa181efc2015-09-03 00:39:046636 int previous_sibling_routing_id) {
naskob8744d22014-08-28 17:07:436637 TRACE_EVENT0("browser,navigation",
6638 "WebContentsImpl::CreateRenderFrameForRenderManager");
[email protected]82307f6b2014-08-07 03:30:126639
6640 RenderFrameHostImpl* rfh =
6641 static_cast<RenderFrameHostImpl*>(render_frame_host);
arthursonzogni1efc7b962019-03-14 09:36:336642 if (!rfh->CreateRenderFrame(previous_routing_id, opener_routing_id,
alexmosa181efc2015-09-03 00:39:046643 parent_routing_id, previous_sibling_routing_id))
[email protected]82307f6b2014-08-07 03:30:126644 return false;
6645
6646 // TODO(nasko): When RenderWidgetHost is owned by RenderFrameHost, the passed
6647 // RenderFrameHost will have to be associated with the appropriate
6648 // RenderWidgetHostView or a new one should be created here.
6649
6650 return true;
6651}
6652
mfomitchev2b8b066a2016-01-28 19:23:156653#if defined(OS_ANDROID)
[email protected]fc2b46b2014-05-03 16:33:456654
[email protected]155c7f22013-12-09 17:07:186655base::android::ScopedJavaLocalRef<jobject>
6656WebContentsImpl::GetJavaWebContents() {
mostynb042582e2015-03-16 22:13:406657 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]0e813a52014-08-13 10:34:566658 return GetWebContentsAndroid()->GetJavaObject();
6659}
[email protected]155c7f22013-12-09 17:07:186660
[email protected]0e813a52014-08-13 10:34:566661WebContentsAndroid* WebContentsImpl::GetWebContentsAndroid() {
Kevin McNee576bb5d82019-05-29 16:47:516662 if (!web_contents_android_) {
6663 web_contents_android_ = std::make_unique<WebContentsAndroid>(this);
[email protected]155c7f22013-12-09 17:07:186664 }
Kevin McNee576bb5d82019-05-29 16:47:516665 return web_contents_android_.get();
6666}
6667
6668void WebContentsImpl::ClearWebContentsAndroid() {
6669 DCHECK_CURRENTLY_ON(BrowserThread::UI);
6670 web_contents_android_.reset();
[email protected]155c7f22013-12-09 17:07:186671}
6672
paulmeyerc0b762b2016-04-13 11:55:176673void WebContentsImpl::ActivateNearestFindResult(float x,
6674 float y) {
6675 GetOrCreateFindRequestManager()->ActivateNearestFindResult(x, y);
6676}
6677
6678void WebContentsImpl::RequestFindMatchRects(int current_version) {
6679 GetOrCreateFindRequestManager()->RequestFindMatchRects(current_version);
6680}
6681
[email protected]7d244f12013-08-22 21:41:516682bool WebContentsImpl::CreateRenderViewForInitialEmptyDocument() {
nasko4c0feb62015-06-05 18:37:066683 return CreateRenderViewForRenderManager(
6684 GetRenderViewHost(), MSG_ROUTING_NONE, MSG_ROUTING_NONE,
Pavel Feldman25234722017-10-11 02:49:066685 frame_tree_.root()->devtools_frame_token(),
lfgbede6392015-09-11 21:54:066686 frame_tree_.root()->current_replication_state());
[email protected]7d244f12013-08-22 21:41:516687}
[email protected]fc2b46b2014-05-03 16:33:456688
rockot400ea35b2016-10-15 19:15:326689service_manager::InterfaceProvider* WebContentsImpl::GetJavaInterfaces() {
sammcf5f1b0f2016-09-20 23:05:116690 if (!java_interfaces_) {
rockot400ea35b2016-10-15 19:15:326691 service_manager::mojom::InterfaceProviderPtr provider;
blundelle0a9f1582016-12-20 11:23:326692 BindInterfaceRegistryForWebContents(mojo::MakeRequest(&provider), this);
rockot400ea35b2016-10-15 19:15:326693 java_interfaces_.reset(new service_manager::InterfaceProvider);
sammcf5f1b0f2016-09-20 23:05:116694 java_interfaces_->Bind(std::move(provider));
6695 }
6696 return java_interfaces_.get();
6697}
6698
Francois Doray6c26f3342018-08-24 17:17:226699#endif
6700
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:416701bool WebContentsImpl::CompletedFirstVisuallyNonEmptyPaint() {
Carlos Caballero91fffb22019-10-29 15:24:306702 return GetRenderViewHost()->did_first_visually_non_empty_paint();
spqchane72c3cb2017-06-30 23:02:106703}
6704
pkotwicz75ca8ffd2016-02-16 23:10:196705void WebContentsImpl::OnDidDownloadImage(
Avi Drissmana5a52dd2018-03-27 03:39:026706 ImageDownloadCallback callback,
pkotwicz75ca8ffd2016-02-16 23:10:196707 int id,
6708 const GURL& image_url,
leon.hancbc4bc3c2016-02-26 07:08:526709 int32_t http_status_code,
leon.hanc2228532016-08-16 05:59:186710 const std::vector<SkBitmap>& images,
6711 const std::vector<gfx::Size>& original_image_sizes) {
Avi Drissmana5a52dd2018-03-27 03:39:026712 std::move(callback).Run(id, http_status_code, image_url, images,
6713 original_image_sizes);
pkotwicz75ca8ffd2016-02-16 23:10:196714}
6715
[email protected]6fba26d2014-04-29 09:38:286716void WebContentsImpl::OnDialogClosed(int render_process_id,
6717 int render_frame_id,
[email protected]b172aee2012-04-10 17:05:266718 IPC::Message* reply_msg,
[email protected]87de04b02014-04-08 22:14:496719 bool dialog_was_suppressed,
[email protected]b172aee2012-04-10 17:05:266720 bool success,
[email protected]fcf75d42013-12-03 20:11:266721 const base::string16& user_input) {
[email protected]6fba26d2014-04-29 09:38:286722 RenderFrameHostImpl* rfh = RenderFrameHostImpl::FromID(render_process_id,
6723 render_frame_id);
[email protected]87de04b02014-04-08 22:14:496724 last_dialog_suppressed_ = dialog_was_suppressed;
6725
Charlie Reis96077362019-07-04 00:34:046726 javascript_dialog_navigation_deferrer_.reset();
6727
[email protected]beb440c2009-11-06 04:08:546728 if (is_showing_before_unload_dialog_ && !success) {
clamybc6f4152016-04-01 20:14:236729 // It is possible for the current RenderFrameHost to have changed in the
6730 // meantime. Do not reset the navigation state in that case.
6731 if (rfh && rfh == rfh->frame_tree_node()->current_frame_host()) {
clamy44e84ce2016-02-22 15:38:256732 rfh->frame_tree_node()->BeforeUnloadCanceled();
clamybc6f4152016-04-01 20:14:236733 controller_.DiscardNonCommittedEntries();
6734 }
[email protected]ec8e8b02013-06-19 04:57:106735
Charles Reis15d60b132017-11-03 17:43:476736 // Update the URL display either way, to avoid showing a stale URL.
6737 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
6738
ericwilligersde386342016-10-19 02:35:096739 for (auto& observer : observers_)
6740 observer.BeforeUnloadDialogCancelled();
[email protected]beb440c2009-11-06 04:08:546741 }
[email protected]87de04b02014-04-08 22:14:496742
[email protected]6fba26d2014-04-29 09:38:286743 if (rfh) {
avi44acfaa82017-05-03 22:55:356744 rfh->JavaScriptDialogClosed(reply_msg, success, user_input);
Pavel Feldman3c1842b2017-08-02 05:00:166745
6746 std::vector<protocol::PageHandler*> page_handlers =
6747 protocol::PageHandler::EnabledForWebContents(this);
6748 for (auto* handler : page_handlers)
6749 handler->DidCloseJavaScriptDialog(success, user_input);
6750
[email protected]6fba26d2014-04-29 09:38:286751 } else {
6752 // Don't leak the sync IPC reply if the RFH or process is gone.
6753 delete reply_msg;
6754 }
avi1c51fb62017-02-27 20:43:036755
6756 is_showing_javascript_dialog_ = false;
6757 is_showing_before_unload_dialog_ = false;
[email protected]beb440c2009-11-06 04:08:546758}
6759
[email protected]1ac10dca2013-08-20 20:47:046760bool WebContentsImpl::IsHidden() {
Francois Doraye6161152018-03-27 22:05:376761 return !IsBeingCaptured() && visibility_ != Visibility::VISIBLE;
[email protected]1ac10dca2013-08-20 20:47:046762}
6763
rob97250742015-12-10 17:45:156764int WebContentsImpl::GetOuterDelegateFrameTreeNodeId() {
lfg601233692017-03-06 22:45:446765 return node_.outer_contents_frame_tree_node_id();
lazyboy6ec48b2a2015-06-29 15:18:146766}
6767
ekaramadaeb3c5c2016-11-09 03:22:356768RenderWidgetHostImpl* WebContentsImpl::GetFullscreenRenderWidgetHost() const {
6769 return RenderWidgetHostImpl::FromID(fullscreen_widget_process_id_,
6770 fullscreen_widget_routing_id_);
6771}
6772
[email protected]b0936d22013-11-28 06:47:366773RenderFrameHostManager* WebContentsImpl::GetRenderManager() const {
[email protected]fa944cb82013-11-15 17:51:216774 return frame_tree_.root()->render_manager();
6775}
6776
[email protected]f8497342013-02-05 22:15:026777BrowserPluginGuest* WebContentsImpl::GetBrowserPluginGuest() const {
[email protected]7a846df2012-09-20 19:17:396778 return browser_plugin_guest_.get();
6779}
6780
Albert J. Wongc55cc64d2018-10-12 02:50:046781void WebContentsImpl::SetBrowserPluginGuest(
6782 std::unique_ptr<BrowserPluginGuest> guest) {
6783 DCHECK(!browser_plugin_guest_);
6784 DCHECK(guest);
6785 browser_plugin_guest_ = std::move(guest);
[email protected]738f57a2013-06-29 21:06:546786}
6787
Aidan Wolter52bcc12a2018-11-14 03:27:296788base::UnguessableToken WebContentsImpl::GetAudioGroupId() {
6789 if (!base::FeatureList::IsEnabled(features::kAudioServiceAudioStreams))
6790 return base::UnguessableToken::Null();
6791
6792 return GetAudioStreamFactory()->group_id();
6793}
6794
Sofiya Semenova5e9d9122019-07-11 02:46:416795ukm::SourceId WebContentsImpl::GetLastCommittedSourceId() {
6796 return last_committed_source_id_;
6797}
6798
[email protected]f8497342013-02-05 22:15:026799BrowserPluginEmbedder* WebContentsImpl::GetBrowserPluginEmbedder() const {
[email protected]7a846df2012-09-20 19:17:396800 return browser_plugin_embedder_.get();
6801}
[email protected]8ff00d72012-10-23 19:12:216802
fsamuel60b42282015-03-10 03:29:146803void WebContentsImpl::CreateBrowserPluginEmbedderIfNecessary() {
6804 if (browser_plugin_embedder_)
6805 return;
6806 browser_plugin_embedder_.reset(BrowserPluginEmbedder::Create(this));
6807}
6808
Jianzhou Fengd8720c72018-01-18 03:06:306809gfx::Size WebContentsImpl::GetSizeForNewRenderView(bool is_main_frame) {
[email protected]dc0fd432013-08-27 15:29:216810 gfx::Size size;
Jianzhou Fengd8720c72018-01-18 03:06:306811 if (is_main_frame)
6812 size = device_emulation_size_;
6813 if (size.IsEmpty() && delegate_)
[email protected]dc0fd432013-08-27 15:29:216814 size = delegate_->GetSizeForNewRenderView(this);
6815 if (size.IsEmpty())
[email protected]fc2b46b2014-05-03 16:33:456816 size = GetContainerBounds().size();
[email protected]dc0fd432013-08-27 15:29:216817 return size;
6818}
6819
[email protected]ae7eeda2014-07-04 01:53:266820void WebContentsImpl::OnFrameRemoved(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:096821 for (auto& observer : observers_)
6822 observer.FrameDeleted(render_frame_host);
[email protected]9b159a52013-10-03 17:24:556823}
6824
[email protected]222f5822014-02-05 23:40:496825void WebContentsImpl::OnPreferredSizeChanged(const gfx::Size& old_size) {
6826 if (!delegate_)
6827 return;
6828 const gfx::Size new_size = GetPreferredSize();
6829 if (new_size != old_size)
6830 delegate_->UpdatePreferredSize(this, new_size);
6831}
6832
Dan Beam055fe8f2017-10-04 23:23:366833std::unique_ptr<WebUIImpl> WebContentsImpl::CreateWebUI(const GURL& url) {
Jeremy Roman04f27c372017-10-27 15:20:556834 std::unique_ptr<WebUIImpl> web_ui = std::make_unique<WebUIImpl>(this);
Lei Zhangee3b63ad2018-06-06 23:25:316835 std::unique_ptr<WebUIController> controller(
avie865b1d2016-10-24 19:42:596836 WebUIControllerFactoryRegistry::GetInstance()
Lei Zhangee3b63ad2018-06-06 23:25:316837 ->CreateWebUIControllerForURL(web_ui.get(), url));
dbeama1b926a2015-08-31 23:17:516838 if (controller) {
Lei Zhangee3b63ad2018-06-06 23:25:316839 web_ui->SetController(std::move(controller));
dbeama1b926a2015-08-31 23:17:516840 return web_ui;
6841 }
6842
avie865b1d2016-10-24 19:42:596843 return nullptr;
dbeama1b926a2015-08-31 23:17:516844}
6845
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:416846FindRequestManager* WebContentsImpl::GetFindRequestManager() {
6847 for (auto* contents = this; contents;
paulmeyerfeafc2d2017-04-25 21:46:406848 contents = contents->GetOuterWebContents()) {
6849 if (contents->find_request_manager_)
6850 return contents->find_request_manager_.get();
6851 }
6852
6853 return nullptr;
6854}
6855
paulmeyerc0b762b2016-04-13 11:55:176856FindRequestManager* WebContentsImpl::GetOrCreateFindRequestManager() {
paulmeyerfeafc2d2017-04-25 21:46:406857 if (FindRequestManager* manager = GetFindRequestManager())
6858 return manager;
6859
Ehsan Karamad6beb2ea2018-11-25 18:15:136860 DCHECK(!browser_plugin_guest_ || GetOuterWebContents());
6861
paulmeyerfeafc2d2017-04-25 21:46:406862 // No existing FindRequestManager found, so one must be created.
6863 find_request_manager_.reset(new FindRequestManager(this));
6864
6865 // Concurrent find sessions must not overlap, so destroy any existing
6866 // FindRequestManagers in any inner WebContentses.
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:166867 for (WebContents* contents : GetWebContentsAndAllInner()) {
6868 auto* web_contents_impl = static_cast<WebContentsImpl*>(contents);
6869 if (web_contents_impl == this)
paulmeyerfeafc2d2017-04-25 21:46:406870 continue;
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:166871 if (web_contents_impl->find_request_manager_) {
6872 web_contents_impl->find_request_manager_->StopFinding(
6873 STOP_FIND_ACTION_CLEAR_SELECTION);
6874 web_contents_impl->find_request_manager_.release();
paulmeyerfeafc2d2017-04-25 21:46:406875 }
6876 }
paulmeyerc0b762b2016-04-13 11:55:176877
6878 return find_request_manager_.get();
6879}
6880
6881void WebContentsImpl::NotifyFindReply(int request_id,
6882 int number_of_matches,
6883 const gfx::Rect& selection_rect,
6884 int active_match_ordinal,
6885 bool final_update) {
Sebastien Marchandcf97ed52017-07-24 23:50:346886 if (delegate_ && !is_being_destroyed_ &&
Lukasz Anforowicze9ae3722017-09-29 17:37:386887 !GetMainFrame()->GetProcess()->FastShutdownStarted()) {
paulmeyerc0b762b2016-04-13 11:55:176888 delegate_->FindReply(this, request_id, number_of_matches, selection_rect,
6889 active_match_ordinal, final_update);
6890 }
6891}
6892
ortuno467e5792016-06-10 04:32:396893void WebContentsImpl::IncrementBluetoothConnectedDeviceCount() {
6894 // Trying to invalidate the tab state while being destroyed could result in a
6895 // use after free.
6896 if (IsBeingDestroyed()) {
6897 return;
6898 }
6899 // Notify for UI updates if the state changes.
6900 bluetooth_connected_device_count_++;
6901 if (bluetooth_connected_device_count_ == 1) {
6902 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6903 }
6904}
6905
6906void WebContentsImpl::DecrementBluetoothConnectedDeviceCount() {
6907 // Trying to invalidate the tab state while being destroyed could result in a
6908 // use after free.
6909 if (IsBeingDestroyed()) {
6910 return;
6911 }
6912 // Notify for UI updates if the state changes.
Lukasz Anforowicze9ae3722017-09-29 17:37:386913 DCHECK_NE(bluetooth_connected_device_count_, 0u);
ortuno467e5792016-06-10 04:32:396914 bluetooth_connected_device_count_--;
6915 if (bluetooth_connected_device_count_ == 0) {
6916 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6917 }
6918}
6919
Reilly Grant5e7c79b22019-04-09 17:26:206920void WebContentsImpl::IncrementSerialActiveFrameCount() {
6921 // Trying to invalidate the tab state while being destroyed could result in a
6922 // use after free.
6923 if (IsBeingDestroyed())
6924 return;
6925
6926 // Notify for UI updates if the state changes.
6927 serial_active_frame_count_++;
6928 if (serial_active_frame_count_ == 1)
6929 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6930}
6931
6932void WebContentsImpl::DecrementSerialActiveFrameCount() {
6933 // Trying to invalidate the tab state while being destroyed could result in a
6934 // use after free.
6935 if (IsBeingDestroyed())
6936 return;
6937
6938 // Notify for UI updates if the state changes.
6939 DCHECK_NE(0u, serial_active_frame_count_);
6940 serial_active_frame_count_--;
6941 if (serial_active_frame_count_ == 0)
6942 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6943}
6944
Matt Reynoldse8c6c1f2019-11-02 09:53:536945void WebContentsImpl::IncrementHidActiveFrameCount() {
6946 // Trying to invalidate the tab state while being destroyed could result in a
6947 // use after free.
6948 if (IsBeingDestroyed())
6949 return;
6950
6951 // Notify for UI updates if the active frame count transitions from zero to
6952 // non-zero.
6953 hid_active_frame_count_++;
6954 if (hid_active_frame_count_ == 1)
6955 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6956}
6957
6958void WebContentsImpl::DecrementHidActiveFrameCount() {
6959 // Trying to invalidate the tab state while being destroyed could result in a
6960 // use after free.
6961 if (IsBeingDestroyed())
6962 return;
6963
6964 // Notify for UI updates if the active frame count transitions from non-zero
6965 // to zero.
6966 DCHECK_NE(0u, hid_active_frame_count_);
6967 hid_active_frame_count_--;
6968 if (hid_active_frame_count_ == 0)
6969 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6970}
6971
Marijn Kruisselbrink29051042019-08-06 22:56:556972void WebContentsImpl::IncrementNativeFileSystemHandleCount() {
6973 // Trying to invalidate the tab state while being destroyed could result in a
6974 // use after free.
6975 if (IsBeingDestroyed())
6976 return;
6977
6978 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
6979 // to update both the tab-level usage indicator and the usage indicator in the
6980 // omnibox.
6981 native_file_system_handle_count_++;
6982 if (native_file_system_handle_count_ == 1) {
6983 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
6984 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
6985 }
6986}
6987
6988void WebContentsImpl::DecrementNativeFileSystemHandleCount() {
6989 // Trying to invalidate the tab state while being destroyed could result in a
6990 // use after free.
6991 if (IsBeingDestroyed())
6992 return;
6993
6994 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
6995 // to update both the tab-level usage indicator and the usage indicator in the
6996 // omnibox.
6997 DCHECK_NE(0u, native_file_system_handle_count_);
6998 native_file_system_handle_count_--;
6999 if (native_file_system_handle_count_ == 0) {
7000 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7001 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7002 }
7003}
7004
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:477005void WebContentsImpl::AddNativeFileSystemDirectoryHandle(
7006 const base::FilePath& path) {
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:337007 // Trying to invalidate the tab state while being destroyed could result in a
7008 // use after free.
7009 if (IsBeingDestroyed())
7010 return;
7011
7012 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7013 // to update both the tab-level usage indicator and the usage indicator in the
7014 // omnibox.
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:477015 const bool was_empty = native_file_system_directory_handles_.empty();
7016 native_file_system_directory_handles_[path]++;
7017 if (was_empty) {
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:337018 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7019 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7020 }
7021}
7022
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:477023void WebContentsImpl::RemoveNativeFileSystemDirectoryHandle(
7024 const base::FilePath& path) {
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:337025 // Trying to invalidate the tab state while being destroyed could result in a
7026 // use after free.
7027 if (IsBeingDestroyed())
7028 return;
7029
7030 // Notify for UI updates if the state changes. Need both TYPE_TAB and TYPE_URL
7031 // to update both the tab-level usage indicator and the usage indicator in the
7032 // omnibox.
Marijn Kruisselbrink46fa4bd2019-07-11 18:15:477033 auto it = native_file_system_directory_handles_.find(path);
7034 DCHECK(it != native_file_system_directory_handles_.end());
7035 DCHECK_NE(0u, it->second);
7036 it->second--;
7037 if (it->second == 0)
7038 native_file_system_directory_handles_.erase(it);
7039 if (native_file_system_directory_handles_.empty()) {
Marijn Kruisselbrinkf1714aa22019-07-02 03:45:337040 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7041 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7042 }
7043}
7044
7045void WebContentsImpl::IncrementWritableNativeFileSystemHandleCount() {
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_writable_handle_count_++;
7055 if (native_file_system_writable_handle_count_ == 1) {
7056 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7057 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7058 }
7059}
7060
7061void WebContentsImpl::DecrementWritableNativeFileSystemHandleCount() {
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_writable_handle_count_);
7071 native_file_system_writable_handle_count_--;
7072 if (native_file_system_writable_handle_count_ == 0) {
7073 NotifyNavigationStateChanged(static_cast<content::InvalidateTypes>(
7074 INVALIDATE_TYPE_TAB | INVALIDATE_TYPE_URL));
7075 }
7076}
7077
zqzhang8ac49002017-03-16 21:51:357078void WebContentsImpl::SetHasPersistentVideo(bool has_persistent_video) {
7079 if (has_persistent_video_ == has_persistent_video)
mlamouri5cd9ae82017-02-18 11:05:097080 return;
7081
zqzhang8ac49002017-03-16 21:51:357082 has_persistent_video_ = has_persistent_video;
mlamouri5cd9ae82017-02-18 11:05:097083 NotifyPreferencesChanged();
zqzhang8ac49002017-03-16 21:51:357084 media_web_contents_observer()->RequestPersistentVideo(has_persistent_video);
mlamouri5cd9ae82017-02-18 11:05:097085}
7086
Ian Vollick5d5c37f2019-06-19 22:50:577087void WebContentsImpl::SetSpatialNavigationDisabled(bool disabled) {
7088 if (is_spatial_navigation_disabled_ == disabled)
7089 return;
7090
7091 is_spatial_navigation_disabled_ = disabled;
7092 NotifyPreferencesChanged();
7093}
7094
paulmeyerfeafc2d2017-04-25 21:46:407095void WebContentsImpl::BrowserPluginGuestWillDetach() {
7096 WebContentsImpl* outermost = GetOutermostWebContents();
7097 if (this != outermost && ContainsOrIsFocusedWebContents())
7098 outermost->SetAsFocusedWebContentsIfNecessary();
7099}
7100
Becca Hughes112832e2019-06-11 17:19:027101PictureInPictureResult WebContentsImpl::EnterPictureInPicture(
Mounir Lamouri11e9ef42018-05-22 03:10:167102 const viz::SurfaceId& surface_id,
7103 const gfx::Size& natural_size) {
François Beaufortf09e4462019-01-18 14:34:517104 return delegate_
7105 ? delegate_->EnterPictureInPicture(this, surface_id, natural_size)
Becca Hughes112832e2019-06-11 17:19:027106 : PictureInPictureResult::kNotSupported;
Mounir Lamouri11e9ef42018-05-22 03:10:167107}
7108
Mounir Lamouri6d759e12018-05-16 20:01:307109void WebContentsImpl::ExitPictureInPicture() {
7110 if (delegate_)
7111 delegate_->ExitPictureInPicture();
7112}
7113
paulmeyerc0b762b2016-04-13 11:55:177114#if defined(OS_ANDROID)
7115void WebContentsImpl::NotifyFindMatchRectsReply(
7116 int version,
7117 const std::vector<gfx::RectF>& rects,
7118 const gfx::RectF& active_rect) {
7119 if (delegate_)
7120 delegate_->FindMatchRectsReply(this, version, rects, active_rect);
7121}
7122#endif
7123
[email protected]34ff1cfc2014-08-20 06:16:057124void WebContentsImpl::SetForceDisableOverscrollContent(bool force_disable) {
7125 force_disable_overscroll_content_ = force_disable;
7126 if (view_)
7127 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
7128}
7129
Jianzhou Fengd8720c72018-01-18 03:06:307130bool WebContentsImpl::SetDeviceEmulationSize(const gfx::Size& new_size) {
7131 device_emulation_size_ = new_size;
7132 RenderWidgetHostView* rwhv = GetMainFrame()->GetView();
7133
7134 const gfx::Size current_size = rwhv->GetViewBounds().size();
7135 if (view_size_before_emulation_.IsEmpty())
7136 view_size_before_emulation_ = current_size;
7137
7138 if (current_size != new_size)
7139 rwhv->SetSize(new_size);
7140
7141 return current_size != new_size;
7142}
7143
7144void WebContentsImpl::ClearDeviceEmulationSize() {
7145 RenderWidgetHostView* rwhv = GetMainFrame()->GetView();
7146 // WebContentsView could get resized during emulation, which also resizes
7147 // RWHV. If it happens, assume user would like to keep using the size after
7148 // emulation.
7149 // TODO(jzfeng): Prohibit resizing RWHV through any other means (at least when
7150 // WebContentsView size changes).
Dmitry Gozmanc63707182018-03-06 00:09:397151 if (!view_size_before_emulation_.IsEmpty() && rwhv &&
7152 rwhv->GetViewBounds().size() == device_emulation_size_) {
Jianzhou Fengd8720c72018-01-18 03:06:307153 rwhv->SetSize(view_size_before_emulation_);
Dmitry Gozmanc63707182018-03-06 00:09:397154 }
Jianzhou Fengd8720c72018-01-18 03:06:307155 device_emulation_size_ = gfx::Size();
7156 view_size_before_emulation_ = gfx::Size();
7157}
7158
Max Morin5bc74f52018-05-09 07:00:217159ForwardingAudioStreamFactory* WebContentsImpl::GetAudioStreamFactory() {
7160 if (!audio_stream_factory_) {
7161 audio_stream_factory_.emplace(
7162 this,
Max Morinddebb972018-09-20 10:04:147163 // BrowserMainLoop::GetInstance() may be null in unit tests.
7164 BrowserMainLoop::GetInstance()
7165 ? static_cast<media::UserInputMonitorBase*>(
7166 BrowserMainLoop::GetInstance()->user_input_monitor())
7167 : nullptr,
Ken Rockotfd03e682019-06-20 21:13:547168 GetSystemConnector()->Clone(), AudioStreamBrokerFactory::CreateImpl());
Max Morin5bc74f52018-05-09 07:00:217169 }
7170
7171 return &*audio_stream_factory_;
7172}
7173
dalecurtis88c240072015-12-09 02:11:187174void WebContentsImpl::MediaStartedPlaying(
billorr21c005d2016-11-17 03:57:047175 const WebContentsObserver::MediaPlayerInfo& media_info,
Mounir Lamouri0f5bdf52019-04-04 16:32:357176 const MediaPlayerId& id) {
billorr21c005d2016-11-17 03:57:047177 if (media_info.has_video)
7178 currently_playing_video_count_++;
7179
ericwilligersde386342016-10-19 02:35:097180 for (auto& observer : observers_)
billorr21c005d2016-11-17 03:57:047181 observer.MediaStartedPlaying(media_info, id);
dalecurtis88c240072015-12-09 02:11:187182}
7183
7184void WebContentsImpl::MediaStoppedPlaying(
billorr21c005d2016-11-17 03:57:047185 const WebContentsObserver::MediaPlayerInfo& media_info,
Mounir Lamouri0f5bdf52019-04-04 16:32:357186 const MediaPlayerId& id,
Becca Hughes220bfc102017-11-14 18:24:077187 WebContentsObserver::MediaStoppedReason reason) {
billorr21c005d2016-11-17 03:57:047188 if (media_info.has_video)
7189 currently_playing_video_count_--;
7190
ericwilligersde386342016-10-19 02:35:097191 for (auto& observer : observers_)
Becca Hughes220bfc102017-11-14 18:24:077192 observer.MediaStoppedPlaying(media_info, id, reason);
billorr21c005d2016-11-17 03:57:047193}
7194
Mounir Lamouri0f5bdf52019-04-04 16:32:357195void WebContentsImpl::MediaResized(const gfx::Size& size,
7196 const MediaPlayerId& id) {
peconn257951522017-06-09 18:24:597197 cached_video_sizes_[id] = size;
7198
7199 for (auto& observer : observers_)
7200 observer.MediaResized(size, id);
7201}
7202
Peter E Conneccb34c22017-09-08 09:37:587203void WebContentsImpl::MediaEffectivelyFullscreenChanged(bool is_fullscreen) {
7204 for (auto& observer : observers_)
7205 observer.MediaEffectivelyFullscreenChanged(is_fullscreen);
7206}
7207
Peter Conn31c726a2017-08-17 11:07:347208base::Optional<gfx::Size> WebContentsImpl::GetFullscreenVideoSize() {
Mounir Lamouri0f5bdf52019-04-04 16:32:357209 base::Optional<MediaPlayerId> id =
Peter Conn31c726a2017-08-17 11:07:347210 media_web_contents_observer_->GetFullscreenVideoMediaPlayerId();
Jan Wilken Dörrie531be7ca2019-06-07 10:05:577211 if (id && base::Contains(cached_video_sizes_, id.value()))
Peter Conn31c726a2017-08-17 11:07:347212 return base::Optional<gfx::Size>(cached_video_sizes_[id.value()]);
Lei Zhang6410ec1a2019-01-31 21:38:587213 return base::nullopt;
peconn257951522017-06-09 18:24:597214}
7215
billorr21c005d2016-11-17 03:57:047216int WebContentsImpl::GetCurrentlyPlayingVideoCount() {
7217 return currently_playing_video_count_;
dalecurtis88c240072015-12-09 02:11:187218}
7219
Raymond Toye413650c2018-08-31 00:12:477220void WebContentsImpl::AudioContextPlaybackStarted(RenderFrameHost* host,
7221 int context_id) {
7222 WebContentsObserver::AudioContextId audio_context_id(host, context_id);
7223 for (auto& observer : observers_)
7224 observer.AudioContextPlaybackStarted(audio_context_id);
7225}
7226
7227void WebContentsImpl::AudioContextPlaybackStopped(RenderFrameHost* host,
7228 int context_id) {
7229 WebContentsObserver::AudioContextId audio_context_id(host, context_id);
7230 for (auto& observer : observers_)
7231 observer.AudioContextPlaybackStopped(audio_context_id);
7232}
7233
evliufc233aa2019-10-31 19:53:037234void WebContentsImpl::MediaWatchTimeChanged(
7235 const content::MediaPlayerWatchTime& watch_time) {
7236 for (auto& observer : observers_)
7237 observer.MediaWatchTimeChanged(watch_time);
7238}
7239
evliu7f736f02019-11-07 17:43:507240media::MediaMetricsProvider::RecordAggregateWatchTimeCallback
7241WebContentsImpl::GetRecordAggregateWatchTimeCallback() {
7242 return base::BindRepeating(
7243 [](base::WeakPtr<RenderFrameHostDelegate> delegate,
7244 GURL last_committed_url, base::TimeDelta total_watch_time,
evliua283c9e2019-11-08 22:57:227245 base::TimeDelta time_stamp, bool has_video, bool has_audio) {
7246 content::MediaPlayerWatchTime watch_time(
7247 last_committed_url, last_committed_url.GetOrigin(),
7248 total_watch_time, time_stamp, has_video, has_audio);
evliu7f736f02019-11-07 17:43:507249
7250 // Save the watch time if the delegate is still alive.
7251 if (delegate)
7252 delegate->MediaWatchTimeChanged(watch_time);
7253 },
7254 weak_factory_.GetWeakPtr(), GetMainFrameLastCommittedURL());
7255}
7256
Ehsan Karamad1c631762019-05-13 23:04:017257RenderFrameHostImpl* WebContentsImpl::GetMainFrameForInnerDelegate(
7258 FrameTreeNode* frame_tree_node) {
7259 if (auto* web_contents = node_.GetInnerWebContentsInFrame(frame_tree_node))
7260 return web_contents->GetMainFrame();
7261 return nullptr;
7262}
7263
John Budorickee1c9512019-10-17 15:32:197264bool WebContentsImpl::IsFrameLowPriority(
7265 const RenderFrameHost* render_frame_host) {
7266 if (!delegate_)
7267 return false;
7268 return delegate_->IsFrameLowPriority(this, render_frame_host);
7269}
7270
Francois Doraye6161152018-03-27 22:05:377271void WebContentsImpl::UpdateWebContentsVisibility(Visibility visibility) {
Francois Doray3f2afbd2018-04-06 19:18:187272 // Occlusion is disabled when |features::kWebContentsOcclusion| is disabled
7273 // (for power and speed impact assessment) or when
7274 // |switches::kDisableBackgroundingOccludedWindowsForTesting| is specified on
7275 // the command line (to avoid flakiness in browser tests).
7276 const bool occlusion_is_disabled =
7277 !base::FeatureList::IsEnabled(features::kWebContentsOcclusion) ||
Francois Doraye6161152018-03-27 22:05:377278 base::CommandLine::ForCurrentProcess()->HasSwitch(
7279 switches::kDisableBackgroundingOccludedWindowsForTesting);
7280 if (occlusion_is_disabled && visibility == Visibility::OCCLUDED)
7281 visibility = Visibility::VISIBLE;
7282
tapted65ff2ea72016-03-01 23:39:007283 if (!did_first_set_visible_) {
Francois Doraye6161152018-03-27 22:05:377284 if (visibility == Visibility::VISIBLE) {
7285 // A WebContents created with CreateParams::initially_hidden = false
7286 // starts with GetVisibility() == Visibility::VISIBLE even though it is
7287 // not really visible. Call WasShown() when it becomes visible for real as
7288 // the page load mechanism and some WebContentsObserver rely on that.
tapted65ff2ea72016-03-01 23:39:007289 WasShown();
Francois Dorayfe4a1772018-02-17 04:17:097290 did_first_set_visible_ = true;
tapted65ff2ea72016-03-01 23:39:007291 }
Francois Doraye6161152018-03-27 22:05:377292
7293 // Trust the initial visibility of the WebContents and do not switch it to
7294 // HIDDEN or OCCLUDED before it becomes VISIBLE for real. Doing so would
7295 // result in destroying resources that would immediately be recreated (e.g.
7296 // UpdateWebContents(HIDDEN) can be called when a WebContents is added to a
7297 // hidden window that is about to be shown).
7298
tapted65ff2ea72016-03-01 23:39:007299 return;
7300 }
Francois Doraye6161152018-03-27 22:05:377301
7302 if (visibility == visibility_)
tapted65ff2ea72016-03-01 23:39:007303 return;
7304
Collin Baker989e0882019-11-01 01:27:177305 UpdateVisibilityAndNotifyPageAndView(visibility);
tapted65ff2ea72016-03-01 23:39:007306}
7307
aelias5252baa2016-04-10 01:18:027308void WebContentsImpl::UpdateOverridingUserAgent() {
mlamouri5cd9ae82017-02-18 11:05:097309 NotifyPreferencesChanged();
aelias5252baa2016-04-10 01:18:027310}
7311
avid53461d2016-02-25 17:15:047312void WebContentsImpl::SetJavaScriptDialogManagerForTesting(
7313 JavaScriptDialogManager* dialog_manager) {
7314 dialog_manager_ = dialog_manager;
7315}
7316
rockotf62002a2016-09-15 00:08:597317void WebContentsImpl::RemoveBindingSet(const std::string& interface_name) {
7318 auto it = binding_sets_.find(interface_name);
7319 if (it != binding_sets_.end())
7320 binding_sets_.erase(it);
7321}
7322
nzolghadrd87a308d2016-12-07 15:45:567323bool WebContentsImpl::AddDomainInfoToRapporSample(rappor::Sample* sample) {
nzolghadrbbffc6c2017-05-25 17:56:397324 // Here we associate this metric to the main frame URL regardless of what
7325 // caused it.
nzolghadrd87a308d2016-12-07 15:45:567326 sample->SetStringField("Domain", ::rappor::GetDomainAndRegistrySampleFromGURL(
7327 GetLastCommittedURL()));
nzolghadrd87a308d2016-12-07 15:45:567328 return true;
7329}
7330
falken52a56e32016-12-08 05:02:407331void WebContentsImpl::ShowInsecureLocalhostWarningIfNeeded() {
7332 bool allow_localhost = base::CommandLine::ForCurrentProcess()->HasSwitch(
7333 switches::kAllowInsecureLocalhost);
7334 if (!allow_localhost)
7335 return;
7336
7337 content::NavigationEntry* entry = GetController().GetLastCommittedEntry();
Rob Wuf79b3ba2018-01-14 01:54:317338 if (!entry || !net::IsLocalhost(entry->GetURL()))
falken52a56e32016-12-08 05:02:407339 return;
7340
7341 content::SSLStatus ssl_status = entry->GetSSL();
Matt Mueller936511442019-09-03 18:15:127342 if (!net::IsCertStatusError(ssl_status.cert_status))
falken52a56e32016-12-08 05:02:407343 return;
7344
7345 GetMainFrame()->AddMessageToConsole(
Abhijeet Kandalkara5928a0a2019-03-13 05:04:427346 blink::mojom::ConsoleMessageLevel::kWarning,
falken52a56e32016-12-08 05:02:407347 base::StringPrintf("This site does not have a valid SSL "
7348 "certificate! Without SSL, your site's and "
7349 "visitors' data is vulnerable to theft and "
7350 "tampering. Get a valid SSL certificate before"
7351 " releasing your website to the public."));
7352}
7353
ekaramadf6750aa2017-06-06 18:29:427354bool WebContentsImpl::IsShowingContextMenuOnPage() const {
7355 return showing_context_menu_;
7356}
7357
Min Qina904f3302018-02-13 23:33:347358download::DownloadUrlParameters::RequestHeadersType
7359WebContentsImpl::ParseDownloadHeaders(const std::string& headers) {
7360 download::DownloadUrlParameters::RequestHeadersType request_headers;
Megan Jablonski2f6a4c52017-07-10 23:01:257361 for (const base::StringPiece& key_value : base::SplitStringPiece(
7362 headers, "\r\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
7363 std::vector<std::string> pair = base::SplitString(
7364 key_value, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
7365 if (2ul == pair.size())
7366 request_headers.push_back(make_pair(pair[0], pair[1]));
7367 }
7368 return request_headers;
7369}
7370
lukasza6f8ac622017-06-06 03:10:207371void WebContentsImpl::SetOpenerForNewContents(FrameTreeNode* opener,
7372 bool opener_suppressed) {
7373 if (opener) {
7374 FrameTreeNode* new_root = GetFrameTree()->root();
7375
7376 // For the "original opener", track the opener's main frame instead, because
7377 // if the opener is a subframe, the opener tracking could be easily bypassed
7378 // by spawning from a subframe and deleting the subframe.
7379 // https://crbug.com/705316
7380 new_root->SetOriginalOpener(opener->frame_tree()->root());
7381
7382 if (!opener_suppressed) {
7383 new_root->SetOpener(opener);
7384 created_with_opener_ = true;
7385 }
7386 }
7387}
7388
Mounir Lamouri0f5bdf52019-04-04 16:32:357389void WebContentsImpl::MediaMutedStatusChanged(const MediaPlayerId& id,
7390 bool muted) {
Becca Hughes9f6fd4b82017-06-15 10:01:407391 for (auto& observer : observers_)
7392 observer.MediaMutedStatusChanged(id, muted);
7393}
7394
EhsanK2075c7e2017-08-21 02:42:397395void WebContentsImpl::SetVisibilityForChildViews(bool visible) {
7396 GetMainFrame()->SetVisibilityForChildViews(visible);
7397}
7398
Dave Tapuskae782bea2019-07-09 16:21:517399mojom::FrameInputHandler* WebContentsImpl::GetFocusedFrameInputHandler() {
7400 auto* focused_frame = GetFocusedFrame();
7401 if (!focused_frame)
7402 return nullptr;
7403 return focused_frame->GetFrameInputHandler();
7404}
7405
[email protected]8ff00d72012-10-23 19:12:217406} // namespace content