blob: 7297db47cf2d48d4eb9bb28194143e773dad814b [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
[email protected]36fb2c7c2011-04-04 15:49:0813#include "base/command_line.h"
creisfafed882016-07-29 00:03:0914#include "base/debug/dump_without_crashing.h"
zqzhang181047e62016-07-01 13:37:1715#include "base/feature_list.h"
jinsukkim79df88a2017-01-04 06:26:1516#include "base/i18n/character_encoding.h"
[email protected]cbb1ef592013-06-05 19:49:4617#include "base/lazy_instance.h"
skyostil95082a62015-06-05 19:53:0718#include "base/location.h"
[email protected]6d636e62013-07-31 03:15:5619#include "base/logging.h"
avib7348942015-12-25 20:57:1020#include "base/macros.h"
fdorayba121422016-12-23 19:51:4821#include "base/memory/ptr_util.h"
dmazzonid95ae842016-04-12 21:17:3922#include "base/memory/ref_counted.h"
asvitkine8d51e9d2016-09-02 23:55:4323#include "base/metrics/histogram_macros.h"
bratell0a7406f2017-03-28 07:46:3724#include "base/metrics/user_metrics.h"
[email protected]04cbd3d2013-12-04 04:58:2025#include "base/process/process.h"
skyostil95082a62015-06-05 19:53:0726#include "base/single_thread_task_runner.h"
[email protected]348fbaac2013-06-11 06:31:5127#include "base/strings/string16.h"
28#include "base/strings/string_number_conversions.h"
29#include "base/strings/string_util.h"
[email protected]74ebfb12013-06-07 20:48:0030#include "base/strings/utf_string_conversions.h"
gab30f26df2016-05-11 19:37:5531#include "base/threading/thread_task_runner_handle.h"
[email protected]a43858f2013-06-28 15:18:3732#include "base/time/time.h"
ssid3e765612015-01-28 04:03:4233#include "base/trace_event/trace_event.h"
avib7348942015-12-25 20:57:1034#include "build/build_config.h"
nzolghadrd87a308d2016-12-07 15:45:5635#include "components/rappor/public/rappor_utils.h"
rsleevi24f64dc22015-08-07 21:39:2136#include "components/url_formatter/url_formatter.h"
[email protected]95640212014-07-26 18:14:3037#include "content/browser/accessibility/browser_accessibility_state_impl.h"
jamescookda2505812015-03-20 18:01:1838#include "content/browser/bad_message.h"
[email protected]7a846df2012-09-20 19:17:3939#include "content/browser/browser_plugin/browser_plugin_embedder.h"
40#include "content/browser/browser_plugin/browser_plugin_guest.h"
[email protected]b9535422012-02-09 01:47:5941#include "content/browser/child_process_security_policy_impl.h"
Pavel Feldman3c1842b2017-08-02 05:00:1642#include "content/browser/devtools/protocol/page_handler.h"
dgozmanf00c4f72016-10-19 17:45:1543#include "content/browser/devtools/render_frame_devtools_agent_host.h"
[email protected]5f2aa722013-08-07 16:59:4144#include "content/browser/dom_storage/dom_storage_context_wrapper.h"
[email protected]1ea3c792012-04-17 01:25:0445#include "content/browser/dom_storage/session_storage_namespace_impl.h"
[email protected]8bd9e562011-08-16 23:55:4646#include "content/browser/download/download_stats.h"
[email protected]aa4f3972012-03-01 18:12:1247#include "content/browser/download/mhtml_generation_manager.h"
[email protected]a53209b2012-01-20 16:48:1648#include "content/browser/download/save_package.h"
paulmeyerc0b762b2016-04-13 11:55:1749#include "content/browser/find_request_manager.h"
[email protected]bffc8302014-01-23 20:52:1650#include "content/browser/frame_host/cross_process_frame_connector.h"
ananta4b7467a52016-09-23 01:42:3851#include "content/browser/frame_host/frame_tree_node.h"
[email protected]d4a8ca482013-10-30 21:06:4052#include "content/browser/frame_host/interstitial_page_impl.h"
53#include "content/browser/frame_host/navigation_entry_impl.h"
clamy0e119882015-07-31 16:12:3354#include "content/browser/frame_host/navigation_handle_impl.h"
[email protected]6ea6bdf2013-12-06 13:35:0155#include "content/browser/frame_host/navigator_impl.h"
[email protected]52913802013-12-10 05:52:1856#include "content/browser/frame_host/render_frame_host_impl.h"
lfgdb5c4ed2016-03-04 23:09:0757#include "content/browser/frame_host/render_frame_proxy_host.h"
csharrison2e8c98e2016-08-01 23:56:2558#include "content/browser/loader/loader_io_thread_notifier.h"
[email protected]678c0362012-12-05 08:02:4459#include "content/browser/loader/resource_dispatcher_host_impl.h"
mlamouriefdca9d2014-09-16 16:55:4060#include "content/browser/manifest/manifest_manager_host.h"
dalecurtisbc6572e12014-09-12 19:22:3061#include "content/browser/media/audio_stream_monitor.h"
miu50f97892014-09-22 22:49:5262#include "content/browser/media/capture/web_contents_audio_muter.h"
dalecurtis88c240072015-12-09 02:11:1863#include "content/browser/media/media_web_contents_observer.h"
zqzhang1adf3cb2016-11-01 11:26:4564#include "content/browser/media/session/media_session_impl.h"
tommyclieb25b2a2014-11-03 19:45:0965#include "content/browser/plugin_content_origin_whitelist.h"
[email protected]f3b1a082011-11-18 00:34:3066#include "content/browser/renderer_host/render_process_host_impl.h"
[email protected]21161032014-05-05 16:56:5067#include "content/browser/renderer_host/render_view_host_delegate_view.h"
[email protected]b3c41c0b2012-03-06 15:48:3268#include "content/browser/renderer_host/render_view_host_impl.h"
[email protected]bafe6cd2012-05-23 23:09:5069#include "content/browser/renderer_host/render_widget_host_impl.h"
kenrb2a565f82015-09-02 20:24:5970#include "content/browser/renderer_host/render_widget_host_input_event_router.h"
[email protected]cfd80b02014-05-01 17:46:4871#include "content/browser/renderer_host/render_widget_host_view_base.h"
Ken Buchanandaef006b2017-08-17 18:32:1572#include "content/browser/renderer_host/render_widget_host_view_child_frame.h"
ekaramadadd882292016-06-08 15:22:5673#include "content/browser/renderer_host/text_input_manager.h"
leon.han552e9de2017-02-09 14:37:3074#include "content/browser/screen_orientation/screen_orientation_provider.h"
[email protected]b6583592012-01-25 19:52:3375#include "content/browser/site_instance_impl.h"
lfgc740d4b22016-04-15 16:45:3376#include "content/browser/web_contents/web_contents_view_child_frame.h"
[email protected]b5a40842012-11-28 15:26:1177#include "content/browser/web_contents/web_contents_view_guest.h"
[email protected]eb2ef212013-01-29 04:27:5878#include "content/browser/webui/generic_handler.h"
[email protected]86a0a6e2013-01-28 06:33:0379#include "content/browser/webui/web_ui_controller_factory_registry.h"
[email protected]d2353452012-01-19 19:53:5680#include "content/browser/webui/web_ui_impl.h"
[email protected]8eb04562013-03-06 03:41:1481#include "content/common/browser_plugin/browser_plugin_constants.h"
[email protected]703dd662013-03-05 07:37:4282#include "content/common/browser_plugin/browser_plugin_messages.h"
Paul Meyer0c58c3712016-11-17 22:59:5183#include "content/common/drag_messages.h"
[email protected]f114fa42013-12-06 17:06:4484#include "content/common/frame_messages.h"
[email protected]1f3fc1d2014-04-03 14:50:1785#include "content/common/input_messages.h"
lfgdb5c4ed2016-03-04 23:09:0786#include "content/common/page_messages.h"
nasko34634672016-07-29 18:46:0687#include "content/common/page_state_serialization.h"
rockot5c478a72016-09-28 23:14:1888#include "content/common/render_message_filter.mojom.h"
avi286019ce2015-07-29 01:26:5889#include "content/common/site_isolation_policy.h"
[email protected]2c5569662011-03-22 20:45:0290#include "content/common/view_messages.h"
[email protected]31a71eaf2014-03-13 01:47:3691#include "content/public/browser/ax_event_notification_details.h"
[email protected]ccb797302011-12-15 16:55:1192#include "content/public/browser/browser_context.h"
[email protected]139355f2014-05-11 14:21:2893#include "content/public/browser/browser_plugin_guest_manager.h"
[email protected]87f3c082011-10-19 18:07:4494#include "content/public/browser/content_browser_client.h"
[email protected]e582fdd2011-12-20 16:48:1795#include "content/public/browser/download_manager.h"
ekaramada110f642016-12-21 19:47:2896#include "content/public/browser/focused_node_details.h"
ekaramad1beabecc2016-09-23 20:18:1797#include "content/public/browser/guest_mode.h"
[email protected]d9083482012-01-06 00:38:4698#include "content/public/browser/invalidate_type.h"
[email protected]71a88bb2013-02-01 22:05:1599#include "content/public/browser/javascript_dialog_manager.h"
skyf65d9bb2017-03-24 02:26:39100#include "content/public/browser/keyboard_event_processing_result.h"
[email protected]09d31d52012-03-11 22:30:27101#include "content/public/browser/load_notification_details.h"
[email protected]5b96836f2011-12-22 07:39:00102#include "content/public/browser/navigation_details.h"
[email protected]375fa1b2012-05-22 22:05:37103#include "content/public/browser/notification_details.h"
[email protected]be2510c02012-05-28 14:52:14104#include "content/public/browser/notification_service.h"
scottmg011d96e32016-06-29 19:15:08105#include "content/public/browser/notification_types.h"
[email protected]95640212014-07-26 18:14:30106#include "content/public/browser/render_widget_host_iterator.h"
[email protected]55578b0a2012-04-18 14:31:32107#include "content/public/browser/resource_request_details.h"
estark5ea80e52015-06-19 18:43:12108#include "content/public/browser/security_style_explanations.h"
falken52a56e32016-12-08 05:02:40109#include "content/public/browser/ssl_status.h"
[email protected]4c3a23582012-08-18 08:54:34110#include "content/public/browser/storage_partition.h"
rockotf62002a2016-09-15 00:08:59111#include "content/public/browser/web_contents_binding_set.h"
[email protected]674bc592011-12-20 23:00:42112#include "content/public/browser/web_contents_delegate.h"
dtapuskae99ec6e52016-10-18 00:15:42113#include "content/public/browser/web_contents_unresponsive_state.h"
[email protected]e091df82011-10-11 18:13:21114#include "content/public/common/bindings_policy.h"
carloskd80262f52015-12-16 14:40:35115#include "content/public/common/browser_side_navigation_policy.h"
alexmosc9e76ec2016-05-16 22:59:37116#include "content/public/common/child_process_host.h"
[email protected]54087fe2011-10-28 22:02:48117#include "content/public/common/content_constants.h"
[email protected]64d69de42012-02-06 00:19:54118#include "content/public/common/content_switches.h"
[email protected]7940b8e2013-07-25 23:08:49119#include "content/public/common/page_zoom.h"
[email protected]04cbd3d2013-12-04 04:58:20120#include "content/public/common/result_codes.h"
[email protected]f16cc6782013-12-16 23:42:57121#include "content/public/common/url_utils.h"
[email protected]b3a97b52014-07-09 06:25:05122#include "content/public/common/web_preferences.h"
Conley Owens6894c4f2017-07-10 19:29:13123#include "device/geolocation/geolocation_context.h"
wjmaclean64951902016-04-29 20:59:12124#include "net/base/url_util.h"
[email protected]8bfc8272013-09-09 20:10:53125#include "net/http/http_cache.h"
126#include "net/http/http_transaction_factory.h"
rhalavati0fbaeef32017-06-01 15:56:30127#include "net/traffic_annotation/network_traffic_annotation.h"
[email protected]8bfc8272013-09-09 20:10:53128#include "net/url_request/url_request_context.h"
[email protected]abe2c032011-03-31 18:49:34129#include "net/url_request/url_request_context_getter.h"
brettw4b461082016-11-19 18:55:16130#include "ppapi/features/features.h"
Mounir Lamourifd9dcefa2017-07-06 10:26:55131#include "services/metrics/public/cpp/ukm_recorder.h"
rockot734fb662016-10-15 16:41:30132#include "services/service_manager/public/cpp/interface_provider.h"
Kinuko Yasuda74702f92017-07-31 03:27:53133#include "third_party/WebKit/common/mime_util/mime_util.h"
estark47ba9c7d2016-10-11 15:40:11134#include "third_party/WebKit/public/platform/WebSecurityStyle.h"
alexmosaedfc6f2016-01-21 23:57:38135#include "third_party/WebKit/public/web/WebSandboxFlags.h"
halton.huoca2eabd2015-07-06 08:17:40136#include "third_party/skia/include/core/SkBitmap.h"
dmazzonid95ae842016-04-12 21:17:39137#include "ui/accessibility/ax_tree_combiner.h"
[email protected]a08412b62012-05-29 21:28:56138#include "ui/base/layout.h"
chongz4a9751942016-08-17 17:49:39139#include "ui/events/blink/web_input_event_traits.h"
[email protected]66bd5512012-08-01 02:02:52140#include "ui/gl/gl_switches.h"
[email protected]3c733bde2010-12-21 19:56:31141
ekaramada110f642016-12-21 19:47:28142#if defined(OS_WIN)
143#include "content/browser/renderer_host/dip_util.h"
144#include "ui/gfx/geometry/dip_util.h"
145#endif
146
[email protected]583418cc2013-01-17 14:01:10147#if defined(OS_ANDROID)
hugo.holgersson61288e6c2015-01-28 17:04:40148#include "content/browser/android/content_video_view.h"
mfomitchev2b8b066a2016-01-28 19:23:15149#include "content/browser/android/date_time_chooser_android.h"
sammcf5f1b0f2016-09-20 23:05:11150#include "content/browser/android/java_interfaces_impl.h"
dalecurtisc85ed632016-01-13 00:22:46151#include "content/browser/media/android/media_web_contents_observer_android.h"
[email protected]155c7f22013-12-09 17:07:18152#include "content/browser/web_contents/web_contents_android.h"
leon.han02ed4aeb2017-05-23 06:33:33153#include "services/device/public/interfaces/nfc.mojom.h"
mcnee336ea2c2017-05-23 22:50:59154#else // !OS_ANDROID
155#include "content/browser/host_zoom_map_impl.h"
156#include "content/browser/host_zoom_map_observer.h"
mfomitchev2b8b066a2016-01-28 19:23:15157#endif // OS_ANDROID
[email protected]583418cc2013-01-17 14:01:10158
[email protected]f66df822012-05-18 16:52:17159#if defined(OS_MACOSX)
[email protected]bafe6cd2012-05-23 23:09:50160#include "base/mac/foundation_util.h"
[email protected]38b098f2012-03-14 21:11:57161#endif
[email protected]3e45ba92009-02-20 21:09:00162
sadrul943e3b32016-08-04 18:22:59163#if defined(USE_AURA)
bend32292b2016-10-07 00:21:58164#include "content/public/common/service_manager_connection.h"
fsamuel9cf7bdf2015-11-20 02:19:32165#endif
166
brettw4b461082016-11-19 18:55:16167#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17168#include "content/browser/media/session/pepper_playback_observer.h"
169#endif // ENABLE_PLUGINS
170
[email protected]8ff00d72012-10-23 19:12:21171namespace content {
[email protected]420ae012009-04-24 05:16:32172namespace {
173
[email protected]960b0372014-05-19 18:01:00174const int kMinimumDelayBetweenLoadingUpdatesMS = 100;
[email protected]82114f52012-03-20 22:53:41175const char kDotGoogleDotCom[] = ".google.com";
[email protected]ca406032011-07-19 21:53:05176
[email protected]155c7f22013-12-09 17:07:18177#if defined(OS_ANDROID)
rob.buisf06a8bf2017-03-10 18:11:32178const void* const kWebContentsAndroidKey = &kWebContentsAndroidKey;
[email protected]155c7f22013-12-09 17:07:18179#endif // OS_ANDROID
180
scottmg5e65e3a2017-03-08 08:48:46181base::LazyInstance<std::vector<WebContentsImpl::CreatedCallback>>::
182 DestructorAtExit g_created_callbacks = LAZY_INSTANCE_INITIALIZER;
[email protected]cbb1ef592013-06-05 19:49:46183
[email protected]8bfc8272013-09-09 20:10:53184void NotifyCacheOnIO(
185 scoped_refptr<net::URLRequestContextGetter> request_context,
186 const GURL& url,
187 const std::string& http_method) {
gunsche668855c2015-03-05 02:37:58188 net::HttpCache* cache = request_context->GetURLRequestContext()->
189 http_transaction_factory()->GetCache();
190 if (cache)
191 cache->OnExternalCacheHit(url, http_method);
[email protected]8bfc8272013-09-09 20:10:53192}
193
dcheng57e39e22016-01-21 00:25:38194bool HasMatchingProcess(FrameTree* tree, int render_process_id) {
195 for (FrameTreeNode* node : tree->Nodes()) {
196 if (node->current_frame_host()->GetProcess()->GetID() == render_process_id)
197 return true;
alexmos4cf2aa32015-07-15 23:40:43198 }
dcheng57e39e22016-01-21 00:25:38199 return false;
[email protected]95640212014-07-26 18:14:30200}
201
kenrb19221852016-04-29 17:21:40202bool HasMatchingWidgetHost(FrameTree* tree, RenderWidgetHost* host) {
203 // This method scans the frame tree rather than checking whether
204 // host->delegate() == this, which allows it to return false when the host
205 // for a frame that is pending or pending deletion.
206 if (!host)
207 return false;
208
209 for (FrameTreeNode* node : tree->Nodes()) {
210 if (node->current_frame_host()->GetRenderWidgetHost() == host)
211 return true;
212 }
213 return false;
214}
215
dmazzonif8a31042016-12-03 00:52:13216void UpdateAccessibilityModeOnFrame(RenderFrameHost* frame_host) {
217 static_cast<RenderFrameHostImpl*>(frame_host)->UpdateAccessibilityMode();
[email protected]95640212014-07-26 18:14:30218}
219
dtseng0dd3fa12015-07-22 19:00:52220void ResetAccessibility(RenderFrameHost* rfh) {
221 static_cast<RenderFrameHostImpl*>(rfh)->AccessibilityReset();
222}
223
dmazzonid95ae842016-04-12 21:17:39224using AXTreeSnapshotCallback =
225 base::Callback<void(const ui::AXTreeUpdate&)>;
226
227// Helper class used by WebContentsImpl::RequestAXTreeSnapshot.
228// Handles the callbacks from parallel snapshot requests to each frame,
229// and feeds the results to an AXTreeCombiner, which converts them into a
230// single combined accessibility tree.
231class AXTreeSnapshotCombiner : public base::RefCounted<AXTreeSnapshotCombiner> {
232 public:
233 explicit AXTreeSnapshotCombiner(AXTreeSnapshotCallback callback)
234 : callback_(callback) {
235 }
236
237 AXTreeSnapshotCallback AddFrame(bool is_root) {
238 // Adds a reference to |this|.
239 return base::Bind(&AXTreeSnapshotCombiner::ReceiveSnapshot,
240 this,
241 is_root);
242 }
243
244 void ReceiveSnapshot(bool is_root, const ui::AXTreeUpdate& snapshot) {
245 combiner_.AddTree(snapshot, is_root);
246 }
247
248 private:
249 friend class base::RefCounted<AXTreeSnapshotCombiner>;
250
251 // This is called automatically after the last call to ReceiveSnapshot
252 // when there are no more references to this object.
253 ~AXTreeSnapshotCombiner() {
254 combiner_.Combine();
255 callback_.Run(combiner_.combined());
256 }
257
258 ui::AXTreeCombiner combiner_;
259 AXTreeSnapshotCallback callback_;
260};
261
paulmeyerfeafc2d2017-04-25 21:46:40262// Helper for GetInnerWebContents().
263bool GetInnerWebContentsHelper(
264 std::vector<WebContentsImpl*>* all_guest_contents,
265 WebContents* guest_contents) {
266 all_guest_contents->push_back(static_cast<WebContentsImpl*>(guest_contents));
267 return false;
268}
269
lukasza6f8ac622017-06-06 03:10:20270FrameTreeNode* FindOpener(const WebContents::CreateParams& params) {
alexmose201c7cd2015-06-10 17:14:21271 FrameTreeNode* opener_node = nullptr;
272 if (params.opener_render_frame_id != MSG_ROUTING_NONE) {
273 RenderFrameHostImpl* opener_rfh = RenderFrameHostImpl::FromID(
274 params.opener_render_process_id, params.opener_render_frame_id);
275 if (opener_rfh)
276 opener_node = opener_rfh->frame_tree_node();
277 }
lukasza6f8ac622017-06-06 03:10:20278 return opener_node;
279}
280
Pavel Feldman3c1842b2017-08-02 05:00:16281// Ensures that OnDialogClosed is only called once.
282class CloseDialogCallbackWrapper
283 : public base::RefCountedThreadSafe<CloseDialogCallbackWrapper> {
284 public:
Avi Drissmane04d3992017-10-05 15:11:36285 using CloseCallback =
286 base::OnceCallback<void(bool, bool, const base::string16&)>;
287
288 explicit CloseDialogCallbackWrapper(CloseCallback callback)
289 : callback_(std::move(callback)) {}
Pavel Feldman3c1842b2017-08-02 05:00:16290
291 void Run(bool dialog_was_suppressed,
292 bool success,
293 const base::string16& user_input) {
Avi Drissmane04d3992017-10-05 15:11:36294 if (callback_.is_null())
Pavel Feldman3c1842b2017-08-02 05:00:16295 return;
Avi Drissmane04d3992017-10-05 15:11:36296 std::move(callback_).Run(dialog_was_suppressed, success, user_input);
Pavel Feldman3c1842b2017-08-02 05:00:16297 }
298
299 private:
300 friend class base::RefCountedThreadSafe<CloseDialogCallbackWrapper>;
301 ~CloseDialogCallbackWrapper() {}
Avi Drissmane04d3992017-10-05 15:11:36302
303 CloseCallback callback_;
Pavel Feldman3c1842b2017-08-02 05:00:16304};
305
lukasza6f8ac622017-06-06 03:10:20306} // namespace
307
308WebContents* WebContents::Create(const WebContents::CreateParams& params) {
309 return WebContentsImpl::CreateWithOpener(params, FindOpener(params));
[email protected]d1198fd2012-08-13 22:50:19310}
311
312WebContents* WebContents::CreateWithSessionStorage(
[email protected]54944cde2012-12-09 09:24:59313 const WebContents::CreateParams& params,
[email protected]fdac6ade2013-07-20 01:06:30314 const SessionStorageNamespaceMap& session_storage_namespace_map) {
alexmose201c7cd2015-06-10 17:14:21315 WebContentsImpl* new_contents = new WebContentsImpl(params.browser_context);
lukasza6f8ac622017-06-06 03:10:20316 new_contents->SetOpenerForNewContents(FindOpener(params),
317 params.opener_suppressed);
[email protected]fdac6ade2013-07-20 01:06:30318
319 for (SessionStorageNamespaceMap::const_iterator it =
320 session_storage_namespace_map.begin();
321 it != session_storage_namespace_map.end();
322 ++it) {
323 new_contents->GetController()
324 .SetSessionStorageNamespace(it->first, it->second.get());
325 }
326
[email protected]54944cde2012-12-09 09:24:59327 new_contents->Init(params);
[email protected]d1198fd2012-08-13 22:50:19328 return new_contents;
[email protected]a81343d232011-12-27 07:39:20329}
[email protected]746d3052012-05-22 15:15:47330
benwells5e7260d2017-03-20 23:36:33331void WebContentsImpl::FriendWrapper::AddCreatedCallbackForTesting(
nickf9acfbe2014-12-23 19:12:37332 const CreatedCallback& callback) {
[email protected]cbb1ef592013-06-05 19:49:46333 g_created_callbacks.Get().push_back(callback);
334}
335
benwells5e7260d2017-03-20 23:36:33336void WebContentsImpl::FriendWrapper::RemoveCreatedCallbackForTesting(
nickf9acfbe2014-12-23 19:12:37337 const CreatedCallback& callback) {
[email protected]cbb1ef592013-06-05 19:49:46338 for (size_t i = 0; i < g_created_callbacks.Get().size(); ++i) {
339 if (g_created_callbacks.Get().at(i).Equals(callback)) {
340 g_created_callbacks.Get().erase(g_created_callbacks.Get().begin() + i);
341 return;
342 }
343 }
344}
345
avidf38c952015-10-27 13:45:13346WebContents* WebContents::FromRenderViewHost(RenderViewHost* rvh) {
347 if (!rvh)
348 return nullptr;
[email protected]746d3052012-05-22 15:15:47349 return rvh->GetDelegate()->GetAsWebContents();
350}
351
[email protected]a86c0e962013-12-17 17:10:39352WebContents* WebContents::FromRenderFrameHost(RenderFrameHost* rfh) {
avidf38c952015-10-27 13:45:13353 if (!rfh)
354 return nullptr;
355 return static_cast<RenderFrameHostImpl*>(rfh)->delegate()->GetAsWebContents();
[email protected]a86c0e962013-12-17 17:10:39356}
357
ananta4b7467a52016-09-23 01:42:38358WebContents* WebContents::FromFrameTreeNodeId(int frame_tree_node_id) {
359 FrameTreeNode* frame_tree_node =
360 FrameTreeNode::GloballyFindByID(frame_tree_node_id);
anantab8cfa3b2016-10-14 22:43:19361 if (!frame_tree_node)
362 return nullptr;
jam8c4edd02017-05-06 18:50:33363 return WebContentsImpl::FromFrameTreeNode(frame_tree_node);
ananta4b7467a52016-09-23 01:42:38364}
365
leon.han552e9de2017-02-09 14:37:30366void WebContents::SetScreenOrientationDelegate(
367 ScreenOrientationDelegate* delegate) {
368 ScreenOrientationProvider::SetDelegate(delegate);
369}
370
[email protected]7fff43e2013-05-21 20:21:10371// WebContentsImpl::DestructionObserver ----------------------------------------
372
373class WebContentsImpl::DestructionObserver : public WebContentsObserver {
374 public:
375 DestructionObserver(WebContentsImpl* owner, WebContents* watched_contents)
376 : WebContentsObserver(watched_contents),
377 owner_(owner) {
378 }
379
380 // WebContentsObserver:
dchengc2282aa2014-10-21 12:07:58381 void WebContentsDestroyed() override {
[email protected]12a46832014-05-09 13:35:58382 owner_->OnWebContentsDestroyed(
383 static_cast<WebContentsImpl*>(web_contents()));
[email protected]7fff43e2013-05-21 20:21:10384 }
385
386 private:
387 WebContentsImpl* owner_;
388
389 DISALLOW_COPY_AND_ASSIGN(DestructionObserver);
390};
391
[email protected]8ed16472014-04-11 19:02:48392WebContentsImpl::ColorChooserInfo::ColorChooserInfo(int render_process_id,
393 int render_frame_id,
394 ColorChooser* chooser,
395 int identifier)
396 : render_process_id(render_process_id),
397 render_frame_id(render_frame_id),
398 chooser(chooser),
399 identifier(identifier) {
400}
401
402WebContentsImpl::ColorChooserInfo::~ColorChooserInfo() {
403}
404
nicka0ac8382016-12-15 23:59:23405bool WebContentsImpl::ColorChooserInfo::Matches(
406 RenderFrameHostImpl* render_frame_host,
407 int color_chooser_id) {
408 return this->render_process_id == render_frame_host->GetProcess()->GetID() &&
409 this->render_frame_id == render_frame_host->GetRoutingID() &&
410 this->identifier == color_chooser_id;
411}
412
lazyboy6ec48b2a2015-06-29 15:18:14413// WebContentsImpl::WebContentsTreeNode ----------------------------------------
lfg601233692017-03-06 22:45:44414WebContentsImpl::WebContentsTreeNode::WebContentsTreeNode(
415 WebContentsImpl* current_web_contents)
416 : current_web_contents_(current_web_contents),
417 outer_web_contents_(nullptr),
lazyboy6ec48b2a2015-06-29 15:18:14418 outer_contents_frame_tree_node_id_(
avallee0206f782016-07-28 18:55:33419 FrameTreeNode::kFrameTreeNodeInvalidId),
lfg601233692017-03-06 22:45:44420 focused_web_contents_(current_web_contents) {}
lazyboy6ec48b2a2015-06-29 15:18:14421
422WebContentsImpl::WebContentsTreeNode::~WebContentsTreeNode() {
lfga3e2bdc2017-03-07 20:44:01423 if (OuterContentsFrameTreeNode())
424 OuterContentsFrameTreeNode()->RemoveObserver(this);
paulmeyerfeafc2d2017-04-25 21:46:40425
426 if (outer_web_contents_)
427 outer_web_contents_->node_.DetachInnerWebContents(current_web_contents_);
lazyboy6ec48b2a2015-06-29 15:18:14428}
429
430void WebContentsImpl::WebContentsTreeNode::ConnectToOuterWebContents(
431 WebContentsImpl* outer_web_contents,
432 RenderFrameHostImpl* outer_contents_frame) {
lfg601233692017-03-06 22:45:44433 focused_web_contents_ = nullptr;
lazyboy6ec48b2a2015-06-29 15:18:14434 outer_web_contents_ = outer_web_contents;
435 outer_contents_frame_tree_node_id_ =
436 outer_contents_frame->frame_tree_node()->frame_tree_node_id();
437
paulmeyerfeafc2d2017-04-25 21:46:40438 outer_web_contents_->node_.AttachInnerWebContents(current_web_contents_);
lfga3e2bdc2017-03-07 20:44:01439 outer_contents_frame->frame_tree_node()->AddObserver(this);
lfg601233692017-03-06 22:45:44440}
lazyboy6ec48b2a2015-06-29 15:18:14441
paulmeyerfeafc2d2017-04-25 21:46:40442void WebContentsImpl::WebContentsTreeNode::AttachInnerWebContents(
443 WebContentsImpl* inner_web_contents) {
444 inner_web_contents_.push_back(inner_web_contents);
445}
446
447void WebContentsImpl::WebContentsTreeNode::DetachInnerWebContents(
448 WebContentsImpl* inner_web_contents) {
449 DCHECK(std::find(inner_web_contents_.begin(), inner_web_contents_.end(),
450 inner_web_contents) != inner_web_contents_.end());
451 inner_web_contents_.erase(
452 std::remove(inner_web_contents_.begin(), inner_web_contents_.end(),
453 inner_web_contents),
454 inner_web_contents_.end());
455}
456
lfga3e2bdc2017-03-07 20:44:01457FrameTreeNode*
458WebContentsImpl::WebContentsTreeNode::OuterContentsFrameTreeNode() const {
459 return FrameTreeNode::GloballyFindByID(outer_contents_frame_tree_node_id_);
lfg601233692017-03-06 22:45:44460}
461
lfga3e2bdc2017-03-07 20:44:01462void WebContentsImpl::WebContentsTreeNode::OnFrameTreeNodeDestroyed(
463 FrameTreeNode* node) {
464 DCHECK_EQ(outer_contents_frame_tree_node_id_, node->frame_tree_node_id())
465 << "WebContentsTreeNode should only receive notifications for the "
466 "FrameTreeNode in its outer WebContents that hosts it.";
467 delete current_web_contents_; // deletes |this| too.
lazyboy6ec48b2a2015-06-29 15:18:14468}
469
avallee0206f782016-07-28 18:55:33470void WebContentsImpl::WebContentsTreeNode::SetFocusedWebContents(
471 WebContentsImpl* web_contents) {
472 DCHECK(!outer_web_contents())
473 << "Only the outermost WebContents tracks focus.";
474 focused_web_contents_ = web_contents;
475}
476
paulmeyerfeafc2d2017-04-25 21:46:40477WebContentsImpl*
478WebContentsImpl::WebContentsTreeNode::GetInnerWebContentsInFrame(
479 const FrameTreeNode* frame) {
480 auto ftn_id = frame->frame_tree_node_id();
481 for (WebContentsImpl* contents : inner_web_contents_) {
482 if (contents->node_.outer_contents_frame_tree_node_id() == ftn_id) {
483 return contents;
484 }
485 }
486 return nullptr;
487}
488
489const std::vector<WebContentsImpl*>&
490WebContentsImpl::WebContentsTreeNode::inner_web_contents() const {
491 return inner_web_contents_;
492}
493
[email protected]b172aee2012-04-10 17:05:26494// WebContentsImpl -------------------------------------------------------------
[email protected]420ae012009-04-24 05:16:32495
alexmose201c7cd2015-06-10 17:14:21496WebContentsImpl::WebContentsImpl(BrowserContext* browser_context)
[email protected]b680ad22009-04-15 23:19:42497 : delegate_(NULL),
[email protected]69e797f2013-04-30 01:10:22498 controller_(this, browser_context),
[email protected]5a3bdf52012-05-24 15:12:57499 render_view_host_delegate_view_(NULL),
alexmose201c7cd2015-06-10 17:14:21500 created_with_opener_(false),
[email protected]6ea6bdf2013-12-06 13:35:01501 frame_tree_(new NavigatorImpl(&controller_, this),
blundellc57b93f2014-10-29 13:19:57502 this,
503 this,
504 this,
505 this),
lfg601233692017-03-06 22:45:44506 node_(this),
[email protected]6dfed692014-05-22 04:18:03507 is_load_to_different_document_(false),
[email protected]443b80e2010-12-14 00:42:23508 crashed_status_(base::TERMINATION_STATUS_STILL_RUNNING),
509 crashed_error_code_(0),
[email protected]d5f942ba2008-09-26 19:30:34510 waiting_for_response_(false),
[email protected]fcf75d42013-12-03 20:11:26511 load_state_(net::LOAD_STATE_IDLE, base::string16()),
[email protected]094e5b22009-09-25 04:23:56512 upload_size_(0),
513 upload_position_(0),
dfalcantarae6b7b46752015-07-10 18:14:16514 is_resume_pending_(false),
creisadca9862017-06-16 19:12:11515 interstitial_page_(nullptr),
[email protected]b4c84012014-04-28 19:51:10516 has_accessed_initial_document_(false),
yusufod41c5f92015-03-06 00:14:28517 theme_color_(SK_ColorTRANSPARENT),
518 last_sent_theme_color_(SK_ColorTRANSPARENT),
peter90afaba2015-06-01 12:05:29519 did_first_visually_non_empty_paint_(false),
[email protected]54597982013-02-06 01:59:55520 capturer_count_(0),
521 should_normally_be_visible_(true),
Francois Doray18800972017-08-25 22:38:58522 should_normally_be_occluded_(false),
tapted65ff2ea72016-03-01 23:39:00523 did_first_set_visible_(false),
[email protected]fdd61c62009-04-22 19:22:57524 is_being_destroyed_(false),
creis97867aa2017-02-17 18:39:45525 is_notifying_observers_(false),
[email protected]fdd61c62009-04-22 19:22:57526 notify_disconnection_(false),
[email protected]71a88bb2013-02-01 22:05:15527 dialog_manager_(NULL),
[email protected]7ab1e7d62009-10-14 23:32:01528 is_showing_before_unload_dialog_(false),
gab0dccfef2015-05-20 18:43:39529 last_active_time_(base::TimeTicks::Now()),
[email protected]ebf40a72010-07-22 01:46:38530 closed_by_user_gesture_(false),
[email protected]8ff00d72012-10-23 19:12:21531 minimum_zoom_percent_(static_cast<int>(kMinimumZoomFactor * 100)),
532 maximum_zoom_percent_(static_cast<int>(kMaximumZoomFactor * 100)),
w.shackleton49bcd392016-01-06 17:38:22533 zoom_scroll_remainder_(0),
alexmosc9e76ec2016-05-16 22:59:37534 fullscreen_widget_process_id_(ChildProcessHost::kInvalidUniqueID),
[email protected]5dcaf8e2013-12-28 01:31:42535 fullscreen_widget_routing_id_(MSG_ROUTING_NONE),
[email protected]0b431992014-06-24 00:08:03536 fullscreen_widget_had_focus_at_shutdown_(false),
[email protected]87de04b02014-04-08 22:14:49537 is_subframe_(false),
[email protected]34ff1cfc2014-08-20 06:16:05538 force_disable_overscroll_content_(false),
[email protected]95640212014-07-26 18:14:30539 last_dialog_suppressed_(false),
Conley Owens6894c4f2017-07-10 19:29:13540 geolocation_context_(new device::GeolocationContext()),
waffles1c12bf402016-02-10 17:45:48541 accessibility_mode_(
542 BrowserAccessibilityStateImpl::GetInstance()->accessibility_mode()),
avayvodcc85bbd2015-08-28 19:11:15543 audio_stream_monitor_(this),
ortunodf4d7982016-04-08 02:33:35544 bluetooth_connected_device_count_(0),
mcnee336ea2c2017-05-23 22:50:59545#if !defined(OS_ANDROID)
mcnee432e47d2015-11-09 19:37:46546 page_scale_factor_is_one_(true),
mcnee336ea2c2017-05-23 22:50:59547#endif // !defined(OS_ANDROID)
lfgbee1e0a2016-06-08 21:24:21548 mouse_lock_widget_(nullptr),
qinmin72e8bd02016-10-21 19:35:37549 is_overlay_content_(false),
ekaramadf6750aa2017-06-06 18:29:42550 showing_context_menu_(false),
pkotwicz75ca8ffd2016-02-16 23:10:19551 loading_weak_factory_(this),
552 weak_factory_(this) {
[email protected]9b159a52013-10-03 17:24:55553 frame_tree_.SetFrameRemoveListener(
554 base::Bind(&WebContentsImpl::OnFrameRemoved,
555 base::Unretained(this)));
dalecurtisc85ed632016-01-13 00:22:46556#if defined(OS_ANDROID)
557 media_web_contents_observer_.reset(new MediaWebContentsObserverAndroid(this));
558#else
qinmin58567c82015-01-07 21:00:20559 media_web_contents_observer_.reset(new MediaWebContentsObserver(this));
dalecurtisc85ed632016-01-13 00:22:46560#endif
brettw4b461082016-11-19 18:55:16561#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17562 pepper_playback_observer_.reset(new PepperPlaybackObserver(this));
563#endif
blundelle75a8f92017-03-27 08:11:17564
csharrisona2280cd2016-02-03 23:21:15565 loader_io_thread_notifier_.reset(new LoaderIOThreadNotifier(this));
mcnee336ea2c2017-05-23 22:50:59566#if !defined(OS_ANDROID)
scottmg276753cf2016-10-27 18:25:22567 host_zoom_map_observer_.reset(new HostZoomMapObserver(this));
mcnee336ea2c2017-05-23 22:50:59568#endif // !defined(OS_ANDROID)
[email protected]332af7732009-03-11 13:21:35569}
initial.commit09911bf2008-07-26 23:55:29570
[email protected]b172aee2012-04-10 17:05:26571WebContentsImpl::~WebContentsImpl() {
creisba91ba82017-05-12 22:56:19572 // Imperfect sanity check against double free, given some crashes unexpectedly
573 // observed in the wild.
574 CHECK(!is_being_destroyed_);
575
576 // We generally keep track of is_being_destroyed_ to let other features know
577 // to avoid certain actions during destruction.
[email protected]420ae012009-04-24 05:16:32578 is_being_destroyed_ = true;
579
creis97867aa2017-02-17 18:39:45580 // A WebContents should never be deleted while it is notifying observers,
creisba91ba82017-05-12 22:56:19581 // since this will lead to a use-after-free as it continues to notify later
creis97867aa2017-02-17 18:39:45582 // observers.
583 CHECK(!is_notifying_observers_);
584
kenrb2a565f82015-09-02 20:24:59585 rwh_input_event_router_.reset();
586
rockotf62002a2016-09-15 00:08:59587 for (auto& entry : binding_sets_)
588 entry.second->CloseAllBindings();
589
avallee0206f782016-07-28 18:55:33590 WebContentsImpl* outermost = GetOutermostWebContents();
avallee9993fca2016-11-17 06:16:50591 if (this != outermost && ContainsOrIsFocusedWebContents()) {
avallee0206f782016-07-28 18:55:33592 // If the current WebContents is in focus, unset it.
avallee9993fca2016-11-17 06:16:50593 outermost->SetAsFocusedWebContentsIfNecessary();
avallee0206f782016-07-28 18:55:33594 }
595
dcheng72be33c2016-01-21 04:11:31596 for (FrameTreeNode* node : frame_tree_.Nodes()) {
597 // Delete all RFHs pending shutdown, which will lead the corresponding RVHs
598 // to be shutdown and be deleted as well.
dcheng57e39e22016-01-21 00:25:38599 node->render_manager()->ClearRFHsPendingShutdown();
dcheng57e39e22016-01-21 00:25:38600 node->render_manager()->ClearWebUIInstances();
dcheng72be33c2016-01-21 04:11:31601 }
carlosk35f35af2015-12-01 10:55:40602
dcheng57e39e22016-01-21 00:25:38603 for (RenderWidgetHostImpl* widget : created_widgets_)
604 widget->DetachDelegate();
[email protected]b24b68a2012-09-24 21:57:26605 created_widgets_.clear();
606
[email protected]3ab9cb82011-06-03 18:02:07607 // Clear out any JavaScript state.
avi5d3b8692016-10-12 22:00:46608 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:53609 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:46610 }
[email protected]3ab9cb82011-06-03 18:02:07611
[email protected]8ed16472014-04-11 19:02:48612 if (color_chooser_info_.get())
613 color_chooser_info_->chooser->End();
[email protected]da8543762012-03-20 08:52:20614
[email protected]420ae012009-04-24 05:16:32615 NotifyDisconnected();
[email protected]420ae012009-04-24 05:16:32616
[email protected]ca13a442012-04-17 14:00:12617 // Notify any observer that have a reference on this WebContents.
[email protected]8ff00d72012-10-23 19:12:21618 NotificationService::current()->Notify(
619 NOTIFICATION_WEB_CONTENTS_DESTROYED,
620 Source<WebContents>(this),
621 NotificationService::NoDetails());
[email protected]420ae012009-04-24 05:16:32622
[email protected]df0c843f2014-05-23 20:37:23623 // Destroy all frame tree nodes except for the root; this notifies observers.
nick53d5cbf2015-04-23 22:50:14624 frame_tree_.root()->ResetForNewProcess();
[email protected]df0c843f2014-05-23 20:37:23625 GetRenderManager()->ResetProxyHosts();
[email protected]c06c58c2014-03-12 20:31:59626
clamy0e119882015-07-31 16:12:33627 // Manually call the observer methods for the root frame tree node. It is
628 // necessary to manually delete all objects tracking navigations
629 // (NavigationHandle, NavigationRequest) for observers to be properly
630 // notified of these navigations stopping before the WebContents is
631 // destroyed.
[email protected]df0c843f2014-05-23 20:37:23632 RenderFrameHostManager* root = GetRenderManager();
naskob21fe4872015-02-24 14:15:56633
clamy0e119882015-07-31 16:12:33634 if (root->pending_frame_host()) {
naskob21fe4872015-02-24 14:15:56635 root->pending_frame_host()->SetRenderFrameCreated(false);
clamy0e119882015-07-31 16:12:33636 root->pending_frame_host()->SetNavigationHandle(
dcheng59716272016-04-09 05:19:08637 std::unique_ptr<NavigationHandleImpl>());
clamy0e119882015-07-31 16:12:33638 }
naskob21fe4872015-02-24 14:15:56639 root->current_frame_host()->SetRenderFrameCreated(false);
clamy0e119882015-07-31 16:12:33640 root->current_frame_host()->SetNavigationHandle(
dcheng59716272016-04-09 05:19:08641 std::unique_ptr<NavigationHandleImpl>());
clamy0e119882015-07-31 16:12:33642
643 // PlzNavigate: clear up state specific to browser-side navigation.
carloskd80262f52015-12-16 14:40:35644 if (IsBrowserSideNavigationEnabled()) {
clamy82a2f4d2016-02-02 14:20:41645 // Do not update state as the WebContents is being destroyed.
clamya86695b2017-03-23 14:45:48646 frame_tree_.root()->ResetNavigationRequest(true, true);
clamy0e119882015-07-31 16:12:33647 if (root->speculative_frame_host()) {
648 root->speculative_frame_host()->SetRenderFrameCreated(false);
649 root->speculative_frame_host()->SetNavigationHandle(
dcheng59716272016-04-09 05:19:08650 std::unique_ptr<NavigationHandleImpl>());
clamy0e119882015-07-31 16:12:33651 }
652 }
[email protected]f273ee52013-10-18 16:05:27653
brettw4b461082016-11-19 18:55:16654#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17655 // Call this before WebContentsDestroyed() is broadcasted since
656 // AudioFocusManager will be destroyed after that.
657 pepper_playback_observer_.reset();
658#endif // defined(ENABLED_PLUGINS)
659
ericwilligersde386342016-10-19 02:35:09660 for (auto& observer : observers_)
661 observer.FrameDeleted(root->current_frame_host());
naskoa83483fb2015-02-27 16:57:10662
[email protected]df0c843f2014-05-23 20:37:23663 if (root->pending_render_view_host()) {
ericwilligersde386342016-10-19 02:35:09664 for (auto& observer : observers_)
665 observer.RenderViewDeleted(root->pending_render_view_host());
[email protected]df0c843f2014-05-23 20:37:23666 }
[email protected]c06c58c2014-03-12 20:31:59667
ericwilligersde386342016-10-19 02:35:09668 for (auto& observer : observers_)
669 observer.RenderViewDeleted(root->current_host());
[email protected]f273ee52013-10-18 16:05:27670
ericwilligersde386342016-10-19 02:35:09671 for (auto& observer : observers_)
672 observer.WebContentsDestroyed();
[email protected]12a46832014-05-09 13:35:58673
ericwilligersde386342016-10-19 02:35:09674 for (auto& observer : observers_)
675 observer.ResetWebContents();
[email protected]232a5812011-03-04 22:42:08676
[email protected]6934a702011-12-20 00:04:51677 SetDelegate(NULL);
[email protected]b5a1d11c2011-02-17 03:09:42678}
679
[email protected]d1198fd2012-08-13 22:50:19680WebContentsImpl* WebContentsImpl::CreateWithOpener(
[email protected]54944cde2012-12-09 09:24:59681 const WebContents::CreateParams& params,
alexmose201c7cd2015-06-10 17:14:21682 FrameTreeNode* opener) {
[email protected]e11f0e92013-06-12 15:12:03683 TRACE_EVENT0("browser", "WebContentsImpl::CreateWithOpener");
alexmose201c7cd2015-06-10 17:14:21684 WebContentsImpl* new_contents = new WebContentsImpl(params.browser_context);
lukasza6f8ac622017-06-06 03:10:20685 new_contents->SetOpenerForNewContents(opener, params.opener_suppressed);
alexmose201c7cd2015-06-10 17:14:21686
alexmosaedfc6f2016-01-21 23:57:38687 // If the opener is sandboxed, a new popup must inherit the opener's sandbox
688 // flags, and these flags take effect immediately. An exception is if the
689 // opener's sandbox flags lack the PropagatesToAuxiliaryBrowsingContexts
690 // bit (which is controlled by the "allow-popups-to-escape-sandbox" token).
691 // See https://html.spec.whatwg.org/#attr-iframe-sandbox.
lukasza6f8ac622017-06-06 03:10:20692 FrameTreeNode* new_root = new_contents->GetFrameTree()->root();
alexmosaedfc6f2016-01-21 23:57:38693 if (opener) {
694 blink::WebSandboxFlags opener_flags = opener->effective_sandbox_flags();
695 const blink::WebSandboxFlags inherit_flag =
Blink Reformat1c4d759e2017-04-09 16:34:54696 blink::WebSandboxFlags::kPropagatesToAuxiliaryBrowsingContexts;
alexmosaedfc6f2016-01-21 23:57:38697 if ((opener_flags & inherit_flag) == inherit_flag) {
698 new_root->SetPendingSandboxFlags(opener_flags);
iclelland92f8c0b2017-04-19 12:43:05699 new_root->CommitPendingFramePolicy();
alexmosaedfc6f2016-01-21 23:57:38700 }
701 }
702
alexmose201c7cd2015-06-10 17:14:21703 // This may be true even when opener is null, such as when opening blocked
704 // popups.
alexmos090fae8e2015-05-28 17:09:28705 if (params.created_with_opener)
706 new_contents->created_with_opener_ = true;
707
[email protected]4858e432014-06-23 18:14:17708 if (params.guest_delegate) {
[email protected]83100cd2014-05-10 11:50:06709 // This makes |new_contents| act as a guest.
710 // For more info, see comment above class BrowserPluginGuest.
[email protected]2101c4c2014-08-22 00:16:16711 BrowserPluginGuest::Create(new_contents, params.guest_delegate);
[email protected]83100cd2014-05-10 11:50:06712 // We are instantiating a WebContents for browser plugin. Set its subframe
713 // bit to true.
714 new_contents->is_subframe_ = true;
715 }
[email protected]54944cde2012-12-09 09:24:59716 new_contents->Init(params);
[email protected]d1198fd2012-08-13 22:50:19717 return new_contents;
718}
719
[email protected]95640212014-07-26 18:14:30720// static
721std::vector<WebContentsImpl*> WebContentsImpl::GetAllWebContents() {
722 std::vector<WebContentsImpl*> result;
dcheng59716272016-04-09 05:19:08723 std::unique_ptr<RenderWidgetHostIterator> widgets(
[email protected]95640212014-07-26 18:14:30724 RenderWidgetHostImpl::GetRenderWidgetHosts());
[email protected]95640212014-07-26 18:14:30725 while (RenderWidgetHost* rwh = widgets->GetNextHost()) {
[email protected]95640212014-07-26 18:14:30726 RenderViewHost* rvh = RenderViewHost::From(rwh);
727 if (!rvh)
728 continue;
729 WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
730 if (!web_contents)
731 continue;
avidf38c952015-10-27 13:45:13732 if (web_contents->GetRenderViewHost() != rvh)
733 continue;
734 // Because a WebContents can only have one current RVH at a time, there will
735 // be no duplicate WebContents here.
736 result.push_back(static_cast<WebContentsImpl*>(web_contents));
[email protected]95640212014-07-26 18:14:30737 }
738 return result;
739}
740
clamya16aa8172015-05-26 13:07:25741// static
742WebContentsImpl* WebContentsImpl::FromFrameTreeNode(
paulmeyerfeafc2d2017-04-25 21:46:40743 const FrameTreeNode* frame_tree_node) {
clamya16aa8172015-05-26 13:07:25744 return static_cast<WebContentsImpl*>(
745 WebContents::FromRenderFrameHost(frame_tree_node->current_frame_host()));
746}
747
clamy0d32d6d2015-11-24 11:16:26748// static
749WebContents* WebContentsImpl::FromRenderFrameHostID(int render_process_host_id,
750 int render_frame_host_id) {
751 DCHECK_CURRENTLY_ON(BrowserThread::UI);
752 RenderFrameHost* render_frame_host =
753 RenderFrameHost::FromID(render_process_host_id, render_frame_host_id);
754 if (!render_frame_host)
755 return nullptr;
756
757 return WebContents::FromRenderFrameHost(render_frame_host);
758}
759
paulmeyerfeafc2d2017-04-25 21:46:40760// static
761WebContentsImpl* WebContentsImpl::FromOuterFrameTreeNode(
762 const FrameTreeNode* frame_tree_node) {
763 return WebContentsImpl::FromFrameTreeNode(frame_tree_node)
764 ->node_.GetInnerWebContentsInFrame(frame_tree_node);
765}
766
[email protected]b0936d22013-11-28 06:47:36767RenderFrameHostManager* WebContentsImpl::GetRenderManagerForTesting() {
[email protected]fa944cb82013-11-15 17:51:21768 return GetRenderManager();
[email protected]765187182012-01-11 23:59:28769}
770
nicka0ac8382016-12-15 23:59:23771bool WebContentsImpl::OnMessageReceived(RenderViewHostImpl* render_view_host,
[email protected]7bb761892012-07-20 09:32:47772 const IPC::Message& message) {
nicka0ac8382016-12-15 23:59:23773 for (auto& observer : observers_) {
Lukasz Anforowicz89f2c1b2017-08-30 21:36:46774 // TODO(nick, creis): https://crbug.com/758026: Replace all uses of this
775 // variant of OnMessageReceived with the version that takes a
776 // RenderFrameHost, and then delete it.
nicka0ac8382016-12-15 23:59:23777 if (observer.OnMessageReceived(message))
778 return true;
[email protected]64ffefa2014-05-10 12:06:33779 }
[email protected]403415a2011-01-10 18:57:53780
[email protected]724159a2010-12-30 01:11:18781 bool handled = true;
nicka0ac8382016-12-15 23:59:23782 IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(WebContentsImpl, message, render_view_host)
783 IPC_MESSAGE_HANDLER(ViewHostMsg_DidFirstVisuallyNonEmptyPaint,
784 OnFirstVisuallyNonEmptyPaint)
785 IPC_MESSAGE_HANDLER(ViewHostMsg_GoToEntryAtOffset, OnGoToEntryAtOffset)
786 IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateZoomLimits, OnUpdateZoomLimits)
787 IPC_MESSAGE_HANDLER(ViewHostMsg_PageScaleFactorChanged,
788 OnPageScaleFactorChanged)
789 IPC_MESSAGE_HANDLER(ViewHostMsg_EnumerateDirectory, OnEnumerateDirectory)
790 IPC_MESSAGE_HANDLER(ViewHostMsg_AppCacheAccessed, OnAppCacheAccessed)
nicka0ac8382016-12-15 23:59:23791#if BUILDFLAG(ENABLE_PLUGINS)
792 IPC_MESSAGE_HANDLER(ViewHostMsg_RequestPpapiBrokerPermission,
793 OnRequestPpapiBrokerPermission)
794#endif
nicka0ac8382016-12-15 23:59:23795 IPC_MESSAGE_HANDLER(ViewHostMsg_ShowValidationMessage,
796 OnShowValidationMessage)
797 IPC_MESSAGE_HANDLER(ViewHostMsg_HideValidationMessage,
798 OnHideValidationMessage)
799 IPC_MESSAGE_HANDLER(ViewHostMsg_MoveValidationMessage,
800 OnMoveValidationMessage)
801#if defined(OS_ANDROID)
802 IPC_MESSAGE_HANDLER(ViewHostMsg_OpenDateTimeDialog, OnOpenDateTimeDialog)
803#endif
804 IPC_MESSAGE_UNHANDLED(handled = false)
805 IPC_END_MESSAGE_MAP()
806
807 return handled;
808}
809
810bool WebContentsImpl::OnMessageReceived(RenderFrameHostImpl* render_frame_host,
811 const IPC::Message& message) {
Lukasz Anforowicz02923102017-10-09 18:11:37812 {
813 WebUIImpl* web_ui = render_frame_host->web_ui();
814 if (web_ui && web_ui->OnMessageReceived(message, render_frame_host))
815 return true;
816 }
817
nicka0ac8382016-12-15 23:59:23818 for (auto& observer : observers_) {
819 if (observer.OnMessageReceived(message, render_frame_host))
820 return true;
821 }
822
823 bool handled = true;
824 IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(WebContentsImpl, message, render_frame_host)
[email protected]cfa856d62014-02-22 07:58:40825 IPC_MESSAGE_HANDLER(FrameHostMsg_DomOperationResponse,
826 OnDomOperationResponse)
[email protected]37b64c52014-07-11 21:14:05827 IPC_MESSAGE_HANDLER(FrameHostMsg_DidChangeThemeColor,
828 OnThemeColorChanged)
[email protected]8ed16472014-04-11 19:02:48829 IPC_MESSAGE_HANDLER(FrameHostMsg_DidFinishDocumentLoad,
830 OnDocumentLoadedInFrame)
831 IPC_MESSAGE_HANDLER(FrameHostMsg_DidFinishLoad, OnDidFinishLoad)
832 IPC_MESSAGE_HANDLER(FrameHostMsg_OpenColorChooser, OnOpenColorChooser)
833 IPC_MESSAGE_HANDLER(FrameHostMsg_EndColorChooser, OnEndColorChooser)
834 IPC_MESSAGE_HANDLER(FrameHostMsg_SetSelectedColorInColorChooser,
835 OnSetSelectedColorInColorChooser)
avi7830c852015-08-31 23:46:25836 IPC_MESSAGE_HANDLER(FrameHostMsg_DidLoadResourceFromMemoryCache,
[email protected]724159a2010-12-30 01:11:18837 OnDidLoadResourceFromMemoryCache)
avi3a3332622015-09-01 01:18:54838 IPC_MESSAGE_HANDLER(FrameHostMsg_DidDisplayInsecureContent,
[email protected]724159a2010-12-30 01:11:18839 OnDidDisplayInsecureContent)
elawrenceb2ac2a232017-03-27 21:46:25840 IPC_MESSAGE_HANDLER(FrameHostMsg_DidContainInsecureFormAction,
841 OnDidContainInsecureFormAction)
avi3a3332622015-09-01 01:18:54842 IPC_MESSAGE_HANDLER(FrameHostMsg_DidRunInsecureContent,
[email protected]724159a2010-12-30 01:11:18843 OnDidRunInsecureContent)
estark910b4572015-12-09 20:55:41844 IPC_MESSAGE_HANDLER(FrameHostMsg_DidDisplayContentWithCertificateErrors,
845 OnDidDisplayContentWithCertificateErrors)
846 IPC_MESSAGE_HANDLER(FrameHostMsg_DidRunContentWithCertificateErrors,
847 OnDidRunContentWithCertificateErrors)
avia23e16b2015-07-09 14:18:48848 IPC_MESSAGE_HANDLER(FrameHostMsg_RegisterProtocolHandler,
849 OnRegisterProtocolHandler)
850 IPC_MESSAGE_HANDLER(FrameHostMsg_UnregisterProtocolHandler,
851 OnUnregisterProtocolHandler)
kouhei40f03cb2015-09-24 07:47:01852 IPC_MESSAGE_HANDLER(FrameHostMsg_UpdatePageImportanceSignals,
853 OnUpdatePageImportanceSignals)
paulmeyer5d0a5f02016-01-21 20:15:52854 IPC_MESSAGE_HANDLER(FrameHostMsg_Find_Reply, OnFindReply)
lukasza178ff092017-06-07 23:39:50855 IPC_MESSAGE_HANDLER(FrameHostMsg_UpdateFaviconURL, OnUpdateFaviconURL)
brettw4b461082016-11-19 18:55:16856#if BUILDFLAG(ENABLE_PLUGINS)
emaxxe70f5e12015-05-29 11:26:00857 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperInstanceCreated,
858 OnPepperInstanceCreated)
859 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperInstanceDeleted,
860 OnPepperInstanceDeleted)
tommyclie6633ca72014-10-31 00:40:42861 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperPluginHung, OnPepperPluginHung)
zqzhang181047e62016-07-01 13:37:17862 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperStartsPlayback,
863 OnPepperStartsPlayback)
864 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperStopsPlayback,
865 OnPepperStopsPlayback)
tommyclie6633ca72014-10-31 00:40:42866 IPC_MESSAGE_HANDLER(FrameHostMsg_PluginCrashed, OnPluginCrashed)
[email protected]c4538072013-03-18 02:17:55867 IPC_MESSAGE_HANDLER_GENERIC(BrowserPluginHostMsg_Attach,
fsamuel833ee7c2015-02-13 23:40:40868 OnBrowserPluginMessage(render_frame_host,
869 message))
thestigc4cac8f2014-09-04 21:17:50870#endif
mfomitchev2b8b066a2016-01-28 19:23:15871#if defined(OS_ANDROID)
paulmeyer5d0a5f02016-01-21 20:15:52872 IPC_MESSAGE_HANDLER(FrameHostMsg_FindMatchRects_Reply,
[email protected]8ed16472014-04-11 19:02:48873 OnFindMatchRectsReply)
paulmeyerc8cb7cb2016-06-07 01:14:19874 IPC_MESSAGE_HANDLER(FrameHostMsg_GetNearestFindResult_Reply,
875 OnGetNearestFindResultReply)
[email protected]8ed16472014-04-11 19:02:48876#endif
[email protected]724159a2010-12-30 01:11:18877 IPC_MESSAGE_UNHANDLED(handled = false)
[email protected]e44d1342014-05-16 21:29:33878 IPC_END_MESSAGE_MAP()
[email protected]724159a2010-12-30 01:11:18879
[email protected]724159a2010-12-30 01:11:18880 return handled;
881}
882
[email protected]d1198fd2012-08-13 22:50:19883NavigationControllerImpl& WebContentsImpl::GetController() {
[email protected]f5fa20e2011-12-21 22:35:56884 return controller_;
885}
886
[email protected]d1198fd2012-08-13 22:50:19887const NavigationControllerImpl& WebContentsImpl::GetController() const {
[email protected]f5fa20e2011-12-21 22:35:56888 return controller_;
889}
890
[email protected]8ff00d72012-10-23 19:12:21891BrowserContext* WebContentsImpl::GetBrowserContext() const {
[email protected]a26023822011-12-29 00:23:55892 return controller_.GetBrowserContext();
[email protected]627e0512011-12-21 22:55:30893}
894
[email protected]b172aee2012-04-10 17:05:26895const GURL& WebContentsImpl::GetURL() const {
[email protected]c854a7e2013-05-21 16:42:24896 // We may not have a navigation entry yet.
[email protected]59167c22013-06-03 18:07:32897 NavigationEntry* entry = controller_.GetVisibleEntry();
[email protected]36fc0392011-12-25 03:59:51898 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
[email protected]be1f56ab2011-12-22 06:55:31899}
900
[email protected]a093ce02013-07-22 20:53:14901const GURL& WebContentsImpl::GetVisibleURL() const {
[email protected]c854a7e2013-05-21 16:42:24902 // We may not have a navigation entry yet.
[email protected]59167c22013-06-03 18:07:32903 NavigationEntry* entry = controller_.GetVisibleEntry();
[email protected]c854a7e2013-05-21 16:42:24904 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
905}
906
907const GURL& WebContentsImpl::GetLastCommittedURL() const {
908 // We may not have a navigation entry yet.
909 NavigationEntry* entry = controller_.GetLastCommittedEntry();
910 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
911}
912
[email protected]8ff00d72012-10-23 19:12:21913WebContentsDelegate* WebContentsImpl::GetDelegate() {
[email protected]be1f56ab2011-12-22 06:55:31914 return delegate_;
915}
916
[email protected]8ff00d72012-10-23 19:12:21917void WebContentsImpl::SetDelegate(WebContentsDelegate* delegate) {
[email protected]be1f56ab2011-12-22 06:55:31918 // TODO(cbentzel): remove this debugging code?
919 if (delegate == delegate_)
920 return;
921 if (delegate_)
922 delegate_->Detach(this);
923 delegate_ = delegate;
[email protected]a6b73c62013-02-11 23:05:08924 if (delegate_) {
[email protected]be1f56ab2011-12-22 06:55:31925 delegate_->Attach(this);
[email protected]a6b73c62013-02-11 23:05:08926 // Ensure the visible RVH reflects the new delegate's preferences.
[email protected]86f98a22013-03-20 14:35:00927 if (view_)
[email protected]e85165c642014-06-10 14:34:31928 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
Joel Einbinder848001c2017-09-19 21:39:31929 if (GetRenderViewHost())
930 RenderFrameDevToolsAgentHost::WebContentsCreated(this);
[email protected]a6b73c62013-02-11 23:05:08931 }
[email protected]be1f56ab2011-12-22 06:55:31932}
933
Lukasz Anforowicze9ae3722017-09-29 17:37:38934RenderFrameHostImpl* WebContentsImpl::GetMainFrame() const {
[email protected]94d0cc12013-12-18 00:07:41935 return frame_tree_.root()->current_frame_host();
[email protected]60eca4eb2013-12-06 00:02:16936}
937
nick53d5cbf2015-04-23 22:50:14938RenderFrameHostImpl* WebContentsImpl::GetFocusedFrame() {
939 FrameTreeNode* focused_node = frame_tree_.GetFocusedFrame();
940 if (!focused_node)
941 return nullptr;
942 return focused_node->current_frame_host();
[email protected]9c9343b2014-03-08 02:56:07943}
944
rob3e2a0732016-01-06 21:22:09945RenderFrameHostImpl* WebContentsImpl::FindFrameByFrameTreeNodeId(
creisf71a2632017-05-04 19:03:50946 int frame_tree_node_id,
947 int process_id) {
948 FrameTreeNode* frame = frame_tree_.FindByID(frame_tree_node_id);
949
950 // Sanity check that this is in the caller's expected process. Otherwise a
951 // recent cross-process navigation may have led to a privilege change that the
952 // caller is not expecting.
953 if (!frame ||
954 frame->current_frame_host()->GetProcess()->GetID() != process_id)
955 return nullptr;
956
957 return frame->current_frame_host();
958}
959
960RenderFrameHostImpl* WebContentsImpl::UnsafeFindFrameByFrameTreeNodeId(
rob3e2a0732016-01-06 21:22:09961 int frame_tree_node_id) {
creisf71a2632017-05-04 19:03:50962 // Beware using this! The RenderFrameHost may have changed since the caller
963 // obtained frame_tree_node_id.
rob3e2a0732016-01-06 21:22:09964 FrameTreeNode* frame = frame_tree_.FindByID(frame_tree_node_id);
965 return frame ? frame->current_frame_host() : nullptr;
966}
967
[email protected]a86c0e962013-12-17 17:10:39968void WebContentsImpl::ForEachFrame(
969 const base::Callback<void(RenderFrameHost*)>& on_frame) {
dcheng57e39e22016-01-21 00:25:38970 for (FrameTreeNode* node : frame_tree_.Nodes()) {
971 on_frame.Run(node->current_frame_host());
972 }
[email protected]a86c0e962013-12-17 17:10:39973}
974
dchengafb53e22016-02-04 08:11:08975std::vector<RenderFrameHost*> WebContentsImpl::GetAllFrames() {
976 std::vector<RenderFrameHost*> frame_hosts;
977 for (FrameTreeNode* node : frame_tree_.Nodes())
978 frame_hosts.push_back(node->current_frame_host());
979 return frame_hosts;
980}
981
lukaszacbdf52e2016-01-15 21:19:51982int WebContentsImpl::SendToAllFrames(IPC::Message* message) {
983 int number_of_messages = 0;
dchengafb53e22016-02-04 08:11:08984 for (RenderFrameHost* rfh : GetAllFrames()) {
lukasza1a9ab2422016-03-02 18:47:25985 if (!rfh->IsRenderFrameLive())
986 continue;
987
dchengafb53e22016-02-04 08:11:08988 ++number_of_messages;
989 IPC::Message* message_copy = new IPC::Message(*message);
990 message_copy->set_routing_id(rfh->GetRoutingID());
991 rfh->Send(message_copy);
992 }
[email protected]a86c0e962013-12-17 17:10:39993 delete message;
lukaszacbdf52e2016-01-15 21:19:51994 return number_of_messages;
[email protected]a86c0e962013-12-17 17:10:39995}
996
lfgdb5c4ed2016-03-04 23:09:07997void WebContentsImpl::SendPageMessage(IPC::Message* msg) {
alexmos136fd6e62016-08-15 20:58:41998 frame_tree_.root()->render_manager()->SendPageMessage(msg, nullptr);
lfgdb5c4ed2016-03-04 23:09:07999}
1000
creisc014b402015-04-23 16:41:451001RenderViewHostImpl* WebContentsImpl::GetRenderViewHost() const {
[email protected]fa944cb82013-11-15 17:51:211002 return GetRenderManager()->current_host();
[email protected]be1f56ab2011-12-22 06:55:311003}
1004
creis89a0f782015-05-27 16:13:171005void WebContentsImpl::CancelActiveAndPendingDialogs() {
avi5d3b8692016-10-12 22:00:461006 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:531007 dialog_manager_->CancelDialogs(this, /*reset_state=*/false);
avi5d3b8692016-10-12 22:00:461008 }
creis89a0f782015-05-27 16:13:171009 if (browser_plugin_embedder_)
1010 browser_plugin_embedder_->CancelGuestDialogs();
lukasza041634d2017-06-26 18:20:561011 if (delegate_)
1012 delegate_->HideValidationMessage(this);
creis89a0f782015-05-27 16:13:171013}
1014
naskoc0fceff2015-04-30 15:53:521015void WebContentsImpl::ClosePage() {
1016 GetRenderViewHost()->ClosePage();
1017}
1018
[email protected]b172aee2012-04-10 17:05:261019RenderWidgetHostView* WebContentsImpl::GetRenderWidgetHostView() const {
[email protected]fa944cb82013-11-15 17:51:211020 return GetRenderManager()->GetRenderWidgetHostView();
[email protected]be1f56ab2011-12-22 06:55:311021}
1022
lfg265a2672016-04-23 03:11:021023RenderWidgetHostView* WebContentsImpl::GetTopLevelRenderWidgetHostView() {
1024 if (GetOuterWebContents())
1025 return GetOuterWebContents()->GetTopLevelRenderWidgetHostView();
1026 return GetRenderManager()->GetRenderWidgetHostView();
1027}
1028
[email protected]4aebbca2013-09-17 22:26:491029RenderWidgetHostView* WebContentsImpl::GetFullscreenRenderWidgetHostView()
1030 const {
vmpstr6d9996c82017-02-23 00:43:251031 if (auto* widget_host = GetFullscreenRenderWidgetHost())
ekaramadaeb3c5c2016-11-09 03:22:351032 return widget_host->GetView();
1033 return nullptr;
[email protected]4aebbca2013-09-17 22:26:491034}
1035
[email protected]8ff00d72012-10-23 19:12:211036WebContentsView* WebContentsImpl::GetView() const {
[email protected]be1f56ab2011-12-22 06:55:311037 return view_.get();
1038}
1039
leon.han552e9de2017-02-09 14:37:301040void WebContentsImpl::OnScreenOrientationChange() {
1041 DCHECK(screen_orientation_provider_);
1042 return screen_orientation_provider_->OnOrientationChange();
leon.hane4db177a2017-02-07 14:19:161043}
1044
yusufod41c5f92015-03-06 00:14:281045SkColor WebContentsImpl::GetThemeColor() const {
1046 return theme_color_;
1047}
1048
Doug Turner63f3c7b2017-07-29 05:10:011049void WebContentsImpl::SetAccessibilityMode(ui::AXMode mode) {
[email protected]95640212014-07-26 18:14:301050 if (mode == accessibility_mode_)
1051 return;
1052
dmazzonif8a31042016-12-03 00:52:131053 // Don't allow accessibility to be enabled for WebContents that are never
1054 // visible, like background pages.
1055 if (IsNeverVisible())
1056 return;
1057
[email protected]95640212014-07-26 18:14:301058 accessibility_mode_ = mode;
dcheng57e39e22016-01-21 00:25:381059
1060 for (FrameTreeNode* node : frame_tree_.Nodes()) {
dmazzonif8a31042016-12-03 00:52:131061 UpdateAccessibilityModeOnFrame(node->current_frame_host());
dcheng57e39e22016-01-21 00:25:381062 RenderFrameHost* pending_frame_host =
1063 node->render_manager()->pending_frame_host();
1064 if (pending_frame_host)
dmazzonif8a31042016-12-03 00:52:131065 UpdateAccessibilityModeOnFrame(pending_frame_host);
dcheng57e39e22016-01-21 00:25:381066 }
[email protected]95640212014-07-26 18:14:301067}
1068
Doug Turner63f3c7b2017-07-29 05:10:011069void WebContentsImpl::AddAccessibilityMode(ui::AXMode mode) {
1070 ui::AXMode new_mode(accessibility_mode_);
dougtcd3dad732017-03-14 03:26:231071 new_mode |= mode;
1072 SetAccessibilityMode(new_mode);
[email protected]95640212014-07-26 18:14:301073}
1074
muyuanlic693ba12017-04-27 19:12:401075void WebContentsImpl::RequestAXTreeSnapshot(
1076 const AXTreeSnapshotCallback& callback) {
dmazzonid95ae842016-04-12 21:17:391077 // Send a request to each of the frames in parallel. Each one will return
1078 // an accessibility tree snapshot, and AXTreeSnapshotCombiner will combine
1079 // them into a single tree and call |callback| with that result, then
1080 // delete |combiner|.
1081 AXTreeSnapshotCombiner* combiner = new AXTreeSnapshotCombiner(callback);
1082 for (FrameTreeNode* frame_tree_node : frame_tree_.Nodes()) {
1083 bool is_root = frame_tree_node->parent() == nullptr;
1084 frame_tree_node->current_frame_host()->RequestAXTreeSnapshot(
1085 combiner->AddFrame(is_root));
1086 }
dmazzoni83ba5c82015-04-14 07:11:511087}
1088
mcnee336ea2c2017-05-23 22:50:591089#if !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:121090void WebContentsImpl::SetTemporaryZoomLevel(double level,
1091 bool temporary_zoom_enabled) {
1092 SendPageMessage(new PageMsg_SetZoomLevel(
1093 MSG_ROUTING_NONE,
1094 temporary_zoom_enabled ? PageMsg_SetZoomLevel_Command::SET_TEMPORARY
1095 : PageMsg_SetZoomLevel_Command::CLEAR_TEMPORARY,
1096 level));
1097}
1098
1099void WebContentsImpl::UpdateZoom(double level) {
1100 // Individual frames may still ignore the new zoom level if their RenderView
1101 // contains a plugin document or if it uses a temporary zoom level.
1102 SendPageMessage(new PageMsg_SetZoomLevel(
1103 MSG_ROUTING_NONE,
1104 PageMsg_SetZoomLevel_Command::USE_CURRENT_TEMPORARY_MODE, level));
1105}
1106
1107void WebContentsImpl::UpdateZoomIfNecessary(const std::string& scheme,
1108 const std::string& host,
1109 double level) {
1110 NavigationEntry* entry = GetController().GetLastCommittedEntry();
1111 if (!entry)
1112 return;
1113
1114 GURL url = HostZoomMap::GetURLFromEntry(entry);
1115 if (host != net::GetHostOrSpecFromURL(url) ||
1116 (!scheme.empty() && !url.SchemeIs(scheme))) {
1117 return;
1118 }
1119
1120 UpdateZoom(level);
1121}
mcnee336ea2c2017-05-23 22:50:591122#endif // !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:121123
rockotf62002a2016-09-15 00:08:591124base::Closure WebContentsImpl::AddBindingSet(
1125 const std::string& interface_name,
1126 WebContentsBindingSet* binding_set) {
1127 auto result =
1128 binding_sets_.insert(std::make_pair(interface_name, binding_set));
1129 DCHECK(result.second);
1130 return base::Bind(&WebContentsImpl::RemoveBindingSet,
1131 weak_factory_.GetWeakPtr(), interface_name);
1132}
1133
rockot8bbad222017-03-22 04:34:051134WebContentsBindingSet* WebContentsImpl::GetBindingSet(
1135 const std::string& interface_name) {
1136 auto it = binding_sets_.find(interface_name);
1137 if (it == binding_sets_.end())
1138 return nullptr;
1139 return it->second;
1140}
1141
paulmeyerfeafc2d2017-04-25 21:46:401142std::vector<WebContentsImpl*> WebContentsImpl::GetInnerWebContents() {
1143 if (browser_plugin_embedder_) {
1144 std::vector<WebContentsImpl*> inner_contents;
1145 GetBrowserContext()->GetGuestManager()->ForEachGuest(
1146 this, base::Bind(&GetInnerWebContentsHelper, &inner_contents));
1147 return inner_contents;
1148 }
1149
1150 return node_.inner_web_contents();
1151}
1152
1153std::vector<WebContentsImpl*> WebContentsImpl::GetWebContentsAndAllInner() {
1154 std::vector<WebContentsImpl*> all_contents(1, this);
1155
1156 for (size_t i = 0; i != all_contents.size(); ++i) {
1157 for (auto* inner_contents : all_contents[i]->GetInnerWebContents()) {
1158 all_contents.push_back(inner_contents);
1159 }
1160 }
1161
1162 return all_contents;
1163}
1164
Sam McNally145fb172017-05-10 00:13:231165void WebContentsImpl::NotifyManifestUrlChanged(
1166 const base::Optional<GURL>& manifest_url) {
1167 for (auto& observer : observers_)
1168 observer.DidUpdateWebManifestURL(manifest_url);
1169}
1170
wjmaclean8a795f32016-08-11 23:49:581171void WebContentsImpl::UpdateDeviceScaleFactor(double device_scale_factor) {
1172 SendPageMessage(
1173 new PageMsg_SetDeviceScaleFactor(MSG_ROUTING_NONE, device_scale_factor));
1174}
1175
ccameron2f451532016-09-07 21:49:271176void WebContentsImpl::GetScreenInfo(ScreenInfo* screen_info) {
wjmaclean8a795f32016-08-11 23:49:581177 if (GetView())
ccameron2f451532016-09-07 21:49:271178 GetView()->GetScreenInfo(screen_info);
wjmaclean8a795f32016-08-11 23:49:581179}
1180
[email protected]8ff00d72012-10-23 19:12:211181WebUI* WebContentsImpl::GetWebUI() const {
carlosk35f35af2015-12-01 10:55:401182 WebUI* commited_web_ui = GetCommittedWebUI();
1183 return commited_web_ui ? commited_web_ui
1184 : GetRenderManager()->GetNavigatingWebUI();
[email protected]be1f56ab2011-12-22 06:55:311185}
1186
[email protected]8ff00d72012-10-23 19:12:211187WebUI* WebContentsImpl::GetCommittedWebUI() const {
carlosk35f35af2015-12-01 10:55:401188 return frame_tree_.root()->current_frame_host()->web_ui();
[email protected]d5f942ba2008-09-26 19:30:341189}
1190
[email protected]86ef6a392012-05-11 22:03:111191void WebContentsImpl::SetUserAgentOverride(const std::string& override) {
[email protected]bf70edce2012-06-20 22:32:221192 if (GetUserAgentOverride() == override)
1193 return;
1194
1195 renderer_preferences_.user_agent_override = override;
1196
1197 // Send the new override string to the renderer.
1198 RenderViewHost* host = GetRenderViewHost();
1199 if (host)
1200 host->SyncRendererPrefs();
1201
1202 // Reload the page if a load is currently in progress to avoid having
1203 // different parts of the page loaded using different user agents.
[email protected]6286a372013-10-09 04:03:271204 NavigationEntry* entry = controller_.GetVisibleEntry();
clamy44e84ce2016-02-22 15:38:251205 if (IsLoading() && entry != NULL && entry->GetIsOverridingUserAgent())
toyoshim6142d96f2016-12-19 09:07:251206 controller_.Reload(ReloadType::BYPASSING_CACHE, true);
[email protected]8d0f3312012-08-18 01:47:531207
ericwilligersde386342016-10-19 02:35:091208 for (auto& observer : observers_)
1209 observer.UserAgentOverrideSet(override);
[email protected]86ef6a392012-05-11 22:03:111210}
1211
1212const std::string& WebContentsImpl::GetUserAgentOverride() const {
[email protected]bf70edce2012-06-20 22:32:221213 return renderer_preferences_.user_agent_override;
[email protected]86ef6a392012-05-11 22:03:111214}
1215
dmazzonidd3d51a72016-12-14 18:41:011216void WebContentsImpl::EnableWebContentsOnlyAccessibilityMode() {
dougtcd3dad732017-03-14 03:26:231217 if (!GetAccessibilityMode().is_mode_off()) {
dchengafb53e22016-02-04 08:11:081218 for (RenderFrameHost* rfh : GetAllFrames())
1219 ResetAccessibility(rfh);
1220 } else {
Doug Turner63f3c7b2017-07-29 05:10:011221 AddAccessibilityMode(ui::kAXModeWebContentsOnly);
dchengafb53e22016-02-04 08:11:081222 }
[email protected]95640212014-07-26 18:14:301223}
1224
dmazzonidd3d51a72016-12-14 18:41:011225bool WebContentsImpl::IsWebContentsOnlyAccessibilityModeForTesting() const {
Doug Turner63f3c7b2017-07-29 05:10:011226 return accessibility_mode_ == ui::kAXModeWebContentsOnly;
[email protected]95640212014-07-26 18:14:301227}
1228
1229bool WebContentsImpl::IsFullAccessibilityModeForTesting() const {
Doug Turner63f3c7b2017-07-29 05:10:011230 return accessibility_mode_ == ui::kAXModeComplete;
[email protected]95640212014-07-26 18:14:301231}
1232
kouhei40f03cb2015-09-24 07:47:011233const PageImportanceSignals& WebContentsImpl::GetPageImportanceSignals() const {
1234 return page_importance_signals_;
1235}
1236
[email protected]fcf75d42013-12-03 20:11:261237const base::string16& WebContentsImpl::GetTitle() const {
[email protected]4c6092c5b2009-06-06 00:23:551238 // Transient entries take precedence. They are used for interstitial pages
1239 // that are shown on top of existing pages.
[email protected]10f417c52011-12-28 21:04:231240 NavigationEntry* entry = controller_.GetTransientEntry();
[email protected]45d0ef7f2011-01-05 13:46:231241 if (entry) {
jshin1fb76462016-04-05 22:13:031242 return entry->GetTitleForDisplay();
[email protected]45d0ef7f2011-01-05 13:46:231243 }
carlosk35f35af2015-12-01 10:55:401244
1245 WebUI* navigating_web_ui = GetRenderManager()->GetNavigatingWebUI();
1246 WebUI* our_web_ui = navigating_web_ui
1247 ? navigating_web_ui
1248 : GetRenderManager()->current_frame_host()->web_ui();
1249
[email protected]7ade2732011-02-10 00:13:581250 if (our_web_ui) {
[email protected]96d185d2009-04-24 03:28:541251 // Don't override the title in view source mode.
[email protected]59167c22013-06-03 18:07:321252 entry = controller_.GetVisibleEntry();
[email protected]96d185d2009-04-24 03:28:541253 if (!(entry && entry->IsViewSourceMode())) {
[email protected]e0112912011-02-02 22:54:351254 // Give the Web UI the chance to override our title.
[email protected]fcf75d42013-12-03 20:11:261255 const base::string16& title = our_web_ui->GetOverriddenTitle();
[email protected]96d185d2009-04-24 03:28:541256 if (!title.empty())
1257 return title;
1258 }
1259 }
1260
1261 // We use the title for the last committed entry rather than a pending
1262 // navigation entry. For example, when the user types in a URL, we want to
1263 // keep the old page's title until the new load has committed and we get a new
1264 // title.
[email protected]96d185d2009-04-24 03:28:541265 entry = controller_.GetLastCommittedEntry();
[email protected]59167c22013-06-03 18:07:321266
creis072b61f2015-09-28 20:52:241267 // We make an exception for initial navigations. We only want to use the title
1268 // from the visible entry if:
1269 // 1. The pending entry has been explicitly assigned a title to display.
1270 // 2. The user is doing a history navigation in a new tab (e.g., Ctrl+Back),
1271 // which case there is a pending entry index other than -1.
1272 //
1273 // Otherwise, we want to stick with the last committed entry's title during
1274 // new navigations, which have pending entries at index -1 with no title.
1275 if (controller_.IsInitialNavigation() &&
1276 ((controller_.GetVisibleEntry() &&
1277 !controller_.GetVisibleEntry()->GetTitle().empty()) ||
1278 controller_.GetPendingEntryIndex() != -1)) {
1279 entry = controller_.GetVisibleEntry();
[email protected]9eeafc012013-11-25 23:49:471280 }
[email protected]59167c22013-06-03 18:07:321281
[email protected]45d0ef7f2011-01-05 13:46:231282 if (entry) {
jshin1fb76462016-04-05 22:13:031283 return entry->GetTitleForDisplay();
[email protected]45d0ef7f2011-01-05 13:46:231284 }
[email protected]987fc3a2011-05-26 14:18:091285
1286 // |page_title_when_no_navigation_entry_| is finally used
1287 // if no title cannot be retrieved.
1288 return page_title_when_no_navigation_entry_;
[email protected]96d185d2009-04-24 03:28:541289}
1290
creiscce56cd2014-09-29 22:45:221291SiteInstanceImpl* WebContentsImpl::GetSiteInstance() const {
[email protected]fa944cb82013-11-15 17:51:211292 return GetRenderManager()->current_host()->GetSiteInstance();
[email protected]96d185d2009-04-24 03:28:541293}
1294
creiscce56cd2014-09-29 22:45:221295SiteInstanceImpl* WebContentsImpl::GetPendingSiteInstance() const {
1296 RenderViewHostImpl* dest_rvh =
1297 GetRenderManager()->pending_render_view_host() ?
1298 GetRenderManager()->pending_render_view_host() :
1299 GetRenderManager()->current_host();
[email protected]9f76c1e2012-03-05 15:15:581300 return dest_rvh->GetSiteInstance();
[email protected]77362eb2011-08-01 17:18:381301}
1302
[email protected]b172aee2012-04-10 17:05:261303bool WebContentsImpl::IsLoading() const {
clamy44e84ce2016-02-22 15:38:251304 return frame_tree_.IsLoading() &&
creisadca9862017-06-16 19:12:111305 !(ShowingInterstitialPage() && interstitial_page_->pause_throbber());
[email protected]3c9e1872010-11-18 16:17:491306}
1307
[email protected]6dfed692014-05-22 04:18:031308bool WebContentsImpl::IsLoadingToDifferentDocument() const {
clamy44e84ce2016-02-22 15:38:251309 return IsLoading() && is_load_to_different_document_;
[email protected]6dfed692014-05-22 04:18:031310}
1311
[email protected]b172aee2012-04-10 17:05:261312bool WebContentsImpl::IsWaitingForResponse() const {
[email protected]6dfed692014-05-22 04:18:031313 return waiting_for_response_ && is_load_to_different_document_;
[email protected]be1f56ab2011-12-22 06:55:311314}
1315
[email protected]b172aee2012-04-10 17:05:261316const net::LoadStateWithParam& WebContentsImpl::GetLoadState() const {
[email protected]be1f56ab2011-12-22 06:55:311317 return load_state_;
1318}
1319
[email protected]fcf75d42013-12-03 20:11:261320const base::string16& WebContentsImpl::GetLoadStateHost() const {
[email protected]be1f56ab2011-12-22 06:55:311321 return load_state_host_;
1322}
1323
avib7348942015-12-25 20:57:101324uint64_t WebContentsImpl::GetUploadSize() const {
[email protected]be1f56ab2011-12-22 06:55:311325 return upload_size_;
1326}
1327
avib7348942015-12-25 20:57:101328uint64_t WebContentsImpl::GetUploadPosition() const {
[email protected]be1f56ab2011-12-22 06:55:311329 return upload_position_;
1330}
1331
[email protected]b172aee2012-04-10 17:05:261332const std::string& WebContentsImpl::GetEncoding() const {
[email protected]ef3adfc2014-05-11 00:04:541333 return canonical_encoding_;
[email protected]be1f56ab2011-12-22 06:55:311334}
1335
[email protected]222f5822014-02-05 23:40:491336void WebContentsImpl::IncrementCapturerCount(const gfx::Size& capture_size) {
[email protected]5a652232013-02-12 06:15:251337 DCHECK(!is_being_destroyed_);
[email protected]54597982013-02-06 01:59:551338 ++capturer_count_;
1339 DVLOG(1) << "There are now " << capturer_count_
1340 << " capturing(s) of WebContentsImpl@" << this;
[email protected]222f5822014-02-05 23:40:491341
1342 // Note: This provides a hint to upstream code to size the views optimally
1343 // for quality (e.g., to avoid scaling).
1344 if (!capture_size.IsEmpty() && preferred_size_for_capture_.IsEmpty()) {
1345 preferred_size_for_capture_ = capture_size;
1346 OnPreferredSizeChanged(preferred_size_);
1347 }
ccameron8807c38f2015-01-17 00:29:191348
1349 // Ensure that all views are un-occluded before capture begins.
Francois Doray18800972017-08-25 22:38:581350 DoWasUnOccluded();
[email protected]54597982013-02-06 01:59:551351}
1352
1353void WebContentsImpl::DecrementCapturerCount() {
1354 --capturer_count_;
1355 DVLOG(1) << "There are now " << capturer_count_
1356 << " capturing(s) of WebContentsImpl@" << this;
1357 DCHECK_LE(0, capturer_count_);
1358
[email protected]5a652232013-02-12 06:15:251359 if (is_being_destroyed_)
1360 return;
1361
[email protected]222f5822014-02-05 23:40:491362 if (capturer_count_ == 0) {
1363 const gfx::Size old_size = preferred_size_for_capture_;
1364 preferred_size_for_capture_ = gfx::Size();
1365 OnPreferredSizeChanged(old_size);
[email protected]222f5822014-02-05 23:40:491366
Francois Doray18800972017-08-25 22:38:581367 if (IsHidden()) {
1368 DVLOG(1) << "Executing delayed WasHidden().";
1369 WasHidden();
1370 }
1371
1372 if (should_normally_be_occluded_)
1373 WasOccluded();
[email protected]54597982013-02-06 01:59:551374 }
[email protected]be1f56ab2011-12-22 06:55:311375}
1376
[email protected]f2bd40812013-07-20 04:30:441377int WebContentsImpl::GetCapturerCount() const {
1378 return capturer_count_;
1379}
1380
miu50f97892014-09-22 22:49:521381bool WebContentsImpl::IsAudioMuted() const {
1382 return audio_muter_.get() && audio_muter_->is_muting();
1383}
1384
1385void WebContentsImpl::SetAudioMuted(bool mute) {
1386 DVLOG(1) << "SetAudioMuted(mute=" << mute << "), was " << IsAudioMuted()
1387 << " for WebContentsImpl@" << this;
1388
1389 if (mute == IsAudioMuted())
1390 return;
1391
1392 if (mute) {
1393 if (!audio_muter_)
1394 audio_muter_.reset(new WebContentsAudioMuter(this));
1395 audio_muter_->StartMuting();
1396 } else {
1397 DCHECK(audio_muter_);
1398 audio_muter_->StopMuting();
1399 }
1400
ericwilligersde386342016-10-19 02:35:091401 for (auto& observer : observers_)
1402 observer.DidUpdateAudioMutingState(mute);
wjmaclean2f797c782016-01-07 14:52:031403
Jan Rucka442c83f2017-08-08 13:27:541404 // Notification for UI updates in response to the changed muting state.
1405 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
1406}
1407
1408bool WebContentsImpl::IsCurrentlyAudible() {
1409 return audio_stream_monitor()->IsCurrentlyAudible();
miu50f97892014-09-22 22:49:521410}
1411
ortunodf4d7982016-04-08 02:33:351412bool WebContentsImpl::IsConnectedToBluetoothDevice() const {
1413 return bluetooth_connected_device_count_ > 0;
ortuno32e7db3c2016-03-29 16:14:201414}
1415
[email protected]b172aee2012-04-10 17:05:261416bool WebContentsImpl::IsCrashed() const {
[email protected]be1f56ab2011-12-22 06:55:311417 return (crashed_status_ == base::TERMINATION_STATUS_PROCESS_CRASHED ||
1418 crashed_status_ == base::TERMINATION_STATUS_ABNORMAL_TERMINATION ||
wfh0d9532a2015-09-02 23:18:581419 crashed_status_ == base::TERMINATION_STATUS_PROCESS_WAS_KILLED ||
oshima620225722015-06-04 19:45:271420#if defined(OS_CHROMEOS)
wfh0d9532a2015-09-02 23:18:581421 crashed_status_ ==
1422 base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM ||
oshima620225722015-06-04 19:45:271423#endif
rkaplowe56a52032017-02-07 00:14:541424 crashed_status_ == base::TERMINATION_STATUS_LAUNCH_FAILED);
[email protected]3c9e1872010-11-18 16:17:491425}
1426
[email protected]b172aee2012-04-10 17:05:261427void WebContentsImpl::SetIsCrashed(base::TerminationStatus status,
1428 int error_code) {
[email protected]443b80e2010-12-14 00:42:231429 if (status == crashed_status_)
[email protected]d5f942ba2008-09-26 19:30:341430 return;
1431
[email protected]443b80e2010-12-14 00:42:231432 crashed_status_ = status;
1433 crashed_error_code_ = error_code;
[email protected]8ff00d72012-10-23 19:12:211434 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
[email protected]d5f942ba2008-09-26 19:30:341435}
1436
[email protected]b172aee2012-04-10 17:05:261437base::TerminationStatus WebContentsImpl::GetCrashedStatus() const {
[email protected]be1f56ab2011-12-22 06:55:311438 return crashed_status_;
1439}
1440
afakhry98241832016-03-11 19:27:471441int WebContentsImpl::GetCrashedErrorCode() const {
1442 return crashed_error_code_;
1443}
1444
[email protected]b172aee2012-04-10 17:05:261445bool WebContentsImpl::IsBeingDestroyed() const {
[email protected]be1f56ab2011-12-22 06:55:311446 return is_being_destroyed_;
1447}
1448
[email protected]7f924832014-08-09 05:57:221449void WebContentsImpl::NotifyNavigationStateChanged(
1450 InvalidateTypes changed_flags) {
dalecurtis88c240072015-12-09 02:11:181451 // Notify the media observer of potential audibility changes.
1452 if (changed_flags & INVALIDATE_TYPE_TAB) {
mlamouri44e4ef42016-01-20 18:42:271453 media_web_contents_observer_->MaybeUpdateAudibleState();
dalecurtisbc6572e12014-09-12 19:22:301454 }
1455
[email protected]d5f942ba2008-09-26 19:30:341456 if (delegate_)
1457 delegate_->NavigationStateChanged(this, changed_flags);
wjmaclean1dabf3e32016-05-13 23:34:441458
1459 if (GetOuterWebContents())
1460 GetOuterWebContents()->NotifyNavigationStateChanged(changed_flags);
[email protected]d5f942ba2008-09-26 19:30:341461}
1462
altiminec87fd1f2016-11-17 20:22:491463void WebContentsImpl::OnAudioStateChanged(bool is_audible) {
1464 SendPageMessage(new PageMsg_AudioStateChanged(MSG_ROUTING_NONE, is_audible));
altimind8bd26c2016-11-04 11:44:541465
altiminec87fd1f2016-11-17 20:22:491466 // Notification for UI updates in response to the changed audio state.
altimind8bd26c2016-11-04 11:44:541467 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
Jan Rucka442c83f2017-08-08 13:27:541468
1469 if (delegate_)
1470 delegate_->OnAudioStateChanged(is_audible);
altimind8bd26c2016-11-04 11:44:541471}
1472
gab0dccfef2015-05-20 18:43:391473base::TimeTicks WebContentsImpl::GetLastActiveTime() const {
[email protected]9a890452014-02-13 22:21:021474 return last_active_time_;
[email protected]3e324142012-06-25 18:26:331475}
1476
georgesak5582cbe2015-05-22 22:08:071477void WebContentsImpl::SetLastActiveTime(base::TimeTicks last_active_time) {
1478 last_active_time_ = last_active_time;
1479}
1480
hajimehoshic4f226a2016-10-21 09:01:571481base::TimeTicks WebContentsImpl::GetLastHiddenTime() const {
1482 return last_hidden_time_;
1483}
1484
[email protected]9e2e4632012-07-27 16:38:411485void WebContentsImpl::WasShown() {
[email protected]96d185d2009-04-24 03:28:541486 controller_.SetActive(true);
[email protected]de3c5d82014-05-28 22:12:591487
EhsanK2075c7e2017-08-21 02:42:391488 if (auto* view = GetRenderWidgetHostView()) {
lfgf949e0e2017-05-10 22:18:111489 view->Show();
[email protected]789e9152009-08-04 21:59:431490#if defined(OS_MACOSX)
lfgf949e0e2017-05-10 22:18:111491 view->SetActive(true);
[email protected]789e9152009-08-04 21:59:431492#endif
1493 }
[email protected]96d185d2009-04-24 03:28:541494
EhsanK2075c7e2017-08-21 02:42:391495 if (!ShowingInterstitialPage())
1496 SetVisibilityForChildViews(true);
1497
lfg717154072016-06-30 15:04:161498 SendPageMessage(new PageMsg_WasShown(MSG_ROUTING_NONE));
1499
gab0dccfef2015-05-20 18:43:391500 last_active_time_ = base::TimeTicks::Now();
[email protected]3e69bc82011-05-26 23:22:381501
ericwilligersde386342016-10-19 02:35:091502 for (auto& observer : observers_)
1503 observer.WasShown();
[email protected]c0d9d5672013-10-09 07:38:031504
[email protected]54597982013-02-06 01:59:551505 should_normally_be_visible_ = true;
[email protected]be1f56ab2011-12-22 06:55:311506}
1507
[email protected]b172aee2012-04-10 17:05:261508void WebContentsImpl::WasHidden() {
[email protected]54597982013-02-06 01:59:551509 // If there are entities capturing screenshots or video (e.g., mirroring),
1510 // don't activate the "disable rendering" optimization.
1511 if (capturer_count_ == 0) {
[email protected]151a63d2011-12-20 22:32:521512 // |GetRenderViewHost()| can be NULL if the user middle clicks a link to
[email protected]54597982013-02-06 01:59:551513 // open a tab in the background, then closes the tab before selecting it.
[email protected]b172aee2012-04-10 17:05:261514 // This is because closing the tab calls WebContentsImpl::Destroy(), which
[email protected]151a63d2011-12-20 22:32:521515 // removes the |GetRenderViewHost()|; then when we actually destroy the
[email protected]3e324142012-06-25 18:26:331516 // window, OnWindowPosChanged() notices and calls WasHidden() (which
[email protected]151a63d2011-12-20 22:32:521517 // calls us).
EhsanK2075c7e2017-08-21 02:42:391518 if (auto* view = GetRenderWidgetHostView())
lfgf949e0e2017-05-10 22:18:111519 view->Hide();
lfg717154072016-06-30 15:04:161520
EhsanK2075c7e2017-08-21 02:42:391521 if (!ShowingInterstitialPage())
Igor Eremeevef59187a2017-09-29 00:25:421522 SetVisibilityForChildViews(false);
EhsanK2075c7e2017-08-21 02:42:391523
lfg717154072016-06-30 15:04:161524 SendPageMessage(new PageMsg_WasHidden(MSG_ROUTING_NONE));
[email protected]96d185d2009-04-24 03:28:541525 }
1526
hajimehoshic4f226a2016-10-21 09:01:571527 last_hidden_time_ = base::TimeTicks::Now();
1528
ericwilligersde386342016-10-19 02:35:091529 for (auto& observer : observers_)
1530 observer.WasHidden();
[email protected]c0d9d5672013-10-09 07:38:031531
[email protected]54597982013-02-06 01:59:551532 should_normally_be_visible_ = false;
[email protected]375fa1b2012-05-22 22:05:371533}
1534
Bo Liu168c8642017-08-28 18:26:021535#if defined(OS_ANDROID)
Jinsuk Kim144909f2017-09-13 23:23:221536std::set<RenderWidgetHostImpl*> WebContentsImpl::GetAllRenderWidgetHosts() {
Bo Liu7c6779e92017-08-16 02:02:281537 std::set<RenderWidgetHostImpl*> set;
1538 if (ShowingInterstitialPage()) {
Jinsuk Kim144909f2017-09-13 23:23:221539 auto* host =
Bo Liu7c6779e92017-08-16 02:02:281540 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
Jinsuk Kim144909f2017-09-13 23:23:221541 ->GetRenderWidgetHost();
Bo Liu7c6779e92017-08-16 02:02:281542 DCHECK(host);
Jinsuk Kim144909f2017-09-13 23:23:221543 set.insert(host);
Bo Liu7c6779e92017-08-16 02:02:281544 }
Jinsuk Kim144909f2017-09-13 23:23:221545 for (RenderFrameHost* rfh : GetAllFrames()) {
1546 auto* host = static_cast<RenderFrameHostImpl*>(rfh)->GetRenderWidgetHost();
1547 DCHECK(host);
1548 set.insert(host);
1549 }
1550 return set;
1551}
1552
1553void WebContentsImpl::SetImportance(ChildProcessImportance importance) {
1554 // Importance should be set on interstitial page as well, which is included
1555 // the set returned by |GetAllRenderWidgetHosts()|.
1556 for (auto* host : GetAllRenderWidgetHosts())
1557 host->SetImportance(importance);
1558
Bo Liu7c6779e92017-08-16 02:02:281559 // TODO(boliu): If this is ever used on platforms other than Android, make
1560 // sure to also update inner WebContents.
1561}
Bo Liu168c8642017-08-28 18:26:021562#endif
Bo Liu7c6779e92017-08-16 02:02:281563
zhenw6edd49c2017-07-12 05:49:451564bool WebContentsImpl::IsVisible() const {
1565 return should_normally_be_visible_;
1566}
1567
ccameron8807c38f2015-01-17 00:29:191568void WebContentsImpl::WasOccluded() {
Francois Doray18800972017-08-25 22:38:581569 if (capturer_count_ == 0) {
1570 for (RenderWidgetHostView* view : GetRenderWidgetHostViewsInTree())
1571 view->WasOccluded();
1572 }
ccameron8807c38f2015-01-17 00:29:191573
Francois Doray18800972017-08-25 22:38:581574 should_normally_be_occluded_ = true;
ccameron8807c38f2015-01-17 00:29:191575}
1576
1577void WebContentsImpl::WasUnOccluded() {
Francois Doray18800972017-08-25 22:38:581578 if (capturer_count_ == 0)
1579 DoWasUnOccluded();
1580
1581 should_normally_be_occluded_ = false;
1582}
1583
1584void WebContentsImpl::DoWasUnOccluded() {
1585 // TODO(fdoray): Only call WasUnOccluded on frames in the active viewport.
lfgf949e0e2017-05-10 22:18:111586 for (RenderWidgetHostView* view : GetRenderWidgetHostViewsInTree())
1587 view->WasUnOccluded();
ccameron8807c38f2015-01-17 00:29:191588}
1589
[email protected]b172aee2012-04-10 17:05:261590bool WebContentsImpl::NeedToFireBeforeUnload() {
[email protected]be1f56ab2011-12-22 06:55:311591 // TODO(creis): Should we fire even for interstitial pages?
creisc014b402015-04-23 16:41:451592 return WillNotifyDisconnection() && !ShowingInterstitialPage() &&
jam40444982017-04-11 03:01:411593 !GetRenderViewHost()->SuddenTerminationAllowed();
[email protected]be1f56ab2011-12-22 06:55:311594}
1595
nasko148bb0b92016-05-10 21:03:191596void WebContentsImpl::DispatchBeforeUnload() {
1597 bool for_cross_site_transition = false;
clamybfd6a812016-05-30 16:25:171598 GetMainFrame()->DispatchBeforeUnload(for_cross_site_transition, false);
[email protected]1c3f80bd2014-04-08 23:02:061599}
1600
lazyboy6ec48b2a2015-06-29 15:18:141601void WebContentsImpl::AttachToOuterWebContentsFrame(
1602 WebContents* outer_web_contents,
1603 RenderFrameHost* outer_contents_frame) {
ekaramad1beabecc2016-09-23 20:18:171604 CHECK(GuestMode::IsCrossProcessFrameGuest(this));
lfg91a79e12016-04-01 23:52:191605 RenderFrameHostManager* render_manager = GetRenderManager();
1606
1607 // When the WebContents being initialized has an opener, the browser side
1608 // Render{View,Frame}Host must be initialized and the RenderWidgetHostView
1609 // created. This is needed because the usual initialization happens during
1610 // the first navigation, but when attaching a new window we don't navigate
1611 // before attaching. If the browser side is already initialized, the calls
1612 // below will just early return.
1613 render_manager->InitRenderView(GetRenderViewHost(), nullptr);
1614 GetMainFrame()->Init();
1615 if (!render_manager->GetRenderWidgetHostView())
1616 CreateRenderWidgetHostViewForRenderManager(GetRenderViewHost());
1617
avallee7529b2a2017-04-26 11:37:511618 auto* outer_web_contents_impl =
1619 static_cast<WebContentsImpl*>(outer_web_contents);
1620 auto* outer_contents_frame_impl =
1621 static_cast<RenderFrameHostImpl*>(outer_contents_frame);
lazyboy6ec48b2a2015-06-29 15:18:141622 // Create a link to our outer WebContents.
avallee7529b2a2017-04-26 11:37:511623 node_.ConnectToOuterWebContents(outer_web_contents_impl,
1624 outer_contents_frame_impl);
lazyboy6ec48b2a2015-06-29 15:18:141625
1626 DCHECK(outer_contents_frame);
1627
1628 // Create a proxy in top-level RenderFrameHostManager, pointing to the
1629 // SiteInstance of the outer WebContents. The proxy will be used to send
1630 // postMessage to the inner WebContents.
lfg91a79e12016-04-01 23:52:191631 render_manager->CreateOuterDelegateProxy(
avallee7529b2a2017-04-26 11:37:511632 outer_contents_frame->GetSiteInstance(), outer_contents_frame_impl);
lazyboy6ec48b2a2015-06-29 15:18:141633
lfg91a79e12016-04-01 23:52:191634 render_manager->SetRWHViewForInnerContents(
1635 render_manager->GetRenderWidgetHostView());
wjmacleanfab616a2016-03-02 18:40:391636
1637 static_cast<RenderWidgetHostViewChildFrame*>(
lfg91a79e12016-04-01 23:52:191638 render_manager->GetRenderWidgetHostView())
fsamuelb6acafa2016-10-04 03:21:521639 ->RegisterFrameSinkId();
ekaramadadd882292016-06-08 15:22:561640
avallee7529b2a2017-04-26 11:37:511641 if (outer_web_contents_impl->frame_tree_.GetFocusedFrame() ==
1642 outer_contents_frame_impl->frame_tree_node()) {
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:571643 SetFocusedFrame(frame_tree_.root(),
1644 outer_contents_frame->GetSiteInstance());
avallee7529b2a2017-04-26 11:37:511645 }
1646
avalleed68cdd12017-06-21 22:07:271647 // Set up the the guest's AX tree to point back at the embedder's AX tree.
1648 auto* parent_frame = outer_contents_frame->GetParent();
1649 GetMainFrame()->set_browser_plugin_embedder_ax_tree_id(
1650 parent_frame->GetAXTreeID());
1651 GetMainFrame()->UpdateAXTreeData();
1652
ekaramadadd882292016-06-08 15:22:561653 // At this point, we should destroy the TextInputManager which will notify all
1654 // the RWHV in this WebContents. The RWHV in this WebContents should use the
1655 // TextInputManager owned by the outer WebContents.
1656 // TODO(ekaramad): Is it possible to have TextInputState before attaching to
1657 // outer WebContents? In such a case, is this still the right way to hand off
1658 // state tracking from inner WebContents's TextInputManager to that of the
1659 // outer WebContent (crbug.com/609846)?
1660 text_input_manager_.reset(nullptr);
lazyboy6ec48b2a2015-06-29 15:18:141661}
1662
dalecurtis6c58ed02016-10-28 23:02:371663void WebContentsImpl::DidChangeVisibleSecurityState() {
1664 if (delegate_) {
1665 delegate_->VisibleSecurityStateChanged(this);
cjgrant6d1d727a2016-12-09 21:16:571666 for (auto& observer : observers_)
1667 observer.DidChangeVisibleSecurityState();
dalecurtis6c58ed02016-10-28 23:02:371668 }
1669}
1670
[email protected]b172aee2012-04-10 17:05:261671void WebContentsImpl::Stop() {
dcheng57e39e22016-01-21 00:25:381672 for (FrameTreeNode* node : frame_tree_.Nodes())
1673 node->StopLoading();
ericwilligersde386342016-10-19 02:35:091674 for (auto& observer : observers_)
1675 observer.NavigationStopped();
[email protected]0bfbf882011-12-22 18:19:271676}
1677
[email protected]b172aee2012-04-10 17:05:261678WebContents* WebContentsImpl::Clone() {
[email protected]14392a52012-05-02 20:28:441679 // We use our current SiteInstance since the cloned entry will use it anyway.
alexmose201c7cd2015-06-10 17:14:211680 // We pass our own opener so that the cloned page can access it if it was set
[email protected]ed245db2012-12-18 08:00:451681 // before.
[email protected]54944cde2012-12-09 09:24:591682 CreateParams create_params(GetBrowserContext(), GetSiteInstance());
[email protected]fc2b46b2014-05-03 16:33:451683 create_params.initial_size = GetContainerBounds().size();
alexmose201c7cd2015-06-10 17:14:211684 WebContentsImpl* tc =
1685 CreateWithOpener(create_params, frame_tree_.root()->opener());
Francois Dorayeaace782017-06-21 16:37:241686 tc->GetController().CopyStateFrom(controller_, true);
ericwilligersde386342016-10-19 02:35:091687 for (auto& observer : observers_)
1688 observer.DidCloneToNewWebContents(this, tc);
[email protected]0bfbf882011-12-22 18:19:271689 return tc;
1690}
1691
[email protected]14392a52012-05-02 20:28:441692void WebContentsImpl::Observe(int type,
[email protected]8ff00d72012-10-23 19:12:211693 const NotificationSource& source,
1694 const NotificationDetails& details) {
[email protected]14392a52012-05-02 20:28:441695 switch (type) {
[email protected]8ff00d72012-10-23 19:12:211696 case NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: {
1697 RenderWidgetHost* host = Source<RenderWidgetHost>(source).ptr();
[email protected]0b431992014-06-24 00:08:031698 RenderWidgetHostView* view = host->GetView();
1699 if (view == GetFullscreenRenderWidgetHostView()) {
1700 // We cannot just call view_->RestoreFocus() here. On some platforms,
1701 // attempting to focus the currently-invisible WebContentsView will be
1702 // flat-out ignored. Therefore, this boolean is used to track whether
1703 // we will request focus after the fullscreen widget has been
1704 // destroyed.
1705 fullscreen_widget_had_focus_at_shutdown_ = (view && view->HasFocus());
1706 } else {
alexmosc2a8cec2016-05-23 22:19:531707 for (auto i = pending_widget_views_.begin();
[email protected]0b431992014-06-24 00:08:031708 i != pending_widget_views_.end(); ++i) {
1709 if (host->GetView() == i->second) {
1710 pending_widget_views_.erase(i);
1711 break;
1712 }
[email protected]bafe6cd2012-05-23 23:09:501713 }
1714 }
1715 break;
1716 }
[email protected]14392a52012-05-02 20:28:441717 default:
1718 NOTREACHED();
1719 }
1720}
1721
[email protected]ec6c05f2013-10-23 18:41:571722WebContents* WebContentsImpl::GetWebContents() {
1723 return this;
1724}
1725
[email protected]54944cde2012-12-09 09:24:591726void WebContentsImpl::Init(const WebContents::CreateParams& params) {
[email protected]fa944cb82013-11-15 17:51:211727 // This is set before initializing the render manager since
[email protected]b0936d22013-11-28 06:47:361728 // RenderFrameHostManager::Init calls back into us via its delegate to ask if
[email protected]fa944cb82013-11-15 17:51:211729 // it should be hidden.
[email protected]d6fa88f2013-10-18 16:00:431730 should_normally_be_visible_ = !params.initially_hidden;
1731
dcheng3ce04b62015-10-26 23:30:551732 // The routing ids must either all be set or all be unset.
avic2c29d782014-12-12 00:23:541733 DCHECK((params.routing_id == MSG_ROUTING_NONE &&
dcheng3ce04b62015-10-26 23:30:551734 params.main_frame_routing_id == MSG_ROUTING_NONE &&
1735 params.main_frame_widget_routing_id == MSG_ROUTING_NONE) ||
avic2c29d782014-12-12 00:23:541736 (params.routing_id != MSG_ROUTING_NONE &&
dcheng3ce04b62015-10-26 23:30:551737 params.main_frame_routing_id != MSG_ROUTING_NONE &&
1738 params.main_frame_widget_routing_id != MSG_ROUTING_NONE));
1739
1740 scoped_refptr<SiteInstance> site_instance = params.site_instance;
1741 if (!site_instance)
1742 site_instance = SiteInstance::Create(params.browser_context);
1743
1744 // A main RenderFrameHost always has a RenderWidgetHost, since it is always a
1745 // local root by definition.
1746 // TODO(avi): Once RenderViewHostImpl has-a RenderWidgetHostImpl, it will no
1747 // longer be necessary to eagerly grab a routing ID for the view.
1748 // https://crbug.com/545684
1749 int32_t view_routing_id = params.routing_id;
1750 int32_t main_frame_widget_routing_id = params.main_frame_widget_routing_id;
1751 if (main_frame_widget_routing_id == MSG_ROUTING_NONE) {
1752 view_routing_id = main_frame_widget_routing_id =
1753 site_instance->GetProcess()->GetNextRoutingID();
1754 }
1755
Dave Tapuska485aca92017-08-08 00:47:581756 GetRenderManager()->Init(
1757 site_instance.get(), view_routing_id, params.main_frame_routing_id,
1758 main_frame_widget_routing_id, params.renderer_initiated_creation);
lukasza464d8692016-02-22 19:26:321759
lukasza5140a412016-09-15 21:12:301760 // blink::FrameTree::setName always keeps |unique_name| empty in case of a
1761 // main frame - let's do the same thing here.
1762 std::string unique_name;
lukasza464d8692016-02-22 19:26:321763 frame_tree_.root()->SetFrameName(params.main_frame_name, unique_name);
[email protected]d1198fd2012-08-13 22:50:191764
[email protected]fc2b46b2014-05-03 16:33:451765 WebContentsViewDelegate* delegate =
1766 GetContentClient()->browser()->GetWebContentsViewDelegate(this);
1767
sky52a39e342016-12-17 17:23:221768 if (GuestMode::IsCrossProcessFrameGuest(this)) {
1769 view_.reset(new WebContentsViewChildFrame(
1770 this, delegate, &render_view_host_delegate_view_));
1771 } else {
1772 view_.reset(CreateWebContentsView(this, delegate,
1773 &render_view_host_delegate_view_));
fsamueladb0033602015-12-09 19:20:411774 }
fsamuel9cf7bdf2015-11-20 02:19:321775
ekaramad1beabecc2016-09-23 20:18:171776 if (browser_plugin_guest_ && !GuestMode::IsCrossProcessFrameGuest(this)) {
fsamuel9cf7bdf2015-11-20 02:19:321777 view_.reset(new WebContentsViewGuest(this, browser_plugin_guest_.get(),
dcheng36b6aec92015-12-26 06:16:361778 std::move(view_),
fsamuel9cf7bdf2015-11-20 02:19:321779 &render_view_host_delegate_view_));
[email protected]d1198fd2012-08-13 22:50:191780 }
[email protected]fc2b46b2014-05-03 16:33:451781 CHECK(render_view_host_delegate_view_);
[email protected]d1198fd2012-08-13 22:50:191782 CHECK(view_.get());
1783
[email protected]ed245db2012-12-18 08:00:451784 gfx::Size initial_size = params.initial_size;
[email protected]54944cde2012-12-09 09:24:591785 view_->CreateView(initial_size, params.context);
[email protected]d1198fd2012-08-13 22:50:191786
brettw4b461082016-11-19 18:55:161787#if BUILDFLAG(ENABLE_PLUGINS)
tommyclieb25b2a2014-11-03 19:45:091788 plugin_content_origin_whitelist_.reset(
1789 new PluginContentOriginWhitelist(this));
1790#endif
1791
[email protected]d1198fd2012-08-13 22:50:191792 registrar_.Add(this,
[email protected]8ff00d72012-10-23 19:12:211793 NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
1794 NotificationService::AllBrowserContextsAndSources());
[email protected]f28ef9a32014-05-12 16:36:101795
leon.hane4db177a2017-02-07 14:19:161796 screen_orientation_provider_.reset(new ScreenOrientationProvider(this));
[email protected]01f83f92014-06-17 14:41:541797
mlamouriefdca9d2014-09-16 16:55:401798 manifest_manager_host_.reset(new ManifestManagerHost(this));
1799
mfomitchev2b8b066a2016-01-28 19:23:151800#if defined(OS_ANDROID)
[email protected]583418cc2013-01-17 14:01:101801 date_time_chooser_.reset(new DateTimeChooserAndroid());
1802#endif
fsamuel7310a4262014-12-05 05:06:441803
1804 // BrowserPluginGuest::Init needs to be called after this WebContents has
1805 // a RenderWidgetHostViewGuest. That is, |view_->CreateView| above.
1806 if (browser_plugin_guest_)
1807 browser_plugin_guest_->Init();
nickf9acfbe2014-12-23 19:12:371808
1809 for (size_t i = 0; i < g_created_callbacks.Get().size(); i++)
1810 g_created_callbacks.Get().at(i).Run(this);
naskob21fe4872015-02-24 14:15:561811
1812 // If the WebContents creation was renderer-initiated, it means that the
1813 // corresponding RenderView and main RenderFrame have already been created.
1814 // Ensure observers are notified about this.
1815 if (params.renderer_initiated_creation) {
avi3627ecac2015-10-16 17:40:431816 GetRenderViewHost()->GetWidget()->set_renderer_initialized(true);
Alex Moshchuk27caae82017-09-11 23:11:181817 GetRenderViewHost()->DispatchRenderViewCreated();
naskob21fe4872015-02-24 14:15:561818 GetRenderManager()->current_frame_host()->SetRenderFrameCreated(true);
1819 }
naskof5940b9f2015-03-02 23:04:051820
lof84501da082016-05-23 21:22:541821 // Create the renderer process in advance if requested.
1822 if (params.initialize_renderer) {
1823 if (!GetRenderManager()->current_frame_host()->IsRenderFrameLive()) {
1824 GetRenderManager()->InitRenderView(GetRenderViewHost(), nullptr);
1825 }
1826 }
1827
naskof5940b9f2015-03-02 23:04:051828 // Ensure that observers are notified of the creation of this WebContents's
1829 // main RenderFrameHost. It must be done here for main frames, since the
1830 // NotifySwappedFromRenderManager expects view_ to already be created and that
1831 // happens after RenderFrameHostManager::Init.
1832 NotifySwappedFromRenderManager(
1833 nullptr, GetRenderManager()->current_frame_host(), true);
[email protected]d1198fd2012-08-13 22:50:191834}
1835
[email protected]7fff43e2013-05-21 20:21:101836void WebContentsImpl::OnWebContentsDestroyed(WebContentsImpl* web_contents) {
1837 RemoveDestructionObserver(web_contents);
1838
[email protected]ceee8cd2013-03-08 04:59:511839 // Clear a pending contents that has been closed before being shown.
alexmosc2a8cec2016-05-23 22:19:531840 for (auto iter = pending_contents_.begin(); iter != pending_contents_.end();
[email protected]ceee8cd2013-03-08 04:59:511841 ++iter) {
1842 if (iter->second != web_contents)
1843 continue;
1844 pending_contents_.erase(iter);
[email protected]ceee8cd2013-03-08 04:59:511845 return;
1846 }
1847 NOTREACHED();
[email protected]14392a52012-05-02 20:28:441848}
1849
[email protected]7fff43e2013-05-21 20:21:101850void WebContentsImpl::AddDestructionObserver(WebContentsImpl* web_contents) {
1851 if (!ContainsKey(destruction_observers_, web_contents)) {
1852 destruction_observers_[web_contents] =
avia8cf81982016-08-12 20:28:461853 base::MakeUnique<DestructionObserver>(this, web_contents);
[email protected]7fff43e2013-05-21 20:21:101854 }
1855}
1856
1857void WebContentsImpl::RemoveDestructionObserver(WebContentsImpl* web_contents) {
avia8cf81982016-08-12 20:28:461858 destruction_observers_.erase(web_contents);
[email protected]7fff43e2013-05-21 20:21:101859}
1860
[email protected]b172aee2012-04-10 17:05:261861void WebContentsImpl::AddObserver(WebContentsObserver* observer) {
[email protected]be1f56ab2011-12-22 06:55:311862 observers_.AddObserver(observer);
1863}
1864
[email protected]b172aee2012-04-10 17:05:261865void WebContentsImpl::RemoveObserver(WebContentsObserver* observer) {
[email protected]be1f56ab2011-12-22 06:55:311866 observers_.RemoveObserver(observer);
1867}
1868
[email protected]948481d2014-06-11 18:32:221869std::set<RenderWidgetHostView*>
1870WebContentsImpl::GetRenderWidgetHostViewsInTree() {
1871 std::set<RenderWidgetHostView*> set;
1872 if (ShowingInterstitialPage()) {
lfgf949e0e2017-05-10 22:18:111873 if (RenderWidgetHostView* rwhv = GetRenderWidgetHostView())
1874 set.insert(rwhv);
[email protected]948481d2014-06-11 18:32:221875 } else {
dchengafb53e22016-02-04 08:11:081876 for (RenderFrameHost* rfh : GetAllFrames()) {
lfgf949e0e2017-05-10 22:18:111877 if (RenderWidgetHostView* rwhv = static_cast<RenderFrameHostImpl*>(rfh)
1878 ->frame_tree_node()
1879 ->render_manager()
1880 ->GetRenderWidgetHostView()) {
1881 set.insert(rwhv);
1882 }
dchengafb53e22016-02-04 08:11:081883 }
[email protected]948481d2014-06-11 18:32:221884 }
[email protected]de3c5d82014-05-28 22:12:591885 return set;
1886}
1887
[email protected]b172aee2012-04-10 17:05:261888void WebContentsImpl::Activate() {
[email protected]d5f942ba2008-09-26 19:30:341889 if (delegate_)
1890 delegate_->ActivateContents(this);
1891}
1892
avi3e4b8512015-11-11 01:55:491893void WebContentsImpl::LostCapture(RenderWidgetHostImpl* render_widget_host) {
1894 if (!RenderViewHostImpl::From(render_widget_host))
1895 return;
1896
[email protected]63954792011-07-11 04:17:481897 if (delegate_)
1898 delegate_->LostCapture();
1899}
1900
lazyboy63f5b312015-11-23 20:19:521901void WebContentsImpl::RenderWidgetCreated(
1902 RenderWidgetHostImpl* render_widget_host) {
1903 created_widgets_.insert(render_widget_host);
1904}
1905
[email protected]b24b68a2012-09-24 21:57:261906void WebContentsImpl::RenderWidgetDeleted(
1907 RenderWidgetHostImpl* render_widget_host) {
lazyboy63f5b312015-11-23 20:19:521908 // Note that |is_being_destroyed_| can be true at this point as
1909 // ~WebContentsImpl() calls RFHM::ClearRFHsPendingShutdown(), which might lead
1910 // us here.
1911 created_widgets_.erase(render_widget_host);
[email protected]b24b68a2012-09-24 21:57:261912
lazyboy63f5b312015-11-23 20:19:521913 if (is_being_destroyed_)
1914 return;
[email protected]44470a22013-01-24 01:21:541915
1916 if (render_widget_host &&
alexmosc9e76ec2016-05-16 22:59:371917 render_widget_host->GetRoutingID() == fullscreen_widget_routing_id_ &&
1918 render_widget_host->GetProcess()->GetID() ==
1919 fullscreen_widget_process_id_) {
[email protected]4aebbca2013-09-17 22:26:491920 if (delegate_ && delegate_->EmbedsFullscreenWidget())
mlamouri7a78d6fd2015-01-17 13:23:531921 delegate_->ExitFullscreenModeForTab(this);
ericwilligersde386342016-10-19 02:35:091922 for (auto& observer : observers_)
1923 observer.DidDestroyFullscreenWidget();
alexmosc9e76ec2016-05-16 22:59:371924 fullscreen_widget_process_id_ = ChildProcessHost::kInvalidUniqueID;
[email protected]44470a22013-01-24 01:21:541925 fullscreen_widget_routing_id_ = MSG_ROUTING_NONE;
[email protected]0b431992014-06-24 00:08:031926 if (fullscreen_widget_had_focus_at_shutdown_)
1927 view_->RestoreFocus();
[email protected]44470a22013-01-24 01:21:541928 }
lfgbee1e0a2016-06-08 21:24:211929
lfg7d4caad2017-03-22 09:01:451930 if (render_widget_host == mouse_lock_widget_)
lfgff8dfc8d2016-10-21 17:42:321931 LostMouseLock(mouse_lock_widget_);
[email protected]b24b68a2012-09-24 21:57:261932}
1933
miu9e14e492014-10-25 02:39:041934void WebContentsImpl::RenderWidgetGotFocus(
1935 RenderWidgetHostImpl* render_widget_host) {
calamity7fe55ce2015-04-10 03:59:371936 // Notify the observers if an embedded fullscreen widget was focused.
1937 if (delegate_ && render_widget_host && delegate_->EmbedsFullscreenWidget() &&
1938 render_widget_host->GetView() == GetFullscreenRenderWidgetHostView()) {
Michael Thiessen896405db2017-07-20 17:52:321939 NotifyWebContentsFocused(render_widget_host);
calamity7fe55ce2015-04-10 03:59:371940 }
miu9e14e492014-10-25 02:39:041941}
1942
zijiehe3bee08e22017-05-17 04:14:461943void WebContentsImpl::RenderWidgetLostFocus(
1944 RenderWidgetHostImpl* render_widget_host) {
Michael Thiessen896405db2017-07-20 17:52:321945 // Notify the observers if an embedded fullscreen widget lost focus.
1946 if (delegate_ && render_widget_host && delegate_->EmbedsFullscreenWidget() &&
1947 render_widget_host->GetView() == GetFullscreenRenderWidgetHostView()) {
1948 NotifyWebContentsLostFocus(render_widget_host);
1949 }
zijiehe3bee08e22017-05-17 04:14:461950}
1951
estaded0a0c992015-01-21 14:12:061952void WebContentsImpl::RenderWidgetWasResized(
rouslan2f5993f2015-01-29 00:18:311953 RenderWidgetHostImpl* render_widget_host,
1954 bool width_changed) {
creisc014b402015-04-23 16:41:451955 RenderFrameHostImpl* rfh = GetMainFrame();
estadece344ec2015-01-23 00:12:291956 if (!rfh || render_widget_host != rfh->GetRenderWidgetHost())
estaded0a0c992015-01-21 14:12:061957 return;
estaded0a0c992015-01-21 14:12:061958
lfg8d649cc2017-04-28 18:04:301959 ScreenInfo screen_info;
1960 GetScreenInfo(&screen_info);
1961 SendPageMessage(new PageMsg_UpdateScreenInfo(MSG_ROUTING_NONE, screen_info));
1962
lfg95f00bd52017-06-08 00:03:201963 // Send resize message to subframes.
1964 for (RenderWidgetHostView* view : GetRenderWidgetHostViewsInTree()) {
1965 if (view != rfh->GetView())
1966 view->GetRenderWidgetHost()->WasResized();
1967 }
1968
ericwilligersde386342016-10-19 02:35:091969 for (auto& observer : observers_)
1970 observer.MainFrameWasResized(width_changed);
estaded0a0c992015-01-21 14:12:061971}
1972
paulmeyer9ef6e4462015-02-24 19:15:101973void WebContentsImpl::ScreenInfoChanged() {
1974 if (browser_plugin_embedder_)
1975 browser_plugin_embedder_->ScreenInfoChanged();
1976}
1977
skyf65d9bb2017-03-24 02:26:391978KeyboardEventProcessingResult WebContentsImpl::PreHandleKeyboardEvent(
1979 const NativeWebKeyboardEvent& event) {
1980 return delegate_ ? delegate_->PreHandleKeyboardEvent(this, event)
1981 : KeyboardEventProcessingResult::NOT_HANDLED;
[email protected]63954792011-07-11 04:17:481982}
1983
[email protected]b172aee2012-04-10 17:05:261984void WebContentsImpl::HandleKeyboardEvent(const NativeWebKeyboardEvent& event) {
[email protected]0b094002014-08-20 18:28:101985 if (browser_plugin_embedder_ &&
1986 browser_plugin_embedder_->HandleKeyboardEvent(event)) {
1987 return;
1988 }
[email protected]63954792011-07-11 04:17:481989 if (delegate_)
[email protected]b3996ba2012-08-08 00:39:131990 delegate_->HandleKeyboardEvent(this, event);
[email protected]63954792011-07-11 04:17:481991}
1992
[email protected]d92026ef2014-03-03 21:04:131993bool WebContentsImpl::HandleWheelEvent(
[email protected]180ef242013-11-07 06:50:461994 const blink::WebMouseWheelEvent& event) {
[email protected]bccc4472013-04-18 16:37:191995#if !defined(OS_MACOSX)
lanweia93644f2015-01-21 22:00:331996 // On platforms other than Mac, control+mousewheel may change zoom. On Mac,
1997 // this isn't done for two reasons:
[email protected]bccc4472013-04-18 16:37:191998 // -the OS already has a gesture to do this through pinch-zoom
1999 // -if a user starts an inertial scroll, let's go, and presses control
2000 // (i.e. control+tab) then the OS's buffered scroll events will come in
2001 // with control key set which isn't what the user wants
Blink Reformat1c4d759e2017-04-09 16:34:542002 if (delegate_ && event.wheel_ticks_y &&
chongz4a9751942016-08-17 17:49:392003 !ui::WebInputEventTraits::CanCauseScroll(event)) {
w.shackleton49bcd392016-01-06 17:38:222004 // Count only integer cumulative scrolls as zoom events; this handles
2005 // smooth scroll and regular scroll device behavior.
Blink Reformat1c4d759e2017-04-09 16:34:542006 zoom_scroll_remainder_ += event.wheel_ticks_y;
w.shackleton49bcd392016-01-06 17:38:222007 int whole_zoom_scroll_remainder_ = std::lround(zoom_scroll_remainder_);
2008 zoom_scroll_remainder_ -= whole_zoom_scroll_remainder_;
2009 if (whole_zoom_scroll_remainder_ != 0) {
2010 delegate_->ContentsZoomChange(whole_zoom_scroll_remainder_ > 0);
2011 }
[email protected]fb3f066e2013-02-12 19:12:522012 return true;
2013 }
[email protected]bccc4472013-04-18 16:37:192014#endif
[email protected]fb3f066e2013-02-12 19:12:522015 return false;
2016}
2017
[email protected]04bce562014-01-30 05:34:542018bool WebContentsImpl::PreHandleGestureEvent(
2019 const blink::WebGestureEvent& event) {
[email protected]28042d32014-02-03 14:10:032020 return delegate_ && delegate_->PreHandleGestureEvent(this, event);
[email protected]04bce562014-01-30 05:34:542021}
2022
kenrb2a565f82015-09-02 20:24:592023RenderWidgetHostInputEventRouter* WebContentsImpl::GetInputEventRouter() {
wjmacleane31234f2015-12-14 17:20:452024 if (!is_being_destroyed_ && GetOuterWebContents())
2025 return GetOuterWebContents()->GetInputEventRouter();
2026
2027 if (!rwh_input_event_router_.get() && !is_being_destroyed_)
kenrb2a565f82015-09-02 20:24:592028 rwh_input_event_router_.reset(new RenderWidgetHostInputEventRouter);
2029 return rwh_input_event_router_.get();
2030}
2031
alexmos3fcd0ca2015-10-23 18:18:332032void WebContentsImpl::ReplicatePageFocus(bool is_focused) {
2033 // Focus loss may occur while this WebContents is being destroyed. Don't
2034 // send the message in this case, as the main frame's RenderFrameHost and
2035 // other state has already been cleared.
2036 if (is_being_destroyed_)
2037 return;
2038
2039 frame_tree_.ReplicatePageFocus(is_focused);
2040}
2041
alexmosc4cbacb2015-11-21 01:29:222042RenderWidgetHostImpl* WebContentsImpl::GetFocusedRenderWidgetHost(
2043 RenderWidgetHostImpl* receiving_widget) {
alexmosc4cbacb2015-11-21 01:29:222044 // Events for widgets other than the main frame (e.g., popup menus) should be
2045 // forwarded directly to the widget they arrived on.
2046 if (receiving_widget != GetMainFrame()->GetRenderWidgetHost())
2047 return receiving_widget;
alexmosc4d183e2015-11-06 00:46:522048
lfg1453e412017-04-11 00:48:502049 WebContentsImpl* focused_contents = GetFocusedWebContents();
2050
2051 // If the focused WebContents is showing an interstitial, return the
2052 // interstitial's widget.
2053 if (focused_contents->ShowingInterstitialPage()) {
2054 return static_cast<RenderFrameHostImpl*>(
creisadca9862017-06-16 19:12:112055 focused_contents->interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:502056 ->GetRenderWidgetHost();
2057 }
2058
paulmeyerfeafc2d2017-04-25 21:46:402059 // If the focused WebContents is a guest WebContents, then get the focused
2060 // frame in the embedder WebContents instead.
2061 FrameTreeNode* focused_frame = nullptr;
2062 if (focused_contents->browser_plugin_guest_ &&
2063 !GuestMode::IsCrossProcessFrameGuest(focused_contents)) {
2064 focused_frame = frame_tree_.GetFocusedFrame();
2065 } else {
2066 focused_frame = GetFocusedWebContents()->frame_tree_.GetFocusedFrame();
2067 }
lfg1453e412017-04-11 00:48:502068
alexmosc4d183e2015-11-06 00:46:522069 if (!focused_frame)
alexmosc4cbacb2015-11-21 01:29:222070 return receiving_widget;
alexmosc4d183e2015-11-06 00:46:522071
alexmos732ca3a2015-12-08 02:01:022072 // The view may be null if a subframe's renderer process has crashed while
2073 // the subframe has focus. Drop the event in that case. Do not give
2074 // it to the main frame, so that the user doesn't unexpectedly type into the
2075 // wrong frame if a focused subframe renderer crashes while they type.
2076 RenderWidgetHostView* view = focused_frame->current_frame_host()->GetView();
2077 if (!view)
2078 return nullptr;
2079
2080 return RenderWidgetHostImpl::From(view->GetRenderWidgetHost());
alexmosc4d183e2015-11-06 00:46:522081}
2082
avallee9993fca2016-11-17 06:16:502083RenderWidgetHostImpl* WebContentsImpl::GetRenderWidgetHostWithPageFocus() {
lfg1453e412017-04-11 00:48:502084 WebContentsImpl* focused_web_contents = GetFocusedWebContents();
2085
2086 if (focused_web_contents->ShowingInterstitialPage()) {
2087 return static_cast<RenderFrameHostImpl*>(
creisadca9862017-06-16 19:12:112088 focused_web_contents->interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:502089 ->GetRenderWidgetHost();
2090 }
Alex Valléedc80ae2ed2017-09-06 21:55:442091 if (!GuestMode::IsCrossProcessFrameGuest(focused_web_contents) &&
2092 focused_web_contents->browser_plugin_guest_) {
2093 // If this is a guest, we need to be controlled by our embedder.
2094 return focused_web_contents->GetOuterWebContents()
2095 ->GetMainFrame()
2096 ->GetRenderWidgetHost();
2097 }
lfg1453e412017-04-11 00:48:502098
2099 return focused_web_contents->GetMainFrame()->GetRenderWidgetHost();
avallee9993fca2016-11-17 06:16:502100}
2101
mlamouri7a78d6fd2015-01-17 13:23:532102void WebContentsImpl::EnterFullscreenMode(const GURL& origin) {
2103 // This method is being called to enter renderer-initiated fullscreen mode.
2104 // Make sure any existing fullscreen widget is shut down first.
[email protected]4aebbca2013-09-17 22:26:492105 RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
avi85a4cef2015-12-18 20:13:372106 if (widget_view) {
2107 RenderWidgetHostImpl::From(widget_view->GetRenderWidgetHost())
2108 ->ShutdownAndDestroyWidget(true);
2109 }
[email protected]4aebbca2013-09-17 22:26:492110
[email protected]8a5e0ca2011-08-25 06:30:472111 if (delegate_)
mlamouri7a78d6fd2015-01-17 13:23:532112 delegate_->EnterFullscreenModeForTab(this, origin);
2113
ericwilligersde386342016-10-19 02:35:092114 for (auto& observer : observers_)
2115 observer.DidToggleFullscreenModeForTab(IsFullscreenForCurrentTab(), false);
mlamouri7a78d6fd2015-01-17 13:23:532116}
2117
bokanece34a82016-01-28 19:49:462118void WebContentsImpl::ExitFullscreenMode(bool will_cause_resize) {
mlamouri7a78d6fd2015-01-17 13:23:532119 // This method is being called to leave renderer-initiated fullscreen mode.
2120 // Make sure any existing fullscreen widget is shut down first.
2121 RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
avi85a4cef2015-12-18 20:13:372122 if (widget_view) {
2123 RenderWidgetHostImpl::From(widget_view->GetRenderWidgetHost())
2124 ->ShutdownAndDestroyWidget(true);
2125 }
mlamouri7a78d6fd2015-01-17 13:23:532126
hugo.holgersson61288e6c2015-01-28 17:04:402127#if defined(OS_ANDROID)
2128 ContentVideoView* video_view = ContentVideoView::GetInstance();
2129 if (video_view != NULL)
watk98292292016-01-19 22:24:082130 video_view->ExitFullscreen();
hugo.holgersson61288e6c2015-01-28 17:04:402131#endif
2132
mlamouri7a78d6fd2015-01-17 13:23:532133 if (delegate_)
2134 delegate_->ExitFullscreenModeForTab(this);
[email protected]657c8e02014-03-19 19:18:372135
bokanece34a82016-01-28 19:49:462136 // The fullscreen state is communicated to the renderer through a resize
2137 // message. If the change in fullscreen state doesn't cause a view resize
2138 // then we must ensure web contents exit the fullscreen state by explicitly
2139 // sending a resize message. This is required for the situation of the browser
2140 // moving the view into a "browser fullscreen" state and then the contents
2141 // entering "tab fullscreen". Exiting the contents "tab fullscreen" then won't
2142 // have the side effect of the view resizing, hence the explicit call here is
2143 // required.
2144 if (!will_cause_resize) {
2145 if (RenderWidgetHostView* rwhv = GetRenderWidgetHostView()) {
2146 if (RenderWidgetHost* render_widget_host = rwhv->GetRenderWidgetHost())
2147 render_widget_host->WasResized();
2148 }
scheib3dcb6c932015-02-23 10:55:582149 }
2150
ericwilligersde386342016-10-19 02:35:092151 for (auto& observer : observers_) {
2152 observer.DidToggleFullscreenModeForTab(IsFullscreenForCurrentTab(),
2153 will_cause_resize);
2154 }
[email protected]8a5e0ca2011-08-25 06:30:472155}
2156
alexmos5dd617d2016-06-07 04:21:152157bool WebContentsImpl::IsFullscreenForCurrentTab() const {
[email protected]199bba6e2012-04-04 16:19:382158 return delegate_ ? delegate_->IsFullscreenForTabOrPending(this) : false;
[email protected]5d5f7af2011-10-01 01:38:122159}
2160
billorr21c005d2016-11-17 03:57:042161bool WebContentsImpl::IsFullscreen() {
2162 return IsFullscreenForCurrentTab();
2163}
2164
avibf58fa0c2015-11-11 01:45:522165blink::WebDisplayMode WebContentsImpl::GetDisplayMode(
2166 RenderWidgetHostImpl* render_widget_host) const {
2167 if (!RenderViewHostImpl::From(render_widget_host))
Blink Reformat1c4d759e2017-04-09 16:34:542168 return blink::kWebDisplayModeBrowser;
avibf58fa0c2015-11-11 01:45:522169
mikhail.pozdnyakovc0e251b2015-04-15 06:51:122170 return delegate_ ? delegate_->GetDisplayMode(this)
Blink Reformat1c4d759e2017-04-09 16:34:542171 : blink::kWebDisplayModeBrowser;
mikhail.pozdnyakovc0e251b2015-04-15 06:51:122172}
2173
avic3aa8422015-11-09 20:57:222174void WebContentsImpl::RequestToLockMouse(
2175 RenderWidgetHostImpl* render_widget_host,
2176 bool user_gesture,
lfgad8244352016-07-13 16:55:512177 bool last_unlocked_by_target,
2178 bool privileged) {
lfgf0cd46e2017-01-04 00:05:232179 for (WebContentsImpl* current = this; current;
2180 current = current->GetOuterWebContents()) {
2181 if (current->mouse_lock_widget_) {
2182 render_widget_host->GotResponseToLockMouseRequest(false);
2183 return;
2184 }
[email protected]e9621112011-10-17 05:38:372185 }
avic3aa8422015-11-09 20:57:222186
lfgad8244352016-07-13 16:55:512187 if (privileged) {
lfgf0cd46e2017-01-04 00:05:232188 DCHECK(!GetOuterWebContents());
lfgad8244352016-07-13 16:55:512189 mouse_lock_widget_ = render_widget_host;
2190 render_widget_host->GotResponseToLockMouseRequest(true);
2191 return;
2192 }
2193
lfgbee1e0a2016-06-08 21:24:212194 bool widget_in_frame_tree = false;
2195 for (FrameTreeNode* node : frame_tree_.Nodes()) {
2196 if (node->current_frame_host()->GetRenderWidgetHost() ==
2197 render_widget_host) {
2198 widget_in_frame_tree = true;
2199 break;
2200 }
2201 }
2202
2203 if (widget_in_frame_tree && delegate_) {
lfgf0cd46e2017-01-04 00:05:232204 for (WebContentsImpl* current = this; current;
2205 current = current->GetOuterWebContents()) {
2206 current->mouse_lock_widget_ = render_widget_host;
2207 }
2208
avic3aa8422015-11-09 20:57:222209 delegate_->RequestToLockMouse(this, user_gesture, last_unlocked_by_target);
lfgbee1e0a2016-06-08 21:24:212210 } else {
2211 render_widget_host->GotResponseToLockMouseRequest(false);
2212 }
[email protected]e9621112011-10-17 05:38:372213}
2214
avi3e4b8512015-11-11 01:55:492215void WebContentsImpl::LostMouseLock(RenderWidgetHostImpl* render_widget_host) {
lfgbee1e0a2016-06-08 21:24:212216 CHECK(mouse_lock_widget_);
lfgf0cd46e2017-01-04 00:05:232217
2218 if (mouse_lock_widget_->delegate()->GetAsWebContents() != this)
2219 return mouse_lock_widget_->delegate()->LostMouseLock(render_widget_host);
2220
lfgbee1e0a2016-06-08 21:24:212221 mouse_lock_widget_->SendMouseLockLost();
lfgf0cd46e2017-01-04 00:05:232222 for (WebContentsImpl* current = this; current;
2223 current = current->GetOuterWebContents()) {
2224 current->mouse_lock_widget_ = nullptr;
2225 }
avi3e4b8512015-11-11 01:55:492226
[email protected]e9621112011-10-17 05:38:372227 if (delegate_)
2228 delegate_->LostMouseLock();
2229}
2230
lfgad8244352016-07-13 16:55:512231bool WebContentsImpl::HasMouseLock(RenderWidgetHostImpl* render_widget_host) {
2232 // To verify if the mouse is locked, the mouse_lock_widget_ needs to be
2233 // assigned to the widget that requested the mouse lock, and the top-level
2234 // platform RenderWidgetHostView needs to hold the mouse lock from the OS.
2235 return mouse_lock_widget_ == render_widget_host &&
2236 GetTopLevelRenderWidgetHostView()->IsMouseLocked();
2237}
2238
lfg84763c92017-02-16 18:55:152239RenderWidgetHostImpl* WebContentsImpl::GetMouseLockWidget() {
lfge2176fb2017-03-26 00:45:472240 if (GetTopLevelRenderWidgetHostView()->IsMouseLocked() ||
2241 (GetFullscreenRenderWidgetHostView() &&
2242 GetFullscreenRenderWidgetHostView()->IsMouseLocked()))
lfg84763c92017-02-16 18:55:152243 return mouse_lock_widget_;
2244
2245 return nullptr;
2246}
2247
ekaramada4f42692016-02-11 19:48:372248void WebContentsImpl::OnRenderFrameProxyVisibilityChanged(bool visible) {
lfg9462cef2016-07-18 23:51:062249 if (visible && !GetOuterWebContents()->IsHidden())
ekaramada4f42692016-02-11 19:48:372250 WasShown();
lfg9462cef2016-07-18 23:51:062251 else if (!visible)
ekaramada4f42692016-02-11 19:48:372252 WasHidden();
2253}
2254
[email protected]bafe6cd2012-05-23 23:09:502255void WebContentsImpl::CreateNewWindow(
csharrison95f01e922017-04-24 18:52:352256 RenderFrameHost* opener,
nick5ae4d2d2017-01-06 01:18:352257 int32_t render_view_route_id,
dcheng3ce04b62015-10-26 23:30:552258 int32_t main_frame_route_id,
2259 int32_t main_frame_widget_route_id,
rockot5c478a72016-09-28 23:14:182260 const mojom::CreateNewWindowParams& params,
[email protected]97714c82012-06-06 10:15:132261 SessionStorageNamespace* session_storage_namespace) {
nick5ae4d2d2017-01-06 01:18:352262 // We should have zero valid routing ids, or three valid routing IDs.
2263 DCHECK_EQ((render_view_route_id == MSG_ROUTING_NONE),
2264 (main_frame_route_id == MSG_ROUTING_NONE));
2265 DCHECK_EQ((render_view_route_id == MSG_ROUTING_NONE),
2266 (main_frame_widget_route_id == MSG_ROUTING_NONE));
csharrison95f01e922017-04-24 18:52:352267 DCHECK(opener);
nick5ae4d2d2017-01-06 01:18:352268
csharrison95f01e922017-04-24 18:52:352269 int render_process_id = opener->GetProcess()->GetID();
2270 SiteInstance* source_site_instance = opener->GetSiteInstance();
2271
2272 // The route IDs passed into this function can be trusted not to already
2273 // be in use; they were allocated by the RenderWidgetHelper by the caller.
nick5ae4d2d2017-01-06 01:18:352274 DCHECK(!RenderFrameHostImpl::FromID(render_process_id, main_frame_route_id));
2275
[email protected]bafe6cd2012-05-23 23:09:502276 // We usually create the new window in the same BrowsingInstance (group of
2277 // script-related windows), by passing in the current SiteInstance. However,
[email protected]c4538072013-03-18 02:17:552278 // if the opener is being suppressed (in a non-guest), we create a new
2279 // SiteInstance in its own BrowsingInstance.
[email protected]a24efc22014-05-26 15:50:252280 bool is_guest = BrowserPluginGuest::IsGuest(this);
[email protected]c4538072013-03-18 02:17:552281
[email protected]04cbd3d2013-12-04 04:58:202282 // If the opener is to be suppressed, the new window can be in any process.
2283 // Since routing ids are process specific, we must not have one passed in
2284 // as argument here.
nick5ae4d2d2017-01-06 01:18:352285 DCHECK(!params.opener_suppressed || render_view_route_id == MSG_ROUTING_NONE);
[email protected]04cbd3d2013-12-04 04:58:202286
[email protected]bafe6cd2012-05-23 23:09:502287 scoped_refptr<SiteInstance> site_instance =
alexmos4cf2aa32015-07-15 23:40:432288 params.opener_suppressed && !is_guest
2289 ? SiteInstance::CreateForURL(GetBrowserContext(), params.target_url)
2290 : source_site_instance;
[email protected]bafe6cd2012-05-23 23:09:502291
[email protected]d1198fd2012-08-13 22:50:192292 // We must assign the SessionStorageNamespace before calling Init().
[email protected]4c3a23582012-08-18 08:54:342293 //
2294 // http://crbug.com/142685
[email protected]fdac6ade2013-07-20 01:06:302295 const std::string& partition_id =
2296 GetContentClient()->browser()->
2297 GetStoragePartitionIdForSite(GetBrowserContext(),
2298 site_instance->GetSiteURL());
[email protected]fc72bb12013-06-02 21:13:462299 StoragePartition* partition = BrowserContext::GetStoragePartition(
2300 GetBrowserContext(), site_instance.get());
[email protected]5f2aa722013-08-07 16:59:412301 DOMStorageContextWrapper* dom_storage_context =
2302 static_cast<DOMStorageContextWrapper*>(partition->GetDOMStorageContext());
[email protected]d1198fd2012-08-13 22:50:192303 SessionStorageNamespaceImpl* session_storage_namespace_impl =
2304 static_cast<SessionStorageNamespaceImpl*>(session_storage_namespace);
2305 CHECK(session_storage_namespace_impl->IsFromContext(dom_storage_context));
[email protected]dd6730412013-08-14 15:03:372306
2307 if (delegate_ &&
dcheng3ce04b62015-10-26 23:30:552308 !delegate_->ShouldCreateWebContents(
lukasza6f8ac622017-06-06 03:10:202309 this, opener, source_site_instance, render_view_route_id,
2310 main_frame_route_id, main_frame_widget_route_id,
2311 params.window_container_type, opener->GetLastCommittedURL(),
2312 params.frame_name, params.target_url, partition_id,
2313 session_storage_namespace)) {
jambaaab3a2016-11-05 00:46:182314 // Note: even though we're not creating a WebContents here, it could have
2315 // been created by the embedder so ensure that the RenderFrameHost is
2316 // properly initialized.
csharrisona2280cd2016-02-03 23:21:152317 // It's safe to only target the frame because the render process will not
2318 // have a chance to create more frames at this point.
jambaaab3a2016-11-05 00:46:182319 RenderFrameHostImpl* rfh =
2320 RenderFrameHostImpl::FromID(render_process_id, main_frame_route_id);
nick5ae4d2d2017-01-06 01:18:352321 if (rfh) {
2322 DCHECK(rfh->IsRenderFrameLive());
jambaaab3a2016-11-05 00:46:182323 rfh->Init();
nick5ae4d2d2017-01-06 01:18:352324 }
[email protected]dd6730412013-08-14 15:03:372325 return;
2326 }
2327
2328 // Create the new web contents. This will automatically create the new
2329 // WebContentsView. In the future, we may want to create the view separately.
[email protected]fc72bb12013-06-02 21:13:462330 CreateParams create_params(GetBrowserContext(), site_instance.get());
nick5ae4d2d2017-01-06 01:18:352331 create_params.routing_id = render_view_route_id;
[email protected]227692c52013-05-31 22:43:042332 create_params.main_frame_routing_id = main_frame_route_id;
dcheng3ce04b62015-10-26 23:30:552333 create_params.main_frame_widget_routing_id = main_frame_widget_route_id;
nasko48321ca32015-07-02 20:44:122334 create_params.main_frame_name = params.frame_name;
alexmos4cf2aa32015-07-15 23:40:432335 create_params.opener_render_process_id = render_process_id;
csharrison95f01e922017-04-24 18:52:352336 create_params.opener_render_frame_id = opener->GetRoutingID();
[email protected]50d326e2014-05-20 17:59:062337 create_params.opener_suppressed = params.opener_suppressed;
nick3b04f322016-08-31 19:29:192338 if (params.disposition == WindowOpenDisposition::NEW_BACKGROUND_TAB)
[email protected]50d326e2014-05-20 17:59:062339 create_params.initially_hidden = true;
lfg269b702f2015-06-08 19:28:192340 create_params.renderer_initiated_creation =
2341 main_frame_route_id != MSG_ROUTING_NONE;
[email protected]50d326e2014-05-20 17:59:062342
[email protected]4858e432014-06-23 18:14:172343 WebContentsImpl* new_contents = NULL;
[email protected]c4538072013-03-18 02:17:552344 if (!is_guest) {
2345 create_params.context = view_->GetNativeView();
[email protected]fc2b46b2014-05-03 16:33:452346 create_params.initial_size = GetContainerBounds().size();
[email protected]4858e432014-06-23 18:14:172347 new_contents = static_cast<WebContentsImpl*>(
2348 WebContents::Create(create_params));
2349 } else {
2350 new_contents = GetBrowserPluginGuest()->CreateNewGuestWindow(create_params);
[email protected]c4538072013-03-18 02:17:552351 }
[email protected]50d326e2014-05-20 17:59:062352 new_contents->GetController().SetSessionStorageNamespace(
2353 partition_id,
2354 session_storage_namespace);
[email protected]d1198fd2012-08-13 22:50:192355
alexmos646fec02015-07-25 00:11:492356 // If the new frame has a name, make sure any SiteInstances that can find
2357 // this named frame have proxies for it. Must be called after
2358 // SetSessionStorageNamespace, since this calls CreateRenderView, which uses
2359 // GetSessionStorageNamespace.
2360 if (!params.frame_name.empty())
2361 new_contents->GetRenderManager()->CreateProxiesForNewNamedFrame();
2362
[email protected]c4538072013-03-18 02:17:552363 // Save the window for later if we're not suppressing the opener (since it
[email protected]d70bea92013-04-05 04:23:342364 // will be shown immediately).
2365 if (!params.opener_suppressed) {
2366 if (!is_guest) {
[email protected]fc2b46b2014-05-03 16:33:452367 WebContentsView* new_view = new_contents->view_.get();
[email protected]bafe6cd2012-05-23 23:09:502368
[email protected]d70bea92013-04-05 04:23:342369 // TODO(brettw): It seems bogus that we have to call this function on the
2370 // newly created object and give it one of its own member variables.
avi3627ecac2015-10-16 17:40:432371 new_view->CreateViewForWidget(
2372 new_contents->GetRenderViewHost()->GetWidget(), false);
[email protected]d70bea92013-04-05 04:23:342373 }
[email protected]bafe6cd2012-05-23 23:09:502374 // Save the created window associated with the route so we can show it
2375 // later.
nick5ae4d2d2017-01-06 01:18:352376 DCHECK_NE(MSG_ROUTING_NONE, main_frame_widget_route_id);
2377 pending_contents_[std::make_pair(
2378 render_process_id, main_frame_widget_route_id)] = new_contents;
[email protected]7fff43e2013-05-21 20:21:102379 AddDestructionObserver(new_contents);
[email protected]bafe6cd2012-05-23 23:09:502380 }
2381
2382 if (delegate_) {
Bryan McQuaded2b93c02017-07-14 22:26:312383 delegate_->WebContentsCreated(this, render_process_id,
2384 opener->GetRoutingID(), params.frame_name,
2385 params.target_url, new_contents);
[email protected]bafe6cd2012-05-23 23:09:502386 }
2387
csharrison95f01e922017-04-24 18:52:352388 if (opener) {
pnolandaae574e2017-03-06 21:04:212389 for (auto& observer : observers_) {
csharrison95f01e922017-04-24 18:52:352390 observer.DidOpenRequestedURL(new_contents, opener, params.target_url,
2391 params.referrer, params.disposition,
2392 ui::PAGE_TRANSITION_LINK,
pnolandaae574e2017-03-06 21:04:212393 false, // started_from_context_menu
2394 true); // renderer_initiated
2395 }
2396 }
2397
Avi Drissmanba3b1b342017-08-29 18:16:132398 // Any new WebContents opened while this WebContents is in fullscreen can be
2399 // used to confuse the user, so drop fullscreen.
2400 if (IsFullscreenForCurrentTab())
2401 ExitFullscreen(true);
2402
[email protected]bafe6cd2012-05-23 23:09:502403 if (params.opener_suppressed) {
2404 // When the opener is suppressed, the original renderer cannot access the
2405 // new window. As a result, we need to show and navigate the window here.
[email protected]eda238a12012-09-07 23:44:002406 bool was_blocked = false;
2407 if (delegate_) {
bokan107a47f2015-02-03 23:23:392408 gfx::Rect initial_rect;
nick0d558482017-02-13 22:27:222409 base::WeakPtr<WebContentsImpl> weak_new_contents =
2410 new_contents->weak_factory_.GetWeakPtr();
2411
[email protected]eda238a12012-09-07 23:44:002412 delegate_->AddNewContents(
bokan107a47f2015-02-03 23:23:392413 this, new_contents, params.disposition, initial_rect,
[email protected]eda238a12012-09-07 23:44:002414 params.user_gesture, &was_blocked);
nick0d558482017-02-13 22:27:222415
2416 if (!weak_new_contents)
2417 return; // The delegate deleted |new_contents| during AddNewContents().
[email protected]eda238a12012-09-07 23:44:002418 }
2419 if (!was_blocked) {
nick3b04f322016-08-31 19:29:192420 OpenURLParams open_params(params.target_url, params.referrer,
2421 WindowOpenDisposition::CURRENT_TAB,
Sylvain Defresnec6ccc77d2014-09-19 10:19:352422 ui::PAGE_TRANSITION_LINK,
[email protected]8ff00d72012-10-23 19:12:212423 true /* is_renderer_initiated */);
[email protected]e7f2e7c2013-07-15 09:41:302424 open_params.user_gesture = params.user_gesture;
mariakhomenkoa4971c12015-07-21 19:04:372425
2426 if (delegate_ && !is_guest &&
2427 !delegate_->ShouldResumeRequestsForCreatedWindow()) {
2428 // We are in asynchronous add new contents path, delay opening url
2429 new_contents->delayed_open_url_params_.reset(
2430 new OpenURLParams(open_params));
2431 } else {
2432 new_contents->OpenURL(open_params);
2433 }
[email protected]eda238a12012-09-07 23:44:002434 }
[email protected]bafe6cd2012-05-23 23:09:502435 }
2436}
2437
avib7348942015-12-25 20:57:102438void WebContentsImpl::CreateNewWidget(int32_t render_process_id,
2439 int32_t route_id,
Dave Tapuska1bdf1832017-07-07 18:07:192440 mojom::WidgetPtr widget,
[email protected]180ef242013-11-07 06:50:462441 blink::WebPopupType popup_type) {
Dave Tapuska1bdf1832017-07-07 18:07:192442 CreateNewWidget(render_process_id, route_id, false, std::move(widget),
2443 popup_type);
[email protected]bafe6cd2012-05-23 23:09:502444}
2445
avib7348942015-12-25 20:57:102446void WebContentsImpl::CreateNewFullscreenWidget(int32_t render_process_id,
Dave Tapuska1bdf1832017-07-07 18:07:192447 int32_t route_id,
2448 mojom::WidgetPtr widget) {
2449 CreateNewWidget(render_process_id, route_id, true, std::move(widget),
2450 blink::kWebPopupTypeNone);
[email protected]bafe6cd2012-05-23 23:09:502451}
2452
avib7348942015-12-25 20:57:102453void WebContentsImpl::CreateNewWidget(int32_t render_process_id,
2454 int32_t route_id,
[email protected]bafe6cd2012-05-23 23:09:502455 bool is_fullscreen,
Dave Tapuska1bdf1832017-07-07 18:07:192456 mojom::WidgetPtr widget,
[email protected]180ef242013-11-07 06:50:462457 blink::WebPopupType popup_type) {
kenrba26d15092016-02-10 22:00:252458 RenderProcessHost* process = RenderProcessHost::FromID(render_process_id);
kenrbb46f86a2015-12-07 07:53:232459 // A message to create a new widget can only come from an active process for
[email protected]a8504022013-12-04 20:23:512460 // this WebContentsImpl instance. If any other process sends the request,
2461 // it is invalid and the process must be terminated.
dcheng57e39e22016-01-21 00:25:382462 if (!HasMatchingProcess(&frame_tree_, render_process_id)) {
kenrba26d15092016-02-10 22:00:252463 base::ProcessHandle process_handle = process->GetHandle();
[email protected]a8504022013-12-04 20:23:512464 if (process_handle != base::kNullProcessHandle) {
2465 RecordAction(
[email protected]e6e30ac2014-01-13 21:24:392466 base::UserMetricsAction("Terminate_ProcessMismatch_CreateNewWidget"));
kenrba26d15092016-02-10 22:00:252467 process->Shutdown(RESULT_CODE_KILLED, false);
[email protected]a8504022013-12-04 20:23:512468 }
2469 return;
2470 }
2471
Dave Tapuska485aca92017-08-08 00:47:582472 RenderWidgetHostImpl* widget_host = new RenderWidgetHostImpl(
2473 this, process, route_id, std::move(widget), IsHidden());
[email protected]b24b68a2012-09-24 21:57:262474
[email protected]cfd80b02014-05-01 17:46:482475 RenderWidgetHostViewBase* widget_view =
2476 static_cast<RenderWidgetHostViewBase*>(
2477 view_->CreateViewForPopupWidget(widget_host));
[email protected]83918ec2013-01-10 15:37:192478 if (!widget_view)
2479 return;
[email protected]bafe6cd2012-05-23 23:09:502480 if (!is_fullscreen) {
2481 // Popups should not get activated.
2482 widget_view->SetPopupType(popup_type);
2483 }
2484 // Save the created widget associated with the route so we can show it later.
alexmosc2a8cec2016-05-23 22:19:532485 pending_widget_views_[std::make_pair(render_process_id, route_id)] =
2486 widget_view;
[email protected]bafe6cd2012-05-23 23:09:502487
2488#if defined(OS_MACOSX)
2489 // A RenderWidgetHostViewMac has lifetime scoped to the view. We'll retain it
2490 // to allow it to survive the trip without being hosted.
2491 base::mac::NSObjectRetain(widget_view->GetNativeView());
2492#endif
2493}
2494
alexmosc2a8cec2016-05-23 22:19:532495void WebContentsImpl::ShowCreatedWindow(int process_id,
nick5ae4d2d2017-01-06 01:18:352496 int main_frame_widget_route_id,
[email protected]bafe6cd2012-05-23 23:09:502497 WindowOpenDisposition disposition,
bokan107a47f2015-02-03 23:23:392498 const gfx::Rect& initial_rect,
[email protected]bafe6cd2012-05-23 23:09:502499 bool user_gesture) {
nick0d558482017-02-13 22:27:222500 WebContentsImpl* popup =
nick5ae4d2d2017-01-06 01:18:352501 GetCreatedWindow(process_id, main_frame_widget_route_id);
nick0d558482017-02-13 22:27:222502 if (popup) {
[email protected]eda238a12012-09-07 23:44:002503 WebContentsDelegate* delegate = GetDelegate();
nick0d558482017-02-13 22:27:222504 popup->is_resume_pending_ = true;
mariakhomenko44bdc4732015-04-29 01:55:382505 if (!delegate || delegate->ShouldResumeRequestsForCreatedWindow())
nick0d558482017-02-13 22:27:222506 popup->ResumeLoadingCreatedWebContents();
mariakhomenko44bdc4732015-04-29 01:55:382507
[email protected]eda238a12012-09-07 23:44:002508 if (delegate) {
nick0d558482017-02-13 22:27:222509 base::WeakPtr<WebContentsImpl> weak_popup =
2510 popup->weak_factory_.GetWeakPtr();
2511 delegate->AddNewContents(this, popup, disposition, initial_rect,
2512 user_gesture, nullptr);
2513 if (!weak_popup)
2514 return; // The delegate deleted |popup| during AddNewContents().
[email protected]eda238a12012-09-07 23:44:002515 }
nick5ae4d2d2017-01-06 01:18:352516
nick0d558482017-02-13 22:27:222517 RenderWidgetHostImpl* rwh = popup->GetMainFrame()->GetRenderWidgetHost();
2518 DCHECK_EQ(main_frame_widget_route_id, rwh->GetRoutingID());
nick5ae4d2d2017-01-06 01:18:352519 rwh->Send(new ViewMsg_Move_ACK(rwh->GetRoutingID()));
[email protected]eda238a12012-09-07 23:44:002520 }
[email protected]bafe6cd2012-05-23 23:09:502521}
2522
alexmosc2a8cec2016-05-23 22:19:532523void WebContentsImpl::ShowCreatedWidget(int process_id,
2524 int route_id,
bokan107a47f2015-02-03 23:23:392525 const gfx::Rect& initial_rect) {
alexmosc2a8cec2016-05-23 22:19:532526 ShowCreatedWidget(process_id, route_id, false, initial_rect);
[email protected]bafe6cd2012-05-23 23:09:502527}
2528
alexmosc2a8cec2016-05-23 22:19:532529void WebContentsImpl::ShowCreatedFullscreenWidget(int process_id,
2530 int route_id) {
2531 ShowCreatedWidget(process_id, route_id, true, gfx::Rect());
[email protected]bafe6cd2012-05-23 23:09:502532}
2533
alexmosc2a8cec2016-05-23 22:19:532534void WebContentsImpl::ShowCreatedWidget(int process_id,
2535 int route_id,
[email protected]bafe6cd2012-05-23 23:09:502536 bool is_fullscreen,
bokan107a47f2015-02-03 23:23:392537 const gfx::Rect& initial_rect) {
[email protected]cfd80b02014-05-01 17:46:482538 RenderWidgetHostViewBase* widget_host_view =
alexmosc2a8cec2016-05-23 22:19:532539 static_cast<RenderWidgetHostViewBase*>(
2540 GetCreatedWidget(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:502541 if (!widget_host_view)
2542 return;
[email protected]cfd80b02014-05-01 17:46:482543
2544 RenderWidgetHostView* view = NULL;
lfgc740d4b22016-04-15 16:45:332545 if (GetOuterWebContents()) {
2546 view = GetOuterWebContents()->GetRenderWidgetHostView();
[email protected]cfd80b02014-05-01 17:46:482547 } else {
2548 view = GetRenderWidgetHostView();
2549 }
2550
[email protected]4aebbca2013-09-17 22:26:492551 if (is_fullscreen) {
[email protected]d7f80ba2013-10-12 07:42:312552 DCHECK_EQ(MSG_ROUTING_NONE, fullscreen_widget_routing_id_);
[email protected]0b431992014-06-24 00:08:032553 view_->StoreFocus();
alexmosc9e76ec2016-05-16 22:59:372554 fullscreen_widget_process_id_ =
2555 widget_host_view->GetRenderWidgetHost()->GetProcess()->GetID();
[email protected]d7f80ba2013-10-12 07:42:312556 fullscreen_widget_routing_id_ = route_id;
[email protected]4aebbca2013-09-17 22:26:492557 if (delegate_ && delegate_->EmbedsFullscreenWidget()) {
2558 widget_host_view->InitAsChild(GetRenderWidgetHostView()->GetNativeView());
mlamouri7a78d6fd2015-01-17 13:23:532559 delegate_->EnterFullscreenModeForTab(this, GURL());
[email protected]4aebbca2013-09-17 22:26:492560 } else {
[email protected]cfd80b02014-05-01 17:46:482561 widget_host_view->InitAsFullscreen(view);
[email protected]4aebbca2013-09-17 22:26:492562 }
ericwilligersde386342016-10-19 02:35:092563 for (auto& observer : observers_)
2564 observer.DidShowFullscreenWidget();
[email protected]4aebbca2013-09-17 22:26:492565 if (!widget_host_view->HasFocus())
2566 widget_host_view->Focus();
2567 } else {
bokan107a47f2015-02-03 23:23:392568 widget_host_view->InitAsPopup(view, initial_rect);
[email protected]4aebbca2013-09-17 22:26:492569 }
[email protected]89054502012-06-03 10:29:242570
2571 RenderWidgetHostImpl* render_widget_host_impl =
2572 RenderWidgetHostImpl::From(widget_host_view->GetRenderWidgetHost());
2573 render_widget_host_impl->Init();
[email protected]d7f80ba2013-10-12 07:42:312574 // Only allow privileged mouse lock for fullscreen render widget, which is
2575 // used to implement Pepper Flash fullscreen.
2576 render_widget_host_impl->set_allow_privileged_mouse_lock(is_fullscreen);
[email protected]bafe6cd2012-05-23 23:09:502577
2578#if defined(OS_MACOSX)
2579 // A RenderWidgetHostViewMac has lifetime scoped to the view. Now that it's
2580 // properly embedded (or purposefully ignored) we can release the retain we
2581 // took in CreateNewWidget().
2582 base::mac::NSObjectRelease(widget_host_view->GetNativeView());
2583#endif
2584}
2585
nick5ae4d2d2017-01-06 01:18:352586WebContentsImpl* WebContentsImpl::GetCreatedWindow(
2587 int process_id,
2588 int main_frame_widget_route_id) {
2589 auto key = std::make_pair(process_id, main_frame_widget_route_id);
2590 auto iter = pending_contents_.find(key);
[email protected]bafe6cd2012-05-23 23:09:502591
2592 // Certain systems can block the creation of new windows. If we didn't succeed
2593 // in creating one, just return NULL.
alexmosc2a8cec2016-05-23 22:19:532594 if (iter == pending_contents_.end())
2595 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:502596
2597 WebContentsImpl* new_contents = iter->second;
nick5ae4d2d2017-01-06 01:18:352598 pending_contents_.erase(key);
[email protected]7fff43e2013-05-21 20:21:102599 RemoveDestructionObserver(new_contents);
[email protected]bafe6cd2012-05-23 23:09:502600
[email protected]d70bea92013-04-05 04:23:342601 // Don't initialize the guest WebContents immediately.
[email protected]a24efc22014-05-26 15:50:252602 if (BrowserPluginGuest::IsGuest(new_contents))
[email protected]d70bea92013-04-05 04:23:342603 return new_contents;
2604
nick5ae4d2d2017-01-06 01:18:352605 if (!new_contents->GetMainFrame()->GetProcess()->HasConnection() ||
2606 !new_contents->GetMainFrame()->GetView()) {
2607 // TODO(nick): http://crbug.com/674318 -- Who deletes |new_contents|?
alexmosc2a8cec2016-05-23 22:19:532608 return nullptr;
nick5ae4d2d2017-01-06 01:18:352609 }
[email protected]bafe6cd2012-05-23 23:09:502610
[email protected]bafe6cd2012-05-23 23:09:502611 return new_contents;
2612}
2613
alexmosc2a8cec2016-05-23 22:19:532614RenderWidgetHostView* WebContentsImpl::GetCreatedWidget(int process_id,
2615 int route_id) {
2616 auto iter = pending_widget_views_.find(std::make_pair(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:502617 if (iter == pending_widget_views_.end()) {
2618 DCHECK(false);
alexmosc2a8cec2016-05-23 22:19:532619 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:502620 }
2621
2622 RenderWidgetHostView* widget_host_view = iter->second;
alexmosc2a8cec2016-05-23 22:19:532623 pending_widget_views_.erase(std::make_pair(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:502624
2625 RenderWidgetHost* widget_host = widget_host_view->GetRenderWidgetHost();
2626 if (!widget_host->GetProcess()->HasConnection()) {
2627 // The view has gone away or the renderer crashed. Nothing to do.
alexmosc2a8cec2016-05-23 22:19:532628 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:502629 }
2630
2631 return widget_host_view;
2632}
2633
[email protected]f13b4202012-06-12 23:53:232634void WebContentsImpl::RequestMediaAccessPermission(
[email protected]33662e52013-01-07 21:31:092635 const MediaStreamRequest& request,
[email protected]8ff00d72012-10-23 19:12:212636 const MediaResponseCallback& callback) {
[email protected]d19b84b2014-03-14 11:52:372637 if (delegate_) {
[email protected]f13b4202012-06-12 23:53:232638 delegate_->RequestMediaAccessPermission(this, request, callback);
[email protected]d19b84b2014-03-14 11:52:372639 } else {
dcheng59716272016-04-09 05:19:082640 callback.Run(MediaStreamDevices(), MEDIA_DEVICE_FAILED_DUE_TO_SHUTDOWN,
2641 std::unique_ptr<MediaStreamUI>());
[email protected]d19b84b2014-03-14 11:52:372642 }
[email protected]f13b4202012-06-12 23:53:232643}
2644
Chandan Padhia4b8bcb72017-09-12 16:41:042645bool WebContentsImpl::CheckMediaAccessPermission(
2646 const url::Origin& security_origin,
2647 MediaStreamType type) {
grunell657d4d82014-09-18 00:09:432648 DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
2649 type == MEDIA_DEVICE_VIDEO_CAPTURE);
Chandan Padhia4b8bcb72017-09-12 16:41:042650 return delegate_ && delegate_->CheckMediaAccessPermission(
2651 this, security_origin.GetURL(), type);
grunell657d4d82014-09-18 00:09:432652}
2653
guidou8a440b842017-01-30 13:58:432654std::string WebContentsImpl::GetDefaultMediaDeviceID(MediaStreamType type) {
2655 if (!delegate_)
2656 return std::string();
2657 return delegate_->GetDefaultMediaDeviceID(this, type);
2658}
2659
[email protected]cc9200432013-07-23 23:02:402660SessionStorageNamespace* WebContentsImpl::GetSessionStorageNamespace(
2661 SiteInstance* instance) {
2662 return controller_.GetSessionStorageNamespace(instance);
2663}
2664
[email protected]6de7fc482014-06-06 10:46:442665SessionStorageNamespaceMap WebContentsImpl::GetSessionStorageNamespaceMap() {
2666 return controller_.GetSessionStorageNamespaceMap();
2667}
2668
[email protected]9b159a52013-10-03 17:24:552669FrameTree* WebContentsImpl::GetFrameTree() {
2670 return &frame_tree_;
2671}
2672
aelias5252baa2016-04-10 01:18:022673bool WebContentsImpl::IsOverridingUserAgent() {
2674 return GetController().GetVisibleEntry() &&
2675 GetController().GetVisibleEntry()->GetIsOverridingUserAgent();
2676}
2677
avi85ee8362016-10-08 02:09:082678bool WebContentsImpl::IsJavaScriptDialogShowing() const {
2679 return is_showing_javascript_dialog_;
2680}
2681
avic031d392017-03-03 03:09:422682bool WebContentsImpl::ShouldIgnoreUnresponsiveRenderer() {
2683 // Ignore unresponsive renderers if the debugger is attached to them since the
2684 // unresponsiveness might be a result of the renderer sitting on a breakpoint.
2685 //
2686 // TODO(pfeldman): Fix this to only return true if the renderer is *actually*
2687 // sitting on a breakpoint. https://crbug.com/684202
2688 return DevToolsAgentHost::IsDebuggerAttached(this);
2689}
2690
Doug Turner63f3c7b2017-07-29 05:10:012691ui::AXMode WebContentsImpl::GetAccessibilityMode() const {
[email protected]95640212014-07-26 18:14:302692 return accessibility_mode_;
2693}
2694
Dominic Mazzonia7b0edb22017-08-09 16:32:512695void WebContentsImpl::AccessibilityEventReceived(
2696 const std::vector<AXEventNotificationDetails>& details) {
ericwilligersde386342016-10-19 02:35:092697 for (auto& observer : observers_)
Dominic Mazzonia7b0edb22017-08-09 16:32:512698 observer.AccessibilityEventReceived(details);
[email protected]31a71eaf2014-03-13 01:47:362699}
2700
dmazzoni2400c462016-08-23 15:07:132701void WebContentsImpl::AccessibilityLocationChangesReceived(
2702 const std::vector<AXLocationChangeNotificationDetails>& details) {
ericwilligersde386342016-10-19 02:35:092703 for (auto& observer : observers_)
Dominic Mazzonia7b0edb22017-08-09 16:32:512704 observer.AccessibilityLocationChangesReceived(details);
dmazzoni2400c462016-08-23 15:07:132705}
2706
dmazzonia656928e2014-09-15 20:28:542707RenderFrameHost* WebContentsImpl::GetGuestByInstanceID(
fsamuel833ee7c2015-02-13 23:40:402708 RenderFrameHost* render_frame_host,
dmazzonia656928e2014-09-15 20:28:542709 int browser_plugin_instance_id) {
2710 BrowserPluginGuestManager* guest_manager =
2711 GetBrowserContext()->GetGuestManager();
fsamuel9cbc00a2015-04-17 20:30:202712 if (!guest_manager)
2713 return nullptr;
2714
dmazzonia656928e2014-09-15 20:28:542715 WebContents* guest = guest_manager->GetGuestByInstanceID(
fsamuel2e9413d2015-02-25 01:25:442716 render_frame_host->GetProcess()->GetID(), browser_plugin_instance_id);
dmazzonia656928e2014-09-15 20:28:542717 if (!guest)
fsamuel9cbc00a2015-04-17 20:30:202718 return nullptr;
2719
dmazzonia656928e2014-09-15 20:28:542720 return guest->GetMainFrame();
2721}
2722
Conley Owens6894c4f2017-07-10 19:29:132723device::GeolocationContext* WebContentsImpl::GetGeolocationContext() {
2724 return geolocation_context_.get();
blundellc57b93f2014-10-29 13:19:572725}
2726
ke.he98b761e2017-05-09 05:59:172727device::mojom::WakeLockContext* WebContentsImpl::GetWakeLockContext() {
blundelld8cd72b2017-03-28 07:18:382728 if (!wake_lock_context_host_)
2729 wake_lock_context_host_.reset(new WakeLockContextHost(this));
blundelle75a8f92017-03-27 08:11:172730 return wake_lock_context_host_->GetWakeLockContext();
alogvinovf50445a2015-10-30 13:00:122731}
2732
juncai8e8d6ec2017-06-06 20:48:182733device::mojom::WakeLock* WebContentsImpl::GetRendererWakeLock() {
2734 // WebContents creates a long-lived connection to one WakeLock.
ke.he98b761e2017-05-09 05:59:172735 // All the frames' requests will be added into the BindingSet of
juncai8e8d6ec2017-06-06 20:48:182736 // WakeLock via this connection.
ke.he98b761e2017-05-09 05:59:172737 if (!renderer_wake_lock_) {
2738 device::mojom::WakeLockContext* wake_lock_context = GetWakeLockContext();
2739 if (!wake_lock_context) {
2740 return nullptr;
2741 }
ke.hef435c1e82017-05-11 04:09:102742 wake_lock_context->GetWakeLock(
2743 device::mojom::WakeLockType::PreventDisplaySleep,
2744 device::mojom::WakeLockReason::ReasonOther, "Wake Lock API",
2745 mojo::MakeRequest(&renderer_wake_lock_));
ke.he98b761e2017-05-09 05:59:172746 }
2747 return renderer_wake_lock_.get();
2748}
2749
blundellf5316fc2017-05-15 11:49:032750#if defined(OS_ANDROID)
Han Leonf6a2e5f2017-05-23 13:40:472751void WebContentsImpl::GetNFC(device::mojom::NFCRequest request) {
blundellf5316fc2017-05-15 11:49:032752 if (!nfc_host_)
2753 nfc_host_.reset(new NFCHost(this));
2754 nfc_host_->GetNFC(std::move(request));
2755}
2756#endif
2757
[email protected]edc3af82013-12-12 21:24:072758void WebContentsImpl::OnShowValidationMessage(
nicka0ac8382016-12-15 23:59:232759 RenderViewHostImpl* source,
[email protected]edc3af82013-12-12 21:24:072760 const gfx::Rect& anchor_in_root_view,
[email protected]6ff9c8f2013-12-20 09:05:292761 const base::string16& main_text,
2762 const base::string16& sub_text) {
nicka0ac8382016-12-15 23:59:232763 // TODO(nick): Should we consider |source| here or pass it to the delegate?
[email protected]edc3af82013-12-12 21:24:072764 if (delegate_)
2765 delegate_->ShowValidationMessage(
2766 this, anchor_in_root_view, main_text, sub_text);
2767}
2768
nicka0ac8382016-12-15 23:59:232769void WebContentsImpl::OnHideValidationMessage(RenderViewHostImpl* source) {
2770 // TODO(nick): Should we consider |source| here or pass it to the delegate?
[email protected]edc3af82013-12-12 21:24:072771 if (delegate_)
2772 delegate_->HideValidationMessage(this);
2773}
2774
2775void WebContentsImpl::OnMoveValidationMessage(
nicka0ac8382016-12-15 23:59:232776 RenderViewHostImpl* source,
[email protected]edc3af82013-12-12 21:24:072777 const gfx::Rect& anchor_in_root_view) {
nicka0ac8382016-12-15 23:59:232778 // TODO(nick): Should we consider |source| here or pass it to the delegate?
[email protected]edc3af82013-12-12 21:24:072779 if (delegate_)
2780 delegate_->MoveValidationMessage(this, anchor_in_root_view);
2781}
2782
Evan Stade5e750ad02017-08-07 21:59:272783void WebContentsImpl::SetNotWaitingForResponse() {
2784 if (waiting_for_response_ == false)
2785 return;
2786
2787 waiting_for_response_ = false;
2788 if (delegate_)
2789 delegate_->LoadingStateChanged(this, is_load_to_different_document_);
2790}
2791
lfgbb9c28a2016-03-01 03:19:492792void WebContentsImpl::SendScreenRects() {
kenrbc52e1b4e2016-03-20 01:03:372793 for (FrameTreeNode* node : frame_tree_.Nodes()) {
kenrb0e8dc202016-05-30 19:51:402794 if (node->current_frame_host()->is_local_root())
kenrbc52e1b4e2016-03-20 01:03:372795 node->current_frame_host()->GetRenderWidgetHost()->SendScreenRects();
2796 }
lfgbb9c28a2016-03-01 03:19:492797
lfgdb5c4ed2016-03-04 23:09:072798 RenderWidgetHostViewBase* rwhv =
2799 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
2800 if (rwhv) {
2801 SendPageMessage(new PageMsg_UpdateWindowScreenRect(
2802 MSG_ROUTING_NONE, rwhv->GetBoundsInRootWindow()));
2803 }
2804
avallee9f43b012016-11-26 07:02:102805 if (browser_plugin_embedder_ && !is_being_destroyed_)
[email protected]a7568e62013-06-14 07:50:442806 browser_plugin_embedder_->DidSendScreenRects();
[email protected]32deec62013-05-15 23:55:042807}
2808
ekaramadadd882292016-06-08 15:22:562809TextInputManager* WebContentsImpl::GetTextInputManager() {
2810 if (GetOuterWebContents())
2811 return GetOuterWebContents()->GetTextInputManager();
2812
2813 if (!text_input_manager_)
2814 text_input_manager_.reset(new TextInputManager());
2815
2816 return text_input_manager_.get();
2817}
2818
paulmeyer7f6f1d4f2016-11-15 00:00:272819bool WebContentsImpl::OnUpdateDragCursor() {
2820 if (browser_plugin_embedder_)
2821 return browser_plugin_embedder_->OnUpdateDragCursor();
2822 return false;
2823}
2824
kenrb11f213a2017-03-24 18:12:062825bool WebContentsImpl::IsWidgetForMainFrame(
2826 RenderWidgetHostImpl* render_widget_host) {
2827 return render_widget_host == GetMainFrame()->GetRenderWidgetHost();
2828}
2829
[email protected]95640212014-07-26 18:14:302830BrowserAccessibilityManager*
2831 WebContentsImpl::GetRootBrowserAccessibilityManager() {
creisc014b402015-04-23 16:41:452832 RenderFrameHostImpl* rfh = GetMainFrame();
2833 return rfh ? rfh->browser_accessibility_manager() : nullptr;
[email protected]95640212014-07-26 18:14:302834}
2835
2836BrowserAccessibilityManager*
2837 WebContentsImpl::GetOrCreateRootBrowserAccessibilityManager() {
creisc014b402015-04-23 16:41:452838 RenderFrameHostImpl* rfh = GetMainFrame();
2839 return rfh ? rfh->GetOrCreateBrowserAccessibilityManager() : nullptr;
[email protected]95640212014-07-26 18:14:302840}
2841
Dave Tapuskab336b922017-07-06 19:24:052842void WebContentsImpl::ExecuteEditCommand(
2843 const std::string& command,
2844 const base::Optional<base::string16>& value) {
2845 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
2846 if (!focused_frame)
2847 return;
2848
2849 focused_frame->GetFrameInputHandler()->ExecuteEditCommand(command, value);
2850}
2851
mohsen7ab1ec16ec2015-07-02 18:26:232852void WebContentsImpl::MoveRangeSelectionExtent(const gfx::Point& extent) {
Dave Tapuskab336b922017-07-06 19:24:052853 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
mohsen7ab1ec16ec2015-07-02 18:26:232854 if (!focused_frame)
2855 return;
2856
dtapuska9d46ef7d2017-05-26 19:06:062857 focused_frame->GetFrameInputHandler()->MoveRangeSelectionExtent(extent);
mohsen7ab1ec16ec2015-07-02 18:26:232858}
2859
2860void WebContentsImpl::SelectRange(const gfx::Point& base,
2861 const gfx::Point& extent) {
Dave Tapuskab336b922017-07-06 19:24:052862 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
mohsen7ab1ec16ec2015-07-02 18:26:232863 if (!focused_frame)
2864 return;
2865
dtapuska9d46ef7d2017-05-26 19:06:062866 focused_frame->GetFrameInputHandler()->SelectRange(base, extent);
mohsen7ab1ec16ec2015-07-02 18:26:232867}
2868
Dave Tapuskab336b922017-07-06 19:24:052869void WebContentsImpl::MoveCaret(const gfx::Point& extent) {
2870 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
2871 if (!focused_frame)
2872 return;
2873
2874 focused_frame->GetFrameInputHandler()->MoveCaret(extent);
2875}
2876
Shimi Zhang37deeb22017-09-28 00:59:012877void WebContentsImpl::AdjustSelectionByCharacterOffset(
2878 int start_adjust,
2879 int end_adjust,
2880 bool show_selection_menu) {
Dave Tapuskab336b922017-07-06 19:24:052881 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
aurimasab0319022015-07-10 21:57:382882 if (!focused_frame)
2883 return;
2884
Shimi Zhang37deeb22017-09-28 00:59:012885 using blink::mojom::SelectionMenuBehavior;
dtapuska9d46ef7d2017-05-26 19:06:062886 focused_frame->GetFrameInputHandler()->AdjustSelectionByCharacterOffset(
Shimi Zhang37deeb22017-09-28 00:59:012887 start_adjust, end_adjust,
2888 show_selection_menu ? SelectionMenuBehavior::kShow
2889 : SelectionMenuBehavior::kHide);
aurimasab0319022015-07-10 21:57:382890}
2891
[email protected]b172aee2012-04-10 17:05:262892void WebContentsImpl::UpdatePreferredSize(const gfx::Size& pref_size) {
[email protected]222f5822014-02-05 23:40:492893 const gfx::Size old_size = GetPreferredSize();
[email protected]bcd2815602012-01-14 18:17:232894 preferred_size_ = pref_size;
[email protected]222f5822014-02-05 23:40:492895 OnPreferredSizeChanged(old_size);
[email protected]0548c5352011-09-07 00:33:332896}
2897
avic3aa8422015-11-09 20:57:222898void WebContentsImpl::ResizeDueToAutoResize(
2899 RenderWidgetHostImpl* render_widget_host,
2900 const gfx::Size& new_size) {
2901 if (render_widget_host != GetRenderViewHost()->GetWidget())
2902 return;
2903
kenrbe4f91082017-06-02 20:32:082904 auto_resize_size_ = new_size;
2905
2906 // Out-of-process iframe visible viewport sizes usually come from the
2907 // top-level RenderWidgetHostView, but when auto-resize is enabled on the
2908 // top frame then that size is used instead.
2909 for (FrameTreeNode* node : frame_tree_.Nodes()) {
2910 if (node->current_frame_host()->is_local_root()) {
2911 RenderWidgetHostImpl* host =
2912 node->current_frame_host()->GetRenderWidgetHost();
2913 if (host != render_widget_host)
2914 host->WasResized();
2915 }
2916 }
2917
[email protected]61e2b3cc2012-03-02 16:13:342918 if (delegate_)
2919 delegate_->ResizeDueToAutoResize(this, new_size);
2920}
2921
kenrbe4f91082017-06-02 20:32:082922gfx::Size WebContentsImpl::GetAutoResizeSize() {
2923 return auto_resize_size_;
2924}
2925
2926void WebContentsImpl::ResetAutoResizeSize() {
2927 auto_resize_size_ = gfx::Size();
2928}
2929
[email protected]b172aee2012-04-10 17:05:262930WebContents* WebContentsImpl::OpenURL(const OpenURLParams& params) {
[email protected]e5d549d2011-12-28 01:29:202931 if (!delegate_)
2932 return NULL;
[email protected]00c37fc2011-08-02 00:22:502933
[email protected]e5d549d2011-12-28 01:29:202934 WebContents* new_contents = delegate_->OpenURLFromTab(this, params);
pnoland488944652017-02-22 18:58:542935
2936 RenderFrameHost* source_render_frame_host = RenderFrameHost::FromID(
2937 params.source_render_process_id, params.source_render_frame_id);
2938
2939 if (source_render_frame_host && params.source_site_instance) {
2940 CHECK_EQ(source_render_frame_host->GetSiteInstance(),
2941 params.source_site_instance.get());
2942 }
2943
2944 if (new_contents && source_render_frame_host && new_contents != this) {
2945 for (auto& observer : observers_) {
2946 observer.DidOpenRequestedURL(new_contents, source_render_frame_host,
2947 params.url, params.referrer,
2948 params.disposition, params.transition,
pnolandaae574e2017-03-06 21:04:212949 params.started_from_context_menu, false);
pnoland488944652017-02-22 18:58:542950 }
2951 }
2952
[email protected]e5d549d2011-12-28 01:29:202953 return new_contents;
[email protected]d5f942ba2008-09-26 19:30:342954}
2955
[email protected]a86c0e962013-12-17 17:10:392956void WebContentsImpl::RenderFrameForInterstitialPageCreated(
2957 RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:092958 for (auto& observer : observers_)
2959 observer.RenderFrameForInterstitialPageCreated(render_frame_host);
[email protected]ba45bfd2012-05-22 21:51:442960}
2961
[email protected]20ca0382013-02-28 19:50:072962void WebContentsImpl::AttachInterstitialPage(
2963 InterstitialPageImpl* interstitial_page) {
creisadca9862017-06-16 19:12:112964 DCHECK(!interstitial_page_ && interstitial_page);
2965 interstitial_page_ = interstitial_page;
[email protected]90fb08ed2013-09-24 17:43:292966
2967 // Cancel any visible dialogs so that they don't interfere with the
2968 // interstitial.
creis89a0f782015-05-27 16:13:172969 CancelActiveAndPendingDialogs();
[email protected]90fb08ed2013-09-24 17:43:292970
ericwilligersde386342016-10-19 02:35:092971 for (auto& observer : observers_)
2972 observer.DidAttachInterstitialPage();
clamy44e84ce2016-02-22 15:38:252973
2974 // Stop the throbber if needed while the interstitial page is shown.
2975 if (frame_tree_.IsLoading())
2976 LoadingStateChanged(true, true, nullptr);
lfg1453e412017-04-11 00:48:502977
2978 // Connect to outer WebContents if necessary.
2979 if (node_.OuterContentsFrameTreeNode()) {
2980 if (GetRenderManager()->GetProxyToOuterDelegate()) {
2981 DCHECK(
2982 static_cast<RenderWidgetHostViewBase*>(interstitial_page->GetView())
2983 ->IsRenderWidgetHostViewChildFrame());
2984 RenderWidgetHostViewChildFrame* view =
2985 static_cast<RenderWidgetHostViewChildFrame*>(
2986 interstitial_page->GetView());
2987 GetRenderManager()->SetRWHViewForInnerContents(view);
2988 }
2989 }
Bo Liu7c6779e92017-08-16 02:02:282990
Bo Liu168c8642017-08-28 18:26:022991#if defined(OS_ANDROID)
Bo Liu7c6779e92017-08-16 02:02:282992 // Update importance of the interstitial.
2993 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
2994 ->GetRenderWidgetHost()
2995 ->SetImportance(GetMainFrame()->GetRenderWidgetHost()->importance());
Bo Liu168c8642017-08-28 18:26:022996#endif
clamy44e84ce2016-02-22 15:38:252997}
2998
2999void WebContentsImpl::DidProceedOnInterstitial() {
3000 // The interstitial page should no longer be pausing the throbber.
creisadca9862017-06-16 19:12:113001 DCHECK(!(ShowingInterstitialPage() && interstitial_page_->pause_throbber()));
clamy44e84ce2016-02-22 15:38:253002
3003 // Restart the throbber now that the interstitial page no longer pauses it.
3004 if (ShowingInterstitialPage() && frame_tree_.IsLoading())
3005 LoadingStateChanged(true, true, nullptr);
[email protected]20ca0382013-02-28 19:50:073006}
3007
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043008void WebContentsImpl::DetachInterstitialPage(bool has_focus) {
Lucas Furukawa Gadani69b609192017-07-10 17:08:343009 bool interstitial_pausing_throbber =
3010 ShowingInterstitialPage() && interstitial_page_->pause_throbber();
3011 if (ShowingInterstitialPage())
3012 interstitial_page_ = nullptr;
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043013
3014 // If the focus was on the interstitial, let's keep it to the page.
3015 // (Note that in unit-tests the RVH may not have a view).
3016 if (has_focus && GetRenderViewHost()->GetWidget()->GetView())
3017 GetRenderViewHost()->GetWidget()->GetView()->Focus();
3018
Lucas Furukawa Gadani69b609192017-07-10 17:08:343019 for (auto& observer : observers_)
3020 observer.DidDetachInterstitialPage();
3021
3022 // Disconnect from outer WebContents if necessary. This must happen after the
3023 // interstitial page is cleared above, since the call to
3024 // SetRWHViewForInnerContents below may loop over all the
3025 // RenderWidgetHostViews in the tree (otherwise, including the now-deleted
3026 // view for the interstitial).
lfg1453e412017-04-11 00:48:503027 if (node_.OuterContentsFrameTreeNode()) {
3028 if (GetRenderManager()->GetProxyToOuterDelegate()) {
3029 DCHECK(static_cast<RenderWidgetHostViewBase*>(
3030 GetRenderManager()->current_frame_host()->GetView())
3031 ->IsRenderWidgetHostViewChildFrame());
3032 RenderWidgetHostViewChildFrame* view =
3033 static_cast<RenderWidgetHostViewChildFrame*>(
3034 GetRenderManager()->current_frame_host()->GetView());
3035 GetRenderManager()->SetRWHViewForInnerContents(view);
3036 }
3037 }
3038
clamy44e84ce2016-02-22 15:38:253039 // Restart the throbber if needed now that the interstitial page is going
3040 // away.
3041 if (interstitial_pausing_throbber && frame_tree_.IsLoading())
3042 LoadingStateChanged(true, true, nullptr);
[email protected]20ca0382013-02-28 19:50:073043}
3044
avi2b177592014-12-10 02:08:023045void WebContentsImpl::SetHistoryOffsetAndLength(int history_offset,
3046 int history_length) {
alexmos136fd6e62016-08-15 20:58:413047 SendPageMessage(new PageMsg_SetHistoryOffsetAndLength(
3048 MSG_ROUTING_NONE, history_offset, history_length));
avi2b177592014-12-10 02:08:023049}
3050
3051void WebContentsImpl::SetHistoryOffsetAndLengthForView(
3052 RenderViewHost* render_view_host,
3053 int history_offset,
3054 int history_length) {
alexmos136fd6e62016-08-15 20:58:413055 render_view_host->Send(new PageMsg_SetHistoryOffsetAndLength(
avi2b177592014-12-10 02:08:023056 render_view_host->GetRoutingID(), history_offset, history_length));
[email protected]796931a92011-08-10 01:32:143057}
3058
toyoshim24a4c7ab2016-04-05 09:24:143059void WebContentsImpl::ReloadFocusedFrame(bool bypass_cache) {
[email protected]1f3fc1d2014-04-03 14:50:173060 RenderFrameHost* focused_frame = GetFocusedFrame();
3061 if (!focused_frame)
3062 return;
3063
[email protected]959be4c2014-04-08 15:01:333064 focused_frame->Send(new FrameMsg_Reload(
toyoshim24a4c7ab2016-04-05 09:24:143065 focused_frame->GetRoutingID(), bypass_cache));
[email protected]959be4c2014-04-08 15:01:333066}
3067
megjablon3f5941072016-02-04 23:27:523068void WebContentsImpl::ReloadLoFiImages() {
3069 SendToAllFrames(new FrameMsg_ReloadLoFiImages(MSG_ROUTING_NONE));
3070}
3071
[email protected]959be4c2014-04-08 15:01:333072void WebContentsImpl::Undo() {
Dave Tapuskab336b922017-07-06 19:24:053073 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333074 if (!focused_frame)
3075 return;
3076
dtapuska9d46ef7d2017-05-26 19:06:063077 focused_frame->GetFrameInputHandler()->Undo();
[email protected]959be4c2014-04-08 15:01:333078 RecordAction(base::UserMetricsAction("Undo"));
3079}
3080
3081void WebContentsImpl::Redo() {
Dave Tapuskab336b922017-07-06 19:24:053082 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333083 if (!focused_frame)
3084 return;
dtapuska9d46ef7d2017-05-26 19:06:063085 focused_frame->GetFrameInputHandler()->Redo();
[email protected]959be4c2014-04-08 15:01:333086 RecordAction(base::UserMetricsAction("Redo"));
3087}
3088
3089void WebContentsImpl::Cut() {
Dave Tapuskab336b922017-07-06 19:24:053090 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333091 if (!focused_frame)
3092 return;
3093
dtapuska9d46ef7d2017-05-26 19:06:063094 focused_frame->GetFrameInputHandler()->Cut();
[email protected]959be4c2014-04-08 15:01:333095 RecordAction(base::UserMetricsAction("Cut"));
3096}
3097
3098void WebContentsImpl::Copy() {
Dave Tapuskab336b922017-07-06 19:24:053099 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333100 if (!focused_frame)
3101 return;
3102
dtapuska9d46ef7d2017-05-26 19:06:063103 focused_frame->GetFrameInputHandler()->Copy();
[email protected]959be4c2014-04-08 15:01:333104 RecordAction(base::UserMetricsAction("Copy"));
3105}
3106
3107void WebContentsImpl::CopyToFindPboard() {
3108#if defined(OS_MACOSX)
Dave Tapuskab336b922017-07-06 19:24:053109 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333110 if (!focused_frame)
3111 return;
3112
3113 // Windows/Linux don't have the concept of a find pasteboard.
dtapuska9d46ef7d2017-05-26 19:06:063114 focused_frame->GetFrameInputHandler()->CopyToFindPboard();
[email protected]959be4c2014-04-08 15:01:333115 RecordAction(base::UserMetricsAction("CopyToFindPboard"));
3116#endif
3117}
3118
3119void WebContentsImpl::Paste() {
Dave Tapuskab336b922017-07-06 19:24:053120 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333121 if (!focused_frame)
3122 return;
3123
dtapuska9d46ef7d2017-05-26 19:06:063124 focused_frame->GetFrameInputHandler()->Paste();
[email protected]959be4c2014-04-08 15:01:333125 RecordAction(base::UserMetricsAction("Paste"));
3126}
3127
3128void WebContentsImpl::PasteAndMatchStyle() {
Dave Tapuskab336b922017-07-06 19:24:053129 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333130 if (!focused_frame)
3131 return;
3132
dtapuska9d46ef7d2017-05-26 19:06:063133 focused_frame->GetFrameInputHandler()->PasteAndMatchStyle();
[email protected]959be4c2014-04-08 15:01:333134 RecordAction(base::UserMetricsAction("PasteAndMatchStyle"));
3135}
3136
3137void WebContentsImpl::Delete() {
Dave Tapuskab336b922017-07-06 19:24:053138 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333139 if (!focused_frame)
3140 return;
3141
dtapuska9d46ef7d2017-05-26 19:06:063142 focused_frame->GetFrameInputHandler()->Delete();
[email protected]959be4c2014-04-08 15:01:333143 RecordAction(base::UserMetricsAction("DeleteSelection"));
3144}
3145
3146void WebContentsImpl::SelectAll() {
Dave Tapuskab336b922017-07-06 19:24:053147 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333148 if (!focused_frame)
3149 return;
3150
dtapuska9d46ef7d2017-05-26 19:06:063151 focused_frame->GetFrameInputHandler()->SelectAll();
[email protected]959be4c2014-04-08 15:01:333152 RecordAction(base::UserMetricsAction("SelectAll"));
3153}
3154
yabinh351e7ec2017-03-10 02:43:243155void WebContentsImpl::CollapseSelection() {
Dave Tapuskab336b922017-07-06 19:24:053156 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333157 if (!focused_frame)
3158 return;
3159
dtapuska9d46ef7d2017-05-26 19:06:063160 focused_frame->GetFrameInputHandler()->CollapseSelection();
[email protected]1f3fc1d2014-04-03 14:50:173161}
3162
3163void WebContentsImpl::Replace(const base::string16& word) {
Dave Tapuskab336b922017-07-06 19:24:053164 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]1f3fc1d2014-04-03 14:50:173165 if (!focused_frame)
3166 return;
3167
dtapuska9d46ef7d2017-05-26 19:06:063168 focused_frame->GetFrameInputHandler()->Replace(word);
[email protected]1f3fc1d2014-04-03 14:50:173169}
3170
3171void WebContentsImpl::ReplaceMisspelling(const base::string16& word) {
Dave Tapuskab336b922017-07-06 19:24:053172 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]1f3fc1d2014-04-03 14:50:173173 if (!focused_frame)
3174 return;
3175
dtapuska9d46ef7d2017-05-26 19:06:063176 focused_frame->GetFrameInputHandler()->ReplaceMisspelling(word);
[email protected]959be4c2014-04-08 15:01:333177}
3178
3179void WebContentsImpl::NotifyContextMenuClosed(
3180 const CustomContextMenuContext& context) {
3181 RenderFrameHost* focused_frame = GetFocusedFrame();
3182 if (!focused_frame)
3183 return;
3184
3185 focused_frame->Send(new FrameMsg_ContextMenuClosed(
3186 focused_frame->GetRoutingID(), context));
3187}
3188
3189void WebContentsImpl::ExecuteCustomContextMenuCommand(
3190 int action, const CustomContextMenuContext& context) {
3191 RenderFrameHost* focused_frame = GetFocusedFrame();
3192 if (!focused_frame)
3193 return;
3194
3195 focused_frame->Send(new FrameMsg_CustomContextMenuAction(
3196 focused_frame->GetRoutingID(), context, action));
[email protected]4fed3702014-04-01 09:08:003197}
3198
[email protected]fc2b46b2014-05-03 16:33:453199gfx::NativeView WebContentsImpl::GetNativeView() {
3200 return view_->GetNativeView();
3201}
3202
3203gfx::NativeView WebContentsImpl::GetContentNativeView() {
3204 return view_->GetContentNativeView();
3205}
3206
3207gfx::NativeWindow WebContentsImpl::GetTopLevelNativeWindow() {
3208 return view_->GetTopLevelNativeWindow();
3209}
3210
3211gfx::Rect WebContentsImpl::GetViewBounds() {
3212 return view_->GetViewBounds();
3213}
3214
3215gfx::Rect WebContentsImpl::GetContainerBounds() {
3216 gfx::Rect rv;
3217 view_->GetContainerBounds(&rv);
3218 return rv;
3219}
3220
3221DropData* WebContentsImpl::GetDropData() {
3222 return view_->GetDropData();
3223}
3224
3225void WebContentsImpl::Focus() {
miu9e14e492014-10-25 02:39:043226 view_->Focus();
[email protected]fc2b46b2014-05-03 16:33:453227}
3228
3229void WebContentsImpl::SetInitialFocus() {
miu9e14e492014-10-25 02:39:043230 view_->SetInitialFocus();
[email protected]fc2b46b2014-05-03 16:33:453231}
3232
3233void WebContentsImpl::StoreFocus() {
miu9e14e492014-10-25 02:39:043234 view_->StoreFocus();
[email protected]fc2b46b2014-05-03 16:33:453235}
3236
3237void WebContentsImpl::RestoreFocus() {
miu9e14e492014-10-25 02:39:043238 view_->RestoreFocus();
[email protected]fc2b46b2014-05-03 16:33:453239}
3240
[email protected]b172aee2012-04-10 17:05:263241void WebContentsImpl::FocusThroughTabTraversal(bool reverse) {
[email protected]0bfbf882011-12-22 18:19:273242 if (ShowingInterstitialPage()) {
creisadca9862017-06-16 19:12:113243 interstitial_page_->FocusThroughTabTraversal(reverse);
[email protected]7e383692009-06-12 19:14:543244 return;
3245 }
[email protected]0b431992014-06-24 00:08:033246 RenderWidgetHostView* const fullscreen_view =
3247 GetFullscreenRenderWidgetHostView();
3248 if (fullscreen_view) {
3249 fullscreen_view->Focus();
3250 return;
3251 }
creisc014b402015-04-23 16:41:453252 GetRenderViewHost()->SetInitialFocus(reverse);
[email protected]96d185d2009-04-24 03:28:543253}
3254
[email protected]b172aee2012-04-10 17:05:263255bool WebContentsImpl::ShowingInterstitialPage() const {
creisadca9862017-06-16 19:12:113256 return interstitial_page_ != nullptr;
[email protected]96d185d2009-04-24 03:28:543257}
3258
Pete Williamson89aa1402017-07-07 19:58:413259void WebContentsImpl::AdjustPreviewsStateForNavigation(
3260 PreviewsState* previews_state) {
3261 if (delegate_)
3262 delegate_->AdjustPreviewsStateForNavigation(previews_state);
3263}
3264
[email protected]b172aee2012-04-10 17:05:263265InterstitialPage* WebContentsImpl::GetInterstitialPage() const {
creisadca9862017-06-16 19:12:113266 return interstitial_page_;
[email protected]686493142011-07-15 21:47:223267}
3268
[email protected]b172aee2012-04-10 17:05:263269bool WebContentsImpl::IsSavable() {
[email protected]a53209b2012-01-20 16:48:163270 // WebKit creates Document object when MIME type is application/xhtml+xml,
3271 // so we also support this MIME type.
3272 return contents_mime_type_ == "text/html" ||
3273 contents_mime_type_ == "text/xml" ||
3274 contents_mime_type_ == "application/xhtml+xml" ||
3275 contents_mime_type_ == "text/plain" ||
3276 contents_mime_type_ == "text/css" ||
Kinuko Yasuda74702f92017-07-31 03:27:533277 blink::IsSupportedJavascriptMimeType(contents_mime_type_);
[email protected]a53209b2012-01-20 16:48:163278}
3279
[email protected]b172aee2012-04-10 17:05:263280void WebContentsImpl::OnSavePage() {
[email protected]c7dd2f62011-07-18 15:57:593281 // If we can not save the page, try to download it.
[email protected]a53209b2012-01-20 16:48:163282 if (!IsSavable()) {
[email protected]35869622012-10-26 23:23:553283 RecordDownloadSource(INITIATED_BY_SAVE_PACKAGE_ON_NON_HTML);
nasko89ad7742015-03-05 22:14:193284 SaveFrame(GetLastCommittedURL(), Referrer());
[email protected]27678b2a2012-02-04 22:09:143285 return;
[email protected]c7dd2f62011-07-18 15:57:593286 }
3287
3288 Stop();
3289
3290 // Create the save package and possibly prompt the user for the name to save
3291 // the page as. The user prompt is an asynchronous operation that runs on
3292 // another thread.
3293 save_package_ = new SavePackage(this);
3294 save_package_->GetSaveInfo();
3295}
3296
3297// Used in automated testing to bypass prompting the user for file names.
3298// Instead, the names and paths are hard coded rather than running them through
3299// file name sanitation and extension / mime checking.
[email protected]2dec8ec2013-02-07 19:20:343300bool WebContentsImpl::SavePage(const base::FilePath& main_file,
3301 const base::FilePath& dir_path,
[email protected]8ff00d72012-10-23 19:12:213302 SavePageType save_type) {
[email protected]c7dd2f62011-07-18 15:57:593303 // Stop the page from navigating.
3304 Stop();
3305
3306 save_package_ = new SavePackage(this, save_type, main_file, dir_path);
[email protected]8ff00d72012-10-23 19:12:213307 return save_package_->Init(SavePackageDownloadCreatedCallback());
[email protected]c7dd2f62011-07-18 15:57:593308}
3309
[email protected]3c71576ce2013-07-23 02:00:013310void WebContentsImpl::SaveFrame(const GURL& url,
3311 const Referrer& referrer) {
kundaji6c7f9692015-03-09 18:00:373312 SaveFrameWithHeaders(url, referrer, std::string());
3313}
3314
3315void WebContentsImpl::SaveFrameWithHeaders(const GURL& url,
3316 const Referrer& referrer,
3317 const std::string& headers) {
nasko89ad7742015-03-05 22:14:193318 if (!GetLastCommittedURL().is_valid())
[email protected]3c71576ce2013-07-23 02:00:013319 return;
sammc92af61552014-11-19 23:27:403320 if (delegate_ && delegate_->SaveFrame(url, referrer))
3321 return;
3322
nasko89ad7742015-03-05 22:14:193323 // TODO(nasko): This check for main frame is incorrect and should be fixed
brettw760f7442016-05-23 21:19:223324 // by explicitly passing in which frame this method should target. This would
3325 // indicate whether it's the main frame, and also tell us the frame pointer
3326 // to use for routing.
nasko89ad7742015-03-05 22:14:193327 bool is_main_frame = (url == GetLastCommittedURL());
brettw760f7442016-05-23 21:19:223328 RenderFrameHost* frame_host = GetMainFrame();
[email protected]3c71576ce2013-07-23 02:00:013329
brettw760f7442016-05-23 21:19:223330 StoragePartition* storage_partition = BrowserContext::GetStoragePartition(
3331 GetBrowserContext(), frame_host->GetSiteInstance());
avib7348942015-12-25 20:57:103332 int64_t post_id = -1;
[email protected]3c71576ce2013-07-23 02:00:013333 if (is_main_frame) {
[email protected]6286a372013-10-09 04:03:273334 const NavigationEntry* entry = controller_.GetLastCommittedEntry();
[email protected]3c71576ce2013-07-23 02:00:013335 if (entry)
3336 post_id = entry->GetPostID();
3337 }
Ramin Halavati24e21012017-07-10 12:56:063338 net::NetworkTrafficAnnotationTag traffic_annotation =
3339 net::DefineNetworkTrafficAnnotation("download_web_contents_frame", R"(
3340 semantics {
3341 sender: "Save Page Action"
3342 description:
3343 "Saves the given frame's URL to the local file system."
3344 trigger:
3345 "The user has triggered a save operation on the frame through a "
3346 "context menu or other mechanism."
3347 data: "None."
3348 destination: WEBSITE
3349 }
3350 policy {
Ramin Halavati3b979782017-07-21 11:40:263351 cookies_allowed: YES
Ramin Halavati24e21012017-07-10 12:56:063352 cookies_store: "user"
3353 setting:
3354 "This feature cannot be disabled by settings, but it's is only "
3355 "triggered by user request."
3356 policy_exception_justification: "Not implemented."
3357 })");
thestig859c78892017-05-15 21:17:063358 auto params = base::MakeUnique<DownloadUrlParameters>(
brettw760f7442016-05-23 21:19:223359 url, frame_host->GetProcess()->GetID(),
3360 frame_host->GetRenderViewHost()->GetRoutingID(),
Ramin Halavati03efa732017-06-12 09:28:203361 frame_host->GetRoutingID(), storage_partition->GetURLRequestContext(),
Ramin Halavati24e21012017-07-10 12:56:063362 traffic_annotation);
[email protected]3c71576ce2013-07-23 02:00:013363 params->set_referrer(referrer);
3364 params->set_post_id(post_id);
[email protected]3c71576ce2013-07-23 02:00:013365 if (post_id >= 0)
3366 params->set_method("POST");
3367 params->set_prompt(true);
kundaji6c7f9692015-03-09 18:00:373368
3369 if (headers.empty()) {
3370 params->set_prefer_cache(true);
3371 } else {
Megan Jablonski2f6a4c52017-07-10 23:01:253372 for (DownloadUrlParameters::RequestHeadersNameValuePair key_value :
3373 ParseDownloadHeaders(headers)) {
3374 params->add_request_header(key_value.first, key_value.second);
kundaji6c7f9692015-03-09 18:00:373375 }
3376 }
thestig859c78892017-05-15 21:17:063377 BrowserContext::GetDownloadManager(GetBrowserContext())
Ramin Halavati03efa732017-06-12 09:28:203378 ->DownloadUrl(std::move(params));
[email protected]3c71576ce2013-07-23 02:00:013379}
3380
[email protected]b172aee2012-04-10 17:05:263381void WebContentsImpl::GenerateMHTML(
dewittj6dc5747a2016-05-17 01:48:473382 const MHTMLGenerationParams& params,
avib7348942015-12-25 20:57:103383 const base::Callback<void(int64_t)>& callback) {
dewittj6dc5747a2016-05-17 01:48:473384 MHTMLGenerationManager::GetInstance()->SaveMHTML(this, params, callback);
[email protected]aa4f3972012-03-01 18:12:123385}
3386
[email protected]b172aee2012-04-10 17:05:263387const std::string& WebContentsImpl::GetContentsMimeType() const {
[email protected]0bfbf882011-12-22 18:19:273388 return contents_mime_type_;
3389}
3390
[email protected]b172aee2012-04-10 17:05:263391bool WebContentsImpl::WillNotifyDisconnection() const {
[email protected]0bfbf882011-12-22 18:19:273392 return notify_disconnection_;
3393}
3394
[email protected]8ff00d72012-10-23 19:12:213395RendererPreferences* WebContentsImpl::GetMutableRendererPrefs() {
[email protected]0bfbf882011-12-22 18:19:273396 return &renderer_preferences_;
3397}
3398
[email protected]e35ccd52012-05-23 16:22:473399void WebContentsImpl::Close() {
3400 Close(GetRenderViewHost());
3401}
3402
paulmeyer8fc8ea92016-11-15 05:12:213403void WebContentsImpl::DragSourceEndedAt(int client_x,
3404 int client_y,
3405 int screen_x,
3406 int screen_y,
Paul Meyer0c58c3712016-11-17 22:59:513407 blink::WebDragOperation operation,
3408 RenderWidgetHost* source_rwh) {
[email protected]cf200a562013-05-03 16:24:293409 if (browser_plugin_embedder_.get())
paulmeyer8fc8ea92016-11-15 05:12:213410 browser_plugin_embedder_->DragSourceEndedAt(
3411 client_x, client_y, screen_x, screen_y, operation);
Paul Meyer0c58c3712016-11-17 22:59:513412 if (source_rwh) {
3413 source_rwh->DragSourceEndedAt(gfx::Point(client_x, client_y),
3414 gfx::Point(screen_x, screen_y),
3415 operation);
3416 }
[email protected]cf200a562013-05-03 16:24:293417}
3418
jam73f892642016-09-11 06:04:063419void WebContentsImpl::LoadStateChanged(
3420 const GURL& url,
3421 const net::LoadStateWithParam& load_state,
3422 uint64_t upload_position,
3423 uint64_t upload_size) {
jam73f892642016-09-11 06:04:063424 load_state_ = load_state;
3425 upload_position_ = upload_position;
3426 upload_size_ = upload_size;
3427 load_state_host_ = url_formatter::IDNToUnicode(url.host());
3428 if (load_state_.state == net::LOAD_STATE_READING_RESPONSE)
3429 SetNotWaitingForResponse();
3430 if (IsLoading()) {
3431 NotifyNavigationStateChanged(static_cast<InvalidateTypes>(
3432 INVALIDATE_TYPE_LOAD | INVALIDATE_TYPE_TAB));
3433 }
3434}
3435
[email protected]d60f3702013-12-26 16:30:243436void WebContentsImpl::DidGetResourceResponseStart(
3437 const ResourceRequestDetails& details) {
Evan Stade38e4aee62017-08-23 17:06:183438 SetNotWaitingForResponse();
estarkf83ac122016-10-05 19:06:063439 controller_.ssl_manager()->DidStartResourceResponse(
3440 details.url, details.has_certificate, details.ssl_cert_status);
[email protected]d60f3702013-12-26 16:30:243441
ericwilligersde386342016-10-19 02:35:093442 for (auto& observer : observers_)
3443 observer.DidGetResourceResponseStart(details);
[email protected]d60f3702013-12-26 16:30:243444}
3445
3446void WebContentsImpl::DidGetRedirectForResourceRequest(
[email protected]d60f3702013-12-26 16:30:243447 const ResourceRedirectDetails& details) {
ericwilligersde386342016-10-19 02:35:093448 for (auto& observer : observers_)
3449 observer.DidGetRedirectForResourceRequest(details);
[email protected]d60f3702013-12-26 16:30:243450}
3451
Michael Thiessen896405db2017-07-20 17:52:323452void WebContentsImpl::NotifyWebContentsFocused(
3453 RenderWidgetHost* render_widget_host) {
ericwilligersde386342016-10-19 02:35:093454 for (auto& observer : observers_)
Michael Thiessen896405db2017-07-20 17:52:323455 observer.OnWebContentsFocused(render_widget_host);
calamity7fe55ce2015-04-10 03:59:373456}
3457
Michael Thiessen896405db2017-07-20 17:52:323458void WebContentsImpl::NotifyWebContentsLostFocus(
3459 RenderWidgetHost* render_widget_host) {
zijiehe3bee08e22017-05-17 04:14:463460 for (auto& observer : observers_)
Michael Thiessen896405db2017-07-20 17:52:323461 observer.OnWebContentsLostFocus(render_widget_host);
zijiehe3bee08e22017-05-17 04:14:463462}
3463
Paul Meyer0c58c3712016-11-17 22:59:513464void WebContentsImpl::SystemDragEnded(RenderWidgetHost* source_rwh) {
3465 if (source_rwh)
3466 source_rwh->DragSourceSystemDragEnded();
[email protected]cf200a562013-05-03 16:24:293467 if (browser_plugin_embedder_.get())
3468 browser_plugin_embedder_->SystemDragEnded();
[email protected]7813bd72011-02-05 02:19:343469}
3470
[email protected]e35ccd52012-05-23 16:22:473471void WebContentsImpl::UserGestureDone() {
dominickn9c7ceaa32016-02-27 01:52:533472 OnUserInteraction(GetRenderViewHost()->GetWidget(),
Blink Reformat1c4d759e2017-04-09 16:34:543473 blink::WebInputEvent::kUndefined);
[email protected]e35ccd52012-05-23 16:22:473474}
3475
[email protected]b172aee2012-04-10 17:05:263476void WebContentsImpl::SetClosedByUserGesture(bool value) {
[email protected]0bfbf882011-12-22 18:19:273477 closed_by_user_gesture_ = value;
3478}
3479
[email protected]b172aee2012-04-10 17:05:263480bool WebContentsImpl::GetClosedByUserGesture() const {
[email protected]0bfbf882011-12-22 18:19:273481 return closed_by_user_gesture_;
3482}
3483
[email protected]b172aee2012-04-10 17:05:263484void WebContentsImpl::ViewSource() {
[email protected]1788e772010-12-15 16:40:503485 if (!delegate_)
3486 return;
3487
[email protected]6286a372013-10-09 04:03:273488 NavigationEntry* entry = GetController().GetLastCommittedEntry();
3489 if (!entry)
[email protected]1788e772010-12-15 16:40:503490 return;
3491
[email protected]6286a372013-10-09 04:03:273492 delegate_->ViewSourceForTab(this, entry->GetURL());
[email protected]77d8d622010-12-15 10:30:123493}
3494
[email protected]b172aee2012-04-10 17:05:263495void WebContentsImpl::ViewFrameSource(const GURL& url,
[email protected]691aa2f2013-05-28 22:52:043496 const PageState& page_state) {
[email protected]932b7a12011-03-09 12:50:273497 if (!delegate_)
3498 return;
3499
[email protected]691aa2f2013-05-28 22:52:043500 delegate_->ViewSourceForFrame(this, url, page_state);
[email protected]932b7a12011-03-09 12:50:273501}
3502
[email protected]b172aee2012-04-10 17:05:263503int WebContentsImpl::GetMinimumZoomPercent() const {
[email protected]0bfbf882011-12-22 18:19:273504 return minimum_zoom_percent_;
3505}
3506
[email protected]b172aee2012-04-10 17:05:263507int WebContentsImpl::GetMaximumZoomPercent() const {
[email protected]0bfbf882011-12-22 18:19:273508 return maximum_zoom_percent_;
3509}
3510
mcnee432e47d2015-11-09 19:37:463511void WebContentsImpl::SetPageScale(float page_scale_factor) {
Lukasz Anforowiczf4357ca2017-09-07 01:43:323512 GetRenderViewHost()->Send(new ViewMsg_SetPageScale(
3513 GetRenderViewHost()->GetRoutingID(), page_scale_factor));
ccameronb7c1d6c2015-03-09 17:08:243514}
3515
[email protected]b172aee2012-04-10 17:05:263516gfx::Size WebContentsImpl::GetPreferredSize() const {
[email protected]222f5822014-02-05 23:40:493517 return capturer_count_ == 0 ? preferred_size_ : preferred_size_for_capture_;
[email protected]bcd2815602012-01-14 18:17:233518}
3519
[email protected]b172aee2012-04-10 17:05:263520bool WebContentsImpl::GotResponseToLockMouseRequest(bool allowed) {
lfgf0cd46e2017-01-04 00:05:233521 if (!GuestMode::IsCrossProcessFrameGuest(GetWebContents()) &&
3522 GetBrowserPluginGuest())
[email protected]660f18e2014-05-15 20:53:053523 return GetBrowserPluginGuest()->LockMouse(allowed);
3524
lfgf0cd46e2017-01-04 00:05:233525 if (mouse_lock_widget_) {
3526 if (mouse_lock_widget_->delegate()->GetAsWebContents() != this) {
3527 return mouse_lock_widget_->delegate()
3528 ->GetAsWebContents()
3529 ->GotResponseToLockMouseRequest(allowed);
3530 }
lfgad8244352016-07-13 16:55:513531
lfgf0cd46e2017-01-04 00:05:233532 if (mouse_lock_widget_->GotResponseToLockMouseRequest(allowed))
3533 return true;
3534 }
3535
3536 for (WebContentsImpl* current = this; current;
3537 current = current->GetOuterWebContents()) {
3538 current->mouse_lock_widget_ = nullptr;
3539 }
3540
lfgbee1e0a2016-06-08 21:24:213541 return false;
[email protected]0bfbf882011-12-22 18:19:273542}
3543
[email protected]b172aee2012-04-10 17:05:263544bool WebContentsImpl::HasOpener() const {
alexmose201c7cd2015-06-10 17:14:213545 return GetOpener() != NULL;
[email protected]a0358d72012-03-09 14:06:503546}
3547
lukasza6f8ac622017-06-06 03:10:203548RenderFrameHostImpl* WebContentsImpl::GetOpener() const {
alexmose201c7cd2015-06-10 17:14:213549 FrameTreeNode* opener_ftn = frame_tree_.root()->opener();
lukasza6f8ac622017-06-06 03:10:203550 return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
jochen55ff3502014-12-18 20:52:573551}
3552
jochen6004a362017-02-04 00:11:403553bool WebContentsImpl::HasOriginalOpener() const {
3554 return GetOriginalOpener() != NULL;
3555}
3556
lukasza6f8ac622017-06-06 03:10:203557RenderFrameHostImpl* WebContentsImpl::GetOriginalOpener() const {
jochen6004a362017-02-04 00:11:403558 FrameTreeNode* opener_ftn = frame_tree_.root()->original_opener();
lukasza6f8ac622017-06-06 03:10:203559 return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
jochen6004a362017-02-04 00:11:403560}
3561
[email protected]cb805452013-05-22 15:16:213562void WebContentsImpl::DidChooseColorInColorChooser(SkColor color) {
[email protected]8ed16472014-04-11 19:02:483563 if (!color_chooser_info_.get())
3564 return;
3565 RenderFrameHost* rfh = RenderFrameHost::FromID(
3566 color_chooser_info_->render_process_id,
3567 color_chooser_info_->render_frame_id);
3568 if (!rfh)
3569 return;
3570
3571 rfh->Send(new FrameMsg_DidChooseColorResponse(
3572 rfh->GetRoutingID(), color_chooser_info_->identifier, color));
[email protected]da8543762012-03-20 08:52:203573}
3574
[email protected]cb805452013-05-22 15:16:213575void WebContentsImpl::DidEndColorChooser() {
[email protected]8ed16472014-04-11 19:02:483576 if (!color_chooser_info_.get())
3577 return;
3578 RenderFrameHost* rfh = RenderFrameHost::FromID(
3579 color_chooser_info_->render_process_id,
3580 color_chooser_info_->render_frame_id);
3581 if (!rfh)
3582 return;
3583
3584 rfh->Send(new FrameMsg_DidEndColorChooser(
3585 rfh->GetRoutingID(), color_chooser_info_->identifier));
3586 color_chooser_info_.reset();
[email protected]da8543762012-03-20 08:52:203587}
3588
halton.huoca2eabd2015-07-06 08:17:403589int WebContentsImpl::DownloadImage(
3590 const GURL& url,
3591 bool is_favicon,
3592 uint32_t max_bitmap_size,
3593 bool bypass_cache,
3594 const WebContents::ImageDownloadCallback& callback) {
amistry9f01b772015-07-29 01:54:553595 DCHECK_CURRENTLY_ON(BrowserThread::UI);
halton.huoca2eabd2015-07-06 08:17:403596 static int next_image_download_id = 0;
leon.han6e9dee22016-02-25 03:44:063597 const content::mojom::ImageDownloaderPtr& mojo_image_downloader =
halton.huoca2eabd2015-07-06 08:17:403598 GetMainFrame()->GetMojoImageDownloader();
amistry9f01b772015-07-29 01:54:553599 const int download_id = ++next_image_download_id;
3600 if (!mojo_image_downloader) {
3601 // If the renderer process is dead (i.e. crash, or memory pressure on
3602 // Android), the downloader service will be invalid. Pre-Mojo, this would
3603 // hang the callback indefinetly since the IPC would be dropped. Now,
3604 // respond with a 400 HTTP error code to indicate that something went wrong.
3605 BrowserThread::PostTask(
3606 BrowserThread::UI, FROM_HERE,
tzike2aca992017-09-05 08:50:543607 base::BindOnce(&WebContentsImpl::OnDidDownloadImage,
3608 weak_factory_.GetWeakPtr(), callback, download_id, url,
3609 400, std::vector<SkBitmap>(), std::vector<gfx::Size>()));
amistry9f01b772015-07-29 01:54:553610 return download_id;
3611 }
3612
halton.huoca2eabd2015-07-06 08:17:403613 mojo_image_downloader->DownloadImage(
sammcf6f4fcf2016-06-21 05:39:393614 url, is_favicon, max_bitmap_size, bypass_cache,
tzike2aca992017-09-05 08:50:543615 base::BindOnce(&WebContentsImpl::OnDidDownloadImage,
3616 weak_factory_.GetWeakPtr(), callback, download_id, url));
amistry9f01b772015-07-29 01:54:553617 return download_id;
[email protected]795c28972012-12-06 06:13:393618}
3619
[email protected]5dcaf8e2013-12-28 01:31:423620bool WebContentsImpl::IsSubframe() const {
3621 return is_subframe_;
3622}
3623
[email protected]36ec24f2014-01-09 00:32:083624void WebContentsImpl::Find(int request_id,
3625 const base::string16& search_text,
3626 const blink::WebFindOptions& options) {
thestig6057a6b22015-11-12 23:01:333627 // Cowardly refuse to search for no text.
3628 if (search_text.empty()) {
3629 NOTREACHED();
3630 return;
3631 }
3632
paulmeyerc0b762b2016-04-13 11:55:173633 GetOrCreateFindRequestManager()->Find(request_id, search_text, options);
[email protected]36ec24f2014-01-09 00:32:083634}
3635
3636void WebContentsImpl::StopFinding(StopFindAction action) {
paulmeyerfeafc2d2017-04-25 21:46:403637 if (FindRequestManager* manager = GetFindRequestManager())
3638 manager->StopFinding(action);
[email protected]36ec24f2014-01-09 00:32:083639}
3640
dalecurtisbc6572e12014-09-12 19:22:303641bool WebContentsImpl::WasRecentlyAudible() {
wjmaclean1dabf3e32016-05-13 23:34:443642 return audio_stream_monitor_.WasRecentlyAudible() ||
3643 (browser_plugin_embedder_ &&
3644 browser_plugin_embedder_->WereAnyGuestsRecentlyAudible());
dalecurtisbc6572e12014-09-12 19:22:303645}
3646
mlamouriefdca9d2014-09-16 16:55:403647void WebContentsImpl::GetManifest(const GetManifestCallback& callback) {
Sam McNally2299ba02017-06-13 00:58:303648 manifest_manager_host_->GetManifest(callback);
mlamouriefdca9d2014-09-16 16:55:403649}
3650
bokanece34a82016-01-28 19:49:463651void WebContentsImpl::ExitFullscreen(bool will_cause_resize) {
mlamouri7a78d6fd2015-01-17 13:23:533652 // Clean up related state and initiate the fullscreen exit.
avi3627ecac2015-10-16 17:40:433653 GetRenderViewHost()->GetWidget()->RejectMouseLockOrUnlockIfNecessary();
bokanece34a82016-01-28 19:49:463654 ExitFullscreenMode(will_cause_resize);
mlamouri7a78d6fd2015-01-17 13:23:533655}
3656
mariakhomenko44bdc4732015-04-29 01:55:383657void WebContentsImpl::ResumeLoadingCreatedWebContents() {
mariakhomenkoa4971c12015-07-21 19:04:373658 if (delayed_open_url_params_.get()) {
3659 OpenURL(*delayed_open_url_params_.get());
3660 delayed_open_url_params_.reset(nullptr);
3661 return;
3662 }
3663
mariakhomenko44bdc4732015-04-29 01:55:383664 // Resume blocked requests for both the RenderViewHost and RenderFrameHost.
3665 // TODO(brettw): It seems bogus to reach into here and initialize the host.
dfalcantarae6b7b46752015-07-10 18:14:163666 if (is_resume_pending_) {
3667 is_resume_pending_ = false;
avi0f1bbc9712015-11-17 02:58:133668 GetRenderViewHost()->GetWidget()->Init();
dfalcantarae6b7b46752015-07-10 18:14:163669 GetMainFrame()->Init();
3670 }
mariakhomenko44bdc4732015-04-29 01:55:383671}
3672
[email protected]b172aee2012-04-10 17:05:263673bool WebContentsImpl::FocusLocationBarByDefault() {
palmerc70cb1f2016-03-04 23:41:263674 // When the browser is started with about:blank as the startup URL, focus
3675 // the location bar (which will also select its contents) so people can
3676 // simply begin typing to navigate elsewhere.
3677 //
3678 // We need to be careful not to trigger this for anything other than the
3679 // startup navigation. In particular, if we allow an attacker to open a
3680 // popup to about:blank, then navigate, focusing the Omnibox will cause the
3681 // end of the new URL to be scrolled into view instead of the start,
3682 // allowing the attacker to spoof other URLs. The conditions checked here
3683 // are all aimed at ensuring no such attacker-controlled navigation can
3684 // trigger this.
3685 //
3686 // Note that we check the pending entry instead of the visible one; for the
3687 // startup URL case these are the same, but for the attacker-controlled
3688 // navigation case the visible entry is the committed "about:blank" URL and
3689 // the pending entry is the problematic navigation elsewhere.
3690 NavigationEntryImpl* entry = controller_.GetPendingEntry();
3691 if (controller_.IsInitialNavigation() && entry &&
3692 !entry->is_renderer_initiated() &&
csharrisona3bd0b32016-10-19 18:40:483693 entry->GetURL() == url::kAboutBlankURL) {
[email protected]0c9406632013-02-08 01:13:333694 return true;
palmerc70cb1f2016-03-04 23:41:263695 }
[email protected]0c9406632013-02-08 01:13:333696 return delegate_ && delegate_->ShouldFocusLocationBarByDefault(this);
[email protected]0bfbf882011-12-22 18:19:273697}
3698
[email protected]b172aee2012-04-10 17:05:263699void WebContentsImpl::SetFocusToLocationBar(bool select_all) {
[email protected]0bfbf882011-12-22 18:19:273700 if (delegate_)
3701 delegate_->SetFocusToLocationBar(select_all);
[email protected]c40d6232011-03-25 00:16:213702}
3703
clamy0e119882015-07-31 16:12:333704void WebContentsImpl::DidStartNavigation(NavigationHandle* navigation_handle) {
ericwilligersde386342016-10-19 02:35:093705 for (auto& observer : observers_)
3706 observer.DidStartNavigation(navigation_handle);
clamy0e119882015-07-31 16:12:333707}
3708
3709void WebContentsImpl::DidRedirectNavigation(
3710 NavigationHandle* navigation_handle) {
ericwilligersde386342016-10-19 02:35:093711 for (auto& observer : observers_)
3712 observer.DidRedirectNavigation(navigation_handle);
jam5f358e52017-02-13 16:37:033713
3714 // Notify accessibility if this is a reload. This has to called on the
3715 // BrowserAccessibilityManager associated with the old RFHI.
3716 if (navigation_handle->GetReloadType() != ReloadType::NONE) {
3717 NavigationHandleImpl* nhi =
3718 static_cast<NavigationHandleImpl*>(navigation_handle);
3719 BrowserAccessibilityManager* manager =
3720 nhi->frame_tree_node()
3721 ->current_frame_host()
3722 ->browser_accessibility_manager();
3723 if (manager)
3724 manager->UserIsReloading();
3725 }
clamy0e119882015-07-31 16:12:333726}
3727
clamyefca29e2015-09-17 00:22:113728void WebContentsImpl::ReadyToCommitNavigation(
3729 NavigationHandle* navigation_handle) {
ericwilligersde386342016-10-19 02:35:093730 for (auto& observer : observers_)
3731 observer.ReadyToCommitNavigation(navigation_handle);
clamyefca29e2015-09-17 00:22:113732}
3733
clamy0e119882015-07-31 16:12:333734void WebContentsImpl::DidFinishNavigation(NavigationHandle* navigation_handle) {
ericwilligersde386342016-10-19 02:35:093735 for (auto& observer : observers_)
3736 observer.DidFinishNavigation(navigation_handle);
clamy0e119882015-07-31 16:12:333737
jam5f358e52017-02-13 16:37:033738 if (navigation_handle->HasCommitted()) {
dmazzonibf8cec42015-02-08 08:28:083739 BrowserAccessibilityManager* manager =
jam5f358e52017-02-13 16:37:033740 static_cast<RenderFrameHostImpl*>(
3741 navigation_handle->GetRenderFrameHost())
3742 ->browser_accessibility_manager();
3743 if (manager) {
3744 if (navigation_handle->IsErrorPage()) {
3745 manager->NavigationFailed();
3746 } else {
3747 manager->NavigationSucceeded();
3748 }
3749 }
dmazzonibf8cec42015-02-08 08:28:083750 }
[email protected]400992b2012-06-14 00:03:543751}
3752
[email protected]b80624c2014-02-09 02:46:553753void WebContentsImpl::DidFailLoadWithError(
3754 RenderFrameHostImpl* render_frame_host,
[email protected]b80624c2014-02-09 02:46:553755 const GURL& url,
[email protected]b80624c2014-02-09 02:46:553756 int error_code,
Yutaka Hirano16d3c5d2017-07-31 06:17:303757 const base::string16& error_description) {
ericwilligersde386342016-10-19 02:35:093758 for (auto& observer : observers_) {
Yutaka Hirano16d3c5d2017-07-31 06:17:303759 observer.DidFailLoad(render_frame_host, url, error_code, error_description);
ericwilligersde386342016-10-19 02:35:093760 }
[email protected]b80624c2014-02-09 02:46:553761}
3762
[email protected]52913802013-12-10 05:52:183763void WebContentsImpl::NotifyChangedNavigationState(
3764 InvalidateTypes changed_flags) {
3765 NotifyNavigationStateChanged(changed_flags);
3766}
3767
toyoshim0df1d3a2016-09-09 09:52:483768void WebContentsImpl::DidStartNavigationToPendingEntry(const GURL& url,
3769 ReloadType reload_type) {
[email protected]3691e5cf2014-01-22 10:16:203770 // Notify observers about navigation.
ericwilligersde386342016-10-19 02:35:093771 for (auto& observer : observers_)
3772 observer.DidStartNavigationToPendingEntry(url, reload_type);
[email protected]3691e5cf2014-01-22 10:16:203773}
3774
lukasza1d025732016-09-28 21:36:083775bool WebContentsImpl::ShouldTransferNavigation(bool is_main_frame_navigation) {
creis29460272015-12-16 04:38:223776 if (!delegate_)
3777 return true;
lukasza1d025732016-09-28 21:36:083778 return delegate_->ShouldTransferNavigation(is_main_frame_navigation);
creis29460272015-12-16 04:38:223779}
3780
[email protected]aa62afd2014-04-22 19:22:463781bool WebContentsImpl::ShouldPreserveAbortedURLs() {
3782 if (!delegate_)
3783 return false;
3784 return delegate_->ShouldPreserveAbortedURLs(this);
3785}
3786
[email protected]0d0f4c492014-04-02 06:42:573787void WebContentsImpl::DidNavigateMainFramePreCommit(
[email protected]5cfbddc2014-06-23 23:52:233788 bool navigation_is_within_page) {
[email protected]0d0f4c492014-04-02 06:42:573789 // Ensure fullscreen mode is exited before committing the navigation to a
3790 // different page. The next page will not start out assuming it is in
3791 // fullscreen mode.
[email protected]5cfbddc2014-06-23 23:52:233792 if (navigation_is_within_page) {
[email protected]dfc39cb2014-04-09 22:58:193793 // No page change? Then, the renderer and browser can remain in fullscreen.
[email protected]0d0f4c492014-04-02 06:42:573794 return;
3795 }
alexmos5dd617d2016-06-07 04:21:153796 if (IsFullscreenForCurrentTab())
bokanece34a82016-01-28 19:49:463797 ExitFullscreen(false);
alexmos5dd617d2016-06-07 04:21:153798 DCHECK(!IsFullscreenForCurrentTab());
[email protected]0d0f4c492014-04-02 06:42:573799}
3800
[email protected]37567b432014-02-12 01:12:223801void WebContentsImpl::DidNavigateMainFramePostCommit(
sky8b00392d2015-01-10 00:30:283802 RenderFrameHostImpl* render_frame_host,
[email protected]37567b432014-02-12 01:12:223803 const LoadCommittedDetails& details,
3804 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
3805 if (details.is_navigation_to_different_page()) {
3806 // Clear the status bubble. This is a workaround for a bug where WebKit
3807 // doesn't let us know that the cursor left an element during a
3808 // transition (this is also why the mouse cursor remains as a hand after
3809 // clicking on a link); see bugs 1184641 and 980803. We don't want to
3810 // clear the bubble when a user navigates to a named anchor in the same
3811 // page.
sky8b00392d2015-01-10 00:30:283812 UpdateTargetURL(render_frame_host->GetRenderViewHost(), GURL());
lanwei9d343ad22015-02-11 01:46:003813
3814 RenderWidgetHostViewBase* rwhvb =
3815 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
3816 if (rwhvb)
3817 rwhvb->OnDidNavigateMainFrameToNewPage();
yusufod41c5f92015-03-06 00:14:283818
peter90afaba2015-06-01 12:05:293819 did_first_visually_non_empty_paint_ = false;
3820
yusufod41c5f92015-03-06 00:14:283821 // Reset theme color on navigation to new page.
3822 theme_color_ = SK_ColorTRANSPARENT;
[email protected]37567b432014-02-12 01:12:223823 }
3824
[email protected]e85165c642014-06-10 14:34:313825 if (delegate_)
[email protected]37567b432014-02-12 01:12:223826 delegate_->DidNavigateMainFramePostCommit(this);
[email protected]e85165c642014-06-10 14:34:313827 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]37567b432014-02-12 01:12:223828}
3829
3830void WebContentsImpl::DidNavigateAnyFramePostCommit(
3831 RenderFrameHostImpl* render_frame_host,
3832 const LoadCommittedDetails& details,
3833 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
[email protected]b4c84012014-04-28 19:51:103834 // Now that something has committed, we don't need to track whether the
3835 // initial page has been accessed.
3836 has_accessed_initial_document_ = false;
3837
[email protected]37567b432014-02-12 01:12:223838 // If we navigate off the page, close all JavaScript dialogs.
eugenebutee08663a2017-04-27 17:43:123839 if (!details.is_same_document)
creis89a0f782015-05-27 16:13:173840 CancelActiveAndPendingDialogs();
[email protected]37567b432014-02-12 01:12:223841
avid53461d2016-02-25 17:15:043842 // If this is a user-initiated navigation, start allowing JavaScript dialogs
3843 // again.
avi5d3b8692016-10-12 22:00:463844 if (params.gesture == NavigationGestureUser && dialog_manager_) {
avi6879fcf2017-01-21 05:27:533845 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:463846 }
[email protected]37567b432014-02-12 01:12:223847}
3848
3849void WebContentsImpl::SetMainFrameMimeType(const std::string& mime_type) {
3850 contents_mime_type_ = mime_type;
3851}
3852
[email protected]277857a2014-06-03 10:38:013853bool WebContentsImpl::CanOverscrollContent() const {
[email protected]e85165c642014-06-10 14:34:313854 // Disable overscroll when touch emulation is on. See crbug.com/369938.
[email protected]34ff1cfc2014-08-20 06:16:053855 if (force_disable_overscroll_content_)
[email protected]e85165c642014-06-10 14:34:313856 return false;
3857
[email protected]37567b432014-02-12 01:12:223858 if (delegate_)
3859 return delegate_->CanOverscrollContent();
3860
3861 return false;
3862}
3863
nicka0ac8382016-12-15 23:59:233864void WebContentsImpl::OnThemeColorChanged(RenderFrameHostImpl* source,
3865 SkColor theme_color) {
3866 if (source != GetMainFrame()) {
3867 // Only the main frame may control the theme.
3868 return;
3869 }
3870
peter90afaba2015-06-01 12:05:293871 // Update the theme color. This is to be published to observers after the
3872 // first visually non-empty paint.
yusufod41c5f92015-03-06 00:14:283873 theme_color_ = theme_color;
peter90afaba2015-06-01 12:05:293874
3875 if (did_first_visually_non_empty_paint_ &&
3876 last_sent_theme_color_ != theme_color_) {
ericwilligersde386342016-10-19 02:35:093877 for (auto& observer : observers_)
3878 observer.DidChangeThemeColor(theme_color_);
peter90afaba2015-06-01 12:05:293879 last_sent_theme_color_ = theme_color_;
3880 }
[email protected]e7104762014-06-20 19:17:253881}
3882
[email protected]b172aee2012-04-10 17:05:263883void WebContentsImpl::OnDidLoadResourceFromMemoryCache(
nicka0ac8382016-12-15 23:59:233884 RenderFrameHostImpl* source,
[email protected]724159a2010-12-30 01:11:183885 const GURL& url,
[email protected]70435962011-08-02 20:13:283886 const std::string& http_method,
[email protected]6d6cfb3a2012-05-23 22:53:183887 const std::string& mime_type,
[email protected]6c1e05212014-07-31 00:59:403888 ResourceType resource_type) {
ericwilligersde386342016-10-19 02:35:093889 for (auto& observer : observers_)
3890 observer.DidLoadResourceFromMemoryCache(url, mime_type, resource_type);
[email protected]b0f724c2013-09-05 04:21:133891
[email protected]8bfc8272013-09-09 20:10:533892 if (url.is_valid() && url.SchemeIsHTTPOrHTTPS()) {
nicka0ac8382016-12-15 23:59:233893 StoragePartition* partition = source->GetProcess()->GetStoragePartition();
[email protected]8bfc8272013-09-09 20:10:533894 scoped_refptr<net::URLRequestContextGetter> request_context(
nicka0ac8382016-12-15 23:59:233895 resource_type == RESOURCE_TYPE_MEDIA
3896 ? partition->GetMediaURLRequestContext()
3897 : partition->GetURLRequestContext());
[email protected]8bfc8272013-09-09 20:10:533898 BrowserThread::PostTask(
nicka0ac8382016-12-15 23:59:233899 BrowserThread::IO, FROM_HERE,
tzike2aca992017-09-05 08:50:543900 base::BindOnce(&NotifyCacheOnIO, request_context, url, http_method));
[email protected]8bfc8272013-09-09 20:10:533901 }
[email protected]724159a2010-12-30 01:11:183902}
3903
nicka0ac8382016-12-15 23:59:233904void WebContentsImpl::OnDidDisplayInsecureContent(RenderFrameHostImpl* source) {
3905 // Any frame can trigger display of insecure content, so we don't check
3906 // |source| here.
carloskd9d97942017-02-16 08:58:093907 DidDisplayInsecureContent();
3908}
3909
3910void WebContentsImpl::DidDisplayInsecureContent() {
estarkc2273502016-10-12 22:03:023911 controller_.ssl_manager()->DidDisplayMixedContent();
[email protected]724159a2010-12-30 01:11:183912}
3913
elawrenceb2ac2a232017-03-27 21:46:253914void WebContentsImpl::OnDidContainInsecureFormAction(
3915 RenderFrameHostImpl* source) {
3916 controller_.ssl_manager()->DidContainInsecureFormAction();
3917}
3918
nicka0ac8382016-12-15 23:59:233919void WebContentsImpl::OnDidRunInsecureContent(RenderFrameHostImpl* source,
3920 const GURL& security_origin,
estark910b4572015-12-09 20:55:413921 const GURL& target_url) {
nicka0ac8382016-12-15 23:59:233922 // TODO(nick, estark): Should we call FilterURL using |source|'s process on
3923 // these parameters? |target_url| seems unused, except for a log message. And
3924 // |security_origin| might be replaceable with the origin of the main frame.
carloskd9d97942017-02-16 08:58:093925 DidRunInsecureContent(security_origin, target_url);
3926}
3927
3928void WebContentsImpl::DidRunInsecureContent(const GURL& security_origin,
3929 const GURL& target_url) {
[email protected]9450c462013-11-23 01:22:583930 LOG(WARNING) << security_origin << " ran insecure content from "
3931 << target_url.possibly_invalid_spec();
[email protected]e6e30ac2014-01-13 21:24:393932 RecordAction(base::UserMetricsAction("SSL.RanInsecureContent"));
estark910b4572015-12-09 20:55:413933 if (base::EndsWith(security_origin.spec(), kDotGoogleDotCom,
brettwa7ff1b292015-07-16 17:49:293934 base::CompareCase::INSENSITIVE_ASCII))
[email protected]e6e30ac2014-01-13 21:24:393935 RecordAction(base::UserMetricsAction("SSL.RanInsecureContentGoogle"));
estarkc2273502016-10-12 22:03:023936 controller_.ssl_manager()->DidRunMixedContent(security_origin);
[email protected]724159a2010-12-30 01:11:183937}
3938
carloskd9d97942017-02-16 08:58:093939void WebContentsImpl::PassiveInsecureContentFound(const GURL& resource_url) {
3940 GetDelegate()->PassiveInsecureContentFound(resource_url);
3941}
3942
3943bool WebContentsImpl::ShouldAllowRunningInsecureContent(
3944 WebContents* web_contents,
3945 bool allowed_per_prefs,
3946 const url::Origin& origin,
3947 const GURL& resource_url) {
3948 return GetDelegate()->ShouldAllowRunningInsecureContent(
3949 web_contents, allowed_per_prefs, origin, resource_url);
3950}
3951
rob.buis300b0872017-03-10 20:43:583952#if defined(OS_ANDROID)
3953base::android::ScopedJavaLocalRef<jobject>
3954WebContentsImpl::GetJavaRenderFrameHostDelegate() {
3955 return GetJavaWebContents();
3956}
3957#endif
3958
estark910b4572015-12-09 20:55:413959void WebContentsImpl::OnDidDisplayContentWithCertificateErrors(
nicka0ac8382016-12-15 23:59:233960 RenderFrameHostImpl* source,
jama385e112016-07-22 00:07:583961 const GURL& url) {
nicka0ac8382016-12-15 23:59:233962 // TODO(nick): |url| is unused; get rid of it.
estarkc2273502016-10-12 22:03:023963 controller_.ssl_manager()->DidDisplayContentWithCertErrors();
estark910b4572015-12-09 20:55:413964}
3965
3966void WebContentsImpl::OnDidRunContentWithCertificateErrors(
nicka0ac8382016-12-15 23:59:233967 RenderFrameHostImpl* source,
jama385e112016-07-22 00:07:583968 const GURL& url) {
nicka0ac8382016-12-15 23:59:233969 // TODO(nick, estark): Do we need to consider |source| here somehow?
estarkcd2e30c2016-08-12 06:51:153970 NavigationEntry* entry = controller_.GetVisibleEntry();
3971 if (!entry)
estarkaeda1422016-05-10 02:31:123972 return;
3973
estarkaeda1422016-05-10 02:31:123974 // TODO(estark): check that this does something reasonable for
3975 // about:blank and sandboxed origins. https://crbug.com/609527
estarkcd2e30c2016-08-12 06:51:153976 controller_.ssl_manager()->DidRunContentWithCertErrors(
3977 entry->GetURL().GetOrigin());
estark910b4572015-12-09 20:55:413978}
3979
nicka0ac8382016-12-15 23:59:233980void WebContentsImpl::OnDocumentLoadedInFrame(RenderFrameHostImpl* source) {
ericwilligersde386342016-10-19 02:35:093981 for (auto& observer : observers_)
nicka0ac8382016-12-15 23:59:233982 observer.DocumentLoadedInFrame(source);
[email protected]724159a2010-12-30 01:11:183983}
3984
nicka0ac8382016-12-15 23:59:233985void WebContentsImpl::OnDidFinishLoad(RenderFrameHostImpl* source,
3986 const GURL& url) {
[email protected]8b3af1e2014-01-24 13:29:123987 GURL validated_url(url);
nicka0ac8382016-12-15 23:59:233988 source->GetProcess()->FilterURL(false, &validated_url);
[email protected]028053d42014-03-05 22:20:373989
ericwilligersde386342016-10-19 02:35:093990 for (auto& observer : observers_)
nicka0ac8382016-12-15 23:59:233991 observer.DidFinishLoad(source, validated_url);
[email protected]1a55c5be2011-11-29 11:36:313992}
3993
nicka0ac8382016-12-15 23:59:233994void WebContentsImpl::OnGoToEntryAtOffset(RenderViewHostImpl* source,
3995 int offset) {
3996 // All frames are allowed to navigate the global history.
avi6ddfcae2015-06-30 15:50:573997 if (!delegate_ || delegate_->OnGoToEntryOffset(offset))
3998 controller_.GoToOffset(offset);
[email protected]216813952011-05-19 22:21:263999}
4000
nicka0ac8382016-12-15 23:59:234001void WebContentsImpl::OnUpdateZoomLimits(RenderViewHostImpl* source,
4002 int minimum_percent,
[email protected]fce823222014-05-30 16:24:304003 int maximum_percent) {
[email protected]216813952011-05-19 22:21:264004 minimum_zoom_percent_ = minimum_percent;
4005 maximum_zoom_percent_ = maximum_percent;
[email protected]216813952011-05-19 22:21:264006}
4007
nicka0ac8382016-12-15 23:59:234008void WebContentsImpl::OnPageScaleFactorChanged(RenderViewHostImpl* source,
4009 float page_scale_factor) {
mcnee336ea2c2017-05-23 22:50:594010#if !defined(OS_ANDROID)
4011 // While page scale factor is used on mobile, this PageScaleFactorIsOne logic
4012 // is only needed on desktop.
mcnee432e47d2015-11-09 19:37:464013 bool is_one = page_scale_factor == 1.f;
4014 if (is_one != page_scale_factor_is_one_) {
4015 page_scale_factor_is_one_ = is_one;
4016
4017 HostZoomMapImpl* host_zoom_map =
4018 static_cast<HostZoomMapImpl*>(HostZoomMap::GetForWebContents(this));
4019
nicka0ac8382016-12-15 23:59:234020 if (host_zoom_map) {
mcnee432e47d2015-11-09 19:37:464021 host_zoom_map->SetPageScaleFactorIsOneForView(
nicka0ac8382016-12-15 23:59:234022 source->GetProcess()->GetID(), source->GetRoutingID(),
mcnee432e47d2015-11-09 19:37:464023 page_scale_factor_is_one_);
4024 }
4025 }
mcnee336ea2c2017-05-23 22:50:594026#endif // !defined(OS_ANDROID)
mcnee432e47d2015-11-09 19:37:464027
ericwilligersde386342016-10-19 02:35:094028 for (auto& observer : observers_)
4029 observer.OnPageScaleFactorChanged(page_scale_factor);
mcnee432e47d2015-11-09 19:37:464030}
4031
nicka0ac8382016-12-15 23:59:234032void WebContentsImpl::OnEnumerateDirectory(RenderViewHostImpl* source,
4033 int request_id,
[email protected]2dec8ec2013-02-07 19:20:344034 const base::FilePath& path) {
[email protected]e5f2de02012-07-20 22:15:434035 if (!delegate_)
4036 return;
4037
[email protected]b9535422012-02-09 01:47:594038 ChildProcessSecurityPolicyImpl* policy =
4039 ChildProcessSecurityPolicyImpl::GetInstance();
nicka0ac8382016-12-15 23:59:234040 if (policy->CanReadFile(source->GetProcess()->GetID(), path)) {
4041 // TODO(nick): |this| param in the call below ought to be a RenderFrameHost.
[email protected]b9535422012-02-09 01:47:594042 delegate_->EnumerateDirectory(this, request_id, path);
nicka0ac8382016-12-15 23:59:234043 }
[email protected]3a29a6e2011-08-24 18:26:214044}
4045
nicka0ac8382016-12-15 23:59:234046void WebContentsImpl::OnRegisterProtocolHandler(RenderFrameHostImpl* source,
4047 const std::string& protocol,
[email protected]b172aee2012-04-10 17:05:264048 const GURL& url,
[email protected]fcf75d42013-12-03 20:11:264049 const base::string16& title,
[email protected]3a3b75a2012-06-01 08:38:364050 bool user_gesture) {
nicka0ac8382016-12-15 23:59:234051 // TODO(nick): Should we consider |source| here or pass it to the delegate?
4052 // TODO(nick): Do we need to apply FilterURL to |url|?
[email protected]e5f2de02012-07-20 22:15:434053 if (!delegate_)
4054 return;
4055
[email protected]b9535422012-02-09 01:47:594056 ChildProcessSecurityPolicyImpl* policy =
4057 ChildProcessSecurityPolicyImpl::GetInstance();
[email protected]8f810632013-06-06 22:33:324058 if (policy->IsPseudoScheme(protocol))
[email protected]b9535422012-02-09 01:47:594059 return;
[email protected]8f810632013-06-06 22:33:324060
[email protected]c125e532014-05-10 20:39:064061 delegate_->RegisterProtocolHandler(this, protocol, url, user_gesture);
[email protected]7d189022011-08-25 22:54:204062}
4063
nicka0ac8382016-12-15 23:59:234064void WebContentsImpl::OnUnregisterProtocolHandler(RenderFrameHostImpl* source,
4065 const std::string& protocol,
[email protected]f5273e52014-07-14 16:30:204066 const GURL& url,
4067 bool user_gesture) {
nicka0ac8382016-12-15 23:59:234068 // TODO(nick): Should we consider |source| here or pass it to the delegate?
4069 // TODO(nick): Do we need to apply FilterURL to |url|?
[email protected]f5273e52014-07-14 16:30:204070 if (!delegate_)
4071 return;
4072
4073 ChildProcessSecurityPolicyImpl* policy =
4074 ChildProcessSecurityPolicyImpl::GetInstance();
4075 if (policy->IsPseudoScheme(protocol))
4076 return;
4077
4078 delegate_->UnregisterProtocolHandler(this, protocol, url, user_gesture);
4079}
4080
kouhei40f03cb2015-09-24 07:47:014081void WebContentsImpl::OnUpdatePageImportanceSignals(
nicka0ac8382016-12-15 23:59:234082 RenderFrameHostImpl* source,
kouhei40f03cb2015-09-24 07:47:014083 const PageImportanceSignals& signals) {
nicka0ac8382016-12-15 23:59:234084 // TODO(nick, kouhei): Fix this for oopifs; currently all frames' state gets
4085 // written to this one field.
kouhei40f03cb2015-09-24 07:47:014086 page_importance_signals_ = signals;
4087}
4088
nicka0ac8382016-12-15 23:59:234089void WebContentsImpl::OnFindReply(RenderFrameHostImpl* source,
4090 int request_id,
[email protected]b172aee2012-04-10 17:05:264091 int number_of_matches,
4092 const gfx::Rect& selection_rect,
4093 int active_match_ordinal,
4094 bool final_update) {
paulmeyerfeafc2d2017-04-25 21:46:404095 if (active_match_ordinal > 0)
4096 SetFocusedFrame(source->frame_tree_node(), source->GetSiteInstance());
4097
paulmeyerc0b762b2016-04-13 11:55:174098 // Forward the find reply to the FindRequestManager, along with the
4099 // RenderFrameHost associated with the frame that the reply came from.
nicka0ac8382016-12-15 23:59:234100 GetOrCreateFindRequestManager()->OnFindReply(
4101 source, request_id, number_of_matches, selection_rect,
4102 active_match_ordinal, final_update);
[email protected]b888919c2011-09-02 00:32:164103}
4104
mfomitchev2b8b066a2016-01-28 19:23:154105#if defined(OS_ANDROID)
[email protected]59363fc92012-09-05 03:46:314106void WebContentsImpl::OnFindMatchRectsReply(
nicka0ac8382016-12-15 23:59:234107 RenderFrameHostImpl* source,
[email protected]59363fc92012-09-05 03:46:314108 int version,
4109 const std::vector<gfx::RectF>& rects,
4110 const gfx::RectF& active_rect) {
nicka0ac8382016-12-15 23:59:234111 GetOrCreateFindRequestManager()->OnFindMatchRectsReply(source, version, rects,
4112 active_rect);
[email protected]59363fc92012-09-05 03:46:314113}
[email protected]583418cc2013-01-17 14:01:104114
nicka0ac8382016-12-15 23:59:234115void WebContentsImpl::OnGetNearestFindResultReply(RenderFrameHostImpl* source,
4116 int request_id,
paulmeyerc8cb7cb2016-06-07 01:14:194117 float distance) {
4118 GetOrCreateFindRequestManager()->OnGetNearestFindResultReply(
nicka0ac8382016-12-15 23:59:234119 source, request_id, distance);
paulmeyerc8cb7cb2016-06-07 01:14:194120}
4121
[email protected]1ff427972013-02-07 21:14:074122void WebContentsImpl::OnOpenDateTimeDialog(
nicka0ac8382016-12-15 23:59:234123 RenderViewHostImpl* source,
[email protected]1ff427972013-02-07 21:14:074124 const ViewHostMsg_DateTimeDialogValue_Params& value) {
nicka0ac8382016-12-15 23:59:234125 date_time_chooser_->ShowDialog(
4126 GetTopLevelNativeWindow(), source, value.dialog_type, value.dialog_value,
4127 value.minimum, value.maximum, value.step, value.suggestions);
[email protected]583418cc2013-01-17 14:01:104128}
[email protected]59363fc92012-09-05 03:46:314129#endif
4130
nicka0ac8382016-12-15 23:59:234131void WebContentsImpl::OnDomOperationResponse(RenderFrameHostImpl* source,
4132 const std::string& json_string) {
4133 // TODO(nick, lukasza): The notification below should probably be updated to
4134 // include |source|.
avi60bd4902015-09-23 20:39:244135 std::string json = json_string;
4136 NotificationService::current()->Notify(NOTIFICATION_DOM_OPERATION_RESPONSE,
4137 Source<WebContents>(this),
4138 Details<std::string>(&json));
[email protected]cfa856d62014-02-22 07:58:404139}
4140
nicka0ac8382016-12-15 23:59:234141void WebContentsImpl::OnAppCacheAccessed(RenderViewHostImpl* source,
4142 const GURL& manifest_url,
[email protected]b172aee2012-04-10 17:05:264143 bool blocked_by_policy) {
nicka0ac8382016-12-15 23:59:234144 // TODO(nick): Should we consider |source| here? Should we call FilterURL on
4145 // |manifest_url|?
4146
[email protected]7fc4bbb2011-09-08 21:23:104147 // Notify observers about navigation.
ericwilligersde386342016-10-19 02:35:094148 for (auto& observer : observers_)
4149 observer.AppCacheAccessed(manifest_url, blocked_by_policy);
[email protected]7fc4bbb2011-09-08 21:23:104150}
4151
[email protected]8bc5ff02013-11-29 06:34:034152void WebContentsImpl::OnOpenColorChooser(
nicka0ac8382016-12-15 23:59:234153 RenderFrameHostImpl* source,
[email protected]8ed16472014-04-11 19:02:484154 int color_chooser_id,
4155 SkColor color,
4156 const std::vector<ColorSuggestion>& suggestions) {
[email protected]aa62afd2014-04-22 19:22:464157 ColorChooser* new_color_chooser = delegate_ ?
4158 delegate_->OpenColorChooser(this, color, suggestions) :
4159 NULL;
[email protected]820957a2014-01-14 14:56:304160 if (!new_color_chooser)
[email protected]cb805452013-05-22 15:16:214161 return;
[email protected]8ed16472014-04-11 19:02:484162 if (color_chooser_info_.get())
4163 color_chooser_info_->chooser->End();
4164
4165 color_chooser_info_.reset(new ColorChooserInfo(
nicka0ac8382016-12-15 23:59:234166 source->GetProcess()->GetID(), source->GetRoutingID(), new_color_chooser,
[email protected]8ed16472014-04-11 19:02:484167 color_chooser_id));
[email protected]da8543762012-03-20 08:52:204168}
4169
nicka0ac8382016-12-15 23:59:234170void WebContentsImpl::OnEndColorChooser(RenderFrameHostImpl* source,
4171 int color_chooser_id) {
[email protected]8ed16472014-04-11 19:02:484172 if (color_chooser_info_ &&
nicka0ac8382016-12-15 23:59:234173 color_chooser_info_->Matches(source, color_chooser_id))
[email protected]8ed16472014-04-11 19:02:484174 color_chooser_info_->chooser->End();
[email protected]da8543762012-03-20 08:52:204175}
4176
nicka0ac8382016-12-15 23:59:234177void WebContentsImpl::OnSetSelectedColorInColorChooser(
4178 RenderFrameHostImpl* source,
4179 int color_chooser_id,
4180 SkColor color) {
[email protected]8ed16472014-04-11 19:02:484181 if (color_chooser_info_ &&
nicka0ac8382016-12-15 23:59:234182 color_chooser_info_->Matches(source, color_chooser_id))
[email protected]8ed16472014-04-11 19:02:484183 color_chooser_info_->chooser->SetSelectedColor(color);
[email protected]da8543762012-03-20 08:52:204184}
4185
brettw4b461082016-11-19 18:55:164186#if BUILDFLAG(ENABLE_PLUGINS)
nicka0ac8382016-12-15 23:59:234187void WebContentsImpl::OnPepperInstanceCreated(RenderFrameHostImpl* source,
4188 int32_t pp_instance) {
ericwilligersde386342016-10-19 02:35:094189 for (auto& observer : observers_)
4190 observer.PepperInstanceCreated();
nicka0ac8382016-12-15 23:59:234191 pepper_playback_observer_->PepperInstanceCreated(source, pp_instance);
emaxxe70f5e12015-05-29 11:26:004192}
4193
nicka0ac8382016-12-15 23:59:234194void WebContentsImpl::OnPepperInstanceDeleted(RenderFrameHostImpl* source,
4195 int32_t pp_instance) {
ericwilligersde386342016-10-19 02:35:094196 for (auto& observer : observers_)
4197 observer.PepperInstanceDeleted();
nicka0ac8382016-12-15 23:59:234198 pepper_playback_observer_->PepperInstanceDeleted(source, pp_instance);
emaxxe70f5e12015-05-29 11:26:004199}
4200
nicka0ac8382016-12-15 23:59:234201void WebContentsImpl::OnPepperPluginHung(RenderFrameHostImpl* source,
4202 int plugin_child_id,
tommyclie6633ca72014-10-31 00:40:424203 const base::FilePath& path,
4204 bool is_hung) {
4205 UMA_HISTOGRAM_COUNTS("Pepper.PluginHung", 1);
4206
ericwilligersde386342016-10-19 02:35:094207 for (auto& observer : observers_)
4208 observer.PluginHungStatusChanged(plugin_child_id, path, is_hung);
tommyclie6633ca72014-10-31 00:40:424209}
4210
nicka0ac8382016-12-15 23:59:234211void WebContentsImpl::OnPepperStartsPlayback(RenderFrameHostImpl* source,
4212 int32_t pp_instance) {
4213 pepper_playback_observer_->PepperStartsPlayback(source, pp_instance);
zqzhang181047e62016-07-01 13:37:174214}
4215
nicka0ac8382016-12-15 23:59:234216void WebContentsImpl::OnPepperStopsPlayback(RenderFrameHostImpl* source,
4217 int32_t pp_instance) {
4218 pepper_playback_observer_->PepperStopsPlayback(source, pp_instance);
zqzhang181047e62016-07-01 13:37:174219}
4220
nicka0ac8382016-12-15 23:59:234221void WebContentsImpl::OnPluginCrashed(RenderFrameHostImpl* source,
4222 const base::FilePath& plugin_path,
tommyclie6633ca72014-10-31 00:40:424223 base::ProcessId plugin_pid) {
nicka0ac8382016-12-15 23:59:234224 // TODO(nick): Eliminate the |plugin_pid| parameter, which can't be trusted,
4225 // and is only used by BlinkTestController.
ericwilligersde386342016-10-19 02:35:094226 for (auto& observer : observers_)
4227 observer.PluginCrashed(plugin_path, plugin_pid);
tommyclie6633ca72014-10-31 00:40:424228}
4229
[email protected]d8415ad92012-08-23 14:40:504230void WebContentsImpl::OnRequestPpapiBrokerPermission(
nicka0ac8382016-12-15 23:59:234231 RenderViewHostImpl* source,
4232 int ppb_broker_route_id,
[email protected]d8415ad92012-08-23 14:40:504233 const GURL& url,
[email protected]2dec8ec2013-02-07 19:20:344234 const base::FilePath& plugin_path) {
nicka0ac8382016-12-15 23:59:234235 base::Callback<void(bool)> permission_result_callback = base::Bind(
4236 &WebContentsImpl::SendPpapiBrokerPermissionResult, base::Unretained(this),
4237 source->GetProcess()->GetID(), ppb_broker_route_id);
[email protected]8c8fc292012-11-23 18:57:164238 if (!delegate_) {
nicka0ac8382016-12-15 23:59:234239 permission_result_callback.Run(false);
[email protected]8c8fc292012-11-23 18:57:164240 return;
[email protected]d8415ad92012-08-23 14:40:504241 }
4242
nicka0ac8382016-12-15 23:59:234243 if (!delegate_->RequestPpapiBrokerPermission(this, url, plugin_path,
4244 permission_result_callback)) {
[email protected]8c8fc292012-11-23 18:57:164245 NOTIMPLEMENTED();
nicka0ac8382016-12-15 23:59:234246 permission_result_callback.Run(false);
[email protected]8c8fc292012-11-23 18:57:164247 }
[email protected]d8415ad92012-08-23 14:40:504248}
4249
nicka0ac8382016-12-15 23:59:234250void WebContentsImpl::SendPpapiBrokerPermissionResult(int process_id,
4251 int ppb_broker_route_id,
4252 bool result) {
4253 RenderProcessHost* rph = RenderProcessHost::FromID(process_id);
4254 if (rph) {
4255 // TODO(nick): Convert this from ViewMsg_ to a Ppapi msg, since it
4256 // is not routed to a RenderView.
4257 rph->Send(
4258 new ViewMsg_PpapiBrokerPermissionResult(ppb_broker_route_id, result));
4259 }
[email protected]d8415ad92012-08-23 14:40:504260}
4261
fsamuel833ee7c2015-02-13 23:40:404262void WebContentsImpl::OnBrowserPluginMessage(RenderFrameHost* render_frame_host,
4263 const IPC::Message& message) {
[email protected]7a846df2012-09-20 19:17:394264 CHECK(!browser_plugin_embedder_.get());
fsamuel60b42282015-03-10 03:29:144265 CreateBrowserPluginEmbedderIfNecessary();
fsamuel833ee7c2015-02-13 23:40:404266 browser_plugin_embedder_->OnMessageReceived(message, render_frame_host);
[email protected]19be7a62012-10-01 23:03:374267}
brettw4b461082016-11-19 18:55:164268#endif // BUILDFLAG(ENABLE_PLUGINS)
[email protected]19be7a62012-10-01 23:03:374269
[email protected]795c28972012-12-06 06:13:394270void WebContentsImpl::OnUpdateFaviconURL(
lukasza178ff092017-06-07 23:39:504271 RenderFrameHostImpl* source,
[email protected]795c28972012-12-06 06:13:394272 const std::vector<FaviconURL>& candidates) {
lukasza178ff092017-06-07 23:39:504273 // Ignore favicons for non-main frame.
4274 if (source->GetParent()) {
4275 NOTREACHED();
4276 return;
4277 }
4278
pkotwiczf9bc20592015-04-21 18:57:064279 // We get updated favicon URLs after the page stops loading. If a cross-site
4280 // navigation occurs while a page is still loading, the initial page
4281 // may stop loading and send us updated favicon URLs after the navigation
4282 // for the new page has committed.
lukasza178ff092017-06-07 23:39:504283 if (!source->IsCurrent())
pkotwiczf9bc20592015-04-21 18:57:064284 return;
4285
ericwilligersde386342016-10-19 02:35:094286 for (auto& observer : observers_)
4287 observer.DidUpdateFaviconURL(candidates);
[email protected]795c28972012-12-06 06:13:394288}
4289
estark703f1b42016-10-10 21:37:154290void WebContentsImpl::OnPasswordInputShownOnHttp() {
estarkc2273502016-10-12 22:03:024291 controller_.ssl_manager()->DidShowPasswordInputOnHttp();
estark703f1b42016-10-10 21:37:154292}
4293
estarkfae6b5872016-11-04 05:20:314294void WebContentsImpl::OnAllPasswordInputsHiddenOnHttp() {
4295 controller_.ssl_manager()->DidHideAllPasswordInputsOnHttp();
4296}
4297
estark703f1b42016-10-10 21:37:154298void WebContentsImpl::OnCreditCardInputShownOnHttp() {
estarkc2273502016-10-12 22:03:024299 controller_.ssl_manager()->DidShowCreditCardInputOnHttp();
estark703f1b42016-10-10 21:37:154300}
4301
qinmin72e8bd02016-10-21 19:35:374302void WebContentsImpl::SetIsOverlayContent(bool is_overlay_content) {
4303 is_overlay_content_ = is_overlay_content;
4304}
4305
nicka0ac8382016-12-15 23:59:234306void WebContentsImpl::OnFirstVisuallyNonEmptyPaint(RenderViewHostImpl* source) {
4307 // TODO(nick): When this is ported to FrameHostMsg_, we should only listen if
4308 // |source| is the main frame.
ericwilligersde386342016-10-19 02:35:094309 for (auto& observer : observers_)
4310 observer.DidFirstVisuallyNonEmptyPaint();
yusufod41c5f92015-03-06 00:14:284311
peter90afaba2015-06-01 12:05:294312 did_first_visually_non_empty_paint_ = true;
4313
yusufod41c5f92015-03-06 00:14:284314 if (theme_color_ != last_sent_theme_color_) {
4315 // Theme color should have updated by now if there was one.
ericwilligersde386342016-10-19 02:35:094316 for (auto& observer : observers_)
4317 observer.DidChangeThemeColor(theme_color_);
yusufod41c5f92015-03-06 00:14:284318 last_sent_theme_color_ = theme_color_;
4319 }
[email protected]9f268072013-11-07 00:02:154320}
[email protected]d9030b82013-07-19 08:26:064321
[email protected]17e286e2013-03-01 23:29:394322void WebContentsImpl::NotifyBeforeFormRepostWarningShow() {
ericwilligersde386342016-10-19 02:35:094323 for (auto& observer : observers_)
4324 observer.BeforeFormRepostWarningShow();
[email protected]17e286e2013-03-01 23:29:394325}
4326
[email protected]ec6c05f2013-10-23 18:41:574327void WebContentsImpl::ActivateAndShowRepostFormWarningDialog() {
4328 Activate();
4329 if (delegate_)
4330 delegate_->ShowRepostFormWarningDialog(this);
4331}
4332
[email protected]b4c84012014-04-28 19:51:104333bool WebContentsImpl::HasAccessedInitialDocument() {
4334 return has_accessed_initial_document_;
4335}
4336
afakhry6f0c1ec22016-07-14 13:55:134337void WebContentsImpl::UpdateTitleForEntry(NavigationEntry* entry,
[email protected]fcf75d42013-12-03 20:11:264338 const base::string16& title) {
[email protected]fcf75d42013-12-03 20:11:264339 base::string16 final_title;
Avi Drissman93002212017-09-27 03:20:524340 base::TrimWhitespace(title, base::TRIM_ALL, &final_title);
[email protected]420ae012009-04-24 05:16:324341
[email protected]987fc3a2011-05-26 14:18:094342 // If a page is created via window.open and never navigated,
4343 // there will be no navigation entry. In this situation,
[email protected]73eb2602012-02-09 19:50:554344 // |page_title_when_no_navigation_entry_| will be used for page title.
[email protected]987fc3a2011-05-26 14:18:094345 if (entry) {
[email protected]36fc0392011-12-25 03:59:514346 if (final_title == entry->GetTitle())
afakhry6f0c1ec22016-07-14 13:55:134347 return; // Nothing changed, don't bother.
[email protected]420ae012009-04-24 05:16:324348
[email protected]36fc0392011-12-25 03:59:514349 entry->SetTitle(final_title);
Avi Drissman93002212017-09-27 03:20:524350
4351 // The title for display may differ from the title just set; grab it.
4352 final_title = entry->GetTitleForDisplay();
[email protected]987fc3a2011-05-26 14:18:094353 } else {
4354 if (page_title_when_no_navigation_entry_ == final_title)
afakhry6f0c1ec22016-07-14 13:55:134355 return; // Nothing changed, don't bother.
[email protected]987fc3a2011-05-26 14:18:094356
4357 page_title_when_no_navigation_entry_ = final_title;
4358 }
[email protected]420ae012009-04-24 05:16:324359
[email protected]420ae012009-04-24 05:16:324360 // Lastly, set the title for the view.
[email protected]790e2fd2011-09-21 20:28:234361 view_->SetPageTitle(final_title);
[email protected]420ae012009-04-24 05:16:324362
ericwilligersde386342016-10-19 02:35:094363 for (auto& observer : observers_)
Avi Drissman93002212017-09-27 03:20:524364 observer.TitleWasSet(entry);
[email protected]66798902013-10-01 18:40:164365
afakhry6f0c1ec22016-07-14 13:55:134366 // Broadcast notifications when the UI should be updated.
4367 if (entry == controller_.GetEntryAtOffset(0))
4368 NotifyNavigationStateChanged(INVALIDATE_TYPE_TITLE);
[email protected]420ae012009-04-24 05:16:324369}
4370
fdegansa696e5112015-04-17 01:57:594371void WebContentsImpl::SendChangeLoadProgress() {
[email protected]960b0372014-05-19 18:01:004372 loading_last_progress_update_ = base::TimeTicks::Now();
[email protected]960b0372014-05-19 18:01:004373 if (delegate_)
fdegansa696e5112015-04-17 01:57:594374 delegate_->LoadProgressChanged(this, frame_tree_.load_progress());
[email protected]960b0372014-05-19 18:01:004375}
4376
4377void WebContentsImpl::ResetLoadProgressState() {
fdegans1d16355162015-03-26 11:58:344378 frame_tree_.ResetLoadProgress();
[email protected]960b0372014-05-19 18:01:004379 loading_weak_factory_.InvalidateWeakPtrs();
4380 loading_last_progress_update_ = base::TimeTicks();
4381}
4382
clamy44e84ce2016-02-22 15:38:254383// Notifies the RenderWidgetHost instance about the fact that the page is
4384// loading, or done loading.
4385void WebContentsImpl::LoadingStateChanged(bool to_different_document,
4386 bool due_to_interstitial,
4387 LoadNotificationDetails* details) {
4388 // Do not send notifications about loading changes in the FrameTree while the
4389 // interstitial page is pausing the throbber.
creisadca9862017-06-16 19:12:114390 if (ShowingInterstitialPage() && interstitial_page_->pause_throbber() &&
clamy44e84ce2016-02-22 15:38:254391 !due_to_interstitial) {
4392 return;
4393 }
4394
4395 bool is_loading = IsLoading();
4396
4397 if (!is_loading) {
4398 load_state_ = net::LoadStateWithParam(net::LOAD_STATE_IDLE,
4399 base::string16());
4400 load_state_host_.clear();
4401 upload_size_ = 0;
4402 upload_position_ = 0;
4403 }
4404
4405 GetRenderManager()->SetIsLoading(is_loading);
4406
4407 waiting_for_response_ = is_loading;
4408 is_load_to_different_document_ = to_different_document;
4409
4410 if (delegate_)
4411 delegate_->LoadingStateChanged(this, to_different_document);
4412 NotifyNavigationStateChanged(INVALIDATE_TYPE_LOAD);
4413
4414 std::string url = (details ? details->url.possibly_invalid_spec() : "NULL");
4415 if (is_loading) {
4416 TRACE_EVENT_ASYNC_BEGIN2("browser,navigation", "WebContentsImpl Loading",
4417 this, "URL", url, "Main FrameTreeNode id",
4418 GetFrameTree()->root()->frame_tree_node_id());
ericwilligersde386342016-10-19 02:35:094419 for (auto& observer : observers_)
4420 observer.DidStartLoading();
clamy44e84ce2016-02-22 15:38:254421 } else {
4422 TRACE_EVENT_ASYNC_END1("browser,navigation", "WebContentsImpl Loading",
4423 this, "URL", url);
ericwilligersde386342016-10-19 02:35:094424 for (auto& observer : observers_)
4425 observer.DidStopLoading();
clamy44e84ce2016-02-22 15:38:254426 }
4427
4428 // TODO(avi): Remove. http://crbug.com/170921
4429 int type = is_loading ? NOTIFICATION_LOAD_START : NOTIFICATION_LOAD_STOP;
4430 NotificationDetails det = NotificationService::NoDetails();
4431 if (details)
4432 det = Details<LoadNotificationDetails>(details);
4433 NotificationService::current()->Notify(
4434 type, Source<NavigationController>(&controller_), det);
4435}
4436
[email protected]02d7b6e2014-06-24 21:01:504437void WebContentsImpl::NotifyViewSwapped(RenderViewHost* old_host,
4438 RenderViewHost* new_host) {
[email protected]420ae012009-04-24 05:16:324439 // After sending out a swap notification, we need to send a disconnect
4440 // notification so that clients that pick up a pointer to |this| can NULL the
4441 // pointer. See Bug 1230284.
4442 notify_disconnection_ = true;
ericwilligersde386342016-10-19 02:35:094443 for (auto& observer : observers_)
4444 observer.RenderViewHostChanged(old_host, new_host);
[email protected]da7a7182013-09-06 08:11:114445
[email protected]7a846df2012-09-20 19:17:394446 // Ensure that the associated embedder gets cleared after a RenderViewHost
4447 // gets swapped, so we don't reuse the same embedder next time a
4448 // RenderViewHost is attached to this WebContents.
4449 RemoveBrowserPluginEmbedder();
[email protected]420ae012009-04-24 05:16:324450}
4451
[email protected]02d7b6e2014-06-24 21:01:504452void WebContentsImpl::NotifyFrameSwapped(RenderFrameHost* old_host,
4453 RenderFrameHost* new_host) {
Bo Liu168c8642017-08-28 18:26:024454#if defined(OS_ANDROID)
Bo Liu7c6779e92017-08-16 02:02:284455 // Try to copy importance from either |old_host| or parent of |new_host|.
4456 // If both are null, then this is the very first frame host created from Init.
4457 // There is no need to pass importance in this case because there is no chance
4458 // for anything to call SetImportance yet.
4459 RenderFrameHostImpl* importance_host = static_cast<RenderFrameHostImpl*>(
4460 old_host ? old_host : new_host->GetParent());
4461 if (importance_host) {
4462 static_cast<RenderFrameHostImpl*>(new_host)
4463 ->GetRenderWidgetHost()
4464 ->SetImportance(importance_host->GetRenderWidgetHost()->importance());
4465 }
Bo Liu168c8642017-08-28 18:26:024466#endif
ericwilligersde386342016-10-19 02:35:094467 for (auto& observer : observers_)
4468 observer.RenderFrameHostChanged(old_host, new_host);
[email protected]02d7b6e2014-06-24 21:01:504469}
4470
[email protected]da7a7182013-09-06 08:11:114471// TODO(avi): Remove this entire function because this notification is already
4472// covered by two observer functions. http://crbug.com/170921
[email protected]b172aee2012-04-10 17:05:264473void WebContentsImpl::NotifyDisconnected() {
[email protected]420ae012009-04-24 05:16:324474 if (!notify_disconnection_)
4475 return;
4476
4477 notify_disconnection_ = false;
[email protected]8ff00d72012-10-23 19:12:214478 NotificationService::current()->Notify(
4479 NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
4480 Source<WebContents>(this),
4481 NotificationService::NoDetails());
[email protected]420ae012009-04-24 05:16:324482}
4483
[email protected]cbb1ef592013-06-05 19:49:464484void WebContentsImpl::NotifyNavigationEntryCommitted(
4485 const LoadCommittedDetails& load_details) {
ericwilligersde386342016-10-19 02:35:094486 for (auto& observer : observers_)
4487 observer.NavigationEntryCommitted(load_details);
[email protected]cbb1ef592013-06-05 19:49:464488}
4489
Sam McNally5c087a32017-08-25 01:46:144490void WebContentsImpl::NotifyNavigationEntryChanged(
4491 const EntryChangedDetails& change_details) {
4492 for (auto& observer : observers_)
4493 observer.NavigationEntryChanged(change_details);
4494}
4495
4496void WebContentsImpl::NotifyNavigationListPruned(
4497 const PrunedDetails& pruned_details) {
4498 for (auto& observer : observers_)
4499 observer.NavigationListPruned(pruned_details);
4500}
4501
rockotf62002a2016-09-15 00:08:594502void WebContentsImpl::OnAssociatedInterfaceRequest(
4503 RenderFrameHost* render_frame_host,
4504 const std::string& interface_name,
4505 mojo::ScopedInterfaceEndpointHandle handle) {
4506 auto it = binding_sets_.find(interface_name);
4507 if (it != binding_sets_.end())
4508 it->second->OnRequestForFrame(render_frame_host, std::move(handle));
4509}
4510
Ben Goodger9e24929e2017-07-21 03:13:404511void WebContentsImpl::OnInterfaceRequest(
4512 RenderFrameHost* render_frame_host,
4513 const std::string& interface_name,
4514 mojo::ScopedMessagePipeHandle* interface_pipe) {
4515 for (auto& observer : observers_) {
4516 observer.OnInterfaceRequestFromFrame(render_frame_host, interface_name,
4517 interface_pipe);
4518 if (!interface_pipe->is_valid())
4519 break;
4520 }
4521}
4522
Nicolas Dossou-gbetebcab2472017-09-09 12:28:404523void WebContentsImpl::OnDidBlockFramebust(const GURL& url) {
4524 if (delegate_)
4525 delegate_->OnDidBlockFramebust(this, url);
4526}
4527
[email protected]c31a84802014-04-03 15:55:494528const GURL& WebContentsImpl::GetMainFrameLastCommittedURL() const {
4529 return GetLastCommittedURL();
4530}
4531
[email protected]b849847b2013-12-10 21:57:584532void WebContentsImpl::RenderFrameCreated(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:094533 for (auto& observer : observers_)
4534 observer.RenderFrameCreated(render_frame_host);
dmazzonif8a31042016-12-03 00:52:134535 UpdateAccessibilityModeOnFrame(render_frame_host);
clamy91b7abf2016-03-24 15:17:454536
4537 if (!render_frame_host->IsRenderFrameLive() || render_frame_host->GetParent())
4538 return;
4539
4540 NavigationEntry* entry = controller_.GetPendingEntry();
4541 if (entry && entry->IsViewSourceMode()) {
4542 // Put the renderer in view source mode.
4543 render_frame_host->Send(
4544 new FrameMsg_EnableViewSourceMode(render_frame_host->GetRoutingID()));
4545 }
[email protected]b849847b2013-12-10 21:57:584546}
4547
4548void WebContentsImpl::RenderFrameDeleted(RenderFrameHost* render_frame_host) {
creis3638897452017-05-09 22:07:504549 is_notifying_observers_ = true;
ericwilligersde386342016-10-19 02:35:094550 for (auto& observer : observers_)
4551 observer.RenderFrameDeleted(render_frame_host);
creis3638897452017-05-09 22:07:504552 is_notifying_observers_ = false;
zqzhang7b6f4f02016-12-07 22:10:224553#if BUILDFLAG(ENABLE_PLUGINS)
4554 pepper_playback_observer_->RenderFrameDeleted(render_frame_host);
4555#endif
[email protected]b849847b2013-12-10 21:57:584556}
4557
[email protected]a09d53ce2014-01-31 00:46:424558void WebContentsImpl::ShowContextMenu(RenderFrameHost* render_frame_host,
4559 const ContextMenuParams& params) {
avie9fd8722017-04-10 16:17:584560 // If a renderer fires off a second command to show a context menu before the
4561 // first context menu is closed, just ignore it. https://crbug.com/707534
ekaramadf6750aa2017-06-06 18:29:424562 if (showing_context_menu_)
avie9fd8722017-04-10 16:17:584563 return;
4564
[email protected]077e704b2014-05-23 19:24:104565 ContextMenuParams context_menu_params(params);
[email protected]a09d53ce2014-01-31 00:46:424566 // Allow WebContentsDelegates to handle the context menu operation first.
[email protected]077e704b2014-05-23 19:24:104567 if (delegate_ && delegate_->HandleContextMenu(context_menu_params))
[email protected]a09d53ce2014-01-31 00:46:424568 return;
4569
[email protected]077e704b2014-05-23 19:24:104570 render_view_host_delegate_view_->ShowContextMenu(render_frame_host,
4571 context_menu_params);
[email protected]a09d53ce2014-01-31 00:46:424572}
4573
avi777ff452017-02-09 19:04:484574void WebContentsImpl::RunJavaScriptDialog(RenderFrameHost* render_frame_host,
4575 const base::string16& message,
4576 const base::string16& default_prompt,
4577 const GURL& frame_url,
4578 JavaScriptDialogType dialog_type,
4579 IPC::Message* reply_msg) {
avi0720b02e2017-06-13 03:22:134580 // Running a dialog causes an exit to webpage-initiated fullscreen.
4581 // http://crbug.com/728276
4582 if (IsFullscreenForCurrentTab())
4583 ExitFullscreen(true);
4584
Avi Drissmane04d3992017-10-05 15:11:364585 auto callback =
4586 base::BindOnce(&WebContentsImpl::OnDialogClosed, base::Unretained(this),
4587 render_frame_host->GetProcess()->GetID(),
4588 render_frame_host->GetRoutingID(), reply_msg);
Pavel Feldman3c1842b2017-08-02 05:00:164589
Pavel Feldman3c1842b2017-08-02 05:00:164590 std::vector<protocol::PageHandler*> page_handlers =
4591 protocol::PageHandler::EnabledForWebContents(this);
4592
Pavel Feldmanfab3cb62017-10-05 01:02:014593 if (delegate_)
4594 dialog_manager_ = delegate_->GetJavaScriptDialogManager(this);
4595
4596 // Suppress JavaScript dialogs when requested. Also suppress messages when
4597 // showing an interstitial as it's shown over the previous page and we don't
4598 // want the hidden page's dialogs to interfere with the interstitial.
4599 bool should_suppress = ShowingInterstitialPage() ||
4600 (delegate_ && delegate_->ShouldSuppressDialogs(this));
4601 bool has_handlers = page_handlers.size() || (delegate_ && dialog_manager_);
4602 bool suppress_this_message = should_suppress || !has_handlers;
4603
4604 if (suppress_this_message) {
Avi Drissmane04d3992017-10-05 15:11:364605 std::move(callback).Run(true, false, base::string16());
Pavel Feldman3c1842b2017-08-02 05:00:164606 return;
4607 }
4608
4609 scoped_refptr<CloseDialogCallbackWrapper> wrapper =
Avi Drissmane04d3992017-10-05 15:11:364610 new CloseDialogCallbackWrapper(std::move(callback));
Pavel Feldman3c1842b2017-08-02 05:00:164611
4612 is_showing_javascript_dialog_ = true;
4613
4614 for (auto* handler : page_handlers) {
Avi Drissmane04d3992017-10-05 15:11:364615 handler->DidRunJavaScriptDialog(
4616 frame_url, message, default_prompt, dialog_type,
4617 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:164618 }
4619
4620 if (dialog_manager_) {
[email protected]87de04b02014-04-08 22:14:494621 dialog_manager_->RunJavaScriptDialog(
avi777ff452017-02-09 19:04:484622 this, frame_url, dialog_type, message, default_prompt,
Avi Drissmane04d3992017-10-05 15:11:364623 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false),
4624 &suppress_this_message);
[email protected]87de04b02014-04-08 22:14:494625 }
4626
4627 if (suppress_this_message) {
4628 // If we are suppressing messages, just reply as if the user immediately
4629 // pressed "Cancel", passing true to |dialog_was_suppressed|.
Avi Drissmane04d3992017-10-05 15:11:364630 wrapper->Run(true, false, base::string16());
[email protected]87de04b02014-04-08 22:14:494631 }
[email protected]87de04b02014-04-08 22:14:494632}
4633
4634void WebContentsImpl::RunBeforeUnloadConfirm(
[email protected]39f2f9252014-05-03 00:54:014635 RenderFrameHost* render_frame_host,
[email protected]87de04b02014-04-08 22:14:494636 bool is_reload,
4637 IPC::Message* reply_msg) {
avi0720b02e2017-06-13 03:22:134638 // Running a dialog causes an exit to webpage-initiated fullscreen.
4639 // http://crbug.com/728276
4640 if (IsFullscreenForCurrentTab())
4641 ExitFullscreen(true);
4642
[email protected]39f2f9252014-05-03 00:54:014643 RenderFrameHostImpl* rfhi =
4644 static_cast<RenderFrameHostImpl*>(render_frame_host);
[email protected]87de04b02014-04-08 22:14:494645 if (delegate_)
4646 delegate_->WillRunBeforeUnloadConfirm();
4647
Avi Drissmane04d3992017-10-05 15:11:364648 auto callback =
4649 base::BindOnce(&WebContentsImpl::OnDialogClosed, base::Unretained(this),
4650 render_frame_host->GetProcess()->GetID(),
4651 render_frame_host->GetRoutingID(), reply_msg);
Pavel Feldman3c1842b2017-08-02 05:00:164652
Pavel Feldman3c1842b2017-08-02 05:00:164653 std::vector<protocol::PageHandler*> page_handlers =
4654 protocol::PageHandler::EnabledForWebContents(this);
4655
Pavel Feldmanfab3cb62017-10-05 01:02:014656 if (delegate_)
4657 dialog_manager_ = delegate_->GetJavaScriptDialogManager(this);
4658
4659 bool should_suppress = ShowingInterstitialPage() || !rfhi->is_active() ||
4660 (delegate_ && delegate_->ShouldSuppressDialogs(this));
4661 bool has_handlers = page_handlers.size() || (delegate_ && dialog_manager_);
4662 if (should_suppress || !has_handlers) {
Avi Drissmane04d3992017-10-05 15:11:364663 std::move(callback).Run(false, true, base::string16());
[email protected]87de04b02014-04-08 22:14:494664 return;
4665 }
4666
4667 is_showing_before_unload_dialog_ = true;
Pavel Feldman3c1842b2017-08-02 05:00:164668
4669 scoped_refptr<CloseDialogCallbackWrapper> wrapper =
Avi Drissmane04d3992017-10-05 15:11:364670 new CloseDialogCallbackWrapper(std::move(callback));
Pavel Feldman3c1842b2017-08-02 05:00:164671
4672 GURL frame_url = rfhi->GetLastCommittedURL();
4673 for (auto* handler : page_handlers) {
Avi Drissmane04d3992017-10-05 15:11:364674 handler->DidRunBeforeUnloadConfirm(
4675 frame_url,
4676 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:164677 }
4678
4679 if (dialog_manager_) {
Avi Drissmane04d3992017-10-05 15:11:364680 dialog_manager_->RunBeforeUnloadDialog(
4681 this, is_reload,
4682 base::BindOnce(&CloseDialogCallbackWrapper::Run, wrapper, false));
Pavel Feldman3c1842b2017-08-02 05:00:164683 }
[email protected]87de04b02014-04-08 22:14:494684}
4685
naskoada75b22016-06-11 16:09:464686void WebContentsImpl::RunFileChooser(RenderFrameHost* render_frame_host,
4687 const FileChooserParams& params) {
4688 if (delegate_)
4689 delegate_->RunFileChooser(render_frame_host, params);
4690}
4691
[email protected]a86c0e962013-12-17 17:10:394692WebContents* WebContentsImpl::GetAsWebContents() {
4693 return this;
4694}
4695
mcnee336ea2c2017-05-23 22:50:594696#if !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:124697double WebContentsImpl::GetPendingPageZoomLevel() {
4698 NavigationEntry* pending_entry = GetController().GetPendingEntry();
4699 if (!pending_entry)
4700 return HostZoomMap::GetZoomLevel(this);
4701
4702 GURL url = pending_entry->GetURL();
4703 return HostZoomMap::GetForWebContents(this)->GetZoomLevelForHostAndScheme(
4704 url.scheme(), net::GetHostOrSpecFromURL(url));
4705}
mcnee336ea2c2017-05-23 22:50:594706#endif // !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:124707
qinmin72e8bd02016-10-21 19:35:374708bool WebContentsImpl::HideDownloadUI() const {
4709 return is_overlay_content_;
4710}
4711
mlamouri5cd9ae82017-02-18 11:05:094712bool WebContentsImpl::HasPersistentVideo() const {
4713 return has_persistent_video_;
4714}
4715
Alex Moshchuk27caae82017-09-11 23:11:184716RenderFrameHost* WebContentsImpl::GetPendingMainFrame() {
4717 if (IsBrowserSideNavigationEnabled())
4718 return GetRenderManager()->speculative_frame_host();
4719 return GetRenderManager()->pending_frame_host();
4720}
4721
mlamourie52c1b542017-02-23 14:57:504722bool WebContentsImpl::HasActiveEffectivelyFullscreenVideo() const {
4723 return media_web_contents_observer_->HasActiveEffectivelyFullscreenVideo();
4724}
4725
ekaramada110f642016-12-21 19:47:284726bool WebContentsImpl::IsFocusedElementEditable() {
4727 RenderFrameHostImpl* frame = GetFocusedFrame();
4728 return frame && frame->has_focused_editable_element();
4729}
4730
ekaramadf6750aa2017-06-06 18:29:424731bool WebContentsImpl::IsShowingContextMenu() const {
4732 return showing_context_menu_;
4733}
4734
4735void WebContentsImpl::SetShowingContextMenu(bool showing) {
4736 DCHECK_NE(showing_context_menu_, showing);
4737 showing_context_menu_ = showing;
4738
4739 if (auto* view = GetRenderWidgetHostView()) {
4740 // Notify the main frame's RWHV to run the platform-specific code, if any.
4741 static_cast<RenderWidgetHostViewBase*>(view)->SetShowingContextMenu(
4742 showing);
4743 }
4744}
4745
ekaramada110f642016-12-21 19:47:284746void WebContentsImpl::ClearFocusedElement() {
4747 if (auto* frame = GetFocusedFrame())
4748 frame->ClearFocusedElement();
4749}
4750
[email protected]7912e822014-04-16 02:37:034751bool WebContentsImpl::IsNeverVisible() {
4752 if (!delegate_)
4753 return false;
4754 return delegate_->IsNeverVisible(this);
4755}
4756
[email protected]5a3bdf52012-05-24 15:12:574757RenderViewHostDelegateView* WebContentsImpl::GetDelegateView() {
4758 return render_view_host_delegate_view_;
[email protected]420ae012009-04-24 05:16:324759}
4760
[email protected]8ff00d72012-10-23 19:12:214761RendererPreferences WebContentsImpl::GetRendererPrefs(
4762 BrowserContext* browser_context) const {
[email protected]840b1512009-07-21 16:53:464763 return renderer_preferences_;
[email protected]80d96fa2009-06-10 22:34:514764}
4765
[email protected]7a846df2012-09-20 19:17:394766void WebContentsImpl::RemoveBrowserPluginEmbedder() {
[email protected]59383c782013-04-17 16:43:274767 if (browser_plugin_embedder_)
[email protected]7a846df2012-09-20 19:17:394768 browser_plugin_embedder_.reset();
4769}
4770
avallee0206f782016-07-28 18:55:334771WebContentsImpl* WebContentsImpl::GetOuterWebContents() {
lfg601233692017-03-06 22:45:444772 if (GuestMode::IsCrossProcessFrameGuest(this))
4773 return node_.outer_web_contents();
ekaramad1beabecc2016-09-23 20:18:174774
4775 if (browser_plugin_guest_)
4776 return browser_plugin_guest_->embedder_web_contents();
4777
avallee0206f782016-07-28 18:55:334778 return nullptr;
4779}
4780
4781WebContentsImpl* WebContentsImpl::GetFocusedWebContents() {
lfg601233692017-03-06 22:45:444782 return GetOutermostWebContents()->node_.focused_web_contents();
avallee0206f782016-07-28 18:55:334783}
4784
avallee9993fca2016-11-17 06:16:504785bool WebContentsImpl::ContainsOrIsFocusedWebContents() {
4786 for (WebContentsImpl* focused_contents = GetFocusedWebContents();
4787 focused_contents;
4788 focused_contents = focused_contents->GetOuterWebContents()) {
4789 if (focused_contents == this)
4790 return true;
4791 }
4792
4793 return false;
4794}
4795
avallee0206f782016-07-28 18:55:334796WebContentsImpl* WebContentsImpl::GetOutermostWebContents() {
4797 WebContentsImpl* root = this;
4798 while (root->GetOuterWebContents())
4799 root = root->GetOuterWebContents();
4800 return root;
4801}
4802
avalleed68cdd12017-06-21 22:07:274803void WebContentsImpl::FocusOuterAttachmentFrameChain() {
4804 WebContentsImpl* outer_contents = GetOuterWebContents();
4805 if (!outer_contents)
4806 return;
4807
4808 FrameTreeNode* outer_node =
4809 FrameTreeNode::GloballyFindByID(GetOuterDelegateFrameTreeNodeId());
4810 outer_contents->frame_tree_.SetFocusedFrame(outer_node, nullptr);
4811
4812 // For a browser initiated focus change, let embedding renderer know of the
4813 // change. Otherwise, if the currently focused element is just across a
4814 // process boundary in focus order, it will not be possible to move across
4815 // that boundary. This is because the target element will already be focused
4816 // (that renderer was not notified) and drop the event.
4817 if (GetRenderManager()->GetProxyToOuterDelegate())
4818 GetRenderManager()->GetProxyToOuterDelegate()->SetFocusedFrame();
4819
4820 outer_contents->FocusOuterAttachmentFrameChain();
4821}
4822
[email protected]b172aee2012-04-10 17:05:264823void WebContentsImpl::RenderViewCreated(RenderViewHost* render_view_host) {
[email protected]86f98a22013-03-20 14:35:004824 if (delegate_)
[email protected]e85165c642014-06-10 14:34:314825 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]a6b73c62013-02-11 23:05:084826
[email protected]8ff00d72012-10-23 19:12:214827 NotificationService::current()->Notify(
4828 NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED,
4829 Source<WebContents>(this),
4830 Details<RenderViewHost>(render_view_host));
[email protected]420ae012009-04-24 05:16:324831
[email protected]60780f412013-02-25 16:34:104832 view_->RenderViewCreated(render_view_host);
[email protected]11f764bb2011-05-25 19:45:264833
ericwilligersde386342016-10-19 02:35:094834 for (auto& observer : observers_)
4835 observer.RenderViewCreated(render_view_host);
Joel Einbinder848001c2017-09-19 21:39:314836 if (delegate_)
4837 RenderFrameDevToolsAgentHost::WebContentsCreated(this);
[email protected]420ae012009-04-24 05:16:324838}
4839
[email protected]b172aee2012-04-10 17:05:264840void WebContentsImpl::RenderViewReady(RenderViewHost* rvh) {
[email protected]151a63d2011-12-20 22:32:524841 if (rvh != GetRenderViewHost()) {
[email protected]420ae012009-04-24 05:16:324842 // Don't notify the world, since this came from a renderer in the
4843 // background.
4844 return;
4845 }
4846
dmazzoni62111452017-04-28 23:46:554847 RenderWidgetHostViewBase* rwhv =
4848 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
4849 if (rwhv)
4850 rwhv->SetMainFrameAXTreeID(GetMainFrame()->GetAXTreeID());
4851
[email protected]da7a7182013-09-06 08:11:114852 notify_disconnection_ = true;
4853 // TODO(avi): Remove. http://crbug.com/170921
4854 NotificationService::current()->Notify(
4855 NOTIFICATION_WEB_CONTENTS_CONNECTED,
4856 Source<WebContents>(this),
4857 NotificationService::NoDetails());
4858
[email protected]be1f56ab2011-12-22 06:55:314859 bool was_crashed = IsCrashed();
[email protected]443b80e2010-12-14 00:42:234860 SetIsCrashed(base::TERMINATION_STATUS_STILL_RUNNING, 0);
[email protected]9d8a4642009-07-29 17:25:304861
4862 // Restore the focus to the tab (otherwise the focus will be on the top
4863 // window).
[email protected]484ae5912010-09-29 19:16:144864 if (was_crashed && !FocusLocationBarByDefault() &&
4865 (!delegate_ || delegate_->ShouldFocusPageAfterCrash())) {
[email protected]f3615f02013-02-26 06:09:064866 view_->Focus();
[email protected]484ae5912010-09-29 19:16:144867 }
[email protected]32ded2212011-11-10 18:51:434868
ericwilligersde386342016-10-19 02:35:094869 for (auto& observer : observers_)
4870 observer.RenderViewReady();
[email protected]420ae012009-04-24 05:16:324871}
4872
[email protected]ec6a7eb2013-04-22 17:34:224873void WebContentsImpl::RenderViewTerminated(RenderViewHost* rvh,
4874 base::TerminationStatus status,
4875 int error_code) {
[email protected]151a63d2011-12-20 22:32:524876 if (rvh != GetRenderViewHost()) {
[email protected]420ae012009-04-24 05:16:324877 // The pending page's RenderViewHost is gone.
4878 return;
4879 }
4880
[email protected]2fcdcc32014-03-05 02:14:074881 // Ensure fullscreen mode is exited in the |delegate_| since a crashed
4882 // renderer may not have made a clean exit.
alexmos5dd617d2016-06-07 04:21:154883 if (IsFullscreenForCurrentTab())
bokanece34a82016-01-28 19:49:464884 ExitFullscreenMode(false);
[email protected]2fcdcc32014-03-05 02:14:074885
[email protected]698191dc2014-02-25 01:06:134886 // Cancel any visible dialogs so they are not left dangling over the sad tab.
creis89a0f782015-05-27 16:13:174887 CancelActiveAndPendingDialogs();
[email protected]698191dc2014-02-25 01:06:134888
dalecurtis3d1e1302017-02-20 22:33:254889 audio_stream_monitor_.RenderProcessGone(rvh->GetProcess()->GetID());
4890
[email protected]960b0372014-05-19 18:01:004891 // Reset the loading progress. TODO(avi): What does it mean to have a
4892 // "renderer crash" when there is more than one renderer process serving a
4893 // webpage? Once this function is called at a more granular frame level, we
4894 // probably will need to more granularly reset the state here.
4895 ResetLoadProgressState();
clamy44e84ce2016-02-22 15:38:254896 NotifyDisconnected();
4897 SetIsCrashed(status, error_code);
[email protected]960b0372014-05-19 18:01:004898
ericwilligersde386342016-10-19 02:35:094899 for (auto& observer : observers_)
4900 observer.RenderProcessGone(GetCrashedStatus());
[email protected]420ae012009-04-24 05:16:324901}
4902
[email protected]b172aee2012-04-10 17:05:264903void WebContentsImpl::RenderViewDeleted(RenderViewHost* rvh) {
ericwilligersde386342016-10-19 02:35:094904 for (auto& observer : observers_)
4905 observer.RenderViewDeleted(rvh);
[email protected]2e4633c2009-07-09 16:58:064906}
4907
sky8b00392d2015-01-10 00:30:284908void WebContentsImpl::UpdateTargetURL(RenderViewHost* render_view_host,
4909 const GURL& url) {
4910 if (fullscreen_widget_routing_id_ != MSG_ROUTING_NONE) {
4911 // If we're fullscreen only update the url if it's from the fullscreen
4912 // renderer.
4913 RenderWidgetHostView* fs = GetFullscreenRenderWidgetHostView();
avif9ab5d942015-10-15 14:05:444914 if (fs && fs->GetRenderWidgetHost() != render_view_host->GetWidget())
sky8b00392d2015-01-10 00:30:284915 return;
4916 }
[email protected]6934a702011-12-20 00:04:514917 if (delegate_)
avi450ce00e2014-09-24 01:58:524918 delegate_->UpdateTargetURL(this, url);
[email protected]420ae012009-04-24 05:16:324919}
4920
[email protected]b172aee2012-04-10 17:05:264921void WebContentsImpl::Close(RenderViewHost* rvh) {
[email protected]60780f412013-02-25 16:34:104922#if defined(OS_MACOSX)
[email protected]07707302009-11-06 00:50:294923 // The UI may be in an event-tracking loop, such as between the
4924 // mouse-down and mouse-up in text selection or a button click.
4925 // Defer the close until after tracking is complete, so that we
4926 // don't free objects out from under the UI.
[email protected]07707302009-11-06 00:50:294927 // TODO(shess): This could get more fine-grained. For instance,
4928 // closing a tab in another window while selecting text in the
4929 // current window's Omnibox should be just fine.
[email protected]60780f412013-02-25 16:34:104930 if (view_->IsEventTracking()) {
4931 view_->CloseTabAfterEventTracking();
[email protected]07707302009-11-06 00:50:294932 return;
4933 }
[email protected]60780f412013-02-25 16:34:104934#endif
[email protected]07707302009-11-06 00:50:294935
[email protected]420ae012009-04-24 05:16:324936 // Ignore this if it comes from a RenderViewHost that we aren't showing.
[email protected]151a63d2011-12-20 22:32:524937 if (delegate_ && rvh == GetRenderViewHost())
[email protected]6934a702011-12-20 00:04:514938 delegate_->CloseContents(this);
[email protected]420ae012009-04-24 05:16:324939}
4940
[email protected]b172aee2012-04-10 17:05:264941void WebContentsImpl::RequestMove(const gfx::Rect& new_bounds) {
[email protected]6934a702011-12-20 00:04:514942 if (delegate_ && delegate_->IsPopupOrPanel(this))
4943 delegate_->MoveContents(this, new_bounds);
[email protected]420ae012009-04-24 05:16:324944}
4945
fdegansa696e5112015-04-17 01:57:594946void WebContentsImpl::DidStartLoading(FrameTreeNode* frame_tree_node,
[email protected]e3b10d12014-03-28 16:06:094947 bool to_different_document) {
Evan Stadec3b26022017-07-14 19:50:244948 LoadingStateChanged(frame_tree_node->IsMainFrame() && to_different_document,
4949 false, nullptr);
dmazzonibf8cec42015-02-08 08:28:084950
4951 // Notify accessibility that the user is navigating away from the
4952 // current document.
4953 //
4954 // TODO(dmazzoni): do this using a WebContentsObserver.
dmazzonibf8cec42015-02-08 08:28:084955 BrowserAccessibilityManager* manager =
fdegansa696e5112015-04-17 01:57:594956 frame_tree_node->current_frame_host()->browser_accessibility_manager();
dmazzonibf8cec42015-02-08 08:28:084957 if (manager)
4958 manager->UserIsNavigatingAway();
[email protected]420ae012009-04-24 05:16:324959}
4960
fdegansc73eec22015-03-19 14:47:544961void WebContentsImpl::DidStopLoading() {
dcheng59716272016-04-09 05:19:084962 std::unique_ptr<LoadNotificationDetails> details;
[email protected]420ae012009-04-24 05:16:324963
[email protected]9595fd82013-04-19 21:28:494964 // Use the last committed entry rather than the active one, in case a
4965 // pending entry has been created.
4966 NavigationEntry* entry = controller_.GetLastCommittedEntry();
[email protected]3691e5cf2014-01-22 10:16:204967 Navigator* navigator = frame_tree_.root()->navigator();
[email protected]9595fd82013-04-19 21:28:494968
[email protected]420ae012009-04-24 05:16:324969 // An entry may not exist for a stop when loading an initial blank page or
4970 // if an iframe injected by script into a blank page finishes loading.
4971 if (entry) {
[email protected]3691e5cf2014-01-22 10:16:204972 base::TimeDelta elapsed =
4973 base::TimeTicks::Now() - navigator->GetCurrentLoadStart();
[email protected]420ae012009-04-24 05:16:324974
4975 details.reset(new LoadNotificationDetails(
[email protected]36fc0392011-12-25 03:59:514976 entry->GetVirtualURL(),
[email protected]420ae012009-04-24 05:16:324977 elapsed,
4978 &controller_,
4979 controller_.GetCurrentEntryIndex()));
4980 }
4981
clamy44e84ce2016-02-22 15:38:254982 LoadingStateChanged(true, false, details.get());
[email protected]420ae012009-04-24 05:16:324983}
4984
fdegansa696e5112015-04-17 01:57:594985void WebContentsImpl::DidChangeLoadProgress() {
4986 double load_progress = frame_tree_.load_progress();
4987
4988 // The delegate is notified immediately for the first and last updates. Also,
4989 // since the message loop may be pretty busy when a page is loaded, it might
4990 // not execute a posted task in a timely manner so the progress report is sent
4991 // immediately if enough time has passed.
4992 base::TimeDelta min_delay =
4993 base::TimeDelta::FromMilliseconds(kMinimumDelayBetweenLoadingUpdatesMS);
4994 bool delay_elapsed = loading_last_progress_update_.is_null() ||
4995 base::TimeTicks::Now() - loading_last_progress_update_ > min_delay;
4996
4997 if (load_progress == 0.0 || load_progress == 1.0 || delay_elapsed) {
4998 // If there is a pending task to send progress, it is now obsolete.
4999 loading_weak_factory_.InvalidateWeakPtrs();
5000
5001 // Notify the load progress change.
5002 SendChangeLoadProgress();
5003
5004 // Clean-up the states if needed.
5005 if (load_progress == 1.0)
5006 ResetLoadProgressState();
5007 return;
5008 }
5009
5010 if (loading_weak_factory_.HasWeakPtrs())
5011 return;
5012
skyostil95082a62015-06-05 19:53:075013 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
tzike2aca992017-09-05 08:50:545014 FROM_HERE,
5015 base::BindOnce(&WebContentsImpl::SendChangeLoadProgress,
5016 loading_weak_factory_.GetWeakPtr()),
fdegansa696e5112015-04-17 01:57:595017 min_delay);
5018}
5019
avid6d88b912017-01-13 00:16:005020std::vector<std::unique_ptr<NavigationThrottle>>
5021WebContentsImpl::CreateThrottlesForNavigation(
clamycbf524d42016-09-27 12:48:355022 NavigationHandle* navigation_handle) {
5023 return GetContentClient()->browser()->CreateThrottlesForNavigation(
5024 navigation_handle);
5025}
5026
clamy1e5574e2016-09-29 16:48:445027std::unique_ptr<NavigationUIData> WebContentsImpl::GetNavigationUIData(
5028 NavigationHandle* navigation_handle) {
5029 DCHECK(IsBrowserSideNavigationEnabled());
5030 return GetContentClient()->browser()->GetNavigationUIData(navigation_handle);
5031}
5032
pdr15f5b5b2017-06-20 00:58:005033void WebContentsImpl::DidCancelLoading() {
5034 controller_.DiscardNonCommittedEntries();
5035
5036 // Update the URL display.
5037 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
5038}
5039
[email protected]59167c22013-06-03 18:07:325040void WebContentsImpl::DidAccessInitialDocument() {
[email protected]b4c84012014-04-28 19:51:105041 has_accessed_initial_document_ = true;
5042
[email protected]d1371bf8e2014-04-19 03:26:245043 // We may have left a failed browser-initiated navigation in the address bar
5044 // to let the user edit it and try again. Clear it now that content might
5045 // show up underneath it.
5046 if (!IsLoading() && controller_.GetPendingEntry())
avi45a72532015-04-07 21:01:455047 controller_.DiscardPendingEntry(false);
[email protected]d1371bf8e2014-04-19 03:26:245048
[email protected]59167c22013-06-03 18:07:325049 // Update the URL display.
thestigc4cac8f2014-09-04 21:17:505050 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
[email protected]59167c22013-06-03 18:07:325051}
5052
alexmosbe2f4c32015-03-10 02:30:235053void WebContentsImpl::DidChangeName(RenderFrameHost* render_frame_host,
5054 const std::string& name) {
ericwilligersde386342016-10-19 02:35:095055 for (auto& observer : observers_)
5056 observer.FrameNameChanged(render_frame_host, name);
alexmosbe2f4c32015-03-10 02:30:235057}
5058
[email protected]39f2f9252014-05-03 00:54:015059void WebContentsImpl::DocumentOnLoadCompleted(
[email protected]50279492014-05-05 23:24:295060 RenderFrameHost* render_frame_host) {
falken52a56e32016-12-08 05:02:405061 ShowInsecureLocalhostWarningIfNeeded();
5062
creis97867aa2017-02-17 18:39:455063 is_notifying_observers_ = true;
ericwilligersde386342016-10-19 02:35:095064 for (auto& observer : observers_)
5065 observer.DocumentOnLoadCompletedInMainFrame();
creis97867aa2017-02-17 18:39:455066 is_notifying_observers_ = false;
[email protected]6578fef2013-10-14 02:35:095067
5068 // TODO(avi): Remove. http://crbug.com/170921
[email protected]8ff00d72012-10-23 19:12:215069 NotificationService::current()->Notify(
5070 NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
5071 Source<WebContents>(this),
[email protected]50279492014-05-05 23:24:295072 NotificationService::NoDetails());
[email protected]25497492010-09-11 15:15:085073}
5074
creis8eb8ef22015-11-04 22:51:385075void WebContentsImpl::UpdateStateForFrame(RenderFrameHost* render_frame_host,
5076 const PageState& page_state) {
creis8eb8ef22015-11-04 22:51:385077 // The state update affects the last NavigationEntry associated with the given
5078 // |render_frame_host|. This may not be the last committed NavigationEntry (as
5079 // in the case of an UpdateState from a frame being swapped out). We track
5080 // which entry this is in the RenderFrameHost's nav_entry_id.
5081 RenderFrameHostImpl* rfhi =
5082 static_cast<RenderFrameHostImpl*>(render_frame_host);
5083 NavigationEntryImpl* entry =
5084 controller_.GetEntryWithUniqueID(rfhi->nav_entry_id());
5085 if (!entry)
5086 return;
5087
5088 FrameNavigationEntry* frame_entry =
5089 entry->GetFrameEntry(rfhi->frame_tree_node());
5090 if (!frame_entry)
5091 return;
5092
creisd06a9422015-11-11 03:08:455093 // The SiteInstance might not match if we do a cross-process navigation with
5094 // replacement (e.g., auto-subframe), in which case the swap out of the old
5095 // RenderFrameHost runs in the background after the old FrameNavigationEntry
5096 // has already been replaced and destroyed.
5097 if (frame_entry->site_instance() != rfhi->GetSiteInstance())
5098 return;
5099
creis8eb8ef22015-11-04 22:51:385100 if (page_state == frame_entry->page_state())
5101 return; // Nothing to update.
5102
creis0cade2e2017-02-28 06:37:475103 DCHECK(page_state.IsValid()) << "Shouldn't set an empty PageState.";
nasko34634672016-07-29 18:46:065104
5105 // The document_sequence_number and item_sequence_number recorded in the
5106 // FrameNavigationEntry should not differ from the one coming with the update,
5107 // since it must come from the same document. Do not update it if a difference
5108 // is detected, as this indicates that |frame_entry| is not the correct one.
5109 ExplodedPageState exploded_state;
5110 if (!DecodePageState(page_state.ToEncodedData(), &exploded_state))
5111 return;
5112
5113 if (exploded_state.top.document_sequence_number !=
5114 frame_entry->document_sequence_number() ||
5115 exploded_state.top.item_sequence_number !=
5116 frame_entry->item_sequence_number()) {
5117 return;
5118 }
5119
nasko04a322f25a2016-09-01 00:00:345120 frame_entry->SetPageState(page_state);
creis8eb8ef22015-11-04 22:51:385121 controller_.NotifyEntryChanged(entry);
5122}
5123
[email protected]ef3adfc2014-05-11 00:04:545124void WebContentsImpl::UpdateTitle(RenderFrameHost* render_frame_host,
[email protected]ef3adfc2014-05-11 00:04:545125 const base::string16& title,
5126 base::i18n::TextDirection title_direction) {
[email protected]ef3adfc2014-05-11 00:04:545127 // If we have a title, that's a pretty good indication that we've started
5128 // getting useful data.
5129 SetNotWaitingForResponse();
5130
5131 // Try to find the navigation entry, which might not be the current one.
avi286019ce2015-07-29 01:26:585132 // For example, it might be from a recently swapped out RFH.
avi1edc8552016-10-13 21:37:165133 NavigationEntryImpl* entry = controller_.GetEntryWithUniqueID(
creisad8c31a2016-05-24 17:07:045134 static_cast<RenderFrameHostImpl*>(render_frame_host)->nav_entry_id());
[email protected]ef3adfc2014-05-11 00:04:545135
5136 // We can handle title updates when we don't have an entry in
5137 // UpdateTitleForEntry, but only if the update is from the current RVH.
5138 // TODO(avi): Change to make decisions based on the RenderFrameHost.
avi286019ce2015-07-29 01:26:585139 if (!entry && render_frame_host != GetMainFrame())
[email protected]ef3adfc2014-05-11 00:04:545140 return;
5141
5142 // TODO(evan): make use of title_direction.
5143 // http://code.google.com/p/chromium/issues/detail?id=27094
afakhry6f0c1ec22016-07-14 13:55:135144 UpdateTitleForEntry(entry, title);
[email protected]ef3adfc2014-05-11 00:04:545145}
5146
5147void WebContentsImpl::UpdateEncoding(RenderFrameHost* render_frame_host,
5148 const std::string& encoding) {
5149 SetEncoding(encoding);
5150}
5151
[email protected]39f2f9252014-05-03 00:54:015152void WebContentsImpl::DocumentAvailableInMainFrame(
5153 RenderViewHost* render_view_host) {
ericwilligersde386342016-10-19 02:35:095154 for (auto& observer : observers_)
5155 observer.DocumentAvailableInMainFrame();
[email protected]39f2f9252014-05-03 00:54:015156}
naskoc0fceff2015-04-30 15:53:525157
[email protected]e1c3a552012-05-04 20:51:325158void WebContentsImpl::RouteCloseEvent(RenderViewHost* rvh) {
5159 // Tell the active RenderViewHost to run unload handlers and close, as long
5160 // as the request came from a RenderViewHost in the same BrowsingInstance.
5161 // In most cases, we receive this from a swapped out RenderViewHost.
5162 // It is possible to receive it from one that has just been swapped in,
5163 // in which case we might as well deliver the message anyway.
5164 if (rvh->GetSiteInstance()->IsRelatedSiteInstance(GetSiteInstance()))
naskoc0fceff2015-04-30 15:53:525165 ClosePage();
[email protected]e1c3a552012-05-04 20:51:325166}
5167
alexmose7da5a12015-04-09 02:22:165168bool WebContentsImpl::ShouldRouteMessageEvent(
5169 RenderFrameHost* target_rfh,
5170 SiteInstance* source_site_instance) const {
5171 // Allow the message if this WebContents is dedicated to a browser plugin
5172 // guest.
[email protected]0eba810b2012-10-18 03:19:365173 // Note: This check means that an embedder could theoretically receive a
5174 // postMessage from anyone (not just its own guests). However, this is
5175 // probably not a risk for apps since other pages won't have references
5176 // to App windows.
alexmose7da5a12015-04-09 02:22:165177 return GetBrowserPluginGuest() || GetBrowserPluginEmbedder();
5178}
[email protected]f546640b2012-05-15 00:03:495179
alexmos58729042015-06-18 23:20:005180void WebContentsImpl::EnsureOpenerProxiesExist(RenderFrameHost* source_rfh) {
alexmose7da5a12015-04-09 02:22:165181 WebContentsImpl* source_web_contents = static_cast<WebContentsImpl*>(
5182 WebContents::FromRenderFrameHost(source_rfh));
[email protected]f546640b2012-05-15 00:03:495183
alexmose7da5a12015-04-09 02:22:165184 if (source_web_contents) {
lazyboy6ec48b2a2015-06-29 15:18:145185 // If this message is going to outer WebContents from inner WebContents,
5186 // then we should not create a RenderView. AttachToOuterWebContentsFrame()
5187 // already created a RenderFrameProxyHost for that purpose.
5188 if (GetBrowserPluginEmbedder() &&
ekaramad1beabecc2016-09-23 20:18:175189 GuestMode::IsCrossProcessFrameGuest(source_web_contents)) {
lazyboy6ec48b2a2015-06-29 15:18:145190 return;
5191 }
5192
lfg812874d2016-02-09 22:26:135193 if (this != source_web_contents && GetBrowserPluginGuest()) {
naskob3041b98a42016-03-12 04:43:065194 // We create a RenderFrameProxyHost for the embedder in the guest's render
5195 // process but we intentionally do not expose the embedder's opener chain
5196 // to it.
5197 source_web_contents->GetRenderManager()->CreateRenderFrameProxy(
5198 GetSiteInstance());
[email protected]f546640b2012-05-15 00:03:495199 } else {
alexmos58729042015-06-18 23:20:005200 RenderFrameHostImpl* source_rfhi =
5201 static_cast<RenderFrameHostImpl*>(source_rfh);
5202 source_rfhi->frame_tree_node()->render_manager()->CreateOpenerProxies(
alexmos90325cf2015-09-02 17:18:395203 GetSiteInstance(), nullptr);
[email protected]f546640b2012-05-15 00:03:495204 }
5205 }
[email protected]f546640b2012-05-15 00:03:495206}
5207
avallee9993fca2016-11-17 06:16:505208void WebContentsImpl::SetAsFocusedWebContentsIfNecessary() {
5209 // Only change focus if we are not currently focused.
5210 WebContentsImpl* old_contents = GetFocusedWebContents();
5211 if (old_contents == this)
5212 return;
5213
paulmeyerfeafc2d2017-04-25 21:46:405214 GetOutermostWebContents()->node_.SetFocusedWebContents(this);
5215
Greg Thompsonfb957602017-09-04 10:25:525216 if (!GuestMode::IsCrossProcessFrameGuest(this) && browser_plugin_guest_)
paulmeyerfeafc2d2017-04-25 21:46:405217 return;
5218
avallee9993fca2016-11-17 06:16:505219 // Send a page level blur to the old contents so that it displays inactive UI
5220 // and focus this contents to activate it.
5221 if (old_contents)
5222 old_contents->GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(false);
avalleec2ff1ef2017-01-21 00:12:305223
5224 // Make sure the outer web contents knows our frame is focused. Otherwise, the
5225 // outer renderer could have the element before or after the frame element
5226 // focused which would return early without actually advancing focus.
avalleed68cdd12017-06-21 22:07:275227 FocusOuterAttachmentFrameChain();
avalleec2ff1ef2017-01-21 00:12:305228
lfg1453e412017-04-11 00:48:505229 if (ShowingInterstitialPage()) {
creisadca9862017-06-16 19:12:115230 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:505231 ->GetRenderWidgetHost()
5232 ->SetPageFocus(true);
5233 } else {
5234 GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(true);
5235 }
avallee9993fca2016-11-17 06:16:505236}
5237
avallee0206f782016-07-28 18:55:335238void WebContentsImpl::SetFocusedFrame(FrameTreeNode* node,
5239 SiteInstance* source) {
avallee0206f782016-07-28 18:55:335240 frame_tree_.SetFocusedFrame(node, source);
avalleed68cdd12017-06-21 22:07:275241
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:575242 if (auto* inner_contents = node_.GetInnerWebContentsInFrame(node)) {
5243 // |this| is an outer WebContents and |node| represents an inner
5244 // WebContents. Transfer the focus to the inner contents if |this| is
5245 // focused.
5246 if (GetFocusedWebContents() == this)
5247 inner_contents->SetAsFocusedWebContentsIfNecessary();
5248 } else if (node_.OuterContentsFrameTreeNode() &&
5249 node_.OuterContentsFrameTreeNode()
5250 ->current_frame_host()
5251 ->GetSiteInstance() == source) {
5252 // |this| is an inner WebContents, |node| is its main FrameTreeNode and
5253 // the outer WebContents FrameTreeNode is at |source|'s SiteInstance.
5254 // Transfer the focus to the inner WebContents if the outer WebContents is
5255 // focused. This branch is used when an inner WebContents is focused through
5256 // its RenderFrameProxyHost (via FrameHostMsg_FrameFocused IPC, used to
5257 // implement the window.focus() API).
5258 if (GetFocusedWebContents() == GetOuterWebContents())
5259 SetAsFocusedWebContentsIfNecessary();
5260 } else if (!GetOuterWebContents()) {
5261 // This is an outermost WebContents.
5262 SetAsFocusedWebContentsIfNecessary();
5263 } else if (!GuestMode::IsCrossProcessFrameGuest(this) &&
5264 GetOuterWebContents()) {
5265 // TODO(lfg, paulmeyer): Allows BrowserPlugins to set themselves as the
5266 // focused WebContents. This works around a bug in FindRequestManager that
5267 // doesn't support properly traversing BrowserPlugins.
5268 SetAsFocusedWebContentsIfNecessary();
5269 }
avalleed68cdd12017-06-21 22:07:275270}
5271
5272RenderFrameHost* WebContentsImpl::GetFocusedFrameIncludingInnerWebContents() {
5273 WebContentsImpl* contents = this;
5274 FrameTreeNode* focused_node = contents->frame_tree_.GetFocusedFrame();
5275
5276 // If there is no focused frame in the outer WebContents, we need to return
5277 // null.
5278 if (!focused_node)
5279 return nullptr;
5280
5281 // If the focused frame is embedding an inner WebContents, we must descend
5282 // into that contents. If the current WebContents does not have a focused
5283 // frame, return the main frame of this contents instead of the focused empty
5284 // frame embedding this contents.
5285 while (true) {
5286 contents = contents->node_.GetInnerWebContentsInFrame(focused_node);
5287 if (!contents)
5288 return focused_node->current_frame_host();
5289
5290 focused_node = contents->frame_tree_.GetFocusedFrame();
5291 if (!focused_node)
5292 return contents->GetMainFrame();
5293 }
avallee0206f782016-07-28 18:55:335294}
5295
Lucas Furukawa Gadaniabbfa342017-08-29 19:37:575296void WebContentsImpl::OnAdvanceFocus(RenderFrameHostImpl* source_rfh) {
5297 // When a RenderFrame needs to advance focus to a RenderFrameProxy (by hitting
5298 // TAB), the RenderFrameProxy sends an IPC to RenderFrameProxyHost. When this
5299 // RenderFrameProxyHost represents an inner WebContents, the outer WebContents
5300 // needs to focus the inner WebContents.
5301 if (GetOuterWebContents() &&
5302 GetOuterWebContents() == source_rfh->delegate()->GetAsWebContents() &&
5303 GetFocusedWebContents() == GetOuterWebContents()) {
5304 SetAsFocusedWebContentsIfNecessary();
5305 }
5306}
5307
ekaramada110f642016-12-21 19:47:285308void WebContentsImpl::OnFocusedElementChangedInFrame(
5309 RenderFrameHostImpl* frame,
5310 const gfx::Rect& bounds_in_root_view) {
5311 RenderWidgetHostViewBase* root_view =
5312 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
5313 if (!root_view || !frame->GetView())
5314 return;
5315
5316 // Converting to screen coordinates.
5317 gfx::Point origin = bounds_in_root_view.origin();
5318 origin += root_view->GetViewBounds().OffsetFromOrigin();
5319 gfx::Rect bounds_in_screen(origin, bounds_in_root_view.size());
5320
5321 root_view->FocusedNodeChanged(frame->has_focused_editable_element(),
5322 bounds_in_screen);
5323
5324 FocusedNodeDetails details = {frame->has_focused_editable_element(),
5325 bounds_in_screen};
5326
5327 // TODO(ekaramad): We should replace this with an observer notification
5328 // (https://crbug.com/675975).
5329 NotificationService::current()->Notify(
5330 NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
5331 Source<RenderViewHost>(GetRenderViewHost()),
5332 Details<FocusedNodeDetails>(&details));
5333}
5334
avia90ae4e2016-11-11 20:49:335335bool WebContentsImpl::DidAddMessageToConsole(int32_t level,
5336 const base::string16& message,
5337 int32_t line_no,
5338 const base::string16& source_id) {
[email protected]a796f202012-05-30 14:14:255339 if (!delegate_)
5340 return false;
avia90ae4e2016-11-11 20:49:335341 return delegate_->DidAddMessageToConsole(this, level, message, line_no,
5342 source_id);
[email protected]a796f202012-05-30 14:14:255343}
5344
dominickn9c7ceaa32016-02-27 01:52:535345void WebContentsImpl::OnUserInteraction(
5346 RenderWidgetHostImpl* render_widget_host,
5347 const blink::WebInputEvent::Type type) {
kenrb19221852016-04-29 17:21:405348 // Ignore unless the widget is currently in the frame tree.
5349 if (!HasMatchingWidgetHost(&frame_tree_, render_widget_host))
avic3aa8422015-11-09 20:57:225350 return;
5351
ericwilligersde386342016-10-19 02:35:095352 for (auto& observer : observers_)
5353 observer.DidGetUserInteraction(type);
dominickn9c7ceaa32016-02-27 01:52:535354
5355 ResourceDispatcherHostImpl* rdh = ResourceDispatcherHostImpl::Get();
5356 // Exclude scroll events as user gestures for resource load dispatches.
5357 // rdh is NULL in unittests.
Blink Reformat1c4d759e2017-04-09 16:34:545358 if (rdh && type != blink::WebInputEvent::kMouseWheel)
scottmge22a5e52016-06-30 00:36:515359 rdh->OnUserGesture();
dominickn2dd142dd2015-10-29 05:30:505360}
5361
avallee9993fca2016-11-17 06:16:505362void WebContentsImpl::FocusOwningWebContents(
5363 RenderWidgetHostImpl* render_widget_host) {
5364 // The PDF plugin still runs as a BrowserPlugin and must go through the
5365 // input redirection mechanism. It must not become focused direcly.
5366 if (!GuestMode::IsCrossProcessFrameGuest(this) && browser_plugin_guest_)
5367 return;
5368
5369 RenderWidgetHostImpl* focused_widget =
5370 GetFocusedRenderWidgetHost(render_widget_host);
5371
5372 if (focused_widget != render_widget_host &&
avallee8e881592016-11-19 00:39:305373 (!focused_widget ||
5374 focused_widget->delegate() != render_widget_host->delegate())) {
avallee9993fca2016-11-17 06:16:505375 SetAsFocusedWebContentsIfNecessary();
5376 }
5377}
5378
[email protected]b172aee2012-04-10 17:05:265379void WebContentsImpl::OnIgnoredUIEvent() {
[email protected]31145092011-09-30 01:49:445380 // Notify observers.
ericwilligersde386342016-10-19 02:35:095381 for (auto& observer : observers_)
5382 observer.DidGetIgnoredUIEvent();
[email protected]fa1cf0b82010-01-15 21:49:445383}
5384
avic3aa8422015-11-09 20:57:225385void WebContentsImpl::RendererUnresponsive(
avice799302017-03-09 16:34:595386 RenderWidgetHostImpl* render_widget_host) {
ericwilligersde386342016-10-19 02:35:095387 for (auto& observer : observers_)
5388 observer.OnRendererUnresponsive(render_widget_host);
afakhry98241832016-03-11 19:27:475389
[email protected]992db4c2011-05-12 15:37:155390 // Don't show hung renderer dialog for a swapped out RVH.
avic3aa8422015-11-09 20:57:225391 if (render_widget_host != GetRenderViewHost()->GetWidget())
[email protected]992db4c2011-05-12 15:37:155392 return;
5393
avic031d392017-03-03 03:09:425394 if (ShouldIgnoreUnresponsiveRenderer())
[email protected]e5fc1632011-08-08 07:51:535395 return;
5396
creisc014b402015-04-23 16:41:455397 if (!GetRenderViewHost() || !GetRenderViewHost()->IsRenderViewLive())
[email protected]55452902011-06-01 21:57:475398 return;
5399
dtapuskae99ec6e52016-10-18 00:15:425400 if (delegate_) {
5401 WebContentsUnresponsiveState unresponsive_state;
dtapuskae99ec6e52016-10-18 00:15:425402 unresponsive_state.outstanding_ack_count =
5403 render_widget_host->in_flight_event_count();
5404 unresponsive_state.outstanding_event_type =
5405 render_widget_host->hang_monitor_event_type();
5406 unresponsive_state.last_event_type = render_widget_host->last_event_type();
5407 delegate_->RendererUnresponsive(this, unresponsive_state);
5408 }
[email protected]420ae012009-04-24 05:16:325409}
5410
avic3aa8422015-11-09 20:57:225411void WebContentsImpl::RendererResponsive(
5412 RenderWidgetHostImpl* render_widget_host) {
5413 if (render_widget_host != GetRenderViewHost()->GetWidget())
5414 return;
5415
[email protected]6934a702011-12-20 00:04:515416 if (delegate_)
5417 delegate_->RendererResponsive(this);
[email protected]420ae012009-04-24 05:16:325418}
5419
[email protected]b172aee2012-04-10 17:05:265420void WebContentsImpl::BeforeUnloadFiredFromRenderManager(
[email protected]feaded02012-09-25 19:12:555421 bool proceed, const base::TimeTicks& proceed_time,
[email protected]420ae012009-04-24 05:16:325422 bool* proceed_to_fire_unload) {
ericwilligersde386342016-10-19 02:35:095423 for (auto& observer : observers_)
5424 observer.BeforeUnloadFired(proceed_time);
[email protected]6934a702011-12-20 00:04:515425 if (delegate_)
5426 delegate_->BeforeUnloadFired(this, proceed, proceed_to_fire_unload);
[email protected]e80af492013-06-24 21:52:095427 // Note: |this| might be deleted at this point.
[email protected]420ae012009-04-24 05:16:325428}
5429
[email protected]58d5cfe2013-07-10 02:40:525430void WebContentsImpl::RenderProcessGoneFromRenderManager(
[email protected]3a3d47472010-07-15 21:03:545431 RenderViewHost* render_view_host) {
[email protected]443b80e2010-12-14 00:42:235432 DCHECK(crashed_status_ != base::TERMINATION_STATUS_STILL_RUNNING);
[email protected]ec6a7eb2013-04-22 17:34:225433 RenderViewTerminated(render_view_host, crashed_status_, crashed_error_code_);
[email protected]3a3d47472010-07-15 21:03:545434}
5435
[email protected]b172aee2012-04-10 17:05:265436void WebContentsImpl::UpdateRenderViewSizeForRenderManager() {
[email protected]8643e6d2012-01-18 20:26:105437 // TODO(brettw) this is a hack. See WebContentsView::SizeContents.
[email protected]dc0fd432013-08-27 15:29:215438 gfx::Size size = GetSizeForNewRenderView();
[email protected]0323ee42010-02-17 22:03:265439 // 0x0 isn't a valid window size (minimal window size is 1x1) but it may be
5440 // here during container initialization and normal window size will be set
5441 // later. In case of tab duplication this resizing to 0x0 prevents setting
5442 // normal size later so just ignore it.
5443 if (!size.IsEmpty())
5444 view_->SizeContents(size);
[email protected]420ae012009-04-24 05:16:325445}
5446
[email protected]af905902013-10-01 21:38:515447void WebContentsImpl::CancelModalDialogsForRenderManager() {
5448 // We need to cancel modal dialogs when doing a process swap, since the load
avi2460c762015-04-17 15:21:545449 // deferrer would prevent us from swapping out. We also clear the state
5450 // because this is a cross-process navigation, which means that it's a new
5451 // site that should not have to pay for the sins of its predecessor.
creis89a0f782015-05-27 16:13:175452 //
5453 // Note that we don't bother telling browser_plugin_embedder_ because the
5454 // cross-process navigation will either destroy the browser plugins or not
5455 // require their dialogs to close.
avi5d3b8692016-10-12 22:00:465456 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:535457 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:465458 }
[email protected]af905902013-10-01 21:38:515459}
5460
[email protected]02d7b6e2014-06-24 21:01:505461void WebContentsImpl::NotifySwappedFromRenderManager(RenderFrameHost* old_host,
5462 RenderFrameHost* new_host,
5463 bool is_main_frame) {
5464 if (is_main_frame) {
naskof5940b9f2015-03-02 23:04:055465 NotifyViewSwapped(old_host ? old_host->GetRenderViewHost() : nullptr,
[email protected]02d7b6e2014-06-24 21:01:505466 new_host->GetRenderViewHost());
[email protected]a6b73c62013-02-11 23:05:085467
[email protected]02d7b6e2014-06-24 21:01:505468 // Make sure the visible RVH reflects the new delegate's preferences.
5469 if (delegate_)
5470 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]d56a49e2013-02-23 00:47:395471
[email protected]02d7b6e2014-06-24 21:01:505472 view_->RenderViewSwappedIn(new_host->GetRenderViewHost());
dmazzoni62111452017-04-28 23:46:555473
5474 RenderWidgetHostViewBase* rwhv =
5475 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
5476 if (rwhv)
5477 rwhv->SetMainFrameAXTreeID(GetMainFrame()->GetAXTreeID());
[email protected]02d7b6e2014-06-24 21:01:505478 }
5479
5480 NotifyFrameSwapped(old_host, new_host);
[email protected]3a3d47472010-07-15 21:03:545481}
5482
naskof5940b9f2015-03-02 23:04:055483void WebContentsImpl::NotifyMainFrameSwappedFromRenderManager(
5484 RenderViewHost* old_host,
5485 RenderViewHost* new_host) {
5486 NotifyViewSwapped(old_host, new_host);
5487}
5488
[email protected]b172aee2012-04-10 17:05:265489NavigationControllerImpl& WebContentsImpl::GetControllerForRenderManager() {
[email protected]d1198fd2012-08-13 22:50:195490 return GetController();
[email protected]3a3d47472010-07-15 21:03:545491}
5492
dcheng59716272016-04-09 05:19:085493std::unique_ptr<WebUIImpl> WebContentsImpl::CreateWebUIForRenderFrameHost(
carlosk37f793792014-11-27 15:08:295494 const GURL& url) {
Dan Beam055fe8f2017-10-04 23:23:365495 return CreateWebUI(url);
[email protected]420ae012009-04-24 05:16:325496}
5497
[email protected]10f417c52011-12-28 21:04:235498NavigationEntry*
[email protected]b172aee2012-04-10 17:05:265499 WebContentsImpl::GetLastCommittedNavigationEntryForRenderManager() {
[email protected]420ae012009-04-24 05:16:325500 return controller_.GetLastCommittedEntry();
5501}
5502
creisadca9862017-06-16 19:12:115503InterstitialPageImpl* WebContentsImpl::GetInterstitialForRenderManager() {
5504 return interstitial_page_;
5505}
5506
lfgbede6392015-09-11 21:54:065507void WebContentsImpl::CreateRenderWidgetHostViewForRenderManager(
5508 RenderViewHost* render_view_host) {
lfgc740d4b22016-04-15 16:45:335509 RenderWidgetHostViewBase* rwh_view =
5510 view_->CreateViewForWidget(render_view_host->GetWidget(), false);
[email protected]1a98a932009-11-17 00:12:525511
[email protected]420ae012009-04-24 05:16:325512 // Now that the RenderView has been created, we need to tell it its size.
[email protected]245f7d52011-11-28 15:36:445513 if (rwh_view)
[email protected]dc0fd432013-08-27 15:29:215514 rwh_view->SetSize(GetSizeForNewRenderView());
lfgbede6392015-09-11 21:54:065515}
5516
5517bool WebContentsImpl::CreateRenderViewForRenderManager(
5518 RenderViewHost* render_view_host,
5519 int opener_frame_routing_id,
5520 int proxy_routing_id,
Pavel Feldman25234722017-10-11 02:49:065521 const base::UnguessableToken& devtools_frame_token,
lfgbede6392015-09-11 21:54:065522 const FrameReplicationState& replicated_frame_state) {
5523 TRACE_EVENT0("browser,navigation",
5524 "WebContentsImpl::CreateRenderViewForRenderManager");
5525
piman00cf9402017-04-03 17:09:205526 if (proxy_routing_id == MSG_ROUTING_NONE)
lfg9431efd2016-12-14 14:45:265527 CreateRenderWidgetHostViewForRenderManager(render_view_host);
lfg9431efd2016-12-14 14:45:265528
piman00cf9402017-04-03 17:09:205529 if (!static_cast<RenderViewHostImpl*>(render_view_host)
5530 ->CreateRenderView(opener_frame_routing_id, proxy_routing_id,
Pavel Feldman25234722017-10-11 02:49:065531 devtools_frame_token, replicated_frame_state,
5532 created_with_opener_)) {
[email protected]a4127722011-04-27 23:13:525533 return false;
[email protected]14392a52012-05-02 20:28:445534 }
[email protected]a4127722011-04-27 23:13:525535
avi2b177592014-12-10 02:08:025536 SetHistoryOffsetAndLengthForView(render_view_host,
5537 controller_.GetLastCommittedEntryIndex(),
5538 controller_.GetEntryCount());
5539
[email protected]a220b5932013-09-21 03:47:445540#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
[email protected]f8233cc2011-05-31 20:24:505541 // Force a ViewMsg_Resize to be sent, needed to make plugins show up on
5542 // linux. See crbug.com/83941.
avif9ab5d942015-10-15 14:05:445543 RenderWidgetHostView* rwh_view = render_view_host->GetWidget()->GetView();
[email protected]245f7d52011-11-28 15:36:445544 if (rwh_view) {
5545 if (RenderWidgetHost* render_widget_host = rwh_view->GetRenderWidgetHost())
5546 render_widget_host->WasResized();
5547 }
[email protected]f8233cc2011-05-31 20:24:505548#endif
5549
[email protected]420ae012009-04-24 05:16:325550 return true;
5551}
5552
[email protected]82307f6b2014-08-07 03:30:125553bool WebContentsImpl::CreateRenderFrameForRenderManager(
5554 RenderFrameHost* render_frame_host,
alexmosa181efc2015-09-03 00:39:045555 int proxy_routing_id,
5556 int opener_routing_id,
japhete6adf142014-10-31 00:01:495557 int parent_routing_id,
alexmosa181efc2015-09-03 00:39:045558 int previous_sibling_routing_id) {
naskob8744d22014-08-28 17:07:435559 TRACE_EVENT0("browser,navigation",
5560 "WebContentsImpl::CreateRenderFrameForRenderManager");
[email protected]82307f6b2014-08-07 03:30:125561
5562 RenderFrameHostImpl* rfh =
5563 static_cast<RenderFrameHostImpl*>(render_frame_host);
alexmosa181efc2015-09-03 00:39:045564 if (!rfh->CreateRenderFrame(proxy_routing_id, opener_routing_id,
5565 parent_routing_id, previous_sibling_routing_id))
[email protected]82307f6b2014-08-07 03:30:125566 return false;
5567
5568 // TODO(nasko): When RenderWidgetHost is owned by RenderFrameHost, the passed
5569 // RenderFrameHost will have to be associated with the appropriate
5570 // RenderWidgetHostView or a new one should be created here.
5571
5572 return true;
5573}
5574
mfomitchev2b8b066a2016-01-28 19:23:155575#if defined(OS_ANDROID)
[email protected]fc2b46b2014-05-03 16:33:455576
[email protected]155c7f22013-12-09 17:07:185577base::android::ScopedJavaLocalRef<jobject>
5578WebContentsImpl::GetJavaWebContents() {
mostynb042582e2015-03-16 22:13:405579 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]0e813a52014-08-13 10:34:565580 return GetWebContentsAndroid()->GetJavaObject();
5581}
[email protected]155c7f22013-12-09 17:07:185582
[email protected]0e813a52014-08-13 10:34:565583WebContentsAndroid* WebContentsImpl::GetWebContentsAndroid() {
[email protected]155c7f22013-12-09 17:07:185584 WebContentsAndroid* web_contents_android =
5585 static_cast<WebContentsAndroid*>(GetUserData(kWebContentsAndroidKey));
5586 if (!web_contents_android) {
5587 web_contents_android = new WebContentsAndroid(this);
avicb129c02017-05-03 06:49:295588 SetUserData(kWebContentsAndroidKey, base::WrapUnique(web_contents_android));
[email protected]155c7f22013-12-09 17:07:185589 }
[email protected]0e813a52014-08-13 10:34:565590 return web_contents_android;
[email protected]155c7f22013-12-09 17:07:185591}
5592
paulmeyerc0b762b2016-04-13 11:55:175593void WebContentsImpl::ActivateNearestFindResult(float x,
5594 float y) {
5595 GetOrCreateFindRequestManager()->ActivateNearestFindResult(x, y);
5596}
5597
5598void WebContentsImpl::RequestFindMatchRects(int current_version) {
5599 GetOrCreateFindRequestManager()->RequestFindMatchRects(current_version);
5600}
5601
[email protected]7d244f12013-08-22 21:41:515602bool WebContentsImpl::CreateRenderViewForInitialEmptyDocument() {
nasko4c0feb62015-06-05 18:37:065603 return CreateRenderViewForRenderManager(
5604 GetRenderViewHost(), MSG_ROUTING_NONE, MSG_ROUTING_NONE,
Pavel Feldman25234722017-10-11 02:49:065605 frame_tree_.root()->devtools_frame_token(),
lfgbede6392015-09-11 21:54:065606 frame_tree_.root()->current_replication_state());
[email protected]7d244f12013-08-22 21:41:515607}
[email protected]fc2b46b2014-05-03 16:33:455608
rockot400ea35b2016-10-15 19:15:325609service_manager::InterfaceProvider* WebContentsImpl::GetJavaInterfaces() {
sammcf5f1b0f2016-09-20 23:05:115610 if (!java_interfaces_) {
rockot400ea35b2016-10-15 19:15:325611 service_manager::mojom::InterfaceProviderPtr provider;
blundelle0a9f1582016-12-20 11:23:325612 BindInterfaceRegistryForWebContents(mojo::MakeRequest(&provider), this);
rockot400ea35b2016-10-15 19:15:325613 java_interfaces_.reset(new service_manager::InterfaceProvider);
sammcf5f1b0f2016-09-20 23:05:115614 java_interfaces_->Bind(std::move(provider));
5615 }
5616 return java_interfaces_.get();
5617}
5618
[email protected]fc2b46b2014-05-03 16:33:455619#elif defined(OS_MACOSX)
5620
[email protected]75f4df72014-07-16 22:39:425621void WebContentsImpl::SetAllowOtherViews(bool allow) {
5622 view_->SetAllowOtherViews(allow);
[email protected]fc2b46b2014-05-03 16:33:455623}
5624
[email protected]75f4df72014-07-16 22:39:425625bool WebContentsImpl::GetAllowOtherViews() {
5626 return view_->GetAllowOtherViews();
[email protected]fc2b46b2014-05-03 16:33:455627}
5628
spqchane72c3cb2017-06-30 23:02:105629bool WebContentsImpl::CompletedFirstVisuallyNonEmptyPaint() const {
5630 return did_first_visually_non_empty_paint_;
5631}
5632
[email protected]7d244f12013-08-22 21:41:515633#endif
5634
pkotwicz75ca8ffd2016-02-16 23:10:195635void WebContentsImpl::OnDidDownloadImage(
5636 const ImageDownloadCallback& callback,
5637 int id,
5638 const GURL& image_url,
leon.hancbc4bc3c2016-02-26 07:08:525639 int32_t http_status_code,
leon.hanc2228532016-08-16 05:59:185640 const std::vector<SkBitmap>& images,
5641 const std::vector<gfx::Size>& original_image_sizes) {
5642 callback.Run(id, http_status_code, image_url, images, original_image_sizes);
pkotwicz75ca8ffd2016-02-16 23:10:195643}
5644
[email protected]6fba26d2014-04-29 09:38:285645void WebContentsImpl::OnDialogClosed(int render_process_id,
5646 int render_frame_id,
[email protected]b172aee2012-04-10 17:05:265647 IPC::Message* reply_msg,
[email protected]87de04b02014-04-08 22:14:495648 bool dialog_was_suppressed,
[email protected]b172aee2012-04-10 17:05:265649 bool success,
[email protected]fcf75d42013-12-03 20:11:265650 const base::string16& user_input) {
[email protected]6fba26d2014-04-29 09:38:285651 RenderFrameHostImpl* rfh = RenderFrameHostImpl::FromID(render_process_id,
5652 render_frame_id);
[email protected]87de04b02014-04-08 22:14:495653 last_dialog_suppressed_ = dialog_was_suppressed;
5654
[email protected]beb440c2009-11-06 04:08:545655 if (is_showing_before_unload_dialog_ && !success) {
clamybc6f4152016-04-01 20:14:235656 // It is possible for the current RenderFrameHost to have changed in the
5657 // meantime. Do not reset the navigation state in that case.
5658 if (rfh && rfh == rfh->frame_tree_node()->current_frame_host()) {
clamy44e84ce2016-02-22 15:38:255659 rfh->frame_tree_node()->BeforeUnloadCanceled();
clamybc6f4152016-04-01 20:14:235660 controller_.DiscardNonCommittedEntries();
5661 }
[email protected]ec8e8b02013-06-19 04:57:105662
ericwilligersde386342016-10-19 02:35:095663 for (auto& observer : observers_)
5664 observer.BeforeUnloadDialogCancelled();
[email protected]beb440c2009-11-06 04:08:545665 }
[email protected]87de04b02014-04-08 22:14:495666
[email protected]6fba26d2014-04-29 09:38:285667 if (rfh) {
avi44acfaa82017-05-03 22:55:355668 rfh->JavaScriptDialogClosed(reply_msg, success, user_input);
Pavel Feldman3c1842b2017-08-02 05:00:165669
5670 std::vector<protocol::PageHandler*> page_handlers =
5671 protocol::PageHandler::EnabledForWebContents(this);
5672 for (auto* handler : page_handlers)
5673 handler->DidCloseJavaScriptDialog(success, user_input);
5674
[email protected]6fba26d2014-04-29 09:38:285675 } else {
5676 // Don't leak the sync IPC reply if the RFH or process is gone.
5677 delete reply_msg;
5678 }
avi1c51fb62017-02-27 20:43:035679
5680 is_showing_javascript_dialog_ = false;
5681 is_showing_before_unload_dialog_ = false;
[email protected]beb440c2009-11-06 04:08:545682}
5683
[email protected]b172aee2012-04-10 17:05:265684void WebContentsImpl::SetEncoding(const std::string& encoding) {
[email protected]ef3adfc2014-05-11 00:04:545685 if (encoding == last_reported_encoding_)
5686 return;
5687 last_reported_encoding_ = encoding;
5688
jinsukkim79df88a2017-01-04 06:26:155689 canonical_encoding_ = base::GetCanonicalEncodingNameByAliasName(encoding);
[email protected]aacd7cc2009-09-02 14:51:105690}
[email protected]f45d2a72010-03-08 23:28:355691
[email protected]1ac10dca2013-08-20 20:47:045692bool WebContentsImpl::IsHidden() {
5693 return capturer_count_ == 0 && !should_normally_be_visible_;
5694}
5695
rob97250742015-12-10 17:45:155696int WebContentsImpl::GetOuterDelegateFrameTreeNodeId() {
lfg601233692017-03-06 22:45:445697 return node_.outer_contents_frame_tree_node_id();
lazyboy6ec48b2a2015-06-29 15:18:145698}
5699
ekaramadaeb3c5c2016-11-09 03:22:355700RenderWidgetHostImpl* WebContentsImpl::GetFullscreenRenderWidgetHost() const {
5701 return RenderWidgetHostImpl::FromID(fullscreen_widget_process_id_,
5702 fullscreen_widget_routing_id_);
5703}
5704
[email protected]b0936d22013-11-28 06:47:365705RenderFrameHostManager* WebContentsImpl::GetRenderManager() const {
[email protected]fa944cb82013-11-15 17:51:215706 return frame_tree_.root()->render_manager();
5707}
5708
[email protected]f8497342013-02-05 22:15:025709BrowserPluginGuest* WebContentsImpl::GetBrowserPluginGuest() const {
[email protected]7a846df2012-09-20 19:17:395710 return browser_plugin_guest_.get();
5711}
5712
[email protected]738f57a2013-06-29 21:06:545713void WebContentsImpl::SetBrowserPluginGuest(BrowserPluginGuest* guest) {
5714 CHECK(!browser_plugin_guest_);
lazyboy6ec48b2a2015-06-29 15:18:145715 CHECK(guest);
[email protected]738f57a2013-06-29 21:06:545716 browser_plugin_guest_.reset(guest);
5717}
5718
[email protected]f8497342013-02-05 22:15:025719BrowserPluginEmbedder* WebContentsImpl::GetBrowserPluginEmbedder() const {
[email protected]7a846df2012-09-20 19:17:395720 return browser_plugin_embedder_.get();
5721}
[email protected]8ff00d72012-10-23 19:12:215722
fsamuel60b42282015-03-10 03:29:145723void WebContentsImpl::CreateBrowserPluginEmbedderIfNecessary() {
5724 if (browser_plugin_embedder_)
5725 return;
5726 browser_plugin_embedder_.reset(BrowserPluginEmbedder::Create(this));
5727}
5728
[email protected]fc2b46b2014-05-03 16:33:455729gfx::Size WebContentsImpl::GetSizeForNewRenderView() {
[email protected]dc0fd432013-08-27 15:29:215730 gfx::Size size;
5731 if (delegate_)
5732 size = delegate_->GetSizeForNewRenderView(this);
5733 if (size.IsEmpty())
[email protected]fc2b46b2014-05-03 16:33:455734 size = GetContainerBounds().size();
[email protected]dc0fd432013-08-27 15:29:215735 return size;
5736}
5737
[email protected]ae7eeda2014-07-04 01:53:265738void WebContentsImpl::OnFrameRemoved(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:095739 for (auto& observer : observers_)
5740 observer.FrameDeleted(render_frame_host);
[email protected]9b159a52013-10-03 17:24:555741}
5742
[email protected]222f5822014-02-05 23:40:495743void WebContentsImpl::OnPreferredSizeChanged(const gfx::Size& old_size) {
5744 if (!delegate_)
5745 return;
5746 const gfx::Size new_size = GetPreferredSize();
5747 if (new_size != old_size)
5748 delegate_->UpdatePreferredSize(this, new_size);
5749}
5750
Dan Beam055fe8f2017-10-04 23:23:365751std::unique_ptr<WebUIImpl> WebContentsImpl::CreateWebUI(const GURL& url) {
5752 std::unique_ptr<WebUIImpl> web_ui = base::MakeUnique<WebUIImpl>(this);
avie865b1d2016-10-24 19:42:595753 WebUIController* controller =
5754 WebUIControllerFactoryRegistry::GetInstance()
5755 ->CreateWebUIControllerForURL(web_ui.get(), url);
dbeama1b926a2015-08-31 23:17:515756 if (controller) {
weisert3dab3b92017-01-10 10:31:175757 web_ui->AddMessageHandler(base::MakeUnique<GenericHandler>());
dbeama1b926a2015-08-31 23:17:515758 web_ui->SetController(controller);
5759 return web_ui;
5760 }
5761
avie865b1d2016-10-24 19:42:595762 return nullptr;
dbeama1b926a2015-08-31 23:17:515763}
5764
paulmeyerfeafc2d2017-04-25 21:46:405765FindRequestManager* WebContentsImpl::GetFindRequestManager() {
5766 for (WebContentsImpl* contents = this; contents;
5767 contents = contents->GetOuterWebContents()) {
5768 if (contents->find_request_manager_)
5769 return contents->find_request_manager_.get();
5770 }
5771
5772 return nullptr;
5773}
5774
paulmeyerc0b762b2016-04-13 11:55:175775FindRequestManager* WebContentsImpl::GetOrCreateFindRequestManager() {
paulmeyerfeafc2d2017-04-25 21:46:405776 if (FindRequestManager* manager = GetFindRequestManager())
5777 return manager;
5778
5779 // No existing FindRequestManager found, so one must be created.
5780 find_request_manager_.reset(new FindRequestManager(this));
5781
5782 // Concurrent find sessions must not overlap, so destroy any existing
5783 // FindRequestManagers in any inner WebContentses.
5784 for (WebContentsImpl* contents : GetWebContentsAndAllInner()) {
5785 if (contents == this)
5786 continue;
5787 if (contents->find_request_manager_) {
5788 contents->find_request_manager_->StopFinding(
5789 content::STOP_FIND_ACTION_CLEAR_SELECTION);
5790 contents->find_request_manager_.release();
5791 }
5792 }
paulmeyerc0b762b2016-04-13 11:55:175793
5794 return find_request_manager_.get();
5795}
5796
5797void WebContentsImpl::NotifyFindReply(int request_id,
5798 int number_of_matches,
5799 const gfx::Rect& selection_rect,
5800 int active_match_ordinal,
5801 bool final_update) {
Sebastien Marchandcf97ed52017-07-24 23:50:345802 if (delegate_ && !is_being_destroyed_ &&
Lukasz Anforowicze9ae3722017-09-29 17:37:385803 !GetMainFrame()->GetProcess()->FastShutdownStarted()) {
paulmeyerc0b762b2016-04-13 11:55:175804 delegate_->FindReply(this, request_id, number_of_matches, selection_rect,
5805 active_match_ordinal, final_update);
5806 }
5807}
5808
ortuno467e5792016-06-10 04:32:395809void WebContentsImpl::IncrementBluetoothConnectedDeviceCount() {
5810 // Trying to invalidate the tab state while being destroyed could result in a
5811 // use after free.
5812 if (IsBeingDestroyed()) {
5813 return;
5814 }
5815 // Notify for UI updates if the state changes.
5816 bluetooth_connected_device_count_++;
5817 if (bluetooth_connected_device_count_ == 1) {
5818 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
5819 }
5820}
5821
5822void WebContentsImpl::DecrementBluetoothConnectedDeviceCount() {
5823 // Trying to invalidate the tab state while being destroyed could result in a
5824 // use after free.
5825 if (IsBeingDestroyed()) {
5826 return;
5827 }
5828 // Notify for UI updates if the state changes.
Lukasz Anforowicze9ae3722017-09-29 17:37:385829 DCHECK_NE(bluetooth_connected_device_count_, 0u);
ortuno467e5792016-06-10 04:32:395830 bluetooth_connected_device_count_--;
5831 if (bluetooth_connected_device_count_ == 0) {
5832 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
5833 }
5834}
5835
zqzhang8ac49002017-03-16 21:51:355836void WebContentsImpl::SetHasPersistentVideo(bool has_persistent_video) {
5837 if (has_persistent_video_ == has_persistent_video)
mlamouri5cd9ae82017-02-18 11:05:095838 return;
5839
zqzhang8ac49002017-03-16 21:51:355840 has_persistent_video_ = has_persistent_video;
mlamouri5cd9ae82017-02-18 11:05:095841 NotifyPreferencesChanged();
zqzhang8ac49002017-03-16 21:51:355842 media_web_contents_observer()->RequestPersistentVideo(has_persistent_video);
mlamouri5cd9ae82017-02-18 11:05:095843}
5844
paulmeyerfeafc2d2017-04-25 21:46:405845void WebContentsImpl::BrowserPluginGuestWillDetach() {
5846 WebContentsImpl* outermost = GetOutermostWebContents();
5847 if (this != outermost && ContainsOrIsFocusedWebContents())
5848 outermost->SetAsFocusedWebContentsIfNecessary();
5849}
5850
paulmeyerc0b762b2016-04-13 11:55:175851#if defined(OS_ANDROID)
5852void WebContentsImpl::NotifyFindMatchRectsReply(
5853 int version,
5854 const std::vector<gfx::RectF>& rects,
5855 const gfx::RectF& active_rect) {
5856 if (delegate_)
5857 delegate_->FindMatchRectsReply(this, version, rects, active_rect);
5858}
5859#endif
5860
[email protected]34ff1cfc2014-08-20 06:16:055861void WebContentsImpl::SetForceDisableOverscrollContent(bool force_disable) {
5862 force_disable_overscroll_content_ = force_disable;
5863 if (view_)
5864 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
5865}
5866
dalecurtis88c240072015-12-09 02:11:185867void WebContentsImpl::MediaStartedPlaying(
billorr21c005d2016-11-17 03:57:045868 const WebContentsObserver::MediaPlayerInfo& media_info,
dalecurtis88c240072015-12-09 02:11:185869 const WebContentsObserver::MediaPlayerId& id) {
billorr21c005d2016-11-17 03:57:045870 if (media_info.has_video)
5871 currently_playing_video_count_++;
5872
ericwilligersde386342016-10-19 02:35:095873 for (auto& observer : observers_)
billorr21c005d2016-11-17 03:57:045874 observer.MediaStartedPlaying(media_info, id);
dalecurtis88c240072015-12-09 02:11:185875}
5876
5877void WebContentsImpl::MediaStoppedPlaying(
billorr21c005d2016-11-17 03:57:045878 const WebContentsObserver::MediaPlayerInfo& media_info,
dalecurtis88c240072015-12-09 02:11:185879 const WebContentsObserver::MediaPlayerId& id) {
billorr21c005d2016-11-17 03:57:045880 if (media_info.has_video)
5881 currently_playing_video_count_--;
5882
ericwilligersde386342016-10-19 02:35:095883 for (auto& observer : observers_)
billorr21c005d2016-11-17 03:57:045884 observer.MediaStoppedPlaying(media_info, id);
5885}
5886
peconn257951522017-06-09 18:24:595887void WebContentsImpl::MediaResized(
5888 const gfx::Size& size,
5889 const WebContentsObserver::MediaPlayerId& id) {
5890 cached_video_sizes_[id] = size;
5891
5892 for (auto& observer : observers_)
5893 observer.MediaResized(size, id);
5894}
5895
Peter E Conneccb34c22017-09-08 09:37:585896void WebContentsImpl::MediaEffectivelyFullscreenChanged(bool is_fullscreen) {
5897 for (auto& observer : observers_)
5898 observer.MediaEffectivelyFullscreenChanged(is_fullscreen);
5899}
5900
Peter Conn31c726a2017-08-17 11:07:345901base::Optional<gfx::Size> WebContentsImpl::GetFullscreenVideoSize() {
5902 base::Optional<WebContentsObserver::MediaPlayerId> id =
5903 media_web_contents_observer_->GetFullscreenVideoMediaPlayerId();
5904 if (id && cached_video_sizes_.count(id.value()))
5905 return base::Optional<gfx::Size>(cached_video_sizes_[id.value()]);
5906 return base::Optional<gfx::Size>();
peconn257951522017-06-09 18:24:595907}
5908
billorr21c005d2016-11-17 03:57:045909int WebContentsImpl::GetCurrentlyPlayingVideoCount() {
5910 return currently_playing_video_count_;
dalecurtis88c240072015-12-09 02:11:185911}
5912
tapted65ff2ea72016-03-01 23:39:005913void WebContentsImpl::UpdateWebContentsVisibility(bool visible) {
5914 if (!did_first_set_visible_) {
5915 // If this WebContents has not yet been set to be visible for the first
5916 // time, ignore any requests to make it hidden, since resources would
5917 // immediately be destroyed and only re-created after content loaded. In
5918 // this state the window content is undefined and can show garbage.
5919 // However, the page load mechanism requires an activation call through a
5920 // visibility call to (re)load.
5921 if (visible) {
5922 did_first_set_visible_ = true;
5923 WasShown();
5924 }
5925 return;
5926 }
5927 if (visible == should_normally_be_visible_)
5928 return;
5929
5930 if (visible)
5931 WasShown();
5932 else
5933 WasHidden();
5934}
5935
aelias5252baa2016-04-10 01:18:025936void WebContentsImpl::UpdateOverridingUserAgent() {
mlamouri5cd9ae82017-02-18 11:05:095937 NotifyPreferencesChanged();
aelias5252baa2016-04-10 01:18:025938}
5939
avid53461d2016-02-25 17:15:045940void WebContentsImpl::SetJavaScriptDialogManagerForTesting(
5941 JavaScriptDialogManager* dialog_manager) {
5942 dialog_manager_ = dialog_manager;
5943}
5944
rockotf62002a2016-09-15 00:08:595945void WebContentsImpl::RemoveBindingSet(const std::string& interface_name) {
5946 auto it = binding_sets_.find(interface_name);
5947 if (it != binding_sets_.end())
5948 binding_sets_.erase(it);
5949}
5950
nzolghadrd87a308d2016-12-07 15:45:565951bool WebContentsImpl::AddDomainInfoToRapporSample(rappor::Sample* sample) {
nzolghadrbbffc6c2017-05-25 17:56:395952 // Here we associate this metric to the main frame URL regardless of what
5953 // caused it.
nzolghadrd87a308d2016-12-07 15:45:565954 sample->SetStringField("Domain", ::rappor::GetDomainAndRegistrySampleFromGURL(
5955 GetLastCommittedURL()));
nzolghadrd87a308d2016-12-07 15:45:565956 return true;
5957}
5958
nzolghadrbbffc6c2017-05-25 17:56:395959void WebContentsImpl::UpdateUrlForUkmSource(ukm::UkmRecorder* service,
5960 ukm::SourceId ukm_source_id) {
5961 // Here we associate this metric to the main frame URL regardless of what
5962 // caused it.
5963 service->UpdateSourceURL(ukm_source_id, GetLastCommittedURL());
5964}
5965
ekaramada110f642016-12-21 19:47:285966void WebContentsImpl::FocusedNodeTouched(bool editable) {
5967#if defined(OS_WIN)
5968 // We use the cursor position to determine where the touch occurred.
5969 RenderWidgetHostView* view = GetRenderWidgetHostView();
5970 if (!view)
5971 return;
5972 POINT cursor_pos = {};
5973 ::GetCursorPos(&cursor_pos);
5974 float scale = GetScaleFactorForView(view);
5975 gfx::Point location_dips_screen =
5976 gfx::ConvertPointToDIP(scale, gfx::Point(cursor_pos));
5977 view->FocusedNodeTouched(location_dips_screen, editable);
5978#endif
5979}
5980
samans90fb8162017-04-04 22:30:455981void WebContentsImpl::DidReceiveCompositorFrame() {
5982 for (auto& observer : observers_)
5983 observer.DidReceiveCompositorFrame();
5984}
5985
falken52a56e32016-12-08 05:02:405986void WebContentsImpl::ShowInsecureLocalhostWarningIfNeeded() {
5987 bool allow_localhost = base::CommandLine::ForCurrentProcess()->HasSwitch(
5988 switches::kAllowInsecureLocalhost);
5989 if (!allow_localhost)
5990 return;
5991
5992 content::NavigationEntry* entry = GetController().GetLastCommittedEntry();
5993 if (!entry || !net::IsLocalhost(entry->GetURL().host()))
5994 return;
5995
5996 content::SSLStatus ssl_status = entry->GetSSL();
5997 bool is_cert_error = net::IsCertStatusError(ssl_status.cert_status) &&
5998 !net::IsCertStatusMinorError(ssl_status.cert_status);
5999 if (!is_cert_error)
6000 return;
6001
6002 GetMainFrame()->AddMessageToConsole(
6003 content::CONSOLE_MESSAGE_LEVEL_WARNING,
6004 base::StringPrintf("This site does not have a valid SSL "
6005 "certificate! Without SSL, your site's and "
6006 "visitors' data is vulnerable to theft and "
6007 "tampering. Get a valid SSL certificate before"
6008 " releasing your website to the public."));
6009}
6010
ekaramadf6750aa2017-06-06 18:29:426011bool WebContentsImpl::IsShowingContextMenuOnPage() const {
6012 return showing_context_menu_;
6013}
6014
mlamouri5cd9ae82017-02-18 11:05:096015void WebContentsImpl::NotifyPreferencesChanged() {
6016 std::set<RenderViewHost*> render_view_host_set;
6017 for (FrameTreeNode* node : frame_tree_.Nodes()) {
6018 RenderWidgetHost* render_widget_host =
6019 node->current_frame_host()->GetRenderWidgetHost();
6020 if (!render_widget_host)
6021 continue;
6022 RenderViewHost* render_view_host = RenderViewHost::From(render_widget_host);
6023 if (!render_view_host)
6024 continue;
6025 render_view_host_set.insert(render_view_host);
6026 }
6027 for (RenderViewHost* render_view_host : render_view_host_set)
6028 render_view_host->OnWebkitPreferencesChanged();
6029}
6030
Megan Jablonski2f6a4c52017-07-10 23:01:256031DownloadUrlParameters::RequestHeadersType WebContentsImpl::ParseDownloadHeaders(
6032 const std::string& headers) {
6033 DownloadUrlParameters::RequestHeadersType request_headers;
6034 for (const base::StringPiece& key_value : base::SplitStringPiece(
6035 headers, "\r\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
6036 std::vector<std::string> pair = base::SplitString(
6037 key_value, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
6038 if (2ul == pair.size())
6039 request_headers.push_back(make_pair(pair[0], pair[1]));
6040 }
6041 return request_headers;
6042}
6043
lukasza6f8ac622017-06-06 03:10:206044void WebContentsImpl::SetOpenerForNewContents(FrameTreeNode* opener,
6045 bool opener_suppressed) {
6046 if (opener) {
6047 FrameTreeNode* new_root = GetFrameTree()->root();
6048
6049 // For the "original opener", track the opener's main frame instead, because
6050 // if the opener is a subframe, the opener tracking could be easily bypassed
6051 // by spawning from a subframe and deleting the subframe.
6052 // https://crbug.com/705316
6053 new_root->SetOriginalOpener(opener->frame_tree()->root());
6054
6055 if (!opener_suppressed) {
6056 new_root->SetOpener(opener);
6057 created_with_opener_ = true;
6058 }
6059 }
6060}
6061
Becca Hughes9f6fd4b82017-06-15 10:01:406062void WebContentsImpl::MediaMutedStatusChanged(
6063 const WebContentsObserver::MediaPlayerId& id,
6064 bool muted) {
6065 for (auto& observer : observers_)
6066 observer.MediaMutedStatusChanged(id, muted);
6067}
6068
EhsanK2075c7e2017-08-21 02:42:396069void WebContentsImpl::SetVisibilityForChildViews(bool visible) {
6070 GetMainFrame()->SetVisibilityForChildViews(visible);
6071}
6072
[email protected]8ff00d72012-10-23 19:12:216073} // namespace content