blob: b358e5571ee8c252702eb3fbb61040457196c6e1 [file] [log] [blame]
[email protected]d4a8ca482013-10-30 21:06:401// Copyright 2013 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]d4a8ca482013-10-30 21:06:405#include "content/browser/frame_host/navigation_controller_impl.h"
initial.commit09911bf2008-07-26 23:55:296
[email protected]c5b88d82012-10-06 17:03:337#include "base/bind.h"
[email protected]eabfe1912014-05-12 10:07:288#include "base/command_line.h"
initial.commit09911bf2008-07-26 23:55:299#include "base/logging.h"
[email protected]d6def3d2014-05-19 18:55:3210#include "base/metrics/histogram.h"
[email protected]348fbaac2013-06-11 06:31:5111#include "base/strings/string_number_conversions.h" // Temporary
12#include "base/strings/string_util.h"
[email protected]74ebfb12013-06-07 20:48:0013#include "base/strings/utf_string_conversions.h"
[email protected]a43858f2013-06-28 15:18:3714#include "base/time/time.h"
ssid3e765612015-01-28 04:03:4215#include "base/trace_event/trace_event.h"
[email protected]eabfe1912014-05-12 10:07:2816#include "cc/base/switches.h"
[email protected]825b1662012-03-12 19:07:3117#include "content/browser/browser_url_handler_impl.h"
[email protected]5f2aa722013-08-07 16:59:4118#include "content/browser/dom_storage/dom_storage_context_wrapper.h"
[email protected]1ea3c792012-04-17 01:25:0419#include "content/browser/dom_storage/session_storage_namespace_impl.h"
[email protected]d4a8ca482013-10-30 21:06:4020#include "content/browser/frame_host/debug_urls.h"
21#include "content/browser/frame_host/interstitial_page_impl.h"
22#include "content/browser/frame_host/navigation_entry_impl.h"
[email protected]d1581d72013-11-05 19:11:2623#include "content/browser/frame_host/navigation_entry_screenshot_manager.h"
[email protected]b3c41c0b2012-03-06 15:48:3224#include "content/browser/renderer_host/render_view_host_impl.h" // Temporary
[email protected]b6583592012-01-25 19:52:3325#include "content/browser/site_instance_impl.h"
[email protected]37567b432014-02-12 01:12:2226#include "content/common/frame_messages.h"
[email protected]0aed2f52011-03-23 18:06:3627#include "content/common/view_messages.h"
[email protected]ccb797302011-12-15 16:55:1128#include "content/public/browser/browser_context.h"
[email protected]d1198fd2012-08-13 22:50:1929#include "content/public/browser/content_browser_client.h"
[email protected]d9083482012-01-06 00:38:4630#include "content/public/browser/invalidate_type.h"
[email protected]5b96836f2011-12-22 07:39:0031#include "content/public/browser/navigation_details.h"
[email protected]7f6f44c2011-12-14 13:23:3832#include "content/public/browser/notification_service.h"
[email protected]0d6e9bd2011-10-18 04:29:1633#include "content/public/browser/notification_types.h"
[email protected]9677a3c2012-12-22 04:18:5834#include "content/public/browser/render_widget_host.h"
35#include "content/public/browser/render_widget_host_view.h"
[email protected]4c3a23582012-08-18 08:54:3436#include "content/public/browser/storage_partition.h"
[email protected]7f6f44c2011-12-14 13:23:3837#include "content/public/browser/user_metrics.h"
[email protected]d1198fd2012-08-13 22:50:1938#include "content/public/common/content_client.h"
[email protected]7f6f44c2011-12-14 13:23:3839#include "content/public/common/content_constants.h"
avi9f07a0c2015-02-18 22:51:2940#include "content/public/common/content_switches.h"
[email protected]a23de8572009-06-03 02:16:3241#include "net/base/escape.h"
[email protected]31682282010-01-15 18:05:1642#include "net/base/mime_util.h"
[email protected]7f070d42011-03-09 20:25:3243#include "net/base/net_util.h"
[email protected]9677a3c2012-12-22 04:18:5844#include "skia/ext/platform_canvas.h"
[email protected]cca6f392014-05-28 21:32:2645#include "url/url_constants.h"
initial.commit09911bf2008-07-26 23:55:2946
[email protected]8ff00d72012-10-23 19:12:2147namespace content {
[email protected]e9ba4472008-09-14 15:42:4348namespace {
49
50// Invoked when entries have been pruned, or removed. For example, if the
51// current entries are [google, digg, yahoo], with the current entry google,
52// and the user types in cnet, then digg and yahoo are pruned.
[email protected]d202a7c2012-01-04 07:53:4753void NotifyPrunedEntries(NavigationControllerImpl* nav_controller,
[email protected]c12bf1a12008-09-17 16:28:4954 bool from_front,
55 int count) {
[email protected]8ff00d72012-10-23 19:12:2156 PrunedDetails details;
[email protected]c12bf1a12008-09-17 16:28:4957 details.from_front = from_front;
58 details.count = count;
[email protected]8ff00d72012-10-23 19:12:2159 NotificationService::current()->Notify(
60 NOTIFICATION_NAV_LIST_PRUNED,
61 Source<NavigationController>(nav_controller),
62 Details<PrunedDetails>(&details));
[email protected]e9ba4472008-09-14 15:42:4363}
64
65// Ensure the given NavigationEntry has a valid state, so that WebKit does not
66// get confused if we navigate back to it.
[email protected]40bcc302009-03-02 20:50:3967//
[email protected]e9ba4472008-09-14 15:42:4368// An empty state is treated as a new navigation by WebKit, which would mean
69// losing the navigation entries and generating a new navigation entry after
70// this one. We don't want that. To avoid this we create a valid state which
71// WebKit will not treat as a new navigation.
[email protected]691aa2f2013-05-28 22:52:0472void SetPageStateIfEmpty(NavigationEntryImpl* entry) {
73 if (!entry->GetPageState().IsValid())
74 entry->SetPageState(PageState::CreateFromURL(entry->GetURL()));
[email protected]e9ba4472008-09-14 15:42:4375}
76
[email protected]2ca1ea662012-10-04 02:26:3677NavigationEntryImpl::RestoreType ControllerRestoreTypeToEntryType(
78 NavigationController::RestoreType type) {
79 switch (type) {
80 case NavigationController::RESTORE_CURRENT_SESSION:
81 return NavigationEntryImpl::RESTORE_CURRENT_SESSION;
82 case NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY:
83 return NavigationEntryImpl::RESTORE_LAST_SESSION_EXITED_CLEANLY;
84 case NavigationController::RESTORE_LAST_SESSION_CRASHED:
85 return NavigationEntryImpl::RESTORE_LAST_SESSION_CRASHED;
86 }
87 NOTREACHED();
88 return NavigationEntryImpl::RESTORE_CURRENT_SESSION;
89}
90
[email protected]e9ba4472008-09-14 15:42:4391// Configure all the NavigationEntries in entries for restore. This resets
92// the transition type to reload and makes sure the content state isn't empty.
93void ConfigureEntriesForRestore(
[email protected]10f417c52011-12-28 21:04:2394 std::vector<linked_ptr<NavigationEntryImpl> >* entries,
[email protected]2ca1ea662012-10-04 02:26:3695 NavigationController::RestoreType type) {
[email protected]e9ba4472008-09-14 15:42:4396 for (size_t i = 0; i < entries->size(); ++i) {
97 // Use a transition type of reload so that we don't incorrectly increase
98 // the typed count.
Sylvain Defresnec6ccc77d2014-09-19 10:19:3599 (*entries)[i]->SetTransitionType(ui::PAGE_TRANSITION_RELOAD);
[email protected]2ca1ea662012-10-04 02:26:36100 (*entries)[i]->set_restore_type(ControllerRestoreTypeToEntryType(type));
[email protected]e9ba4472008-09-14 15:42:43101 // NOTE(darin): This code is only needed for backwards compat.
[email protected]691aa2f2013-05-28 22:52:04102 SetPageStateIfEmpty((*entries)[i].get());
[email protected]e9ba4472008-09-14 15:42:43103 }
104}
105
[email protected]5cfbddc2014-06-23 23:52:23106// There are two general cases where a navigation is in page:
107// 1. A fragment navigation, in which the url is kept the same except for the
108// reference fragment.
109// 2. A history API navigation (pushState and replaceState). This case is
110// always in-page, but the urls are not guaranteed to match excluding the
111// fragment. The relevant spec allows pushState/replaceState to any URL on
112// the same origin.
113// However, due to reloads, even identical urls are *not* guaranteed to be
114// in-page navigations, we have to trust the renderer almost entirely.
115// The one thing we do know is that cross-origin navigations will *never* be
116// in-page. Therefore, trust the renderer if the URLs are on the same origin,
117// and assume the renderer is malicious if a cross-origin navigation claims to
118// be in-page.
[email protected]ce760d742012-08-30 22:31:10119bool AreURLsInPageNavigation(const GURL& existing_url,
120 const GURL& new_url,
[email protected]b9d4dfdc2013-08-08 00:25:12121 bool renderer_says_in_page,
[email protected]5cfbddc2014-06-23 23:52:23122 RenderFrameHost* rfh) {
123 WebPreferences prefs = rfh->GetRenderViewHost()->GetWebkitPreferences();
124 bool is_same_origin = existing_url.is_empty() ||
[email protected]62e412b2014-07-11 20:06:03125 // TODO(japhet): We should only permit navigations
126 // originating from about:blank to be in-page if the
127 // about:blank is the first document that frame loaded.
128 // We don't have sufficient information to identify
129 // that case at the moment, so always allow about:blank
130 // for now.
131 existing_url == GURL(url::kAboutBlankURL) ||
[email protected]5cfbddc2014-06-23 23:52:23132 existing_url.GetOrigin() == new_url.GetOrigin() ||
ningxin.hu3d4264362015-01-26 09:10:57133 !prefs.web_security_enabled ||
134 (prefs.allow_universal_access_from_file_urls &&
135 existing_url.SchemeIs(url::kFileScheme));
[email protected]5cfbddc2014-06-23 23:52:23136 if (!is_same_origin && renderer_says_in_page)
137 rfh->GetProcess()->ReceivedBadMessage();
138 return is_same_origin && renderer_says_in_page;
[email protected]e9ba4472008-09-14 15:42:43139}
140
[email protected]bf70edce2012-06-20 22:32:22141// Determines whether or not we should be carrying over a user agent override
142// between two NavigationEntries.
[email protected]8ff00d72012-10-23 19:12:21143bool ShouldKeepOverride(const NavigationEntry* last_entry) {
[email protected]bf70edce2012-06-20 22:32:22144 return last_entry && last_entry->GetIsOverridingUserAgent();
145}
146
[email protected]e9ba4472008-09-14 15:42:43147} // namespace
148
[email protected]d202a7c2012-01-04 07:53:47149// NavigationControllerImpl ----------------------------------------------------
initial.commit09911bf2008-07-26 23:55:29150
[email protected]23a918b2014-07-15 09:51:36151const size_t kMaxEntryCountForTestingNotSet = static_cast<size_t>(-1);
[email protected]9b51970d2011-12-09 23:10:23152
[email protected]765b35502008-08-21 00:51:20153// static
[email protected]d202a7c2012-01-04 07:53:47154size_t NavigationControllerImpl::max_entry_count_for_testing_ =
[email protected]9b51970d2011-12-09 23:10:23155 kMaxEntryCountForTestingNotSet;
[email protected]765b35502008-08-21 00:51:20156
[email protected]e6fec472013-05-14 05:29:02157// Should Reload check for post data? The default is true, but is set to false
[email protected]cdcb1dee2012-01-04 00:46:20158// when testing.
159static bool g_check_for_repost = true;
initial.commit09911bf2008-07-26 23:55:29160
[email protected]71fde352011-12-29 03:29:56161// static
[email protected]cdcb1dee2012-01-04 00:46:20162NavigationEntry* NavigationController::CreateNavigationEntry(
[email protected]71fde352011-12-29 03:29:56163 const GURL& url,
[email protected]cdcb1dee2012-01-04 00:46:20164 const Referrer& referrer,
Sylvain Defresnec6ccc77d2014-09-19 10:19:35165 ui::PageTransition transition,
[email protected]71fde352011-12-29 03:29:56166 bool is_renderer_initiated,
167 const std::string& extra_headers,
[email protected]cdcb1dee2012-01-04 00:46:20168 BrowserContext* browser_context) {
creis94a977f62015-02-18 23:51:05169 // Fix up the given URL before letting it be rewritten, so that any minor
170 // cleanup (e.g., removing leading dots) will not lead to a virtual URL.
171 GURL dest_url(url);
172 BrowserURLHandlerImpl::GetInstance()->FixupURLBeforeRewrite(&dest_url,
173 browser_context);
174
[email protected]71fde352011-12-29 03:29:56175 // Allow the browser URL handler to rewrite the URL. This will, for example,
176 // remove "view-source:" from the beginning of the URL to get the URL that
177 // will actually be loaded. This real URL won't be shown to the user, just
178 // used internally.
creis94a977f62015-02-18 23:51:05179 GURL loaded_url(dest_url);
[email protected]71fde352011-12-29 03:29:56180 bool reverse_on_redirect = false;
[email protected]825b1662012-03-12 19:07:31181 BrowserURLHandlerImpl::GetInstance()->RewriteURLIfNecessary(
[email protected]71fde352011-12-29 03:29:56182 &loaded_url, browser_context, &reverse_on_redirect);
183
184 NavigationEntryImpl* entry = new NavigationEntryImpl(
185 NULL, // The site instance for tabs is sent on navigation
[email protected]2db9bd72012-04-13 20:20:56186 // (WebContents::GetSiteInstance).
[email protected]71fde352011-12-29 03:29:56187 -1,
188 loaded_url,
189 referrer,
[email protected]fcf75d42013-12-03 20:11:26190 base::string16(),
[email protected]71fde352011-12-29 03:29:56191 transition,
192 is_renderer_initiated);
creis94a977f62015-02-18 23:51:05193 entry->SetVirtualURL(dest_url);
194 entry->set_user_typed_url(dest_url);
[email protected]71fde352011-12-29 03:29:56195 entry->set_update_virtual_url_with_url(reverse_on_redirect);
196 entry->set_extra_headers(extra_headers);
197 return entry;
198}
199
[email protected]cdcb1dee2012-01-04 00:46:20200// static
201void NavigationController::DisablePromptOnRepost() {
202 g_check_for_repost = false;
203}
204
[email protected]c5b88d82012-10-06 17:03:33205base::Time NavigationControllerImpl::TimeSmoother::GetSmoothedTime(
206 base::Time t) {
207 // If |t| is between the water marks, we're in a run of duplicates
208 // or just getting out of it, so increase the high-water mark to get
209 // a time that probably hasn't been used before and return it.
210 if (low_water_mark_ <= t && t <= high_water_mark_) {
211 high_water_mark_ += base::TimeDelta::FromMicroseconds(1);
212 return high_water_mark_;
213 }
214
215 // Otherwise, we're clear of the last duplicate run, so reset the
216 // water marks.
217 low_water_mark_ = high_water_mark_ = t;
218 return t;
219}
220
[email protected]d202a7c2012-01-04 07:53:47221NavigationControllerImpl::NavigationControllerImpl(
[email protected]ec6c05f2013-10-23 18:41:57222 NavigationControllerDelegate* delegate,
[email protected]d1198fd2012-08-13 22:50:19223 BrowserContext* browser_context)
[email protected]3d7474ff2011-07-27 17:47:37224 : browser_context_(browser_context),
[email protected]765b35502008-08-21 00:51:20225 pending_entry_(NULL),
226 last_committed_entry_index_(-1),
227 pending_entry_index_(-1),
[email protected]cbab76d2008-10-13 22:42:47228 transient_entry_index_(-1),
[email protected]ec6c05f2013-10-23 18:41:57229 delegate_(delegate),
initial.commit09911bf2008-07-26 23:55:29230 max_restored_page_id_(-1),
[email protected]69e797f2013-04-30 01:10:22231 ssl_manager_(this),
[email protected]38b8f4e2009-09-24 19:44:57232 needs_reload_(false),
[email protected]27ba81c2012-08-21 17:04:09233 is_initial_navigation_(true),
[email protected]40fd3032014-02-28 22:16:28234 in_navigate_to_pending_entry_(false),
[email protected]c5b88d82012-10-06 17:03:33235 pending_reload_(NO_RELOAD),
[email protected]8cea7892013-02-06 06:49:31236 get_timestamp_callback_(base::Bind(&base::Time::Now)),
[email protected]d1581d72013-11-05 19:11:26237 screenshot_manager_(new NavigationEntryScreenshotManager(this)) {
[email protected]3d7474ff2011-07-27 17:47:37238 DCHECK(browser_context_);
initial.commit09911bf2008-07-26 23:55:29239}
240
[email protected]d202a7c2012-01-04 07:53:47241NavigationControllerImpl::~NavigationControllerImpl() {
[email protected]cbab76d2008-10-13 22:42:47242 DiscardNonCommittedEntriesInternal();
initial.commit09911bf2008-07-26 23:55:29243}
244
[email protected]d202a7c2012-01-04 07:53:47245WebContents* NavigationControllerImpl::GetWebContents() const {
[email protected]ec6c05f2013-10-23 18:41:57246 return delegate_->GetWebContents();
[email protected]fbc5e5f92012-01-02 06:08:32247}
248
[email protected]d202a7c2012-01-04 07:53:47249BrowserContext* NavigationControllerImpl::GetBrowserContext() const {
[email protected]a26023822011-12-29 00:23:55250 return browser_context_;
251}
252
[email protected]d202a7c2012-01-04 07:53:47253void NavigationControllerImpl::SetBrowserContext(
254 BrowserContext* browser_context) {
[email protected]cdcb1dee2012-01-04 00:46:20255 browser_context_ = browser_context;
256}
257
[email protected]d202a7c2012-01-04 07:53:47258void NavigationControllerImpl::Restore(
[email protected]5e369672009-11-03 23:48:30259 int selected_navigation,
[email protected]2ca1ea662012-10-04 02:26:36260 RestoreType type,
[email protected]10f417c52011-12-28 21:04:23261 std::vector<NavigationEntry*>* entries) {
[email protected]ce3fa3c2009-04-20 19:55:57262 // Verify that this controller is unused and that the input is valid.
[email protected]a26023822011-12-29 00:23:55263 DCHECK(GetEntryCount() == 0 && !GetPendingEntry());
[email protected]ce3fa3c2009-04-20 19:55:57264 DCHECK(selected_navigation >= 0 &&
[email protected]03838e22011-06-06 15:27:14265 selected_navigation < static_cast<int>(entries->size()));
[email protected]ce3fa3c2009-04-20 19:55:57266
[email protected]ce3fa3c2009-04-20 19:55:57267 needs_reload_ = true;
[email protected]ad23a092011-12-28 07:02:04268 for (size_t i = 0; i < entries->size(); ++i) {
[email protected]10f417c52011-12-28 21:04:23269 NavigationEntryImpl* entry =
270 NavigationEntryImpl::FromNavigationEntry((*entries)[i]);
271 entries_.push_back(linked_ptr<NavigationEntryImpl>(entry));
[email protected]ad23a092011-12-28 07:02:04272 }
[email protected]03838e22011-06-06 15:27:14273 entries->clear();
[email protected]ce3fa3c2009-04-20 19:55:57274
275 // And finish the restore.
[email protected]2ca1ea662012-10-04 02:26:36276 FinishRestore(selected_navigation, type);
[email protected]ce3fa3c2009-04-20 19:55:57277}
278
[email protected]d202a7c2012-01-04 07:53:47279void NavigationControllerImpl::Reload(bool check_for_repost) {
[email protected]1ccb3568d2010-02-19 10:51:16280 ReloadInternal(check_for_repost, RELOAD);
281}
[email protected]d202a7c2012-01-04 07:53:47282void NavigationControllerImpl::ReloadIgnoringCache(bool check_for_repost) {
[email protected]1ccb3568d2010-02-19 10:51:16283 ReloadInternal(check_for_repost, RELOAD_IGNORING_CACHE);
284}
[email protected]7c16976c2012-08-04 02:38:23285void NavigationControllerImpl::ReloadOriginalRequestURL(bool check_for_repost) {
286 ReloadInternal(check_for_repost, RELOAD_ORIGINAL_REQUEST_URL);
287}
[email protected]1ccb3568d2010-02-19 10:51:16288
[email protected]d202a7c2012-01-04 07:53:47289void NavigationControllerImpl::ReloadInternal(bool check_for_repost,
290 ReloadType reload_type) {
[email protected]669e0ba2012-08-30 23:57:36291 if (transient_entry_index_ != -1) {
292 // If an interstitial is showing, treat a reload as a navigation to the
293 // transient entry's URL.
[email protected]6286a3792013-10-09 04:03:27294 NavigationEntryImpl* transient_entry =
295 NavigationEntryImpl::FromNavigationEntry(GetTransientEntry());
296 if (!transient_entry)
[email protected]669e0ba2012-08-30 23:57:36297 return;
[email protected]6286a3792013-10-09 04:03:27298 LoadURL(transient_entry->GetURL(),
[email protected]8ff00d72012-10-23 19:12:21299 Referrer(),
Sylvain Defresnec6ccc77d2014-09-19 10:19:35300 ui::PAGE_TRANSITION_RELOAD,
[email protected]6286a3792013-10-09 04:03:27301 transient_entry->extra_headers());
[email protected]cbab76d2008-10-13 22:42:47302 return;
[email protected]669e0ba2012-08-30 23:57:36303 }
[email protected]cbab76d2008-10-13 22:42:47304
[email protected]59167c22013-06-03 18:07:32305 NavigationEntryImpl* entry = NULL;
306 int current_index = -1;
307
308 // If we are reloading the initial navigation, just use the current
309 // pending entry. Otherwise look up the current entry.
310 if (IsInitialNavigation() && pending_entry_) {
311 entry = pending_entry_;
312 // The pending entry might be in entries_ (e.g., after a Clone), so we
313 // should also update the current_index.
314 current_index = pending_entry_index_;
315 } else {
316 DiscardNonCommittedEntriesInternal();
317 current_index = GetCurrentEntryIndex();
318 if (current_index != -1) {
319 entry = NavigationEntryImpl::FromNavigationEntry(
320 GetEntryAtIndex(current_index));
321 }
[email protected]979a4bc2013-04-24 01:27:15322 }
[email protected]241db352013-04-22 18:04:05323
[email protected]59167c22013-06-03 18:07:32324 // If we are no where, then we can't reload. TODO(darin): We should add a
325 // CanReload method.
326 if (!entry)
327 return;
328
[email protected]eaaba7dd2013-10-14 02:38:07329 if (reload_type == NavigationControllerImpl::RELOAD_ORIGINAL_REQUEST_URL &&
330 entry->GetOriginalRequestURL().is_valid() && !entry->GetHasPostData()) {
331 // We may have been redirected when navigating to the current URL.
332 // Use the URL the user originally intended to visit, if it's valid and if a
333 // POST wasn't involved; the latter case avoids issues with sending data to
334 // the wrong page.
335 entry->SetURL(entry->GetOriginalRequestURL());
[email protected]25cd5f12014-01-10 11:02:20336 entry->SetReferrer(Referrer());
[email protected]eaaba7dd2013-10-14 02:38:07337 }
338
[email protected]cdcb1dee2012-01-04 00:46:20339 if (g_check_for_repost && check_for_repost &&
[email protected]59167c22013-06-03 18:07:32340 entry->GetHasPostData()) {
[email protected]a3a1d142008-12-19 00:42:30341 // The user is asking to reload a page with POST data. Prompt to make sure
[email protected]b5bb35f2009-02-05 20:17:07342 // they really want to do this. If they do, the dialog will call us back
343 // with check_for_repost = false.
[email protected]ec6c05f2013-10-23 18:41:57344 delegate_->NotifyBeforeFormRepostWarningShow();
[email protected]965bb092010-04-09 11:59:02345
[email protected]106a0812010-03-18 00:15:12346 pending_reload_ = reload_type;
[email protected]ec6c05f2013-10-23 18:41:57347 delegate_->ActivateAndShowRepostFormWarningDialog();
initial.commit09911bf2008-07-26 23:55:29348 } else {
[email protected]59167c22013-06-03 18:07:32349 if (!IsInitialNavigation())
350 DiscardNonCommittedEntriesInternal();
[email protected]c3b3d952012-01-31 12:52:26351
[email protected]bcd904482012-02-01 01:54:22352 // If we are reloading an entry that no longer belongs to the current
353 // site instance (for example, refreshing a page for just installed app),
354 // the reload must happen in a new process.
355 // The new entry must have a new page_id and site instance, so it behaves
356 // as new navigation (which happens to clear forward history).
[email protected]7e58cb272012-03-30 21:22:30357 // Tabs that are discarded due to low memory conditions may not have a site
358 // instance, and should not be treated as a cross-site reload.
[email protected]59167c22013-06-03 18:07:32359 SiteInstanceImpl* site_instance = entry->site_instance();
[email protected]fb4cc8e2013-12-17 17:56:21360 // Permit reloading guests without further checks.
[email protected]fe294ce2014-05-30 05:55:01361 bool is_isolated_guest = site_instance && site_instance->HasProcess() &&
362 site_instance->GetProcess()->IsIsolatedGuest();
363 if (!is_isolated_guest && site_instance &&
[email protected]7e58cb272012-03-30 21:22:30364 site_instance->HasWrongProcessForURL(entry->GetURL())) {
[email protected]bcd904482012-02-01 01:54:22365 // Create a navigation entry that resembles the current one, but do not
[email protected]688aa65c62012-09-28 04:32:22366 // copy page id, site instance, content state, or timestamp.
[email protected]bcd904482012-02-01 01:54:22367 NavigationEntryImpl* nav_entry = NavigationEntryImpl::FromNavigationEntry(
368 CreateNavigationEntry(
369 entry->GetURL(), entry->GetReferrer(), entry->GetTransitionType(),
370 false, entry->extra_headers(), browser_context_));
[email protected]c3b3d952012-01-31 12:52:26371
[email protected]11535962012-02-09 21:02:10372 // Mark the reload type as NO_RELOAD, so navigation will not be considered
373 // a reload in the renderer.
374 reload_type = NavigationController::NO_RELOAD;
375
[email protected]e2caa032012-11-15 23:29:18376 nav_entry->set_should_replace_entry(true);
[email protected]bcd904482012-02-01 01:54:22377 pending_entry_ = nav_entry;
378 } else {
[email protected]59167c22013-06-03 18:07:32379 pending_entry_ = entry;
[email protected]bcd904482012-02-01 01:54:22380 pending_entry_index_ = current_index;
381
382 // The title of the page being reloaded might have been removed in the
383 // meanwhile, so we need to revert to the default title upon reload and
384 // invalidate the previously cached title (SetTitle will do both).
385 // See Chromium issue 96041.
[email protected]fcf75d42013-12-03 20:11:26386 pending_entry_->SetTitle(base::string16());
[email protected]bcd904482012-02-01 01:54:22387
Sylvain Defresnec6ccc77d2014-09-19 10:19:35388 pending_entry_->SetTransitionType(ui::PAGE_TRANSITION_RELOAD);
[email protected]bcd904482012-02-01 01:54:22389 }
390
[email protected]1ccb3568d2010-02-19 10:51:16391 NavigateToPendingEntry(reload_type);
initial.commit09911bf2008-07-26 23:55:29392 }
393}
394
[email protected]d202a7c2012-01-04 07:53:47395void NavigationControllerImpl::CancelPendingReload() {
[email protected]106a0812010-03-18 00:15:12396 DCHECK(pending_reload_ != NO_RELOAD);
397 pending_reload_ = NO_RELOAD;
398}
399
[email protected]d202a7c2012-01-04 07:53:47400void NavigationControllerImpl::ContinuePendingReload() {
[email protected]106a0812010-03-18 00:15:12401 if (pending_reload_ == NO_RELOAD) {
402 NOTREACHED();
403 } else {
404 ReloadInternal(false, pending_reload_);
[email protected]965bb092010-04-09 11:59:02405 pending_reload_ = NO_RELOAD;
[email protected]106a0812010-03-18 00:15:12406 }
407}
408
[email protected]cd2e15742013-03-08 04:08:31409bool NavigationControllerImpl::IsInitialNavigation() const {
[email protected]27ba81c2012-08-21 17:04:09410 return is_initial_navigation_;
[email protected]c70f9b82010-04-21 07:31:11411}
412
[email protected]d202a7c2012-01-04 07:53:47413NavigationEntryImpl* NavigationControllerImpl::GetEntryWithPageID(
[email protected]b6583592012-01-25 19:52:33414 SiteInstance* instance, int32 page_id) const {
[email protected]7f0005a2009-04-15 03:25:11415 int index = GetEntryIndexWithPageID(instance, page_id);
[email protected]765b35502008-08-21 00:51:20416 return (index != -1) ? entries_[index].get() : NULL;
417}
418
[email protected]d202a7c2012-01-04 07:53:47419void NavigationControllerImpl::LoadEntry(NavigationEntryImpl* entry) {
[email protected]765b35502008-08-21 00:51:20420 // When navigating to a new page, we don't know for sure if we will actually
421 // end up leaving the current page. The new page load could for example
422 // result in a download or a 'no content' response (e.g., a mailto: URL).
[email protected]59167c22013-06-03 18:07:32423 SetPendingEntry(entry);
424 NavigateToPendingEntry(NO_RELOAD);
425}
426
427void NavigationControllerImpl::SetPendingEntry(NavigationEntryImpl* entry) {
[email protected]cbab76d2008-10-13 22:42:47428 DiscardNonCommittedEntriesInternal();
[email protected]765b35502008-08-21 00:51:20429 pending_entry_ = entry;
[email protected]8ff00d72012-10-23 19:12:21430 NotificationService::current()->Notify(
431 NOTIFICATION_NAV_ENTRY_PENDING,
432 Source<NavigationController>(this),
433 Details<NavigationEntry>(entry));
[email protected]765b35502008-08-21 00:51:20434}
435
[email protected]d202a7c2012-01-04 07:53:47436NavigationEntry* NavigationControllerImpl::GetActiveEntry() const {
[email protected]cbab76d2008-10-13 22:42:47437 if (transient_entry_index_ != -1)
438 return entries_[transient_entry_index_].get();
439 if (pending_entry_)
440 return pending_entry_;
441 return GetLastCommittedEntry();
[email protected]765b35502008-08-21 00:51:20442}
443
[email protected]d202a7c2012-01-04 07:53:47444NavigationEntry* NavigationControllerImpl::GetVisibleEntry() const {
[email protected]867e1f92011-08-30 19:01:19445 if (transient_entry_index_ != -1)
446 return entries_[transient_entry_index_].get();
[email protected]59167c22013-06-03 18:07:32447 // The pending entry is safe to return for new (non-history), browser-
448 // initiated navigations. Most renderer-initiated navigations should not
449 // show the pending entry, to prevent URL spoof attacks.
450 //
451 // We make an exception for renderer-initiated navigations in new tabs, as
452 // long as no other page has tried to access the initial empty document in
453 // the new tab. If another page modifies this blank page, a URL spoof is
454 // possible, so we must stop showing the pending entry.
[email protected]59167c22013-06-03 18:07:32455 bool safe_to_show_pending =
456 pending_entry_ &&
457 // Require a new navigation.
avi0dca04d2015-01-26 20:21:09458 pending_entry_index_ == -1 &&
[email protected]59167c22013-06-03 18:07:32459 // Require either browser-initiated or an unmodified new tab.
[email protected]aa62afd2014-04-22 19:22:46460 (!pending_entry_->is_renderer_initiated() || IsUnmodifiedBlankTab());
[email protected]59167c22013-06-03 18:07:32461
462 // Also allow showing the pending entry for history navigations in a new tab,
463 // such as Ctrl+Back. In this case, no existing page is visible and no one
464 // can script the new tab before it commits.
465 if (!safe_to_show_pending &&
466 pending_entry_ &&
avi0dca04d2015-01-26 20:21:09467 pending_entry_index_ != -1 &&
[email protected]59167c22013-06-03 18:07:32468 IsInitialNavigation() &&
[email protected]e47ae9472011-10-13 19:48:34469 !pending_entry_->is_renderer_initiated())
[email protected]59167c22013-06-03 18:07:32470 safe_to_show_pending = true;
471
472 if (safe_to_show_pending)
[email protected]867e1f92011-08-30 19:01:19473 return pending_entry_;
474 return GetLastCommittedEntry();
475}
476
[email protected]d202a7c2012-01-04 07:53:47477int NavigationControllerImpl::GetCurrentEntryIndex() const {
[email protected]cbab76d2008-10-13 22:42:47478 if (transient_entry_index_ != -1)
479 return transient_entry_index_;
[email protected]765b35502008-08-21 00:51:20480 if (pending_entry_index_ != -1)
481 return pending_entry_index_;
482 return last_committed_entry_index_;
483}
484
[email protected]d202a7c2012-01-04 07:53:47485NavigationEntry* NavigationControllerImpl::GetLastCommittedEntry() const {
[email protected]765b35502008-08-21 00:51:20486 if (last_committed_entry_index_ == -1)
487 return NULL;
488 return entries_[last_committed_entry_index_].get();
489}
490
[email protected]d202a7c2012-01-04 07:53:47491bool NavigationControllerImpl::CanViewSource() const {
[email protected]ec6c05f2013-10-23 18:41:57492 const std::string& mime_type = delegate_->GetContentsMimeType();
[email protected]9d86c4982013-01-09 00:38:34493 bool is_viewable_mime_type = net::IsSupportedNonImageMimeType(mime_type) &&
494 !net::IsSupportedMediaMimeType(mime_type);
[email protected]6286a3792013-10-09 04:03:27495 NavigationEntry* visible_entry = GetVisibleEntry();
496 return visible_entry && !visible_entry->IsViewSourceMode() &&
[email protected]ec6c05f2013-10-23 18:41:57497 is_viewable_mime_type && !delegate_->GetInterstitialPage();
[email protected]31682282010-01-15 18:05:16498}
499
[email protected]d202a7c2012-01-04 07:53:47500int NavigationControllerImpl::GetLastCommittedEntryIndex() const {
[email protected]a26023822011-12-29 00:23:55501 return last_committed_entry_index_;
502}
503
[email protected]d202a7c2012-01-04 07:53:47504int NavigationControllerImpl::GetEntryCount() const {
[email protected]944822b2012-03-02 20:57:25505 DCHECK(entries_.size() <= max_entry_count());
[email protected]a26023822011-12-29 00:23:55506 return static_cast<int>(entries_.size());
507}
508
[email protected]d202a7c2012-01-04 07:53:47509NavigationEntry* NavigationControllerImpl::GetEntryAtIndex(
[email protected]022af742011-12-28 18:37:25510 int index) const {
511 return entries_.at(index).get();
512}
513
[email protected]d202a7c2012-01-04 07:53:47514NavigationEntry* NavigationControllerImpl::GetEntryAtOffset(
[email protected]022af742011-12-28 18:37:25515 int offset) const {
[email protected]9ba14052012-06-22 23:50:03516 int index = GetIndexForOffset(offset);
[email protected]a26023822011-12-29 00:23:55517 if (index < 0 || index >= GetEntryCount())
[email protected]765b35502008-08-21 00:51:20518 return NULL;
519
520 return entries_[index].get();
521}
522
[email protected]9ba14052012-06-22 23:50:03523int NavigationControllerImpl::GetIndexForOffset(int offset) const {
[email protected]7bc2b032012-12-19 22:45:46524 return GetCurrentEntryIndex() + offset;
[email protected]9ba14052012-06-22 23:50:03525}
526
[email protected]9677a3c2012-12-22 04:18:58527void NavigationControllerImpl::TakeScreenshot() {
[email protected]1a3f5312013-04-26 21:00:10528 screenshot_manager_->TakeScreenshot();
[email protected]9677a3c2012-12-22 04:18:58529}
530
[email protected]1a3f5312013-04-26 21:00:10531void NavigationControllerImpl::SetScreenshotManager(
[email protected]d1581d72013-11-05 19:11:26532 NavigationEntryScreenshotManager* manager) {
[email protected]1a3f5312013-04-26 21:00:10533 screenshot_manager_.reset(manager ? manager :
[email protected]d1581d72013-11-05 19:11:26534 new NavigationEntryScreenshotManager(this));
[email protected]9677a3c2012-12-22 04:18:58535}
536
[email protected]d202a7c2012-01-04 07:53:47537bool NavigationControllerImpl::CanGoBack() const {
[email protected]765b35502008-08-21 00:51:20538 return entries_.size() > 1 && GetCurrentEntryIndex() > 0;
539}
540
[email protected]d202a7c2012-01-04 07:53:47541bool NavigationControllerImpl::CanGoForward() const {
[email protected]765b35502008-08-21 00:51:20542 int index = GetCurrentEntryIndex();
543 return index >= 0 && index < (static_cast<int>(entries_.size()) - 1);
544}
545
[email protected]9ba14052012-06-22 23:50:03546bool NavigationControllerImpl::CanGoToOffset(int offset) const {
547 int index = GetIndexForOffset(offset);
548 return index >= 0 && index < GetEntryCount();
549}
550
[email protected]d202a7c2012-01-04 07:53:47551void NavigationControllerImpl::GoBack() {
[email protected]765b35502008-08-21 00:51:20552 if (!CanGoBack()) {
553 NOTREACHED();
554 return;
555 }
556
557 // Base the navigation on where we are now...
558 int current_index = GetCurrentEntryIndex();
559
[email protected]cbab76d2008-10-13 22:42:47560 DiscardNonCommittedEntries();
[email protected]765b35502008-08-21 00:51:20561
562 pending_entry_index_ = current_index - 1;
[email protected]022af742011-12-28 18:37:25563 entries_[pending_entry_index_]->SetTransitionType(
Sylvain Defresnec6ccc77d2014-09-19 10:19:35564 ui::PageTransitionFromInt(
[email protected]36fc0392011-12-25 03:59:51565 entries_[pending_entry_index_]->GetTransitionType() |
Sylvain Defresnec6ccc77d2014-09-19 10:19:35566 ui::PAGE_TRANSITION_FORWARD_BACK));
[email protected]1ccb3568d2010-02-19 10:51:16567 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20568}
569
[email protected]d202a7c2012-01-04 07:53:47570void NavigationControllerImpl::GoForward() {
[email protected]765b35502008-08-21 00:51:20571 if (!CanGoForward()) {
572 NOTREACHED();
573 return;
574 }
575
[email protected]cbab76d2008-10-13 22:42:47576 bool transient = (transient_entry_index_ != -1);
577
[email protected]765b35502008-08-21 00:51:20578 // Base the navigation on where we are now...
579 int current_index = GetCurrentEntryIndex();
580
[email protected]cbab76d2008-10-13 22:42:47581 DiscardNonCommittedEntries();
[email protected]765b35502008-08-21 00:51:20582
[email protected]cbab76d2008-10-13 22:42:47583 pending_entry_index_ = current_index;
584 // If there was a transient entry, we removed it making the current index
585 // the next page.
586 if (!transient)
587 pending_entry_index_++;
588
[email protected]022af742011-12-28 18:37:25589 entries_[pending_entry_index_]->SetTransitionType(
Sylvain Defresnec6ccc77d2014-09-19 10:19:35590 ui::PageTransitionFromInt(
[email protected]36fc0392011-12-25 03:59:51591 entries_[pending_entry_index_]->GetTransitionType() |
Sylvain Defresnec6ccc77d2014-09-19 10:19:35592 ui::PAGE_TRANSITION_FORWARD_BACK));
[email protected]1ccb3568d2010-02-19 10:51:16593 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20594}
595
[email protected]d202a7c2012-01-04 07:53:47596void NavigationControllerImpl::GoToIndex(int index) {
[email protected]765b35502008-08-21 00:51:20597 if (index < 0 || index >= static_cast<int>(entries_.size())) {
598 NOTREACHED();
599 return;
600 }
601
[email protected]cbab76d2008-10-13 22:42:47602 if (transient_entry_index_ != -1) {
603 if (index == transient_entry_index_) {
604 // Nothing to do when navigating to the transient.
605 return;
606 }
607 if (index > transient_entry_index_) {
608 // Removing the transient is goint to shift all entries by 1.
609 index--;
610 }
611 }
612
613 DiscardNonCommittedEntries();
[email protected]765b35502008-08-21 00:51:20614
615 pending_entry_index_ = index;
[email protected]022af742011-12-28 18:37:25616 entries_[pending_entry_index_]->SetTransitionType(
Sylvain Defresnec6ccc77d2014-09-19 10:19:35617 ui::PageTransitionFromInt(
[email protected]36fc0392011-12-25 03:59:51618 entries_[pending_entry_index_]->GetTransitionType() |
Sylvain Defresnec6ccc77d2014-09-19 10:19:35619 ui::PAGE_TRANSITION_FORWARD_BACK));
[email protected]1ccb3568d2010-02-19 10:51:16620 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20621}
622
[email protected]d202a7c2012-01-04 07:53:47623void NavigationControllerImpl::GoToOffset(int offset) {
[email protected]9ba14052012-06-22 23:50:03624 if (!CanGoToOffset(offset))
[email protected]765b35502008-08-21 00:51:20625 return;
626
[email protected]9ba14052012-06-22 23:50:03627 GoToIndex(GetIndexForOffset(offset));
[email protected]765b35502008-08-21 00:51:20628}
629
[email protected]41374f12013-07-24 02:49:28630bool NavigationControllerImpl::RemoveEntryAtIndex(int index) {
631 if (index == last_committed_entry_index_ ||
632 index == pending_entry_index_)
633 return false;
[email protected]6a13a6c2011-12-20 21:47:12634
[email protected]43032342011-03-21 14:10:31635 RemoveEntryAtIndexInternal(index);
[email protected]41374f12013-07-24 02:49:28636 return true;
[email protected]cbab76d2008-10-13 22:42:47637}
638
[email protected]d202a7c2012-01-04 07:53:47639void NavigationControllerImpl::UpdateVirtualURLToURL(
[email protected]10f417c52011-12-28 21:04:23640 NavigationEntryImpl* entry, const GURL& new_url) {
[email protected]38178a42009-12-17 18:58:32641 GURL new_virtual_url(new_url);
[email protected]825b1662012-03-12 19:07:31642 if (BrowserURLHandlerImpl::GetInstance()->ReverseURLRewrite(
[email protected]36fc0392011-12-25 03:59:51643 &new_virtual_url, entry->GetVirtualURL(), browser_context_)) {
644 entry->SetVirtualURL(new_virtual_url);
[email protected]38178a42009-12-17 18:58:32645 }
646}
647
[email protected]d202a7c2012-01-04 07:53:47648void NavigationControllerImpl::LoadURL(
[email protected]6c6b02d2011-09-02 03:36:47649 const GURL& url,
[email protected]8ff00d72012-10-23 19:12:21650 const Referrer& referrer,
Sylvain Defresnec6ccc77d2014-09-19 10:19:35651 ui::PageTransition transition,
[email protected]6c6b02d2011-09-02 03:36:47652 const std::string& extra_headers) {
[email protected]cf002332012-08-14 19:17:47653 LoadURLParams params(url);
654 params.referrer = referrer;
655 params.transition_type = transition;
656 params.extra_headers = extra_headers;
657 LoadURLWithParams(params);
658}
659
660void NavigationControllerImpl::LoadURLWithParams(const LoadURLParams& params) {
naskob8744d22014-08-28 17:07:43661 TRACE_EVENT1("browser,navigation",
662 "NavigationControllerImpl::LoadURLWithParams",
663 "url", params.url.possibly_invalid_spec());
[email protected]47752982014-07-29 08:01:43664 if (HandleDebugURL(params.url, params.transition_type)) {
665 // If Telemetry is running, allow the URL load to proceed as if it's
666 // unhandled, otherwise Telemetry can't tell if Navigation completed.
avi83883c82014-12-23 00:08:49667 if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
[email protected]47752982014-07-29 08:01:43668 cc::switches::kEnableGpuBenchmarking))
669 return;
670 }
[email protected]8bf1048012012-02-08 01:22:18671
[email protected]c02f1ba2014-02-03 06:53:53672 // Any renderer-side debug URLs or javascript: URLs should be ignored if the
[email protected]c21e5c22014-02-05 23:56:41673 // renderer process is not live, unless it is the initial navigation of the
674 // tab.
[email protected]c02f1ba2014-02-03 06:53:53675 if (IsRendererDebugURL(params.url)) {
676 // TODO(creis): Find the RVH for the correct frame.
[email protected]c21e5c22014-02-05 23:56:41677 if (!delegate_->GetRenderViewHost()->IsRenderViewLive() &&
678 !IsInitialNavigation())
[email protected]c02f1ba2014-02-03 06:53:53679 return;
680 }
681
[email protected]cf002332012-08-14 19:17:47682 // Checks based on params.load_type.
683 switch (params.load_type) {
684 case LOAD_TYPE_DEFAULT:
685 break;
686 case LOAD_TYPE_BROWSER_INITIATED_HTTP_POST:
[email protected]e8ca69c2014-05-07 15:31:19687 if (!params.url.SchemeIs(url::kHttpScheme) &&
688 !params.url.SchemeIs(url::kHttpsScheme)) {
[email protected]cf002332012-08-14 19:17:47689 NOTREACHED() << "Http post load must use http(s) scheme.";
690 return;
691 }
692 break;
693 case LOAD_TYPE_DATA:
[email protected]cca6f392014-05-28 21:32:26694 if (!params.url.SchemeIs(url::kDataScheme)) {
[email protected]cf002332012-08-14 19:17:47695 NOTREACHED() << "Data load must use data scheme.";
696 return;
697 }
698 break;
699 default:
700 NOTREACHED();
701 break;
702 };
[email protected]e47ae9472011-10-13 19:48:34703
[email protected]e47ae9472011-10-13 19:48:34704 // The user initiated a load, we don't need to reload anymore.
705 needs_reload_ = false;
706
[email protected]cf002332012-08-14 19:17:47707 bool override = false;
708 switch (params.override_user_agent) {
709 case UA_OVERRIDE_INHERIT:
710 override = ShouldKeepOverride(GetLastCommittedEntry());
711 break;
712 case UA_OVERRIDE_TRUE:
713 override = true;
714 break;
715 case UA_OVERRIDE_FALSE:
716 override = false;
717 break;
718 default:
719 NOTREACHED();
720 break;
[email protected]d1ef81d2012-07-24 11:39:36721 }
722
[email protected]d1ef81d2012-07-24 11:39:36723 NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
724 CreateNavigationEntry(
[email protected]cf002332012-08-14 19:17:47725 params.url,
726 params.referrer,
727 params.transition_type,
728 params.is_renderer_initiated,
729 params.extra_headers,
[email protected]d1ef81d2012-07-24 11:39:36730 browser_context_));
[email protected]c80297782013-11-21 07:10:16731 if (params.frame_tree_node_id != -1)
732 entry->set_frame_tree_node_id(params.frame_tree_node_id);
lfg9ef7d2d2014-12-15 22:32:30733 entry->set_source_site_instance(
734 static_cast<SiteInstanceImpl*>(params.source_site_instance.get()));
[email protected]f8872902013-10-30 03:18:57735 if (params.redirect_chain.size() > 0)
[email protected]c1982ff2014-04-23 03:37:21736 entry->SetRedirectChain(params.redirect_chain);
avib6cc1562015-02-12 19:56:39737 // Don't allow an entry replacement if there is no entry to replace.
738 // http://crbug.com/457149
739 if (params.should_replace_current_entry && entries_.size() > 0)
[email protected]e2caa032012-11-15 23:29:18740 entry->set_should_replace_entry(true);
[email protected]60d6cca2013-04-30 08:47:13741 entry->set_should_clear_history_list(params.should_clear_history_list);
[email protected]cf002332012-08-14 19:17:47742 entry->SetIsOverridingUserAgent(override);
743 entry->set_transferred_global_request_id(
744 params.transferred_global_request_id);
[email protected]d2494ff2013-02-20 08:22:37745 entry->SetFrameToNavigate(params.frame_name);
[email protected]d1ef81d2012-07-24 11:39:36746
clamy8451aa62015-01-23 16:56:08747#if defined(OS_ANDROID)
748 if (params.intent_received_timestamp > 0) {
749 entry->set_intent_received_timestamp(
750 base::TimeTicks() +
751 base::TimeDelta::FromMilliseconds(params.intent_received_timestamp));
752 }
753#endif
754
[email protected]cf002332012-08-14 19:17:47755 switch (params.load_type) {
756 case LOAD_TYPE_DEFAULT:
757 break;
758 case LOAD_TYPE_BROWSER_INITIATED_HTTP_POST:
759 entry->SetHasPostData(true);
760 entry->SetBrowserInitiatedPostData(
[email protected]fc72bb12013-06-02 21:13:46761 params.browser_initiated_post_data.get());
[email protected]cf002332012-08-14 19:17:47762 break;
763 case LOAD_TYPE_DATA:
764 entry->SetBaseURLForDataURL(params.base_url_for_data_url);
765 entry->SetVirtualURL(params.virtual_url_for_data_url);
[email protected]951a64832012-10-11 16:26:37766 entry->SetCanLoadLocalResources(params.can_load_local_resources);
[email protected]cf002332012-08-14 19:17:47767 break;
768 default:
769 NOTREACHED();
770 break;
771 };
[email protected]132e281a2012-07-31 18:32:44772
773 LoadEntry(entry);
774}
775
[email protected]d202a7c2012-01-04 07:53:47776bool NavigationControllerImpl::RendererDidNavigate(
[email protected]27dd82fd2014-03-03 22:11:43777 RenderFrameHost* rfh,
[email protected]37567b432014-02-12 01:12:22778 const FrameHostMsg_DidCommitProvisionalLoad_Params& params,
[email protected]8ff00d72012-10-23 19:12:21779 LoadCommittedDetails* details) {
[email protected]cd2e15742013-03-08 04:08:31780 is_initial_navigation_ = false;
781
[email protected]0e8db942008-09-24 21:21:48782 // Save the previous state before we clobber it.
783 if (GetLastCommittedEntry()) {
[email protected]36fc0392011-12-25 03:59:51784 details->previous_url = GetLastCommittedEntry()->GetURL();
[email protected]a26023822011-12-29 00:23:55785 details->previous_entry_index = GetLastCommittedEntryIndex();
[email protected]0e8db942008-09-24 21:21:48786 } else {
787 details->previous_url = GURL();
788 details->previous_entry_index = -1;
789 }
[email protected]ecd9d8702008-08-28 22:10:17790
[email protected]77362eb2011-08-01 17:18:38791 // If we have a pending entry at this point, it should have a SiteInstance.
792 // Restored entries start out with a null SiteInstance, but we should have
793 // assigned one in NavigateToPendingEntry.
794 DCHECK(pending_entry_index_ == -1 || pending_entry_->site_instance());
[email protected]e9ba4472008-09-14 15:42:43795
[email protected]bcd904482012-02-01 01:54:22796 // If we are doing a cross-site reload, we need to replace the existing
797 // navigation entry, not add another entry to the history. This has the side
798 // effect of removing forward browsing history, if such existed.
[email protected]e2caa032012-11-15 23:29:18799 // Or if we are doing a cross-site redirect navigation,
800 // we will do a similar thing.
[email protected]4ac5fbe2012-09-01 02:19:59801 details->did_replace_entry =
[email protected]e2caa032012-11-15 23:29:18802 pending_entry_ && pending_entry_->should_replace_entry();
[email protected]bcd904482012-02-01 01:54:22803
[email protected]e9ba4472008-09-14 15:42:43804 // Do navigation-type specific actions. These will make and commit an entry.
[email protected]27dd82fd2014-03-03 22:11:43805 details->type = ClassifyNavigation(rfh, params);
[email protected]4bf3522c2010-08-19 21:00:20806
[email protected]b9d4dfdc2013-08-08 00:25:12807 // is_in_page must be computed before the entry gets committed.
[email protected]5cfbddc2014-06-23 23:52:23808 details->is_in_page = AreURLsInPageNavigation(rfh->GetLastCommittedURL(),
809 params.url, params.was_within_same_page, rfh);
[email protected]b9d4dfdc2013-08-08 00:25:12810
[email protected]0e8db942008-09-24 21:21:48811 switch (details->type) {
[email protected]8ff00d72012-10-23 19:12:21812 case NAVIGATION_TYPE_NEW_PAGE:
[email protected]27dd82fd2014-03-03 22:11:43813 RendererDidNavigateToNewPage(rfh, params, details->did_replace_entry);
[email protected]e9ba4472008-09-14 15:42:43814 break;
[email protected]8ff00d72012-10-23 19:12:21815 case NAVIGATION_TYPE_EXISTING_PAGE:
[email protected]27dd82fd2014-03-03 22:11:43816 RendererDidNavigateToExistingPage(rfh, params);
[email protected]e9ba4472008-09-14 15:42:43817 break;
[email protected]8ff00d72012-10-23 19:12:21818 case NAVIGATION_TYPE_SAME_PAGE:
[email protected]27dd82fd2014-03-03 22:11:43819 RendererDidNavigateToSamePage(rfh, params);
[email protected]e9ba4472008-09-14 15:42:43820 break;
[email protected]8ff00d72012-10-23 19:12:21821 case NAVIGATION_TYPE_IN_PAGE:
[email protected]27dd82fd2014-03-03 22:11:43822 RendererDidNavigateInPage(rfh, params, &details->did_replace_entry);
[email protected]e9ba4472008-09-14 15:42:43823 break;
[email protected]8ff00d72012-10-23 19:12:21824 case NAVIGATION_TYPE_NEW_SUBFRAME:
[email protected]27dd82fd2014-03-03 22:11:43825 RendererDidNavigateNewSubframe(rfh, params);
[email protected]e9ba4472008-09-14 15:42:43826 break;
[email protected]8ff00d72012-10-23 19:12:21827 case NAVIGATION_TYPE_AUTO_SUBFRAME:
[email protected]27dd82fd2014-03-03 22:11:43828 if (!RendererDidNavigateAutoSubframe(rfh, params))
[email protected]e9ba4472008-09-14 15:42:43829 return false;
830 break;
[email protected]8ff00d72012-10-23 19:12:21831 case NAVIGATION_TYPE_NAV_IGNORE:
[email protected]20d1c992011-04-12 21:17:49832 // If a pending navigation was in progress, this canceled it. We should
833 // discard it and make sure it is removed from the URL bar. After that,
834 // there is nothing we can do with this navigation, so we just return to
[email protected]e9ba4472008-09-14 15:42:43835 // the caller that nothing has happened.
[email protected]20d1c992011-04-12 21:17:49836 if (pending_entry_) {
837 DiscardNonCommittedEntries();
[email protected]ec6c05f2013-10-23 18:41:57838 delegate_->NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
[email protected]20d1c992011-04-12 21:17:49839 }
[email protected]e9ba4472008-09-14 15:42:43840 return false;
841 default:
842 NOTREACHED();
[email protected]765b35502008-08-21 00:51:20843 }
844
[email protected]688aa65c62012-09-28 04:32:22845 // At this point, we know that the navigation has just completed, so
846 // record the time.
847 //
848 // TODO(akalin): Use "sane time" as described in
849 // http://www.chromium.org/developers/design-documents/sane-time .
[email protected]c5b88d82012-10-06 17:03:33850 base::Time timestamp =
851 time_smoother_.GetSmoothedTime(get_timestamp_callback_.Run());
852 DVLOG(1) << "Navigation finished at (smoothed) timestamp "
[email protected]688aa65c62012-09-28 04:32:22853 << timestamp.ToInternalValue();
854
[email protected]f233e4232013-02-23 00:55:14855 // We should not have a pending entry anymore. Clear it again in case any
856 // error cases above forgot to do so.
857 DiscardNonCommittedEntriesInternal();
858
[email protected]e9ba4472008-09-14 15:42:43859 // All committed entries should have nonempty content state so WebKit doesn't
860 // get confused when we go back to them (see the function for details).
[email protected]691aa2f2013-05-28 22:52:04861 DCHECK(params.page_state.IsValid());
[email protected]10f417c52011-12-28 21:04:23862 NavigationEntryImpl* active_entry =
[email protected]f233e4232013-02-23 00:55:14863 NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry());
[email protected]688aa65c62012-09-28 04:32:22864 active_entry->SetTimestamp(timestamp);
[email protected]f49737b32013-08-28 07:51:44865 active_entry->SetHttpStatusCode(params.http_status_code);
[email protected]691aa2f2013-05-28 22:52:04866 active_entry->SetPageState(params.page_state);
[email protected]c1982ff2014-04-23 03:37:21867 active_entry->SetRedirectChain(params.redirects);
[email protected]132e281a2012-07-31 18:32:44868
[email protected]d6def3d2014-05-19 18:55:32869 // Use histogram to track memory impact of redirect chain because it's now
870 // not cleared for committed entries.
871 size_t redirect_chain_size = 0;
872 for (size_t i = 0; i < params.redirects.size(); ++i) {
873 redirect_chain_size += params.redirects[i].spec().length();
874 }
875 UMA_HISTOGRAM_COUNTS("Navigation.RedirectChainSize", redirect_chain_size);
876
[email protected]97d8f0d2013-10-29 16:49:21877 // Once it is committed, we no longer need to track several pieces of state on
878 // the entry.
879 active_entry->ResetForCommit();
[email protected]60d6cca2013-04-30 08:47:13880
[email protected]49bd30e62011-03-22 20:12:59881 // The active entry's SiteInstance should match our SiteInstance.
[email protected]a1b99262013-12-27 21:56:22882 // TODO(creis): This check won't pass for subframes until we create entries
883 // for subframe navigations.
Sylvain Defresnec6ccc77d2014-09-19 10:19:35884 if (ui::PageTransitionIsMainFrame(params.transition))
[email protected]27dd82fd2014-03-03 22:11:43885 CHECK(active_entry->site_instance() == rfh->GetSiteInstance());
[email protected]49bd30e62011-03-22 20:12:59886
[email protected]b26de072013-02-23 02:33:44887 // Remember the bindings the renderer process has at this point, so that
888 // we do not grant this entry additional bindings if we come back to it.
[email protected]27dd82fd2014-03-03 22:11:43889 active_entry->SetBindings(
890 static_cast<RenderFrameHostImpl*>(rfh)->GetEnabledBindings());
[email protected]b26de072013-02-23 02:33:44891
[email protected]e9ba4472008-09-14 15:42:43892 // Now prep the rest of the details for the notification and broadcast.
[email protected]0f38dc4552011-02-25 11:24:00893 details->entry = active_entry;
[email protected]2905f742011-10-13 03:51:58894 details->is_main_frame =
Sylvain Defresnec6ccc77d2014-09-19 10:19:35895 ui::PageTransitionIsMainFrame(params.transition);
[email protected]f072d2ce2008-09-17 17:16:24896 details->serialized_security_info = params.security_info;
[email protected]2e39d2e2009-02-19 18:41:31897 details->http_status_code = params.http_status_code;
[email protected]93f230e02011-06-01 14:40:00898 NotifyNavigationEntryCommitted(details);
initial.commit09911bf2008-07-26 23:55:29899
[email protected]e9ba4472008-09-14 15:42:43900 return true;
initial.commit09911bf2008-07-26 23:55:29901}
902
[email protected]8ff00d72012-10-23 19:12:21903NavigationType NavigationControllerImpl::ClassifyNavigation(
[email protected]27dd82fd2014-03-03 22:11:43904 RenderFrameHost* rfh,
[email protected]37567b432014-02-12 01:12:22905 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) const {
[email protected]e9ba4472008-09-14 15:42:43906 if (params.page_id == -1) {
[email protected]82307f6b2014-08-07 03:30:12907 // TODO(nasko, creis): An out-of-process child frame has no way of
908 // knowing the page_id of its parent, so it is passing back -1. The
909 // semantics here should be re-evaluated during session history refactor
910 // (see http://crbug.com/236848). For now, we assume this means the
911 // child frame loaded and proceed. Note that this may do the wrong thing
912 // for cross-process AUTO_SUBFRAME navigations.
913 if (rfh->IsCrossProcessSubframe())
914 return NAVIGATION_TYPE_NEW_SUBFRAME;
915
[email protected]eef9de32009-09-23 17:19:46916 // The renderer generates the page IDs, and so if it gives us the invalid
917 // page ID (-1) we know it didn't actually navigate. This happens in a few
918 // cases:
919 //
920 // - If a page makes a popup navigated to about blank, and then writes
921 // stuff like a subframe navigated to a real page. We'll get the commit
922 // for the subframe, but there won't be any commit for the outer page.
923 //
924 // - We were also getting these for failed loads (for example, bug 21849).
925 // The guess is that we get a "load commit" for the alternate error page,
926 // but that doesn't affect the page ID, so we get the "old" one, which
927 // could be invalid. This can also happen for a cross-site transition
928 // that causes us to swap processes. Then the error page load will be in
929 // a new process with no page IDs ever assigned (and hence a -1 value),
930 // yet the navigation controller still might have previous pages in its
931 // list.
932 //
933 // In these cases, there's nothing we can do with them, so ignore.
[email protected]8ff00d72012-10-23 19:12:21934 return NAVIGATION_TYPE_NAV_IGNORE;
[email protected]e9ba4472008-09-14 15:42:43935 }
936
[email protected]a1b99262013-12-27 21:56:22937 if (params.page_id > delegate_->GetMaxPageIDForSiteInstance(
[email protected]27dd82fd2014-03-03 22:11:43938 rfh->GetSiteInstance())) {
[email protected]e9ba4472008-09-14 15:42:43939 // Greater page IDs than we've ever seen before are new pages. We may or may
940 // not have a pending entry for the page, and this may or may not be the
941 // main frame.
Sylvain Defresnec6ccc77d2014-09-19 10:19:35942 if (ui::PageTransitionIsMainFrame(params.transition))
[email protected]8ff00d72012-10-23 19:12:21943 return NAVIGATION_TYPE_NEW_PAGE;
[email protected]4c27ba82008-09-24 16:49:09944
945 // When this is a new subframe navigation, we should have a committed page
946 // for which it's a suframe in. This may not be the case when an iframe is
947 // navigated on a popup navigated to about:blank (the iframe would be
948 // written into the popup by script on the main page). For these cases,
949 // there isn't any navigation stuff we can do, so just ignore it.
950 if (!GetLastCommittedEntry())
[email protected]8ff00d72012-10-23 19:12:21951 return NAVIGATION_TYPE_NAV_IGNORE;
[email protected]4c27ba82008-09-24 16:49:09952
953 // Valid subframe navigation.
[email protected]8ff00d72012-10-23 19:12:21954 return NAVIGATION_TYPE_NEW_SUBFRAME;
[email protected]e9ba4472008-09-14 15:42:43955 }
956
[email protected]60d6cca2013-04-30 08:47:13957 // We only clear the session history when navigating to a new page.
958 DCHECK(!params.history_list_was_cleared);
959
[email protected]e9ba4472008-09-14 15:42:43960 // Now we know that the notification is for an existing page. Find that entry.
961 int existing_entry_index = GetEntryIndexWithPageID(
[email protected]27dd82fd2014-03-03 22:11:43962 rfh->GetSiteInstance(),
[email protected]e9ba4472008-09-14 15:42:43963 params.page_id);
964 if (existing_entry_index == -1) {
965 // The page was not found. It could have been pruned because of the limit on
966 // back/forward entries (not likely since we'll usually tell it to navigate
967 // to such entries). It could also mean that the renderer is smoking crack.
968 NOTREACHED();
[email protected]485e8232011-07-24 18:03:46969
970 // Because the unknown entry has committed, we risk showing the wrong URL in
971 // release builds. Instead, we'll kill the renderer process to be safe.
972 LOG(ERROR) << "terminating renderer for bad navigation: " << params.url;
[email protected]e6e30ac2014-01-13 21:24:39973 RecordAction(base::UserMetricsAction("BadMessageTerminate_NC"));
[email protected]b69934e2011-10-29 02:51:52974
[email protected]7ec6f382011-11-11 01:28:17975 // Temporary code so we can get more information. Format:
[email protected]8c380582011-12-02 03:16:10976 // http://url/foo.html#page1#max3#frame1#ids:2_Nx,1_1x,3_2
977 std::string temp = params.url.spec();
[email protected]7ec6f382011-11-11 01:28:17978 temp.append("#page");
[email protected]b69934e2011-10-29 02:51:52979 temp.append(base::IntToString(params.page_id));
[email protected]7ec6f382011-11-11 01:28:17980 temp.append("#max");
[email protected]ec6c05f2013-10-23 18:41:57981 temp.append(base::IntToString(delegate_->GetMaxPageID()));
[email protected]7ec6f382011-11-11 01:28:17982 temp.append("#frame");
[email protected]27dd82fd2014-03-03 22:11:43983 temp.append(base::IntToString(rfh->GetRoutingID()));
[email protected]7ec6f382011-11-11 01:28:17984 temp.append("#ids");
985 for (int i = 0; i < static_cast<int>(entries_.size()); ++i) {
[email protected]8c380582011-12-02 03:16:10986 // Append entry metadata (e.g., 3_7x):
987 // 3: page_id
988 // 7: SiteInstance ID, or N for null
989 // x: appended if not from the current SiteInstance
[email protected]36fc0392011-12-25 03:59:51990 temp.append(base::IntToString(entries_[i]->GetPageID()));
[email protected]8c380582011-12-02 03:16:10991 temp.append("_");
992 if (entries_[i]->site_instance())
[email protected]b6583592012-01-25 19:52:33993 temp.append(base::IntToString(entries_[i]->site_instance()->GetId()));
[email protected]7ec6f382011-11-11 01:28:17994 else
[email protected]8c380582011-12-02 03:16:10995 temp.append("N");
[email protected]27dd82fd2014-03-03 22:11:43996 if (entries_[i]->site_instance() != rfh->GetSiteInstance())
[email protected]7ec6f382011-11-11 01:28:17997 temp.append("x");
998 temp.append(",");
[email protected]b69934e2011-10-29 02:51:52999 }
1000 GURL url(temp);
[email protected]27dd82fd2014-03-03 22:11:431001 static_cast<RenderFrameHostImpl*>(rfh)->render_view_host()->Send(
[email protected]a1b99262013-12-27 21:56:221002 new ViewMsg_TempCrashWithData(url));
[email protected]8ff00d72012-10-23 19:12:211003 return NAVIGATION_TYPE_NAV_IGNORE;
[email protected]e9ba4472008-09-14 15:42:431004 }
[email protected]10f417c52011-12-28 21:04:231005 NavigationEntryImpl* existing_entry = entries_[existing_entry_index].get();
[email protected]e9ba4472008-09-14 15:42:431006
Sylvain Defresnec6ccc77d2014-09-19 10:19:351007 if (!ui::PageTransitionIsMainFrame(params.transition)) {
[email protected]e6035c22010-05-25 16:15:521008 // All manual subframes would get new IDs and were handled above, so we
1009 // know this is auto. Since the current page was found in the navigation
1010 // entry list, we're guaranteed to have a last committed entry.
1011 DCHECK(GetLastCommittedEntry());
[email protected]8ff00d72012-10-23 19:12:211012 return NAVIGATION_TYPE_AUTO_SUBFRAME;
[email protected]e6035c22010-05-25 16:15:521013 }
1014
1015 // Anything below here we know is a main frame navigation.
[email protected]e9ba4472008-09-14 15:42:431016 if (pending_entry_ &&
[email protected]59167c22013-06-03 18:07:321017 !pending_entry_->is_renderer_initiated() &&
[email protected]e9ba4472008-09-14 15:42:431018 existing_entry != pending_entry_ &&
[email protected]36fc0392011-12-25 03:59:511019 pending_entry_->GetPageID() == -1 &&
[email protected]230c0012011-04-08 16:27:241020 existing_entry == GetLastCommittedEntry()) {
[email protected]e9ba4472008-09-14 15:42:431021 // In this case, we have a pending entry for a URL but WebCore didn't do a
1022 // new navigation. This happens when you press enter in the URL bar to
1023 // reload. We will create a pending entry, but WebKit will convert it to
1024 // a reload since it's the same page and not create a new entry for it
1025 // (the user doesn't want to have a new back/forward entry when they do
[email protected]230c0012011-04-08 16:27:241026 // this). If this matches the last committed entry, we want to just ignore
1027 // the pending entry and go back to where we were (the "existing entry").
[email protected]8ff00d72012-10-23 19:12:211028 return NAVIGATION_TYPE_SAME_PAGE;
[email protected]e9ba4472008-09-14 15:42:431029 }
1030
[email protected]fc60f222008-12-18 17:36:541031 // Any toplevel navigations with the same base (minus the reference fragment)
1032 // are in-page navigations. We weeded out subframe navigations above. Most of
1033 // the time this doesn't matter since WebKit doesn't tell us about subframe
1034 // navigations that don't actually navigate, but it can happen when there is
1035 // an encoding override (it always sends a navigation request).
[email protected]4ac5fbe2012-09-01 02:19:591036 if (AreURLsInPageNavigation(existing_entry->GetURL(), params.url,
[email protected]5cfbddc2014-06-23 23:52:231037 params.was_within_same_page, rfh)) {
[email protected]8ff00d72012-10-23 19:12:211038 return NAVIGATION_TYPE_IN_PAGE;
[email protected]4ac5fbe2012-09-01 02:19:591039 }
[email protected]fc60f222008-12-18 17:36:541040
[email protected]e9ba4472008-09-14 15:42:431041 // Since we weeded out "new" navigations above, we know this is an existing
[email protected]4c27ba82008-09-24 16:49:091042 // (back/forward) navigation.
[email protected]8ff00d72012-10-23 19:12:211043 return NAVIGATION_TYPE_EXISTING_PAGE;
[email protected]e9ba4472008-09-14 15:42:431044}
1045
[email protected]d202a7c2012-01-04 07:53:471046void NavigationControllerImpl::RendererDidNavigateToNewPage(
[email protected]27dd82fd2014-03-03 22:11:431047 RenderFrameHost* rfh,
[email protected]37567b432014-02-12 01:12:221048 const FrameHostMsg_DidCommitProvisionalLoad_Params& params,
[email protected]a1b99262013-12-27 21:56:221049 bool replace_entry) {
[email protected]10f417c52011-12-28 21:04:231050 NavigationEntryImpl* new_entry;
[email protected]f1eb87a2011-05-06 17:49:411051 bool update_virtual_url;
[email protected]6dd86ab2013-02-27 00:30:341052 // Only make a copy of the pending entry if it is appropriate for the new page
1053 // that was just loaded. We verify this at a coarse grain by checking that
1054 // the SiteInstance hasn't been assigned to something else.
1055 if (pending_entry_ &&
1056 (!pending_entry_->site_instance() ||
[email protected]27dd82fd2014-03-03 22:11:431057 pending_entry_->site_instance() == rfh->GetSiteInstance())) {
[email protected]10f417c52011-12-28 21:04:231058 new_entry = new NavigationEntryImpl(*pending_entry_);
[email protected]e9ba4472008-09-14 15:42:431059
1060 // Don't use the page type from the pending entry. Some interstitial page
1061 // may have set the type to interstitial. Once we commit, however, the page
1062 // type must always be normal.
[email protected]8ff00d72012-10-23 19:12:211063 new_entry->set_page_type(PAGE_TYPE_NORMAL);
[email protected]f1eb87a2011-05-06 17:49:411064 update_virtual_url = new_entry->update_virtual_url_with_url();
[email protected]e9ba4472008-09-14 15:42:431065 } else {
[email protected]10f417c52011-12-28 21:04:231066 new_entry = new NavigationEntryImpl;
[email protected]f8f93eb2012-09-25 03:06:241067
1068 // Find out whether the new entry needs to update its virtual URL on URL
1069 // change and set up the entry accordingly. This is needed to correctly
1070 // update the virtual URL when replaceState is called after a pushState.
1071 GURL url = params.url;
1072 bool needs_update = false;
[email protected]47752982014-07-29 08:01:431073 BrowserURLHandlerImpl::GetInstance()->RewriteURLIfNecessary(
1074 &url, browser_context_, &needs_update);
[email protected]f8f93eb2012-09-25 03:06:241075 new_entry->set_update_virtual_url_with_url(needs_update);
1076
[email protected]f1eb87a2011-05-06 17:49:411077 // When navigating to a new page, give the browser URL handler a chance to
1078 // update the virtual URL based on the new URL. For example, this is needed
1079 // to show chrome://bookmarks/#1 when the bookmarks webui extension changes
1080 // the URL.
[email protected]f8f93eb2012-09-25 03:06:241081 update_virtual_url = needs_update;
[email protected]e9ba4472008-09-14 15:42:431082 }
1083
wjmacleane6a5d222014-09-25 01:41:411084 if (params.url_is_unreachable)
1085 new_entry->set_page_type(PAGE_TYPE_ERROR);
[email protected]ad23a092011-12-28 07:02:041086 new_entry->SetURL(params.url);
[email protected]f1eb87a2011-05-06 17:49:411087 if (update_virtual_url)
[email protected]38178a42009-12-17 18:58:321088 UpdateVirtualURLToURL(new_entry, params.url);
[email protected]022af742011-12-28 18:37:251089 new_entry->SetReferrer(params.referrer);
[email protected]36fc0392011-12-25 03:59:511090 new_entry->SetPageID(params.page_id);
[email protected]022af742011-12-28 18:37:251091 new_entry->SetTransitionType(params.transition);
[email protected]b6583592012-01-25 19:52:331092 new_entry->set_site_instance(
[email protected]27dd82fd2014-03-03 22:11:431093 static_cast<SiteInstanceImpl*>(rfh->GetSiteInstance()));
[email protected]36fc0392011-12-25 03:59:511094 new_entry->SetHasPostData(params.is_post);
[email protected]86cd9472012-02-03 19:51:051095 new_entry->SetPostID(params.post_id);
[email protected]7c16976c2012-08-04 02:38:231096 new_entry->SetOriginalRequestURL(params.original_request_url);
[email protected]bf70edce2012-06-20 22:32:221097 new_entry->SetIsOverridingUserAgent(params.is_overriding_user_agent);
[email protected]e9ba4472008-09-14 15:42:431098
[email protected]ff64b3e2014-05-31 04:07:331099 // history.pushState() is classified as a navigation to a new page, but
1100 // sets was_within_same_page to true. In this case, we already have the
[email protected]3a868f212014-08-09 10:41:191101 // title and favicon available, so set them immediately.
1102 if (params.was_within_same_page && GetLastCommittedEntry()) {
[email protected]ff64b3e2014-05-31 04:07:331103 new_entry->SetTitle(GetLastCommittedEntry()->GetTitle());
[email protected]3a868f212014-08-09 10:41:191104 new_entry->GetFavicon() = GetLastCommittedEntry()->GetFavicon();
1105 }
[email protected]ff64b3e2014-05-31 04:07:331106
[email protected]60d6cca2013-04-30 08:47:131107 DCHECK(!params.history_list_was_cleared || !replace_entry);
1108 // The browser requested to clear the session history when it initiated the
1109 // navigation. Now we know that the renderer has updated its state accordingly
1110 // and it is safe to also clear the browser side history.
1111 if (params.history_list_was_cleared) {
1112 DiscardNonCommittedEntriesInternal();
1113 entries_.clear();
1114 last_committed_entry_index_ = -1;
1115 }
1116
[email protected]4ac5fbe2012-09-01 02:19:591117 InsertOrReplaceEntry(new_entry, replace_entry);
[email protected]e9ba4472008-09-14 15:42:431118}
1119
[email protected]d202a7c2012-01-04 07:53:471120void NavigationControllerImpl::RendererDidNavigateToExistingPage(
[email protected]27dd82fd2014-03-03 22:11:431121 RenderFrameHost* rfh,
[email protected]37567b432014-02-12 01:12:221122 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
[email protected]e9ba4472008-09-14 15:42:431123 // We should only get here for main frame navigations.
Sylvain Defresnec6ccc77d2014-09-19 10:19:351124 DCHECK(ui::PageTransitionIsMainFrame(params.transition));
[email protected]e9ba4472008-09-14 15:42:431125
1126 // This is a back/forward navigation. The existing page for the ID is
[email protected]4c27ba82008-09-24 16:49:091127 // guaranteed to exist by ClassifyNavigation, and we just need to update it
1128 // with new information from the renderer.
[email protected]27dd82fd2014-03-03 22:11:431129 int entry_index = GetEntryIndexWithPageID(rfh->GetSiteInstance(),
[email protected]7f0005a2009-04-15 03:25:111130 params.page_id);
[email protected]e9ba4472008-09-14 15:42:431131 DCHECK(entry_index >= 0 &&
1132 entry_index < static_cast<int>(entries_.size()));
[email protected]10f417c52011-12-28 21:04:231133 NavigationEntryImpl* entry = entries_[entry_index].get();
[email protected]e9ba4472008-09-14 15:42:431134
[email protected]5ccd4dc2012-10-24 02:28:141135 // The URL may have changed due to redirects.
[email protected]ad23a092011-12-28 07:02:041136 entry->SetURL(params.url);
[email protected]25cd5f12014-01-10 11:02:201137 entry->SetReferrer(params.referrer);
[email protected]38178a42009-12-17 18:58:321138 if (entry->update_virtual_url_with_url())
1139 UpdateVirtualURLToURL(entry, params.url);
[email protected]5ccd4dc2012-10-24 02:28:141140
1141 // The redirected to page should not inherit the favicon from the previous
1142 // page.
Sylvain Defresnec6ccc77d2014-09-19 10:19:351143 if (ui::PageTransitionIsRedirect(params.transition))
[email protected]91a4ff82012-10-29 20:29:481144 entry->GetFavicon() = FaviconStatus();
[email protected]5ccd4dc2012-10-24 02:28:141145
1146 // The site instance will normally be the same except during session restore,
1147 // when no site instance will be assigned.
[email protected]e9ba4472008-09-14 15:42:431148 DCHECK(entry->site_instance() == NULL ||
[email protected]27dd82fd2014-03-03 22:11:431149 entry->site_instance() == rfh->GetSiteInstance());
[email protected]b6583592012-01-25 19:52:331150 entry->set_site_instance(
[email protected]27dd82fd2014-03-03 22:11:431151 static_cast<SiteInstanceImpl*>(rfh->GetSiteInstance()));
[email protected]e9ba4472008-09-14 15:42:431152
[email protected]36fc0392011-12-25 03:59:511153 entry->SetHasPostData(params.is_post);
[email protected]86cd9472012-02-03 19:51:051154 entry->SetPostID(params.post_id);
[email protected]d5a49e52010-01-08 03:01:411155
[email protected]e9ba4472008-09-14 15:42:431156 // The entry we found in the list might be pending if the user hit
1157 // back/forward/reload. This load should commit it (since it's already in the
[email protected]49bd30e62011-03-22 20:12:591158 // list, we can just discard the pending pointer). We should also discard the
1159 // pending entry if it corresponds to a different navigation, since that one
1160 // is now likely canceled. If it is not canceled, we will treat it as a new
1161 // navigation when it arrives, which is also ok.
[email protected]e9ba4472008-09-14 15:42:431162 //
1163 // Note that we need to use the "internal" version since we don't want to
1164 // actually change any other state, just kill the pointer.
[email protected]6eebaab2012-11-15 04:39:491165 DiscardNonCommittedEntriesInternal();
[email protected]40bcc302009-03-02 20:50:391166
[email protected]80858db52009-10-15 00:35:181167 // If a transient entry was removed, the indices might have changed, so we
1168 // have to query the entry index again.
1169 last_committed_entry_index_ =
[email protected]27dd82fd2014-03-03 22:11:431170 GetEntryIndexWithPageID(rfh->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:431171}
1172
[email protected]d202a7c2012-01-04 07:53:471173void NavigationControllerImpl::RendererDidNavigateToSamePage(
[email protected]27dd82fd2014-03-03 22:11:431174 RenderFrameHost* rfh,
[email protected]37567b432014-02-12 01:12:221175 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
[email protected]e9ba4472008-09-14 15:42:431176 // This mode implies we have a pending entry that's the same as an existing
[email protected]4c27ba82008-09-24 16:49:091177 // entry for this page ID. This entry is guaranteed to exist by
1178 // ClassifyNavigation. All we need to do is update the existing entry.
[email protected]10f417c52011-12-28 21:04:231179 NavigationEntryImpl* existing_entry = GetEntryWithPageID(
[email protected]27dd82fd2014-03-03 22:11:431180 rfh->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:431181
1182 // We assign the entry's unique ID to be that of the new one. Since this is
1183 // always the result of a user action, we want to dismiss infobars, etc. like
1184 // a regular user-initiated navigation.
[email protected]36fc0392011-12-25 03:59:511185 existing_entry->set_unique_id(pending_entry_->GetUniqueID());
[email protected]e9ba4472008-09-14 15:42:431186
[email protected]a0e69262009-06-03 19:08:481187 // The URL may have changed due to redirects.
[email protected]38178a42009-12-17 18:58:321188 if (existing_entry->update_virtual_url_with_url())
1189 UpdateVirtualURLToURL(existing_entry, params.url);
[email protected]ad23a092011-12-28 07:02:041190 existing_entry->SetURL(params.url);
[email protected]25cd5f12014-01-10 11:02:201191 existing_entry->SetReferrer(params.referrer);
[email protected]a0e69262009-06-03 19:08:481192
[email protected]b77686522013-12-11 20:34:191193 // The page may have been requested with a different HTTP method.
1194 existing_entry->SetHasPostData(params.is_post);
1195 existing_entry->SetPostID(params.post_id);
1196
[email protected]cbab76d2008-10-13 22:42:471197 DiscardNonCommittedEntries();
[email protected]e9ba4472008-09-14 15:42:431198}
1199
[email protected]d202a7c2012-01-04 07:53:471200void NavigationControllerImpl::RendererDidNavigateInPage(
[email protected]27dd82fd2014-03-03 22:11:431201 RenderFrameHost* rfh,
[email protected]37567b432014-02-12 01:12:221202 const FrameHostMsg_DidCommitProvisionalLoad_Params& params,
[email protected]a1b99262013-12-27 21:56:221203 bool* did_replace_entry) {
Sylvain Defresnec6ccc77d2014-09-19 10:19:351204 DCHECK(ui::PageTransitionIsMainFrame(params.transition)) <<
[email protected]e9ba4472008-09-14 15:42:431205 "WebKit should only tell us about in-page navs for the main frame.";
1206 // We're guaranteed to have an entry for this one.
[email protected]10f417c52011-12-28 21:04:231207 NavigationEntryImpl* existing_entry = GetEntryWithPageID(
[email protected]27dd82fd2014-03-03 22:11:431208 rfh->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:431209
1210 // Reference fragment navigation. We're guaranteed to have the last_committed
1211 // entry and it will be the same page as the new navigation (minus the
[email protected]d466b8a2011-07-15 21:48:031212 // reference fragments, of course). We'll update the URL of the existing
1213 // entry without pruning the forward history.
[email protected]ad23a092011-12-28 07:02:041214 existing_entry->SetURL(params.url);
[email protected]d466b8a2011-07-15 21:48:031215 if (existing_entry->update_virtual_url_with_url())
1216 UpdateVirtualURLToURL(existing_entry, params.url);
[email protected]ccbe04e2010-03-17 17:58:431217
[email protected]12cef652014-05-31 22:25:151218 existing_entry->SetHasPostData(params.is_post);
1219 existing_entry->SetPostID(params.post_id);
1220
[email protected]ccbe04e2010-03-17 17:58:431221 // This replaces the existing entry since the page ID didn't change.
1222 *did_replace_entry = true;
[email protected]d466b8a2011-07-15 21:48:031223
[email protected]6eebaab2012-11-15 04:39:491224 DiscardNonCommittedEntriesInternal();
[email protected]d466b8a2011-07-15 21:48:031225
1226 // If a transient entry was removed, the indices might have changed, so we
1227 // have to query the entry index again.
1228 last_committed_entry_index_ =
[email protected]27dd82fd2014-03-03 22:11:431229 GetEntryIndexWithPageID(rfh->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:431230}
1231
[email protected]d202a7c2012-01-04 07:53:471232void NavigationControllerImpl::RendererDidNavigateNewSubframe(
[email protected]27dd82fd2014-03-03 22:11:431233 RenderFrameHost* rfh,
[email protected]37567b432014-02-12 01:12:221234 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
avi9f07a0c2015-02-18 22:51:291235 if (!ui::PageTransitionCoreTypeIs(params.transition,
1236 ui::PAGE_TRANSITION_MANUAL_SUBFRAME)) {
1237 // There was a comment here that said, "This is not user-initiated. Ignore."
1238 // But this makes no sense; non-user-initiated navigations should be
1239 // determined to be of type NAVIGATION_TYPE_AUTO_SUBFRAME and sent to
1240 // RendererDidNavigateAutoSubframe below.
1241 //
1242 // This if clause dates back to https://codereview.chromium.org/115919 and
1243 // the handling of immediate redirects. TODO(avi): Is this still valid? I'm
1244 // pretty sure that's there's nothing left of that code and that we should
1245 // take this out.
1246 //
1247 // Except for cross-process iframes; this doesn't work yet for them.
1248 if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
1249 switches::kSitePerProcess)) {
1250 NOTREACHED();
1251 }
1252
[email protected]f233e4232013-02-23 00:55:141253 DiscardNonCommittedEntriesInternal();
[email protected]09b8f82f2009-06-16 20:22:111254 return;
1255 }
[email protected]09b8f82f2009-06-16 20:22:111256
[email protected]e9ba4472008-09-14 15:42:431257 // Manual subframe navigations just get the current entry cloned so the user
1258 // can go back or forward to it. The actual subframe information will be
1259 // stored in the page state for each of those entries. This happens out of
1260 // band with the actual navigations.
[email protected]4c27ba82008-09-24 16:49:091261 DCHECK(GetLastCommittedEntry()) << "ClassifyNavigation should guarantee "
1262 << "that a last committed entry exists.";
[email protected]10f417c52011-12-28 21:04:231263 NavigationEntryImpl* new_entry = new NavigationEntryImpl(
1264 *NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry()));
[email protected]36fc0392011-12-25 03:59:511265 new_entry->SetPageID(params.page_id);
[email protected]672eba292009-05-13 13:22:451266 InsertOrReplaceEntry(new_entry, false);
[email protected]e9ba4472008-09-14 15:42:431267}
1268
[email protected]d202a7c2012-01-04 07:53:471269bool NavigationControllerImpl::RendererDidNavigateAutoSubframe(
[email protected]27dd82fd2014-03-03 22:11:431270 RenderFrameHost* rfh,
[email protected]37567b432014-02-12 01:12:221271 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
avi9f07a0c2015-02-18 22:51:291272 DCHECK(ui::PageTransitionCoreTypeIs(params.transition,
1273 ui::PAGE_TRANSITION_AUTO_SUBFRAME));
1274
[email protected]e9ba4472008-09-14 15:42:431275 // We're guaranteed to have a previously committed entry, and we now need to
1276 // handle navigation inside of a subframe in it without creating a new entry.
1277 DCHECK(GetLastCommittedEntry());
1278
1279 // Handle the case where we're navigating back/forward to a previous subframe
1280 // navigation entry. This is case "2." in NAV_AUTO_SUBFRAME comment in the
1281 // header file. In case "1." this will be a NOP.
1282 int entry_index = GetEntryIndexWithPageID(
[email protected]27dd82fd2014-03-03 22:11:431283 rfh->GetSiteInstance(),
[email protected]e9ba4472008-09-14 15:42:431284 params.page_id);
1285 if (entry_index < 0 ||
1286 entry_index >= static_cast<int>(entries_.size())) {
1287 NOTREACHED();
1288 return false;
1289 }
1290
1291 // Update the current navigation entry in case we're going back/forward.
1292 if (entry_index != last_committed_entry_index_) {
[email protected]e9ba4472008-09-14 15:42:431293 last_committed_entry_index_ = entry_index;
[email protected]f233e4232013-02-23 00:55:141294 DiscardNonCommittedEntriesInternal();
[email protected]e9ba4472008-09-14 15:42:431295 return true;
1296 }
[email protected]f233e4232013-02-23 00:55:141297
1298 // We do not need to discard the pending entry in this case, since we will
1299 // not generate commit notifications for this auto-subframe navigation.
[email protected]e9ba4472008-09-14 15:42:431300 return false;
1301}
1302
[email protected]d202a7c2012-01-04 07:53:471303int NavigationControllerImpl::GetIndexOfEntry(
[email protected]10f417c52011-12-28 21:04:231304 const NavigationEntryImpl* entry) const {
[email protected]765b35502008-08-21 00:51:201305 const NavigationEntries::const_iterator i(std::find(
1306 entries_.begin(),
1307 entries_.end(),
1308 entry));
1309 return (i == entries_.end()) ? -1 : static_cast<int>(i - entries_.begin());
1310}
1311
[email protected]ce760d742012-08-30 22:31:101312bool NavigationControllerImpl::IsURLInPageNavigation(
[email protected]b9d4dfdc2013-08-08 00:25:121313 const GURL& url,
1314 bool renderer_says_in_page,
[email protected]5cfbddc2014-06-23 23:52:231315 RenderFrameHost* rfh) const {
[email protected]10f417c52011-12-28 21:04:231316 NavigationEntry* last_committed = GetLastCommittedEntry();
[email protected]ce760d742012-08-30 22:31:101317 return last_committed && AreURLsInPageNavigation(
[email protected]5cfbddc2014-06-23 23:52:231318 last_committed->GetURL(), url, renderer_says_in_page, rfh);
[email protected]e9ba4472008-09-14 15:42:431319}
1320
[email protected]d202a7c2012-01-04 07:53:471321void NavigationControllerImpl::CopyStateFrom(
[email protected]c5eed492012-01-04 17:07:501322 const NavigationController& temp) {
[email protected]d202a7c2012-01-04 07:53:471323 const NavigationControllerImpl& source =
1324 static_cast<const NavigationControllerImpl&>(temp);
[email protected]ce3fa3c2009-04-20 19:55:571325 // Verify that we look new.
[email protected]a26023822011-12-29 00:23:551326 DCHECK(GetEntryCount() == 0 && !GetPendingEntry());
[email protected]ce3fa3c2009-04-20 19:55:571327
[email protected]a26023822011-12-29 00:23:551328 if (source.GetEntryCount() == 0)
[email protected]ce3fa3c2009-04-20 19:55:571329 return; // Nothing new to do.
1330
1331 needs_reload_ = true;
[email protected]a26023822011-12-29 00:23:551332 InsertEntriesFrom(source, source.GetEntryCount());
[email protected]ce3fa3c2009-04-20 19:55:571333
[email protected]fdac6ade2013-07-20 01:06:301334 for (SessionStorageNamespaceMap::const_iterator it =
1335 source.session_storage_namespace_map_.begin();
1336 it != source.session_storage_namespace_map_.end();
1337 ++it) {
1338 SessionStorageNamespaceImpl* source_namespace =
1339 static_cast<SessionStorageNamespaceImpl*>(it->second.get());
1340 session_storage_namespace_map_[it->first] = source_namespace->Clone();
1341 }
[email protected]4e6419c2010-01-15 04:50:341342
[email protected]2ca1ea662012-10-04 02:26:361343 FinishRestore(source.last_committed_entry_index_, RESTORE_CURRENT_SESSION);
[email protected]91854cd2012-01-10 19:43:571344
1345 // Copy the max page id map from the old tab to the new tab. This ensures
1346 // that new and existing navigations in the tab's current SiteInstances
1347 // are identified properly.
[email protected]ec6c05f2013-10-23 18:41:571348 delegate_->CopyMaxPageIDsFrom(source.delegate()->GetWebContents());
[email protected]ce3fa3c2009-04-20 19:55:571349}
1350
[email protected]d202a7c2012-01-04 07:53:471351void NavigationControllerImpl::CopyStateFromAndPrune(
[email protected]e78a6852013-12-13 08:08:571352 NavigationController* temp,
1353 bool replace_entry) {
[email protected]474f8512013-05-31 22:31:161354 // It is up to callers to check the invariants before calling this.
[email protected]79368982013-11-13 01:11:011355 CHECK(CanPruneAllButLastCommitted());
[email protected]474f8512013-05-31 22:31:161356
[email protected]d202a7c2012-01-04 07:53:471357 NavigationControllerImpl* source =
1358 static_cast<NavigationControllerImpl*>(temp);
[email protected]e1cd5452010-08-26 18:03:251359
avi2b177592014-12-10 02:08:021360 // Remove all the entries leaving the last committed entry.
[email protected]79368982013-11-13 01:11:011361 PruneAllButLastCommittedInternal();
[email protected]e1cd5452010-08-26 18:03:251362
[email protected]474f8512013-05-31 22:31:161363 // We now have one entry, possibly with a new pending entry. Ensure that
1364 // adding the entries from source won't put us over the limit.
1365 DCHECK_EQ(1, GetEntryCount());
[email protected]e78a6852013-12-13 08:08:571366 if (!replace_entry)
1367 source->PruneOldestEntryIfFull();
[email protected]944822b2012-03-02 20:57:251368
[email protected]47e020a2010-10-15 14:43:371369 // Insert the entries from source. Don't use source->GetCurrentEntryIndex as
avi2b177592014-12-10 02:08:021370 // we don't want to copy over the transient entry. Ignore any pending entry,
[email protected]474f8512013-05-31 22:31:161371 // since it has not committed in source.
1372 int max_source_index = source->last_committed_entry_index_;
[email protected]e1cd5452010-08-26 18:03:251373 if (max_source_index == -1)
[email protected]a26023822011-12-29 00:23:551374 max_source_index = source->GetEntryCount();
[email protected]e1cd5452010-08-26 18:03:251375 else
1376 max_source_index++;
[email protected]e78a6852013-12-13 08:08:571377
1378 // Ignore the source's current entry if merging with replacement.
1379 // TODO(davidben): This should preserve entries forward of the current
1380 // too. http://crbug.com/317872
1381 if (replace_entry && max_source_index > 0)
1382 max_source_index--;
1383
[email protected]47e020a2010-10-15 14:43:371384 InsertEntriesFrom(*source, max_source_index);
[email protected]e1cd5452010-08-26 18:03:251385
1386 // Adjust indices such that the last entry and pending are at the end now.
[email protected]a26023822011-12-29 00:23:551387 last_committed_entry_index_ = GetEntryCount() - 1;
[email protected]796931a92011-08-10 01:32:141388
avi2b177592014-12-10 02:08:021389 delegate_->SetHistoryOffsetAndLength(last_committed_entry_index_,
1390 GetEntryCount());
[email protected]91854cd2012-01-10 19:43:571391
avi2b177592014-12-10 02:08:021392 // Copy the max page id map from the old tab to the new tab. This ensures that
1393 // new and existing navigations in the tab's current SiteInstances are
1394 // identified properly.
1395 NavigationEntryImpl* last_committed =
1396 NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry());
1397 int32 site_max_page_id =
1398 delegate_->GetMaxPageIDForSiteInstance(last_committed->site_instance());
[email protected]ec6c05f2013-10-23 18:41:571399 delegate_->CopyMaxPageIDsFrom(source->delegate()->GetWebContents());
avi2b177592014-12-10 02:08:021400 delegate_->UpdateMaxPageIDForSiteInstance(last_committed->site_instance(),
1401 site_max_page_id);
[email protected]f69ed362014-04-28 14:01:421402 max_restored_page_id_ = source->max_restored_page_id_;
[email protected]e1cd5452010-08-26 18:03:251403}
1404
[email protected]79368982013-11-13 01:11:011405bool NavigationControllerImpl::CanPruneAllButLastCommitted() {
[email protected]474f8512013-05-31 22:31:161406 // If there is no last committed entry, we cannot prune. Even if there is a
1407 // pending entry, it may not commit, leaving this WebContents blank, despite
1408 // possibly giving it new entries via CopyStateFromAndPrune.
1409 if (last_committed_entry_index_ == -1)
1410 return false;
[email protected]9350602e2013-02-26 23:27:441411
[email protected]474f8512013-05-31 22:31:161412 // We cannot prune if there is a pending entry at an existing entry index.
1413 // It may not commit, so we have to keep the last committed entry, and thus
1414 // there is no sensible place to keep the pending entry. It is ok to have
1415 // a new pending entry, which can optionally commit as a new navigation.
1416 if (pending_entry_index_ != -1)
1417 return false;
1418
1419 // We should not prune if we are currently showing a transient entry.
1420 if (transient_entry_index_ != -1)
1421 return false;
1422
1423 return true;
1424}
1425
[email protected]79368982013-11-13 01:11:011426void NavigationControllerImpl::PruneAllButLastCommitted() {
1427 PruneAllButLastCommittedInternal();
[email protected]474f8512013-05-31 22:31:161428
avi2b177592014-12-10 02:08:021429 DCHECK_EQ(0, last_committed_entry_index_);
1430 DCHECK_EQ(1, GetEntryCount());
[email protected]9350602e2013-02-26 23:27:441431
avi2b177592014-12-10 02:08:021432 delegate_->SetHistoryOffsetAndLength(last_committed_entry_index_,
1433 GetEntryCount());
[email protected]9350602e2013-02-26 23:27:441434}
1435
[email protected]79368982013-11-13 01:11:011436void NavigationControllerImpl::PruneAllButLastCommittedInternal() {
[email protected]474f8512013-05-31 22:31:161437 // It is up to callers to check the invariants before calling this.
[email protected]79368982013-11-13 01:11:011438 CHECK(CanPruneAllButLastCommitted());
[email protected]97b6c4f2010-09-27 19:31:261439
[email protected]474f8512013-05-31 22:31:161440 // Erase all entries but the last committed entry. There may still be a
1441 // new pending entry after this.
1442 entries_.erase(entries_.begin(),
1443 entries_.begin() + last_committed_entry_index_);
1444 entries_.erase(entries_.begin() + 1, entries_.end());
1445 last_committed_entry_index_ = 0;
[email protected]97b6c4f2010-09-27 19:31:261446}
1447
[email protected]15f46dc2013-01-24 05:40:241448void NavigationControllerImpl::ClearAllScreenshots() {
[email protected]1a3f5312013-04-26 21:00:101449 screenshot_manager_->ClearAllScreenshots();
[email protected]15f46dc2013-01-24 05:40:241450}
1451
[email protected]d1198fd2012-08-13 22:50:191452void NavigationControllerImpl::SetSessionStorageNamespace(
[email protected]fdac6ade2013-07-20 01:06:301453 const std::string& partition_id,
[email protected]8ff00d72012-10-23 19:12:211454 SessionStorageNamespace* session_storage_namespace) {
[email protected]d1198fd2012-08-13 22:50:191455 if (!session_storage_namespace)
1456 return;
1457
1458 // We can't overwrite an existing SessionStorage without violating spec.
1459 // Attempts to do so may give a tab access to another tab's session storage
1460 // so die hard on an error.
[email protected]fdac6ade2013-07-20 01:06:301461 bool successful_insert = session_storage_namespace_map_.insert(
1462 make_pair(partition_id,
1463 static_cast<SessionStorageNamespaceImpl*>(
1464 session_storage_namespace)))
1465 .second;
1466 CHECK(successful_insert) << "Cannot replace existing SessionStorageNamespace";
[email protected]d1198fd2012-08-13 22:50:191467}
1468
[email protected]d202a7c2012-01-04 07:53:471469void NavigationControllerImpl::SetMaxRestoredPageID(int32 max_id) {
[email protected]71fde352011-12-29 03:29:561470 max_restored_page_id_ = max_id;
1471}
1472
[email protected]d202a7c2012-01-04 07:53:471473int32 NavigationControllerImpl::GetMaxRestoredPageID() const {
[email protected]71fde352011-12-29 03:29:561474 return max_restored_page_id_;
[email protected]a26023822011-12-29 00:23:551475}
1476
[email protected]aa62afd2014-04-22 19:22:461477bool NavigationControllerImpl::IsUnmodifiedBlankTab() const {
[email protected]aa62afd2014-04-22 19:22:461478 return IsInitialNavigation() &&
[email protected]b4c84012014-04-28 19:51:101479 !GetLastCommittedEntry() &&
1480 !delegate_->HasAccessedInitialDocument();
[email protected]aa62afd2014-04-22 19:22:461481}
1482
[email protected]a26023822011-12-29 00:23:551483SessionStorageNamespace*
[email protected]fdac6ade2013-07-20 01:06:301484NavigationControllerImpl::GetSessionStorageNamespace(SiteInstance* instance) {
1485 std::string partition_id;
1486 if (instance) {
1487 // TODO(ajwong): When GetDefaultSessionStorageNamespace() goes away, remove
1488 // this if statement so |instance| must not be NULL.
1489 partition_id =
1490 GetContentClient()->browser()->GetStoragePartitionIdForSite(
1491 browser_context_, instance->GetSiteURL());
1492 }
[email protected]d1198fd2012-08-13 22:50:191493
[email protected]fdac6ade2013-07-20 01:06:301494 SessionStorageNamespaceMap::const_iterator it =
1495 session_storage_namespace_map_.find(partition_id);
1496 if (it != session_storage_namespace_map_.end())
1497 return it->second.get();
1498
1499 // Create one if no one has accessed session storage for this partition yet.
1500 //
1501 // TODO(ajwong): Should this use the |partition_id| directly rather than
1502 // re-lookup via |instance|? http://crbug.com/142685
1503 StoragePartition* partition =
1504 BrowserContext::GetStoragePartition(browser_context_, instance);
1505 SessionStorageNamespaceImpl* session_storage_namespace =
1506 new SessionStorageNamespaceImpl(
[email protected]5f2aa722013-08-07 16:59:411507 static_cast<DOMStorageContextWrapper*>(
[email protected]fdac6ade2013-07-20 01:06:301508 partition->GetDOMStorageContext()));
1509 session_storage_namespace_map_[partition_id] = session_storage_namespace;
1510
1511 return session_storage_namespace;
1512}
1513
1514SessionStorageNamespace*
1515NavigationControllerImpl::GetDefaultSessionStorageNamespace() {
1516 // TODO(ajwong): Remove if statement in GetSessionStorageNamespace().
1517 return GetSessionStorageNamespace(NULL);
1518}
1519
1520const SessionStorageNamespaceMap&
1521NavigationControllerImpl::GetSessionStorageNamespaceMap() const {
1522 return session_storage_namespace_map_;
[email protected]a26023822011-12-29 00:23:551523}
[email protected]d202a7c2012-01-04 07:53:471524
1525bool NavigationControllerImpl::NeedsReload() const {
[email protected]71fde352011-12-29 03:29:561526 return needs_reload_;
1527}
[email protected]a26023822011-12-29 00:23:551528
[email protected]46bb5e9c2013-10-03 22:16:471529void NavigationControllerImpl::SetNeedsReload() {
1530 needs_reload_ = true;
jaekyunc8cefa82015-01-09 20:14:541531
1532 if (last_committed_entry_index_ != -1) {
1533 entries_[last_committed_entry_index_]->SetTransitionType(
1534 ui::PAGE_TRANSITION_RELOAD);
1535 }
[email protected]46bb5e9c2013-10-03 22:16:471536}
1537
[email protected]d202a7c2012-01-04 07:53:471538void NavigationControllerImpl::RemoveEntryAtIndexInternal(int index) {
[email protected]a26023822011-12-29 00:23:551539 DCHECK(index < GetEntryCount());
[email protected]6a13a6c2011-12-20 21:47:121540 DCHECK(index != last_committed_entry_index_);
[email protected]43032342011-03-21 14:10:311541
1542 DiscardNonCommittedEntries();
1543
1544 entries_.erase(entries_.begin() + index);
[email protected]6a13a6c2011-12-20 21:47:121545 if (last_committed_entry_index_ > index)
[email protected]43032342011-03-21 14:10:311546 last_committed_entry_index_--;
1547}
1548
[email protected]d202a7c2012-01-04 07:53:471549void NavigationControllerImpl::DiscardNonCommittedEntries() {
[email protected]cbab76d2008-10-13 22:42:471550 bool transient = transient_entry_index_ != -1;
1551 DiscardNonCommittedEntriesInternal();
initial.commit09911bf2008-07-26 23:55:291552
[email protected]cbab76d2008-10-13 22:42:471553 // If there was a transient entry, invalidate everything so the new active
1554 // entry state is shown.
1555 if (transient) {
[email protected]7f924832014-08-09 05:57:221556 delegate_->NotifyNavigationStateChanged(INVALIDATE_TYPE_ALL);
[email protected]cbab76d2008-10-13 22:42:471557 }
initial.commit09911bf2008-07-26 23:55:291558}
1559
[email protected]d202a7c2012-01-04 07:53:471560NavigationEntry* NavigationControllerImpl::GetPendingEntry() const {
[email protected]022af742011-12-28 18:37:251561 return pending_entry_;
1562}
1563
[email protected]d202a7c2012-01-04 07:53:471564int NavigationControllerImpl::GetPendingEntryIndex() const {
[email protected]a26023822011-12-29 00:23:551565 return pending_entry_index_;
1566}
1567
[email protected]d202a7c2012-01-04 07:53:471568void NavigationControllerImpl::InsertOrReplaceEntry(NavigationEntryImpl* entry,
1569 bool replace) {
Sylvain Defresnec6ccc77d2014-09-19 10:19:351570 DCHECK(entry->GetTransitionType() != ui::PAGE_TRANSITION_AUTO_SUBFRAME);
[email protected]765b35502008-08-21 00:51:201571
1572 // Copy the pending entry's unique ID to the committed entry.
1573 // I don't know if pending_entry_index_ can be other than -1 here.
[email protected]10f417c52011-12-28 21:04:231574 const NavigationEntryImpl* const pending_entry =
1575 (pending_entry_index_ == -1) ?
1576 pending_entry_ : entries_[pending_entry_index_].get();
[email protected]765b35502008-08-21 00:51:201577 if (pending_entry)
[email protected]36fc0392011-12-25 03:59:511578 entry->set_unique_id(pending_entry->GetUniqueID());
[email protected]765b35502008-08-21 00:51:201579
[email protected]cbab76d2008-10-13 22:42:471580 DiscardNonCommittedEntriesInternal();
[email protected]765b35502008-08-21 00:51:201581
1582 int current_size = static_cast<int>(entries_.size());
avib6cc1562015-02-12 19:56:391583 DCHECK(current_size > 0 || !replace);
[email protected]765b35502008-08-21 00:51:201584
[email protected]765b35502008-08-21 00:51:201585 if (current_size > 0) {
[email protected]672eba292009-05-13 13:22:451586 // Prune any entries which are in front of the current entry.
1587 // Also prune the current entry if we are to replace the current entry.
[email protected]47dcbdc2011-05-27 15:08:311588 // last_committed_entry_index_ must be updated here since calls to
1589 // NotifyPrunedEntries() below may re-enter and we must make sure
1590 // last_committed_entry_index_ is not left in an invalid state.
1591 if (replace)
1592 --last_committed_entry_index_;
1593
[email protected]c12bf1a12008-09-17 16:28:491594 int num_pruned = 0;
[email protected]47dcbdc2011-05-27 15:08:311595 while (last_committed_entry_index_ < (current_size - 1)) {
[email protected]c12bf1a12008-09-17 16:28:491596 num_pruned++;
[email protected]765b35502008-08-21 00:51:201597 entries_.pop_back();
1598 current_size--;
1599 }
[email protected]c12bf1a12008-09-17 16:28:491600 if (num_pruned > 0) // Only notify if we did prune something.
1601 NotifyPrunedEntries(this, false, num_pruned);
[email protected]765b35502008-08-21 00:51:201602 }
1603
[email protected]944822b2012-03-02 20:57:251604 PruneOldestEntryIfFull();
[email protected]765b35502008-08-21 00:51:201605
[email protected]10f417c52011-12-28 21:04:231606 entries_.push_back(linked_ptr<NavigationEntryImpl>(entry));
[email protected]765b35502008-08-21 00:51:201607 last_committed_entry_index_ = static_cast<int>(entries_.size()) - 1;
[email protected]e9ba4472008-09-14 15:42:431608
1609 // This is a new page ID, so we need everybody to know about it.
[email protected]ec6c05f2013-10-23 18:41:571610 delegate_->UpdateMaxPageID(entry->GetPageID());
initial.commit09911bf2008-07-26 23:55:291611}
1612
[email protected]944822b2012-03-02 20:57:251613void NavigationControllerImpl::PruneOldestEntryIfFull() {
1614 if (entries_.size() >= max_entry_count()) {
1615 DCHECK_EQ(max_entry_count(), entries_.size());
[email protected]e6fec472013-05-14 05:29:021616 DCHECK_GT(last_committed_entry_index_, 0);
[email protected]944822b2012-03-02 20:57:251617 RemoveEntryAtIndex(0);
1618 NotifyPrunedEntries(this, true, 1);
1619 }
1620}
1621
[email protected]d202a7c2012-01-04 07:53:471622void NavigationControllerImpl::NavigateToPendingEntry(ReloadType reload_type) {
[email protected]72097fd02010-01-21 23:36:011623 needs_reload_ = false;
1624
[email protected]83c2e232011-10-07 21:36:461625 // If we were navigating to a slow-to-commit page, and the user performs
1626 // a session history navigation to the last committed page, RenderViewHost
1627 // will force the throbber to start, but WebKit will essentially ignore the
1628 // navigation, and won't send a message to stop the throbber. To prevent this
1629 // from happening, we drop the navigation here and stop the slow-to-commit
1630 // page from loading (which would normally happen during the navigation).
1631 if (pending_entry_index_ != -1 &&
1632 pending_entry_index_ == last_committed_entry_index_ &&
1633 (entries_[pending_entry_index_]->restore_type() ==
[email protected]10f417c52011-12-28 21:04:231634 NavigationEntryImpl::RESTORE_NONE) &&
[email protected]36fc0392011-12-25 03:59:511635 (entries_[pending_entry_index_]->GetTransitionType() &
Sylvain Defresnec6ccc77d2014-09-19 10:19:351636 ui::PAGE_TRANSITION_FORWARD_BACK)) {
[email protected]ec6c05f2013-10-23 18:41:571637 delegate_->Stop();
[email protected]6a13a6c2011-12-20 21:47:121638
1639 // If an interstitial page is showing, we want to close it to get back
1640 // to what was showing before.
[email protected]ec6c05f2013-10-23 18:41:571641 if (delegate_->GetInterstitialPage())
1642 delegate_->GetInterstitialPage()->DontProceed();
[email protected]6a13a6c2011-12-20 21:47:121643
[email protected]83c2e232011-10-07 21:36:461644 DiscardNonCommittedEntries();
1645 return;
1646 }
1647
[email protected]6a13a6c2011-12-20 21:47:121648 // If an interstitial page is showing, the previous renderer is blocked and
1649 // cannot make new requests. Unblock (and disable) it to allow this
1650 // navigation to succeed. The interstitial will stay visible until the
1651 // resulting DidNavigate.
[email protected]ec6c05f2013-10-23 18:41:571652 if (delegate_->GetInterstitialPage()) {
1653 static_cast<InterstitialPageImpl*>(delegate_->GetInterstitialPage())->
[email protected]cadaec52012-02-08 21:53:131654 CancelForNavigation();
1655 }
[email protected]6a13a6c2011-12-20 21:47:121656
initial.commit09911bf2008-07-26 23:55:291657 // For session history navigations only the pending_entry_index_ is set.
1658 if (!pending_entry_) {
[email protected]4bf3522c2010-08-19 21:00:201659 DCHECK_NE(pending_entry_index_, -1);
[email protected]765b35502008-08-21 00:51:201660 pending_entry_ = entries_[pending_entry_index_].get();
initial.commit09911bf2008-07-26 23:55:291661 }
1662
[email protected]40fd3032014-02-28 22:16:281663 // This call does not support re-entrancy. See http://crbug.com/347742.
1664 CHECK(!in_navigate_to_pending_entry_);
1665 in_navigate_to_pending_entry_ = true;
1666 bool success = delegate_->NavigateToPendingEntry(reload_type);
1667 in_navigate_to_pending_entry_ = false;
1668
1669 if (!success)
[email protected]cbab76d2008-10-13 22:42:471670 DiscardNonCommittedEntries();
[email protected]77362eb2011-08-01 17:18:381671
1672 // If the entry is being restored and doesn't have a SiteInstance yet, fill
1673 // it in now that we know. This allows us to find the entry when it commits.
[email protected]77362eb2011-08-01 17:18:381674 if (pending_entry_ && !pending_entry_->site_instance() &&
[email protected]10f417c52011-12-28 21:04:231675 pending_entry_->restore_type() != NavigationEntryImpl::RESTORE_NONE) {
[email protected]b6583592012-01-25 19:52:331676 pending_entry_->set_site_instance(static_cast<SiteInstanceImpl*>(
[email protected]ec6c05f2013-10-23 18:41:571677 delegate_->GetPendingSiteInstance()));
[email protected]10f417c52011-12-28 21:04:231678 pending_entry_->set_restore_type(NavigationEntryImpl::RESTORE_NONE);
[email protected]77362eb2011-08-01 17:18:381679 }
initial.commit09911bf2008-07-26 23:55:291680}
1681
[email protected]d202a7c2012-01-04 07:53:471682void NavigationControllerImpl::NotifyNavigationEntryCommitted(
[email protected]8ff00d72012-10-23 19:12:211683 LoadCommittedDetails* details) {
[email protected]6286a3792013-10-09 04:03:271684 details->entry = GetLastCommittedEntry();
[email protected]df1af242009-05-01 00:11:401685
[email protected]2db9bd72012-04-13 20:20:561686 // We need to notify the ssl_manager_ before the web_contents_ so the
[email protected]df1af242009-05-01 00:11:401687 // location bar will have up-to-date information about the security style
1688 // when it wants to draw. See http://crbug.com/11157
[email protected]b0f724c2013-09-05 04:21:131689 ssl_manager_.DidCommitProvisionalLoad(*details);
[email protected]df1af242009-05-01 00:11:401690
[email protected]7f924832014-08-09 05:57:221691 delegate_->NotifyNavigationStateChanged(INVALIDATE_TYPE_ALL);
[email protected]ec6c05f2013-10-23 18:41:571692 delegate_->NotifyNavigationEntryCommitted(*details);
[email protected]cbb1ef592013-06-05 19:49:461693
[email protected]b0f724c2013-09-05 04:21:131694 // TODO(avi): Remove. http://crbug.com/170921
1695 NotificationDetails notification_details =
1696 Details<LoadCommittedDetails>(details);
[email protected]8ff00d72012-10-23 19:12:211697 NotificationService::current()->Notify(
1698 NOTIFICATION_NAV_ENTRY_COMMITTED,
1699 Source<NavigationController>(this),
[email protected]df1af242009-05-01 00:11:401700 notification_details);
initial.commit09911bf2008-07-26 23:55:291701}
1702
initial.commit09911bf2008-07-26 23:55:291703// static
[email protected]d202a7c2012-01-04 07:53:471704size_t NavigationControllerImpl::max_entry_count() {
[email protected]9b51970d2011-12-09 23:10:231705 if (max_entry_count_for_testing_ != kMaxEntryCountForTestingNotSet)
1706 return max_entry_count_for_testing_;
[email protected]8ff00d72012-10-23 19:12:211707 return kMaxSessionHistoryEntries;
[email protected]9b51970d2011-12-09 23:10:231708}
1709
[email protected]d202a7c2012-01-04 07:53:471710void NavigationControllerImpl::SetActive(bool is_active) {
[email protected]ee613922009-09-02 20:38:221711 if (is_active && needs_reload_)
1712 LoadIfNecessary();
initial.commit09911bf2008-07-26 23:55:291713}
1714
[email protected]d202a7c2012-01-04 07:53:471715void NavigationControllerImpl::LoadIfNecessary() {
initial.commit09911bf2008-07-26 23:55:291716 if (!needs_reload_)
1717 return;
1718
initial.commit09911bf2008-07-26 23:55:291719 // Calling Reload() results in ignoring state, and not loading.
1720 // Explicitly use NavigateToPendingEntry so that the renderer uses the
1721 // cached state.
1722 pending_entry_index_ = last_committed_entry_index_;
[email protected]1ccb3568d2010-02-19 10:51:161723 NavigateToPendingEntry(NO_RELOAD);
initial.commit09911bf2008-07-26 23:55:291724}
1725
[email protected]d202a7c2012-01-04 07:53:471726void NavigationControllerImpl::NotifyEntryChanged(const NavigationEntry* entry,
1727 int index) {
[email protected]8ff00d72012-10-23 19:12:211728 EntryChangedDetails det;
[email protected]534e54b2008-08-13 15:40:091729 det.changed_entry = entry;
1730 det.index = index;
[email protected]8ff00d72012-10-23 19:12:211731 NotificationService::current()->Notify(
1732 NOTIFICATION_NAV_ENTRY_CHANGED,
1733 Source<NavigationController>(this),
1734 Details<EntryChangedDetails>(&det));
initial.commit09911bf2008-07-26 23:55:291735}
1736
[email protected]d202a7c2012-01-04 07:53:471737void NavigationControllerImpl::FinishRestore(int selected_index,
[email protected]2ca1ea662012-10-04 02:26:361738 RestoreType type) {
[email protected]a26023822011-12-29 00:23:551739 DCHECK(selected_index >= 0 && selected_index < GetEntryCount());
[email protected]2ca1ea662012-10-04 02:26:361740 ConfigureEntriesForRestore(&entries_, type);
initial.commit09911bf2008-07-26 23:55:291741
[email protected]71fde352011-12-29 03:29:561742 SetMaxRestoredPageID(static_cast<int32>(GetEntryCount()));
initial.commit09911bf2008-07-26 23:55:291743
1744 last_committed_entry_index_ = selected_index;
initial.commit09911bf2008-07-26 23:55:291745}
[email protected]765b35502008-08-21 00:51:201746
[email protected]d202a7c2012-01-04 07:53:471747void NavigationControllerImpl::DiscardNonCommittedEntriesInternal() {
[email protected]b12eb222013-09-10 00:11:481748 DiscardPendingEntry();
1749 DiscardTransientEntry();
1750}
1751
1752void NavigationControllerImpl::DiscardPendingEntry() {
[email protected]40fd3032014-02-28 22:16:281753 // It is not safe to call DiscardPendingEntry while NavigateToEntry is in
[email protected]e7fee58a2014-04-11 19:51:401754 // progress, since this will cause a use-after-free. (We only allow this
1755 // when the tab is being destroyed for shutdown, since it won't return to
1756 // NavigateToEntry in that case.) http://crbug.com/347742.
1757 CHECK(!in_navigate_to_pending_entry_ || delegate_->IsBeingDestroyed());
[email protected]40fd3032014-02-28 22:16:281758
[email protected]765b35502008-08-21 00:51:201759 if (pending_entry_index_ == -1)
1760 delete pending_entry_;
1761 pending_entry_ = NULL;
1762 pending_entry_index_ = -1;
[email protected]cbab76d2008-10-13 22:42:471763}
1764
[email protected]d202a7c2012-01-04 07:53:471765void NavigationControllerImpl::DiscardTransientEntry() {
[email protected]cbab76d2008-10-13 22:42:471766 if (transient_entry_index_ == -1)
1767 return;
[email protected]a0e69262009-06-03 19:08:481768 entries_.erase(entries_.begin() + transient_entry_index_);
[email protected]80858db52009-10-15 00:35:181769 if (last_committed_entry_index_ > transient_entry_index_)
1770 last_committed_entry_index_--;
[email protected]cbab76d2008-10-13 22:42:471771 transient_entry_index_ = -1;
[email protected]765b35502008-08-21 00:51:201772}
1773
[email protected]d202a7c2012-01-04 07:53:471774int NavigationControllerImpl::GetEntryIndexWithPageID(
[email protected]7f0005a2009-04-15 03:25:111775 SiteInstance* instance, int32 page_id) const {
[email protected]765b35502008-08-21 00:51:201776 for (int i = static_cast<int>(entries_.size()) - 1; i >= 0; --i) {
[email protected]7f0005a2009-04-15 03:25:111777 if ((entries_[i]->site_instance() == instance) &&
[email protected]36fc0392011-12-25 03:59:511778 (entries_[i]->GetPageID() == page_id))
[email protected]765b35502008-08-21 00:51:201779 return i;
1780 }
1781 return -1;
1782}
[email protected]cbab76d2008-10-13 22:42:471783
[email protected]d202a7c2012-01-04 07:53:471784NavigationEntry* NavigationControllerImpl::GetTransientEntry() const {
[email protected]cbab76d2008-10-13 22:42:471785 if (transient_entry_index_ == -1)
1786 return NULL;
1787 return entries_[transient_entry_index_].get();
1788}
[email protected]e1cd5452010-08-26 18:03:251789
[email protected]0b684262013-02-20 02:18:211790void NavigationControllerImpl::SetTransientEntry(NavigationEntry* entry) {
1791 // Discard any current transient entry, we can only have one at a time.
1792 int index = 0;
1793 if (last_committed_entry_index_ != -1)
1794 index = last_committed_entry_index_ + 1;
1795 DiscardTransientEntry();
1796 entries_.insert(
1797 entries_.begin() + index, linked_ptr<NavigationEntryImpl>(
1798 NavigationEntryImpl::FromNavigationEntry(entry)));
1799 transient_entry_index_ = index;
[email protected]7f924832014-08-09 05:57:221800 delegate_->NotifyNavigationStateChanged(INVALIDATE_TYPE_ALL);
[email protected]0b684262013-02-20 02:18:211801}
1802
[email protected]d202a7c2012-01-04 07:53:471803void NavigationControllerImpl::InsertEntriesFrom(
1804 const NavigationControllerImpl& source,
[email protected]e1cd5452010-08-26 18:03:251805 int max_index) {
[email protected]a26023822011-12-29 00:23:551806 DCHECK_LE(max_index, source.GetEntryCount());
[email protected]e1cd5452010-08-26 18:03:251807 size_t insert_index = 0;
1808 for (int i = 0; i < max_index; i++) {
1809 // When cloning a tab, copy all entries except interstitial pages
[email protected]ad23a092011-12-28 07:02:041810 if (source.entries_[i].get()->GetPageType() !=
[email protected]8ff00d72012-10-23 19:12:211811 PAGE_TYPE_INTERSTITIAL) {
[email protected]e1cd5452010-08-26 18:03:251812 entries_.insert(entries_.begin() + insert_index++,
[email protected]10f417c52011-12-28 21:04:231813 linked_ptr<NavigationEntryImpl>(
1814 new NavigationEntryImpl(*source.entries_[i])));
[email protected]e1cd5452010-08-26 18:03:251815 }
1816 }
1817}
[email protected]c5b88d82012-10-06 17:03:331818
1819void NavigationControllerImpl::SetGetTimestampCallbackForTest(
1820 const base::Callback<base::Time()>& get_timestamp_callback) {
1821 get_timestamp_callback_ = get_timestamp_callback;
1822}
[email protected]8ff00d72012-10-23 19:12:211823
1824} // namespace content