blob: a7b62249574e0966513b5f4b79087243e2152015 [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]adbfb8df2012-02-24 01:19:4315#include "content/browser/in_process_webkit/dom_storage_context_impl.h"
16#include "content/browser/in_process_webkit/session_storage_namespace_impl.h"
[email protected]b69934e2011-10-29 02:51:5217#include "content/browser/renderer_host/render_view_host.h" // Temporary
[email protected]b6583592012-01-25 19:52:3318#include "content/browser/site_instance_impl.h"
[email protected]8bf1048012012-02-08 01:22:1819#include "content/browser/tab_contents/debug_urls.h"
[email protected]cadaec52012-02-08 21:53:1320#include "content/browser/tab_contents/interstitial_page_impl.h"
[email protected]10f417c52011-12-28 21:04:2321#include "content/browser/tab_contents/navigation_entry_impl.h"
[email protected]0dd3a0ab2011-02-18 08:17:4422#include "content/browser/tab_contents/tab_contents.h"
[email protected]0aed2f52011-03-23 18:06:3623#include "content/common/view_messages.h"
[email protected]ccb797302011-12-15 16:55:1124#include "content/public/browser/browser_context.h"
[email protected]d9083482012-01-06 00:38:4625#include "content/public/browser/invalidate_type.h"
[email protected]5b96836f2011-12-22 07:39:0026#include "content/public/browser/navigation_details.h"
[email protected]7f6f44c2011-12-14 13:23:3827#include "content/public/browser/notification_service.h"
[email protected]0d6e9bd2011-10-18 04:29:1628#include "content/public/browser/notification_types.h"
[email protected]7f6f44c2011-12-14 13:23:3829#include "content/public/browser/user_metrics.h"
[email protected]674bc592011-12-20 23:00:4230#include "content/public/browser/web_contents_delegate.h"
[email protected]7f6f44c2011-12-14 13:23:3831#include "content/public/common/content_constants.h"
[email protected]a23de8572009-06-03 02:16:3232#include "net/base/escape.h"
[email protected]31682282010-01-15 18:05:1633#include "net/base/mime_util.h"
[email protected]7f070d42011-03-09 20:25:3234#include "net/base/net_util.h"
[email protected]765b35502008-08-21 00:51:2035#include "webkit/glue/webkit_glue.h"
initial.commit09911bf2008-07-26 23:55:2936
[email protected]cdcb1dee2012-01-04 00:46:2037using content::BrowserContext;
[email protected]adbfb8df2012-02-24 01:19:4338using content::DOMStorageContext;
[email protected]e5d549d2011-12-28 01:29:2039using content::GlobalRequestID;
[email protected]c5eed492012-01-04 17:07:5040using content::NavigationController;
[email protected]10f417c52011-12-28 21:04:2341using content::NavigationEntry;
42using content::NavigationEntryImpl;
[email protected]adbfb8df2012-02-24 01:19:4343using content::SessionStorageNamespace;
[email protected]b6583592012-01-25 19:52:3344using content::SiteInstance;
[email protected]7f6f44c2011-12-14 13:23:3845using content::UserMetricsAction;
[email protected]fbc5e5f92012-01-02 06:08:3246using content::WebContents;
[email protected]7f6f44c2011-12-14 13:23:3847
[email protected]e9ba4472008-09-14 15:42:4348namespace {
49
[email protected]93f230e02011-06-01 14:40:0050const int kInvalidateAll = 0xFFFFFFFF;
[email protected]8030f012009-09-25 18:09:3751
[email protected]e9ba4472008-09-14 15:42:4352// Invoked when entries have been pruned, or removed. For example, if the
53// current entries are [google, digg, yahoo], with the current entry google,
54// and the user types in cnet, then digg and yahoo are pruned.
[email protected]d202a7c2012-01-04 07:53:4755void NotifyPrunedEntries(NavigationControllerImpl* nav_controller,
[email protected]c12bf1a12008-09-17 16:28:4956 bool from_front,
57 int count) {
[email protected]8286f51a2011-05-31 17:39:1358 content::PrunedDetails details;
[email protected]c12bf1a12008-09-17 16:28:4959 details.from_front = from_front;
60 details.count = count;
[email protected]ad50def52011-10-19 23:17:0761 content::NotificationService::current()->Notify(
[email protected]432115822011-07-10 15:52:2762 content::NOTIFICATION_NAV_LIST_PRUNED,
[email protected]c5eed492012-01-04 17:07:5063 content::Source<NavigationController>(nav_controller),
[email protected]6c2381d2011-10-19 02:52:5364 content::Details<content::PrunedDetails>(&details));
[email protected]e9ba4472008-09-14 15:42:4365}
66
67// Ensure the given NavigationEntry has a valid state, so that WebKit does not
68// get confused if we navigate back to it.
[email protected]40bcc302009-03-02 20:50:3969//
[email protected]e9ba4472008-09-14 15:42:4370// An empty state is treated as a new navigation by WebKit, which would mean
71// losing the navigation entries and generating a new navigation entry after
72// this one. We don't want that. To avoid this we create a valid state which
73// WebKit will not treat as a new navigation.
[email protected]10f417c52011-12-28 21:04:2374void SetContentStateIfEmpty(NavigationEntryImpl* entry) {
[email protected]36fc0392011-12-25 03:59:5175 if (entry->GetContentState().empty()) {
76 entry->SetContentState(
77 webkit_glue::CreateHistoryStateForURL(entry->GetURL()));
[email protected]e9ba4472008-09-14 15:42:4378 }
79}
80
81// Configure all the NavigationEntries in entries for restore. This resets
82// the transition type to reload and makes sure the content state isn't empty.
83void ConfigureEntriesForRestore(
[email protected]10f417c52011-12-28 21:04:2384 std::vector<linked_ptr<NavigationEntryImpl> >* entries,
[email protected]5e369672009-11-03 23:48:3085 bool from_last_session) {
[email protected]e9ba4472008-09-14 15:42:4386 for (size_t i = 0; i < entries->size(); ++i) {
87 // Use a transition type of reload so that we don't incorrectly increase
88 // the typed count.
[email protected]022af742011-12-28 18:37:2589 (*entries)[i]->SetTransitionType(content::PAGE_TRANSITION_RELOAD);
[email protected]5e369672009-11-03 23:48:3090 (*entries)[i]->set_restore_type(from_last_session ?
[email protected]10f417c52011-12-28 21:04:2391 NavigationEntryImpl::RESTORE_LAST_SESSION :
92 NavigationEntryImpl::RESTORE_CURRENT_SESSION);
[email protected]e9ba4472008-09-14 15:42:4393 // NOTE(darin): This code is only needed for backwards compat.
94 SetContentStateIfEmpty((*entries)[i].get());
95 }
96}
97
98// See NavigationController::IsURLInPageNavigation for how this works and why.
99bool AreURLsInPageNavigation(const GURL& existing_url, const GURL& new_url) {
[email protected]192d8c5e2010-02-23 07:26:32100 if (existing_url == new_url || !new_url.has_ref()) {
101 // TODO(jcampan): what about when navigating back from a ref URL to the top
102 // non ref URL? Nothing is loaded in that case but we return false here.
103 // The user could also navigate from the ref URL to the non ref URL by
104 // entering the non ref URL in the location bar or through a bookmark, in
105 // which case there would be a load. I am not sure if the non-load/load
106 // scenarios can be differentiated with the TransitionType.
[email protected]e9ba4472008-09-14 15:42:43107 return false;
[email protected]192d8c5e2010-02-23 07:26:32108 }
[email protected]e9ba4472008-09-14 15:42:43109
110 url_canon::Replacements<char> replacements;
111 replacements.ClearRef();
112 return existing_url.ReplaceComponents(replacements) ==
113 new_url.ReplaceComponents(replacements);
114}
115
116} // namespace
117
[email protected]d202a7c2012-01-04 07:53:47118// NavigationControllerImpl ----------------------------------------------------
initial.commit09911bf2008-07-26 23:55:29119
[email protected]9b51970d2011-12-09 23:10:23120const size_t kMaxEntryCountForTestingNotSet = -1;
121
[email protected]765b35502008-08-21 00:51:20122// static
[email protected]d202a7c2012-01-04 07:53:47123size_t NavigationControllerImpl::max_entry_count_for_testing_ =
[email protected]9b51970d2011-12-09 23:10:23124 kMaxEntryCountForTestingNotSet;
[email protected]765b35502008-08-21 00:51:20125
[email protected]cdcb1dee2012-01-04 00:46:20126 // Should Reload check for post data? The default is true, but is set to false
127// when testing.
128static bool g_check_for_repost = true;
initial.commit09911bf2008-07-26 23:55:29129
[email protected]cdcb1dee2012-01-04 00:46:20130namespace content {
[email protected]71fde352011-12-29 03:29:56131// static
[email protected]cdcb1dee2012-01-04 00:46:20132NavigationEntry* NavigationController::CreateNavigationEntry(
[email protected]71fde352011-12-29 03:29:56133 const GURL& url,
[email protected]cdcb1dee2012-01-04 00:46:20134 const Referrer& referrer,
135 PageTransition transition,
[email protected]71fde352011-12-29 03:29:56136 bool is_renderer_initiated,
137 const std::string& extra_headers,
[email protected]cdcb1dee2012-01-04 00:46:20138 BrowserContext* browser_context) {
[email protected]71fde352011-12-29 03:29:56139 // Allow the browser URL handler to rewrite the URL. This will, for example,
140 // remove "view-source:" from the beginning of the URL to get the URL that
141 // will actually be loaded. This real URL won't be shown to the user, just
142 // used internally.
143 GURL loaded_url(url);
144 bool reverse_on_redirect = false;
145 BrowserURLHandler::GetInstance()->RewriteURLIfNecessary(
146 &loaded_url, browser_context, &reverse_on_redirect);
147
148 NavigationEntryImpl* entry = new NavigationEntryImpl(
149 NULL, // The site instance for tabs is sent on navigation
150 // (TabContents::GetSiteInstance).
151 -1,
152 loaded_url,
153 referrer,
154 string16(),
155 transition,
156 is_renderer_initiated);
157 entry->SetVirtualURL(url);
158 entry->set_user_typed_url(url);
159 entry->set_update_virtual_url_with_url(reverse_on_redirect);
160 entry->set_extra_headers(extra_headers);
161 return entry;
162}
163
[email protected]cdcb1dee2012-01-04 00:46:20164// static
165void NavigationController::DisablePromptOnRepost() {
166 g_check_for_repost = false;
167}
168
169} // namespace content
170
[email protected]d202a7c2012-01-04 07:53:47171NavigationControllerImpl::NavigationControllerImpl(
[email protected]6ee12c42010-09-14 09:36:07172 TabContents* contents,
[email protected]cdcb1dee2012-01-04 00:46:20173 BrowserContext* browser_context,
[email protected]adbfb8df2012-02-24 01:19:43174 SessionStorageNamespaceImpl* session_storage_namespace)
[email protected]3d7474ff2011-07-27 17:47:37175 : browser_context_(browser_context),
[email protected]765b35502008-08-21 00:51:20176 pending_entry_(NULL),
177 last_committed_entry_index_(-1),
178 pending_entry_index_(-1),
[email protected]cbab76d2008-10-13 22:42:47179 transient_entry_index_(-1),
[email protected]9423d9412009-04-14 22:13:55180 tab_contents_(contents),
initial.commit09911bf2008-07-26 23:55:29181 max_restored_page_id_(-1),
[email protected]5d063842009-05-15 04:08:24182 ALLOW_THIS_IN_INITIALIZER_LIST(ssl_manager_(this)),
[email protected]38b8f4e2009-09-24 19:44:57183 needs_reload_(false),
[email protected]6ee12c42010-09-14 09:36:07184 session_storage_namespace_(session_storage_namespace),
[email protected]106a0812010-03-18 00:15:12185 pending_reload_(NO_RELOAD) {
[email protected]3d7474ff2011-07-27 17:47:37186 DCHECK(browser_context_);
[email protected]228d06592011-04-01 20:38:59187 if (!session_storage_namespace_) {
[email protected]adbfb8df2012-02-24 01:19:43188 session_storage_namespace_ = new SessionStorageNamespaceImpl(
189 static_cast<DOMStorageContextImpl*>(
190 DOMStorageContext::GetForBrowserContext(browser_context_)));
[email protected]228d06592011-04-01 20:38:59191 }
initial.commit09911bf2008-07-26 23:55:29192}
193
[email protected]d202a7c2012-01-04 07:53:47194NavigationControllerImpl::~NavigationControllerImpl() {
[email protected]cbab76d2008-10-13 22:42:47195 DiscardNonCommittedEntriesInternal();
[email protected]c0993872008-08-21 19:59:44196
[email protected]ad50def52011-10-19 23:17:07197 content::NotificationService::current()->Notify(
[email protected]432115822011-07-10 15:52:27198 content::NOTIFICATION_TAB_CLOSED,
[email protected]c5eed492012-01-04 17:07:50199 content::Source<NavigationController>(this),
[email protected]ad50def52011-10-19 23:17:07200 content::NotificationService::NoDetails());
initial.commit09911bf2008-07-26 23:55:29201}
202
[email protected]d202a7c2012-01-04 07:53:47203WebContents* NavigationControllerImpl::GetWebContents() const {
[email protected]fbc5e5f92012-01-02 06:08:32204 return tab_contents_;
205}
206
[email protected]d202a7c2012-01-04 07:53:47207BrowserContext* NavigationControllerImpl::GetBrowserContext() const {
[email protected]a26023822011-12-29 00:23:55208 return browser_context_;
209}
210
[email protected]d202a7c2012-01-04 07:53:47211void NavigationControllerImpl::SetBrowserContext(
212 BrowserContext* browser_context) {
[email protected]cdcb1dee2012-01-04 00:46:20213 browser_context_ = browser_context;
214}
215
[email protected]d202a7c2012-01-04 07:53:47216void NavigationControllerImpl::Restore(
[email protected]5e369672009-11-03 23:48:30217 int selected_navigation,
[email protected]03838e22011-06-06 15:27:14218 bool from_last_session,
[email protected]10f417c52011-12-28 21:04:23219 std::vector<NavigationEntry*>* entries) {
[email protected]ce3fa3c2009-04-20 19:55:57220 // Verify that this controller is unused and that the input is valid.
[email protected]a26023822011-12-29 00:23:55221 DCHECK(GetEntryCount() == 0 && !GetPendingEntry());
[email protected]ce3fa3c2009-04-20 19:55:57222 DCHECK(selected_navigation >= 0 &&
[email protected]03838e22011-06-06 15:27:14223 selected_navigation < static_cast<int>(entries->size()));
[email protected]ce3fa3c2009-04-20 19:55:57224
[email protected]ce3fa3c2009-04-20 19:55:57225 needs_reload_ = true;
[email protected]ad23a092011-12-28 07:02:04226 for (size_t i = 0; i < entries->size(); ++i) {
[email protected]10f417c52011-12-28 21:04:23227 NavigationEntryImpl* entry =
228 NavigationEntryImpl::FromNavigationEntry((*entries)[i]);
229 entries_.push_back(linked_ptr<NavigationEntryImpl>(entry));
[email protected]ad23a092011-12-28 07:02:04230 }
[email protected]03838e22011-06-06 15:27:14231 entries->clear();
[email protected]ce3fa3c2009-04-20 19:55:57232
233 // And finish the restore.
[email protected]5e369672009-11-03 23:48:30234 FinishRestore(selected_navigation, from_last_session);
[email protected]ce3fa3c2009-04-20 19:55:57235}
236
[email protected]d202a7c2012-01-04 07:53:47237void NavigationControllerImpl::Reload(bool check_for_repost) {
[email protected]1ccb3568d2010-02-19 10:51:16238 ReloadInternal(check_for_repost, RELOAD);
239}
[email protected]d202a7c2012-01-04 07:53:47240void NavigationControllerImpl::ReloadIgnoringCache(bool check_for_repost) {
[email protected]1ccb3568d2010-02-19 10:51:16241 ReloadInternal(check_for_repost, RELOAD_IGNORING_CACHE);
242}
243
[email protected]d202a7c2012-01-04 07:53:47244void NavigationControllerImpl::ReloadInternal(bool check_for_repost,
245 ReloadType reload_type) {
[email protected]cbab76d2008-10-13 22:42:47246 // Reloading a transient entry does nothing.
247 if (transient_entry_index_ != -1)
248 return;
249
250 DiscardNonCommittedEntriesInternal();
initial.commit09911bf2008-07-26 23:55:29251 int current_index = GetCurrentEntryIndex();
[email protected]106a0812010-03-18 00:15:12252 // If we are no where, then we can't reload. TODO(darin): We should add a
253 // CanReload method.
254 if (current_index == -1) {
255 return;
256 }
257
[email protected]cdcb1dee2012-01-04 00:46:20258 if (g_check_for_repost && check_for_repost &&
[email protected]36fc0392011-12-25 03:59:51259 GetEntryAtIndex(current_index)->GetHasPostData()) {
[email protected]a3a1d142008-12-19 00:42:30260 // The user is asking to reload a page with POST data. Prompt to make sure
[email protected]b5bb35f2009-02-05 20:17:07261 // they really want to do this. If they do, the dialog will call us back
262 // with check_for_repost = false.
[email protected]ad50def52011-10-19 23:17:07263 content::NotificationService::current()->Notify(
[email protected]432115822011-07-10 15:52:27264 content::NOTIFICATION_REPOST_WARNING_SHOWN,
[email protected]c5eed492012-01-04 17:07:50265 content::Source<NavigationController>(this),
[email protected]ad50def52011-10-19 23:17:07266 content::NotificationService::NoDetails());
[email protected]965bb092010-04-09 11:59:02267
[email protected]106a0812010-03-18 00:15:12268 pending_reload_ = reload_type;
[email protected]9423d9412009-04-14 22:13:55269 tab_contents_->Activate();
[email protected]6934a702011-12-20 00:04:51270 tab_contents_->GetDelegate()->ShowRepostFormWarningDialog(tab_contents_);
initial.commit09911bf2008-07-26 23:55:29271 } else {
[email protected]cbab76d2008-10-13 22:42:47272 DiscardNonCommittedEntriesInternal();
[email protected]765b35502008-08-21 00:51:20273
[email protected]bcd904482012-02-01 01:54:22274 NavigationEntryImpl* entry = entries_[current_index].get();
275 SiteInstanceImpl* site_instance = entry->site_instance();
276 DCHECK(site_instance);
[email protected]c3b3d952012-01-31 12:52:26277
[email protected]bcd904482012-02-01 01:54:22278 // If we are reloading an entry that no longer belongs to the current
279 // site instance (for example, refreshing a page for just installed app),
280 // the reload must happen in a new process.
281 // The new entry must have a new page_id and site instance, so it behaves
282 // as new navigation (which happens to clear forward history).
283 if (site_instance->HasWrongProcessForURL(entry->GetURL())) {
284 // Create a navigation entry that resembles the current one, but do not
285 // copy page id, site instance, and content state.
286 NavigationEntryImpl* nav_entry = NavigationEntryImpl::FromNavigationEntry(
287 CreateNavigationEntry(
288 entry->GetURL(), entry->GetReferrer(), entry->GetTransitionType(),
289 false, entry->extra_headers(), browser_context_));
[email protected]c3b3d952012-01-31 12:52:26290
[email protected]11535962012-02-09 21:02:10291 // Mark the reload type as NO_RELOAD, so navigation will not be considered
292 // a reload in the renderer.
293 reload_type = NavigationController::NO_RELOAD;
294
[email protected]bcd904482012-02-01 01:54:22295 nav_entry->set_is_cross_site_reload(true);
296 pending_entry_ = nav_entry;
297 } else {
298 pending_entry_index_ = current_index;
299
300 // The title of the page being reloaded might have been removed in the
301 // meanwhile, so we need to revert to the default title upon reload and
302 // invalidate the previously cached title (SetTitle will do both).
303 // See Chromium issue 96041.
304 entries_[pending_entry_index_]->SetTitle(string16());
305
306 entries_[pending_entry_index_]->SetTransitionType(
307 content::PAGE_TRANSITION_RELOAD);
308 }
309
[email protected]1ccb3568d2010-02-19 10:51:16310 NavigateToPendingEntry(reload_type);
initial.commit09911bf2008-07-26 23:55:29311 }
312}
313
[email protected]d202a7c2012-01-04 07:53:47314void NavigationControllerImpl::CancelPendingReload() {
[email protected]106a0812010-03-18 00:15:12315 DCHECK(pending_reload_ != NO_RELOAD);
316 pending_reload_ = NO_RELOAD;
317}
318
[email protected]d202a7c2012-01-04 07:53:47319void NavigationControllerImpl::ContinuePendingReload() {
[email protected]106a0812010-03-18 00:15:12320 if (pending_reload_ == NO_RELOAD) {
321 NOTREACHED();
322 } else {
323 ReloadInternal(false, pending_reload_);
[email protected]965bb092010-04-09 11:59:02324 pending_reload_ = NO_RELOAD;
[email protected]106a0812010-03-18 00:15:12325 }
326}
327
[email protected]d202a7c2012-01-04 07:53:47328bool NavigationControllerImpl::IsInitialNavigation() {
[email protected]c70f9b82010-04-21 07:31:11329 return last_document_loaded_.is_null();
330}
331
[email protected]d202a7c2012-01-04 07:53:47332NavigationEntryImpl* NavigationControllerImpl::GetEntryWithPageID(
[email protected]b6583592012-01-25 19:52:33333 SiteInstance* instance, int32 page_id) const {
[email protected]7f0005a2009-04-15 03:25:11334 int index = GetEntryIndexWithPageID(instance, page_id);
[email protected]765b35502008-08-21 00:51:20335 return (index != -1) ? entries_[index].get() : NULL;
336}
337
[email protected]d202a7c2012-01-04 07:53:47338void NavigationControllerImpl::LoadEntry(NavigationEntryImpl* entry) {
[email protected]419a0572011-04-18 22:21:46339 // Don't navigate to URLs disabled by policy. This prevents showing the URL
340 // on the Omnibar when it is also going to be blocked by
341 // ChildProcessSecurityPolicy::CanRequestURL.
[email protected]b9535422012-02-09 01:47:59342 ChildProcessSecurityPolicyImpl* policy =
343 ChildProcessSecurityPolicyImpl::GetInstance();
[email protected]36fc0392011-12-25 03:59:51344 if (policy->IsDisabledScheme(entry->GetURL().scheme()) ||
345 policy->IsDisabledScheme(entry->GetVirtualURL().scheme())) {
[email protected]419a0572011-04-18 22:21:46346 VLOG(1) << "URL not loaded because the scheme is blocked by policy: "
[email protected]36fc0392011-12-25 03:59:51347 << entry->GetURL();
[email protected]419a0572011-04-18 22:21:46348 delete entry;
349 return;
350 }
351
[email protected]765b35502008-08-21 00:51:20352 // When navigating to a new page, we don't know for sure if we will actually
353 // end up leaving the current page. The new page load could for example
354 // result in a download or a 'no content' response (e.g., a mailto: URL).
[email protected]cbab76d2008-10-13 22:42:47355 DiscardNonCommittedEntriesInternal();
[email protected]765b35502008-08-21 00:51:20356 pending_entry_ = entry;
[email protected]ad50def52011-10-19 23:17:07357 content::NotificationService::current()->Notify(
[email protected]432115822011-07-10 15:52:27358 content::NOTIFICATION_NAV_ENTRY_PENDING,
[email protected]c5eed492012-01-04 17:07:50359 content::Source<NavigationController>(this),
[email protected]10f417c52011-12-28 21:04:23360 content::Details<NavigationEntry>(entry));
[email protected]1ccb3568d2010-02-19 10:51:16361 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20362}
363
[email protected]d202a7c2012-01-04 07:53:47364NavigationEntry* NavigationControllerImpl::GetActiveEntry() const {
[email protected]cbab76d2008-10-13 22:42:47365 if (transient_entry_index_ != -1)
366 return entries_[transient_entry_index_].get();
367 if (pending_entry_)
368 return pending_entry_;
369 return GetLastCommittedEntry();
[email protected]765b35502008-08-21 00:51:20370}
371
[email protected]d202a7c2012-01-04 07:53:47372NavigationEntry* NavigationControllerImpl::GetVisibleEntry() const {
[email protected]867e1f92011-08-30 19:01:19373 if (transient_entry_index_ != -1)
374 return entries_[transient_entry_index_].get();
[email protected]e47ae9472011-10-13 19:48:34375 // Only return the pending_entry for new (non-history), browser-initiated
376 // navigations, in order to prevent URL spoof attacks.
377 // Ideally we would also show the pending entry's URL for new renderer-
378 // initiated navigations with no last committed entry (e.g., a link opening
379 // in a new tab), but an attacker can insert content into the about:blank
380 // page while the pending URL loads in that case.
381 if (pending_entry_ &&
[email protected]36fc0392011-12-25 03:59:51382 pending_entry_->GetPageID() == -1 &&
[email protected]e47ae9472011-10-13 19:48:34383 !pending_entry_->is_renderer_initiated())
[email protected]867e1f92011-08-30 19:01:19384 return pending_entry_;
385 return GetLastCommittedEntry();
386}
387
[email protected]d202a7c2012-01-04 07:53:47388int NavigationControllerImpl::GetCurrentEntryIndex() const {
[email protected]cbab76d2008-10-13 22:42:47389 if (transient_entry_index_ != -1)
390 return transient_entry_index_;
[email protected]765b35502008-08-21 00:51:20391 if (pending_entry_index_ != -1)
392 return pending_entry_index_;
393 return last_committed_entry_index_;
394}
395
[email protected]d202a7c2012-01-04 07:53:47396NavigationEntry* NavigationControllerImpl::GetLastCommittedEntry() const {
[email protected]765b35502008-08-21 00:51:20397 if (last_committed_entry_index_ == -1)
398 return NULL;
399 return entries_[last_committed_entry_index_].get();
400}
401
[email protected]d202a7c2012-01-04 07:53:47402bool NavigationControllerImpl::CanViewSource() const {
[email protected]31682282010-01-15 18:05:16403 bool is_supported_mime_type = net::IsSupportedNonImageMimeType(
[email protected]0bfbf882011-12-22 18:19:27404 tab_contents_->GetContentsMimeType().c_str());
[email protected]10f417c52011-12-28 21:04:23405 NavigationEntry* active_entry = GetActiveEntry();
[email protected]31682282010-01-15 18:05:16406 return active_entry && !active_entry->IsViewSourceMode() &&
[email protected]0bfbf882011-12-22 18:19:27407 is_supported_mime_type && !tab_contents_->GetInterstitialPage();
[email protected]31682282010-01-15 18:05:16408}
409
[email protected]d202a7c2012-01-04 07:53:47410int NavigationControllerImpl::GetLastCommittedEntryIndex() const {
[email protected]a26023822011-12-29 00:23:55411 return last_committed_entry_index_;
412}
413
[email protected]d202a7c2012-01-04 07:53:47414int NavigationControllerImpl::GetEntryCount() const {
[email protected]a26023822011-12-29 00:23:55415 return static_cast<int>(entries_.size());
416}
417
[email protected]d202a7c2012-01-04 07:53:47418NavigationEntry* NavigationControllerImpl::GetEntryAtIndex(
[email protected]022af742011-12-28 18:37:25419 int index) const {
420 return entries_.at(index).get();
421}
422
[email protected]d202a7c2012-01-04 07:53:47423NavigationEntry* NavigationControllerImpl::GetEntryAtOffset(
[email protected]022af742011-12-28 18:37:25424 int offset) const {
[email protected]cbab76d2008-10-13 22:42:47425 int index = (transient_entry_index_ != -1) ?
426 transient_entry_index_ + offset :
427 last_committed_entry_index_ + offset;
[email protected]a26023822011-12-29 00:23:55428 if (index < 0 || index >= GetEntryCount())
[email protected]765b35502008-08-21 00:51:20429 return NULL;
430
431 return entries_[index].get();
432}
433
[email protected]d202a7c2012-01-04 07:53:47434bool NavigationControllerImpl::CanGoBack() const {
[email protected]765b35502008-08-21 00:51:20435 return entries_.size() > 1 && GetCurrentEntryIndex() > 0;
436}
437
[email protected]d202a7c2012-01-04 07:53:47438bool NavigationControllerImpl::CanGoForward() const {
[email protected]765b35502008-08-21 00:51:20439 int index = GetCurrentEntryIndex();
440 return index >= 0 && index < (static_cast<int>(entries_.size()) - 1);
441}
442
[email protected]d202a7c2012-01-04 07:53:47443void NavigationControllerImpl::GoBack() {
[email protected]765b35502008-08-21 00:51:20444 if (!CanGoBack()) {
445 NOTREACHED();
446 return;
447 }
448
449 // Base the navigation on where we are now...
450 int current_index = GetCurrentEntryIndex();
451
[email protected]cbab76d2008-10-13 22:42:47452 DiscardNonCommittedEntries();
[email protected]765b35502008-08-21 00:51:20453
454 pending_entry_index_ = current_index - 1;
[email protected]022af742011-12-28 18:37:25455 entries_[pending_entry_index_]->SetTransitionType(
[email protected]2905f742011-10-13 03:51:58456 content::PageTransitionFromInt(
[email protected]36fc0392011-12-25 03:59:51457 entries_[pending_entry_index_]->GetTransitionType() |
[email protected]2905f742011-10-13 03:51:58458 content::PAGE_TRANSITION_FORWARD_BACK));
[email protected]1ccb3568d2010-02-19 10:51:16459 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20460}
461
[email protected]d202a7c2012-01-04 07:53:47462void NavigationControllerImpl::GoForward() {
[email protected]765b35502008-08-21 00:51:20463 if (!CanGoForward()) {
464 NOTREACHED();
465 return;
466 }
467
[email protected]cbab76d2008-10-13 22:42:47468 bool transient = (transient_entry_index_ != -1);
469
[email protected]765b35502008-08-21 00:51:20470 // Base the navigation on where we are now...
471 int current_index = GetCurrentEntryIndex();
472
[email protected]cbab76d2008-10-13 22:42:47473 DiscardNonCommittedEntries();
[email protected]765b35502008-08-21 00:51:20474
[email protected]cbab76d2008-10-13 22:42:47475 pending_entry_index_ = current_index;
476 // If there was a transient entry, we removed it making the current index
477 // the next page.
478 if (!transient)
479 pending_entry_index_++;
480
[email protected]022af742011-12-28 18:37:25481 entries_[pending_entry_index_]->SetTransitionType(
[email protected]2905f742011-10-13 03:51:58482 content::PageTransitionFromInt(
[email protected]36fc0392011-12-25 03:59:51483 entries_[pending_entry_index_]->GetTransitionType() |
[email protected]2905f742011-10-13 03:51:58484 content::PAGE_TRANSITION_FORWARD_BACK));
[email protected]1ccb3568d2010-02-19 10:51:16485 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20486}
487
[email protected]d202a7c2012-01-04 07:53:47488void NavigationControllerImpl::GoToIndex(int index) {
[email protected]765b35502008-08-21 00:51:20489 if (index < 0 || index >= static_cast<int>(entries_.size())) {
490 NOTREACHED();
491 return;
492 }
493
[email protected]cbab76d2008-10-13 22:42:47494 if (transient_entry_index_ != -1) {
495 if (index == transient_entry_index_) {
496 // Nothing to do when navigating to the transient.
497 return;
498 }
499 if (index > transient_entry_index_) {
500 // Removing the transient is goint to shift all entries by 1.
501 index--;
502 }
503 }
504
505 DiscardNonCommittedEntries();
[email protected]765b35502008-08-21 00:51:20506
507 pending_entry_index_ = index;
[email protected]022af742011-12-28 18:37:25508 entries_[pending_entry_index_]->SetTransitionType(
[email protected]2905f742011-10-13 03:51:58509 content::PageTransitionFromInt(
[email protected]36fc0392011-12-25 03:59:51510 entries_[pending_entry_index_]->GetTransitionType() |
[email protected]2905f742011-10-13 03:51:58511 content::PAGE_TRANSITION_FORWARD_BACK));
[email protected]1ccb3568d2010-02-19 10:51:16512 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20513}
514
[email protected]d202a7c2012-01-04 07:53:47515void NavigationControllerImpl::GoToOffset(int offset) {
[email protected]cbab76d2008-10-13 22:42:47516 int index = (transient_entry_index_ != -1) ?
517 transient_entry_index_ + offset :
518 last_committed_entry_index_ + offset;
[email protected]a26023822011-12-29 00:23:55519 if (index < 0 || index >= GetEntryCount())
[email protected]765b35502008-08-21 00:51:20520 return;
521
522 GoToIndex(index);
523}
524
[email protected]d202a7c2012-01-04 07:53:47525void NavigationControllerImpl::RemoveEntryAtIndex(int index) {
[email protected]6a13a6c2011-12-20 21:47:12526 if (index == last_committed_entry_index_)
527 return;
528
[email protected]43032342011-03-21 14:10:31529 RemoveEntryAtIndexInternal(index);
[email protected]cbab76d2008-10-13 22:42:47530}
531
[email protected]d202a7c2012-01-04 07:53:47532void NavigationControllerImpl::UpdateVirtualURLToURL(
[email protected]10f417c52011-12-28 21:04:23533 NavigationEntryImpl* entry, const GURL& new_url) {
[email protected]38178a42009-12-17 18:58:32534 GURL new_virtual_url(new_url);
[email protected]f1eb87a2011-05-06 17:49:41535 if (BrowserURLHandler::GetInstance()->ReverseURLRewrite(
[email protected]36fc0392011-12-25 03:59:51536 &new_virtual_url, entry->GetVirtualURL(), browser_context_)) {
537 entry->SetVirtualURL(new_virtual_url);
[email protected]38178a42009-12-17 18:58:32538 }
539}
540
[email protected]d202a7c2012-01-04 07:53:47541void NavigationControllerImpl::AddTransientEntry(NavigationEntryImpl* entry) {
[email protected]cbab76d2008-10-13 22:42:47542 // Discard any current transient entry, we can only have one at a time.
543 int index = 0;
544 if (last_committed_entry_index_ != -1)
545 index = last_committed_entry_index_ + 1;
546 DiscardTransientEntry();
[email protected]10f417c52011-12-28 21:04:23547 entries_.insert(
548 entries_.begin() + index, linked_ptr<NavigationEntryImpl>(entry));
[email protected]e1cd5452010-08-26 18:03:25549 transient_entry_index_ = index;
[email protected]93f230e02011-06-01 14:40:00550 tab_contents_->NotifyNavigationStateChanged(kInvalidateAll);
[email protected]cbab76d2008-10-13 22:42:47551}
552
[email protected]d202a7c2012-01-04 07:53:47553void NavigationControllerImpl::TransferURL(
[email protected]4ad5d77d2011-12-03 02:00:48554 const GURL& url,
[email protected]95dacd02011-12-05 10:35:26555 const content::Referrer& referrer,
[email protected]4ad5d77d2011-12-03 02:00:48556 content::PageTransition transition,
557 const std::string& extra_headers,
558 const GlobalRequestID& transferred_global_request_id,
559 bool is_renderer_initiated) {
560 // The user initiated a load, we don't need to reload anymore.
561 needs_reload_ = false;
562
[email protected]71fde352011-12-29 03:29:56563 NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
564 CreateNavigationEntry(
565 url, referrer, transition, is_renderer_initiated, extra_headers,
566 browser_context_));
[email protected]4ad5d77d2011-12-03 02:00:48567 entry->set_transferred_global_request_id(transferred_global_request_id);
568
569 LoadEntry(entry);
570}
571
[email protected]d202a7c2012-01-04 07:53:47572void NavigationControllerImpl::LoadURL(
[email protected]6c6b02d2011-09-02 03:36:47573 const GURL& url,
[email protected]95dacd02011-12-05 10:35:26574 const content::Referrer& referrer,
[email protected]2905f742011-10-13 03:51:58575 content::PageTransition transition,
[email protected]6c6b02d2011-09-02 03:36:47576 const std::string& extra_headers) {
[email protected]8bf1048012012-02-08 01:22:18577 if (content::HandleDebugURL(url, transition))
578 return;
579
initial.commit09911bf2008-07-26 23:55:29580 // The user initiated a load, we don't need to reload anymore.
581 needs_reload_ = false;
582
[email protected]71fde352011-12-29 03:29:56583 NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
584 CreateNavigationEntry(
585 url, referrer, transition, false, extra_headers, browser_context_));
[email protected]e47ae9472011-10-13 19:48:34586
587 LoadEntry(entry);
588}
589
[email protected]d202a7c2012-01-04 07:53:47590void NavigationControllerImpl::LoadURLFromRenderer(
[email protected]e47ae9472011-10-13 19:48:34591 const GURL& url,
[email protected]95dacd02011-12-05 10:35:26592 const content::Referrer& referrer,
[email protected]e47ae9472011-10-13 19:48:34593 content::PageTransition transition,
594 const std::string& extra_headers) {
595 // The user initiated a load, we don't need to reload anymore.
596 needs_reload_ = false;
597
[email protected]71fde352011-12-29 03:29:56598 NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
599 CreateNavigationEntry(
600 url, referrer, transition, true, extra_headers, browser_context_));
initial.commit09911bf2008-07-26 23:55:29601
602 LoadEntry(entry);
603}
604
[email protected]d202a7c2012-01-04 07:53:47605void NavigationControllerImpl::DocumentLoadedInFrame() {
[email protected]09b8f82f2009-06-16 20:22:11606 last_document_loaded_ = base::TimeTicks::Now();
607}
608
[email protected]d202a7c2012-01-04 07:53:47609bool NavigationControllerImpl::RendererDidNavigate(
[email protected]e9ba4472008-09-14 15:42:43610 const ViewHostMsg_FrameNavigate_Params& params,
[email protected]8286f51a2011-05-31 17:39:13611 content::LoadCommittedDetails* details) {
[email protected]4bf3522c2010-08-19 21:00:20612
[email protected]0e8db942008-09-24 21:21:48613 // Save the previous state before we clobber it.
614 if (GetLastCommittedEntry()) {
[email protected]36fc0392011-12-25 03:59:51615 details->previous_url = GetLastCommittedEntry()->GetURL();
[email protected]a26023822011-12-29 00:23:55616 details->previous_entry_index = GetLastCommittedEntryIndex();
[email protected]0e8db942008-09-24 21:21:48617 } else {
618 details->previous_url = GURL();
619 details->previous_entry_index = -1;
620 }
[email protected]ecd9d8702008-08-28 22:10:17621
[email protected]77362eb2011-08-01 17:18:38622 // If we have a pending entry at this point, it should have a SiteInstance.
623 // Restored entries start out with a null SiteInstance, but we should have
624 // assigned one in NavigateToPendingEntry.
625 DCHECK(pending_entry_index_ == -1 || pending_entry_->site_instance());
[email protected]e9ba4472008-09-14 15:42:43626
[email protected]bcd904482012-02-01 01:54:22627 // If we are doing a cross-site reload, we need to replace the existing
628 // navigation entry, not add another entry to the history. This has the side
629 // effect of removing forward browsing history, if such existed.
630 if (pending_entry_ != NULL) {
631 details->did_replace_entry = pending_entry_->is_cross_site_reload();
632 }
633
[email protected]192d8c5e2010-02-23 07:26:32634 // is_in_page must be computed before the entry gets committed.
635 details->is_in_page = IsURLInPageNavigation(params.url);
636
[email protected]e9ba4472008-09-14 15:42:43637 // Do navigation-type specific actions. These will make and commit an entry.
[email protected]0e8db942008-09-24 21:21:48638 details->type = ClassifyNavigation(params);
[email protected]4bf3522c2010-08-19 21:00:20639
[email protected]0e8db942008-09-24 21:21:48640 switch (details->type) {
[email protected]610cbb82011-10-18 16:35:08641 case content::NAVIGATION_TYPE_NEW_PAGE:
[email protected]befd8d822009-07-01 04:51:47642 RendererDidNavigateToNewPage(params, &(details->did_replace_entry));
[email protected]e9ba4472008-09-14 15:42:43643 break;
[email protected]610cbb82011-10-18 16:35:08644 case content::NAVIGATION_TYPE_EXISTING_PAGE:
[email protected]e9ba4472008-09-14 15:42:43645 RendererDidNavigateToExistingPage(params);
646 break;
[email protected]610cbb82011-10-18 16:35:08647 case content::NAVIGATION_TYPE_SAME_PAGE:
[email protected]e9ba4472008-09-14 15:42:43648 RendererDidNavigateToSamePage(params);
649 break;
[email protected]610cbb82011-10-18 16:35:08650 case content::NAVIGATION_TYPE_IN_PAGE:
[email protected]befd8d822009-07-01 04:51:47651 RendererDidNavigateInPage(params, &(details->did_replace_entry));
[email protected]e9ba4472008-09-14 15:42:43652 break;
[email protected]610cbb82011-10-18 16:35:08653 case content::NAVIGATION_TYPE_NEW_SUBFRAME:
[email protected]e9ba4472008-09-14 15:42:43654 RendererDidNavigateNewSubframe(params);
655 break;
[email protected]610cbb82011-10-18 16:35:08656 case content::NAVIGATION_TYPE_AUTO_SUBFRAME:
[email protected]e9ba4472008-09-14 15:42:43657 if (!RendererDidNavigateAutoSubframe(params))
658 return false;
659 break;
[email protected]610cbb82011-10-18 16:35:08660 case content::NAVIGATION_TYPE_NAV_IGNORE:
[email protected]20d1c992011-04-12 21:17:49661 // If a pending navigation was in progress, this canceled it. We should
662 // discard it and make sure it is removed from the URL bar. After that,
663 // there is nothing we can do with this navigation, so we just return to
[email protected]e9ba4472008-09-14 15:42:43664 // the caller that nothing has happened.
[email protected]20d1c992011-04-12 21:17:49665 if (pending_entry_) {
666 DiscardNonCommittedEntries();
[email protected]93f230e02011-06-01 14:40:00667 tab_contents_->NotifyNavigationStateChanged(
[email protected]d9083482012-01-06 00:38:46668 content::INVALIDATE_TYPE_URL);
[email protected]20d1c992011-04-12 21:17:49669 }
[email protected]e9ba4472008-09-14 15:42:43670 return false;
671 default:
672 NOTREACHED();
[email protected]765b35502008-08-21 00:51:20673 }
674
[email protected]e9ba4472008-09-14 15:42:43675 // All committed entries should have nonempty content state so WebKit doesn't
676 // get confused when we go back to them (see the function for details).
[email protected]0f38dc4552011-02-25 11:24:00677 DCHECK(!params.content_state.empty());
[email protected]10f417c52011-12-28 21:04:23678 NavigationEntryImpl* active_entry =
679 NavigationEntryImpl::FromNavigationEntry(GetActiveEntry());
[email protected]36fc0392011-12-25 03:59:51680 active_entry->SetContentState(params.content_state);
[email protected]765b35502008-08-21 00:51:20681
[email protected]e47ae9472011-10-13 19:48:34682 // Once committed, we do not need to track if the entry was initiated by
683 // the renderer.
684 active_entry->set_is_renderer_initiated(false);
685
[email protected]49bd30e62011-03-22 20:12:59686 // The active entry's SiteInstance should match our SiteInstance.
687 DCHECK(active_entry->site_instance() == tab_contents_->GetSiteInstance());
688
[email protected]e9ba4472008-09-14 15:42:43689 // Now prep the rest of the details for the notification and broadcast.
[email protected]0f38dc4552011-02-25 11:24:00690 details->entry = active_entry;
[email protected]2905f742011-10-13 03:51:58691 details->is_main_frame =
692 content::PageTransitionIsMainFrame(params.transition);
[email protected]f072d2ce2008-09-17 17:16:24693 details->serialized_security_info = params.security_info;
[email protected]2e39d2e2009-02-19 18:41:31694 details->http_status_code = params.http_status_code;
[email protected]93f230e02011-06-01 14:40:00695 NotifyNavigationEntryCommitted(details);
initial.commit09911bf2008-07-26 23:55:29696
[email protected]e9ba4472008-09-14 15:42:43697 return true;
initial.commit09911bf2008-07-26 23:55:29698}
699
[email protected]d202a7c2012-01-04 07:53:47700content::NavigationType NavigationControllerImpl::ClassifyNavigation(
[email protected]e9ba4472008-09-14 15:42:43701 const ViewHostMsg_FrameNavigate_Params& params) const {
[email protected]e9ba4472008-09-14 15:42:43702 if (params.page_id == -1) {
[email protected]eef9de32009-09-23 17:19:46703 // The renderer generates the page IDs, and so if it gives us the invalid
704 // page ID (-1) we know it didn't actually navigate. This happens in a few
705 // cases:
706 //
707 // - If a page makes a popup navigated to about blank, and then writes
708 // stuff like a subframe navigated to a real page. We'll get the commit
709 // for the subframe, but there won't be any commit for the outer page.
710 //
711 // - We were also getting these for failed loads (for example, bug 21849).
712 // The guess is that we get a "load commit" for the alternate error page,
713 // but that doesn't affect the page ID, so we get the "old" one, which
714 // could be invalid. This can also happen for a cross-site transition
715 // that causes us to swap processes. Then the error page load will be in
716 // a new process with no page IDs ever assigned (and hence a -1 value),
717 // yet the navigation controller still might have previous pages in its
718 // list.
719 //
720 // In these cases, there's nothing we can do with them, so ignore.
[email protected]610cbb82011-10-18 16:35:08721 return content::NAVIGATION_TYPE_NAV_IGNORE;
[email protected]e9ba4472008-09-14 15:42:43722 }
723
[email protected]9423d9412009-04-14 22:13:55724 if (params.page_id > tab_contents_->GetMaxPageID()) {
[email protected]e9ba4472008-09-14 15:42:43725 // Greater page IDs than we've ever seen before are new pages. We may or may
726 // not have a pending entry for the page, and this may or may not be the
727 // main frame.
[email protected]2905f742011-10-13 03:51:58728 if (content::PageTransitionIsMainFrame(params.transition))
[email protected]610cbb82011-10-18 16:35:08729 return content::NAVIGATION_TYPE_NEW_PAGE;
[email protected]4c27ba82008-09-24 16:49:09730
731 // When this is a new subframe navigation, we should have a committed page
732 // for which it's a suframe in. This may not be the case when an iframe is
733 // navigated on a popup navigated to about:blank (the iframe would be
734 // written into the popup by script on the main page). For these cases,
735 // there isn't any navigation stuff we can do, so just ignore it.
736 if (!GetLastCommittedEntry())
[email protected]610cbb82011-10-18 16:35:08737 return content::NAVIGATION_TYPE_NAV_IGNORE;
[email protected]4c27ba82008-09-24 16:49:09738
739 // Valid subframe navigation.
[email protected]610cbb82011-10-18 16:35:08740 return content::NAVIGATION_TYPE_NEW_SUBFRAME;
[email protected]e9ba4472008-09-14 15:42:43741 }
742
743 // Now we know that the notification is for an existing page. Find that entry.
744 int existing_entry_index = GetEntryIndexWithPageID(
[email protected]9423d9412009-04-14 22:13:55745 tab_contents_->GetSiteInstance(),
[email protected]e9ba4472008-09-14 15:42:43746 params.page_id);
747 if (existing_entry_index == -1) {
748 // The page was not found. It could have been pruned because of the limit on
749 // back/forward entries (not likely since we'll usually tell it to navigate
750 // to such entries). It could also mean that the renderer is smoking crack.
751 NOTREACHED();
[email protected]485e8232011-07-24 18:03:46752
753 // Because the unknown entry has committed, we risk showing the wrong URL in
754 // release builds. Instead, we'll kill the renderer process to be safe.
755 LOG(ERROR) << "terminating renderer for bad navigation: " << params.url;
[email protected]7f6f44c2011-12-14 13:23:38756 content::RecordAction(UserMetricsAction("BadMessageTerminate_NC"));
[email protected]b69934e2011-10-29 02:51:52757
[email protected]7ec6f382011-11-11 01:28:17758 // Temporary code so we can get more information. Format:
[email protected]8c380582011-12-02 03:16:10759 // http://url/foo.html#page1#max3#frame1#ids:2_Nx,1_1x,3_2
760 std::string temp = params.url.spec();
[email protected]7ec6f382011-11-11 01:28:17761 temp.append("#page");
[email protected]b69934e2011-10-29 02:51:52762 temp.append(base::IntToString(params.page_id));
[email protected]7ec6f382011-11-11 01:28:17763 temp.append("#max");
764 temp.append(base::IntToString(tab_contents_->GetMaxPageID()));
765 temp.append("#frame");
766 temp.append(base::IntToString(params.frame_id));
767 temp.append("#ids");
768 for (int i = 0; i < static_cast<int>(entries_.size()); ++i) {
[email protected]8c380582011-12-02 03:16:10769 // Append entry metadata (e.g., 3_7x):
770 // 3: page_id
771 // 7: SiteInstance ID, or N for null
772 // x: appended if not from the current SiteInstance
[email protected]36fc0392011-12-25 03:59:51773 temp.append(base::IntToString(entries_[i]->GetPageID()));
[email protected]8c380582011-12-02 03:16:10774 temp.append("_");
775 if (entries_[i]->site_instance())
[email protected]b6583592012-01-25 19:52:33776 temp.append(base::IntToString(entries_[i]->site_instance()->GetId()));
[email protected]7ec6f382011-11-11 01:28:17777 else
[email protected]8c380582011-12-02 03:16:10778 temp.append("N");
779 if (entries_[i]->site_instance() != tab_contents_->GetSiteInstance())
[email protected]7ec6f382011-11-11 01:28:17780 temp.append("x");
781 temp.append(",");
[email protected]b69934e2011-10-29 02:51:52782 }
783 GURL url(temp);
[email protected]151a63d2011-12-20 22:32:52784 tab_contents_->GetRenderViewHost()->Send(new ViewMsg_TempCrashWithData(url));
[email protected]b69934e2011-10-29 02:51:52785 return content::NAVIGATION_TYPE_NAV_IGNORE;
[email protected]e9ba4472008-09-14 15:42:43786 }
[email protected]10f417c52011-12-28 21:04:23787 NavigationEntryImpl* existing_entry = entries_[existing_entry_index].get();
[email protected]e9ba4472008-09-14 15:42:43788
[email protected]2905f742011-10-13 03:51:58789 if (!content::PageTransitionIsMainFrame(params.transition)) {
[email protected]e6035c22010-05-25 16:15:52790 // All manual subframes would get new IDs and were handled above, so we
791 // know this is auto. Since the current page was found in the navigation
792 // entry list, we're guaranteed to have a last committed entry.
793 DCHECK(GetLastCommittedEntry());
[email protected]610cbb82011-10-18 16:35:08794 return content::NAVIGATION_TYPE_AUTO_SUBFRAME;
[email protected]e6035c22010-05-25 16:15:52795 }
796
797 // Anything below here we know is a main frame navigation.
[email protected]e9ba4472008-09-14 15:42:43798 if (pending_entry_ &&
[email protected]e9ba4472008-09-14 15:42:43799 existing_entry != pending_entry_ &&
[email protected]36fc0392011-12-25 03:59:51800 pending_entry_->GetPageID() == -1 &&
[email protected]230c0012011-04-08 16:27:24801 existing_entry == GetLastCommittedEntry()) {
[email protected]e9ba4472008-09-14 15:42:43802 // In this case, we have a pending entry for a URL but WebCore didn't do a
803 // new navigation. This happens when you press enter in the URL bar to
804 // reload. We will create a pending entry, but WebKit will convert it to
805 // a reload since it's the same page and not create a new entry for it
806 // (the user doesn't want to have a new back/forward entry when they do
[email protected]230c0012011-04-08 16:27:24807 // this). If this matches the last committed entry, we want to just ignore
808 // the pending entry and go back to where we were (the "existing entry").
[email protected]610cbb82011-10-18 16:35:08809 return content::NAVIGATION_TYPE_SAME_PAGE;
[email protected]e9ba4472008-09-14 15:42:43810 }
811
[email protected]fc60f222008-12-18 17:36:54812 // Any toplevel navigations with the same base (minus the reference fragment)
813 // are in-page navigations. We weeded out subframe navigations above. Most of
814 // the time this doesn't matter since WebKit doesn't tell us about subframe
815 // navigations that don't actually navigate, but it can happen when there is
816 // an encoding override (it always sends a navigation request).
[email protected]36fc0392011-12-25 03:59:51817 if (AreURLsInPageNavigation(existing_entry->GetURL(), params.url))
[email protected]610cbb82011-10-18 16:35:08818 return content::NAVIGATION_TYPE_IN_PAGE;
[email protected]fc60f222008-12-18 17:36:54819
[email protected]e9ba4472008-09-14 15:42:43820 // Since we weeded out "new" navigations above, we know this is an existing
[email protected]4c27ba82008-09-24 16:49:09821 // (back/forward) navigation.
[email protected]610cbb82011-10-18 16:35:08822 return content::NAVIGATION_TYPE_EXISTING_PAGE;
[email protected]e9ba4472008-09-14 15:42:43823}
824
[email protected]d202a7c2012-01-04 07:53:47825bool NavigationControllerImpl::IsRedirect(
[email protected]09b8f82f2009-06-16 20:22:11826 const ViewHostMsg_FrameNavigate_Params& params) {
827 // For main frame transition, we judge by params.transition.
828 // Otherwise, by params.redirects.
[email protected]2905f742011-10-13 03:51:58829 if (content::PageTransitionIsMainFrame(params.transition)) {
830 return content::PageTransitionIsRedirect(params.transition);
[email protected]09b8f82f2009-06-16 20:22:11831 }
832 return params.redirects.size() > 1;
833}
834
[email protected]d202a7c2012-01-04 07:53:47835void NavigationControllerImpl::RendererDidNavigateToNewPage(
[email protected]befd8d822009-07-01 04:51:47836 const ViewHostMsg_FrameNavigate_Params& params, bool* did_replace_entry) {
[email protected]10f417c52011-12-28 21:04:23837 NavigationEntryImpl* new_entry;
[email protected]f1eb87a2011-05-06 17:49:41838 bool update_virtual_url;
[email protected]e9ba4472008-09-14 15:42:43839 if (pending_entry_) {
840 // TODO(brettw) this assumes that the pending entry is appropriate for the
841 // new page that was just loaded. I don't think this is necessarily the
[email protected]49bd30e62011-03-22 20:12:59842 // case! We should have some more tracking to know for sure.
[email protected]10f417c52011-12-28 21:04:23843 new_entry = new NavigationEntryImpl(*pending_entry_);
[email protected]e9ba4472008-09-14 15:42:43844
845 // Don't use the page type from the pending entry. Some interstitial page
846 // may have set the type to interstitial. Once we commit, however, the page
847 // type must always be normal.
[email protected]66fdbd52011-10-18 17:08:53848 new_entry->set_page_type(content::PAGE_TYPE_NORMAL);
[email protected]f1eb87a2011-05-06 17:49:41849 update_virtual_url = new_entry->update_virtual_url_with_url();
[email protected]e9ba4472008-09-14 15:42:43850 } else {
[email protected]10f417c52011-12-28 21:04:23851 new_entry = new NavigationEntryImpl;
[email protected]f1eb87a2011-05-06 17:49:41852 // When navigating to a new page, give the browser URL handler a chance to
853 // update the virtual URL based on the new URL. For example, this is needed
854 // to show chrome://bookmarks/#1 when the bookmarks webui extension changes
855 // the URL.
856 update_virtual_url = true;
[email protected]e9ba4472008-09-14 15:42:43857 }
858
[email protected]ad23a092011-12-28 07:02:04859 new_entry->SetURL(params.url);
[email protected]f1eb87a2011-05-06 17:49:41860 if (update_virtual_url)
[email protected]38178a42009-12-17 18:58:32861 UpdateVirtualURLToURL(new_entry, params.url);
[email protected]022af742011-12-28 18:37:25862 new_entry->SetReferrer(params.referrer);
[email protected]36fc0392011-12-25 03:59:51863 new_entry->SetPageID(params.page_id);
[email protected]022af742011-12-28 18:37:25864 new_entry->SetTransitionType(params.transition);
[email protected]b6583592012-01-25 19:52:33865 new_entry->set_site_instance(
866 static_cast<SiteInstanceImpl*>(tab_contents_->GetSiteInstance()));
[email protected]36fc0392011-12-25 03:59:51867 new_entry->SetHasPostData(params.is_post);
[email protected]86cd9472012-02-03 19:51:05868 new_entry->SetPostID(params.post_id);
[email protected]e9ba4472008-09-14 15:42:43869
[email protected]befd8d822009-07-01 04:51:47870 InsertOrReplaceEntry(new_entry, *did_replace_entry);
[email protected]e9ba4472008-09-14 15:42:43871}
872
[email protected]d202a7c2012-01-04 07:53:47873void NavigationControllerImpl::RendererDidNavigateToExistingPage(
[email protected]e9ba4472008-09-14 15:42:43874 const ViewHostMsg_FrameNavigate_Params& params) {
875 // We should only get here for main frame navigations.
[email protected]2905f742011-10-13 03:51:58876 DCHECK(content::PageTransitionIsMainFrame(params.transition));
[email protected]e9ba4472008-09-14 15:42:43877
878 // This is a back/forward navigation. The existing page for the ID is
[email protected]4c27ba82008-09-24 16:49:09879 // guaranteed to exist by ClassifyNavigation, and we just need to update it
880 // with new information from the renderer.
[email protected]7f0005a2009-04-15 03:25:11881 int entry_index = GetEntryIndexWithPageID(tab_contents_->GetSiteInstance(),
882 params.page_id);
[email protected]e9ba4472008-09-14 15:42:43883 DCHECK(entry_index >= 0 &&
884 entry_index < static_cast<int>(entries_.size()));
[email protected]10f417c52011-12-28 21:04:23885 NavigationEntryImpl* entry = entries_[entry_index].get();
[email protected]e9ba4472008-09-14 15:42:43886
887 // The URL may have changed due to redirects. The site instance will normally
888 // be the same except during session restore, when no site instance will be
889 // assigned.
[email protected]ad23a092011-12-28 07:02:04890 entry->SetURL(params.url);
[email protected]38178a42009-12-17 18:58:32891 if (entry->update_virtual_url_with_url())
892 UpdateVirtualURLToURL(entry, params.url);
[email protected]e9ba4472008-09-14 15:42:43893 DCHECK(entry->site_instance() == NULL ||
[email protected]9423d9412009-04-14 22:13:55894 entry->site_instance() == tab_contents_->GetSiteInstance());
[email protected]b6583592012-01-25 19:52:33895 entry->set_site_instance(
896 static_cast<SiteInstanceImpl*>(tab_contents_->GetSiteInstance()));
[email protected]e9ba4472008-09-14 15:42:43897
[email protected]36fc0392011-12-25 03:59:51898 entry->SetHasPostData(params.is_post);
[email protected]86cd9472012-02-03 19:51:05899 entry->SetPostID(params.post_id);
[email protected]d5a49e52010-01-08 03:01:41900
[email protected]e9ba4472008-09-14 15:42:43901 // The entry we found in the list might be pending if the user hit
902 // back/forward/reload. This load should commit it (since it's already in the
[email protected]49bd30e62011-03-22 20:12:59903 // list, we can just discard the pending pointer). We should also discard the
904 // pending entry if it corresponds to a different navigation, since that one
905 // is now likely canceled. If it is not canceled, we will treat it as a new
906 // navigation when it arrives, which is also ok.
[email protected]e9ba4472008-09-14 15:42:43907 //
908 // Note that we need to use the "internal" version since we don't want to
909 // actually change any other state, just kill the pointer.
[email protected]49bd30e62011-03-22 20:12:59910 if (pending_entry_)
[email protected]cbab76d2008-10-13 22:42:47911 DiscardNonCommittedEntriesInternal();
[email protected]40bcc302009-03-02 20:50:39912
[email protected]80858db52009-10-15 00:35:18913 // If a transient entry was removed, the indices might have changed, so we
914 // have to query the entry index again.
915 last_committed_entry_index_ =
916 GetEntryIndexWithPageID(tab_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:43917}
918
[email protected]d202a7c2012-01-04 07:53:47919void NavigationControllerImpl::RendererDidNavigateToSamePage(
[email protected]e9ba4472008-09-14 15:42:43920 const ViewHostMsg_FrameNavigate_Params& params) {
921 // This mode implies we have a pending entry that's the same as an existing
[email protected]4c27ba82008-09-24 16:49:09922 // entry for this page ID. This entry is guaranteed to exist by
923 // ClassifyNavigation. All we need to do is update the existing entry.
[email protected]10f417c52011-12-28 21:04:23924 NavigationEntryImpl* existing_entry = GetEntryWithPageID(
925 tab_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:43926
927 // We assign the entry's unique ID to be that of the new one. Since this is
928 // always the result of a user action, we want to dismiss infobars, etc. like
929 // a regular user-initiated navigation.
[email protected]36fc0392011-12-25 03:59:51930 existing_entry->set_unique_id(pending_entry_->GetUniqueID());
[email protected]e9ba4472008-09-14 15:42:43931
[email protected]a0e69262009-06-03 19:08:48932 // The URL may have changed due to redirects.
[email protected]38178a42009-12-17 18:58:32933 if (existing_entry->update_virtual_url_with_url())
934 UpdateVirtualURLToURL(existing_entry, params.url);
[email protected]ad23a092011-12-28 07:02:04935 existing_entry->SetURL(params.url);
[email protected]a0e69262009-06-03 19:08:48936
[email protected]cbab76d2008-10-13 22:42:47937 DiscardNonCommittedEntries();
[email protected]e9ba4472008-09-14 15:42:43938}
939
[email protected]d202a7c2012-01-04 07:53:47940void NavigationControllerImpl::RendererDidNavigateInPage(
[email protected]befd8d822009-07-01 04:51:47941 const ViewHostMsg_FrameNavigate_Params& params, bool* did_replace_entry) {
[email protected]2905f742011-10-13 03:51:58942 DCHECK(content::PageTransitionIsMainFrame(params.transition)) <<
[email protected]e9ba4472008-09-14 15:42:43943 "WebKit should only tell us about in-page navs for the main frame.";
944 // We're guaranteed to have an entry for this one.
[email protected]10f417c52011-12-28 21:04:23945 NavigationEntryImpl* existing_entry = GetEntryWithPageID(
946 tab_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:43947
948 // Reference fragment navigation. We're guaranteed to have the last_committed
949 // entry and it will be the same page as the new navigation (minus the
[email protected]d466b8a2011-07-15 21:48:03950 // reference fragments, of course). We'll update the URL of the existing
951 // entry without pruning the forward history.
[email protected]ad23a092011-12-28 07:02:04952 existing_entry->SetURL(params.url);
[email protected]d466b8a2011-07-15 21:48:03953 if (existing_entry->update_virtual_url_with_url())
954 UpdateVirtualURLToURL(existing_entry, params.url);
[email protected]ccbe04e2010-03-17 17:58:43955
956 // This replaces the existing entry since the page ID didn't change.
957 *did_replace_entry = true;
[email protected]d466b8a2011-07-15 21:48:03958
959 if (pending_entry_)
960 DiscardNonCommittedEntriesInternal();
961
962 // If a transient entry was removed, the indices might have changed, so we
963 // have to query the entry index again.
964 last_committed_entry_index_ =
965 GetEntryIndexWithPageID(tab_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:43966}
967
[email protected]d202a7c2012-01-04 07:53:47968void NavigationControllerImpl::RendererDidNavigateNewSubframe(
[email protected]e9ba4472008-09-14 15:42:43969 const ViewHostMsg_FrameNavigate_Params& params) {
[email protected]2905f742011-10-13 03:51:58970 if (content::PageTransitionStripQualifier(params.transition) ==
971 content::PAGE_TRANSITION_AUTO_SUBFRAME) {
[email protected]09b8f82f2009-06-16 20:22:11972 // This is not user-initiated. Ignore.
973 return;
974 }
[email protected]09b8f82f2009-06-16 20:22:11975
[email protected]e9ba4472008-09-14 15:42:43976 // Manual subframe navigations just get the current entry cloned so the user
977 // can go back or forward to it. The actual subframe information will be
978 // stored in the page state for each of those entries. This happens out of
979 // band with the actual navigations.
[email protected]4c27ba82008-09-24 16:49:09980 DCHECK(GetLastCommittedEntry()) << "ClassifyNavigation should guarantee "
981 << "that a last committed entry exists.";
[email protected]10f417c52011-12-28 21:04:23982 NavigationEntryImpl* new_entry = new NavigationEntryImpl(
983 *NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry()));
[email protected]36fc0392011-12-25 03:59:51984 new_entry->SetPageID(params.page_id);
[email protected]672eba292009-05-13 13:22:45985 InsertOrReplaceEntry(new_entry, false);
[email protected]e9ba4472008-09-14 15:42:43986}
987
[email protected]d202a7c2012-01-04 07:53:47988bool NavigationControllerImpl::RendererDidNavigateAutoSubframe(
[email protected]e9ba4472008-09-14 15:42:43989 const ViewHostMsg_FrameNavigate_Params& params) {
990 // We're guaranteed to have a previously committed entry, and we now need to
991 // handle navigation inside of a subframe in it without creating a new entry.
992 DCHECK(GetLastCommittedEntry());
993
994 // Handle the case where we're navigating back/forward to a previous subframe
995 // navigation entry. This is case "2." in NAV_AUTO_SUBFRAME comment in the
996 // header file. In case "1." this will be a NOP.
997 int entry_index = GetEntryIndexWithPageID(
[email protected]9423d9412009-04-14 22:13:55998 tab_contents_->GetSiteInstance(),
[email protected]e9ba4472008-09-14 15:42:43999 params.page_id);
1000 if (entry_index < 0 ||
1001 entry_index >= static_cast<int>(entries_.size())) {
1002 NOTREACHED();
1003 return false;
1004 }
1005
1006 // Update the current navigation entry in case we're going back/forward.
1007 if (entry_index != last_committed_entry_index_) {
[email protected]e9ba4472008-09-14 15:42:431008 last_committed_entry_index_ = entry_index;
[email protected]e9ba4472008-09-14 15:42:431009 return true;
1010 }
1011 return false;
1012}
1013
[email protected]d202a7c2012-01-04 07:53:471014int NavigationControllerImpl::GetIndexOfEntry(
[email protected]10f417c52011-12-28 21:04:231015 const NavigationEntryImpl* entry) const {
[email protected]765b35502008-08-21 00:51:201016 const NavigationEntries::const_iterator i(std::find(
1017 entries_.begin(),
1018 entries_.end(),
1019 entry));
1020 return (i == entries_.end()) ? -1 : static_cast<int>(i - entries_.begin());
1021}
1022
[email protected]d202a7c2012-01-04 07:53:471023bool NavigationControllerImpl::IsURLInPageNavigation(const GURL& url) const {
[email protected]10f417c52011-12-28 21:04:231024 NavigationEntry* last_committed = GetLastCommittedEntry();
[email protected]e9ba4472008-09-14 15:42:431025 if (!last_committed)
1026 return false;
[email protected]36fc0392011-12-25 03:59:511027 return AreURLsInPageNavigation(last_committed->GetURL(), url);
[email protected]e9ba4472008-09-14 15:42:431028}
1029
[email protected]d202a7c2012-01-04 07:53:471030void NavigationControllerImpl::CopyStateFrom(
[email protected]c5eed492012-01-04 17:07:501031 const NavigationController& temp) {
[email protected]d202a7c2012-01-04 07:53:471032 const NavigationControllerImpl& source =
1033 static_cast<const NavigationControllerImpl&>(temp);
[email protected]ce3fa3c2009-04-20 19:55:571034 // Verify that we look new.
[email protected]a26023822011-12-29 00:23:551035 DCHECK(GetEntryCount() == 0 && !GetPendingEntry());
[email protected]ce3fa3c2009-04-20 19:55:571036
[email protected]a26023822011-12-29 00:23:551037 if (source.GetEntryCount() == 0)
[email protected]ce3fa3c2009-04-20 19:55:571038 return; // Nothing new to do.
1039
1040 needs_reload_ = true;
[email protected]a26023822011-12-29 00:23:551041 InsertEntriesFrom(source, source.GetEntryCount());
[email protected]ce3fa3c2009-04-20 19:55:571042
[email protected]6ee12c42010-09-14 09:36:071043 session_storage_namespace_ = source.session_storage_namespace_->Clone();
[email protected]4e6419c2010-01-15 04:50:341044
[email protected]5e369672009-11-03 23:48:301045 FinishRestore(source.last_committed_entry_index_, false);
[email protected]91854cd2012-01-10 19:43:571046
1047 // Copy the max page id map from the old tab to the new tab. This ensures
1048 // that new and existing navigations in the tab's current SiteInstances
1049 // are identified properly.
1050 tab_contents_->CopyMaxPageIDsFrom(source.tab_contents());
[email protected]ce3fa3c2009-04-20 19:55:571051}
1052
[email protected]d202a7c2012-01-04 07:53:471053void NavigationControllerImpl::CopyStateFromAndPrune(
[email protected]c5eed492012-01-04 17:07:501054 NavigationController* temp) {
[email protected]d202a7c2012-01-04 07:53:471055 NavigationControllerImpl* source =
1056 static_cast<NavigationControllerImpl*>(temp);
[email protected]9e1ad4b2011-08-14 16:49:191057 // The SiteInstance and page_id of the last committed entry needs to be
1058 // remembered at this point, in case there is only one committed entry
[email protected]91854cd2012-01-10 19:43:571059 // and it is pruned. We use a scoped_refptr to ensure the SiteInstance
1060 // can't be freed during this time period.
[email protected]10f417c52011-12-28 21:04:231061 NavigationEntryImpl* last_committed =
1062 NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry());
[email protected]91854cd2012-01-10 19:43:571063 scoped_refptr<SiteInstance> site_instance(
1064 last_committed ? last_committed->site_instance() : NULL);
[email protected]36fc0392011-12-25 03:59:511065 int32 minimum_page_id = last_committed ? last_committed->GetPageID() : -1;
[email protected]91854cd2012-01-10 19:43:571066 int32 max_page_id = last_committed ?
1067 tab_contents_->GetMaxPageIDForSiteInstance(site_instance.get()) : -1;
[email protected]9e1ad4b2011-08-14 16:49:191068
[email protected]e1cd5452010-08-26 18:03:251069 // This code is intended for use when the last entry is the active entry.
[email protected]a26023822011-12-29 00:23:551070 DCHECK(
1071 (transient_entry_index_ != -1 &&
[email protected]91854cd2012-01-10 19:43:571072 transient_entry_index_ == GetEntryCount() - 1) ||
[email protected]a26023822011-12-29 00:23:551073 (pending_entry_ && (pending_entry_index_ == -1 ||
1074 pending_entry_index_ == GetEntryCount() - 1)) ||
1075 (!pending_entry_ && last_committed_entry_index_ == GetEntryCount() - 1));
[email protected]e1cd5452010-08-26 18:03:251076
1077 // Remove all the entries leaving the active entry.
1078 PruneAllButActive();
1079
[email protected]47e020a2010-10-15 14:43:371080 // Insert the entries from source. Don't use source->GetCurrentEntryIndex as
[email protected]e1cd5452010-08-26 18:03:251081 // we don't want to copy over the transient entry.
[email protected]47e020a2010-10-15 14:43:371082 int max_source_index = source->pending_entry_index_ != -1 ?
1083 source->pending_entry_index_ : source->last_committed_entry_index_;
[email protected]e1cd5452010-08-26 18:03:251084 if (max_source_index == -1)
[email protected]a26023822011-12-29 00:23:551085 max_source_index = source->GetEntryCount();
[email protected]e1cd5452010-08-26 18:03:251086 else
1087 max_source_index++;
[email protected]47e020a2010-10-15 14:43:371088 InsertEntriesFrom(*source, max_source_index);
[email protected]e1cd5452010-08-26 18:03:251089
1090 // Adjust indices such that the last entry and pending are at the end now.
[email protected]a26023822011-12-29 00:23:551091 last_committed_entry_index_ = GetEntryCount() - 1;
[email protected]e1cd5452010-08-26 18:03:251092 if (pending_entry_index_ != -1)
[email protected]a26023822011-12-29 00:23:551093 pending_entry_index_ = GetEntryCount() - 1;
[email protected]e1cd5452010-08-26 18:03:251094 if (transient_entry_index_ != -1) {
1095 // There's a transient entry. In this case we want the last committed to
1096 // point to the previous entry.
[email protected]a26023822011-12-29 00:23:551097 transient_entry_index_ = GetEntryCount() - 1;
[email protected]e1cd5452010-08-26 18:03:251098 if (last_committed_entry_index_ != -1)
1099 last_committed_entry_index_--;
1100 }
[email protected]796931a92011-08-10 01:32:141101
[email protected]91854cd2012-01-10 19:43:571102 tab_contents_->SetHistoryLengthAndPrune(site_instance.get(),
[email protected]9e1ad4b2011-08-14 16:49:191103 max_source_index,
1104 minimum_page_id);
[email protected]91854cd2012-01-10 19:43:571105
1106 // Copy the max page id map from the old tab to the new tab. This ensures
1107 // that new and existing navigations in the tab's current SiteInstances
1108 // are identified properly.
1109 tab_contents_->CopyMaxPageIDsFrom(source->tab_contents());
1110
1111 // If there is a last committed entry, be sure to include it in the new
1112 // max page ID map.
1113 if (max_page_id > -1) {
1114 tab_contents_->UpdateMaxPageIDForSiteInstance(site_instance.get(),
1115 max_page_id);
1116 }
[email protected]e1cd5452010-08-26 18:03:251117}
1118
[email protected]d202a7c2012-01-04 07:53:471119void NavigationControllerImpl::PruneAllButActive() {
[email protected]97b6c4f2010-09-27 19:31:261120 if (transient_entry_index_ != -1) {
1121 // There is a transient entry. Prune up to it.
[email protected]a26023822011-12-29 00:23:551122 DCHECK_EQ(GetEntryCount() - 1, transient_entry_index_);
[email protected]77d8d622010-12-15 10:30:121123 entries_.erase(entries_.begin(), entries_.begin() + transient_entry_index_);
[email protected]97b6c4f2010-09-27 19:31:261124 transient_entry_index_ = 0;
1125 last_committed_entry_index_ = -1;
1126 pending_entry_index_ = -1;
1127 } else if (!pending_entry_) {
1128 // There's no pending entry. Leave the last entry (if there is one).
[email protected]a26023822011-12-29 00:23:551129 if (!GetEntryCount())
[email protected]97b6c4f2010-09-27 19:31:261130 return;
1131
[email protected]77d8d622010-12-15 10:30:121132 DCHECK(last_committed_entry_index_ >= 0);
1133 entries_.erase(entries_.begin(),
1134 entries_.begin() + last_committed_entry_index_);
1135 entries_.erase(entries_.begin() + 1, entries_.end());
[email protected]97b6c4f2010-09-27 19:31:261136 last_committed_entry_index_ = 0;
1137 } else if (pending_entry_index_ != -1) {
[email protected]77d8d622010-12-15 10:30:121138 entries_.erase(entries_.begin(), entries_.begin() + pending_entry_index_);
1139 entries_.erase(entries_.begin() + 1, entries_.end());
[email protected]97b6c4f2010-09-27 19:31:261140 pending_entry_index_ = 0;
1141 last_committed_entry_index_ = 0;
[email protected]97b6c4f2010-09-27 19:31:261142 } else {
1143 // There is a pending_entry, but it's not in entries_.
1144 pending_entry_index_ = -1;
1145 last_committed_entry_index_ = -1;
[email protected]77d8d622010-12-15 10:30:121146 entries_.clear();
[email protected]97b6c4f2010-09-27 19:31:261147 }
1148
[email protected]0bfbf882011-12-22 18:19:271149 if (tab_contents_->GetInterstitialPage()) {
[email protected]97b6c4f2010-09-27 19:31:261150 // Normally the interstitial page hides itself if the user doesn't proceeed.
1151 // This would result in showing a NavigationEntry we just removed. Set this
1152 // so the interstitial triggers a reload if the user doesn't proceed.
[email protected]cadaec52012-02-08 21:53:131153 static_cast<InterstitialPageImpl*>(tab_contents_->GetInterstitialPage())->
1154 set_reload_on_dont_proceed(true);
[email protected]97b6c4f2010-09-27 19:31:261155 }
[email protected]97b6c4f2010-09-27 19:31:261156}
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}