blob: 4813c6002901563df32b8d9e9d56bac4aa890988 [file] [log] [blame]
[email protected]91854cd2012-01-10 19:43:571// Copyright (c) 2012 The Chromium Authors. All rights reserved.
license.botbf09a502008-08-24 00:55:552// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commit09911bf2008-07-26 23:55:294
[email protected]d202a7c2012-01-04 07:53:475#include "content/browser/tab_contents/navigation_controller_impl.h"
initial.commit09911bf2008-07-26 23:55:296
initial.commit09911bf2008-07-26 23:55:297#include "base/file_util.h"
8#include "base/logging.h"
[email protected]b69934e2011-10-29 02:51:529#include "base/string_number_conversions.h" // Temporary
initial.commit09911bf2008-07-26 23:55:2910#include "base/string_util.h"
[email protected]b689fce72009-03-17 22:45:3411#include "base/time.h"
[email protected]252cad62010-08-18 18:33:5712#include "base/utf_string_conversions.h"
[email protected]b8148ac2011-07-13 22:03:2513#include "content/browser/browser_url_handler.h"
[email protected]b9535422012-02-09 01:47:5914#include "content/browser/child_process_security_policy_impl.h"
[email protected]567812d2011-02-24 17:40:5015#include "content/browser/in_process_webkit/session_storage_namespace.h"
[email protected]b69934e2011-10-29 02:51:5216#include "content/browser/renderer_host/render_view_host.h" // Temporary
[email protected]b6583592012-01-25 19:52:3317#include "content/browser/site_instance_impl.h"
[email protected]8bf1048012012-02-08 01:22:1818#include "content/browser/tab_contents/debug_urls.h"
[email protected]cadaec52012-02-08 21:53:1319#include "content/browser/tab_contents/interstitial_page_impl.h"
[email protected]10f417c52011-12-28 21:04:2320#include "content/browser/tab_contents/navigation_entry_impl.h"
[email protected]0dd3a0ab2011-02-18 08:17:4421#include "content/browser/tab_contents/tab_contents.h"
[email protected]0aed2f52011-03-23 18:06:3622#include "content/common/view_messages.h"
[email protected]ccb797302011-12-15 16:55:1123#include "content/public/browser/browser_context.h"
[email protected]d9083482012-01-06 00:38:4624#include "content/public/browser/invalidate_type.h"
[email protected]5b96836f2011-12-22 07:39:0025#include "content/public/browser/navigation_details.h"
[email protected]7f6f44c2011-12-14 13:23:3826#include "content/public/browser/notification_service.h"
[email protected]0d6e9bd2011-10-18 04:29:1627#include "content/public/browser/notification_types.h"
[email protected]7f6f44c2011-12-14 13:23:3828#include "content/public/browser/user_metrics.h"
[email protected]674bc592011-12-20 23:00:4229#include "content/public/browser/web_contents_delegate.h"
[email protected]7f6f44c2011-12-14 13:23:3830#include "content/public/common/content_constants.h"
[email protected]a23de8572009-06-03 02:16:3231#include "net/base/escape.h"
[email protected]31682282010-01-15 18:05:1632#include "net/base/mime_util.h"
[email protected]7f070d42011-03-09 20:25:3233#include "net/base/net_util.h"
[email protected]765b35502008-08-21 00:51:2034#include "webkit/glue/webkit_glue.h"
initial.commit09911bf2008-07-26 23:55:2935
[email protected]cdcb1dee2012-01-04 00:46:2036using content::BrowserContext;
[email protected]e5d549d2011-12-28 01:29:2037using content::GlobalRequestID;
[email protected]c5eed492012-01-04 17:07:5038using content::NavigationController;
[email protected]10f417c52011-12-28 21:04:2339using content::NavigationEntry;
40using content::NavigationEntryImpl;
[email protected]b6583592012-01-25 19:52:3341using content::SiteInstance;
[email protected]7f6f44c2011-12-14 13:23:3842using content::UserMetricsAction;
[email protected]fbc5e5f92012-01-02 06:08:3243using content::WebContents;
[email protected]7f6f44c2011-12-14 13:23:3844
[email protected]e9ba4472008-09-14 15:42:4345namespace {
46
[email protected]93f230e02011-06-01 14:40:0047const int kInvalidateAll = 0xFFFFFFFF;
[email protected]8030f012009-09-25 18:09:3748
[email protected]e9ba4472008-09-14 15:42:4349// Invoked when entries have been pruned, or removed. For example, if the
50// current entries are [google, digg, yahoo], with the current entry google,
51// and the user types in cnet, then digg and yahoo are pruned.
[email protected]d202a7c2012-01-04 07:53:4752void NotifyPrunedEntries(NavigationControllerImpl* nav_controller,
[email protected]c12bf1a12008-09-17 16:28:4953 bool from_front,
54 int count) {
[email protected]8286f51a2011-05-31 17:39:1355 content::PrunedDetails details;
[email protected]c12bf1a12008-09-17 16:28:4956 details.from_front = from_front;
57 details.count = count;
[email protected]ad50def52011-10-19 23:17:0758 content::NotificationService::current()->Notify(
[email protected]432115822011-07-10 15:52:2759 content::NOTIFICATION_NAV_LIST_PRUNED,
[email protected]c5eed492012-01-04 17:07:5060 content::Source<NavigationController>(nav_controller),
[email protected]6c2381d2011-10-19 02:52:5361 content::Details<content::PrunedDetails>(&details));
[email protected]e9ba4472008-09-14 15:42:4362}
63
64// Ensure the given NavigationEntry has a valid state, so that WebKit does not
65// get confused if we navigate back to it.
[email protected]40bcc302009-03-02 20:50:3966//
[email protected]e9ba4472008-09-14 15:42:4367// An empty state is treated as a new navigation by WebKit, which would mean
68// losing the navigation entries and generating a new navigation entry after
69// this one. We don't want that. To avoid this we create a valid state which
70// WebKit will not treat as a new navigation.
[email protected]10f417c52011-12-28 21:04:2371void SetContentStateIfEmpty(NavigationEntryImpl* entry) {
[email protected]36fc0392011-12-25 03:59:5172 if (entry->GetContentState().empty()) {
73 entry->SetContentState(
74 webkit_glue::CreateHistoryStateForURL(entry->GetURL()));
[email protected]e9ba4472008-09-14 15:42:4375 }
76}
77
78// Configure all the NavigationEntries in entries for restore. This resets
79// the transition type to reload and makes sure the content state isn't empty.
80void ConfigureEntriesForRestore(
[email protected]10f417c52011-12-28 21:04:2381 std::vector<linked_ptr<NavigationEntryImpl> >* entries,
[email protected]5e369672009-11-03 23:48:3082 bool from_last_session) {
[email protected]e9ba4472008-09-14 15:42:4383 for (size_t i = 0; i < entries->size(); ++i) {
84 // Use a transition type of reload so that we don't incorrectly increase
85 // the typed count.
[email protected]022af742011-12-28 18:37:2586 (*entries)[i]->SetTransitionType(content::PAGE_TRANSITION_RELOAD);
[email protected]5e369672009-11-03 23:48:3087 (*entries)[i]->set_restore_type(from_last_session ?
[email protected]10f417c52011-12-28 21:04:2388 NavigationEntryImpl::RESTORE_LAST_SESSION :
89 NavigationEntryImpl::RESTORE_CURRENT_SESSION);
[email protected]e9ba4472008-09-14 15:42:4390 // NOTE(darin): This code is only needed for backwards compat.
91 SetContentStateIfEmpty((*entries)[i].get());
92 }
93}
94
95// See NavigationController::IsURLInPageNavigation for how this works and why.
96bool AreURLsInPageNavigation(const GURL& existing_url, const GURL& new_url) {
[email protected]192d8c5e2010-02-23 07:26:3297 if (existing_url == new_url || !new_url.has_ref()) {
98 // TODO(jcampan): what about when navigating back from a ref URL to the top
99 // non ref URL? Nothing is loaded in that case but we return false here.
100 // The user could also navigate from the ref URL to the non ref URL by
101 // entering the non ref URL in the location bar or through a bookmark, in
102 // which case there would be a load. I am not sure if the non-load/load
103 // scenarios can be differentiated with the TransitionType.
[email protected]e9ba4472008-09-14 15:42:43104 return false;
[email protected]192d8c5e2010-02-23 07:26:32105 }
[email protected]e9ba4472008-09-14 15:42:43106
107 url_canon::Replacements<char> replacements;
108 replacements.ClearRef();
109 return existing_url.ReplaceComponents(replacements) ==
110 new_url.ReplaceComponents(replacements);
111}
112
113} // namespace
114
[email protected]d202a7c2012-01-04 07:53:47115// NavigationControllerImpl ----------------------------------------------------
initial.commit09911bf2008-07-26 23:55:29116
[email protected]9b51970d2011-12-09 23:10:23117const size_t kMaxEntryCountForTestingNotSet = -1;
118
[email protected]765b35502008-08-21 00:51:20119// static
[email protected]d202a7c2012-01-04 07:53:47120size_t NavigationControllerImpl::max_entry_count_for_testing_ =
[email protected]9b51970d2011-12-09 23:10:23121 kMaxEntryCountForTestingNotSet;
[email protected]765b35502008-08-21 00:51:20122
[email protected]cdcb1dee2012-01-04 00:46:20123 // Should Reload check for post data? The default is true, but is set to false
124// when testing.
125static bool g_check_for_repost = true;
initial.commit09911bf2008-07-26 23:55:29126
[email protected]cdcb1dee2012-01-04 00:46:20127namespace content {
[email protected]71fde352011-12-29 03:29:56128// static
[email protected]cdcb1dee2012-01-04 00:46:20129NavigationEntry* NavigationController::CreateNavigationEntry(
[email protected]71fde352011-12-29 03:29:56130 const GURL& url,
[email protected]cdcb1dee2012-01-04 00:46:20131 const Referrer& referrer,
132 PageTransition transition,
[email protected]71fde352011-12-29 03:29:56133 bool is_renderer_initiated,
134 const std::string& extra_headers,
[email protected]cdcb1dee2012-01-04 00:46:20135 BrowserContext* browser_context) {
[email protected]71fde352011-12-29 03:29:56136 // Allow the browser URL handler to rewrite the URL. This will, for example,
137 // remove "view-source:" from the beginning of the URL to get the URL that
138 // will actually be loaded. This real URL won't be shown to the user, just
139 // used internally.
140 GURL loaded_url(url);
141 bool reverse_on_redirect = false;
142 BrowserURLHandler::GetInstance()->RewriteURLIfNecessary(
143 &loaded_url, browser_context, &reverse_on_redirect);
144
145 NavigationEntryImpl* entry = new NavigationEntryImpl(
146 NULL, // The site instance for tabs is sent on navigation
147 // (TabContents::GetSiteInstance).
148 -1,
149 loaded_url,
150 referrer,
151 string16(),
152 transition,
153 is_renderer_initiated);
154 entry->SetVirtualURL(url);
155 entry->set_user_typed_url(url);
156 entry->set_update_virtual_url_with_url(reverse_on_redirect);
157 entry->set_extra_headers(extra_headers);
158 return entry;
159}
160
[email protected]cdcb1dee2012-01-04 00:46:20161// static
162void NavigationController::DisablePromptOnRepost() {
163 g_check_for_repost = false;
164}
165
166} // namespace content
167
[email protected]d202a7c2012-01-04 07:53:47168NavigationControllerImpl::NavigationControllerImpl(
[email protected]6ee12c42010-09-14 09:36:07169 TabContents* contents,
[email protected]cdcb1dee2012-01-04 00:46:20170 BrowserContext* browser_context,
[email protected]6ee12c42010-09-14 09:36:07171 SessionStorageNamespace* session_storage_namespace)
[email protected]3d7474ff2011-07-27 17:47:37172 : browser_context_(browser_context),
[email protected]765b35502008-08-21 00:51:20173 pending_entry_(NULL),
174 last_committed_entry_index_(-1),
175 pending_entry_index_(-1),
[email protected]cbab76d2008-10-13 22:42:47176 transient_entry_index_(-1),
[email protected]9423d9412009-04-14 22:13:55177 tab_contents_(contents),
initial.commit09911bf2008-07-26 23:55:29178 max_restored_page_id_(-1),
[email protected]5d063842009-05-15 04:08:24179 ALLOW_THIS_IN_INITIALIZER_LIST(ssl_manager_(this)),
[email protected]38b8f4e2009-09-24 19:44:57180 needs_reload_(false),
[email protected]6ee12c42010-09-14 09:36:07181 session_storage_namespace_(session_storage_namespace),
[email protected]106a0812010-03-18 00:15:12182 pending_reload_(NO_RELOAD) {
[email protected]3d7474ff2011-07-27 17:47:37183 DCHECK(browser_context_);
[email protected]228d06592011-04-01 20:38:59184 if (!session_storage_namespace_) {
185 session_storage_namespace_ = new SessionStorageNamespace(
[email protected]3d7474ff2011-07-27 17:47:37186 browser_context_->GetWebKitContext());
[email protected]228d06592011-04-01 20:38:59187 }
initial.commit09911bf2008-07-26 23:55:29188}
189
[email protected]d202a7c2012-01-04 07:53:47190NavigationControllerImpl::~NavigationControllerImpl() {
[email protected]cbab76d2008-10-13 22:42:47191 DiscardNonCommittedEntriesInternal();
[email protected]c0993872008-08-21 19:59:44192
[email protected]ad50def52011-10-19 23:17:07193 content::NotificationService::current()->Notify(
[email protected]432115822011-07-10 15:52:27194 content::NOTIFICATION_TAB_CLOSED,
[email protected]c5eed492012-01-04 17:07:50195 content::Source<NavigationController>(this),
[email protected]ad50def52011-10-19 23:17:07196 content::NotificationService::NoDetails());
initial.commit09911bf2008-07-26 23:55:29197}
198
[email protected]d202a7c2012-01-04 07:53:47199WebContents* NavigationControllerImpl::GetWebContents() const {
[email protected]fbc5e5f92012-01-02 06:08:32200 return tab_contents_;
201}
202
[email protected]d202a7c2012-01-04 07:53:47203BrowserContext* NavigationControllerImpl::GetBrowserContext() const {
[email protected]a26023822011-12-29 00:23:55204 return browser_context_;
205}
206
[email protected]d202a7c2012-01-04 07:53:47207void NavigationControllerImpl::SetBrowserContext(
208 BrowserContext* browser_context) {
[email protected]cdcb1dee2012-01-04 00:46:20209 browser_context_ = browser_context;
210}
211
[email protected]d202a7c2012-01-04 07:53:47212void NavigationControllerImpl::Restore(
[email protected]5e369672009-11-03 23:48:30213 int selected_navigation,
[email protected]03838e22011-06-06 15:27:14214 bool from_last_session,
[email protected]10f417c52011-12-28 21:04:23215 std::vector<NavigationEntry*>* entries) {
[email protected]ce3fa3c2009-04-20 19:55:57216 // Verify that this controller is unused and that the input is valid.
[email protected]a26023822011-12-29 00:23:55217 DCHECK(GetEntryCount() == 0 && !GetPendingEntry());
[email protected]ce3fa3c2009-04-20 19:55:57218 DCHECK(selected_navigation >= 0 &&
[email protected]03838e22011-06-06 15:27:14219 selected_navigation < static_cast<int>(entries->size()));
[email protected]ce3fa3c2009-04-20 19:55:57220
[email protected]ce3fa3c2009-04-20 19:55:57221 needs_reload_ = true;
[email protected]ad23a092011-12-28 07:02:04222 for (size_t i = 0; i < entries->size(); ++i) {
[email protected]10f417c52011-12-28 21:04:23223 NavigationEntryImpl* entry =
224 NavigationEntryImpl::FromNavigationEntry((*entries)[i]);
225 entries_.push_back(linked_ptr<NavigationEntryImpl>(entry));
[email protected]ad23a092011-12-28 07:02:04226 }
[email protected]03838e22011-06-06 15:27:14227 entries->clear();
[email protected]ce3fa3c2009-04-20 19:55:57228
229 // And finish the restore.
[email protected]5e369672009-11-03 23:48:30230 FinishRestore(selected_navigation, from_last_session);
[email protected]ce3fa3c2009-04-20 19:55:57231}
232
[email protected]d202a7c2012-01-04 07:53:47233void NavigationControllerImpl::Reload(bool check_for_repost) {
[email protected]1ccb3568d2010-02-19 10:51:16234 ReloadInternal(check_for_repost, RELOAD);
235}
[email protected]d202a7c2012-01-04 07:53:47236void NavigationControllerImpl::ReloadIgnoringCache(bool check_for_repost) {
[email protected]1ccb3568d2010-02-19 10:51:16237 ReloadInternal(check_for_repost, RELOAD_IGNORING_CACHE);
238}
239
[email protected]d202a7c2012-01-04 07:53:47240void NavigationControllerImpl::ReloadInternal(bool check_for_repost,
241 ReloadType reload_type) {
[email protected]cbab76d2008-10-13 22:42:47242 // Reloading a transient entry does nothing.
243 if (transient_entry_index_ != -1)
244 return;
245
246 DiscardNonCommittedEntriesInternal();
initial.commit09911bf2008-07-26 23:55:29247 int current_index = GetCurrentEntryIndex();
[email protected]106a0812010-03-18 00:15:12248 // If we are no where, then we can't reload. TODO(darin): We should add a
249 // CanReload method.
250 if (current_index == -1) {
251 return;
252 }
253
[email protected]cdcb1dee2012-01-04 00:46:20254 if (g_check_for_repost && check_for_repost &&
[email protected]36fc0392011-12-25 03:59:51255 GetEntryAtIndex(current_index)->GetHasPostData()) {
[email protected]a3a1d142008-12-19 00:42:30256 // The user is asking to reload a page with POST data. Prompt to make sure
[email protected]b5bb35f2009-02-05 20:17:07257 // they really want to do this. If they do, the dialog will call us back
258 // with check_for_repost = false.
[email protected]ad50def52011-10-19 23:17:07259 content::NotificationService::current()->Notify(
[email protected]432115822011-07-10 15:52:27260 content::NOTIFICATION_REPOST_WARNING_SHOWN,
[email protected]c5eed492012-01-04 17:07:50261 content::Source<NavigationController>(this),
[email protected]ad50def52011-10-19 23:17:07262 content::NotificationService::NoDetails());
[email protected]965bb092010-04-09 11:59:02263
[email protected]106a0812010-03-18 00:15:12264 pending_reload_ = reload_type;
[email protected]9423d9412009-04-14 22:13:55265 tab_contents_->Activate();
[email protected]6934a702011-12-20 00:04:51266 tab_contents_->GetDelegate()->ShowRepostFormWarningDialog(tab_contents_);
initial.commit09911bf2008-07-26 23:55:29267 } else {
[email protected]cbab76d2008-10-13 22:42:47268 DiscardNonCommittedEntriesInternal();
[email protected]765b35502008-08-21 00:51:20269
[email protected]bcd904482012-02-01 01:54:22270 NavigationEntryImpl* entry = entries_[current_index].get();
271 SiteInstanceImpl* site_instance = entry->site_instance();
272 DCHECK(site_instance);
[email protected]c3b3d952012-01-31 12:52:26273
[email protected]bcd904482012-02-01 01:54:22274 // If we are reloading an entry that no longer belongs to the current
275 // site instance (for example, refreshing a page for just installed app),
276 // the reload must happen in a new process.
277 // The new entry must have a new page_id and site instance, so it behaves
278 // as new navigation (which happens to clear forward history).
279 if (site_instance->HasWrongProcessForURL(entry->GetURL())) {
280 // Create a navigation entry that resembles the current one, but do not
281 // copy page id, site instance, and content state.
282 NavigationEntryImpl* nav_entry = NavigationEntryImpl::FromNavigationEntry(
283 CreateNavigationEntry(
284 entry->GetURL(), entry->GetReferrer(), entry->GetTransitionType(),
285 false, entry->extra_headers(), browser_context_));
[email protected]c3b3d952012-01-31 12:52:26286
[email protected]11535962012-02-09 21:02:10287 // Mark the reload type as NO_RELOAD, so navigation will not be considered
288 // a reload in the renderer.
289 reload_type = NavigationController::NO_RELOAD;
290
[email protected]bcd904482012-02-01 01:54:22291 nav_entry->set_is_cross_site_reload(true);
292 pending_entry_ = nav_entry;
293 } else {
294 pending_entry_index_ = current_index;
295
296 // The title of the page being reloaded might have been removed in the
297 // meanwhile, so we need to revert to the default title upon reload and
298 // invalidate the previously cached title (SetTitle will do both).
299 // See Chromium issue 96041.
300 entries_[pending_entry_index_]->SetTitle(string16());
301
302 entries_[pending_entry_index_]->SetTransitionType(
303 content::PAGE_TRANSITION_RELOAD);
304 }
305
[email protected]1ccb3568d2010-02-19 10:51:16306 NavigateToPendingEntry(reload_type);
initial.commit09911bf2008-07-26 23:55:29307 }
308}
309
[email protected]d202a7c2012-01-04 07:53:47310void NavigationControllerImpl::CancelPendingReload() {
[email protected]106a0812010-03-18 00:15:12311 DCHECK(pending_reload_ != NO_RELOAD);
312 pending_reload_ = NO_RELOAD;
313}
314
[email protected]d202a7c2012-01-04 07:53:47315void NavigationControllerImpl::ContinuePendingReload() {
[email protected]106a0812010-03-18 00:15:12316 if (pending_reload_ == NO_RELOAD) {
317 NOTREACHED();
318 } else {
319 ReloadInternal(false, pending_reload_);
[email protected]965bb092010-04-09 11:59:02320 pending_reload_ = NO_RELOAD;
[email protected]106a0812010-03-18 00:15:12321 }
322}
323
[email protected]d202a7c2012-01-04 07:53:47324bool NavigationControllerImpl::IsInitialNavigation() {
[email protected]c70f9b82010-04-21 07:31:11325 return last_document_loaded_.is_null();
326}
327
[email protected]d202a7c2012-01-04 07:53:47328NavigationEntryImpl* NavigationControllerImpl::GetEntryWithPageID(
[email protected]b6583592012-01-25 19:52:33329 SiteInstance* instance, int32 page_id) const {
[email protected]7f0005a2009-04-15 03:25:11330 int index = GetEntryIndexWithPageID(instance, page_id);
[email protected]765b35502008-08-21 00:51:20331 return (index != -1) ? entries_[index].get() : NULL;
332}
333
[email protected]d202a7c2012-01-04 07:53:47334void NavigationControllerImpl::LoadEntry(NavigationEntryImpl* entry) {
[email protected]419a0572011-04-18 22:21:46335 // Don't navigate to URLs disabled by policy. This prevents showing the URL
336 // on the Omnibar when it is also going to be blocked by
337 // ChildProcessSecurityPolicy::CanRequestURL.
[email protected]b9535422012-02-09 01:47:59338 ChildProcessSecurityPolicyImpl* policy =
339 ChildProcessSecurityPolicyImpl::GetInstance();
[email protected]36fc0392011-12-25 03:59:51340 if (policy->IsDisabledScheme(entry->GetURL().scheme()) ||
341 policy->IsDisabledScheme(entry->GetVirtualURL().scheme())) {
[email protected]419a0572011-04-18 22:21:46342 VLOG(1) << "URL not loaded because the scheme is blocked by policy: "
[email protected]36fc0392011-12-25 03:59:51343 << entry->GetURL();
[email protected]419a0572011-04-18 22:21:46344 delete entry;
345 return;
346 }
347
[email protected]765b35502008-08-21 00:51:20348 // When navigating to a new page, we don't know for sure if we will actually
349 // end up leaving the current page. The new page load could for example
350 // result in a download or a 'no content' response (e.g., a mailto: URL).
[email protected]cbab76d2008-10-13 22:42:47351 DiscardNonCommittedEntriesInternal();
[email protected]765b35502008-08-21 00:51:20352 pending_entry_ = entry;
[email protected]ad50def52011-10-19 23:17:07353 content::NotificationService::current()->Notify(
[email protected]432115822011-07-10 15:52:27354 content::NOTIFICATION_NAV_ENTRY_PENDING,
[email protected]c5eed492012-01-04 17:07:50355 content::Source<NavigationController>(this),
[email protected]10f417c52011-12-28 21:04:23356 content::Details<NavigationEntry>(entry));
[email protected]1ccb3568d2010-02-19 10:51:16357 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20358}
359
[email protected]d202a7c2012-01-04 07:53:47360NavigationEntry* NavigationControllerImpl::GetActiveEntry() const {
[email protected]cbab76d2008-10-13 22:42:47361 if (transient_entry_index_ != -1)
362 return entries_[transient_entry_index_].get();
363 if (pending_entry_)
364 return pending_entry_;
365 return GetLastCommittedEntry();
[email protected]765b35502008-08-21 00:51:20366}
367
[email protected]d202a7c2012-01-04 07:53:47368NavigationEntry* NavigationControllerImpl::GetVisibleEntry() const {
[email protected]867e1f92011-08-30 19:01:19369 if (transient_entry_index_ != -1)
370 return entries_[transient_entry_index_].get();
[email protected]e47ae9472011-10-13 19:48:34371 // Only return the pending_entry for new (non-history), browser-initiated
372 // navigations, in order to prevent URL spoof attacks.
373 // Ideally we would also show the pending entry's URL for new renderer-
374 // initiated navigations with no last committed entry (e.g., a link opening
375 // in a new tab), but an attacker can insert content into the about:blank
376 // page while the pending URL loads in that case.
377 if (pending_entry_ &&
[email protected]36fc0392011-12-25 03:59:51378 pending_entry_->GetPageID() == -1 &&
[email protected]e47ae9472011-10-13 19:48:34379 !pending_entry_->is_renderer_initiated())
[email protected]867e1f92011-08-30 19:01:19380 return pending_entry_;
381 return GetLastCommittedEntry();
382}
383
[email protected]d202a7c2012-01-04 07:53:47384int NavigationControllerImpl::GetCurrentEntryIndex() const {
[email protected]cbab76d2008-10-13 22:42:47385 if (transient_entry_index_ != -1)
386 return transient_entry_index_;
[email protected]765b35502008-08-21 00:51:20387 if (pending_entry_index_ != -1)
388 return pending_entry_index_;
389 return last_committed_entry_index_;
390}
391
[email protected]d202a7c2012-01-04 07:53:47392NavigationEntry* NavigationControllerImpl::GetLastCommittedEntry() const {
[email protected]765b35502008-08-21 00:51:20393 if (last_committed_entry_index_ == -1)
394 return NULL;
395 return entries_[last_committed_entry_index_].get();
396}
397
[email protected]d202a7c2012-01-04 07:53:47398bool NavigationControllerImpl::CanViewSource() const {
[email protected]31682282010-01-15 18:05:16399 bool is_supported_mime_type = net::IsSupportedNonImageMimeType(
[email protected]0bfbf882011-12-22 18:19:27400 tab_contents_->GetContentsMimeType().c_str());
[email protected]10f417c52011-12-28 21:04:23401 NavigationEntry* active_entry = GetActiveEntry();
[email protected]31682282010-01-15 18:05:16402 return active_entry && !active_entry->IsViewSourceMode() &&
[email protected]0bfbf882011-12-22 18:19:27403 is_supported_mime_type && !tab_contents_->GetInterstitialPage();
[email protected]31682282010-01-15 18:05:16404}
405
[email protected]d202a7c2012-01-04 07:53:47406int NavigationControllerImpl::GetLastCommittedEntryIndex() const {
[email protected]a26023822011-12-29 00:23:55407 return last_committed_entry_index_;
408}
409
[email protected]d202a7c2012-01-04 07:53:47410int NavigationControllerImpl::GetEntryCount() const {
[email protected]a26023822011-12-29 00:23:55411 return static_cast<int>(entries_.size());
412}
413
[email protected]d202a7c2012-01-04 07:53:47414NavigationEntry* NavigationControllerImpl::GetEntryAtIndex(
[email protected]022af742011-12-28 18:37:25415 int index) const {
416 return entries_.at(index).get();
417}
418
[email protected]d202a7c2012-01-04 07:53:47419NavigationEntry* NavigationControllerImpl::GetEntryAtOffset(
[email protected]022af742011-12-28 18:37:25420 int offset) const {
[email protected]cbab76d2008-10-13 22:42:47421 int index = (transient_entry_index_ != -1) ?
422 transient_entry_index_ + offset :
423 last_committed_entry_index_ + offset;
[email protected]a26023822011-12-29 00:23:55424 if (index < 0 || index >= GetEntryCount())
[email protected]765b35502008-08-21 00:51:20425 return NULL;
426
427 return entries_[index].get();
428}
429
[email protected]d202a7c2012-01-04 07:53:47430bool NavigationControllerImpl::CanGoBack() const {
[email protected]765b35502008-08-21 00:51:20431 return entries_.size() > 1 && GetCurrentEntryIndex() > 0;
432}
433
[email protected]d202a7c2012-01-04 07:53:47434bool NavigationControllerImpl::CanGoForward() const {
[email protected]765b35502008-08-21 00:51:20435 int index = GetCurrentEntryIndex();
436 return index >= 0 && index < (static_cast<int>(entries_.size()) - 1);
437}
438
[email protected]d202a7c2012-01-04 07:53:47439void NavigationControllerImpl::GoBack() {
[email protected]765b35502008-08-21 00:51:20440 if (!CanGoBack()) {
441 NOTREACHED();
442 return;
443 }
444
445 // Base the navigation on where we are now...
446 int current_index = GetCurrentEntryIndex();
447
[email protected]cbab76d2008-10-13 22:42:47448 DiscardNonCommittedEntries();
[email protected]765b35502008-08-21 00:51:20449
450 pending_entry_index_ = current_index - 1;
[email protected]022af742011-12-28 18:37:25451 entries_[pending_entry_index_]->SetTransitionType(
[email protected]2905f742011-10-13 03:51:58452 content::PageTransitionFromInt(
[email protected]36fc0392011-12-25 03:59:51453 entries_[pending_entry_index_]->GetTransitionType() |
[email protected]2905f742011-10-13 03:51:58454 content::PAGE_TRANSITION_FORWARD_BACK));
[email protected]1ccb3568d2010-02-19 10:51:16455 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20456}
457
[email protected]d202a7c2012-01-04 07:53:47458void NavigationControllerImpl::GoForward() {
[email protected]765b35502008-08-21 00:51:20459 if (!CanGoForward()) {
460 NOTREACHED();
461 return;
462 }
463
[email protected]cbab76d2008-10-13 22:42:47464 bool transient = (transient_entry_index_ != -1);
465
[email protected]765b35502008-08-21 00:51:20466 // Base the navigation on where we are now...
467 int current_index = GetCurrentEntryIndex();
468
[email protected]cbab76d2008-10-13 22:42:47469 DiscardNonCommittedEntries();
[email protected]765b35502008-08-21 00:51:20470
[email protected]cbab76d2008-10-13 22:42:47471 pending_entry_index_ = current_index;
472 // If there was a transient entry, we removed it making the current index
473 // the next page.
474 if (!transient)
475 pending_entry_index_++;
476
[email protected]022af742011-12-28 18:37:25477 entries_[pending_entry_index_]->SetTransitionType(
[email protected]2905f742011-10-13 03:51:58478 content::PageTransitionFromInt(
[email protected]36fc0392011-12-25 03:59:51479 entries_[pending_entry_index_]->GetTransitionType() |
[email protected]2905f742011-10-13 03:51:58480 content::PAGE_TRANSITION_FORWARD_BACK));
[email protected]1ccb3568d2010-02-19 10:51:16481 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20482}
483
[email protected]d202a7c2012-01-04 07:53:47484void NavigationControllerImpl::GoToIndex(int index) {
[email protected]765b35502008-08-21 00:51:20485 if (index < 0 || index >= static_cast<int>(entries_.size())) {
486 NOTREACHED();
487 return;
488 }
489
[email protected]cbab76d2008-10-13 22:42:47490 if (transient_entry_index_ != -1) {
491 if (index == transient_entry_index_) {
492 // Nothing to do when navigating to the transient.
493 return;
494 }
495 if (index > transient_entry_index_) {
496 // Removing the transient is goint to shift all entries by 1.
497 index--;
498 }
499 }
500
501 DiscardNonCommittedEntries();
[email protected]765b35502008-08-21 00:51:20502
503 pending_entry_index_ = index;
[email protected]022af742011-12-28 18:37:25504 entries_[pending_entry_index_]->SetTransitionType(
[email protected]2905f742011-10-13 03:51:58505 content::PageTransitionFromInt(
[email protected]36fc0392011-12-25 03:59:51506 entries_[pending_entry_index_]->GetTransitionType() |
[email protected]2905f742011-10-13 03:51:58507 content::PAGE_TRANSITION_FORWARD_BACK));
[email protected]1ccb3568d2010-02-19 10:51:16508 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20509}
510
[email protected]d202a7c2012-01-04 07:53:47511void NavigationControllerImpl::GoToOffset(int offset) {
[email protected]cbab76d2008-10-13 22:42:47512 int index = (transient_entry_index_ != -1) ?
513 transient_entry_index_ + offset :
514 last_committed_entry_index_ + offset;
[email protected]a26023822011-12-29 00:23:55515 if (index < 0 || index >= GetEntryCount())
[email protected]765b35502008-08-21 00:51:20516 return;
517
518 GoToIndex(index);
519}
520
[email protected]d202a7c2012-01-04 07:53:47521void NavigationControllerImpl::RemoveEntryAtIndex(int index) {
[email protected]6a13a6c2011-12-20 21:47:12522 if (index == last_committed_entry_index_)
523 return;
524
[email protected]43032342011-03-21 14:10:31525 RemoveEntryAtIndexInternal(index);
[email protected]cbab76d2008-10-13 22:42:47526}
527
[email protected]d202a7c2012-01-04 07:53:47528void NavigationControllerImpl::UpdateVirtualURLToURL(
[email protected]10f417c52011-12-28 21:04:23529 NavigationEntryImpl* entry, const GURL& new_url) {
[email protected]38178a42009-12-17 18:58:32530 GURL new_virtual_url(new_url);
[email protected]f1eb87a2011-05-06 17:49:41531 if (BrowserURLHandler::GetInstance()->ReverseURLRewrite(
[email protected]36fc0392011-12-25 03:59:51532 &new_virtual_url, entry->GetVirtualURL(), browser_context_)) {
533 entry->SetVirtualURL(new_virtual_url);
[email protected]38178a42009-12-17 18:58:32534 }
535}
536
[email protected]d202a7c2012-01-04 07:53:47537void NavigationControllerImpl::AddTransientEntry(NavigationEntryImpl* entry) {
[email protected]cbab76d2008-10-13 22:42:47538 // Discard any current transient entry, we can only have one at a time.
539 int index = 0;
540 if (last_committed_entry_index_ != -1)
541 index = last_committed_entry_index_ + 1;
542 DiscardTransientEntry();
[email protected]10f417c52011-12-28 21:04:23543 entries_.insert(
544 entries_.begin() + index, linked_ptr<NavigationEntryImpl>(entry));
[email protected]e1cd5452010-08-26 18:03:25545 transient_entry_index_ = index;
[email protected]93f230e02011-06-01 14:40:00546 tab_contents_->NotifyNavigationStateChanged(kInvalidateAll);
[email protected]cbab76d2008-10-13 22:42:47547}
548
[email protected]d202a7c2012-01-04 07:53:47549void NavigationControllerImpl::TransferURL(
[email protected]4ad5d77d2011-12-03 02:00:48550 const GURL& url,
[email protected]95dacd02011-12-05 10:35:26551 const content::Referrer& referrer,
[email protected]4ad5d77d2011-12-03 02:00:48552 content::PageTransition transition,
553 const std::string& extra_headers,
554 const GlobalRequestID& transferred_global_request_id,
555 bool is_renderer_initiated) {
556 // The user initiated a load, we don't need to reload anymore.
557 needs_reload_ = false;
558
[email protected]71fde352011-12-29 03:29:56559 NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
560 CreateNavigationEntry(
561 url, referrer, transition, is_renderer_initiated, extra_headers,
562 browser_context_));
[email protected]4ad5d77d2011-12-03 02:00:48563 entry->set_transferred_global_request_id(transferred_global_request_id);
564
565 LoadEntry(entry);
566}
567
[email protected]d202a7c2012-01-04 07:53:47568void NavigationControllerImpl::LoadURL(
[email protected]6c6b02d2011-09-02 03:36:47569 const GURL& url,
[email protected]95dacd02011-12-05 10:35:26570 const content::Referrer& referrer,
[email protected]2905f742011-10-13 03:51:58571 content::PageTransition transition,
[email protected]6c6b02d2011-09-02 03:36:47572 const std::string& extra_headers) {
[email protected]8bf1048012012-02-08 01:22:18573 if (content::HandleDebugURL(url, transition))
574 return;
575
initial.commit09911bf2008-07-26 23:55:29576 // The user initiated a load, we don't need to reload anymore.
577 needs_reload_ = false;
578
[email protected]71fde352011-12-29 03:29:56579 NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
580 CreateNavigationEntry(
581 url, referrer, transition, false, extra_headers, browser_context_));
[email protected]e47ae9472011-10-13 19:48:34582
583 LoadEntry(entry);
584}
585
[email protected]d202a7c2012-01-04 07:53:47586void NavigationControllerImpl::LoadURLFromRenderer(
[email protected]e47ae9472011-10-13 19:48:34587 const GURL& url,
[email protected]95dacd02011-12-05 10:35:26588 const content::Referrer& referrer,
[email protected]e47ae9472011-10-13 19:48:34589 content::PageTransition transition,
590 const std::string& extra_headers) {
591 // The user initiated a load, we don't need to reload anymore.
592 needs_reload_ = false;
593
[email protected]71fde352011-12-29 03:29:56594 NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
595 CreateNavigationEntry(
596 url, referrer, transition, true, extra_headers, browser_context_));
initial.commit09911bf2008-07-26 23:55:29597
598 LoadEntry(entry);
599}
600
[email protected]d202a7c2012-01-04 07:53:47601void NavigationControllerImpl::DocumentLoadedInFrame() {
[email protected]09b8f82f2009-06-16 20:22:11602 last_document_loaded_ = base::TimeTicks::Now();
603}
604
[email protected]d202a7c2012-01-04 07:53:47605bool NavigationControllerImpl::RendererDidNavigate(
[email protected]e9ba4472008-09-14 15:42:43606 const ViewHostMsg_FrameNavigate_Params& params,
[email protected]8286f51a2011-05-31 17:39:13607 content::LoadCommittedDetails* details) {
[email protected]4bf3522c2010-08-19 21:00:20608
[email protected]0e8db942008-09-24 21:21:48609 // Save the previous state before we clobber it.
610 if (GetLastCommittedEntry()) {
[email protected]36fc0392011-12-25 03:59:51611 details->previous_url = GetLastCommittedEntry()->GetURL();
[email protected]a26023822011-12-29 00:23:55612 details->previous_entry_index = GetLastCommittedEntryIndex();
[email protected]0e8db942008-09-24 21:21:48613 } else {
614 details->previous_url = GURL();
615 details->previous_entry_index = -1;
616 }
[email protected]ecd9d8702008-08-28 22:10:17617
[email protected]77362eb2011-08-01 17:18:38618 // If we have a pending entry at this point, it should have a SiteInstance.
619 // Restored entries start out with a null SiteInstance, but we should have
620 // assigned one in NavigateToPendingEntry.
621 DCHECK(pending_entry_index_ == -1 || pending_entry_->site_instance());
[email protected]e9ba4472008-09-14 15:42:43622
[email protected]bcd904482012-02-01 01:54:22623 // If we are doing a cross-site reload, we need to replace the existing
624 // navigation entry, not add another entry to the history. This has the side
625 // effect of removing forward browsing history, if such existed.
626 if (pending_entry_ != NULL) {
627 details->did_replace_entry = pending_entry_->is_cross_site_reload();
628 }
629
[email protected]192d8c5e2010-02-23 07:26:32630 // is_in_page must be computed before the entry gets committed.
631 details->is_in_page = IsURLInPageNavigation(params.url);
632
[email protected]e9ba4472008-09-14 15:42:43633 // Do navigation-type specific actions. These will make and commit an entry.
[email protected]0e8db942008-09-24 21:21:48634 details->type = ClassifyNavigation(params);
[email protected]4bf3522c2010-08-19 21:00:20635
[email protected]0e8db942008-09-24 21:21:48636 switch (details->type) {
[email protected]610cbb82011-10-18 16:35:08637 case content::NAVIGATION_TYPE_NEW_PAGE:
[email protected]befd8d822009-07-01 04:51:47638 RendererDidNavigateToNewPage(params, &(details->did_replace_entry));
[email protected]e9ba4472008-09-14 15:42:43639 break;
[email protected]610cbb82011-10-18 16:35:08640 case content::NAVIGATION_TYPE_EXISTING_PAGE:
[email protected]e9ba4472008-09-14 15:42:43641 RendererDidNavigateToExistingPage(params);
642 break;
[email protected]610cbb82011-10-18 16:35:08643 case content::NAVIGATION_TYPE_SAME_PAGE:
[email protected]e9ba4472008-09-14 15:42:43644 RendererDidNavigateToSamePage(params);
645 break;
[email protected]610cbb82011-10-18 16:35:08646 case content::NAVIGATION_TYPE_IN_PAGE:
[email protected]befd8d822009-07-01 04:51:47647 RendererDidNavigateInPage(params, &(details->did_replace_entry));
[email protected]e9ba4472008-09-14 15:42:43648 break;
[email protected]610cbb82011-10-18 16:35:08649 case content::NAVIGATION_TYPE_NEW_SUBFRAME:
[email protected]e9ba4472008-09-14 15:42:43650 RendererDidNavigateNewSubframe(params);
651 break;
[email protected]610cbb82011-10-18 16:35:08652 case content::NAVIGATION_TYPE_AUTO_SUBFRAME:
[email protected]e9ba4472008-09-14 15:42:43653 if (!RendererDidNavigateAutoSubframe(params))
654 return false;
655 break;
[email protected]610cbb82011-10-18 16:35:08656 case content::NAVIGATION_TYPE_NAV_IGNORE:
[email protected]20d1c992011-04-12 21:17:49657 // If a pending navigation was in progress, this canceled it. We should
658 // discard it and make sure it is removed from the URL bar. After that,
659 // there is nothing we can do with this navigation, so we just return to
[email protected]e9ba4472008-09-14 15:42:43660 // the caller that nothing has happened.
[email protected]20d1c992011-04-12 21:17:49661 if (pending_entry_) {
662 DiscardNonCommittedEntries();
[email protected]93f230e02011-06-01 14:40:00663 tab_contents_->NotifyNavigationStateChanged(
[email protected]d9083482012-01-06 00:38:46664 content::INVALIDATE_TYPE_URL);
[email protected]20d1c992011-04-12 21:17:49665 }
[email protected]e9ba4472008-09-14 15:42:43666 return false;
667 default:
668 NOTREACHED();
[email protected]765b35502008-08-21 00:51:20669 }
670
[email protected]e9ba4472008-09-14 15:42:43671 // All committed entries should have nonempty content state so WebKit doesn't
672 // get confused when we go back to them (see the function for details).
[email protected]0f38dc4552011-02-25 11:24:00673 DCHECK(!params.content_state.empty());
[email protected]10f417c52011-12-28 21:04:23674 NavigationEntryImpl* active_entry =
675 NavigationEntryImpl::FromNavigationEntry(GetActiveEntry());
[email protected]36fc0392011-12-25 03:59:51676 active_entry->SetContentState(params.content_state);
[email protected]765b35502008-08-21 00:51:20677
[email protected]e47ae9472011-10-13 19:48:34678 // Once committed, we do not need to track if the entry was initiated by
679 // the renderer.
680 active_entry->set_is_renderer_initiated(false);
681
[email protected]49bd30e62011-03-22 20:12:59682 // The active entry's SiteInstance should match our SiteInstance.
683 DCHECK(active_entry->site_instance() == tab_contents_->GetSiteInstance());
684
[email protected]e9ba4472008-09-14 15:42:43685 // Now prep the rest of the details for the notification and broadcast.
[email protected]0f38dc4552011-02-25 11:24:00686 details->entry = active_entry;
[email protected]2905f742011-10-13 03:51:58687 details->is_main_frame =
688 content::PageTransitionIsMainFrame(params.transition);
[email protected]f072d2ce2008-09-17 17:16:24689 details->serialized_security_info = params.security_info;
[email protected]2e39d2e2009-02-19 18:41:31690 details->http_status_code = params.http_status_code;
[email protected]93f230e02011-06-01 14:40:00691 NotifyNavigationEntryCommitted(details);
initial.commit09911bf2008-07-26 23:55:29692
[email protected]e9ba4472008-09-14 15:42:43693 return true;
initial.commit09911bf2008-07-26 23:55:29694}
695
[email protected]d202a7c2012-01-04 07:53:47696content::NavigationType NavigationControllerImpl::ClassifyNavigation(
[email protected]e9ba4472008-09-14 15:42:43697 const ViewHostMsg_FrameNavigate_Params& params) const {
[email protected]e9ba4472008-09-14 15:42:43698 if (params.page_id == -1) {
[email protected]eef9de32009-09-23 17:19:46699 // The renderer generates the page IDs, and so if it gives us the invalid
700 // page ID (-1) we know it didn't actually navigate. This happens in a few
701 // cases:
702 //
703 // - If a page makes a popup navigated to about blank, and then writes
704 // stuff like a subframe navigated to a real page. We'll get the commit
705 // for the subframe, but there won't be any commit for the outer page.
706 //
707 // - We were also getting these for failed loads (for example, bug 21849).
708 // The guess is that we get a "load commit" for the alternate error page,
709 // but that doesn't affect the page ID, so we get the "old" one, which
710 // could be invalid. This can also happen for a cross-site transition
711 // that causes us to swap processes. Then the error page load will be in
712 // a new process with no page IDs ever assigned (and hence a -1 value),
713 // yet the navigation controller still might have previous pages in its
714 // list.
715 //
716 // In these cases, there's nothing we can do with them, so ignore.
[email protected]610cbb82011-10-18 16:35:08717 return content::NAVIGATION_TYPE_NAV_IGNORE;
[email protected]e9ba4472008-09-14 15:42:43718 }
719
[email protected]9423d9412009-04-14 22:13:55720 if (params.page_id > tab_contents_->GetMaxPageID()) {
[email protected]e9ba4472008-09-14 15:42:43721 // Greater page IDs than we've ever seen before are new pages. We may or may
722 // not have a pending entry for the page, and this may or may not be the
723 // main frame.
[email protected]2905f742011-10-13 03:51:58724 if (content::PageTransitionIsMainFrame(params.transition))
[email protected]610cbb82011-10-18 16:35:08725 return content::NAVIGATION_TYPE_NEW_PAGE;
[email protected]4c27ba82008-09-24 16:49:09726
727 // When this is a new subframe navigation, we should have a committed page
728 // for which it's a suframe in. This may not be the case when an iframe is
729 // navigated on a popup navigated to about:blank (the iframe would be
730 // written into the popup by script on the main page). For these cases,
731 // there isn't any navigation stuff we can do, so just ignore it.
732 if (!GetLastCommittedEntry())
[email protected]610cbb82011-10-18 16:35:08733 return content::NAVIGATION_TYPE_NAV_IGNORE;
[email protected]4c27ba82008-09-24 16:49:09734
735 // Valid subframe navigation.
[email protected]610cbb82011-10-18 16:35:08736 return content::NAVIGATION_TYPE_NEW_SUBFRAME;
[email protected]e9ba4472008-09-14 15:42:43737 }
738
739 // Now we know that the notification is for an existing page. Find that entry.
740 int existing_entry_index = GetEntryIndexWithPageID(
[email protected]9423d9412009-04-14 22:13:55741 tab_contents_->GetSiteInstance(),
[email protected]e9ba4472008-09-14 15:42:43742 params.page_id);
743 if (existing_entry_index == -1) {
744 // The page was not found. It could have been pruned because of the limit on
745 // back/forward entries (not likely since we'll usually tell it to navigate
746 // to such entries). It could also mean that the renderer is smoking crack.
747 NOTREACHED();
[email protected]485e8232011-07-24 18:03:46748
749 // Because the unknown entry has committed, we risk showing the wrong URL in
750 // release builds. Instead, we'll kill the renderer process to be safe.
751 LOG(ERROR) << "terminating renderer for bad navigation: " << params.url;
[email protected]7f6f44c2011-12-14 13:23:38752 content::RecordAction(UserMetricsAction("BadMessageTerminate_NC"));
[email protected]b69934e2011-10-29 02:51:52753
[email protected]7ec6f382011-11-11 01:28:17754 // Temporary code so we can get more information. Format:
[email protected]8c380582011-12-02 03:16:10755 // http://url/foo.html#page1#max3#frame1#ids:2_Nx,1_1x,3_2
756 std::string temp = params.url.spec();
[email protected]7ec6f382011-11-11 01:28:17757 temp.append("#page");
[email protected]b69934e2011-10-29 02:51:52758 temp.append(base::IntToString(params.page_id));
[email protected]7ec6f382011-11-11 01:28:17759 temp.append("#max");
760 temp.append(base::IntToString(tab_contents_->GetMaxPageID()));
761 temp.append("#frame");
762 temp.append(base::IntToString(params.frame_id));
763 temp.append("#ids");
764 for (int i = 0; i < static_cast<int>(entries_.size()); ++i) {
[email protected]8c380582011-12-02 03:16:10765 // Append entry metadata (e.g., 3_7x):
766 // 3: page_id
767 // 7: SiteInstance ID, or N for null
768 // x: appended if not from the current SiteInstance
[email protected]36fc0392011-12-25 03:59:51769 temp.append(base::IntToString(entries_[i]->GetPageID()));
[email protected]8c380582011-12-02 03:16:10770 temp.append("_");
771 if (entries_[i]->site_instance())
[email protected]b6583592012-01-25 19:52:33772 temp.append(base::IntToString(entries_[i]->site_instance()->GetId()));
[email protected]7ec6f382011-11-11 01:28:17773 else
[email protected]8c380582011-12-02 03:16:10774 temp.append("N");
775 if (entries_[i]->site_instance() != tab_contents_->GetSiteInstance())
[email protected]7ec6f382011-11-11 01:28:17776 temp.append("x");
777 temp.append(",");
[email protected]b69934e2011-10-29 02:51:52778 }
779 GURL url(temp);
[email protected]151a63d2011-12-20 22:32:52780 tab_contents_->GetRenderViewHost()->Send(new ViewMsg_TempCrashWithData(url));
[email protected]b69934e2011-10-29 02:51:52781 return content::NAVIGATION_TYPE_NAV_IGNORE;
[email protected]e9ba4472008-09-14 15:42:43782 }
[email protected]10f417c52011-12-28 21:04:23783 NavigationEntryImpl* existing_entry = entries_[existing_entry_index].get();
[email protected]e9ba4472008-09-14 15:42:43784
[email protected]2905f742011-10-13 03:51:58785 if (!content::PageTransitionIsMainFrame(params.transition)) {
[email protected]e6035c22010-05-25 16:15:52786 // All manual subframes would get new IDs and were handled above, so we
787 // know this is auto. Since the current page was found in the navigation
788 // entry list, we're guaranteed to have a last committed entry.
789 DCHECK(GetLastCommittedEntry());
[email protected]610cbb82011-10-18 16:35:08790 return content::NAVIGATION_TYPE_AUTO_SUBFRAME;
[email protected]e6035c22010-05-25 16:15:52791 }
792
793 // Anything below here we know is a main frame navigation.
[email protected]e9ba4472008-09-14 15:42:43794 if (pending_entry_ &&
[email protected]e9ba4472008-09-14 15:42:43795 existing_entry != pending_entry_ &&
[email protected]36fc0392011-12-25 03:59:51796 pending_entry_->GetPageID() == -1 &&
[email protected]230c0012011-04-08 16:27:24797 existing_entry == GetLastCommittedEntry()) {
[email protected]e9ba4472008-09-14 15:42:43798 // In this case, we have a pending entry for a URL but WebCore didn't do a
799 // new navigation. This happens when you press enter in the URL bar to
800 // reload. We will create a pending entry, but WebKit will convert it to
801 // a reload since it's the same page and not create a new entry for it
802 // (the user doesn't want to have a new back/forward entry when they do
[email protected]230c0012011-04-08 16:27:24803 // this). If this matches the last committed entry, we want to just ignore
804 // the pending entry and go back to where we were (the "existing entry").
[email protected]610cbb82011-10-18 16:35:08805 return content::NAVIGATION_TYPE_SAME_PAGE;
[email protected]e9ba4472008-09-14 15:42:43806 }
807
[email protected]fc60f222008-12-18 17:36:54808 // Any toplevel navigations with the same base (minus the reference fragment)
809 // are in-page navigations. We weeded out subframe navigations above. Most of
810 // the time this doesn't matter since WebKit doesn't tell us about subframe
811 // navigations that don't actually navigate, but it can happen when there is
812 // an encoding override (it always sends a navigation request).
[email protected]36fc0392011-12-25 03:59:51813 if (AreURLsInPageNavigation(existing_entry->GetURL(), params.url))
[email protected]610cbb82011-10-18 16:35:08814 return content::NAVIGATION_TYPE_IN_PAGE;
[email protected]fc60f222008-12-18 17:36:54815
[email protected]e9ba4472008-09-14 15:42:43816 // Since we weeded out "new" navigations above, we know this is an existing
[email protected]4c27ba82008-09-24 16:49:09817 // (back/forward) navigation.
[email protected]610cbb82011-10-18 16:35:08818 return content::NAVIGATION_TYPE_EXISTING_PAGE;
[email protected]e9ba4472008-09-14 15:42:43819}
820
[email protected]d202a7c2012-01-04 07:53:47821bool NavigationControllerImpl::IsRedirect(
[email protected]09b8f82f2009-06-16 20:22:11822 const ViewHostMsg_FrameNavigate_Params& params) {
823 // For main frame transition, we judge by params.transition.
824 // Otherwise, by params.redirects.
[email protected]2905f742011-10-13 03:51:58825 if (content::PageTransitionIsMainFrame(params.transition)) {
826 return content::PageTransitionIsRedirect(params.transition);
[email protected]09b8f82f2009-06-16 20:22:11827 }
828 return params.redirects.size() > 1;
829}
830
[email protected]d202a7c2012-01-04 07:53:47831void NavigationControllerImpl::RendererDidNavigateToNewPage(
[email protected]befd8d822009-07-01 04:51:47832 const ViewHostMsg_FrameNavigate_Params& params, bool* did_replace_entry) {
[email protected]10f417c52011-12-28 21:04:23833 NavigationEntryImpl* new_entry;
[email protected]f1eb87a2011-05-06 17:49:41834 bool update_virtual_url;
[email protected]e9ba4472008-09-14 15:42:43835 if (pending_entry_) {
836 // TODO(brettw) this assumes that the pending entry is appropriate for the
837 // new page that was just loaded. I don't think this is necessarily the
[email protected]49bd30e62011-03-22 20:12:59838 // case! We should have some more tracking to know for sure.
[email protected]10f417c52011-12-28 21:04:23839 new_entry = new NavigationEntryImpl(*pending_entry_);
[email protected]e9ba4472008-09-14 15:42:43840
841 // Don't use the page type from the pending entry. Some interstitial page
842 // may have set the type to interstitial. Once we commit, however, the page
843 // type must always be normal.
[email protected]66fdbd52011-10-18 17:08:53844 new_entry->set_page_type(content::PAGE_TYPE_NORMAL);
[email protected]f1eb87a2011-05-06 17:49:41845 update_virtual_url = new_entry->update_virtual_url_with_url();
[email protected]e9ba4472008-09-14 15:42:43846 } else {
[email protected]10f417c52011-12-28 21:04:23847 new_entry = new NavigationEntryImpl;
[email protected]f1eb87a2011-05-06 17:49:41848 // When navigating to a new page, give the browser URL handler a chance to
849 // update the virtual URL based on the new URL. For example, this is needed
850 // to show chrome://bookmarks/#1 when the bookmarks webui extension changes
851 // the URL.
852 update_virtual_url = true;
[email protected]e9ba4472008-09-14 15:42:43853 }
854
[email protected]ad23a092011-12-28 07:02:04855 new_entry->SetURL(params.url);
[email protected]f1eb87a2011-05-06 17:49:41856 if (update_virtual_url)
[email protected]38178a42009-12-17 18:58:32857 UpdateVirtualURLToURL(new_entry, params.url);
[email protected]022af742011-12-28 18:37:25858 new_entry->SetReferrer(params.referrer);
[email protected]36fc0392011-12-25 03:59:51859 new_entry->SetPageID(params.page_id);
[email protected]022af742011-12-28 18:37:25860 new_entry->SetTransitionType(params.transition);
[email protected]b6583592012-01-25 19:52:33861 new_entry->set_site_instance(
862 static_cast<SiteInstanceImpl*>(tab_contents_->GetSiteInstance()));
[email protected]36fc0392011-12-25 03:59:51863 new_entry->SetHasPostData(params.is_post);
[email protected]86cd9472012-02-03 19:51:05864 new_entry->SetPostID(params.post_id);
[email protected]e9ba4472008-09-14 15:42:43865
[email protected]befd8d822009-07-01 04:51:47866 InsertOrReplaceEntry(new_entry, *did_replace_entry);
[email protected]e9ba4472008-09-14 15:42:43867}
868
[email protected]d202a7c2012-01-04 07:53:47869void NavigationControllerImpl::RendererDidNavigateToExistingPage(
[email protected]e9ba4472008-09-14 15:42:43870 const ViewHostMsg_FrameNavigate_Params& params) {
871 // We should only get here for main frame navigations.
[email protected]2905f742011-10-13 03:51:58872 DCHECK(content::PageTransitionIsMainFrame(params.transition));
[email protected]e9ba4472008-09-14 15:42:43873
874 // This is a back/forward navigation. The existing page for the ID is
[email protected]4c27ba82008-09-24 16:49:09875 // guaranteed to exist by ClassifyNavigation, and we just need to update it
876 // with new information from the renderer.
[email protected]7f0005a2009-04-15 03:25:11877 int entry_index = GetEntryIndexWithPageID(tab_contents_->GetSiteInstance(),
878 params.page_id);
[email protected]e9ba4472008-09-14 15:42:43879 DCHECK(entry_index >= 0 &&
880 entry_index < static_cast<int>(entries_.size()));
[email protected]10f417c52011-12-28 21:04:23881 NavigationEntryImpl* entry = entries_[entry_index].get();
[email protected]e9ba4472008-09-14 15:42:43882
883 // The URL may have changed due to redirects. The site instance will normally
884 // be the same except during session restore, when no site instance will be
885 // assigned.
[email protected]ad23a092011-12-28 07:02:04886 entry->SetURL(params.url);
[email protected]38178a42009-12-17 18:58:32887 if (entry->update_virtual_url_with_url())
888 UpdateVirtualURLToURL(entry, params.url);
[email protected]e9ba4472008-09-14 15:42:43889 DCHECK(entry->site_instance() == NULL ||
[email protected]9423d9412009-04-14 22:13:55890 entry->site_instance() == tab_contents_->GetSiteInstance());
[email protected]b6583592012-01-25 19:52:33891 entry->set_site_instance(
892 static_cast<SiteInstanceImpl*>(tab_contents_->GetSiteInstance()));
[email protected]e9ba4472008-09-14 15:42:43893
[email protected]36fc0392011-12-25 03:59:51894 entry->SetHasPostData(params.is_post);
[email protected]86cd9472012-02-03 19:51:05895 entry->SetPostID(params.post_id);
[email protected]d5a49e52010-01-08 03:01:41896
[email protected]e9ba4472008-09-14 15:42:43897 // The entry we found in the list might be pending if the user hit
898 // back/forward/reload. This load should commit it (since it's already in the
[email protected]49bd30e62011-03-22 20:12:59899 // list, we can just discard the pending pointer). We should also discard the
900 // pending entry if it corresponds to a different navigation, since that one
901 // is now likely canceled. If it is not canceled, we will treat it as a new
902 // navigation when it arrives, which is also ok.
[email protected]e9ba4472008-09-14 15:42:43903 //
904 // Note that we need to use the "internal" version since we don't want to
905 // actually change any other state, just kill the pointer.
[email protected]49bd30e62011-03-22 20:12:59906 if (pending_entry_)
[email protected]cbab76d2008-10-13 22:42:47907 DiscardNonCommittedEntriesInternal();
[email protected]40bcc302009-03-02 20:50:39908
[email protected]80858db52009-10-15 00:35:18909 // If a transient entry was removed, the indices might have changed, so we
910 // have to query the entry index again.
911 last_committed_entry_index_ =
912 GetEntryIndexWithPageID(tab_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:43913}
914
[email protected]d202a7c2012-01-04 07:53:47915void NavigationControllerImpl::RendererDidNavigateToSamePage(
[email protected]e9ba4472008-09-14 15:42:43916 const ViewHostMsg_FrameNavigate_Params& params) {
917 // This mode implies we have a pending entry that's the same as an existing
[email protected]4c27ba82008-09-24 16:49:09918 // entry for this page ID. This entry is guaranteed to exist by
919 // ClassifyNavigation. All we need to do is update the existing entry.
[email protected]10f417c52011-12-28 21:04:23920 NavigationEntryImpl* existing_entry = GetEntryWithPageID(
921 tab_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:43922
923 // We assign the entry's unique ID to be that of the new one. Since this is
924 // always the result of a user action, we want to dismiss infobars, etc. like
925 // a regular user-initiated navigation.
[email protected]36fc0392011-12-25 03:59:51926 existing_entry->set_unique_id(pending_entry_->GetUniqueID());
[email protected]e9ba4472008-09-14 15:42:43927
[email protected]a0e69262009-06-03 19:08:48928 // The URL may have changed due to redirects.
[email protected]38178a42009-12-17 18:58:32929 if (existing_entry->update_virtual_url_with_url())
930 UpdateVirtualURLToURL(existing_entry, params.url);
[email protected]ad23a092011-12-28 07:02:04931 existing_entry->SetURL(params.url);
[email protected]a0e69262009-06-03 19:08:48932
[email protected]cbab76d2008-10-13 22:42:47933 DiscardNonCommittedEntries();
[email protected]e9ba4472008-09-14 15:42:43934}
935
[email protected]d202a7c2012-01-04 07:53:47936void NavigationControllerImpl::RendererDidNavigateInPage(
[email protected]befd8d822009-07-01 04:51:47937 const ViewHostMsg_FrameNavigate_Params& params, bool* did_replace_entry) {
[email protected]2905f742011-10-13 03:51:58938 DCHECK(content::PageTransitionIsMainFrame(params.transition)) <<
[email protected]e9ba4472008-09-14 15:42:43939 "WebKit should only tell us about in-page navs for the main frame.";
940 // We're guaranteed to have an entry for this one.
[email protected]10f417c52011-12-28 21:04:23941 NavigationEntryImpl* existing_entry = GetEntryWithPageID(
942 tab_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:43943
944 // Reference fragment navigation. We're guaranteed to have the last_committed
945 // entry and it will be the same page as the new navigation (minus the
[email protected]d466b8a2011-07-15 21:48:03946 // reference fragments, of course). We'll update the URL of the existing
947 // entry without pruning the forward history.
[email protected]ad23a092011-12-28 07:02:04948 existing_entry->SetURL(params.url);
[email protected]d466b8a2011-07-15 21:48:03949 if (existing_entry->update_virtual_url_with_url())
950 UpdateVirtualURLToURL(existing_entry, params.url);
[email protected]ccbe04e2010-03-17 17:58:43951
952 // This replaces the existing entry since the page ID didn't change.
953 *did_replace_entry = true;
[email protected]d466b8a2011-07-15 21:48:03954
955 if (pending_entry_)
956 DiscardNonCommittedEntriesInternal();
957
958 // If a transient entry was removed, the indices might have changed, so we
959 // have to query the entry index again.
960 last_committed_entry_index_ =
961 GetEntryIndexWithPageID(tab_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:43962}
963
[email protected]d202a7c2012-01-04 07:53:47964void NavigationControllerImpl::RendererDidNavigateNewSubframe(
[email protected]e9ba4472008-09-14 15:42:43965 const ViewHostMsg_FrameNavigate_Params& params) {
[email protected]2905f742011-10-13 03:51:58966 if (content::PageTransitionStripQualifier(params.transition) ==
967 content::PAGE_TRANSITION_AUTO_SUBFRAME) {
[email protected]09b8f82f2009-06-16 20:22:11968 // This is not user-initiated. Ignore.
969 return;
970 }
[email protected]09b8f82f2009-06-16 20:22:11971
[email protected]e9ba4472008-09-14 15:42:43972 // Manual subframe navigations just get the current entry cloned so the user
973 // can go back or forward to it. The actual subframe information will be
974 // stored in the page state for each of those entries. This happens out of
975 // band with the actual navigations.
[email protected]4c27ba82008-09-24 16:49:09976 DCHECK(GetLastCommittedEntry()) << "ClassifyNavigation should guarantee "
977 << "that a last committed entry exists.";
[email protected]10f417c52011-12-28 21:04:23978 NavigationEntryImpl* new_entry = new NavigationEntryImpl(
979 *NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry()));
[email protected]36fc0392011-12-25 03:59:51980 new_entry->SetPageID(params.page_id);
[email protected]672eba292009-05-13 13:22:45981 InsertOrReplaceEntry(new_entry, false);
[email protected]e9ba4472008-09-14 15:42:43982}
983
[email protected]d202a7c2012-01-04 07:53:47984bool NavigationControllerImpl::RendererDidNavigateAutoSubframe(
[email protected]e9ba4472008-09-14 15:42:43985 const ViewHostMsg_FrameNavigate_Params& params) {
986 // We're guaranteed to have a previously committed entry, and we now need to
987 // handle navigation inside of a subframe in it without creating a new entry.
988 DCHECK(GetLastCommittedEntry());
989
990 // Handle the case where we're navigating back/forward to a previous subframe
991 // navigation entry. This is case "2." in NAV_AUTO_SUBFRAME comment in the
992 // header file. In case "1." this will be a NOP.
993 int entry_index = GetEntryIndexWithPageID(
[email protected]9423d9412009-04-14 22:13:55994 tab_contents_->GetSiteInstance(),
[email protected]e9ba4472008-09-14 15:42:43995 params.page_id);
996 if (entry_index < 0 ||
997 entry_index >= static_cast<int>(entries_.size())) {
998 NOTREACHED();
999 return false;
1000 }
1001
1002 // Update the current navigation entry in case we're going back/forward.
1003 if (entry_index != last_committed_entry_index_) {
[email protected]e9ba4472008-09-14 15:42:431004 last_committed_entry_index_ = entry_index;
[email protected]e9ba4472008-09-14 15:42:431005 return true;
1006 }
1007 return false;
1008}
1009
[email protected]d202a7c2012-01-04 07:53:471010int NavigationControllerImpl::GetIndexOfEntry(
[email protected]10f417c52011-12-28 21:04:231011 const NavigationEntryImpl* entry) const {
[email protected]765b35502008-08-21 00:51:201012 const NavigationEntries::const_iterator i(std::find(
1013 entries_.begin(),
1014 entries_.end(),
1015 entry));
1016 return (i == entries_.end()) ? -1 : static_cast<int>(i - entries_.begin());
1017}
1018
[email protected]d202a7c2012-01-04 07:53:471019bool NavigationControllerImpl::IsURLInPageNavigation(const GURL& url) const {
[email protected]10f417c52011-12-28 21:04:231020 NavigationEntry* last_committed = GetLastCommittedEntry();
[email protected]e9ba4472008-09-14 15:42:431021 if (!last_committed)
1022 return false;
[email protected]36fc0392011-12-25 03:59:511023 return AreURLsInPageNavigation(last_committed->GetURL(), url);
[email protected]e9ba4472008-09-14 15:42:431024}
1025
[email protected]d202a7c2012-01-04 07:53:471026void NavigationControllerImpl::CopyStateFrom(
[email protected]c5eed492012-01-04 17:07:501027 const NavigationController& temp) {
[email protected]d202a7c2012-01-04 07:53:471028 const NavigationControllerImpl& source =
1029 static_cast<const NavigationControllerImpl&>(temp);
[email protected]ce3fa3c2009-04-20 19:55:571030 // Verify that we look new.
[email protected]a26023822011-12-29 00:23:551031 DCHECK(GetEntryCount() == 0 && !GetPendingEntry());
[email protected]ce3fa3c2009-04-20 19:55:571032
[email protected]a26023822011-12-29 00:23:551033 if (source.GetEntryCount() == 0)
[email protected]ce3fa3c2009-04-20 19:55:571034 return; // Nothing new to do.
1035
1036 needs_reload_ = true;
[email protected]a26023822011-12-29 00:23:551037 InsertEntriesFrom(source, source.GetEntryCount());
[email protected]ce3fa3c2009-04-20 19:55:571038
[email protected]6ee12c42010-09-14 09:36:071039 session_storage_namespace_ = source.session_storage_namespace_->Clone();
[email protected]4e6419c2010-01-15 04:50:341040
[email protected]5e369672009-11-03 23:48:301041 FinishRestore(source.last_committed_entry_index_, false);
[email protected]91854cd2012-01-10 19:43:571042
1043 // Copy the max page id map from the old tab to the new tab. This ensures
1044 // that new and existing navigations in the tab's current SiteInstances
1045 // are identified properly.
1046 tab_contents_->CopyMaxPageIDsFrom(source.tab_contents());
[email protected]ce3fa3c2009-04-20 19:55:571047}
1048
[email protected]d202a7c2012-01-04 07:53:471049void NavigationControllerImpl::CopyStateFromAndPrune(
[email protected]c5eed492012-01-04 17:07:501050 NavigationController* temp) {
[email protected]d202a7c2012-01-04 07:53:471051 NavigationControllerImpl* source =
1052 static_cast<NavigationControllerImpl*>(temp);
[email protected]9e1ad4b2011-08-14 16:49:191053 // The SiteInstance and page_id of the last committed entry needs to be
1054 // remembered at this point, in case there is only one committed entry
[email protected]91854cd2012-01-10 19:43:571055 // and it is pruned. We use a scoped_refptr to ensure the SiteInstance
1056 // can't be freed during this time period.
[email protected]10f417c52011-12-28 21:04:231057 NavigationEntryImpl* last_committed =
1058 NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry());
[email protected]91854cd2012-01-10 19:43:571059 scoped_refptr<SiteInstance> site_instance(
1060 last_committed ? last_committed->site_instance() : NULL);
[email protected]36fc0392011-12-25 03:59:511061 int32 minimum_page_id = last_committed ? last_committed->GetPageID() : -1;
[email protected]91854cd2012-01-10 19:43:571062 int32 max_page_id = last_committed ?
1063 tab_contents_->GetMaxPageIDForSiteInstance(site_instance.get()) : -1;
[email protected]9e1ad4b2011-08-14 16:49:191064
[email protected]e1cd5452010-08-26 18:03:251065 // This code is intended for use when the last entry is the active entry.
[email protected]a26023822011-12-29 00:23:551066 DCHECK(
1067 (transient_entry_index_ != -1 &&
[email protected]91854cd2012-01-10 19:43:571068 transient_entry_index_ == GetEntryCount() - 1) ||
[email protected]a26023822011-12-29 00:23:551069 (pending_entry_ && (pending_entry_index_ == -1 ||
1070 pending_entry_index_ == GetEntryCount() - 1)) ||
1071 (!pending_entry_ && last_committed_entry_index_ == GetEntryCount() - 1));
[email protected]e1cd5452010-08-26 18:03:251072
1073 // Remove all the entries leaving the active entry.
1074 PruneAllButActive();
1075
[email protected]47e020a2010-10-15 14:43:371076 // Insert the entries from source. Don't use source->GetCurrentEntryIndex as
[email protected]e1cd5452010-08-26 18:03:251077 // we don't want to copy over the transient entry.
[email protected]47e020a2010-10-15 14:43:371078 int max_source_index = source->pending_entry_index_ != -1 ?
1079 source->pending_entry_index_ : source->last_committed_entry_index_;
[email protected]e1cd5452010-08-26 18:03:251080 if (max_source_index == -1)
[email protected]a26023822011-12-29 00:23:551081 max_source_index = source->GetEntryCount();
[email protected]e1cd5452010-08-26 18:03:251082 else
1083 max_source_index++;
[email protected]47e020a2010-10-15 14:43:371084 InsertEntriesFrom(*source, max_source_index);
[email protected]e1cd5452010-08-26 18:03:251085
1086 // Adjust indices such that the last entry and pending are at the end now.
[email protected]a26023822011-12-29 00:23:551087 last_committed_entry_index_ = GetEntryCount() - 1;
[email protected]e1cd5452010-08-26 18:03:251088 if (pending_entry_index_ != -1)
[email protected]a26023822011-12-29 00:23:551089 pending_entry_index_ = GetEntryCount() - 1;
[email protected]e1cd5452010-08-26 18:03:251090 if (transient_entry_index_ != -1) {
1091 // There's a transient entry. In this case we want the last committed to
1092 // point to the previous entry.
[email protected]a26023822011-12-29 00:23:551093 transient_entry_index_ = GetEntryCount() - 1;
[email protected]e1cd5452010-08-26 18:03:251094 if (last_committed_entry_index_ != -1)
1095 last_committed_entry_index_--;
1096 }
[email protected]796931a92011-08-10 01:32:141097
[email protected]91854cd2012-01-10 19:43:571098 tab_contents_->SetHistoryLengthAndPrune(site_instance.get(),
[email protected]9e1ad4b2011-08-14 16:49:191099 max_source_index,
1100 minimum_page_id);
[email protected]91854cd2012-01-10 19:43:571101
1102 // Copy the max page id map from the old tab to the new tab. This ensures
1103 // that new and existing navigations in the tab's current SiteInstances
1104 // are identified properly.
1105 tab_contents_->CopyMaxPageIDsFrom(source->tab_contents());
1106
1107 // If there is a last committed entry, be sure to include it in the new
1108 // max page ID map.
1109 if (max_page_id > -1) {
1110 tab_contents_->UpdateMaxPageIDForSiteInstance(site_instance.get(),
1111 max_page_id);
1112 }
[email protected]e1cd5452010-08-26 18:03:251113}
1114
[email protected]d202a7c2012-01-04 07:53:471115void NavigationControllerImpl::PruneAllButActive() {
[email protected]97b6c4f2010-09-27 19:31:261116 if (transient_entry_index_ != -1) {
1117 // There is a transient entry. Prune up to it.
[email protected]a26023822011-12-29 00:23:551118 DCHECK_EQ(GetEntryCount() - 1, transient_entry_index_);
[email protected]77d8d622010-12-15 10:30:121119 entries_.erase(entries_.begin(), entries_.begin() + transient_entry_index_);
[email protected]97b6c4f2010-09-27 19:31:261120 transient_entry_index_ = 0;
1121 last_committed_entry_index_ = -1;
1122 pending_entry_index_ = -1;
1123 } else if (!pending_entry_) {
1124 // There's no pending entry. Leave the last entry (if there is one).
[email protected]a26023822011-12-29 00:23:551125 if (!GetEntryCount())
[email protected]97b6c4f2010-09-27 19:31:261126 return;
1127
[email protected]77d8d622010-12-15 10:30:121128 DCHECK(last_committed_entry_index_ >= 0);
1129 entries_.erase(entries_.begin(),
1130 entries_.begin() + last_committed_entry_index_);
1131 entries_.erase(entries_.begin() + 1, entries_.end());
[email protected]97b6c4f2010-09-27 19:31:261132 last_committed_entry_index_ = 0;
1133 } else if (pending_entry_index_ != -1) {
[email protected]77d8d622010-12-15 10:30:121134 entries_.erase(entries_.begin(), entries_.begin() + pending_entry_index_);
1135 entries_.erase(entries_.begin() + 1, entries_.end());
[email protected]97b6c4f2010-09-27 19:31:261136 pending_entry_index_ = 0;
1137 last_committed_entry_index_ = 0;
[email protected]97b6c4f2010-09-27 19:31:261138 } else {
1139 // There is a pending_entry, but it's not in entries_.
1140 pending_entry_index_ = -1;
1141 last_committed_entry_index_ = -1;
[email protected]77d8d622010-12-15 10:30:121142 entries_.clear();
[email protected]97b6c4f2010-09-27 19:31:261143 }
1144
[email protected]0bfbf882011-12-22 18:19:271145 if (tab_contents_->GetInterstitialPage()) {
[email protected]97b6c4f2010-09-27 19:31:261146 // Normally the interstitial page hides itself if the user doesn't proceeed.
1147 // This would result in showing a NavigationEntry we just removed. Set this
1148 // so the interstitial triggers a reload if the user doesn't proceed.
[email protected]cadaec52012-02-08 21:53:131149 static_cast<InterstitialPageImpl*>(tab_contents_->GetInterstitialPage())->
1150 set_reload_on_dont_proceed(true);
[email protected]97b6c4f2010-09-27 19:31:261151 }
[email protected]97b6c4f2010-09-27 19:31:261152}
1153
[email protected]d202a7c2012-01-04 07:53:471154SSLManager* NavigationControllerImpl::GetSSLManager() {
[email protected]71fde352011-12-29 03:29:561155 return &ssl_manager_;
1156}
1157
[email protected]d202a7c2012-01-04 07:53:471158void NavigationControllerImpl::SetMaxRestoredPageID(int32 max_id) {
[email protected]71fde352011-12-29 03:29:561159 max_restored_page_id_ = max_id;
1160}
1161
[email protected]d202a7c2012-01-04 07:53:471162int32 NavigationControllerImpl::GetMaxRestoredPageID() const {
[email protected]71fde352011-12-29 03:29:561163 return max_restored_page_id_;
[email protected]a26023822011-12-29 00:23:551164}
1165
1166SessionStorageNamespace*
[email protected]d202a7c2012-01-04 07:53:471167 NavigationControllerImpl::GetSessionStorageNamespace() const {
[email protected]a26023822011-12-29 00:23:551168 return session_storage_namespace_;
1169}
[email protected]d202a7c2012-01-04 07:53:471170
1171bool NavigationControllerImpl::NeedsReload() const {
[email protected]71fde352011-12-29 03:29:561172 return needs_reload_;
1173}
[email protected]a26023822011-12-29 00:23:551174
[email protected]d202a7c2012-01-04 07:53:471175void NavigationControllerImpl::RemoveEntryAtIndexInternal(int index) {
[email protected]a26023822011-12-29 00:23:551176 DCHECK(index < GetEntryCount());
[email protected]6a13a6c2011-12-20 21:47:121177 DCHECK(index != last_committed_entry_index_);
[email protected]43032342011-03-21 14:10:311178
1179 DiscardNonCommittedEntries();
1180
1181 entries_.erase(entries_.begin() + index);
[email protected]6a13a6c2011-12-20 21:47:121182 if (last_committed_entry_index_ > index)
[email protected]43032342011-03-21 14:10:311183 last_committed_entry_index_--;
1184}
1185
[email protected]d202a7c2012-01-04 07:53:471186void NavigationControllerImpl::DiscardNonCommittedEntries() {
[email protected]cbab76d2008-10-13 22:42:471187 bool transient = transient_entry_index_ != -1;
1188 DiscardNonCommittedEntriesInternal();
initial.commit09911bf2008-07-26 23:55:291189
[email protected]cbab76d2008-10-13 22:42:471190 // If there was a transient entry, invalidate everything so the new active
1191 // entry state is shown.
1192 if (transient) {
[email protected]93f230e02011-06-01 14:40:001193 tab_contents_->NotifyNavigationStateChanged(kInvalidateAll);
[email protected]cbab76d2008-10-13 22:42:471194 }
initial.commit09911bf2008-07-26 23:55:291195}
1196
[email protected]d202a7c2012-01-04 07:53:471197NavigationEntry* NavigationControllerImpl::GetPendingEntry() const {
[email protected]022af742011-12-28 18:37:251198 return pending_entry_;
1199}
1200
[email protected]d202a7c2012-01-04 07:53:471201int NavigationControllerImpl::GetPendingEntryIndex() const {
[email protected]a26023822011-12-29 00:23:551202 return pending_entry_index_;
1203}
1204
[email protected]d202a7c2012-01-04 07:53:471205void NavigationControllerImpl::InsertOrReplaceEntry(NavigationEntryImpl* entry,
1206 bool replace) {
[email protected]36fc0392011-12-25 03:59:511207 DCHECK(entry->GetTransitionType() != content::PAGE_TRANSITION_AUTO_SUBFRAME);
[email protected]765b35502008-08-21 00:51:201208
1209 // Copy the pending entry's unique ID to the committed entry.
1210 // I don't know if pending_entry_index_ can be other than -1 here.
[email protected]10f417c52011-12-28 21:04:231211 const NavigationEntryImpl* const pending_entry =
1212 (pending_entry_index_ == -1) ?
1213 pending_entry_ : entries_[pending_entry_index_].get();
[email protected]765b35502008-08-21 00:51:201214 if (pending_entry)
[email protected]36fc0392011-12-25 03:59:511215 entry->set_unique_id(pending_entry->GetUniqueID());
[email protected]765b35502008-08-21 00:51:201216
[email protected]cbab76d2008-10-13 22:42:471217 DiscardNonCommittedEntriesInternal();
[email protected]765b35502008-08-21 00:51:201218
1219 int current_size = static_cast<int>(entries_.size());
1220
[email protected]765b35502008-08-21 00:51:201221 if (current_size > 0) {
[email protected]672eba292009-05-13 13:22:451222 // Prune any entries which are in front of the current entry.
1223 // Also prune the current entry if we are to replace the current entry.
[email protected]47dcbdc2011-05-27 15:08:311224 // last_committed_entry_index_ must be updated here since calls to
1225 // NotifyPrunedEntries() below may re-enter and we must make sure
1226 // last_committed_entry_index_ is not left in an invalid state.
1227 if (replace)
1228 --last_committed_entry_index_;
1229
[email protected]c12bf1a12008-09-17 16:28:491230 int num_pruned = 0;
[email protected]47dcbdc2011-05-27 15:08:311231 while (last_committed_entry_index_ < (current_size - 1)) {
[email protected]c12bf1a12008-09-17 16:28:491232 num_pruned++;
[email protected]765b35502008-08-21 00:51:201233 entries_.pop_back();
1234 current_size--;
1235 }
[email protected]c12bf1a12008-09-17 16:28:491236 if (num_pruned > 0) // Only notify if we did prune something.
1237 NotifyPrunedEntries(this, false, num_pruned);
[email protected]765b35502008-08-21 00:51:201238 }
1239
[email protected]9b51970d2011-12-09 23:10:231240 if (entries_.size() >= max_entry_count()) {
[email protected]6a13a6c2011-12-20 21:47:121241 DCHECK(last_committed_entry_index_ > 0);
1242 RemoveEntryAtIndex(0);
[email protected]c12bf1a12008-09-17 16:28:491243 NotifyPrunedEntries(this, true, 1);
1244 }
[email protected]765b35502008-08-21 00:51:201245
[email protected]10f417c52011-12-28 21:04:231246 entries_.push_back(linked_ptr<NavigationEntryImpl>(entry));
[email protected]765b35502008-08-21 00:51:201247 last_committed_entry_index_ = static_cast<int>(entries_.size()) - 1;
[email protected]e9ba4472008-09-14 15:42:431248
1249 // This is a new page ID, so we need everybody to know about it.
[email protected]36fc0392011-12-25 03:59:511250 tab_contents_->UpdateMaxPageID(entry->GetPageID());
initial.commit09911bf2008-07-26 23:55:291251}
1252
[email protected]d202a7c2012-01-04 07:53:471253void NavigationControllerImpl::NavigateToPendingEntry(ReloadType reload_type) {
[email protected]72097fd02010-01-21 23:36:011254 needs_reload_ = false;
1255
[email protected]83c2e232011-10-07 21:36:461256 // If we were navigating to a slow-to-commit page, and the user performs
1257 // a session history navigation to the last committed page, RenderViewHost
1258 // will force the throbber to start, but WebKit will essentially ignore the
1259 // navigation, and won't send a message to stop the throbber. To prevent this
1260 // from happening, we drop the navigation here and stop the slow-to-commit
1261 // page from loading (which would normally happen during the navigation).
1262 if (pending_entry_index_ != -1 &&
1263 pending_entry_index_ == last_committed_entry_index_ &&
1264 (entries_[pending_entry_index_]->restore_type() ==
[email protected]10f417c52011-12-28 21:04:231265 NavigationEntryImpl::RESTORE_NONE) &&
[email protected]36fc0392011-12-25 03:59:511266 (entries_[pending_entry_index_]->GetTransitionType() &
[email protected]2905f742011-10-13 03:51:581267 content::PAGE_TRANSITION_FORWARD_BACK)) {
[email protected]83c2e232011-10-07 21:36:461268 tab_contents_->Stop();
[email protected]6a13a6c2011-12-20 21:47:121269
1270 // If an interstitial page is showing, we want to close it to get back
1271 // to what was showing before.
[email protected]0bfbf882011-12-22 18:19:271272 if (tab_contents_->GetInterstitialPage())
1273 tab_contents_->GetInterstitialPage()->DontProceed();
[email protected]6a13a6c2011-12-20 21:47:121274
[email protected]83c2e232011-10-07 21:36:461275 DiscardNonCommittedEntries();
1276 return;
1277 }
1278
[email protected]6a13a6c2011-12-20 21:47:121279 // If an interstitial page is showing, the previous renderer is blocked and
1280 // cannot make new requests. Unblock (and disable) it to allow this
1281 // navigation to succeed. The interstitial will stay visible until the
1282 // resulting DidNavigate.
[email protected]cadaec52012-02-08 21:53:131283 if (tab_contents_->GetInterstitialPage()) {
1284 static_cast<InterstitialPageImpl*>(tab_contents_->GetInterstitialPage())->
1285 CancelForNavigation();
1286 }
[email protected]6a13a6c2011-12-20 21:47:121287
initial.commit09911bf2008-07-26 23:55:291288 // For session history navigations only the pending_entry_index_ is set.
1289 if (!pending_entry_) {
[email protected]4bf3522c2010-08-19 21:00:201290 DCHECK_NE(pending_entry_index_, -1);
[email protected]765b35502008-08-21 00:51:201291 pending_entry_ = entries_[pending_entry_index_].get();
initial.commit09911bf2008-07-26 23:55:291292 }
1293
[email protected]1ccb3568d2010-02-19 10:51:161294 if (!tab_contents_->NavigateToPendingEntry(reload_type))
[email protected]cbab76d2008-10-13 22:42:471295 DiscardNonCommittedEntries();
[email protected]77362eb2011-08-01 17:18:381296
1297 // If the entry is being restored and doesn't have a SiteInstance yet, fill
1298 // it in now that we know. This allows us to find the entry when it commits.
1299 // This works for browser-initiated navigations. We handle renderer-initiated
1300 // navigations to restored entries in TabContents::OnGoToEntryAtOffset.
1301 if (pending_entry_ && !pending_entry_->site_instance() &&
[email protected]10f417c52011-12-28 21:04:231302 pending_entry_->restore_type() != NavigationEntryImpl::RESTORE_NONE) {
[email protected]b6583592012-01-25 19:52:331303 pending_entry_->set_site_instance(static_cast<SiteInstanceImpl*>(
1304 tab_contents_->GetPendingSiteInstance()));
[email protected]10f417c52011-12-28 21:04:231305 pending_entry_->set_restore_type(NavigationEntryImpl::RESTORE_NONE);
[email protected]77362eb2011-08-01 17:18:381306 }
initial.commit09911bf2008-07-26 23:55:291307}
1308
[email protected]d202a7c2012-01-04 07:53:471309void NavigationControllerImpl::NotifyNavigationEntryCommitted(
[email protected]93f230e02011-06-01 14:40:001310 content::LoadCommittedDetails* details) {
[email protected]df1af242009-05-01 00:11:401311 details->entry = GetActiveEntry();
[email protected]6c2381d2011-10-19 02:52:531312 content::NotificationDetails notification_details =
1313 content::Details<content::LoadCommittedDetails>(details);
[email protected]df1af242009-05-01 00:11:401314
1315 // We need to notify the ssl_manager_ before the tab_contents_ so the
1316 // location bar will have up-to-date information about the security style
1317 // when it wants to draw. See http://crbug.com/11157
1318 ssl_manager_.DidCommitProvisionalLoad(notification_details);
1319
initial.commit09911bf2008-07-26 23:55:291320 // TODO(pkasting): http://b/1113079 Probably these explicit notification paths
1321 // should be removed, and interested parties should just listen for the
1322 // notification below instead.
[email protected]93f230e02011-06-01 14:40:001323 tab_contents_->NotifyNavigationStateChanged(kInvalidateAll);
initial.commit09911bf2008-07-26 23:55:291324
[email protected]ad50def52011-10-19 23:17:071325 content::NotificationService::current()->Notify(
[email protected]432115822011-07-10 15:52:271326 content::NOTIFICATION_NAV_ENTRY_COMMITTED,
[email protected]c5eed492012-01-04 17:07:501327 content::Source<NavigationController>(this),
[email protected]df1af242009-05-01 00:11:401328 notification_details);
initial.commit09911bf2008-07-26 23:55:291329}
1330
initial.commit09911bf2008-07-26 23:55:291331// static
[email protected]d202a7c2012-01-04 07:53:471332size_t NavigationControllerImpl::max_entry_count() {
[email protected]9b51970d2011-12-09 23:10:231333 if (max_entry_count_for_testing_ != kMaxEntryCountForTestingNotSet)
1334 return max_entry_count_for_testing_;
1335 return content::kMaxSessionHistoryEntries;
1336}
1337
[email protected]d202a7c2012-01-04 07:53:471338void NavigationControllerImpl::SetActive(bool is_active) {
[email protected]ee613922009-09-02 20:38:221339 if (is_active && needs_reload_)
1340 LoadIfNecessary();
initial.commit09911bf2008-07-26 23:55:291341}
1342
[email protected]d202a7c2012-01-04 07:53:471343void NavigationControllerImpl::LoadIfNecessary() {
initial.commit09911bf2008-07-26 23:55:291344 if (!needs_reload_)
1345 return;
1346
initial.commit09911bf2008-07-26 23:55:291347 // Calling Reload() results in ignoring state, and not loading.
1348 // Explicitly use NavigateToPendingEntry so that the renderer uses the
1349 // cached state.
1350 pending_entry_index_ = last_committed_entry_index_;
[email protected]1ccb3568d2010-02-19 10:51:161351 NavigateToPendingEntry(NO_RELOAD);
initial.commit09911bf2008-07-26 23:55:291352}
1353
[email protected]d202a7c2012-01-04 07:53:471354void NavigationControllerImpl::NotifyEntryChanged(const NavigationEntry* entry,
1355 int index) {
[email protected]8286f51a2011-05-31 17:39:131356 content::EntryChangedDetails det;
[email protected]534e54b2008-08-13 15:40:091357 det.changed_entry = entry;
1358 det.index = index;
[email protected]ad50def52011-10-19 23:17:071359 content::NotificationService::current()->Notify(
[email protected]432115822011-07-10 15:52:271360 content::NOTIFICATION_NAV_ENTRY_CHANGED,
[email protected]c5eed492012-01-04 17:07:501361 content::Source<NavigationController>(this),
[email protected]6c2381d2011-10-19 02:52:531362 content::Details<content::EntryChangedDetails>(&det));
initial.commit09911bf2008-07-26 23:55:291363}
1364
[email protected]d202a7c2012-01-04 07:53:471365void NavigationControllerImpl::FinishRestore(int selected_index,
1366 bool from_last_session) {
[email protected]a26023822011-12-29 00:23:551367 DCHECK(selected_index >= 0 && selected_index < GetEntryCount());
[email protected]5e369672009-11-03 23:48:301368 ConfigureEntriesForRestore(&entries_, from_last_session);
initial.commit09911bf2008-07-26 23:55:291369
[email protected]71fde352011-12-29 03:29:561370 SetMaxRestoredPageID(static_cast<int32>(GetEntryCount()));
initial.commit09911bf2008-07-26 23:55:291371
1372 last_committed_entry_index_ = selected_index;
initial.commit09911bf2008-07-26 23:55:291373}
[email protected]765b35502008-08-21 00:51:201374
[email protected]d202a7c2012-01-04 07:53:471375void NavigationControllerImpl::DiscardNonCommittedEntriesInternal() {
[email protected]765b35502008-08-21 00:51:201376 if (pending_entry_index_ == -1)
1377 delete pending_entry_;
1378 pending_entry_ = NULL;
1379 pending_entry_index_ = -1;
[email protected]cbab76d2008-10-13 22:42:471380
1381 DiscardTransientEntry();
1382}
1383
[email protected]d202a7c2012-01-04 07:53:471384void NavigationControllerImpl::DiscardTransientEntry() {
[email protected]cbab76d2008-10-13 22:42:471385 if (transient_entry_index_ == -1)
1386 return;
[email protected]a0e69262009-06-03 19:08:481387 entries_.erase(entries_.begin() + transient_entry_index_);
[email protected]80858db52009-10-15 00:35:181388 if (last_committed_entry_index_ > transient_entry_index_)
1389 last_committed_entry_index_--;
[email protected]cbab76d2008-10-13 22:42:471390 transient_entry_index_ = -1;
[email protected]765b35502008-08-21 00:51:201391}
1392
[email protected]d202a7c2012-01-04 07:53:471393int NavigationControllerImpl::GetEntryIndexWithPageID(
[email protected]7f0005a2009-04-15 03:25:111394 SiteInstance* instance, int32 page_id) const {
[email protected]765b35502008-08-21 00:51:201395 for (int i = static_cast<int>(entries_.size()) - 1; i >= 0; --i) {
[email protected]7f0005a2009-04-15 03:25:111396 if ((entries_[i]->site_instance() == instance) &&
[email protected]36fc0392011-12-25 03:59:511397 (entries_[i]->GetPageID() == page_id))
[email protected]765b35502008-08-21 00:51:201398 return i;
1399 }
1400 return -1;
1401}
[email protected]cbab76d2008-10-13 22:42:471402
[email protected]d202a7c2012-01-04 07:53:471403NavigationEntry* NavigationControllerImpl::GetTransientEntry() const {
[email protected]cbab76d2008-10-13 22:42:471404 if (transient_entry_index_ == -1)
1405 return NULL;
1406 return entries_[transient_entry_index_].get();
1407}
[email protected]e1cd5452010-08-26 18:03:251408
[email protected]d202a7c2012-01-04 07:53:471409void NavigationControllerImpl::InsertEntriesFrom(
1410 const NavigationControllerImpl& source,
[email protected]e1cd5452010-08-26 18:03:251411 int max_index) {
[email protected]a26023822011-12-29 00:23:551412 DCHECK_LE(max_index, source.GetEntryCount());
[email protected]e1cd5452010-08-26 18:03:251413 size_t insert_index = 0;
1414 for (int i = 0; i < max_index; i++) {
1415 // When cloning a tab, copy all entries except interstitial pages
[email protected]ad23a092011-12-28 07:02:041416 if (source.entries_[i].get()->GetPageType() !=
[email protected]66fdbd52011-10-18 17:08:531417 content::PAGE_TYPE_INTERSTITIAL) {
[email protected]e1cd5452010-08-26 18:03:251418 entries_.insert(entries_.begin() + insert_index++,
[email protected]10f417c52011-12-28 21:04:231419 linked_ptr<NavigationEntryImpl>(
1420 new NavigationEntryImpl(*source.entries_[i])));
[email protected]e1cd5452010-08-26 18:03:251421 }
1422 }
1423}