blob: 8d1cb4e5edefd365241d898c1b682292d7333386 [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"
erikchen35629cc2015-03-10 20:43:2226#include "base/profiler/scoped_tracker.h"
skyostil95082a62015-06-05 19:53:0727#include "base/single_thread_task_runner.h"
[email protected]348fbaac2013-06-11 06:31:5128#include "base/strings/string16.h"
29#include "base/strings/string_number_conversions.h"
30#include "base/strings/string_util.h"
[email protected]74ebfb12013-06-07 20:48:0031#include "base/strings/utf_string_conversions.h"
gab30f26df2016-05-11 19:37:5532#include "base/threading/thread_task_runner_handle.h"
[email protected]a43858f2013-06-28 15:18:3733#include "base/time/time.h"
ssid3e765612015-01-28 04:03:4234#include "base/trace_event/trace_event.h"
avib7348942015-12-25 20:57:1035#include "build/build_config.h"
nzolghadrd87a308d2016-12-07 15:45:5636#include "components/rappor/public/rappor_utils.h"
rsleevi24f64dc22015-08-07 21:39:2137#include "components/url_formatter/url_formatter.h"
[email protected]95640212014-07-26 18:14:3038#include "content/browser/accessibility/browser_accessibility_state_impl.h"
jamescookda2505812015-03-20 18:01:1839#include "content/browser/bad_message.h"
[email protected]7a846df2012-09-20 19:17:3940#include "content/browser/browser_plugin/browser_plugin_embedder.h"
41#include "content/browser/browser_plugin/browser_plugin_guest.h"
[email protected]b9535422012-02-09 01:47:5942#include "content/browser/child_process_security_policy_impl.h"
Pavel Feldman3c1842b2017-08-02 05:00:1643#include "content/browser/devtools/protocol/page_handler.h"
dgozmanf00c4f72016-10-19 17:45:1544#include "content/browser/devtools/render_frame_devtools_agent_host.h"
[email protected]5f2aa722013-08-07 16:59:4145#include "content/browser/dom_storage/dom_storage_context_wrapper.h"
[email protected]1ea3c792012-04-17 01:25:0446#include "content/browser/dom_storage/session_storage_namespace_impl.h"
[email protected]8bd9e562011-08-16 23:55:4647#include "content/browser/download/download_stats.h"
[email protected]aa4f3972012-03-01 18:12:1248#include "content/browser/download/mhtml_generation_manager.h"
[email protected]a53209b2012-01-20 16:48:1649#include "content/browser/download/save_package.h"
paulmeyerc0b762b2016-04-13 11:55:1750#include "content/browser/find_request_manager.h"
[email protected]bffc8302014-01-23 20:52:1651#include "content/browser/frame_host/cross_process_frame_connector.h"
ananta4b7467a52016-09-23 01:42:3852#include "content/browser/frame_host/frame_tree_node.h"
[email protected]d4a8ca482013-10-30 21:06:4053#include "content/browser/frame_host/interstitial_page_impl.h"
54#include "content/browser/frame_host/navigation_entry_impl.h"
clamy0e119882015-07-31 16:12:3355#include "content/browser/frame_host/navigation_handle_impl.h"
[email protected]6ea6bdf2013-12-06 13:35:0156#include "content/browser/frame_host/navigator_impl.h"
[email protected]52913802013-12-10 05:52:1857#include "content/browser/frame_host/render_frame_host_impl.h"
lfgdb5c4ed2016-03-04 23:09:0758#include "content/browser/frame_host/render_frame_proxy_host.h"
csharrison2e8c98e2016-08-01 23:56:2559#include "content/browser/loader/loader_io_thread_notifier.h"
[email protected]678c0362012-12-05 08:02:4460#include "content/browser/loader/resource_dispatcher_host_impl.h"
mlamouriefdca9d2014-09-16 16:55:4061#include "content/browser/manifest/manifest_manager_host.h"
dalecurtisbc6572e12014-09-12 19:22:3062#include "content/browser/media/audio_stream_monitor.h"
miu50f97892014-09-22 22:49:5263#include "content/browser/media/capture/web_contents_audio_muter.h"
dalecurtis88c240072015-12-09 02:11:1864#include "content/browser/media/media_web_contents_observer.h"
zqzhang1adf3cb2016-11-01 11:26:4565#include "content/browser/media/session/media_session_impl.h"
tommyclieb25b2a2014-11-03 19:45:0966#include "content/browser/plugin_content_origin_whitelist.h"
[email protected]f3b1a082011-11-18 00:34:3067#include "content/browser/renderer_host/render_process_host_impl.h"
[email protected]21161032014-05-05 16:56:5068#include "content/browser/renderer_host/render_view_host_delegate_view.h"
[email protected]b3c41c0b2012-03-06 15:48:3269#include "content/browser/renderer_host/render_view_host_impl.h"
[email protected]bafe6cd2012-05-23 23:09:5070#include "content/browser/renderer_host/render_widget_host_impl.h"
kenrb2a565f82015-09-02 20:24:5971#include "content/browser/renderer_host/render_widget_host_input_event_router.h"
[email protected]cfd80b02014-05-01 17:46:4872#include "content/browser/renderer_host/render_widget_host_view_base.h"
Ken Buchanandaef006b2017-08-17 18:32:1573#include "content/browser/renderer_host/render_widget_host_view_child_frame.h"
ekaramadadd882292016-06-08 15:22:5674#include "content/browser/renderer_host/text_input_manager.h"
leon.han552e9de2017-02-09 14:37:3075#include "content/browser/screen_orientation/screen_orientation_provider.h"
[email protected]b6583592012-01-25 19:52:3376#include "content/browser/site_instance_impl.h"
lfgc740d4b22016-04-15 16:45:3377#include "content/browser/web_contents/web_contents_view_child_frame.h"
[email protected]b5a40842012-11-28 15:26:1178#include "content/browser/web_contents/web_contents_view_guest.h"
[email protected]eb2ef212013-01-29 04:27:5879#include "content/browser/webui/generic_handler.h"
[email protected]86a0a6e2013-01-28 06:33:0380#include "content/browser/webui/web_ui_controller_factory_registry.h"
[email protected]d2353452012-01-19 19:53:5681#include "content/browser/webui/web_ui_impl.h"
[email protected]8eb04562013-03-06 03:41:1482#include "content/common/browser_plugin/browser_plugin_constants.h"
[email protected]703dd662013-03-05 07:37:4283#include "content/common/browser_plugin/browser_plugin_messages.h"
Paul Meyer0c58c3712016-11-17 22:59:5184#include "content/common/drag_messages.h"
[email protected]f114fa42013-12-06 17:06:4485#include "content/common/frame_messages.h"
[email protected]1f3fc1d2014-04-03 14:50:1786#include "content/common/input_messages.h"
lfgdb5c4ed2016-03-04 23:09:0787#include "content/common/page_messages.h"
nasko34634672016-07-29 18:46:0688#include "content/common/page_state_serialization.h"
rockot5c478a72016-09-28 23:14:1889#include "content/common/render_message_filter.mojom.h"
avi286019ce2015-07-29 01:26:5890#include "content/common/site_isolation_policy.h"
[email protected]2c5569662011-03-22 20:45:0291#include "content/common/view_messages.h"
[email protected]31a71eaf2014-03-13 01:47:3692#include "content/public/browser/ax_event_notification_details.h"
[email protected]ccb797302011-12-15 16:55:1193#include "content/public/browser/browser_context.h"
[email protected]139355f2014-05-11 14:21:2894#include "content/public/browser/browser_plugin_guest_manager.h"
[email protected]87f3c082011-10-19 18:07:4495#include "content/public/browser/content_browser_client.h"
[email protected]e582fdd2011-12-20 16:48:1796#include "content/public/browser/download_manager.h"
ekaramada110f642016-12-21 19:47:2897#include "content/public/browser/focused_node_details.h"
ekaramad1beabecc2016-09-23 20:18:1798#include "content/public/browser/guest_mode.h"
[email protected]d9083482012-01-06 00:38:4699#include "content/public/browser/invalidate_type.h"
[email protected]71a88bb2013-02-01 22:05:15100#include "content/public/browser/javascript_dialog_manager.h"
skyf65d9bb2017-03-24 02:26:39101#include "content/public/browser/keyboard_event_processing_result.h"
[email protected]09d31d52012-03-11 22:30:27102#include "content/public/browser/load_notification_details.h"
[email protected]5b96836f2011-12-22 07:39:00103#include "content/public/browser/navigation_details.h"
[email protected]375fa1b2012-05-22 22:05:37104#include "content/public/browser/notification_details.h"
[email protected]be2510c02012-05-28 14:52:14105#include "content/public/browser/notification_service.h"
scottmg011d96e32016-06-29 19:15:08106#include "content/public/browser/notification_types.h"
[email protected]95640212014-07-26 18:14:30107#include "content/public/browser/render_widget_host_iterator.h"
[email protected]55578b0a2012-04-18 14:31:32108#include "content/public/browser/resource_request_details.h"
estark5ea80e52015-06-19 18:43:12109#include "content/public/browser/security_style_explanations.h"
falken52a56e32016-12-08 05:02:40110#include "content/public/browser/ssl_status.h"
[email protected]4c3a23582012-08-18 08:54:34111#include "content/public/browser/storage_partition.h"
rockotf62002a2016-09-15 00:08:59112#include "content/public/browser/web_contents_binding_set.h"
[email protected]674bc592011-12-20 23:00:42113#include "content/public/browser/web_contents_delegate.h"
dtapuskae99ec6e52016-10-18 00:15:42114#include "content/public/browser/web_contents_unresponsive_state.h"
[email protected]e091df82011-10-11 18:13:21115#include "content/public/common/bindings_policy.h"
carloskd80262f52015-12-16 14:40:35116#include "content/public/common/browser_side_navigation_policy.h"
alexmosc9e76ec2016-05-16 22:59:37117#include "content/public/common/child_process_host.h"
[email protected]54087fe2011-10-28 22:02:48118#include "content/public/common/content_constants.h"
[email protected]64d69de42012-02-06 00:19:54119#include "content/public/common/content_switches.h"
[email protected]7940b8e2013-07-25 23:08:49120#include "content/public/common/page_zoom.h"
[email protected]04cbd3d2013-12-04 04:58:20121#include "content/public/common/result_codes.h"
[email protected]f16cc6782013-12-16 23:42:57122#include "content/public/common/url_utils.h"
[email protected]b3a97b52014-07-09 06:25:05123#include "content/public/common/web_preferences.h"
Conley Owens6894c4f2017-07-10 19:29:13124#include "device/geolocation/geolocation_context.h"
wjmaclean64951902016-04-29 20:59:12125#include "net/base/url_util.h"
[email protected]8bfc8272013-09-09 20:10:53126#include "net/http/http_cache.h"
127#include "net/http/http_transaction_factory.h"
rhalavati0fbaeef32017-06-01 15:56:30128#include "net/traffic_annotation/network_traffic_annotation.h"
[email protected]8bfc8272013-09-09 20:10:53129#include "net/url_request/url_request_context.h"
[email protected]abe2c032011-03-31 18:49:34130#include "net/url_request/url_request_context_getter.h"
brettw4b461082016-11-19 18:55:16131#include "ppapi/features/features.h"
Mounir Lamourifd9dcefa2017-07-06 10:26:55132#include "services/metrics/public/cpp/ukm_recorder.h"
rockot734fb662016-10-15 16:41:30133#include "services/service_manager/public/cpp/interface_provider.h"
Kinuko Yasuda74702f92017-07-31 03:27:53134#include "third_party/WebKit/common/mime_util/mime_util.h"
estark47ba9c7d2016-10-11 15:40:11135#include "third_party/WebKit/public/platform/WebSecurityStyle.h"
alexmosaedfc6f2016-01-21 23:57:38136#include "third_party/WebKit/public/web/WebSandboxFlags.h"
halton.huoca2eabd2015-07-06 08:17:40137#include "third_party/skia/include/core/SkBitmap.h"
dmazzonid95ae842016-04-12 21:17:39138#include "ui/accessibility/ax_tree_combiner.h"
[email protected]a08412b62012-05-29 21:28:56139#include "ui/base/layout.h"
chongz4a9751942016-08-17 17:49:39140#include "ui/events/blink/web_input_event_traits.h"
[email protected]66bd5512012-08-01 02:02:52141#include "ui/gl/gl_switches.h"
[email protected]3c733bde2010-12-21 19:56:31142
ekaramada110f642016-12-21 19:47:28143#if defined(OS_WIN)
144#include "content/browser/renderer_host/dip_util.h"
145#include "ui/gfx/geometry/dip_util.h"
146#endif
147
[email protected]583418cc2013-01-17 14:01:10148#if defined(OS_ANDROID)
hugo.holgersson61288e6c2015-01-28 17:04:40149#include "content/browser/android/content_video_view.h"
mfomitchev2b8b066a2016-01-28 19:23:15150#include "content/browser/android/date_time_chooser_android.h"
sammcf5f1b0f2016-09-20 23:05:11151#include "content/browser/android/java_interfaces_impl.h"
dalecurtisc85ed632016-01-13 00:22:46152#include "content/browser/media/android/media_web_contents_observer_android.h"
[email protected]155c7f22013-12-09 17:07:18153#include "content/browser/web_contents/web_contents_android.h"
leon.han02ed4aeb2017-05-23 06:33:33154#include "services/device/public/interfaces/nfc.mojom.h"
mcnee336ea2c2017-05-23 22:50:59155#else // !OS_ANDROID
156#include "content/browser/host_zoom_map_impl.h"
157#include "content/browser/host_zoom_map_observer.h"
mfomitchev2b8b066a2016-01-28 19:23:15158#endif // OS_ANDROID
[email protected]583418cc2013-01-17 14:01:10159
[email protected]f66df822012-05-18 16:52:17160#if defined(OS_MACOSX)
[email protected]bafe6cd2012-05-23 23:09:50161#include "base/mac/foundation_util.h"
[email protected]38b098f2012-03-14 21:11:57162#endif
[email protected]3e45ba92009-02-20 21:09:00163
sadrul943e3b32016-08-04 18:22:59164#if defined(USE_AURA)
bend32292b2016-10-07 00:21:58165#include "content/public/common/service_manager_connection.h"
fsamuel9cf7bdf2015-11-20 02:19:32166#endif
167
brettw4b461082016-11-19 18:55:16168#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17169#include "content/browser/media/session/pepper_playback_observer.h"
170#endif // ENABLE_PLUGINS
171
[email protected]8ff00d72012-10-23 19:12:21172namespace content {
[email protected]420ae012009-04-24 05:16:32173namespace {
174
[email protected]960b0372014-05-19 18:01:00175const int kMinimumDelayBetweenLoadingUpdatesMS = 100;
[email protected]82114f52012-03-20 22:53:41176const char kDotGoogleDotCom[] = ".google.com";
[email protected]ca406032011-07-19 21:53:05177
[email protected]155c7f22013-12-09 17:07:18178#if defined(OS_ANDROID)
rob.buisf06a8bf2017-03-10 18:11:32179const void* const kWebContentsAndroidKey = &kWebContentsAndroidKey;
[email protected]155c7f22013-12-09 17:07:18180#endif // OS_ANDROID
181
scottmg5e65e3a2017-03-08 08:48:46182base::LazyInstance<std::vector<WebContentsImpl::CreatedCallback>>::
183 DestructorAtExit g_created_callbacks = LAZY_INSTANCE_INITIALIZER;
[email protected]cbb1ef592013-06-05 19:49:46184
[email protected]8bfc8272013-09-09 20:10:53185void NotifyCacheOnIO(
186 scoped_refptr<net::URLRequestContextGetter> request_context,
187 const GURL& url,
188 const std::string& http_method) {
gunsche668855c2015-03-05 02:37:58189 net::HttpCache* cache = request_context->GetURLRequestContext()->
190 http_transaction_factory()->GetCache();
191 if (cache)
192 cache->OnExternalCacheHit(url, http_method);
[email protected]8bfc8272013-09-09 20:10:53193}
194
dcheng57e39e22016-01-21 00:25:38195bool HasMatchingProcess(FrameTree* tree, int render_process_id) {
196 for (FrameTreeNode* node : tree->Nodes()) {
197 if (node->current_frame_host()->GetProcess()->GetID() == render_process_id)
198 return true;
alexmos4cf2aa32015-07-15 23:40:43199 }
dcheng57e39e22016-01-21 00:25:38200 return false;
[email protected]95640212014-07-26 18:14:30201}
202
kenrb19221852016-04-29 17:21:40203bool HasMatchingWidgetHost(FrameTree* tree, RenderWidgetHost* host) {
204 // This method scans the frame tree rather than checking whether
205 // host->delegate() == this, which allows it to return false when the host
206 // for a frame that is pending or pending deletion.
207 if (!host)
208 return false;
209
210 for (FrameTreeNode* node : tree->Nodes()) {
211 if (node->current_frame_host()->GetRenderWidgetHost() == host)
212 return true;
213 }
214 return false;
215}
216
dmazzonif8a31042016-12-03 00:52:13217void UpdateAccessibilityModeOnFrame(RenderFrameHost* frame_host) {
218 static_cast<RenderFrameHostImpl*>(frame_host)->UpdateAccessibilityMode();
[email protected]95640212014-07-26 18:14:30219}
220
dtseng0dd3fa12015-07-22 19:00:52221void ResetAccessibility(RenderFrameHost* rfh) {
222 static_cast<RenderFrameHostImpl*>(rfh)->AccessibilityReset();
223}
224
dmazzonid95ae842016-04-12 21:17:39225using AXTreeSnapshotCallback =
226 base::Callback<void(const ui::AXTreeUpdate&)>;
227
228// Helper class used by WebContentsImpl::RequestAXTreeSnapshot.
229// Handles the callbacks from parallel snapshot requests to each frame,
230// and feeds the results to an AXTreeCombiner, which converts them into a
231// single combined accessibility tree.
232class AXTreeSnapshotCombiner : public base::RefCounted<AXTreeSnapshotCombiner> {
233 public:
234 explicit AXTreeSnapshotCombiner(AXTreeSnapshotCallback callback)
235 : callback_(callback) {
236 }
237
238 AXTreeSnapshotCallback AddFrame(bool is_root) {
239 // Adds a reference to |this|.
240 return base::Bind(&AXTreeSnapshotCombiner::ReceiveSnapshot,
241 this,
242 is_root);
243 }
244
245 void ReceiveSnapshot(bool is_root, const ui::AXTreeUpdate& snapshot) {
246 combiner_.AddTree(snapshot, is_root);
247 }
248
249 private:
250 friend class base::RefCounted<AXTreeSnapshotCombiner>;
251
252 // This is called automatically after the last call to ReceiveSnapshot
253 // when there are no more references to this object.
254 ~AXTreeSnapshotCombiner() {
255 combiner_.Combine();
256 callback_.Run(combiner_.combined());
257 }
258
259 ui::AXTreeCombiner combiner_;
260 AXTreeSnapshotCallback callback_;
261};
262
paulmeyerfeafc2d2017-04-25 21:46:40263// Helper for GetInnerWebContents().
264bool GetInnerWebContentsHelper(
265 std::vector<WebContentsImpl*>* all_guest_contents,
266 WebContents* guest_contents) {
267 all_guest_contents->push_back(static_cast<WebContentsImpl*>(guest_contents));
268 return false;
269}
270
lukasza6f8ac622017-06-06 03:10:20271FrameTreeNode* FindOpener(const WebContents::CreateParams& params) {
alexmose201c7cd2015-06-10 17:14:21272 FrameTreeNode* opener_node = nullptr;
273 if (params.opener_render_frame_id != MSG_ROUTING_NONE) {
274 RenderFrameHostImpl* opener_rfh = RenderFrameHostImpl::FromID(
275 params.opener_render_process_id, params.opener_render_frame_id);
276 if (opener_rfh)
277 opener_node = opener_rfh->frame_tree_node();
278 }
lukasza6f8ac622017-06-06 03:10:20279 return opener_node;
280}
281
Pavel Feldman3c1842b2017-08-02 05:00:16282// Ensures that OnDialogClosed is only called once.
283class CloseDialogCallbackWrapper
284 : public base::RefCountedThreadSafe<CloseDialogCallbackWrapper> {
285 public:
286 CloseDialogCallbackWrapper(
287 const base::Callback<void(bool, bool, const base::string16&)> callback)
288 : callback_(callback) {}
289
290 void Run(bool dialog_was_suppressed,
291 bool success,
292 const base::string16& user_input) {
293 if (already_fired_)
294 return;
295 already_fired_ = true;
296 callback_.Run(dialog_was_suppressed, success, user_input);
297 }
298
299 private:
300 friend class base::RefCountedThreadSafe<CloseDialogCallbackWrapper>;
301 ~CloseDialogCallbackWrapper() {}
302 bool already_fired_ = false;
303 base::Callback<void(bool, bool, const base::string16&)> callback_;
304};
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),
mohan.reddyaae039a2014-11-21 17:39:50545 virtual_keyboard_requested_(false),
mcnee336ea2c2017-05-23 22:50:59546#if !defined(OS_ANDROID)
mcnee432e47d2015-11-09 19:37:46547 page_scale_factor_is_one_(true),
mcnee336ea2c2017-05-23 22:50:59548#endif // !defined(OS_ANDROID)
lfgbee1e0a2016-06-08 21:24:21549 mouse_lock_widget_(nullptr),
qinmin72e8bd02016-10-21 19:35:37550 is_overlay_content_(false),
ekaramadf6750aa2017-06-06 18:29:42551 showing_context_menu_(false),
pkotwicz75ca8ffd2016-02-16 23:10:19552 loading_weak_factory_(this),
553 weak_factory_(this) {
[email protected]9b159a52013-10-03 17:24:55554 frame_tree_.SetFrameRemoveListener(
555 base::Bind(&WebContentsImpl::OnFrameRemoved,
556 base::Unretained(this)));
dalecurtisc85ed632016-01-13 00:22:46557#if defined(OS_ANDROID)
558 media_web_contents_observer_.reset(new MediaWebContentsObserverAndroid(this));
559#else
qinmin58567c82015-01-07 21:00:20560 media_web_contents_observer_.reset(new MediaWebContentsObserver(this));
dalecurtisc85ed632016-01-13 00:22:46561#endif
brettw4b461082016-11-19 18:55:16562#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17563 pepper_playback_observer_.reset(new PepperPlaybackObserver(this));
564#endif
blundelle75a8f92017-03-27 08:11:17565
csharrisona2280cd2016-02-03 23:21:15566 loader_io_thread_notifier_.reset(new LoaderIOThreadNotifier(this));
mcnee336ea2c2017-05-23 22:50:59567#if !defined(OS_ANDROID)
scottmg276753cf2016-10-27 18:25:22568 host_zoom_map_observer_.reset(new HostZoomMapObserver(this));
mcnee336ea2c2017-05-23 22:50:59569#endif // !defined(OS_ANDROID)
[email protected]332af7732009-03-11 13:21:35570}
initial.commit09911bf2008-07-26 23:55:29571
[email protected]b172aee2012-04-10 17:05:26572WebContentsImpl::~WebContentsImpl() {
creisba91ba82017-05-12 22:56:19573 // Imperfect sanity check against double free, given some crashes unexpectedly
574 // observed in the wild.
575 CHECK(!is_being_destroyed_);
576
577 // We generally keep track of is_being_destroyed_ to let other features know
578 // to avoid certain actions during destruction.
[email protected]420ae012009-04-24 05:16:32579 is_being_destroyed_ = true;
580
creis97867aa2017-02-17 18:39:45581 // A WebContents should never be deleted while it is notifying observers,
creisba91ba82017-05-12 22:56:19582 // since this will lead to a use-after-free as it continues to notify later
creis97867aa2017-02-17 18:39:45583 // observers.
584 CHECK(!is_notifying_observers_);
585
kenrb2a565f82015-09-02 20:24:59586 rwh_input_event_router_.reset();
587
rockotf62002a2016-09-15 00:08:59588 for (auto& entry : binding_sets_)
589 entry.second->CloseAllBindings();
590
avallee0206f782016-07-28 18:55:33591 WebContentsImpl* outermost = GetOutermostWebContents();
avallee9993fca2016-11-17 06:16:50592 if (this != outermost && ContainsOrIsFocusedWebContents()) {
avallee0206f782016-07-28 18:55:33593 // If the current WebContents is in focus, unset it.
avallee9993fca2016-11-17 06:16:50594 outermost->SetAsFocusedWebContentsIfNecessary();
avallee0206f782016-07-28 18:55:33595 }
596
dcheng72be33c2016-01-21 04:11:31597 for (FrameTreeNode* node : frame_tree_.Nodes()) {
598 // Delete all RFHs pending shutdown, which will lead the corresponding RVHs
599 // to be shutdown and be deleted as well.
dcheng57e39e22016-01-21 00:25:38600 node->render_manager()->ClearRFHsPendingShutdown();
dcheng57e39e22016-01-21 00:25:38601 node->render_manager()->ClearWebUIInstances();
dcheng72be33c2016-01-21 04:11:31602 }
carlosk35f35af2015-12-01 10:55:40603
dcheng57e39e22016-01-21 00:25:38604 for (RenderWidgetHostImpl* widget : created_widgets_)
605 widget->DetachDelegate();
[email protected]b24b68a2012-09-24 21:57:26606 created_widgets_.clear();
607
[email protected]3ab9cb82011-06-03 18:02:07608 // Clear out any JavaScript state.
avi5d3b8692016-10-12 22:00:46609 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:53610 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:46611 }
[email protected]3ab9cb82011-06-03 18:02:07612
[email protected]8ed16472014-04-11 19:02:48613 if (color_chooser_info_.get())
614 color_chooser_info_->chooser->End();
[email protected]da8543762012-03-20 08:52:20615
[email protected]420ae012009-04-24 05:16:32616 NotifyDisconnected();
[email protected]420ae012009-04-24 05:16:32617
[email protected]ca13a442012-04-17 14:00:12618 // Notify any observer that have a reference on this WebContents.
[email protected]8ff00d72012-10-23 19:12:21619 NotificationService::current()->Notify(
620 NOTIFICATION_WEB_CONTENTS_DESTROYED,
621 Source<WebContents>(this),
622 NotificationService::NoDetails());
[email protected]420ae012009-04-24 05:16:32623
[email protected]df0c843f2014-05-23 20:37:23624 // Destroy all frame tree nodes except for the root; this notifies observers.
nick53d5cbf2015-04-23 22:50:14625 frame_tree_.root()->ResetForNewProcess();
[email protected]df0c843f2014-05-23 20:37:23626 GetRenderManager()->ResetProxyHosts();
[email protected]c06c58c2014-03-12 20:31:59627
clamy0e119882015-07-31 16:12:33628 // Manually call the observer methods for the root frame tree node. It is
629 // necessary to manually delete all objects tracking navigations
630 // (NavigationHandle, NavigationRequest) for observers to be properly
631 // notified of these navigations stopping before the WebContents is
632 // destroyed.
[email protected]df0c843f2014-05-23 20:37:23633 RenderFrameHostManager* root = GetRenderManager();
naskob21fe4872015-02-24 14:15:56634
clamy0e119882015-07-31 16:12:33635 if (root->pending_frame_host()) {
naskob21fe4872015-02-24 14:15:56636 root->pending_frame_host()->SetRenderFrameCreated(false);
clamy0e119882015-07-31 16:12:33637 root->pending_frame_host()->SetNavigationHandle(
dcheng59716272016-04-09 05:19:08638 std::unique_ptr<NavigationHandleImpl>());
clamy0e119882015-07-31 16:12:33639 }
naskob21fe4872015-02-24 14:15:56640 root->current_frame_host()->SetRenderFrameCreated(false);
clamy0e119882015-07-31 16:12:33641 root->current_frame_host()->SetNavigationHandle(
dcheng59716272016-04-09 05:19:08642 std::unique_ptr<NavigationHandleImpl>());
clamy0e119882015-07-31 16:12:33643
644 // PlzNavigate: clear up state specific to browser-side navigation.
carloskd80262f52015-12-16 14:40:35645 if (IsBrowserSideNavigationEnabled()) {
clamy82a2f4d2016-02-02 14:20:41646 // Do not update state as the WebContents is being destroyed.
clamya86695b2017-03-23 14:45:48647 frame_tree_.root()->ResetNavigationRequest(true, true);
clamy0e119882015-07-31 16:12:33648 if (root->speculative_frame_host()) {
649 root->speculative_frame_host()->SetRenderFrameCreated(false);
650 root->speculative_frame_host()->SetNavigationHandle(
dcheng59716272016-04-09 05:19:08651 std::unique_ptr<NavigationHandleImpl>());
clamy0e119882015-07-31 16:12:33652 }
653 }
[email protected]f273ee52013-10-18 16:05:27654
brettw4b461082016-11-19 18:55:16655#if BUILDFLAG(ENABLE_PLUGINS)
zqzhang181047e62016-07-01 13:37:17656 // Call this before WebContentsDestroyed() is broadcasted since
657 // AudioFocusManager will be destroyed after that.
658 pepper_playback_observer_.reset();
659#endif // defined(ENABLED_PLUGINS)
660
ericwilligersde386342016-10-19 02:35:09661 for (auto& observer : observers_)
662 observer.FrameDeleted(root->current_frame_host());
naskoa83483fb2015-02-27 16:57:10663
[email protected]df0c843f2014-05-23 20:37:23664 if (root->pending_render_view_host()) {
ericwilligersde386342016-10-19 02:35:09665 for (auto& observer : observers_)
666 observer.RenderViewDeleted(root->pending_render_view_host());
[email protected]df0c843f2014-05-23 20:37:23667 }
[email protected]c06c58c2014-03-12 20:31:59668
ericwilligersde386342016-10-19 02:35:09669 for (auto& observer : observers_)
670 observer.RenderViewDeleted(root->current_host());
[email protected]f273ee52013-10-18 16:05:27671
ericwilligersde386342016-10-19 02:35:09672 for (auto& observer : observers_)
673 observer.WebContentsDestroyed();
[email protected]12a46832014-05-09 13:35:58674
ericwilligersde386342016-10-19 02:35:09675 for (auto& observer : observers_)
676 observer.ResetWebContents();
[email protected]232a5812011-03-04 22:42:08677
[email protected]6934a702011-12-20 00:04:51678 SetDelegate(NULL);
[email protected]b5a1d11c2011-02-17 03:09:42679}
680
[email protected]d1198fd2012-08-13 22:50:19681WebContentsImpl* WebContentsImpl::CreateWithOpener(
[email protected]54944cde2012-12-09 09:24:59682 const WebContents::CreateParams& params,
alexmose201c7cd2015-06-10 17:14:21683 FrameTreeNode* opener) {
[email protected]e11f0e92013-06-12 15:12:03684 TRACE_EVENT0("browser", "WebContentsImpl::CreateWithOpener");
alexmose201c7cd2015-06-10 17:14:21685 WebContentsImpl* new_contents = new WebContentsImpl(params.browser_context);
lukasza6f8ac622017-06-06 03:10:20686 new_contents->SetOpenerForNewContents(opener, params.opener_suppressed);
alexmose201c7cd2015-06-10 17:14:21687
alexmosaedfc6f2016-01-21 23:57:38688 // If the opener is sandboxed, a new popup must inherit the opener's sandbox
689 // flags, and these flags take effect immediately. An exception is if the
690 // opener's sandbox flags lack the PropagatesToAuxiliaryBrowsingContexts
691 // bit (which is controlled by the "allow-popups-to-escape-sandbox" token).
692 // See https://html.spec.whatwg.org/#attr-iframe-sandbox.
lukasza6f8ac622017-06-06 03:10:20693 FrameTreeNode* new_root = new_contents->GetFrameTree()->root();
alexmosaedfc6f2016-01-21 23:57:38694 if (opener) {
695 blink::WebSandboxFlags opener_flags = opener->effective_sandbox_flags();
696 const blink::WebSandboxFlags inherit_flag =
Blink Reformat1c4d759e2017-04-09 16:34:54697 blink::WebSandboxFlags::kPropagatesToAuxiliaryBrowsingContexts;
alexmosaedfc6f2016-01-21 23:57:38698 if ((opener_flags & inherit_flag) == inherit_flag) {
699 new_root->SetPendingSandboxFlags(opener_flags);
iclelland92f8c0b2017-04-19 12:43:05700 new_root->CommitPendingFramePolicy();
alexmosaedfc6f2016-01-21 23:57:38701 }
702 }
703
alexmose201c7cd2015-06-10 17:14:21704 // This may be true even when opener is null, such as when opening blocked
705 // popups.
alexmos090fae8e2015-05-28 17:09:28706 if (params.created_with_opener)
707 new_contents->created_with_opener_ = true;
708
[email protected]4858e432014-06-23 18:14:17709 if (params.guest_delegate) {
[email protected]83100cd2014-05-10 11:50:06710 // This makes |new_contents| act as a guest.
711 // For more info, see comment above class BrowserPluginGuest.
[email protected]2101c4c2014-08-22 00:16:16712 BrowserPluginGuest::Create(new_contents, params.guest_delegate);
[email protected]83100cd2014-05-10 11:50:06713 // We are instantiating a WebContents for browser plugin. Set its subframe
714 // bit to true.
715 new_contents->is_subframe_ = true;
716 }
[email protected]54944cde2012-12-09 09:24:59717 new_contents->Init(params);
[email protected]d1198fd2012-08-13 22:50:19718 return new_contents;
719}
720
[email protected]95640212014-07-26 18:14:30721// static
722std::vector<WebContentsImpl*> WebContentsImpl::GetAllWebContents() {
723 std::vector<WebContentsImpl*> result;
dcheng59716272016-04-09 05:19:08724 std::unique_ptr<RenderWidgetHostIterator> widgets(
[email protected]95640212014-07-26 18:14:30725 RenderWidgetHostImpl::GetRenderWidgetHosts());
[email protected]95640212014-07-26 18:14:30726 while (RenderWidgetHost* rwh = widgets->GetNextHost()) {
[email protected]95640212014-07-26 18:14:30727 RenderViewHost* rvh = RenderViewHost::From(rwh);
728 if (!rvh)
729 continue;
730 WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
731 if (!web_contents)
732 continue;
avidf38c952015-10-27 13:45:13733 if (web_contents->GetRenderViewHost() != rvh)
734 continue;
735 // Because a WebContents can only have one current RVH at a time, there will
736 // be no duplicate WebContents here.
737 result.push_back(static_cast<WebContentsImpl*>(web_contents));
[email protected]95640212014-07-26 18:14:30738 }
739 return result;
740}
741
clamya16aa8172015-05-26 13:07:25742// static
743WebContentsImpl* WebContentsImpl::FromFrameTreeNode(
paulmeyerfeafc2d2017-04-25 21:46:40744 const FrameTreeNode* frame_tree_node) {
clamya16aa8172015-05-26 13:07:25745 return static_cast<WebContentsImpl*>(
746 WebContents::FromRenderFrameHost(frame_tree_node->current_frame_host()));
747}
748
clamy0d32d6d2015-11-24 11:16:26749// static
750WebContents* WebContentsImpl::FromRenderFrameHostID(int render_process_host_id,
751 int render_frame_host_id) {
752 DCHECK_CURRENTLY_ON(BrowserThread::UI);
753 RenderFrameHost* render_frame_host =
754 RenderFrameHost::FromID(render_process_host_id, render_frame_host_id);
755 if (!render_frame_host)
756 return nullptr;
757
758 return WebContents::FromRenderFrameHost(render_frame_host);
759}
760
paulmeyerfeafc2d2017-04-25 21:46:40761// static
762WebContentsImpl* WebContentsImpl::FromOuterFrameTreeNode(
763 const FrameTreeNode* frame_tree_node) {
764 return WebContentsImpl::FromFrameTreeNode(frame_tree_node)
765 ->node_.GetInnerWebContentsInFrame(frame_tree_node);
766}
767
[email protected]b0936d22013-11-28 06:47:36768RenderFrameHostManager* WebContentsImpl::GetRenderManagerForTesting() {
[email protected]fa944cb82013-11-15 17:51:21769 return GetRenderManager();
[email protected]765187182012-01-11 23:59:28770}
771
nicka0ac8382016-12-15 23:59:23772bool WebContentsImpl::OnMessageReceived(RenderViewHostImpl* render_view_host,
[email protected]7bb761892012-07-20 09:32:47773 const IPC::Message& message) {
nicka0ac8382016-12-15 23:59:23774 RenderFrameHost* main_frame = render_view_host->GetMainFrame();
775 if (main_frame) {
776 WebUIImpl* web_ui = static_cast<RenderFrameHostImpl*>(main_frame)->web_ui();
777 if (web_ui && web_ui->OnMessageReceived(message))
778 return true;
[email protected]d2353452012-01-19 19:53:56779 }
[email protected]f82d57b52011-04-27 19:13:17780
nicka0ac8382016-12-15 23:59:23781 for (auto& observer : observers_) {
782 // TODO(nick, creis): Replace all uses of this variant of OnMessageReceived
783 // with the version that takes a RenderFrameHost, and delete it.
784 if (observer.OnMessageReceived(message))
785 return true;
[email protected]64ffefa2014-05-10 12:06:33786 }
[email protected]403415a2011-01-10 18:57:53787
[email protected]724159a2010-12-30 01:11:18788 bool handled = true;
nicka0ac8382016-12-15 23:59:23789 IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(WebContentsImpl, message, render_view_host)
790 IPC_MESSAGE_HANDLER(ViewHostMsg_DidFirstVisuallyNonEmptyPaint,
791 OnFirstVisuallyNonEmptyPaint)
792 IPC_MESSAGE_HANDLER(ViewHostMsg_GoToEntryAtOffset, OnGoToEntryAtOffset)
793 IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateZoomLimits, OnUpdateZoomLimits)
794 IPC_MESSAGE_HANDLER(ViewHostMsg_PageScaleFactorChanged,
795 OnPageScaleFactorChanged)
796 IPC_MESSAGE_HANDLER(ViewHostMsg_EnumerateDirectory, OnEnumerateDirectory)
797 IPC_MESSAGE_HANDLER(ViewHostMsg_AppCacheAccessed, OnAppCacheAccessed)
798 IPC_MESSAGE_HANDLER(ViewHostMsg_WebUISend, OnWebUISend)
799#if BUILDFLAG(ENABLE_PLUGINS)
800 IPC_MESSAGE_HANDLER(ViewHostMsg_RequestPpapiBrokerPermission,
801 OnRequestPpapiBrokerPermission)
802#endif
nicka0ac8382016-12-15 23:59:23803 IPC_MESSAGE_HANDLER(ViewHostMsg_ShowValidationMessage,
804 OnShowValidationMessage)
805 IPC_MESSAGE_HANDLER(ViewHostMsg_HideValidationMessage,
806 OnHideValidationMessage)
807 IPC_MESSAGE_HANDLER(ViewHostMsg_MoveValidationMessage,
808 OnMoveValidationMessage)
809#if defined(OS_ANDROID)
810 IPC_MESSAGE_HANDLER(ViewHostMsg_OpenDateTimeDialog, OnOpenDateTimeDialog)
811#endif
812 IPC_MESSAGE_UNHANDLED(handled = false)
813 IPC_END_MESSAGE_MAP()
814
815 return handled;
816}
817
818bool WebContentsImpl::OnMessageReceived(RenderFrameHostImpl* render_frame_host,
819 const IPC::Message& message) {
820 for (auto& observer : observers_) {
821 if (observer.OnMessageReceived(message, render_frame_host))
822 return true;
823 }
824
825 bool handled = true;
826 IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(WebContentsImpl, message, render_frame_host)
[email protected]cfa856d62014-02-22 07:58:40827 IPC_MESSAGE_HANDLER(FrameHostMsg_DomOperationResponse,
828 OnDomOperationResponse)
[email protected]37b64c52014-07-11 21:14:05829 IPC_MESSAGE_HANDLER(FrameHostMsg_DidChangeThemeColor,
830 OnThemeColorChanged)
[email protected]8ed16472014-04-11 19:02:48831 IPC_MESSAGE_HANDLER(FrameHostMsg_DidFinishDocumentLoad,
832 OnDocumentLoadedInFrame)
833 IPC_MESSAGE_HANDLER(FrameHostMsg_DidFinishLoad, OnDidFinishLoad)
834 IPC_MESSAGE_HANDLER(FrameHostMsg_OpenColorChooser, OnOpenColorChooser)
835 IPC_MESSAGE_HANDLER(FrameHostMsg_EndColorChooser, OnEndColorChooser)
836 IPC_MESSAGE_HANDLER(FrameHostMsg_SetSelectedColorInColorChooser,
837 OnSetSelectedColorInColorChooser)
avi7830c852015-08-31 23:46:25838 IPC_MESSAGE_HANDLER(FrameHostMsg_DidLoadResourceFromMemoryCache,
[email protected]724159a2010-12-30 01:11:18839 OnDidLoadResourceFromMemoryCache)
avi3a3332622015-09-01 01:18:54840 IPC_MESSAGE_HANDLER(FrameHostMsg_DidDisplayInsecureContent,
[email protected]724159a2010-12-30 01:11:18841 OnDidDisplayInsecureContent)
elawrenceb2ac2a232017-03-27 21:46:25842 IPC_MESSAGE_HANDLER(FrameHostMsg_DidContainInsecureFormAction,
843 OnDidContainInsecureFormAction)
avi3a3332622015-09-01 01:18:54844 IPC_MESSAGE_HANDLER(FrameHostMsg_DidRunInsecureContent,
[email protected]724159a2010-12-30 01:11:18845 OnDidRunInsecureContent)
estark910b4572015-12-09 20:55:41846 IPC_MESSAGE_HANDLER(FrameHostMsg_DidDisplayContentWithCertificateErrors,
847 OnDidDisplayContentWithCertificateErrors)
848 IPC_MESSAGE_HANDLER(FrameHostMsg_DidRunContentWithCertificateErrors,
849 OnDidRunContentWithCertificateErrors)
avia23e16b2015-07-09 14:18:48850 IPC_MESSAGE_HANDLER(FrameHostMsg_RegisterProtocolHandler,
851 OnRegisterProtocolHandler)
852 IPC_MESSAGE_HANDLER(FrameHostMsg_UnregisterProtocolHandler,
853 OnUnregisterProtocolHandler)
kouhei40f03cb2015-09-24 07:47:01854 IPC_MESSAGE_HANDLER(FrameHostMsg_UpdatePageImportanceSignals,
855 OnUpdatePageImportanceSignals)
paulmeyer5d0a5f02016-01-21 20:15:52856 IPC_MESSAGE_HANDLER(FrameHostMsg_Find_Reply, OnFindReply)
lukasza178ff092017-06-07 23:39:50857 IPC_MESSAGE_HANDLER(FrameHostMsg_UpdateFaviconURL, OnUpdateFaviconURL)
brettw4b461082016-11-19 18:55:16858#if BUILDFLAG(ENABLE_PLUGINS)
emaxxe70f5e12015-05-29 11:26:00859 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperInstanceCreated,
860 OnPepperInstanceCreated)
861 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperInstanceDeleted,
862 OnPepperInstanceDeleted)
tommyclie6633ca72014-10-31 00:40:42863 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperPluginHung, OnPepperPluginHung)
zqzhang181047e62016-07-01 13:37:17864 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperStartsPlayback,
865 OnPepperStartsPlayback)
866 IPC_MESSAGE_HANDLER(FrameHostMsg_PepperStopsPlayback,
867 OnPepperStopsPlayback)
tommyclie6633ca72014-10-31 00:40:42868 IPC_MESSAGE_HANDLER(FrameHostMsg_PluginCrashed, OnPluginCrashed)
[email protected]c4538072013-03-18 02:17:55869 IPC_MESSAGE_HANDLER_GENERIC(BrowserPluginHostMsg_Attach,
fsamuel833ee7c2015-02-13 23:40:40870 OnBrowserPluginMessage(render_frame_host,
871 message))
thestigc4cac8f2014-09-04 21:17:50872#endif
mfomitchev2b8b066a2016-01-28 19:23:15873#if defined(OS_ANDROID)
paulmeyer5d0a5f02016-01-21 20:15:52874 IPC_MESSAGE_HANDLER(FrameHostMsg_FindMatchRects_Reply,
[email protected]8ed16472014-04-11 19:02:48875 OnFindMatchRectsReply)
paulmeyerc8cb7cb2016-06-07 01:14:19876 IPC_MESSAGE_HANDLER(FrameHostMsg_GetNearestFindResult_Reply,
877 OnGetNearestFindResultReply)
[email protected]8ed16472014-04-11 19:02:48878#endif
[email protected]724159a2010-12-30 01:11:18879 IPC_MESSAGE_UNHANDLED(handled = false)
[email protected]e44d1342014-05-16 21:29:33880 IPC_END_MESSAGE_MAP()
[email protected]724159a2010-12-30 01:11:18881
[email protected]724159a2010-12-30 01:11:18882 return handled;
883}
884
[email protected]d1198fd2012-08-13 22:50:19885NavigationControllerImpl& WebContentsImpl::GetController() {
[email protected]f5fa20e2011-12-21 22:35:56886 return controller_;
887}
888
[email protected]d1198fd2012-08-13 22:50:19889const NavigationControllerImpl& WebContentsImpl::GetController() const {
[email protected]f5fa20e2011-12-21 22:35:56890 return controller_;
891}
892
[email protected]8ff00d72012-10-23 19:12:21893BrowserContext* WebContentsImpl::GetBrowserContext() const {
[email protected]a26023822011-12-29 00:23:55894 return controller_.GetBrowserContext();
[email protected]627e0512011-12-21 22:55:30895}
896
[email protected]b172aee2012-04-10 17:05:26897const GURL& WebContentsImpl::GetURL() const {
[email protected]c854a7e2013-05-21 16:42:24898 // We may not have a navigation entry yet.
[email protected]59167c22013-06-03 18:07:32899 NavigationEntry* entry = controller_.GetVisibleEntry();
[email protected]36fc0392011-12-25 03:59:51900 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
[email protected]be1f56ab2011-12-22 06:55:31901}
902
[email protected]a093ce02013-07-22 20:53:14903const GURL& WebContentsImpl::GetVisibleURL() const {
[email protected]c854a7e2013-05-21 16:42:24904 // We may not have a navigation entry yet.
[email protected]59167c22013-06-03 18:07:32905 NavigationEntry* entry = controller_.GetVisibleEntry();
[email protected]c854a7e2013-05-21 16:42:24906 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
907}
908
909const GURL& WebContentsImpl::GetLastCommittedURL() const {
910 // We may not have a navigation entry yet.
911 NavigationEntry* entry = controller_.GetLastCommittedEntry();
912 return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
913}
914
[email protected]8ff00d72012-10-23 19:12:21915WebContentsDelegate* WebContentsImpl::GetDelegate() {
[email protected]be1f56ab2011-12-22 06:55:31916 return delegate_;
917}
918
[email protected]8ff00d72012-10-23 19:12:21919void WebContentsImpl::SetDelegate(WebContentsDelegate* delegate) {
[email protected]be1f56ab2011-12-22 06:55:31920 // TODO(cbentzel): remove this debugging code?
921 if (delegate == delegate_)
922 return;
923 if (delegate_)
924 delegate_->Detach(this);
925 delegate_ = delegate;
[email protected]a6b73c62013-02-11 23:05:08926 if (delegate_) {
[email protected]be1f56ab2011-12-22 06:55:31927 delegate_->Attach(this);
[email protected]a6b73c62013-02-11 23:05:08928 // Ensure the visible RVH reflects the new delegate's preferences.
[email protected]86f98a22013-03-20 14:35:00929 if (view_)
[email protected]e85165c642014-06-10 14:34:31930 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]a6b73c62013-02-11 23:05:08931 }
[email protected]be1f56ab2011-12-22 06:55:31932}
933
[email protected]8ff00d72012-10-23 19:12:21934RenderProcessHost* WebContentsImpl::GetRenderProcessHost() const {
[email protected]fa944cb82013-11-15 17:51:21935 RenderViewHostImpl* host = GetRenderManager()->current_host();
[email protected]82114f52012-03-20 22:53:41936 return host ? host->GetProcess() : NULL;
[email protected]8cb5d5b2010-02-09 11:36:16937}
938
clamydf1975e2015-02-05 19:12:24939RenderFrameHostImpl* WebContentsImpl::GetMainFrame() {
[email protected]94d0cc12013-12-18 00:07:41940 return frame_tree_.root()->current_frame_host();
[email protected]60eca4eb2013-12-06 00:02:16941}
942
nick53d5cbf2015-04-23 22:50:14943RenderFrameHostImpl* WebContentsImpl::GetFocusedFrame() {
944 FrameTreeNode* focused_node = frame_tree_.GetFocusedFrame();
945 if (!focused_node)
946 return nullptr;
947 return focused_node->current_frame_host();
[email protected]9c9343b2014-03-08 02:56:07948}
949
rob3e2a0732016-01-06 21:22:09950RenderFrameHostImpl* WebContentsImpl::FindFrameByFrameTreeNodeId(
creisf71a2632017-05-04 19:03:50951 int frame_tree_node_id,
952 int process_id) {
953 FrameTreeNode* frame = frame_tree_.FindByID(frame_tree_node_id);
954
955 // Sanity check that this is in the caller's expected process. Otherwise a
956 // recent cross-process navigation may have led to a privilege change that the
957 // caller is not expecting.
958 if (!frame ||
959 frame->current_frame_host()->GetProcess()->GetID() != process_id)
960 return nullptr;
961
962 return frame->current_frame_host();
963}
964
965RenderFrameHostImpl* WebContentsImpl::UnsafeFindFrameByFrameTreeNodeId(
rob3e2a0732016-01-06 21:22:09966 int frame_tree_node_id) {
creisf71a2632017-05-04 19:03:50967 // Beware using this! The RenderFrameHost may have changed since the caller
968 // obtained frame_tree_node_id.
rob3e2a0732016-01-06 21:22:09969 FrameTreeNode* frame = frame_tree_.FindByID(frame_tree_node_id);
970 return frame ? frame->current_frame_host() : nullptr;
971}
972
[email protected]a86c0e962013-12-17 17:10:39973void WebContentsImpl::ForEachFrame(
974 const base::Callback<void(RenderFrameHost*)>& on_frame) {
dcheng57e39e22016-01-21 00:25:38975 for (FrameTreeNode* node : frame_tree_.Nodes()) {
976 on_frame.Run(node->current_frame_host());
977 }
[email protected]a86c0e962013-12-17 17:10:39978}
979
dchengafb53e22016-02-04 08:11:08980std::vector<RenderFrameHost*> WebContentsImpl::GetAllFrames() {
981 std::vector<RenderFrameHost*> frame_hosts;
982 for (FrameTreeNode* node : frame_tree_.Nodes())
983 frame_hosts.push_back(node->current_frame_host());
984 return frame_hosts;
985}
986
lukaszacbdf52e2016-01-15 21:19:51987int WebContentsImpl::SendToAllFrames(IPC::Message* message) {
988 int number_of_messages = 0;
dchengafb53e22016-02-04 08:11:08989 for (RenderFrameHost* rfh : GetAllFrames()) {
lukasza1a9ab2422016-03-02 18:47:25990 if (!rfh->IsRenderFrameLive())
991 continue;
992
dchengafb53e22016-02-04 08:11:08993 ++number_of_messages;
994 IPC::Message* message_copy = new IPC::Message(*message);
995 message_copy->set_routing_id(rfh->GetRoutingID());
996 rfh->Send(message_copy);
997 }
[email protected]a86c0e962013-12-17 17:10:39998 delete message;
lukaszacbdf52e2016-01-15 21:19:51999 return number_of_messages;
[email protected]a86c0e962013-12-17 17:10:391000}
1001
lfgdb5c4ed2016-03-04 23:09:071002void WebContentsImpl::SendPageMessage(IPC::Message* msg) {
alexmos136fd6e62016-08-15 20:58:411003 frame_tree_.root()->render_manager()->SendPageMessage(msg, nullptr);
lfgdb5c4ed2016-03-04 23:09:071004}
1005
creisc014b402015-04-23 16:41:451006RenderViewHostImpl* WebContentsImpl::GetRenderViewHost() const {
[email protected]fa944cb82013-11-15 17:51:211007 return GetRenderManager()->current_host();
[email protected]be1f56ab2011-12-22 06:55:311008}
1009
creis89a0f782015-05-27 16:13:171010void WebContentsImpl::CancelActiveAndPendingDialogs() {
avi5d3b8692016-10-12 22:00:461011 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:531012 dialog_manager_->CancelDialogs(this, /*reset_state=*/false);
avi5d3b8692016-10-12 22:00:461013 }
creis89a0f782015-05-27 16:13:171014 if (browser_plugin_embedder_)
1015 browser_plugin_embedder_->CancelGuestDialogs();
lukasza041634d2017-06-26 18:20:561016 if (delegate_)
1017 delegate_->HideValidationMessage(this);
creis89a0f782015-05-27 16:13:171018}
1019
naskoc0fceff2015-04-30 15:53:521020void WebContentsImpl::ClosePage() {
1021 GetRenderViewHost()->ClosePage();
1022}
1023
[email protected]b172aee2012-04-10 17:05:261024RenderWidgetHostView* WebContentsImpl::GetRenderWidgetHostView() const {
[email protected]fa944cb82013-11-15 17:51:211025 return GetRenderManager()->GetRenderWidgetHostView();
[email protected]be1f56ab2011-12-22 06:55:311026}
1027
lfg265a2672016-04-23 03:11:021028RenderWidgetHostView* WebContentsImpl::GetTopLevelRenderWidgetHostView() {
1029 if (GetOuterWebContents())
1030 return GetOuterWebContents()->GetTopLevelRenderWidgetHostView();
1031 return GetRenderManager()->GetRenderWidgetHostView();
1032}
1033
[email protected]4aebbca2013-09-17 22:26:491034RenderWidgetHostView* WebContentsImpl::GetFullscreenRenderWidgetHostView()
1035 const {
vmpstr6d9996c82017-02-23 00:43:251036 if (auto* widget_host = GetFullscreenRenderWidgetHost())
ekaramadaeb3c5c2016-11-09 03:22:351037 return widget_host->GetView();
1038 return nullptr;
[email protected]4aebbca2013-09-17 22:26:491039}
1040
[email protected]8ff00d72012-10-23 19:12:211041WebContentsView* WebContentsImpl::GetView() const {
[email protected]be1f56ab2011-12-22 06:55:311042 return view_.get();
1043}
1044
leon.han552e9de2017-02-09 14:37:301045void WebContentsImpl::OnScreenOrientationChange() {
1046 DCHECK(screen_orientation_provider_);
1047 return screen_orientation_provider_->OnOrientationChange();
leon.hane4db177a2017-02-07 14:19:161048}
1049
yusufod41c5f92015-03-06 00:14:281050SkColor WebContentsImpl::GetThemeColor() const {
1051 return theme_color_;
1052}
1053
Doug Turner63f3c7b2017-07-29 05:10:011054void WebContentsImpl::SetAccessibilityMode(ui::AXMode mode) {
[email protected]95640212014-07-26 18:14:301055 if (mode == accessibility_mode_)
1056 return;
1057
dmazzonif8a31042016-12-03 00:52:131058 // Don't allow accessibility to be enabled for WebContents that are never
1059 // visible, like background pages.
1060 if (IsNeverVisible())
1061 return;
1062
[email protected]95640212014-07-26 18:14:301063 accessibility_mode_ = mode;
dcheng57e39e22016-01-21 00:25:381064
1065 for (FrameTreeNode* node : frame_tree_.Nodes()) {
dmazzonif8a31042016-12-03 00:52:131066 UpdateAccessibilityModeOnFrame(node->current_frame_host());
dcheng57e39e22016-01-21 00:25:381067 RenderFrameHost* pending_frame_host =
1068 node->render_manager()->pending_frame_host();
1069 if (pending_frame_host)
dmazzonif8a31042016-12-03 00:52:131070 UpdateAccessibilityModeOnFrame(pending_frame_host);
dcheng57e39e22016-01-21 00:25:381071 }
[email protected]95640212014-07-26 18:14:301072}
1073
Doug Turner63f3c7b2017-07-29 05:10:011074void WebContentsImpl::AddAccessibilityMode(ui::AXMode mode) {
1075 ui::AXMode new_mode(accessibility_mode_);
dougtcd3dad732017-03-14 03:26:231076 new_mode |= mode;
1077 SetAccessibilityMode(new_mode);
[email protected]95640212014-07-26 18:14:301078}
1079
muyuanlic693ba12017-04-27 19:12:401080void WebContentsImpl::RequestAXTreeSnapshot(
1081 const AXTreeSnapshotCallback& callback) {
dmazzonid95ae842016-04-12 21:17:391082 // Send a request to each of the frames in parallel. Each one will return
1083 // an accessibility tree snapshot, and AXTreeSnapshotCombiner will combine
1084 // them into a single tree and call |callback| with that result, then
1085 // delete |combiner|.
1086 AXTreeSnapshotCombiner* combiner = new AXTreeSnapshotCombiner(callback);
1087 for (FrameTreeNode* frame_tree_node : frame_tree_.Nodes()) {
1088 bool is_root = frame_tree_node->parent() == nullptr;
1089 frame_tree_node->current_frame_host()->RequestAXTreeSnapshot(
1090 combiner->AddFrame(is_root));
1091 }
dmazzoni83ba5c82015-04-14 07:11:511092}
1093
mcnee336ea2c2017-05-23 22:50:591094#if !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:121095void WebContentsImpl::SetTemporaryZoomLevel(double level,
1096 bool temporary_zoom_enabled) {
1097 SendPageMessage(new PageMsg_SetZoomLevel(
1098 MSG_ROUTING_NONE,
1099 temporary_zoom_enabled ? PageMsg_SetZoomLevel_Command::SET_TEMPORARY
1100 : PageMsg_SetZoomLevel_Command::CLEAR_TEMPORARY,
1101 level));
1102}
1103
1104void WebContentsImpl::UpdateZoom(double level) {
1105 // Individual frames may still ignore the new zoom level if their RenderView
1106 // contains a plugin document or if it uses a temporary zoom level.
1107 SendPageMessage(new PageMsg_SetZoomLevel(
1108 MSG_ROUTING_NONE,
1109 PageMsg_SetZoomLevel_Command::USE_CURRENT_TEMPORARY_MODE, level));
1110}
1111
1112void WebContentsImpl::UpdateZoomIfNecessary(const std::string& scheme,
1113 const std::string& host,
1114 double level) {
1115 NavigationEntry* entry = GetController().GetLastCommittedEntry();
1116 if (!entry)
1117 return;
1118
1119 GURL url = HostZoomMap::GetURLFromEntry(entry);
1120 if (host != net::GetHostOrSpecFromURL(url) ||
1121 (!scheme.empty() && !url.SchemeIs(scheme))) {
1122 return;
1123 }
1124
1125 UpdateZoom(level);
1126}
mcnee336ea2c2017-05-23 22:50:591127#endif // !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:121128
rockotf62002a2016-09-15 00:08:591129base::Closure WebContentsImpl::AddBindingSet(
1130 const std::string& interface_name,
1131 WebContentsBindingSet* binding_set) {
1132 auto result =
1133 binding_sets_.insert(std::make_pair(interface_name, binding_set));
1134 DCHECK(result.second);
1135 return base::Bind(&WebContentsImpl::RemoveBindingSet,
1136 weak_factory_.GetWeakPtr(), interface_name);
1137}
1138
rockot8bbad222017-03-22 04:34:051139WebContentsBindingSet* WebContentsImpl::GetBindingSet(
1140 const std::string& interface_name) {
1141 auto it = binding_sets_.find(interface_name);
1142 if (it == binding_sets_.end())
1143 return nullptr;
1144 return it->second;
1145}
1146
paulmeyerfeafc2d2017-04-25 21:46:401147std::vector<WebContentsImpl*> WebContentsImpl::GetInnerWebContents() {
1148 if (browser_plugin_embedder_) {
1149 std::vector<WebContentsImpl*> inner_contents;
1150 GetBrowserContext()->GetGuestManager()->ForEachGuest(
1151 this, base::Bind(&GetInnerWebContentsHelper, &inner_contents));
1152 return inner_contents;
1153 }
1154
1155 return node_.inner_web_contents();
1156}
1157
1158std::vector<WebContentsImpl*> WebContentsImpl::GetWebContentsAndAllInner() {
1159 std::vector<WebContentsImpl*> all_contents(1, this);
1160
1161 for (size_t i = 0; i != all_contents.size(); ++i) {
1162 for (auto* inner_contents : all_contents[i]->GetInnerWebContents()) {
1163 all_contents.push_back(inner_contents);
1164 }
1165 }
1166
1167 return all_contents;
1168}
1169
Sam McNally145fb172017-05-10 00:13:231170void WebContentsImpl::NotifyManifestUrlChanged(
1171 const base::Optional<GURL>& manifest_url) {
1172 for (auto& observer : observers_)
1173 observer.DidUpdateWebManifestURL(manifest_url);
1174}
1175
wjmaclean8a795f32016-08-11 23:49:581176void WebContentsImpl::UpdateDeviceScaleFactor(double device_scale_factor) {
1177 SendPageMessage(
1178 new PageMsg_SetDeviceScaleFactor(MSG_ROUTING_NONE, device_scale_factor));
1179}
1180
ccameron2f451532016-09-07 21:49:271181void WebContentsImpl::GetScreenInfo(ScreenInfo* screen_info) {
wjmaclean8a795f32016-08-11 23:49:581182 if (GetView())
ccameron2f451532016-09-07 21:49:271183 GetView()->GetScreenInfo(screen_info);
wjmaclean8a795f32016-08-11 23:49:581184}
1185
avie865b1d2016-10-24 19:42:591186std::unique_ptr<WebUI> WebContentsImpl::CreateSubframeWebUI(
1187 const GURL& url,
1188 const std::string& frame_name) {
dbeama1b926a2015-08-31 23:17:511189 DCHECK(!frame_name.empty());
1190 return CreateWebUI(url, frame_name);
[email protected]c63cedf22012-01-17 18:42:221191}
1192
[email protected]8ff00d72012-10-23 19:12:211193WebUI* WebContentsImpl::GetWebUI() const {
carlosk35f35af2015-12-01 10:55:401194 WebUI* commited_web_ui = GetCommittedWebUI();
1195 return commited_web_ui ? commited_web_ui
1196 : GetRenderManager()->GetNavigatingWebUI();
[email protected]be1f56ab2011-12-22 06:55:311197}
1198
[email protected]8ff00d72012-10-23 19:12:211199WebUI* WebContentsImpl::GetCommittedWebUI() const {
carlosk35f35af2015-12-01 10:55:401200 return frame_tree_.root()->current_frame_host()->web_ui();
[email protected]d5f942ba2008-09-26 19:30:341201}
1202
[email protected]86ef6a392012-05-11 22:03:111203void WebContentsImpl::SetUserAgentOverride(const std::string& override) {
[email protected]bf70edce2012-06-20 22:32:221204 if (GetUserAgentOverride() == override)
1205 return;
1206
1207 renderer_preferences_.user_agent_override = override;
1208
1209 // Send the new override string to the renderer.
1210 RenderViewHost* host = GetRenderViewHost();
1211 if (host)
1212 host->SyncRendererPrefs();
1213
1214 // Reload the page if a load is currently in progress to avoid having
1215 // different parts of the page loaded using different user agents.
[email protected]6286a372013-10-09 04:03:271216 NavigationEntry* entry = controller_.GetVisibleEntry();
clamy44e84ce2016-02-22 15:38:251217 if (IsLoading() && entry != NULL && entry->GetIsOverridingUserAgent())
toyoshim6142d96f2016-12-19 09:07:251218 controller_.Reload(ReloadType::BYPASSING_CACHE, true);
[email protected]8d0f3312012-08-18 01:47:531219
ericwilligersde386342016-10-19 02:35:091220 for (auto& observer : observers_)
1221 observer.UserAgentOverrideSet(override);
[email protected]86ef6a392012-05-11 22:03:111222}
1223
1224const std::string& WebContentsImpl::GetUserAgentOverride() const {
[email protected]bf70edce2012-06-20 22:32:221225 return renderer_preferences_.user_agent_override;
[email protected]86ef6a392012-05-11 22:03:111226}
1227
dmazzonidd3d51a72016-12-14 18:41:011228void WebContentsImpl::EnableWebContentsOnlyAccessibilityMode() {
dougtcd3dad732017-03-14 03:26:231229 if (!GetAccessibilityMode().is_mode_off()) {
dchengafb53e22016-02-04 08:11:081230 for (RenderFrameHost* rfh : GetAllFrames())
1231 ResetAccessibility(rfh);
1232 } else {
Doug Turner63f3c7b2017-07-29 05:10:011233 AddAccessibilityMode(ui::kAXModeWebContentsOnly);
dchengafb53e22016-02-04 08:11:081234 }
[email protected]95640212014-07-26 18:14:301235}
1236
dmazzonidd3d51a72016-12-14 18:41:011237bool WebContentsImpl::IsWebContentsOnlyAccessibilityModeForTesting() const {
Doug Turner63f3c7b2017-07-29 05:10:011238 return accessibility_mode_ == ui::kAXModeWebContentsOnly;
[email protected]95640212014-07-26 18:14:301239}
1240
1241bool WebContentsImpl::IsFullAccessibilityModeForTesting() const {
Doug Turner63f3c7b2017-07-29 05:10:011242 return accessibility_mode_ == ui::kAXModeComplete;
[email protected]95640212014-07-26 18:14:301243}
1244
kouhei40f03cb2015-09-24 07:47:011245const PageImportanceSignals& WebContentsImpl::GetPageImportanceSignals() const {
1246 return page_importance_signals_;
1247}
1248
[email protected]fcf75d42013-12-03 20:11:261249const base::string16& WebContentsImpl::GetTitle() const {
[email protected]4c6092c5b2009-06-06 00:23:551250 // Transient entries take precedence. They are used for interstitial pages
1251 // that are shown on top of existing pages.
[email protected]10f417c52011-12-28 21:04:231252 NavigationEntry* entry = controller_.GetTransientEntry();
[email protected]45d0ef7f2011-01-05 13:46:231253 if (entry) {
jshin1fb76462016-04-05 22:13:031254 return entry->GetTitleForDisplay();
[email protected]45d0ef7f2011-01-05 13:46:231255 }
carlosk35f35af2015-12-01 10:55:401256
1257 WebUI* navigating_web_ui = GetRenderManager()->GetNavigatingWebUI();
1258 WebUI* our_web_ui = navigating_web_ui
1259 ? navigating_web_ui
1260 : GetRenderManager()->current_frame_host()->web_ui();
1261
[email protected]7ade2732011-02-10 00:13:581262 if (our_web_ui) {
[email protected]96d185d2009-04-24 03:28:541263 // Don't override the title in view source mode.
[email protected]59167c22013-06-03 18:07:321264 entry = controller_.GetVisibleEntry();
[email protected]96d185d2009-04-24 03:28:541265 if (!(entry && entry->IsViewSourceMode())) {
[email protected]e0112912011-02-02 22:54:351266 // Give the Web UI the chance to override our title.
[email protected]fcf75d42013-12-03 20:11:261267 const base::string16& title = our_web_ui->GetOverriddenTitle();
[email protected]96d185d2009-04-24 03:28:541268 if (!title.empty())
1269 return title;
1270 }
1271 }
1272
1273 // We use the title for the last committed entry rather than a pending
1274 // navigation entry. For example, when the user types in a URL, we want to
1275 // keep the old page's title until the new load has committed and we get a new
1276 // title.
[email protected]96d185d2009-04-24 03:28:541277 entry = controller_.GetLastCommittedEntry();
[email protected]59167c22013-06-03 18:07:321278
creis072b61f2015-09-28 20:52:241279 // We make an exception for initial navigations. We only want to use the title
1280 // from the visible entry if:
1281 // 1. The pending entry has been explicitly assigned a title to display.
1282 // 2. The user is doing a history navigation in a new tab (e.g., Ctrl+Back),
1283 // which case there is a pending entry index other than -1.
1284 //
1285 // Otherwise, we want to stick with the last committed entry's title during
1286 // new navigations, which have pending entries at index -1 with no title.
1287 if (controller_.IsInitialNavigation() &&
1288 ((controller_.GetVisibleEntry() &&
1289 !controller_.GetVisibleEntry()->GetTitle().empty()) ||
1290 controller_.GetPendingEntryIndex() != -1)) {
1291 entry = controller_.GetVisibleEntry();
[email protected]9eeafc012013-11-25 23:49:471292 }
[email protected]59167c22013-06-03 18:07:321293
[email protected]45d0ef7f2011-01-05 13:46:231294 if (entry) {
jshin1fb76462016-04-05 22:13:031295 return entry->GetTitleForDisplay();
[email protected]45d0ef7f2011-01-05 13:46:231296 }
[email protected]987fc3a2011-05-26 14:18:091297
1298 // |page_title_when_no_navigation_entry_| is finally used
1299 // if no title cannot be retrieved.
1300 return page_title_when_no_navigation_entry_;
[email protected]96d185d2009-04-24 03:28:541301}
1302
creiscce56cd2014-09-29 22:45:221303SiteInstanceImpl* WebContentsImpl::GetSiteInstance() const {
[email protected]fa944cb82013-11-15 17:51:211304 return GetRenderManager()->current_host()->GetSiteInstance();
[email protected]96d185d2009-04-24 03:28:541305}
1306
creiscce56cd2014-09-29 22:45:221307SiteInstanceImpl* WebContentsImpl::GetPendingSiteInstance() const {
1308 RenderViewHostImpl* dest_rvh =
1309 GetRenderManager()->pending_render_view_host() ?
1310 GetRenderManager()->pending_render_view_host() :
1311 GetRenderManager()->current_host();
[email protected]9f76c1e2012-03-05 15:15:581312 return dest_rvh->GetSiteInstance();
[email protected]77362eb2011-08-01 17:18:381313}
1314
[email protected]b172aee2012-04-10 17:05:261315bool WebContentsImpl::IsLoading() const {
clamy44e84ce2016-02-22 15:38:251316 return frame_tree_.IsLoading() &&
creisadca9862017-06-16 19:12:111317 !(ShowingInterstitialPage() && interstitial_page_->pause_throbber());
[email protected]3c9e1872010-11-18 16:17:491318}
1319
[email protected]6dfed692014-05-22 04:18:031320bool WebContentsImpl::IsLoadingToDifferentDocument() const {
clamy44e84ce2016-02-22 15:38:251321 return IsLoading() && is_load_to_different_document_;
[email protected]6dfed692014-05-22 04:18:031322}
1323
[email protected]b172aee2012-04-10 17:05:261324bool WebContentsImpl::IsWaitingForResponse() const {
[email protected]6dfed692014-05-22 04:18:031325 return waiting_for_response_ && is_load_to_different_document_;
[email protected]be1f56ab2011-12-22 06:55:311326}
1327
[email protected]b172aee2012-04-10 17:05:261328const net::LoadStateWithParam& WebContentsImpl::GetLoadState() const {
[email protected]be1f56ab2011-12-22 06:55:311329 return load_state_;
1330}
1331
[email protected]fcf75d42013-12-03 20:11:261332const base::string16& WebContentsImpl::GetLoadStateHost() const {
[email protected]be1f56ab2011-12-22 06:55:311333 return load_state_host_;
1334}
1335
avib7348942015-12-25 20:57:101336uint64_t WebContentsImpl::GetUploadSize() const {
[email protected]be1f56ab2011-12-22 06:55:311337 return upload_size_;
1338}
1339
avib7348942015-12-25 20:57:101340uint64_t WebContentsImpl::GetUploadPosition() const {
[email protected]be1f56ab2011-12-22 06:55:311341 return upload_position_;
1342}
1343
[email protected]b172aee2012-04-10 17:05:261344const std::string& WebContentsImpl::GetEncoding() const {
[email protected]ef3adfc2014-05-11 00:04:541345 return canonical_encoding_;
[email protected]be1f56ab2011-12-22 06:55:311346}
1347
[email protected]222f5822014-02-05 23:40:491348void WebContentsImpl::IncrementCapturerCount(const gfx::Size& capture_size) {
[email protected]5a652232013-02-12 06:15:251349 DCHECK(!is_being_destroyed_);
[email protected]54597982013-02-06 01:59:551350 ++capturer_count_;
1351 DVLOG(1) << "There are now " << capturer_count_
1352 << " capturing(s) of WebContentsImpl@" << this;
[email protected]222f5822014-02-05 23:40:491353
1354 // Note: This provides a hint to upstream code to size the views optimally
1355 // for quality (e.g., to avoid scaling).
1356 if (!capture_size.IsEmpty() && preferred_size_for_capture_.IsEmpty()) {
1357 preferred_size_for_capture_ = capture_size;
1358 OnPreferredSizeChanged(preferred_size_);
1359 }
ccameron8807c38f2015-01-17 00:29:191360
1361 // Ensure that all views are un-occluded before capture begins.
Francois Doray18800972017-08-25 22:38:581362 DoWasUnOccluded();
[email protected]54597982013-02-06 01:59:551363}
1364
1365void WebContentsImpl::DecrementCapturerCount() {
1366 --capturer_count_;
1367 DVLOG(1) << "There are now " << capturer_count_
1368 << " capturing(s) of WebContentsImpl@" << this;
1369 DCHECK_LE(0, capturer_count_);
1370
[email protected]5a652232013-02-12 06:15:251371 if (is_being_destroyed_)
1372 return;
1373
[email protected]222f5822014-02-05 23:40:491374 if (capturer_count_ == 0) {
1375 const gfx::Size old_size = preferred_size_for_capture_;
1376 preferred_size_for_capture_ = gfx::Size();
1377 OnPreferredSizeChanged(old_size);
[email protected]222f5822014-02-05 23:40:491378
Francois Doray18800972017-08-25 22:38:581379 if (IsHidden()) {
1380 DVLOG(1) << "Executing delayed WasHidden().";
1381 WasHidden();
1382 }
1383
1384 if (should_normally_be_occluded_)
1385 WasOccluded();
[email protected]54597982013-02-06 01:59:551386 }
[email protected]be1f56ab2011-12-22 06:55:311387}
1388
[email protected]f2bd40812013-07-20 04:30:441389int WebContentsImpl::GetCapturerCount() const {
1390 return capturer_count_;
1391}
1392
miu50f97892014-09-22 22:49:521393bool WebContentsImpl::IsAudioMuted() const {
1394 return audio_muter_.get() && audio_muter_->is_muting();
1395}
1396
1397void WebContentsImpl::SetAudioMuted(bool mute) {
1398 DVLOG(1) << "SetAudioMuted(mute=" << mute << "), was " << IsAudioMuted()
1399 << " for WebContentsImpl@" << this;
1400
1401 if (mute == IsAudioMuted())
1402 return;
1403
1404 if (mute) {
1405 if (!audio_muter_)
1406 audio_muter_.reset(new WebContentsAudioMuter(this));
1407 audio_muter_->StartMuting();
1408 } else {
1409 DCHECK(audio_muter_);
1410 audio_muter_->StopMuting();
1411 }
1412
ericwilligersde386342016-10-19 02:35:091413 for (auto& observer : observers_)
1414 observer.DidUpdateAudioMutingState(mute);
wjmaclean2f797c782016-01-07 14:52:031415
Jan Rucka442c83f2017-08-08 13:27:541416 // Notification for UI updates in response to the changed muting state.
1417 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
1418}
1419
1420bool WebContentsImpl::IsCurrentlyAudible() {
1421 return audio_stream_monitor()->IsCurrentlyAudible();
miu50f97892014-09-22 22:49:521422}
1423
ortunodf4d7982016-04-08 02:33:351424bool WebContentsImpl::IsConnectedToBluetoothDevice() const {
1425 return bluetooth_connected_device_count_ > 0;
ortuno32e7db3c2016-03-29 16:14:201426}
1427
[email protected]b172aee2012-04-10 17:05:261428bool WebContentsImpl::IsCrashed() const {
[email protected]be1f56ab2011-12-22 06:55:311429 return (crashed_status_ == base::TERMINATION_STATUS_PROCESS_CRASHED ||
1430 crashed_status_ == base::TERMINATION_STATUS_ABNORMAL_TERMINATION ||
wfh0d9532a2015-09-02 23:18:581431 crashed_status_ == base::TERMINATION_STATUS_PROCESS_WAS_KILLED ||
oshima620225722015-06-04 19:45:271432#if defined(OS_CHROMEOS)
wfh0d9532a2015-09-02 23:18:581433 crashed_status_ ==
1434 base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM ||
oshima620225722015-06-04 19:45:271435#endif
rkaplowe56a52032017-02-07 00:14:541436 crashed_status_ == base::TERMINATION_STATUS_LAUNCH_FAILED);
[email protected]3c9e1872010-11-18 16:17:491437}
1438
[email protected]b172aee2012-04-10 17:05:261439void WebContentsImpl::SetIsCrashed(base::TerminationStatus status,
1440 int error_code) {
[email protected]443b80e2010-12-14 00:42:231441 if (status == crashed_status_)
[email protected]d5f942ba2008-09-26 19:30:341442 return;
1443
[email protected]443b80e2010-12-14 00:42:231444 crashed_status_ = status;
1445 crashed_error_code_ = error_code;
[email protected]8ff00d72012-10-23 19:12:211446 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
[email protected]d5f942ba2008-09-26 19:30:341447}
1448
[email protected]b172aee2012-04-10 17:05:261449base::TerminationStatus WebContentsImpl::GetCrashedStatus() const {
[email protected]be1f56ab2011-12-22 06:55:311450 return crashed_status_;
1451}
1452
afakhry98241832016-03-11 19:27:471453int WebContentsImpl::GetCrashedErrorCode() const {
1454 return crashed_error_code_;
1455}
1456
[email protected]b172aee2012-04-10 17:05:261457bool WebContentsImpl::IsBeingDestroyed() const {
[email protected]be1f56ab2011-12-22 06:55:311458 return is_being_destroyed_;
1459}
1460
[email protected]7f924832014-08-09 05:57:221461void WebContentsImpl::NotifyNavigationStateChanged(
1462 InvalidateTypes changed_flags) {
erikchen174b78c62015-03-11 22:02:541463 // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466285
1464 // is fixed.
1465 tracked_objects::ScopedTracker tracking_profile(
1466 FROM_HERE_WITH_EXPLICIT_FUNCTION(
1467 "466285 WebContentsImpl::NotifyNavigationStateChanged"));
dalecurtis88c240072015-12-09 02:11:181468 // Notify the media observer of potential audibility changes.
1469 if (changed_flags & INVALIDATE_TYPE_TAB) {
mlamouri44e4ef42016-01-20 18:42:271470 media_web_contents_observer_->MaybeUpdateAudibleState();
dalecurtisbc6572e12014-09-12 19:22:301471 }
1472
[email protected]d5f942ba2008-09-26 19:30:341473 if (delegate_)
1474 delegate_->NavigationStateChanged(this, changed_flags);
wjmaclean1dabf3e32016-05-13 23:34:441475
1476 if (GetOuterWebContents())
1477 GetOuterWebContents()->NotifyNavigationStateChanged(changed_flags);
[email protected]d5f942ba2008-09-26 19:30:341478}
1479
altiminec87fd1f2016-11-17 20:22:491480void WebContentsImpl::OnAudioStateChanged(bool is_audible) {
1481 SendPageMessage(new PageMsg_AudioStateChanged(MSG_ROUTING_NONE, is_audible));
altimind8bd26c2016-11-04 11:44:541482
altiminec87fd1f2016-11-17 20:22:491483 // Notification for UI updates in response to the changed audio state.
altimind8bd26c2016-11-04 11:44:541484 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
Jan Rucka442c83f2017-08-08 13:27:541485
1486 if (delegate_)
1487 delegate_->OnAudioStateChanged(is_audible);
altimind8bd26c2016-11-04 11:44:541488}
1489
gab0dccfef2015-05-20 18:43:391490base::TimeTicks WebContentsImpl::GetLastActiveTime() const {
[email protected]9a890452014-02-13 22:21:021491 return last_active_time_;
[email protected]3e324142012-06-25 18:26:331492}
1493
georgesak5582cbe2015-05-22 22:08:071494void WebContentsImpl::SetLastActiveTime(base::TimeTicks last_active_time) {
1495 last_active_time_ = last_active_time;
1496}
1497
hajimehoshic4f226a2016-10-21 09:01:571498base::TimeTicks WebContentsImpl::GetLastHiddenTime() const {
1499 return last_hidden_time_;
1500}
1501
[email protected]9e2e4632012-07-27 16:38:411502void WebContentsImpl::WasShown() {
[email protected]96d185d2009-04-24 03:28:541503 controller_.SetActive(true);
[email protected]de3c5d82014-05-28 22:12:591504
EhsanK2075c7e2017-08-21 02:42:391505 if (auto* view = GetRenderWidgetHostView()) {
lfgf949e0e2017-05-10 22:18:111506 view->Show();
[email protected]789e9152009-08-04 21:59:431507#if defined(OS_MACOSX)
lfgf949e0e2017-05-10 22:18:111508 view->SetActive(true);
[email protected]789e9152009-08-04 21:59:431509#endif
1510 }
[email protected]96d185d2009-04-24 03:28:541511
EhsanK2075c7e2017-08-21 02:42:391512 if (!ShowingInterstitialPage())
1513 SetVisibilityForChildViews(true);
1514
lfg717154072016-06-30 15:04:161515 SendPageMessage(new PageMsg_WasShown(MSG_ROUTING_NONE));
1516
gab0dccfef2015-05-20 18:43:391517 last_active_time_ = base::TimeTicks::Now();
[email protected]3e69bc82011-05-26 23:22:381518
ericwilligersde386342016-10-19 02:35:091519 for (auto& observer : observers_)
1520 observer.WasShown();
[email protected]c0d9d5672013-10-09 07:38:031521
[email protected]54597982013-02-06 01:59:551522 should_normally_be_visible_ = true;
[email protected]be1f56ab2011-12-22 06:55:311523}
1524
[email protected]b172aee2012-04-10 17:05:261525void WebContentsImpl::WasHidden() {
[email protected]54597982013-02-06 01:59:551526 // If there are entities capturing screenshots or video (e.g., mirroring),
1527 // don't activate the "disable rendering" optimization.
1528 if (capturer_count_ == 0) {
[email protected]151a63d2011-12-20 22:32:521529 // |GetRenderViewHost()| can be NULL if the user middle clicks a link to
[email protected]54597982013-02-06 01:59:551530 // open a tab in the background, then closes the tab before selecting it.
[email protected]b172aee2012-04-10 17:05:261531 // This is because closing the tab calls WebContentsImpl::Destroy(), which
[email protected]151a63d2011-12-20 22:32:521532 // removes the |GetRenderViewHost()|; then when we actually destroy the
[email protected]3e324142012-06-25 18:26:331533 // window, OnWindowPosChanged() notices and calls WasHidden() (which
[email protected]151a63d2011-12-20 22:32:521534 // calls us).
EhsanK2075c7e2017-08-21 02:42:391535 if (auto* view = GetRenderWidgetHostView())
lfgf949e0e2017-05-10 22:18:111536 view->Hide();
lfg717154072016-06-30 15:04:161537
EhsanK2075c7e2017-08-21 02:42:391538 if (!ShowingInterstitialPage())
1539 SetVisibilityForChildViews(true);
1540
lfg717154072016-06-30 15:04:161541 SendPageMessage(new PageMsg_WasHidden(MSG_ROUTING_NONE));
[email protected]96d185d2009-04-24 03:28:541542 }
1543
hajimehoshic4f226a2016-10-21 09:01:571544 last_hidden_time_ = base::TimeTicks::Now();
1545
ericwilligersde386342016-10-19 02:35:091546 for (auto& observer : observers_)
1547 observer.WasHidden();
[email protected]c0d9d5672013-10-09 07:38:031548
[email protected]54597982013-02-06 01:59:551549 should_normally_be_visible_ = false;
[email protected]375fa1b2012-05-22 22:05:371550}
1551
Bo Liu7c6779e92017-08-16 02:02:281552void WebContentsImpl::SetImportance(ChildProcessImportance importance) {
1553 // Not calling GetRenderWidgetHostView since importance should be set on both
1554 // the interstitial and underlying page.
1555 std::set<RenderWidgetHostImpl*> set;
1556 if (ShowingInterstitialPage()) {
1557 set.insert(
1558 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
1559 ->GetRenderWidgetHost());
1560 }
1561 for (RenderFrameHost* rfh : GetAllFrames())
1562 set.insert(static_cast<RenderFrameHostImpl*>(rfh)->GetRenderWidgetHost());
1563 for (RenderWidgetHostImpl* host : set) {
1564 DCHECK(host);
1565 host->SetImportance(importance);
1566 }
1567 // TODO(boliu): If this is ever used on platforms other than Android, make
1568 // sure to also update inner WebContents.
1569}
1570
zhenw6edd49c2017-07-12 05:49:451571bool WebContentsImpl::IsVisible() const {
1572 return should_normally_be_visible_;
1573}
1574
ccameron8807c38f2015-01-17 00:29:191575void WebContentsImpl::WasOccluded() {
Francois Doray18800972017-08-25 22:38:581576 if (capturer_count_ == 0) {
1577 for (RenderWidgetHostView* view : GetRenderWidgetHostViewsInTree())
1578 view->WasOccluded();
1579 }
ccameron8807c38f2015-01-17 00:29:191580
Francois Doray18800972017-08-25 22:38:581581 should_normally_be_occluded_ = true;
ccameron8807c38f2015-01-17 00:29:191582}
1583
1584void WebContentsImpl::WasUnOccluded() {
Francois Doray18800972017-08-25 22:38:581585 if (capturer_count_ == 0)
1586 DoWasUnOccluded();
1587
1588 should_normally_be_occluded_ = false;
1589}
1590
1591void WebContentsImpl::DoWasUnOccluded() {
1592 // TODO(fdoray): Only call WasUnOccluded on frames in the active viewport.
lfgf949e0e2017-05-10 22:18:111593 for (RenderWidgetHostView* view : GetRenderWidgetHostViewsInTree())
1594 view->WasUnOccluded();
ccameron8807c38f2015-01-17 00:29:191595}
1596
[email protected]b172aee2012-04-10 17:05:261597bool WebContentsImpl::NeedToFireBeforeUnload() {
[email protected]be1f56ab2011-12-22 06:55:311598 // TODO(creis): Should we fire even for interstitial pages?
creisc014b402015-04-23 16:41:451599 return WillNotifyDisconnection() && !ShowingInterstitialPage() &&
jam40444982017-04-11 03:01:411600 !GetRenderViewHost()->SuddenTerminationAllowed();
[email protected]be1f56ab2011-12-22 06:55:311601}
1602
nasko148bb0b92016-05-10 21:03:191603void WebContentsImpl::DispatchBeforeUnload() {
1604 bool for_cross_site_transition = false;
clamybfd6a812016-05-30 16:25:171605 GetMainFrame()->DispatchBeforeUnload(for_cross_site_transition, false);
[email protected]1c3f80bd2014-04-08 23:02:061606}
1607
lazyboy6ec48b2a2015-06-29 15:18:141608void WebContentsImpl::AttachToOuterWebContentsFrame(
1609 WebContents* outer_web_contents,
1610 RenderFrameHost* outer_contents_frame) {
ekaramad1beabecc2016-09-23 20:18:171611 CHECK(GuestMode::IsCrossProcessFrameGuest(this));
lfg91a79e12016-04-01 23:52:191612 RenderFrameHostManager* render_manager = GetRenderManager();
1613
1614 // When the WebContents being initialized has an opener, the browser side
1615 // Render{View,Frame}Host must be initialized and the RenderWidgetHostView
1616 // created. This is needed because the usual initialization happens during
1617 // the first navigation, but when attaching a new window we don't navigate
1618 // before attaching. If the browser side is already initialized, the calls
1619 // below will just early return.
1620 render_manager->InitRenderView(GetRenderViewHost(), nullptr);
1621 GetMainFrame()->Init();
1622 if (!render_manager->GetRenderWidgetHostView())
1623 CreateRenderWidgetHostViewForRenderManager(GetRenderViewHost());
1624
avallee7529b2a2017-04-26 11:37:511625 auto* outer_web_contents_impl =
1626 static_cast<WebContentsImpl*>(outer_web_contents);
1627 auto* outer_contents_frame_impl =
1628 static_cast<RenderFrameHostImpl*>(outer_contents_frame);
lazyboy6ec48b2a2015-06-29 15:18:141629 // Create a link to our outer WebContents.
avallee7529b2a2017-04-26 11:37:511630 node_.ConnectToOuterWebContents(outer_web_contents_impl,
1631 outer_contents_frame_impl);
lazyboy6ec48b2a2015-06-29 15:18:141632
1633 DCHECK(outer_contents_frame);
1634
1635 // Create a proxy in top-level RenderFrameHostManager, pointing to the
1636 // SiteInstance of the outer WebContents. The proxy will be used to send
1637 // postMessage to the inner WebContents.
lfg91a79e12016-04-01 23:52:191638 render_manager->CreateOuterDelegateProxy(
avallee7529b2a2017-04-26 11:37:511639 outer_contents_frame->GetSiteInstance(), outer_contents_frame_impl);
lazyboy6ec48b2a2015-06-29 15:18:141640
lfg91a79e12016-04-01 23:52:191641 render_manager->SetRWHViewForInnerContents(
1642 render_manager->GetRenderWidgetHostView());
wjmacleanfab616a2016-03-02 18:40:391643
1644 static_cast<RenderWidgetHostViewChildFrame*>(
lfg91a79e12016-04-01 23:52:191645 render_manager->GetRenderWidgetHostView())
fsamuelb6acafa2016-10-04 03:21:521646 ->RegisterFrameSinkId();
ekaramadadd882292016-06-08 15:22:561647
avallee7529b2a2017-04-26 11:37:511648 if (outer_web_contents_impl->frame_tree_.GetFocusedFrame() ==
1649 outer_contents_frame_impl->frame_tree_node()) {
1650 SetFocusedFrame(frame_tree_.root(), nullptr);
1651 }
1652
avalleed68cdd12017-06-21 22:07:271653 // Set up the the guest's AX tree to point back at the embedder's AX tree.
1654 auto* parent_frame = outer_contents_frame->GetParent();
1655 GetMainFrame()->set_browser_plugin_embedder_ax_tree_id(
1656 parent_frame->GetAXTreeID());
1657 GetMainFrame()->UpdateAXTreeData();
1658
ekaramadadd882292016-06-08 15:22:561659 // At this point, we should destroy the TextInputManager which will notify all
1660 // the RWHV in this WebContents. The RWHV in this WebContents should use the
1661 // TextInputManager owned by the outer WebContents.
1662 // TODO(ekaramad): Is it possible to have TextInputState before attaching to
1663 // outer WebContents? In such a case, is this still the right way to hand off
1664 // state tracking from inner WebContents's TextInputManager to that of the
1665 // outer WebContent (crbug.com/609846)?
1666 text_input_manager_.reset(nullptr);
lazyboy6ec48b2a2015-06-29 15:18:141667}
1668
dalecurtis6c58ed02016-10-28 23:02:371669void WebContentsImpl::DidChangeVisibleSecurityState() {
1670 if (delegate_) {
1671 delegate_->VisibleSecurityStateChanged(this);
cjgrant6d1d727a2016-12-09 21:16:571672 for (auto& observer : observers_)
1673 observer.DidChangeVisibleSecurityState();
dalecurtis6c58ed02016-10-28 23:02:371674 }
1675}
1676
[email protected]b172aee2012-04-10 17:05:261677void WebContentsImpl::Stop() {
dcheng57e39e22016-01-21 00:25:381678 for (FrameTreeNode* node : frame_tree_.Nodes())
1679 node->StopLoading();
ericwilligersde386342016-10-19 02:35:091680 for (auto& observer : observers_)
1681 observer.NavigationStopped();
[email protected]0bfbf882011-12-22 18:19:271682}
1683
[email protected]b172aee2012-04-10 17:05:261684WebContents* WebContentsImpl::Clone() {
[email protected]14392a52012-05-02 20:28:441685 // We use our current SiteInstance since the cloned entry will use it anyway.
alexmose201c7cd2015-06-10 17:14:211686 // We pass our own opener so that the cloned page can access it if it was set
[email protected]ed245db2012-12-18 08:00:451687 // before.
[email protected]54944cde2012-12-09 09:24:591688 CreateParams create_params(GetBrowserContext(), GetSiteInstance());
[email protected]fc2b46b2014-05-03 16:33:451689 create_params.initial_size = GetContainerBounds().size();
alexmose201c7cd2015-06-10 17:14:211690 WebContentsImpl* tc =
1691 CreateWithOpener(create_params, frame_tree_.root()->opener());
Francois Dorayeaace782017-06-21 16:37:241692 tc->GetController().CopyStateFrom(controller_, true);
ericwilligersde386342016-10-19 02:35:091693 for (auto& observer : observers_)
1694 observer.DidCloneToNewWebContents(this, tc);
[email protected]0bfbf882011-12-22 18:19:271695 return tc;
1696}
1697
[email protected]14392a52012-05-02 20:28:441698void WebContentsImpl::Observe(int type,
[email protected]8ff00d72012-10-23 19:12:211699 const NotificationSource& source,
1700 const NotificationDetails& details) {
[email protected]14392a52012-05-02 20:28:441701 switch (type) {
[email protected]8ff00d72012-10-23 19:12:211702 case NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: {
1703 RenderWidgetHost* host = Source<RenderWidgetHost>(source).ptr();
[email protected]0b431992014-06-24 00:08:031704 RenderWidgetHostView* view = host->GetView();
1705 if (view == GetFullscreenRenderWidgetHostView()) {
1706 // We cannot just call view_->RestoreFocus() here. On some platforms,
1707 // attempting to focus the currently-invisible WebContentsView will be
1708 // flat-out ignored. Therefore, this boolean is used to track whether
1709 // we will request focus after the fullscreen widget has been
1710 // destroyed.
1711 fullscreen_widget_had_focus_at_shutdown_ = (view && view->HasFocus());
1712 } else {
alexmosc2a8cec2016-05-23 22:19:531713 for (auto i = pending_widget_views_.begin();
[email protected]0b431992014-06-24 00:08:031714 i != pending_widget_views_.end(); ++i) {
1715 if (host->GetView() == i->second) {
1716 pending_widget_views_.erase(i);
1717 break;
1718 }
[email protected]bafe6cd2012-05-23 23:09:501719 }
1720 }
1721 break;
1722 }
[email protected]14392a52012-05-02 20:28:441723 default:
1724 NOTREACHED();
1725 }
1726}
1727
[email protected]ec6c05f2013-10-23 18:41:571728WebContents* WebContentsImpl::GetWebContents() {
1729 return this;
1730}
1731
[email protected]54944cde2012-12-09 09:24:591732void WebContentsImpl::Init(const WebContents::CreateParams& params) {
[email protected]fa944cb82013-11-15 17:51:211733 // This is set before initializing the render manager since
[email protected]b0936d22013-11-28 06:47:361734 // RenderFrameHostManager::Init calls back into us via its delegate to ask if
[email protected]fa944cb82013-11-15 17:51:211735 // it should be hidden.
[email protected]d6fa88f2013-10-18 16:00:431736 should_normally_be_visible_ = !params.initially_hidden;
1737
dcheng3ce04b62015-10-26 23:30:551738 // The routing ids must either all be set or all be unset.
avic2c29d782014-12-12 00:23:541739 DCHECK((params.routing_id == MSG_ROUTING_NONE &&
dcheng3ce04b62015-10-26 23:30:551740 params.main_frame_routing_id == MSG_ROUTING_NONE &&
1741 params.main_frame_widget_routing_id == MSG_ROUTING_NONE) ||
avic2c29d782014-12-12 00:23:541742 (params.routing_id != MSG_ROUTING_NONE &&
dcheng3ce04b62015-10-26 23:30:551743 params.main_frame_routing_id != MSG_ROUTING_NONE &&
1744 params.main_frame_widget_routing_id != MSG_ROUTING_NONE));
1745
1746 scoped_refptr<SiteInstance> site_instance = params.site_instance;
1747 if (!site_instance)
1748 site_instance = SiteInstance::Create(params.browser_context);
1749
1750 // A main RenderFrameHost always has a RenderWidgetHost, since it is always a
1751 // local root by definition.
1752 // TODO(avi): Once RenderViewHostImpl has-a RenderWidgetHostImpl, it will no
1753 // longer be necessary to eagerly grab a routing ID for the view.
1754 // https://crbug.com/545684
1755 int32_t view_routing_id = params.routing_id;
1756 int32_t main_frame_widget_routing_id = params.main_frame_widget_routing_id;
1757 if (main_frame_widget_routing_id == MSG_ROUTING_NONE) {
1758 view_routing_id = main_frame_widget_routing_id =
1759 site_instance->GetProcess()->GetNextRoutingID();
1760 }
1761
Dave Tapuska485aca92017-08-08 00:47:581762 GetRenderManager()->Init(
1763 site_instance.get(), view_routing_id, params.main_frame_routing_id,
1764 main_frame_widget_routing_id, params.renderer_initiated_creation);
lukasza464d8692016-02-22 19:26:321765
lukasza5140a412016-09-15 21:12:301766 // blink::FrameTree::setName always keeps |unique_name| empty in case of a
1767 // main frame - let's do the same thing here.
1768 std::string unique_name;
lukasza464d8692016-02-22 19:26:321769 frame_tree_.root()->SetFrameName(params.main_frame_name, unique_name);
[email protected]d1198fd2012-08-13 22:50:191770
[email protected]fc2b46b2014-05-03 16:33:451771 WebContentsViewDelegate* delegate =
1772 GetContentClient()->browser()->GetWebContentsViewDelegate(this);
1773
sky52a39e342016-12-17 17:23:221774 if (GuestMode::IsCrossProcessFrameGuest(this)) {
1775 view_.reset(new WebContentsViewChildFrame(
1776 this, delegate, &render_view_host_delegate_view_));
1777 } else {
1778 view_.reset(CreateWebContentsView(this, delegate,
1779 &render_view_host_delegate_view_));
fsamueladb0033602015-12-09 19:20:411780 }
fsamuel9cf7bdf2015-11-20 02:19:321781
ekaramad1beabecc2016-09-23 20:18:171782 if (browser_plugin_guest_ && !GuestMode::IsCrossProcessFrameGuest(this)) {
fsamuel9cf7bdf2015-11-20 02:19:321783 view_.reset(new WebContentsViewGuest(this, browser_plugin_guest_.get(),
dcheng36b6aec92015-12-26 06:16:361784 std::move(view_),
fsamuel9cf7bdf2015-11-20 02:19:321785 &render_view_host_delegate_view_));
[email protected]d1198fd2012-08-13 22:50:191786 }
[email protected]fc2b46b2014-05-03 16:33:451787 CHECK(render_view_host_delegate_view_);
[email protected]d1198fd2012-08-13 22:50:191788 CHECK(view_.get());
1789
[email protected]ed245db2012-12-18 08:00:451790 gfx::Size initial_size = params.initial_size;
[email protected]54944cde2012-12-09 09:24:591791 view_->CreateView(initial_size, params.context);
[email protected]d1198fd2012-08-13 22:50:191792
brettw4b461082016-11-19 18:55:161793#if BUILDFLAG(ENABLE_PLUGINS)
tommyclieb25b2a2014-11-03 19:45:091794 plugin_content_origin_whitelist_.reset(
1795 new PluginContentOriginWhitelist(this));
1796#endif
1797
[email protected]d1198fd2012-08-13 22:50:191798 registrar_.Add(this,
[email protected]8ff00d72012-10-23 19:12:211799 NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
1800 NotificationService::AllBrowserContextsAndSources());
[email protected]f28ef9a32014-05-12 16:36:101801
leon.hane4db177a2017-02-07 14:19:161802 screen_orientation_provider_.reset(new ScreenOrientationProvider(this));
[email protected]01f83f92014-06-17 14:41:541803
mlamouriefdca9d2014-09-16 16:55:401804 manifest_manager_host_.reset(new ManifestManagerHost(this));
1805
mfomitchev2b8b066a2016-01-28 19:23:151806#if defined(OS_ANDROID)
[email protected]583418cc2013-01-17 14:01:101807 date_time_chooser_.reset(new DateTimeChooserAndroid());
1808#endif
fsamuel7310a4262014-12-05 05:06:441809
1810 // BrowserPluginGuest::Init needs to be called after this WebContents has
1811 // a RenderWidgetHostViewGuest. That is, |view_->CreateView| above.
1812 if (browser_plugin_guest_)
1813 browser_plugin_guest_->Init();
nickf9acfbe2014-12-23 19:12:371814
1815 for (size_t i = 0; i < g_created_callbacks.Get().size(); i++)
1816 g_created_callbacks.Get().at(i).Run(this);
naskob21fe4872015-02-24 14:15:561817
1818 // If the WebContents creation was renderer-initiated, it means that the
1819 // corresponding RenderView and main RenderFrame have already been created.
1820 // Ensure observers are notified about this.
1821 if (params.renderer_initiated_creation) {
avi3627ecac2015-10-16 17:40:431822 GetRenderViewHost()->GetWidget()->set_renderer_initialized(true);
naskob21fe4872015-02-24 14:15:561823 RenderViewCreated(GetRenderViewHost());
1824 GetRenderManager()->current_frame_host()->SetRenderFrameCreated(true);
1825 }
naskof5940b9f2015-03-02 23:04:051826
lof84501da082016-05-23 21:22:541827 // Create the renderer process in advance if requested.
1828 if (params.initialize_renderer) {
1829 if (!GetRenderManager()->current_frame_host()->IsRenderFrameLive()) {
1830 GetRenderManager()->InitRenderView(GetRenderViewHost(), nullptr);
1831 }
1832 }
1833
naskof5940b9f2015-03-02 23:04:051834 // Ensure that observers are notified of the creation of this WebContents's
1835 // main RenderFrameHost. It must be done here for main frames, since the
1836 // NotifySwappedFromRenderManager expects view_ to already be created and that
1837 // happens after RenderFrameHostManager::Init.
1838 NotifySwappedFromRenderManager(
1839 nullptr, GetRenderManager()->current_frame_host(), true);
[email protected]d1198fd2012-08-13 22:50:191840}
1841
[email protected]7fff43e2013-05-21 20:21:101842void WebContentsImpl::OnWebContentsDestroyed(WebContentsImpl* web_contents) {
1843 RemoveDestructionObserver(web_contents);
1844
[email protected]ceee8cd2013-03-08 04:59:511845 // Clear a pending contents that has been closed before being shown.
alexmosc2a8cec2016-05-23 22:19:531846 for (auto iter = pending_contents_.begin(); iter != pending_contents_.end();
[email protected]ceee8cd2013-03-08 04:59:511847 ++iter) {
1848 if (iter->second != web_contents)
1849 continue;
1850 pending_contents_.erase(iter);
[email protected]ceee8cd2013-03-08 04:59:511851 return;
1852 }
1853 NOTREACHED();
[email protected]14392a52012-05-02 20:28:441854}
1855
[email protected]7fff43e2013-05-21 20:21:101856void WebContentsImpl::AddDestructionObserver(WebContentsImpl* web_contents) {
1857 if (!ContainsKey(destruction_observers_, web_contents)) {
1858 destruction_observers_[web_contents] =
avia8cf81982016-08-12 20:28:461859 base::MakeUnique<DestructionObserver>(this, web_contents);
[email protected]7fff43e2013-05-21 20:21:101860 }
1861}
1862
1863void WebContentsImpl::RemoveDestructionObserver(WebContentsImpl* web_contents) {
avia8cf81982016-08-12 20:28:461864 destruction_observers_.erase(web_contents);
[email protected]7fff43e2013-05-21 20:21:101865}
1866
[email protected]b172aee2012-04-10 17:05:261867void WebContentsImpl::AddObserver(WebContentsObserver* observer) {
[email protected]be1f56ab2011-12-22 06:55:311868 observers_.AddObserver(observer);
1869}
1870
[email protected]b172aee2012-04-10 17:05:261871void WebContentsImpl::RemoveObserver(WebContentsObserver* observer) {
[email protected]be1f56ab2011-12-22 06:55:311872 observers_.RemoveObserver(observer);
1873}
1874
[email protected]948481d2014-06-11 18:32:221875std::set<RenderWidgetHostView*>
1876WebContentsImpl::GetRenderWidgetHostViewsInTree() {
1877 std::set<RenderWidgetHostView*> set;
1878 if (ShowingInterstitialPage()) {
lfgf949e0e2017-05-10 22:18:111879 if (RenderWidgetHostView* rwhv = GetRenderWidgetHostView())
1880 set.insert(rwhv);
[email protected]948481d2014-06-11 18:32:221881 } else {
dchengafb53e22016-02-04 08:11:081882 for (RenderFrameHost* rfh : GetAllFrames()) {
lfgf949e0e2017-05-10 22:18:111883 if (RenderWidgetHostView* rwhv = static_cast<RenderFrameHostImpl*>(rfh)
1884 ->frame_tree_node()
1885 ->render_manager()
1886 ->GetRenderWidgetHostView()) {
1887 set.insert(rwhv);
1888 }
dchengafb53e22016-02-04 08:11:081889 }
[email protected]948481d2014-06-11 18:32:221890 }
[email protected]de3c5d82014-05-28 22:12:591891 return set;
1892}
1893
[email protected]b172aee2012-04-10 17:05:261894void WebContentsImpl::Activate() {
[email protected]d5f942ba2008-09-26 19:30:341895 if (delegate_)
1896 delegate_->ActivateContents(this);
1897}
1898
avi3e4b8512015-11-11 01:55:491899void WebContentsImpl::LostCapture(RenderWidgetHostImpl* render_widget_host) {
1900 if (!RenderViewHostImpl::From(render_widget_host))
1901 return;
1902
[email protected]63954792011-07-11 04:17:481903 if (delegate_)
1904 delegate_->LostCapture();
1905}
1906
lazyboy63f5b312015-11-23 20:19:521907void WebContentsImpl::RenderWidgetCreated(
1908 RenderWidgetHostImpl* render_widget_host) {
1909 created_widgets_.insert(render_widget_host);
1910}
1911
[email protected]b24b68a2012-09-24 21:57:261912void WebContentsImpl::RenderWidgetDeleted(
1913 RenderWidgetHostImpl* render_widget_host) {
lazyboy63f5b312015-11-23 20:19:521914 // Note that |is_being_destroyed_| can be true at this point as
1915 // ~WebContentsImpl() calls RFHM::ClearRFHsPendingShutdown(), which might lead
1916 // us here.
1917 created_widgets_.erase(render_widget_host);
[email protected]b24b68a2012-09-24 21:57:261918
lazyboy63f5b312015-11-23 20:19:521919 if (is_being_destroyed_)
1920 return;
[email protected]44470a22013-01-24 01:21:541921
1922 if (render_widget_host &&
alexmosc9e76ec2016-05-16 22:59:371923 render_widget_host->GetRoutingID() == fullscreen_widget_routing_id_ &&
1924 render_widget_host->GetProcess()->GetID() ==
1925 fullscreen_widget_process_id_) {
[email protected]4aebbca2013-09-17 22:26:491926 if (delegate_ && delegate_->EmbedsFullscreenWidget())
mlamouri7a78d6fd2015-01-17 13:23:531927 delegate_->ExitFullscreenModeForTab(this);
ericwilligersde386342016-10-19 02:35:091928 for (auto& observer : observers_)
1929 observer.DidDestroyFullscreenWidget();
alexmosc9e76ec2016-05-16 22:59:371930 fullscreen_widget_process_id_ = ChildProcessHost::kInvalidUniqueID;
[email protected]44470a22013-01-24 01:21:541931 fullscreen_widget_routing_id_ = MSG_ROUTING_NONE;
[email protected]0b431992014-06-24 00:08:031932 if (fullscreen_widget_had_focus_at_shutdown_)
1933 view_->RestoreFocus();
[email protected]44470a22013-01-24 01:21:541934 }
lfgbee1e0a2016-06-08 21:24:211935
lfg7d4caad2017-03-22 09:01:451936 if (render_widget_host == mouse_lock_widget_)
lfgff8dfc8d2016-10-21 17:42:321937 LostMouseLock(mouse_lock_widget_);
[email protected]b24b68a2012-09-24 21:57:261938}
1939
miu9e14e492014-10-25 02:39:041940void WebContentsImpl::RenderWidgetGotFocus(
1941 RenderWidgetHostImpl* render_widget_host) {
calamity7fe55ce2015-04-10 03:59:371942 // Notify the observers if an embedded fullscreen widget was focused.
1943 if (delegate_ && render_widget_host && delegate_->EmbedsFullscreenWidget() &&
1944 render_widget_host->GetView() == GetFullscreenRenderWidgetHostView()) {
Michael Thiessen896405db2017-07-20 17:52:321945 NotifyWebContentsFocused(render_widget_host);
calamity7fe55ce2015-04-10 03:59:371946 }
miu9e14e492014-10-25 02:39:041947}
1948
zijiehe3bee08e22017-05-17 04:14:461949void WebContentsImpl::RenderWidgetLostFocus(
1950 RenderWidgetHostImpl* render_widget_host) {
Michael Thiessen896405db2017-07-20 17:52:321951 // Notify the observers if an embedded fullscreen widget lost focus.
1952 if (delegate_ && render_widget_host && delegate_->EmbedsFullscreenWidget() &&
1953 render_widget_host->GetView() == GetFullscreenRenderWidgetHostView()) {
1954 NotifyWebContentsLostFocus(render_widget_host);
1955 }
zijiehe3bee08e22017-05-17 04:14:461956}
1957
estaded0a0c992015-01-21 14:12:061958void WebContentsImpl::RenderWidgetWasResized(
rouslan2f5993f2015-01-29 00:18:311959 RenderWidgetHostImpl* render_widget_host,
1960 bool width_changed) {
creisc014b402015-04-23 16:41:451961 RenderFrameHostImpl* rfh = GetMainFrame();
estadece344ec2015-01-23 00:12:291962 if (!rfh || render_widget_host != rfh->GetRenderWidgetHost())
estaded0a0c992015-01-21 14:12:061963 return;
estaded0a0c992015-01-21 14:12:061964
lfg8d649cc2017-04-28 18:04:301965 ScreenInfo screen_info;
1966 GetScreenInfo(&screen_info);
1967 SendPageMessage(new PageMsg_UpdateScreenInfo(MSG_ROUTING_NONE, screen_info));
1968
lfg95f00bd52017-06-08 00:03:201969 // Send resize message to subframes.
1970 for (RenderWidgetHostView* view : GetRenderWidgetHostViewsInTree()) {
1971 if (view != rfh->GetView())
1972 view->GetRenderWidgetHost()->WasResized();
1973 }
1974
ericwilligersde386342016-10-19 02:35:091975 for (auto& observer : observers_)
1976 observer.MainFrameWasResized(width_changed);
estaded0a0c992015-01-21 14:12:061977}
1978
paulmeyer9ef6e4462015-02-24 19:15:101979void WebContentsImpl::ScreenInfoChanged() {
1980 if (browser_plugin_embedder_)
1981 browser_plugin_embedder_->ScreenInfoChanged();
1982}
1983
skyf65d9bb2017-03-24 02:26:391984KeyboardEventProcessingResult WebContentsImpl::PreHandleKeyboardEvent(
1985 const NativeWebKeyboardEvent& event) {
1986 return delegate_ ? delegate_->PreHandleKeyboardEvent(this, event)
1987 : KeyboardEventProcessingResult::NOT_HANDLED;
[email protected]63954792011-07-11 04:17:481988}
1989
[email protected]b172aee2012-04-10 17:05:261990void WebContentsImpl::HandleKeyboardEvent(const NativeWebKeyboardEvent& event) {
[email protected]0b094002014-08-20 18:28:101991 if (browser_plugin_embedder_ &&
1992 browser_plugin_embedder_->HandleKeyboardEvent(event)) {
1993 return;
1994 }
[email protected]63954792011-07-11 04:17:481995 if (delegate_)
[email protected]b3996ba2012-08-08 00:39:131996 delegate_->HandleKeyboardEvent(this, event);
[email protected]63954792011-07-11 04:17:481997}
1998
[email protected]d92026ef2014-03-03 21:04:131999bool WebContentsImpl::HandleWheelEvent(
[email protected]180ef242013-11-07 06:50:462000 const blink::WebMouseWheelEvent& event) {
[email protected]bccc4472013-04-18 16:37:192001#if !defined(OS_MACOSX)
lanweia93644f2015-01-21 22:00:332002 // On platforms other than Mac, control+mousewheel may change zoom. On Mac,
2003 // this isn't done for two reasons:
[email protected]bccc4472013-04-18 16:37:192004 // -the OS already has a gesture to do this through pinch-zoom
2005 // -if a user starts an inertial scroll, let's go, and presses control
2006 // (i.e. control+tab) then the OS's buffered scroll events will come in
2007 // with control key set which isn't what the user wants
Blink Reformat1c4d759e2017-04-09 16:34:542008 if (delegate_ && event.wheel_ticks_y &&
chongz4a9751942016-08-17 17:49:392009 !ui::WebInputEventTraits::CanCauseScroll(event)) {
w.shackleton49bcd392016-01-06 17:38:222010 // Count only integer cumulative scrolls as zoom events; this handles
2011 // smooth scroll and regular scroll device behavior.
Blink Reformat1c4d759e2017-04-09 16:34:542012 zoom_scroll_remainder_ += event.wheel_ticks_y;
w.shackleton49bcd392016-01-06 17:38:222013 int whole_zoom_scroll_remainder_ = std::lround(zoom_scroll_remainder_);
2014 zoom_scroll_remainder_ -= whole_zoom_scroll_remainder_;
2015 if (whole_zoom_scroll_remainder_ != 0) {
2016 delegate_->ContentsZoomChange(whole_zoom_scroll_remainder_ > 0);
2017 }
[email protected]fb3f066e2013-02-12 19:12:522018 return true;
2019 }
[email protected]bccc4472013-04-18 16:37:192020#endif
[email protected]fb3f066e2013-02-12 19:12:522021 return false;
2022}
2023
[email protected]04bce562014-01-30 05:34:542024bool WebContentsImpl::PreHandleGestureEvent(
2025 const blink::WebGestureEvent& event) {
[email protected]28042d32014-02-03 14:10:032026 return delegate_ && delegate_->PreHandleGestureEvent(this, event);
[email protected]04bce562014-01-30 05:34:542027}
2028
kenrb2a565f82015-09-02 20:24:592029RenderWidgetHostInputEventRouter* WebContentsImpl::GetInputEventRouter() {
wjmacleane31234f2015-12-14 17:20:452030 if (!is_being_destroyed_ && GetOuterWebContents())
2031 return GetOuterWebContents()->GetInputEventRouter();
2032
2033 if (!rwh_input_event_router_.get() && !is_being_destroyed_)
kenrb2a565f82015-09-02 20:24:592034 rwh_input_event_router_.reset(new RenderWidgetHostInputEventRouter);
2035 return rwh_input_event_router_.get();
2036}
2037
alexmos3fcd0ca2015-10-23 18:18:332038void WebContentsImpl::ReplicatePageFocus(bool is_focused) {
2039 // Focus loss may occur while this WebContents is being destroyed. Don't
2040 // send the message in this case, as the main frame's RenderFrameHost and
2041 // other state has already been cleared.
2042 if (is_being_destroyed_)
2043 return;
2044
2045 frame_tree_.ReplicatePageFocus(is_focused);
2046}
2047
alexmosc4cbacb2015-11-21 01:29:222048RenderWidgetHostImpl* WebContentsImpl::GetFocusedRenderWidgetHost(
2049 RenderWidgetHostImpl* receiving_widget) {
alexmosc4cbacb2015-11-21 01:29:222050 // Events for widgets other than the main frame (e.g., popup menus) should be
2051 // forwarded directly to the widget they arrived on.
2052 if (receiving_widget != GetMainFrame()->GetRenderWidgetHost())
2053 return receiving_widget;
alexmosc4d183e2015-11-06 00:46:522054
lfg1453e412017-04-11 00:48:502055 WebContentsImpl* focused_contents = GetFocusedWebContents();
2056
2057 // If the focused WebContents is showing an interstitial, return the
2058 // interstitial's widget.
2059 if (focused_contents->ShowingInterstitialPage()) {
2060 return static_cast<RenderFrameHostImpl*>(
creisadca9862017-06-16 19:12:112061 focused_contents->interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:502062 ->GetRenderWidgetHost();
2063 }
2064
paulmeyerfeafc2d2017-04-25 21:46:402065 // If the focused WebContents is a guest WebContents, then get the focused
2066 // frame in the embedder WebContents instead.
2067 FrameTreeNode* focused_frame = nullptr;
2068 if (focused_contents->browser_plugin_guest_ &&
2069 !GuestMode::IsCrossProcessFrameGuest(focused_contents)) {
2070 focused_frame = frame_tree_.GetFocusedFrame();
2071 } else {
2072 focused_frame = GetFocusedWebContents()->frame_tree_.GetFocusedFrame();
2073 }
lfg1453e412017-04-11 00:48:502074
alexmosc4d183e2015-11-06 00:46:522075 if (!focused_frame)
alexmosc4cbacb2015-11-21 01:29:222076 return receiving_widget;
alexmosc4d183e2015-11-06 00:46:522077
alexmos732ca3a2015-12-08 02:01:022078 // The view may be null if a subframe's renderer process has crashed while
2079 // the subframe has focus. Drop the event in that case. Do not give
2080 // it to the main frame, so that the user doesn't unexpectedly type into the
2081 // wrong frame if a focused subframe renderer crashes while they type.
2082 RenderWidgetHostView* view = focused_frame->current_frame_host()->GetView();
2083 if (!view)
2084 return nullptr;
2085
2086 return RenderWidgetHostImpl::From(view->GetRenderWidgetHost());
alexmosc4d183e2015-11-06 00:46:522087}
2088
avallee9993fca2016-11-17 06:16:502089RenderWidgetHostImpl* WebContentsImpl::GetRenderWidgetHostWithPageFocus() {
lfg1453e412017-04-11 00:48:502090 WebContentsImpl* focused_web_contents = GetFocusedWebContents();
2091
2092 if (focused_web_contents->ShowingInterstitialPage()) {
2093 return static_cast<RenderFrameHostImpl*>(
creisadca9862017-06-16 19:12:112094 focused_web_contents->interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:502095 ->GetRenderWidgetHost();
2096 }
2097
2098 return focused_web_contents->GetMainFrame()->GetRenderWidgetHost();
avallee9993fca2016-11-17 06:16:502099}
2100
mlamouri7a78d6fd2015-01-17 13:23:532101void WebContentsImpl::EnterFullscreenMode(const GURL& origin) {
2102 // This method is being called to enter renderer-initiated fullscreen mode.
2103 // Make sure any existing fullscreen widget is shut down first.
[email protected]4aebbca2013-09-17 22:26:492104 RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
avi85a4cef2015-12-18 20:13:372105 if (widget_view) {
2106 RenderWidgetHostImpl::From(widget_view->GetRenderWidgetHost())
2107 ->ShutdownAndDestroyWidget(true);
2108 }
[email protected]4aebbca2013-09-17 22:26:492109
[email protected]8a5e0ca2011-08-25 06:30:472110 if (delegate_)
mlamouri7a78d6fd2015-01-17 13:23:532111 delegate_->EnterFullscreenModeForTab(this, origin);
2112
ericwilligersde386342016-10-19 02:35:092113 for (auto& observer : observers_)
2114 observer.DidToggleFullscreenModeForTab(IsFullscreenForCurrentTab(), false);
mlamouri7a78d6fd2015-01-17 13:23:532115}
2116
bokanece34a82016-01-28 19:49:462117void WebContentsImpl::ExitFullscreenMode(bool will_cause_resize) {
mlamouri7a78d6fd2015-01-17 13:23:532118 // This method is being called to leave renderer-initiated fullscreen mode.
2119 // Make sure any existing fullscreen widget is shut down first.
2120 RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
avi85a4cef2015-12-18 20:13:372121 if (widget_view) {
2122 RenderWidgetHostImpl::From(widget_view->GetRenderWidgetHost())
2123 ->ShutdownAndDestroyWidget(true);
2124 }
mlamouri7a78d6fd2015-01-17 13:23:532125
hugo.holgersson61288e6c2015-01-28 17:04:402126#if defined(OS_ANDROID)
2127 ContentVideoView* video_view = ContentVideoView::GetInstance();
2128 if (video_view != NULL)
watk98292292016-01-19 22:24:082129 video_view->ExitFullscreen();
hugo.holgersson61288e6c2015-01-28 17:04:402130#endif
2131
mlamouri7a78d6fd2015-01-17 13:23:532132 if (delegate_)
2133 delegate_->ExitFullscreenModeForTab(this);
[email protected]657c8e02014-03-19 19:18:372134
bokanece34a82016-01-28 19:49:462135 // The fullscreen state is communicated to the renderer through a resize
2136 // message. If the change in fullscreen state doesn't cause a view resize
2137 // then we must ensure web contents exit the fullscreen state by explicitly
2138 // sending a resize message. This is required for the situation of the browser
2139 // moving the view into a "browser fullscreen" state and then the contents
2140 // entering "tab fullscreen". Exiting the contents "tab fullscreen" then won't
2141 // have the side effect of the view resizing, hence the explicit call here is
2142 // required.
2143 if (!will_cause_resize) {
2144 if (RenderWidgetHostView* rwhv = GetRenderWidgetHostView()) {
2145 if (RenderWidgetHost* render_widget_host = rwhv->GetRenderWidgetHost())
2146 render_widget_host->WasResized();
2147 }
scheib3dcb6c932015-02-23 10:55:582148 }
2149
ericwilligersde386342016-10-19 02:35:092150 for (auto& observer : observers_) {
2151 observer.DidToggleFullscreenModeForTab(IsFullscreenForCurrentTab(),
2152 will_cause_resize);
2153 }
[email protected]8a5e0ca2011-08-25 06:30:472154}
2155
alexmos5dd617d2016-06-07 04:21:152156bool WebContentsImpl::IsFullscreenForCurrentTab() const {
[email protected]199bba6e2012-04-04 16:19:382157 return delegate_ ? delegate_->IsFullscreenForTabOrPending(this) : false;
[email protected]5d5f7af2011-10-01 01:38:122158}
2159
billorr21c005d2016-11-17 03:57:042160bool WebContentsImpl::IsFullscreen() {
2161 return IsFullscreenForCurrentTab();
2162}
2163
avibf58fa0c2015-11-11 01:45:522164blink::WebDisplayMode WebContentsImpl::GetDisplayMode(
2165 RenderWidgetHostImpl* render_widget_host) const {
2166 if (!RenderViewHostImpl::From(render_widget_host))
Blink Reformat1c4d759e2017-04-09 16:34:542167 return blink::kWebDisplayModeBrowser;
avibf58fa0c2015-11-11 01:45:522168
mikhail.pozdnyakovc0e251b2015-04-15 06:51:122169 return delegate_ ? delegate_->GetDisplayMode(this)
Blink Reformat1c4d759e2017-04-09 16:34:542170 : blink::kWebDisplayModeBrowser;
mikhail.pozdnyakovc0e251b2015-04-15 06:51:122171}
2172
avic3aa8422015-11-09 20:57:222173void WebContentsImpl::RequestToLockMouse(
2174 RenderWidgetHostImpl* render_widget_host,
2175 bool user_gesture,
lfgad8244352016-07-13 16:55:512176 bool last_unlocked_by_target,
2177 bool privileged) {
lfgf0cd46e2017-01-04 00:05:232178 for (WebContentsImpl* current = this; current;
2179 current = current->GetOuterWebContents()) {
2180 if (current->mouse_lock_widget_) {
2181 render_widget_host->GotResponseToLockMouseRequest(false);
2182 return;
2183 }
[email protected]e9621112011-10-17 05:38:372184 }
avic3aa8422015-11-09 20:57:222185
lfgad8244352016-07-13 16:55:512186 if (privileged) {
lfgf0cd46e2017-01-04 00:05:232187 DCHECK(!GetOuterWebContents());
lfgad8244352016-07-13 16:55:512188 mouse_lock_widget_ = render_widget_host;
2189 render_widget_host->GotResponseToLockMouseRequest(true);
2190 return;
2191 }
2192
lfgbee1e0a2016-06-08 21:24:212193 bool widget_in_frame_tree = false;
2194 for (FrameTreeNode* node : frame_tree_.Nodes()) {
2195 if (node->current_frame_host()->GetRenderWidgetHost() ==
2196 render_widget_host) {
2197 widget_in_frame_tree = true;
2198 break;
2199 }
2200 }
2201
2202 if (widget_in_frame_tree && delegate_) {
lfgf0cd46e2017-01-04 00:05:232203 for (WebContentsImpl* current = this; current;
2204 current = current->GetOuterWebContents()) {
2205 current->mouse_lock_widget_ = render_widget_host;
2206 }
2207
avic3aa8422015-11-09 20:57:222208 delegate_->RequestToLockMouse(this, user_gesture, last_unlocked_by_target);
lfgbee1e0a2016-06-08 21:24:212209 } else {
2210 render_widget_host->GotResponseToLockMouseRequest(false);
2211 }
[email protected]e9621112011-10-17 05:38:372212}
2213
avi3e4b8512015-11-11 01:55:492214void WebContentsImpl::LostMouseLock(RenderWidgetHostImpl* render_widget_host) {
lfgbee1e0a2016-06-08 21:24:212215 CHECK(mouse_lock_widget_);
lfgf0cd46e2017-01-04 00:05:232216
2217 if (mouse_lock_widget_->delegate()->GetAsWebContents() != this)
2218 return mouse_lock_widget_->delegate()->LostMouseLock(render_widget_host);
2219
lfgbee1e0a2016-06-08 21:24:212220 mouse_lock_widget_->SendMouseLockLost();
lfgf0cd46e2017-01-04 00:05:232221 for (WebContentsImpl* current = this; current;
2222 current = current->GetOuterWebContents()) {
2223 current->mouse_lock_widget_ = nullptr;
2224 }
avi3e4b8512015-11-11 01:55:492225
[email protected]e9621112011-10-17 05:38:372226 if (delegate_)
2227 delegate_->LostMouseLock();
2228}
2229
lfgad8244352016-07-13 16:55:512230bool WebContentsImpl::HasMouseLock(RenderWidgetHostImpl* render_widget_host) {
2231 // To verify if the mouse is locked, the mouse_lock_widget_ needs to be
2232 // assigned to the widget that requested the mouse lock, and the top-level
2233 // platform RenderWidgetHostView needs to hold the mouse lock from the OS.
2234 return mouse_lock_widget_ == render_widget_host &&
2235 GetTopLevelRenderWidgetHostView()->IsMouseLocked();
2236}
2237
lfg84763c92017-02-16 18:55:152238RenderWidgetHostImpl* WebContentsImpl::GetMouseLockWidget() {
lfge2176fb2017-03-26 00:45:472239 if (GetTopLevelRenderWidgetHostView()->IsMouseLocked() ||
2240 (GetFullscreenRenderWidgetHostView() &&
2241 GetFullscreenRenderWidgetHostView()->IsMouseLocked()))
lfg84763c92017-02-16 18:55:152242 return mouse_lock_widget_;
2243
2244 return nullptr;
2245}
2246
ekaramada4f42692016-02-11 19:48:372247void WebContentsImpl::OnRenderFrameProxyVisibilityChanged(bool visible) {
lfg9462cef2016-07-18 23:51:062248 if (visible && !GetOuterWebContents()->IsHidden())
ekaramada4f42692016-02-11 19:48:372249 WasShown();
lfg9462cef2016-07-18 23:51:062250 else if (!visible)
ekaramada4f42692016-02-11 19:48:372251 WasHidden();
2252}
2253
[email protected]bafe6cd2012-05-23 23:09:502254void WebContentsImpl::CreateNewWindow(
csharrison95f01e922017-04-24 18:52:352255 RenderFrameHost* opener,
nick5ae4d2d2017-01-06 01:18:352256 int32_t render_view_route_id,
dcheng3ce04b62015-10-26 23:30:552257 int32_t main_frame_route_id,
2258 int32_t main_frame_widget_route_id,
rockot5c478a72016-09-28 23:14:182259 const mojom::CreateNewWindowParams& params,
[email protected]97714c82012-06-06 10:15:132260 SessionStorageNamespace* session_storage_namespace) {
nick5ae4d2d2017-01-06 01:18:352261 // We should have zero valid routing ids, or three valid routing IDs.
2262 DCHECK_EQ((render_view_route_id == MSG_ROUTING_NONE),
2263 (main_frame_route_id == MSG_ROUTING_NONE));
2264 DCHECK_EQ((render_view_route_id == MSG_ROUTING_NONE),
2265 (main_frame_widget_route_id == MSG_ROUTING_NONE));
csharrison95f01e922017-04-24 18:52:352266 DCHECK(opener);
nick5ae4d2d2017-01-06 01:18:352267
csharrison95f01e922017-04-24 18:52:352268 int render_process_id = opener->GetProcess()->GetID();
2269 SiteInstance* source_site_instance = opener->GetSiteInstance();
2270
2271 // The route IDs passed into this function can be trusted not to already
2272 // be in use; they were allocated by the RenderWidgetHelper by the caller.
nick5ae4d2d2017-01-06 01:18:352273 DCHECK(!RenderFrameHostImpl::FromID(render_process_id, main_frame_route_id));
2274
[email protected]bafe6cd2012-05-23 23:09:502275 // We usually create the new window in the same BrowsingInstance (group of
2276 // script-related windows), by passing in the current SiteInstance. However,
[email protected]c4538072013-03-18 02:17:552277 // if the opener is being suppressed (in a non-guest), we create a new
2278 // SiteInstance in its own BrowsingInstance.
[email protected]a24efc22014-05-26 15:50:252279 bool is_guest = BrowserPluginGuest::IsGuest(this);
[email protected]c4538072013-03-18 02:17:552280
[email protected]04cbd3d2013-12-04 04:58:202281 // If the opener is to be suppressed, the new window can be in any process.
2282 // Since routing ids are process specific, we must not have one passed in
2283 // as argument here.
nick5ae4d2d2017-01-06 01:18:352284 DCHECK(!params.opener_suppressed || render_view_route_id == MSG_ROUTING_NONE);
[email protected]04cbd3d2013-12-04 04:58:202285
[email protected]bafe6cd2012-05-23 23:09:502286 scoped_refptr<SiteInstance> site_instance =
alexmos4cf2aa32015-07-15 23:40:432287 params.opener_suppressed && !is_guest
2288 ? SiteInstance::CreateForURL(GetBrowserContext(), params.target_url)
2289 : source_site_instance;
[email protected]bafe6cd2012-05-23 23:09:502290
[email protected]d1198fd2012-08-13 22:50:192291 // We must assign the SessionStorageNamespace before calling Init().
[email protected]4c3a23582012-08-18 08:54:342292 //
2293 // http://crbug.com/142685
[email protected]fdac6ade2013-07-20 01:06:302294 const std::string& partition_id =
2295 GetContentClient()->browser()->
2296 GetStoragePartitionIdForSite(GetBrowserContext(),
2297 site_instance->GetSiteURL());
[email protected]fc72bb12013-06-02 21:13:462298 StoragePartition* partition = BrowserContext::GetStoragePartition(
2299 GetBrowserContext(), site_instance.get());
[email protected]5f2aa722013-08-07 16:59:412300 DOMStorageContextWrapper* dom_storage_context =
2301 static_cast<DOMStorageContextWrapper*>(partition->GetDOMStorageContext());
[email protected]d1198fd2012-08-13 22:50:192302 SessionStorageNamespaceImpl* session_storage_namespace_impl =
2303 static_cast<SessionStorageNamespaceImpl*>(session_storage_namespace);
2304 CHECK(session_storage_namespace_impl->IsFromContext(dom_storage_context));
[email protected]dd6730412013-08-14 15:03:372305
2306 if (delegate_ &&
dcheng3ce04b62015-10-26 23:30:552307 !delegate_->ShouldCreateWebContents(
lukasza6f8ac622017-06-06 03:10:202308 this, opener, source_site_instance, render_view_route_id,
2309 main_frame_route_id, main_frame_widget_route_id,
2310 params.window_container_type, opener->GetLastCommittedURL(),
2311 params.frame_name, params.target_url, partition_id,
2312 session_storage_namespace)) {
jambaaab3a2016-11-05 00:46:182313 // Note: even though we're not creating a WebContents here, it could have
2314 // been created by the embedder so ensure that the RenderFrameHost is
2315 // properly initialized.
csharrisona2280cd2016-02-03 23:21:152316 // It's safe to only target the frame because the render process will not
2317 // have a chance to create more frames at this point.
jambaaab3a2016-11-05 00:46:182318 RenderFrameHostImpl* rfh =
2319 RenderFrameHostImpl::FromID(render_process_id, main_frame_route_id);
nick5ae4d2d2017-01-06 01:18:352320 if (rfh) {
2321 DCHECK(rfh->IsRenderFrameLive());
jambaaab3a2016-11-05 00:46:182322 rfh->Init();
nick5ae4d2d2017-01-06 01:18:352323 }
[email protected]dd6730412013-08-14 15:03:372324 return;
2325 }
2326
2327 // Create the new web contents. This will automatically create the new
2328 // WebContentsView. In the future, we may want to create the view separately.
[email protected]fc72bb12013-06-02 21:13:462329 CreateParams create_params(GetBrowserContext(), site_instance.get());
nick5ae4d2d2017-01-06 01:18:352330 create_params.routing_id = render_view_route_id;
[email protected]227692c52013-05-31 22:43:042331 create_params.main_frame_routing_id = main_frame_route_id;
dcheng3ce04b62015-10-26 23:30:552332 create_params.main_frame_widget_routing_id = main_frame_widget_route_id;
nasko48321ca32015-07-02 20:44:122333 create_params.main_frame_name = params.frame_name;
alexmos4cf2aa32015-07-15 23:40:432334 create_params.opener_render_process_id = render_process_id;
csharrison95f01e922017-04-24 18:52:352335 create_params.opener_render_frame_id = opener->GetRoutingID();
[email protected]50d326e2014-05-20 17:59:062336 create_params.opener_suppressed = params.opener_suppressed;
nick3b04f322016-08-31 19:29:192337 if (params.disposition == WindowOpenDisposition::NEW_BACKGROUND_TAB)
[email protected]50d326e2014-05-20 17:59:062338 create_params.initially_hidden = true;
lfg269b702f2015-06-08 19:28:192339 create_params.renderer_initiated_creation =
2340 main_frame_route_id != MSG_ROUTING_NONE;
[email protected]50d326e2014-05-20 17:59:062341
[email protected]4858e432014-06-23 18:14:172342 WebContentsImpl* new_contents = NULL;
[email protected]c4538072013-03-18 02:17:552343 if (!is_guest) {
2344 create_params.context = view_->GetNativeView();
[email protected]fc2b46b2014-05-03 16:33:452345 create_params.initial_size = GetContainerBounds().size();
[email protected]4858e432014-06-23 18:14:172346 new_contents = static_cast<WebContentsImpl*>(
2347 WebContents::Create(create_params));
2348 } else {
2349 new_contents = GetBrowserPluginGuest()->CreateNewGuestWindow(create_params);
[email protected]c4538072013-03-18 02:17:552350 }
[email protected]50d326e2014-05-20 17:59:062351 new_contents->GetController().SetSessionStorageNamespace(
2352 partition_id,
2353 session_storage_namespace);
[email protected]d1198fd2012-08-13 22:50:192354
alexmos646fec02015-07-25 00:11:492355 // If the new frame has a name, make sure any SiteInstances that can find
2356 // this named frame have proxies for it. Must be called after
2357 // SetSessionStorageNamespace, since this calls CreateRenderView, which uses
2358 // GetSessionStorageNamespace.
2359 if (!params.frame_name.empty())
2360 new_contents->GetRenderManager()->CreateProxiesForNewNamedFrame();
2361
[email protected]c4538072013-03-18 02:17:552362 // Save the window for later if we're not suppressing the opener (since it
[email protected]d70bea92013-04-05 04:23:342363 // will be shown immediately).
2364 if (!params.opener_suppressed) {
2365 if (!is_guest) {
[email protected]fc2b46b2014-05-03 16:33:452366 WebContentsView* new_view = new_contents->view_.get();
[email protected]bafe6cd2012-05-23 23:09:502367
[email protected]d70bea92013-04-05 04:23:342368 // TODO(brettw): It seems bogus that we have to call this function on the
2369 // newly created object and give it one of its own member variables.
avi3627ecac2015-10-16 17:40:432370 new_view->CreateViewForWidget(
2371 new_contents->GetRenderViewHost()->GetWidget(), false);
[email protected]d70bea92013-04-05 04:23:342372 }
[email protected]bafe6cd2012-05-23 23:09:502373 // Save the created window associated with the route so we can show it
2374 // later.
nick5ae4d2d2017-01-06 01:18:352375 DCHECK_NE(MSG_ROUTING_NONE, main_frame_widget_route_id);
2376 pending_contents_[std::make_pair(
2377 render_process_id, main_frame_widget_route_id)] = new_contents;
[email protected]7fff43e2013-05-21 20:21:102378 AddDestructionObserver(new_contents);
[email protected]bafe6cd2012-05-23 23:09:502379 }
2380
2381 if (delegate_) {
Bryan McQuaded2b93c02017-07-14 22:26:312382 delegate_->WebContentsCreated(this, render_process_id,
2383 opener->GetRoutingID(), params.frame_name,
2384 params.target_url, new_contents);
[email protected]bafe6cd2012-05-23 23:09:502385 }
2386
csharrison95f01e922017-04-24 18:52:352387 if (opener) {
pnolandaae574e2017-03-06 21:04:212388 for (auto& observer : observers_) {
csharrison95f01e922017-04-24 18:52:352389 observer.DidOpenRequestedURL(new_contents, opener, params.target_url,
2390 params.referrer, params.disposition,
2391 ui::PAGE_TRANSITION_LINK,
pnolandaae574e2017-03-06 21:04:212392 false, // started_from_context_menu
2393 true); // renderer_initiated
2394 }
2395 }
2396
[email protected]bafe6cd2012-05-23 23:09:502397 if (params.opener_suppressed) {
2398 // When the opener is suppressed, the original renderer cannot access the
2399 // new window. As a result, we need to show and navigate the window here.
[email protected]eda238a12012-09-07 23:44:002400 bool was_blocked = false;
2401 if (delegate_) {
bokan107a47f2015-02-03 23:23:392402 gfx::Rect initial_rect;
nick0d558482017-02-13 22:27:222403 base::WeakPtr<WebContentsImpl> weak_new_contents =
2404 new_contents->weak_factory_.GetWeakPtr();
2405
[email protected]eda238a12012-09-07 23:44:002406 delegate_->AddNewContents(
bokan107a47f2015-02-03 23:23:392407 this, new_contents, params.disposition, initial_rect,
[email protected]eda238a12012-09-07 23:44:002408 params.user_gesture, &was_blocked);
nick0d558482017-02-13 22:27:222409
2410 if (!weak_new_contents)
2411 return; // The delegate deleted |new_contents| during AddNewContents().
[email protected]eda238a12012-09-07 23:44:002412 }
2413 if (!was_blocked) {
nick3b04f322016-08-31 19:29:192414 OpenURLParams open_params(params.target_url, params.referrer,
2415 WindowOpenDisposition::CURRENT_TAB,
Sylvain Defresnec6ccc77d2014-09-19 10:19:352416 ui::PAGE_TRANSITION_LINK,
[email protected]8ff00d72012-10-23 19:12:212417 true /* is_renderer_initiated */);
[email protected]e7f2e7c2013-07-15 09:41:302418 open_params.user_gesture = params.user_gesture;
mariakhomenkoa4971c12015-07-21 19:04:372419
2420 if (delegate_ && !is_guest &&
2421 !delegate_->ShouldResumeRequestsForCreatedWindow()) {
2422 // We are in asynchronous add new contents path, delay opening url
2423 new_contents->delayed_open_url_params_.reset(
2424 new OpenURLParams(open_params));
2425 } else {
2426 new_contents->OpenURL(open_params);
2427 }
[email protected]eda238a12012-09-07 23:44:002428 }
[email protected]bafe6cd2012-05-23 23:09:502429 }
2430}
2431
avib7348942015-12-25 20:57:102432void WebContentsImpl::CreateNewWidget(int32_t render_process_id,
2433 int32_t route_id,
Dave Tapuska1bdf1832017-07-07 18:07:192434 mojom::WidgetPtr widget,
[email protected]180ef242013-11-07 06:50:462435 blink::WebPopupType popup_type) {
Dave Tapuska1bdf1832017-07-07 18:07:192436 CreateNewWidget(render_process_id, route_id, false, std::move(widget),
2437 popup_type);
[email protected]bafe6cd2012-05-23 23:09:502438}
2439
avib7348942015-12-25 20:57:102440void WebContentsImpl::CreateNewFullscreenWidget(int32_t render_process_id,
Dave Tapuska1bdf1832017-07-07 18:07:192441 int32_t route_id,
2442 mojom::WidgetPtr widget) {
2443 CreateNewWidget(render_process_id, route_id, true, std::move(widget),
2444 blink::kWebPopupTypeNone);
[email protected]bafe6cd2012-05-23 23:09:502445}
2446
avib7348942015-12-25 20:57:102447void WebContentsImpl::CreateNewWidget(int32_t render_process_id,
2448 int32_t route_id,
[email protected]bafe6cd2012-05-23 23:09:502449 bool is_fullscreen,
Dave Tapuska1bdf1832017-07-07 18:07:192450 mojom::WidgetPtr widget,
[email protected]180ef242013-11-07 06:50:462451 blink::WebPopupType popup_type) {
kenrba26d15092016-02-10 22:00:252452 RenderProcessHost* process = RenderProcessHost::FromID(render_process_id);
kenrbb46f86a2015-12-07 07:53:232453 // A message to create a new widget can only come from an active process for
[email protected]a8504022013-12-04 20:23:512454 // this WebContentsImpl instance. If any other process sends the request,
2455 // it is invalid and the process must be terminated.
dcheng57e39e22016-01-21 00:25:382456 if (!HasMatchingProcess(&frame_tree_, render_process_id)) {
kenrba26d15092016-02-10 22:00:252457 base::ProcessHandle process_handle = process->GetHandle();
[email protected]a8504022013-12-04 20:23:512458 if (process_handle != base::kNullProcessHandle) {
2459 RecordAction(
[email protected]e6e30ac2014-01-13 21:24:392460 base::UserMetricsAction("Terminate_ProcessMismatch_CreateNewWidget"));
kenrba26d15092016-02-10 22:00:252461 process->Shutdown(RESULT_CODE_KILLED, false);
[email protected]a8504022013-12-04 20:23:512462 }
2463 return;
2464 }
2465
Dave Tapuska485aca92017-08-08 00:47:582466 RenderWidgetHostImpl* widget_host = new RenderWidgetHostImpl(
2467 this, process, route_id, std::move(widget), IsHidden());
[email protected]b24b68a2012-09-24 21:57:262468
[email protected]cfd80b02014-05-01 17:46:482469 RenderWidgetHostViewBase* widget_view =
2470 static_cast<RenderWidgetHostViewBase*>(
2471 view_->CreateViewForPopupWidget(widget_host));
[email protected]83918ec2013-01-10 15:37:192472 if (!widget_view)
2473 return;
[email protected]bafe6cd2012-05-23 23:09:502474 if (!is_fullscreen) {
2475 // Popups should not get activated.
2476 widget_view->SetPopupType(popup_type);
2477 }
2478 // Save the created widget associated with the route so we can show it later.
alexmosc2a8cec2016-05-23 22:19:532479 pending_widget_views_[std::make_pair(render_process_id, route_id)] =
2480 widget_view;
[email protected]bafe6cd2012-05-23 23:09:502481
2482#if defined(OS_MACOSX)
2483 // A RenderWidgetHostViewMac has lifetime scoped to the view. We'll retain it
2484 // to allow it to survive the trip without being hosted.
2485 base::mac::NSObjectRetain(widget_view->GetNativeView());
2486#endif
2487}
2488
alexmosc2a8cec2016-05-23 22:19:532489void WebContentsImpl::ShowCreatedWindow(int process_id,
nick5ae4d2d2017-01-06 01:18:352490 int main_frame_widget_route_id,
[email protected]bafe6cd2012-05-23 23:09:502491 WindowOpenDisposition disposition,
bokan107a47f2015-02-03 23:23:392492 const gfx::Rect& initial_rect,
[email protected]bafe6cd2012-05-23 23:09:502493 bool user_gesture) {
nick0d558482017-02-13 22:27:222494 WebContentsImpl* popup =
nick5ae4d2d2017-01-06 01:18:352495 GetCreatedWindow(process_id, main_frame_widget_route_id);
nick0d558482017-02-13 22:27:222496 if (popup) {
[email protected]eda238a12012-09-07 23:44:002497 WebContentsDelegate* delegate = GetDelegate();
nick0d558482017-02-13 22:27:222498 popup->is_resume_pending_ = true;
mariakhomenko44bdc4732015-04-29 01:55:382499 if (!delegate || delegate->ShouldResumeRequestsForCreatedWindow())
nick0d558482017-02-13 22:27:222500 popup->ResumeLoadingCreatedWebContents();
mariakhomenko44bdc4732015-04-29 01:55:382501
[email protected]eda238a12012-09-07 23:44:002502 if (delegate) {
nick0d558482017-02-13 22:27:222503 base::WeakPtr<WebContentsImpl> weak_popup =
2504 popup->weak_factory_.GetWeakPtr();
2505 delegate->AddNewContents(this, popup, disposition, initial_rect,
2506 user_gesture, nullptr);
2507 if (!weak_popup)
2508 return; // The delegate deleted |popup| during AddNewContents().
[email protected]eda238a12012-09-07 23:44:002509 }
nick5ae4d2d2017-01-06 01:18:352510
nick0d558482017-02-13 22:27:222511 RenderWidgetHostImpl* rwh = popup->GetMainFrame()->GetRenderWidgetHost();
2512 DCHECK_EQ(main_frame_widget_route_id, rwh->GetRoutingID());
nick5ae4d2d2017-01-06 01:18:352513 rwh->Send(new ViewMsg_Move_ACK(rwh->GetRoutingID()));
[email protected]eda238a12012-09-07 23:44:002514 }
[email protected]bafe6cd2012-05-23 23:09:502515}
2516
alexmosc2a8cec2016-05-23 22:19:532517void WebContentsImpl::ShowCreatedWidget(int process_id,
2518 int route_id,
bokan107a47f2015-02-03 23:23:392519 const gfx::Rect& initial_rect) {
alexmosc2a8cec2016-05-23 22:19:532520 ShowCreatedWidget(process_id, route_id, false, initial_rect);
[email protected]bafe6cd2012-05-23 23:09:502521}
2522
alexmosc2a8cec2016-05-23 22:19:532523void WebContentsImpl::ShowCreatedFullscreenWidget(int process_id,
2524 int route_id) {
2525 ShowCreatedWidget(process_id, route_id, true, gfx::Rect());
[email protected]bafe6cd2012-05-23 23:09:502526}
2527
alexmosc2a8cec2016-05-23 22:19:532528void WebContentsImpl::ShowCreatedWidget(int process_id,
2529 int route_id,
[email protected]bafe6cd2012-05-23 23:09:502530 bool is_fullscreen,
bokan107a47f2015-02-03 23:23:392531 const gfx::Rect& initial_rect) {
[email protected]cfd80b02014-05-01 17:46:482532 RenderWidgetHostViewBase* widget_host_view =
alexmosc2a8cec2016-05-23 22:19:532533 static_cast<RenderWidgetHostViewBase*>(
2534 GetCreatedWidget(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:502535 if (!widget_host_view)
2536 return;
[email protected]cfd80b02014-05-01 17:46:482537
2538 RenderWidgetHostView* view = NULL;
lfgc740d4b22016-04-15 16:45:332539 if (GetOuterWebContents()) {
2540 view = GetOuterWebContents()->GetRenderWidgetHostView();
[email protected]cfd80b02014-05-01 17:46:482541 } else {
2542 view = GetRenderWidgetHostView();
2543 }
2544
[email protected]4aebbca2013-09-17 22:26:492545 if (is_fullscreen) {
[email protected]d7f80ba2013-10-12 07:42:312546 DCHECK_EQ(MSG_ROUTING_NONE, fullscreen_widget_routing_id_);
[email protected]0b431992014-06-24 00:08:032547 view_->StoreFocus();
alexmosc9e76ec2016-05-16 22:59:372548 fullscreen_widget_process_id_ =
2549 widget_host_view->GetRenderWidgetHost()->GetProcess()->GetID();
[email protected]d7f80ba2013-10-12 07:42:312550 fullscreen_widget_routing_id_ = route_id;
[email protected]4aebbca2013-09-17 22:26:492551 if (delegate_ && delegate_->EmbedsFullscreenWidget()) {
2552 widget_host_view->InitAsChild(GetRenderWidgetHostView()->GetNativeView());
mlamouri7a78d6fd2015-01-17 13:23:532553 delegate_->EnterFullscreenModeForTab(this, GURL());
[email protected]4aebbca2013-09-17 22:26:492554 } else {
[email protected]cfd80b02014-05-01 17:46:482555 widget_host_view->InitAsFullscreen(view);
[email protected]4aebbca2013-09-17 22:26:492556 }
ericwilligersde386342016-10-19 02:35:092557 for (auto& observer : observers_)
2558 observer.DidShowFullscreenWidget();
[email protected]4aebbca2013-09-17 22:26:492559 if (!widget_host_view->HasFocus())
2560 widget_host_view->Focus();
2561 } else {
bokan107a47f2015-02-03 23:23:392562 widget_host_view->InitAsPopup(view, initial_rect);
[email protected]4aebbca2013-09-17 22:26:492563 }
[email protected]89054502012-06-03 10:29:242564
2565 RenderWidgetHostImpl* render_widget_host_impl =
2566 RenderWidgetHostImpl::From(widget_host_view->GetRenderWidgetHost());
2567 render_widget_host_impl->Init();
[email protected]d7f80ba2013-10-12 07:42:312568 // Only allow privileged mouse lock for fullscreen render widget, which is
2569 // used to implement Pepper Flash fullscreen.
2570 render_widget_host_impl->set_allow_privileged_mouse_lock(is_fullscreen);
[email protected]bafe6cd2012-05-23 23:09:502571
2572#if defined(OS_MACOSX)
2573 // A RenderWidgetHostViewMac has lifetime scoped to the view. Now that it's
2574 // properly embedded (or purposefully ignored) we can release the retain we
2575 // took in CreateNewWidget().
2576 base::mac::NSObjectRelease(widget_host_view->GetNativeView());
2577#endif
2578}
2579
nick5ae4d2d2017-01-06 01:18:352580WebContentsImpl* WebContentsImpl::GetCreatedWindow(
2581 int process_id,
2582 int main_frame_widget_route_id) {
2583 auto key = std::make_pair(process_id, main_frame_widget_route_id);
2584 auto iter = pending_contents_.find(key);
[email protected]bafe6cd2012-05-23 23:09:502585
2586 // Certain systems can block the creation of new windows. If we didn't succeed
2587 // in creating one, just return NULL.
alexmosc2a8cec2016-05-23 22:19:532588 if (iter == pending_contents_.end())
2589 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:502590
2591 WebContentsImpl* new_contents = iter->second;
nick5ae4d2d2017-01-06 01:18:352592 pending_contents_.erase(key);
[email protected]7fff43e2013-05-21 20:21:102593 RemoveDestructionObserver(new_contents);
[email protected]bafe6cd2012-05-23 23:09:502594
[email protected]d70bea92013-04-05 04:23:342595 // Don't initialize the guest WebContents immediately.
[email protected]a24efc22014-05-26 15:50:252596 if (BrowserPluginGuest::IsGuest(new_contents))
[email protected]d70bea92013-04-05 04:23:342597 return new_contents;
2598
nick5ae4d2d2017-01-06 01:18:352599 if (!new_contents->GetMainFrame()->GetProcess()->HasConnection() ||
2600 !new_contents->GetMainFrame()->GetView()) {
2601 // TODO(nick): http://crbug.com/674318 -- Who deletes |new_contents|?
alexmosc2a8cec2016-05-23 22:19:532602 return nullptr;
nick5ae4d2d2017-01-06 01:18:352603 }
[email protected]bafe6cd2012-05-23 23:09:502604
[email protected]bafe6cd2012-05-23 23:09:502605 return new_contents;
2606}
2607
alexmosc2a8cec2016-05-23 22:19:532608RenderWidgetHostView* WebContentsImpl::GetCreatedWidget(int process_id,
2609 int route_id) {
2610 auto iter = pending_widget_views_.find(std::make_pair(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:502611 if (iter == pending_widget_views_.end()) {
2612 DCHECK(false);
alexmosc2a8cec2016-05-23 22:19:532613 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:502614 }
2615
2616 RenderWidgetHostView* widget_host_view = iter->second;
alexmosc2a8cec2016-05-23 22:19:532617 pending_widget_views_.erase(std::make_pair(process_id, route_id));
[email protected]bafe6cd2012-05-23 23:09:502618
2619 RenderWidgetHost* widget_host = widget_host_view->GetRenderWidgetHost();
2620 if (!widget_host->GetProcess()->HasConnection()) {
2621 // The view has gone away or the renderer crashed. Nothing to do.
alexmosc2a8cec2016-05-23 22:19:532622 return nullptr;
[email protected]bafe6cd2012-05-23 23:09:502623 }
2624
2625 return widget_host_view;
2626}
2627
[email protected]f13b4202012-06-12 23:53:232628void WebContentsImpl::RequestMediaAccessPermission(
[email protected]33662e52013-01-07 21:31:092629 const MediaStreamRequest& request,
[email protected]8ff00d72012-10-23 19:12:212630 const MediaResponseCallback& callback) {
[email protected]d19b84b2014-03-14 11:52:372631 if (delegate_) {
[email protected]f13b4202012-06-12 23:53:232632 delegate_->RequestMediaAccessPermission(this, request, callback);
[email protected]d19b84b2014-03-14 11:52:372633 } else {
dcheng59716272016-04-09 05:19:082634 callback.Run(MediaStreamDevices(), MEDIA_DEVICE_FAILED_DUE_TO_SHUTDOWN,
2635 std::unique_ptr<MediaStreamUI>());
[email protected]d19b84b2014-03-14 11:52:372636 }
[email protected]f13b4202012-06-12 23:53:232637}
2638
grunell657d4d82014-09-18 00:09:432639bool WebContentsImpl::CheckMediaAccessPermission(const GURL& security_origin,
2640 MediaStreamType type) {
2641 DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
2642 type == MEDIA_DEVICE_VIDEO_CAPTURE);
2643 return delegate_ &&
2644 delegate_->CheckMediaAccessPermission(this, security_origin, type);
2645}
2646
guidou8a440b842017-01-30 13:58:432647std::string WebContentsImpl::GetDefaultMediaDeviceID(MediaStreamType type) {
2648 if (!delegate_)
2649 return std::string();
2650 return delegate_->GetDefaultMediaDeviceID(this, type);
2651}
2652
[email protected]cc9200432013-07-23 23:02:402653SessionStorageNamespace* WebContentsImpl::GetSessionStorageNamespace(
2654 SiteInstance* instance) {
2655 return controller_.GetSessionStorageNamespace(instance);
2656}
2657
[email protected]6de7fc482014-06-06 10:46:442658SessionStorageNamespaceMap WebContentsImpl::GetSessionStorageNamespaceMap() {
2659 return controller_.GetSessionStorageNamespaceMap();
2660}
2661
[email protected]9b159a52013-10-03 17:24:552662FrameTree* WebContentsImpl::GetFrameTree() {
2663 return &frame_tree_;
2664}
2665
lukendc35e7f2014-11-10 19:06:142666void WebContentsImpl::SetIsVirtualKeyboardRequested(bool requested) {
2667 virtual_keyboard_requested_ = requested;
2668}
2669
2670bool WebContentsImpl::IsVirtualKeyboardRequested() {
2671 return virtual_keyboard_requested_;
2672}
2673
aelias5252baa2016-04-10 01:18:022674bool WebContentsImpl::IsOverridingUserAgent() {
2675 return GetController().GetVisibleEntry() &&
2676 GetController().GetVisibleEntry()->GetIsOverridingUserAgent();
2677}
2678
avi85ee8362016-10-08 02:09:082679bool WebContentsImpl::IsJavaScriptDialogShowing() const {
2680 return is_showing_javascript_dialog_;
2681}
2682
avic031d392017-03-03 03:09:422683bool WebContentsImpl::ShouldIgnoreUnresponsiveRenderer() {
2684 // Ignore unresponsive renderers if the debugger is attached to them since the
2685 // unresponsiveness might be a result of the renderer sitting on a breakpoint.
2686 //
2687 // TODO(pfeldman): Fix this to only return true if the renderer is *actually*
2688 // sitting on a breakpoint. https://crbug.com/684202
2689 return DevToolsAgentHost::IsDebuggerAttached(this);
2690}
2691
Doug Turner63f3c7b2017-07-29 05:10:012692ui::AXMode WebContentsImpl::GetAccessibilityMode() const {
[email protected]95640212014-07-26 18:14:302693 return accessibility_mode_;
2694}
2695
Dominic Mazzonia7b0edb22017-08-09 16:32:512696void WebContentsImpl::AccessibilityEventReceived(
2697 const std::vector<AXEventNotificationDetails>& details) {
ericwilligersde386342016-10-19 02:35:092698 for (auto& observer : observers_)
Dominic Mazzonia7b0edb22017-08-09 16:32:512699 observer.AccessibilityEventReceived(details);
[email protected]31a71eaf2014-03-13 01:47:362700}
2701
dmazzoni2400c462016-08-23 15:07:132702void WebContentsImpl::AccessibilityLocationChangesReceived(
2703 const std::vector<AXLocationChangeNotificationDetails>& details) {
ericwilligersde386342016-10-19 02:35:092704 for (auto& observer : observers_)
Dominic Mazzonia7b0edb22017-08-09 16:32:512705 observer.AccessibilityLocationChangesReceived(details);
dmazzoni2400c462016-08-23 15:07:132706}
2707
dmazzonia656928e2014-09-15 20:28:542708RenderFrameHost* WebContentsImpl::GetGuestByInstanceID(
fsamuel833ee7c2015-02-13 23:40:402709 RenderFrameHost* render_frame_host,
dmazzonia656928e2014-09-15 20:28:542710 int browser_plugin_instance_id) {
2711 BrowserPluginGuestManager* guest_manager =
2712 GetBrowserContext()->GetGuestManager();
fsamuel9cbc00a2015-04-17 20:30:202713 if (!guest_manager)
2714 return nullptr;
2715
dmazzonia656928e2014-09-15 20:28:542716 WebContents* guest = guest_manager->GetGuestByInstanceID(
fsamuel2e9413d2015-02-25 01:25:442717 render_frame_host->GetProcess()->GetID(), browser_plugin_instance_id);
dmazzonia656928e2014-09-15 20:28:542718 if (!guest)
fsamuel9cbc00a2015-04-17 20:30:202719 return nullptr;
2720
dmazzonia656928e2014-09-15 20:28:542721 return guest->GetMainFrame();
2722}
2723
Conley Owens6894c4f2017-07-10 19:29:132724device::GeolocationContext* WebContentsImpl::GetGeolocationContext() {
2725 return geolocation_context_.get();
blundellc57b93f2014-10-29 13:19:572726}
2727
ke.he98b761e2017-05-09 05:59:172728device::mojom::WakeLockContext* WebContentsImpl::GetWakeLockContext() {
blundelld8cd72b2017-03-28 07:18:382729 if (!wake_lock_context_host_)
2730 wake_lock_context_host_.reset(new WakeLockContextHost(this));
blundelle75a8f92017-03-27 08:11:172731 return wake_lock_context_host_->GetWakeLockContext();
alogvinovf50445a2015-10-30 13:00:122732}
2733
juncai8e8d6ec2017-06-06 20:48:182734device::mojom::WakeLock* WebContentsImpl::GetRendererWakeLock() {
2735 // WebContents creates a long-lived connection to one WakeLock.
ke.he98b761e2017-05-09 05:59:172736 // All the frames' requests will be added into the BindingSet of
juncai8e8d6ec2017-06-06 20:48:182737 // WakeLock via this connection.
ke.he98b761e2017-05-09 05:59:172738 if (!renderer_wake_lock_) {
2739 device::mojom::WakeLockContext* wake_lock_context = GetWakeLockContext();
2740 if (!wake_lock_context) {
2741 return nullptr;
2742 }
ke.hef435c1e82017-05-11 04:09:102743 wake_lock_context->GetWakeLock(
2744 device::mojom::WakeLockType::PreventDisplaySleep,
2745 device::mojom::WakeLockReason::ReasonOther, "Wake Lock API",
2746 mojo::MakeRequest(&renderer_wake_lock_));
ke.he98b761e2017-05-09 05:59:172747 }
2748 return renderer_wake_lock_.get();
2749}
2750
blundellf5316fc2017-05-15 11:49:032751#if defined(OS_ANDROID)
Han Leonf6a2e5f2017-05-23 13:40:472752void WebContentsImpl::GetNFC(device::mojom::NFCRequest request) {
blundellf5316fc2017-05-15 11:49:032753 if (!nfc_host_)
2754 nfc_host_.reset(new NFCHost(this));
2755 nfc_host_->GetNFC(std::move(request));
2756}
2757#endif
2758
[email protected]edc3af82013-12-12 21:24:072759void WebContentsImpl::OnShowValidationMessage(
nicka0ac8382016-12-15 23:59:232760 RenderViewHostImpl* source,
[email protected]edc3af82013-12-12 21:24:072761 const gfx::Rect& anchor_in_root_view,
[email protected]6ff9c8f2013-12-20 09:05:292762 const base::string16& main_text,
2763 const base::string16& sub_text) {
nicka0ac8382016-12-15 23:59:232764 // TODO(nick): Should we consider |source| here or pass it to the delegate?
[email protected]edc3af82013-12-12 21:24:072765 if (delegate_)
2766 delegate_->ShowValidationMessage(
2767 this, anchor_in_root_view, main_text, sub_text);
2768}
2769
nicka0ac8382016-12-15 23:59:232770void WebContentsImpl::OnHideValidationMessage(RenderViewHostImpl* source) {
2771 // TODO(nick): Should we consider |source| here or pass it to the delegate?
[email protected]edc3af82013-12-12 21:24:072772 if (delegate_)
2773 delegate_->HideValidationMessage(this);
2774}
2775
2776void WebContentsImpl::OnMoveValidationMessage(
nicka0ac8382016-12-15 23:59:232777 RenderViewHostImpl* source,
[email protected]edc3af82013-12-12 21:24:072778 const gfx::Rect& anchor_in_root_view) {
nicka0ac8382016-12-15 23:59:232779 // TODO(nick): Should we consider |source| here or pass it to the delegate?
[email protected]edc3af82013-12-12 21:24:072780 if (delegate_)
2781 delegate_->MoveValidationMessage(this, anchor_in_root_view);
2782}
2783
Evan Stade5e750ad02017-08-07 21:59:272784void WebContentsImpl::SetNotWaitingForResponse() {
2785 if (waiting_for_response_ == false)
2786 return;
2787
2788 waiting_for_response_ = false;
2789 if (delegate_)
2790 delegate_->LoadingStateChanged(this, is_load_to_different_document_);
2791}
2792
lfgbb9c28a2016-03-01 03:19:492793void WebContentsImpl::SendScreenRects() {
kenrbc52e1b4e2016-03-20 01:03:372794 for (FrameTreeNode* node : frame_tree_.Nodes()) {
kenrb0e8dc202016-05-30 19:51:402795 if (node->current_frame_host()->is_local_root())
kenrbc52e1b4e2016-03-20 01:03:372796 node->current_frame_host()->GetRenderWidgetHost()->SendScreenRects();
2797 }
lfgbb9c28a2016-03-01 03:19:492798
lfgdb5c4ed2016-03-04 23:09:072799 RenderWidgetHostViewBase* rwhv =
2800 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
2801 if (rwhv) {
2802 SendPageMessage(new PageMsg_UpdateWindowScreenRect(
2803 MSG_ROUTING_NONE, rwhv->GetBoundsInRootWindow()));
2804 }
2805
avallee9f43b012016-11-26 07:02:102806 if (browser_plugin_embedder_ && !is_being_destroyed_)
[email protected]a7568e62013-06-14 07:50:442807 browser_plugin_embedder_->DidSendScreenRects();
[email protected]32deec62013-05-15 23:55:042808}
2809
ekaramadadd882292016-06-08 15:22:562810TextInputManager* WebContentsImpl::GetTextInputManager() {
2811 if (GetOuterWebContents())
2812 return GetOuterWebContents()->GetTextInputManager();
2813
2814 if (!text_input_manager_)
2815 text_input_manager_.reset(new TextInputManager());
2816
2817 return text_input_manager_.get();
2818}
2819
paulmeyer7f6f1d4f2016-11-15 00:00:272820bool WebContentsImpl::OnUpdateDragCursor() {
2821 if (browser_plugin_embedder_)
2822 return browser_plugin_embedder_->OnUpdateDragCursor();
2823 return false;
2824}
2825
kenrb11f213a2017-03-24 18:12:062826bool WebContentsImpl::IsWidgetForMainFrame(
2827 RenderWidgetHostImpl* render_widget_host) {
2828 return render_widget_host == GetMainFrame()->GetRenderWidgetHost();
2829}
2830
[email protected]95640212014-07-26 18:14:302831BrowserAccessibilityManager*
2832 WebContentsImpl::GetRootBrowserAccessibilityManager() {
creisc014b402015-04-23 16:41:452833 RenderFrameHostImpl* rfh = GetMainFrame();
2834 return rfh ? rfh->browser_accessibility_manager() : nullptr;
[email protected]95640212014-07-26 18:14:302835}
2836
2837BrowserAccessibilityManager*
2838 WebContentsImpl::GetOrCreateRootBrowserAccessibilityManager() {
creisc014b402015-04-23 16:41:452839 RenderFrameHostImpl* rfh = GetMainFrame();
2840 return rfh ? rfh->GetOrCreateBrowserAccessibilityManager() : nullptr;
[email protected]95640212014-07-26 18:14:302841}
2842
Dave Tapuskab336b922017-07-06 19:24:052843void WebContentsImpl::ExecuteEditCommand(
2844 const std::string& command,
2845 const base::Optional<base::string16>& value) {
2846 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
2847 if (!focused_frame)
2848 return;
2849
2850 focused_frame->GetFrameInputHandler()->ExecuteEditCommand(command, value);
2851}
2852
mohsen7ab1ec16ec2015-07-02 18:26:232853void WebContentsImpl::MoveRangeSelectionExtent(const gfx::Point& extent) {
Dave Tapuskab336b922017-07-06 19:24:052854 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
mohsen7ab1ec16ec2015-07-02 18:26:232855 if (!focused_frame)
2856 return;
2857
dtapuska9d46ef7d2017-05-26 19:06:062858 focused_frame->GetFrameInputHandler()->MoveRangeSelectionExtent(extent);
mohsen7ab1ec16ec2015-07-02 18:26:232859}
2860
2861void WebContentsImpl::SelectRange(const gfx::Point& base,
2862 const gfx::Point& extent) {
Dave Tapuskab336b922017-07-06 19:24:052863 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
mohsen7ab1ec16ec2015-07-02 18:26:232864 if (!focused_frame)
2865 return;
2866
dtapuska9d46ef7d2017-05-26 19:06:062867 focused_frame->GetFrameInputHandler()->SelectRange(base, extent);
mohsen7ab1ec16ec2015-07-02 18:26:232868}
2869
Dave Tapuskab336b922017-07-06 19:24:052870void WebContentsImpl::MoveCaret(const gfx::Point& extent) {
2871 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
2872 if (!focused_frame)
2873 return;
2874
2875 focused_frame->GetFrameInputHandler()->MoveCaret(extent);
2876}
2877
aurimasab0319022015-07-10 21:57:382878void WebContentsImpl::AdjustSelectionByCharacterOffset(int start_adjust,
2879 int end_adjust) {
Dave Tapuskab336b922017-07-06 19:24:052880 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
aurimasab0319022015-07-10 21:57:382881 if (!focused_frame)
2882 return;
2883
dtapuska9d46ef7d2017-05-26 19:06:062884 focused_frame->GetFrameInputHandler()->AdjustSelectionByCharacterOffset(
2885 start_adjust, end_adjust);
aurimasab0319022015-07-10 21:57:382886}
2887
[email protected]b172aee2012-04-10 17:05:262888void WebContentsImpl::UpdatePreferredSize(const gfx::Size& pref_size) {
[email protected]222f5822014-02-05 23:40:492889 const gfx::Size old_size = GetPreferredSize();
[email protected]bcd2815602012-01-14 18:17:232890 preferred_size_ = pref_size;
[email protected]222f5822014-02-05 23:40:492891 OnPreferredSizeChanged(old_size);
[email protected]0548c5352011-09-07 00:33:332892}
2893
avic3aa8422015-11-09 20:57:222894void WebContentsImpl::ResizeDueToAutoResize(
2895 RenderWidgetHostImpl* render_widget_host,
2896 const gfx::Size& new_size) {
2897 if (render_widget_host != GetRenderViewHost()->GetWidget())
2898 return;
2899
kenrbe4f91082017-06-02 20:32:082900 auto_resize_size_ = new_size;
2901
2902 // Out-of-process iframe visible viewport sizes usually come from the
2903 // top-level RenderWidgetHostView, but when auto-resize is enabled on the
2904 // top frame then that size is used instead.
2905 for (FrameTreeNode* node : frame_tree_.Nodes()) {
2906 if (node->current_frame_host()->is_local_root()) {
2907 RenderWidgetHostImpl* host =
2908 node->current_frame_host()->GetRenderWidgetHost();
2909 if (host != render_widget_host)
2910 host->WasResized();
2911 }
2912 }
2913
[email protected]61e2b3cc2012-03-02 16:13:342914 if (delegate_)
2915 delegate_->ResizeDueToAutoResize(this, new_size);
2916}
2917
kenrbe4f91082017-06-02 20:32:082918gfx::Size WebContentsImpl::GetAutoResizeSize() {
2919 return auto_resize_size_;
2920}
2921
2922void WebContentsImpl::ResetAutoResizeSize() {
2923 auto_resize_size_ = gfx::Size();
2924}
2925
[email protected]b172aee2012-04-10 17:05:262926WebContents* WebContentsImpl::OpenURL(const OpenURLParams& params) {
[email protected]e5d549d2011-12-28 01:29:202927 if (!delegate_)
2928 return NULL;
[email protected]00c37fc2011-08-02 00:22:502929
[email protected]e5d549d2011-12-28 01:29:202930 WebContents* new_contents = delegate_->OpenURLFromTab(this, params);
pnoland488944652017-02-22 18:58:542931
2932 RenderFrameHost* source_render_frame_host = RenderFrameHost::FromID(
2933 params.source_render_process_id, params.source_render_frame_id);
2934
2935 if (source_render_frame_host && params.source_site_instance) {
2936 CHECK_EQ(source_render_frame_host->GetSiteInstance(),
2937 params.source_site_instance.get());
2938 }
2939
2940 if (new_contents && source_render_frame_host && new_contents != this) {
2941 for (auto& observer : observers_) {
2942 observer.DidOpenRequestedURL(new_contents, source_render_frame_host,
2943 params.url, params.referrer,
2944 params.disposition, params.transition,
pnolandaae574e2017-03-06 21:04:212945 params.started_from_context_menu, false);
pnoland488944652017-02-22 18:58:542946 }
2947 }
2948
[email protected]e5d549d2011-12-28 01:29:202949 return new_contents;
[email protected]d5f942ba2008-09-26 19:30:342950}
2951
[email protected]6b618e62012-08-16 12:59:182952bool WebContentsImpl::Send(IPC::Message* message) {
2953 if (!GetRenderViewHost()) {
2954 delete message;
2955 return false;
2956 }
2957
2958 return GetRenderViewHost()->Send(message);
2959}
2960
[email protected]a86c0e962013-12-17 17:10:392961void WebContentsImpl::RenderFrameForInterstitialPageCreated(
2962 RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:092963 for (auto& observer : observers_)
2964 observer.RenderFrameForInterstitialPageCreated(render_frame_host);
[email protected]ba45bfd2012-05-22 21:51:442965}
2966
[email protected]20ca0382013-02-28 19:50:072967void WebContentsImpl::AttachInterstitialPage(
2968 InterstitialPageImpl* interstitial_page) {
creisadca9862017-06-16 19:12:112969 DCHECK(!interstitial_page_ && interstitial_page);
2970 interstitial_page_ = interstitial_page;
[email protected]90fb08ed2013-09-24 17:43:292971
2972 // Cancel any visible dialogs so that they don't interfere with the
2973 // interstitial.
creis89a0f782015-05-27 16:13:172974 CancelActiveAndPendingDialogs();
[email protected]90fb08ed2013-09-24 17:43:292975
ericwilligersde386342016-10-19 02:35:092976 for (auto& observer : observers_)
2977 observer.DidAttachInterstitialPage();
clamy44e84ce2016-02-22 15:38:252978
2979 // Stop the throbber if needed while the interstitial page is shown.
2980 if (frame_tree_.IsLoading())
2981 LoadingStateChanged(true, true, nullptr);
lfg1453e412017-04-11 00:48:502982
2983 // Connect to outer WebContents if necessary.
2984 if (node_.OuterContentsFrameTreeNode()) {
2985 if (GetRenderManager()->GetProxyToOuterDelegate()) {
2986 DCHECK(
2987 static_cast<RenderWidgetHostViewBase*>(interstitial_page->GetView())
2988 ->IsRenderWidgetHostViewChildFrame());
2989 RenderWidgetHostViewChildFrame* view =
2990 static_cast<RenderWidgetHostViewChildFrame*>(
2991 interstitial_page->GetView());
2992 GetRenderManager()->SetRWHViewForInnerContents(view);
2993 }
2994 }
Bo Liu7c6779e92017-08-16 02:02:282995
2996 // Update importance of the interstitial.
2997 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
2998 ->GetRenderWidgetHost()
2999 ->SetImportance(GetMainFrame()->GetRenderWidgetHost()->importance());
clamy44e84ce2016-02-22 15:38:253000}
3001
3002void WebContentsImpl::DidProceedOnInterstitial() {
3003 // The interstitial page should no longer be pausing the throbber.
creisadca9862017-06-16 19:12:113004 DCHECK(!(ShowingInterstitialPage() && interstitial_page_->pause_throbber()));
clamy44e84ce2016-02-22 15:38:253005
3006 // Restart the throbber now that the interstitial page no longer pauses it.
3007 if (ShowingInterstitialPage() && frame_tree_.IsLoading())
3008 LoadingStateChanged(true, true, nullptr);
[email protected]20ca0382013-02-28 19:50:073009}
3010
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043011void WebContentsImpl::DetachInterstitialPage(bool has_focus) {
Lucas Furukawa Gadani69b609192017-07-10 17:08:343012 bool interstitial_pausing_throbber =
3013 ShowingInterstitialPage() && interstitial_page_->pause_throbber();
3014 if (ShowingInterstitialPage())
3015 interstitial_page_ = nullptr;
Lucas Furukawa Gadani7f1241d2017-07-12 01:45:043016
3017 // If the focus was on the interstitial, let's keep it to the page.
3018 // (Note that in unit-tests the RVH may not have a view).
3019 if (has_focus && GetRenderViewHost()->GetWidget()->GetView())
3020 GetRenderViewHost()->GetWidget()->GetView()->Focus();
3021
Lucas Furukawa Gadani69b609192017-07-10 17:08:343022 for (auto& observer : observers_)
3023 observer.DidDetachInterstitialPage();
3024
3025 // Disconnect from outer WebContents if necessary. This must happen after the
3026 // interstitial page is cleared above, since the call to
3027 // SetRWHViewForInnerContents below may loop over all the
3028 // RenderWidgetHostViews in the tree (otherwise, including the now-deleted
3029 // view for the interstitial).
lfg1453e412017-04-11 00:48:503030 if (node_.OuterContentsFrameTreeNode()) {
3031 if (GetRenderManager()->GetProxyToOuterDelegate()) {
3032 DCHECK(static_cast<RenderWidgetHostViewBase*>(
3033 GetRenderManager()->current_frame_host()->GetView())
3034 ->IsRenderWidgetHostViewChildFrame());
3035 RenderWidgetHostViewChildFrame* view =
3036 static_cast<RenderWidgetHostViewChildFrame*>(
3037 GetRenderManager()->current_frame_host()->GetView());
3038 GetRenderManager()->SetRWHViewForInnerContents(view);
3039 }
3040 }
3041
clamy44e84ce2016-02-22 15:38:253042 // Restart the throbber if needed now that the interstitial page is going
3043 // away.
3044 if (interstitial_pausing_throbber && frame_tree_.IsLoading())
3045 LoadingStateChanged(true, true, nullptr);
[email protected]20ca0382013-02-28 19:50:073046}
3047
avi2b177592014-12-10 02:08:023048void WebContentsImpl::SetHistoryOffsetAndLength(int history_offset,
3049 int history_length) {
alexmos136fd6e62016-08-15 20:58:413050 SendPageMessage(new PageMsg_SetHistoryOffsetAndLength(
3051 MSG_ROUTING_NONE, history_offset, history_length));
avi2b177592014-12-10 02:08:023052}
3053
3054void WebContentsImpl::SetHistoryOffsetAndLengthForView(
3055 RenderViewHost* render_view_host,
3056 int history_offset,
3057 int history_length) {
alexmos136fd6e62016-08-15 20:58:413058 render_view_host->Send(new PageMsg_SetHistoryOffsetAndLength(
avi2b177592014-12-10 02:08:023059 render_view_host->GetRoutingID(), history_offset, history_length));
[email protected]796931a92011-08-10 01:32:143060}
3061
toyoshim24a4c7ab2016-04-05 09:24:143062void WebContentsImpl::ReloadFocusedFrame(bool bypass_cache) {
[email protected]1f3fc1d2014-04-03 14:50:173063 RenderFrameHost* focused_frame = GetFocusedFrame();
3064 if (!focused_frame)
3065 return;
3066
[email protected]959be4c2014-04-08 15:01:333067 focused_frame->Send(new FrameMsg_Reload(
toyoshim24a4c7ab2016-04-05 09:24:143068 focused_frame->GetRoutingID(), bypass_cache));
[email protected]959be4c2014-04-08 15:01:333069}
3070
megjablon3f5941072016-02-04 23:27:523071void WebContentsImpl::ReloadLoFiImages() {
3072 SendToAllFrames(new FrameMsg_ReloadLoFiImages(MSG_ROUTING_NONE));
3073}
3074
[email protected]959be4c2014-04-08 15:01:333075void WebContentsImpl::Undo() {
Dave Tapuskab336b922017-07-06 19:24:053076 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333077 if (!focused_frame)
3078 return;
3079
dtapuska9d46ef7d2017-05-26 19:06:063080 focused_frame->GetFrameInputHandler()->Undo();
[email protected]959be4c2014-04-08 15:01:333081 RecordAction(base::UserMetricsAction("Undo"));
3082}
3083
3084void WebContentsImpl::Redo() {
Dave Tapuskab336b922017-07-06 19:24:053085 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333086 if (!focused_frame)
3087 return;
dtapuska9d46ef7d2017-05-26 19:06:063088 focused_frame->GetFrameInputHandler()->Redo();
[email protected]959be4c2014-04-08 15:01:333089 RecordAction(base::UserMetricsAction("Redo"));
3090}
3091
3092void WebContentsImpl::Cut() {
Dave Tapuskab336b922017-07-06 19:24:053093 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333094 if (!focused_frame)
3095 return;
3096
dtapuska9d46ef7d2017-05-26 19:06:063097 focused_frame->GetFrameInputHandler()->Cut();
[email protected]959be4c2014-04-08 15:01:333098 RecordAction(base::UserMetricsAction("Cut"));
3099}
3100
3101void WebContentsImpl::Copy() {
Dave Tapuskab336b922017-07-06 19:24:053102 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333103 if (!focused_frame)
3104 return;
3105
dtapuska9d46ef7d2017-05-26 19:06:063106 focused_frame->GetFrameInputHandler()->Copy();
[email protected]959be4c2014-04-08 15:01:333107 RecordAction(base::UserMetricsAction("Copy"));
3108}
3109
3110void WebContentsImpl::CopyToFindPboard() {
3111#if defined(OS_MACOSX)
Dave Tapuskab336b922017-07-06 19:24:053112 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333113 if (!focused_frame)
3114 return;
3115
3116 // Windows/Linux don't have the concept of a find pasteboard.
dtapuska9d46ef7d2017-05-26 19:06:063117 focused_frame->GetFrameInputHandler()->CopyToFindPboard();
[email protected]959be4c2014-04-08 15:01:333118 RecordAction(base::UserMetricsAction("CopyToFindPboard"));
3119#endif
3120}
3121
3122void WebContentsImpl::Paste() {
Dave Tapuskab336b922017-07-06 19:24:053123 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333124 if (!focused_frame)
3125 return;
3126
dtapuska9d46ef7d2017-05-26 19:06:063127 focused_frame->GetFrameInputHandler()->Paste();
[email protected]959be4c2014-04-08 15:01:333128 RecordAction(base::UserMetricsAction("Paste"));
3129}
3130
3131void WebContentsImpl::PasteAndMatchStyle() {
Dave Tapuskab336b922017-07-06 19:24:053132 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333133 if (!focused_frame)
3134 return;
3135
dtapuska9d46ef7d2017-05-26 19:06:063136 focused_frame->GetFrameInputHandler()->PasteAndMatchStyle();
[email protected]959be4c2014-04-08 15:01:333137 RecordAction(base::UserMetricsAction("PasteAndMatchStyle"));
3138}
3139
3140void WebContentsImpl::Delete() {
Dave Tapuskab336b922017-07-06 19:24:053141 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333142 if (!focused_frame)
3143 return;
3144
dtapuska9d46ef7d2017-05-26 19:06:063145 focused_frame->GetFrameInputHandler()->Delete();
[email protected]959be4c2014-04-08 15:01:333146 RecordAction(base::UserMetricsAction("DeleteSelection"));
3147}
3148
3149void WebContentsImpl::SelectAll() {
Dave Tapuskab336b922017-07-06 19:24:053150 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333151 if (!focused_frame)
3152 return;
3153
dtapuska9d46ef7d2017-05-26 19:06:063154 focused_frame->GetFrameInputHandler()->SelectAll();
[email protected]959be4c2014-04-08 15:01:333155 RecordAction(base::UserMetricsAction("SelectAll"));
3156}
3157
yabinh351e7ec2017-03-10 02:43:243158void WebContentsImpl::CollapseSelection() {
Dave Tapuskab336b922017-07-06 19:24:053159 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]959be4c2014-04-08 15:01:333160 if (!focused_frame)
3161 return;
3162
dtapuska9d46ef7d2017-05-26 19:06:063163 focused_frame->GetFrameInputHandler()->CollapseSelection();
[email protected]1f3fc1d2014-04-03 14:50:173164}
3165
3166void WebContentsImpl::Replace(const base::string16& word) {
Dave Tapuskab336b922017-07-06 19:24:053167 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]1f3fc1d2014-04-03 14:50:173168 if (!focused_frame)
3169 return;
3170
dtapuska9d46ef7d2017-05-26 19:06:063171 focused_frame->GetFrameInputHandler()->Replace(word);
[email protected]1f3fc1d2014-04-03 14:50:173172}
3173
3174void WebContentsImpl::ReplaceMisspelling(const base::string16& word) {
Dave Tapuskab336b922017-07-06 19:24:053175 RenderFrameHostImpl* focused_frame = GetFocusedFrame();
[email protected]1f3fc1d2014-04-03 14:50:173176 if (!focused_frame)
3177 return;
3178
dtapuska9d46ef7d2017-05-26 19:06:063179 focused_frame->GetFrameInputHandler()->ReplaceMisspelling(word);
[email protected]959be4c2014-04-08 15:01:333180}
3181
3182void WebContentsImpl::NotifyContextMenuClosed(
3183 const CustomContextMenuContext& context) {
3184 RenderFrameHost* focused_frame = GetFocusedFrame();
3185 if (!focused_frame)
3186 return;
3187
3188 focused_frame->Send(new FrameMsg_ContextMenuClosed(
3189 focused_frame->GetRoutingID(), context));
3190}
3191
3192void WebContentsImpl::ExecuteCustomContextMenuCommand(
3193 int action, const CustomContextMenuContext& context) {
3194 RenderFrameHost* focused_frame = GetFocusedFrame();
3195 if (!focused_frame)
3196 return;
3197
3198 focused_frame->Send(new FrameMsg_CustomContextMenuAction(
3199 focused_frame->GetRoutingID(), context, action));
[email protected]4fed3702014-04-01 09:08:003200}
3201
[email protected]fc2b46b2014-05-03 16:33:453202gfx::NativeView WebContentsImpl::GetNativeView() {
3203 return view_->GetNativeView();
3204}
3205
3206gfx::NativeView WebContentsImpl::GetContentNativeView() {
3207 return view_->GetContentNativeView();
3208}
3209
3210gfx::NativeWindow WebContentsImpl::GetTopLevelNativeWindow() {
3211 return view_->GetTopLevelNativeWindow();
3212}
3213
3214gfx::Rect WebContentsImpl::GetViewBounds() {
3215 return view_->GetViewBounds();
3216}
3217
3218gfx::Rect WebContentsImpl::GetContainerBounds() {
3219 gfx::Rect rv;
3220 view_->GetContainerBounds(&rv);
3221 return rv;
3222}
3223
3224DropData* WebContentsImpl::GetDropData() {
3225 return view_->GetDropData();
3226}
3227
3228void WebContentsImpl::Focus() {
miu9e14e492014-10-25 02:39:043229 view_->Focus();
[email protected]fc2b46b2014-05-03 16:33:453230}
3231
3232void WebContentsImpl::SetInitialFocus() {
miu9e14e492014-10-25 02:39:043233 view_->SetInitialFocus();
[email protected]fc2b46b2014-05-03 16:33:453234}
3235
3236void WebContentsImpl::StoreFocus() {
miu9e14e492014-10-25 02:39:043237 view_->StoreFocus();
[email protected]fc2b46b2014-05-03 16:33:453238}
3239
3240void WebContentsImpl::RestoreFocus() {
miu9e14e492014-10-25 02:39:043241 view_->RestoreFocus();
[email protected]fc2b46b2014-05-03 16:33:453242}
3243
[email protected]b172aee2012-04-10 17:05:263244void WebContentsImpl::FocusThroughTabTraversal(bool reverse) {
[email protected]0bfbf882011-12-22 18:19:273245 if (ShowingInterstitialPage()) {
creisadca9862017-06-16 19:12:113246 interstitial_page_->FocusThroughTabTraversal(reverse);
[email protected]7e383692009-06-12 19:14:543247 return;
3248 }
[email protected]0b431992014-06-24 00:08:033249 RenderWidgetHostView* const fullscreen_view =
3250 GetFullscreenRenderWidgetHostView();
3251 if (fullscreen_view) {
3252 fullscreen_view->Focus();
3253 return;
3254 }
creisc014b402015-04-23 16:41:453255 GetRenderViewHost()->SetInitialFocus(reverse);
[email protected]96d185d2009-04-24 03:28:543256}
3257
[email protected]b172aee2012-04-10 17:05:263258bool WebContentsImpl::ShowingInterstitialPage() const {
creisadca9862017-06-16 19:12:113259 return interstitial_page_ != nullptr;
[email protected]96d185d2009-04-24 03:28:543260}
3261
Pete Williamson89aa1402017-07-07 19:58:413262void WebContentsImpl::AdjustPreviewsStateForNavigation(
3263 PreviewsState* previews_state) {
3264 if (delegate_)
3265 delegate_->AdjustPreviewsStateForNavigation(previews_state);
3266}
3267
[email protected]b172aee2012-04-10 17:05:263268InterstitialPage* WebContentsImpl::GetInterstitialPage() const {
creisadca9862017-06-16 19:12:113269 return interstitial_page_;
[email protected]686493142011-07-15 21:47:223270}
3271
[email protected]b172aee2012-04-10 17:05:263272bool WebContentsImpl::IsSavable() {
[email protected]a53209b2012-01-20 16:48:163273 // WebKit creates Document object when MIME type is application/xhtml+xml,
3274 // so we also support this MIME type.
3275 return contents_mime_type_ == "text/html" ||
3276 contents_mime_type_ == "text/xml" ||
3277 contents_mime_type_ == "application/xhtml+xml" ||
3278 contents_mime_type_ == "text/plain" ||
3279 contents_mime_type_ == "text/css" ||
Kinuko Yasuda74702f92017-07-31 03:27:533280 blink::IsSupportedJavascriptMimeType(contents_mime_type_);
[email protected]a53209b2012-01-20 16:48:163281}
3282
[email protected]b172aee2012-04-10 17:05:263283void WebContentsImpl::OnSavePage() {
[email protected]c7dd2f62011-07-18 15:57:593284 // If we can not save the page, try to download it.
[email protected]a53209b2012-01-20 16:48:163285 if (!IsSavable()) {
[email protected]35869622012-10-26 23:23:553286 RecordDownloadSource(INITIATED_BY_SAVE_PACKAGE_ON_NON_HTML);
nasko89ad7742015-03-05 22:14:193287 SaveFrame(GetLastCommittedURL(), Referrer());
[email protected]27678b2a2012-02-04 22:09:143288 return;
[email protected]c7dd2f62011-07-18 15:57:593289 }
3290
3291 Stop();
3292
3293 // Create the save package and possibly prompt the user for the name to save
3294 // the page as. The user prompt is an asynchronous operation that runs on
3295 // another thread.
3296 save_package_ = new SavePackage(this);
3297 save_package_->GetSaveInfo();
3298}
3299
3300// Used in automated testing to bypass prompting the user for file names.
3301// Instead, the names and paths are hard coded rather than running them through
3302// file name sanitation and extension / mime checking.
[email protected]2dec8ec2013-02-07 19:20:343303bool WebContentsImpl::SavePage(const base::FilePath& main_file,
3304 const base::FilePath& dir_path,
[email protected]8ff00d72012-10-23 19:12:213305 SavePageType save_type) {
[email protected]c7dd2f62011-07-18 15:57:593306 // Stop the page from navigating.
3307 Stop();
3308
3309 save_package_ = new SavePackage(this, save_type, main_file, dir_path);
[email protected]8ff00d72012-10-23 19:12:213310 return save_package_->Init(SavePackageDownloadCreatedCallback());
[email protected]c7dd2f62011-07-18 15:57:593311}
3312
[email protected]3c71576ce2013-07-23 02:00:013313void WebContentsImpl::SaveFrame(const GURL& url,
3314 const Referrer& referrer) {
kundaji6c7f9692015-03-09 18:00:373315 SaveFrameWithHeaders(url, referrer, std::string());
3316}
3317
3318void WebContentsImpl::SaveFrameWithHeaders(const GURL& url,
3319 const Referrer& referrer,
3320 const std::string& headers) {
nasko89ad7742015-03-05 22:14:193321 if (!GetLastCommittedURL().is_valid())
[email protected]3c71576ce2013-07-23 02:00:013322 return;
sammc92af61552014-11-19 23:27:403323 if (delegate_ && delegate_->SaveFrame(url, referrer))
3324 return;
3325
nasko89ad7742015-03-05 22:14:193326 // TODO(nasko): This check for main frame is incorrect and should be fixed
brettw760f7442016-05-23 21:19:223327 // by explicitly passing in which frame this method should target. This would
3328 // indicate whether it's the main frame, and also tell us the frame pointer
3329 // to use for routing.
nasko89ad7742015-03-05 22:14:193330 bool is_main_frame = (url == GetLastCommittedURL());
brettw760f7442016-05-23 21:19:223331 RenderFrameHost* frame_host = GetMainFrame();
[email protected]3c71576ce2013-07-23 02:00:013332
brettw760f7442016-05-23 21:19:223333 StoragePartition* storage_partition = BrowserContext::GetStoragePartition(
3334 GetBrowserContext(), frame_host->GetSiteInstance());
avib7348942015-12-25 20:57:103335 int64_t post_id = -1;
[email protected]3c71576ce2013-07-23 02:00:013336 if (is_main_frame) {
[email protected]6286a372013-10-09 04:03:273337 const NavigationEntry* entry = controller_.GetLastCommittedEntry();
[email protected]3c71576ce2013-07-23 02:00:013338 if (entry)
3339 post_id = entry->GetPostID();
3340 }
Ramin Halavati24e21012017-07-10 12:56:063341 net::NetworkTrafficAnnotationTag traffic_annotation =
3342 net::DefineNetworkTrafficAnnotation("download_web_contents_frame", R"(
3343 semantics {
3344 sender: "Save Page Action"
3345 description:
3346 "Saves the given frame's URL to the local file system."
3347 trigger:
3348 "The user has triggered a save operation on the frame through a "
3349 "context menu or other mechanism."
3350 data: "None."
3351 destination: WEBSITE
3352 }
3353 policy {
Ramin Halavati3b979782017-07-21 11:40:263354 cookies_allowed: YES
Ramin Halavati24e21012017-07-10 12:56:063355 cookies_store: "user"
3356 setting:
3357 "This feature cannot be disabled by settings, but it's is only "
3358 "triggered by user request."
3359 policy_exception_justification: "Not implemented."
3360 })");
thestig859c78892017-05-15 21:17:063361 auto params = base::MakeUnique<DownloadUrlParameters>(
brettw760f7442016-05-23 21:19:223362 url, frame_host->GetProcess()->GetID(),
3363 frame_host->GetRenderViewHost()->GetRoutingID(),
Ramin Halavati03efa732017-06-12 09:28:203364 frame_host->GetRoutingID(), storage_partition->GetURLRequestContext(),
Ramin Halavati24e21012017-07-10 12:56:063365 traffic_annotation);
[email protected]3c71576ce2013-07-23 02:00:013366 params->set_referrer(referrer);
3367 params->set_post_id(post_id);
[email protected]3c71576ce2013-07-23 02:00:013368 if (post_id >= 0)
3369 params->set_method("POST");
3370 params->set_prompt(true);
kundaji6c7f9692015-03-09 18:00:373371
3372 if (headers.empty()) {
3373 params->set_prefer_cache(true);
3374 } else {
Megan Jablonski2f6a4c52017-07-10 23:01:253375 for (DownloadUrlParameters::RequestHeadersNameValuePair key_value :
3376 ParseDownloadHeaders(headers)) {
3377 params->add_request_header(key_value.first, key_value.second);
kundaji6c7f9692015-03-09 18:00:373378 }
3379 }
thestig859c78892017-05-15 21:17:063380 BrowserContext::GetDownloadManager(GetBrowserContext())
Ramin Halavati03efa732017-06-12 09:28:203381 ->DownloadUrl(std::move(params));
[email protected]3c71576ce2013-07-23 02:00:013382}
3383
[email protected]b172aee2012-04-10 17:05:263384void WebContentsImpl::GenerateMHTML(
dewittj6dc5747a2016-05-17 01:48:473385 const MHTMLGenerationParams& params,
avib7348942015-12-25 20:57:103386 const base::Callback<void(int64_t)>& callback) {
dewittj6dc5747a2016-05-17 01:48:473387 MHTMLGenerationManager::GetInstance()->SaveMHTML(this, params, callback);
[email protected]aa4f3972012-03-01 18:12:123388}
3389
[email protected]b172aee2012-04-10 17:05:263390const std::string& WebContentsImpl::GetContentsMimeType() const {
[email protected]0bfbf882011-12-22 18:19:273391 return contents_mime_type_;
3392}
3393
[email protected]b172aee2012-04-10 17:05:263394bool WebContentsImpl::WillNotifyDisconnection() const {
[email protected]0bfbf882011-12-22 18:19:273395 return notify_disconnection_;
3396}
3397
[email protected]8ff00d72012-10-23 19:12:213398RendererPreferences* WebContentsImpl::GetMutableRendererPrefs() {
[email protected]0bfbf882011-12-22 18:19:273399 return &renderer_preferences_;
3400}
3401
[email protected]e35ccd52012-05-23 16:22:473402void WebContentsImpl::Close() {
3403 Close(GetRenderViewHost());
3404}
3405
paulmeyer8fc8ea92016-11-15 05:12:213406void WebContentsImpl::DragSourceEndedAt(int client_x,
3407 int client_y,
3408 int screen_x,
3409 int screen_y,
Paul Meyer0c58c3712016-11-17 22:59:513410 blink::WebDragOperation operation,
3411 RenderWidgetHost* source_rwh) {
[email protected]cf200a562013-05-03 16:24:293412 if (browser_plugin_embedder_.get())
paulmeyer8fc8ea92016-11-15 05:12:213413 browser_plugin_embedder_->DragSourceEndedAt(
3414 client_x, client_y, screen_x, screen_y, operation);
Paul Meyer0c58c3712016-11-17 22:59:513415 if (source_rwh) {
3416 source_rwh->DragSourceEndedAt(gfx::Point(client_x, client_y),
3417 gfx::Point(screen_x, screen_y),
3418 operation);
3419 }
[email protected]cf200a562013-05-03 16:24:293420}
3421
jam73f892642016-09-11 06:04:063422void WebContentsImpl::LoadStateChanged(
3423 const GURL& url,
3424 const net::LoadStateWithParam& load_state,
3425 uint64_t upload_position,
3426 uint64_t upload_size) {
3427 // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466285
3428 // is fixed.
3429 tracked_objects::ScopedTracker tracking_profile1(
3430 FROM_HERE_WITH_EXPLICIT_FUNCTION(
3431 "466285 WebContentsImpl::LoadStateChanged::Start"));
3432 load_state_ = load_state;
3433 upload_position_ = upload_position;
3434 upload_size_ = upload_size;
3435 load_state_host_ = url_formatter::IDNToUnicode(url.host());
3436 if (load_state_.state == net::LOAD_STATE_READING_RESPONSE)
3437 SetNotWaitingForResponse();
3438 if (IsLoading()) {
3439 NotifyNavigationStateChanged(static_cast<InvalidateTypes>(
3440 INVALIDATE_TYPE_LOAD | INVALIDATE_TYPE_TAB));
3441 }
3442}
3443
[email protected]d60f3702013-12-26 16:30:243444void WebContentsImpl::DidGetResourceResponseStart(
3445 const ResourceRequestDetails& details) {
Evan Stade38e4aee62017-08-23 17:06:183446 SetNotWaitingForResponse();
estarkf83ac122016-10-05 19:06:063447 controller_.ssl_manager()->DidStartResourceResponse(
3448 details.url, details.has_certificate, details.ssl_cert_status);
[email protected]d60f3702013-12-26 16:30:243449
ericwilligersde386342016-10-19 02:35:093450 for (auto& observer : observers_)
3451 observer.DidGetResourceResponseStart(details);
[email protected]d60f3702013-12-26 16:30:243452}
3453
3454void WebContentsImpl::DidGetRedirectForResourceRequest(
[email protected]d60f3702013-12-26 16:30:243455 const ResourceRedirectDetails& details) {
ericwilligersde386342016-10-19 02:35:093456 for (auto& observer : observers_)
3457 observer.DidGetRedirectForResourceRequest(details);
[email protected]d60f3702013-12-26 16:30:243458
3459 // TODO(avi): Remove. http://crbug.com/170921
3460 NotificationService::current()->Notify(
3461 NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
3462 Source<WebContents>(this),
3463 Details<const ResourceRedirectDetails>(&details));
3464}
3465
Michael Thiessen896405db2017-07-20 17:52:323466void WebContentsImpl::NotifyWebContentsFocused(
3467 RenderWidgetHost* render_widget_host) {
ericwilligersde386342016-10-19 02:35:093468 for (auto& observer : observers_)
Michael Thiessen896405db2017-07-20 17:52:323469 observer.OnWebContentsFocused(render_widget_host);
calamity7fe55ce2015-04-10 03:59:373470}
3471
Michael Thiessen896405db2017-07-20 17:52:323472void WebContentsImpl::NotifyWebContentsLostFocus(
3473 RenderWidgetHost* render_widget_host) {
zijiehe3bee08e22017-05-17 04:14:463474 for (auto& observer : observers_)
Michael Thiessen896405db2017-07-20 17:52:323475 observer.OnWebContentsLostFocus(render_widget_host);
zijiehe3bee08e22017-05-17 04:14:463476}
3477
Paul Meyer0c58c3712016-11-17 22:59:513478void WebContentsImpl::SystemDragEnded(RenderWidgetHost* source_rwh) {
3479 if (source_rwh)
3480 source_rwh->DragSourceSystemDragEnded();
[email protected]cf200a562013-05-03 16:24:293481 if (browser_plugin_embedder_.get())
3482 browser_plugin_embedder_->SystemDragEnded();
[email protected]7813bd72011-02-05 02:19:343483}
3484
[email protected]e35ccd52012-05-23 16:22:473485void WebContentsImpl::UserGestureDone() {
dominickn9c7ceaa32016-02-27 01:52:533486 OnUserInteraction(GetRenderViewHost()->GetWidget(),
Blink Reformat1c4d759e2017-04-09 16:34:543487 blink::WebInputEvent::kUndefined);
[email protected]e35ccd52012-05-23 16:22:473488}
3489
[email protected]b172aee2012-04-10 17:05:263490void WebContentsImpl::SetClosedByUserGesture(bool value) {
[email protected]0bfbf882011-12-22 18:19:273491 closed_by_user_gesture_ = value;
3492}
3493
[email protected]b172aee2012-04-10 17:05:263494bool WebContentsImpl::GetClosedByUserGesture() const {
[email protected]0bfbf882011-12-22 18:19:273495 return closed_by_user_gesture_;
3496}
3497
[email protected]b172aee2012-04-10 17:05:263498void WebContentsImpl::ViewSource() {
[email protected]1788e772010-12-15 16:40:503499 if (!delegate_)
3500 return;
3501
[email protected]6286a372013-10-09 04:03:273502 NavigationEntry* entry = GetController().GetLastCommittedEntry();
3503 if (!entry)
[email protected]1788e772010-12-15 16:40:503504 return;
3505
[email protected]6286a372013-10-09 04:03:273506 delegate_->ViewSourceForTab(this, entry->GetURL());
[email protected]77d8d622010-12-15 10:30:123507}
3508
[email protected]b172aee2012-04-10 17:05:263509void WebContentsImpl::ViewFrameSource(const GURL& url,
[email protected]691aa2f2013-05-28 22:52:043510 const PageState& page_state) {
[email protected]932b7a12011-03-09 12:50:273511 if (!delegate_)
3512 return;
3513
[email protected]691aa2f2013-05-28 22:52:043514 delegate_->ViewSourceForFrame(this, url, page_state);
[email protected]932b7a12011-03-09 12:50:273515}
3516
[email protected]b172aee2012-04-10 17:05:263517int WebContentsImpl::GetMinimumZoomPercent() const {
[email protected]0bfbf882011-12-22 18:19:273518 return minimum_zoom_percent_;
3519}
3520
[email protected]b172aee2012-04-10 17:05:263521int WebContentsImpl::GetMaximumZoomPercent() const {
[email protected]0bfbf882011-12-22 18:19:273522 return maximum_zoom_percent_;
3523}
3524
mcnee432e47d2015-11-09 19:37:463525void WebContentsImpl::SetPageScale(float page_scale_factor) {
davidsac996be112016-11-30 08:56:383526 Send(new ViewMsg_SetPageScale(GetRenderViewHost()->GetRoutingID(),
3527 page_scale_factor));
ccameronb7c1d6c2015-03-09 17:08:243528}
3529
[email protected]b172aee2012-04-10 17:05:263530gfx::Size WebContentsImpl::GetPreferredSize() const {
[email protected]222f5822014-02-05 23:40:493531 return capturer_count_ == 0 ? preferred_size_ : preferred_size_for_capture_;
[email protected]bcd2815602012-01-14 18:17:233532}
3533
[email protected]b172aee2012-04-10 17:05:263534bool WebContentsImpl::GotResponseToLockMouseRequest(bool allowed) {
lfgf0cd46e2017-01-04 00:05:233535 if (!GuestMode::IsCrossProcessFrameGuest(GetWebContents()) &&
3536 GetBrowserPluginGuest())
[email protected]660f18e2014-05-15 20:53:053537 return GetBrowserPluginGuest()->LockMouse(allowed);
3538
lfgf0cd46e2017-01-04 00:05:233539 if (mouse_lock_widget_) {
3540 if (mouse_lock_widget_->delegate()->GetAsWebContents() != this) {
3541 return mouse_lock_widget_->delegate()
3542 ->GetAsWebContents()
3543 ->GotResponseToLockMouseRequest(allowed);
3544 }
lfgad8244352016-07-13 16:55:513545
lfgf0cd46e2017-01-04 00:05:233546 if (mouse_lock_widget_->GotResponseToLockMouseRequest(allowed))
3547 return true;
3548 }
3549
3550 for (WebContentsImpl* current = this; current;
3551 current = current->GetOuterWebContents()) {
3552 current->mouse_lock_widget_ = nullptr;
3553 }
3554
lfgbee1e0a2016-06-08 21:24:213555 return false;
[email protected]0bfbf882011-12-22 18:19:273556}
3557
[email protected]b172aee2012-04-10 17:05:263558bool WebContentsImpl::HasOpener() const {
alexmose201c7cd2015-06-10 17:14:213559 return GetOpener() != NULL;
[email protected]a0358d72012-03-09 14:06:503560}
3561
lukasza6f8ac622017-06-06 03:10:203562RenderFrameHostImpl* WebContentsImpl::GetOpener() const {
alexmose201c7cd2015-06-10 17:14:213563 FrameTreeNode* opener_ftn = frame_tree_.root()->opener();
lukasza6f8ac622017-06-06 03:10:203564 return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
jochen55ff3502014-12-18 20:52:573565}
3566
jochen6004a362017-02-04 00:11:403567bool WebContentsImpl::HasOriginalOpener() const {
3568 return GetOriginalOpener() != NULL;
3569}
3570
lukasza6f8ac622017-06-06 03:10:203571RenderFrameHostImpl* WebContentsImpl::GetOriginalOpener() const {
jochen6004a362017-02-04 00:11:403572 FrameTreeNode* opener_ftn = frame_tree_.root()->original_opener();
lukasza6f8ac622017-06-06 03:10:203573 return opener_ftn ? opener_ftn->current_frame_host() : nullptr;
jochen6004a362017-02-04 00:11:403574}
3575
[email protected]cb805452013-05-22 15:16:213576void WebContentsImpl::DidChooseColorInColorChooser(SkColor color) {
[email protected]8ed16472014-04-11 19:02:483577 if (!color_chooser_info_.get())
3578 return;
3579 RenderFrameHost* rfh = RenderFrameHost::FromID(
3580 color_chooser_info_->render_process_id,
3581 color_chooser_info_->render_frame_id);
3582 if (!rfh)
3583 return;
3584
3585 rfh->Send(new FrameMsg_DidChooseColorResponse(
3586 rfh->GetRoutingID(), color_chooser_info_->identifier, color));
[email protected]da8543762012-03-20 08:52:203587}
3588
[email protected]cb805452013-05-22 15:16:213589void WebContentsImpl::DidEndColorChooser() {
[email protected]8ed16472014-04-11 19:02:483590 if (!color_chooser_info_.get())
3591 return;
3592 RenderFrameHost* rfh = RenderFrameHost::FromID(
3593 color_chooser_info_->render_process_id,
3594 color_chooser_info_->render_frame_id);
3595 if (!rfh)
3596 return;
3597
3598 rfh->Send(new FrameMsg_DidEndColorChooser(
3599 rfh->GetRoutingID(), color_chooser_info_->identifier));
3600 color_chooser_info_.reset();
[email protected]da8543762012-03-20 08:52:203601}
3602
halton.huoca2eabd2015-07-06 08:17:403603int WebContentsImpl::DownloadImage(
3604 const GURL& url,
3605 bool is_favicon,
3606 uint32_t max_bitmap_size,
3607 bool bypass_cache,
3608 const WebContents::ImageDownloadCallback& callback) {
amistry9f01b772015-07-29 01:54:553609 DCHECK_CURRENTLY_ON(BrowserThread::UI);
halton.huoca2eabd2015-07-06 08:17:403610 static int next_image_download_id = 0;
leon.han6e9dee22016-02-25 03:44:063611 const content::mojom::ImageDownloaderPtr& mojo_image_downloader =
halton.huoca2eabd2015-07-06 08:17:403612 GetMainFrame()->GetMojoImageDownloader();
amistry9f01b772015-07-29 01:54:553613 const int download_id = ++next_image_download_id;
3614 if (!mojo_image_downloader) {
3615 // If the renderer process is dead (i.e. crash, or memory pressure on
3616 // Android), the downloader service will be invalid. Pre-Mojo, this would
3617 // hang the callback indefinetly since the IPC would be dropped. Now,
3618 // respond with a 400 HTTP error code to indicate that something went wrong.
3619 BrowserThread::PostTask(
3620 BrowserThread::UI, FROM_HERE,
pkotwicz75ca8ffd2016-02-16 23:10:193621 base::Bind(&WebContentsImpl::OnDidDownloadImage,
leon.hancbc4bc3c2016-02-26 07:08:523622 weak_factory_.GetWeakPtr(), callback, download_id, url, 400,
leon.hanc2228532016-08-16 05:59:183623 std::vector<SkBitmap>(), std::vector<gfx::Size>()));
amistry9f01b772015-07-29 01:54:553624 return download_id;
3625 }
3626
halton.huoca2eabd2015-07-06 08:17:403627 mojo_image_downloader->DownloadImage(
sammcf6f4fcf2016-06-21 05:39:393628 url, is_favicon, max_bitmap_size, bypass_cache,
leon.hancbc4bc3c2016-02-26 07:08:523629 base::Bind(&WebContentsImpl::OnDidDownloadImage,
3630 weak_factory_.GetWeakPtr(), callback, download_id, url));
amistry9f01b772015-07-29 01:54:553631 return download_id;
[email protected]795c28972012-12-06 06:13:393632}
3633
[email protected]5dcaf8e2013-12-28 01:31:423634bool WebContentsImpl::IsSubframe() const {
3635 return is_subframe_;
3636}
3637
[email protected]36ec24f2014-01-09 00:32:083638void WebContentsImpl::Find(int request_id,
3639 const base::string16& search_text,
3640 const blink::WebFindOptions& options) {
thestig6057a6b22015-11-12 23:01:333641 // Cowardly refuse to search for no text.
3642 if (search_text.empty()) {
3643 NOTREACHED();
3644 return;
3645 }
3646
paulmeyerc0b762b2016-04-13 11:55:173647 GetOrCreateFindRequestManager()->Find(request_id, search_text, options);
[email protected]36ec24f2014-01-09 00:32:083648}
3649
3650void WebContentsImpl::StopFinding(StopFindAction action) {
paulmeyerfeafc2d2017-04-25 21:46:403651 if (FindRequestManager* manager = GetFindRequestManager())
3652 manager->StopFinding(action);
[email protected]36ec24f2014-01-09 00:32:083653}
3654
dalecurtisbc6572e12014-09-12 19:22:303655bool WebContentsImpl::WasRecentlyAudible() {
wjmaclean1dabf3e32016-05-13 23:34:443656 return audio_stream_monitor_.WasRecentlyAudible() ||
3657 (browser_plugin_embedder_ &&
3658 browser_plugin_embedder_->WereAnyGuestsRecentlyAudible());
dalecurtisbc6572e12014-09-12 19:22:303659}
3660
mlamouriefdca9d2014-09-16 16:55:403661void WebContentsImpl::GetManifest(const GetManifestCallback& callback) {
Sam McNally2299ba02017-06-13 00:58:303662 manifest_manager_host_->GetManifest(callback);
mlamouriefdca9d2014-09-16 16:55:403663}
3664
bokanece34a82016-01-28 19:49:463665void WebContentsImpl::ExitFullscreen(bool will_cause_resize) {
mlamouri7a78d6fd2015-01-17 13:23:533666 // Clean up related state and initiate the fullscreen exit.
avi3627ecac2015-10-16 17:40:433667 GetRenderViewHost()->GetWidget()->RejectMouseLockOrUnlockIfNecessary();
bokanece34a82016-01-28 19:49:463668 ExitFullscreenMode(will_cause_resize);
mlamouri7a78d6fd2015-01-17 13:23:533669}
3670
mariakhomenko44bdc4732015-04-29 01:55:383671void WebContentsImpl::ResumeLoadingCreatedWebContents() {
mariakhomenkoa4971c12015-07-21 19:04:373672 if (delayed_open_url_params_.get()) {
3673 OpenURL(*delayed_open_url_params_.get());
3674 delayed_open_url_params_.reset(nullptr);
3675 return;
3676 }
3677
mariakhomenko44bdc4732015-04-29 01:55:383678 // Resume blocked requests for both the RenderViewHost and RenderFrameHost.
3679 // TODO(brettw): It seems bogus to reach into here and initialize the host.
dfalcantarae6b7b46752015-07-10 18:14:163680 if (is_resume_pending_) {
3681 is_resume_pending_ = false;
avi0f1bbc9712015-11-17 02:58:133682 GetRenderViewHost()->GetWidget()->Init();
dfalcantarae6b7b46752015-07-10 18:14:163683 GetMainFrame()->Init();
3684 }
mariakhomenko44bdc4732015-04-29 01:55:383685}
3686
[email protected]b172aee2012-04-10 17:05:263687bool WebContentsImpl::FocusLocationBarByDefault() {
palmerc70cb1f2016-03-04 23:41:263688 // When the browser is started with about:blank as the startup URL, focus
3689 // the location bar (which will also select its contents) so people can
3690 // simply begin typing to navigate elsewhere.
3691 //
3692 // We need to be careful not to trigger this for anything other than the
3693 // startup navigation. In particular, if we allow an attacker to open a
3694 // popup to about:blank, then navigate, focusing the Omnibox will cause the
3695 // end of the new URL to be scrolled into view instead of the start,
3696 // allowing the attacker to spoof other URLs. The conditions checked here
3697 // are all aimed at ensuring no such attacker-controlled navigation can
3698 // trigger this.
3699 //
3700 // Note that we check the pending entry instead of the visible one; for the
3701 // startup URL case these are the same, but for the attacker-controlled
3702 // navigation case the visible entry is the committed "about:blank" URL and
3703 // the pending entry is the problematic navigation elsewhere.
3704 NavigationEntryImpl* entry = controller_.GetPendingEntry();
3705 if (controller_.IsInitialNavigation() && entry &&
3706 !entry->is_renderer_initiated() &&
csharrisona3bd0b32016-10-19 18:40:483707 entry->GetURL() == url::kAboutBlankURL) {
[email protected]0c9406632013-02-08 01:13:333708 return true;
palmerc70cb1f2016-03-04 23:41:263709 }
[email protected]0c9406632013-02-08 01:13:333710 return delegate_ && delegate_->ShouldFocusLocationBarByDefault(this);
[email protected]0bfbf882011-12-22 18:19:273711}
3712
[email protected]b172aee2012-04-10 17:05:263713void WebContentsImpl::SetFocusToLocationBar(bool select_all) {
[email protected]0bfbf882011-12-22 18:19:273714 if (delegate_)
3715 delegate_->SetFocusToLocationBar(select_all);
[email protected]c40d6232011-03-25 00:16:213716}
3717
clamy0e119882015-07-31 16:12:333718void WebContentsImpl::DidStartNavigation(NavigationHandle* navigation_handle) {
ericwilligersde386342016-10-19 02:35:093719 for (auto& observer : observers_)
3720 observer.DidStartNavigation(navigation_handle);
clamy0e119882015-07-31 16:12:333721}
3722
3723void WebContentsImpl::DidRedirectNavigation(
3724 NavigationHandle* navigation_handle) {
ericwilligersde386342016-10-19 02:35:093725 for (auto& observer : observers_)
3726 observer.DidRedirectNavigation(navigation_handle);
jam5f358e52017-02-13 16:37:033727
3728 // Notify accessibility if this is a reload. This has to called on the
3729 // BrowserAccessibilityManager associated with the old RFHI.
3730 if (navigation_handle->GetReloadType() != ReloadType::NONE) {
3731 NavigationHandleImpl* nhi =
3732 static_cast<NavigationHandleImpl*>(navigation_handle);
3733 BrowserAccessibilityManager* manager =
3734 nhi->frame_tree_node()
3735 ->current_frame_host()
3736 ->browser_accessibility_manager();
3737 if (manager)
3738 manager->UserIsReloading();
3739 }
clamy0e119882015-07-31 16:12:333740}
3741
clamyefca29e2015-09-17 00:22:113742void WebContentsImpl::ReadyToCommitNavigation(
3743 NavigationHandle* navigation_handle) {
ericwilligersde386342016-10-19 02:35:093744 for (auto& observer : observers_)
3745 observer.ReadyToCommitNavigation(navigation_handle);
clamyefca29e2015-09-17 00:22:113746}
3747
clamy0e119882015-07-31 16:12:333748void WebContentsImpl::DidFinishNavigation(NavigationHandle* navigation_handle) {
ericwilligersde386342016-10-19 02:35:093749 for (auto& observer : observers_)
3750 observer.DidFinishNavigation(navigation_handle);
clamy0e119882015-07-31 16:12:333751
jam5f358e52017-02-13 16:37:033752 if (navigation_handle->HasCommitted()) {
dmazzonibf8cec42015-02-08 08:28:083753 BrowserAccessibilityManager* manager =
jam5f358e52017-02-13 16:37:033754 static_cast<RenderFrameHostImpl*>(
3755 navigation_handle->GetRenderFrameHost())
3756 ->browser_accessibility_manager();
3757 if (manager) {
3758 if (navigation_handle->IsErrorPage()) {
3759 manager->NavigationFailed();
3760 } else {
3761 manager->NavigationSucceeded();
3762 }
3763 }
dmazzonibf8cec42015-02-08 08:28:083764 }
[email protected]400992b2012-06-14 00:03:543765}
3766
[email protected]b80624c2014-02-09 02:46:553767void WebContentsImpl::DidFailLoadWithError(
3768 RenderFrameHostImpl* render_frame_host,
[email protected]b80624c2014-02-09 02:46:553769 const GURL& url,
[email protected]b80624c2014-02-09 02:46:553770 int error_code,
Yutaka Hirano16d3c5d2017-07-31 06:17:303771 const base::string16& error_description) {
ericwilligersde386342016-10-19 02:35:093772 for (auto& observer : observers_) {
Yutaka Hirano16d3c5d2017-07-31 06:17:303773 observer.DidFailLoad(render_frame_host, url, error_code, error_description);
ericwilligersde386342016-10-19 02:35:093774 }
[email protected]b80624c2014-02-09 02:46:553775}
3776
[email protected]52913802013-12-10 05:52:183777void WebContentsImpl::NotifyChangedNavigationState(
3778 InvalidateTypes changed_flags) {
3779 NotifyNavigationStateChanged(changed_flags);
3780}
3781
toyoshim0df1d3a2016-09-09 09:52:483782void WebContentsImpl::DidStartNavigationToPendingEntry(const GURL& url,
3783 ReloadType reload_type) {
[email protected]3691e5cf2014-01-22 10:16:203784 // Notify observers about navigation.
ericwilligersde386342016-10-19 02:35:093785 for (auto& observer : observers_)
3786 observer.DidStartNavigationToPendingEntry(url, reload_type);
[email protected]3691e5cf2014-01-22 10:16:203787}
3788
lukasza1d025732016-09-28 21:36:083789bool WebContentsImpl::ShouldTransferNavigation(bool is_main_frame_navigation) {
creis29460272015-12-16 04:38:223790 if (!delegate_)
3791 return true;
lukasza1d025732016-09-28 21:36:083792 return delegate_->ShouldTransferNavigation(is_main_frame_navigation);
creis29460272015-12-16 04:38:223793}
3794
[email protected]aa62afd2014-04-22 19:22:463795bool WebContentsImpl::ShouldPreserveAbortedURLs() {
3796 if (!delegate_)
3797 return false;
3798 return delegate_->ShouldPreserveAbortedURLs(this);
3799}
3800
[email protected]0d0f4c492014-04-02 06:42:573801void WebContentsImpl::DidNavigateMainFramePreCommit(
[email protected]5cfbddc2014-06-23 23:52:233802 bool navigation_is_within_page) {
[email protected]0d0f4c492014-04-02 06:42:573803 // Ensure fullscreen mode is exited before committing the navigation to a
3804 // different page. The next page will not start out assuming it is in
3805 // fullscreen mode.
[email protected]5cfbddc2014-06-23 23:52:233806 if (navigation_is_within_page) {
[email protected]dfc39cb2014-04-09 22:58:193807 // No page change? Then, the renderer and browser can remain in fullscreen.
[email protected]0d0f4c492014-04-02 06:42:573808 return;
3809 }
alexmos5dd617d2016-06-07 04:21:153810 if (IsFullscreenForCurrentTab())
bokanece34a82016-01-28 19:49:463811 ExitFullscreen(false);
alexmos5dd617d2016-06-07 04:21:153812 DCHECK(!IsFullscreenForCurrentTab());
[email protected]0d0f4c492014-04-02 06:42:573813}
3814
[email protected]37567b432014-02-12 01:12:223815void WebContentsImpl::DidNavigateMainFramePostCommit(
sky8b00392d2015-01-10 00:30:283816 RenderFrameHostImpl* render_frame_host,
[email protected]37567b432014-02-12 01:12:223817 const LoadCommittedDetails& details,
3818 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
3819 if (details.is_navigation_to_different_page()) {
3820 // Clear the status bubble. This is a workaround for a bug where WebKit
3821 // doesn't let us know that the cursor left an element during a
3822 // transition (this is also why the mouse cursor remains as a hand after
3823 // clicking on a link); see bugs 1184641 and 980803. We don't want to
3824 // clear the bubble when a user navigates to a named anchor in the same
3825 // page.
sky8b00392d2015-01-10 00:30:283826 UpdateTargetURL(render_frame_host->GetRenderViewHost(), GURL());
lanwei9d343ad22015-02-11 01:46:003827
3828 RenderWidgetHostViewBase* rwhvb =
3829 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
3830 if (rwhvb)
3831 rwhvb->OnDidNavigateMainFrameToNewPage();
yusufod41c5f92015-03-06 00:14:283832
peter90afaba2015-06-01 12:05:293833 did_first_visually_non_empty_paint_ = false;
3834
yusufod41c5f92015-03-06 00:14:283835 // Reset theme color on navigation to new page.
3836 theme_color_ = SK_ColorTRANSPARENT;
[email protected]37567b432014-02-12 01:12:223837 }
3838
[email protected]e85165c642014-06-10 14:34:313839 if (delegate_)
[email protected]37567b432014-02-12 01:12:223840 delegate_->DidNavigateMainFramePostCommit(this);
[email protected]e85165c642014-06-10 14:34:313841 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]37567b432014-02-12 01:12:223842}
3843
3844void WebContentsImpl::DidNavigateAnyFramePostCommit(
3845 RenderFrameHostImpl* render_frame_host,
3846 const LoadCommittedDetails& details,
3847 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
[email protected]b4c84012014-04-28 19:51:103848 // Now that something has committed, we don't need to track whether the
3849 // initial page has been accessed.
3850 has_accessed_initial_document_ = false;
3851
[email protected]37567b432014-02-12 01:12:223852 // If we navigate off the page, close all JavaScript dialogs.
eugenebutee08663a2017-04-27 17:43:123853 if (!details.is_same_document)
creis89a0f782015-05-27 16:13:173854 CancelActiveAndPendingDialogs();
[email protected]37567b432014-02-12 01:12:223855
avid53461d2016-02-25 17:15:043856 // If this is a user-initiated navigation, start allowing JavaScript dialogs
3857 // again.
avi5d3b8692016-10-12 22:00:463858 if (params.gesture == NavigationGestureUser && dialog_manager_) {
avi6879fcf2017-01-21 05:27:533859 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:463860 }
[email protected]37567b432014-02-12 01:12:223861}
3862
3863void WebContentsImpl::SetMainFrameMimeType(const std::string& mime_type) {
3864 contents_mime_type_ = mime_type;
3865}
3866
[email protected]277857a2014-06-03 10:38:013867bool WebContentsImpl::CanOverscrollContent() const {
[email protected]e85165c642014-06-10 14:34:313868 // Disable overscroll when touch emulation is on. See crbug.com/369938.
[email protected]34ff1cfc2014-08-20 06:16:053869 if (force_disable_overscroll_content_)
[email protected]e85165c642014-06-10 14:34:313870 return false;
3871
[email protected]37567b432014-02-12 01:12:223872 if (delegate_)
3873 return delegate_->CanOverscrollContent();
3874
3875 return false;
3876}
3877
nicka0ac8382016-12-15 23:59:233878void WebContentsImpl::OnThemeColorChanged(RenderFrameHostImpl* source,
3879 SkColor theme_color) {
3880 if (source != GetMainFrame()) {
3881 // Only the main frame may control the theme.
3882 return;
3883 }
3884
peter90afaba2015-06-01 12:05:293885 // Update the theme color. This is to be published to observers after the
3886 // first visually non-empty paint.
yusufod41c5f92015-03-06 00:14:283887 theme_color_ = theme_color;
peter90afaba2015-06-01 12:05:293888
3889 if (did_first_visually_non_empty_paint_ &&
3890 last_sent_theme_color_ != theme_color_) {
ericwilligersde386342016-10-19 02:35:093891 for (auto& observer : observers_)
3892 observer.DidChangeThemeColor(theme_color_);
peter90afaba2015-06-01 12:05:293893 last_sent_theme_color_ = theme_color_;
3894 }
[email protected]e7104762014-06-20 19:17:253895}
3896
[email protected]b172aee2012-04-10 17:05:263897void WebContentsImpl::OnDidLoadResourceFromMemoryCache(
nicka0ac8382016-12-15 23:59:233898 RenderFrameHostImpl* source,
[email protected]724159a2010-12-30 01:11:183899 const GURL& url,
[email protected]70435962011-08-02 20:13:283900 const std::string& http_method,
[email protected]6d6cfb3a2012-05-23 22:53:183901 const std::string& mime_type,
[email protected]6c1e05212014-07-31 00:59:403902 ResourceType resource_type) {
ericwilligersde386342016-10-19 02:35:093903 for (auto& observer : observers_)
3904 observer.DidLoadResourceFromMemoryCache(url, mime_type, resource_type);
[email protected]b0f724c2013-09-05 04:21:133905
[email protected]8bfc8272013-09-09 20:10:533906 if (url.is_valid() && url.SchemeIsHTTPOrHTTPS()) {
nicka0ac8382016-12-15 23:59:233907 StoragePartition* partition = source->GetProcess()->GetStoragePartition();
[email protected]8bfc8272013-09-09 20:10:533908 scoped_refptr<net::URLRequestContextGetter> request_context(
nicka0ac8382016-12-15 23:59:233909 resource_type == RESOURCE_TYPE_MEDIA
3910 ? partition->GetMediaURLRequestContext()
3911 : partition->GetURLRequestContext());
[email protected]8bfc8272013-09-09 20:10:533912 BrowserThread::PostTask(
nicka0ac8382016-12-15 23:59:233913 BrowserThread::IO, FROM_HERE,
[email protected]8bfc8272013-09-09 20:10:533914 base::Bind(&NotifyCacheOnIO, request_context, url, http_method));
3915 }
[email protected]724159a2010-12-30 01:11:183916}
3917
nicka0ac8382016-12-15 23:59:233918void WebContentsImpl::OnDidDisplayInsecureContent(RenderFrameHostImpl* source) {
3919 // Any frame can trigger display of insecure content, so we don't check
3920 // |source| here.
carloskd9d97942017-02-16 08:58:093921 DidDisplayInsecureContent();
3922}
3923
3924void WebContentsImpl::DidDisplayInsecureContent() {
estarkc2273502016-10-12 22:03:023925 controller_.ssl_manager()->DidDisplayMixedContent();
[email protected]724159a2010-12-30 01:11:183926}
3927
elawrenceb2ac2a232017-03-27 21:46:253928void WebContentsImpl::OnDidContainInsecureFormAction(
3929 RenderFrameHostImpl* source) {
3930 controller_.ssl_manager()->DidContainInsecureFormAction();
3931}
3932
nicka0ac8382016-12-15 23:59:233933void WebContentsImpl::OnDidRunInsecureContent(RenderFrameHostImpl* source,
3934 const GURL& security_origin,
estark910b4572015-12-09 20:55:413935 const GURL& target_url) {
nicka0ac8382016-12-15 23:59:233936 // TODO(nick, estark): Should we call FilterURL using |source|'s process on
3937 // these parameters? |target_url| seems unused, except for a log message. And
3938 // |security_origin| might be replaceable with the origin of the main frame.
carloskd9d97942017-02-16 08:58:093939 DidRunInsecureContent(security_origin, target_url);
3940}
3941
3942void WebContentsImpl::DidRunInsecureContent(const GURL& security_origin,
3943 const GURL& target_url) {
[email protected]9450c462013-11-23 01:22:583944 LOG(WARNING) << security_origin << " ran insecure content from "
3945 << target_url.possibly_invalid_spec();
[email protected]e6e30ac2014-01-13 21:24:393946 RecordAction(base::UserMetricsAction("SSL.RanInsecureContent"));
estark910b4572015-12-09 20:55:413947 if (base::EndsWith(security_origin.spec(), kDotGoogleDotCom,
brettwa7ff1b292015-07-16 17:49:293948 base::CompareCase::INSENSITIVE_ASCII))
[email protected]e6e30ac2014-01-13 21:24:393949 RecordAction(base::UserMetricsAction("SSL.RanInsecureContentGoogle"));
estarkc2273502016-10-12 22:03:023950 controller_.ssl_manager()->DidRunMixedContent(security_origin);
[email protected]724159a2010-12-30 01:11:183951}
3952
carloskd9d97942017-02-16 08:58:093953void WebContentsImpl::PassiveInsecureContentFound(const GURL& resource_url) {
3954 GetDelegate()->PassiveInsecureContentFound(resource_url);
3955}
3956
3957bool WebContentsImpl::ShouldAllowRunningInsecureContent(
3958 WebContents* web_contents,
3959 bool allowed_per_prefs,
3960 const url::Origin& origin,
3961 const GURL& resource_url) {
3962 return GetDelegate()->ShouldAllowRunningInsecureContent(
3963 web_contents, allowed_per_prefs, origin, resource_url);
3964}
3965
rob.buis300b0872017-03-10 20:43:583966#if defined(OS_ANDROID)
3967base::android::ScopedJavaLocalRef<jobject>
3968WebContentsImpl::GetJavaRenderFrameHostDelegate() {
3969 return GetJavaWebContents();
3970}
3971#endif
3972
estark910b4572015-12-09 20:55:413973void WebContentsImpl::OnDidDisplayContentWithCertificateErrors(
nicka0ac8382016-12-15 23:59:233974 RenderFrameHostImpl* source,
jama385e112016-07-22 00:07:583975 const GURL& url) {
nicka0ac8382016-12-15 23:59:233976 // TODO(nick): |url| is unused; get rid of it.
estarkc2273502016-10-12 22:03:023977 controller_.ssl_manager()->DidDisplayContentWithCertErrors();
estark910b4572015-12-09 20:55:413978}
3979
3980void WebContentsImpl::OnDidRunContentWithCertificateErrors(
nicka0ac8382016-12-15 23:59:233981 RenderFrameHostImpl* source,
jama385e112016-07-22 00:07:583982 const GURL& url) {
nicka0ac8382016-12-15 23:59:233983 // TODO(nick, estark): Do we need to consider |source| here somehow?
estarkcd2e30c2016-08-12 06:51:153984 NavigationEntry* entry = controller_.GetVisibleEntry();
3985 if (!entry)
estarkaeda1422016-05-10 02:31:123986 return;
3987
estarkaeda1422016-05-10 02:31:123988 // TODO(estark): check that this does something reasonable for
3989 // about:blank and sandboxed origins. https://crbug.com/609527
estarkcd2e30c2016-08-12 06:51:153990 controller_.ssl_manager()->DidRunContentWithCertErrors(
3991 entry->GetURL().GetOrigin());
estark910b4572015-12-09 20:55:413992}
3993
nicka0ac8382016-12-15 23:59:233994void WebContentsImpl::OnDocumentLoadedInFrame(RenderFrameHostImpl* source) {
ericwilligersde386342016-10-19 02:35:093995 for (auto& observer : observers_)
nicka0ac8382016-12-15 23:59:233996 observer.DocumentLoadedInFrame(source);
[email protected]724159a2010-12-30 01:11:183997}
3998
nicka0ac8382016-12-15 23:59:233999void WebContentsImpl::OnDidFinishLoad(RenderFrameHostImpl* source,
4000 const GURL& url) {
[email protected]8b3af1e2014-01-24 13:29:124001 GURL validated_url(url);
nicka0ac8382016-12-15 23:59:234002 source->GetProcess()->FilterURL(false, &validated_url);
[email protected]028053d42014-03-05 22:20:374003
ericwilligersde386342016-10-19 02:35:094004 for (auto& observer : observers_)
nicka0ac8382016-12-15 23:59:234005 observer.DidFinishLoad(source, validated_url);
[email protected]1a55c5be2011-11-29 11:36:314006}
4007
nicka0ac8382016-12-15 23:59:234008void WebContentsImpl::OnGoToEntryAtOffset(RenderViewHostImpl* source,
4009 int offset) {
4010 // All frames are allowed to navigate the global history.
avi6ddfcae2015-06-30 15:50:574011 if (!delegate_ || delegate_->OnGoToEntryOffset(offset))
4012 controller_.GoToOffset(offset);
[email protected]216813952011-05-19 22:21:264013}
4014
nicka0ac8382016-12-15 23:59:234015void WebContentsImpl::OnUpdateZoomLimits(RenderViewHostImpl* source,
4016 int minimum_percent,
[email protected]fce823222014-05-30 16:24:304017 int maximum_percent) {
[email protected]216813952011-05-19 22:21:264018 minimum_zoom_percent_ = minimum_percent;
4019 maximum_zoom_percent_ = maximum_percent;
[email protected]216813952011-05-19 22:21:264020}
4021
nicka0ac8382016-12-15 23:59:234022void WebContentsImpl::OnPageScaleFactorChanged(RenderViewHostImpl* source,
4023 float page_scale_factor) {
mcnee336ea2c2017-05-23 22:50:594024#if !defined(OS_ANDROID)
4025 // While page scale factor is used on mobile, this PageScaleFactorIsOne logic
4026 // is only needed on desktop.
mcnee432e47d2015-11-09 19:37:464027 bool is_one = page_scale_factor == 1.f;
4028 if (is_one != page_scale_factor_is_one_) {
4029 page_scale_factor_is_one_ = is_one;
4030
4031 HostZoomMapImpl* host_zoom_map =
4032 static_cast<HostZoomMapImpl*>(HostZoomMap::GetForWebContents(this));
4033
nicka0ac8382016-12-15 23:59:234034 if (host_zoom_map) {
mcnee432e47d2015-11-09 19:37:464035 host_zoom_map->SetPageScaleFactorIsOneForView(
nicka0ac8382016-12-15 23:59:234036 source->GetProcess()->GetID(), source->GetRoutingID(),
mcnee432e47d2015-11-09 19:37:464037 page_scale_factor_is_one_);
4038 }
4039 }
mcnee336ea2c2017-05-23 22:50:594040#endif // !defined(OS_ANDROID)
mcnee432e47d2015-11-09 19:37:464041
ericwilligersde386342016-10-19 02:35:094042 for (auto& observer : observers_)
4043 observer.OnPageScaleFactorChanged(page_scale_factor);
mcnee432e47d2015-11-09 19:37:464044}
4045
nicka0ac8382016-12-15 23:59:234046void WebContentsImpl::OnEnumerateDirectory(RenderViewHostImpl* source,
4047 int request_id,
[email protected]2dec8ec2013-02-07 19:20:344048 const base::FilePath& path) {
[email protected]e5f2de02012-07-20 22:15:434049 if (!delegate_)
4050 return;
4051
[email protected]b9535422012-02-09 01:47:594052 ChildProcessSecurityPolicyImpl* policy =
4053 ChildProcessSecurityPolicyImpl::GetInstance();
nicka0ac8382016-12-15 23:59:234054 if (policy->CanReadFile(source->GetProcess()->GetID(), path)) {
4055 // TODO(nick): |this| param in the call below ought to be a RenderFrameHost.
[email protected]b9535422012-02-09 01:47:594056 delegate_->EnumerateDirectory(this, request_id, path);
nicka0ac8382016-12-15 23:59:234057 }
[email protected]3a29a6e2011-08-24 18:26:214058}
4059
nicka0ac8382016-12-15 23:59:234060void WebContentsImpl::OnRegisterProtocolHandler(RenderFrameHostImpl* source,
4061 const std::string& protocol,
[email protected]b172aee2012-04-10 17:05:264062 const GURL& url,
[email protected]fcf75d42013-12-03 20:11:264063 const base::string16& title,
[email protected]3a3b75a2012-06-01 08:38:364064 bool user_gesture) {
nicka0ac8382016-12-15 23:59:234065 // TODO(nick): Should we consider |source| here or pass it to the delegate?
4066 // TODO(nick): Do we need to apply FilterURL to |url|?
[email protected]e5f2de02012-07-20 22:15:434067 if (!delegate_)
4068 return;
4069
[email protected]b9535422012-02-09 01:47:594070 ChildProcessSecurityPolicyImpl* policy =
4071 ChildProcessSecurityPolicyImpl::GetInstance();
[email protected]8f810632013-06-06 22:33:324072 if (policy->IsPseudoScheme(protocol))
[email protected]b9535422012-02-09 01:47:594073 return;
[email protected]8f810632013-06-06 22:33:324074
[email protected]c125e532014-05-10 20:39:064075 delegate_->RegisterProtocolHandler(this, protocol, url, user_gesture);
[email protected]7d189022011-08-25 22:54:204076}
4077
nicka0ac8382016-12-15 23:59:234078void WebContentsImpl::OnUnregisterProtocolHandler(RenderFrameHostImpl* source,
4079 const std::string& protocol,
[email protected]f5273e52014-07-14 16:30:204080 const GURL& url,
4081 bool user_gesture) {
nicka0ac8382016-12-15 23:59:234082 // TODO(nick): Should we consider |source| here or pass it to the delegate?
4083 // TODO(nick): Do we need to apply FilterURL to |url|?
[email protected]f5273e52014-07-14 16:30:204084 if (!delegate_)
4085 return;
4086
4087 ChildProcessSecurityPolicyImpl* policy =
4088 ChildProcessSecurityPolicyImpl::GetInstance();
4089 if (policy->IsPseudoScheme(protocol))
4090 return;
4091
4092 delegate_->UnregisterProtocolHandler(this, protocol, url, user_gesture);
4093}
4094
kouhei40f03cb2015-09-24 07:47:014095void WebContentsImpl::OnUpdatePageImportanceSignals(
nicka0ac8382016-12-15 23:59:234096 RenderFrameHostImpl* source,
kouhei40f03cb2015-09-24 07:47:014097 const PageImportanceSignals& signals) {
nicka0ac8382016-12-15 23:59:234098 // TODO(nick, kouhei): Fix this for oopifs; currently all frames' state gets
4099 // written to this one field.
kouhei40f03cb2015-09-24 07:47:014100 page_importance_signals_ = signals;
4101}
4102
nicka0ac8382016-12-15 23:59:234103void WebContentsImpl::OnFindReply(RenderFrameHostImpl* source,
4104 int request_id,
[email protected]b172aee2012-04-10 17:05:264105 int number_of_matches,
4106 const gfx::Rect& selection_rect,
4107 int active_match_ordinal,
4108 bool final_update) {
paulmeyerfeafc2d2017-04-25 21:46:404109 if (active_match_ordinal > 0)
4110 SetFocusedFrame(source->frame_tree_node(), source->GetSiteInstance());
4111
paulmeyerc0b762b2016-04-13 11:55:174112 // Forward the find reply to the FindRequestManager, along with the
4113 // RenderFrameHost associated with the frame that the reply came from.
nicka0ac8382016-12-15 23:59:234114 GetOrCreateFindRequestManager()->OnFindReply(
4115 source, request_id, number_of_matches, selection_rect,
4116 active_match_ordinal, final_update);
[email protected]b888919c2011-09-02 00:32:164117}
4118
mfomitchev2b8b066a2016-01-28 19:23:154119#if defined(OS_ANDROID)
[email protected]59363fc92012-09-05 03:46:314120void WebContentsImpl::OnFindMatchRectsReply(
nicka0ac8382016-12-15 23:59:234121 RenderFrameHostImpl* source,
[email protected]59363fc92012-09-05 03:46:314122 int version,
4123 const std::vector<gfx::RectF>& rects,
4124 const gfx::RectF& active_rect) {
nicka0ac8382016-12-15 23:59:234125 GetOrCreateFindRequestManager()->OnFindMatchRectsReply(source, version, rects,
4126 active_rect);
[email protected]59363fc92012-09-05 03:46:314127}
[email protected]583418cc2013-01-17 14:01:104128
nicka0ac8382016-12-15 23:59:234129void WebContentsImpl::OnGetNearestFindResultReply(RenderFrameHostImpl* source,
4130 int request_id,
paulmeyerc8cb7cb2016-06-07 01:14:194131 float distance) {
4132 GetOrCreateFindRequestManager()->OnGetNearestFindResultReply(
nicka0ac8382016-12-15 23:59:234133 source, request_id, distance);
paulmeyerc8cb7cb2016-06-07 01:14:194134}
4135
[email protected]1ff427972013-02-07 21:14:074136void WebContentsImpl::OnOpenDateTimeDialog(
nicka0ac8382016-12-15 23:59:234137 RenderViewHostImpl* source,
[email protected]1ff427972013-02-07 21:14:074138 const ViewHostMsg_DateTimeDialogValue_Params& value) {
nicka0ac8382016-12-15 23:59:234139 date_time_chooser_->ShowDialog(
4140 GetTopLevelNativeWindow(), source, value.dialog_type, value.dialog_value,
4141 value.minimum, value.maximum, value.step, value.suggestions);
[email protected]583418cc2013-01-17 14:01:104142}
[email protected]59363fc92012-09-05 03:46:314143#endif
4144
nicka0ac8382016-12-15 23:59:234145void WebContentsImpl::OnDomOperationResponse(RenderFrameHostImpl* source,
4146 const std::string& json_string) {
4147 // TODO(nick, lukasza): The notification below should probably be updated to
4148 // include |source|.
avi60bd4902015-09-23 20:39:244149 std::string json = json_string;
4150 NotificationService::current()->Notify(NOTIFICATION_DOM_OPERATION_RESPONSE,
4151 Source<WebContents>(this),
4152 Details<std::string>(&json));
[email protected]cfa856d62014-02-22 07:58:404153}
4154
nicka0ac8382016-12-15 23:59:234155void WebContentsImpl::OnAppCacheAccessed(RenderViewHostImpl* source,
4156 const GURL& manifest_url,
[email protected]b172aee2012-04-10 17:05:264157 bool blocked_by_policy) {
nicka0ac8382016-12-15 23:59:234158 // TODO(nick): Should we consider |source| here? Should we call FilterURL on
4159 // |manifest_url|?
4160
[email protected]7fc4bbb2011-09-08 21:23:104161 // Notify observers about navigation.
ericwilligersde386342016-10-19 02:35:094162 for (auto& observer : observers_)
4163 observer.AppCacheAccessed(manifest_url, blocked_by_policy);
[email protected]7fc4bbb2011-09-08 21:23:104164}
4165
[email protected]8bc5ff02013-11-29 06:34:034166void WebContentsImpl::OnOpenColorChooser(
nicka0ac8382016-12-15 23:59:234167 RenderFrameHostImpl* source,
[email protected]8ed16472014-04-11 19:02:484168 int color_chooser_id,
4169 SkColor color,
4170 const std::vector<ColorSuggestion>& suggestions) {
[email protected]aa62afd2014-04-22 19:22:464171 ColorChooser* new_color_chooser = delegate_ ?
4172 delegate_->OpenColorChooser(this, color, suggestions) :
4173 NULL;
[email protected]820957a2014-01-14 14:56:304174 if (!new_color_chooser)
[email protected]cb805452013-05-22 15:16:214175 return;
[email protected]8ed16472014-04-11 19:02:484176 if (color_chooser_info_.get())
4177 color_chooser_info_->chooser->End();
4178
4179 color_chooser_info_.reset(new ColorChooserInfo(
nicka0ac8382016-12-15 23:59:234180 source->GetProcess()->GetID(), source->GetRoutingID(), new_color_chooser,
[email protected]8ed16472014-04-11 19:02:484181 color_chooser_id));
[email protected]da8543762012-03-20 08:52:204182}
4183
nicka0ac8382016-12-15 23:59:234184void WebContentsImpl::OnEndColorChooser(RenderFrameHostImpl* source,
4185 int color_chooser_id) {
[email protected]8ed16472014-04-11 19:02:484186 if (color_chooser_info_ &&
nicka0ac8382016-12-15 23:59:234187 color_chooser_info_->Matches(source, color_chooser_id))
[email protected]8ed16472014-04-11 19:02:484188 color_chooser_info_->chooser->End();
[email protected]da8543762012-03-20 08:52:204189}
4190
nicka0ac8382016-12-15 23:59:234191void WebContentsImpl::OnSetSelectedColorInColorChooser(
4192 RenderFrameHostImpl* source,
4193 int color_chooser_id,
4194 SkColor color) {
[email protected]8ed16472014-04-11 19:02:484195 if (color_chooser_info_ &&
nicka0ac8382016-12-15 23:59:234196 color_chooser_info_->Matches(source, color_chooser_id))
[email protected]8ed16472014-04-11 19:02:484197 color_chooser_info_->chooser->SetSelectedColor(color);
[email protected]da8543762012-03-20 08:52:204198}
4199
[email protected]d0759f492012-04-19 22:50:504200// This exists for render views that don't have a WebUI, but do have WebUI
4201// bindings enabled.
nicka0ac8382016-12-15 23:59:234202void WebContentsImpl::OnWebUISend(RenderViewHostImpl* source,
4203 const GURL& source_url,
[email protected]d0759f492012-04-19 22:50:504204 const std::string& name,
4205 const base::ListValue& args) {
nicka0ac8382016-12-15 23:59:234206 // TODO(nick): Should we consider |source| here or pass it to the delegate?
4207 // TODO(nick): Should FilterURL be applied to |source_url|?
4208 // TODO(nick): This IPC should be ported to FrameHostMsg_, and |source_url|
4209 // should be eliminated (use last_committed_url() on the RFH instead).
[email protected]d0759f492012-04-19 22:50:504210 if (delegate_)
4211 delegate_->WebUISend(this, source_url, name, args);
4212}
4213
brettw4b461082016-11-19 18:55:164214#if BUILDFLAG(ENABLE_PLUGINS)
nicka0ac8382016-12-15 23:59:234215void WebContentsImpl::OnPepperInstanceCreated(RenderFrameHostImpl* source,
4216 int32_t pp_instance) {
ericwilligersde386342016-10-19 02:35:094217 for (auto& observer : observers_)
4218 observer.PepperInstanceCreated();
nicka0ac8382016-12-15 23:59:234219 pepper_playback_observer_->PepperInstanceCreated(source, pp_instance);
emaxxe70f5e12015-05-29 11:26:004220}
4221
nicka0ac8382016-12-15 23:59:234222void WebContentsImpl::OnPepperInstanceDeleted(RenderFrameHostImpl* source,
4223 int32_t pp_instance) {
ericwilligersde386342016-10-19 02:35:094224 for (auto& observer : observers_)
4225 observer.PepperInstanceDeleted();
nicka0ac8382016-12-15 23:59:234226 pepper_playback_observer_->PepperInstanceDeleted(source, pp_instance);
emaxxe70f5e12015-05-29 11:26:004227}
4228
nicka0ac8382016-12-15 23:59:234229void WebContentsImpl::OnPepperPluginHung(RenderFrameHostImpl* source,
4230 int plugin_child_id,
tommyclie6633ca72014-10-31 00:40:424231 const base::FilePath& path,
4232 bool is_hung) {
4233 UMA_HISTOGRAM_COUNTS("Pepper.PluginHung", 1);
4234
ericwilligersde386342016-10-19 02:35:094235 for (auto& observer : observers_)
4236 observer.PluginHungStatusChanged(plugin_child_id, path, is_hung);
tommyclie6633ca72014-10-31 00:40:424237}
4238
nicka0ac8382016-12-15 23:59:234239void WebContentsImpl::OnPepperStartsPlayback(RenderFrameHostImpl* source,
4240 int32_t pp_instance) {
4241 pepper_playback_observer_->PepperStartsPlayback(source, pp_instance);
zqzhang181047e62016-07-01 13:37:174242}
4243
nicka0ac8382016-12-15 23:59:234244void WebContentsImpl::OnPepperStopsPlayback(RenderFrameHostImpl* source,
4245 int32_t pp_instance) {
4246 pepper_playback_observer_->PepperStopsPlayback(source, pp_instance);
zqzhang181047e62016-07-01 13:37:174247}
4248
nicka0ac8382016-12-15 23:59:234249void WebContentsImpl::OnPluginCrashed(RenderFrameHostImpl* source,
4250 const base::FilePath& plugin_path,
tommyclie6633ca72014-10-31 00:40:424251 base::ProcessId plugin_pid) {
nicka0ac8382016-12-15 23:59:234252 // TODO(nick): Eliminate the |plugin_pid| parameter, which can't be trusted,
4253 // and is only used by BlinkTestController.
ericwilligersde386342016-10-19 02:35:094254 for (auto& observer : observers_)
4255 observer.PluginCrashed(plugin_path, plugin_pid);
tommyclie6633ca72014-10-31 00:40:424256}
4257
[email protected]d8415ad92012-08-23 14:40:504258void WebContentsImpl::OnRequestPpapiBrokerPermission(
nicka0ac8382016-12-15 23:59:234259 RenderViewHostImpl* source,
4260 int ppb_broker_route_id,
[email protected]d8415ad92012-08-23 14:40:504261 const GURL& url,
[email protected]2dec8ec2013-02-07 19:20:344262 const base::FilePath& plugin_path) {
nicka0ac8382016-12-15 23:59:234263 base::Callback<void(bool)> permission_result_callback = base::Bind(
4264 &WebContentsImpl::SendPpapiBrokerPermissionResult, base::Unretained(this),
4265 source->GetProcess()->GetID(), ppb_broker_route_id);
[email protected]8c8fc292012-11-23 18:57:164266 if (!delegate_) {
nicka0ac8382016-12-15 23:59:234267 permission_result_callback.Run(false);
[email protected]8c8fc292012-11-23 18:57:164268 return;
[email protected]d8415ad92012-08-23 14:40:504269 }
4270
nicka0ac8382016-12-15 23:59:234271 if (!delegate_->RequestPpapiBrokerPermission(this, url, plugin_path,
4272 permission_result_callback)) {
[email protected]8c8fc292012-11-23 18:57:164273 NOTIMPLEMENTED();
nicka0ac8382016-12-15 23:59:234274 permission_result_callback.Run(false);
[email protected]8c8fc292012-11-23 18:57:164275 }
[email protected]d8415ad92012-08-23 14:40:504276}
4277
nicka0ac8382016-12-15 23:59:234278void WebContentsImpl::SendPpapiBrokerPermissionResult(int process_id,
4279 int ppb_broker_route_id,
4280 bool result) {
4281 RenderProcessHost* rph = RenderProcessHost::FromID(process_id);
4282 if (rph) {
4283 // TODO(nick): Convert this from ViewMsg_ to a Ppapi msg, since it
4284 // is not routed to a RenderView.
4285 rph->Send(
4286 new ViewMsg_PpapiBrokerPermissionResult(ppb_broker_route_id, result));
4287 }
[email protected]d8415ad92012-08-23 14:40:504288}
4289
fsamuel833ee7c2015-02-13 23:40:404290void WebContentsImpl::OnBrowserPluginMessage(RenderFrameHost* render_frame_host,
4291 const IPC::Message& message) {
[email protected]7a846df2012-09-20 19:17:394292 CHECK(!browser_plugin_embedder_.get());
fsamuel60b42282015-03-10 03:29:144293 CreateBrowserPluginEmbedderIfNecessary();
fsamuel833ee7c2015-02-13 23:40:404294 browser_plugin_embedder_->OnMessageReceived(message, render_frame_host);
[email protected]19be7a62012-10-01 23:03:374295}
brettw4b461082016-11-19 18:55:164296#endif // BUILDFLAG(ENABLE_PLUGINS)
[email protected]19be7a62012-10-01 23:03:374297
[email protected]795c28972012-12-06 06:13:394298void WebContentsImpl::OnUpdateFaviconURL(
lukasza178ff092017-06-07 23:39:504299 RenderFrameHostImpl* source,
[email protected]795c28972012-12-06 06:13:394300 const std::vector<FaviconURL>& candidates) {
lukasza178ff092017-06-07 23:39:504301 // Ignore favicons for non-main frame.
4302 if (source->GetParent()) {
4303 NOTREACHED();
4304 return;
4305 }
4306
pkotwiczf9bc20592015-04-21 18:57:064307 // We get updated favicon URLs after the page stops loading. If a cross-site
4308 // navigation occurs while a page is still loading, the initial page
4309 // may stop loading and send us updated favicon URLs after the navigation
4310 // for the new page has committed.
lukasza178ff092017-06-07 23:39:504311 if (!source->IsCurrent())
pkotwiczf9bc20592015-04-21 18:57:064312 return;
4313
ericwilligersde386342016-10-19 02:35:094314 for (auto& observer : observers_)
4315 observer.DidUpdateFaviconURL(candidates);
[email protected]795c28972012-12-06 06:13:394316}
4317
estark703f1b42016-10-10 21:37:154318void WebContentsImpl::OnPasswordInputShownOnHttp() {
estarkc2273502016-10-12 22:03:024319 controller_.ssl_manager()->DidShowPasswordInputOnHttp();
estark703f1b42016-10-10 21:37:154320}
4321
estarkfae6b5872016-11-04 05:20:314322void WebContentsImpl::OnAllPasswordInputsHiddenOnHttp() {
4323 controller_.ssl_manager()->DidHideAllPasswordInputsOnHttp();
4324}
4325
estark703f1b42016-10-10 21:37:154326void WebContentsImpl::OnCreditCardInputShownOnHttp() {
estarkc2273502016-10-12 22:03:024327 controller_.ssl_manager()->DidShowCreditCardInputOnHttp();
estark703f1b42016-10-10 21:37:154328}
4329
qinmin72e8bd02016-10-21 19:35:374330void WebContentsImpl::SetIsOverlayContent(bool is_overlay_content) {
4331 is_overlay_content_ = is_overlay_content;
4332}
4333
nicka0ac8382016-12-15 23:59:234334void WebContentsImpl::OnFirstVisuallyNonEmptyPaint(RenderViewHostImpl* source) {
4335 // TODO(nick): When this is ported to FrameHostMsg_, we should only listen if
4336 // |source| is the main frame.
ericwilligersde386342016-10-19 02:35:094337 for (auto& observer : observers_)
4338 observer.DidFirstVisuallyNonEmptyPaint();
yusufod41c5f92015-03-06 00:14:284339
peter90afaba2015-06-01 12:05:294340 did_first_visually_non_empty_paint_ = true;
4341
yusufod41c5f92015-03-06 00:14:284342 if (theme_color_ != last_sent_theme_color_) {
4343 // Theme color should have updated by now if there was one.
ericwilligersde386342016-10-19 02:35:094344 for (auto& observer : observers_)
4345 observer.DidChangeThemeColor(theme_color_);
yusufod41c5f92015-03-06 00:14:284346 last_sent_theme_color_ = theme_color_;
4347 }
[email protected]9f268072013-11-07 00:02:154348}
[email protected]d9030b82013-07-19 08:26:064349
[email protected]17e286e2013-03-01 23:29:394350void WebContentsImpl::NotifyBeforeFormRepostWarningShow() {
ericwilligersde386342016-10-19 02:35:094351 for (auto& observer : observers_)
4352 observer.BeforeFormRepostWarningShow();
[email protected]17e286e2013-03-01 23:29:394353}
4354
[email protected]ec6c05f2013-10-23 18:41:574355void WebContentsImpl::ActivateAndShowRepostFormWarningDialog() {
4356 Activate();
4357 if (delegate_)
4358 delegate_->ShowRepostFormWarningDialog(this);
4359}
4360
[email protected]b4c84012014-04-28 19:51:104361bool WebContentsImpl::HasAccessedInitialDocument() {
4362 return has_accessed_initial_document_;
4363}
4364
afakhry6f0c1ec22016-07-14 13:55:134365void WebContentsImpl::UpdateTitleForEntry(NavigationEntry* entry,
[email protected]fcf75d42013-12-03 20:11:264366 const base::string16& title) {
[email protected]420ae012009-04-24 05:16:324367 // For file URLs without a title, use the pathname instead. In the case of a
4368 // synthesized title, we don't want the update to count toward the "one set
4369 // per page of the title to history."
[email protected]fcf75d42013-12-03 20:11:264370 base::string16 final_title;
[email protected]420ae012009-04-24 05:16:324371 bool explicit_set;
[email protected]36fc0392011-12-25 03:59:514372 if (entry && entry->GetURL().SchemeIsFile() && title.empty()) {
[email protected]32956122013-12-25 07:29:244373 final_title = base::UTF8ToUTF16(entry->GetURL().ExtractFileName());
[email protected]420ae012009-04-24 05:16:324374 explicit_set = false; // Don't count synthetic titles toward the set limit.
4375 } else {
[email protected]8af69c6c2014-03-03 19:05:314376 base::TrimWhitespace(title, base::TRIM_ALL, &final_title);
[email protected]420ae012009-04-24 05:16:324377 explicit_set = true;
4378 }
4379
[email protected]987fc3a2011-05-26 14:18:094380 // If a page is created via window.open and never navigated,
4381 // there will be no navigation entry. In this situation,
[email protected]73eb2602012-02-09 19:50:554382 // |page_title_when_no_navigation_entry_| will be used for page title.
[email protected]987fc3a2011-05-26 14:18:094383 if (entry) {
[email protected]36fc0392011-12-25 03:59:514384 if (final_title == entry->GetTitle())
afakhry6f0c1ec22016-07-14 13:55:134385 return; // Nothing changed, don't bother.
[email protected]420ae012009-04-24 05:16:324386
[email protected]36fc0392011-12-25 03:59:514387 entry->SetTitle(final_title);
[email protected]987fc3a2011-05-26 14:18:094388 } else {
4389 if (page_title_when_no_navigation_entry_ == final_title)
afakhry6f0c1ec22016-07-14 13:55:134390 return; // Nothing changed, don't bother.
[email protected]987fc3a2011-05-26 14:18:094391
4392 page_title_when_no_navigation_entry_ = final_title;
4393 }
[email protected]420ae012009-04-24 05:16:324394
[email protected]420ae012009-04-24 05:16:324395 // Lastly, set the title for the view.
[email protected]790e2fd2011-09-21 20:28:234396 view_->SetPageTitle(final_title);
[email protected]420ae012009-04-24 05:16:324397
ericwilligersde386342016-10-19 02:35:094398 for (auto& observer : observers_)
4399 observer.TitleWasSet(entry, explicit_set);
[email protected]66798902013-10-01 18:40:164400
afakhry6f0c1ec22016-07-14 13:55:134401 // Broadcast notifications when the UI should be updated.
4402 if (entry == controller_.GetEntryAtOffset(0))
4403 NotifyNavigationStateChanged(INVALIDATE_TYPE_TITLE);
[email protected]420ae012009-04-24 05:16:324404}
4405
fdegansa696e5112015-04-17 01:57:594406void WebContentsImpl::SendChangeLoadProgress() {
[email protected]960b0372014-05-19 18:01:004407 loading_last_progress_update_ = base::TimeTicks::Now();
[email protected]960b0372014-05-19 18:01:004408 if (delegate_)
fdegansa696e5112015-04-17 01:57:594409 delegate_->LoadProgressChanged(this, frame_tree_.load_progress());
[email protected]960b0372014-05-19 18:01:004410}
4411
4412void WebContentsImpl::ResetLoadProgressState() {
fdegans1d16355162015-03-26 11:58:344413 frame_tree_.ResetLoadProgress();
[email protected]960b0372014-05-19 18:01:004414 loading_weak_factory_.InvalidateWeakPtrs();
4415 loading_last_progress_update_ = base::TimeTicks();
4416}
4417
clamy44e84ce2016-02-22 15:38:254418// Notifies the RenderWidgetHost instance about the fact that the page is
4419// loading, or done loading.
4420void WebContentsImpl::LoadingStateChanged(bool to_different_document,
4421 bool due_to_interstitial,
4422 LoadNotificationDetails* details) {
4423 // Do not send notifications about loading changes in the FrameTree while the
4424 // interstitial page is pausing the throbber.
creisadca9862017-06-16 19:12:114425 if (ShowingInterstitialPage() && interstitial_page_->pause_throbber() &&
clamy44e84ce2016-02-22 15:38:254426 !due_to_interstitial) {
4427 return;
4428 }
4429
4430 bool is_loading = IsLoading();
4431
4432 if (!is_loading) {
4433 load_state_ = net::LoadStateWithParam(net::LOAD_STATE_IDLE,
4434 base::string16());
4435 load_state_host_.clear();
4436 upload_size_ = 0;
4437 upload_position_ = 0;
4438 }
4439
4440 GetRenderManager()->SetIsLoading(is_loading);
4441
4442 waiting_for_response_ = is_loading;
4443 is_load_to_different_document_ = to_different_document;
4444
4445 if (delegate_)
4446 delegate_->LoadingStateChanged(this, to_different_document);
4447 NotifyNavigationStateChanged(INVALIDATE_TYPE_LOAD);
4448
4449 std::string url = (details ? details->url.possibly_invalid_spec() : "NULL");
4450 if (is_loading) {
4451 TRACE_EVENT_ASYNC_BEGIN2("browser,navigation", "WebContentsImpl Loading",
4452 this, "URL", url, "Main FrameTreeNode id",
4453 GetFrameTree()->root()->frame_tree_node_id());
ericwilligersde386342016-10-19 02:35:094454 for (auto& observer : observers_)
4455 observer.DidStartLoading();
clamy44e84ce2016-02-22 15:38:254456 } else {
4457 TRACE_EVENT_ASYNC_END1("browser,navigation", "WebContentsImpl Loading",
4458 this, "URL", url);
ericwilligersde386342016-10-19 02:35:094459 for (auto& observer : observers_)
4460 observer.DidStopLoading();
clamy44e84ce2016-02-22 15:38:254461 }
4462
4463 // TODO(avi): Remove. http://crbug.com/170921
4464 int type = is_loading ? NOTIFICATION_LOAD_START : NOTIFICATION_LOAD_STOP;
4465 NotificationDetails det = NotificationService::NoDetails();
4466 if (details)
4467 det = Details<LoadNotificationDetails>(details);
4468 NotificationService::current()->Notify(
4469 type, Source<NavigationController>(&controller_), det);
4470}
4471
[email protected]02d7b6e2014-06-24 21:01:504472void WebContentsImpl::NotifyViewSwapped(RenderViewHost* old_host,
4473 RenderViewHost* new_host) {
[email protected]420ae012009-04-24 05:16:324474 // After sending out a swap notification, we need to send a disconnect
4475 // notification so that clients that pick up a pointer to |this| can NULL the
4476 // pointer. See Bug 1230284.
4477 notify_disconnection_ = true;
ericwilligersde386342016-10-19 02:35:094478 for (auto& observer : observers_)
4479 observer.RenderViewHostChanged(old_host, new_host);
[email protected]da7a7182013-09-06 08:11:114480
[email protected]7a846df2012-09-20 19:17:394481 // Ensure that the associated embedder gets cleared after a RenderViewHost
4482 // gets swapped, so we don't reuse the same embedder next time a
4483 // RenderViewHost is attached to this WebContents.
4484 RemoveBrowserPluginEmbedder();
[email protected]420ae012009-04-24 05:16:324485}
4486
[email protected]02d7b6e2014-06-24 21:01:504487void WebContentsImpl::NotifyFrameSwapped(RenderFrameHost* old_host,
4488 RenderFrameHost* new_host) {
Bo Liu7c6779e92017-08-16 02:02:284489 // Try to copy importance from either |old_host| or parent of |new_host|.
4490 // If both are null, then this is the very first frame host created from Init.
4491 // There is no need to pass importance in this case because there is no chance
4492 // for anything to call SetImportance yet.
4493 RenderFrameHostImpl* importance_host = static_cast<RenderFrameHostImpl*>(
4494 old_host ? old_host : new_host->GetParent());
4495 if (importance_host) {
4496 static_cast<RenderFrameHostImpl*>(new_host)
4497 ->GetRenderWidgetHost()
4498 ->SetImportance(importance_host->GetRenderWidgetHost()->importance());
4499 }
ericwilligersde386342016-10-19 02:35:094500 for (auto& observer : observers_)
4501 observer.RenderFrameHostChanged(old_host, new_host);
[email protected]02d7b6e2014-06-24 21:01:504502}
4503
[email protected]da7a7182013-09-06 08:11:114504// TODO(avi): Remove this entire function because this notification is already
4505// covered by two observer functions. http://crbug.com/170921
[email protected]b172aee2012-04-10 17:05:264506void WebContentsImpl::NotifyDisconnected() {
[email protected]420ae012009-04-24 05:16:324507 if (!notify_disconnection_)
4508 return;
4509
4510 notify_disconnection_ = false;
[email protected]8ff00d72012-10-23 19:12:214511 NotificationService::current()->Notify(
4512 NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
4513 Source<WebContents>(this),
4514 NotificationService::NoDetails());
[email protected]420ae012009-04-24 05:16:324515}
4516
[email protected]cbb1ef592013-06-05 19:49:464517void WebContentsImpl::NotifyNavigationEntryCommitted(
4518 const LoadCommittedDetails& load_details) {
ericwilligersde386342016-10-19 02:35:094519 for (auto& observer : observers_)
4520 observer.NavigationEntryCommitted(load_details);
[email protected]cbb1ef592013-06-05 19:49:464521}
4522
Sam McNally5c087a32017-08-25 01:46:144523void WebContentsImpl::NotifyNavigationEntryChanged(
4524 const EntryChangedDetails& change_details) {
4525 for (auto& observer : observers_)
4526 observer.NavigationEntryChanged(change_details);
4527}
4528
4529void WebContentsImpl::NotifyNavigationListPruned(
4530 const PrunedDetails& pruned_details) {
4531 for (auto& observer : observers_)
4532 observer.NavigationListPruned(pruned_details);
4533}
4534
rockotf62002a2016-09-15 00:08:594535void WebContentsImpl::OnAssociatedInterfaceRequest(
4536 RenderFrameHost* render_frame_host,
4537 const std::string& interface_name,
4538 mojo::ScopedInterfaceEndpointHandle handle) {
4539 auto it = binding_sets_.find(interface_name);
4540 if (it != binding_sets_.end())
4541 it->second->OnRequestForFrame(render_frame_host, std::move(handle));
4542}
4543
Ben Goodger9e24929e2017-07-21 03:13:404544void WebContentsImpl::OnInterfaceRequest(
4545 RenderFrameHost* render_frame_host,
4546 const std::string& interface_name,
4547 mojo::ScopedMessagePipeHandle* interface_pipe) {
4548 for (auto& observer : observers_) {
4549 observer.OnInterfaceRequestFromFrame(render_frame_host, interface_name,
4550 interface_pipe);
4551 if (!interface_pipe->is_valid())
4552 break;
4553 }
4554}
4555
[email protected]c31a84802014-04-03 15:55:494556const GURL& WebContentsImpl::GetMainFrameLastCommittedURL() const {
4557 return GetLastCommittedURL();
4558}
4559
[email protected]b849847b2013-12-10 21:57:584560void WebContentsImpl::RenderFrameCreated(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:094561 for (auto& observer : observers_)
4562 observer.RenderFrameCreated(render_frame_host);
dmazzonif8a31042016-12-03 00:52:134563 UpdateAccessibilityModeOnFrame(render_frame_host);
clamy91b7abf2016-03-24 15:17:454564
4565 if (!render_frame_host->IsRenderFrameLive() || render_frame_host->GetParent())
4566 return;
4567
4568 NavigationEntry* entry = controller_.GetPendingEntry();
4569 if (entry && entry->IsViewSourceMode()) {
4570 // Put the renderer in view source mode.
4571 render_frame_host->Send(
4572 new FrameMsg_EnableViewSourceMode(render_frame_host->GetRoutingID()));
4573 }
[email protected]b849847b2013-12-10 21:57:584574}
4575
4576void WebContentsImpl::RenderFrameDeleted(RenderFrameHost* render_frame_host) {
creis3638897452017-05-09 22:07:504577 is_notifying_observers_ = true;
ericwilligersde386342016-10-19 02:35:094578 for (auto& observer : observers_)
4579 observer.RenderFrameDeleted(render_frame_host);
creis3638897452017-05-09 22:07:504580 is_notifying_observers_ = false;
zqzhang7b6f4f02016-12-07 22:10:224581#if BUILDFLAG(ENABLE_PLUGINS)
4582 pepper_playback_observer_->RenderFrameDeleted(render_frame_host);
4583#endif
[email protected]b849847b2013-12-10 21:57:584584}
4585
[email protected]a09d53ce2014-01-31 00:46:424586void WebContentsImpl::ShowContextMenu(RenderFrameHost* render_frame_host,
4587 const ContextMenuParams& params) {
avie9fd8722017-04-10 16:17:584588 // If a renderer fires off a second command to show a context menu before the
4589 // first context menu is closed, just ignore it. https://crbug.com/707534
ekaramadf6750aa2017-06-06 18:29:424590 if (showing_context_menu_)
avie9fd8722017-04-10 16:17:584591 return;
4592
[email protected]077e704b2014-05-23 19:24:104593 ContextMenuParams context_menu_params(params);
[email protected]a09d53ce2014-01-31 00:46:424594 // Allow WebContentsDelegates to handle the context menu operation first.
[email protected]077e704b2014-05-23 19:24:104595 if (delegate_ && delegate_->HandleContextMenu(context_menu_params))
[email protected]a09d53ce2014-01-31 00:46:424596 return;
4597
[email protected]077e704b2014-05-23 19:24:104598 render_view_host_delegate_view_->ShowContextMenu(render_frame_host,
4599 context_menu_params);
[email protected]a09d53ce2014-01-31 00:46:424600}
4601
avi777ff452017-02-09 19:04:484602void WebContentsImpl::RunJavaScriptDialog(RenderFrameHost* render_frame_host,
4603 const base::string16& message,
4604 const base::string16& default_prompt,
4605 const GURL& frame_url,
4606 JavaScriptDialogType dialog_type,
4607 IPC::Message* reply_msg) {
avi0720b02e2017-06-13 03:22:134608 // Running a dialog causes an exit to webpage-initiated fullscreen.
4609 // http://crbug.com/728276
4610 if (IsFullscreenForCurrentTab())
4611 ExitFullscreen(true);
4612
Pavel Feldman3c1842b2017-08-02 05:00:164613 base::Callback<void(bool, bool, const base::string16&)> callback =
4614 base::Bind(&WebContentsImpl::OnDialogClosed, base::Unretained(this),
4615 render_frame_host->GetProcess()->GetID(),
4616 render_frame_host->GetRoutingID(), reply_msg);
4617
[email protected]87de04b02014-04-08 22:14:494618 // Suppress JavaScript dialogs when requested. Also suppress messages when
4619 // showing an interstitial as it's shown over the previous page and we don't
4620 // want the hidden page's dialogs to interfere with the interstitial.
Pavel Feldman3c1842b2017-08-02 05:00:164621 bool suppress_this_message = ShowingInterstitialPage() || !delegate_ ||
4622 delegate_->ShouldSuppressDialogs(this);
4623 if (delegate_)
mathiash72a5e462014-11-19 08:18:504624 dialog_manager_ = delegate_->GetJavaScriptDialogManager(this);
Pavel Feldman3c1842b2017-08-02 05:00:164625
4626 std::vector<protocol::PageHandler*> page_handlers =
4627 protocol::PageHandler::EnabledForWebContents(this);
4628
4629 if (suppress_this_message || (!dialog_manager_ && !page_handlers.size())) {
4630 callback.Run(true, false, base::string16());
4631 return;
4632 }
4633
4634 scoped_refptr<CloseDialogCallbackWrapper> wrapper =
4635 new CloseDialogCallbackWrapper(callback);
4636 callback = base::Bind(&CloseDialogCallbackWrapper::Run, wrapper);
4637
4638 is_showing_javascript_dialog_ = true;
4639
4640 for (auto* handler : page_handlers) {
4641 handler->DidRunJavaScriptDialog(frame_url, message, default_prompt,
4642 dialog_type, base::Bind(callback, false));
4643 }
4644
4645 if (dialog_manager_) {
[email protected]87de04b02014-04-08 22:14:494646 dialog_manager_->RunJavaScriptDialog(
avi777ff452017-02-09 19:04:484647 this, frame_url, dialog_type, message, default_prompt,
Pavel Feldman3c1842b2017-08-02 05:00:164648 base::Bind(callback, false), &suppress_this_message);
[email protected]87de04b02014-04-08 22:14:494649 }
4650
4651 if (suppress_this_message) {
4652 // If we are suppressing messages, just reply as if the user immediately
4653 // pressed "Cancel", passing true to |dialog_was_suppressed|.
Pavel Feldman3c1842b2017-08-02 05:00:164654 callback.Run(true, false, base::string16());
[email protected]87de04b02014-04-08 22:14:494655 }
[email protected]87de04b02014-04-08 22:14:494656}
4657
4658void WebContentsImpl::RunBeforeUnloadConfirm(
[email protected]39f2f9252014-05-03 00:54:014659 RenderFrameHost* render_frame_host,
[email protected]87de04b02014-04-08 22:14:494660 bool is_reload,
4661 IPC::Message* reply_msg) {
avi0720b02e2017-06-13 03:22:134662 // Running a dialog causes an exit to webpage-initiated fullscreen.
4663 // http://crbug.com/728276
4664 if (IsFullscreenForCurrentTab())
4665 ExitFullscreen(true);
4666
[email protected]39f2f9252014-05-03 00:54:014667 RenderFrameHostImpl* rfhi =
4668 static_cast<RenderFrameHostImpl*>(render_frame_host);
[email protected]87de04b02014-04-08 22:14:494669 if (delegate_)
4670 delegate_->WillRunBeforeUnloadConfirm();
4671
Pavel Feldman3c1842b2017-08-02 05:00:164672 base::Callback<void(bool, bool, const base::string16&)> callback =
4673 base::Bind(&WebContentsImpl::OnDialogClosed, base::Unretained(this),
4674 render_frame_host->GetProcess()->GetID(),
4675 render_frame_host->GetRoutingID(), reply_msg);
4676
4677 bool suppress_this_message = !rfhi->is_active() ||
4678 ShowingInterstitialPage() || !delegate_ ||
4679 delegate_->ShouldSuppressDialogs(this);
4680 if (delegate_)
4681 dialog_manager_ = delegate_->GetJavaScriptDialogManager(this);
4682
4683 std::vector<protocol::PageHandler*> page_handlers =
4684 protocol::PageHandler::EnabledForWebContents(this);
4685
4686 if (suppress_this_message || (!dialog_manager_ && !page_handlers.size())) {
4687 callback.Run(false, true, base::string16());
[email protected]87de04b02014-04-08 22:14:494688 return;
4689 }
4690
4691 is_showing_before_unload_dialog_ = true;
Pavel Feldman3c1842b2017-08-02 05:00:164692
4693 scoped_refptr<CloseDialogCallbackWrapper> wrapper =
4694 new CloseDialogCallbackWrapper(callback);
4695 callback = base::Bind(&CloseDialogCallbackWrapper::Run, wrapper);
4696
4697 GURL frame_url = rfhi->GetLastCommittedURL();
4698 for (auto* handler : page_handlers) {
4699 handler->DidRunBeforeUnloadConfirm(frame_url, base::Bind(callback, false));
4700 }
4701
4702 if (dialog_manager_) {
4703 dialog_manager_->RunBeforeUnloadDialog(this, is_reload,
4704 base::Bind(callback, false));
4705 }
[email protected]87de04b02014-04-08 22:14:494706}
4707
naskoada75b22016-06-11 16:09:464708void WebContentsImpl::RunFileChooser(RenderFrameHost* render_frame_host,
4709 const FileChooserParams& params) {
4710 if (delegate_)
4711 delegate_->RunFileChooser(render_frame_host, params);
4712}
4713
[email protected]a86c0e962013-12-17 17:10:394714WebContents* WebContentsImpl::GetAsWebContents() {
4715 return this;
4716}
4717
mcnee336ea2c2017-05-23 22:50:594718#if !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:124719double WebContentsImpl::GetPendingPageZoomLevel() {
4720 NavigationEntry* pending_entry = GetController().GetPendingEntry();
4721 if (!pending_entry)
4722 return HostZoomMap::GetZoomLevel(this);
4723
4724 GURL url = pending_entry->GetURL();
4725 return HostZoomMap::GetForWebContents(this)->GetZoomLevelForHostAndScheme(
4726 url.scheme(), net::GetHostOrSpecFromURL(url));
4727}
mcnee336ea2c2017-05-23 22:50:594728#endif // !defined(OS_ANDROID)
wjmaclean64951902016-04-29 20:59:124729
qinmin72e8bd02016-10-21 19:35:374730bool WebContentsImpl::HideDownloadUI() const {
4731 return is_overlay_content_;
4732}
4733
mlamouri5cd9ae82017-02-18 11:05:094734bool WebContentsImpl::HasPersistentVideo() const {
4735 return has_persistent_video_;
4736}
4737
mlamourie52c1b542017-02-23 14:57:504738bool WebContentsImpl::HasActiveEffectivelyFullscreenVideo() const {
4739 return media_web_contents_observer_->HasActiveEffectivelyFullscreenVideo();
4740}
4741
ekaramada110f642016-12-21 19:47:284742bool WebContentsImpl::IsFocusedElementEditable() {
4743 RenderFrameHostImpl* frame = GetFocusedFrame();
4744 return frame && frame->has_focused_editable_element();
4745}
4746
ekaramadf6750aa2017-06-06 18:29:424747bool WebContentsImpl::IsShowingContextMenu() const {
4748 return showing_context_menu_;
4749}
4750
4751void WebContentsImpl::SetShowingContextMenu(bool showing) {
4752 DCHECK_NE(showing_context_menu_, showing);
4753 showing_context_menu_ = showing;
4754
4755 if (auto* view = GetRenderWidgetHostView()) {
4756 // Notify the main frame's RWHV to run the platform-specific code, if any.
4757 static_cast<RenderWidgetHostViewBase*>(view)->SetShowingContextMenu(
4758 showing);
4759 }
4760}
4761
ekaramada110f642016-12-21 19:47:284762void WebContentsImpl::ClearFocusedElement() {
4763 if (auto* frame = GetFocusedFrame())
4764 frame->ClearFocusedElement();
4765}
4766
[email protected]7912e822014-04-16 02:37:034767bool WebContentsImpl::IsNeverVisible() {
4768 if (!delegate_)
4769 return false;
4770 return delegate_->IsNeverVisible(this);
4771}
4772
[email protected]5a3bdf52012-05-24 15:12:574773RenderViewHostDelegateView* WebContentsImpl::GetDelegateView() {
4774 return render_view_host_delegate_view_;
[email protected]420ae012009-04-24 05:16:324775}
4776
[email protected]8ff00d72012-10-23 19:12:214777RendererPreferences WebContentsImpl::GetRendererPrefs(
4778 BrowserContext* browser_context) const {
[email protected]840b1512009-07-21 16:53:464779 return renderer_preferences_;
[email protected]80d96fa2009-06-10 22:34:514780}
4781
[email protected]7a846df2012-09-20 19:17:394782void WebContentsImpl::RemoveBrowserPluginEmbedder() {
[email protected]59383c782013-04-17 16:43:274783 if (browser_plugin_embedder_)
[email protected]7a846df2012-09-20 19:17:394784 browser_plugin_embedder_.reset();
4785}
4786
avallee0206f782016-07-28 18:55:334787WebContentsImpl* WebContentsImpl::GetOuterWebContents() {
lfg601233692017-03-06 22:45:444788 if (GuestMode::IsCrossProcessFrameGuest(this))
4789 return node_.outer_web_contents();
ekaramad1beabecc2016-09-23 20:18:174790
4791 if (browser_plugin_guest_)
4792 return browser_plugin_guest_->embedder_web_contents();
4793
avallee0206f782016-07-28 18:55:334794 return nullptr;
4795}
4796
4797WebContentsImpl* WebContentsImpl::GetFocusedWebContents() {
lfg601233692017-03-06 22:45:444798 return GetOutermostWebContents()->node_.focused_web_contents();
avallee0206f782016-07-28 18:55:334799}
4800
avallee9993fca2016-11-17 06:16:504801bool WebContentsImpl::ContainsOrIsFocusedWebContents() {
4802 for (WebContentsImpl* focused_contents = GetFocusedWebContents();
4803 focused_contents;
4804 focused_contents = focused_contents->GetOuterWebContents()) {
4805 if (focused_contents == this)
4806 return true;
4807 }
4808
4809 return false;
4810}
4811
avallee0206f782016-07-28 18:55:334812WebContentsImpl* WebContentsImpl::GetOutermostWebContents() {
4813 WebContentsImpl* root = this;
4814 while (root->GetOuterWebContents())
4815 root = root->GetOuterWebContents();
4816 return root;
4817}
4818
avalleed68cdd12017-06-21 22:07:274819void WebContentsImpl::FocusOuterAttachmentFrameChain() {
4820 WebContentsImpl* outer_contents = GetOuterWebContents();
4821 if (!outer_contents)
4822 return;
4823
4824 FrameTreeNode* outer_node =
4825 FrameTreeNode::GloballyFindByID(GetOuterDelegateFrameTreeNodeId());
4826 outer_contents->frame_tree_.SetFocusedFrame(outer_node, nullptr);
4827
4828 // For a browser initiated focus change, let embedding renderer know of the
4829 // change. Otherwise, if the currently focused element is just across a
4830 // process boundary in focus order, it will not be possible to move across
4831 // that boundary. This is because the target element will already be focused
4832 // (that renderer was not notified) and drop the event.
4833 if (GetRenderManager()->GetProxyToOuterDelegate())
4834 GetRenderManager()->GetProxyToOuterDelegate()->SetFocusedFrame();
4835
4836 outer_contents->FocusOuterAttachmentFrameChain();
4837}
4838
[email protected]b172aee2012-04-10 17:05:264839void WebContentsImpl::RenderViewCreated(RenderViewHost* render_view_host) {
[email protected]14392a52012-05-02 20:28:444840 // Don't send notifications if we are just creating a swapped-out RVH for
4841 // the opener chain. These won't be used for view-source or WebUI, so it's
4842 // ok to return early.
creiscce56cd2014-09-29 22:45:224843 if (!static_cast<RenderViewHostImpl*>(render_view_host)->is_active())
[email protected]14392a52012-05-02 20:28:444844 return;
4845
[email protected]86f98a22013-03-20 14:35:004846 if (delegate_)
[email protected]e85165c642014-06-10 14:34:314847 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]a6b73c62013-02-11 23:05:084848
[email protected]8ff00d72012-10-23 19:12:214849 NotificationService::current()->Notify(
4850 NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED,
4851 Source<WebContents>(this),
4852 Details<RenderViewHost>(render_view_host));
[email protected]420ae012009-04-24 05:16:324853
[email protected]60780f412013-02-25 16:34:104854 view_->RenderViewCreated(render_view_host);
[email protected]11f764bb2011-05-25 19:45:264855
ericwilligersde386342016-10-19 02:35:094856 for (auto& observer : observers_)
4857 observer.RenderViewCreated(render_view_host);
dgozmanf00c4f72016-10-19 17:45:154858 RenderFrameDevToolsAgentHost::WebContentsCreated(this);
[email protected]420ae012009-04-24 05:16:324859}
4860
[email protected]b172aee2012-04-10 17:05:264861void WebContentsImpl::RenderViewReady(RenderViewHost* rvh) {
[email protected]151a63d2011-12-20 22:32:524862 if (rvh != GetRenderViewHost()) {
[email protected]420ae012009-04-24 05:16:324863 // Don't notify the world, since this came from a renderer in the
4864 // background.
4865 return;
4866 }
4867
dmazzoni62111452017-04-28 23:46:554868 RenderWidgetHostViewBase* rwhv =
4869 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
4870 if (rwhv)
4871 rwhv->SetMainFrameAXTreeID(GetMainFrame()->GetAXTreeID());
4872
[email protected]da7a7182013-09-06 08:11:114873 notify_disconnection_ = true;
4874 // TODO(avi): Remove. http://crbug.com/170921
4875 NotificationService::current()->Notify(
4876 NOTIFICATION_WEB_CONTENTS_CONNECTED,
4877 Source<WebContents>(this),
4878 NotificationService::NoDetails());
4879
[email protected]be1f56ab2011-12-22 06:55:314880 bool was_crashed = IsCrashed();
[email protected]443b80e2010-12-14 00:42:234881 SetIsCrashed(base::TERMINATION_STATUS_STILL_RUNNING, 0);
[email protected]9d8a4642009-07-29 17:25:304882
4883 // Restore the focus to the tab (otherwise the focus will be on the top
4884 // window).
[email protected]484ae5912010-09-29 19:16:144885 if (was_crashed && !FocusLocationBarByDefault() &&
4886 (!delegate_ || delegate_->ShouldFocusPageAfterCrash())) {
[email protected]f3615f02013-02-26 06:09:064887 view_->Focus();
[email protected]484ae5912010-09-29 19:16:144888 }
[email protected]32ded2212011-11-10 18:51:434889
ericwilligersde386342016-10-19 02:35:094890 for (auto& observer : observers_)
4891 observer.RenderViewReady();
[email protected]420ae012009-04-24 05:16:324892}
4893
[email protected]ec6a7eb2013-04-22 17:34:224894void WebContentsImpl::RenderViewTerminated(RenderViewHost* rvh,
4895 base::TerminationStatus status,
4896 int error_code) {
[email protected]151a63d2011-12-20 22:32:524897 if (rvh != GetRenderViewHost()) {
[email protected]420ae012009-04-24 05:16:324898 // The pending page's RenderViewHost is gone.
4899 return;
4900 }
4901
[email protected]2fcdcc32014-03-05 02:14:074902 // Ensure fullscreen mode is exited in the |delegate_| since a crashed
4903 // renderer may not have made a clean exit.
alexmos5dd617d2016-06-07 04:21:154904 if (IsFullscreenForCurrentTab())
bokanece34a82016-01-28 19:49:464905 ExitFullscreenMode(false);
[email protected]2fcdcc32014-03-05 02:14:074906
[email protected]698191dc2014-02-25 01:06:134907 // Cancel any visible dialogs so they are not left dangling over the sad tab.
creis89a0f782015-05-27 16:13:174908 CancelActiveAndPendingDialogs();
[email protected]698191dc2014-02-25 01:06:134909
dalecurtis3d1e1302017-02-20 22:33:254910 audio_stream_monitor_.RenderProcessGone(rvh->GetProcess()->GetID());
4911
[email protected]960b0372014-05-19 18:01:004912 // Reset the loading progress. TODO(avi): What does it mean to have a
4913 // "renderer crash" when there is more than one renderer process serving a
4914 // webpage? Once this function is called at a more granular frame level, we
4915 // probably will need to more granularly reset the state here.
4916 ResetLoadProgressState();
clamy44e84ce2016-02-22 15:38:254917 NotifyDisconnected();
4918 SetIsCrashed(status, error_code);
[email protected]960b0372014-05-19 18:01:004919
ericwilligersde386342016-10-19 02:35:094920 for (auto& observer : observers_)
4921 observer.RenderProcessGone(GetCrashedStatus());
[email protected]420ae012009-04-24 05:16:324922}
4923
[email protected]b172aee2012-04-10 17:05:264924void WebContentsImpl::RenderViewDeleted(RenderViewHost* rvh) {
ericwilligersde386342016-10-19 02:35:094925 for (auto& observer : observers_)
4926 observer.RenderViewDeleted(rvh);
[email protected]2e4633c2009-07-09 16:58:064927}
4928
sky8b00392d2015-01-10 00:30:284929void WebContentsImpl::UpdateTargetURL(RenderViewHost* render_view_host,
4930 const GURL& url) {
4931 if (fullscreen_widget_routing_id_ != MSG_ROUTING_NONE) {
4932 // If we're fullscreen only update the url if it's from the fullscreen
4933 // renderer.
4934 RenderWidgetHostView* fs = GetFullscreenRenderWidgetHostView();
avif9ab5d942015-10-15 14:05:444935 if (fs && fs->GetRenderWidgetHost() != render_view_host->GetWidget())
sky8b00392d2015-01-10 00:30:284936 return;
4937 }
[email protected]6934a702011-12-20 00:04:514938 if (delegate_)
avi450ce00e2014-09-24 01:58:524939 delegate_->UpdateTargetURL(this, url);
[email protected]420ae012009-04-24 05:16:324940}
4941
[email protected]b172aee2012-04-10 17:05:264942void WebContentsImpl::Close(RenderViewHost* rvh) {
[email protected]60780f412013-02-25 16:34:104943#if defined(OS_MACOSX)
[email protected]07707302009-11-06 00:50:294944 // The UI may be in an event-tracking loop, such as between the
4945 // mouse-down and mouse-up in text selection or a button click.
4946 // Defer the close until after tracking is complete, so that we
4947 // don't free objects out from under the UI.
[email protected]07707302009-11-06 00:50:294948 // TODO(shess): This could get more fine-grained. For instance,
4949 // closing a tab in another window while selecting text in the
4950 // current window's Omnibox should be just fine.
[email protected]60780f412013-02-25 16:34:104951 if (view_->IsEventTracking()) {
4952 view_->CloseTabAfterEventTracking();
[email protected]07707302009-11-06 00:50:294953 return;
4954 }
[email protected]60780f412013-02-25 16:34:104955#endif
[email protected]07707302009-11-06 00:50:294956
[email protected]420ae012009-04-24 05:16:324957 // Ignore this if it comes from a RenderViewHost that we aren't showing.
[email protected]151a63d2011-12-20 22:32:524958 if (delegate_ && rvh == GetRenderViewHost())
[email protected]6934a702011-12-20 00:04:514959 delegate_->CloseContents(this);
[email protected]420ae012009-04-24 05:16:324960}
4961
[email protected]b172aee2012-04-10 17:05:264962void WebContentsImpl::RequestMove(const gfx::Rect& new_bounds) {
[email protected]6934a702011-12-20 00:04:514963 if (delegate_ && delegate_->IsPopupOrPanel(this))
4964 delegate_->MoveContents(this, new_bounds);
[email protected]420ae012009-04-24 05:16:324965}
4966
fdegansa696e5112015-04-17 01:57:594967void WebContentsImpl::DidStartLoading(FrameTreeNode* frame_tree_node,
[email protected]e3b10d12014-03-28 16:06:094968 bool to_different_document) {
Evan Stadec3b26022017-07-14 19:50:244969 LoadingStateChanged(frame_tree_node->IsMainFrame() && to_different_document,
4970 false, nullptr);
dmazzonibf8cec42015-02-08 08:28:084971
4972 // Notify accessibility that the user is navigating away from the
4973 // current document.
4974 //
4975 // TODO(dmazzoni): do this using a WebContentsObserver.
dmazzonibf8cec42015-02-08 08:28:084976 BrowserAccessibilityManager* manager =
fdegansa696e5112015-04-17 01:57:594977 frame_tree_node->current_frame_host()->browser_accessibility_manager();
dmazzonibf8cec42015-02-08 08:28:084978 if (manager)
4979 manager->UserIsNavigatingAway();
[email protected]420ae012009-04-24 05:16:324980}
4981
fdegansc73eec22015-03-19 14:47:544982void WebContentsImpl::DidStopLoading() {
dcheng59716272016-04-09 05:19:084983 std::unique_ptr<LoadNotificationDetails> details;
[email protected]420ae012009-04-24 05:16:324984
[email protected]9595fd82013-04-19 21:28:494985 // Use the last committed entry rather than the active one, in case a
4986 // pending entry has been created.
4987 NavigationEntry* entry = controller_.GetLastCommittedEntry();
[email protected]3691e5cf2014-01-22 10:16:204988 Navigator* navigator = frame_tree_.root()->navigator();
[email protected]9595fd82013-04-19 21:28:494989
[email protected]420ae012009-04-24 05:16:324990 // An entry may not exist for a stop when loading an initial blank page or
4991 // if an iframe injected by script into a blank page finishes loading.
4992 if (entry) {
[email protected]3691e5cf2014-01-22 10:16:204993 base::TimeDelta elapsed =
4994 base::TimeTicks::Now() - navigator->GetCurrentLoadStart();
[email protected]420ae012009-04-24 05:16:324995
4996 details.reset(new LoadNotificationDetails(
[email protected]36fc0392011-12-25 03:59:514997 entry->GetVirtualURL(),
[email protected]420ae012009-04-24 05:16:324998 elapsed,
4999 &controller_,
5000 controller_.GetCurrentEntryIndex()));
5001 }
5002
clamy44e84ce2016-02-22 15:38:255003 LoadingStateChanged(true, false, details.get());
[email protected]420ae012009-04-24 05:16:325004}
5005
fdegansa696e5112015-04-17 01:57:595006void WebContentsImpl::DidChangeLoadProgress() {
5007 double load_progress = frame_tree_.load_progress();
5008
5009 // The delegate is notified immediately for the first and last updates. Also,
5010 // since the message loop may be pretty busy when a page is loaded, it might
5011 // not execute a posted task in a timely manner so the progress report is sent
5012 // immediately if enough time has passed.
5013 base::TimeDelta min_delay =
5014 base::TimeDelta::FromMilliseconds(kMinimumDelayBetweenLoadingUpdatesMS);
5015 bool delay_elapsed = loading_last_progress_update_.is_null() ||
5016 base::TimeTicks::Now() - loading_last_progress_update_ > min_delay;
5017
5018 if (load_progress == 0.0 || load_progress == 1.0 || delay_elapsed) {
5019 // If there is a pending task to send progress, it is now obsolete.
5020 loading_weak_factory_.InvalidateWeakPtrs();
5021
5022 // Notify the load progress change.
5023 SendChangeLoadProgress();
5024
5025 // Clean-up the states if needed.
5026 if (load_progress == 1.0)
5027 ResetLoadProgressState();
5028 return;
5029 }
5030
5031 if (loading_weak_factory_.HasWeakPtrs())
5032 return;
5033
skyostil95082a62015-06-05 19:53:075034 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
5035 FROM_HERE, base::Bind(&WebContentsImpl::SendChangeLoadProgress,
5036 loading_weak_factory_.GetWeakPtr()),
fdegansa696e5112015-04-17 01:57:595037 min_delay);
5038}
5039
avid6d88b912017-01-13 00:16:005040std::vector<std::unique_ptr<NavigationThrottle>>
5041WebContentsImpl::CreateThrottlesForNavigation(
clamycbf524d42016-09-27 12:48:355042 NavigationHandle* navigation_handle) {
5043 return GetContentClient()->browser()->CreateThrottlesForNavigation(
5044 navigation_handle);
5045}
5046
clamy1e5574e2016-09-29 16:48:445047std::unique_ptr<NavigationUIData> WebContentsImpl::GetNavigationUIData(
5048 NavigationHandle* navigation_handle) {
5049 DCHECK(IsBrowserSideNavigationEnabled());
5050 return GetContentClient()->browser()->GetNavigationUIData(navigation_handle);
5051}
5052
pdr15f5b5b2017-06-20 00:58:005053void WebContentsImpl::DidCancelLoading() {
5054 controller_.DiscardNonCommittedEntries();
5055
5056 // Update the URL display.
5057 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
5058}
5059
[email protected]59167c22013-06-03 18:07:325060void WebContentsImpl::DidAccessInitialDocument() {
[email protected]b4c84012014-04-28 19:51:105061 has_accessed_initial_document_ = true;
5062
[email protected]d1371bf8e2014-04-19 03:26:245063 // We may have left a failed browser-initiated navigation in the address bar
5064 // to let the user edit it and try again. Clear it now that content might
5065 // show up underneath it.
5066 if (!IsLoading() && controller_.GetPendingEntry())
avi45a72532015-04-07 21:01:455067 controller_.DiscardPendingEntry(false);
[email protected]d1371bf8e2014-04-19 03:26:245068
[email protected]59167c22013-06-03 18:07:325069 // Update the URL display.
thestigc4cac8f2014-09-04 21:17:505070 NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
[email protected]59167c22013-06-03 18:07:325071}
5072
alexmosbe2f4c32015-03-10 02:30:235073void WebContentsImpl::DidChangeName(RenderFrameHost* render_frame_host,
5074 const std::string& name) {
ericwilligersde386342016-10-19 02:35:095075 for (auto& observer : observers_)
5076 observer.FrameNameChanged(render_frame_host, name);
alexmosbe2f4c32015-03-10 02:30:235077}
5078
[email protected]39f2f9252014-05-03 00:54:015079void WebContentsImpl::DocumentOnLoadCompleted(
[email protected]50279492014-05-05 23:24:295080 RenderFrameHost* render_frame_host) {
falken52a56e32016-12-08 05:02:405081 ShowInsecureLocalhostWarningIfNeeded();
5082
creis97867aa2017-02-17 18:39:455083 is_notifying_observers_ = true;
ericwilligersde386342016-10-19 02:35:095084 for (auto& observer : observers_)
5085 observer.DocumentOnLoadCompletedInMainFrame();
creis97867aa2017-02-17 18:39:455086 is_notifying_observers_ = false;
[email protected]6578fef2013-10-14 02:35:095087
5088 // TODO(avi): Remove. http://crbug.com/170921
[email protected]8ff00d72012-10-23 19:12:215089 NotificationService::current()->Notify(
5090 NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
5091 Source<WebContents>(this),
[email protected]50279492014-05-05 23:24:295092 NotificationService::NoDetails());
[email protected]25497492010-09-11 15:15:085093}
5094
creis8eb8ef22015-11-04 22:51:385095void WebContentsImpl::UpdateStateForFrame(RenderFrameHost* render_frame_host,
5096 const PageState& page_state) {
creis8eb8ef22015-11-04 22:51:385097 // The state update affects the last NavigationEntry associated with the given
5098 // |render_frame_host|. This may not be the last committed NavigationEntry (as
5099 // in the case of an UpdateState from a frame being swapped out). We track
5100 // which entry this is in the RenderFrameHost's nav_entry_id.
5101 RenderFrameHostImpl* rfhi =
5102 static_cast<RenderFrameHostImpl*>(render_frame_host);
5103 NavigationEntryImpl* entry =
5104 controller_.GetEntryWithUniqueID(rfhi->nav_entry_id());
5105 if (!entry)
5106 return;
5107
5108 FrameNavigationEntry* frame_entry =
5109 entry->GetFrameEntry(rfhi->frame_tree_node());
5110 if (!frame_entry)
5111 return;
5112
creisd06a9422015-11-11 03:08:455113 // The SiteInstance might not match if we do a cross-process navigation with
5114 // replacement (e.g., auto-subframe), in which case the swap out of the old
5115 // RenderFrameHost runs in the background after the old FrameNavigationEntry
5116 // has already been replaced and destroyed.
5117 if (frame_entry->site_instance() != rfhi->GetSiteInstance())
5118 return;
5119
creis8eb8ef22015-11-04 22:51:385120 if (page_state == frame_entry->page_state())
5121 return; // Nothing to update.
5122
creis0cade2e2017-02-28 06:37:475123 DCHECK(page_state.IsValid()) << "Shouldn't set an empty PageState.";
nasko34634672016-07-29 18:46:065124
5125 // The document_sequence_number and item_sequence_number recorded in the
5126 // FrameNavigationEntry should not differ from the one coming with the update,
5127 // since it must come from the same document. Do not update it if a difference
5128 // is detected, as this indicates that |frame_entry| is not the correct one.
5129 ExplodedPageState exploded_state;
5130 if (!DecodePageState(page_state.ToEncodedData(), &exploded_state))
5131 return;
5132
5133 if (exploded_state.top.document_sequence_number !=
5134 frame_entry->document_sequence_number() ||
5135 exploded_state.top.item_sequence_number !=
5136 frame_entry->item_sequence_number()) {
5137 return;
5138 }
5139
nasko04a322f25a2016-09-01 00:00:345140 frame_entry->SetPageState(page_state);
creis8eb8ef22015-11-04 22:51:385141 controller_.NotifyEntryChanged(entry);
5142}
5143
[email protected]ef3adfc2014-05-11 00:04:545144void WebContentsImpl::UpdateTitle(RenderFrameHost* render_frame_host,
[email protected]ef3adfc2014-05-11 00:04:545145 const base::string16& title,
5146 base::i18n::TextDirection title_direction) {
[email protected]ef3adfc2014-05-11 00:04:545147 // If we have a title, that's a pretty good indication that we've started
5148 // getting useful data.
5149 SetNotWaitingForResponse();
5150
5151 // Try to find the navigation entry, which might not be the current one.
avi286019ce2015-07-29 01:26:585152 // For example, it might be from a recently swapped out RFH.
avi1edc8552016-10-13 21:37:165153 NavigationEntryImpl* entry = controller_.GetEntryWithUniqueID(
creisad8c31a2016-05-24 17:07:045154 static_cast<RenderFrameHostImpl*>(render_frame_host)->nav_entry_id());
[email protected]ef3adfc2014-05-11 00:04:545155
5156 // We can handle title updates when we don't have an entry in
5157 // UpdateTitleForEntry, but only if the update is from the current RVH.
5158 // TODO(avi): Change to make decisions based on the RenderFrameHost.
avi286019ce2015-07-29 01:26:585159 if (!entry && render_frame_host != GetMainFrame())
[email protected]ef3adfc2014-05-11 00:04:545160 return;
5161
5162 // TODO(evan): make use of title_direction.
5163 // http://code.google.com/p/chromium/issues/detail?id=27094
afakhry6f0c1ec22016-07-14 13:55:135164 UpdateTitleForEntry(entry, title);
[email protected]ef3adfc2014-05-11 00:04:545165}
5166
5167void WebContentsImpl::UpdateEncoding(RenderFrameHost* render_frame_host,
5168 const std::string& encoding) {
5169 SetEncoding(encoding);
5170}
5171
[email protected]39f2f9252014-05-03 00:54:015172void WebContentsImpl::DocumentAvailableInMainFrame(
5173 RenderViewHost* render_view_host) {
ericwilligersde386342016-10-19 02:35:095174 for (auto& observer : observers_)
5175 observer.DocumentAvailableInMainFrame();
[email protected]39f2f9252014-05-03 00:54:015176}
naskoc0fceff2015-04-30 15:53:525177
[email protected]e1c3a552012-05-04 20:51:325178void WebContentsImpl::RouteCloseEvent(RenderViewHost* rvh) {
5179 // Tell the active RenderViewHost to run unload handlers and close, as long
5180 // as the request came from a RenderViewHost in the same BrowsingInstance.
5181 // In most cases, we receive this from a swapped out RenderViewHost.
5182 // It is possible to receive it from one that has just been swapped in,
5183 // in which case we might as well deliver the message anyway.
5184 if (rvh->GetSiteInstance()->IsRelatedSiteInstance(GetSiteInstance()))
naskoc0fceff2015-04-30 15:53:525185 ClosePage();
[email protected]e1c3a552012-05-04 20:51:325186}
5187
alexmose7da5a12015-04-09 02:22:165188bool WebContentsImpl::ShouldRouteMessageEvent(
5189 RenderFrameHost* target_rfh,
5190 SiteInstance* source_site_instance) const {
5191 // Allow the message if this WebContents is dedicated to a browser plugin
5192 // guest.
[email protected]0eba810b2012-10-18 03:19:365193 // Note: This check means that an embedder could theoretically receive a
5194 // postMessage from anyone (not just its own guests). However, this is
5195 // probably not a risk for apps since other pages won't have references
5196 // to App windows.
alexmose7da5a12015-04-09 02:22:165197 return GetBrowserPluginGuest() || GetBrowserPluginEmbedder();
5198}
[email protected]f546640b2012-05-15 00:03:495199
alexmos58729042015-06-18 23:20:005200void WebContentsImpl::EnsureOpenerProxiesExist(RenderFrameHost* source_rfh) {
alexmose7da5a12015-04-09 02:22:165201 WebContentsImpl* source_web_contents = static_cast<WebContentsImpl*>(
5202 WebContents::FromRenderFrameHost(source_rfh));
[email protected]f546640b2012-05-15 00:03:495203
alexmose7da5a12015-04-09 02:22:165204 if (source_web_contents) {
lazyboy6ec48b2a2015-06-29 15:18:145205 // If this message is going to outer WebContents from inner WebContents,
5206 // then we should not create a RenderView. AttachToOuterWebContentsFrame()
5207 // already created a RenderFrameProxyHost for that purpose.
5208 if (GetBrowserPluginEmbedder() &&
ekaramad1beabecc2016-09-23 20:18:175209 GuestMode::IsCrossProcessFrameGuest(source_web_contents)) {
lazyboy6ec48b2a2015-06-29 15:18:145210 return;
5211 }
5212
lfg812874d2016-02-09 22:26:135213 if (this != source_web_contents && GetBrowserPluginGuest()) {
naskob3041b98a42016-03-12 04:43:065214 // We create a RenderFrameProxyHost for the embedder in the guest's render
5215 // process but we intentionally do not expose the embedder's opener chain
5216 // to it.
5217 source_web_contents->GetRenderManager()->CreateRenderFrameProxy(
5218 GetSiteInstance());
[email protected]f546640b2012-05-15 00:03:495219 } else {
alexmos58729042015-06-18 23:20:005220 RenderFrameHostImpl* source_rfhi =
5221 static_cast<RenderFrameHostImpl*>(source_rfh);
5222 source_rfhi->frame_tree_node()->render_manager()->CreateOpenerProxies(
alexmos90325cf2015-09-02 17:18:395223 GetSiteInstance(), nullptr);
[email protected]f546640b2012-05-15 00:03:495224 }
5225 }
[email protected]f546640b2012-05-15 00:03:495226}
5227
avallee9993fca2016-11-17 06:16:505228void WebContentsImpl::SetAsFocusedWebContentsIfNecessary() {
5229 // Only change focus if we are not currently focused.
5230 WebContentsImpl* old_contents = GetFocusedWebContents();
5231 if (old_contents == this)
5232 return;
5233
paulmeyerfeafc2d2017-04-25 21:46:405234 GetOutermostWebContents()->node_.SetFocusedWebContents(this);
5235
5236 if (!GuestMode::IsCrossProcessFrameGuest(this) && browser_plugin_guest_)
5237 return;
5238
avallee9993fca2016-11-17 06:16:505239 // Send a page level blur to the old contents so that it displays inactive UI
5240 // and focus this contents to activate it.
5241 if (old_contents)
5242 old_contents->GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(false);
avalleec2ff1ef2017-01-21 00:12:305243
5244 // Make sure the outer web contents knows our frame is focused. Otherwise, the
5245 // outer renderer could have the element before or after the frame element
5246 // focused which would return early without actually advancing focus.
avalleed68cdd12017-06-21 22:07:275247 FocusOuterAttachmentFrameChain();
avalleec2ff1ef2017-01-21 00:12:305248
lfg1453e412017-04-11 00:48:505249 if (ShowingInterstitialPage()) {
creisadca9862017-06-16 19:12:115250 static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
lfg1453e412017-04-11 00:48:505251 ->GetRenderWidgetHost()
5252 ->SetPageFocus(true);
5253 } else {
5254 GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(true);
5255 }
avallee9993fca2016-11-17 06:16:505256}
5257
avallee0206f782016-07-28 18:55:335258void WebContentsImpl::SetFocusedFrame(FrameTreeNode* node,
5259 SiteInstance* source) {
avallee9993fca2016-11-17 06:16:505260 SetAsFocusedWebContentsIfNecessary();
avalleed68cdd12017-06-21 22:07:275261
avallee0206f782016-07-28 18:55:335262 frame_tree_.SetFocusedFrame(node, source);
avalleed68cdd12017-06-21 22:07:275263
5264 WebContentsImpl* inner_contents = node_.GetInnerWebContentsInFrame(node);
5265
5266 WebContentsImpl* contents_to_focus = inner_contents ? inner_contents : this;
5267 contents_to_focus->SetAsFocusedWebContentsIfNecessary();
5268}
5269
5270RenderFrameHost* WebContentsImpl::GetFocusedFrameIncludingInnerWebContents() {
5271 WebContentsImpl* contents = this;
5272 FrameTreeNode* focused_node = contents->frame_tree_.GetFocusedFrame();
5273
5274 // If there is no focused frame in the outer WebContents, we need to return
5275 // null.
5276 if (!focused_node)
5277 return nullptr;
5278
5279 // If the focused frame is embedding an inner WebContents, we must descend
5280 // into that contents. If the current WebContents does not have a focused
5281 // frame, return the main frame of this contents instead of the focused empty
5282 // frame embedding this contents.
5283 while (true) {
5284 contents = contents->node_.GetInnerWebContentsInFrame(focused_node);
5285 if (!contents)
5286 return focused_node->current_frame_host();
5287
5288 focused_node = contents->frame_tree_.GetFocusedFrame();
5289 if (!focused_node)
5290 return contents->GetMainFrame();
5291 }
avallee0206f782016-07-28 18:55:335292}
5293
ekaramada110f642016-12-21 19:47:285294void WebContentsImpl::OnFocusedElementChangedInFrame(
5295 RenderFrameHostImpl* frame,
5296 const gfx::Rect& bounds_in_root_view) {
5297 RenderWidgetHostViewBase* root_view =
5298 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
5299 if (!root_view || !frame->GetView())
5300 return;
5301
5302 // Converting to screen coordinates.
5303 gfx::Point origin = bounds_in_root_view.origin();
5304 origin += root_view->GetViewBounds().OffsetFromOrigin();
5305 gfx::Rect bounds_in_screen(origin, bounds_in_root_view.size());
5306
5307 root_view->FocusedNodeChanged(frame->has_focused_editable_element(),
5308 bounds_in_screen);
5309
5310 FocusedNodeDetails details = {frame->has_focused_editable_element(),
5311 bounds_in_screen};
5312
5313 // TODO(ekaramad): We should replace this with an observer notification
5314 // (https://crbug.com/675975).
5315 NotificationService::current()->Notify(
5316 NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
5317 Source<RenderViewHost>(GetRenderViewHost()),
5318 Details<FocusedNodeDetails>(&details));
5319}
5320
avia90ae4e2016-11-11 20:49:335321bool WebContentsImpl::DidAddMessageToConsole(int32_t level,
5322 const base::string16& message,
5323 int32_t line_no,
5324 const base::string16& source_id) {
[email protected]a796f202012-05-30 14:14:255325 if (!delegate_)
5326 return false;
avia90ae4e2016-11-11 20:49:335327 return delegate_->DidAddMessageToConsole(this, level, message, line_no,
5328 source_id);
[email protected]a796f202012-05-30 14:14:255329}
5330
dominickn9c7ceaa32016-02-27 01:52:535331void WebContentsImpl::OnUserInteraction(
5332 RenderWidgetHostImpl* render_widget_host,
5333 const blink::WebInputEvent::Type type) {
kenrb19221852016-04-29 17:21:405334 // Ignore unless the widget is currently in the frame tree.
5335 if (!HasMatchingWidgetHost(&frame_tree_, render_widget_host))
avic3aa8422015-11-09 20:57:225336 return;
5337
ericwilligersde386342016-10-19 02:35:095338 for (auto& observer : observers_)
5339 observer.DidGetUserInteraction(type);
dominickn9c7ceaa32016-02-27 01:52:535340
5341 ResourceDispatcherHostImpl* rdh = ResourceDispatcherHostImpl::Get();
5342 // Exclude scroll events as user gestures for resource load dispatches.
5343 // rdh is NULL in unittests.
Blink Reformat1c4d759e2017-04-09 16:34:545344 if (rdh && type != blink::WebInputEvent::kMouseWheel)
scottmge22a5e52016-06-30 00:36:515345 rdh->OnUserGesture();
dominickn2dd142dd2015-10-29 05:30:505346}
5347
avallee9993fca2016-11-17 06:16:505348void WebContentsImpl::FocusOwningWebContents(
5349 RenderWidgetHostImpl* render_widget_host) {
5350 // The PDF plugin still runs as a BrowserPlugin and must go through the
5351 // input redirection mechanism. It must not become focused direcly.
5352 if (!GuestMode::IsCrossProcessFrameGuest(this) && browser_plugin_guest_)
5353 return;
5354
5355 RenderWidgetHostImpl* focused_widget =
5356 GetFocusedRenderWidgetHost(render_widget_host);
5357
5358 if (focused_widget != render_widget_host &&
avallee8e881592016-11-19 00:39:305359 (!focused_widget ||
5360 focused_widget->delegate() != render_widget_host->delegate())) {
avallee9993fca2016-11-17 06:16:505361 SetAsFocusedWebContentsIfNecessary();
5362 }
5363}
5364
[email protected]b172aee2012-04-10 17:05:265365void WebContentsImpl::OnIgnoredUIEvent() {
[email protected]31145092011-09-30 01:49:445366 // Notify observers.
ericwilligersde386342016-10-19 02:35:095367 for (auto& observer : observers_)
5368 observer.DidGetIgnoredUIEvent();
[email protected]fa1cf0b82010-01-15 21:49:445369}
5370
avic3aa8422015-11-09 20:57:225371void WebContentsImpl::RendererUnresponsive(
avice799302017-03-09 16:34:595372 RenderWidgetHostImpl* render_widget_host) {
ericwilligersde386342016-10-19 02:35:095373 for (auto& observer : observers_)
5374 observer.OnRendererUnresponsive(render_widget_host);
afakhry98241832016-03-11 19:27:475375
[email protected]992db4c2011-05-12 15:37:155376 // Don't show hung renderer dialog for a swapped out RVH.
avic3aa8422015-11-09 20:57:225377 if (render_widget_host != GetRenderViewHost()->GetWidget())
[email protected]992db4c2011-05-12 15:37:155378 return;
5379
avic031d392017-03-03 03:09:425380 if (ShouldIgnoreUnresponsiveRenderer())
[email protected]e5fc1632011-08-08 07:51:535381 return;
5382
creisc014b402015-04-23 16:41:455383 if (!GetRenderViewHost() || !GetRenderViewHost()->IsRenderViewLive())
[email protected]55452902011-06-01 21:57:475384 return;
5385
dtapuskae99ec6e52016-10-18 00:15:425386 if (delegate_) {
5387 WebContentsUnresponsiveState unresponsive_state;
dtapuskae99ec6e52016-10-18 00:15:425388 unresponsive_state.outstanding_ack_count =
5389 render_widget_host->in_flight_event_count();
5390 unresponsive_state.outstanding_event_type =
5391 render_widget_host->hang_monitor_event_type();
5392 unresponsive_state.last_event_type = render_widget_host->last_event_type();
5393 delegate_->RendererUnresponsive(this, unresponsive_state);
5394 }
[email protected]420ae012009-04-24 05:16:325395}
5396
avic3aa8422015-11-09 20:57:225397void WebContentsImpl::RendererResponsive(
5398 RenderWidgetHostImpl* render_widget_host) {
5399 if (render_widget_host != GetRenderViewHost()->GetWidget())
5400 return;
5401
[email protected]6934a702011-12-20 00:04:515402 if (delegate_)
5403 delegate_->RendererResponsive(this);
[email protected]420ae012009-04-24 05:16:325404}
5405
[email protected]b172aee2012-04-10 17:05:265406void WebContentsImpl::BeforeUnloadFiredFromRenderManager(
[email protected]feaded02012-09-25 19:12:555407 bool proceed, const base::TimeTicks& proceed_time,
[email protected]420ae012009-04-24 05:16:325408 bool* proceed_to_fire_unload) {
ericwilligersde386342016-10-19 02:35:095409 for (auto& observer : observers_)
5410 observer.BeforeUnloadFired(proceed_time);
[email protected]6934a702011-12-20 00:04:515411 if (delegate_)
5412 delegate_->BeforeUnloadFired(this, proceed, proceed_to_fire_unload);
[email protected]e80af492013-06-24 21:52:095413 // Note: |this| might be deleted at this point.
[email protected]420ae012009-04-24 05:16:325414}
5415
[email protected]58d5cfe2013-07-10 02:40:525416void WebContentsImpl::RenderProcessGoneFromRenderManager(
[email protected]3a3d47472010-07-15 21:03:545417 RenderViewHost* render_view_host) {
[email protected]443b80e2010-12-14 00:42:235418 DCHECK(crashed_status_ != base::TERMINATION_STATUS_STILL_RUNNING);
[email protected]ec6a7eb2013-04-22 17:34:225419 RenderViewTerminated(render_view_host, crashed_status_, crashed_error_code_);
[email protected]3a3d47472010-07-15 21:03:545420}
5421
[email protected]b172aee2012-04-10 17:05:265422void WebContentsImpl::UpdateRenderViewSizeForRenderManager() {
[email protected]8643e6d2012-01-18 20:26:105423 // TODO(brettw) this is a hack. See WebContentsView::SizeContents.
[email protected]dc0fd432013-08-27 15:29:215424 gfx::Size size = GetSizeForNewRenderView();
[email protected]0323ee42010-02-17 22:03:265425 // 0x0 isn't a valid window size (minimal window size is 1x1) but it may be
5426 // here during container initialization and normal window size will be set
5427 // later. In case of tab duplication this resizing to 0x0 prevents setting
5428 // normal size later so just ignore it.
5429 if (!size.IsEmpty())
5430 view_->SizeContents(size);
[email protected]420ae012009-04-24 05:16:325431}
5432
[email protected]af905902013-10-01 21:38:515433void WebContentsImpl::CancelModalDialogsForRenderManager() {
5434 // We need to cancel modal dialogs when doing a process swap, since the load
avi2460c762015-04-17 15:21:545435 // deferrer would prevent us from swapping out. We also clear the state
5436 // because this is a cross-process navigation, which means that it's a new
5437 // site that should not have to pay for the sins of its predecessor.
creis89a0f782015-05-27 16:13:175438 //
5439 // Note that we don't bother telling browser_plugin_embedder_ because the
5440 // cross-process navigation will either destroy the browser plugins or not
5441 // require their dialogs to close.
avi5d3b8692016-10-12 22:00:465442 if (dialog_manager_) {
avi6879fcf2017-01-21 05:27:535443 dialog_manager_->CancelDialogs(this, /*reset_state=*/true);
avi5d3b8692016-10-12 22:00:465444 }
[email protected]af905902013-10-01 21:38:515445}
5446
[email protected]02d7b6e2014-06-24 21:01:505447void WebContentsImpl::NotifySwappedFromRenderManager(RenderFrameHost* old_host,
5448 RenderFrameHost* new_host,
5449 bool is_main_frame) {
5450 if (is_main_frame) {
naskof5940b9f2015-03-02 23:04:055451 NotifyViewSwapped(old_host ? old_host->GetRenderViewHost() : nullptr,
[email protected]02d7b6e2014-06-24 21:01:505452 new_host->GetRenderViewHost());
[email protected]a6b73c62013-02-11 23:05:085453
[email protected]02d7b6e2014-06-24 21:01:505454 // Make sure the visible RVH reflects the new delegate's preferences.
5455 if (delegate_)
5456 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
[email protected]d56a49e2013-02-23 00:47:395457
[email protected]02d7b6e2014-06-24 21:01:505458 view_->RenderViewSwappedIn(new_host->GetRenderViewHost());
dmazzoni62111452017-04-28 23:46:555459
5460 RenderWidgetHostViewBase* rwhv =
5461 static_cast<RenderWidgetHostViewBase*>(GetRenderWidgetHostView());
5462 if (rwhv)
5463 rwhv->SetMainFrameAXTreeID(GetMainFrame()->GetAXTreeID());
[email protected]02d7b6e2014-06-24 21:01:505464 }
5465
5466 NotifyFrameSwapped(old_host, new_host);
[email protected]3a3d47472010-07-15 21:03:545467}
5468
naskof5940b9f2015-03-02 23:04:055469void WebContentsImpl::NotifyMainFrameSwappedFromRenderManager(
5470 RenderViewHost* old_host,
5471 RenderViewHost* new_host) {
5472 NotifyViewSwapped(old_host, new_host);
5473}
5474
[email protected]b172aee2012-04-10 17:05:265475NavigationControllerImpl& WebContentsImpl::GetControllerForRenderManager() {
[email protected]d1198fd2012-08-13 22:50:195476 return GetController();
[email protected]3a3d47472010-07-15 21:03:545477}
5478
dcheng59716272016-04-09 05:19:085479std::unique_ptr<WebUIImpl> WebContentsImpl::CreateWebUIForRenderFrameHost(
carlosk37f793792014-11-27 15:08:295480 const GURL& url) {
avie865b1d2016-10-24 19:42:595481 return CreateWebUI(url, std::string());
[email protected]420ae012009-04-24 05:16:325482}
5483
[email protected]10f417c52011-12-28 21:04:235484NavigationEntry*
[email protected]b172aee2012-04-10 17:05:265485 WebContentsImpl::GetLastCommittedNavigationEntryForRenderManager() {
[email protected]420ae012009-04-24 05:16:325486 return controller_.GetLastCommittedEntry();
5487}
5488
creisadca9862017-06-16 19:12:115489InterstitialPageImpl* WebContentsImpl::GetInterstitialForRenderManager() {
5490 return interstitial_page_;
5491}
5492
lfgbede6392015-09-11 21:54:065493void WebContentsImpl::CreateRenderWidgetHostViewForRenderManager(
5494 RenderViewHost* render_view_host) {
lfgc740d4b22016-04-15 16:45:335495 RenderWidgetHostViewBase* rwh_view =
5496 view_->CreateViewForWidget(render_view_host->GetWidget(), false);
[email protected]1a98a932009-11-17 00:12:525497
[email protected]420ae012009-04-24 05:16:325498 // Now that the RenderView has been created, we need to tell it its size.
[email protected]245f7d52011-11-28 15:36:445499 if (rwh_view)
[email protected]dc0fd432013-08-27 15:29:215500 rwh_view->SetSize(GetSizeForNewRenderView());
lfgbede6392015-09-11 21:54:065501}
5502
5503bool WebContentsImpl::CreateRenderViewForRenderManager(
5504 RenderViewHost* render_view_host,
5505 int opener_frame_routing_id,
5506 int proxy_routing_id,
5507 const FrameReplicationState& replicated_frame_state) {
5508 TRACE_EVENT0("browser,navigation",
5509 "WebContentsImpl::CreateRenderViewForRenderManager");
5510
piman00cf9402017-04-03 17:09:205511 if (proxy_routing_id == MSG_ROUTING_NONE)
lfg9431efd2016-12-14 14:45:265512 CreateRenderWidgetHostViewForRenderManager(render_view_host);
lfg9431efd2016-12-14 14:45:265513
piman00cf9402017-04-03 17:09:205514 if (!static_cast<RenderViewHostImpl*>(render_view_host)
5515 ->CreateRenderView(opener_frame_routing_id, proxy_routing_id,
lfg9431efd2016-12-14 14:45:265516 replicated_frame_state, created_with_opener_)) {
[email protected]a4127722011-04-27 23:13:525517 return false;
[email protected]14392a52012-05-02 20:28:445518 }
[email protected]a4127722011-04-27 23:13:525519
avi2b177592014-12-10 02:08:025520 SetHistoryOffsetAndLengthForView(render_view_host,
5521 controller_.GetLastCommittedEntryIndex(),
5522 controller_.GetEntryCount());
5523
[email protected]a220b5932013-09-21 03:47:445524#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
[email protected]f8233cc2011-05-31 20:24:505525 // Force a ViewMsg_Resize to be sent, needed to make plugins show up on
5526 // linux. See crbug.com/83941.
avif9ab5d942015-10-15 14:05:445527 RenderWidgetHostView* rwh_view = render_view_host->GetWidget()->GetView();
[email protected]245f7d52011-11-28 15:36:445528 if (rwh_view) {
5529 if (RenderWidgetHost* render_widget_host = rwh_view->GetRenderWidgetHost())
5530 render_widget_host->WasResized();
5531 }
[email protected]f8233cc2011-05-31 20:24:505532#endif
5533
[email protected]420ae012009-04-24 05:16:325534 return true;
5535}
5536
[email protected]82307f6b2014-08-07 03:30:125537bool WebContentsImpl::CreateRenderFrameForRenderManager(
5538 RenderFrameHost* render_frame_host,
alexmosa181efc2015-09-03 00:39:045539 int proxy_routing_id,
5540 int opener_routing_id,
japhete6adf142014-10-31 00:01:495541 int parent_routing_id,
alexmosa181efc2015-09-03 00:39:045542 int previous_sibling_routing_id) {
naskob8744d22014-08-28 17:07:435543 TRACE_EVENT0("browser,navigation",
5544 "WebContentsImpl::CreateRenderFrameForRenderManager");
[email protected]82307f6b2014-08-07 03:30:125545
5546 RenderFrameHostImpl* rfh =
5547 static_cast<RenderFrameHostImpl*>(render_frame_host);
alexmosa181efc2015-09-03 00:39:045548 if (!rfh->CreateRenderFrame(proxy_routing_id, opener_routing_id,
5549 parent_routing_id, previous_sibling_routing_id))
[email protected]82307f6b2014-08-07 03:30:125550 return false;
5551
5552 // TODO(nasko): When RenderWidgetHost is owned by RenderFrameHost, the passed
5553 // RenderFrameHost will have to be associated with the appropriate
5554 // RenderWidgetHostView or a new one should be created here.
5555
5556 return true;
5557}
5558
mfomitchev2b8b066a2016-01-28 19:23:155559#if defined(OS_ANDROID)
[email protected]fc2b46b2014-05-03 16:33:455560
[email protected]155c7f22013-12-09 17:07:185561base::android::ScopedJavaLocalRef<jobject>
5562WebContentsImpl::GetJavaWebContents() {
mostynb042582e2015-03-16 22:13:405563 DCHECK_CURRENTLY_ON(BrowserThread::UI);
[email protected]0e813a52014-08-13 10:34:565564 return GetWebContentsAndroid()->GetJavaObject();
5565}
[email protected]155c7f22013-12-09 17:07:185566
[email protected]0e813a52014-08-13 10:34:565567WebContentsAndroid* WebContentsImpl::GetWebContentsAndroid() {
[email protected]155c7f22013-12-09 17:07:185568 WebContentsAndroid* web_contents_android =
5569 static_cast<WebContentsAndroid*>(GetUserData(kWebContentsAndroidKey));
5570 if (!web_contents_android) {
5571 web_contents_android = new WebContentsAndroid(this);
avicb129c02017-05-03 06:49:295572 SetUserData(kWebContentsAndroidKey, base::WrapUnique(web_contents_android));
[email protected]155c7f22013-12-09 17:07:185573 }
[email protected]0e813a52014-08-13 10:34:565574 return web_contents_android;
[email protected]155c7f22013-12-09 17:07:185575}
5576
paulmeyerc0b762b2016-04-13 11:55:175577void WebContentsImpl::ActivateNearestFindResult(float x,
5578 float y) {
5579 GetOrCreateFindRequestManager()->ActivateNearestFindResult(x, y);
5580}
5581
5582void WebContentsImpl::RequestFindMatchRects(int current_version) {
5583 GetOrCreateFindRequestManager()->RequestFindMatchRects(current_version);
5584}
5585
[email protected]7d244f12013-08-22 21:41:515586bool WebContentsImpl::CreateRenderViewForInitialEmptyDocument() {
nasko4c0feb62015-06-05 18:37:065587 return CreateRenderViewForRenderManager(
5588 GetRenderViewHost(), MSG_ROUTING_NONE, MSG_ROUTING_NONE,
lfgbede6392015-09-11 21:54:065589 frame_tree_.root()->current_replication_state());
[email protected]7d244f12013-08-22 21:41:515590}
[email protected]fc2b46b2014-05-03 16:33:455591
rockot400ea35b2016-10-15 19:15:325592service_manager::InterfaceProvider* WebContentsImpl::GetJavaInterfaces() {
sammcf5f1b0f2016-09-20 23:05:115593 if (!java_interfaces_) {
rockot400ea35b2016-10-15 19:15:325594 service_manager::mojom::InterfaceProviderPtr provider;
blundelle0a9f1582016-12-20 11:23:325595 BindInterfaceRegistryForWebContents(mojo::MakeRequest(&provider), this);
rockot400ea35b2016-10-15 19:15:325596 java_interfaces_.reset(new service_manager::InterfaceProvider);
sammcf5f1b0f2016-09-20 23:05:115597 java_interfaces_->Bind(std::move(provider));
5598 }
5599 return java_interfaces_.get();
5600}
5601
[email protected]fc2b46b2014-05-03 16:33:455602#elif defined(OS_MACOSX)
5603
[email protected]75f4df72014-07-16 22:39:425604void WebContentsImpl::SetAllowOtherViews(bool allow) {
5605 view_->SetAllowOtherViews(allow);
[email protected]fc2b46b2014-05-03 16:33:455606}
5607
[email protected]75f4df72014-07-16 22:39:425608bool WebContentsImpl::GetAllowOtherViews() {
5609 return view_->GetAllowOtherViews();
[email protected]fc2b46b2014-05-03 16:33:455610}
5611
spqchane72c3cb2017-06-30 23:02:105612bool WebContentsImpl::CompletedFirstVisuallyNonEmptyPaint() const {
5613 return did_first_visually_non_empty_paint_;
5614}
5615
[email protected]7d244f12013-08-22 21:41:515616#endif
5617
pkotwicz75ca8ffd2016-02-16 23:10:195618void WebContentsImpl::OnDidDownloadImage(
5619 const ImageDownloadCallback& callback,
5620 int id,
5621 const GURL& image_url,
leon.hancbc4bc3c2016-02-26 07:08:525622 int32_t http_status_code,
leon.hanc2228532016-08-16 05:59:185623 const std::vector<SkBitmap>& images,
5624 const std::vector<gfx::Size>& original_image_sizes) {
5625 callback.Run(id, http_status_code, image_url, images, original_image_sizes);
pkotwicz75ca8ffd2016-02-16 23:10:195626}
5627
[email protected]6fba26d2014-04-29 09:38:285628void WebContentsImpl::OnDialogClosed(int render_process_id,
5629 int render_frame_id,
[email protected]b172aee2012-04-10 17:05:265630 IPC::Message* reply_msg,
[email protected]87de04b02014-04-08 22:14:495631 bool dialog_was_suppressed,
[email protected]b172aee2012-04-10 17:05:265632 bool success,
[email protected]fcf75d42013-12-03 20:11:265633 const base::string16& user_input) {
[email protected]6fba26d2014-04-29 09:38:285634 RenderFrameHostImpl* rfh = RenderFrameHostImpl::FromID(render_process_id,
5635 render_frame_id);
[email protected]87de04b02014-04-08 22:14:495636 last_dialog_suppressed_ = dialog_was_suppressed;
5637
[email protected]beb440c2009-11-06 04:08:545638 if (is_showing_before_unload_dialog_ && !success) {
clamybc6f4152016-04-01 20:14:235639 // It is possible for the current RenderFrameHost to have changed in the
5640 // meantime. Do not reset the navigation state in that case.
5641 if (rfh && rfh == rfh->frame_tree_node()->current_frame_host()) {
clamy44e84ce2016-02-22 15:38:255642 rfh->frame_tree_node()->BeforeUnloadCanceled();
clamybc6f4152016-04-01 20:14:235643 controller_.DiscardNonCommittedEntries();
5644 }
[email protected]ec8e8b02013-06-19 04:57:105645
ericwilligersde386342016-10-19 02:35:095646 for (auto& observer : observers_)
5647 observer.BeforeUnloadDialogCancelled();
[email protected]beb440c2009-11-06 04:08:545648 }
[email protected]87de04b02014-04-08 22:14:495649
[email protected]6fba26d2014-04-29 09:38:285650 if (rfh) {
avi44acfaa82017-05-03 22:55:355651 rfh->JavaScriptDialogClosed(reply_msg, success, user_input);
Pavel Feldman3c1842b2017-08-02 05:00:165652
5653 std::vector<protocol::PageHandler*> page_handlers =
5654 protocol::PageHandler::EnabledForWebContents(this);
5655 for (auto* handler : page_handlers)
5656 handler->DidCloseJavaScriptDialog(success, user_input);
5657
[email protected]6fba26d2014-04-29 09:38:285658 } else {
5659 // Don't leak the sync IPC reply if the RFH or process is gone.
5660 delete reply_msg;
5661 }
avi1c51fb62017-02-27 20:43:035662
5663 is_showing_javascript_dialog_ = false;
5664 is_showing_before_unload_dialog_ = false;
[email protected]beb440c2009-11-06 04:08:545665}
5666
[email protected]b172aee2012-04-10 17:05:265667void WebContentsImpl::SetEncoding(const std::string& encoding) {
[email protected]ef3adfc2014-05-11 00:04:545668 if (encoding == last_reported_encoding_)
5669 return;
5670 last_reported_encoding_ = encoding;
5671
jinsukkim79df88a2017-01-04 06:26:155672 canonical_encoding_ = base::GetCanonicalEncodingNameByAliasName(encoding);
[email protected]aacd7cc2009-09-02 14:51:105673}
[email protected]f45d2a72010-03-08 23:28:355674
[email protected]1ac10dca2013-08-20 20:47:045675bool WebContentsImpl::IsHidden() {
5676 return capturer_count_ == 0 && !should_normally_be_visible_;
5677}
5678
rob97250742015-12-10 17:45:155679int WebContentsImpl::GetOuterDelegateFrameTreeNodeId() {
lfg601233692017-03-06 22:45:445680 return node_.outer_contents_frame_tree_node_id();
lazyboy6ec48b2a2015-06-29 15:18:145681}
5682
ekaramadaeb3c5c2016-11-09 03:22:355683RenderWidgetHostImpl* WebContentsImpl::GetFullscreenRenderWidgetHost() const {
5684 return RenderWidgetHostImpl::FromID(fullscreen_widget_process_id_,
5685 fullscreen_widget_routing_id_);
5686}
5687
[email protected]b0936d22013-11-28 06:47:365688RenderFrameHostManager* WebContentsImpl::GetRenderManager() const {
[email protected]fa944cb82013-11-15 17:51:215689 return frame_tree_.root()->render_manager();
5690}
5691
[email protected]f8497342013-02-05 22:15:025692BrowserPluginGuest* WebContentsImpl::GetBrowserPluginGuest() const {
[email protected]7a846df2012-09-20 19:17:395693 return browser_plugin_guest_.get();
5694}
5695
[email protected]738f57a2013-06-29 21:06:545696void WebContentsImpl::SetBrowserPluginGuest(BrowserPluginGuest* guest) {
5697 CHECK(!browser_plugin_guest_);
lazyboy6ec48b2a2015-06-29 15:18:145698 CHECK(guest);
[email protected]738f57a2013-06-29 21:06:545699 browser_plugin_guest_.reset(guest);
5700}
5701
[email protected]f8497342013-02-05 22:15:025702BrowserPluginEmbedder* WebContentsImpl::GetBrowserPluginEmbedder() const {
[email protected]7a846df2012-09-20 19:17:395703 return browser_plugin_embedder_.get();
5704}
[email protected]8ff00d72012-10-23 19:12:215705
fsamuel60b42282015-03-10 03:29:145706void WebContentsImpl::CreateBrowserPluginEmbedderIfNecessary() {
5707 if (browser_plugin_embedder_)
5708 return;
5709 browser_plugin_embedder_.reset(BrowserPluginEmbedder::Create(this));
5710}
5711
[email protected]fc2b46b2014-05-03 16:33:455712gfx::Size WebContentsImpl::GetSizeForNewRenderView() {
[email protected]dc0fd432013-08-27 15:29:215713 gfx::Size size;
5714 if (delegate_)
5715 size = delegate_->GetSizeForNewRenderView(this);
5716 if (size.IsEmpty())
[email protected]fc2b46b2014-05-03 16:33:455717 size = GetContainerBounds().size();
[email protected]dc0fd432013-08-27 15:29:215718 return size;
5719}
5720
[email protected]ae7eeda2014-07-04 01:53:265721void WebContentsImpl::OnFrameRemoved(RenderFrameHost* render_frame_host) {
ericwilligersde386342016-10-19 02:35:095722 for (auto& observer : observers_)
5723 observer.FrameDeleted(render_frame_host);
[email protected]9b159a52013-10-03 17:24:555724}
5725
[email protected]222f5822014-02-05 23:40:495726void WebContentsImpl::OnPreferredSizeChanged(const gfx::Size& old_size) {
5727 if (!delegate_)
5728 return;
5729 const gfx::Size new_size = GetPreferredSize();
5730 if (new_size != old_size)
5731 delegate_->UpdatePreferredSize(this, new_size);
5732}
5733
avie865b1d2016-10-24 19:42:595734std::unique_ptr<WebUIImpl> WebContentsImpl::CreateWebUI(
5735 const GURL& url,
5736 const std::string& frame_name) {
5737 std::unique_ptr<WebUIImpl> web_ui =
5738 base::MakeUnique<WebUIImpl>(this, frame_name);
5739 WebUIController* controller =
5740 WebUIControllerFactoryRegistry::GetInstance()
5741 ->CreateWebUIControllerForURL(web_ui.get(), url);
dbeama1b926a2015-08-31 23:17:515742 if (controller) {
weisert3dab3b92017-01-10 10:31:175743 web_ui->AddMessageHandler(base::MakeUnique<GenericHandler>());
dbeama1b926a2015-08-31 23:17:515744 web_ui->SetController(controller);
5745 return web_ui;
5746 }
5747
avie865b1d2016-10-24 19:42:595748 return nullptr;
dbeama1b926a2015-08-31 23:17:515749}
5750
paulmeyerfeafc2d2017-04-25 21:46:405751FindRequestManager* WebContentsImpl::GetFindRequestManager() {
5752 for (WebContentsImpl* contents = this; contents;
5753 contents = contents->GetOuterWebContents()) {
5754 if (contents->find_request_manager_)
5755 return contents->find_request_manager_.get();
5756 }
5757
5758 return nullptr;
5759}
5760
paulmeyerc0b762b2016-04-13 11:55:175761FindRequestManager* WebContentsImpl::GetOrCreateFindRequestManager() {
paulmeyerfeafc2d2017-04-25 21:46:405762 if (FindRequestManager* manager = GetFindRequestManager())
5763 return manager;
5764
5765 // No existing FindRequestManager found, so one must be created.
5766 find_request_manager_.reset(new FindRequestManager(this));
5767
5768 // Concurrent find sessions must not overlap, so destroy any existing
5769 // FindRequestManagers in any inner WebContentses.
5770 for (WebContentsImpl* contents : GetWebContentsAndAllInner()) {
5771 if (contents == this)
5772 continue;
5773 if (contents->find_request_manager_) {
5774 contents->find_request_manager_->StopFinding(
5775 content::STOP_FIND_ACTION_CLEAR_SELECTION);
5776 contents->find_request_manager_.release();
5777 }
5778 }
paulmeyerc0b762b2016-04-13 11:55:175779
5780 return find_request_manager_.get();
5781}
5782
5783void WebContentsImpl::NotifyFindReply(int request_id,
5784 int number_of_matches,
5785 const gfx::Rect& selection_rect,
5786 int active_match_ordinal,
5787 bool final_update) {
Sebastien Marchandcf97ed52017-07-24 23:50:345788 if (delegate_ && !is_being_destroyed_ &&
5789 !GetRenderProcessHost()->FastShutdownStarted()) {
paulmeyerc0b762b2016-04-13 11:55:175790 delegate_->FindReply(this, request_id, number_of_matches, selection_rect,
5791 active_match_ordinal, final_update);
5792 }
5793}
5794
ortuno467e5792016-06-10 04:32:395795void WebContentsImpl::IncrementBluetoothConnectedDeviceCount() {
5796 // Trying to invalidate the tab state while being destroyed could result in a
5797 // use after free.
5798 if (IsBeingDestroyed()) {
5799 return;
5800 }
5801 // Notify for UI updates if the state changes.
5802 bluetooth_connected_device_count_++;
5803 if (bluetooth_connected_device_count_ == 1) {
5804 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
5805 }
5806}
5807
5808void WebContentsImpl::DecrementBluetoothConnectedDeviceCount() {
5809 // Trying to invalidate the tab state while being destroyed could result in a
5810 // use after free.
5811 if (IsBeingDestroyed()) {
5812 return;
5813 }
5814 // Notify for UI updates if the state changes.
5815 DCHECK(bluetooth_connected_device_count_ != 0);
5816 bluetooth_connected_device_count_--;
5817 if (bluetooth_connected_device_count_ == 0) {
5818 NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
5819 }
5820}
5821
zqzhang8ac49002017-03-16 21:51:355822void WebContentsImpl::SetHasPersistentVideo(bool has_persistent_video) {
5823 if (has_persistent_video_ == has_persistent_video)
mlamouri5cd9ae82017-02-18 11:05:095824 return;
5825
zqzhang8ac49002017-03-16 21:51:355826 has_persistent_video_ = has_persistent_video;
mlamouri5cd9ae82017-02-18 11:05:095827 NotifyPreferencesChanged();
zqzhang8ac49002017-03-16 21:51:355828 media_web_contents_observer()->RequestPersistentVideo(has_persistent_video);
mlamouri5cd9ae82017-02-18 11:05:095829}
5830
paulmeyerfeafc2d2017-04-25 21:46:405831void WebContentsImpl::BrowserPluginGuestWillDetach() {
5832 WebContentsImpl* outermost = GetOutermostWebContents();
5833 if (this != outermost && ContainsOrIsFocusedWebContents())
5834 outermost->SetAsFocusedWebContentsIfNecessary();
5835}
5836
paulmeyerc0b762b2016-04-13 11:55:175837#if defined(OS_ANDROID)
5838void WebContentsImpl::NotifyFindMatchRectsReply(
5839 int version,
5840 const std::vector<gfx::RectF>& rects,
5841 const gfx::RectF& active_rect) {
5842 if (delegate_)
5843 delegate_->FindMatchRectsReply(this, version, rects, active_rect);
5844}
5845#endif
5846
[email protected]34ff1cfc2014-08-20 06:16:055847void WebContentsImpl::SetForceDisableOverscrollContent(bool force_disable) {
5848 force_disable_overscroll_content_ = force_disable;
5849 if (view_)
5850 view_->SetOverscrollControllerEnabled(CanOverscrollContent());
5851}
5852
dalecurtis88c240072015-12-09 02:11:185853void WebContentsImpl::MediaStartedPlaying(
billorr21c005d2016-11-17 03:57:045854 const WebContentsObserver::MediaPlayerInfo& media_info,
dalecurtis88c240072015-12-09 02:11:185855 const WebContentsObserver::MediaPlayerId& id) {
billorr21c005d2016-11-17 03:57:045856 if (media_info.has_video)
5857 currently_playing_video_count_++;
5858
ericwilligersde386342016-10-19 02:35:095859 for (auto& observer : observers_)
billorr21c005d2016-11-17 03:57:045860 observer.MediaStartedPlaying(media_info, id);
dalecurtis88c240072015-12-09 02:11:185861}
5862
5863void WebContentsImpl::MediaStoppedPlaying(
billorr21c005d2016-11-17 03:57:045864 const WebContentsObserver::MediaPlayerInfo& media_info,
dalecurtis88c240072015-12-09 02:11:185865 const WebContentsObserver::MediaPlayerId& id) {
billorr21c005d2016-11-17 03:57:045866 if (media_info.has_video)
5867 currently_playing_video_count_--;
5868
ericwilligersde386342016-10-19 02:35:095869 for (auto& observer : observers_)
billorr21c005d2016-11-17 03:57:045870 observer.MediaStoppedPlaying(media_info, id);
5871}
5872
peconn257951522017-06-09 18:24:595873void WebContentsImpl::MediaResized(
5874 const gfx::Size& size,
5875 const WebContentsObserver::MediaPlayerId& id) {
5876 cached_video_sizes_[id] = size;
5877
5878 for (auto& observer : observers_)
5879 observer.MediaResized(size, id);
5880}
5881
Peter Conn31c726a2017-08-17 11:07:345882base::Optional<gfx::Size> WebContentsImpl::GetFullscreenVideoSize() {
5883 base::Optional<WebContentsObserver::MediaPlayerId> id =
5884 media_web_contents_observer_->GetFullscreenVideoMediaPlayerId();
5885 if (id && cached_video_sizes_.count(id.value()))
5886 return base::Optional<gfx::Size>(cached_video_sizes_[id.value()]);
5887 return base::Optional<gfx::Size>();
peconn257951522017-06-09 18:24:595888}
5889
billorr21c005d2016-11-17 03:57:045890int WebContentsImpl::GetCurrentlyPlayingVideoCount() {
5891 return currently_playing_video_count_;
dalecurtis88c240072015-12-09 02:11:185892}
5893
tapted65ff2ea72016-03-01 23:39:005894void WebContentsImpl::UpdateWebContentsVisibility(bool visible) {
5895 if (!did_first_set_visible_) {
5896 // If this WebContents has not yet been set to be visible for the first
5897 // time, ignore any requests to make it hidden, since resources would
5898 // immediately be destroyed and only re-created after content loaded. In
5899 // this state the window content is undefined and can show garbage.
5900 // However, the page load mechanism requires an activation call through a
5901 // visibility call to (re)load.
5902 if (visible) {
5903 did_first_set_visible_ = true;
5904 WasShown();
5905 }
5906 return;
5907 }
5908 if (visible == should_normally_be_visible_)
5909 return;
5910
5911 if (visible)
5912 WasShown();
5913 else
5914 WasHidden();
5915}
5916
aelias5252baa2016-04-10 01:18:025917void WebContentsImpl::UpdateOverridingUserAgent() {
mlamouri5cd9ae82017-02-18 11:05:095918 NotifyPreferencesChanged();
aelias5252baa2016-04-10 01:18:025919}
5920
avid53461d2016-02-25 17:15:045921void WebContentsImpl::SetJavaScriptDialogManagerForTesting(
5922 JavaScriptDialogManager* dialog_manager) {
5923 dialog_manager_ = dialog_manager;
5924}
5925
rockotf62002a2016-09-15 00:08:595926void WebContentsImpl::RemoveBindingSet(const std::string& interface_name) {
5927 auto it = binding_sets_.find(interface_name);
5928 if (it != binding_sets_.end())
5929 binding_sets_.erase(it);
5930}
5931
nzolghadrd87a308d2016-12-07 15:45:565932bool WebContentsImpl::AddDomainInfoToRapporSample(rappor::Sample* sample) {
nzolghadrbbffc6c2017-05-25 17:56:395933 // Here we associate this metric to the main frame URL regardless of what
5934 // caused it.
nzolghadrd87a308d2016-12-07 15:45:565935 sample->SetStringField("Domain", ::rappor::GetDomainAndRegistrySampleFromGURL(
5936 GetLastCommittedURL()));
nzolghadrd87a308d2016-12-07 15:45:565937 return true;
5938}
5939
nzolghadrbbffc6c2017-05-25 17:56:395940void WebContentsImpl::UpdateUrlForUkmSource(ukm::UkmRecorder* service,
5941 ukm::SourceId ukm_source_id) {
5942 // Here we associate this metric to the main frame URL regardless of what
5943 // caused it.
5944 service->UpdateSourceURL(ukm_source_id, GetLastCommittedURL());
5945}
5946
ekaramada110f642016-12-21 19:47:285947void WebContentsImpl::FocusedNodeTouched(bool editable) {
5948#if defined(OS_WIN)
5949 // We use the cursor position to determine where the touch occurred.
5950 RenderWidgetHostView* view = GetRenderWidgetHostView();
5951 if (!view)
5952 return;
5953 POINT cursor_pos = {};
5954 ::GetCursorPos(&cursor_pos);
5955 float scale = GetScaleFactorForView(view);
5956 gfx::Point location_dips_screen =
5957 gfx::ConvertPointToDIP(scale, gfx::Point(cursor_pos));
5958 view->FocusedNodeTouched(location_dips_screen, editable);
5959#endif
5960}
5961
samans90fb8162017-04-04 22:30:455962void WebContentsImpl::DidReceiveCompositorFrame() {
5963 for (auto& observer : observers_)
5964 observer.DidReceiveCompositorFrame();
5965}
5966
falken52a56e32016-12-08 05:02:405967void WebContentsImpl::ShowInsecureLocalhostWarningIfNeeded() {
5968 bool allow_localhost = base::CommandLine::ForCurrentProcess()->HasSwitch(
5969 switches::kAllowInsecureLocalhost);
5970 if (!allow_localhost)
5971 return;
5972
5973 content::NavigationEntry* entry = GetController().GetLastCommittedEntry();
5974 if (!entry || !net::IsLocalhost(entry->GetURL().host()))
5975 return;
5976
5977 content::SSLStatus ssl_status = entry->GetSSL();
5978 bool is_cert_error = net::IsCertStatusError(ssl_status.cert_status) &&
5979 !net::IsCertStatusMinorError(ssl_status.cert_status);
5980 if (!is_cert_error)
5981 return;
5982
5983 GetMainFrame()->AddMessageToConsole(
5984 content::CONSOLE_MESSAGE_LEVEL_WARNING,
5985 base::StringPrintf("This site does not have a valid SSL "
5986 "certificate! Without SSL, your site's and "
5987 "visitors' data is vulnerable to theft and "
5988 "tampering. Get a valid SSL certificate before"
5989 " releasing your website to the public."));
5990}
5991
ekaramadf6750aa2017-06-06 18:29:425992bool WebContentsImpl::IsShowingContextMenuOnPage() const {
5993 return showing_context_menu_;
5994}
5995
mlamouri5cd9ae82017-02-18 11:05:095996void WebContentsImpl::NotifyPreferencesChanged() {
5997 std::set<RenderViewHost*> render_view_host_set;
5998 for (FrameTreeNode* node : frame_tree_.Nodes()) {
5999 RenderWidgetHost* render_widget_host =
6000 node->current_frame_host()->GetRenderWidgetHost();
6001 if (!render_widget_host)
6002 continue;
6003 RenderViewHost* render_view_host = RenderViewHost::From(render_widget_host);
6004 if (!render_view_host)
6005 continue;
6006 render_view_host_set.insert(render_view_host);
6007 }
6008 for (RenderViewHost* render_view_host : render_view_host_set)
6009 render_view_host->OnWebkitPreferencesChanged();
6010}
6011
Megan Jablonski2f6a4c52017-07-10 23:01:256012DownloadUrlParameters::RequestHeadersType WebContentsImpl::ParseDownloadHeaders(
6013 const std::string& headers) {
6014 DownloadUrlParameters::RequestHeadersType request_headers;
6015 for (const base::StringPiece& key_value : base::SplitStringPiece(
6016 headers, "\r\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
6017 std::vector<std::string> pair = base::SplitString(
6018 key_value, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
6019 if (2ul == pair.size())
6020 request_headers.push_back(make_pair(pair[0], pair[1]));
6021 }
6022 return request_headers;
6023}
6024
lukasza6f8ac622017-06-06 03:10:206025void WebContentsImpl::SetOpenerForNewContents(FrameTreeNode* opener,
6026 bool opener_suppressed) {
6027 if (opener) {
6028 FrameTreeNode* new_root = GetFrameTree()->root();
6029
6030 // For the "original opener", track the opener's main frame instead, because
6031 // if the opener is a subframe, the opener tracking could be easily bypassed
6032 // by spawning from a subframe and deleting the subframe.
6033 // https://crbug.com/705316
6034 new_root->SetOriginalOpener(opener->frame_tree()->root());
6035
6036 if (!opener_suppressed) {
6037 new_root->SetOpener(opener);
6038 created_with_opener_ = true;
6039 }
6040 }
6041}
6042
Becca Hughes9f6fd4b82017-06-15 10:01:406043void WebContentsImpl::MediaMutedStatusChanged(
6044 const WebContentsObserver::MediaPlayerId& id,
6045 bool muted) {
6046 for (auto& observer : observers_)
6047 observer.MediaMutedStatusChanged(id, muted);
6048}
6049
EhsanK2075c7e2017-08-21 02:42:396050void WebContentsImpl::SetVisibilityForChildViews(bool visible) {
6051 GetMainFrame()->SetVisibilityForChildViews(visible);
6052}
6053
[email protected]8ff00d72012-10-23 19:12:216054} // namespace content