blob: 5cbb7018516e251e7757de70d78878bedceb51e0 [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"
jinsukkim79df88a2017-01-04 06:26:1517#include "base/i18n/character_encoding.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"
[email protected]04cbd3d2013-12-04 04:58:2027#include "base/process/process.h"
skyostil95082a62015-06-05 19:53:0728#include "base/single_thread_task_runner.h"
Arthur Sonzogni929d29f2018-09-17 14:19:4429#include "base/stl_util.h"
[email protected]348fbaac2013-06-11 06:31:5130#include "base/strings/string16.h"
31#include "base/strings/string_number_conversions.h"
Avi Drissman4891b852018-09-25 18:12:5832#include "base/strings/string_split.h"
[email protected]348fbaac2013-06-11 06:31:5133#include "base/strings/string_util.h"
[email protected]74ebfb12013-06-07 20:48:0034#include "base/strings/utf_string_conversions.h"
Eric Seckler8652dcd52018-09-20 10:42:2835#include "base/task/post_task.h"
gab30f26df2016-05-11 19:37:5536#include "base/threading/thread_task_runner_handle.h"
[email protected]a43858f2013-06-28 15:18:3737#include "base/time/time.h"
ssid3e765612015-01-28 04:03:4238#include "base/trace_event/trace_event.h"
avib7348942015-12-25 20:57:1039#include "build/build_config.h"
Min Qinda0ed2062018-02-23 22:00:5340#include "components/download/public/common/download_stats.h"
nzolghadrd87a308d2016-12-07 15:45:5641#include "components/rappor/public/rappor_utils.h"
rsleevi24f64dc22015-08-07 21:39:2142#include "components/url_formatter/url_formatter.h"
James Wallace-Leeeafc94cb92018-07-23 21:35:0943#include "content/browser/accessibility/accessibility_tree_formatter.h"
44#include "content/browser/accessibility/accessibility_tree_formatter_blink.h"
jamescookda2505812015-03-20 18:01:1845#include "content/browser/bad_message.h"
Max Morinddebb972018-09-20 10:04:1446#include "content/browser/browser_main_loop.h"
[email protected]7a846df2012-09-20 19:17:3947#include "content/browser/browser_plugin/browser_plugin_embedder.h"
48#include "content/browser/browser_plugin/browser_plugin_guest.h"
[email protected]b9535422012-02-09 01:47:5949#include "content/browser/child_process_security_policy_impl.h"
Pavel Feldman3c1842b2017-08-02 05:00:1650#include "content/browser/devtools/protocol/page_handler.h"
dgozmanf00c4f72016-10-19 17:45:1551#include "content/browser/devtools/render_frame_devtools_agent_host.h"
Becca Hughes3b5a43482018-07-17 22:31:5552#include "content/browser/display_cutout/display_cutout_host_impl.h"
[email protected]5f2aa722013-08-07 16:59:4153#include "content/browser/dom_storage/dom_storage_context_wrapper.h"
[email protected]1ea3c792012-04-17 01:25:0454#include "content/browser/dom_storage/session_storage_namespace_impl.h"
[email protected]aa4f3972012-03-01 18:12:1255#include "content/browser/download/mhtml_generation_manager.h"
[email protected]a53209b2012-01-20 16:48:1656#include "content/browser/download/save_package.h"
paulmeyerc0b762b2016-04-13 11:55:1757#include "content/browser/find_request_manager.h"
[email protected]bffc8302014-01-23 20:52:1658#include "content/browser/frame_host/cross_process_frame_connector.h"
ananta4b7467a52016-09-23 01:42:3859#include "content/browser/frame_host/frame_tree_node.h"
[email protected]d4a8ca482013-10-30 21:06:4060#include "content/browser/frame_host/interstitial_page_impl.h"
61#include "content/browser/frame_host/navigation_entry_impl.h"
clamy0e119882015-07-31 16:12:3362#include "content/browser/frame_host/navigation_handle_impl.h"
Arthur Hemeryc3380172018-01-22 14:00:1763#include "content/browser/frame_host/navigation_request.h"
[email protected]6ea6bdf2013-12-06 13:35:0164#include "content/browser/frame_host/navigator_impl.h"
[email protected]52913802013-12-10 05:52:1865#include "content/browser/frame_host/render_frame_host_impl.h"
lfgdb5c4ed2016-03-04 23:09:0766#include "content/browser/frame_host/render_frame_proxy_host.h"
Kenneth Russell954ed9ce2018-04-12 23:07:0167#include "content/browser/gpu/gpu_data_manager_impl.h"
csharrison2e8c98e2016-08-01 23:56:2568#include "content/browser/loader/loader_io_thread_notifier.h"
[email protected]678c0362012-12-05 08:02:4469#include "content/browser/loader/resource_dispatcher_host_impl.h"
mlamouriefdca9d2014-09-16 16:55:4070#include "content/browser/manifest/manifest_manager_host.h"
Max Morin5bc74f52018-05-09 07:00:2171#include "content/browser/media/audio_stream_broker.h"
dalecurtisbc6572e12014-09-12 19:22:3072#include "content/browser/media/audio_stream_monitor.h"
miu50f97892014-09-22 22:49:5273#include "content/browser/media/capture/web_contents_audio_muter.h"
dalecurtis88c240072015-12-09 02:11:1874#include "content/browser/media/media_web_contents_observer.h"
zqzhang1adf3cb2016-11-01 11:26:4575#include "content/browser/media/session/media_session_impl.h"
tommyclieb25b2a2014-11-03 19:45:0976#include "content/browser/plugin_content_origin_whitelist.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"
lfgc740d4b22016-04-15 16:45:3387#include "content/browser/web_contents/web_contents_view_child_frame.h"
[email protected]b5a40842012-11-28 15:26:1188#include "content/browser/web_contents/web_contents_view_guest.h"
[email protected]eb2ef212013-01-29 04:27:5889#include "content/browser/webui/generic_handler.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"
[email protected]31a71eaf2014-03-13 01:47:36102#include "content/public/browser/ax_event_notification_details.h"
[email protected]ccb797302011-12-15 16:55:11103#include "content/public/browser/browser_context.h"
[email protected]139355f2014-05-11 14:21:28104#include "content/public/browser/browser_plugin_guest_manager.h"
Eric Seckler8652dcd52018-09-20 10:42:28105#include "content/public/browser/browser_task_traits.h"
Gabriel Charette790754c2018-03-16 21:32:59106#include "content/public/browser/browser_thread.h"
[email protected]87f3c082011-10-19 18:07:44107#include "content/public/browser/content_browser_client.h"
[email protected]e582fdd2011-12-20 16:48:17108#include "content/public/browser/download_manager.h"
Kent Tamura512a27e2018-10-04 00:49:32109#include "content/public/browser/file_select_listener.h"
ekaramada110f642016-12-21 19:47:28110#include "content/public/browser/focused_node_details.h"
ekaramad1beabecc2016-09-23 20:18:17111#include "content/public/browser/guest_mode.h"
[email protected]d9083482012-01-06 00:38:46112#include "content/public/browser/invalidate_type.h"
[email protected]71a88bb2013-02-01 22:05:15113#include "content/public/browser/javascript_dialog_manager.h"
skyf65d9bb2017-03-24 02:26:39114#include "content/public/browser/keyboard_event_processing_result.h"
[email protected]09d31d52012-03-11 22:30:27115#include "content/public/browser/load_notification_details.h"
[email protected]5b96836f2011-12-22 07:39:00116#include "content/public/browser/navigation_details.h"
[email protected]375fa1b2012-05-22 22:05:37117#include "content/public/browser/notification_details.h"
[email protected]be2510c02012-05-28 14:52:14118#include "content/public/browser/notification_service.h"
scottmg011d96e32016-06-29 19:15:08119#include "content/public/browser/notification_types.h"
[email protected]95640212014-07-26 18:14:30120#include "content/public/browser/render_widget_host_iterator.h"
Lukasz Anforowicze1b954d92017-10-30 21:28:06121#include "content/public/browser/restore_type.h"
estark5ea80e52015-06-19 18:43:12122#include "content/public/browser/security_style_explanations.h"
falken52a56e32016-12-08 05:02:40123#include "content/public/browser/ssl_status.h"
[email protected]4c3a23582012-08-18 08:54:34124#include "content/public/browser/storage_partition.h"
Ken Rockotfd03e682019-06-20 21:13:54125#include "content/public/browser/system_connector.h"
rockotf62002a2016-09-15 00:08:59126#include "content/public/browser/web_contents_binding_set.h"
[email protected]674bc592011-12-20 23:00:42127#include "content/public/browser/web_contents_delegate.h"
Lei Zhangee3b63ad2018-06-06 23:25:31128#include "content/public/browser/web_ui_controller.h"
[email protected]e091df82011-10-11 18:13:21129#include "content/public/common/bindings_policy.h"
alexmosc9e76ec2016-05-16 22:59:37130#include "content/public/common/child_process_host.h"
[email protected]54087fe2011-10-28 22:02:48131#include "content/public/common/content_constants.h"
Francois Doray3f2afbd2018-04-06 19:18:18132#include "content/public/common/content_features.h"
[email protected]64d69de42012-02-06 00:19:54133#include "content/public/common/content_switches.h"
Lukasz Anforowicze1b954d92017-10-30 21:28:06134#include "content/public/common/page_state.h"
[email protected]7940b8e2013-07-25 23:08:49135#include "content/public/common/page_zoom.h"
Leon Han963dc182018-11-06 05:41:48136#include "content/public/common/referrer_type_converters.h"
[email protected]04cbd3d2013-12-04 04:58:20137#include "content/public/common/result_codes.h"
[email protected]f16cc6782013-12-16 23:42:57138#include "content/public/common/url_utils.h"
[email protected]b3a97b52014-07-09 06:25:05139#include "content/public/common/web_preferences.h"
Max Morinddebb972018-09-20 10:04:14140#include "media/base/user_input_monitor.h"
wjmaclean64951902016-04-29 20:59:12141#include "net/base/url_util.h"
[email protected]8bfc8272013-09-09 20:10:53142#include "net/http/http_cache.h"
143#include "net/http/http_transaction_factory.h"
rhalavati0fbaeef32017-06-01 15:56:30144#include "net/traffic_annotation/network_traffic_annotation.h"
[email protected]8bfc8272013-09-09 20:10:53145#include "net/url_request/url_request_context.h"
[email protected]abe2c032011-03-31 18:49:34146#include "net/url_request/url_request_context_getter.h"
Scott Violet02e38b92018-03-27 23:42:14147#include "ppapi/buildflags/buildflags.h"
Ke He31d0bb02018-02-24 07:16:24148#include "services/device/public/mojom/constants.mojom.h"
Mounir Lamourifd9dcefa2017-07-06 10:26:55149#include "services/metrics/public/cpp/ukm_recorder.h"
John Abd-El-Malekb175a612018-12-03 20:11:58150#include "services/network/public/cpp/features.h"
Ke He7319dbe2017-11-09 05:54:44151#include "services/service_manager/public/cpp/connector.h"
rockot734fb662016-10-15 16:41:30152#include "services/service_manager/public/cpp/interface_provider.h"
Becca Hughes6daf5662018-06-27 16:50:54153#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
Blink Reformata30d4232018-04-07 15:31:06154#include "third_party/blink/public/common/frame/sandbox_flags.h"
155#include "third_party/blink/public/common/mime_util/mime_util.h"
Takuto Ikutaaa3b796c2019-02-06 02:54:56156#include "third_party/blink/public/mojom/loader/pause_subresource_loading_handle.mojom.h"
Antonio Gomes0d42960a2019-06-05 12:35:51157#include "third_party/blink/public/mojom/mediastream/media_stream.mojom-shared.h"
Blink Reformata30d4232018-04-07 15:31:06158#include "third_party/blink/public/platform/web_security_style.h"
halton.huoca2eabd2015-07-06 08:17:40159#include "third_party/skia/include/core/SkBitmap.h"
dmazzonid95ae842016-04-12 21:17:39160#include "ui/accessibility/ax_tree_combiner.h"
[email protected]a08412b62012-05-29 21:28:56161#include "ui/base/layout.h"
Daniel Cheng90196c82018-04-25 21:49:14162#include "ui/events/base_event_utils.h"
chongz4a9751942016-08-17 17:49:39163#include "ui/events/blink/web_input_event_traits.h"
[email protected]66bd5512012-08-01 02:02:52164#include "ui/gl/gl_switches.h"
[email protected]3c733bde2010-12-21 19:56:31165
ekaramada110f642016-12-21 19:47:28166#if defined(OS_WIN)
167#include "content/browser/renderer_host/dip_util.h"
168#include "ui/gfx/geometry/dip_util.h"
169#endif
170
[email protected]583418cc2013-01-17 14:01:10171#if defined(OS_ANDROID)
mfomitchev2b8b066a2016-01-28 19:23:15172#include "content/browser/android/date_time_chooser_android.h"
sammcf5f1b0f2016-09-20 23:05:11173#include "content/browser/android/java_interfaces_impl.h"
[email protected]155c7f22013-12-09 17:07:18174#include "content/browser/web_contents/web_contents_android.h"
Ke He31d0bb02018-02-24 07:16:24175#include "services/device/public/mojom/nfc.mojom.h"
mcnee336ea2c2017-05-23 22:50:59176#else // !OS_ANDROID
177#include "content/browser/host_zoom_map_impl.h"
178#include "content/browser/host_zoom_map_observer.h"
mfomitchev2b8b066a2016-01-28 19:23:15179#endif // OS_ANDROID
[email protected]583418cc2013-01-17 14:01:10180
brettw4b461082016-11-19 18:55:16181#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17182#include "content/browser/media/session/pepper_playback_observer.h"
Lei Zhangebcc6302018-01-12 19:46:45183#endif
zqzhang181047e62016-07-01 13:37:17184
[email protected]8ff00d72012-10-23 19:12:21185namespace content {
[email protected]420ae012009-04-24 05:16:32186namespace {
187
[email protected]960b0372014-05-19 18:01:00188const int kMinimumDelayBetweenLoadingUpdatesMS = 100;
[email protected]82114f52012-03-20 22:53:41189const char kDotGoogleDotCom[] = ".google.com";
[email protected]ca406032011-07-19 21:53:05190
Avi Drissmana9114822018-03-23 18:25:55191base::LazyInstance<std::vector<
192 WebContentsImpl::FriendWrapper::CreatedCallback>>::DestructorAtExit
193 g_created_callbacks = LAZY_INSTANCE_INITIALIZER;
[email protected]cbb1ef592013-06-05 19:49:46194
[email protected]8bfc8272013-09-09 20:10:53195void NotifyCacheOnIO(
196 scoped_refptr<net::URLRequestContextGetter> request_context,
197 const GURL& url,
Maks Orlovich158ea092018-12-17 22:16:12198 const std::string& http_method,
199 const base::Optional<url::Origin>& top_frame_origin) {
gunsche668855c2015-03-05 02:37:58200 net::HttpCache* cache = request_context->GetURLRequestContext()->
201 http_transaction_factory()->GetCache();
202 if (cache)
Maks Orlovich158ea092018-12-17 22:16:12203 cache->OnExternalCacheHit(url, http_method, top_frame_origin);
[email protected]8bfc8272013-09-09 20:10:53204}
205
dcheng57e39e22016-01-21 00:25:38206bool HasMatchingProcess(FrameTree* tree, int render_process_id) {
207 for (FrameTreeNode* node : tree->Nodes()) {
208 if (node->current_frame_host()->GetProcess()->GetID() == render_process_id)
209 return true;
alexmos4cf2aa32015-07-15 23:40:43210 }
dcheng57e39e22016-01-21 00:25:38211 return false;
[email protected]95640212014-07-26 18:14:30212}
213
kenrb19221852016-04-29 17:21:40214bool HasMatchingWidgetHost(FrameTree* tree, RenderWidgetHost* host) {
215 // This method scans the frame tree rather than checking whether
216 // host->delegate() == this, which allows it to return false when the host
217 // for a frame that is pending or pending deletion.
218 if (!host)
219 return false;
220
221 for (FrameTreeNode* node : tree->Nodes()) {
222 if (node->current_frame_host()->GetRenderWidgetHost() == host)
223 return true;
224 }
225 return false;
226}
227
dmazzonif8a31042016-12-03 00:52:13228void UpdateAccessibilityModeOnFrame(RenderFrameHost* frame_host) {
229 static_cast<RenderFrameHostImpl*>(frame_host)->UpdateAccessibilityMode();
[email protected]95640212014-07-26 18:14:30230}
231
dtseng0dd3fa12015-07-22 19:00:52232void ResetAccessibility(RenderFrameHost* rfh) {
233 static_cast<RenderFrameHostImpl*>(rfh)->AccessibilityReset();
234}
235
paulmeyerfeafc2d2017-04-25 21:46:40236// Helper for GetInnerWebContents().
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:16237bool GetInnerWebContentsHelper(std::vector<WebContents*>* all_guest_contents,
238 WebContents* guest_contents) {
Ehsan Karamad6beb2ea2018-11-25 18:15:13239 auto* web_contents_impl = static_cast<WebContentsImpl*>(guest_contents);
240 if (web_contents_impl->GetBrowserPluginGuest()->attached() &&
241 !GuestMode::IsCrossProcessFrameGuest(web_contents_impl)) {
242 all_guest_contents->push_back(web_contents_impl);
243 }
paulmeyerfeafc2d2017-04-25 21:46:40244 return false;
245}
246
Ian Clelland5cbaaf82017-11-27 22:00:03247RenderFrameHostImpl* FindOpenerRFH(const WebContents::CreateParams& params) {
248 RenderFrameHostImpl* opener_rfh = nullptr;
alexmose201c7cd2015-06-10 17:14:21249 if (params.opener_render_frame_id != MSG_ROUTING_NONE) {
Ian Clelland5cbaaf82017-11-27 22:00:03250 opener_rfh = RenderFrameHostImpl::FromID(params.opener_render_process_id,
251 params.opener_render_frame_id);
alexmose201c7cd2015-06-10 17:14:21252 }
Ian Clelland5cbaaf82017-11-27 22:00:03253 return opener_rfh;
lukasza6f8ac622017-06-06 03:10:20254}
255
Dominick Ng37a15052018-07-17 23:56:35256// Returns |true| if |type| is the kind of user input that should trigger the
257// user interaction observers.
258bool IsUserInteractionInputType(blink::WebInputEvent::Type type) {
259 // Ideally, this list would be based more off of
260 // https://whatwg.org/C/interaction.html#triggered-by-user-activation.
261 return type == blink::WebInputEvent::kMouseDown ||
262 type == blink::WebInputEvent::kGestureScrollBegin ||
263 type == blink::WebInputEvent::kTouchStart ||
264 type == blink::WebInputEvent::kRawKeyDown;
265}
266
267// Returns |true| if |type| is the kind of user input that should be used as
268// a user gesture signal for resource load dispatches.
269bool IsResourceLoadUserInteractionInputType(blink::WebInputEvent::Type type) {
270 return type == blink::WebInputEvent::kMouseDown ||
271 type == blink::WebInputEvent::kTouchStart ||
272 type == blink::WebInputEvent::kRawKeyDown;
273}
274
Pavel Feldman3c1842b2017-08-02 05:00:16275// Ensures that OnDialogClosed is only called once.
276class CloseDialogCallbackWrapper
277 : public base::RefCountedThreadSafe<CloseDialogCallbackWrapper> {
278 public:
Avi Drissmane04d3992017-10-05 15:11:36279 using CloseCallback =
280 base::OnceCallback<void(bool, bool, const base::string16&)>;
281
282 explicit CloseDialogCallbackWrapper(CloseCallback callback)
283 : callback_(std::move(callback)) {}
Pavel Feldman3c1842b2017-08-02 05:00:16284
285 void Run(bool dialog_was_suppressed,
286 bool success,
287 const base::string16& user_input) {
Avi Drissmane04d3992017-10-05 15:11:36288 if (callback_.is_null())
Pavel Feldman3c1842b2017-08-02 05:00:16289 return;
Avi Drissmane04d3992017-10-05 15:11:36290 std::move(callback_).Run(dialog_was_suppressed, success, user_input);
Pavel Feldman3c1842b2017-08-02 05:00:16291 }
292
293 private:
294 friend class base::RefCountedThreadSafe<CloseDialogCallbackWrapper>;
295 ~CloseDialogCallbackWrapper() {}
Avi Drissmane04d3992017-10-05 15:11:36296
297 CloseCallback callback_;
Pavel Feldman3c1842b2017-08-02 05:00:16298};
299
Arthur Sonzogni929d29f2018-09-17 14:19:44300bool FrameCompareDepth(RenderFrameHostImpl* a, RenderFrameHostImpl* b) {
301 return a->frame_tree_node()->depth() < b->frame_tree_node()->depth();
302}
303
lukasza6f8ac622017-06-06 03:10:20304} // namespace
305
Erik Chenbb8e738e2018-04-28 14:10:43306std::unique_ptr<WebContents> WebContents::Create(
307 const WebContents::CreateParams& params) {
erikchen50735fd2018-05-05 15:08:33308 return WebContentsImpl::CreateWithOpener(params, FindOpenerRFH(params));
[email protected]d1198fd2012-08-13 22:50:19309}
310
erikchenade1fef2018-05-02 22:07:57311std::unique_ptr<WebContents> WebContents::CreateWithSessionStorage(
[email protected]54944cde2012-12-09 09:24:59312 const WebContents::CreateParams& params,
[email protected]fdac6ade2013-07-20 01:06:30313 const SessionStorageNamespaceMap& session_storage_namespace_map) {
erikchenade1fef2018-05-02 22:07:57314 std::unique_ptr<WebContentsImpl> new_contents(
315 new WebContentsImpl(params.browser_context));
Ian Clelland5cbaaf82017-11-27 22:00:03316 RenderFrameHostImpl* opener_rfh = FindOpenerRFH(params);
317 FrameTreeNode* opener = nullptr;
318 if (opener_rfh)
319 opener = opener_rfh->frame_tree_node();
320 new_contents->SetOpenerForNewContents(opener, params.opener_suppressed);
[email protected]fdac6ade2013-07-20 01:06:30321
jdoerrie55ec69d2018-10-08 13:34:46322 for (auto it = session_storage_namespace_map.begin();
323 it != session_storage_namespace_map.end(); ++it) {
[email protected]fdac6ade2013-07-20 01:06:30324 new_contents->GetController()
325 .SetSessionStorageNamespace(it->first, it->second.get());
326 }
327
Sean Toppingbbc4a2bd2019-01-30 02:16:14328 WebContentsImpl* outer_web_contents = nullptr;
Sam McNally69a33772018-06-27 16:54:12329 if (params.guest_delegate) {
330 // This makes |new_contents| act as a guest.
331 // For more info, see comment above class BrowserPluginGuest.
Albert J. Wongc55cc64d2018-10-12 02:50:04332 BrowserPluginGuest::CreateInWebContents(new_contents.get(),
333 params.guest_delegate);
Sean Toppingbbc4a2bd2019-01-30 02:16:14334 outer_web_contents = static_cast<WebContentsImpl*>(
335 params.guest_delegate->GetOwnerWebContents());
Sam McNally69a33772018-06-27 16:54:12336 }
337
[email protected]54944cde2012-12-09 09:24:59338 new_contents->Init(params);
Sean Toppingbbc4a2bd2019-01-30 02:16:14339 if (outer_web_contents)
340 outer_web_contents->InnerWebContentsCreated(new_contents.get());
[email protected]d1198fd2012-08-13 22:50:19341 return new_contents;
[email protected]a81343d232011-12-27 07:39:20342}
[email protected]746d3052012-05-22 15:15:47343
benwells5e7260d2017-03-20 23:36:33344void WebContentsImpl::FriendWrapper::AddCreatedCallbackForTesting(
nickf9acfbe2014-12-23 19:12:37345 const CreatedCallback& callback) {
[email protected]cbb1ef592013-06-05 19:49:46346 g_created_callbacks.Get().push_back(callback);
347}
348
benwells5e7260d2017-03-20 23:36:33349void WebContentsImpl::FriendWrapper::RemoveCreatedCallbackForTesting(
nickf9acfbe2014-12-23 19:12:37350 const CreatedCallback& callback) {
[email protected]cbb1ef592013-06-05 19:49:46351 for (size_t i = 0; i < g_created_callbacks.Get().size(); ++i) {
Robert Liao1db5a352019-06-05 20:57:34352 if (g_created_callbacks.Get().at(i) == callback) {
[email protected]cbb1ef592013-06-05 19:49:46353 g_created_callbacks.Get().erase(g_created_callbacks.Get().begin() + i);
354 return;
355 }
356 }
357}
358
avidf38c952015-10-27 13:45:13359WebContents* WebContents::FromRenderViewHost(RenderViewHost* rvh) {
360 if (!rvh)
361 return nullptr;
[email protected]746d3052012-05-22 15:15:47362 return rvh->GetDelegate()->GetAsWebContents();
363}
364
[email protected]a86c0e962013-12-17 17:10:39365WebContents* WebContents::FromRenderFrameHost(RenderFrameHost* rfh) {
avidf38c952015-10-27 13:45:13366 if (!rfh)
367 return nullptr;
368 return static_cast<RenderFrameHostImpl*>(rfh)->delegate()->GetAsWebContents();
[email protected]a86c0e962013-12-17 17:10:39369}
370
ananta4b7467a52016-09-23 01:42:38371WebContents* WebContents::FromFrameTreeNodeId(int frame_tree_node_id) {
372 FrameTreeNode* frame_tree_node =
373 FrameTreeNode::GloballyFindByID(frame_tree_node_id);
anantab8cfa3b2016-10-14 22:43:19374 if (!frame_tree_node)
375 return nullptr;
jam8c4edd02017-05-06 18:50:33376 return WebContentsImpl::FromFrameTreeNode(frame_tree_node);
ananta4b7467a52016-09-23 01:42:38377}
378
leon.han552e9de2017-02-09 14:37:30379void WebContents::SetScreenOrientationDelegate(
380 ScreenOrientationDelegate* delegate) {
381 ScreenOrientationProvider::SetDelegate(delegate);
382}
383
[email protected]7fff43e2013-05-21 20:21:10384// WebContentsImpl::DestructionObserver ----------------------------------------
385
386class WebContentsImpl::DestructionObserver : public WebContentsObserver {
387 public:
388 DestructionObserver(WebContentsImpl* owner, WebContents* watched_contents)
389 : WebContentsObserver(watched_contents),
390 owner_(owner) {
391 }
392
393 // WebContentsObserver:
dchengc2282aa2014-10-21 12:07:58394 void WebContentsDestroyed() override {
[email protected]12a46832014-05-09 13:35:58395 owner_->OnWebContentsDestroyed(
396 static_cast<WebContentsImpl*>(web_contents()));
[email protected]7fff43e2013-05-21 20:21:10397 }
398
399 private:
400 WebContentsImpl* owner_;
401
402 DISALLOW_COPY_AND_ASSIGN(DestructionObserver);
403};
404
Joel Hockey85b379d2017-12-11 10:42:13405// WebContentsImpl::ColorChooser ----------------------------------------------
Joel Hockey163835a2017-12-20 11:51:57406class WebContentsImpl::ColorChooser : public blink::mojom::ColorChooser {
Joel Hockey85b379d2017-12-11 10:42:13407 public:
408 ColorChooser(content::ColorChooser* chooser,
Joel Hockey163835a2017-12-20 11:51:57409 blink::mojom::ColorChooserRequest request,
410 blink::mojom::ColorChooserClientPtr client)
Joel Hockey85b379d2017-12-11 10:42:13411 : chooser_(chooser),
412 binding_(this, std::move(request)),
413 client_(std::move(client)) {
414 binding_.set_connection_error_handler(
415 base::BindOnce([](content::ColorChooser* chooser) { chooser->End(); },
416 base::Unretained(chooser)));
417 }
[email protected]8ed16472014-04-11 19:02:48418
Joel Hockey85b379d2017-12-11 10:42:13419 ~ColorChooser() override { chooser_->End(); }
[email protected]8ed16472014-04-11 19:02:48420
Joel Hockey85b379d2017-12-11 10:42:13421 void SetSelectedColor(SkColor color) override {
422 chooser_->SetSelectedColor(color);
423 }
424
425 void DidChooseColorInColorChooser(SkColor color) {
426 client_->DidChooseColor(color);
427 }
428
429 private:
430 // Color chooser that was opened by this tab.
431 std::unique_ptr<content::ColorChooser> chooser_;
432
433 // mojo bindings.
Joel Hockey163835a2017-12-20 11:51:57434 mojo::Binding<blink::mojom::ColorChooser> binding_;
Joel Hockey85b379d2017-12-11 10:42:13435
436 // mojo renderer client.
Joel Hockey163835a2017-12-20 11:51:57437 blink::mojom::ColorChooserClientPtr client_;
Joel Hockey85b379d2017-12-11 10:42:13438};
nicka0ac8382016-12-15 23:59:23439
lazyboy6ec48b2a2015-06-29 15:18:14440// WebContentsImpl::WebContentsTreeNode ----------------------------------------
lfg601233692017-03-06 22:45:44441WebContentsImpl::WebContentsTreeNode::WebContentsTreeNode(
442 WebContentsImpl* current_web_contents)
443 : current_web_contents_(current_web_contents),
444 outer_web_contents_(nullptr),
lazyboy6ec48b2a2015-06-29 15:18:14445 outer_contents_frame_tree_node_id_(
avallee0206f782016-07-28 18:55:33446 FrameTreeNode::kFrameTreeNodeInvalidId),
lfg601233692017-03-06 22:45:44447 focused_web_contents_(current_web_contents) {}
lazyboy6ec48b2a2015-06-29 15:18:14448
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18449WebContentsImpl::WebContentsTreeNode::~WebContentsTreeNode() {}
lazyboy6ec48b2a2015-06-29 15:18:14450
Lucas Furukawa Gadani99125822019-01-03 15:41:49451std::unique_ptr<WebContents>
452WebContentsImpl::WebContentsTreeNode::DisconnectFromOuterWebContents() {
453 std::unique_ptr<WebContents> inner_contents =
454 outer_web_contents_->node_.DetachInnerWebContents(current_web_contents_);
455 OuterContentsFrameTreeNode()->RemoveObserver(this);
456 outer_contents_frame_tree_node_id_ = FrameTreeNode::kFrameTreeNodeInvalidId;
457 outer_web_contents_ = nullptr;
458 return inner_contents;
459}
460
paulmeyerfeafc2d2017-04-25 21:46:40461void WebContentsImpl::WebContentsTreeNode::AttachInnerWebContents(
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:50462 std::unique_ptr<WebContents> inner_web_contents,
463 RenderFrameHostImpl* render_frame_host) {
464 WebContentsImpl* inner_web_contents_impl =
465 static_cast<WebContentsImpl*>(inner_web_contents.get());
466 WebContentsTreeNode& inner_web_contents_node = inner_web_contents_impl->node_;
467
468 inner_web_contents_node.focused_web_contents_ = nullptr;
469 inner_web_contents_node.outer_web_contents_ = current_web_contents_;
470 inner_web_contents_node.outer_contents_frame_tree_node_id_ =
471 render_frame_host->frame_tree_node()->frame_tree_node_id();
472
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18473 inner_web_contents_.push_back(std::move(inner_web_contents));
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:50474
475 render_frame_host->frame_tree_node()->AddObserver(&inner_web_contents_node);
paulmeyerfeafc2d2017-04-25 21:46:40476}
477
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18478std::unique_ptr<WebContents>
479WebContentsImpl::WebContentsTreeNode::DetachInnerWebContents(
paulmeyerfeafc2d2017-04-25 21:46:40480 WebContentsImpl* inner_web_contents) {
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18481 std::unique_ptr<WebContents> detached_contents;
482 for (std::unique_ptr<WebContents>& web_contents : inner_web_contents_) {
483 if (web_contents.get() == inner_web_contents) {
484 detached_contents = std::move(web_contents);
485 std::swap(web_contents, inner_web_contents_.back());
486 inner_web_contents_.pop_back();
487 return detached_contents;
488 }
489 }
490
491 NOTREACHED();
492 return nullptr;
paulmeyerfeafc2d2017-04-25 21:46:40493}
494
lfga3e2bdc2017-03-07 20:44:01495FrameTreeNode*
496WebContentsImpl::WebContentsTreeNode::OuterContentsFrameTreeNode() const {
497 return FrameTreeNode::GloballyFindByID(outer_contents_frame_tree_node_id_);
lfg601233692017-03-06 22:45:44498}
499
lfga3e2bdc2017-03-07 20:44:01500void WebContentsImpl::WebContentsTreeNode::OnFrameTreeNodeDestroyed(
501 FrameTreeNode* node) {
502 DCHECK_EQ(outer_contents_frame_tree_node_id_, node->frame_tree_node_id())
503 << "WebContentsTreeNode should only receive notifications for the "
504 "FrameTreeNode in its outer WebContents that hosts it.";
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18505
506 // Deletes |this| too.
507 outer_web_contents_->node_.DetachInnerWebContents(current_web_contents_);
lazyboy6ec48b2a2015-06-29 15:18:14508}
509
avallee0206f782016-07-28 18:55:33510void WebContentsImpl::WebContentsTreeNode::SetFocusedWebContents(
511 WebContentsImpl* web_contents) {
512 DCHECK(!outer_web_contents())
513 << "Only the outermost WebContents tracks focus.";
514 focused_web_contents_ = web_contents;
515}
516
paulmeyerfeafc2d2017-04-25 21:46:40517WebContentsImpl*
518WebContentsImpl::WebContentsTreeNode::GetInnerWebContentsInFrame(
519 const FrameTreeNode* frame) {
520 auto ftn_id = frame->frame_tree_node_id();
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18521 for (auto& contents : inner_web_contents_) {
522 WebContentsImpl* impl = static_cast<WebContentsImpl*>(contents.get());
523 if (impl->node_.outer_contents_frame_tree_node_id() == ftn_id) {
524 return impl;
paulmeyerfeafc2d2017-04-25 21:46:40525 }
526 }
527 return nullptr;
528}
529
Lucas Furukawa Gadani3d38ec152018-10-26 20:55:18530std::vector<WebContentsImpl*>
531WebContentsImpl::WebContentsTreeNode::GetInnerWebContents() const {
532 std::vector<WebContentsImpl*> inner_web_contents;
533 for (auto& contents : inner_web_contents_)
534 inner_web_contents.push_back(static_cast<WebContentsImpl*>(contents.get()));
535
536 return inner_web_contents;
paulmeyerfeafc2d2017-04-25 21:46:40537}
538
[email protected]b172aee2012-04-10 17:05:26539// WebContentsImpl -------------------------------------------------------------
[email protected]420ae012009-04-24 05:16:32540
alexmose201c7cd2015-06-10 17:14:21541WebContentsImpl::WebContentsImpl(BrowserContext* browser_context)
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28542 : delegate_(nullptr),
[email protected]69e797f2013-04-30 01:10:22543 controller_(this, browser_context),
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28544 render_view_host_delegate_view_(nullptr),
alexmose201c7cd2015-06-10 17:14:21545 created_with_opener_(false),
Lucas Furukawa Gadani99125822019-01-03 15:41:49546 node_(this),
[email protected]6ea6bdf2013-12-06 13:35:01547 frame_tree_(new NavigatorImpl(&controller_, this),
blundellc57b93f2014-10-29 13:19:57548 this,
549 this,
550 this,
551 this),
[email protected]6dfed692014-05-22 04:18:03552 is_load_to_different_document_(false),
[email protected]443b80e2010-12-14 00:42:23553 crashed_status_(base::TERMINATION_STATUS_STILL_RUNNING),
554 crashed_error_code_(0),
[email protected]d5f942ba2008-09-26 19:30:34555 waiting_for_response_(false),
[email protected]fcf75d42013-12-03 20:11:26556 load_state_(net::LOAD_STATE_IDLE, base::string16()),
[email protected]094e5b22009-09-25 04:23:56557 upload_size_(0),
558 upload_position_(0),
dfalcantarae6b7b46752015-07-10 18:14:16559 is_resume_pending_(false),
creisadca9862017-06-16 19:12:11560 interstitial_page_(nullptr),
[email protected]b4c84012014-04-28 19:51:10561 has_accessed_initial_document_(false),
peter90afaba2015-06-01 12:05:29562 did_first_visually_non_empty_paint_(false),
[email protected]54597982013-02-06 01:59:55563 capturer_count_(0),
[email protected]fdd61c62009-04-22 19:22:57564 is_being_destroyed_(false),
creis97867aa2017-02-17 18:39:45565 is_notifying_observers_(false),
[email protected]fdd61c62009-04-22 19:22:57566 notify_disconnection_(false),
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28567 dialog_manager_(nullptr),
[email protected]7ab1e7d62009-10-14 23:32:01568 is_showing_before_unload_dialog_(false),
gab0dccfef2015-05-20 18:43:39569 last_active_time_(base::TimeTicks::Now()),
[email protected]ebf40a72010-07-22 01:46:38570 closed_by_user_gesture_(false),
[email protected]8ff00d72012-10-23 19:12:21571 minimum_zoom_percent_(static_cast<int>(kMinimumZoomFactor * 100)),
572 maximum_zoom_percent_(static_cast<int>(kMaximumZoomFactor * 100)),
w.shackleton49bcd392016-01-06 17:38:22573 zoom_scroll_remainder_(0),
alexmosc9e76ec2016-05-16 22:59:37574 fullscreen_widget_process_id_(ChildProcessHost::kInvalidUniqueID),
[email protected]5dcaf8e2013-12-28 01:31:42575 fullscreen_widget_routing_id_(MSG_ROUTING_NONE),
[email protected]0b431992014-06-24 00:08:03576 fullscreen_widget_had_focus_at_shutdown_(false),
[email protected]34ff1cfc2014-08-20 06:16:05577 force_disable_overscroll_content_(false),
[email protected]95640212014-07-26 18:14:30578 last_dialog_suppressed_(false),
waffles1c12bf402016-02-10 17:45:48579 accessibility_mode_(
Dominic Mazzoni21fb0282019-02-13 18:32:47580 GetContentClient()->browser()->GetAXModeForBrowserContext(
581 browser_context)),
avayvodcc85bbd2015-08-28 19:11:15582 audio_stream_monitor_(this),
Thomas Guilbert882c4cec2019-02-14 05:55:45583 media_web_contents_observer_(
584 std::make_unique<MediaWebContentsObserver>(this)),
Guido Urdanetaf4008002018-05-03 10:43:04585 media_device_group_id_salt_base_(
586 BrowserContext::CreateRandomMediaDeviceIDSalt()),
mcnee336ea2c2017-05-23 22:50:59587#if !defined(OS_ANDROID)
mcnee432e47d2015-11-09 19:37:46588 page_scale_factor_is_one_(true),
mcnee336ea2c2017-05-23 22:50:59589#endif // !defined(OS_ANDROID)
qinmin72e8bd02016-10-21 19:35:37590 is_overlay_content_(false),
ekaramadf6750aa2017-06-06 18:29:42591 showing_context_menu_(false),
W. James MacLean62198672019-06-04 16:46:10592 text_autosizer_page_info_({0, 0, 1.f}),
Shivani Sharma985474f2019-05-23 21:36:47593 had_inner_webcontents_(false),
pkotwicz75ca8ffd2016-02-16 23:10:19594 loading_weak_factory_(this),
595 weak_factory_(this) {
[email protected]9b159a52013-10-03 17:24:55596 frame_tree_.SetFrameRemoveListener(
597 base::Bind(&WebContentsImpl::OnFrameRemoved,
598 base::Unretained(this)));
brettw4b461082016-11-19 18:55:16599#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17600 pepper_playback_observer_.reset(new PepperPlaybackObserver(this));
601#endif
blundelle75a8f92017-03-27 08:11:17602
csharrisona2280cd2016-02-03 23:21:15603 loader_io_thread_notifier_.reset(new LoaderIOThreadNotifier(this));
mcnee336ea2c2017-05-23 22:50:59604#if !defined(OS_ANDROID)
scottmg276753cf2016-10-27 18:25:22605 host_zoom_map_observer_.reset(new HostZoomMapObserver(this));
mcnee336ea2c2017-05-23 22:50:59606#endif // !defined(OS_ANDROID)
Joel Hockey85b379d2017-12-11 10:42:13607
Becca Hughes86334622018-07-09 21:29:38608#if defined(OS_ANDROID)
Elly Fong-Jonescdd7ae82019-02-20 23:26:33609 display_cutout_host_impl_ = std::make_unique<DisplayCutoutHostImpl>(this);
Becca Hughes86334622018-07-09 21:29:38610#endif
Becca Hughes6fe54e432018-06-09 04:18:56611
Joel Hockey85b379d2017-12-11 10:42:13612 registry_.AddInterface(base::BindRepeating(
613 &WebContentsImpl::OnColorChooserFactoryRequest, base::Unretained(this)));
Rune Lillesveen5d8c49982019-04-24 19:07:30614
615 dark_mode_observer_.Start();
[email protected]332af7732009-03-11 13:21:35616}
initial.commit09911bf2008-07-26 23:55:29617
[email protected]b172aee2012-04-10 17:05:26618WebContentsImpl::~WebContentsImpl() {
creisba91ba82017-05-12 22:56:19619 // Imperfect sanity check against double free, given some crashes unexpectedly
620 // observed in the wild.
621 CHECK(!is_being_destroyed_);
622
623 // We generally keep track of is_being_destroyed_ to let other features know
624 // to avoid certain actions during destruction.
[email protected]420ae012009-04-24 05:16:32625 is_being_destroyed_ = true;
626
creis97867aa2017-02-17 18:39:45627 // A WebContents should never be deleted while it is notifying observers,
creisba91ba82017-05-12 22:56:19628 // since this will lead to a use-after-free as it continues to notify later
creis97867aa2017-02-17 18:39:45629 // observers.
630 CHECK(!is_notifying_observers_);
631
kenrb2a565f82015-09-02 20:24:59632 rwh_input_event_router_.reset();
633
rockotf62002a2016-09-15 00:08:59634 for (auto& entry : binding_sets_)
635 entry.second->CloseAllBindings();
636
avallee0206f782016-07-28 18:55:33637 WebContentsImpl* outermost = GetOutermostWebContents();
avallee9993fca2016-11-17 06:16:50638 if (this != outermost && ContainsOrIsFocusedWebContents()) {
avallee0206f782016-07-28 18:55:33639 // If the current WebContents is in focus, unset it.
avallee9993fca2016-11-17 06:16:50640 outermost->SetAsFocusedWebContentsIfNecessary();
avallee0206f782016-07-28 18:55:33641 }
642
Nick Carterd73635b2018-03-13 18:31:41643 if (mouse_lock_widget_)
644 mouse_lock_widget_->RejectMouseLockOrUnlockIfNecessary();
645
dcheng72be33c2016-01-21 04:11:31646 for (FrameTreeNode* node : frame_tree_.Nodes()) {
647 // Delete all RFHs pending shutdown, which will lead the corresponding RVHs
648 // to be shutdown and be deleted as well.
dcheng57e39e22016-01-21 00:25:38649 node->render_manager()->ClearRFHsPendingShutdown();
dcheng57e39e22016-01-21 00:25:38650 node->render_manager()->ClearWebUIInstances();
dcheng72be33c2016-01-21 04:11:31651 }
carlosk35f35af2015-12-01 10:55:40652
dcheng57e39e22016-01-21 00:25:38653 for (RenderWidgetHostImpl* widget : created_widgets_)
654 widget->DetachDelegate();
[email protected]b24b68a2012-09-24 21:57:26655 created_widgets_.clear();
656
[email protected]3ab9cb82011-06-03 18:02:07657 // Clear out any JavaScript state.
avi5d3b8692016-10-12 22:00:46658 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:53659 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:46660 }
[email protected]3ab9cb82011-06-03 18:02:07661
Joel Hockey85b379d2017-12-11 10:42:13662 color_chooser_.reset();
Rakina Zata Amni16196122018-11-14 02:14:00663 find_request_manager_.reset();
[email protected]da8543762012-03-20 08:52:20664
[email protected]420ae012009-04-24 05:16:32665 NotifyDisconnected();
[email protected]420ae012009-04-24 05:16:32666
[email protected]ca13a442012-04-17 14:00:12667 // Notify any observer that have a reference on this WebContents.
[email protected]8ff00d72012-10-23 19:12:21668 NotificationService::current()->Notify(
669 NOTIFICATION_WEB_CONTENTS_DESTROYED,
670 Source<WebContents>(this),
671 NotificationService::NoDetails());
[email protected]420ae012009-04-24 05:16:32672
Arthur Sonzogni5a9a88c2018-10-18 13:16:00673 // Destroy all subframes now. This notifies observers.
674 GetMainFrame()->ResetChildren();
[email protected]df0c843f2014-05-23 20:37:23675 GetRenderManager()->ResetProxyHosts();
[email protected]c06c58c2014-03-12 20:31:59676
clamy0e119882015-07-31 16:12:33677 // Manually call the observer methods for the root frame tree node. It is
678 // necessary to manually delete all objects tracking navigations
679 // (NavigationHandle, NavigationRequest) for observers to be properly
680 // notified of these navigations stopping before the WebContents is
681 // destroyed.
[email protected]df0c843f2014-05-23 20:37:23682 RenderFrameHostManager* root = GetRenderManager();
naskob21fe4872015-02-24 14:15:56683
Arthur Sonzogni620cec62018-12-13 13:08:57684 GetController().back_forward_cache().Flush();
naskob21fe4872015-02-24 14:15:56685 root->current_frame_host()->SetRenderFrameCreated(false);
clamyfc3850d2018-02-23 14:35:28686 root->current_frame_host()->ResetNavigationRequests();
clamy0e119882015-07-31 16:12:33687
Arthur Hemeryc3380172018-01-22 14:00:17688 // Do not update state as the WebContents is being destroyed.
689 frame_tree_.root()->ResetNavigationRequest(true, true);
690 if (root->speculative_frame_host()) {
danakjf2342432019-05-15 21:46:09691 root->speculative_frame_host()->DeleteRenderFrame(
692 FrameDeleteIntention::kSpeculativeMainFrameForShutdown);
Arthur Hemeryc3380172018-01-22 14:00:17693 root->speculative_frame_host()->SetRenderFrameCreated(false);
clamyfc3850d2018-02-23 14:35:28694 root->speculative_frame_host()->ResetNavigationRequests();
clamy0e119882015-07-31 16:12:33695 }
[email protected]f273ee52013-10-18 16:05:27696
brettw4b461082016-11-19 18:55:16697#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17698 // Call this before WebContentsDestroyed() is broadcasted since
699 // AudioFocusManager will be destroyed after that.
700 pepper_playback_observer_.reset();
701#endif // defined(ENABLED_PLUGINS)
702
Chris Hamiltondf0d72cd2018-05-29 16:23:53703 // If audio is playing then notify external observers of the audio stream
704 // disappearing.
705 if (is_currently_audible_) {
706 is_currently_audible_ = false;
707 for (auto& observer : observers_)
708 observer.OnAudioStateChanged(false);
709
710 if (GetOuterWebContents())
711 GetOuterWebContents()->OnAudioStateChanged();
712 }
713
ericwilligersde386342016-10-19 02:35:09714 for (auto& observer : observers_)
715 observer.FrameDeleted(root->current_frame_host());
naskoa83483fb2015-02-27 16:57:10716
ericwilligersde386342016-10-19 02:35:09717 for (auto& observer : observers_)
718 observer.RenderViewDeleted(root->current_host());
[email protected]f273ee52013-10-18 16:05:27719
Kevin McNee576bb5d82019-05-29 16:47:51720#if defined(OS_ANDROID)
721 // For simplicity, destroy the Java WebContents before we notify of the
722 // destruction of the WebContents.
723 ClearWebContentsAndroid();
724#endif
725
ericwilligersde386342016-10-19 02:35:09726 for (auto& observer : observers_)
727 observer.WebContentsDestroyed();
[email protected]12a46832014-05-09 13:35:58728
Becca Hughesd11d6502018-07-31 17:01:28729 if (display_cutout_host_impl_)
730 display_cutout_host_impl_->WebContentsDestroyed();
731
ericwilligersde386342016-10-19 02:35:09732 for (auto& observer : observers_)
733 observer.ResetWebContents();
[email protected]232a5812011-03-04 22:42:08734
Ivan Kotenkov2c0d2bb32017-11-01 15:41:28735 SetDelegate(nullptr);
[email protected]b5a1d11c2011-02-17 03:09:42736}
737
erikchen50735fd2018-05-05 15:08:33738std::unique_ptr<WebContentsImpl> WebContentsImpl::CreateWithOpener(
[email protected]54944cde2012-12-09 09:24:59739 const WebContents::CreateParams& params,
Ian Clelland5cbaaf82017-11-27 22:00:03740 RenderFrameHostImpl* opener_rfh) {
[email protected]e11f0e92013-06-12 15:12:03741 TRACE_EVENT0("browser", "WebContentsImpl::CreateWithOpener");
Ian Clelland5cbaaf82017-11-27 22:00:03742 FrameTreeNode* opener = nullptr;
743 if (opener_rfh)
744 opener = opener_rfh->frame_tree_node();
erikchen50735fd2018-05-05 15:08:33745 std::unique_ptr<WebContentsImpl> new_contents(
746 new WebContentsImpl(params.browser_context));
lukasza6f8ac622017-06-06 03:10:20747 new_contents->SetOpenerForNewContents(opener, params.opener_suppressed);
alexmose201c7cd2015-06-10 17:14:21748
alexmosaedfc6f2016-01-21 23:57:38749 // If the opener is sandboxed, a new popup must inherit the opener's sandbox
750 // flags, and these flags take effect immediately. An exception is if the
751 // opener's sandbox flags lack the PropagatesToAuxiliaryBrowsingContexts
752 // bit (which is controlled by the "allow-popups-to-escape-sandbox" token).
753 // See https://html.spec.whatwg.org/#attr-iframe-sandbox.
lukasza6f8ac622017-06-06 03:10:20754 FrameTreeNode* new_root = new_contents->GetFrameTree()->root();
alexmosaedfc6f2016-01-21 23:57:38755 if (opener) {
Ian Clelland5cbaaf82017-11-27 22:00:03756 blink::WebSandboxFlags opener_flags = opener_rfh->active_sandbox_flags();
alexmosaedfc6f2016-01-21 23:57:38757 const blink::WebSandboxFlags inherit_flag =
Blink Reformat1c4d759e2017-04-09 16:34:54758 blink::WebSandboxFlags::kPropagatesToAuxiliaryBrowsingContexts;
Ehsan Karamad39407082019-02-19 23:38:19759 bool sandbox_propagates_to_auxilary_context =
760 (opener_flags & inherit_flag) == inherit_flag;
761 if (sandbox_propagates_to_auxilary_context)
Ian Clellandcdc4f312017-10-13 22:24:12762 new_root->SetPendingFramePolicy({opener_flags, {}});
Ehsan Karamad39407082019-02-19 23:38:19763 if (opener_flags == blink::WebSandboxFlags::kNone ||
764 sandbox_propagates_to_auxilary_context) {
765 // TODO(ekaramad, iclelland): Do not propagate feature policies from non-
766 // sandboxed disowned openers (rel=noopener).
767 // If the current page is not sandboxed, or if the sandbox is to propagate
768 // to the popups then opener's feature policy will apply to the new popup
769 // as well.
770 new_root->SetOpenerFeaturePolicyState(
Ehsan Karamad34d10682019-02-26 20:55:04771 opener_rfh->feature_policy()->GetFeatureState());
alexmosaedfc6f2016-01-21 23:57:38772 }
773 }
774
mark a. foltzef394fce2017-10-21 09:11:02775 // Apply starting sandbox flags.
Luna Luc3fdacdf2017-11-08 04:48:53776 blink::FramePolicy frame_policy(new_root->pending_frame_policy());
mark a. foltzef394fce2017-10-21 09:11:02777 frame_policy.sandbox_flags |= params.starting_sandbox_flags;
778 new_root->SetPendingFramePolicy(frame_policy);
779 new_root->CommitPendingFramePolicy();
780
alexmose201c7cd2015-06-10 17:14:21781 // This may be true even when opener is null, such as when opening blocked
782 // popups.
alexmos090fae8e2015-05-28 17:09:28783 if (params.created_with_opener)
784 new_contents->created_with_opener_ = true;
785
Sean Toppingbbc4a2bd2019-01-30 02:16:14786 WebContentsImpl* outer_web_contents = nullptr;
[email protected]4858e432014-06-23 18:14:17787 if (params.guest_delegate) {
[email protected]83100cd2014-05-10 11:50:06788 // This makes |new_contents| act as a guest.
789 // For more info, see comment above class BrowserPluginGuest.
Albert J. Wongc55cc64d2018-10-12 02:50:04790 BrowserPluginGuest::CreateInWebContents(new_contents.get(),
791 params.guest_delegate);
Sean Toppingbbc4a2bd2019-01-30 02:16:14792 outer_web_contents = static_cast<WebContentsImpl*>(
793 params.guest_delegate->GetOwnerWebContents());
[email protected]83100cd2014-05-10 11:50:06794 }
mark a. foltzef394fce2017-10-21 09:11:02795
[email protected]54944cde2012-12-09 09:24:59796 new_contents->Init(params);
Sean Toppingbbc4a2bd2019-01-30 02:16:14797 if (outer_web_contents)
798 outer_web_contents->InnerWebContentsCreated(new_contents.get());
[email protected]d1198fd2012-08-13 22:50:19799 return new_contents;
800}
801
[email protected]95640212014-07-26 18:14:30802// static
803std::vector<WebContentsImpl*> WebContentsImpl::GetAllWebContents() {
804 std::vector<WebContentsImpl*> result;
dcheng59716272016-04-09 05:19:08805 std::unique_ptr<RenderWidgetHostIterator> widgets(
[email protected]95640212014-07-26 18:14:30806 RenderWidgetHostImpl::GetRenderWidgetHosts());
[email protected]95640212014-07-26 18:14:30807 while (RenderWidgetHost* rwh = widgets->GetNextHost()) {
[email protected]95640212014-07-26 18:14:30808 RenderViewHost* rvh = RenderViewHost::From(rwh);
809 if (!rvh)
810 continue;
811 WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
812 if (!web_contents)
813 continue;
avidf38c952015-10-27 13:45:13814 if (web_contents->GetRenderViewHost() != rvh)
815 continue;
816 // Because a WebContents can only have one current RVH at a time, there will
817 // be no duplicate WebContents here.
818 result.push_back(static_cast<WebContentsImpl*>(web_contents));
[email protected]95640212014-07-26 18:14:30819 }
820 return result;
821}
822
clamya16aa8172015-05-26 13:07:25823// static
824WebContentsImpl* WebContentsImpl::FromFrameTreeNode(
paulmeyerfeafc2d2017-04-25 21:46:40825 const FrameTreeNode* frame_tree_node) {
clamya16aa8172015-05-26 13:07:25826 return static_cast<WebContentsImpl*>(
827 WebContents::FromRenderFrameHost(frame_tree_node->current_frame_host()));
828}
829
clamy0d32d6d2015-11-24 11:16:26830// static
831WebContents* WebContentsImpl::FromRenderFrameHostID(int render_process_host_id,
832 int render_frame_host_id) {
Min Qina1150112019-02-15 01:47:49833 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
834 !BrowserThread::IsThreadInitialized(BrowserThread::UI));
clamy0d32d6d2015-11-24 11:16:26835 RenderFrameHost* render_frame_host =
836 RenderFrameHost::FromID(render_process_host_id, render_frame_host_id);
837 if (!render_frame_host)
838 return nullptr;
839
840 return WebContents::FromRenderFrameHost(render_frame_host);
841}
842
paulmeyerfeafc2d2017-04-25 21:46:40843// static
844WebContentsImpl* WebContentsImpl::FromOuterFrameTreeNode(
845 const FrameTreeNode* frame_tree_node) {
846 return WebContentsImpl::FromFrameTreeNode(frame_tree_node)
847 ->node_.GetInnerWebContentsInFrame(frame_tree_node);
848}
849
[email protected]b0936d22013-11-28 06:47:36850RenderFrameHostManager* WebContentsImpl::GetRenderManagerForTesting() {
[email protected]fa944cb82013-11-15 17:51:21851 return GetRenderManager();
[email protected]765187182012-01-11 23:59:28852}
853
nicka0ac8382016-12-15 23:59:23854bool WebContentsImpl::OnMessageReceived(RenderViewHostImpl* render_view_host,
[email protected]7bb761892012-07-20 09:32:47855 const IPC::Message& message) {
nicka0ac8382016-12-15 23:59:23856 for (auto& observer : observers_) {
Lukasz Anforowicz89f2c1b2017-08-30 21:36:46857 // TODO(nick, creis): https://crbug.com/758026: Replace all uses of this
858 // variant of OnMessageReceived with the version that takes a
859 // RenderFrameHost, and then delete it.
nicka0ac8382016-12-15 23:59:23860 if (observer.OnMessageReceived(message))
861 return true;
[email protected]64ffefa2014-05-10 12:06:33862 }
[email protected]403415a2011-01-10 18:57:53863
[email protected]724159a2010-12-30 01:11:18864 bool handled = true;
nicka0ac8382016-12-15 23:59:23865 IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(WebContentsImpl, message, render_view_host)
nicka0ac8382016-12-15 23:59:23866 IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateZoomLimits, OnUpdateZoomLimits)
867 IPC_MESSAGE_HANDLER(ViewHostMsg_PageScaleFactorChanged,
868 OnPageScaleFactorChanged)
W. James MacLean62198672019-06-04 16:46:10869 IPC_MESSAGE_HANDLER(
870 ViewHostMsg_NotifyTextAutosizerPageInfoChangedInLocalMainFrame,
871 OnTextAutosizerPageInfoChanged)
nicka0ac8382016-12-15 23:59:23872#if BUILDFLAG(ENABLE_PLUGINS)
873 IPC_MESSAGE_HANDLER(ViewHostMsg_RequestPpapiBrokerPermission,
874 OnRequestPpapiBrokerPermission)
875#endif
nicka0ac8382016-12-15 23:59:23876 IPC_MESSAGE_UNHANDLED(handled = false)
877 IPC_END_MESSAGE_MAP()
878
879 return handled;
880}
881
882bool WebContentsImpl::OnMessageReceived(RenderFrameHostImpl* render_frame_host,
883 const IPC::Message& message) {
Lukasz Anforowicz02923102017-10-09 18:11:37884 {
885 WebUIImpl* web_ui = render_frame_host->web_ui();
886 if (web_ui && web_ui->OnMessageReceived(message, render_frame_host))
887 return true;
888 }
889
nicka0ac8382016-12-15 23:59:23890 for (auto& observer : observers_) {
891 if (observer.OnMessageReceived(message, render_frame_host))
892 return true;
893 }
894
895 bool handled = true;
896 IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(WebContentsImpl, message, render_frame_host)
[email protected]cfa856d62014-02-22 07:58:40897 IPC_MESSAGE_HANDLER(FrameHostMsg_DomOperationResponse,
898 OnDomOperationResponse)
[email protected]37b64c52014-07-11 21:14:05899 IPC_MESSAGE_HANDLER(FrameHostMsg_DidChangeThemeColor,
900 OnThemeColorChanged)
[email protected]8ed16472014-04-11 19:02:48901 IPC_MESSAGE_HANDLER(FrameHostMsg_DidFinishDocumentLoad,
902 OnDocumentLoadedInFrame)
903 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_DidDisplayInsecureContent,
[email protected]724159a2010-12-30 01:11:18907 OnDidDisplayInsecureContent)
elawrenceb2ac2a232017-03-27 21:46:25908 IPC_MESSAGE_HANDLER(FrameHostMsg_DidContainInsecureFormAction,
909 OnDidContainInsecureFormAction)
avi3a3332622015-09-01 01:18:54910 IPC_MESSAGE_HANDLER(FrameHostMsg_DidRunInsecureContent,
[email protected]724159a2010-12-30 01:11:18911 OnDidRunInsecureContent)
estark910b4572015-12-09 20:55:41912 IPC_MESSAGE_HANDLER(FrameHostMsg_DidDisplayContentWithCertificateErrors,
913 OnDidDisplayContentWithCertificateErrors)
914 IPC_MESSAGE_HANDLER(FrameHostMsg_DidRunContentWithCertificateErrors,
915 OnDidRunContentWithCertificateErrors)
Dave Tapuska549baab2019-03-19 15:52:40916 IPC_MESSAGE_HANDLER(FrameHostMsg_GoToEntryAtOffset, OnGoToEntryAtOffset)
avia23e16b2015-07-09 14:18:48917 IPC_MESSAGE_HANDLER(FrameHostMsg_RegisterProtocolHandler,
918 OnRegisterProtocolHandler)
919 IPC_MESSAGE_HANDLER(FrameHostMsg_UnregisterProtocolHandler,
920 OnUnregisterProtocolHandler)
kouhei40f03cb2015-09-24 07:47:01921 IPC_MESSAGE_HANDLER(FrameHostMsg_UpdatePageImportanceSignals,
922 OnUpdatePageImportanceSignals)
lukasza178ff092017-06-07 23:39:50923 IPC_MESSAGE_HANDLER(FrameHostMsg_UpdateFaviconURL, OnUpdateFaviconURL)
brettw4b461082016-11-19 18:55:16924#if BUILDFLAG(ENABLE_PLUGINS)
emaxxe70f5e12015-05-29 11:26:00925 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperInstanceCreated,
926 OnPepperInstanceCreated)
927 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperInstanceDeleted,
928 OnPepperInstanceDeleted)
tommyclie6633ca72014-10-31 00:40:42929 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperPluginHung, OnPepperPluginHung)
zqzhang181047e62016-07-01 13:37:17930 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperStartsPlayback,
931 OnPepperStartsPlayback)
932 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperStopsPlayback,
933 OnPepperStopsPlayback)
tommyclie6633ca72014-10-31 00:40:42934 IPC_MESSAGE_HANDLER(FrameHostMsg_PluginCrashed, OnPluginCrashed)
[email protected]c4538072013-03-18 02:17:55935 IPC_MESSAGE_HANDLER_GENERIC(BrowserPluginHostMsg_Attach,
fsamuel833ee7c2015-02-13 23:40:40936 OnBrowserPluginMessage(render_frame_host,
937 message))
thestigc4cac8f2014-09-04 21:17:50938#endif
[email protected]724159a2010-12-30 01:11:18939 IPC_MESSAGE_UNHANDLED(handled = false)
[email protected]e44d1342014-05-16 21:29:33940 IPC_END_MESSAGE_MAP()
[email protected]724159a2010-12-30 01:11:18941
[email protected]724159a2010-12-30 01:11:18942 return handled;
943}
944
[email protected]d1198fd2012-08-13 22:50:19945NavigationControllerImpl& WebContentsImpl::GetController() {
[email protected]f5fa20e2011-12-21 22:35:56946 return controller_;
947}
948
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41949BrowserContext* WebContentsImpl::GetBrowserContext() {
[email protected]a26023822011-12-29 00:23:55950 return controller_.GetBrowserContext();
[email protected]627e0512011-12-21 22:55:30951}
952
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41953const GURL& WebContentsImpl::GetURL() {
Peter Boström101d7672018-12-15 00:43:59954 return GetVisibleURL();
[email protected]be1f56ab2011-12-22 06:55:31955}
956
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41957const GURL& WebContentsImpl::GetVisibleURL() {
[email protected]c854a7e2013-05-21 16:42:24958 // We may not have a navigation entry yet.
[email protected]59167c22013-06-03 18:07:32959 NavigationEntry* entry = controller_.GetVisibleEntry();
[email protected]c854a7e2013-05-21 16:42:24960 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
961}
962
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41963const GURL& WebContentsImpl::GetLastCommittedURL() {
[email protected]c854a7e2013-05-21 16:42:24964 // We may not have a navigation entry yet.
965 NavigationEntry* entry = controller_.GetLastCommittedEntry();
966 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
967}
968
[email protected]8ff00d72012-10-23 19:12:21969WebContentsDelegate* WebContentsImpl::GetDelegate() {
[email protected]be1f56ab2011-12-22 06:55:31970 return delegate_;
971}
972
[email protected]8ff00d72012-10-23 19:12:21973void WebContentsImpl::SetDelegate(WebContentsDelegate* delegate) {
[email protected]be1f56ab2011-12-22 06:55:31974 // TODO(cbentzel): remove this debugging code?
975 if (delegate == delegate_)
976 return;
977 if (delegate_)
978 delegate_->Detach(this);
979 delegate_ = delegate;
[email protected]a6b73c62013-02-11 23:05:08980 if (delegate_) {
[email protected]be1f56ab2011-12-22 06:55:31981 delegate_->Attach(this);
[email protected]a6b73c62013-02-11 23:05:08982 // Ensure the visible RVH reflects the new delegate's preferences.
[email protected]86f98a22013-03-20 14:35:00983 if (view_)
[email protected]e85165c642014-06-10 14:34:31984 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
Joel Einbinder848001c2017-09-19 21:39:31985 if (GetRenderViewHost())
986 RenderFrameDevToolsAgentHost::WebContentsCreated(this);
[email protected]a6b73c62013-02-11 23:05:08987 }
[email protected]be1f56ab2011-12-22 06:55:31988}
989
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:41990RenderFrameHostImpl* WebContentsImpl::GetMainFrame() {
[email protected]94d0cc12013-12-18 00:07:41991 return frame_tree_.root()->current_frame_host();
[email protected]60eca4eb2013-12-06 00:02:16992}
993
nick53d5cbf2015-04-23 22:50:14994RenderFrameHostImpl* WebContentsImpl::GetFocusedFrame() {
995 FrameTreeNode* focused_node = frame_tree_.GetFocusedFrame();
996 if (!focused_node)
997 return nullptr;
998 return focused_node->current_frame_host();
[email protected]9c9343b2014-03-08 02:56:07999}
1000
rob3e2a0732016-01-06 21:22:091001RenderFrameHostImpl* WebContentsImpl::FindFrameByFrameTreeNodeId(
creisf71a2632017-05-04 19:03:501002 int frame_tree_node_id,
1003 int process_id) {
1004 FrameTreeNode* frame = frame_tree_.FindByID(frame_tree_node_id);
1005
1006 // Sanity check that this is in the caller's expected process. Otherwise a
1007 // recent cross-process navigation may have led to a privilege change that the
1008 // caller is not expecting.
1009 if (!frame ||
1010 frame->current_frame_host()->GetProcess()->GetID() != process_id)
1011 return nullptr;
1012
1013 return frame->current_frame_host();
1014}
1015
1016RenderFrameHostImpl* WebContentsImpl::UnsafeFindFrameByFrameTreeNodeId(
rob3e2a0732016-01-06 21:22:091017 int frame_tree_node_id) {
creisf71a2632017-05-04 19:03:501018 // Beware using this! The RenderFrameHost may have changed since the caller
1019 // obtained frame_tree_node_id.
rob3e2a0732016-01-06 21:22:091020 FrameTreeNode* frame = frame_tree_.FindByID(frame_tree_node_id);
1021 return frame ? frame->current_frame_host() : nullptr;
1022}
1023
[email protected]a86c0e962013-12-17 17:10:391024void WebContentsImpl::ForEachFrame(
Lei Zhangebcc6302018-01-12 19:46:451025 const base::RepeatingCallback<void(RenderFrameHost*)>& on_frame) {
dcheng57e39e22016-01-21 00:25:381026 for (FrameTreeNode* node : frame_tree_.Nodes()) {
1027 on_frame.Run(node->current_frame_host());
1028 }
[email protected]a86c0e962013-12-17 17:10:391029}
1030
dchengafb53e22016-02-04 08:11:081031std::vector<RenderFrameHost*> WebContentsImpl::GetAllFrames() {
1032 std::vector<RenderFrameHost*> frame_hosts;
1033 for (FrameTreeNode* node : frame_tree_.Nodes())
1034 frame_hosts.push_back(node->current_frame_host());
1035 return frame_hosts;
1036}
1037
lukaszacbdf52e2016-01-15 21:19:511038int WebContentsImpl::SendToAllFrames(IPC::Message* message) {
1039 int number_of_messages = 0;
dchengafb53e22016-02-04 08:11:081040 for (RenderFrameHost* rfh : GetAllFrames()) {
lukasza1a9ab2422016-03-02 18:47:251041 if (!rfh->IsRenderFrameLive())
1042 continue;
1043
dchengafb53e22016-02-04 08:11:081044 ++number_of_messages;
1045 IPC::Message* message_copy = new IPC::Message(*message);
1046 message_copy->set_routing_id(rfh->GetRoutingID());
1047 rfh->Send(message_copy);
1048 }
[email protected]a86c0e962013-12-17 17:10:391049 delete message;
lukaszacbdf52e2016-01-15 21:19:511050 return number_of_messages;
[email protected]a86c0e962013-12-17 17:10:391051}
1052
lfgdb5c4ed2016-03-04 23:09:071053void WebContentsImpl::SendPageMessage(IPC::Message* msg) {
alexmos136fd6e62016-08-15 20:58:411054 frame_tree_.root()->render_manager()->SendPageMessage(msg, nullptr);
lfgdb5c4ed2016-03-04 23:09:071055}
1056
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411057RenderViewHostImpl* WebContentsImpl::GetRenderViewHost() {
[email protected]fa944cb82013-11-15 17:51:211058 return GetRenderManager()->current_host();
[email protected]be1f56ab2011-12-22 06:55:311059}
1060
creis89a0f782015-05-27 16:13:171061void WebContentsImpl::CancelActiveAndPendingDialogs() {
avi5d3b8692016-10-12 22:00:461062 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:531063 dialog_manager_->CancelDialogs(this, /*reset_state=*/false);
avi5d3b8692016-10-12 22:00:461064 }
creis89a0f782015-05-27 16:13:171065 if (browser_plugin_embedder_)
1066 browser_plugin_embedder_->CancelGuestDialogs();
1067}
1068
naskoc0fceff2015-04-30 15:53:521069void WebContentsImpl::ClosePage() {
1070 GetRenderViewHost()->ClosePage();
1071}
1072
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411073RenderWidgetHostView* WebContentsImpl::GetRenderWidgetHostView() {
[email protected]fa944cb82013-11-15 17:51:211074 return GetRenderManager()->GetRenderWidgetHostView();
[email protected]be1f56ab2011-12-22 06:55:311075}
1076
lfg265a2672016-04-23 03:11:021077RenderWidgetHostView* WebContentsImpl::GetTopLevelRenderWidgetHostView() {
1078 if (GetOuterWebContents())
1079 return GetOuterWebContents()->GetTopLevelRenderWidgetHostView();
1080 return GetRenderManager()->GetRenderWidgetHostView();
1081}
1082
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411083RenderWidgetHostView* WebContentsImpl::GetFullscreenRenderWidgetHostView() {
vmpstr6d9996c82017-02-23 00:43:251084 if (auto* widget_host = GetFullscreenRenderWidgetHost())
ekaramadaeb3c5c2016-11-09 03:22:351085 return widget_host->GetView();
1086 return nullptr;
[email protected]4aebbca2013-09-17 22:26:491087}
1088
[email protected]8ff00d72012-10-23 19:12:211089WebContentsView* WebContentsImpl::GetView() const {
[email protected]be1f56ab2011-12-22 06:55:311090 return view_.get();
1091}
1092
leon.han552e9de2017-02-09 14:37:301093void WebContentsImpl::OnScreenOrientationChange() {
1094 DCHECK(screen_orientation_provider_);
Becca Hughese9e27952018-06-25 17:08:271095 screen_orientation_provider_->OnOrientationChange();
leon.hane4db177a2017-02-07 14:19:161096}
1097
Alan Cutter92d59252019-03-29 02:32:331098base::Optional<SkColor> WebContentsImpl::GetThemeColor() {
yusufod41c5f92015-03-06 00:14:281099 return theme_color_;
1100}
1101
Doug Turner63f3c7b2017-07-29 05:10:011102void WebContentsImpl::SetAccessibilityMode(ui::AXMode mode) {
[email protected]95640212014-07-26 18:14:301103 if (mode == accessibility_mode_)
1104 return;
1105
dmazzonif8a31042016-12-03 00:52:131106 // Don't allow accessibility to be enabled for WebContents that are never
1107 // visible, like background pages.
1108 if (IsNeverVisible())
1109 return;
1110
[email protected]95640212014-07-26 18:14:301111 accessibility_mode_ = mode;
dcheng57e39e22016-01-21 00:25:381112
1113 for (FrameTreeNode* node : frame_tree_.Nodes()) {
dmazzonif8a31042016-12-03 00:52:131114 UpdateAccessibilityModeOnFrame(node->current_frame_host());
clamy610c63b32017-12-22 15:05:181115 // Also update accessibility mode on the speculative RenderFrameHost for
1116 // this FrameTreeNode, if one exists.
Alex Moshchuk3d8a1f392017-10-24 19:01:261117 RenderFrameHost* speculative_frame_host =
1118 node->render_manager()->speculative_frame_host();
1119 if (speculative_frame_host)
1120 UpdateAccessibilityModeOnFrame(speculative_frame_host);
dcheng57e39e22016-01-21 00:25:381121 }
[email protected]95640212014-07-26 18:14:301122}
1123
Doug Turner63f3c7b2017-07-29 05:10:011124void WebContentsImpl::AddAccessibilityMode(ui::AXMode mode) {
1125 ui::AXMode new_mode(accessibility_mode_);
dougtcd3dad732017-03-14 03:26:231126 new_mode |= mode;
1127 SetAccessibilityMode(new_mode);
[email protected]95640212014-07-26 18:14:301128}
1129
Avi Drissman1e620f32018-03-16 13:57:291130// Helper class used by WebContentsImpl::RequestAXTreeSnapshot.
1131// Handles the callbacks from parallel snapshot requests to each frame,
1132// and feeds the results to an AXTreeCombiner, which converts them into a
1133// single combined accessibility tree.
1134class WebContentsImpl::AXTreeSnapshotCombiner
1135 : public base::RefCounted<AXTreeSnapshotCombiner> {
1136 public:
1137 explicit AXTreeSnapshotCombiner(AXTreeSnapshotCallback callback)
1138 : callback_(std::move(callback)) {}
1139
1140 AXTreeSnapshotCallback AddFrame(bool is_root) {
1141 // Adds a reference to |this|.
1142 return base::BindOnce(&AXTreeSnapshotCombiner::ReceiveSnapshot, this,
1143 is_root);
1144 }
1145
1146 void ReceiveSnapshot(bool is_root, const ui::AXTreeUpdate& snapshot) {
1147 combiner_.AddTree(snapshot, is_root);
1148 }
1149
1150 private:
1151 friend class base::RefCounted<AXTreeSnapshotCombiner>;
1152
1153 // This is called automatically after the last call to ReceiveSnapshot
1154 // when there are no more references to this object.
1155 ~AXTreeSnapshotCombiner() {
1156 combiner_.Combine();
1157 std::move(callback_).Run(combiner_.combined());
1158 }
1159
1160 ui::AXTreeCombiner combiner_;
1161 AXTreeSnapshotCallback callback_;
1162};
1163
1164void WebContentsImpl::RequestAXTreeSnapshot(AXTreeSnapshotCallback callback,
1165 ui::AXMode ax_mode) {
dmazzonid95ae842016-04-12 21:17:391166 // Send a request to each of the frames in parallel. Each one will return
1167 // an accessibility tree snapshot, and AXTreeSnapshotCombiner will combine
1168 // them into a single tree and call |callback| with that result, then
1169 // delete |combiner|.
Avi Drissman1e620f32018-03-16 13:57:291170 FrameTreeNode* root_node = frame_tree_.root();
tzik58faa742018-08-01 10:54:181171 auto combiner =
1172 base::MakeRefCounted<AXTreeSnapshotCombiner>(std::move(callback));
Avi Drissman1e620f32018-03-16 13:57:291173
tzik58faa742018-08-01 10:54:181174 RecursiveRequestAXTreeSnapshotOnFrame(root_node, combiner.get(), ax_mode);
Avi Drissman1e620f32018-03-16 13:57:291175}
1176
1177void WebContentsImpl::RecursiveRequestAXTreeSnapshotOnFrame(
1178 FrameTreeNode* root_node,
1179 AXTreeSnapshotCombiner* combiner,
1180 ui::AXMode ax_mode) {
dmazzonid95ae842016-04-12 21:17:391181 for (FrameTreeNode* frame_tree_node : frame_tree_.Nodes()) {
Avi Drissman1e620f32018-03-16 13:57:291182 WebContentsImpl* inner_contents =
1183 node_.GetInnerWebContentsInFrame(frame_tree_node);
1184 if (inner_contents) {
1185 inner_contents->RecursiveRequestAXTreeSnapshotOnFrame(root_node, combiner,
1186 ax_mode);
1187 } else {
1188 bool is_root = frame_tree_node == root_node;
1189 frame_tree_node->current_frame_host()->RequestAXTreeSnapshot(
1190 combiner->AddFrame(is_root), ax_mode);
1191 }
dmazzonid95ae842016-04-12 21:17:391192 }
dmazzoni83ba5c82015-04-14 07:11:511193}
1194
Becca Hughes3b5a43482018-07-17 22:31:551195void WebContentsImpl::NotifyViewportFitChanged(
1196 blink::mojom::ViewportFit value) {
1197 for (auto& observer : observers_)
1198 observer.ViewportFitChanged(value);
1199}
1200
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411201FindRequestManager* WebContentsImpl::GetFindRequestManagerForTesting() {
Ehsan Karamad6beb2ea2018-11-25 18:15:131202 return GetFindRequestManager();
1203}
1204
mcnee336ea2c2017-05-23 22:50:591205#if !defined(OS_ANDROID)
akabac6bd1212018-06-25 20:10:481206void WebContentsImpl::UpdateZoom() {
1207 RenderWidgetHostImpl* rwh = GetRenderViewHost()->GetWidget();
1208 if (rwh->GetView())
1209 rwh->SynchronizeVisualProperties();
wjmaclean64951902016-04-29 20:59:121210}
1211
wjmaclean64951902016-04-29 20:59:121212
1213void WebContentsImpl::UpdateZoomIfNecessary(const std::string& scheme,
akabac6bd1212018-06-25 20:10:481214 const std::string& host) {
wjmaclean64951902016-04-29 20:59:121215 NavigationEntry* entry = GetController().GetLastCommittedEntry();
1216 if (!entry)
1217 return;
1218
1219 GURL url = HostZoomMap::GetURLFromEntry(entry);
1220 if (host != net::GetHostOrSpecFromURL(url) ||
1221 (!scheme.empty() && !url.SchemeIs(scheme))) {
1222 return;
1223 }
1224
akabac6bd1212018-06-25 20:10:481225 UpdateZoom();
wjmaclean64951902016-04-29 20:59:121226}
mcnee336ea2c2017-05-23 22:50:591227#endif // !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:121228
rockotf62002a2016-09-15 00:08:591229base::Closure WebContentsImpl::AddBindingSet(
1230 const std::string& interface_name,
1231 WebContentsBindingSet* binding_set) {
1232 auto result =
1233 binding_sets_.insert(std::make_pair(interface_name, binding_set));
1234 DCHECK(result.second);
1235 return base::Bind(&WebContentsImpl::RemoveBindingSet,
1236 weak_factory_.GetWeakPtr(), interface_name);
1237}
1238
rockot8bbad222017-03-22 04:34:051239WebContentsBindingSet* WebContentsImpl::GetBindingSet(
1240 const std::string& interface_name) {
1241 auto it = binding_sets_.find(interface_name);
1242 if (it == binding_sets_.end())
1243 return nullptr;
1244 return it->second;
1245}
1246
paulmeyerfeafc2d2017-04-25 21:46:401247std::vector<WebContentsImpl*> WebContentsImpl::GetWebContentsAndAllInner() {
1248 std::vector<WebContentsImpl*> all_contents(1, this);
1249
1250 for (size_t i = 0; i != all_contents.size(); ++i) {
1251 for (auto* inner_contents : all_contents[i]->GetInnerWebContents()) {
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:161252 all_contents.push_back(static_cast<WebContentsImpl*>(inner_contents));
paulmeyerfeafc2d2017-04-25 21:46:401253 }
1254 }
1255
1256 return all_contents;
1257}
1258
Sam McNally145fb172017-05-10 00:13:231259void WebContentsImpl::NotifyManifestUrlChanged(
1260 const base::Optional<GURL>& manifest_url) {
1261 for (auto& observer : observers_)
1262 observer.DidUpdateWebManifestURL(manifest_url);
1263}
1264
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411265WebUI* WebContentsImpl::GetWebUI() {
carlosk35f35af2015-12-01 10:55:401266 WebUI* commited_web_ui = GetCommittedWebUI();
1267 return commited_web_ui ? commited_web_ui
1268 : GetRenderManager()->GetNavigatingWebUI();
[email protected]be1f56ab2011-12-22 06:55:311269}
1270
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411271WebUI* WebContentsImpl::GetCommittedWebUI() {
carlosk35f35af2015-12-01 10:55:401272 return frame_tree_.root()->current_frame_host()->web_ui();
[email protected]d5f942ba2008-09-26 19:30:341273}
1274
Changwan Ryuc1134a82018-03-07 02:10:141275void WebContentsImpl::SetUserAgentOverride(const std::string& override,
1276 bool override_in_new_tabs) {
[email protected]bf70edce2012-06-20 22:32:221277 if (GetUserAgentOverride() == override)
1278 return;
1279
Changwan Ryuc1134a82018-03-07 02:10:141280 should_override_user_agent_in_new_tabs_ = override_in_new_tabs;
1281
[email protected]bf70edce2012-06-20 22:32:221282 renderer_preferences_.user_agent_override = override;
1283
1284 // Send the new override string to the renderer.
1285 RenderViewHost* host = GetRenderViewHost();
1286 if (host)
1287 host->SyncRendererPrefs();
1288
1289 // Reload the page if a load is currently in progress to avoid having
1290 // different parts of the page loaded using different user agents.
[email protected]6286a372013-10-09 04:03:271291 NavigationEntry* entry = controller_.GetVisibleEntry();
Ivan Kotenkov2c0d2bb32017-11-01 15:41:281292 if (IsLoading() && entry != nullptr && entry->GetIsOverridingUserAgent())
toyoshim6142d96f2016-12-19 09:07:251293 controller_.Reload(ReloadType::BYPASSING_CACHE, true);
[email protected]8d0f3312012-08-18 01:47:531294
ericwilligersde386342016-10-19 02:35:091295 for (auto& observer : observers_)
1296 observer.UserAgentOverrideSet(override);
[email protected]86ef6a392012-05-11 22:03:111297}
1298
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411299const std::string& WebContentsImpl::GetUserAgentOverride() {
[email protected]bf70edce2012-06-20 22:32:221300 return renderer_preferences_.user_agent_override;
[email protected]86ef6a392012-05-11 22:03:111301}
1302
Changwan Ryuc1134a82018-03-07 02:10:141303bool WebContentsImpl::ShouldOverrideUserAgentInNewTabs() {
1304 return should_override_user_agent_in_new_tabs_;
1305}
1306
dmazzonidd3d51a72016-12-14 18:41:011307void WebContentsImpl::EnableWebContentsOnlyAccessibilityMode() {
Dominic Mazzonid9fda172019-03-07 17:12:071308 // If accessibility is already enabled, we'll need to force a reset
1309 // in order to ensure new observers of accessibility events get the
1310 // full accessibility tree from scratch.
1311 bool need_reset = GetAccessibilityMode().has_mode(ui::AXMode::kWebContents);
1312
1313 ui::AXMode desired_mode =
1314 GetContentClient()->browser()->GetAXModeForBrowserContext(
1315 GetBrowserContext());
1316 desired_mode |= ui::kAXModeWebContentsOnly;
1317 AddAccessibilityMode(desired_mode);
1318
1319 if (need_reset) {
dchengafb53e22016-02-04 08:11:081320 for (RenderFrameHost* rfh : GetAllFrames())
1321 ResetAccessibility(rfh);
dchengafb53e22016-02-04 08:11:081322 }
[email protected]95640212014-07-26 18:14:301323}
1324
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411325bool WebContentsImpl::IsWebContentsOnlyAccessibilityModeForTesting() {
Doug Turner63f3c7b2017-07-29 05:10:011326 return accessibility_mode_ == ui::kAXModeWebContentsOnly;
[email protected]95640212014-07-26 18:14:301327}
1328
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411329bool WebContentsImpl::IsFullAccessibilityModeForTesting() {
Doug Turner63f3c7b2017-07-29 05:10:011330 return accessibility_mode_ == ui::kAXModeComplete;
[email protected]95640212014-07-26 18:14:301331}
1332
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411333const PageImportanceSignals& WebContentsImpl::GetPageImportanceSignals() {
kouhei40f03cb2015-09-24 07:47:011334 return page_importance_signals_;
1335}
1336
Guido Urdanetaf4008002018-05-03 10:43:041337const std::string& WebContentsImpl::GetMediaDeviceGroupIDSaltBase() const {
1338 return media_device_group_id_salt_base_;
1339}
1340
Becca Hughes6daf5662018-06-27 16:50:541341#if defined(OS_ANDROID)
1342
1343void WebContentsImpl::SetDisplayCutoutSafeArea(gfx::Insets insets) {
Becca Hughes86334622018-07-09 21:29:381344 if (display_cutout_host_impl_)
1345 display_cutout_host_impl_->SetDisplayCutoutSafeArea(insets);
Becca Hughes6daf5662018-06-27 16:50:541346}
1347
1348#endif
1349
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411350const base::string16& WebContentsImpl::GetTitle() {
[email protected]4c6092c5b2009-06-06 00:23:551351 // Transient entries take precedence. They are used for interstitial pages
1352 // that are shown on top of existing pages.
[email protected]10f417c52011-12-28 21:04:231353 NavigationEntry* entry = controller_.GetTransientEntry();
[email protected]45d0ef7f2011-01-05 13:46:231354 if (entry) {
jshin1fb76462016-04-05 22:13:031355 return entry->GetTitleForDisplay();
[email protected]45d0ef7f2011-01-05 13:46:231356 }
carlosk35f35af2015-12-01 10:55:401357
1358 WebUI* navigating_web_ui = GetRenderManager()->GetNavigatingWebUI();
1359 WebUI* our_web_ui = navigating_web_ui
1360 ? navigating_web_ui
1361 : GetRenderManager()->current_frame_host()->web_ui();
1362
[email protected]7ade2732011-02-10 00:13:581363 if (our_web_ui) {
[email protected]96d185d2009-04-24 03:28:541364 // Don't override the title in view source mode.
[email protected]59167c22013-06-03 18:07:321365 entry = controller_.GetVisibleEntry();
[email protected]96d185d2009-04-24 03:28:541366 if (!(entry && entry->IsViewSourceMode())) {
[email protected]e0112912011-02-02 22:54:351367 // Give the Web UI the chance to override our title.
[email protected]fcf75d42013-12-03 20:11:261368 const base::string16& title = our_web_ui->GetOverriddenTitle();
[email protected]96d185d2009-04-24 03:28:541369 if (!title.empty())
1370 return title;
1371 }
1372 }
1373
1374 // We use the title for the last committed entry rather than a pending
1375 // navigation entry. For example, when the user types in a URL, we want to
1376 // keep the old page's title until the new load has committed and we get a new
1377 // title.
[email protected]96d185d2009-04-24 03:28:541378 entry = controller_.GetLastCommittedEntry();
[email protected]59167c22013-06-03 18:07:321379
creis072b61f2015-09-28 20:52:241380 // We make an exception for initial navigations. We only want to use the title
1381 // from the visible entry if:
1382 // 1. The pending entry has been explicitly assigned a title to display.
1383 // 2. The user is doing a history navigation in a new tab (e.g., Ctrl+Back),
1384 // which case there is a pending entry index other than -1.
1385 //
1386 // Otherwise, we want to stick with the last committed entry's title during
1387 // new navigations, which have pending entries at index -1 with no title.
1388 if (controller_.IsInitialNavigation() &&
1389 ((controller_.GetVisibleEntry() &&
1390 !controller_.GetVisibleEntry()->GetTitle().empty()) ||
1391 controller_.GetPendingEntryIndex() != -1)) {
1392 entry = controller_.GetVisibleEntry();
[email protected]9eeafc012013-11-25 23:49:471393 }
[email protected]59167c22013-06-03 18:07:321394
[email protected]45d0ef7f2011-01-05 13:46:231395 if (entry) {
jshin1fb76462016-04-05 22:13:031396 return entry->GetTitleForDisplay();
[email protected]45d0ef7f2011-01-05 13:46:231397 }
[email protected]987fc3a2011-05-26 14:18:091398
1399 // |page_title_when_no_navigation_entry_| is finally used
1400 // if no title cannot be retrieved.
1401 return page_title_when_no_navigation_entry_;
[email protected]96d185d2009-04-24 03:28:541402}
1403
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411404SiteInstanceImpl* WebContentsImpl::GetSiteInstance() {
[email protected]fa944cb82013-11-15 17:51:211405 return GetRenderManager()->current_host()->GetSiteInstance();
[email protected]96d185d2009-04-24 03:28:541406}
1407
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411408bool WebContentsImpl::IsLoading() {
clamy44e84ce2016-02-22 15:38:251409 return frame_tree_.IsLoading() &&
creisadca9862017-06-16 19:12:111410 !(ShowingInterstitialPage() && interstitial_page_->pause_throbber());
[email protected]3c9e1872010-11-18 16:17:491411}
1412
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411413double WebContentsImpl::GetLoadProgress() {
Peter Boström18a40fa2018-10-31 19:03:501414 return frame_tree_.load_progress();
1415}
1416
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411417bool WebContentsImpl::IsLoadingToDifferentDocument() {
clamy44e84ce2016-02-22 15:38:251418 return IsLoading() && is_load_to_different_document_;
[email protected]6dfed692014-05-22 04:18:031419}
1420
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411421bool WebContentsImpl::IsWaitingForResponse() {
Peter Boströma9a27f6e2018-11-21 13:12:191422 NavigationRequest* ongoing_navigation_request =
1423 frame_tree_.root()->navigation_request();
1424
1425 // An ongoing navigation request means we're waiting for a response.
1426 return ongoing_navigation_request != nullptr;
[email protected]be1f56ab2011-12-22 06:55:311427}
1428
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411429const net::LoadStateWithParam& WebContentsImpl::GetLoadState() {
[email protected]be1f56ab2011-12-22 06:55:311430 return load_state_;
1431}
1432
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411433const base::string16& WebContentsImpl::GetLoadStateHost() {
[email protected]be1f56ab2011-12-22 06:55:311434 return load_state_host_;
1435}
1436
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411437uint64_t WebContentsImpl::GetUploadSize() {
[email protected]be1f56ab2011-12-22 06:55:311438 return upload_size_;
1439}
1440
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411441uint64_t WebContentsImpl::GetUploadPosition() {
[email protected]be1f56ab2011-12-22 06:55:311442 return upload_position_;
1443}
1444
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411445const std::string& WebContentsImpl::GetEncoding() {
[email protected]ef3adfc2014-05-11 00:04:541446 return canonical_encoding_;
[email protected]be1f56ab2011-12-22 06:55:311447}
1448
Charles Zhaod72f99d2018-09-17 14:18:271449bool WebContentsImpl::WasDiscarded() {
1450 return GetFrameTree()->root()->was_discarded();
1451}
1452
Shubhie Panickerddf2a4e2018-03-06 00:09:061453void WebContentsImpl::SetWasDiscarded(bool was_discarded) {
1454 GetFrameTree()->root()->set_was_discarded();
1455}
1456
[email protected]222f5822014-02-05 23:40:491457void WebContentsImpl::IncrementCapturerCount(const gfx::Size& capture_size) {
[email protected]5a652232013-02-12 06:15:251458 DCHECK(!is_being_destroyed_);
Francois Doraye6161152018-03-27 22:05:371459 const bool was_captured = IsBeingCaptured();
[email protected]54597982013-02-06 01:59:551460 ++capturer_count_;
1461 DVLOG(1) << "There are now " << capturer_count_
1462 << " capturing(s) of WebContentsImpl@" << this;
[email protected]222f5822014-02-05 23:40:491463
1464 // Note: This provides a hint to upstream code to size the views optimally
1465 // for quality (e.g., to avoid scaling).
1466 if (!capture_size.IsEmpty() && preferred_size_for_capture_.IsEmpty()) {
1467 preferred_size_for_capture_ = capture_size;
1468 OnPreferredSizeChanged(preferred_size_);
1469 }
ccameron8807c38f2015-01-17 00:29:191470
Francois Doraye6161152018-03-27 22:05:371471 if (GetVisibility() != Visibility::VISIBLE && !was_captured) {
1472 // Ensure that all views act as if they were visible before capture begins.
1473 // TODO(fdoray): Replace RenderWidgetHostView::WasUnOccluded() with a method
1474 // to explicitly notify the RenderWidgetHostView that capture began.
1475 // https://crbug.com/668690
Ehsan Karamada03e1582018-12-05 23:07:561476 if (auto* main_view = GetRenderWidgetHostView())
1477 main_view->WasUnOccluded();
1478 if (!ShowingInterstitialPage())
1479 SetVisibilityForChildViews(true);
Francois Doraye6161152018-03-27 22:05:371480 }
[email protected]54597982013-02-06 01:59:551481}
1482
1483void WebContentsImpl::DecrementCapturerCount() {
1484 --capturer_count_;
1485 DVLOG(1) << "There are now " << capturer_count_
1486 << " capturing(s) of WebContentsImpl@" << this;
1487 DCHECK_LE(0, capturer_count_);
1488
[email protected]5a652232013-02-12 06:15:251489 if (is_being_destroyed_)
1490 return;
1491
Francois Doray24fc62c2017-12-11 17:27:331492 if (!IsBeingCaptured()) {
[email protected]222f5822014-02-05 23:40:491493 const gfx::Size old_size = preferred_size_for_capture_;
1494 preferred_size_for_capture_ = gfx::Size();
1495 OnPreferredSizeChanged(old_size);
[email protected]222f5822014-02-05 23:40:491496
Francois Doraye6161152018-03-27 22:05:371497 if (visibility_ == Visibility::HIDDEN) {
Francois Doray18800972017-08-25 22:38:581498 DVLOG(1) << "Executing delayed WasHidden().";
1499 WasHidden();
Francois Doraye6161152018-03-27 22:05:371500 } else if (visibility_ == Visibility::OCCLUDED) {
Mitsuru Oshima04a80242018-03-03 03:06:151501 WasOccluded();
Francois Doraye6161152018-03-27 22:05:371502 }
[email protected]54597982013-02-06 01:59:551503 }
[email protected]be1f56ab2011-12-22 06:55:311504}
1505
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411506bool WebContentsImpl::IsBeingCaptured() {
Francois Doray24fc62c2017-12-11 17:27:331507 return capturer_count_ > 0;
[email protected]f2bd40812013-07-20 04:30:441508}
1509
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411510bool WebContentsImpl::IsAudioMuted() {
Max Morinb5506f72018-05-16 07:33:101511 if (base::FeatureList::IsEnabled(features::kAudioServiceAudioStreams)) {
1512 return audio_stream_factory_ && audio_stream_factory_->IsMuted();
1513 }
miu50f97892014-09-22 22:49:521514 return audio_muter_.get() && audio_muter_->is_muting();
1515}
1516
1517void WebContentsImpl::SetAudioMuted(bool mute) {
1518 DVLOG(1) << "SetAudioMuted(mute=" << mute << "), was " << IsAudioMuted()
1519 << " for WebContentsImpl@" << this;
1520
1521 if (mute == IsAudioMuted())
1522 return;
1523
Max Morinb5506f72018-05-16 07:33:101524 if (base::FeatureList::IsEnabled(features::kAudioServiceAudioStreams)) {
1525 GetAudioStreamFactory()->SetMuted(mute);
miu50f97892014-09-22 22:49:521526 } else {
Max Morinb5506f72018-05-16 07:33:101527 if (mute) {
1528 if (!audio_muter_)
1529 audio_muter_.reset(new WebContentsAudioMuter(this));
1530 audio_muter_->StartMuting();
1531 } else {
1532 DCHECK(audio_muter_);
1533 audio_muter_->StopMuting();
1534 }
miu50f97892014-09-22 22:49:521535 }
1536
ericwilligersde386342016-10-19 02:35:091537 for (auto& observer : observers_)
1538 observer.DidUpdateAudioMutingState(mute);
wjmaclean2f797c782016-01-07 14:52:031539
Jan Rucka442c83f2017-08-08 13:27:541540 // Notification for UI updates in response to the changed muting state.
1541 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
1542}
1543
1544bool WebContentsImpl::IsCurrentlyAudible() {
Chris Hamiltondf0d72cd2018-05-29 16:23:531545 return is_currently_audible_;
miu50f97892014-09-22 22:49:521546}
1547
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411548bool WebContentsImpl::IsConnectedToBluetoothDevice() {
ortunodf4d7982016-04-08 02:33:351549 return bluetooth_connected_device_count_ > 0;
ortuno32e7db3c2016-03-29 16:14:201550}
1551
Lucas Furukawa Gadani4b4eed02019-06-04 23:12:041552bool WebContentsImpl::IsConnectedToSerialPort() {
Reilly Grant5e7c79b22019-04-09 17:26:201553 return serial_active_frame_count_ > 0;
1554}
1555
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411556bool WebContentsImpl::HasPictureInPictureVideo() {
sawtellea7333a82018-05-31 02:36:361557 return has_picture_in_picture_video_;
1558}
1559
1560void WebContentsImpl::SetHasPictureInPictureVideo(
1561 bool has_picture_in_picture_video) {
1562 // If status of |this| is already accurate, there is no need to update.
1563 if (has_picture_in_picture_video == has_picture_in_picture_video_)
1564 return;
1565 has_picture_in_picture_video_ = has_picture_in_picture_video;
1566 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
François Beaufort058085d2018-08-30 15:29:141567 for (auto& observer : observers_)
1568 observer.MediaPictureInPictureChanged(has_picture_in_picture_video_);
sawtellea7333a82018-05-31 02:36:361569}
1570
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411571bool WebContentsImpl::IsCrashed() {
Dominic Mazzoni73a48322018-05-25 18:14:071572 switch (crashed_status_) {
1573 case base::TERMINATION_STATUS_PROCESS_CRASHED:
1574 case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
1575 case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
1576 case base::TERMINATION_STATUS_OOM:
1577 case base::TERMINATION_STATUS_LAUNCH_FAILED:
oshima620225722015-06-04 19:45:271578#if defined(OS_CHROMEOS)
Dominic Mazzoni73a48322018-05-25 18:14:071579 case base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM:
oshima620225722015-06-04 19:45:271580#endif
Dominic Mazzoni73a48322018-05-25 18:14:071581#if defined(OS_ANDROID)
1582 case base::TERMINATION_STATUS_OOM_PROTECTED:
1583#endif
1584 return true;
1585 case base::TERMINATION_STATUS_NORMAL_TERMINATION:
1586 case base::TERMINATION_STATUS_STILL_RUNNING:
1587 return false;
1588 case base::TERMINATION_STATUS_MAX_ENUM:
1589 NOTREACHED();
1590 return false;
1591 }
1592
1593 NOTREACHED();
1594 return false;
[email protected]3c9e1872010-11-18 16:17:491595}
1596
[email protected]b172aee2012-04-10 17:05:261597void WebContentsImpl::SetIsCrashed(base::TerminationStatus status,
1598 int error_code) {
[email protected]443b80e2010-12-14 00:42:231599 if (status == crashed_status_)
[email protected]d5f942ba2008-09-26 19:30:341600 return;
1601
[email protected]443b80e2010-12-14 00:42:231602 crashed_status_ = status;
1603 crashed_error_code_ = error_code;
[email protected]8ff00d72012-10-23 19:12:211604 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
[email protected]d5f942ba2008-09-26 19:30:341605}
1606
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411607base::TerminationStatus WebContentsImpl::GetCrashedStatus() {
[email protected]be1f56ab2011-12-22 06:55:311608 return crashed_status_;
1609}
1610
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411611int WebContentsImpl::GetCrashedErrorCode() {
afakhry98241832016-03-11 19:27:471612 return crashed_error_code_;
1613}
1614
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411615bool WebContentsImpl::IsBeingDestroyed() {
[email protected]be1f56ab2011-12-22 06:55:311616 return is_being_destroyed_;
1617}
1618
[email protected]7f924832014-08-09 05:57:221619void WebContentsImpl::NotifyNavigationStateChanged(
1620 InvalidateTypes changed_flags) {
dalecurtis88c240072015-12-09 02:11:181621 // Notify the media observer of potential audibility changes.
1622 if (changed_flags & INVALIDATE_TYPE_TAB) {
mlamouri44e4ef42016-01-20 18:42:271623 media_web_contents_observer_->MaybeUpdateAudibleState();
dalecurtisbc6572e12014-09-12 19:22:301624 }
1625
[email protected]d5f942ba2008-09-26 19:30:341626 if (delegate_)
1627 delegate_->NavigationStateChanged(this, changed_flags);
wjmaclean1dabf3e32016-05-13 23:34:441628
1629 if (GetOuterWebContents())
1630 GetOuterWebContents()->NotifyNavigationStateChanged(changed_flags);
[email protected]d5f942ba2008-09-26 19:30:341631}
1632
W. James MacLean7c8581072019-06-18 18:07:531633void WebContentsImpl::NotifyVisibleViewportSizeChanged(
1634 const gfx::Size& visible_viewport_size) {
1635 SendPageMessage(new PageMsg_UpdatePageVisualProperties(
1636 MSG_ROUTING_NONE, visible_viewport_size));
1637}
1638
Chris Hamiltondf0d72cd2018-05-29 16:23:531639void WebContentsImpl::OnAudioStateChanged() {
1640 // This notification can come from any embedded contents or from this
1641 // WebContents' stream monitor. Aggregate these signals to get the actual
1642 // state.
1643 bool is_currently_audible =
1644 audio_stream_monitor_.IsCurrentlyAudible() ||
1645 (browser_plugin_embedder_ &&
1646 browser_plugin_embedder_->AreAnyGuestsCurrentlyAudible());
1647 if (is_currently_audible == is_currently_audible_)
1648 return;
1649
1650 // Update internal state.
1651 is_currently_audible_ = is_currently_audible;
1652 was_ever_audible_ = was_ever_audible_ || is_currently_audible_;
1653
1654 SendPageMessage(
1655 new PageMsg_AudioStateChanged(MSG_ROUTING_NONE, is_currently_audible_));
altimind8bd26c2016-11-04 11:44:541656
altiminec87fd1f2016-11-17 20:22:491657 // Notification for UI updates in response to the changed audio state.
altimind8bd26c2016-11-04 11:44:541658 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
Jan Rucka442c83f2017-08-08 13:27:541659
Chris Hamiltondf0d72cd2018-05-29 16:23:531660 // Ensure that audio state changes propagate from innermost to outermost
1661 // WebContents.
1662 if (GetOuterWebContents())
1663 GetOuterWebContents()->OnAudioStateChanged();
Tommy Steimel18360512017-11-01 00:38:191664
Chris Hamiltoneb41198f2018-05-24 18:41:261665 for (auto& observer : observers_)
Chris Hamiltondf0d72cd2018-05-29 16:23:531666 observer.OnAudioStateChanged(is_currently_audible_);
altimind8bd26c2016-11-04 11:44:541667}
1668
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411669base::TimeTicks WebContentsImpl::GetLastActiveTime() {
[email protected]9a890452014-02-13 22:21:021670 return last_active_time_;
[email protected]3e324142012-06-25 18:26:331671}
1672
[email protected]9e2e4632012-07-27 16:38:411673void WebContentsImpl::WasShown() {
[email protected]96d185d2009-04-24 03:28:541674 controller_.SetActive(true);
[email protected]de3c5d82014-05-28 22:12:591675
danakjc1e71e4f2018-12-05 19:34:351676 // This shows the Page before showing the individual RenderWidgets, as
1677 // RenderWidgets will work to produce compositor frames and handle input
1678 // as soon as they are shown. But the Page and other classes do not expect to
1679 // be producing frames when the Page is hidden. So we make sure the Page is
1680 // shown first.
1681 SendPageMessage(new PageMsg_WasShown(MSG_ROUTING_NONE));
1682
EhsanK2075c7e2017-08-21 02:42:391683 if (auto* view = GetRenderWidgetHostView()) {
lfgf949e0e2017-05-10 22:18:111684 view->Show();
[email protected]789e9152009-08-04 21:59:431685#if defined(OS_MACOSX)
lfgf949e0e2017-05-10 22:18:111686 view->SetActive(true);
[email protected]789e9152009-08-04 21:59:431687#endif
1688 }
[email protected]96d185d2009-04-24 03:28:541689
EhsanK2075c7e2017-08-21 02:42:391690 if (!ShowingInterstitialPage())
1691 SetVisibilityForChildViews(true);
1692
gab0dccfef2015-05-20 18:43:391693 last_active_time_ = base::TimeTicks::Now();
Francois Doraye6161152018-03-27 22:05:371694 SetVisibility(Visibility::VISIBLE);
Lukasz Anforowicz873e6082018-05-17 00:12:331695
1696 for (FrameTreeNode* node : frame_tree_.Nodes()) {
1697 RenderFrameProxyHost* parent = node->render_manager()->GetProxyToParent();
1698 if (!parent)
1699 continue;
1700
Alex Moshchuk2b0c91d2018-10-10 18:41:161701 parent->cross_process_frame_connector()->DelegateWasShown();
Lukasz Anforowicz873e6082018-05-17 00:12:331702 }
[email protected]be1f56ab2011-12-22 06:55:311703}
1704
[email protected]b172aee2012-04-10 17:05:261705void WebContentsImpl::WasHidden() {
Jennifer Apacible72c31412018-06-19 16:52:241706 // If there are entities capturing screenshots or video (e.g. mirroring),
François Beaufort0e27cee02019-01-18 13:21:351707 // or in Picture-in-Picture mode, don't activate the "disable rendering"
1708 // optimization.
1709 if (!IsBeingCaptured() && !HasPictureInPictureVideo()) {
danakjc1e71e4f2018-12-05 19:34:351710 // This hides the individual RenderWidgets before hiding the Page, as
1711 // RenderWidgets will work to produce compositor frames and handle input
1712 // until they are hidden. But the Page and other classes do not expect to
1713 // be producing frames when the Page is hidden. So we stop the widgets,
1714 // then hide the Page.
1715 //
[email protected]151a63d2011-12-20 22:32:521716 // |GetRenderViewHost()| can be NULL if the user middle clicks a link to
[email protected]54597982013-02-06 01:59:551717 // open a tab in the background, then closes the tab before selecting it.
[email protected]b172aee2012-04-10 17:05:261718 // This is because closing the tab calls WebContentsImpl::Destroy(), which
[email protected]151a63d2011-12-20 22:32:521719 // removes the |GetRenderViewHost()|; then when we actually destroy the
[email protected]3e324142012-06-25 18:26:331720 // window, OnWindowPosChanged() notices and calls WasHidden() (which
[email protected]151a63d2011-12-20 22:32:521721 // calls us).
EhsanK2075c7e2017-08-21 02:42:391722 if (auto* view = GetRenderWidgetHostView())
lfgf949e0e2017-05-10 22:18:111723 view->Hide();
lfg717154072016-06-30 15:04:161724
EhsanK2075c7e2017-08-21 02:42:391725 if (!ShowingInterstitialPage())
Igor Eremeevef59187a2017-09-29 00:25:421726 SetVisibilityForChildViews(false);
[email protected]96d185d2009-04-24 03:28:541727 }
1728
François Beaufort0e27cee02019-01-18 13:21:351729 // Inform the renderer that the page was hidden if there are no entities
1730 // capturing screenshots or video (e.g. mirroring).
1731 if (!IsBeingCaptured())
1732 SendPageMessage(new PageMsg_WasHidden(MSG_ROUTING_NONE));
1733
Francois Doraye6161152018-03-27 22:05:371734 SetVisibility(Visibility::HIDDEN);
[email protected]375fa1b2012-05-22 22:05:371735}
1736
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411737bool WebContentsImpl::HasRecentInteractiveInputEvent() {
Daniel Cheng90196c82018-04-25 21:49:141738 static constexpr base::TimeDelta kMaxInterval =
1739 base::TimeDelta::FromSeconds(5);
1740 base::TimeDelta delta =
1741 ui::EventTimeForNow() - last_interactive_input_event_time_;
1742 // Note: the expectation is that the caller is typically expecting an input
1743 // event, e.g. validating that a WebUI message that requires a gesture is
1744 // actually attached to a gesture. Logging to UMA here should hopefully give
1745 // sufficient data if 5 seconds is actually sufficient (or even too high a
1746 // threshhold).
1747 UMA_HISTOGRAM_TIMES("Tabs.TimeSinceLastInteraction", delta);
1748 return delta <= kMaxInterval;
1749}
1750
Avi Drissman738ea192018-08-29 20:24:161751void WebContentsImpl::SetIgnoreInputEvents(bool ignore_input_events) {
1752 ignore_input_events_ = ignore_input_events;
1753}
1754
Bo Liu168c8642017-08-28 18:26:021755#if defined(OS_ANDROID)
Bo Liu16dd7b8322018-05-02 21:19:501756void WebContentsImpl::SetMainFrameImportance(
1757 ChildProcessImportance importance) {
1758 GetMainFrame()->GetRenderWidgetHost()->SetImportance(importance);
Bo Liu7c6779e92017-08-16 02:02:281759 if (ShowingInterstitialPage()) {
Bo Liu16dd7b8322018-05-02 21:19:501760 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
1761 ->GetRenderWidgetHost()
1762 ->SetImportance(importance);
Bo Liu7c6779e92017-08-16 02:02:281763 }
Bo Liu7c6779e92017-08-16 02:02:281764}
Bo Liu168c8642017-08-28 18:26:021765#endif
Bo Liu7c6779e92017-08-16 02:02:281766
ccameron8807c38f2015-01-17 00:29:191767void WebContentsImpl::WasOccluded() {
François Beaufortfec686f2019-01-18 17:12:491768 // If there are entities capturing screenshots or video (e.g. mirroring),
1769 // or in Picture-in-Picture mode, don't activate the "disable rendering"
1770 // optimization.
1771 if (!IsBeingCaptured() && !HasPictureInPictureVideo()) {
Ehsan Karamada03e1582018-12-05 23:07:561772 if (auto* main_view = GetRenderWidgetHostView())
1773 main_view->WasOccluded();
1774 if (!ShowingInterstitialPage()) {
1775 // Occluding child view is treated as hiding the view
1776 // (https://crbug.com/903455).
1777 SetVisibilityForChildViews(false);
1778 }
Francois Doray18800972017-08-25 22:38:581779 }
François Beaufortfec686f2019-01-18 17:12:491780
1781 // Inform the renderer that the page was hidden if there are no entities
1782 // capturing screenshots or video (e.g. mirroring).
1783 if (!IsBeingCaptured())
1784 SendPageMessage(new PageMsg_WasHidden(MSG_ROUTING_NONE));
1785
Francois Doraye6161152018-03-27 22:05:371786 SetVisibility(Visibility::OCCLUDED);
ccameron8807c38f2015-01-17 00:29:191787}
1788
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:411789Visibility WebContentsImpl::GetVisibility() {
Francois Doraye6161152018-03-27 22:05:371790 return visibility_;
Francois Dorayfe4a1772018-02-17 04:17:091791}
1792
Alex Moshchuk6fcaca752018-07-14 02:13:591793// TODO(alexmos): rename to NeedToFireBeforeUnloadOrUnload().
[email protected]b172aee2012-04-10 17:05:261794bool WebContentsImpl::NeedToFireBeforeUnload() {
[email protected]be1f56ab2011-12-22 06:55:311795 // TODO(creis): Should we fire even for interstitial pages?
Alex Moshchuk6fcaca752018-07-14 02:13:591796 if (ShowingInterstitialPage())
1797 return false;
1798
1799 if (!WillNotifyDisconnection())
1800 return false;
1801
1802 // Don't fire if the main frame's RenderViewHost indicates that beforeunload
1803 // and unload have already executed (e.g., after receiving a ClosePage ACK)
1804 // or should be ignored.
1805 if (GetRenderViewHost()->SuddenTerminationAllowed())
1806 return false;
1807
Aditya Keerthi34f37e62019-03-08 15:54:531808 // Check whether the main frame needs to run beforeunload or unload handlers.
1809 if (GetMainFrame()->GetSuddenTerminationDisablerState(
1810 blink::kBeforeUnloadHandler | blink::kUnloadHandler)) {
Alex Moshchuk6fcaca752018-07-14 02:13:591811 return true;
Aditya Keerthi34f37e62019-03-08 15:54:531812 }
Alex Moshchuk6fcaca752018-07-14 02:13:591813
1814 // Check whether any subframes need to run beforeunload handlers.
1815 //
1816 // TODO(alexmos): Also check whether subframes need to run unload handlers in
1817 // addition to beforeunload.
1818 return GetMainFrame()->ShouldDispatchBeforeUnload(
1819 true /* check_subframes_only */);
[email protected]be1f56ab2011-12-22 06:55:311820}
1821
Chris Hamilton3b3e315d2018-09-19 13:16:211822void WebContentsImpl::DispatchBeforeUnload(bool auto_cancel) {
1823 auto before_unload_type =
1824 auto_cancel ? RenderFrameHostImpl::BeforeUnloadType::DISCARD
1825 : RenderFrameHostImpl::BeforeUnloadType::TAB_CLOSE;
1826 GetMainFrame()->DispatchBeforeUnload(before_unload_type, false);
[email protected]1c3f80bd2014-04-08 23:02:061827}
1828
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501829void WebContentsImpl::AttachInnerWebContents(
1830 std::unique_ptr<WebContents> inner_web_contents,
1831 RenderFrameHost* render_frame_host) {
1832 WebContentsImpl* inner_web_contents_impl =
1833 static_cast<WebContentsImpl*>(inner_web_contents.get());
1834 DCHECK(!inner_web_contents_impl->node_.outer_web_contents());
1835 auto* render_frame_host_impl =
1836 static_cast<RenderFrameHostImpl*>(render_frame_host);
1837 DCHECK_EQ(&frame_tree_,
1838 render_frame_host_impl->frame_tree_node()->frame_tree());
Lucas Furukawa Gadani105de1e812018-05-31 19:38:391839
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501840 RenderFrameHostManager* inner_render_manager =
1841 inner_web_contents_impl->GetRenderManager();
1842 RenderFrameHostImpl* inner_main_frame =
1843 inner_render_manager->current_frame_host();
1844 RenderViewHostImpl* inner_render_view_host =
1845 inner_render_manager->current_host();
1846 auto* outer_render_manager =
1847 render_frame_host_impl->frame_tree_node()->render_manager();
lfg91a79e12016-04-01 23:52:191848
Lucas Furukawa Gadani105de1e812018-05-31 19:38:391849 // When attaching a WebContents as an inner WebContents, we need to replace
1850 // the Webcontents' view with a WebContentsViewChildFrame.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501851 inner_web_contents_impl->view_.reset(new WebContentsViewChildFrame(
1852 inner_web_contents_impl,
1853 GetContentClient()->browser()->GetWebContentsViewDelegate(
1854 inner_web_contents_impl),
1855 &inner_web_contents_impl->render_view_host_delegate_view_));
Lucas Furukawa Gadani105de1e812018-05-31 19:38:391856
lfg91a79e12016-04-01 23:52:191857 // When the WebContents being initialized has an opener, the browser side
1858 // Render{View,Frame}Host must be initialized and the RenderWidgetHostView
1859 // created. This is needed because the usual initialization happens during
1860 // the first navigation, but when attaching a new window we don't navigate
1861 // before attaching. If the browser side is already initialized, the calls
1862 // below will just early return.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501863 inner_render_manager->InitRenderView(inner_render_view_host, nullptr);
1864 inner_main_frame->Init();
1865 if (!inner_render_manager->GetRenderWidgetHostView()) {
1866 inner_web_contents_impl->CreateRenderWidgetHostViewForRenderManager(
1867 inner_render_view_host);
1868 }
lfg91a79e12016-04-01 23:52:191869
lazyboy6ec48b2a2015-06-29 15:18:141870 // Create a link to our outer WebContents.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501871 node_.AttachInnerWebContents(std::move(inner_web_contents),
1872 render_frame_host_impl);
lazyboy6ec48b2a2015-06-29 15:18:141873
lazyboy6ec48b2a2015-06-29 15:18:141874 // Create a proxy in top-level RenderFrameHostManager, pointing to the
1875 // SiteInstance of the outer WebContents. The proxy will be used to send
1876 // postMessage to the inner WebContents.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501877 auto* proxy = inner_render_manager->CreateOuterDelegateProxy(
1878 render_frame_host_impl->GetSiteInstance());
lazyboy6ec48b2a2015-06-29 15:18:141879
Lucas Furukawa Gadani99125822019-01-03 15:41:491880 // When attaching a GuestView as an inner WebContents, there should already be
1881 // a live RenderFrame, which has to be swapped. When attaching a portal, there
1882 // will not be a live RenderFrame before creating the proxy.
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501883 if (render_frame_host_impl->IsRenderFrameLive()) {
1884 inner_render_manager->SwapOuterDelegateFrame(render_frame_host_impl, proxy);
Lucas Furukawa Gadani99125822019-01-03 15:41:491885
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501886 inner_web_contents_impl->ReattachToOuterWebContentsFrame();
Lucas Furukawa Gadani99125822019-01-03 15:41:491887 }
ekaramadadd882292016-06-08 15:22:561888
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501889 if (frame_tree_.GetFocusedFrame() ==
1890 render_frame_host_impl->frame_tree_node()) {
1891 inner_web_contents_impl->SetFocusedFrame(
1892 inner_web_contents_impl->frame_tree_.root(),
1893 render_frame_host_impl->GetSiteInstance());
avallee7529b2a2017-04-26 11:37:511894 }
Lucas Furukawa Gadani6e5b4f32019-03-02 04:18:501895 outer_render_manager->set_attach_complete();
lazyboy6ec48b2a2015-06-29 15:18:141896}
1897
Lucas Furukawa Gadani99125822019-01-03 15:41:491898std::unique_ptr<WebContents> WebContentsImpl::DetachFromOuterWebContents() {
1899 DCHECK(node_.outer_web_contents());
1900 if (RenderWidgetHostViewBase* view =
1901 static_cast<RenderWidgetHostViewBase*>(GetMainFrame()->GetView())) {
1902 view->Destroy();
1903 }
1904 GetRenderManager()->DeleteOuterDelegateProxy(
1905 node_.OuterContentsFrameTreeNode()
1906 ->current_frame_host()
1907 ->GetSiteInstance());
1908 view_.reset(CreateWebContentsView(
1909 this, GetContentClient()->browser()->GetWebContentsViewDelegate(this),
1910 &render_view_host_delegate_view_));
1911 view_->CreateView(GetPreferredSize(), nullptr);
1912 std::unique_ptr<WebContents> web_contents =
1913 node_.DisconnectFromOuterWebContents();
1914 DCHECK_EQ(web_contents.get(), this);
1915 node_.SetFocusedWebContents(this);
1916 CreateRenderWidgetHostViewForRenderManager(GetRenderViewHost());
1917 return web_contents;
1918}
1919
W. James MacLean2dc75ed42019-03-06 14:31:091920void WebContentsImpl::RecursivelyRegisterFrameSinkIds() {
1921 auto* view = static_cast<RenderWidgetHostViewBase*>(
1922 GetRenderManager()->GetRenderWidgetHostView());
1923 DCHECK(view);
1924 if (!view->IsRenderWidgetHostViewChildFrame())
1925 return;
1926 static_cast<RenderWidgetHostViewChildFrame*>(view)->RegisterFrameSinkId();
1927
1928 for (auto* inner_web_contents : node_.GetInnerWebContents()) {
1929 static_cast<WebContentsImpl*>(inner_web_contents)
1930 ->RecursivelyRegisterFrameSinkIds();
1931 }
1932}
1933
Lucas Furukawa Gadaniaed1fed2017-10-13 17:34:141934void WebContentsImpl::ReattachToOuterWebContentsFrame() {
1935 DCHECK(node_.outer_web_contents());
1936 auto* render_manager = GetRenderManager();
1937 auto* parent_frame =
1938 node_.OuterContentsFrameTreeNode()->current_frame_host()->GetParent();
1939 render_manager->SetRWHViewForInnerContents(
1940 render_manager->GetRenderWidgetHostView());
1941
W. James MacLean2dc75ed42019-03-06 14:31:091942 RecursivelyRegisterFrameSinkIds();
Lucas Furukawa Gadaniaed1fed2017-10-13 17:34:141943
1944 // Set up the the guest's AX tree to point back at the embedder's AX tree.
1945 GetMainFrame()->set_browser_plugin_embedder_ax_tree_id(
1946 parent_frame->GetAXTreeID());
1947 GetMainFrame()->UpdateAXTreeData();
1948}
1949
dalecurtis6c58ed02016-10-28 23:02:371950void WebContentsImpl::DidChangeVisibleSecurityState() {
Emily Starkc663b0242019-04-26 19:34:451951 if (delegate_)
dalecurtis6c58ed02016-10-28 23:02:371952 delegate_->VisibleSecurityStateChanged(this);
Emily Starkc663b0242019-04-26 19:34:451953 for (auto& observer : observers_)
1954 observer.DidChangeVisibleSecurityState();
dalecurtis6c58ed02016-10-28 23:02:371955}
1956
Ahmed Fakhryd70bf37b2018-04-04 17:07:241957void WebContentsImpl::NotifyPreferencesChanged() {
1958 std::set<RenderViewHost*> render_view_host_set;
1959 for (FrameTreeNode* node : frame_tree_.Nodes()) {
Giovanni Ortuño Urquidi17a5d7c2018-04-30 06:48:531960 render_view_host_set.insert(
1961 node->current_frame_host()->GetRenderViewHost());
Ahmed Fakhryd70bf37b2018-04-04 17:07:241962 }
Giovanni Ortuño Urquidi17a5d7c2018-04-30 06:48:531963
Ahmed Fakhryd70bf37b2018-04-04 17:07:241964 for (RenderViewHost* render_view_host : render_view_host_set)
1965 render_view_host->OnWebkitPreferencesChanged();
1966}
1967
[email protected]b172aee2012-04-10 17:05:261968void WebContentsImpl::Stop() {
dcheng57e39e22016-01-21 00:25:381969 for (FrameTreeNode* node : frame_tree_.Nodes())
1970 node->StopLoading();
ericwilligersde386342016-10-19 02:35:091971 for (auto& observer : observers_)
1972 observer.NavigationStopped();
[email protected]0bfbf882011-12-22 18:19:271973}
1974
Francois Doray47f759d2018-06-11 18:13:511975void WebContentsImpl::SetPageFrozen(bool frozen) {
1976 // A visible page is never frozen.
1977 DCHECK_NE(Visibility::VISIBLE, GetVisibility());
1978
1979 SendPageMessage(new PageMsg_SetPageFrozen(MSG_ROUTING_NONE, frozen));
Fadi Meawada6573e02018-03-10 00:52:111980}
1981
erikchen6c7df7f7a2018-05-03 18:13:591982std::unique_ptr<WebContents> WebContentsImpl::Clone() {
[email protected]14392a52012-05-02 20:28:441983 // We use our current SiteInstance since the cloned entry will use it anyway.
alexmose201c7cd2015-06-10 17:14:211984 // We pass our own opener so that the cloned page can access it if it was set
[email protected]ed245db2012-12-18 08:00:451985 // before.
[email protected]54944cde2012-12-09 09:24:591986 CreateParams create_params(GetBrowserContext(), GetSiteInstance());
[email protected]fc2b46b2014-05-03 16:33:451987 create_params.initial_size = GetContainerBounds().size();
Ian Clelland5cbaaf82017-11-27 22:00:031988 FrameTreeNode* opener = frame_tree_.root()->opener();
1989 RenderFrameHostImpl* opener_rfh = nullptr;
1990 if (opener)
1991 opener_rfh = opener->current_frame_host();
erikchen6c7df7f7a2018-05-03 18:13:591992 std::unique_ptr<WebContentsImpl> tc =
erikchen50735fd2018-05-05 15:08:331993 CreateWithOpener(create_params, opener_rfh);
Lucas Furukawa Gadani5553a152019-01-08 18:55:571994 tc->GetController().CopyStateFrom(&controller_, true);
ericwilligersde386342016-10-19 02:35:091995 for (auto& observer : observers_)
erikchen6c7df7f7a2018-05-03 18:13:591996 observer.DidCloneToNewWebContents(this, tc.get());
[email protected]0bfbf882011-12-22 18:19:271997 return tc;
1998}
1999
[email protected]14392a52012-05-02 20:28:442000void WebContentsImpl::Observe(int type,
[email protected]8ff00d72012-10-23 19:12:212001 const NotificationSource& source,
2002 const NotificationDetails& details) {
[email protected]14392a52012-05-02 20:28:442003 switch (type) {
[email protected]8ff00d72012-10-23 19:12:212004 case NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: {
2005 RenderWidgetHost* host = Source<RenderWidgetHost>(source).ptr();
[email protected]0b431992014-06-24 00:08:032006 RenderWidgetHostView* view = host->GetView();
2007 if (view == GetFullscreenRenderWidgetHostView()) {
2008 // We cannot just call view_->RestoreFocus() here. On some platforms,
2009 // attempting to focus the currently-invisible WebContentsView will be
2010 // flat-out ignored. Therefore, this boolean is used to track whether
2011 // we will request focus after the fullscreen widget has been
2012 // destroyed.
2013 fullscreen_widget_had_focus_at_shutdown_ = (view && view->HasFocus());
2014 } else {
alexmosc2a8cec2016-05-23 22:19:532015 for (auto i = pending_widget_views_.begin();
[email protected]0b431992014-06-24 00:08:032016 i != pending_widget_views_.end(); ++i) {
2017 if (host->GetView() == i->second) {
2018 pending_widget_views_.erase(i);
2019 break;
2020 }
[email protected]bafe6cd2012-05-23 23:09:502021 }
2022 }
2023 break;
2024 }
[email protected]14392a52012-05-02 20:28:442025 default:
2026 NOTREACHED();
2027 }
2028}
2029
[email protected]ec6c05f2013-10-23 18:41:572030WebContents* WebContentsImpl::GetWebContents() {
2031 return this;
2032}
2033
[email protected]54944cde2012-12-09 09:24:592034void WebContentsImpl::Init(const WebContents::CreateParams& params) {
[email protected]fa944cb82013-11-15 17:51:212035 // This is set before initializing the render manager since
[email protected]b0936d22013-11-28 06:47:362036 // RenderFrameHostManager::Init calls back into us via its delegate to ask if
[email protected]fa944cb82013-11-15 17:51:212037 // it should be hidden.
Francois Doraye6161152018-03-27 22:05:372038 visibility_ =
2039 params.initially_hidden ? Visibility::HIDDEN : Visibility::VISIBLE;
[email protected]d6fa88f2013-10-18 16:00:432040
Sebastien Marchand28cf23182018-06-20 02:39:352041 if (!params.last_active_time.is_null())
2042 last_active_time_ = params.last_active_time;
2043
dcheng3ce04b62015-10-26 23:30:552044 // The routing ids must either all be set or all be unset.
avic2c29d782014-12-12 00:23:542045 DCHECK((params.routing_id == MSG_ROUTING_NONE &&
dcheng3ce04b62015-10-26 23:30:552046 params.main_frame_routing_id == MSG_ROUTING_NONE &&
2047 params.main_frame_widget_routing_id == MSG_ROUTING_NONE) ||
avic2c29d782014-12-12 00:23:542048 (params.routing_id != MSG_ROUTING_NONE &&
dcheng3ce04b62015-10-26 23:30:552049 params.main_frame_routing_id != MSG_ROUTING_NONE &&
2050 params.main_frame_widget_routing_id != MSG_ROUTING_NONE));
2051
2052 scoped_refptr<SiteInstance> site_instance = params.site_instance;
2053 if (!site_instance)
2054 site_instance = SiteInstance::Create(params.browser_context);
Lukasz Anforowicz3caa8372018-06-05 17:22:072055 if (params.desired_renderer_state == CreateParams::kNoRendererProcess) {
2056 static_cast<SiteInstanceImpl*>(site_instance.get())
2057 ->PreventAssociationWithSpareProcess();
2058 }
dcheng3ce04b62015-10-26 23:30:552059
2060 // A main RenderFrameHost always has a RenderWidgetHost, since it is always a
2061 // local root by definition.
2062 // TODO(avi): Once RenderViewHostImpl has-a RenderWidgetHostImpl, it will no
2063 // longer be necessary to eagerly grab a routing ID for the view.
2064 // https://crbug.com/545684
2065 int32_t view_routing_id = params.routing_id;
2066 int32_t main_frame_widget_routing_id = params.main_frame_widget_routing_id;
2067 if (main_frame_widget_routing_id == MSG_ROUTING_NONE) {
Albert J. Wongcb004632018-07-10 22:58:252068 view_routing_id = site_instance->GetProcess()->GetNextRoutingID();
2069 main_frame_widget_routing_id =
dcheng3ce04b62015-10-26 23:30:552070 site_instance->GetProcess()->GetNextRoutingID();
2071 }
2072
Albert J. Wongcb004632018-07-10 22:58:252073 DCHECK_NE(view_routing_id, main_frame_widget_routing_id);
2074
Dave Tapuska485aca92017-08-08 00:47:582075 GetRenderManager()->Init(
2076 site_instance.get(), view_routing_id, params.main_frame_routing_id,
2077 main_frame_widget_routing_id, params.renderer_initiated_creation);
lukasza464d8692016-02-22 19:26:322078
lukasza5140a412016-09-15 21:12:302079 // blink::FrameTree::setName always keeps |unique_name| empty in case of a
2080 // main frame - let's do the same thing here.
2081 std::string unique_name;
lukasza464d8692016-02-22 19:26:322082 frame_tree_.root()->SetFrameName(params.main_frame_name, unique_name);
[email protected]d1198fd2012-08-13 22:50:192083
[email protected]fc2b46b2014-05-03 16:33:452084 WebContentsViewDelegate* delegate =
2085 GetContentClient()->browser()->GetWebContentsViewDelegate(this);
2086
sky52a39e342016-12-17 17:23:222087 if (GuestMode::IsCrossProcessFrameGuest(this)) {
2088 view_.reset(new WebContentsViewChildFrame(
2089 this, delegate, &render_view_host_delegate_view_));
2090 } else {
2091 view_.reset(CreateWebContentsView(this, delegate,
2092 &render_view_host_delegate_view_));
Scott Violetc884c7fd2017-11-03 23:51:012093 if (browser_plugin_guest_) {
2094 view_ = std::make_unique<WebContentsViewGuest>(
2095 this, browser_plugin_guest_.get(), std::move(view_),
2096 &render_view_host_delegate_view_);
2097 }
[email protected]d1198fd2012-08-13 22:50:192098 }
[email protected]fc2b46b2014-05-03 16:33:452099 CHECK(render_view_host_delegate_view_);
[email protected]d1198fd2012-08-13 22:50:192100 CHECK(view_.get());
2101
[email protected]ed245db2012-12-18 08:00:452102 gfx::Size initial_size = params.initial_size;
[email protected]54944cde2012-12-09 09:24:592103 view_->CreateView(initial_size, params.context);
[email protected]d1198fd2012-08-13 22:50:192104
brettw4b461082016-11-19 18:55:162105#if BUILDFLAG(ENABLE_PLUGINS)
tommyclieb25b2a2014-11-03 19:45:092106 plugin_content_origin_whitelist_.reset(
2107 new PluginContentOriginWhitelist(this));
2108#endif
2109
[email protected]d1198fd2012-08-13 22:50:192110 registrar_.Add(this,
[email protected]8ff00d72012-10-23 19:12:212111 NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
2112 NotificationService::AllBrowserContextsAndSources());
[email protected]f28ef9a32014-05-12 16:36:102113
leon.hane4db177a2017-02-07 14:19:162114 screen_orientation_provider_.reset(new ScreenOrientationProvider(this));
[email protected]01f83f92014-06-17 14:41:542115
mlamouriefdca9d2014-09-16 16:55:402116 manifest_manager_host_.reset(new ManifestManagerHost(this));
2117
mfomitchev2b8b066a2016-01-28 19:23:152118#if defined(OS_ANDROID)
Gyuyoung Kim1f672aa2019-04-25 02:10:252119 date_time_chooser_.reset(new DateTimeChooserAndroid(this));
[email protected]583418cc2013-01-17 14:01:102120#endif
fsamuel7310a4262014-12-05 05:06:442121
2122 // BrowserPluginGuest::Init needs to be called after this WebContents has
2123 // a RenderWidgetHostViewGuest. That is, |view_->CreateView| above.
2124 if (browser_plugin_guest_)
2125 browser_plugin_guest_->Init();
nickf9acfbe2014-12-23 19:12:372126
2127 for (size_t i = 0; i < g_created_callbacks.Get().size(); i++)
2128 g_created_callbacks.Get().at(i).Run(this);
naskob21fe4872015-02-24 14:15:562129
2130 // If the WebContents creation was renderer-initiated, it means that the
2131 // corresponding RenderView and main RenderFrame have already been created.
2132 // Ensure observers are notified about this.
2133 if (params.renderer_initiated_creation) {
avi3627ecac2015-10-16 17:40:432134 GetRenderViewHost()->GetWidget()->set_renderer_initialized(true);
Alex Moshchuk27caae82017-09-11 23:11:182135 GetRenderViewHost()->DispatchRenderViewCreated();
naskob21fe4872015-02-24 14:15:562136 GetRenderManager()->current_frame_host()->SetRenderFrameCreated(true);
2137 }
naskof5940b9f2015-03-02 23:04:052138
lof84501da082016-05-23 21:22:542139 // Create the renderer process in advance if requested.
Lukasz Anforowicz3caa8372018-06-05 17:22:072140 if (params.desired_renderer_state ==
2141 CreateParams::kInitializeAndWarmupRendererProcess) {
lof84501da082016-05-23 21:22:542142 if (!GetRenderManager()->current_frame_host()->IsRenderFrameLive()) {
2143 GetRenderManager()->InitRenderView(GetRenderViewHost(), nullptr);
2144 }
2145 }
2146
naskof5940b9f2015-03-02 23:04:052147 // Ensure that observers are notified of the creation of this WebContents's
2148 // main RenderFrameHost. It must be done here for main frames, since the
2149 // NotifySwappedFromRenderManager expects view_ to already be created and that
2150 // happens after RenderFrameHostManager::Init.
2151 NotifySwappedFromRenderManager(
2152 nullptr, GetRenderManager()->current_frame_host(), true);
[email protected]d1198fd2012-08-13 22:50:192153}
2154
[email protected]7fff43e2013-05-21 20:21:102155void WebContentsImpl::OnWebContentsDestroyed(WebContentsImpl* web_contents) {
2156 RemoveDestructionObserver(web_contents);
2157
[email protected]ceee8cd2013-03-08 04:59:512158 // Clear a pending contents that has been closed before being shown.
alexmosc2a8cec2016-05-23 22:19:532159 for (auto iter = pending_contents_.begin(); iter != pending_contents_.end();
[email protected]ceee8cd2013-03-08 04:59:512160 ++iter) {
erikchenbee5c9622018-04-27 19:30:252161 if (iter->second.get() != web_contents)
[email protected]ceee8cd2013-03-08 04:59:512162 continue;
erikchenbee5c9622018-04-27 19:30:252163
2164 // Someone else has deleted the WebContents. That should never happen!
2165 // TODO(erikchen): Fix semantics here. https://crbug.com/832879.
2166 iter->second.release();
[email protected]ceee8cd2013-03-08 04:59:512167 pending_contents_.erase(iter);
[email protected]ceee8cd2013-03-08 04:59:512168 return;
2169 }
2170 NOTREACHED();
[email protected]14392a52012-05-02 20:28:442171}
2172
[email protected]7fff43e2013-05-21 20:21:102173void WebContentsImpl::AddDestructionObserver(WebContentsImpl* web_contents) {
Jan Wilken Dörrie73c901e2019-06-12 09:02:322174 if (!base::Contains(destruction_observers_, web_contents)) {
[email protected]7fff43e2013-05-21 20:21:102175 destruction_observers_[web_contents] =
Jeremy Roman04f27c372017-10-27 15:20:552176 std::make_unique<DestructionObserver>(this, web_contents);
[email protected]7fff43e2013-05-21 20:21:102177 }
2178}
2179
2180void WebContentsImpl::RemoveDestructionObserver(WebContentsImpl* web_contents) {
avia8cf81982016-08-12 20:28:462181 destruction_observers_.erase(web_contents);
[email protected]7fff43e2013-05-21 20:21:102182}
2183
[email protected]b172aee2012-04-10 17:05:262184void WebContentsImpl::AddObserver(WebContentsObserver* observer) {
[email protected]be1f56ab2011-12-22 06:55:312185 observers_.AddObserver(observer);
2186}
2187
[email protected]b172aee2012-04-10 17:05:262188void WebContentsImpl::RemoveObserver(WebContentsObserver* observer) {
[email protected]be1f56ab2011-12-22 06:55:312189 observers_.RemoveObserver(observer);
2190}
2191
[email protected]948481d2014-06-11 18:32:222192std::set<RenderWidgetHostView*>
2193WebContentsImpl::GetRenderWidgetHostViewsInTree() {
2194 std::set<RenderWidgetHostView*> set;
2195 if (ShowingInterstitialPage()) {
lfgf949e0e2017-05-10 22:18:112196 if (RenderWidgetHostView* rwhv = GetRenderWidgetHostView())
2197 set.insert(rwhv);
[email protected]948481d2014-06-11 18:32:222198 } else {
dchengafb53e22016-02-04 08:11:082199 for (RenderFrameHost* rfh : GetAllFrames()) {
lfgf949e0e2017-05-10 22:18:112200 if (RenderWidgetHostView* rwhv = static_cast<RenderFrameHostImpl*>(rfh)
2201 ->frame_tree_node()
2202 ->render_manager()
2203 ->GetRenderWidgetHostView()) {
2204 set.insert(rwhv);
2205 }
dchengafb53e22016-02-04 08:11:082206 }
[email protected]948481d2014-06-11 18:32:222207 }
[email protected]de3c5d82014-05-28 22:12:592208 return set;
2209}
2210
[email protected]b172aee2012-04-10 17:05:262211void WebContentsImpl::Activate() {
[email protected]d5f942ba2008-09-26 19:30:342212 if (delegate_)
2213 delegate_->ActivateContents(this);
2214}
2215
avi3e4b8512015-11-11 01:55:492216void WebContentsImpl::LostCapture(RenderWidgetHostImpl* render_widget_host) {
2217 if (!RenderViewHostImpl::From(render_widget_host))
2218 return;
2219
[email protected]63954792011-07-11 04:17:482220 if (delegate_)
2221 delegate_->LostCapture();
2222}
2223
Steven Holte38041342018-06-22 22:00:572224ukm::SourceId WebContentsImpl::GetUkmSourceIdForLastCommittedSource() const {
2225 return last_committed_source_id_;
2226}
2227
Ahmed Fakhryfaa32d22018-10-05 15:56:162228void WebContentsImpl::SetTopControlsShownRatio(
2229 RenderWidgetHostImpl* render_widget_host,
2230 float ratio) {
2231 if (!delegate_)
2232 return;
2233
2234 RenderFrameHostImpl* rfh = GetMainFrame();
2235 if (!rfh || render_widget_host != rfh->GetRenderWidgetHost())
2236 return;
2237
2238 delegate_->SetTopControlsShownRatio(this, ratio);
Ahmed Fakhry58e6ef542018-09-04 18:05:382239}
2240
Ahmed Fakhry58e6ef542018-09-04 18:05:382241void WebContentsImpl::SetTopControlsGestureScrollInProgress(bool in_progress) {
2242 if (delegate_)
2243 delegate_->SetTopControlsGestureScrollInProgress(in_progress);
2244}
2245
lazyboy63f5b312015-11-23 20:19:522246void WebContentsImpl::RenderWidgetCreated(
2247 RenderWidgetHostImpl* render_widget_host) {
2248 created_widgets_.insert(render_widget_host);
2249}
2250
[email protected]b24b68a2012-09-24 21:57:262251void WebContentsImpl::RenderWidgetDeleted(
2252 RenderWidgetHostImpl* render_widget_host) {
lazyboy63f5b312015-11-23 20:19:522253 // Note that |is_being_destroyed_| can be true at this point as
2254 // ~WebContentsImpl() calls RFHM::ClearRFHsPendingShutdown(), which might lead
2255 // us here.
2256 created_widgets_.erase(render_widget_host);
[email protected]b24b68a2012-09-24 21:57:262257
lazyboy63f5b312015-11-23 20:19:522258 if (is_being_destroyed_)
2259 return;
[email protected]44470a22013-01-24 01:21:542260
2261 if (render_widget_host &&
alexmosc9e76ec2016-05-16 22:59:372262 render_widget_host->GetRoutingID() == fullscreen_widget_routing_id_ &&
2263 render_widget_host->GetProcess()->GetID() ==
2264 fullscreen_widget_process_id_) {
[email protected]4aebbca2013-09-17 22:26:492265 if (delegate_ && delegate_->EmbedsFullscreenWidget())
mlamouri7a78d6fd2015-01-17 13:23:532266 delegate_->ExitFullscreenModeForTab(this);
ericwilligersde386342016-10-19 02:35:092267 for (auto& observer : observers_)
2268 observer.DidDestroyFullscreenWidget();
alexmosc9e76ec2016-05-16 22:59:372269 fullscreen_widget_process_id_ = ChildProcessHost::kInvalidUniqueID;
[email protected]44470a22013-01-24 01:21:542270 fullscreen_widget_routing_id_ = MSG_ROUTING_NONE;
[email protected]0b431992014-06-24 00:08:032271 if (fullscreen_widget_had_focus_at_shutdown_)
2272 view_->RestoreFocus();
[email protected]44470a22013-01-24 01:21:542273 }
lfgbee1e0a2016-06-08 21:24:212274
lfg7d4caad2017-03-22 09:01:452275 if (render_widget_host == mouse_lock_widget_)
lfgff8dfc8d2016-10-21 17:42:322276 LostMouseLock(mouse_lock_widget_);
Joe Downing192998b22018-03-22 15:51:362277
Joe Downingc1a57efe2018-05-09 18:23:542278 CancelKeyboardLock(render_widget_host);
[email protected]b24b68a2012-09-24 21:57:262279}
2280
miu9e14e492014-10-25 02:39:042281void WebContentsImpl::RenderWidgetGotFocus(
2282 RenderWidgetHostImpl* render_widget_host) {
calamity7fe55ce2015-04-10 03:59:372283 // Notify the observers if an embedded fullscreen widget was focused.
2284 if (delegate_ && render_widget_host && delegate_->EmbedsFullscreenWidget() &&
2285 render_widget_host->GetView() == GetFullscreenRenderWidgetHostView()) {
Michael Thiessen896405db2017-07-20 17:52:322286 NotifyWebContentsFocused(render_widget_host);
calamity7fe55ce2015-04-10 03:59:372287 }
miu9e14e492014-10-25 02:39:042288}
2289
zijiehe3bee08e22017-05-17 04:14:462290void WebContentsImpl::RenderWidgetLostFocus(
2291 RenderWidgetHostImpl* render_widget_host) {
Michael Thiessen896405db2017-07-20 17:52:322292 // Notify the observers if an embedded fullscreen widget lost focus.
2293 if (delegate_ && render_widget_host && delegate_->EmbedsFullscreenWidget() &&
2294 render_widget_host->GetView() == GetFullscreenRenderWidgetHostView()) {
2295 NotifyWebContentsLostFocus(render_widget_host);
2296 }
zijiehe3bee08e22017-05-17 04:14:462297}
2298
estaded0a0c992015-01-21 14:12:062299void WebContentsImpl::RenderWidgetWasResized(
rouslan2f5993f2015-01-29 00:18:312300 RenderWidgetHostImpl* render_widget_host,
Christopher Cameron07f666b2018-02-13 23:41:192301 const ScreenInfo& screen_info,
rouslan2f5993f2015-01-29 00:18:312302 bool width_changed) {
creisc014b402015-04-23 16:41:452303 RenderFrameHostImpl* rfh = GetMainFrame();
estadece344ec2015-01-23 00:12:292304 if (!rfh || render_widget_host != rfh->GetRenderWidgetHost())
estaded0a0c992015-01-21 14:12:062305 return;
estaded0a0c992015-01-21 14:12:062306
lfg8d649cc2017-04-28 18:04:302307 SendPageMessage(new PageMsg_UpdateScreenInfo(MSG_ROUTING_NONE, screen_info));
2308
ericwilligersde386342016-10-19 02:35:092309 for (auto& observer : observers_)
2310 observer.MainFrameWasResized(width_changed);
estaded0a0c992015-01-21 14:12:062311}
2312
skyf65d9bb2017-03-24 02:26:392313KeyboardEventProcessingResult WebContentsImpl::PreHandleKeyboardEvent(
2314 const NativeWebKeyboardEvent& event) {
2315 return delegate_ ? delegate_->PreHandleKeyboardEvent(this, event)
2316 : KeyboardEventProcessingResult::NOT_HANDLED;
[email protected]63954792011-07-11 04:17:482317}
2318
Scott Violetd5caa872018-10-16 22:00:512319bool WebContentsImpl::HandleKeyboardEvent(const NativeWebKeyboardEvent& event) {
[email protected]0b094002014-08-20 18:28:102320 if (browser_plugin_embedder_ &&
2321 browser_plugin_embedder_->HandleKeyboardEvent(event)) {
Scott Violetd5caa872018-10-16 22:00:512322 return true;
[email protected]0b094002014-08-20 18:28:102323 }
Scott Violetd5caa872018-10-16 22:00:512324 return delegate_ && delegate_->HandleKeyboardEvent(this, event);
[email protected]63954792011-07-11 04:17:482325}
2326
[email protected]d92026ef2014-03-03 21:04:132327bool WebContentsImpl::HandleWheelEvent(
[email protected]180ef242013-11-07 06:50:462328 const blink::WebMouseWheelEvent& event) {
[email protected]bccc4472013-04-18 16:37:192329#if !defined(OS_MACOSX)
lanweia93644f2015-01-21 22:00:332330 // On platforms other than Mac, control+mousewheel may change zoom. On Mac,
2331 // this isn't done for two reasons:
[email protected]bccc4472013-04-18 16:37:192332 // -the OS already has a gesture to do this through pinch-zoom
2333 // -if a user starts an inertial scroll, let's go, and presses control
2334 // (i.e. control+tab) then the OS's buffered scroll events will come in
2335 // with control key set which isn't what the user wants
Blink Reformat1c4d759e2017-04-09 16:34:542336 if (delegate_ && event.wheel_ticks_y &&
Ehsan Karamad0f83cb112018-09-06 22:07:362337 event.event_action == blink::WebMouseWheelEvent::EventAction::kPageZoom) {
w.shackleton49bcd392016-01-06 17:38:222338 // Count only integer cumulative scrolls as zoom events; this handles
2339 // smooth scroll and regular scroll device behavior.
Blink Reformat1c4d759e2017-04-09 16:34:542340 zoom_scroll_remainder_ += event.wheel_ticks_y;
w.shackleton49bcd392016-01-06 17:38:222341 int whole_zoom_scroll_remainder_ = std::lround(zoom_scroll_remainder_);
2342 zoom_scroll_remainder_ -= whole_zoom_scroll_remainder_;
2343 if (whole_zoom_scroll_remainder_ != 0) {
2344 delegate_->ContentsZoomChange(whole_zoom_scroll_remainder_ > 0);
2345 }
[email protected]fb3f066e2013-02-12 19:12:522346 return true;
2347 }
[email protected]bccc4472013-04-18 16:37:192348#endif
[email protected]fb3f066e2013-02-12 19:12:522349 return false;
2350}
2351
[email protected]04bce562014-01-30 05:34:542352bool WebContentsImpl::PreHandleGestureEvent(
2353 const blink::WebGestureEvent& event) {
[email protected]28042d32014-02-03 14:10:032354 return delegate_ && delegate_->PreHandleGestureEvent(this, event);
[email protected]04bce562014-01-30 05:34:542355}
2356
kenrb2a565f82015-09-02 20:24:592357RenderWidgetHostInputEventRouter* WebContentsImpl::GetInputEventRouter() {
wjmacleane31234f2015-12-14 17:20:452358 if (!is_being_destroyed_ && GetOuterWebContents())
2359 return GetOuterWebContents()->GetInputEventRouter();
2360
2361 if (!rwh_input_event_router_.get() && !is_being_destroyed_)
kenrb2a565f82015-09-02 20:24:592362 rwh_input_event_router_.reset(new RenderWidgetHostInputEventRouter);
2363 return rwh_input_event_router_.get();
2364}
2365
alexmos3fcd0ca2015-10-23 18:18:332366void WebContentsImpl::ReplicatePageFocus(bool is_focused) {
2367 // Focus loss may occur while this WebContents is being destroyed. Don't
2368 // send the message in this case, as the main frame's RenderFrameHost and
2369 // other state has already been cleared.
2370 if (is_being_destroyed_)
2371 return;
2372
2373 frame_tree_.ReplicatePageFocus(is_focused);
2374}
2375
alexmosc4cbacb2015-11-21 01:29:222376RenderWidgetHostImpl* WebContentsImpl::GetFocusedRenderWidgetHost(
2377 RenderWidgetHostImpl* receiving_widget) {
alexmosc4cbacb2015-11-21 01:29:222378 // Events for widgets other than the main frame (e.g., popup menus) should be
2379 // forwarded directly to the widget they arrived on.
2380 if (receiving_widget != GetMainFrame()->GetRenderWidgetHost())
2381 return receiving_widget;
alexmosc4d183e2015-11-06 00:46:522382
lfg1453e412017-04-11 00:48:502383 WebContentsImpl* focused_contents = GetFocusedWebContents();
2384
2385 // If the focused WebContents is showing an interstitial, return the
2386 // interstitial's widget.
2387 if (focused_contents->ShowingInterstitialPage()) {
2388 return static_cast<RenderFrameHostImpl*>(
creisadca9862017-06-16 19:12:112389 focused_contents->interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:502390 ->GetRenderWidgetHost();
2391 }
2392
paulmeyerfeafc2d2017-04-25 21:46:402393 // If the focused WebContents is a guest WebContents, then get the focused
2394 // frame in the embedder WebContents instead.
2395 FrameTreeNode* focused_frame = nullptr;
2396 if (focused_contents->browser_plugin_guest_ &&
2397 !GuestMode::IsCrossProcessFrameGuest(focused_contents)) {
2398 focused_frame = frame_tree_.GetFocusedFrame();
2399 } else {
2400 focused_frame = GetFocusedWebContents()->frame_tree_.GetFocusedFrame();
2401 }
lfg1453e412017-04-11 00:48:502402
alexmosc4d183e2015-11-06 00:46:522403 if (!focused_frame)
alexmosc4cbacb2015-11-21 01:29:222404 return receiving_widget;
alexmosc4d183e2015-11-06 00:46:522405
alexmos732ca3a2015-12-08 02:01:022406 // The view may be null if a subframe's renderer process has crashed while
2407 // the subframe has focus. Drop the event in that case. Do not give
2408 // it to the main frame, so that the user doesn't unexpectedly type into the
2409 // wrong frame if a focused subframe renderer crashes while they type.
2410 RenderWidgetHostView* view = focused_frame->current_frame_host()->GetView();
2411 if (!view)
2412 return nullptr;
2413
2414 return RenderWidgetHostImpl::From(view->GetRenderWidgetHost());
alexmosc4d183e2015-11-06 00:46:522415}
2416
avallee9993fca2016-11-17 06:16:502417RenderWidgetHostImpl* WebContentsImpl::GetRenderWidgetHostWithPageFocus() {
lfg1453e412017-04-11 00:48:502418 WebContentsImpl* focused_web_contents = GetFocusedWebContents();
2419
2420 if (focused_web_contents->ShowingInterstitialPage()) {
2421 return static_cast<RenderFrameHostImpl*>(
creisadca9862017-06-16 19:12:112422 focused_web_contents->interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:502423 ->GetRenderWidgetHost();
2424 }
Alex Valléedc80ae2ed2017-09-06 21:55:442425 if (!GuestMode::IsCrossProcessFrameGuest(focused_web_contents) &&
2426 focused_web_contents->browser_plugin_guest_) {
2427 // If this is a guest, we need to be controlled by our embedder.
2428 return focused_web_contents->GetOuterWebContents()
2429 ->GetMainFrame()
2430 ->GetRenderWidgetHost();
2431 }
lfg1453e412017-04-11 00:48:502432
2433 return focused_web_contents->GetMainFrame()->GetRenderWidgetHost();
avallee9993fca2016-11-17 06:16:502434}
2435
Dave Tapuska3ed44192018-05-01 18:53:302436void WebContentsImpl::EnterFullscreenMode(
2437 const GURL& origin,
2438 const blink::WebFullscreenOptions& options) {
mlamouri7a78d6fd2015-01-17 13:23:532439 // This method is being called to enter renderer-initiated fullscreen mode.
2440 // Make sure any existing fullscreen widget is shut down first.
[email protected]4aebbca2013-09-17 22:26:492441 RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
avi85a4cef2015-12-18 20:13:372442 if (widget_view) {
2443 RenderWidgetHostImpl::From(widget_view->GetRenderWidgetHost())
2444 ->ShutdownAndDestroyWidget(true);
2445 }
[email protected]4aebbca2013-09-17 22:26:492446
Joe Downing13dd76b2018-04-09 18:32:152447 if (delegate_) {
Dave Tapuska3ed44192018-05-01 18:53:302448 delegate_->EnterFullscreenModeForTab(this, origin, options);
mlamouri7a78d6fd2015-01-17 13:23:532449
Joe Downing13dd76b2018-04-09 18:32:152450 if (keyboard_lock_widget_)
2451 delegate_->RequestKeyboardLock(this, esc_key_locked_);
2452 }
2453
ericwilligersde386342016-10-19 02:35:092454 for (auto& observer : observers_)
2455 observer.DidToggleFullscreenModeForTab(IsFullscreenForCurrentTab(), false);
mlamouri7a78d6fd2015-01-17 13:23:532456}
2457
bokanece34a82016-01-28 19:49:462458void WebContentsImpl::ExitFullscreenMode(bool will_cause_resize) {
mlamouri7a78d6fd2015-01-17 13:23:532459 // This method is being called to leave renderer-initiated fullscreen mode.
2460 // Make sure any existing fullscreen widget is shut down first.
2461 RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
avi85a4cef2015-12-18 20:13:372462 if (widget_view) {
2463 RenderWidgetHostImpl::From(widget_view->GetRenderWidgetHost())
2464 ->ShutdownAndDestroyWidget(true);
2465 }
mlamouri7a78d6fd2015-01-17 13:23:532466
Joe Downing13dd76b2018-04-09 18:32:152467 if (delegate_) {
mlamouri7a78d6fd2015-01-17 13:23:532468 delegate_->ExitFullscreenModeForTab(this);
[email protected]657c8e02014-03-19 19:18:372469
Joe Downing13dd76b2018-04-09 18:32:152470 if (keyboard_lock_widget_)
2471 delegate_->CancelKeyboardLockRequest(this);
2472 }
2473
bokanece34a82016-01-28 19:49:462474 // The fullscreen state is communicated to the renderer through a resize
2475 // message. If the change in fullscreen state doesn't cause a view resize
2476 // then we must ensure web contents exit the fullscreen state by explicitly
2477 // sending a resize message. This is required for the situation of the browser
2478 // moving the view into a "browser fullscreen" state and then the contents
2479 // entering "tab fullscreen". Exiting the contents "tab fullscreen" then won't
2480 // have the side effect of the view resizing, hence the explicit call here is
2481 // required.
2482 if (!will_cause_resize) {
2483 if (RenderWidgetHostView* rwhv = GetRenderWidgetHostView()) {
2484 if (RenderWidgetHost* render_widget_host = rwhv->GetRenderWidgetHost())
Fady Samuel0b911822018-04-25 13:22:162485 render_widget_host->SynchronizeVisualProperties();
bokanece34a82016-01-28 19:49:462486 }
scheib3dcb6c932015-02-23 10:55:582487 }
2488
Arthur Sonzogni929d29f2018-09-17 14:19:442489 current_fullscreen_frame_ = nullptr;
Becca Hughese9e27952018-06-25 17:08:272490
ericwilligersde386342016-10-19 02:35:092491 for (auto& observer : observers_) {
2492 observer.DidToggleFullscreenModeForTab(IsFullscreenForCurrentTab(),
2493 will_cause_resize);
2494 }
Becca Hughesd11d6502018-07-31 17:01:282495
2496 if (display_cutout_host_impl_)
2497 display_cutout_host_impl_->DidExitFullscreen();
[email protected]8a5e0ca2011-08-25 06:30:472498}
2499
Becca Hughesfd5d8f892018-06-14 18:23:362500void WebContentsImpl::FullscreenStateChanged(RenderFrameHost* rfh,
2501 bool is_fullscreen) {
Arthur Sonzogni929d29f2018-09-17 14:19:442502 RenderFrameHostImpl* frame = static_cast<RenderFrameHostImpl*>(rfh);
Becca Hughesfd5d8f892018-06-14 18:23:362503
2504 if (is_fullscreen) {
Jan Wilken Dörrie531be7ca2019-06-07 10:05:572505 if (!base::Contains(fullscreen_frames_, frame)) {
Arthur Sonzogni929d29f2018-09-17 14:19:442506 fullscreen_frames_.insert(frame);
2507 FullscreenFrameSetUpdated();
Becca Hughesfd5d8f892018-06-14 18:23:362508 }
Arthur Sonzogni929d29f2018-09-17 14:19:442509 return;
2510 }
Becca Hughesfd5d8f892018-06-14 18:23:362511
Arthur Sonzogni929d29f2018-09-17 14:19:442512 // If |frame| is no longer in fullscreen, remove it and any descendants.
2513 // See https://fullscreen.spec.whatwg.org.
Arthur Sonzogni969a794e2018-10-11 08:56:092514 size_t size_before_deletion = fullscreen_frames_.size();
2515 base::EraseIf(fullscreen_frames_, [&](RenderFrameHostImpl* current) {
2516 return (current == frame || current->IsDescendantOf(frame));
Arthur Sonzogni929d29f2018-09-17 14:19:442517 });
2518
Arthur Sonzogni969a794e2018-10-11 08:56:092519 if (size_before_deletion != fullscreen_frames_.size())
Arthur Sonzogni929d29f2018-09-17 14:19:442520 FullscreenFrameSetUpdated();
2521}
2522
2523void WebContentsImpl::FullscreenFrameSetUpdated() {
2524 if (fullscreen_frames_.empty()) {
2525 current_fullscreen_frame_ = nullptr;
2526 return;
Becca Hughesfd5d8f892018-06-14 18:23:362527 }
2528
Arthur Sonzogni929d29f2018-09-17 14:19:442529 // Find the current fullscreen frame and call the observers.
2530 // If frame A is fullscreen, then frame B goes into inner fullscreen, then B
2531 // exits fullscreen - that will result in A being fullscreen.
2532 RenderFrameHostImpl* new_fullscreen_frame = *std::max_element(
2533 fullscreen_frames_.begin(), fullscreen_frames_.end(), FrameCompareDepth);
Becca Hughesfd5d8f892018-06-14 18:23:362534
Arthur Sonzogni929d29f2018-09-17 14:19:442535 // If we have already notified observers about this frame then we should not
2536 // fire the observers again.
2537 if (new_fullscreen_frame == current_fullscreen_frame_)
2538 return;
2539 current_fullscreen_frame_ = new_fullscreen_frame;
Becca Hughesfd5d8f892018-06-14 18:23:362540
Arthur Sonzogni929d29f2018-09-17 14:19:442541 for (auto& observer : observers_)
2542 observer.DidAcquireFullscreen(new_fullscreen_frame);
Becca Hughesfd5d8f892018-06-14 18:23:362543
Arthur Sonzogni929d29f2018-09-17 14:19:442544 if (display_cutout_host_impl_)
2545 display_cutout_host_impl_->DidAcquireFullscreen(new_fullscreen_frame);
Becca Hughesfd5d8f892018-06-14 18:23:362546}
2547
Clark DuValla0e42992018-09-17 17:00:112548#if defined(OS_ANDROID)
2549void WebContentsImpl::UpdateUserGestureCarryoverInfo() {
2550 if (delegate_)
2551 delegate_->UpdateUserGestureCarryoverInfo(this);
2552}
2553#endif
2554
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:412555bool WebContentsImpl::IsFullscreenForCurrentTab() {
[email protected]199bba6e2012-04-04 16:19:382556 return delegate_ ? delegate_->IsFullscreenForTabOrPending(this) : false;
[email protected]5d5f7af2011-10-01 01:38:122557}
2558
Malay Keshav87c42c02019-01-15 08:37:472559bool WebContentsImpl::ShouldShowStaleContentOnEviction() {
2560 return GetDelegate() && GetDelegate()->ShouldShowStaleContentOnEviction(this);
2561}
2562
billorr21c005d2016-11-17 03:57:042563bool WebContentsImpl::IsFullscreen() {
2564 return IsFullscreenForCurrentTab();
2565}
2566
avibf58fa0c2015-11-11 01:45:522567blink::WebDisplayMode WebContentsImpl::GetDisplayMode(
2568 RenderWidgetHostImpl* render_widget_host) const {
2569 if (!RenderViewHostImpl::From(render_widget_host))
Blink Reformat1c4d759e2017-04-09 16:34:542570 return blink::kWebDisplayModeBrowser;
avibf58fa0c2015-11-11 01:45:522571
mikhail.pozdnyakovc0e251b2015-04-15 06:51:122572 return delegate_ ? delegate_->GetDisplayMode(this)
Blink Reformat1c4d759e2017-04-09 16:34:542573 : blink::kWebDisplayModeBrowser;
mikhail.pozdnyakovc0e251b2015-04-15 06:51:122574}
2575
avic3aa8422015-11-09 20:57:222576void WebContentsImpl::RequestToLockMouse(
2577 RenderWidgetHostImpl* render_widget_host,
2578 bool user_gesture,
lfgad8244352016-07-13 16:55:512579 bool last_unlocked_by_target,
2580 bool privileged) {
lfgf0cd46e2017-01-04 00:05:232581 for (WebContentsImpl* current = this; current;
2582 current = current->GetOuterWebContents()) {
2583 if (current->mouse_lock_widget_) {
2584 render_widget_host->GotResponseToLockMouseRequest(false);
2585 return;
2586 }
[email protected]e9621112011-10-17 05:38:372587 }
avic3aa8422015-11-09 20:57:222588
lfgad8244352016-07-13 16:55:512589 if (privileged) {
lfgf0cd46e2017-01-04 00:05:232590 DCHECK(!GetOuterWebContents());
lfgad8244352016-07-13 16:55:512591 mouse_lock_widget_ = render_widget_host;
2592 render_widget_host->GotResponseToLockMouseRequest(true);
2593 return;
2594 }
2595
lfgbee1e0a2016-06-08 21:24:212596 bool widget_in_frame_tree = false;
2597 for (FrameTreeNode* node : frame_tree_.Nodes()) {
2598 if (node->current_frame_host()->GetRenderWidgetHost() ==
2599 render_widget_host) {
2600 widget_in_frame_tree = true;
2601 break;
2602 }
2603 }
2604
2605 if (widget_in_frame_tree && delegate_) {
lfgf0cd46e2017-01-04 00:05:232606 for (WebContentsImpl* current = this; current;
2607 current = current->GetOuterWebContents()) {
2608 current->mouse_lock_widget_ = render_widget_host;
2609 }
2610
avic3aa8422015-11-09 20:57:222611 delegate_->RequestToLockMouse(this, user_gesture, last_unlocked_by_target);
lfgbee1e0a2016-06-08 21:24:212612 } else {
2613 render_widget_host->GotResponseToLockMouseRequest(false);
2614 }
[email protected]e9621112011-10-17 05:38:372615}
2616
avi3e4b8512015-11-11 01:55:492617void WebContentsImpl::LostMouseLock(RenderWidgetHostImpl* render_widget_host) {
lfgbee1e0a2016-06-08 21:24:212618 CHECK(mouse_lock_widget_);
lfgf0cd46e2017-01-04 00:05:232619
2620 if (mouse_lock_widget_->delegate()->GetAsWebContents() != this)
2621 return mouse_lock_widget_->delegate()->LostMouseLock(render_widget_host);
2622
lfgbee1e0a2016-06-08 21:24:212623 mouse_lock_widget_->SendMouseLockLost();
lfgf0cd46e2017-01-04 00:05:232624 for (WebContentsImpl* current = this; current;
2625 current = current->GetOuterWebContents()) {
2626 current->mouse_lock_widget_ = nullptr;
2627 }
avi3e4b8512015-11-11 01:55:492628
[email protected]e9621112011-10-17 05:38:372629 if (delegate_)
2630 delegate_->LostMouseLock();
2631}
2632
lfgad8244352016-07-13 16:55:512633bool WebContentsImpl::HasMouseLock(RenderWidgetHostImpl* render_widget_host) {
2634 // To verify if the mouse is locked, the mouse_lock_widget_ needs to be
2635 // assigned to the widget that requested the mouse lock, and the top-level
2636 // platform RenderWidgetHostView needs to hold the mouse lock from the OS.
Lucas Gadania0ea0172018-09-20 18:31:372637 auto* widget_host = GetTopLevelRenderWidgetHostView();
2638 return mouse_lock_widget_ == render_widget_host && widget_host &&
2639 widget_host->IsMouseLocked();
lfgad8244352016-07-13 16:55:512640}
2641
lfg84763c92017-02-16 18:55:152642RenderWidgetHostImpl* WebContentsImpl::GetMouseLockWidget() {
Lucas Gadania0ea0172018-09-20 18:31:372643 auto* widget_host = GetTopLevelRenderWidgetHostView();
2644 if ((widget_host && widget_host->IsMouseLocked()) ||
lfge2176fb2017-03-26 00:45:472645 (GetFullscreenRenderWidgetHostView() &&
Lucas Gadania0ea0172018-09-20 18:31:372646 GetFullscreenRenderWidgetHostView()->IsMouseLocked())) {
lfg84763c92017-02-16 18:55:152647 return mouse_lock_widget_;
Lucas Gadania0ea0172018-09-20 18:31:372648 }
lfg84763c92017-02-16 18:55:152649
2650 return nullptr;
2651}
2652
Joe Downing192998b22018-03-22 15:51:362653bool WebContentsImpl::RequestKeyboardLock(
Joe Downing13dd76b2018-04-09 18:32:152654 RenderWidgetHostImpl* render_widget_host,
2655 bool esc_key_locked) {
Joe Downing192998b22018-03-22 15:51:362656 DCHECK(render_widget_host);
Joe Downing192998b22018-03-22 15:51:362657 if (render_widget_host->delegate()->GetAsWebContents() != this) {
2658 NOTREACHED();
2659 return false;
2660 }
2661
2662 // KeyboardLock is only supported when called by the top-level browsing
2663 // context and is not supported in embedded content scenarios.
2664 if (GetOuterWebContents())
2665 return false;
2666
Joe Downing13dd76b2018-04-09 18:32:152667 esc_key_locked_ = esc_key_locked;
Joe Downing192998b22018-03-22 15:51:362668 keyboard_lock_widget_ = render_widget_host;
2669
Joe Downing13dd76b2018-04-09 18:32:152670 if (delegate_)
2671 delegate_->RequestKeyboardLock(this, esc_key_locked_);
Joe Downing192998b22018-03-22 15:51:362672 return true;
2673}
2674
2675void WebContentsImpl::CancelKeyboardLock(
2676 RenderWidgetHostImpl* render_widget_host) {
2677 if (!keyboard_lock_widget_ || render_widget_host != keyboard_lock_widget_)
2678 return;
2679
2680 RenderWidgetHostImpl* old_keyboard_lock_widget = keyboard_lock_widget_;
2681 keyboard_lock_widget_ = nullptr;
2682
Joe Downing13dd76b2018-04-09 18:32:152683 if (delegate_)
2684 delegate_->CancelKeyboardLockRequest(this);
2685
Joe Downing192998b22018-03-22 15:51:362686 old_keyboard_lock_widget->CancelKeyboardLock();
2687}
2688
2689RenderWidgetHostImpl* WebContentsImpl::GetKeyboardLockWidget() {
2690 return keyboard_lock_widget_;
2691}
2692
Dave Tapuskac3344362019-02-20 17:54:282693void WebContentsImpl::OnRenderFrameProxyVisibilityChanged(
2694 blink::mojom::FrameVisibility visibility) {
2695 switch (visibility) {
2696 case blink::mojom::FrameVisibility::kRenderedInViewport:
2697 WasShown();
2698 break;
2699 case blink::mojom::FrameVisibility::kNotRendered:
2700 WasHidden();
2701 break;
2702 case blink::mojom::FrameVisibility::kRenderedOutOfViewport:
2703 WasOccluded();
2704 break;
2705 }
ekaramada4f42692016-02-11 19:48:372706}
2707
[email protected]bafe6cd2012-05-23 23:09:502708void WebContentsImpl::CreateNewWindow(
csharrison95f01e922017-04-24 18:52:352709 RenderFrameHost* opener,
nick5ae4d2d2017-01-06 01:18:352710 int32_t render_view_route_id,
dcheng3ce04b62015-10-26 23:30:552711 int32_t main_frame_route_id,
2712 int32_t main_frame_widget_route_id,
rockot5c478a72016-09-28 23:14:182713 const mojom::CreateNewWindowParams& params,
Sergey Kuznetsov32257a22019-02-11 20:26:502714 bool has_user_gesture,
[email protected]97714c82012-06-06 10:15:132715 SessionStorageNamespace* session_storage_namespace) {
nick5ae4d2d2017-01-06 01:18:352716 // We should have zero valid routing ids, or three valid routing IDs.
2717 DCHECK_EQ((render_view_route_id == MSG_ROUTING_NONE),
2718 (main_frame_route_id == MSG_ROUTING_NONE));
2719 DCHECK_EQ((render_view_route_id == MSG_ROUTING_NONE),
2720 (main_frame_widget_route_id == MSG_ROUTING_NONE));
csharrison95f01e922017-04-24 18:52:352721 DCHECK(opener);
nick5ae4d2d2017-01-06 01:18:352722
csharrison95f01e922017-04-24 18:52:352723 int render_process_id = opener->GetProcess()->GetID();
2724 SiteInstance* source_site_instance = opener->GetSiteInstance();
2725
2726 // The route IDs passed into this function can be trusted not to already
2727 // be in use; they were allocated by the RenderWidgetHelper by the caller.
nick5ae4d2d2017-01-06 01:18:352728 DCHECK(!RenderFrameHostImpl::FromID(render_process_id, main_frame_route_id));
2729
[email protected]bafe6cd2012-05-23 23:09:502730 // We usually create the new window in the same BrowsingInstance (group of
2731 // script-related windows), by passing in the current SiteInstance. However,
[email protected]c4538072013-03-18 02:17:552732 // if the opener is being suppressed (in a non-guest), we create a new
2733 // SiteInstance in its own BrowsingInstance.
[email protected]a24efc22014-05-26 15:50:252734 bool is_guest = BrowserPluginGuest::IsGuest(this);
[email protected]c4538072013-03-18 02:17:552735
[email protected]04cbd3d2013-12-04 04:58:202736 // If the opener is to be suppressed, the new window can be in any process.
2737 // Since routing ids are process specific, we must not have one passed in
2738 // as argument here.
nick5ae4d2d2017-01-06 01:18:352739 DCHECK(!params.opener_suppressed || render_view_route_id == MSG_ROUTING_NONE);
[email protected]04cbd3d2013-12-04 04:58:202740
[email protected]bafe6cd2012-05-23 23:09:502741 scoped_refptr<SiteInstance> site_instance =
alexmos4cf2aa32015-07-15 23:40:432742 params.opener_suppressed && !is_guest
2743 ? SiteInstance::CreateForURL(GetBrowserContext(), params.target_url)
2744 : source_site_instance;
[email protected]bafe6cd2012-05-23 23:09:502745
[email protected]d1198fd2012-08-13 22:50:192746 // We must assign the SessionStorageNamespace before calling Init().
[email protected]4c3a23582012-08-18 08:54:342747 //
2748 // http://crbug.com/142685
[email protected]fdac6ade2013-07-20 01:06:302749 const std::string& partition_id =
2750 GetContentClient()->browser()->
2751 GetStoragePartitionIdForSite(GetBrowserContext(),
2752 site_instance->GetSiteURL());
[email protected]fc72bb12013-06-02 21:13:462753 StoragePartition* partition = BrowserContext::GetStoragePartition(
2754 GetBrowserContext(), site_instance.get());
[email protected]5f2aa722013-08-07 16:59:412755 DOMStorageContextWrapper* dom_storage_context =
2756 static_cast<DOMStorageContextWrapper*>(partition->GetDOMStorageContext());
[email protected]d1198fd2012-08-13 22:50:192757 SessionStorageNamespaceImpl* session_storage_namespace_impl =
2758 static_cast<SessionStorageNamespaceImpl*>(session_storage_namespace);
2759 CHECK(session_storage_namespace_impl->IsFromContext(dom_storage_context));
[email protected]dd6730412013-08-14 15:03:372760
2761 if (delegate_ &&
dcheng3ce04b62015-10-26 23:30:552762 !delegate_->ShouldCreateWebContents(
lukasza6f8ac622017-06-06 03:10:202763 this, opener, source_site_instance, render_view_route_id,
2764 main_frame_route_id, main_frame_widget_route_id,
2765 params.window_container_type, opener->GetLastCommittedURL(),
2766 params.frame_name, params.target_url, partition_id,
2767 session_storage_namespace)) {
jambaaab3a2016-11-05 00:46:182768 // Note: even though we're not creating a WebContents here, it could have
2769 // been created by the embedder so ensure that the RenderFrameHost is
2770 // properly initialized.
csharrisona2280cd2016-02-03 23:21:152771 // It's safe to only target the frame because the render process will not
2772 // have a chance to create more frames at this point.
jambaaab3a2016-11-05 00:46:182773 RenderFrameHostImpl* rfh =
2774 RenderFrameHostImpl::FromID(render_process_id, main_frame_route_id);
nick5ae4d2d2017-01-06 01:18:352775 if (rfh) {
2776 DCHECK(rfh->IsRenderFrameLive());
jambaaab3a2016-11-05 00:46:182777 rfh->Init();
nick5ae4d2d2017-01-06 01:18:352778 }
[email protected]dd6730412013-08-14 15:03:372779 return;
2780 }
2781
2782 // Create the new web contents. This will automatically create the new
2783 // WebContentsView. In the future, we may want to create the view separately.
[email protected]fc72bb12013-06-02 21:13:462784 CreateParams create_params(GetBrowserContext(), site_instance.get());
nick5ae4d2d2017-01-06 01:18:352785 create_params.routing_id = render_view_route_id;
[email protected]227692c52013-05-31 22:43:042786 create_params.main_frame_routing_id = main_frame_route_id;
dcheng3ce04b62015-10-26 23:30:552787 create_params.main_frame_widget_routing_id = main_frame_widget_route_id;
nasko48321ca32015-07-02 20:44:122788 create_params.main_frame_name = params.frame_name;
alexmos4cf2aa32015-07-15 23:40:432789 create_params.opener_render_process_id = render_process_id;
csharrison95f01e922017-04-24 18:52:352790 create_params.opener_render_frame_id = opener->GetRoutingID();
[email protected]50d326e2014-05-20 17:59:062791 create_params.opener_suppressed = params.opener_suppressed;
nick3b04f322016-08-31 19:29:192792 if (params.disposition == WindowOpenDisposition::NEW_BACKGROUND_TAB)
[email protected]50d326e2014-05-20 17:59:062793 create_params.initially_hidden = true;
lfg269b702f2015-06-08 19:28:192794 create_params.renderer_initiated_creation =
2795 main_frame_route_id != MSG_ROUTING_NONE;
[email protected]50d326e2014-05-20 17:59:062796
erikchenbee5c9622018-04-27 19:30:252797 std::unique_ptr<WebContents> new_contents;
[email protected]c4538072013-03-18 02:17:552798 if (!is_guest) {
2799 create_params.context = view_->GetNativeView();
[email protected]fc2b46b2014-05-03 16:33:452800 create_params.initial_size = GetContainerBounds().size();
Erik Chenbb8e738e2018-04-28 14:10:432801 new_contents = WebContents::Create(create_params);
[email protected]4858e432014-06-23 18:14:172802 } else {
erikchenbee5c9622018-04-27 19:30:252803 new_contents = base::WrapUnique(
2804 GetBrowserPluginGuest()->CreateNewGuestWindow(create_params));
[email protected]c4538072013-03-18 02:17:552805 }
danakje6c01622018-10-05 19:39:262806 auto owning_contents_impl =
2807 base::WrapUnique(static_cast<WebContentsImpl*>(new_contents.release()));
2808 auto* new_contents_impl = owning_contents_impl.get();
2809
2810 new_contents_impl->GetController().SetSessionStorageNamespace(
erikchenbee5c9622018-04-27 19:30:252811 partition_id, session_storage_namespace);
[email protected]d1198fd2012-08-13 22:50:192812
alexmos646fec02015-07-25 00:11:492813 // If the new frame has a name, make sure any SiteInstances that can find
2814 // this named frame have proxies for it. Must be called after
2815 // SetSessionStorageNamespace, since this calls CreateRenderView, which uses
2816 // GetSessionStorageNamespace.
2817 if (!params.frame_name.empty())
danakje6c01622018-10-05 19:39:262818 new_contents_impl->GetRenderManager()->CreateProxiesForNewNamedFrame();
alexmos646fec02015-07-25 00:11:492819
[email protected]c4538072013-03-18 02:17:552820 // Save the window for later if we're not suppressing the opener (since it
[email protected]d70bea92013-04-05 04:23:342821 // will be shown immediately).
2822 if (!params.opener_suppressed) {
2823 if (!is_guest) {
danakje6c01622018-10-05 19:39:262824 WebContentsView* new_view = new_contents_impl->view_.get();
[email protected]bafe6cd2012-05-23 23:09:502825
[email protected]d70bea92013-04-05 04:23:342826 // TODO(brettw): It seems bogus that we have to call this function on the
2827 // newly created object and give it one of its own member variables.
avi3627ecac2015-10-16 17:40:432828 new_view->CreateViewForWidget(
danakje6c01622018-10-05 19:39:262829 new_contents_impl->GetRenderViewHost()->GetWidget(), false);
[email protected]d70bea92013-04-05 04:23:342830 }
[email protected]bafe6cd2012-05-23 23:09:502831 // Save the created window associated with the route so we can show it
2832 // later.
Albert J. Wongcb004632018-07-10 22:58:252833 //
2834 // TODO(ajwong): This should be keyed off the RenderFrame routing id or the
2835 // FrameTreeNode id instead of the routing id of the Widget for the main
2836 // frame. https://crbug.com/545684
nick5ae4d2d2017-01-06 01:18:352837 DCHECK_NE(MSG_ROUTING_NONE, main_frame_widget_route_id);
danakje6c01622018-10-05 19:39:262838 GlobalRoutingID id(render_process_id, main_frame_widget_route_id);
2839 pending_contents_[id] = std::move(owning_contents_impl);
2840 AddDestructionObserver(new_contents_impl);
[email protected]bafe6cd2012-05-23 23:09:502841 }
2842
2843 if (delegate_) {
Bryan McQuaded2b93c02017-07-14 22:26:312844 delegate_->WebContentsCreated(this, render_process_id,
2845 opener->GetRoutingID(), params.frame_name,
danakje6c01622018-10-05 19:39:262846 params.target_url, new_contents_impl);
[email protected]bafe6cd2012-05-23 23:09:502847 }
2848
Charlie Harrisonf60dd1c2018-08-15 21:15:412849 for (auto& observer : observers_) {
danakje6c01622018-10-05 19:39:262850 observer.DidOpenRequestedURL(new_contents_impl, opener, params.target_url,
Leon Han963dc182018-11-06 05:41:482851 params.referrer.To<Referrer>(),
2852 params.disposition, ui::PAGE_TRANSITION_LINK,
Charlie Harrisonf60dd1c2018-08-15 21:15:412853 false, // started_from_context_menu
2854 true); // renderer_initiated
pnolandaae574e2017-03-06 21:04:212855 }
2856
Avi Drissmanba3b1b342017-08-29 18:16:132857 // Any new WebContents opened while this WebContents is in fullscreen can be
2858 // used to confuse the user, so drop fullscreen.
Avi Drissmand18c51972018-08-15 18:32:092859 ForSecurityDropFullscreen();
Avi Drissmanba3b1b342017-08-29 18:16:132860
[email protected]bafe6cd2012-05-23 23:09:502861 if (params.opener_suppressed) {
2862 // When the opener is suppressed, the original renderer cannot access the
2863 // new window. As a result, we need to show and navigate the window here.
[email protected]eda238a12012-09-07 23:44:002864 bool was_blocked = false;
erikchenbee5c9622018-04-27 19:30:252865
[email protected]eda238a12012-09-07 23:44:002866 if (delegate_) {
danakje6c01622018-10-05 19:39:262867 base::WeakPtr<WebContentsImpl> weak_new_contents =
2868 new_contents_impl->weak_factory_.GetWeakPtr();
nick0d558482017-02-13 22:27:222869
danakje6c01622018-10-05 19:39:262870 gfx::Rect initial_rect; // Report an empty initial rect.
2871 delegate_->AddNewContents(this, std::move(owning_contents_impl),
erikchenbee5c9622018-04-27 19:30:252872 params.disposition, initial_rect,
Sergey Kuznetsov32257a22019-02-11 20:26:502873 has_user_gesture, &was_blocked);
danakje6c01622018-10-05 19:39:262874 // The delegate may delete |new_contents_impl| during AddNewContents().
nick0d558482017-02-13 22:27:222875 if (!weak_new_contents)
danakje6c01622018-10-05 19:39:262876 return;
[email protected]eda238a12012-09-07 23:44:002877 }
erikchenbee5c9622018-04-27 19:30:252878
[email protected]eda238a12012-09-07 23:44:002879 if (!was_blocked) {
Nasko Oskov83a8cf92018-10-19 14:58:562880 std::unique_ptr<NavigationController::LoadURLParams> load_params =
2881 std::make_unique<NavigationController::LoadURLParams>(
2882 params.target_url);
Nasko Oskov93e7c55c2018-12-19 01:59:292883 load_params->initiator_origin = opener->GetLastCommittedOrigin();
Leon Han963dc182018-11-06 05:41:482884 load_params->referrer = params.referrer.To<Referrer>();
Nasko Oskov83a8cf92018-10-19 14:58:562885 load_params->transition_type = ui::PAGE_TRANSITION_LINK;
2886 load_params->is_renderer_initiated = true;
Sergey Kuznetsov32257a22019-02-11 20:26:502887 load_params->has_user_gesture = has_user_gesture;
mariakhomenkoa4971c12015-07-21 19:04:372888
2889 if (delegate_ && !is_guest &&
2890 !delegate_->ShouldResumeRequestsForCreatedWindow()) {
Nasko Oskov83a8cf92018-10-19 14:58:562891 // We are in asynchronous add new contents path, delay navigation.
2892 DCHECK(!new_contents_impl->delayed_open_url_params_);
2893 new_contents_impl->delayed_load_url_params_ = std::move(load_params);
mariakhomenkoa4971c12015-07-21 19:04:372894 } else {
Nasko Oskov83a8cf92018-10-19 14:58:562895 new_contents_impl->controller_.LoadURLWithParams(*load_params.get());
Nasko Oskov28ebd5b2018-12-07 22:29:332896 if (!is_guest)
2897 new_contents_impl->Focus();
mariakhomenkoa4971c12015-07-21 19:04:372898 }
[email protected]eda238a12012-09-07 23:44:002899 }
[email protected]bafe6cd2012-05-23 23:09:502900 }
2901}
2902
avib7348942015-12-25 20:57:102903void WebContentsImpl::CreateNewWidget(int32_t render_process_id,
Albert J. Wongf6e13ed2018-09-18 15:25:472904 int32_t widget_route_id,
danakj829cdd142018-09-14 21:13:272905 mojom::WidgetPtr widget) {
Albert J. Wongf6e13ed2018-09-18 15:25:472906 CreateNewWidget(render_process_id, widget_route_id, /*is_fullscreen=*/false,
danakj829cdd142018-09-14 21:13:272907 std::move(widget));
[email protected]bafe6cd2012-05-23 23:09:502908}
2909
avib7348942015-12-25 20:57:102910void WebContentsImpl::CreateNewFullscreenWidget(int32_t render_process_id,
Albert J. Wongf6e13ed2018-09-18 15:25:472911 int32_t widget_route_id,
Dave Tapuska1bdf1832017-07-07 18:07:192912 mojom::WidgetPtr widget) {
Albert J. Wongf6e13ed2018-09-18 15:25:472913 CreateNewWidget(render_process_id, widget_route_id, /*is_fullscreen=*/true,
danakj829cdd142018-09-14 21:13:272914 std::move(widget));
[email protected]bafe6cd2012-05-23 23:09:502915}
2916
avib7348942015-12-25 20:57:102917void WebContentsImpl::CreateNewWidget(int32_t render_process_id,
2918 int32_t route_id,
[email protected]bafe6cd2012-05-23 23:09:502919 bool is_fullscreen,
danakj829cdd142018-09-14 21:13:272920 mojom::WidgetPtr widget) {
kenrba26d15092016-02-10 22:00:252921 RenderProcessHost* process = RenderProcessHost::FromID(render_process_id);
kenrbb46f86a2015-12-07 07:53:232922 // A message to create a new widget can only come from an active process for
[email protected]a8504022013-12-04 20:23:512923 // this WebContentsImpl instance. If any other process sends the request,
2924 // it is invalid and the process must be terminated.
dcheng57e39e22016-01-21 00:25:382925 if (!HasMatchingProcess(&frame_tree_, render_process_id)) {
Lukasz Anforowicz6f746282018-01-04 23:24:512926 ReceivedBadMessage(process, bad_message::WCI_NEW_WIDGET_PROCESS_MISMATCH);
[email protected]a8504022013-12-04 20:23:512927 return;
2928 }
2929
Dave Tapuska485aca92017-08-08 00:47:582930 RenderWidgetHostImpl* widget_host = new RenderWidgetHostImpl(
2931 this, process, route_id, std::move(widget), IsHidden());
[email protected]b24b68a2012-09-24 21:57:262932
[email protected]cfd80b02014-05-01 17:46:482933 RenderWidgetHostViewBase* widget_view =
2934 static_cast<RenderWidgetHostViewBase*>(
danakj0b246942018-09-17 21:30:272935 view_->CreateViewForChildWidget(widget_host));
[email protected]83918ec2013-01-10 15:37:192936 if (!widget_view)
2937 return;
danakj0b246942018-09-17 21:30:272938 // Fullscreen child widgets are frames, other child widgets are popups, and
2939 // popups should not get activated.
2940 if (!is_fullscreen)
2941 widget_view->SetWidgetType(WidgetType::kPopup);
[email protected]bafe6cd2012-05-23 23:09:502942 // Save the created widget associated with the route so we can show it later.
Lukasz Anforowicz09060bdf72018-08-23 15:53:172943 pending_widget_views_[GlobalRoutingID(render_process_id, route_id)] =
alexmosc2a8cec2016-05-23 22:19:532944 widget_view;
[email protected]bafe6cd2012-05-23 23:09:502945}
2946
alexmosc2a8cec2016-05-23 22:19:532947void WebContentsImpl::ShowCreatedWindow(int process_id,
nick5ae4d2d2017-01-06 01:18:352948 int main_frame_widget_route_id,
[email protected]bafe6cd2012-05-23 23:09:502949 WindowOpenDisposition disposition,
bokan107a47f2015-02-03 23:23:392950 const gfx::Rect& initial_rect,
[email protected]bafe6cd2012-05-23 23:09:502951 bool user_gesture) {
danakje6c01622018-10-05 19:39:262952 // This method is the renderer requesting an existing top level window to
2953 // show a new top level window that the renderer created. Each top level
2954 // window is associated with a WebContents. In this case it was created
2955 // earlier but showing it was deferred until the renderer requested for it
2956 // to be shown. We find that previously created WebContents here.
2957 // TODO(danakj): Why do we defer this show step until the renderer asks for it
2958 // when it will always do so. What needs to happen in the renderer before we
2959 // reach here?
2960 std::unique_ptr<WebContentsImpl> owned_created =
nick5ae4d2d2017-01-06 01:18:352961 GetCreatedWindow(process_id, main_frame_widget_route_id);
danakje6c01622018-10-05 19:39:262962 WebContentsImpl* created = owned_created.get();
2963 // The browser may have rejected the request to make a new window, or the
2964 // renderer could be sending an invalid route id. Ignore the request then.
2965 if (!created)
2966 return;
mariakhomenko44bdc4732015-04-29 01:55:382967
danakje6c01622018-10-05 19:39:262968 // This uses the delegate for the WebContents where the window was created
2969 // from, to control how to show the newly created window.
2970 WebContentsDelegate* delegate = GetDelegate();
nick5ae4d2d2017-01-06 01:18:352971
danakje6c01622018-10-05 19:39:262972 // The delegate can be null in tests, so we must check for it :(.
2973 if (delegate) {
2974 // Mark the web contents as pending resume, then immediately do
2975 // the resume if the delegate wants it.
2976 created->is_resume_pending_ = true;
2977 if (delegate->ShouldResumeRequestsForCreatedWindow())
2978 created->ResumeLoadingCreatedWebContents();
2979
2980 base::WeakPtr<WebContentsImpl> weak_created =
2981 created->weak_factory_.GetWeakPtr();
2982 delegate->AddNewContents(this, std::move(owned_created), disposition,
2983 initial_rect, user_gesture, nullptr);
2984 // The delegate may delete |created| during AddNewContents().
2985 if (!weak_created)
2986 return;
[email protected]eda238a12012-09-07 23:44:002987 }
danakje6c01622018-10-05 19:39:262988
2989 RenderWidgetHostImpl* rwh = created->GetMainFrame()->GetRenderWidgetHost();
2990 DCHECK_EQ(main_frame_widget_route_id, rwh->GetRoutingID());
2991 rwh->Send(new WidgetMsg_SetBounds_ACK(rwh->GetRoutingID()));
[email protected]bafe6cd2012-05-23 23:09:502992}
2993
alexmosc2a8cec2016-05-23 22:19:532994void WebContentsImpl::ShowCreatedWidget(int process_id,
Albert J. Wongf6e13ed2018-09-18 15:25:472995 int widget_route_id,
bokan107a47f2015-02-03 23:23:392996 const gfx::Rect& initial_rect) {
Albert J. Wongf6e13ed2018-09-18 15:25:472997 ShowCreatedWidget(process_id, widget_route_id, false, initial_rect);
[email protected]bafe6cd2012-05-23 23:09:502998}
2999
alexmosc2a8cec2016-05-23 22:19:533000void WebContentsImpl::ShowCreatedFullscreenWidget(int process_id,
Albert J. Wongf6e13ed2018-09-18 15:25:473001 int widget_route_id) {
3002 ShowCreatedWidget(process_id, widget_route_id, true, gfx::Rect());
[email protected]bafe6cd2012-05-23 23:09:503003}
3004
alexmosc2a8cec2016-05-23 22:19:533005void WebContentsImpl::ShowCreatedWidget(int process_id,
3006 int route_id,
[email protected]bafe6cd2012-05-23 23:09:503007 bool is_fullscreen,
bokan107a47f2015-02-03 23:23:393008 const gfx::Rect& initial_rect) {
[email protected]cfd80b02014-05-01 17:46:483009 RenderWidgetHostViewBase* widget_host_view =
alexmosc2a8cec2016-05-23 22:19:533010 static_cast<RenderWidgetHostViewBase*>(
3011 GetCreatedWidget(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:503012 if (!widget_host_view)
3013 return;
[email protected]cfd80b02014-05-01 17:46:483014
Ivan Kotenkov2c0d2bb32017-11-01 15:41:283015 RenderWidgetHostView* view = nullptr;
lfgc740d4b22016-04-15 16:45:333016 if (GetOuterWebContents()) {
3017 view = GetOuterWebContents()->GetRenderWidgetHostView();
[email protected]cfd80b02014-05-01 17:46:483018 } else {
3019 view = GetRenderWidgetHostView();
3020 }
3021
danakj0b246942018-09-17 21:30:273022 // Fullscreen child widgets are frames, other child widgets are popups.
[email protected]4aebbca2013-09-17 22:26:493023 if (is_fullscreen) {
[email protected]d7f80ba2013-10-12 07:42:313024 DCHECK_EQ(MSG_ROUTING_NONE, fullscreen_widget_routing_id_);
[email protected]0b431992014-06-24 00:08:033025 view_->StoreFocus();
alexmosc9e76ec2016-05-16 22:59:373026 fullscreen_widget_process_id_ =
3027 widget_host_view->GetRenderWidgetHost()->GetProcess()->GetID();
[email protected]d7f80ba2013-10-12 07:42:313028 fullscreen_widget_routing_id_ = route_id;
[email protected]4aebbca2013-09-17 22:26:493029 if (delegate_ && delegate_->EmbedsFullscreenWidget()) {
3030 widget_host_view->InitAsChild(GetRenderWidgetHostView()->GetNativeView());
Dave Tapuska3ed44192018-05-01 18:53:303031 delegate_->EnterFullscreenModeForTab(this, GURL(),
3032 blink::WebFullscreenOptions());
[email protected]4aebbca2013-09-17 22:26:493033 } else {
[email protected]cfd80b02014-05-01 17:46:483034 widget_host_view->InitAsFullscreen(view);
[email protected]4aebbca2013-09-17 22:26:493035 }
ericwilligersde386342016-10-19 02:35:093036 for (auto& observer : observers_)
3037 observer.DidShowFullscreenWidget();
[email protected]4aebbca2013-09-17 22:26:493038 if (!widget_host_view->HasFocus())
3039 widget_host_view->Focus();
3040 } else {
bokan107a47f2015-02-03 23:23:393041 widget_host_view->InitAsPopup(view, initial_rect);
[email protected]4aebbca2013-09-17 22:26:493042 }
[email protected]89054502012-06-03 10:29:243043
yiyixcb1fbc4f2018-03-16 19:54:083044 RenderWidgetHostImpl* render_widget_host_impl = widget_host_view->host();
[email protected]89054502012-06-03 10:29:243045 render_widget_host_impl->Init();
[email protected]d7f80ba2013-10-12 07:42:313046 // Only allow privileged mouse lock for fullscreen render widget, which is
3047 // used to implement Pepper Flash fullscreen.
3048 render_widget_host_impl->set_allow_privileged_mouse_lock(is_fullscreen);
[email protected]bafe6cd2012-05-23 23:09:503049}
3050
danakje6c01622018-10-05 19:39:263051std::unique_ptr<WebContentsImpl> WebContentsImpl::GetCreatedWindow(
nick5ae4d2d2017-01-06 01:18:353052 int process_id,
3053 int main_frame_widget_route_id) {
Lukasz Anforowicz09060bdf72018-08-23 15:53:173054 auto key = GlobalRoutingID(process_id, main_frame_widget_route_id);
nick5ae4d2d2017-01-06 01:18:353055 auto iter = pending_contents_.find(key);
[email protected]bafe6cd2012-05-23 23:09:503056
3057 // Certain systems can block the creation of new windows. If we didn't succeed
3058 // in creating one, just return NULL.
alexmosc2a8cec2016-05-23 22:19:533059 if (iter == pending_contents_.end())
3060 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:503061
danakje6c01622018-10-05 19:39:263062 std::unique_ptr<WebContentsImpl> new_contents = std::move(iter->second);
nick5ae4d2d2017-01-06 01:18:353063 pending_contents_.erase(key);
danakje6c01622018-10-05 19:39:263064 RemoveDestructionObserver(new_contents.get());
[email protected]bafe6cd2012-05-23 23:09:503065
[email protected]d70bea92013-04-05 04:23:343066 // Don't initialize the guest WebContents immediately.
danakje6c01622018-10-05 19:39:263067 if (BrowserPluginGuest::IsGuest(new_contents.get()))
[email protected]d70bea92013-04-05 04:23:343068 return new_contents;
3069
Lukasz Anforowicz5510ed652018-06-06 16:16:193070 if (!new_contents->GetMainFrame()->GetProcess()->IsInitializedAndNotDead() ||
nick5ae4d2d2017-01-06 01:18:353071 !new_contents->GetMainFrame()->GetView()) {
alexmosc2a8cec2016-05-23 22:19:533072 return nullptr;
nick5ae4d2d2017-01-06 01:18:353073 }
[email protected]bafe6cd2012-05-23 23:09:503074
[email protected]bafe6cd2012-05-23 23:09:503075 return new_contents;
3076}
3077
alexmosc2a8cec2016-05-23 22:19:533078RenderWidgetHostView* WebContentsImpl::GetCreatedWidget(int process_id,
3079 int route_id) {
Lukasz Anforowicz09060bdf72018-08-23 15:53:173080 auto iter = pending_widget_views_.find(GlobalRoutingID(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:503081 if (iter == pending_widget_views_.end()) {
3082 DCHECK(false);
alexmosc2a8cec2016-05-23 22:19:533083 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:503084 }
3085
3086 RenderWidgetHostView* widget_host_view = iter->second;
Lukasz Anforowicz09060bdf72018-08-23 15:53:173087 pending_widget_views_.erase(GlobalRoutingID(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:503088
3089 RenderWidgetHost* widget_host = widget_host_view->GetRenderWidgetHost();
Lukasz Anforowicz5510ed652018-06-06 16:16:193090 if (!widget_host->GetProcess()->IsInitializedAndNotDead()) {
[email protected]bafe6cd2012-05-23 23:09:503091 // The view has gone away or the renderer crashed. Nothing to do.
alexmosc2a8cec2016-05-23 22:19:533092 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:503093 }
3094
3095 return widget_host_view;
3096}
3097
[email protected]f13b4202012-06-12 23:53:233098void WebContentsImpl::RequestMediaAccessPermission(
[email protected]33662e52013-01-07 21:31:093099 const MediaStreamRequest& request,
Mark Pilgrim57499082018-06-12 12:38:303100 MediaResponseCallback callback) {
[email protected]d19b84b2014-03-14 11:52:373101 if (delegate_) {
Mark Pilgrim57499082018-06-12 12:38:303102 delegate_->RequestMediaAccessPermission(this, request, std::move(callback));
[email protected]d19b84b2014-03-14 11:52:373103 } else {
Antonio Gomes0d42960a2019-06-05 12:35:513104 std::move(callback).Run(
3105 blink::MediaStreamDevices(),
3106 blink::mojom::MediaStreamRequestResult::FAILED_DUE_TO_SHUTDOWN,
3107 std::unique_ptr<MediaStreamUI>());
[email protected]d19b84b2014-03-14 11:52:373108 }
[email protected]f13b4202012-06-12 23:53:233109}
3110
Chandan Padhia4b8bcb72017-09-12 16:41:043111bool WebContentsImpl::CheckMediaAccessPermission(
Raymes Khouryad7c24a12018-03-05 23:22:583112 RenderFrameHost* render_frame_host,
Chandan Padhia4b8bcb72017-09-12 16:41:043113 const url::Origin& security_origin,
Antonio Gomesc8b734b2019-06-05 18:22:163114 blink::mojom::MediaStreamType type) {
3115 DCHECK(type == blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE ||
3116 type == blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE);
Chandan Padhia4b8bcb72017-09-12 16:41:043117 return delegate_ && delegate_->CheckMediaAccessPermission(
Raymes Khouryad7c24a12018-03-05 23:22:583118 render_frame_host, security_origin.GetURL(), type);
grunell657d4d82014-09-18 00:09:433119}
3120
Guido Urdaneta73fa6632019-01-14 18:46:263121std::string WebContentsImpl::GetDefaultMediaDeviceID(
Antonio Gomesc8b734b2019-06-05 18:22:163122 blink::mojom::MediaStreamType type) {
guidou8a440b842017-01-30 13:58:433123 if (!delegate_)
3124 return std::string();
3125 return delegate_->GetDefaultMediaDeviceID(this, type);
3126}
3127
[email protected]cc9200432013-07-23 23:02:403128SessionStorageNamespace* WebContentsImpl::GetSessionStorageNamespace(
3129 SiteInstance* instance) {
3130 return controller_.GetSessionStorageNamespace(instance);
3131}
3132
[email protected]6de7fc482014-06-06 10:46:443133SessionStorageNamespaceMap WebContentsImpl::GetSessionStorageNamespaceMap() {
3134 return controller_.GetSessionStorageNamespaceMap();
3135}
3136
[email protected]9b159a52013-10-03 17:24:553137FrameTree* WebContentsImpl::GetFrameTree() {
3138 return &frame_tree_;
3139}
3140
aelias5252baa2016-04-10 01:18:023141bool WebContentsImpl::IsOverridingUserAgent() {
3142 return GetController().GetVisibleEntry() &&
3143 GetController().GetVisibleEntry()->GetIsOverridingUserAgent();
3144}
3145
avi85ee8362016-10-08 02:09:083146bool WebContentsImpl::IsJavaScriptDialogShowing() const {
3147 return is_showing_javascript_dialog_;
3148}
3149
avic031d392017-03-03 03:09:423150bool WebContentsImpl::ShouldIgnoreUnresponsiveRenderer() {
3151 // Ignore unresponsive renderers if the debugger is attached to them since the
3152 // unresponsiveness might be a result of the renderer sitting on a breakpoint.
3153 //
David Bienvenu525f8a02019-02-15 02:02:423154#ifdef OS_WIN
3155 // Check if a windows debugger is attached to the renderer process.
3156 base::ProcessHandle process_handle =
3157 GetMainFrame()->GetProcess()->GetProcess().Handle();
3158 BOOL debugger_present = FALSE;
3159 if (CheckRemoteDebuggerPresent(process_handle, &debugger_present) &&
3160 debugger_present)
3161 return true;
3162#endif // OS_WIN
3163
avic031d392017-03-03 03:09:423164 // TODO(pfeldman): Fix this to only return true if the renderer is *actually*
3165 // sitting on a breakpoint. https://crbug.com/684202
3166 return DevToolsAgentHost::IsDebuggerAttached(this);
3167}
3168
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:413169ui::AXMode WebContentsImpl::GetAccessibilityMode() {
[email protected]95640212014-07-26 18:14:303170 return accessibility_mode_;
3171}
3172
Dominic Mazzonia7b0edb22017-08-09 16:32:513173void WebContentsImpl::AccessibilityEventReceived(
Dominic Mazzoniccbaa9b2018-06-06 07:44:233174 const AXEventNotificationDetails& details) {
ericwilligersde386342016-10-19 02:35:093175 for (auto& observer : observers_)
Dominic Mazzonia7b0edb22017-08-09 16:32:513176 observer.AccessibilityEventReceived(details);
[email protected]31a71eaf2014-03-13 01:47:363177}
3178
dmazzoni2400c462016-08-23 15:07:133179void WebContentsImpl::AccessibilityLocationChangesReceived(
3180 const std::vector<AXLocationChangeNotificationDetails>& details) {
ericwilligersde386342016-10-19 02:35:093181 for (auto& observer : observers_)
Dominic Mazzonia7b0edb22017-08-09 16:32:513182 observer.AccessibilityLocationChangesReceived(details);
dmazzoni2400c462016-08-23 15:07:133183}
3184
James Wallace-Leeeafc94cb92018-07-23 21:35:093185base::string16 WebContentsImpl::DumpAccessibilityTree(bool internal) {
3186 auto* ax_mgr = GetOrCreateRootBrowserAccessibilityManager();
3187 DCHECK(ax_mgr);
3188 return AccessibilityTreeFormatter::DumpAccessibilityTreeFromManager(ax_mgr,
3189 internal);
3190}
3191
dmazzonia656928e2014-09-15 20:28:543192RenderFrameHost* WebContentsImpl::GetGuestByInstanceID(
fsamuel833ee7c2015-02-13 23:40:403193 RenderFrameHost* render_frame_host,
dmazzonia656928e2014-09-15 20:28:543194 int browser_plugin_instance_id) {
3195 BrowserPluginGuestManager* guest_manager =
3196 GetBrowserContext()->GetGuestManager();
fsamuel9cbc00a2015-04-17 20:30:203197 if (!guest_manager)
3198 return nullptr;
3199
dmazzonia656928e2014-09-15 20:28:543200 WebContents* guest = guest_manager->GetGuestByInstanceID(
fsamuel2e9413d2015-02-25 01:25:443201 render_frame_host->GetProcess()->GetID(), browser_plugin_instance_id);
dmazzonia656928e2014-09-15 20:28:543202 if (!guest)
fsamuel9cbc00a2015-04-17 20:30:203203 return nullptr;
3204
dmazzonia656928e2014-09-15 20:28:543205 return guest->GetMainFrame();
3206}
3207
Ke He7319dbe2017-11-09 05:54:443208device::mojom::GeolocationContext* WebContentsImpl::GetGeolocationContext() {
3209 if (geolocation_context_)
3210 return geolocation_context_.get();
3211
3212 auto request = mojo::MakeRequest(&geolocation_context_);
Ken Rockotfd03e682019-06-20 21:13:543213 service_manager::Connector* connector = GetSystemConnector();
3214 if (connector)
3215 connector->BindInterface(device::mojom::kServiceName, std::move(request));
Conley Owens6894c4f2017-07-10 19:29:133216 return geolocation_context_.get();
blundellc57b93f2014-10-29 13:19:573217}
3218
ke.he98b761e2017-05-09 05:59:173219device::mojom::WakeLockContext* WebContentsImpl::GetWakeLockContext() {
blundelld8cd72b2017-03-28 07:18:383220 if (!wake_lock_context_host_)
3221 wake_lock_context_host_.reset(new WakeLockContextHost(this));
blundelle75a8f92017-03-27 08:11:173222 return wake_lock_context_host_->GetWakeLockContext();
alogvinovf50445a2015-10-30 13:00:123223}
3224
blundellf5316fc2017-05-15 11:49:033225#if defined(OS_ANDROID)
Han Leonf6a2e5f2017-05-23 13:40:473226void WebContentsImpl::GetNFC(device::mojom::NFCRequest request) {
blundellf5316fc2017-05-15 11:49:033227 if (!nfc_host_)
3228 nfc_host_.reset(new NFCHost(this));
3229 nfc_host_->GetNFC(std::move(request));
3230}
3231#endif
3232
Evan Stade5e750ad02017-08-07 21:59:273233void WebContentsImpl::SetNotWaitingForResponse() {
3234 if (waiting_for_response_ == false)
3235 return;
3236
3237 waiting_for_response_ = false;
3238 if (delegate_)
3239 delegate_->LoadingStateChanged(this, is_load_to_different_document_);
Chris Hamiltonf82f2a702018-02-15 19:37:293240 for (auto& observer : observers_)
3241 observer.DidReceiveResponse();
Evan Stade5e750ad02017-08-07 21:59:273242}
3243
lfgbb9c28a2016-03-01 03:19:493244void WebContentsImpl::SendScreenRects() {
kenrbc52e1b4e2016-03-20 01:03:373245 for (FrameTreeNode* node : frame_tree_.Nodes()) {
kenrb0e8dc202016-05-30 19:51:403246 if (node->current_frame_host()->is_local_root())
kenrbc52e1b4e2016-03-20 01:03:373247 node->current_frame_host()->GetRenderWidgetHost()->SendScreenRects();
3248 }
lfgbb9c28a2016-03-01 03:19:493249
danakj4df8a9d02019-02-05 20:36:593250 // Interstitials have their own |frame_tree_|.
3251 if (interstitial_page_) {
3252 FrameTree* interstitial_frame_tree = interstitial_page_->GetFrameTree();
3253 for (FrameTreeNode* node : interstitial_frame_tree->Nodes()) {
3254 if (node->current_frame_host()->is_local_root())
3255 node->current_frame_host()->GetRenderWidgetHost()->SendScreenRects();
3256 }
lfgdb5c4ed2016-03-04 23:09:073257 }
3258
avallee9f43b012016-11-26 07:02:103259 if (browser_plugin_embedder_ && !is_being_destroyed_)
[email protected]a7568e62013-06-14 07:50:443260 browser_plugin_embedder_->DidSendScreenRects();
[email protected]32deec62013-05-15 23:55:043261}
3262
ekaramadadd882292016-06-08 15:22:563263TextInputManager* WebContentsImpl::GetTextInputManager() {
3264 if (GetOuterWebContents())
3265 return GetOuterWebContents()->GetTextInputManager();
3266
Ehsan Karamadc179dc02018-12-15 03:09:293267 if (!text_input_manager_ && !browser_plugin_guest_) {
Darren Shenca53d5f2018-05-15 04:56:013268 text_input_manager_.reset(new TextInputManager(
3269 GetBrowserContext() &&
3270 !GetBrowserContext()->IsOffTheRecord()) /* should_do_learning */);
3271 }
ekaramadadd882292016-06-08 15:22:563272
3273 return text_input_manager_.get();
3274}
3275
paulmeyer7f6f1d4f2016-11-15 00:00:273276bool WebContentsImpl::OnUpdateDragCursor() {
Lei Zhang6410ec1a2019-01-31 21:38:583277 return browser_plugin_embedder_ &&
3278 browser_plugin_embedder_->OnUpdateDragCursor();
paulmeyer7f6f1d4f2016-11-15 00:00:273279}
3280
kenrb11f213a2017-03-24 18:12:063281bool WebContentsImpl::IsWidgetForMainFrame(
3282 RenderWidgetHostImpl* render_widget_host) {
3283 return render_widget_host == GetMainFrame()->GetRenderWidgetHost();
3284}
3285
[email protected]95640212014-07-26 18:14:303286BrowserAccessibilityManager*
3287 WebContentsImpl::GetRootBrowserAccessibilityManager() {
Dominic Mazzoniefb5f9e32017-12-21 01:08:223288 RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(
3289 ShowingInterstitialPage() ? GetInterstitialPage()->GetMainFrame()
3290 : GetMainFrame());
creisc014b402015-04-23 16:41:453291 return rfh ? rfh->browser_accessibility_manager() : nullptr;
[email protected]95640212014-07-26 18:14:303292}
3293
3294BrowserAccessibilityManager*
3295 WebContentsImpl::GetOrCreateRootBrowserAccessibilityManager() {
Dominic Mazzoniefb5f9e32017-12-21 01:08:223296 RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(
3297 ShowingInterstitialPage() ? GetInterstitialPage()->GetMainFrame()
3298 : GetMainFrame());
creisc014b402015-04-23 16:41:453299 return rfh ? rfh->GetOrCreateBrowserAccessibilityManager() : nullptr;
[email protected]95640212014-07-26 18:14:303300}
3301
Dave Tapuskab336b922017-07-06 19:24:053302void WebContentsImpl::ExecuteEditCommand(
3303 const std::string& command,
3304 const base::Optional<base::string16>& value) {
3305 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
3306 if (!focused_frame)
3307 return;
3308
3309 focused_frame->GetFrameInputHandler()->ExecuteEditCommand(command, value);
3310}
3311
mohsen7ab1ec16ec2015-07-02 18:26:233312void WebContentsImpl::MoveRangeSelectionExtent(const gfx::Point& extent) {
Dave Tapuskab336b922017-07-06 19:24:053313 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
mohsen7ab1ec16ec2015-07-02 18:26:233314 if (!focused_frame)
3315 return;
3316
dtapuska9d46ef7d2017-05-26 19:06:063317 focused_frame->GetFrameInputHandler()->MoveRangeSelectionExtent(extent);
mohsen7ab1ec16ec2015-07-02 18:26:233318}
3319
3320void WebContentsImpl::SelectRange(const gfx::Point& base,
3321 const gfx::Point& extent) {
Dave Tapuskab336b922017-07-06 19:24:053322 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
mohsen7ab1ec16ec2015-07-02 18:26:233323 if (!focused_frame)
3324 return;
3325
dtapuska9d46ef7d2017-05-26 19:06:063326 focused_frame->GetFrameInputHandler()->SelectRange(base, extent);
mohsen7ab1ec16ec2015-07-02 18:26:233327}
3328
Dave Tapuskab336b922017-07-06 19:24:053329void WebContentsImpl::MoveCaret(const gfx::Point& extent) {
3330 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
3331 if (!focused_frame)
3332 return;
3333
3334 focused_frame->GetFrameInputHandler()->MoveCaret(extent);
3335}
3336
Shimi Zhang37deeb22017-09-28 00:59:013337void WebContentsImpl::AdjustSelectionByCharacterOffset(
3338 int start_adjust,
3339 int end_adjust,
3340 bool show_selection_menu) {
Dave Tapuskab336b922017-07-06 19:24:053341 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
aurimasab0319022015-07-10 21:57:383342 if (!focused_frame)
3343 return;
3344
Shimi Zhang37deeb22017-09-28 00:59:013345 using blink::mojom::SelectionMenuBehavior;
dtapuska9d46ef7d2017-05-26 19:06:063346 focused_frame->GetFrameInputHandler()->AdjustSelectionByCharacterOffset(
Shimi Zhang37deeb22017-09-28 00:59:013347 start_adjust, end_adjust,
3348 show_selection_menu ? SelectionMenuBehavior::kShow
3349 : SelectionMenuBehavior::kHide);
aurimasab0319022015-07-10 21:57:383350}
3351
[email protected]b172aee2012-04-10 17:05:263352void WebContentsImpl::UpdatePreferredSize(const gfx::Size& pref_size) {
[email protected]222f5822014-02-05 23:40:493353 const gfx::Size old_size = GetPreferredSize();
[email protected]bcd2815602012-01-14 18:17:233354 preferred_size_ = pref_size;
[email protected]222f5822014-02-05 23:40:493355 OnPreferredSizeChanged(old_size);
[email protected]0548c5352011-09-07 00:33:333356}
3357
avic3aa8422015-11-09 20:57:223358void WebContentsImpl::ResizeDueToAutoResize(
3359 RenderWidgetHostImpl* render_widget_host,
Fady Samuel97947112018-05-05 16:24:543360 const gfx::Size& new_size) {
avic3aa8422015-11-09 20:57:223361 if (render_widget_host != GetRenderViewHost()->GetWidget())
3362 return;
3363
kenrbe4f91082017-06-02 20:32:083364 auto_resize_size_ = new_size;
3365
3366 // Out-of-process iframe visible viewport sizes usually come from the
3367 // top-level RenderWidgetHostView, but when auto-resize is enabled on the
3368 // top frame then that size is used instead.
3369 for (FrameTreeNode* node : frame_tree_.Nodes()) {
3370 if (node->current_frame_host()->is_local_root()) {
3371 RenderWidgetHostImpl* host =
3372 node->current_frame_host()->GetRenderWidgetHost();
3373 if (host != render_widget_host)
Fady Samuel0b911822018-04-25 13:22:163374 host->SynchronizeVisualProperties();
kenrbe4f91082017-06-02 20:32:083375 }
3376 }
3377
[email protected]61e2b3cc2012-03-02 16:13:343378 if (delegate_)
3379 delegate_->ResizeDueToAutoResize(this, new_size);
3380}
3381
kenrbe4f91082017-06-02 20:32:083382gfx::Size WebContentsImpl::GetAutoResizeSize() {
3383 return auto_resize_size_;
3384}
3385
3386void WebContentsImpl::ResetAutoResizeSize() {
3387 auto_resize_size_ = gfx::Size();
3388}
3389
Albert J. Wongeb28e7e2018-10-12 00:57:433390InputEventShim* WebContentsImpl::GetInputEventShim() const {
3391 // The only thing that intercepts text input and mouse lock is the
3392 // BrowserPluginGuest. Delegate to the BrowserPluginGuest logic for
3393 // whether or not it needs to shim these events.
3394 if (browser_plugin_guest_) {
3395 return browser_plugin_guest_->GetInputEventShim();
3396 }
3397 return nullptr;
3398}
3399
[email protected]b172aee2012-04-10 17:05:263400WebContents* WebContentsImpl::OpenURL(const OpenURLParams& params) {
Bo Liu300c6052018-06-12 04:46:073401 if (!delegate_) {
3402 // Embedder can delay setting a delegate on new WebContents with
3403 // WebContentsDelegate::ShouldResumeRequestsForCreatedWindow. In the mean
3404 // time, navigations, including the initial one, that goes through OpenURL
3405 // should be delayed until embedder is ready to resume loading.
3406 delayed_open_url_params_ = std::make_unique<OpenURLParams>(params);
Nasko Oskov83a8cf92018-10-19 14:58:563407
3408 // If there was a navigation deferred when creating the window through
3409 // CreateNewWindow, drop it in favor of this navigation.
3410 delayed_load_url_params_.reset();
3411
Ivan Kotenkov2c0d2bb32017-11-01 15:41:283412 return nullptr;
Bo Liu300c6052018-06-12 04:46:073413 }
[email protected]00c37fc2011-08-02 00:22:503414
[email protected]e5d549d2011-12-28 01:29:203415 WebContents* new_contents = delegate_->OpenURLFromTab(this, params);
pnoland488944652017-02-22 18:58:543416
3417 RenderFrameHost* source_render_frame_host = RenderFrameHost::FromID(
3418 params.source_render_process_id, params.source_render_frame_id);
3419
3420 if (source_render_frame_host && params.source_site_instance) {
3421 CHECK_EQ(source_render_frame_host->GetSiteInstance(),
3422 params.source_site_instance.get());
3423 }
3424
3425 if (new_contents && source_render_frame_host && new_contents != this) {
3426 for (auto& observer : observers_) {
Lukasz Anforowicz48c9f872018-08-01 00:58:413427 observer.DidOpenRequestedURL(
3428 new_contents, source_render_frame_host, params.url, params.referrer,
3429 params.disposition, params.transition,
3430 params.started_from_context_menu, params.is_renderer_initiated);
pnoland488944652017-02-22 18:58:543431 }
3432 }
3433
[email protected]e5d549d2011-12-28 01:29:203434 return new_contents;
[email protected]d5f942ba2008-09-26 19:30:343435}
3436
[email protected]a86c0e962013-12-17 17:10:393437void WebContentsImpl::RenderFrameForInterstitialPageCreated(
3438 RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:093439 for (auto& observer : observers_)
3440 observer.RenderFrameForInterstitialPageCreated(render_frame_host);
[email protected]ba45bfd2012-05-22 21:51:443441}
3442
[email protected]20ca0382013-02-28 19:50:073443void WebContentsImpl::AttachInterstitialPage(
3444 InterstitialPageImpl* interstitial_page) {
creisadca9862017-06-16 19:12:113445 DCHECK(!interstitial_page_ && interstitial_page);
3446 interstitial_page_ = interstitial_page;
[email protected]90fb08ed2013-09-24 17:43:293447
3448 // Cancel any visible dialogs so that they don't interfere with the
3449 // interstitial.
creis89a0f782015-05-27 16:13:173450 CancelActiveAndPendingDialogs();
[email protected]90fb08ed2013-09-24 17:43:293451
ericwilligersde386342016-10-19 02:35:093452 for (auto& observer : observers_)
3453 observer.DidAttachInterstitialPage();
clamy44e84ce2016-02-22 15:38:253454
3455 // Stop the throbber if needed while the interstitial page is shown.
3456 if (frame_tree_.IsLoading())
3457 LoadingStateChanged(true, true, nullptr);
lfg1453e412017-04-11 00:48:503458
3459 // Connect to outer WebContents if necessary.
3460 if (node_.OuterContentsFrameTreeNode()) {
3461 if (GetRenderManager()->GetProxyToOuterDelegate()) {
3462 DCHECK(
3463 static_cast<RenderWidgetHostViewBase*>(interstitial_page->GetView())
3464 ->IsRenderWidgetHostViewChildFrame());
3465 RenderWidgetHostViewChildFrame* view =
3466 static_cast<RenderWidgetHostViewChildFrame*>(
3467 interstitial_page->GetView());
3468 GetRenderManager()->SetRWHViewForInnerContents(view);
3469 }
3470 }
Bo Liu7c6779e92017-08-16 02:02:283471
Bo Liu168c8642017-08-28 18:26:023472#if defined(OS_ANDROID)
Bo Liu7c6779e92017-08-16 02:02:283473 // Update importance of the interstitial.
3474 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
3475 ->GetRenderWidgetHost()
3476 ->SetImportance(GetMainFrame()->GetRenderWidgetHost()->importance());
Bo Liu168c8642017-08-28 18:26:023477#endif
Dominic Mazzoniefb5f9e32017-12-21 01:08:223478
3479 if (accessibility_mode_.has_mode(ui::AXMode::kNativeAPIs)) {
3480 // Make sure that the main page's accessibility tree is hidden and the
3481 // interstitial gets focus.
3482 RenderFrameHostImpl* rfh =
3483 static_cast<RenderFrameHostImpl*>(GetMainFrame());
3484 if (rfh) {
3485 BrowserAccessibilityManager* accessibility_manager =
3486 rfh->browser_accessibility_manager();
3487 if (accessibility_manager)
3488 accessibility_manager->set_hidden_by_interstitial_page(true);
3489 }
3490 rfh = static_cast<RenderFrameHostImpl*>(
3491 GetInterstitialPage()->GetMainFrame());
3492 if (rfh) {
3493 BrowserAccessibilityManager* accessibility_manager =
3494 rfh->GetOrCreateBrowserAccessibilityManager();
3495 if (accessibility_manager)
3496 accessibility_manager->OnWindowFocused();
3497 }
3498 }
clamy44e84ce2016-02-22 15:38:253499}
3500
3501void WebContentsImpl::DidProceedOnInterstitial() {
3502 // The interstitial page should no longer be pausing the throbber.
creisadca9862017-06-16 19:12:113503 DCHECK(!(ShowingInterstitialPage() && interstitial_page_->pause_throbber()));
clamy44e84ce2016-02-22 15:38:253504
3505 // Restart the throbber now that the interstitial page no longer pauses it.
3506 if (ShowingInterstitialPage() && frame_tree_.IsLoading())
3507 LoadingStateChanged(true, true, nullptr);
[email protected]20ca0382013-02-28 19:50:073508}
3509
Shivani Sharma985474f2019-05-23 21:36:473510bool WebContentsImpl::HadInnerWebContents() {
3511 return had_inner_webcontents_;
3512}
3513
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043514void WebContentsImpl::DetachInterstitialPage(bool has_focus) {
Lucas Furukawa Gadani69b609192017-07-10 17:08:343515 bool interstitial_pausing_throbber =
3516 ShowingInterstitialPage() && interstitial_page_->pause_throbber();
3517 if (ShowingInterstitialPage())
3518 interstitial_page_ = nullptr;
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043519
Dominic Mazzoniefb5f9e32017-12-21 01:08:223520 // Make sure that the main page's accessibility tree is no longer
3521 // suppressed.
3522 RenderFrameHostImpl* rfh = GetMainFrame();
3523 if (rfh) {
3524 BrowserAccessibilityManager* accessibility_manager =
3525 rfh->browser_accessibility_manager();
3526 if (accessibility_manager)
3527 accessibility_manager->set_hidden_by_interstitial_page(false);
3528 }
3529
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043530 // If the focus was on the interstitial, let's keep it to the page.
3531 // (Note that in unit-tests the RVH may not have a view).
3532 if (has_focus && GetRenderViewHost()->GetWidget()->GetView())
3533 GetRenderViewHost()->GetWidget()->GetView()->Focus();
3534
Lucas Furukawa Gadani69b609192017-07-10 17:08:343535 for (auto& observer : observers_)
3536 observer.DidDetachInterstitialPage();
3537
3538 // Disconnect from outer WebContents if necessary. This must happen after the
3539 // interstitial page is cleared above, since the call to
3540 // SetRWHViewForInnerContents below may loop over all the
3541 // RenderWidgetHostViews in the tree (otherwise, including the now-deleted
3542 // view for the interstitial).
lfg1453e412017-04-11 00:48:503543 if (node_.OuterContentsFrameTreeNode()) {
3544 if (GetRenderManager()->GetProxyToOuterDelegate()) {
3545 DCHECK(static_cast<RenderWidgetHostViewBase*>(
3546 GetRenderManager()->current_frame_host()->GetView())
3547 ->IsRenderWidgetHostViewChildFrame());
3548 RenderWidgetHostViewChildFrame* view =
3549 static_cast<RenderWidgetHostViewChildFrame*>(
3550 GetRenderManager()->current_frame_host()->GetView());
3551 GetRenderManager()->SetRWHViewForInnerContents(view);
3552 }
3553 }
3554
clamy44e84ce2016-02-22 15:38:253555 // Restart the throbber if needed now that the interstitial page is going
3556 // away.
3557 if (interstitial_pausing_throbber && frame_tree_.IsLoading())
3558 LoadingStateChanged(true, true, nullptr);
[email protected]20ca0382013-02-28 19:50:073559}
3560
avi2b177592014-12-10 02:08:023561void WebContentsImpl::SetHistoryOffsetAndLength(int history_offset,
3562 int history_length) {
alexmos136fd6e62016-08-15 20:58:413563 SendPageMessage(new PageMsg_SetHistoryOffsetAndLength(
3564 MSG_ROUTING_NONE, history_offset, history_length));
avi2b177592014-12-10 02:08:023565}
3566
3567void WebContentsImpl::SetHistoryOffsetAndLengthForView(
3568 RenderViewHost* render_view_host,
3569 int history_offset,
3570 int history_length) {
alexmos136fd6e62016-08-15 20:58:413571 render_view_host->Send(new PageMsg_SetHistoryOffsetAndLength(
avi2b177592014-12-10 02:08:023572 render_view_host->GetRoutingID(), history_offset, history_length));
[email protected]796931a92011-08-10 01:32:143573}
3574
toyoshim24a4c7ab2016-04-05 09:24:143575void WebContentsImpl::ReloadFocusedFrame(bool bypass_cache) {
[email protected]1f3fc1d2014-04-03 14:50:173576 RenderFrameHost* focused_frame = GetFocusedFrame();
3577 if (!focused_frame)
3578 return;
3579
[email protected]959be4c2014-04-08 15:01:333580 focused_frame->Send(new FrameMsg_Reload(
toyoshim24a4c7ab2016-04-05 09:24:143581 focused_frame->GetRoutingID(), bypass_cache));
[email protected]959be4c2014-04-08 15:01:333582}
3583
megjablon3f5941072016-02-04 23:27:523584void WebContentsImpl::ReloadLoFiImages() {
3585 SendToAllFrames(new FrameMsg_ReloadLoFiImages(MSG_ROUTING_NONE));
Robert Ogden34e97962018-09-14 23:50:273586 for (auto& observer : observers_)
3587 observer.DidReloadLoFiImages();
megjablon3f5941072016-02-04 23:27:523588}
3589
Ryan Sturmc65dbe42018-05-31 20:37:043590std::vector<blink::mojom::PauseSubresourceLoadingHandlePtr>
3591WebContentsImpl::PauseSubresourceLoading() {
3592 std::vector<blink::mojom::PauseSubresourceLoadingHandlePtr> handles;
3593 for (RenderFrameHost* rfh : GetAllFrames()) {
3594 if (!rfh->IsRenderFrameLive())
3595 continue;
3596 handles.push_back(rfh->PauseSubresourceLoading());
3597 }
3598 return handles;
3599}
3600
[email protected]959be4c2014-04-08 15:01:333601void WebContentsImpl::Undo() {
Dave Tapuskab336b922017-07-06 19:24:053602 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333603 if (!focused_frame)
3604 return;
3605
dtapuska9d46ef7d2017-05-26 19:06:063606 focused_frame->GetFrameInputHandler()->Undo();
[email protected]959be4c2014-04-08 15:01:333607 RecordAction(base::UserMetricsAction("Undo"));
3608}
3609
3610void WebContentsImpl::Redo() {
Dave Tapuskab336b922017-07-06 19:24:053611 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333612 if (!focused_frame)
3613 return;
dtapuska9d46ef7d2017-05-26 19:06:063614 focused_frame->GetFrameInputHandler()->Redo();
[email protected]959be4c2014-04-08 15:01:333615 RecordAction(base::UserMetricsAction("Redo"));
3616}
3617
3618void WebContentsImpl::Cut() {
Dave Tapuskab336b922017-07-06 19:24:053619 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333620 if (!focused_frame)
3621 return;
3622
dtapuska9d46ef7d2017-05-26 19:06:063623 focused_frame->GetFrameInputHandler()->Cut();
[email protected]959be4c2014-04-08 15:01:333624 RecordAction(base::UserMetricsAction("Cut"));
3625}
3626
3627void WebContentsImpl::Copy() {
Dave Tapuskab336b922017-07-06 19:24:053628 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333629 if (!focused_frame)
3630 return;
3631
dtapuska9d46ef7d2017-05-26 19:06:063632 focused_frame->GetFrameInputHandler()->Copy();
[email protected]959be4c2014-04-08 15:01:333633 RecordAction(base::UserMetricsAction("Copy"));
3634}
3635
3636void WebContentsImpl::CopyToFindPboard() {
3637#if defined(OS_MACOSX)
Dave Tapuskab336b922017-07-06 19:24:053638 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333639 if (!focused_frame)
3640 return;
3641
3642 // Windows/Linux don't have the concept of a find pasteboard.
dtapuska9d46ef7d2017-05-26 19:06:063643 focused_frame->GetFrameInputHandler()->CopyToFindPboard();
[email protected]959be4c2014-04-08 15:01:333644 RecordAction(base::UserMetricsAction("CopyToFindPboard"));
3645#endif
3646}
3647
3648void WebContentsImpl::Paste() {
Dave Tapuskab336b922017-07-06 19:24:053649 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333650 if (!focused_frame)
3651 return;
3652
dtapuska9d46ef7d2017-05-26 19:06:063653 focused_frame->GetFrameInputHandler()->Paste();
Archana Simhaf67090c2019-05-06 23:43:233654 for (auto& observer : observers_)
3655 observer.OnPaste();
[email protected]959be4c2014-04-08 15:01:333656 RecordAction(base::UserMetricsAction("Paste"));
3657}
3658
3659void WebContentsImpl::PasteAndMatchStyle() {
Dave Tapuskab336b922017-07-06 19:24:053660 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333661 if (!focused_frame)
3662 return;
3663
dtapuska9d46ef7d2017-05-26 19:06:063664 focused_frame->GetFrameInputHandler()->PasteAndMatchStyle();
Archana Simhaf67090c2019-05-06 23:43:233665 for (auto& observer : observers_)
3666 observer.OnPaste();
[email protected]959be4c2014-04-08 15:01:333667 RecordAction(base::UserMetricsAction("PasteAndMatchStyle"));
3668}
3669
3670void WebContentsImpl::Delete() {
Dave Tapuskab336b922017-07-06 19:24:053671 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333672 if (!focused_frame)
3673 return;
3674
dtapuska9d46ef7d2017-05-26 19:06:063675 focused_frame->GetFrameInputHandler()->Delete();
[email protected]959be4c2014-04-08 15:01:333676 RecordAction(base::UserMetricsAction("DeleteSelection"));
3677}
3678
3679void WebContentsImpl::SelectAll() {
Dave Tapuskab336b922017-07-06 19:24:053680 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333681 if (!focused_frame)
3682 return;
3683
dtapuska9d46ef7d2017-05-26 19:06:063684 focused_frame->GetFrameInputHandler()->SelectAll();
[email protected]959be4c2014-04-08 15:01:333685 RecordAction(base::UserMetricsAction("SelectAll"));
3686}
3687
yabinh351e7ec2017-03-10 02:43:243688void WebContentsImpl::CollapseSelection() {
Dave Tapuskab336b922017-07-06 19:24:053689 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333690 if (!focused_frame)
3691 return;
3692
dtapuska9d46ef7d2017-05-26 19:06:063693 focused_frame->GetFrameInputHandler()->CollapseSelection();
[email protected]1f3fc1d2014-04-03 14:50:173694}
3695
3696void WebContentsImpl::Replace(const base::string16& word) {
Dave Tapuskab336b922017-07-06 19:24:053697 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]1f3fc1d2014-04-03 14:50:173698 if (!focused_frame)
3699 return;
3700
dtapuska9d46ef7d2017-05-26 19:06:063701 focused_frame->GetFrameInputHandler()->Replace(word);
[email protected]1f3fc1d2014-04-03 14:50:173702}
3703
3704void WebContentsImpl::ReplaceMisspelling(const base::string16& word) {
Dave Tapuskab336b922017-07-06 19:24:053705 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]1f3fc1d2014-04-03 14:50:173706 if (!focused_frame)
3707 return;
3708
dtapuska9d46ef7d2017-05-26 19:06:063709 focused_frame->GetFrameInputHandler()->ReplaceMisspelling(word);
[email protected]959be4c2014-04-08 15:01:333710}
3711
3712void WebContentsImpl::NotifyContextMenuClosed(
3713 const CustomContextMenuContext& context) {
3714 RenderFrameHost* focused_frame = GetFocusedFrame();
3715 if (!focused_frame)
3716 return;
3717
3718 focused_frame->Send(new FrameMsg_ContextMenuClosed(
3719 focused_frame->GetRoutingID(), context));
3720}
3721
3722void WebContentsImpl::ExecuteCustomContextMenuCommand(
3723 int action, const CustomContextMenuContext& context) {
3724 RenderFrameHost* focused_frame = GetFocusedFrame();
3725 if (!focused_frame)
3726 return;
3727
3728 focused_frame->Send(new FrameMsg_CustomContextMenuAction(
3729 focused_frame->GetRoutingID(), context, action));
[email protected]4fed3702014-04-01 09:08:003730}
3731
[email protected]fc2b46b2014-05-03 16:33:453732gfx::NativeView WebContentsImpl::GetNativeView() {
3733 return view_->GetNativeView();
3734}
3735
3736gfx::NativeView WebContentsImpl::GetContentNativeView() {
3737 return view_->GetContentNativeView();
3738}
3739
3740gfx::NativeWindow WebContentsImpl::GetTopLevelNativeWindow() {
3741 return view_->GetTopLevelNativeWindow();
3742}
3743
3744gfx::Rect WebContentsImpl::GetViewBounds() {
3745 return view_->GetViewBounds();
3746}
3747
3748gfx::Rect WebContentsImpl::GetContainerBounds() {
3749 gfx::Rect rv;
3750 view_->GetContainerBounds(&rv);
3751 return rv;
3752}
3753
3754DropData* WebContentsImpl::GetDropData() {
3755 return view_->GetDropData();
3756}
3757
3758void WebContentsImpl::Focus() {
miu9e14e492014-10-25 02:39:043759 view_->Focus();
[email protected]fc2b46b2014-05-03 16:33:453760}
3761
3762void WebContentsImpl::SetInitialFocus() {
miu9e14e492014-10-25 02:39:043763 view_->SetInitialFocus();
[email protected]fc2b46b2014-05-03 16:33:453764}
3765
3766void WebContentsImpl::StoreFocus() {
miu9e14e492014-10-25 02:39:043767 view_->StoreFocus();
[email protected]fc2b46b2014-05-03 16:33:453768}
3769
3770void WebContentsImpl::RestoreFocus() {
miu9e14e492014-10-25 02:39:043771 view_->RestoreFocus();
[email protected]fc2b46b2014-05-03 16:33:453772}
3773
[email protected]b172aee2012-04-10 17:05:263774void WebContentsImpl::FocusThroughTabTraversal(bool reverse) {
Maxim Podgorodskiya926c4ff2017-11-20 02:06:393775 view_->FocusThroughTabTraversal(reverse);
[email protected]96d185d2009-04-24 03:28:543776}
3777
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:413778bool WebContentsImpl::ShowingInterstitialPage() {
creisadca9862017-06-16 19:12:113779 return interstitial_page_ != nullptr;
[email protected]96d185d2009-04-24 03:28:543780}
3781
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:413782InterstitialPageImpl* WebContentsImpl::GetInterstitialPage() {
creisadca9862017-06-16 19:12:113783 return interstitial_page_;
[email protected]686493142011-07-15 21:47:223784}
3785
[email protected]b172aee2012-04-10 17:05:263786bool WebContentsImpl::IsSavable() {
[email protected]a53209b2012-01-20 16:48:163787 // WebKit creates Document object when MIME type is application/xhtml+xml,
3788 // so we also support this MIME type.
3789 return contents_mime_type_ == "text/html" ||
3790 contents_mime_type_ == "text/xml" ||
3791 contents_mime_type_ == "application/xhtml+xml" ||
3792 contents_mime_type_ == "text/plain" ||
3793 contents_mime_type_ == "text/css" ||
Kinuko Yasuda74702f92017-07-31 03:27:533794 blink::IsSupportedJavascriptMimeType(contents_mime_type_);
[email protected]a53209b2012-01-20 16:48:163795}
3796
[email protected]b172aee2012-04-10 17:05:263797void WebContentsImpl::OnSavePage() {
[email protected]c7dd2f62011-07-18 15:57:593798 // If we can not save the page, try to download it.
[email protected]a53209b2012-01-20 16:48:163799 if (!IsSavable()) {
Min Qinda0ed2062018-02-23 22:00:533800 download::RecordSavePackageEvent(
3801 download::SAVE_PACKAGE_DOWNLOAD_ON_NON_HTML);
nasko89ad7742015-03-05 22:14:193802 SaveFrame(GetLastCommittedURL(), Referrer());
[email protected]27678b2a2012-02-04 22:09:143803 return;
[email protected]c7dd2f62011-07-18 15:57:593804 }
3805
3806 Stop();
3807
3808 // Create the save package and possibly prompt the user for the name to save
3809 // the page as. The user prompt is an asynchronous operation that runs on
3810 // another thread.
3811 save_package_ = new SavePackage(this);
3812 save_package_->GetSaveInfo();
3813}
3814
3815// Used in automated testing to bypass prompting the user for file names.
3816// Instead, the names and paths are hard coded rather than running them through
3817// file name sanitation and extension / mime checking.
[email protected]2dec8ec2013-02-07 19:20:343818bool WebContentsImpl::SavePage(const base::FilePath& main_file,
3819 const base::FilePath& dir_path,
[email protected]8ff00d72012-10-23 19:12:213820 SavePageType save_type) {
[email protected]c7dd2f62011-07-18 15:57:593821 // Stop the page from navigating.
3822 Stop();
3823
3824 save_package_ = new SavePackage(this, save_type, main_file, dir_path);
[email protected]8ff00d72012-10-23 19:12:213825 return save_package_->Init(SavePackageDownloadCreatedCallback());
[email protected]c7dd2f62011-07-18 15:57:593826}
3827
[email protected]3c71576ce2013-07-23 02:00:013828void WebContentsImpl::SaveFrame(const GURL& url,
3829 const Referrer& referrer) {
Xing Liu10329bf2018-03-20 19:22:143830 SaveFrameWithHeaders(url, referrer, std::string(), base::string16());
kundaji6c7f9692015-03-09 18:00:373831}
3832
Xing Liu10329bf2018-03-20 19:22:143833void WebContentsImpl::SaveFrameWithHeaders(
3834 const GURL& url,
3835 const Referrer& referrer,
3836 const std::string& headers,
3837 const base::string16& suggested_filename) {
Lei Zhang13a42e42019-02-19 23:28:113838 // Check and see if the guest can handle this.
3839 if (delegate_) {
3840 WebContents* guest_web_contents = nullptr;
3841 if (browser_plugin_embedder_) {
3842 BrowserPluginGuest* guest = browser_plugin_embedder_->GetFullPageGuest();
3843 if (guest)
3844 guest_web_contents = guest->GetWebContents();
3845 } else if (browser_plugin_guest_) {
3846 guest_web_contents = this;
3847 }
3848
3849 if (guest_web_contents && delegate_->GuestSaveFrame(guest_web_contents))
3850 return;
3851 }
3852
nasko89ad7742015-03-05 22:14:193853 if (!GetLastCommittedURL().is_valid())
[email protected]3c71576ce2013-07-23 02:00:013854 return;
sammc92af61552014-11-19 23:27:403855 if (delegate_ && delegate_->SaveFrame(url, referrer))
3856 return;
3857
nasko89ad7742015-03-05 22:14:193858 // TODO(nasko): This check for main frame is incorrect and should be fixed
brettw760f7442016-05-23 21:19:223859 // by explicitly passing in which frame this method should target. This would
3860 // indicate whether it's the main frame, and also tell us the frame pointer
3861 // to use for routing.
nasko89ad7742015-03-05 22:14:193862 bool is_main_frame = (url == GetLastCommittedURL());
brettw760f7442016-05-23 21:19:223863 RenderFrameHost* frame_host = GetMainFrame();
[email protected]3c71576ce2013-07-23 02:00:013864
avib7348942015-12-25 20:57:103865 int64_t post_id = -1;
[email protected]3c71576ce2013-07-23 02:00:013866 if (is_main_frame) {
Lucas Furukawa Gadani5553a152019-01-08 18:55:573867 NavigationEntry* entry = controller_.GetLastCommittedEntry();
[email protected]3c71576ce2013-07-23 02:00:013868 if (entry)
3869 post_id = entry->GetPostID();
3870 }
Ramin Halavati24e21012017-07-10 12:56:063871 net::NetworkTrafficAnnotationTag traffic_annotation =
3872 net::DefineNetworkTrafficAnnotation("download_web_contents_frame", R"(
3873 semantics {
3874 sender: "Save Page Action"
3875 description:
3876 "Saves the given frame's URL to the local file system."
3877 trigger:
3878 "The user has triggered a save operation on the frame through a "
3879 "context menu or other mechanism."
3880 data: "None."
3881 destination: WEBSITE
3882 }
3883 policy {
Ramin Halavati3b979782017-07-21 11:40:263884 cookies_allowed: YES
Ramin Halavati24e21012017-07-10 12:56:063885 cookies_store: "user"
3886 setting:
3887 "This feature cannot be disabled by settings, but it's is only "
3888 "triggered by user request."
3889 policy_exception_justification: "Not implemented."
3890 })");
Min Qina904f3302018-02-13 23:33:343891 auto params = std::make_unique<download::DownloadUrlParameters>(
brettw760f7442016-05-23 21:19:223892 url, frame_host->GetProcess()->GetID(),
3893 frame_host->GetRenderViewHost()->GetRoutingID(),
Matt Menke6d93c3c2018-10-10 15:21:503894 frame_host->GetRoutingID(), traffic_annotation);
Min Qina904f3302018-02-13 23:33:343895 params->set_referrer(referrer.url);
3896 params->set_referrer_policy(
3897 Referrer::ReferrerPolicyForUrlRequest(referrer.policy));
[email protected]3c71576ce2013-07-23 02:00:013898 params->set_post_id(post_id);
[email protected]3c71576ce2013-07-23 02:00:013899 if (post_id >= 0)
3900 params->set_method("POST");
3901 params->set_prompt(true);
kundaji6c7f9692015-03-09 18:00:373902
3903 if (headers.empty()) {
3904 params->set_prefer_cache(true);
3905 } else {
Min Qina904f3302018-02-13 23:33:343906 for (download::DownloadUrlParameters::RequestHeadersNameValuePair
3907 key_value : ParseDownloadHeaders(headers)) {
Megan Jablonski2f6a4c52017-07-10 23:01:253908 params->add_request_header(key_value.first, key_value.second);
kundaji6c7f9692015-03-09 18:00:373909 }
3910 }
Xing Liu10329bf2018-03-20 19:22:143911 params->set_suggested_name(suggested_filename);
Min Qin0ca8e1ee2018-01-31 00:49:353912 params->set_download_source(download::DownloadSource::WEB_CONTENTS_API);
thestig859c78892017-05-15 21:17:063913 BrowserContext::GetDownloadManager(GetBrowserContext())
Ramin Halavati03efa732017-06-12 09:28:203914 ->DownloadUrl(std::move(params));
[email protected]3c71576ce2013-07-23 02:00:013915}
3916
[email protected]b172aee2012-04-10 17:05:263917void WebContentsImpl::GenerateMHTML(
dewittj6dc5747a2016-05-17 01:48:473918 const MHTMLGenerationParams& params,
Avi Drissman149b7832018-03-23 14:31:493919 base::OnceCallback<void(int64_t)> callback) {
3920 MHTMLGenerationManager::GetInstance()->SaveMHTML(this, params,
3921 std::move(callback));
[email protected]aa4f3972012-03-01 18:12:123922}
3923
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:413924const std::string& WebContentsImpl::GetContentsMimeType() {
[email protected]0bfbf882011-12-22 18:19:273925 return contents_mime_type_;
3926}
3927
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:413928bool WebContentsImpl::WillNotifyDisconnection() {
[email protected]0bfbf882011-12-22 18:19:273929 return notify_disconnection_;
3930}
3931
Leon Hanc819dc62019-01-28 04:30:193932blink::mojom::RendererPreferences* WebContentsImpl::GetMutableRendererPrefs() {
[email protected]0bfbf882011-12-22 18:19:273933 return &renderer_preferences_;
3934}
3935
[email protected]e35ccd52012-05-23 16:22:473936void WebContentsImpl::Close() {
3937 Close(GetRenderViewHost());
3938}
3939
Ella Ge80a52dce2017-11-15 18:01:523940void WebContentsImpl::DragSourceEndedAt(float client_x,
3941 float client_y,
3942 float screen_x,
3943 float screen_y,
Paul Meyer0c58c3712016-11-17 22:59:513944 blink::WebDragOperation operation,
3945 RenderWidgetHost* source_rwh) {
Lei Zhang6410ec1a2019-01-31 21:38:583946 if (browser_plugin_embedder_) {
paulmeyer8fc8ea92016-11-15 05:12:213947 browser_plugin_embedder_->DragSourceEndedAt(
3948 client_x, client_y, screen_x, screen_y, operation);
Lei Zhang6410ec1a2019-01-31 21:38:583949 }
Paul Meyer0c58c3712016-11-17 22:59:513950 if (source_rwh) {
Ella Ge80a52dce2017-11-15 18:01:523951 source_rwh->DragSourceEndedAt(gfx::PointF(client_x, client_y),
3952 gfx::PointF(screen_x, screen_y), operation);
Paul Meyer0c58c3712016-11-17 22:59:513953 }
[email protected]cf200a562013-05-03 16:24:293954}
3955
jam73f892642016-09-11 06:04:063956void WebContentsImpl::LoadStateChanged(
Charles Harrison911fa062018-03-06 21:01:463957 const std::string& host,
jam73f892642016-09-11 06:04:063958 const net::LoadStateWithParam& load_state,
3959 uint64_t upload_position,
3960 uint64_t upload_size) {
Charles Harrison911fa062018-03-06 21:01:463961 base::string16 host16 = url_formatter::IDNToUnicode(host);
Elly Fong-Jonescad9c3d12018-01-31 17:26:103962 // Drop no-op updates.
3963 if (load_state_.state == load_state.state &&
3964 load_state_.param == load_state.param &&
3965 upload_position_ == upload_position && upload_size_ == upload_size &&
Charles Harrison911fa062018-03-06 21:01:463966 load_state_host_ == host16) {
Elly Fong-Jonescad9c3d12018-01-31 17:26:103967 return;
3968 }
jam73f892642016-09-11 06:04:063969 load_state_ = load_state;
3970 upload_position_ = upload_position;
3971 upload_size_ = upload_size;
Charles Harrison911fa062018-03-06 21:01:463972 load_state_host_ = host16;
jam73f892642016-09-11 06:04:063973 if (load_state_.state == net::LOAD_STATE_READING_RESPONSE)
3974 SetNotWaitingForResponse();
3975 if (IsLoading()) {
3976 NotifyNavigationStateChanged(static_cast<InvalidateTypes>(
3977 INVALIDATE_TYPE_LOAD | INVALIDATE_TYPE_TAB));
3978 }
3979}
3980
Francois Doraye6161152018-03-27 22:05:373981void WebContentsImpl::SetVisibility(Visibility visibility) {
3982 const Visibility previous_visibility = visibility_;
3983 visibility_ = visibility;
3984
Francois Dorayfe4a1772018-02-17 04:17:093985 // Notify observers if the visibility changed or if WasShown() is being called
3986 // for the first time.
Francois Dorayfe4a1772018-02-17 04:17:093987 if (visibility != previous_visibility ||
3988 (visibility == Visibility::VISIBLE && !did_first_set_visible_)) {
3989 for (auto& observer : observers_)
3990 observer.OnVisibilityChanged(visibility);
3991 }
3992}
3993
Michael Thiessen896405db2017-07-20 17:52:323994void WebContentsImpl::NotifyWebContentsFocused(
3995 RenderWidgetHost* render_widget_host) {
ericwilligersde386342016-10-19 02:35:093996 for (auto& observer : observers_)
Michael Thiessen896405db2017-07-20 17:52:323997 observer.OnWebContentsFocused(render_widget_host);
calamity7fe55ce2015-04-10 03:59:373998}
3999
Michael Thiessen896405db2017-07-20 17:52:324000void WebContentsImpl::NotifyWebContentsLostFocus(
4001 RenderWidgetHost* render_widget_host) {
zijiehe3bee08e22017-05-17 04:14:464002 for (auto& observer : observers_)
Michael Thiessen896405db2017-07-20 17:52:324003 observer.OnWebContentsLostFocus(render_widget_host);
zijiehe3bee08e22017-05-17 04:14:464004}
4005
Paul Meyer0c58c3712016-11-17 22:59:514006void WebContentsImpl::SystemDragEnded(RenderWidgetHost* source_rwh) {
4007 if (source_rwh)
4008 source_rwh->DragSourceSystemDragEnded();
Lei Zhang6410ec1a2019-01-31 21:38:584009 if (browser_plugin_embedder_)
[email protected]cf200a562013-05-03 16:24:294010 browser_plugin_embedder_->SystemDragEnded();
[email protected]7813bd72011-02-05 02:19:344011}
4012
Daniel Cheng90196c82018-04-25 21:49:144013void WebContentsImpl::NavigatedByUser() {
Dominick Ng37a15052018-07-17 23:56:354014 SendUserGestureForResourceDispatchHost();
[email protected]e35ccd52012-05-23 16:22:474015}
4016
[email protected]b172aee2012-04-10 17:05:264017void WebContentsImpl::SetClosedByUserGesture(bool value) {
[email protected]0bfbf882011-12-22 18:19:274018 closed_by_user_gesture_ = value;
4019}
4020
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414021bool WebContentsImpl::GetClosedByUserGesture() {
[email protected]0bfbf882011-12-22 18:19:274022 return closed_by_user_gesture_;
4023}
4024
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414025int WebContentsImpl::GetMinimumZoomPercent() {
[email protected]0bfbf882011-12-22 18:19:274026 return minimum_zoom_percent_;
4027}
4028
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414029int WebContentsImpl::GetMaximumZoomPercent() {
[email protected]0bfbf882011-12-22 18:19:274030 return maximum_zoom_percent_;
4031}
4032
mcnee432e47d2015-11-09 19:37:464033void WebContentsImpl::SetPageScale(float page_scale_factor) {
Lukasz Anforowiczf4357ca2017-09-07 01:43:324034 GetRenderViewHost()->Send(new ViewMsg_SetPageScale(
4035 GetRenderViewHost()->GetRoutingID(), page_scale_factor));
ccameronb7c1d6c2015-03-09 17:08:244036}
4037
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414038gfx::Size WebContentsImpl::GetPreferredSize() {
Francois Doray24fc62c2017-12-11 17:27:334039 return IsBeingCaptured() ? preferred_size_for_capture_ : preferred_size_;
[email protected]bcd2815602012-01-14 18:17:234040}
4041
[email protected]b172aee2012-04-10 17:05:264042bool WebContentsImpl::GotResponseToLockMouseRequest(bool allowed) {
lfgf0cd46e2017-01-04 00:05:234043 if (!GuestMode::IsCrossProcessFrameGuest(GetWebContents()) &&
4044 GetBrowserPluginGuest())
[email protected]660f18e2014-05-15 20:53:054045 return GetBrowserPluginGuest()->LockMouse(allowed);
4046
lfgf0cd46e2017-01-04 00:05:234047 if (mouse_lock_widget_) {
4048 if (mouse_lock_widget_->delegate()->GetAsWebContents() != this) {
4049 return mouse_lock_widget_->delegate()
4050 ->GetAsWebContents()
4051 ->GotResponseToLockMouseRequest(allowed);
4052 }
lfgad8244352016-07-13 16:55:514053
lfgf0cd46e2017-01-04 00:05:234054 if (mouse_lock_widget_->GotResponseToLockMouseRequest(allowed))
4055 return true;
4056 }
4057
4058 for (WebContentsImpl* current = this; current;
4059 current = current->GetOuterWebContents()) {
4060 current->mouse_lock_widget_ = nullptr;
4061 }
4062
lfgbee1e0a2016-06-08 21:24:214063 return false;
[email protected]0bfbf882011-12-22 18:19:274064}
4065
Joe Downing13dd76b2018-04-09 18:32:154066bool WebContentsImpl::GotResponseToKeyboardLockRequest(bool allowed) {
4067 if (!keyboard_lock_widget_)
4068 return false;
4069
4070 if (keyboard_lock_widget_->delegate()->GetAsWebContents() != this) {
4071 NOTREACHED();
4072 return false;
4073 }
4074
4075 // KeyboardLock is only supported when called by the top-level browsing
4076 // context and is not supported in embedded content scenarios.
4077 if (GetOuterWebContents())
4078 return false;
4079
4080 keyboard_lock_widget_->GotResponseToKeyboardLockRequest(allowed);
4081 return true;
4082}
4083
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414084bool WebContentsImpl::HasOpener() {
Ivan Kotenkov2c0d2bb32017-11-01 15:41:284085 return GetOpener() != nullptr;
[email protected]a0358d72012-03-09 14:06:504086}
4087
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414088RenderFrameHostImpl* WebContentsImpl::GetOpener() {
alexmose201c7cd2015-06-10 17:14:214089 FrameTreeNode* opener_ftn = frame_tree_.root()->opener();
lukasza6f8ac622017-06-06 03:10:204090 return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
jochen55ff3502014-12-18 20:52:574091}
4092
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414093bool WebContentsImpl::HasOriginalOpener() {
Ivan Kotenkov2c0d2bb32017-11-01 15:41:284094 return GetOriginalOpener() != nullptr;
jochen6004a362017-02-04 00:11:404095}
4096
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:414097RenderFrameHostImpl* WebContentsImpl::GetOriginalOpener() {
jochen6004a362017-02-04 00:11:404098 FrameTreeNode* opener_ftn = frame_tree_.root()->original_opener();
lukasza6f8ac622017-06-06 03:10:204099 return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
jochen6004a362017-02-04 00:11:404100}
4101
[email protected]cb805452013-05-22 15:16:214102void WebContentsImpl::DidChooseColorInColorChooser(SkColor color) {
Joel Hockey85b379d2017-12-11 10:42:134103 color_chooser_->DidChooseColorInColorChooser(color);
[email protected]da8543762012-03-20 08:52:204104}
4105
[email protected]cb805452013-05-22 15:16:214106void WebContentsImpl::DidEndColorChooser() {
Joel Hockey85b379d2017-12-11 10:42:134107 color_chooser_.reset();
[email protected]da8543762012-03-20 08:52:204108}
4109
halton.huoca2eabd2015-07-06 08:17:404110int WebContentsImpl::DownloadImage(
4111 const GURL& url,
4112 bool is_favicon,
4113 uint32_t max_bitmap_size,
4114 bool bypass_cache,
Avi Drissmana5a52dd2018-03-27 03:39:024115 WebContents::ImageDownloadCallback callback) {
amistry9f01b772015-07-29 01:54:554116 DCHECK_CURRENTLY_ON(BrowserThread::UI);
halton.huoca2eabd2015-07-06 08:17:404117 static int next_image_download_id = 0;
leon.han6e9dee22016-02-25 03:44:064118 const content::mojom::ImageDownloaderPtr& mojo_image_downloader =
halton.huoca2eabd2015-07-06 08:17:404119 GetMainFrame()->GetMojoImageDownloader();
amistry9f01b772015-07-29 01:54:554120 const int download_id = ++next_image_download_id;
4121 if (!mojo_image_downloader) {
4122 // If the renderer process is dead (i.e. crash, or memory pressure on
4123 // Android), the downloader service will be invalid. Pre-Mojo, this would
Avi Drissmana5a52dd2018-03-27 03:39:024124 // hang the callback indefinitely since the IPC would be dropped. Now,
amistry9f01b772015-07-29 01:54:554125 // respond with a 400 HTTP error code to indicate that something went wrong.
Eric Seckler8652dcd52018-09-20 10:42:284126 base::PostTaskWithTraits(
4127 FROM_HERE, {BrowserThread::UI},
tzike2aca992017-09-05 08:50:544128 base::BindOnce(&WebContentsImpl::OnDidDownloadImage,
Avi Drissmana5a52dd2018-03-27 03:39:024129 weak_factory_.GetWeakPtr(), std::move(callback),
4130 download_id, url, 400, std::vector<SkBitmap>(),
4131 std::vector<gfx::Size>()));
amistry9f01b772015-07-29 01:54:554132 return download_id;
4133 }
4134
halton.huoca2eabd2015-07-06 08:17:404135 mojo_image_downloader->DownloadImage(
sammcf6f4fcf2016-06-21 05:39:394136 url, is_favicon, max_bitmap_size, bypass_cache,
tzike2aca992017-09-05 08:50:544137 base::BindOnce(&WebContentsImpl::OnDidDownloadImage,
Avi Drissmana5a52dd2018-03-27 03:39:024138 weak_factory_.GetWeakPtr(), std::move(callback),
4139 download_id, url));
amistry9f01b772015-07-29 01:54:554140 return download_id;
[email protected]795c28972012-12-06 06:13:394141}
4142
[email protected]36ec24f2014-01-09 00:32:084143void WebContentsImpl::Find(int request_id,
4144 const base::string16& search_text,
Rakina Zata Amni3f77dff2018-09-08 16:19:434145 blink::mojom::FindOptionsPtr options) {
thestig6057a6b22015-11-12 23:01:334146 // Cowardly refuse to search for no text.
4147 if (search_text.empty()) {
4148 NOTREACHED();
4149 return;
4150 }
4151
Rakina Zata Amni3f77dff2018-09-08 16:19:434152 GetOrCreateFindRequestManager()->Find(request_id, search_text,
4153 std::move(options));
[email protected]36ec24f2014-01-09 00:32:084154}
4155
4156void WebContentsImpl::StopFinding(StopFindAction action) {
paulmeyerfeafc2d2017-04-25 21:46:404157 if (FindRequestManager* manager = GetFindRequestManager())
4158 manager->StopFinding(action);
[email protected]36ec24f2014-01-09 00:32:084159}
4160
Tommy Steimel18360512017-11-01 00:38:194161bool WebContentsImpl::WasEverAudible() {
4162 return was_ever_audible_;
4163}
4164
Avi Drissmana5a52dd2018-03-27 03:39:024165void WebContentsImpl::GetManifest(GetManifestCallback callback) {
4166 manifest_manager_host_->GetManifest(std::move(callback));
mlamouriefdca9d2014-09-16 16:55:404167}
4168
bokanece34a82016-01-28 19:49:464169void WebContentsImpl::ExitFullscreen(bool will_cause_resize) {
mlamouri7a78d6fd2015-01-17 13:23:534170 // Clean up related state and initiate the fullscreen exit.
avi3627ecac2015-10-16 17:40:434171 GetRenderViewHost()->GetWidget()->RejectMouseLockOrUnlockIfNecessary();
bokanece34a82016-01-28 19:49:464172 ExitFullscreenMode(will_cause_resize);
mlamouri7a78d6fd2015-01-17 13:23:534173}
4174
mariakhomenko44bdc4732015-04-29 01:55:384175void WebContentsImpl::ResumeLoadingCreatedWebContents() {
Nasko Oskov83a8cf92018-10-19 14:58:564176 if (delayed_load_url_params_.get()) {
4177 DCHECK(!delayed_open_url_params_);
4178 controller_.LoadURLWithParams(*delayed_load_url_params_.get());
4179 delayed_load_url_params_.reset(nullptr);
4180 return;
4181 }
4182
mariakhomenkoa4971c12015-07-21 19:04:374183 if (delayed_open_url_params_.get()) {
4184 OpenURL(*delayed_open_url_params_.get());
4185 delayed_open_url_params_.reset(nullptr);
4186 return;
4187 }
4188
mariakhomenko44bdc4732015-04-29 01:55:384189 // Resume blocked requests for both the RenderViewHost and RenderFrameHost.
4190 // TODO(brettw): It seems bogus to reach into here and initialize the host.
dfalcantarae6b7b46752015-07-10 18:14:164191 if (is_resume_pending_) {
4192 is_resume_pending_ = false;
avi0f1bbc9712015-11-17 02:58:134193 GetRenderViewHost()->GetWidget()->Init();
dfalcantarae6b7b46752015-07-10 18:14:164194 GetMainFrame()->Init();
4195 }
mariakhomenko44bdc4732015-04-29 01:55:384196}
4197
[email protected]b172aee2012-04-10 17:05:264198bool WebContentsImpl::FocusLocationBarByDefault() {
Xiyuan Xia2a66b112018-12-06 15:52:164199 if (should_focus_location_bar_by_default_)
[email protected]0c9406632013-02-08 01:13:334200 return true;
Xiyuan Xia2a66b112018-12-06 15:52:164201
[email protected]0c9406632013-02-08 01:13:334202 return delegate_ && delegate_->ShouldFocusLocationBarByDefault(this);
[email protected]0bfbf882011-12-22 18:19:274203}
4204
Tommy C. Li8bb5bf42019-01-18 18:45:514205void WebContentsImpl::SetFocusToLocationBar() {
[email protected]0bfbf882011-12-22 18:19:274206 if (delegate_)
Tommy C. Li8bb5bf42019-01-18 18:45:514207 delegate_->SetFocusToLocationBar();
[email protected]c40d6232011-03-25 00:16:214208}
4209
clamy0e119882015-07-31 16:12:334210void WebContentsImpl::DidStartNavigation(NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484211 TRACE_EVENT1("navigation", "WebContentsImpl::DidStartNavigation",
4212 "navigation_handle", navigation_handle);
ericwilligersde386342016-10-19 02:35:094213 for (auto& observer : observers_)
4214 observer.DidStartNavigation(navigation_handle);
Becca Hughesd11d6502018-07-31 17:01:284215
4216 if (display_cutout_host_impl_)
4217 display_cutout_host_impl_->DidStartNavigation(navigation_handle);
Xiyuan Xia2a66b112018-12-06 15:52:164218
4219 if (navigation_handle->IsInMainFrame()) {
4220 // When the browser is started with about:blank as the startup URL, focus
4221 // the location bar (which will also select its contents) so people can
4222 // simply begin typing to navigate elsewhere.
4223 //
4224 // We need to be careful not to trigger this for anything other than the
4225 // startup navigation. In particular, if we allow an attacker to open a
4226 // popup to about:blank, then navigate, focusing the Omnibox will cause the
4227 // end of the new URL to be scrolled into view instead of the start,
4228 // allowing the attacker to spoof other URLs. The conditions checked here
4229 // are all aimed at ensuring no such attacker-controlled navigation can
4230 // trigger this.
4231 should_focus_location_bar_by_default_ =
4232 controller_.IsInitialNavigation() &&
4233 !navigation_handle->IsRendererInitiated() &&
4234 navigation_handle->GetURL() == url::kAboutBlankURL;
4235 }
clamy0e119882015-07-31 16:12:334236}
4237
4238void WebContentsImpl::DidRedirectNavigation(
4239 NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484240 TRACE_EVENT1("navigation", "WebContentsImpl::DidRedirectNavigation",
4241 "navigation_handle", navigation_handle);
ericwilligersde386342016-10-19 02:35:094242 for (auto& observer : observers_)
4243 observer.DidRedirectNavigation(navigation_handle);
jam5f358e52017-02-13 16:37:034244
4245 // Notify accessibility if this is a reload. This has to called on the
4246 // BrowserAccessibilityManager associated with the old RFHI.
4247 if (navigation_handle->GetReloadType() != ReloadType::NONE) {
4248 NavigationHandleImpl* nhi =
4249 static_cast<NavigationHandleImpl*>(navigation_handle);
4250 BrowserAccessibilityManager* manager =
4251 nhi->frame_tree_node()
4252 ->current_frame_host()
4253 ->browser_accessibility_manager();
4254 if (manager)
4255 manager->UserIsReloading();
4256 }
clamy0e119882015-07-31 16:12:334257}
4258
clamyefca29e2015-09-17 00:22:114259void WebContentsImpl::ReadyToCommitNavigation(
4260 NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484261 TRACE_EVENT1("navigation", "WebContentsImpl::ReadyToCommitNavigation",
4262 "navigation_handle", navigation_handle);
ericwilligersde386342016-10-19 02:35:094263 for (auto& observer : observers_)
4264 observer.ReadyToCommitNavigation(navigation_handle);
John Abd-El-Malekd4882642017-12-04 21:45:194265
Kenneth Russell954ed9ce2018-04-12 23:07:014266 // If any domains are blocked from accessing 3D APIs because they may
4267 // have caused the GPU to reset recently, unblock them here if the user
4268 // initiated this navigation. This implies that the user was involved in
4269 // the decision to navigate, so there's no concern about
4270 // denial-of-service issues. Want to do this as early as
4271 // possible to avoid race conditions with pages attempting to access
4272 // WebGL early on.
4273 //
4274 // TODO(crbug.com/617904): currently navigations initiated by the browser
4275 // (reload button, reload menu option, pressing return in the Omnibox)
4276 // return false from HasUserGesture(). If or when that is addressed,
4277 // remove the check for IsRendererInitiated() below.
4278 //
4279 // TODO(crbug.com/832180): HasUserGesture comes from the renderer
4280 // process and isn't validated. Until it is, don't trust it.
4281 if (!navigation_handle->IsRendererInitiated()) {
4282 GpuDataManagerImpl::GetInstance()->UnblockDomainFrom3DAPIs(
4283 navigation_handle->GetURL());
4284 }
4285
John Abd-El-Malekfde08e6da2017-12-05 04:06:244286 if (navigation_handle->IsSameDocument())
4287 return;
4288
Livvie Lin139bf442018-08-10 00:18:544289 // SSLInfo is not needed on subframe navigations since the main-frame
4290 // certificate is the only one that can be inspected (using the info
4291 // bubble) without refreshing the page with DevTools open.
Carlos ILaed1e7b2019-03-12 19:27:214292 // We don't call DidStartResourceResponse on net errors, since that results on
4293 // existing cert exceptions being revoked, which leads to weird behavior with
4294 // committed interstitials or while offline. We only need the error check for
4295 // the main frame case because unlike this method, SubresourceResponseStarted
4296 // does not get called on network errors.
4297 if (navigation_handle->IsInMainFrame() &&
4298 navigation_handle->GetNetErrorCode() == net::OK) {
Livvie Lin139bf442018-08-10 00:18:544299 controller_.ssl_manager()->DidStartResourceResponse(
4300 navigation_handle->GetURL(),
Camille Lamy62b826012019-02-26 09:15:474301 navigation_handle->GetSSLInfo().has_value()
4302 ? net::IsCertStatusError(
4303 navigation_handle->GetSSLInfo()->cert_status)
4304 : false);
4305 }
John Abd-El-Malekfde08e6da2017-12-05 04:06:244306
4307 SetNotWaitingForResponse();
clamyefca29e2015-09-17 00:22:114308}
4309
clamy0e119882015-07-31 16:12:334310void WebContentsImpl::DidFinishNavigation(NavigationHandle* navigation_handle) {
Charles Harrison53096ba2017-12-15 15:39:484311 TRACE_EVENT1("navigation", "WebContentsImpl::DidFinishNavigation",
4312 "navigation_handle", navigation_handle);
Steven Holte38041342018-06-22 22:00:574313
ericwilligersde386342016-10-19 02:35:094314 for (auto& observer : observers_)
4315 observer.DidFinishNavigation(navigation_handle);
clamy0e119882015-07-31 16:12:334316
Becca Hughesd11d6502018-07-31 17:01:284317 if (display_cutout_host_impl_)
4318 display_cutout_host_impl_->DidFinishNavigation(navigation_handle);
4319
jam5f358e52017-02-13 16:37:034320 if (navigation_handle->HasCommitted()) {
dmazzonibf8cec42015-02-08 08:28:084321 BrowserAccessibilityManager* manager =
jam5f358e52017-02-13 16:37:034322 static_cast<RenderFrameHostImpl*>(
4323 navigation_handle->GetRenderFrameHost())
4324 ->browser_accessibility_manager();
4325 if (manager) {
4326 if (navigation_handle->IsErrorPage()) {
4327 manager->NavigationFailed();
4328 } else {
4329 manager->NavigationSucceeded();
4330 }
4331 }
Tommy Steimel18360512017-11-01 00:38:194332
4333 if (navigation_handle->IsInMainFrame() &&
4334 !navigation_handle->IsSameDocument()) {
4335 was_ever_audible_ = false;
Steven Holte38041342018-06-22 22:00:574336 last_committed_source_id_ =
4337 ukm::ConvertToSourceId(navigation_handle->GetNavigationId(),
4338 ukm::SourceIdType::NAVIGATION_ID);
Tommy Steimel18360512017-11-01 00:38:194339 }
dmazzonibf8cec42015-02-08 08:28:084340 }
Xiyuan Xia2a66b112018-12-06 15:52:164341
4342 // If we didn't end up on about:blank after setting this in DidStartNavigation
4343 // then don't focus the location bar.
4344 if (should_focus_location_bar_by_default_ &&
4345 navigation_handle->GetURL() != url::kAboutBlankURL) {
4346 should_focus_location_bar_by_default_ = false;
4347 }
[email protected]400992b2012-06-14 00:03:544348}
4349
[email protected]b80624c2014-02-09 02:46:554350void WebContentsImpl::DidFailLoadWithError(
4351 RenderFrameHostImpl* render_frame_host,
[email protected]b80624c2014-02-09 02:46:554352 const GURL& url,
[email protected]b80624c2014-02-09 02:46:554353 int error_code,
Yutaka Hirano16d3c5d2017-07-31 06:17:304354 const base::string16& error_description) {
ericwilligersde386342016-10-19 02:35:094355 for (auto& observer : observers_) {
Yutaka Hirano16d3c5d2017-07-31 06:17:304356 observer.DidFailLoad(render_frame_host, url, error_code, error_description);
ericwilligersde386342016-10-19 02:35:094357 }
[email protected]b80624c2014-02-09 02:46:554358}
4359
[email protected]52913802013-12-10 05:52:184360void WebContentsImpl::NotifyChangedNavigationState(
4361 InvalidateTypes changed_flags) {
4362 NotifyNavigationStateChanged(changed_flags);
4363}
4364
toyoshim0df1d3a2016-09-09 09:52:484365void WebContentsImpl::DidStartNavigationToPendingEntry(const GURL& url,
4366 ReloadType reload_type) {
[email protected]3691e5cf2014-01-22 10:16:204367 // Notify observers about navigation.
ericwilligersde386342016-10-19 02:35:094368 for (auto& observer : observers_)
4369 observer.DidStartNavigationToPendingEntry(url, reload_type);
[email protected]3691e5cf2014-01-22 10:16:204370}
4371
lukasza1d025732016-09-28 21:36:084372bool WebContentsImpl::ShouldTransferNavigation(bool is_main_frame_navigation) {
creis29460272015-12-16 04:38:224373 if (!delegate_)
4374 return true;
lukasza1d025732016-09-28 21:36:084375 return delegate_->ShouldTransferNavigation(is_main_frame_navigation);
creis29460272015-12-16 04:38:224376}
4377
[email protected]aa62afd2014-04-22 19:22:464378bool WebContentsImpl::ShouldPreserveAbortedURLs() {
4379 if (!delegate_)
4380 return false;
4381 return delegate_->ShouldPreserveAbortedURLs(this);
4382}
4383
[email protected]0d0f4c492014-04-02 06:42:574384void WebContentsImpl::DidNavigateMainFramePreCommit(
[email protected]5cfbddc2014-06-23 23:52:234385 bool navigation_is_within_page) {
[email protected]0d0f4c492014-04-02 06:42:574386 // Ensure fullscreen mode is exited before committing the navigation to a
4387 // different page. The next page will not start out assuming it is in
4388 // fullscreen mode.
[email protected]5cfbddc2014-06-23 23:52:234389 if (navigation_is_within_page) {
[email protected]dfc39cb2014-04-09 22:58:194390 // No page change? Then, the renderer and browser can remain in fullscreen.
[email protected]0d0f4c492014-04-02 06:42:574391 return;
4392 }
alexmos5dd617d2016-06-07 04:21:154393 if (IsFullscreenForCurrentTab())
bokanece34a82016-01-28 19:49:464394 ExitFullscreen(false);
alexmos5dd617d2016-06-07 04:21:154395 DCHECK(!IsFullscreenForCurrentTab());
Joe Downingc1a57efe2018-05-09 18:23:544396
4397 // Clean up keyboard lock state when navigating.
4398 CancelKeyboardLock(keyboard_lock_widget_);
[email protected]0d0f4c492014-04-02 06:42:574399}
4400
[email protected]37567b432014-02-12 01:12:224401void WebContentsImpl::DidNavigateMainFramePostCommit(
sky8b00392d2015-01-10 00:30:284402 RenderFrameHostImpl* render_frame_host,
[email protected]37567b432014-02-12 01:12:224403 const LoadCommittedDetails& details,
4404 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
4405 if (details.is_navigation_to_different_page()) {
4406 // Clear the status bubble. This is a workaround for a bug where WebKit
4407 // doesn't let us know that the cursor left an element during a
4408 // transition (this is also why the mouse cursor remains as a hand after
4409 // clicking on a link); see bugs 1184641 and 980803. We don't want to
4410 // clear the bubble when a user navigates to a named anchor in the same
4411 // page.
Lukasz Anforowiczfd707142018-02-07 19:46:134412 ClearTargetURL();
lanwei9d343ad22015-02-11 01:46:004413
4414 RenderWidgetHostViewBase* rwhvb =
4415 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
4416 if (rwhvb)
4417 rwhvb->OnDidNavigateMainFrameToNewPage();
yusufod41c5f92015-03-06 00:14:284418
peter90afaba2015-06-01 12:05:294419 did_first_visually_non_empty_paint_ = false;
4420
yusufod41c5f92015-03-06 00:14:284421 // Reset theme color on navigation to new page.
Alan Cutter92d59252019-03-29 02:32:334422 theme_color_.reset();
[email protected]37567b432014-02-12 01:12:224423 }
4424
[email protected]e85165c642014-06-10 14:34:314425 if (delegate_)
[email protected]37567b432014-02-12 01:12:224426 delegate_->DidNavigateMainFramePostCommit(this);
[email protected]e85165c642014-06-10 14:34:314427 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
Shivani Sharma985474f2019-05-23 21:36:474428
4429 if (!details.is_same_document && GetInnerWebContents().empty())
4430 had_inner_webcontents_ = false;
[email protected]37567b432014-02-12 01:12:224431}
4432
4433void WebContentsImpl::DidNavigateAnyFramePostCommit(
4434 RenderFrameHostImpl* render_frame_host,
4435 const LoadCommittedDetails& details,
4436 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
[email protected]b4c84012014-04-28 19:51:104437 // Now that something has committed, we don't need to track whether the
4438 // initial page has been accessed.
4439 has_accessed_initial_document_ = false;
4440
[email protected]37567b432014-02-12 01:12:224441 // If we navigate off the page, close all JavaScript dialogs.
eugenebutee08663a2017-04-27 17:43:124442 if (!details.is_same_document)
creis89a0f782015-05-27 16:13:174443 CancelActiveAndPendingDialogs();
[email protected]37567b432014-02-12 01:12:224444
avid53461d2016-02-25 17:15:044445 // If this is a user-initiated navigation, start allowing JavaScript dialogs
4446 // again.
avi5d3b8692016-10-12 22:00:464447 if (params.gesture == NavigationGestureUser && dialog_manager_) {
avi6879fcf2017-01-21 05:27:534448 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:464449 }
[email protected]37567b432014-02-12 01:12:224450}
4451
4452void WebContentsImpl::SetMainFrameMimeType(const std::string& mime_type) {
4453 contents_mime_type_ = mime_type;
4454}
4455
[email protected]277857a2014-06-03 10:38:014456bool WebContentsImpl::CanOverscrollContent() const {
[email protected]e85165c642014-06-10 14:34:314457 // Disable overscroll when touch emulation is on. See crbug.com/369938.
[email protected]34ff1cfc2014-08-20 06:16:054458 if (force_disable_overscroll_content_)
[email protected]e85165c642014-06-10 14:34:314459 return false;
4460
[email protected]37567b432014-02-12 01:12:224461 if (delegate_)
4462 return delegate_->CanOverscrollContent();
4463
4464 return false;
4465}
4466
nicka0ac8382016-12-15 23:59:234467void WebContentsImpl::OnThemeColorChanged(RenderFrameHostImpl* source,
Alan Cutter92d59252019-03-29 02:32:334468 base::Optional<SkColor> theme_color) {
nicka0ac8382016-12-15 23:59:234469 if (source != GetMainFrame()) {
4470 // Only the main frame may control the theme.
4471 return;
4472 }
4473
peter90afaba2015-06-01 12:05:294474 // Update the theme color. This is to be published to observers after the
4475 // first visually non-empty paint.
yusufod41c5f92015-03-06 00:14:284476 theme_color_ = theme_color;
peter90afaba2015-06-01 12:05:294477
4478 if (did_first_visually_non_empty_paint_ &&
4479 last_sent_theme_color_ != theme_color_) {
ericwilligersde386342016-10-19 02:35:094480 for (auto& observer : observers_)
4481 observer.DidChangeThemeColor(theme_color_);
peter90afaba2015-06-01 12:05:294482 last_sent_theme_color_ = theme_color_;
4483 }
[email protected]e7104762014-06-20 19:17:254484}
4485
[email protected]b172aee2012-04-10 17:05:264486void WebContentsImpl::OnDidLoadResourceFromMemoryCache(
nicka0ac8382016-12-15 23:59:234487 RenderFrameHostImpl* source,
[email protected]724159a2010-12-30 01:11:184488 const GURL& url,
[email protected]70435962011-08-02 20:13:284489 const std::string& http_method,
[email protected]6d6cfb3a2012-05-23 22:53:184490 const std::string& mime_type,
Maks Orlovich158ea092018-12-17 22:16:124491 const base::Optional<url::Origin>& top_frame_origin,
[email protected]6c1e05212014-07-31 00:59:404492 ResourceType resource_type) {
ericwilligersde386342016-10-19 02:35:094493 for (auto& observer : observers_)
4494 observer.DidLoadResourceFromMemoryCache(url, mime_type, resource_type);
[email protected]b0f724c2013-09-05 04:21:134495
Steven Bingler674fb0822018-12-12 18:04:524496 if (url.is_valid() && url.SchemeIsHTTPOrHTTPS()) {
nicka0ac8382016-12-15 23:59:234497 StoragePartition* partition = source->GetProcess()->GetStoragePartition();
Steven Bingler674fb0822018-12-12 18:04:524498
4499 // We require different paths here because there is no NetworkContext
4500 // for media cache.
4501 if (base::FeatureList::IsEnabled(network::features::kNetworkService)) {
Maks Orlovich158ea092018-12-17 22:16:124502 partition->GetNetworkContext()->NotifyExternalCacheHit(url, http_method,
4503 top_frame_origin);
Steven Bingler674fb0822018-12-12 18:04:524504 } else {
4505 scoped_refptr<net::URLRequestContextGetter> request_context(
Daniel Chengaee5c0312019-04-18 23:49:054506 resource_type == ResourceType::kMedia
Steven Bingler674fb0822018-12-12 18:04:524507 ? partition->GetMediaURLRequestContext()
4508 : partition->GetURLRequestContext());
4509 base::PostTaskWithTraits(
4510 FROM_HERE, {BrowserThread::IO},
Maks Orlovich158ea092018-12-17 22:16:124511 base::BindOnce(&NotifyCacheOnIO, request_context, url, http_method,
4512 top_frame_origin));
Steven Bingler674fb0822018-12-12 18:04:524513 }
[email protected]8bfc8272013-09-09 20:10:534514 }
[email protected]724159a2010-12-30 01:11:184515}
4516
nicka0ac8382016-12-15 23:59:234517void WebContentsImpl::OnDidDisplayInsecureContent(RenderFrameHostImpl* source) {
4518 // Any frame can trigger display of insecure content, so we don't check
4519 // |source| here.
carloskd9d97942017-02-16 08:58:094520 DidDisplayInsecureContent();
4521}
4522
4523void WebContentsImpl::DidDisplayInsecureContent() {
estarkc2273502016-10-12 22:03:024524 controller_.ssl_manager()->DidDisplayMixedContent();
[email protected]724159a2010-12-30 01:11:184525}
4526
elawrenceb2ac2a232017-03-27 21:46:254527void WebContentsImpl::OnDidContainInsecureFormAction(
4528 RenderFrameHostImpl* source) {
4529 controller_.ssl_manager()->DidContainInsecureFormAction();
4530}
4531
nicka0ac8382016-12-15 23:59:234532void WebContentsImpl::OnDidRunInsecureContent(RenderFrameHostImpl* source,
4533 const GURL& security_origin,
estark910b4572015-12-09 20:55:414534 const GURL& target_url) {
nicka0ac8382016-12-15 23:59:234535 // TODO(nick, estark): Should we call FilterURL using |source|'s process on
4536 // these parameters? |target_url| seems unused, except for a log message. And
4537 // |security_origin| might be replaceable with the origin of the main frame.
carloskd9d97942017-02-16 08:58:094538 DidRunInsecureContent(security_origin, target_url);
4539}
4540
4541void WebContentsImpl::DidRunInsecureContent(const GURL& security_origin,
4542 const GURL& target_url) {
[email protected]9450c462013-11-23 01:22:584543 LOG(WARNING) << security_origin << " ran insecure content from "
4544 << target_url.possibly_invalid_spec();
[email protected]e6e30ac2014-01-13 21:24:394545 RecordAction(base::UserMetricsAction("SSL.RanInsecureContent"));
estark910b4572015-12-09 20:55:414546 if (base::EndsWith(security_origin.spec(), kDotGoogleDotCom,
brettwa7ff1b292015-07-16 17:49:294547 base::CompareCase::INSENSITIVE_ASCII))
[email protected]e6e30ac2014-01-13 21:24:394548 RecordAction(base::UserMetricsAction("SSL.RanInsecureContentGoogle"));
estarkc2273502016-10-12 22:03:024549 controller_.ssl_manager()->DidRunMixedContent(security_origin);
[email protected]724159a2010-12-30 01:11:184550}
4551
carloskd9d97942017-02-16 08:58:094552void WebContentsImpl::PassiveInsecureContentFound(const GURL& resource_url) {
Sergey Kuznetsov3ebc01b2018-02-01 04:57:364553 if (delegate_) {
4554 delegate_->PassiveInsecureContentFound(resource_url);
4555 }
carloskd9d97942017-02-16 08:58:094556}
4557
4558bool WebContentsImpl::ShouldAllowRunningInsecureContent(
4559 WebContents* web_contents,
4560 bool allowed_per_prefs,
4561 const url::Origin& origin,
4562 const GURL& resource_url) {
Sergey Kuznetsov3ebc01b2018-02-01 04:57:364563 if (delegate_) {
4564 return delegate_->ShouldAllowRunningInsecureContent(
4565 web_contents, allowed_per_prefs, origin, resource_url);
4566 }
4567
4568 return allowed_per_prefs;
carloskd9d97942017-02-16 08:58:094569}
4570
Lukasz Anforowicze1b954d92017-10-30 21:28:064571void WebContentsImpl::ViewSource(RenderFrameHostImpl* frame) {
4572 DCHECK_EQ(this, WebContents::FromRenderFrameHost(frame));
4573
4574 // Don't do anything if there is no |delegate_| that could accept and show the
4575 // new WebContents containing the view-source.
4576 if (!delegate_)
4577 return;
4578
4579 // Use the last committed entry, since the pending entry hasn't loaded yet and
4580 // won't be copied into the cloned tab.
4581 NavigationEntryImpl* last_committed_entry =
4582 static_cast<NavigationEntryImpl*>(frame->frame_tree_node()
4583 ->navigator()
4584 ->GetController()
4585 ->GetLastCommittedEntry());
4586 if (!last_committed_entry)
4587 return;
4588
4589 FrameNavigationEntry* frame_entry =
4590 last_committed_entry->GetFrameEntry(frame->frame_tree_node());
4591 if (!frame_entry)
4592 return;
4593
4594 // Any new WebContents opened while this WebContents is in fullscreen can be
4595 // used to confuse the user, so drop fullscreen.
Avi Drissmand18c51972018-08-15 18:32:094596 ForSecurityDropFullscreen();
Lukasz Anforowicze1b954d92017-10-30 21:28:064597
4598 // We intentionally don't share the SiteInstance with the original frame so
4599 // that view source has a consistent process model and always ends up in a new
4600 // process (https://crbug.com/699493).
4601 scoped_refptr<SiteInstanceImpl> site_instance_for_view_source = nullptr;
4602 // Referrer is not important, because view-source should not hit the network,
4603 // but should be served from the cache instead.
4604 Referrer referrer_for_view_source;
4605 // Do not restore title, derive it from the url.
4606 base::string16 title_for_view_source;
4607 auto navigation_entry = std::make_unique<NavigationEntryImpl>(
4608 site_instance_for_view_source, frame_entry->url(),
4609 referrer_for_view_source, title_for_view_source, ui::PAGE_TRANSITION_LINK,
Marijn Kruisselbrink7a0d5e182018-05-24 22:55:094610 /* is_renderer_initiated = */ false,
4611 /* blob_url_loader_factory = */ nullptr);
Lukasz Anforowicze1b954d92017-10-30 21:28:064612 navigation_entry->SetVirtualURL(GURL(content::kViewSourceScheme +
4613 std::string(":") +
4614 frame_entry->url().spec()));
4615
4616 // Do not restore scroller position.
4617 // TODO(creis, lukasza, arthursonzogni): Do not reuse the original PageState,
4618 // but start from a new one and only copy the needed data.
4619 const PageState& new_page_state =
4620 frame_entry->page_state().RemoveScrollOffset();
4621
4622 scoped_refptr<FrameNavigationEntry> new_frame_entry =
4623 navigation_entry->root_node()->frame_entry;
4624 new_frame_entry->set_method(frame_entry->method());
4625 new_frame_entry->SetPageState(new_page_state);
4626
4627 // Create a new WebContents, which is used to display the source code.
erikchenbee5c9622018-04-27 19:30:254628 std::unique_ptr<WebContents> view_source_contents =
Erik Chenbb8e738e2018-04-28 14:10:434629 Create(CreateParams(GetBrowserContext()));
Lukasz Anforowicze1b954d92017-10-30 21:28:064630
4631 // Restore the previously created NavigationEntry.
4632 std::vector<std::unique_ptr<NavigationEntry>> navigation_entries;
4633 navigation_entries.push_back(std::move(navigation_entry));
4634 view_source_contents->GetController().Restore(0, RestoreType::CURRENT_SESSION,
4635 &navigation_entries);
4636
4637 // Add |view_source_contents| as a new tab.
4638 gfx::Rect initial_rect;
4639 constexpr bool kUserGesture = true;
4640 bool ignored_was_blocked;
erikchenbee5c9622018-04-27 19:30:254641 delegate_->AddNewContents(this, std::move(view_source_contents),
Lukasz Anforowicze1b954d92017-10-30 21:28:064642 WindowOpenDisposition::NEW_FOREGROUND_TAB,
4643 initial_rect, kUserGesture, &ignored_was_blocked);
4644 // Note that the |delegate_| could have deleted |view_source_contents| during
4645 // AddNewContents method call.
4646}
4647
Jay Civellid5904f02018-03-23 19:43:574648void WebContentsImpl::SubresourceResponseStarted(const GURL& url,
4649 net::CertStatus cert_status) {
4650 controller_.ssl_manager()->DidStartResourceResponse(url, cert_status);
4651 SetNotWaitingForResponse();
4652}
4653
Jay Civelli116683f2018-03-27 19:56:234654void WebContentsImpl::ResourceLoadComplete(
Jay Civelli52a63302018-04-30 22:39:554655 RenderFrameHost* render_frame_host,
Clark DuVall36164bd2018-08-09 22:49:084656 const GlobalRequestID& request_id,
Jay Civelli116683f2018-03-27 19:56:234657 mojom::ResourceLoadInfoPtr resource_load_info) {
John Abd-El-Malek9b8f7fa2017-12-04 23:52:254658 for (auto& observer : observers_) {
Clark DuVall36164bd2018-08-09 22:49:084659 observer.ResourceLoadComplete(render_frame_host, request_id,
4660 *resource_load_info);
John Abd-El-Malek9b8f7fa2017-12-04 23:52:254661 }
John Abd-El-Malekd4882642017-12-04 21:45:194662}
4663
Wei Li5bb659742018-02-14 03:07:584664void WebContentsImpl::PrintCrossProcessSubframe(
4665 const gfx::Rect& rect,
4666 int document_cookie,
4667 RenderFrameHost* subframe_host) {
Wei Li5c0b4d12018-03-22 15:05:224668 auto* outer_contents = GetOuterWebContents();
4669 if (outer_contents) {
4670 // When an extension or app page is printed, the content should be
4671 // composited with outer content, so the outer contents should handle the
4672 // print request.
4673 outer_contents->PrintCrossProcessSubframe(rect, document_cookie,
4674 subframe_host);
4675 return;
4676 }
4677
Wei Li5bb659742018-02-14 03:07:584678 // If there is no delegate such as in tests or during deletion, do nothing.
4679 if (!delegate_)
4680 return;
4681
4682 delegate_->PrintCrossProcessSubframe(this, rect, document_cookie,
4683 subframe_host);
4684}
4685
rob.buis300b0872017-03-10 20:43:584686#if defined(OS_ANDROID)
4687base::android::ScopedJavaLocalRef<jobject>
4688WebContentsImpl::GetJavaRenderFrameHostDelegate() {
4689 return GetJavaWebContents();
4690}
4691#endif
4692
estark910b4572015-12-09 20:55:414693void WebContentsImpl::OnDidDisplayContentWithCertificateErrors(
Zhuoyu Qian4353f7f2018-01-08 05:33:004694 RenderFrameHostImpl* source) {
estarkc2273502016-10-12 22:03:024695 controller_.ssl_manager()->DidDisplayContentWithCertErrors();
estark910b4572015-12-09 20:55:414696}
4697
4698void WebContentsImpl::OnDidRunContentWithCertificateErrors(
Zhuoyu Qian4353f7f2018-01-08 05:33:004699 RenderFrameHostImpl* source) {
nicka0ac8382016-12-15 23:59:234700 // TODO(nick, estark): Do we need to consider |source| here somehow?
estarkcd2e30c2016-08-12 06:51:154701 NavigationEntry* entry = controller_.GetVisibleEntry();
4702 if (!entry)
estarkaeda1422016-05-10 02:31:124703 return;
4704
estarkaeda1422016-05-10 02:31:124705 // TODO(estark): check that this does something reasonable for
4706 // about:blank and sandboxed origins. https://crbug.com/609527
estarkcd2e30c2016-08-12 06:51:154707 controller_.ssl_manager()->DidRunContentWithCertErrors(
4708 entry->GetURL().GetOrigin());
estark910b4572015-12-09 20:55:414709}
4710
nicka0ac8382016-12-15 23:59:234711void WebContentsImpl::OnDocumentLoadedInFrame(RenderFrameHostImpl* source) {
ericwilligersde386342016-10-19 02:35:094712 for (auto& observer : observers_)
nicka0ac8382016-12-15 23:59:234713 observer.DocumentLoadedInFrame(source);
[email protected]724159a2010-12-30 01:11:184714}
4715
nicka0ac8382016-12-15 23:59:234716void WebContentsImpl::OnDidFinishLoad(RenderFrameHostImpl* source,
4717 const GURL& url) {
[email protected]8b3af1e2014-01-24 13:29:124718 GURL validated_url(url);
nicka0ac8382016-12-15 23:59:234719 source->GetProcess()->FilterURL(false, &validated_url);
[email protected]028053d42014-03-05 22:20:374720
ericwilligersde386342016-10-19 02:35:094721 for (auto& observer : observers_)
nicka0ac8382016-12-15 23:59:234722 observer.DidFinishLoad(source, validated_url);
[email protected]1a55c5be2011-11-29 11:36:314723}
4724
Dave Tapuska549baab2019-03-19 15:52:404725void WebContentsImpl::OnGoToEntryAtOffset(RenderFrameHostImpl* source,
Arthur Sonzognia7d715a2018-09-20 16:11:134726 int offset,
4727 bool has_user_gesture) {
4728 // Non-user initiated navigations coming from the renderer should be ignored
4729 // if there is an ongoing browser-initiated navigation.
4730 // See https://crbug.com/879965.
4731 // TODO(arthursonzogni): See if this should check for ongoing navigations in
4732 // the frame(s) affected by the session history navigation, rather than just
4733 // the main frame.
4734 if (!has_user_gesture) {
4735 NavigationRequest* ongoing_navigation_request =
4736 frame_tree_.root()->navigation_request();
4737 if (ongoing_navigation_request &&
4738 ongoing_navigation_request->browser_initiated()) {
4739 return;
4740 }
4741 }
4742
nicka0ac8382016-12-15 23:59:234743 // All frames are allowed to navigate the global history.
Dave Tapuska8bfd84c2019-03-26 20:47:164744 if (!delegate_ || delegate_->OnGoToEntryOffset(offset)) {
4745 if (source->IsSandboxed(blink::WebSandboxFlags::kTopNavigation)) {
4746 // Keep track of whether this is a session history from a sandboxed iframe
4747 // with top level navigation disallowed.
4748 controller_.GoToOffsetInSandboxedFrame(offset,
4749 source->GetFrameTreeNodeId());
4750 } else {
4751 controller_.GoToOffset(offset);
4752 }
4753 }
[email protected]216813952011-05-19 22:21:264754}
4755
nicka0ac8382016-12-15 23:59:234756void WebContentsImpl::OnUpdateZoomLimits(RenderViewHostImpl* source,
4757 int minimum_percent,
[email protected]fce823222014-05-30 16:24:304758 int maximum_percent) {
[email protected]216813952011-05-19 22:21:264759 minimum_zoom_percent_ = minimum_percent;
4760 maximum_zoom_percent_ = maximum_percent;
[email protected]216813952011-05-19 22:21:264761}
4762
nicka0ac8382016-12-15 23:59:234763void WebContentsImpl::OnPageScaleFactorChanged(RenderViewHostImpl* source,
4764 float page_scale_factor) {
mcnee336ea2c2017-05-23 22:50:594765#if !defined(OS_ANDROID)
4766 // While page scale factor is used on mobile, this PageScaleFactorIsOne logic
4767 // is only needed on desktop.
mcnee432e47d2015-11-09 19:37:464768 bool is_one = page_scale_factor == 1.f;
4769 if (is_one != page_scale_factor_is_one_) {
4770 page_scale_factor_is_one_ = is_one;
4771
4772 HostZoomMapImpl* host_zoom_map =
4773 static_cast<HostZoomMapImpl*>(HostZoomMap::GetForWebContents(this));
4774
nicka0ac8382016-12-15 23:59:234775 if (host_zoom_map) {
mcnee432e47d2015-11-09 19:37:464776 host_zoom_map->SetPageScaleFactorIsOneForView(
nicka0ac8382016-12-15 23:59:234777 source->GetProcess()->GetID(), source->GetRoutingID(),
mcnee432e47d2015-11-09 19:37:464778 page_scale_factor_is_one_);
4779 }
4780 }
mcnee336ea2c2017-05-23 22:50:594781#endif // !defined(OS_ANDROID)
mcnee432e47d2015-11-09 19:37:464782
ericwilligersde386342016-10-19 02:35:094783 for (auto& observer : observers_)
4784 observer.OnPageScaleFactorChanged(page_scale_factor);
mcnee432e47d2015-11-09 19:37:464785}
4786
W. James MacLean62198672019-06-04 16:46:104787void WebContentsImpl::OnTextAutosizerPageInfoChanged(
4788 RenderViewHostImpl* source,
4789 const blink::WebTextAutosizerPageInfo& page_info) {
4790 // Keep a copy of |page_info| in case we create a new RenderView before
4791 // the next update.
4792 text_autosizer_page_info_ = page_info;
4793 frame_tree_.root()->render_manager()->SendPageMessage(
4794 new PageMsg_UpdateTextAutosizerPageInfoForRemoteMainFrames(
4795 MSG_ROUTING_NONE, page_info),
4796 source->GetSiteInstance());
4797}
4798
Kent Tamura8c9e0562018-11-06 07:02:194799void WebContentsImpl::EnumerateDirectory(
4800 RenderFrameHost* render_frame_host,
4801 std::unique_ptr<FileSelectListener> listener,
4802 const base::FilePath& directory_path) {
4803 if (delegate_)
4804 delegate_->EnumerateDirectory(this, std::move(listener), directory_path);
4805 else
4806 listener->FileSelectionCanceled();
[email protected]3a29a6e2011-08-24 18:26:214807}
4808
nicka0ac8382016-12-15 23:59:234809void WebContentsImpl::OnRegisterProtocolHandler(RenderFrameHostImpl* source,
4810 const std::string& protocol,
[email protected]b172aee2012-04-10 17:05:264811 const GURL& url,
[email protected]fcf75d42013-12-03 20:11:264812 const base::string16& title,
[email protected]3a3b75a2012-06-01 08:38:364813 bool user_gesture) {
nicka0ac8382016-12-15 23:59:234814 // TODO(nick): Should we consider |source| here or pass it to the delegate?
4815 // TODO(nick): Do we need to apply FilterURL to |url|?
[email protected]e5f2de02012-07-20 22:15:434816 if (!delegate_)
4817 return;
4818
[email protected]b9535422012-02-09 01:47:594819 ChildProcessSecurityPolicyImpl* policy =
4820 ChildProcessSecurityPolicyImpl::GetInstance();
[email protected]8f810632013-06-06 22:33:324821 if (policy->IsPseudoScheme(protocol))
[email protected]b9535422012-02-09 01:47:594822 return;
[email protected]8f810632013-06-06 22:33:324823
[email protected]c125e532014-05-10 20:39:064824 delegate_->RegisterProtocolHandler(this, protocol, url, user_gesture);
[email protected]7d189022011-08-25 22:54:204825}
4826
nicka0ac8382016-12-15 23:59:234827void WebContentsImpl::OnUnregisterProtocolHandler(RenderFrameHostImpl* source,
4828 const std::string& protocol,
[email protected]f5273e52014-07-14 16:30:204829 const GURL& url,
4830 bool user_gesture) {
nicka0ac8382016-12-15 23:59:234831 // TODO(nick): Should we consider |source| here or pass it to the delegate?
4832 // TODO(nick): Do we need to apply FilterURL to |url|?
[email protected]f5273e52014-07-14 16:30:204833 if (!delegate_)
4834 return;
4835
4836 ChildProcessSecurityPolicyImpl* policy =
4837 ChildProcessSecurityPolicyImpl::GetInstance();
4838 if (policy->IsPseudoScheme(protocol))
4839 return;
4840
4841 delegate_->UnregisterProtocolHandler(this, protocol, url, user_gesture);
4842}
4843
kouhei40f03cb2015-09-24 07:47:014844void WebContentsImpl::OnUpdatePageImportanceSignals(
nicka0ac8382016-12-15 23:59:234845 RenderFrameHostImpl* source,
kouhei40f03cb2015-09-24 07:47:014846 const PageImportanceSignals& signals) {
nicka0ac8382016-12-15 23:59:234847 // TODO(nick, kouhei): Fix this for oopifs; currently all frames' state gets
4848 // written to this one field.
kouhei40f03cb2015-09-24 07:47:014849 page_importance_signals_ = signals;
4850}
4851
nicka0ac8382016-12-15 23:59:234852void WebContentsImpl::OnDomOperationResponse(RenderFrameHostImpl* source,
4853 const std::string& json_string) {
4854 // TODO(nick, lukasza): The notification below should probably be updated to
4855 // include |source|.
avi60bd4902015-09-23 20:39:244856 std::string json = json_string;
4857 NotificationService::current()->Notify(NOTIFICATION_DOM_OPERATION_RESPONSE,
4858 Source<WebContents>(this),
4859 Details<std::string>(&json));
[email protected]cfa856d62014-02-22 07:58:404860}
4861
Marijn Kruisselbrink7f519672019-02-05 19:12:504862void WebContentsImpl::OnAppCacheAccessed(const GURL& manifest_url,
[email protected]b172aee2012-04-10 17:05:264863 bool blocked_by_policy) {
nicka0ac8382016-12-15 23:59:234864 // TODO(nick): Should we consider |source| here? Should we call FilterURL on
4865 // |manifest_url|?
4866
[email protected]7fc4bbb2011-09-08 21:23:104867 // Notify observers about navigation.
ericwilligersde386342016-10-19 02:35:094868 for (auto& observer : observers_)
4869 observer.AppCacheAccessed(manifest_url, blocked_by_policy);
[email protected]7fc4bbb2011-09-08 21:23:104870}
4871
Joel Hockey85b379d2017-12-11 10:42:134872void WebContentsImpl::OnColorChooserFactoryRequest(
Joel Hockey163835a2017-12-20 11:51:574873 blink::mojom::ColorChooserFactoryRequest request) {
Joel Hockey85b379d2017-12-11 10:42:134874 color_chooser_factory_bindings_.AddBinding(this, std::move(request));
4875}
4876
4877void WebContentsImpl::OpenColorChooser(
Joel Hockey163835a2017-12-20 11:51:574878 blink::mojom::ColorChooserRequest chooser_request,
4879 blink::mojom::ColorChooserClientPtr client,
[email protected]8ed16472014-04-11 19:02:484880 SkColor color,
Joel Hockey163835a2017-12-20 11:51:574881 std::vector<blink::mojom::ColorSuggestionPtr> suggestions) {
Joel Hockey85b379d2017-12-11 10:42:134882 content::ColorChooser* new_color_chooser =
Ivan Kotenkov2c0d2bb32017-11-01 15:41:284883 delegate_ ? delegate_->OpenColorChooser(this, color, suggestions)
4884 : nullptr;
[email protected]820957a2014-01-14 14:56:304885 if (!new_color_chooser)
[email protected]cb805452013-05-22 15:16:214886 return;
[email protected]8ed16472014-04-11 19:02:484887
Joel Hockey85b379d2017-12-11 10:42:134888 color_chooser_.reset();
4889 color_chooser_ = std::make_unique<ColorChooser>(
4890 new_color_chooser, std::move(chooser_request), std::move(client));
[email protected]da8543762012-03-20 08:52:204891}
4892
brettw4b461082016-11-19 18:55:164893#if BUILDFLAG(ENABLE_PLUGINS)
nicka0ac8382016-12-15 23:59:234894void WebContentsImpl::OnPepperInstanceCreated(RenderFrameHostImpl* source,
4895 int32_t pp_instance) {
ericwilligersde386342016-10-19 02:35:094896 for (auto& observer : observers_)
4897 observer.PepperInstanceCreated();
nicka0ac8382016-12-15 23:59:234898 pepper_playback_observer_->PepperInstanceCreated(source, pp_instance);
emaxxe70f5e12015-05-29 11:26:004899}
4900
nicka0ac8382016-12-15 23:59:234901void WebContentsImpl::OnPepperInstanceDeleted(RenderFrameHostImpl* source,
4902 int32_t pp_instance) {
ericwilligersde386342016-10-19 02:35:094903 for (auto& observer : observers_)
4904 observer.PepperInstanceDeleted();
nicka0ac8382016-12-15 23:59:234905 pepper_playback_observer_->PepperInstanceDeleted(source, pp_instance);
emaxxe70f5e12015-05-29 11:26:004906}
4907
nicka0ac8382016-12-15 23:59:234908void WebContentsImpl::OnPepperPluginHung(RenderFrameHostImpl* source,
4909 int plugin_child_id,
tommyclie6633ca72014-10-31 00:40:424910 const base::FilePath& path,
4911 bool is_hung) {
Steven Holte95922222018-09-14 20:06:234912 UMA_HISTOGRAM_COUNTS_1M("Pepper.PluginHung", 1);
tommyclie6633ca72014-10-31 00:40:424913
ericwilligersde386342016-10-19 02:35:094914 for (auto& observer : observers_)
4915 observer.PluginHungStatusChanged(plugin_child_id, path, is_hung);
tommyclie6633ca72014-10-31 00:40:424916}
4917
nicka0ac8382016-12-15 23:59:234918void WebContentsImpl::OnPepperStartsPlayback(RenderFrameHostImpl* source,
4919 int32_t pp_instance) {
4920 pepper_playback_observer_->PepperStartsPlayback(source, pp_instance);
zqzhang181047e62016-07-01 13:37:174921}
4922
nicka0ac8382016-12-15 23:59:234923void WebContentsImpl::OnPepperStopsPlayback(RenderFrameHostImpl* source,
4924 int32_t pp_instance) {
4925 pepper_playback_observer_->PepperStopsPlayback(source, pp_instance);
zqzhang181047e62016-07-01 13:37:174926}
4927
nicka0ac8382016-12-15 23:59:234928void WebContentsImpl::OnPluginCrashed(RenderFrameHostImpl* source,
4929 const base::FilePath& plugin_path,
tommyclie6633ca72014-10-31 00:40:424930 base::ProcessId plugin_pid) {
nicka0ac8382016-12-15 23:59:234931 // TODO(nick): Eliminate the |plugin_pid| parameter, which can't be trusted,
4932 // and is only used by BlinkTestController.
ericwilligersde386342016-10-19 02:35:094933 for (auto& observer : observers_)
4934 observer.PluginCrashed(plugin_path, plugin_pid);
tommyclie6633ca72014-10-31 00:40:424935}
4936
[email protected]d8415ad92012-08-23 14:40:504937void WebContentsImpl::OnRequestPpapiBrokerPermission(
nicka0ac8382016-12-15 23:59:234938 RenderViewHostImpl* source,
4939 int ppb_broker_route_id,
[email protected]d8415ad92012-08-23 14:40:504940 const GURL& url,
[email protected]2dec8ec2013-02-07 19:20:344941 const base::FilePath& plugin_path) {
Avi Drissman0a2a967d2019-04-01 19:33:524942 base::OnceCallback<void(bool)> permission_result_callback = base::BindOnce(
nicka0ac8382016-12-15 23:59:234943 &WebContentsImpl::SendPpapiBrokerPermissionResult, base::Unretained(this),
4944 source->GetProcess()->GetID(), ppb_broker_route_id);
[email protected]8c8fc292012-11-23 18:57:164945 if (!delegate_) {
Tommy Nyquist4b749d02018-03-20 21:46:294946 std::move(permission_result_callback).Run(false);
[email protected]8c8fc292012-11-23 18:57:164947 return;
[email protected]d8415ad92012-08-23 14:40:504948 }
4949
Avi Drissman0a2a967d2019-04-01 19:33:524950 delegate_->RequestPpapiBrokerPermission(
4951 this, url, plugin_path, std::move(permission_result_callback));
[email protected]d8415ad92012-08-23 14:40:504952}
4953
nicka0ac8382016-12-15 23:59:234954void WebContentsImpl::SendPpapiBrokerPermissionResult(int process_id,
4955 int ppb_broker_route_id,
4956 bool result) {
4957 RenderProcessHost* rph = RenderProcessHost::FromID(process_id);
4958 if (rph) {
4959 // TODO(nick): Convert this from ViewMsg_ to a Ppapi msg, since it
4960 // is not routed to a RenderView.
4961 rph->Send(
4962 new ViewMsg_PpapiBrokerPermissionResult(ppb_broker_route_id, result));
4963 }
[email protected]d8415ad92012-08-23 14:40:504964}
4965
fsamuel833ee7c2015-02-13 23:40:404966void WebContentsImpl::OnBrowserPluginMessage(RenderFrameHost* render_frame_host,
4967 const IPC::Message& message) {
Lei Zhang6410ec1a2019-01-31 21:38:584968 CHECK(!browser_plugin_embedder_);
fsamuel60b42282015-03-10 03:29:144969 CreateBrowserPluginEmbedderIfNecessary();
fsamuel833ee7c2015-02-13 23:40:404970 browser_plugin_embedder_->OnMessageReceived(message, render_frame_host);
[email protected]19be7a62012-10-01 23:03:374971}
brettw4b461082016-11-19 18:55:164972#endif // BUILDFLAG(ENABLE_PLUGINS)
[email protected]19be7a62012-10-01 23:03:374973
[email protected]795c28972012-12-06 06:13:394974void WebContentsImpl::OnUpdateFaviconURL(
lukasza178ff092017-06-07 23:39:504975 RenderFrameHostImpl* source,
[email protected]795c28972012-12-06 06:13:394976 const std::vector<FaviconURL>& candidates) {
lukasza178ff092017-06-07 23:39:504977 // Ignore favicons for non-main frame.
4978 if (source->GetParent()) {
4979 NOTREACHED();
4980 return;
4981 }
4982
pkotwiczf9bc20592015-04-21 18:57:064983 // We get updated favicon URLs after the page stops loading. If a cross-site
4984 // navigation occurs while a page is still loading, the initial page
4985 // may stop loading and send us updated favicon URLs after the navigation
4986 // for the new page has committed.
lukasza178ff092017-06-07 23:39:504987 if (!source->IsCurrent())
pkotwiczf9bc20592015-04-21 18:57:064988 return;
4989
ericwilligersde386342016-10-19 02:35:094990 for (auto& observer : observers_)
4991 observer.DidUpdateFaviconURL(candidates);
[email protected]795c28972012-12-06 06:13:394992}
4993
qinmin72e8bd02016-10-21 19:35:374994void WebContentsImpl::SetIsOverlayContent(bool is_overlay_content) {
4995 is_overlay_content_ = is_overlay_content;
4996}
4997
Albert J. Wongfb64e142018-10-16 01:10:454998void WebContentsImpl::DidFirstVisuallyNonEmptyPaint(
4999 RenderViewHostImpl* source) {
Francois Dorayae33f2f2018-10-30 13:40:045000 // Set |did_first_visually_non_empty_paint_| before notifying observers so
5001 // they can see that CompletedFirstVisuallyNonEmptyPaint() is true.
5002 did_first_visually_non_empty_paint_ = true;
5003
nicka0ac8382016-12-15 23:59:235004 // TODO(nick): When this is ported to FrameHostMsg_, we should only listen if
5005 // |source| is the main frame.
ericwilligersde386342016-10-19 02:35:095006 for (auto& observer : observers_)
5007 observer.DidFirstVisuallyNonEmptyPaint();
yusufod41c5f92015-03-06 00:14:285008
5009 if (theme_color_ != last_sent_theme_color_) {
5010 // Theme color should have updated by now if there was one.
ericwilligersde386342016-10-19 02:35:095011 for (auto& observer : observers_)
5012 observer.DidChangeThemeColor(theme_color_);
yusufod41c5f92015-03-06 00:14:285013 last_sent_theme_color_ = theme_color_;
5014 }
[email protected]9f268072013-11-07 00:02:155015}
[email protected]d9030b82013-07-19 08:26:065016
Albert J. Wongfb64e142018-10-16 01:10:455017void WebContentsImpl::DidCommitAndDrawCompositorFrame(
Yiming Zhoudd60b0b2018-07-20 18:51:355018 RenderViewHostImpl* source) {
5019 for (auto& observer : observers_)
5020 observer.DidCommitAndDrawCompositorFrame();
5021}
5022
Adithya Srinivasan46b8a792019-02-01 14:47:235023bool WebContentsImpl::IsPortal() const {
5024 return portal();
5025}
5026
[email protected]17e286e2013-03-01 23:29:395027void WebContentsImpl::NotifyBeforeFormRepostWarningShow() {
ericwilligersde386342016-10-19 02:35:095028 for (auto& observer : observers_)
5029 observer.BeforeFormRepostWarningShow();
[email protected]17e286e2013-03-01 23:29:395030}
5031
[email protected]ec6c05f2013-10-23 18:41:575032void WebContentsImpl::ActivateAndShowRepostFormWarningDialog() {
5033 Activate();
5034 if (delegate_)
5035 delegate_->ShowRepostFormWarningDialog(this);
5036}
5037
[email protected]b4c84012014-04-28 19:51:105038bool WebContentsImpl::HasAccessedInitialDocument() {
5039 return has_accessed_initial_document_;
5040}
5041
afakhry6f0c1ec22016-07-14 13:55:135042void WebContentsImpl::UpdateTitleForEntry(NavigationEntry* entry,
[email protected]fcf75d42013-12-03 20:11:265043 const base::string16& title) {
[email protected]fcf75d42013-12-03 20:11:265044 base::string16 final_title;
Avi Drissman93002212017-09-27 03:20:525045 base::TrimWhitespace(title, base::TRIM_ALL, &final_title);
[email protected]420ae012009-04-24 05:16:325046
[email protected]987fc3a2011-05-26 14:18:095047 // If a page is created via window.open and never navigated,
5048 // there will be no navigation entry. In this situation,
[email protected]73eb2602012-02-09 19:50:555049 // |page_title_when_no_navigation_entry_| will be used for page title.
[email protected]987fc3a2011-05-26 14:18:095050 if (entry) {
[email protected]36fc0392011-12-25 03:59:515051 if (final_title == entry->GetTitle())
afakhry6f0c1ec22016-07-14 13:55:135052 return; // Nothing changed, don't bother.
[email protected]420ae012009-04-24 05:16:325053
[email protected]36fc0392011-12-25 03:59:515054 entry->SetTitle(final_title);
Avi Drissman93002212017-09-27 03:20:525055
5056 // The title for display may differ from the title just set; grab it.
5057 final_title = entry->GetTitleForDisplay();
[email protected]987fc3a2011-05-26 14:18:095058 } else {
5059 if (page_title_when_no_navigation_entry_ == final_title)
afakhry6f0c1ec22016-07-14 13:55:135060 return; // Nothing changed, don't bother.
[email protected]987fc3a2011-05-26 14:18:095061
5062 page_title_when_no_navigation_entry_ = final_title;
5063 }
[email protected]420ae012009-04-24 05:16:325064
[email protected]420ae012009-04-24 05:16:325065 // Lastly, set the title for the view.
[email protected]790e2fd2011-09-21 20:28:235066 view_->SetPageTitle(final_title);
[email protected]420ae012009-04-24 05:16:325067
ericwilligersde386342016-10-19 02:35:095068 for (auto& observer : observers_)
Avi Drissman93002212017-09-27 03:20:525069 observer.TitleWasSet(entry);
[email protected]66798902013-10-01 18:40:165070
afakhry6f0c1ec22016-07-14 13:55:135071 // Broadcast notifications when the UI should be updated.
5072 if (entry == controller_.GetEntryAtOffset(0))
5073 NotifyNavigationStateChanged(INVALIDATE_TYPE_TITLE);
[email protected]420ae012009-04-24 05:16:325074}
5075
fdegansa696e5112015-04-17 01:57:595076void WebContentsImpl::SendChangeLoadProgress() {
[email protected]960b0372014-05-19 18:01:005077 loading_last_progress_update_ = base::TimeTicks::Now();
[email protected]960b0372014-05-19 18:01:005078 if (delegate_)
fdegansa696e5112015-04-17 01:57:595079 delegate_->LoadProgressChanged(this, frame_tree_.load_progress());
[email protected]960b0372014-05-19 18:01:005080}
5081
5082void WebContentsImpl::ResetLoadProgressState() {
fdegans1d16355162015-03-26 11:58:345083 frame_tree_.ResetLoadProgress();
[email protected]960b0372014-05-19 18:01:005084 loading_weak_factory_.InvalidateWeakPtrs();
5085 loading_last_progress_update_ = base::TimeTicks();
5086}
5087
clamy44e84ce2016-02-22 15:38:255088// Notifies the RenderWidgetHost instance about the fact that the page is
5089// loading, or done loading.
5090void WebContentsImpl::LoadingStateChanged(bool to_different_document,
5091 bool due_to_interstitial,
5092 LoadNotificationDetails* details) {
Nate Chapin22ea6592019-03-05 22:29:025093 if (is_being_destroyed_)
5094 return;
clamy44e84ce2016-02-22 15:38:255095 // Do not send notifications about loading changes in the FrameTree while the
5096 // interstitial page is pausing the throbber.
creisadca9862017-06-16 19:12:115097 if (ShowingInterstitialPage() && interstitial_page_->pause_throbber() &&
clamy44e84ce2016-02-22 15:38:255098 !due_to_interstitial) {
5099 return;
5100 }
5101
5102 bool is_loading = IsLoading();
5103
5104 if (!is_loading) {
5105 load_state_ = net::LoadStateWithParam(net::LOAD_STATE_IDLE,
5106 base::string16());
5107 load_state_host_.clear();
5108 upload_size_ = 0;
5109 upload_position_ = 0;
5110 }
5111
5112 GetRenderManager()->SetIsLoading(is_loading);
5113
5114 waiting_for_response_ = is_loading;
5115 is_load_to_different_document_ = to_different_document;
5116
5117 if (delegate_)
5118 delegate_->LoadingStateChanged(this, to_different_document);
5119 NotifyNavigationStateChanged(INVALIDATE_TYPE_LOAD);
5120
5121 std::string url = (details ? details->url.possibly_invalid_spec() : "NULL");
5122 if (is_loading) {
5123 TRACE_EVENT_ASYNC_BEGIN2("browser,navigation", "WebContentsImpl Loading",
5124 this, "URL", url, "Main FrameTreeNode id",
5125 GetFrameTree()->root()->frame_tree_node_id());
ericwilligersde386342016-10-19 02:35:095126 for (auto& observer : observers_)
5127 observer.DidStartLoading();
clamy44e84ce2016-02-22 15:38:255128 } else {
5129 TRACE_EVENT_ASYNC_END1("browser,navigation", "WebContentsImpl Loading",
5130 this, "URL", url);
ericwilligersde386342016-10-19 02:35:095131 for (auto& observer : observers_)
5132 observer.DidStopLoading();
clamy44e84ce2016-02-22 15:38:255133 }
5134
5135 // TODO(avi): Remove. http://crbug.com/170921
5136 int type = is_loading ? NOTIFICATION_LOAD_START : NOTIFICATION_LOAD_STOP;
5137 NotificationDetails det = NotificationService::NoDetails();
5138 if (details)
5139 det = Details<LoadNotificationDetails>(details);
5140 NotificationService::current()->Notify(
5141 type, Source<NavigationController>(&controller_), det);
5142}
5143
[email protected]02d7b6e2014-06-24 21:01:505144void WebContentsImpl::NotifyViewSwapped(RenderViewHost* old_host,
5145 RenderViewHost* new_host) {
[email protected]420ae012009-04-24 05:16:325146 // After sending out a swap notification, we need to send a disconnect
5147 // notification so that clients that pick up a pointer to |this| can NULL the
5148 // pointer. See Bug 1230284.
5149 notify_disconnection_ = true;
ericwilligersde386342016-10-19 02:35:095150 for (auto& observer : observers_)
5151 observer.RenderViewHostChanged(old_host, new_host);
[email protected]da7a7182013-09-06 08:11:115152
Jinsuk Kimdc5284c22018-07-11 02:22:065153 view_->RenderViewHostChanged(old_host, new_host);
5154
Lucas Furukawa Gadanif9ea4fc2018-08-03 23:57:135155 // If this is an inner WebContents that has swapped views, we need to reattach
5156 // it to its outer WebContents.
5157 if (node_.outer_web_contents())
5158 ReattachToOuterWebContentsFrame();
5159
[email protected]7a846df2012-09-20 19:17:395160 // Ensure that the associated embedder gets cleared after a RenderViewHost
5161 // gets swapped, so we don't reuse the same embedder next time a
5162 // RenderViewHost is attached to this WebContents.
5163 RemoveBrowserPluginEmbedder();
[email protected]420ae012009-04-24 05:16:325164}
5165
[email protected]02d7b6e2014-06-24 21:01:505166void WebContentsImpl::NotifyFrameSwapped(RenderFrameHost* old_host,
Jinsuk Kim895b2c52018-07-03 06:49:165167 RenderFrameHost* new_host,
5168 bool is_main_frame) {
Bo Liu168c8642017-08-28 18:26:025169#if defined(OS_ANDROID)
Bo Liu16dd7b8322018-05-02 21:19:505170 // Copy importance from |old_host| if |new_host| is a main frame.
5171 if (old_host && !new_host->GetParent()) {
Bo Liu7c6779e92017-08-16 02:02:285172 static_cast<RenderFrameHostImpl*>(new_host)
5173 ->GetRenderWidgetHost()
Bo Liu16dd7b8322018-05-02 21:19:505174 ->SetImportance(static_cast<RenderFrameHostImpl*>(old_host)
5175 ->GetRenderWidgetHost()
5176 ->importance());
Bo Liu7c6779e92017-08-16 02:02:285177 }
Bo Liu168c8642017-08-28 18:26:025178#endif
ericwilligersde386342016-10-19 02:35:095179 for (auto& observer : observers_)
5180 observer.RenderFrameHostChanged(old_host, new_host);
[email protected]02d7b6e2014-06-24 21:01:505181}
5182
[email protected]da7a7182013-09-06 08:11:115183// TODO(avi): Remove this entire function because this notification is already
5184// covered by two observer functions. http://crbug.com/170921
[email protected]b172aee2012-04-10 17:05:265185void WebContentsImpl::NotifyDisconnected() {
[email protected]420ae012009-04-24 05:16:325186 if (!notify_disconnection_)
5187 return;
5188
5189 notify_disconnection_ = false;
[email protected]8ff00d72012-10-23 19:12:215190 NotificationService::current()->Notify(
5191 NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
5192 Source<WebContents>(this),
5193 NotificationService::NoDetails());
[email protected]420ae012009-04-24 05:16:325194}
5195
[email protected]cbb1ef592013-06-05 19:49:465196void WebContentsImpl::NotifyNavigationEntryCommitted(
5197 const LoadCommittedDetails& load_details) {
ericwilligersde386342016-10-19 02:35:095198 for (auto& observer : observers_)
5199 observer.NavigationEntryCommitted(load_details);
[email protected]cbb1ef592013-06-05 19:49:465200}
5201
Sam McNally5c087a32017-08-25 01:46:145202void WebContentsImpl::NotifyNavigationEntryChanged(
5203 const EntryChangedDetails& change_details) {
5204 for (auto& observer : observers_)
5205 observer.NavigationEntryChanged(change_details);
5206}
5207
5208void WebContentsImpl::NotifyNavigationListPruned(
5209 const PrunedDetails& pruned_details) {
5210 for (auto& observer : observers_)
5211 observer.NavigationListPruned(pruned_details);
5212}
5213
Christian Dullweber1af31e62018-02-22 11:49:485214void WebContentsImpl::NotifyNavigationEntriesDeleted() {
5215 for (auto& observer : observers_)
5216 observer.NavigationEntriesDeleted();
5217}
5218
rockotf62002a2016-09-15 00:08:595219void WebContentsImpl::OnAssociatedInterfaceRequest(
5220 RenderFrameHost* render_frame_host,
5221 const std::string& interface_name,
5222 mojo::ScopedInterfaceEndpointHandle handle) {
5223 auto it = binding_sets_.find(interface_name);
5224 if (it != binding_sets_.end())
5225 it->second->OnRequestForFrame(render_frame_host, std::move(handle));
5226}
5227
Ben Goodger9e24929e2017-07-21 03:13:405228void WebContentsImpl::OnInterfaceRequest(
5229 RenderFrameHost* render_frame_host,
5230 const std::string& interface_name,
5231 mojo::ScopedMessagePipeHandle* interface_pipe) {
Joel Hockey85b379d2017-12-11 10:42:135232 registry_.TryBindInterface(interface_name, interface_pipe);
Ben Goodger9e24929e2017-07-21 03:13:405233 for (auto& observer : observers_) {
5234 observer.OnInterfaceRequestFromFrame(render_frame_host, interface_name,
5235 interface_pipe);
5236 if (!interface_pipe->is_valid())
5237 break;
5238 }
5239}
5240
Varun Khaneja5da94302019-06-25 04:48:105241void WebContentsImpl::OnDidBlockNavigation(
5242 const GURL& blocked_url,
5243 const GURL& initiator_url,
5244 blink::NavigationBlockedReason reason) {
Nicolas Dossou-gbetebcab2472017-09-09 12:28:405245 if (delegate_)
Varun Khaneja5da94302019-06-25 04:48:105246 delegate_->OnDidBlockNavigation(this, blocked_url, initiator_url, reason);
Nicolas Dossou-gbetebcab2472017-09-09 12:28:405247}
5248
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415249const GURL& WebContentsImpl::GetMainFrameLastCommittedURL() {
[email protected]c31a84802014-04-03 15:55:495250 return GetLastCommittedURL();
5251}
5252
[email protected]b849847b2013-12-10 21:57:585253void WebContentsImpl::RenderFrameCreated(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:095254 for (auto& observer : observers_)
5255 observer.RenderFrameCreated(render_frame_host);
dmazzonif8a31042016-12-03 00:52:135256 UpdateAccessibilityModeOnFrame(render_frame_host);
clamy91b7abf2016-03-24 15:17:455257
Becca Hughesd11d6502018-07-31 17:01:285258 if (display_cutout_host_impl_)
5259 display_cutout_host_impl_->RenderFrameCreated(render_frame_host);
5260
clamy91b7abf2016-03-24 15:17:455261 if (!render_frame_host->IsRenderFrameLive() || render_frame_host->GetParent())
5262 return;
5263
5264 NavigationEntry* entry = controller_.GetPendingEntry();
5265 if (entry && entry->IsViewSourceMode()) {
5266 // Put the renderer in view source mode.
5267 render_frame_host->Send(
5268 new FrameMsg_EnableViewSourceMode(render_frame_host->GetRoutingID()));
5269 }
[email protected]b849847b2013-12-10 21:57:585270}
5271
5272void WebContentsImpl::RenderFrameDeleted(RenderFrameHost* render_frame_host) {
creis3638897452017-05-09 22:07:505273 is_notifying_observers_ = true;
ericwilligersde386342016-10-19 02:35:095274 for (auto& observer : observers_)
5275 observer.RenderFrameDeleted(render_frame_host);
creis3638897452017-05-09 22:07:505276 is_notifying_observers_ = false;
zqzhang7b6f4f02016-12-07 22:10:225277#if BUILDFLAG(ENABLE_PLUGINS)
5278 pepper_playback_observer_->RenderFrameDeleted(render_frame_host);
5279#endif
Becca Hughesfd5d8f892018-06-14 18:23:365280
Becca Hughesd11d6502018-07-31 17:01:285281 if (display_cutout_host_impl_)
5282 display_cutout_host_impl_->RenderFrameDeleted(render_frame_host);
5283
Becca Hughesfd5d8f892018-06-14 18:23:365284 // Remove any fullscreen state that the frame has stored.
5285 FullscreenStateChanged(render_frame_host, false /* is_fullscreen */);
[email protected]b849847b2013-12-10 21:57:585286}
5287
[email protected]a09d53ce2014-01-31 00:46:425288void WebContentsImpl::ShowContextMenu(RenderFrameHost* render_frame_host,
5289 const ContextMenuParams& params) {
avie9fd8722017-04-10 16:17:585290 // If a renderer fires off a second command to show a context menu before the
5291 // first context menu is closed, just ignore it. https://crbug.com/707534
ekaramadf6750aa2017-06-06 18:29:425292 if (showing_context_menu_)
avie9fd8722017-04-10 16:17:585293 return;
5294
[email protected]077e704b2014-05-23 19:24:105295 ContextMenuParams context_menu_params(params);
[email protected]a09d53ce2014-01-31 00:46:425296 // Allow WebContentsDelegates to handle the context menu operation first.
Joel Klinghed0ea22ea2019-02-20 22:04:225297 if (delegate_ &&
5298 delegate_->HandleContextMenu(render_frame_host, context_menu_params))
[email protected]a09d53ce2014-01-31 00:46:425299 return;
5300
[email protected]077e704b2014-05-23 19:24:105301 render_view_host_delegate_view_->ShowContextMenu(render_frame_host,
5302 context_menu_params);
[email protected]a09d53ce2014-01-31 00:46:425303}
5304
Avi Drissman4891b852018-09-25 18:12:585305namespace {
5306// Normalizes the line endings: \r\n -> \n, lone \r -> \n.
5307base::string16 NormalizeLineBreaks(const base::string16& source) {
5308 static const base::NoDestructor<base::string16> kReturnNewline(
5309 base::ASCIIToUTF16("\r\n"));
5310 static const base::NoDestructor<base::string16> kReturn(
5311 base::ASCIIToUTF16("\r"));
5312 static const base::NoDestructor<base::string16> kNewline(
5313 base::ASCIIToUTF16("\n"));
5314
5315 std::vector<base::StringPiece16> pieces;
5316
5317 for (const auto& rn_line : base::SplitStringPieceUsingSubstr(
5318 source, *kReturnNewline, base::KEEP_WHITESPACE,
5319 base::SPLIT_WANT_ALL)) {
5320 auto r_lines = base::SplitStringPieceUsingSubstr(
5321 rn_line, *kReturn, base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
5322 std::move(std::begin(r_lines), std::end(r_lines),
5323 std::back_inserter(pieces));
5324 }
5325
5326 return base::JoinString(pieces, *kNewline);
5327}
5328} // namespace
5329
avi777ff452017-02-09 19:04:485330void WebContentsImpl::RunJavaScriptDialog(RenderFrameHost* render_frame_host,
5331 const base::string16& message,
5332 const base::string16& default_prompt,
avi777ff452017-02-09 19:04:485333 JavaScriptDialogType dialog_type,
5334 IPC::Message* reply_msg) {
Avi Drissman2ccbb402018-03-20 21:11:365335 // Ensure that if showing a dialog is the first thing that a page does, that
5336 // the contents of the previous page aren't shown behind it. This is required
5337 // because showing a dialog freezes the renderer, so no frames will be coming
5338 // from it. https://crbug.com/823353
5339 auto* render_widget_host_impl =
5340 static_cast<RenderFrameHostImpl*>(render_frame_host)
5341 ->GetRenderWidgetHost();
5342 if (render_widget_host_impl)
5343 render_widget_host_impl->ForceFirstFrameAfterNavigationTimeout();
5344
avi0720b02e2017-06-13 03:22:135345 // Running a dialog causes an exit to webpage-initiated fullscreen.
5346 // http://crbug.com/728276
Avi Drissmand18c51972018-08-15 18:32:095347 ForSecurityDropFullscreen();
avi0720b02e2017-06-13 03:22:135348
Avi Drissmane04d3992017-10-05 15:11:365349 auto callback =
5350 base::BindOnce(&WebContentsImpl::OnDialogClosed, base::Unretained(this),
5351 render_frame_host->GetProcess()->GetID(),
5352 render_frame_host->GetRoutingID(), reply_msg);
Pavel Feldman3c1842b2017-08-02 05:00:165353
Pavel Feldman3c1842b2017-08-02 05:00:165354 std::vector<protocol::PageHandler*> page_handlers =
5355 protocol::PageHandler::EnabledForWebContents(this);
5356
Pavel Feldmanfab3cb62017-10-05 01:02:015357 if (delegate_)
5358 dialog_manager_ = delegate_->GetJavaScriptDialogManager(this);
5359
5360 // Suppress JavaScript dialogs when requested. Also suppress messages when
5361 // showing an interstitial as it's shown over the previous page and we don't
5362 // want the hidden page's dialogs to interfere with the interstitial.
5363 bool should_suppress = ShowingInterstitialPage() ||
5364 (delegate_ && delegate_->ShouldSuppressDialogs(this));
Pavel Feldman1c587bc52018-04-04 21:16:055365 bool has_non_devtools_handlers = delegate_ && dialog_manager_;
5366 bool has_handlers = page_handlers.size() || has_non_devtools_handlers;
Pavel Feldmanfab3cb62017-10-05 01:02:015367 bool suppress_this_message = should_suppress || !has_handlers;
5368
5369 if (suppress_this_message) {
Avi Drissmane04d3992017-10-05 15:11:365370 std::move(callback).Run(true, false, base::string16());
Pavel Feldman3c1842b2017-08-02 05:00:165371 return;
5372 }
5373
5374 scoped_refptr<CloseDialogCallbackWrapper> wrapper =
Avi Drissmane04d3992017-10-05 15:11:365375 new CloseDialogCallbackWrapper(std::move(callback));
Pavel Feldman3c1842b2017-08-02 05:00:165376
5377 is_showing_javascript_dialog_ = true;
5378
Avi Drissman4891b852018-09-25 18:12:585379 base::string16 normalized_message = NormalizeLineBreaks(message);
5380
Pavel Feldman3c1842b2017-08-02 05:00:165381 for (auto* handler : page_handlers) {
Avi Drissmane04d3992017-10-05 15:11:365382 handler->DidRunJavaScriptDialog(
Avi Drissman4891b852018-09-25 18:12:585383 render_frame_host->GetLastCommittedURL(), normalized_message,
5384 default_prompt, dialog_type, has_non_devtools_handlers,
Avi Drissmane04d3992017-10-05 15:11:365385 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:165386 }
5387
5388 if (dialog_manager_) {
[email protected]87de04b02014-04-08 22:14:495389 dialog_manager_->RunJavaScriptDialog(
Avi Drissman4891b852018-09-25 18:12:585390 this, render_frame_host, dialog_type, normalized_message,
5391 default_prompt,
Avi Drissmane04d3992017-10-05 15:11:365392 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false),
5393 &suppress_this_message);
[email protected]87de04b02014-04-08 22:14:495394 }
5395
5396 if (suppress_this_message) {
5397 // If we are suppressing messages, just reply as if the user immediately
5398 // pressed "Cancel", passing true to |dialog_was_suppressed|.
Avi Drissmane04d3992017-10-05 15:11:365399 wrapper->Run(true, false, base::string16());
[email protected]87de04b02014-04-08 22:14:495400 }
[email protected]87de04b02014-04-08 22:14:495401}
5402
5403void WebContentsImpl::RunBeforeUnloadConfirm(
[email protected]39f2f9252014-05-03 00:54:015404 RenderFrameHost* render_frame_host,
[email protected]87de04b02014-04-08 22:14:495405 bool is_reload,
5406 IPC::Message* reply_msg) {
Avi Drissman2ccbb402018-03-20 21:11:365407 // Ensure that if showing a dialog is the first thing that a page does, that
5408 // the contents of the previous page aren't shown behind it. This is required
5409 // because showing a dialog freezes the renderer, so no frames will be coming
5410 // from it. https://crbug.com/823353
5411 auto* render_widget_host_impl =
5412 static_cast<RenderFrameHostImpl*>(render_frame_host)
5413 ->GetRenderWidgetHost();
5414 if (render_widget_host_impl)
5415 render_widget_host_impl->ForceFirstFrameAfterNavigationTimeout();
5416
avi0720b02e2017-06-13 03:22:135417 // Running a dialog causes an exit to webpage-initiated fullscreen.
5418 // http://crbug.com/728276
Avi Drissmand18c51972018-08-15 18:32:095419 ForSecurityDropFullscreen();
avi0720b02e2017-06-13 03:22:135420
[email protected]39f2f9252014-05-03 00:54:015421 RenderFrameHostImpl* rfhi =
5422 static_cast<RenderFrameHostImpl*>(render_frame_host);
[email protected]87de04b02014-04-08 22:14:495423 if (delegate_)
5424 delegate_->WillRunBeforeUnloadConfirm();
5425
Avi Drissmane04d3992017-10-05 15:11:365426 auto callback =
5427 base::BindOnce(&WebContentsImpl::OnDialogClosed, base::Unretained(this),
5428 render_frame_host->GetProcess()->GetID(),
5429 render_frame_host->GetRoutingID(), reply_msg);
Pavel Feldman3c1842b2017-08-02 05:00:165430
Pavel Feldman3c1842b2017-08-02 05:00:165431 std::vector<protocol::PageHandler*> page_handlers =
5432 protocol::PageHandler::EnabledForWebContents(this);
5433
Pavel Feldmanfab3cb62017-10-05 01:02:015434 if (delegate_)
5435 dialog_manager_ = delegate_->GetJavaScriptDialogManager(this);
5436
5437 bool should_suppress = ShowingInterstitialPage() || !rfhi->is_active() ||
5438 (delegate_ && delegate_->ShouldSuppressDialogs(this));
Pavel Feldman1c587bc52018-04-04 21:16:055439 bool has_non_devtools_handlers = delegate_ && dialog_manager_;
5440 bool has_handlers = page_handlers.size() || has_non_devtools_handlers;
Pavel Feldmanfab3cb62017-10-05 01:02:015441 if (should_suppress || !has_handlers) {
Avi Drissmane04d3992017-10-05 15:11:365442 std::move(callback).Run(false, true, base::string16());
[email protected]87de04b02014-04-08 22:14:495443 return;
5444 }
5445
5446 is_showing_before_unload_dialog_ = true;
Pavel Feldman3c1842b2017-08-02 05:00:165447
5448 scoped_refptr<CloseDialogCallbackWrapper> wrapper =
Avi Drissmane04d3992017-10-05 15:11:365449 new CloseDialogCallbackWrapper(std::move(callback));
Pavel Feldman3c1842b2017-08-02 05:00:165450
5451 GURL frame_url = rfhi->GetLastCommittedURL();
5452 for (auto* handler : page_handlers) {
Avi Drissmane04d3992017-10-05 15:11:365453 handler->DidRunBeforeUnloadConfirm(
Pavel Feldman1c587bc52018-04-04 21:16:055454 frame_url, has_non_devtools_handlers,
Avi Drissmane04d3992017-10-05 15:11:365455 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:165456 }
5457
5458 if (dialog_manager_) {
Avi Drissmane04d3992017-10-05 15:11:365459 dialog_manager_->RunBeforeUnloadDialog(
Avi Drissmanff9ed752017-11-28 21:18:125460 this, render_frame_host, is_reload,
Avi Drissmane04d3992017-10-05 15:11:365461 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:165462 }
[email protected]87de04b02014-04-08 22:14:495463}
5464
Kent Tamurac260c9a2018-09-14 09:10:565465void WebContentsImpl::RunFileChooser(
5466 RenderFrameHost* render_frame_host,
Kent Tamura512a27e2018-10-04 00:49:325467 std::unique_ptr<content::FileSelectListener> listener,
Kent Tamurac260c9a2018-09-14 09:10:565468 const blink::mojom::FileChooserParams& params) {
Avi Drissman3d41e7712018-08-27 21:18:085469 // Any explicit focusing of another window while this WebContents is in
5470 // fullscreen can be used to confuse the user, so drop fullscreen.
5471 ForSecurityDropFullscreen();
5472
naskoada75b22016-06-11 16:09:465473 if (delegate_)
Kent Tamura512a27e2018-10-04 00:49:325474 delegate_->RunFileChooser(render_frame_host, std::move(listener), params);
5475 else
5476 listener->FileSelectionCanceled();
naskoada75b22016-06-11 16:09:465477}
5478
[email protected]a86c0e962013-12-17 17:10:395479WebContents* WebContentsImpl::GetAsWebContents() {
5480 return this;
5481}
5482
mcnee336ea2c2017-05-23 22:50:595483#if !defined(OS_ANDROID)
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415484double WebContentsImpl::GetPendingPageZoomLevel() {
wjmaclean64951902016-04-29 20:59:125485 NavigationEntry* pending_entry = GetController().GetPendingEntry();
5486 if (!pending_entry)
5487 return HostZoomMap::GetZoomLevel(this);
5488
5489 GURL url = pending_entry->GetURL();
5490 return HostZoomMap::GetForWebContents(this)->GetZoomLevelForHostAndScheme(
5491 url.scheme(), net::GetHostOrSpecFromURL(url));
5492}
mcnee336ea2c2017-05-23 22:50:595493#endif // !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:125494
qinmin72e8bd02016-10-21 19:35:375495bool WebContentsImpl::HideDownloadUI() const {
5496 return is_overlay_content_;
5497}
5498
mlamouri5cd9ae82017-02-18 11:05:095499bool WebContentsImpl::HasPersistentVideo() const {
5500 return has_persistent_video_;
5501}
5502
Ian Vollick5d5c37f2019-06-19 22:50:575503bool WebContentsImpl::IsSpatialNavigationDisabled() const {
5504 return is_spatial_navigation_disabled_;
5505}
5506
Alex Moshchuk27caae82017-09-11 23:11:185507RenderFrameHost* WebContentsImpl::GetPendingMainFrame() {
clamy610c63b32017-12-22 15:05:185508 return GetRenderManager()->speculative_frame_host();
Alex Moshchuk27caae82017-09-11 23:11:185509}
5510
mlamourie52c1b542017-02-23 14:57:505511bool WebContentsImpl::HasActiveEffectivelyFullscreenVideo() const {
5512 return media_web_contents_observer_->HasActiveEffectivelyFullscreenVideo();
5513}
5514
François Beaufortad6c5232018-02-26 11:00:445515bool WebContentsImpl::IsPictureInPictureAllowedForFullscreenVideo() const {
5516 return media_web_contents_observer_
5517 ->IsPictureInPictureAllowedForFullscreenVideo();
5518}
5519
ekaramada110f642016-12-21 19:47:285520bool WebContentsImpl::IsFocusedElementEditable() {
5521 RenderFrameHostImpl* frame = GetFocusedFrame();
5522 return frame && frame->has_focused_editable_element();
5523}
5524
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415525bool WebContentsImpl::IsShowingContextMenu() {
ekaramadf6750aa2017-06-06 18:29:425526 return showing_context_menu_;
5527}
5528
5529void WebContentsImpl::SetShowingContextMenu(bool showing) {
5530 DCHECK_NE(showing_context_menu_, showing);
5531 showing_context_menu_ = showing;
5532
5533 if (auto* view = GetRenderWidgetHostView()) {
5534 // Notify the main frame's RWHV to run the platform-specific code, if any.
5535 static_cast<RenderWidgetHostViewBase*>(view)->SetShowingContextMenu(
5536 showing);
5537 }
5538}
5539
ekaramada110f642016-12-21 19:47:285540void WebContentsImpl::ClearFocusedElement() {
5541 if (auto* frame = GetFocusedFrame())
5542 frame->ClearFocusedElement();
5543}
5544
[email protected]7912e822014-04-16 02:37:035545bool WebContentsImpl::IsNeverVisible() {
5546 if (!delegate_)
5547 return false;
5548 return delegate_->IsNeverVisible(this);
5549}
5550
[email protected]5a3bdf52012-05-24 15:12:575551RenderViewHostDelegateView* WebContentsImpl::GetDelegateView() {
5552 return render_view_host_delegate_view_;
[email protected]420ae012009-04-24 05:16:325553}
5554
Leon Hanc819dc62019-01-28 04:30:195555blink::mojom::RendererPreferences WebContentsImpl::GetRendererPrefs(
[email protected]8ff00d72012-10-23 19:12:215556 BrowserContext* browser_context) const {
[email protected]840b1512009-07-21 16:53:465557 return renderer_preferences_;
[email protected]80d96fa2009-06-10 22:34:515558}
5559
[email protected]7a846df2012-09-20 19:17:395560void WebContentsImpl::RemoveBrowserPluginEmbedder() {
Lei Zhang6410ec1a2019-01-31 21:38:585561 browser_plugin_embedder_.reset();
[email protected]7a846df2012-09-20 19:17:395562}
5563
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165564RenderFrameHostImpl* WebContentsImpl::GetOuterWebContentsFrame() {
5565 if (GetOuterDelegateFrameTreeNodeId() ==
5566 FrameTreeNode::kFrameTreeNodeInvalidId) {
5567 return nullptr;
5568 }
5569
5570 FrameTreeNode* outer_node =
5571 FrameTreeNode::GloballyFindByID(GetOuterDelegateFrameTreeNodeId());
5572 // The outer node should be in the outer WebContents.
5573 DCHECK_EQ(outer_node->frame_tree(), GetOuterWebContents()->GetFrameTree());
5574 return outer_node->parent()->current_frame_host();
5575}
5576
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:415577WebContentsImpl* WebContentsImpl::GetOuterWebContents() {
lfg601233692017-03-06 22:45:445578 if (GuestMode::IsCrossProcessFrameGuest(this))
5579 return node_.outer_web_contents();
ekaramad1beabecc2016-09-23 20:18:175580
5581 if (browser_plugin_guest_)
5582 return browser_plugin_guest_->embedder_web_contents();
5583
Lucas Furukawa Gadani105de1e812018-05-31 19:38:395584 return node_.outer_web_contents();
avallee0206f782016-07-28 18:55:335585}
5586
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165587std::vector<WebContents*> WebContentsImpl::GetInnerWebContents() {
5588 std::vector<WebContents*> all_inner_contents;
5589 if (browser_plugin_embedder_) {
Sean Topping7df73952019-05-16 17:21:165590 BrowserPluginGuestManager* guest_manager =
5591 GetBrowserContext()->GetGuestManager();
5592 if (guest_manager) {
5593 guest_manager->ForEachGuest(
5594 this,
5595 base::BindRepeating(&GetInnerWebContentsHelper, &all_inner_contents));
5596 }
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:165597 }
5598 const auto& inner_contents = node_.GetInnerWebContents();
5599 all_inner_contents.insert(all_inner_contents.end(), inner_contents.begin(),
5600 inner_contents.end());
5601 return all_inner_contents;
5602}
5603
avallee0206f782016-07-28 18:55:335604WebContentsImpl* WebContentsImpl::GetFocusedWebContents() {
lfg601233692017-03-06 22:45:445605 return GetOutermostWebContents()->node_.focused_web_contents();
avallee0206f782016-07-28 18:55:335606}
5607
avallee9993fca2016-11-17 06:16:505608bool WebContentsImpl::ContainsOrIsFocusedWebContents() {
5609 for (WebContentsImpl* focused_contents = GetFocusedWebContents();
5610 focused_contents;
5611 focused_contents = focused_contents->GetOuterWebContents()) {
5612 if (focused_contents == this)
5613 return true;
5614 }
5615
5616 return false;
5617}
5618
avallee0206f782016-07-28 18:55:335619WebContentsImpl* WebContentsImpl::GetOutermostWebContents() {
5620 WebContentsImpl* root = this;
5621 while (root->GetOuterWebContents())
5622 root = root->GetOuterWebContents();
5623 return root;
5624}
5625
avalleed68cdd12017-06-21 22:07:275626void WebContentsImpl::FocusOuterAttachmentFrameChain() {
5627 WebContentsImpl* outer_contents = GetOuterWebContents();
5628 if (!outer_contents)
5629 return;
5630
5631 FrameTreeNode* outer_node =
5632 FrameTreeNode::GloballyFindByID(GetOuterDelegateFrameTreeNodeId());
5633 outer_contents->frame_tree_.SetFocusedFrame(outer_node, nullptr);
5634
5635 // For a browser initiated focus change, let embedding renderer know of the
5636 // change. Otherwise, if the currently focused element is just across a
5637 // process boundary in focus order, it will not be possible to move across
5638 // that boundary. This is because the target element will already be focused
5639 // (that renderer was not notified) and drop the event.
5640 if (GetRenderManager()->GetProxyToOuterDelegate())
5641 GetRenderManager()->GetProxyToOuterDelegate()->SetFocusedFrame();
5642
5643 outer_contents->FocusOuterAttachmentFrameChain();
5644}
5645
Sean Toppingbbc4a2bd2019-01-30 02:16:145646void WebContentsImpl::InnerWebContentsCreated(WebContents* inner_web_contents) {
Shivani Sharma985474f2019-05-23 21:36:475647 had_inner_webcontents_ = true;
Sean Toppingbbc4a2bd2019-01-30 02:16:145648 for (auto& observer : observers_)
5649 observer.InnerWebContentsCreated(inner_web_contents);
5650}
5651
[email protected]b172aee2012-04-10 17:05:265652void WebContentsImpl::RenderViewCreated(RenderViewHost* render_view_host) {
[email protected]86f98a22013-03-20 14:35:005653 if (delegate_)
[email protected]e85165c642014-06-10 14:34:315654 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]a6b73c62013-02-11 23:05:085655
[email protected]8ff00d72012-10-23 19:12:215656 NotificationService::current()->Notify(
5657 NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED,
5658 Source<WebContents>(this),
5659 Details<RenderViewHost>(render_view_host));
[email protected]420ae012009-04-24 05:16:325660
[email protected]60780f412013-02-25 16:34:105661 view_->RenderViewCreated(render_view_host);
[email protected]11f764bb2011-05-25 19:45:265662
ericwilligersde386342016-10-19 02:35:095663 for (auto& observer : observers_)
5664 observer.RenderViewCreated(render_view_host);
Joel Einbinder848001c2017-09-19 21:39:315665 if (delegate_)
5666 RenderFrameDevToolsAgentHost::WebContentsCreated(this);
[email protected]420ae012009-04-24 05:16:325667}
5668
[email protected]b172aee2012-04-10 17:05:265669void WebContentsImpl::RenderViewReady(RenderViewHost* rvh) {
[email protected]151a63d2011-12-20 22:32:525670 if (rvh != GetRenderViewHost()) {
[email protected]420ae012009-04-24 05:16:325671 // Don't notify the world, since this came from a renderer in the
5672 // background.
5673 return;
5674 }
5675
dmazzoni62111452017-04-28 23:46:555676 RenderWidgetHostViewBase* rwhv =
5677 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
5678 if (rwhv)
5679 rwhv->SetMainFrameAXTreeID(GetMainFrame()->GetAXTreeID());
5680
[email protected]da7a7182013-09-06 08:11:115681 notify_disconnection_ = true;
[email protected]da7a7182013-09-06 08:11:115682
[email protected]be1f56ab2011-12-22 06:55:315683 bool was_crashed = IsCrashed();
[email protected]443b80e2010-12-14 00:42:235684 SetIsCrashed(base::TERMINATION_STATUS_STILL_RUNNING, 0);
[email protected]9d8a4642009-07-29 17:25:305685
5686 // Restore the focus to the tab (otherwise the focus will be on the top
5687 // window).
[email protected]484ae5912010-09-29 19:16:145688 if (was_crashed && !FocusLocationBarByDefault() &&
5689 (!delegate_ || delegate_->ShouldFocusPageAfterCrash())) {
[email protected]f3615f02013-02-26 06:09:065690 view_->Focus();
[email protected]484ae5912010-09-29 19:16:145691 }
[email protected]32ded2212011-11-10 18:51:435692
ericwilligersde386342016-10-19 02:35:095693 for (auto& observer : observers_)
5694 observer.RenderViewReady();
Jinsuk Kim895b2c52018-07-03 06:49:165695
5696 view_->RenderViewReady();
[email protected]420ae012009-04-24 05:16:325697}
5698
[email protected]ec6a7eb2013-04-22 17:34:225699void WebContentsImpl::RenderViewTerminated(RenderViewHost* rvh,
5700 base::TerminationStatus status,
5701 int error_code) {
[email protected]151a63d2011-12-20 22:32:525702 if (rvh != GetRenderViewHost()) {
[email protected]420ae012009-04-24 05:16:325703 // The pending page's RenderViewHost is gone.
5704 return;
5705 }
5706
[email protected]2fcdcc32014-03-05 02:14:075707 // Ensure fullscreen mode is exited in the |delegate_| since a crashed
5708 // renderer may not have made a clean exit.
alexmos5dd617d2016-06-07 04:21:155709 if (IsFullscreenForCurrentTab())
bokanece34a82016-01-28 19:49:465710 ExitFullscreenMode(false);
[email protected]2fcdcc32014-03-05 02:14:075711
Jennifer Apacibleb4b972a2018-06-07 04:41:025712 // Ensure any video in Picture-in-Picture is exited in the |delegate_| since
5713 // a crashed renderer may not have made a clean exit.
5714 if (HasPictureInPictureVideo())
5715 ExitPictureInPicture();
5716
[email protected]698191dc2014-02-25 01:06:135717 // Cancel any visible dialogs so they are not left dangling over the sad tab.
creis89a0f782015-05-27 16:13:175718 CancelActiveAndPendingDialogs();
[email protected]698191dc2014-02-25 01:06:135719
dalecurtis3d1e1302017-02-20 22:33:255720 audio_stream_monitor_.RenderProcessGone(rvh->GetProcess()->GetID());
5721
[email protected]960b0372014-05-19 18:01:005722 // Reset the loading progress. TODO(avi): What does it mean to have a
5723 // "renderer crash" when there is more than one renderer process serving a
5724 // webpage? Once this function is called at a more granular frame level, we
5725 // probably will need to more granularly reset the state here.
5726 ResetLoadProgressState();
clamy44e84ce2016-02-22 15:38:255727 NotifyDisconnected();
5728 SetIsCrashed(status, error_code);
[email protected]960b0372014-05-19 18:01:005729
ericwilligersde386342016-10-19 02:35:095730 for (auto& observer : observers_)
5731 observer.RenderProcessGone(GetCrashedStatus());
[email protected]420ae012009-04-24 05:16:325732}
5733
[email protected]b172aee2012-04-10 17:05:265734void WebContentsImpl::RenderViewDeleted(RenderViewHost* rvh) {
ericwilligersde386342016-10-19 02:35:095735 for (auto& observer : observers_)
5736 observer.RenderViewDeleted(rvh);
[email protected]2e4633c2009-07-09 16:58:065737}
5738
sky8b00392d2015-01-10 00:30:285739void WebContentsImpl::UpdateTargetURL(RenderViewHost* render_view_host,
5740 const GURL& url) {
5741 if (fullscreen_widget_routing_id_ != MSG_ROUTING_NONE) {
Lukasz Anforowiczfd707142018-02-07 19:46:135742 // If we're in flash fullscreen (i.e. Pepper plugin fullscreen) only update
5743 // the url if it's from the fullscreen renderer.
sky8b00392d2015-01-10 00:30:285744 RenderWidgetHostView* fs = GetFullscreenRenderWidgetHostView();
avif9ab5d942015-10-15 14:05:445745 if (fs && fs->GetRenderWidgetHost() != render_view_host->GetWidget())
sky8b00392d2015-01-10 00:30:285746 return;
5747 }
Lukasz Anforowiczfd707142018-02-07 19:46:135748
5749 // In case of racey updates from multiple RenderViewHosts, the last URL should
5750 // be shown - see also some discussion in https://crbug.com/807776.
5751 if (!url.is_valid() && render_view_host != view_that_set_last_target_url_)
5752 return;
5753 view_that_set_last_target_url_ = url.is_valid() ? render_view_host : nullptr;
5754
[email protected]6934a702011-12-20 00:04:515755 if (delegate_)
avi450ce00e2014-09-24 01:58:525756 delegate_->UpdateTargetURL(this, url);
[email protected]420ae012009-04-24 05:16:325757}
5758
Lukasz Anforowiczfd707142018-02-07 19:46:135759void WebContentsImpl::ClearTargetURL() {
5760 view_that_set_last_target_url_ = nullptr;
5761 if (delegate_)
5762 delegate_->UpdateTargetURL(this, GURL());
5763}
5764
[email protected]b172aee2012-04-10 17:05:265765void WebContentsImpl::Close(RenderViewHost* rvh) {
[email protected]60780f412013-02-25 16:34:105766#if defined(OS_MACOSX)
[email protected]07707302009-11-06 00:50:295767 // The UI may be in an event-tracking loop, such as between the
5768 // mouse-down and mouse-up in text selection or a button click.
5769 // Defer the close until after tracking is complete, so that we
5770 // don't free objects out from under the UI.
[email protected]07707302009-11-06 00:50:295771 // TODO(shess): This could get more fine-grained. For instance,
5772 // closing a tab in another window while selecting text in the
5773 // current window's Omnibox should be just fine.
Christopher Cameron9ae31e0d2019-03-01 20:01:195774 if (view_->CloseTabAfterEventTrackingIfNeeded())
[email protected]07707302009-11-06 00:50:295775 return;
[email protected]60780f412013-02-25 16:34:105776#endif
[email protected]07707302009-11-06 00:50:295777
[email protected]420ae012009-04-24 05:16:325778 // Ignore this if it comes from a RenderViewHost that we aren't showing.
[email protected]151a63d2011-12-20 22:32:525779 if (delegate_ && rvh == GetRenderViewHost())
[email protected]6934a702011-12-20 00:04:515780 delegate_->CloseContents(this);
[email protected]420ae012009-04-24 05:16:325781}
5782
Avi Drissman014dec72018-06-07 02:34:015783void WebContentsImpl::RequestSetBounds(const gfx::Rect& new_bounds) {
5784 if (delegate_)
5785 delegate_->SetContentsBounds(this, new_bounds);
[email protected]420ae012009-04-24 05:16:325786}
5787
fdegansa696e5112015-04-17 01:57:595788void WebContentsImpl::DidStartLoading(FrameTreeNode* frame_tree_node,
[email protected]e3b10d12014-03-28 16:06:095789 bool to_different_document) {
Evan Stadec3b26022017-07-14 19:50:245790 LoadingStateChanged(frame_tree_node->IsMainFrame() && to_different_document,
5791 false, nullptr);
dmazzonibf8cec42015-02-08 08:28:085792
Xiyuan Xia2a66b112018-12-06 15:52:165793 // Reset the focus state from DidStartNavigation to false if a new load starts
5794 // afterward, in case loading logic triggers a FocusLocationBarByDefault call.
5795 should_focus_location_bar_by_default_ = false;
5796
dmazzonibf8cec42015-02-08 08:28:085797 // Notify accessibility that the user is navigating away from the
5798 // current document.
5799 //
5800 // TODO(dmazzoni): do this using a WebContentsObserver.
dmazzonibf8cec42015-02-08 08:28:085801 BrowserAccessibilityManager* manager =
fdegansa696e5112015-04-17 01:57:595802 frame_tree_node->current_frame_host()->browser_accessibility_manager();
dmazzonibf8cec42015-02-08 08:28:085803 if (manager)
5804 manager->UserIsNavigatingAway();
[email protected]420ae012009-04-24 05:16:325805}
5806
fdegansc73eec22015-03-19 14:47:545807void WebContentsImpl::DidStopLoading() {
dcheng59716272016-04-09 05:19:085808 std::unique_ptr<LoadNotificationDetails> details;
[email protected]420ae012009-04-24 05:16:325809
[email protected]9595fd82013-04-19 21:28:495810 // Use the last committed entry rather than the active one, in case a
5811 // pending entry has been created.
5812 NavigationEntry* entry = controller_.GetLastCommittedEntry();
[email protected]3691e5cf2014-01-22 10:16:205813 Navigator* navigator = frame_tree_.root()->navigator();
[email protected]9595fd82013-04-19 21:28:495814
[email protected]420ae012009-04-24 05:16:325815 // An entry may not exist for a stop when loading an initial blank page or
5816 // if an iframe injected by script into a blank page finishes loading.
5817 if (entry) {
[email protected]3691e5cf2014-01-22 10:16:205818 base::TimeDelta elapsed =
5819 base::TimeTicks::Now() - navigator->GetCurrentLoadStart();
[email protected]420ae012009-04-24 05:16:325820
5821 details.reset(new LoadNotificationDetails(
[email protected]36fc0392011-12-25 03:59:515822 entry->GetVirtualURL(),
[email protected]420ae012009-04-24 05:16:325823 elapsed,
5824 &controller_,
5825 controller_.GetCurrentEntryIndex()));
5826 }
5827
clamy44e84ce2016-02-22 15:38:255828 LoadingStateChanged(true, false, details.get());
[email protected]420ae012009-04-24 05:16:325829}
5830
fdegansa696e5112015-04-17 01:57:595831void WebContentsImpl::DidChangeLoadProgress() {
Nate Chapin22ea6592019-03-05 22:29:025832 if (is_being_destroyed_)
5833 return;
fdegansa696e5112015-04-17 01:57:595834 double load_progress = frame_tree_.load_progress();
5835
5836 // The delegate is notified immediately for the first and last updates. Also,
5837 // since the message loop may be pretty busy when a page is loaded, it might
5838 // not execute a posted task in a timely manner so the progress report is sent
5839 // immediately if enough time has passed.
5840 base::TimeDelta min_delay =
5841 base::TimeDelta::FromMilliseconds(kMinimumDelayBetweenLoadingUpdatesMS);
5842 bool delay_elapsed = loading_last_progress_update_.is_null() ||
5843 base::TimeTicks::Now() - loading_last_progress_update_ > min_delay;
5844
5845 if (load_progress == 0.0 || load_progress == 1.0 || delay_elapsed) {
5846 // If there is a pending task to send progress, it is now obsolete.
5847 loading_weak_factory_.InvalidateWeakPtrs();
5848
5849 // Notify the load progress change.
5850 SendChangeLoadProgress();
5851
5852 // Clean-up the states if needed.
5853 if (load_progress == 1.0)
5854 ResetLoadProgressState();
5855 return;
5856 }
5857
5858 if (loading_weak_factory_.HasWeakPtrs())
5859 return;
5860
skyostil95082a62015-06-05 19:53:075861 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
tzike2aca992017-09-05 08:50:545862 FROM_HERE,
5863 base::BindOnce(&WebContentsImpl::SendChangeLoadProgress,
5864 loading_weak_factory_.GetWeakPtr()),
fdegansa696e5112015-04-17 01:57:595865 min_delay);
5866}
5867
avid6d88b912017-01-13 00:16:005868std::vector<std::unique_ptr<NavigationThrottle>>
5869WebContentsImpl::CreateThrottlesForNavigation(
clamycbf524d42016-09-27 12:48:355870 NavigationHandle* navigation_handle) {
5871 return GetContentClient()->browser()->CreateThrottlesForNavigation(
5872 navigation_handle);
5873}
5874
clamy1e5574e2016-09-29 16:48:445875std::unique_ptr<NavigationUIData> WebContentsImpl::GetNavigationUIData(
5876 NavigationHandle* navigation_handle) {
clamy1e5574e2016-09-29 16:48:445877 return GetContentClient()->browser()->GetNavigationUIData(navigation_handle);
5878}
5879
pdr15f5b5b2017-06-20 00:58:005880void WebContentsImpl::DidCancelLoading() {
5881 controller_.DiscardNonCommittedEntries();
5882
5883 // Update the URL display.
5884 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
5885}
5886
[email protected]59167c22013-06-03 18:07:325887void WebContentsImpl::DidAccessInitialDocument() {
[email protected]b4c84012014-04-28 19:51:105888 has_accessed_initial_document_ = true;
5889
[email protected]d1371bf8e2014-04-19 03:26:245890 // We may have left a failed browser-initiated navigation in the address bar
5891 // to let the user edit it and try again. Clear it now that content might
5892 // show up underneath it.
5893 if (!IsLoading() && controller_.GetPendingEntry())
avi45a72532015-04-07 21:01:455894 controller_.DiscardPendingEntry(false);
[email protected]d1371bf8e2014-04-19 03:26:245895
[email protected]59167c22013-06-03 18:07:325896 // Update the URL display.
thestigc4cac8f2014-09-04 21:17:505897 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
[email protected]59167c22013-06-03 18:07:325898}
5899
alexmosbe2f4c32015-03-10 02:30:235900void WebContentsImpl::DidChangeName(RenderFrameHost* render_frame_host,
5901 const std::string& name) {
ericwilligersde386342016-10-19 02:35:095902 for (auto& observer : observers_)
5903 observer.FrameNameChanged(render_frame_host, name);
alexmosbe2f4c32015-03-10 02:30:235904}
5905
John Delaneyedd8d6c2019-01-25 00:23:575906void WebContentsImpl::DidReceiveFirstUserActivation(
5907 RenderFrameHost* render_frame_host) {
5908 for (auto& observer : observers_)
5909 observer.FrameReceivedFirstUserActivation(render_frame_host);
5910}
5911
John Delaney0146a742019-01-25 19:25:285912void WebContentsImpl::DidChangeDisplayState(RenderFrameHost* render_frame_host,
5913 bool is_display_none) {
5914 for (auto& observer : observers_)
5915 observer.FrameDisplayStateChanged(render_frame_host, is_display_none);
5916}
5917
5918void WebContentsImpl::FrameSizeChanged(RenderFrameHost* render_frame_host,
5919 const gfx::Size& frame_size) {
5920 for (auto& observer : observers_)
5921 observer.FrameSizeChanged(render_frame_host, frame_size);
5922}
5923
[email protected]39f2f9252014-05-03 00:54:015924void WebContentsImpl::DocumentOnLoadCompleted(
[email protected]50279492014-05-05 23:24:295925 RenderFrameHost* render_frame_host) {
falken52a56e32016-12-08 05:02:405926 ShowInsecureLocalhostWarningIfNeeded();
5927
creis97867aa2017-02-17 18:39:455928 is_notifying_observers_ = true;
ericwilligersde386342016-10-19 02:35:095929 for (auto& observer : observers_)
5930 observer.DocumentOnLoadCompletedInMainFrame();
creis97867aa2017-02-17 18:39:455931 is_notifying_observers_ = false;
[email protected]6578fef2013-10-14 02:35:095932
5933 // TODO(avi): Remove. http://crbug.com/170921
[email protected]8ff00d72012-10-23 19:12:215934 NotificationService::current()->Notify(
5935 NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
5936 Source<WebContents>(this),
[email protected]50279492014-05-05 23:24:295937 NotificationService::NoDetails());
[email protected]25497492010-09-11 15:15:085938}
5939
creis8eb8ef22015-11-04 22:51:385940void WebContentsImpl::UpdateStateForFrame(RenderFrameHost* render_frame_host,
5941 const PageState& page_state) {
creis8eb8ef22015-11-04 22:51:385942 // The state update affects the last NavigationEntry associated with the given
5943 // |render_frame_host|. This may not be the last committed NavigationEntry (as
5944 // in the case of an UpdateState from a frame being swapped out). We track
5945 // which entry this is in the RenderFrameHost's nav_entry_id.
5946 RenderFrameHostImpl* rfhi =
5947 static_cast<RenderFrameHostImpl*>(render_frame_host);
5948 NavigationEntryImpl* entry =
5949 controller_.GetEntryWithUniqueID(rfhi->nav_entry_id());
5950 if (!entry)
5951 return;
5952
5953 FrameNavigationEntry* frame_entry =
5954 entry->GetFrameEntry(rfhi->frame_tree_node());
5955 if (!frame_entry)
5956 return;
5957
creisd06a9422015-11-11 03:08:455958 // The SiteInstance might not match if we do a cross-process navigation with
5959 // replacement (e.g., auto-subframe), in which case the swap out of the old
5960 // RenderFrameHost runs in the background after the old FrameNavigationEntry
5961 // has already been replaced and destroyed.
5962 if (frame_entry->site_instance() != rfhi->GetSiteInstance())
5963 return;
5964
creis8eb8ef22015-11-04 22:51:385965 if (page_state == frame_entry->page_state())
5966 return; // Nothing to update.
5967
creis0cade2e2017-02-28 06:37:475968 DCHECK(page_state.IsValid()) << "Shouldn't set an empty PageState.";
nasko34634672016-07-29 18:46:065969
5970 // The document_sequence_number and item_sequence_number recorded in the
5971 // FrameNavigationEntry should not differ from the one coming with the update,
5972 // since it must come from the same document. Do not update it if a difference
5973 // is detected, as this indicates that |frame_entry| is not the correct one.
5974 ExplodedPageState exploded_state;
5975 if (!DecodePageState(page_state.ToEncodedData(), &exploded_state))
5976 return;
5977
5978 if (exploded_state.top.document_sequence_number !=
5979 frame_entry->document_sequence_number() ||
5980 exploded_state.top.item_sequence_number !=
5981 frame_entry->item_sequence_number()) {
5982 return;
5983 }
5984
nasko04a322f25a2016-09-01 00:00:345985 frame_entry->SetPageState(page_state);
creis8eb8ef22015-11-04 22:51:385986 controller_.NotifyEntryChanged(entry);
5987}
5988
[email protected]ef3adfc2014-05-11 00:04:545989void WebContentsImpl::UpdateTitle(RenderFrameHost* render_frame_host,
[email protected]ef3adfc2014-05-11 00:04:545990 const base::string16& title,
5991 base::i18n::TextDirection title_direction) {
[email protected]ef3adfc2014-05-11 00:04:545992 // Try to find the navigation entry, which might not be the current one.
avi286019ce2015-07-29 01:26:585993 // For example, it might be from a recently swapped out RFH.
avi1edc8552016-10-13 21:37:165994 NavigationEntryImpl* entry = controller_.GetEntryWithUniqueID(
creisad8c31a2016-05-24 17:07:045995 static_cast<RenderFrameHostImpl*>(render_frame_host)->nav_entry_id());
[email protected]ef3adfc2014-05-11 00:04:545996
5997 // We can handle title updates when we don't have an entry in
5998 // UpdateTitleForEntry, but only if the update is from the current RVH.
5999 // TODO(avi): Change to make decisions based on the RenderFrameHost.
avi286019ce2015-07-29 01:26:586000 if (!entry && render_frame_host != GetMainFrame())
[email protected]ef3adfc2014-05-11 00:04:546001 return;
6002
6003 // TODO(evan): make use of title_direction.
6004 // http://code.google.com/p/chromium/issues/detail?id=27094
afakhry6f0c1ec22016-07-14 13:55:136005 UpdateTitleForEntry(entry, title);
[email protected]ef3adfc2014-05-11 00:04:546006}
6007
6008void WebContentsImpl::UpdateEncoding(RenderFrameHost* render_frame_host,
6009 const std::string& encoding) {
6010 SetEncoding(encoding);
6011}
6012
[email protected]39f2f9252014-05-03 00:54:016013void WebContentsImpl::DocumentAvailableInMainFrame(
6014 RenderViewHost* render_view_host) {
ericwilligersde386342016-10-19 02:35:096015 for (auto& observer : observers_)
6016 observer.DocumentAvailableInMainFrame();
[email protected]39f2f9252014-05-03 00:54:016017}
naskoc0fceff2015-04-30 15:53:526018
[email protected]e1c3a552012-05-04 20:51:326019void WebContentsImpl::RouteCloseEvent(RenderViewHost* rvh) {
6020 // Tell the active RenderViewHost to run unload handlers and close, as long
6021 // as the request came from a RenderViewHost in the same BrowsingInstance.
6022 // In most cases, we receive this from a swapped out RenderViewHost.
6023 // It is possible to receive it from one that has just been swapped in,
6024 // in which case we might as well deliver the message anyway.
6025 if (rvh->GetSiteInstance()->IsRelatedSiteInstance(GetSiteInstance()))
naskoc0fceff2015-04-30 15:53:526026 ClosePage();
[email protected]e1c3a552012-05-04 20:51:326027}
6028
alexmose7da5a12015-04-09 02:22:166029bool WebContentsImpl::ShouldRouteMessageEvent(
6030 RenderFrameHost* target_rfh,
6031 SiteInstance* source_site_instance) const {
6032 // Allow the message if this WebContents is dedicated to a browser plugin
6033 // guest.
[email protected]0eba810b2012-10-18 03:19:366034 // Note: This check means that an embedder could theoretically receive a
6035 // postMessage from anyone (not just its own guests). However, this is
6036 // probably not a risk for apps since other pages won't have references
6037 // to App windows.
alexmose7da5a12015-04-09 02:22:166038 return GetBrowserPluginGuest() || GetBrowserPluginEmbedder();
6039}
[email protected]f546640b2012-05-15 00:03:496040
alexmos58729042015-06-18 23:20:006041void WebContentsImpl::EnsureOpenerProxiesExist(RenderFrameHost* source_rfh) {
alexmose7da5a12015-04-09 02:22:166042 WebContentsImpl* source_web_contents = static_cast<WebContentsImpl*>(
6043 WebContents::FromRenderFrameHost(source_rfh));
[email protected]f546640b2012-05-15 00:03:496044
alexmose7da5a12015-04-09 02:22:166045 if (source_web_contents) {
lazyboy6ec48b2a2015-06-29 15:18:146046 // If this message is going to outer WebContents from inner WebContents,
6047 // then we should not create a RenderView. AttachToOuterWebContentsFrame()
6048 // already created a RenderFrameProxyHost for that purpose.
6049 if (GetBrowserPluginEmbedder() &&
ekaramad1beabecc2016-09-23 20:18:176050 GuestMode::IsCrossProcessFrameGuest(source_web_contents)) {
lazyboy6ec48b2a2015-06-29 15:18:146051 return;
6052 }
6053
lfg812874d2016-02-09 22:26:136054 if (this != source_web_contents && GetBrowserPluginGuest()) {
naskob3041b98a42016-03-12 04:43:066055 // We create a RenderFrameProxyHost for the embedder in the guest's render
6056 // process but we intentionally do not expose the embedder's opener chain
6057 // to it.
6058 source_web_contents->GetRenderManager()->CreateRenderFrameProxy(
6059 GetSiteInstance());
[email protected]f546640b2012-05-15 00:03:496060 } else {
alexmos58729042015-06-18 23:20:006061 RenderFrameHostImpl* source_rfhi =
6062 static_cast<RenderFrameHostImpl*>(source_rfh);
6063 source_rfhi->frame_tree_node()->render_manager()->CreateOpenerProxies(
alexmos90325cf2015-09-02 17:18:396064 GetSiteInstance(), nullptr);
[email protected]f546640b2012-05-15 00:03:496065 }
6066 }
[email protected]f546640b2012-05-15 00:03:496067}
6068
Avi Drissmand18c51972018-08-15 18:32:096069void WebContentsImpl::ForSecurityDropFullscreen() {
Avi Drissman734edf82019-06-20 22:10:106070 // There are two chains of WebContents to kick out of fullscreen.
6071 //
6072 // Chain 1, the inner/outer WebContents chain. If an inner WebContents has
6073 // done something that requires the browser to drop fullscreen, drop
6074 // fullscreen from it and any outer WebContents that may be in fullscreen.
6075 //
6076 // Chain 2, the opener WebContents chain. If a WebContents has done something
6077 // that requires the browser to drop fullscreen, drop fullscreen from any
6078 // WebContents that was involved in the chain of opening it.
6079 //
6080 // Note that these two chains don't interact, as only a top-level WebContents
6081 // can have an opener. This simplifies things.
6082
6083 WebContents* web_contents = this;
Avi Drissmand18c51972018-08-15 18:32:096084 while (web_contents) {
6085 if (web_contents->IsFullscreenForCurrentTab())
6086 web_contents->ExitFullscreen(true);
Avi Drissman734edf82019-06-20 22:10:106087
6088 if (web_contents->HasOriginalOpener())
6089 web_contents = FromRenderFrameHost(web_contents->GetOriginalOpener());
6090 else
6091 web_contents = web_contents->GetOuterWebContents();
Avi Drissmand18c51972018-08-15 18:32:096092 }
6093}
6094
avallee9993fca2016-11-17 06:16:506095void WebContentsImpl::SetAsFocusedWebContentsIfNecessary() {
6096 // Only change focus if we are not currently focused.
6097 WebContentsImpl* old_contents = GetFocusedWebContents();
6098 if (old_contents == this)
6099 return;
6100
paulmeyerfeafc2d2017-04-25 21:46:406101 GetOutermostWebContents()->node_.SetFocusedWebContents(this);
6102
Greg Thompsonfb957602017-09-04 10:25:526103 if (!GuestMode::IsCrossProcessFrameGuest(this) && browser_plugin_guest_)
paulmeyerfeafc2d2017-04-25 21:46:406104 return;
6105
avallee9993fca2016-11-17 06:16:506106 // Send a page level blur to the old contents so that it displays inactive UI
6107 // and focus this contents to activate it.
6108 if (old_contents)
6109 old_contents->GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(false);
avalleec2ff1ef2017-01-21 00:12:306110
6111 // Make sure the outer web contents knows our frame is focused. Otherwise, the
6112 // outer renderer could have the element before or after the frame element
6113 // focused which would return early without actually advancing focus.
avalleed68cdd12017-06-21 22:07:276114 FocusOuterAttachmentFrameChain();
avalleec2ff1ef2017-01-21 00:12:306115
lfg1453e412017-04-11 00:48:506116 if (ShowingInterstitialPage()) {
creisadca9862017-06-16 19:12:116117 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:506118 ->GetRenderWidgetHost()
6119 ->SetPageFocus(true);
6120 } else {
6121 GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(true);
6122 }
avallee9993fca2016-11-17 06:16:506123}
6124
avallee0206f782016-07-28 18:55:336125void WebContentsImpl::SetFocusedFrame(FrameTreeNode* node,
6126 SiteInstance* source) {
avallee0206f782016-07-28 18:55:336127 frame_tree_.SetFocusedFrame(node, source);
avalleed68cdd12017-06-21 22:07:276128
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576129 if (auto* inner_contents = node_.GetInnerWebContentsInFrame(node)) {
6130 // |this| is an outer WebContents and |node| represents an inner
6131 // WebContents. Transfer the focus to the inner contents if |this| is
6132 // focused.
6133 if (GetFocusedWebContents() == this)
6134 inner_contents->SetAsFocusedWebContentsIfNecessary();
6135 } else if (node_.OuterContentsFrameTreeNode() &&
6136 node_.OuterContentsFrameTreeNode()
6137 ->current_frame_host()
6138 ->GetSiteInstance() == source) {
6139 // |this| is an inner WebContents, |node| is its main FrameTreeNode and
6140 // the outer WebContents FrameTreeNode is at |source|'s SiteInstance.
6141 // Transfer the focus to the inner WebContents if the outer WebContents is
6142 // focused. This branch is used when an inner WebContents is focused through
6143 // its RenderFrameProxyHost (via FrameHostMsg_FrameFocused IPC, used to
6144 // implement the window.focus() API).
6145 if (GetFocusedWebContents() == GetOuterWebContents())
6146 SetAsFocusedWebContentsIfNecessary();
6147 } else if (!GetOuterWebContents()) {
6148 // This is an outermost WebContents.
6149 SetAsFocusedWebContentsIfNecessary();
6150 } else if (!GuestMode::IsCrossProcessFrameGuest(this) &&
6151 GetOuterWebContents()) {
6152 // TODO(lfg, paulmeyer): Allows BrowserPlugins to set themselves as the
6153 // focused WebContents. This works around a bug in FindRequestManager that
6154 // doesn't support properly traversing BrowserPlugins.
6155 SetAsFocusedWebContentsIfNecessary();
6156 }
avalleed68cdd12017-06-21 22:07:276157}
6158
Avi Drissman36f801f2018-02-01 20:06:046159void WebContentsImpl::DidCallFocus() {
6160 // Any explicit focusing of another window while this WebContents is in
6161 // fullscreen can be used to confuse the user, so drop fullscreen.
Avi Drissmand18c51972018-08-15 18:32:096162 ForSecurityDropFullscreen();
Avi Drissman36f801f2018-02-01 20:06:046163}
6164
avalleed68cdd12017-06-21 22:07:276165RenderFrameHost* WebContentsImpl::GetFocusedFrameIncludingInnerWebContents() {
6166 WebContentsImpl* contents = this;
6167 FrameTreeNode* focused_node = contents->frame_tree_.GetFocusedFrame();
6168
6169 // If there is no focused frame in the outer WebContents, we need to return
6170 // null.
6171 if (!focused_node)
6172 return nullptr;
6173
6174 // If the focused frame is embedding an inner WebContents, we must descend
6175 // into that contents. If the current WebContents does not have a focused
6176 // frame, return the main frame of this contents instead of the focused empty
6177 // frame embedding this contents.
6178 while (true) {
6179 contents = contents->node_.GetInnerWebContentsInFrame(focused_node);
6180 if (!contents)
6181 return focused_node->current_frame_host();
6182
6183 focused_node = contents->frame_tree_.GetFocusedFrame();
6184 if (!focused_node)
6185 return contents->GetMainFrame();
6186 }
avallee0206f782016-07-28 18:55:336187}
6188
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:576189void WebContentsImpl::OnAdvanceFocus(RenderFrameHostImpl* source_rfh) {
6190 // When a RenderFrame needs to advance focus to a RenderFrameProxy (by hitting
6191 // TAB), the RenderFrameProxy sends an IPC to RenderFrameProxyHost. When this
6192 // RenderFrameProxyHost represents an inner WebContents, the outer WebContents
6193 // needs to focus the inner WebContents.
6194 if (GetOuterWebContents() &&
6195 GetOuterWebContents() == source_rfh->delegate()->GetAsWebContents() &&
6196 GetFocusedWebContents() == GetOuterWebContents()) {
6197 SetAsFocusedWebContentsIfNecessary();
6198 }
6199}
6200
ekaramada110f642016-12-21 19:47:286201void WebContentsImpl::OnFocusedElementChangedInFrame(
6202 RenderFrameHostImpl* frame,
6203 const gfx::Rect& bounds_in_root_view) {
6204 RenderWidgetHostViewBase* root_view =
6205 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
6206 if (!root_view || !frame->GetView())
6207 return;
6208
6209 // Converting to screen coordinates.
6210 gfx::Point origin = bounds_in_root_view.origin();
6211 origin += root_view->GetViewBounds().OffsetFromOrigin();
6212 gfx::Rect bounds_in_screen(origin, bounds_in_root_view.size());
6213
6214 root_view->FocusedNodeChanged(frame->has_focused_editable_element(),
6215 bounds_in_screen);
6216
6217 FocusedNodeDetails details = {frame->has_focused_editable_element(),
6218 bounds_in_screen};
6219
6220 // TODO(ekaramad): We should replace this with an observer notification
6221 // (https://crbug.com/675975).
6222 NotificationService::current()->Notify(
6223 NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
6224 Source<RenderViewHost>(GetRenderViewHost()),
6225 Details<FocusedNodeDetails>(&details));
6226}
6227
Lowell Manners1de5242e2019-04-25 10:18:466228bool WebContentsImpl::DidAddMessageToConsole(
6229 blink::mojom::ConsoleMessageLevel log_level,
6230 const base::string16& message,
6231 int32_t line_no,
6232 const base::string16& source_id) {
[email protected]a796f202012-05-30 14:14:256233 if (!delegate_)
6234 return false;
Lowell Manners1de5242e2019-04-25 10:18:466235 return delegate_->DidAddMessageToConsole(this, log_level, message, line_no,
avia90ae4e2016-11-11 20:49:336236 source_id);
[email protected]a796f202012-05-30 14:14:256237}
6238
Daniel Cheng90196c82018-04-25 21:49:146239void WebContentsImpl::DidReceiveInputEvent(
dominickn9c7ceaa32016-02-27 01:52:536240 RenderWidgetHostImpl* render_widget_host,
6241 const blink::WebInputEvent::Type type) {
Dominick Ng37a15052018-07-17 23:56:356242 if (!IsUserInteractionInputType(type))
Daniel Cheng90196c82018-04-25 21:49:146243 return;
6244
kenrb19221852016-04-29 17:21:406245 // Ignore unless the widget is currently in the frame tree.
6246 if (!HasMatchingWidgetHost(&frame_tree_, render_widget_host))
avic3aa8422015-11-09 20:57:226247 return;
6248
Daniel Cheng90196c82018-04-25 21:49:146249 if (type != blink::WebInputEvent::kGestureScrollBegin)
6250 last_interactive_input_event_time_ = ui::EventTimeForNow();
dominickn9c7ceaa32016-02-27 01:52:536251
Dominick Ng37a15052018-07-17 23:56:356252 for (auto& observer : observers_)
6253 observer.DidGetUserInteraction(type);
6254
6255 if (IsResourceLoadUserInteractionInputType(type))
6256 SendUserGestureForResourceDispatchHost();
dominickn2dd142dd2015-10-29 05:30:506257}
6258
Avi Drissman738ea192018-08-29 20:24:166259bool WebContentsImpl::ShouldIgnoreInputEvents() {
6260 WebContentsImpl* web_contents = this;
6261 while (web_contents) {
6262 if (web_contents->ignore_input_events_)
6263 return true;
6264 web_contents = web_contents->GetOuterWebContents();
6265 }
6266
6267 return false;
6268}
6269
avallee9993fca2016-11-17 06:16:506270void WebContentsImpl::FocusOwningWebContents(
6271 RenderWidgetHostImpl* render_widget_host) {
6272 // The PDF plugin still runs as a BrowserPlugin and must go through the
6273 // input redirection mechanism. It must not become focused direcly.
6274 if (!GuestMode::IsCrossProcessFrameGuest(this) && browser_plugin_guest_)
6275 return;
6276
6277 RenderWidgetHostImpl* focused_widget =
6278 GetFocusedRenderWidgetHost(render_widget_host);
6279
6280 if (focused_widget != render_widget_host &&
avallee8e881592016-11-19 00:39:306281 (!focused_widget ||
6282 focused_widget->delegate() != render_widget_host->delegate())) {
avallee9993fca2016-11-17 06:16:506283 SetAsFocusedWebContentsIfNecessary();
6284 }
6285}
6286
[email protected]b172aee2012-04-10 17:05:266287void WebContentsImpl::OnIgnoredUIEvent() {
[email protected]31145092011-09-30 01:49:446288 // Notify observers.
ericwilligersde386342016-10-19 02:35:096289 for (auto& observer : observers_)
6290 observer.DidGetIgnoredUIEvent();
[email protected]fa1cf0b82010-01-15 21:49:446291}
6292
avic3aa8422015-11-09 20:57:226293void WebContentsImpl::RendererUnresponsive(
Lukasz Anforowicz52b93722018-06-20 16:11:396294 RenderWidgetHostImpl* render_widget_host,
6295 base::RepeatingClosure hang_monitor_restarter) {
avic031d392017-03-03 03:09:426296 if (ShouldIgnoreUnresponsiveRenderer())
[email protected]e5fc1632011-08-08 07:51:536297 return;
6298
Lukasz Anforowicz4f0593d2018-09-21 18:33:546299 // Do not report hangs (to task manager, to hang renderer dialog, etc.) for
6300 // invisible tabs (like extension background page, background tabs). See
6301 // https://crbug.com/881812 for rationale and for choosing the visibility
6302 // (rather than process priority) as the signal here.
6303 if (GetVisibility() != Visibility::VISIBLE)
6304 return;
6305
Avi Drissman8920def2018-01-31 19:53:366306 if (!render_widget_host->renderer_initialized())
[email protected]55452902011-06-01 21:57:476307 return;
6308
Lukasz Anforowicz4f0593d2018-09-21 18:33:546309 for (auto& observer : observers_)
6310 observer.OnRendererUnresponsive(render_widget_host->GetProcess());
6311
Dave Tapuskac6146c52017-12-20 22:48:156312 if (delegate_)
Lukasz Anforowicz52b93722018-06-20 16:11:396313 delegate_->RendererUnresponsive(this, render_widget_host,
6314 std::move(hang_monitor_restarter));
[email protected]420ae012009-04-24 05:16:326315}
6316
avic3aa8422015-11-09 20:57:226317void WebContentsImpl::RendererResponsive(
6318 RenderWidgetHostImpl* render_widget_host) {
[email protected]6934a702011-12-20 00:04:516319 if (delegate_)
Avi Drissman1572e8c3c2018-02-02 19:06:366320 delegate_->RendererResponsive(this, render_widget_host);
[email protected]420ae012009-04-24 05:16:326321}
6322
Alex Moshchuk7b4f0652019-05-30 18:54:416323void WebContentsImpl::SubframeCrashed(
6324 blink::mojom::FrameVisibility visibility) {
6325 // If a subframe crashed on a hidden tab, mark the tab for reload to avoid
6326 // showing a sad frame to the user if they ever switch back to that tab. Do
6327 // this for subframes that are either visible in viewport or visible but
6328 // scrolled out of view, but skip subframes that are not rendered (e.g., via
6329 // "display:none"), since in that case the user wouldn't see a sad frame
6330 // anyway.
6331 bool did_mark_for_reload = false;
6332 if (IsHidden() && visibility != blink::mojom::FrameVisibility::kNotRendered &&
6333 base::FeatureList::IsEnabled(
6334 features::kReloadHiddenTabsWithCrashedSubframes)) {
6335 controller_.SetNeedsReload(
6336 NavigationControllerImpl::NeedsReloadType::kCrashedSubframe);
6337 did_mark_for_reload = true;
6338 UMA_HISTOGRAM_ENUMERATION(
6339 "Stability.ChildFrameCrash.TabMarkedForReload.Visibility", visibility);
6340 }
6341
6342 UMA_HISTOGRAM_BOOLEAN("Stability.ChildFrameCrash.TabMarkedForReload",
6343 did_mark_for_reload);
6344}
6345
[email protected]b172aee2012-04-10 17:05:266346void WebContentsImpl::BeforeUnloadFiredFromRenderManager(
[email protected]feaded02012-09-25 19:12:556347 bool proceed, const base::TimeTicks& proceed_time,
[email protected]420ae012009-04-24 05:16:326348 bool* proceed_to_fire_unload) {
ericwilligersde386342016-10-19 02:35:096349 for (auto& observer : observers_)
Chris Hamilton3b3e315d2018-09-19 13:16:216350 observer.BeforeUnloadFired(proceed, proceed_time);
[email protected]6934a702011-12-20 00:04:516351 if (delegate_)
6352 delegate_->BeforeUnloadFired(this, proceed, proceed_to_fire_unload);
[email protected]e80af492013-06-24 21:52:096353 // Note: |this| might be deleted at this point.
[email protected]420ae012009-04-24 05:16:326354}
6355
[email protected]58d5cfe2013-07-10 02:40:526356void WebContentsImpl::RenderProcessGoneFromRenderManager(
[email protected]3a3d47472010-07-15 21:03:546357 RenderViewHost* render_view_host) {
[email protected]443b80e2010-12-14 00:42:236358 DCHECK(crashed_status_ != base::TERMINATION_STATUS_STILL_RUNNING);
[email protected]ec6a7eb2013-04-22 17:34:226359 RenderViewTerminated(render_view_host, crashed_status_, crashed_error_code_);
[email protected]3a3d47472010-07-15 21:03:546360}
6361
Jianzhou Fengd8720c72018-01-18 03:06:306362void WebContentsImpl::UpdateRenderViewSizeForRenderManager(bool is_main_frame) {
[email protected]8643e6d2012-01-18 20:26:106363 // TODO(brettw) this is a hack. See WebContentsView::SizeContents.
Jianzhou Fengd8720c72018-01-18 03:06:306364 gfx::Size size = GetSizeForNewRenderView(is_main_frame);
[email protected]0323ee42010-02-17 22:03:266365 // 0x0 isn't a valid window size (minimal window size is 1x1) but it may be
6366 // here during container initialization and normal window size will be set
6367 // later. In case of tab duplication this resizing to 0x0 prevents setting
6368 // normal size later so just ignore it.
6369 if (!size.IsEmpty())
6370 view_->SizeContents(size);
[email protected]420ae012009-04-24 05:16:326371}
6372
[email protected]af905902013-10-01 21:38:516373void WebContentsImpl::CancelModalDialogsForRenderManager() {
6374 // We need to cancel modal dialogs when doing a process swap, since the load
avi2460c762015-04-17 15:21:546375 // deferrer would prevent us from swapping out. We also clear the state
6376 // because this is a cross-process navigation, which means that it's a new
6377 // site that should not have to pay for the sins of its predecessor.
creis89a0f782015-05-27 16:13:176378 //
Lei Zhang6410ec1a2019-01-31 21:38:586379 // Note that we don't bother telling |browser_plugin_embedder_| because the
creis89a0f782015-05-27 16:13:176380 // cross-process navigation will either destroy the browser plugins or not
6381 // require their dialogs to close.
avi5d3b8692016-10-12 22:00:466382 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:536383 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:466384 }
[email protected]af905902013-10-01 21:38:516385}
6386
[email protected]02d7b6e2014-06-24 21:01:506387void WebContentsImpl::NotifySwappedFromRenderManager(RenderFrameHost* old_host,
6388 RenderFrameHost* new_host,
6389 bool is_main_frame) {
6390 if (is_main_frame) {
naskof5940b9f2015-03-02 23:04:056391 NotifyViewSwapped(old_host ? old_host->GetRenderViewHost() : nullptr,
[email protected]02d7b6e2014-06-24 21:01:506392 new_host->GetRenderViewHost());
[email protected]a6b73c62013-02-11 23:05:086393
[email protected]02d7b6e2014-06-24 21:01:506394 // Make sure the visible RVH reflects the new delegate's preferences.
6395 if (delegate_)
6396 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]d56a49e2013-02-23 00:47:396397
dmazzoni62111452017-04-28 23:46:556398 RenderWidgetHostViewBase* rwhv =
6399 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
6400 if (rwhv)
6401 rwhv->SetMainFrameAXTreeID(GetMainFrame()->GetAXTreeID());
[email protected]02d7b6e2014-06-24 21:01:506402 }
6403
Jinsuk Kim895b2c52018-07-03 06:49:166404 NotifyFrameSwapped(old_host, new_host, is_main_frame);
[email protected]3a3d47472010-07-15 21:03:546405}
6406
naskof5940b9f2015-03-02 23:04:056407void WebContentsImpl::NotifyMainFrameSwappedFromRenderManager(
Jinsuk Kim895b2c52018-07-03 06:49:166408 RenderFrameHost* old_host,
6409 RenderFrameHost* new_host) {
6410 NotifyViewSwapped(old_host ? old_host->GetRenderViewHost() : nullptr,
6411 new_host->GetRenderViewHost());
naskof5940b9f2015-03-02 23:04:056412}
6413
[email protected]b172aee2012-04-10 17:05:266414NavigationControllerImpl& WebContentsImpl::GetControllerForRenderManager() {
[email protected]d1198fd2012-08-13 22:50:196415 return GetController();
[email protected]3a3d47472010-07-15 21:03:546416}
6417
dcheng59716272016-04-09 05:19:086418std::unique_ptr<WebUIImpl> WebContentsImpl::CreateWebUIForRenderFrameHost(
carlosk37f793792014-11-27 15:08:296419 const GURL& url) {
Dan Beam055fe8f2017-10-04 23:23:366420 return CreateWebUI(url);
[email protected]420ae012009-04-24 05:16:326421}
6422
[email protected]10f417c52011-12-28 21:04:236423NavigationEntry*
[email protected]b172aee2012-04-10 17:05:266424 WebContentsImpl::GetLastCommittedNavigationEntryForRenderManager() {
[email protected]420ae012009-04-24 05:16:326425 return controller_.GetLastCommittedEntry();
6426}
6427
creisadca9862017-06-16 19:12:116428InterstitialPageImpl* WebContentsImpl::GetInterstitialForRenderManager() {
6429 return interstitial_page_;
6430}
6431
lfgbede6392015-09-11 21:54:066432void WebContentsImpl::CreateRenderWidgetHostViewForRenderManager(
6433 RenderViewHost* render_view_host) {
lfgc740d4b22016-04-15 16:45:336434 RenderWidgetHostViewBase* rwh_view =
6435 view_->CreateViewForWidget(render_view_host->GetWidget(), false);
[email protected]1a98a932009-11-17 00:12:526436
[email protected]420ae012009-04-24 05:16:326437 // Now that the RenderView has been created, we need to tell it its size.
[email protected]245f7d52011-11-28 15:36:446438 if (rwh_view)
Jianzhou Fengd8720c72018-01-18 03:06:306439 rwh_view->SetSize(GetSizeForNewRenderView(true));
lfgbede6392015-09-11 21:54:066440}
6441
6442bool WebContentsImpl::CreateRenderViewForRenderManager(
6443 RenderViewHost* render_view_host,
6444 int opener_frame_routing_id,
6445 int proxy_routing_id,
Pavel Feldman25234722017-10-11 02:49:066446 const base::UnguessableToken& devtools_frame_token,
lfgbede6392015-09-11 21:54:066447 const FrameReplicationState& replicated_frame_state) {
6448 TRACE_EVENT0("browser,navigation",
6449 "WebContentsImpl::CreateRenderViewForRenderManager");
6450
piman00cf9402017-04-03 17:09:206451 if (proxy_routing_id == MSG_ROUTING_NONE)
lfg9431efd2016-12-14 14:45:266452 CreateRenderWidgetHostViewForRenderManager(render_view_host);
lfg9431efd2016-12-14 14:45:266453
piman00cf9402017-04-03 17:09:206454 if (!static_cast<RenderViewHostImpl*>(render_view_host)
6455 ->CreateRenderView(opener_frame_routing_id, proxy_routing_id,
Pavel Feldman25234722017-10-11 02:49:066456 devtools_frame_token, replicated_frame_state,
6457 created_with_opener_)) {
[email protected]a4127722011-04-27 23:13:526458 return false;
[email protected]14392a52012-05-02 20:28:446459 }
W. James MacLean62198672019-06-04 16:46:106460 // Set the TextAutosizer state from the main frame's renderer on the new view,
6461 // but only if it's not for the main frame. Main frame renderers should create
6462 // this state themselves from up-to-date values, so we shouldn't override it
6463 // with the cached values.
6464 if (!render_view_host->GetMainFrame()) {
6465 render_view_host->Send(
6466 new PageMsg_UpdateTextAutosizerPageInfoForRemoteMainFrames(
6467 render_view_host->GetRoutingID(), text_autosizer_page_info_));
6468 }
[email protected]a4127722011-04-27 23:13:526469
Lucas Furukawa Gadaniaed1fed2017-10-13 17:34:146470 if (proxy_routing_id == MSG_ROUTING_NONE && node_.outer_web_contents())
6471 ReattachToOuterWebContentsFrame();
6472
avi2b177592014-12-10 02:08:026473 SetHistoryOffsetAndLengthForView(render_view_host,
6474 controller_.GetLastCommittedEntryIndex(),
6475 controller_.GetEntryCount());
6476
[email protected]a220b5932013-09-21 03:47:446477#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
[email protected]f8233cc2011-05-31 20:24:506478 // Force a ViewMsg_Resize to be sent, needed to make plugins show up on
6479 // linux. See crbug.com/83941.
avif9ab5d942015-10-15 14:05:446480 RenderWidgetHostView* rwh_view = render_view_host->GetWidget()->GetView();
[email protected]245f7d52011-11-28 15:36:446481 if (rwh_view) {
6482 if (RenderWidgetHost* render_widget_host = rwh_view->GetRenderWidgetHost())
Fady Samuel0b911822018-04-25 13:22:166483 render_widget_host->SynchronizeVisualProperties();
[email protected]245f7d52011-11-28 15:36:446484 }
[email protected]f8233cc2011-05-31 20:24:506485#endif
6486
[email protected]420ae012009-04-24 05:16:326487 return true;
6488}
6489
[email protected]82307f6b2014-08-07 03:30:126490bool WebContentsImpl::CreateRenderFrameForRenderManager(
6491 RenderFrameHost* render_frame_host,
arthursonzogni1efc7b962019-03-14 09:36:336492 int previous_routing_id,
alexmosa181efc2015-09-03 00:39:046493 int opener_routing_id,
japhete6adf142014-10-31 00:01:496494 int parent_routing_id,
alexmosa181efc2015-09-03 00:39:046495 int previous_sibling_routing_id) {
naskob8744d22014-08-28 17:07:436496 TRACE_EVENT0("browser,navigation",
6497 "WebContentsImpl::CreateRenderFrameForRenderManager");
[email protected]82307f6b2014-08-07 03:30:126498
6499 RenderFrameHostImpl* rfh =
6500 static_cast<RenderFrameHostImpl*>(render_frame_host);
arthursonzogni1efc7b962019-03-14 09:36:336501 if (!rfh->CreateRenderFrame(previous_routing_id, opener_routing_id,
alexmosa181efc2015-09-03 00:39:046502 parent_routing_id, previous_sibling_routing_id))
[email protected]82307f6b2014-08-07 03:30:126503 return false;
6504
6505 // TODO(nasko): When RenderWidgetHost is owned by RenderFrameHost, the passed
6506 // RenderFrameHost will have to be associated with the appropriate
6507 // RenderWidgetHostView or a new one should be created here.
6508
6509 return true;
6510}
6511
mfomitchev2b8b066a2016-01-28 19:23:156512#if defined(OS_ANDROID)
[email protected]fc2b46b2014-05-03 16:33:456513
[email protected]155c7f22013-12-09 17:07:186514base::android::ScopedJavaLocalRef<jobject>
6515WebContentsImpl::GetJavaWebContents() {
mostynb042582e2015-03-16 22:13:406516 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]0e813a52014-08-13 10:34:566517 return GetWebContentsAndroid()->GetJavaObject();
6518}
[email protected]155c7f22013-12-09 17:07:186519
[email protected]0e813a52014-08-13 10:34:566520WebContentsAndroid* WebContentsImpl::GetWebContentsAndroid() {
Kevin McNee576bb5d82019-05-29 16:47:516521 if (!web_contents_android_) {
6522 web_contents_android_ = std::make_unique<WebContentsAndroid>(this);
[email protected]155c7f22013-12-09 17:07:186523 }
Kevin McNee576bb5d82019-05-29 16:47:516524 return web_contents_android_.get();
6525}
6526
6527void WebContentsImpl::ClearWebContentsAndroid() {
6528 DCHECK_CURRENTLY_ON(BrowserThread::UI);
6529 web_contents_android_.reset();
[email protected]155c7f22013-12-09 17:07:186530}
6531
paulmeyerc0b762b2016-04-13 11:55:176532void WebContentsImpl::ActivateNearestFindResult(float x,
6533 float y) {
6534 GetOrCreateFindRequestManager()->ActivateNearestFindResult(x, y);
6535}
6536
6537void WebContentsImpl::RequestFindMatchRects(int current_version) {
6538 GetOrCreateFindRequestManager()->RequestFindMatchRects(current_version);
6539}
6540
[email protected]7d244f12013-08-22 21:41:516541bool WebContentsImpl::CreateRenderViewForInitialEmptyDocument() {
nasko4c0feb62015-06-05 18:37:066542 return CreateRenderViewForRenderManager(
6543 GetRenderViewHost(), MSG_ROUTING_NONE, MSG_ROUTING_NONE,
Pavel Feldman25234722017-10-11 02:49:066544 frame_tree_.root()->devtools_frame_token(),
lfgbede6392015-09-11 21:54:066545 frame_tree_.root()->current_replication_state());
[email protected]7d244f12013-08-22 21:41:516546}
[email protected]fc2b46b2014-05-03 16:33:456547
rockot400ea35b2016-10-15 19:15:326548service_manager::InterfaceProvider* WebContentsImpl::GetJavaInterfaces() {
sammcf5f1b0f2016-09-20 23:05:116549 if (!java_interfaces_) {
rockot400ea35b2016-10-15 19:15:326550 service_manager::mojom::InterfaceProviderPtr provider;
blundelle0a9f1582016-12-20 11:23:326551 BindInterfaceRegistryForWebContents(mojo::MakeRequest(&provider), this);
rockot400ea35b2016-10-15 19:15:326552 java_interfaces_.reset(new service_manager::InterfaceProvider);
sammcf5f1b0f2016-09-20 23:05:116553 java_interfaces_->Bind(std::move(provider));
6554 }
6555 return java_interfaces_.get();
6556}
6557
Francois Doray6c26f3342018-08-24 17:17:226558#endif
6559
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:416560bool WebContentsImpl::CompletedFirstVisuallyNonEmptyPaint() {
spqchane72c3cb2017-06-30 23:02:106561 return did_first_visually_non_empty_paint_;
6562}
6563
pkotwicz75ca8ffd2016-02-16 23:10:196564void WebContentsImpl::OnDidDownloadImage(
Avi Drissmana5a52dd2018-03-27 03:39:026565 ImageDownloadCallback callback,
pkotwicz75ca8ffd2016-02-16 23:10:196566 int id,
6567 const GURL& image_url,
leon.hancbc4bc3c2016-02-26 07:08:526568 int32_t http_status_code,
leon.hanc2228532016-08-16 05:59:186569 const std::vector<SkBitmap>& images,
6570 const std::vector<gfx::Size>& original_image_sizes) {
Avi Drissmana5a52dd2018-03-27 03:39:026571 std::move(callback).Run(id, http_status_code, image_url, images,
6572 original_image_sizes);
pkotwicz75ca8ffd2016-02-16 23:10:196573}
6574
[email protected]6fba26d2014-04-29 09:38:286575void WebContentsImpl::OnDialogClosed(int render_process_id,
6576 int render_frame_id,
[email protected]b172aee2012-04-10 17:05:266577 IPC::Message* reply_msg,
[email protected]87de04b02014-04-08 22:14:496578 bool dialog_was_suppressed,
[email protected]b172aee2012-04-10 17:05:266579 bool success,
[email protected]fcf75d42013-12-03 20:11:266580 const base::string16& user_input) {
[email protected]6fba26d2014-04-29 09:38:286581 RenderFrameHostImpl* rfh = RenderFrameHostImpl::FromID(render_process_id,
6582 render_frame_id);
[email protected]87de04b02014-04-08 22:14:496583 last_dialog_suppressed_ = dialog_was_suppressed;
6584
[email protected]beb440c2009-11-06 04:08:546585 if (is_showing_before_unload_dialog_ && !success) {
clamybc6f4152016-04-01 20:14:236586 // It is possible for the current RenderFrameHost to have changed in the
6587 // meantime. Do not reset the navigation state in that case.
6588 if (rfh && rfh == rfh->frame_tree_node()->current_frame_host()) {
clamy44e84ce2016-02-22 15:38:256589 rfh->frame_tree_node()->BeforeUnloadCanceled();
clamybc6f4152016-04-01 20:14:236590 controller_.DiscardNonCommittedEntries();
6591 }
[email protected]ec8e8b02013-06-19 04:57:106592
Charles Reis15d60b132017-11-03 17:43:476593 // Update the URL display either way, to avoid showing a stale URL.
6594 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
6595
ericwilligersde386342016-10-19 02:35:096596 for (auto& observer : observers_)
6597 observer.BeforeUnloadDialogCancelled();
[email protected]beb440c2009-11-06 04:08:546598 }
[email protected]87de04b02014-04-08 22:14:496599
[email protected]6fba26d2014-04-29 09:38:286600 if (rfh) {
avi44acfaa82017-05-03 22:55:356601 rfh->JavaScriptDialogClosed(reply_msg, success, user_input);
Pavel Feldman3c1842b2017-08-02 05:00:166602
6603 std::vector<protocol::PageHandler*> page_handlers =
6604 protocol::PageHandler::EnabledForWebContents(this);
6605 for (auto* handler : page_handlers)
6606 handler->DidCloseJavaScriptDialog(success, user_input);
6607
[email protected]6fba26d2014-04-29 09:38:286608 } else {
6609 // Don't leak the sync IPC reply if the RFH or process is gone.
6610 delete reply_msg;
6611 }
avi1c51fb62017-02-27 20:43:036612
6613 is_showing_javascript_dialog_ = false;
6614 is_showing_before_unload_dialog_ = false;
[email protected]beb440c2009-11-06 04:08:546615}
6616
[email protected]b172aee2012-04-10 17:05:266617void WebContentsImpl::SetEncoding(const std::string& encoding) {
[email protected]ef3adfc2014-05-11 00:04:546618 if (encoding == last_reported_encoding_)
6619 return;
6620 last_reported_encoding_ = encoding;
6621
jinsukkim79df88a2017-01-04 06:26:156622 canonical_encoding_ = base::GetCanonicalEncodingNameByAliasName(encoding);
[email protected]aacd7cc2009-09-02 14:51:106623}
[email protected]f45d2a72010-03-08 23:28:356624
[email protected]1ac10dca2013-08-20 20:47:046625bool WebContentsImpl::IsHidden() {
Francois Doraye6161152018-03-27 22:05:376626 return !IsBeingCaptured() && visibility_ != Visibility::VISIBLE;
[email protected]1ac10dca2013-08-20 20:47:046627}
6628
rob97250742015-12-10 17:45:156629int WebContentsImpl::GetOuterDelegateFrameTreeNodeId() {
lfg601233692017-03-06 22:45:446630 return node_.outer_contents_frame_tree_node_id();
lazyboy6ec48b2a2015-06-29 15:18:146631}
6632
ekaramadaeb3c5c2016-11-09 03:22:356633RenderWidgetHostImpl* WebContentsImpl::GetFullscreenRenderWidgetHost() const {
6634 return RenderWidgetHostImpl::FromID(fullscreen_widget_process_id_,
6635 fullscreen_widget_routing_id_);
6636}
6637
[email protected]b0936d22013-11-28 06:47:366638RenderFrameHostManager* WebContentsImpl::GetRenderManager() const {
[email protected]fa944cb82013-11-15 17:51:216639 return frame_tree_.root()->render_manager();
6640}
6641
[email protected]f8497342013-02-05 22:15:026642BrowserPluginGuest* WebContentsImpl::GetBrowserPluginGuest() const {
[email protected]7a846df2012-09-20 19:17:396643 return browser_plugin_guest_.get();
6644}
6645
Albert J. Wongc55cc64d2018-10-12 02:50:046646void WebContentsImpl::SetBrowserPluginGuest(
6647 std::unique_ptr<BrowserPluginGuest> guest) {
6648 DCHECK(!browser_plugin_guest_);
6649 DCHECK(guest);
6650 browser_plugin_guest_ = std::move(guest);
[email protected]738f57a2013-06-29 21:06:546651}
6652
Aidan Wolter52bcc12a2018-11-14 03:27:296653base::UnguessableToken WebContentsImpl::GetAudioGroupId() {
6654 if (!base::FeatureList::IsEnabled(features::kAudioServiceAudioStreams))
6655 return base::UnguessableToken::Null();
6656
6657 return GetAudioStreamFactory()->group_id();
6658}
6659
[email protected]f8497342013-02-05 22:15:026660BrowserPluginEmbedder* WebContentsImpl::GetBrowserPluginEmbedder() const {
[email protected]7a846df2012-09-20 19:17:396661 return browser_plugin_embedder_.get();
6662}
[email protected]8ff00d72012-10-23 19:12:216663
fsamuel60b42282015-03-10 03:29:146664void WebContentsImpl::CreateBrowserPluginEmbedderIfNecessary() {
6665 if (browser_plugin_embedder_)
6666 return;
6667 browser_plugin_embedder_.reset(BrowserPluginEmbedder::Create(this));
6668}
6669
Jianzhou Fengd8720c72018-01-18 03:06:306670gfx::Size WebContentsImpl::GetSizeForNewRenderView(bool is_main_frame) {
[email protected]dc0fd432013-08-27 15:29:216671 gfx::Size size;
Jianzhou Fengd8720c72018-01-18 03:06:306672 if (is_main_frame)
6673 size = device_emulation_size_;
6674 if (size.IsEmpty() && delegate_)
[email protected]dc0fd432013-08-27 15:29:216675 size = delegate_->GetSizeForNewRenderView(this);
6676 if (size.IsEmpty())
[email protected]fc2b46b2014-05-03 16:33:456677 size = GetContainerBounds().size();
[email protected]dc0fd432013-08-27 15:29:216678 return size;
6679}
6680
[email protected]ae7eeda2014-07-04 01:53:266681void WebContentsImpl::OnFrameRemoved(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:096682 for (auto& observer : observers_)
6683 observer.FrameDeleted(render_frame_host);
[email protected]9b159a52013-10-03 17:24:556684}
6685
[email protected]222f5822014-02-05 23:40:496686void WebContentsImpl::OnPreferredSizeChanged(const gfx::Size& old_size) {
6687 if (!delegate_)
6688 return;
6689 const gfx::Size new_size = GetPreferredSize();
6690 if (new_size != old_size)
6691 delegate_->UpdatePreferredSize(this, new_size);
6692}
6693
Dominick Ng37a15052018-07-17 23:56:356694void WebContentsImpl::SendUserGestureForResourceDispatchHost() {
6695 // This is null in unittests. =(
Daniel Cheng90196c82018-04-25 21:49:146696 ResourceDispatcherHostImpl* rdh = ResourceDispatcherHostImpl::Get();
Dominick Ng37a15052018-07-17 23:56:356697
6698 if (rdh)
Daniel Cheng90196c82018-04-25 21:49:146699 rdh->OnUserGesture();
6700}
6701
Dan Beam055fe8f2017-10-04 23:23:366702std::unique_ptr<WebUIImpl> WebContentsImpl::CreateWebUI(const GURL& url) {
Jeremy Roman04f27c372017-10-27 15:20:556703 std::unique_ptr<WebUIImpl> web_ui = std::make_unique<WebUIImpl>(this);
Lei Zhangee3b63ad2018-06-06 23:25:316704 std::unique_ptr<WebUIController> controller(
avie865b1d2016-10-24 19:42:596705 WebUIControllerFactoryRegistry::GetInstance()
Lei Zhangee3b63ad2018-06-06 23:25:316706 ->CreateWebUIControllerForURL(web_ui.get(), url));
dbeama1b926a2015-08-31 23:17:516707 if (controller) {
Jeremy Roman04f27c372017-10-27 15:20:556708 web_ui->AddMessageHandler(std::make_unique<GenericHandler>());
Lei Zhangee3b63ad2018-06-06 23:25:316709 web_ui->SetController(std::move(controller));
dbeama1b926a2015-08-31 23:17:516710 return web_ui;
6711 }
6712
avie865b1d2016-10-24 19:42:596713 return nullptr;
dbeama1b926a2015-08-31 23:17:516714}
6715
Lucas Furukawa Gadanie1c5dfda2018-11-29 17:57:416716FindRequestManager* WebContentsImpl::GetFindRequestManager() {
6717 for (auto* contents = this; contents;
paulmeyerfeafc2d2017-04-25 21:46:406718 contents = contents->GetOuterWebContents()) {
6719 if (contents->find_request_manager_)
6720 return contents->find_request_manager_.get();
6721 }
6722
6723 return nullptr;
6724}
6725
paulmeyerc0b762b2016-04-13 11:55:176726FindRequestManager* WebContentsImpl::GetOrCreateFindRequestManager() {
paulmeyerfeafc2d2017-04-25 21:46:406727 if (FindRequestManager* manager = GetFindRequestManager())
6728 return manager;
6729
Ehsan Karamad6beb2ea2018-11-25 18:15:136730 DCHECK(!browser_plugin_guest_ || GetOuterWebContents());
6731
paulmeyerfeafc2d2017-04-25 21:46:406732 // No existing FindRequestManager found, so one must be created.
6733 find_request_manager_.reset(new FindRequestManager(this));
6734
6735 // Concurrent find sessions must not overlap, so destroy any existing
6736 // FindRequestManagers in any inner WebContentses.
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:166737 for (WebContents* contents : GetWebContentsAndAllInner()) {
6738 auto* web_contents_impl = static_cast<WebContentsImpl*>(contents);
6739 if (web_contents_impl == this)
paulmeyerfeafc2d2017-04-25 21:46:406740 continue;
Lucas Furukawa Gadani2ec00c82018-12-14 15:53:166741 if (web_contents_impl->find_request_manager_) {
6742 web_contents_impl->find_request_manager_->StopFinding(
6743 STOP_FIND_ACTION_CLEAR_SELECTION);
6744 web_contents_impl->find_request_manager_.release();
paulmeyerfeafc2d2017-04-25 21:46:406745 }
6746 }
paulmeyerc0b762b2016-04-13 11:55:176747
6748 return find_request_manager_.get();
6749}
6750
6751void WebContentsImpl::NotifyFindReply(int request_id,
6752 int number_of_matches,
6753 const gfx::Rect& selection_rect,
6754 int active_match_ordinal,
6755 bool final_update) {
Sebastien Marchandcf97ed52017-07-24 23:50:346756 if (delegate_ && !is_being_destroyed_ &&
Lukasz Anforowicze9ae3722017-09-29 17:37:386757 !GetMainFrame()->GetProcess()->FastShutdownStarted()) {
paulmeyerc0b762b2016-04-13 11:55:176758 delegate_->FindReply(this, request_id, number_of_matches, selection_rect,
6759 active_match_ordinal, final_update);
6760 }
6761}
6762
ortuno467e5792016-06-10 04:32:396763void WebContentsImpl::IncrementBluetoothConnectedDeviceCount() {
6764 // Trying to invalidate the tab state while being destroyed could result in a
6765 // use after free.
6766 if (IsBeingDestroyed()) {
6767 return;
6768 }
6769 // Notify for UI updates if the state changes.
6770 bluetooth_connected_device_count_++;
6771 if (bluetooth_connected_device_count_ == 1) {
6772 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6773 }
6774}
6775
6776void WebContentsImpl::DecrementBluetoothConnectedDeviceCount() {
6777 // Trying to invalidate the tab state while being destroyed could result in a
6778 // use after free.
6779 if (IsBeingDestroyed()) {
6780 return;
6781 }
6782 // Notify for UI updates if the state changes.
Lukasz Anforowicze9ae3722017-09-29 17:37:386783 DCHECK_NE(bluetooth_connected_device_count_, 0u);
ortuno467e5792016-06-10 04:32:396784 bluetooth_connected_device_count_--;
6785 if (bluetooth_connected_device_count_ == 0) {
6786 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6787 }
6788}
6789
Reilly Grant5e7c79b22019-04-09 17:26:206790void WebContentsImpl::IncrementSerialActiveFrameCount() {
6791 // Trying to invalidate the tab state while being destroyed could result in a
6792 // use after free.
6793 if (IsBeingDestroyed())
6794 return;
6795
6796 // Notify for UI updates if the state changes.
6797 serial_active_frame_count_++;
6798 if (serial_active_frame_count_ == 1)
6799 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6800}
6801
6802void WebContentsImpl::DecrementSerialActiveFrameCount() {
6803 // Trying to invalidate the tab state while being destroyed could result in a
6804 // use after free.
6805 if (IsBeingDestroyed())
6806 return;
6807
6808 // Notify for UI updates if the state changes.
6809 DCHECK_NE(0u, serial_active_frame_count_);
6810 serial_active_frame_count_--;
6811 if (serial_active_frame_count_ == 0)
6812 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
6813}
6814
zqzhang8ac49002017-03-16 21:51:356815void WebContentsImpl::SetHasPersistentVideo(bool has_persistent_video) {
6816 if (has_persistent_video_ == has_persistent_video)
mlamouri5cd9ae82017-02-18 11:05:096817 return;
6818
zqzhang8ac49002017-03-16 21:51:356819 has_persistent_video_ = has_persistent_video;
mlamouri5cd9ae82017-02-18 11:05:096820 NotifyPreferencesChanged();
zqzhang8ac49002017-03-16 21:51:356821 media_web_contents_observer()->RequestPersistentVideo(has_persistent_video);
mlamouri5cd9ae82017-02-18 11:05:096822}
6823
Ian Vollick5d5c37f2019-06-19 22:50:576824void WebContentsImpl::SetSpatialNavigationDisabled(bool disabled) {
6825 if (is_spatial_navigation_disabled_ == disabled)
6826 return;
6827
6828 is_spatial_navigation_disabled_ = disabled;
6829 NotifyPreferencesChanged();
6830}
6831
paulmeyerfeafc2d2017-04-25 21:46:406832void WebContentsImpl::BrowserPluginGuestWillDetach() {
6833 WebContentsImpl* outermost = GetOutermostWebContents();
6834 if (this != outermost && ContainsOrIsFocusedWebContents())
6835 outermost->SetAsFocusedWebContentsIfNecessary();
6836}
6837
Becca Hughes112832e2019-06-11 17:19:026838PictureInPictureResult WebContentsImpl::EnterPictureInPicture(
Mounir Lamouri11e9ef42018-05-22 03:10:166839 const viz::SurfaceId& surface_id,
6840 const gfx::Size& natural_size) {
François Beaufortf09e4462019-01-18 14:34:516841 return delegate_
6842 ? delegate_->EnterPictureInPicture(this, surface_id, natural_size)
Becca Hughes112832e2019-06-11 17:19:026843 : PictureInPictureResult::kNotSupported;
Mounir Lamouri11e9ef42018-05-22 03:10:166844}
6845
Mounir Lamouri6d759e12018-05-16 20:01:306846void WebContentsImpl::ExitPictureInPicture() {
6847 if (delegate_)
6848 delegate_->ExitPictureInPicture();
6849}
6850
paulmeyerc0b762b2016-04-13 11:55:176851#if defined(OS_ANDROID)
6852void WebContentsImpl::NotifyFindMatchRectsReply(
6853 int version,
6854 const std::vector<gfx::RectF>& rects,
6855 const gfx::RectF& active_rect) {
6856 if (delegate_)
6857 delegate_->FindMatchRectsReply(this, version, rects, active_rect);
6858}
6859#endif
6860
[email protected]34ff1cfc2014-08-20 06:16:056861void WebContentsImpl::SetForceDisableOverscrollContent(bool force_disable) {
6862 force_disable_overscroll_content_ = force_disable;
6863 if (view_)
6864 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
6865}
6866
Jianzhou Fengd8720c72018-01-18 03:06:306867bool WebContentsImpl::SetDeviceEmulationSize(const gfx::Size& new_size) {
6868 device_emulation_size_ = new_size;
6869 RenderWidgetHostView* rwhv = GetMainFrame()->GetView();
6870
6871 const gfx::Size current_size = rwhv->GetViewBounds().size();
6872 if (view_size_before_emulation_.IsEmpty())
6873 view_size_before_emulation_ = current_size;
6874
6875 if (current_size != new_size)
6876 rwhv->SetSize(new_size);
6877
6878 return current_size != new_size;
6879}
6880
6881void WebContentsImpl::ClearDeviceEmulationSize() {
6882 RenderWidgetHostView* rwhv = GetMainFrame()->GetView();
6883 // WebContentsView could get resized during emulation, which also resizes
6884 // RWHV. If it happens, assume user would like to keep using the size after
6885 // emulation.
6886 // TODO(jzfeng): Prohibit resizing RWHV through any other means (at least when
6887 // WebContentsView size changes).
Dmitry Gozmanc63707182018-03-06 00:09:396888 if (!view_size_before_emulation_.IsEmpty() && rwhv &&
6889 rwhv->GetViewBounds().size() == device_emulation_size_) {
Jianzhou Fengd8720c72018-01-18 03:06:306890 rwhv->SetSize(view_size_before_emulation_);
Dmitry Gozmanc63707182018-03-06 00:09:396891 }
Jianzhou Fengd8720c72018-01-18 03:06:306892 device_emulation_size_ = gfx::Size();
6893 view_size_before_emulation_ = gfx::Size();
6894}
6895
Max Morin5bc74f52018-05-09 07:00:216896ForwardingAudioStreamFactory* WebContentsImpl::GetAudioStreamFactory() {
6897 if (!audio_stream_factory_) {
6898 audio_stream_factory_.emplace(
6899 this,
Max Morinddebb972018-09-20 10:04:146900 // BrowserMainLoop::GetInstance() may be null in unit tests.
6901 BrowserMainLoop::GetInstance()
6902 ? static_cast<media::UserInputMonitorBase*>(
6903 BrowserMainLoop::GetInstance()->user_input_monitor())
6904 : nullptr,
Ken Rockotfd03e682019-06-20 21:13:546905 GetSystemConnector()->Clone(), AudioStreamBrokerFactory::CreateImpl());
Max Morin5bc74f52018-05-09 07:00:216906 }
6907
6908 return &*audio_stream_factory_;
6909}
6910
dalecurtis88c240072015-12-09 02:11:186911void WebContentsImpl::MediaStartedPlaying(
billorr21c005d2016-11-17 03:57:046912 const WebContentsObserver::MediaPlayerInfo& media_info,
Mounir Lamouri0f5bdf52019-04-04 16:32:356913 const MediaPlayerId& id) {
billorr21c005d2016-11-17 03:57:046914 if (media_info.has_video)
6915 currently_playing_video_count_++;
6916
ericwilligersde386342016-10-19 02:35:096917 for (auto& observer : observers_)
billorr21c005d2016-11-17 03:57:046918 observer.MediaStartedPlaying(media_info, id);
dalecurtis88c240072015-12-09 02:11:186919}
6920
6921void WebContentsImpl::MediaStoppedPlaying(
billorr21c005d2016-11-17 03:57:046922 const WebContentsObserver::MediaPlayerInfo& media_info,
Mounir Lamouri0f5bdf52019-04-04 16:32:356923 const MediaPlayerId& id,
Becca Hughes220bfc102017-11-14 18:24:076924 WebContentsObserver::MediaStoppedReason reason) {
billorr21c005d2016-11-17 03:57:046925 if (media_info.has_video)
6926 currently_playing_video_count_--;
6927
ericwilligersde386342016-10-19 02:35:096928 for (auto& observer : observers_)
Becca Hughes220bfc102017-11-14 18:24:076929 observer.MediaStoppedPlaying(media_info, id, reason);
billorr21c005d2016-11-17 03:57:046930}
6931
Mounir Lamouri0f5bdf52019-04-04 16:32:356932void WebContentsImpl::MediaResized(const gfx::Size& size,
6933 const MediaPlayerId& id) {
peconn257951522017-06-09 18:24:596934 cached_video_sizes_[id] = size;
6935
6936 for (auto& observer : observers_)
6937 observer.MediaResized(size, id);
6938}
6939
Peter E Conneccb34c22017-09-08 09:37:586940void WebContentsImpl::MediaEffectivelyFullscreenChanged(bool is_fullscreen) {
6941 for (auto& observer : observers_)
6942 observer.MediaEffectivelyFullscreenChanged(is_fullscreen);
6943}
6944
Peter Conn31c726a2017-08-17 11:07:346945base::Optional<gfx::Size> WebContentsImpl::GetFullscreenVideoSize() {
Mounir Lamouri0f5bdf52019-04-04 16:32:356946 base::Optional<MediaPlayerId> id =
Peter Conn31c726a2017-08-17 11:07:346947 media_web_contents_observer_->GetFullscreenVideoMediaPlayerId();
Jan Wilken Dörrie531be7ca2019-06-07 10:05:576948 if (id && base::Contains(cached_video_sizes_, id.value()))
Peter Conn31c726a2017-08-17 11:07:346949 return base::Optional<gfx::Size>(cached_video_sizes_[id.value()]);
Lei Zhang6410ec1a2019-01-31 21:38:586950 return base::nullopt;
peconn257951522017-06-09 18:24:596951}
6952
billorr21c005d2016-11-17 03:57:046953int WebContentsImpl::GetCurrentlyPlayingVideoCount() {
6954 return currently_playing_video_count_;
dalecurtis88c240072015-12-09 02:11:186955}
6956
Raymond Toye413650c2018-08-31 00:12:476957void WebContentsImpl::AudioContextPlaybackStarted(RenderFrameHost* host,
6958 int context_id) {
6959 WebContentsObserver::AudioContextId audio_context_id(host, context_id);
6960 for (auto& observer : observers_)
6961 observer.AudioContextPlaybackStarted(audio_context_id);
6962}
6963
6964void WebContentsImpl::AudioContextPlaybackStopped(RenderFrameHost* host,
6965 int context_id) {
6966 WebContentsObserver::AudioContextId audio_context_id(host, context_id);
6967 for (auto& observer : observers_)
6968 observer.AudioContextPlaybackStopped(audio_context_id);
6969}
6970
Ehsan Karamad1c631762019-05-13 23:04:016971RenderFrameHostImpl* WebContentsImpl::GetMainFrameForInnerDelegate(
6972 FrameTreeNode* frame_tree_node) {
6973 if (auto* web_contents = node_.GetInnerWebContentsInFrame(frame_tree_node))
6974 return web_contents->GetMainFrame();
6975 return nullptr;
6976}
6977
Francois Doraye6161152018-03-27 22:05:376978void WebContentsImpl::UpdateWebContentsVisibility(Visibility visibility) {
Francois Doray3f2afbd2018-04-06 19:18:186979 // Occlusion is disabled when |features::kWebContentsOcclusion| is disabled
6980 // (for power and speed impact assessment) or when
6981 // |switches::kDisableBackgroundingOccludedWindowsForTesting| is specified on
6982 // the command line (to avoid flakiness in browser tests).
6983 const bool occlusion_is_disabled =
6984 !base::FeatureList::IsEnabled(features::kWebContentsOcclusion) ||
Francois Doraye6161152018-03-27 22:05:376985 base::CommandLine::ForCurrentProcess()->HasSwitch(
6986 switches::kDisableBackgroundingOccludedWindowsForTesting);
6987 if (occlusion_is_disabled && visibility == Visibility::OCCLUDED)
6988 visibility = Visibility::VISIBLE;
6989
tapted65ff2ea72016-03-01 23:39:006990 if (!did_first_set_visible_) {
Francois Doraye6161152018-03-27 22:05:376991 if (visibility == Visibility::VISIBLE) {
6992 // A WebContents created with CreateParams::initially_hidden = false
6993 // starts with GetVisibility() == Visibility::VISIBLE even though it is
6994 // not really visible. Call WasShown() when it becomes visible for real as
6995 // the page load mechanism and some WebContentsObserver rely on that.
tapted65ff2ea72016-03-01 23:39:006996 WasShown();
Francois Dorayfe4a1772018-02-17 04:17:096997 did_first_set_visible_ = true;
tapted65ff2ea72016-03-01 23:39:006998 }
Francois Doraye6161152018-03-27 22:05:376999
7000 // Trust the initial visibility of the WebContents and do not switch it to
7001 // HIDDEN or OCCLUDED before it becomes VISIBLE for real. Doing so would
7002 // result in destroying resources that would immediately be recreated (e.g.
7003 // UpdateWebContents(HIDDEN) can be called when a WebContents is added to a
7004 // hidden window that is about to be shown).
7005
tapted65ff2ea72016-03-01 23:39:007006 return;
7007 }
Francois Doraye6161152018-03-27 22:05:377008
7009 if (visibility == visibility_)
tapted65ff2ea72016-03-01 23:39:007010 return;
7011
Francois Doraye6161152018-03-27 22:05:377012 if (visibility == Visibility::VISIBLE)
tapted65ff2ea72016-03-01 23:39:007013 WasShown();
Francois Doraye6161152018-03-27 22:05:377014 else if (visibility == Visibility::OCCLUDED)
7015 WasOccluded();
tapted65ff2ea72016-03-01 23:39:007016 else
7017 WasHidden();
7018}
7019
aelias5252baa2016-04-10 01:18:027020void WebContentsImpl::UpdateOverridingUserAgent() {
mlamouri5cd9ae82017-02-18 11:05:097021 NotifyPreferencesChanged();
aelias5252baa2016-04-10 01:18:027022}
7023
avid53461d2016-02-25 17:15:047024void WebContentsImpl::SetJavaScriptDialogManagerForTesting(
7025 JavaScriptDialogManager* dialog_manager) {
7026 dialog_manager_ = dialog_manager;
7027}
7028
rockotf62002a2016-09-15 00:08:597029void WebContentsImpl::RemoveBindingSet(const std::string& interface_name) {
7030 auto it = binding_sets_.find(interface_name);
7031 if (it != binding_sets_.end())
7032 binding_sets_.erase(it);
7033}
7034
nzolghadrd87a308d2016-12-07 15:45:567035bool WebContentsImpl::AddDomainInfoToRapporSample(rappor::Sample* sample) {
nzolghadrbbffc6c2017-05-25 17:56:397036 // Here we associate this metric to the main frame URL regardless of what
7037 // caused it.
nzolghadrd87a308d2016-12-07 15:45:567038 sample->SetStringField("Domain", ::rappor::GetDomainAndRegistrySampleFromGURL(
7039 GetLastCommittedURL()));
nzolghadrd87a308d2016-12-07 15:45:567040 return true;
7041}
7042
ekaramada110f642016-12-21 19:47:287043void WebContentsImpl::FocusedNodeTouched(bool editable) {
7044#if defined(OS_WIN)
ekaramada110f642016-12-21 19:47:287045 RenderWidgetHostView* view = GetRenderWidgetHostView();
7046 if (!view)
7047 return;
Dave Tapuska2315d8f2018-03-06 17:52:557048 view->FocusedNodeTouched(editable);
ekaramada110f642016-12-21 19:47:287049#endif
7050}
7051
falken52a56e32016-12-08 05:02:407052void WebContentsImpl::ShowInsecureLocalhostWarningIfNeeded() {
7053 bool allow_localhost = base::CommandLine::ForCurrentProcess()->HasSwitch(
7054 switches::kAllowInsecureLocalhost);
7055 if (!allow_localhost)
7056 return;
7057
7058 content::NavigationEntry* entry = GetController().GetLastCommittedEntry();
Rob Wuf79b3ba2018-01-14 01:54:317059 if (!entry || !net::IsLocalhost(entry->GetURL()))
falken52a56e32016-12-08 05:02:407060 return;
7061
7062 content::SSLStatus ssl_status = entry->GetSSL();
7063 bool is_cert_error = net::IsCertStatusError(ssl_status.cert_status) &&
7064 !net::IsCertStatusMinorError(ssl_status.cert_status);
7065 if (!is_cert_error)
7066 return;
7067
7068 GetMainFrame()->AddMessageToConsole(
Abhijeet Kandalkara5928a0a2019-03-13 05:04:427069 blink::mojom::ConsoleMessageLevel::kWarning,
falken52a56e32016-12-08 05:02:407070 base::StringPrintf("This site does not have a valid SSL "
7071 "certificate! Without SSL, your site's and "
7072 "visitors' data is vulnerable to theft and "
7073 "tampering. Get a valid SSL certificate before"
7074 " releasing your website to the public."));
7075}
7076
ekaramadf6750aa2017-06-06 18:29:427077bool WebContentsImpl::IsShowingContextMenuOnPage() const {
7078 return showing_context_menu_;
7079}
7080
Min Qina904f3302018-02-13 23:33:347081download::DownloadUrlParameters::RequestHeadersType
7082WebContentsImpl::ParseDownloadHeaders(const std::string& headers) {
7083 download::DownloadUrlParameters::RequestHeadersType request_headers;
Megan Jablonski2f6a4c52017-07-10 23:01:257084 for (const base::StringPiece& key_value : base::SplitStringPiece(
7085 headers, "\r\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
7086 std::vector<std::string> pair = base::SplitString(
7087 key_value, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
7088 if (2ul == pair.size())
7089 request_headers.push_back(make_pair(pair[0], pair[1]));
7090 }
7091 return request_headers;
7092}
7093
lukasza6f8ac622017-06-06 03:10:207094void WebContentsImpl::SetOpenerForNewContents(FrameTreeNode* opener,
7095 bool opener_suppressed) {
7096 if (opener) {
7097 FrameTreeNode* new_root = GetFrameTree()->root();
7098
7099 // For the "original opener", track the opener's main frame instead, because
7100 // if the opener is a subframe, the opener tracking could be easily bypassed
7101 // by spawning from a subframe and deleting the subframe.
7102 // https://crbug.com/705316
7103 new_root->SetOriginalOpener(opener->frame_tree()->root());
7104
7105 if (!opener_suppressed) {
7106 new_root->SetOpener(opener);
7107 created_with_opener_ = true;
7108 }
7109 }
7110}
7111
Mounir Lamouri0f5bdf52019-04-04 16:32:357112void WebContentsImpl::MediaMutedStatusChanged(const MediaPlayerId& id,
7113 bool muted) {
Becca Hughes9f6fd4b82017-06-15 10:01:407114 for (auto& observer : observers_)
7115 observer.MediaMutedStatusChanged(id, muted);
7116}
7117
EhsanK2075c7e2017-08-21 02:42:397118void WebContentsImpl::SetVisibilityForChildViews(bool visible) {
7119 GetMainFrame()->SetVisibilityForChildViews(visible);
7120}
7121
Rune Lillesveen5d8c49982019-04-24 19:07:307122void WebContentsImpl::OnDarkModeChanged(bool dark_mode) {
7123 NotifyPreferencesChanged();
7124}
7125
[email protected]8ff00d72012-10-23 19:12:217126} // namespace content