blob: 25d4874d1083a1bbfd6df35da7670c905ddb7d4a [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]f9e4dae2012-04-10 21:26:375#include "content/browser/web_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]825b1662012-03-12 19:07:3113#include "content/browser/browser_url_handler_impl.h"
[email protected]b9535422012-02-09 01:47:5914#include "content/browser/child_process_security_policy_impl.h"
[email protected]1ea3c792012-04-17 01:25:0415#include "content/browser/dom_storage/dom_storage_context_impl.h"
16#include "content/browser/dom_storage/session_storage_namespace_impl.h"
[email protected]b3c41c0b2012-03-06 15:48:3217#include "content/browser/renderer_host/render_view_host_impl.h" // Temporary
[email protected]b6583592012-01-25 19:52:3318#include "content/browser/site_instance_impl.h"
[email protected]f9e4dae2012-04-10 21:26:3719#include "content/browser/web_contents/debug_urls.h"
20#include "content/browser/web_contents/interstitial_page_impl.h"
21#include "content/browser/web_contents/navigation_entry_impl.h"
[email protected]93ddb3c2012-04-11 21:44:2922#include "content/browser/web_contents/web_contents_impl.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]d1198fd2012-08-13 22:50:1925#include "content/public/browser/content_browser_client.h"
[email protected]d9083482012-01-06 00:38:4626#include "content/public/browser/invalidate_type.h"
[email protected]5b96836f2011-12-22 07:39:0027#include "content/public/browser/navigation_details.h"
[email protected]7f6f44c2011-12-14 13:23:3828#include "content/public/browser/notification_service.h"
[email protected]0d6e9bd2011-10-18 04:29:1629#include "content/public/browser/notification_types.h"
[email protected]7f6f44c2011-12-14 13:23:3830#include "content/public/browser/user_metrics.h"
[email protected]674bc592011-12-20 23:00:4231#include "content/public/browser/web_contents_delegate.h"
[email protected]d1198fd2012-08-13 22:50:1932#include "content/public/common/content_client.h"
[email protected]7f6f44c2011-12-14 13:23:3833#include "content/public/common/content_constants.h"
[email protected]d1ef81d2012-07-24 11:39:3634#include "content/public/common/url_constants.h"
[email protected]a23de8572009-06-03 02:16:3235#include "net/base/escape.h"
[email protected]31682282010-01-15 18:05:1636#include "net/base/mime_util.h"
[email protected]7f070d42011-03-09 20:25:3237#include "net/base/net_util.h"
[email protected]765b35502008-08-21 00:51:2038#include "webkit/glue/webkit_glue.h"
initial.commit09911bf2008-07-26 23:55:2939
[email protected]cdcb1dee2012-01-04 00:46:2040using content::BrowserContext;
[email protected]adbfb8df2012-02-24 01:19:4341using content::DOMStorageContext;
[email protected]d1198fd2012-08-13 22:50:1942using content::GetContentClient;
[email protected]e5d549d2011-12-28 01:29:2043using content::GlobalRequestID;
[email protected]c5eed492012-01-04 17:07:5044using content::NavigationController;
[email protected]10f417c52011-12-28 21:04:2345using content::NavigationEntry;
46using content::NavigationEntryImpl;
[email protected]eaabba22012-03-07 15:02:1147using content::RenderViewHostImpl;
[email protected]adbfb8df2012-02-24 01:19:4348using content::SessionStorageNamespace;
[email protected]d1198fd2012-08-13 22:50:1949using content::SessionStorageNamespaceMap;
[email protected]b6583592012-01-25 19:52:3350using content::SiteInstance;
[email protected]7f6f44c2011-12-14 13:23:3851using content::UserMetricsAction;
[email protected]fbc5e5f92012-01-02 06:08:3252using content::WebContents;
[email protected]7f6f44c2011-12-14 13:23:3853
[email protected]e9ba4472008-09-14 15:42:4354namespace {
55
[email protected]93f230e02011-06-01 14:40:0056const int kInvalidateAll = 0xFFFFFFFF;
[email protected]8030f012009-09-25 18:09:3757
[email protected]e9ba4472008-09-14 15:42:4358// Invoked when entries have been pruned, or removed. For example, if the
59// current entries are [google, digg, yahoo], with the current entry google,
60// and the user types in cnet, then digg and yahoo are pruned.
[email protected]d202a7c2012-01-04 07:53:4761void NotifyPrunedEntries(NavigationControllerImpl* nav_controller,
[email protected]c12bf1a12008-09-17 16:28:4962 bool from_front,
63 int count) {
[email protected]8286f51a2011-05-31 17:39:1364 content::PrunedDetails details;
[email protected]c12bf1a12008-09-17 16:28:4965 details.from_front = from_front;
66 details.count = count;
[email protected]ad50def52011-10-19 23:17:0767 content::NotificationService::current()->Notify(
[email protected]432115822011-07-10 15:52:2768 content::NOTIFICATION_NAV_LIST_PRUNED,
[email protected]c5eed492012-01-04 17:07:5069 content::Source<NavigationController>(nav_controller),
[email protected]6c2381d2011-10-19 02:52:5370 content::Details<content::PrunedDetails>(&details));
[email protected]e9ba4472008-09-14 15:42:4371}
72
73// Ensure the given NavigationEntry has a valid state, so that WebKit does not
74// get confused if we navigate back to it.
[email protected]40bcc302009-03-02 20:50:3975//
[email protected]e9ba4472008-09-14 15:42:4376// An empty state is treated as a new navigation by WebKit, which would mean
77// losing the navigation entries and generating a new navigation entry after
78// this one. We don't want that. To avoid this we create a valid state which
79// WebKit will not treat as a new navigation.
[email protected]10f417c52011-12-28 21:04:2380void SetContentStateIfEmpty(NavigationEntryImpl* entry) {
[email protected]36fc0392011-12-25 03:59:5181 if (entry->GetContentState().empty()) {
82 entry->SetContentState(
83 webkit_glue::CreateHistoryStateForURL(entry->GetURL()));
[email protected]e9ba4472008-09-14 15:42:4384 }
85}
86
87// Configure all the NavigationEntries in entries for restore. This resets
88// the transition type to reload and makes sure the content state isn't empty.
89void ConfigureEntriesForRestore(
[email protected]10f417c52011-12-28 21:04:2390 std::vector<linked_ptr<NavigationEntryImpl> >* entries,
[email protected]5e369672009-11-03 23:48:3091 bool from_last_session) {
[email protected]e9ba4472008-09-14 15:42:4392 for (size_t i = 0; i < entries->size(); ++i) {
93 // Use a transition type of reload so that we don't incorrectly increase
94 // the typed count.
[email protected]022af742011-12-28 18:37:2595 (*entries)[i]->SetTransitionType(content::PAGE_TRANSITION_RELOAD);
[email protected]5e369672009-11-03 23:48:3096 (*entries)[i]->set_restore_type(from_last_session ?
[email protected]10f417c52011-12-28 21:04:2397 NavigationEntryImpl::RESTORE_LAST_SESSION :
98 NavigationEntryImpl::RESTORE_CURRENT_SESSION);
[email protected]e9ba4472008-09-14 15:42:4399 // NOTE(darin): This code is only needed for backwards compat.
100 SetContentStateIfEmpty((*entries)[i].get());
101 }
102}
103
104// See NavigationController::IsURLInPageNavigation for how this works and why.
105bool AreURLsInPageNavigation(const GURL& existing_url, const GURL& new_url) {
[email protected]192d8c5e2010-02-23 07:26:32106 if (existing_url == new_url || !new_url.has_ref()) {
107 // TODO(jcampan): what about when navigating back from a ref URL to the top
108 // non ref URL? Nothing is loaded in that case but we return false here.
109 // The user could also navigate from the ref URL to the non ref URL by
110 // entering the non ref URL in the location bar or through a bookmark, in
111 // which case there would be a load. I am not sure if the non-load/load
112 // scenarios can be differentiated with the TransitionType.
[email protected]e9ba4472008-09-14 15:42:43113 return false;
[email protected]192d8c5e2010-02-23 07:26:32114 }
[email protected]e9ba4472008-09-14 15:42:43115
116 url_canon::Replacements<char> replacements;
117 replacements.ClearRef();
118 return existing_url.ReplaceComponents(replacements) ==
119 new_url.ReplaceComponents(replacements);
120}
121
[email protected]bf70edce2012-06-20 22:32:22122// Determines whether or not we should be carrying over a user agent override
123// between two NavigationEntries.
124bool ShouldKeepOverride(const content::NavigationEntry* last_entry) {
125 return last_entry && last_entry->GetIsOverridingUserAgent();
126}
127
[email protected]e9ba4472008-09-14 15:42:43128} // namespace
129
[email protected]d202a7c2012-01-04 07:53:47130// NavigationControllerImpl ----------------------------------------------------
initial.commit09911bf2008-07-26 23:55:29131
[email protected]9b51970d2011-12-09 23:10:23132const size_t kMaxEntryCountForTestingNotSet = -1;
133
[email protected]765b35502008-08-21 00:51:20134// static
[email protected]d202a7c2012-01-04 07:53:47135size_t NavigationControllerImpl::max_entry_count_for_testing_ =
[email protected]9b51970d2011-12-09 23:10:23136 kMaxEntryCountForTestingNotSet;
[email protected]765b35502008-08-21 00:51:20137
[email protected]cdcb1dee2012-01-04 00:46:20138 // Should Reload check for post data? The default is true, but is set to false
139// when testing.
140static bool g_check_for_repost = true;
initial.commit09911bf2008-07-26 23:55:29141
[email protected]cdcb1dee2012-01-04 00:46:20142namespace content {
[email protected]71fde352011-12-29 03:29:56143// static
[email protected]cdcb1dee2012-01-04 00:46:20144NavigationEntry* NavigationController::CreateNavigationEntry(
[email protected]71fde352011-12-29 03:29:56145 const GURL& url,
[email protected]cdcb1dee2012-01-04 00:46:20146 const Referrer& referrer,
147 PageTransition transition,
[email protected]71fde352011-12-29 03:29:56148 bool is_renderer_initiated,
149 const std::string& extra_headers,
[email protected]cdcb1dee2012-01-04 00:46:20150 BrowserContext* browser_context) {
[email protected]71fde352011-12-29 03:29:56151 // Allow the browser URL handler to rewrite the URL. This will, for example,
152 // remove "view-source:" from the beginning of the URL to get the URL that
153 // will actually be loaded. This real URL won't be shown to the user, just
154 // used internally.
155 GURL loaded_url(url);
156 bool reverse_on_redirect = false;
[email protected]825b1662012-03-12 19:07:31157 BrowserURLHandlerImpl::GetInstance()->RewriteURLIfNecessary(
[email protected]71fde352011-12-29 03:29:56158 &loaded_url, browser_context, &reverse_on_redirect);
159
160 NavigationEntryImpl* entry = new NavigationEntryImpl(
161 NULL, // The site instance for tabs is sent on navigation
[email protected]2db9bd72012-04-13 20:20:56162 // (WebContents::GetSiteInstance).
[email protected]71fde352011-12-29 03:29:56163 -1,
164 loaded_url,
165 referrer,
166 string16(),
167 transition,
168 is_renderer_initiated);
169 entry->SetVirtualURL(url);
170 entry->set_user_typed_url(url);
171 entry->set_update_virtual_url_with_url(reverse_on_redirect);
172 entry->set_extra_headers(extra_headers);
173 return entry;
174}
175
[email protected]cdcb1dee2012-01-04 00:46:20176// static
177void NavigationController::DisablePromptOnRepost() {
178 g_check_for_repost = false;
179}
180
181} // namespace content
182
[email protected]d202a7c2012-01-04 07:53:47183NavigationControllerImpl::NavigationControllerImpl(
[email protected]2db9bd72012-04-13 20:20:56184 WebContentsImpl* web_contents,
[email protected]d1198fd2012-08-13 22:50:19185 BrowserContext* browser_context)
[email protected]3d7474ff2011-07-27 17:47:37186 : browser_context_(browser_context),
[email protected]765b35502008-08-21 00:51:20187 pending_entry_(NULL),
188 last_committed_entry_index_(-1),
189 pending_entry_index_(-1),
[email protected]cbab76d2008-10-13 22:42:47190 transient_entry_index_(-1),
[email protected]2db9bd72012-04-13 20:20:56191 web_contents_(web_contents),
initial.commit09911bf2008-07-26 23:55:29192 max_restored_page_id_(-1),
[email protected]5d063842009-05-15 04:08:24193 ALLOW_THIS_IN_INITIALIZER_LIST(ssl_manager_(this)),
[email protected]38b8f4e2009-09-24 19:44:57194 needs_reload_(false),
[email protected]106a0812010-03-18 00:15:12195 pending_reload_(NO_RELOAD) {
[email protected]3d7474ff2011-07-27 17:47:37196 DCHECK(browser_context_);
initial.commit09911bf2008-07-26 23:55:29197}
198
[email protected]d202a7c2012-01-04 07:53:47199NavigationControllerImpl::~NavigationControllerImpl() {
[email protected]cbab76d2008-10-13 22:42:47200 DiscardNonCommittedEntriesInternal();
initial.commit09911bf2008-07-26 23:55:29201}
202
[email protected]d202a7c2012-01-04 07:53:47203WebContents* NavigationControllerImpl::GetWebContents() const {
[email protected]2db9bd72012-04-13 20:20:56204 return web_contents_;
[email protected]fbc5e5f92012-01-02 06:08:32205}
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}
[email protected]7c16976c2012-08-04 02:38:23243void NavigationControllerImpl::ReloadOriginalRequestURL(bool check_for_repost) {
244 ReloadInternal(check_for_repost, RELOAD_ORIGINAL_REQUEST_URL);
245}
[email protected]1ccb3568d2010-02-19 10:51:16246
[email protected]d202a7c2012-01-04 07:53:47247void NavigationControllerImpl::ReloadInternal(bool check_for_repost,
248 ReloadType reload_type) {
[email protected]cbab76d2008-10-13 22:42:47249 // Reloading a transient entry does nothing.
250 if (transient_entry_index_ != -1)
251 return;
252
253 DiscardNonCommittedEntriesInternal();
initial.commit09911bf2008-07-26 23:55:29254 int current_index = GetCurrentEntryIndex();
[email protected]106a0812010-03-18 00:15:12255 // If we are no where, then we can't reload. TODO(darin): We should add a
256 // CanReload method.
257 if (current_index == -1) {
258 return;
259 }
260
[email protected]cdcb1dee2012-01-04 00:46:20261 if (g_check_for_repost && check_for_repost &&
[email protected]36fc0392011-12-25 03:59:51262 GetEntryAtIndex(current_index)->GetHasPostData()) {
[email protected]a3a1d142008-12-19 00:42:30263 // The user is asking to reload a page with POST data. Prompt to make sure
[email protected]b5bb35f2009-02-05 20:17:07264 // they really want to do this. If they do, the dialog will call us back
265 // with check_for_repost = false.
[email protected]ad50def52011-10-19 23:17:07266 content::NotificationService::current()->Notify(
[email protected]432115822011-07-10 15:52:27267 content::NOTIFICATION_REPOST_WARNING_SHOWN,
[email protected]c5eed492012-01-04 17:07:50268 content::Source<NavigationController>(this),
[email protected]ad50def52011-10-19 23:17:07269 content::NotificationService::NoDetails());
[email protected]965bb092010-04-09 11:59:02270
[email protected]106a0812010-03-18 00:15:12271 pending_reload_ = reload_type;
[email protected]2db9bd72012-04-13 20:20:56272 web_contents_->Activate();
273 web_contents_->GetDelegate()->ShowRepostFormWarningDialog(web_contents_);
initial.commit09911bf2008-07-26 23:55:29274 } else {
[email protected]cbab76d2008-10-13 22:42:47275 DiscardNonCommittedEntriesInternal();
[email protected]765b35502008-08-21 00:51:20276
[email protected]bcd904482012-02-01 01:54:22277 NavigationEntryImpl* entry = entries_[current_index].get();
278 SiteInstanceImpl* site_instance = entry->site_instance();
279 DCHECK(site_instance);
[email protected]c3b3d952012-01-31 12:52:26280
[email protected]bcd904482012-02-01 01:54:22281 // If we are reloading an entry that no longer belongs to the current
282 // site instance (for example, refreshing a page for just installed app),
283 // the reload must happen in a new process.
284 // The new entry must have a new page_id and site instance, so it behaves
285 // as new navigation (which happens to clear forward history).
[email protected]7e58cb272012-03-30 21:22:30286 // Tabs that are discarded due to low memory conditions may not have a site
287 // instance, and should not be treated as a cross-site reload.
288 if (site_instance &&
289 site_instance->HasWrongProcessForURL(entry->GetURL())) {
[email protected]bcd904482012-02-01 01:54:22290 // Create a navigation entry that resembles the current one, but do not
291 // copy page id, site instance, and content state.
292 NavigationEntryImpl* nav_entry = NavigationEntryImpl::FromNavigationEntry(
293 CreateNavigationEntry(
294 entry->GetURL(), entry->GetReferrer(), entry->GetTransitionType(),
295 false, entry->extra_headers(), browser_context_));
[email protected]c3b3d952012-01-31 12:52:26296
[email protected]11535962012-02-09 21:02:10297 // Mark the reload type as NO_RELOAD, so navigation will not be considered
298 // a reload in the renderer.
299 reload_type = NavigationController::NO_RELOAD;
300
[email protected]bcd904482012-02-01 01:54:22301 nav_entry->set_is_cross_site_reload(true);
302 pending_entry_ = nav_entry;
303 } else {
304 pending_entry_index_ = current_index;
305
306 // The title of the page being reloaded might have been removed in the
307 // meanwhile, so we need to revert to the default title upon reload and
308 // invalidate the previously cached title (SetTitle will do both).
309 // See Chromium issue 96041.
310 entries_[pending_entry_index_]->SetTitle(string16());
311
312 entries_[pending_entry_index_]->SetTransitionType(
313 content::PAGE_TRANSITION_RELOAD);
314 }
315
[email protected]1ccb3568d2010-02-19 10:51:16316 NavigateToPendingEntry(reload_type);
initial.commit09911bf2008-07-26 23:55:29317 }
318}
319
[email protected]d202a7c2012-01-04 07:53:47320void NavigationControllerImpl::CancelPendingReload() {
[email protected]106a0812010-03-18 00:15:12321 DCHECK(pending_reload_ != NO_RELOAD);
322 pending_reload_ = NO_RELOAD;
323}
324
[email protected]d202a7c2012-01-04 07:53:47325void NavigationControllerImpl::ContinuePendingReload() {
[email protected]106a0812010-03-18 00:15:12326 if (pending_reload_ == NO_RELOAD) {
327 NOTREACHED();
328 } else {
329 ReloadInternal(false, pending_reload_);
[email protected]965bb092010-04-09 11:59:02330 pending_reload_ = NO_RELOAD;
[email protected]106a0812010-03-18 00:15:12331 }
332}
333
[email protected]d202a7c2012-01-04 07:53:47334bool NavigationControllerImpl::IsInitialNavigation() {
[email protected]c70f9b82010-04-21 07:31:11335 return last_document_loaded_.is_null();
336}
337
[email protected]d202a7c2012-01-04 07:53:47338NavigationEntryImpl* NavigationControllerImpl::GetEntryWithPageID(
[email protected]b6583592012-01-25 19:52:33339 SiteInstance* instance, int32 page_id) const {
[email protected]7f0005a2009-04-15 03:25:11340 int index = GetEntryIndexWithPageID(instance, page_id);
[email protected]765b35502008-08-21 00:51:20341 return (index != -1) ? entries_[index].get() : NULL;
342}
343
[email protected]d202a7c2012-01-04 07:53:47344void NavigationControllerImpl::LoadEntry(NavigationEntryImpl* entry) {
[email protected]419a0572011-04-18 22:21:46345 // Don't navigate to URLs disabled by policy. This prevents showing the URL
346 // on the Omnibar when it is also going to be blocked by
347 // ChildProcessSecurityPolicy::CanRequestURL.
[email protected]b9535422012-02-09 01:47:59348 ChildProcessSecurityPolicyImpl* policy =
349 ChildProcessSecurityPolicyImpl::GetInstance();
[email protected]36fc0392011-12-25 03:59:51350 if (policy->IsDisabledScheme(entry->GetURL().scheme()) ||
351 policy->IsDisabledScheme(entry->GetVirtualURL().scheme())) {
[email protected]419a0572011-04-18 22:21:46352 VLOG(1) << "URL not loaded because the scheme is blocked by policy: "
[email protected]36fc0392011-12-25 03:59:51353 << entry->GetURL();
[email protected]419a0572011-04-18 22:21:46354 delete entry;
355 return;
356 }
357
[email protected]765b35502008-08-21 00:51:20358 // When navigating to a new page, we don't know for sure if we will actually
359 // end up leaving the current page. The new page load could for example
360 // result in a download or a 'no content' response (e.g., a mailto: URL).
[email protected]cbab76d2008-10-13 22:42:47361 DiscardNonCommittedEntriesInternal();
[email protected]765b35502008-08-21 00:51:20362 pending_entry_ = entry;
[email protected]ad50def52011-10-19 23:17:07363 content::NotificationService::current()->Notify(
[email protected]432115822011-07-10 15:52:27364 content::NOTIFICATION_NAV_ENTRY_PENDING,
[email protected]c5eed492012-01-04 17:07:50365 content::Source<NavigationController>(this),
[email protected]10f417c52011-12-28 21:04:23366 content::Details<NavigationEntry>(entry));
[email protected]1ccb3568d2010-02-19 10:51:16367 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20368}
369
[email protected]d202a7c2012-01-04 07:53:47370NavigationEntry* NavigationControllerImpl::GetActiveEntry() const {
[email protected]cbab76d2008-10-13 22:42:47371 if (transient_entry_index_ != -1)
372 return entries_[transient_entry_index_].get();
373 if (pending_entry_)
374 return pending_entry_;
375 return GetLastCommittedEntry();
[email protected]765b35502008-08-21 00:51:20376}
377
[email protected]d202a7c2012-01-04 07:53:47378NavigationEntry* NavigationControllerImpl::GetVisibleEntry() const {
[email protected]867e1f92011-08-30 19:01:19379 if (transient_entry_index_ != -1)
380 return entries_[transient_entry_index_].get();
[email protected]e47ae9472011-10-13 19:48:34381 // Only return the pending_entry for new (non-history), browser-initiated
382 // navigations, in order to prevent URL spoof attacks.
383 // Ideally we would also show the pending entry's URL for new renderer-
384 // initiated navigations with no last committed entry (e.g., a link opening
385 // in a new tab), but an attacker can insert content into the about:blank
386 // page while the pending URL loads in that case.
387 if (pending_entry_ &&
[email protected]36fc0392011-12-25 03:59:51388 pending_entry_->GetPageID() == -1 &&
[email protected]e47ae9472011-10-13 19:48:34389 !pending_entry_->is_renderer_initiated())
[email protected]867e1f92011-08-30 19:01:19390 return pending_entry_;
391 return GetLastCommittedEntry();
392}
393
[email protected]d202a7c2012-01-04 07:53:47394int NavigationControllerImpl::GetCurrentEntryIndex() const {
[email protected]cbab76d2008-10-13 22:42:47395 if (transient_entry_index_ != -1)
396 return transient_entry_index_;
[email protected]765b35502008-08-21 00:51:20397 if (pending_entry_index_ != -1)
398 return pending_entry_index_;
399 return last_committed_entry_index_;
400}
401
[email protected]d202a7c2012-01-04 07:53:47402NavigationEntry* NavigationControllerImpl::GetLastCommittedEntry() const {
[email protected]765b35502008-08-21 00:51:20403 if (last_committed_entry_index_ == -1)
404 return NULL;
405 return entries_[last_committed_entry_index_].get();
406}
407
[email protected]d202a7c2012-01-04 07:53:47408bool NavigationControllerImpl::CanViewSource() const {
[email protected]31682282010-01-15 18:05:16409 bool is_supported_mime_type = net::IsSupportedNonImageMimeType(
[email protected]2db9bd72012-04-13 20:20:56410 web_contents_->GetContentsMimeType().c_str());
[email protected]10f417c52011-12-28 21:04:23411 NavigationEntry* active_entry = GetActiveEntry();
[email protected]31682282010-01-15 18:05:16412 return active_entry && !active_entry->IsViewSourceMode() &&
[email protected]2db9bd72012-04-13 20:20:56413 is_supported_mime_type && !web_contents_->GetInterstitialPage();
[email protected]31682282010-01-15 18:05:16414}
415
[email protected]d202a7c2012-01-04 07:53:47416int NavigationControllerImpl::GetLastCommittedEntryIndex() const {
[email protected]a26023822011-12-29 00:23:55417 return last_committed_entry_index_;
418}
419
[email protected]d202a7c2012-01-04 07:53:47420int NavigationControllerImpl::GetEntryCount() const {
[email protected]944822b2012-03-02 20:57:25421 DCHECK(entries_.size() <= max_entry_count());
[email protected]a26023822011-12-29 00:23:55422 return static_cast<int>(entries_.size());
423}
424
[email protected]d202a7c2012-01-04 07:53:47425NavigationEntry* NavigationControllerImpl::GetEntryAtIndex(
[email protected]022af742011-12-28 18:37:25426 int index) const {
427 return entries_.at(index).get();
428}
429
[email protected]d202a7c2012-01-04 07:53:47430NavigationEntry* NavigationControllerImpl::GetEntryAtOffset(
[email protected]022af742011-12-28 18:37:25431 int offset) const {
[email protected]9ba14052012-06-22 23:50:03432 int index = GetIndexForOffset(offset);
[email protected]a26023822011-12-29 00:23:55433 if (index < 0 || index >= GetEntryCount())
[email protected]765b35502008-08-21 00:51:20434 return NULL;
435
436 return entries_[index].get();
437}
438
[email protected]9ba14052012-06-22 23:50:03439int NavigationControllerImpl::GetIndexForOffset(int offset) const {
440 return (transient_entry_index_ != -1) ?
441 transient_entry_index_ + offset :
442 last_committed_entry_index_ + offset;
443}
444
[email protected]d202a7c2012-01-04 07:53:47445bool NavigationControllerImpl::CanGoBack() const {
[email protected]765b35502008-08-21 00:51:20446 return entries_.size() > 1 && GetCurrentEntryIndex() > 0;
447}
448
[email protected]d202a7c2012-01-04 07:53:47449bool NavigationControllerImpl::CanGoForward() const {
[email protected]765b35502008-08-21 00:51:20450 int index = GetCurrentEntryIndex();
451 return index >= 0 && index < (static_cast<int>(entries_.size()) - 1);
452}
453
[email protected]9ba14052012-06-22 23:50:03454bool NavigationControllerImpl::CanGoToOffset(int offset) const {
455 int index = GetIndexForOffset(offset);
456 return index >= 0 && index < GetEntryCount();
457}
458
[email protected]d202a7c2012-01-04 07:53:47459void NavigationControllerImpl::GoBack() {
[email protected]765b35502008-08-21 00:51:20460 if (!CanGoBack()) {
461 NOTREACHED();
462 return;
463 }
464
465 // Base the navigation on where we are now...
466 int current_index = GetCurrentEntryIndex();
467
[email protected]cbab76d2008-10-13 22:42:47468 DiscardNonCommittedEntries();
[email protected]765b35502008-08-21 00:51:20469
470 pending_entry_index_ = current_index - 1;
[email protected]022af742011-12-28 18:37:25471 entries_[pending_entry_index_]->SetTransitionType(
[email protected]2905f742011-10-13 03:51:58472 content::PageTransitionFromInt(
[email protected]36fc0392011-12-25 03:59:51473 entries_[pending_entry_index_]->GetTransitionType() |
[email protected]2905f742011-10-13 03:51:58474 content::PAGE_TRANSITION_FORWARD_BACK));
[email protected]1ccb3568d2010-02-19 10:51:16475 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20476}
477
[email protected]d202a7c2012-01-04 07:53:47478void NavigationControllerImpl::GoForward() {
[email protected]765b35502008-08-21 00:51:20479 if (!CanGoForward()) {
480 NOTREACHED();
481 return;
482 }
483
[email protected]cbab76d2008-10-13 22:42:47484 bool transient = (transient_entry_index_ != -1);
485
[email protected]765b35502008-08-21 00:51:20486 // Base the navigation on where we are now...
487 int current_index = GetCurrentEntryIndex();
488
[email protected]cbab76d2008-10-13 22:42:47489 DiscardNonCommittedEntries();
[email protected]765b35502008-08-21 00:51:20490
[email protected]cbab76d2008-10-13 22:42:47491 pending_entry_index_ = current_index;
492 // If there was a transient entry, we removed it making the current index
493 // the next page.
494 if (!transient)
495 pending_entry_index_++;
496
[email protected]022af742011-12-28 18:37:25497 entries_[pending_entry_index_]->SetTransitionType(
[email protected]2905f742011-10-13 03:51:58498 content::PageTransitionFromInt(
[email protected]36fc0392011-12-25 03:59:51499 entries_[pending_entry_index_]->GetTransitionType() |
[email protected]2905f742011-10-13 03:51:58500 content::PAGE_TRANSITION_FORWARD_BACK));
[email protected]1ccb3568d2010-02-19 10:51:16501 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20502}
503
[email protected]d202a7c2012-01-04 07:53:47504void NavigationControllerImpl::GoToIndex(int index) {
[email protected]765b35502008-08-21 00:51:20505 if (index < 0 || index >= static_cast<int>(entries_.size())) {
506 NOTREACHED();
507 return;
508 }
509
[email protected]cbab76d2008-10-13 22:42:47510 if (transient_entry_index_ != -1) {
511 if (index == transient_entry_index_) {
512 // Nothing to do when navigating to the transient.
513 return;
514 }
515 if (index > transient_entry_index_) {
516 // Removing the transient is goint to shift all entries by 1.
517 index--;
518 }
519 }
520
521 DiscardNonCommittedEntries();
[email protected]765b35502008-08-21 00:51:20522
523 pending_entry_index_ = index;
[email protected]022af742011-12-28 18:37:25524 entries_[pending_entry_index_]->SetTransitionType(
[email protected]2905f742011-10-13 03:51:58525 content::PageTransitionFromInt(
[email protected]36fc0392011-12-25 03:59:51526 entries_[pending_entry_index_]->GetTransitionType() |
[email protected]2905f742011-10-13 03:51:58527 content::PAGE_TRANSITION_FORWARD_BACK));
[email protected]1ccb3568d2010-02-19 10:51:16528 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20529}
530
[email protected]d202a7c2012-01-04 07:53:47531void NavigationControllerImpl::GoToOffset(int offset) {
[email protected]9ba14052012-06-22 23:50:03532 if (!CanGoToOffset(offset))
[email protected]765b35502008-08-21 00:51:20533 return;
534
[email protected]9ba14052012-06-22 23:50:03535 GoToIndex(GetIndexForOffset(offset));
[email protected]765b35502008-08-21 00:51:20536}
537
[email protected]d202a7c2012-01-04 07:53:47538void NavigationControllerImpl::RemoveEntryAtIndex(int index) {
[email protected]6a13a6c2011-12-20 21:47:12539 if (index == last_committed_entry_index_)
540 return;
541
[email protected]43032342011-03-21 14:10:31542 RemoveEntryAtIndexInternal(index);
[email protected]cbab76d2008-10-13 22:42:47543}
544
[email protected]d202a7c2012-01-04 07:53:47545void NavigationControllerImpl::UpdateVirtualURLToURL(
[email protected]10f417c52011-12-28 21:04:23546 NavigationEntryImpl* entry, const GURL& new_url) {
[email protected]38178a42009-12-17 18:58:32547 GURL new_virtual_url(new_url);
[email protected]825b1662012-03-12 19:07:31548 if (BrowserURLHandlerImpl::GetInstance()->ReverseURLRewrite(
[email protected]36fc0392011-12-25 03:59:51549 &new_virtual_url, entry->GetVirtualURL(), browser_context_)) {
550 entry->SetVirtualURL(new_virtual_url);
[email protected]38178a42009-12-17 18:58:32551 }
552}
553
[email protected]d202a7c2012-01-04 07:53:47554void NavigationControllerImpl::AddTransientEntry(NavigationEntryImpl* entry) {
[email protected]cbab76d2008-10-13 22:42:47555 // Discard any current transient entry, we can only have one at a time.
556 int index = 0;
557 if (last_committed_entry_index_ != -1)
558 index = last_committed_entry_index_ + 1;
559 DiscardTransientEntry();
[email protected]10f417c52011-12-28 21:04:23560 entries_.insert(
561 entries_.begin() + index, linked_ptr<NavigationEntryImpl>(entry));
[email protected]e1cd5452010-08-26 18:03:25562 transient_entry_index_ = index;
[email protected]2db9bd72012-04-13 20:20:56563 web_contents_->NotifyNavigationStateChanged(kInvalidateAll);
[email protected]cbab76d2008-10-13 22:42:47564}
565
[email protected]d202a7c2012-01-04 07:53:47566void NavigationControllerImpl::TransferURL(
[email protected]4ad5d77d2011-12-03 02:00:48567 const GURL& url,
[email protected]95dacd02011-12-05 10:35:26568 const content::Referrer& referrer,
[email protected]4ad5d77d2011-12-03 02:00:48569 content::PageTransition transition,
570 const std::string& extra_headers,
571 const GlobalRequestID& transferred_global_request_id,
572 bool is_renderer_initiated) {
573 // The user initiated a load, we don't need to reload anymore.
574 needs_reload_ = false;
575
[email protected]71fde352011-12-29 03:29:56576 NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
577 CreateNavigationEntry(
578 url, referrer, transition, is_renderer_initiated, extra_headers,
579 browser_context_));
[email protected]4ad5d77d2011-12-03 02:00:48580 entry->set_transferred_global_request_id(transferred_global_request_id);
581
582 LoadEntry(entry);
583}
584
[email protected]d202a7c2012-01-04 07:53:47585void NavigationControllerImpl::LoadURL(
[email protected]6c6b02d2011-09-02 03:36:47586 const GURL& url,
[email protected]95dacd02011-12-05 10:35:26587 const content::Referrer& referrer,
[email protected]2905f742011-10-13 03:51:58588 content::PageTransition transition,
[email protected]6c6b02d2011-09-02 03:36:47589 const std::string& extra_headers) {
[email protected]8bf1048012012-02-08 01:22:18590 if (content::HandleDebugURL(url, transition))
591 return;
592
[email protected]bf70edce2012-06-20 22:32:22593 bool override = ShouldKeepOverride(GetLastCommittedEntry());
594 LoadURLWithUserAgentOverride(url, referrer, transition, false, extra_headers,
595 override);
[email protected]e47ae9472011-10-13 19:48:34596}
597
[email protected]d202a7c2012-01-04 07:53:47598void NavigationControllerImpl::LoadURLFromRenderer(
[email protected]e47ae9472011-10-13 19:48:34599 const GURL& url,
[email protected]95dacd02011-12-05 10:35:26600 const content::Referrer& referrer,
[email protected]e47ae9472011-10-13 19:48:34601 content::PageTransition transition,
602 const std::string& extra_headers) {
[email protected]bf70edce2012-06-20 22:32:22603 bool override = ShouldKeepOverride(GetLastCommittedEntry());
604 LoadURLWithUserAgentOverride(url, referrer, transition, true, extra_headers,
605 override);
606}
607
608void NavigationControllerImpl::LoadURLWithUserAgentOverride(
609 const GURL& url,
610 const content::Referrer& referrer,
611 content::PageTransition transition,
612 bool is_renderer_initiated,
613 const std::string& extra_headers,
614 bool is_overriding_user_agent) {
[email protected]e47ae9472011-10-13 19:48:34615 // The user initiated a load, we don't need to reload anymore.
616 needs_reload_ = false;
617
[email protected]71fde352011-12-29 03:29:56618 NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
619 CreateNavigationEntry(
[email protected]bf70edce2012-06-20 22:32:22620 url, referrer, transition, is_renderer_initiated, extra_headers,
621 browser_context_));
622 entry->SetIsOverridingUserAgent(is_overriding_user_agent);
initial.commit09911bf2008-07-26 23:55:29623
624 LoadEntry(entry);
625}
626
[email protected]d1ef81d2012-07-24 11:39:36627void NavigationControllerImpl::LoadDataWithBaseURL(
628 const GURL& data_url,
629 const content::Referrer& referrer,
630 const GURL& base_url,
631 const GURL& history_url,
632 bool is_overriding_user_agent) {
633 // Make sure we don't allow non-'data:' URLs.
634 if (!data_url.SchemeIs(chrome::kDataScheme)) {
635 NOTREACHED();
636 return;
637 }
638
639 needs_reload_ = false;
640
641 NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
642 CreateNavigationEntry(
643 data_url,
644 referrer,
645 content::PAGE_TRANSITION_TYPED,
646 false,
647 std::string(),
648 browser_context_));
649 entry->SetIsOverridingUserAgent(is_overriding_user_agent);
650 entry->SetBaseURLForDataURL(base_url);
651 entry->SetVirtualURL(history_url);
652
653 LoadEntry(entry);
654}
655
[email protected]132e281a2012-07-31 18:32:44656void NavigationControllerImpl::PostURL(
657 const GURL& url,
658 const content::Referrer& referrer,
659 const base::RefCountedMemory& http_body,
660 bool is_overriding_user_agent) {
661 // Must be http scheme for a post request.
662 if (!url.SchemeIs(chrome::kHttpScheme) &&
663 !url.SchemeIs(chrome::kHttpsScheme)) {
664 NOTREACHED();
665 return;
666 }
667
668 needs_reload_ = false;
669
670 NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
671 CreateNavigationEntry(
672 url,
673 referrer,
674 content::PAGE_TRANSITION_TYPED,
675 false,
676 std::string(),
677 browser_context_));
678 entry->SetIsOverridingUserAgent(is_overriding_user_agent);
679 entry->SetHasPostData(true);
680 entry->SetBrowserInitiatedPostData(&http_body);
681
682 LoadEntry(entry);
683}
684
[email protected]d202a7c2012-01-04 07:53:47685void NavigationControllerImpl::DocumentLoadedInFrame() {
[email protected]09b8f82f2009-06-16 20:22:11686 last_document_loaded_ = base::TimeTicks::Now();
687}
688
[email protected]d202a7c2012-01-04 07:53:47689bool NavigationControllerImpl::RendererDidNavigate(
[email protected]e9ba4472008-09-14 15:42:43690 const ViewHostMsg_FrameNavigate_Params& params,
[email protected]8286f51a2011-05-31 17:39:13691 content::LoadCommittedDetails* details) {
[email protected]4bf3522c2010-08-19 21:00:20692
[email protected]0e8db942008-09-24 21:21:48693 // Save the previous state before we clobber it.
694 if (GetLastCommittedEntry()) {
[email protected]36fc0392011-12-25 03:59:51695 details->previous_url = GetLastCommittedEntry()->GetURL();
[email protected]a26023822011-12-29 00:23:55696 details->previous_entry_index = GetLastCommittedEntryIndex();
[email protected]0e8db942008-09-24 21:21:48697 } else {
698 details->previous_url = GURL();
699 details->previous_entry_index = -1;
700 }
[email protected]ecd9d8702008-08-28 22:10:17701
[email protected]77362eb2011-08-01 17:18:38702 // If we have a pending entry at this point, it should have a SiteInstance.
703 // Restored entries start out with a null SiteInstance, but we should have
704 // assigned one in NavigateToPendingEntry.
705 DCHECK(pending_entry_index_ == -1 || pending_entry_->site_instance());
[email protected]e9ba4472008-09-14 15:42:43706
[email protected]bcd904482012-02-01 01:54:22707 // If we are doing a cross-site reload, we need to replace the existing
708 // navigation entry, not add another entry to the history. This has the side
709 // effect of removing forward browsing history, if such existed.
710 if (pending_entry_ != NULL) {
711 details->did_replace_entry = pending_entry_->is_cross_site_reload();
712 }
713
[email protected]192d8c5e2010-02-23 07:26:32714 // is_in_page must be computed before the entry gets committed.
715 details->is_in_page = IsURLInPageNavigation(params.url);
716
[email protected]e9ba4472008-09-14 15:42:43717 // Do navigation-type specific actions. These will make and commit an entry.
[email protected]0e8db942008-09-24 21:21:48718 details->type = ClassifyNavigation(params);
[email protected]4bf3522c2010-08-19 21:00:20719
[email protected]0e8db942008-09-24 21:21:48720 switch (details->type) {
[email protected]610cbb82011-10-18 16:35:08721 case content::NAVIGATION_TYPE_NEW_PAGE:
[email protected]befd8d822009-07-01 04:51:47722 RendererDidNavigateToNewPage(params, &(details->did_replace_entry));
[email protected]e9ba4472008-09-14 15:42:43723 break;
[email protected]610cbb82011-10-18 16:35:08724 case content::NAVIGATION_TYPE_EXISTING_PAGE:
[email protected]e9ba4472008-09-14 15:42:43725 RendererDidNavigateToExistingPage(params);
726 break;
[email protected]610cbb82011-10-18 16:35:08727 case content::NAVIGATION_TYPE_SAME_PAGE:
[email protected]e9ba4472008-09-14 15:42:43728 RendererDidNavigateToSamePage(params);
729 break;
[email protected]610cbb82011-10-18 16:35:08730 case content::NAVIGATION_TYPE_IN_PAGE:
[email protected]befd8d822009-07-01 04:51:47731 RendererDidNavigateInPage(params, &(details->did_replace_entry));
[email protected]e9ba4472008-09-14 15:42:43732 break;
[email protected]610cbb82011-10-18 16:35:08733 case content::NAVIGATION_TYPE_NEW_SUBFRAME:
[email protected]e9ba4472008-09-14 15:42:43734 RendererDidNavigateNewSubframe(params);
735 break;
[email protected]610cbb82011-10-18 16:35:08736 case content::NAVIGATION_TYPE_AUTO_SUBFRAME:
[email protected]e9ba4472008-09-14 15:42:43737 if (!RendererDidNavigateAutoSubframe(params))
738 return false;
739 break;
[email protected]610cbb82011-10-18 16:35:08740 case content::NAVIGATION_TYPE_NAV_IGNORE:
[email protected]20d1c992011-04-12 21:17:49741 // If a pending navigation was in progress, this canceled it. We should
742 // discard it and make sure it is removed from the URL bar. After that,
743 // there is nothing we can do with this navigation, so we just return to
[email protected]e9ba4472008-09-14 15:42:43744 // the caller that nothing has happened.
[email protected]20d1c992011-04-12 21:17:49745 if (pending_entry_) {
746 DiscardNonCommittedEntries();
[email protected]2db9bd72012-04-13 20:20:56747 web_contents_->NotifyNavigationStateChanged(
[email protected]d9083482012-01-06 00:38:46748 content::INVALIDATE_TYPE_URL);
[email protected]20d1c992011-04-12 21:17:49749 }
[email protected]e9ba4472008-09-14 15:42:43750 return false;
751 default:
752 NOTREACHED();
[email protected]765b35502008-08-21 00:51:20753 }
754
[email protected]e9ba4472008-09-14 15:42:43755 // All committed entries should have nonempty content state so WebKit doesn't
756 // get confused when we go back to them (see the function for details).
[email protected]0f38dc4552011-02-25 11:24:00757 DCHECK(!params.content_state.empty());
[email protected]10f417c52011-12-28 21:04:23758 NavigationEntryImpl* active_entry =
759 NavigationEntryImpl::FromNavigationEntry(GetActiveEntry());
[email protected]36fc0392011-12-25 03:59:51760 active_entry->SetContentState(params.content_state);
[email protected]132e281a2012-07-31 18:32:44761 // No longer needed since content state will hold the post data if any.
762 active_entry->SetBrowserInitiatedPostData(NULL);
763
[email protected]765b35502008-08-21 00:51:20764
[email protected]e47ae9472011-10-13 19:48:34765 // Once committed, we do not need to track if the entry was initiated by
766 // the renderer.
767 active_entry->set_is_renderer_initiated(false);
768
[email protected]49bd30e62011-03-22 20:12:59769 // The active entry's SiteInstance should match our SiteInstance.
[email protected]2db9bd72012-04-13 20:20:56770 DCHECK(active_entry->site_instance() == web_contents_->GetSiteInstance());
[email protected]49bd30e62011-03-22 20:12:59771
[email protected]e9ba4472008-09-14 15:42:43772 // Now prep the rest of the details for the notification and broadcast.
[email protected]0f38dc4552011-02-25 11:24:00773 details->entry = active_entry;
[email protected]2905f742011-10-13 03:51:58774 details->is_main_frame =
775 content::PageTransitionIsMainFrame(params.transition);
[email protected]f072d2ce2008-09-17 17:16:24776 details->serialized_security_info = params.security_info;
[email protected]2e39d2e2009-02-19 18:41:31777 details->http_status_code = params.http_status_code;
[email protected]93f230e02011-06-01 14:40:00778 NotifyNavigationEntryCommitted(details);
initial.commit09911bf2008-07-26 23:55:29779
[email protected]e9ba4472008-09-14 15:42:43780 return true;
initial.commit09911bf2008-07-26 23:55:29781}
782
[email protected]d202a7c2012-01-04 07:53:47783content::NavigationType NavigationControllerImpl::ClassifyNavigation(
[email protected]e9ba4472008-09-14 15:42:43784 const ViewHostMsg_FrameNavigate_Params& params) const {
[email protected]e9ba4472008-09-14 15:42:43785 if (params.page_id == -1) {
[email protected]eef9de32009-09-23 17:19:46786 // The renderer generates the page IDs, and so if it gives us the invalid
787 // page ID (-1) we know it didn't actually navigate. This happens in a few
788 // cases:
789 //
790 // - If a page makes a popup navigated to about blank, and then writes
791 // stuff like a subframe navigated to a real page. We'll get the commit
792 // for the subframe, but there won't be any commit for the outer page.
793 //
794 // - We were also getting these for failed loads (for example, bug 21849).
795 // The guess is that we get a "load commit" for the alternate error page,
796 // but that doesn't affect the page ID, so we get the "old" one, which
797 // could be invalid. This can also happen for a cross-site transition
798 // that causes us to swap processes. Then the error page load will be in
799 // a new process with no page IDs ever assigned (and hence a -1 value),
800 // yet the navigation controller still might have previous pages in its
801 // list.
802 //
803 // In these cases, there's nothing we can do with them, so ignore.
[email protected]610cbb82011-10-18 16:35:08804 return content::NAVIGATION_TYPE_NAV_IGNORE;
[email protected]e9ba4472008-09-14 15:42:43805 }
806
[email protected]2db9bd72012-04-13 20:20:56807 if (params.page_id > web_contents_->GetMaxPageID()) {
[email protected]e9ba4472008-09-14 15:42:43808 // Greater page IDs than we've ever seen before are new pages. We may or may
809 // not have a pending entry for the page, and this may or may not be the
810 // main frame.
[email protected]2905f742011-10-13 03:51:58811 if (content::PageTransitionIsMainFrame(params.transition))
[email protected]610cbb82011-10-18 16:35:08812 return content::NAVIGATION_TYPE_NEW_PAGE;
[email protected]4c27ba82008-09-24 16:49:09813
814 // When this is a new subframe navigation, we should have a committed page
815 // for which it's a suframe in. This may not be the case when an iframe is
816 // navigated on a popup navigated to about:blank (the iframe would be
817 // written into the popup by script on the main page). For these cases,
818 // there isn't any navigation stuff we can do, so just ignore it.
819 if (!GetLastCommittedEntry())
[email protected]610cbb82011-10-18 16:35:08820 return content::NAVIGATION_TYPE_NAV_IGNORE;
[email protected]4c27ba82008-09-24 16:49:09821
822 // Valid subframe navigation.
[email protected]610cbb82011-10-18 16:35:08823 return content::NAVIGATION_TYPE_NEW_SUBFRAME;
[email protected]e9ba4472008-09-14 15:42:43824 }
825
826 // Now we know that the notification is for an existing page. Find that entry.
827 int existing_entry_index = GetEntryIndexWithPageID(
[email protected]2db9bd72012-04-13 20:20:56828 web_contents_->GetSiteInstance(),
[email protected]e9ba4472008-09-14 15:42:43829 params.page_id);
830 if (existing_entry_index == -1) {
831 // The page was not found. It could have been pruned because of the limit on
832 // back/forward entries (not likely since we'll usually tell it to navigate
833 // to such entries). It could also mean that the renderer is smoking crack.
834 NOTREACHED();
[email protected]485e8232011-07-24 18:03:46835
836 // Because the unknown entry has committed, we risk showing the wrong URL in
837 // release builds. Instead, we'll kill the renderer process to be safe.
838 LOG(ERROR) << "terminating renderer for bad navigation: " << params.url;
[email protected]7f6f44c2011-12-14 13:23:38839 content::RecordAction(UserMetricsAction("BadMessageTerminate_NC"));
[email protected]b69934e2011-10-29 02:51:52840
[email protected]7ec6f382011-11-11 01:28:17841 // Temporary code so we can get more information. Format:
[email protected]8c380582011-12-02 03:16:10842 // http://url/foo.html#page1#max3#frame1#ids:2_Nx,1_1x,3_2
843 std::string temp = params.url.spec();
[email protected]7ec6f382011-11-11 01:28:17844 temp.append("#page");
[email protected]b69934e2011-10-29 02:51:52845 temp.append(base::IntToString(params.page_id));
[email protected]7ec6f382011-11-11 01:28:17846 temp.append("#max");
[email protected]2db9bd72012-04-13 20:20:56847 temp.append(base::IntToString(web_contents_->GetMaxPageID()));
[email protected]7ec6f382011-11-11 01:28:17848 temp.append("#frame");
849 temp.append(base::IntToString(params.frame_id));
850 temp.append("#ids");
851 for (int i = 0; i < static_cast<int>(entries_.size()); ++i) {
[email protected]8c380582011-12-02 03:16:10852 // Append entry metadata (e.g., 3_7x):
853 // 3: page_id
854 // 7: SiteInstance ID, or N for null
855 // x: appended if not from the current SiteInstance
[email protected]36fc0392011-12-25 03:59:51856 temp.append(base::IntToString(entries_[i]->GetPageID()));
[email protected]8c380582011-12-02 03:16:10857 temp.append("_");
858 if (entries_[i]->site_instance())
[email protected]b6583592012-01-25 19:52:33859 temp.append(base::IntToString(entries_[i]->site_instance()->GetId()));
[email protected]7ec6f382011-11-11 01:28:17860 else
[email protected]8c380582011-12-02 03:16:10861 temp.append("N");
[email protected]2db9bd72012-04-13 20:20:56862 if (entries_[i]->site_instance() != web_contents_->GetSiteInstance())
[email protected]7ec6f382011-11-11 01:28:17863 temp.append("x");
864 temp.append(",");
[email protected]b69934e2011-10-29 02:51:52865 }
866 GURL url(temp);
[email protected]9f76c1e2012-03-05 15:15:58867 static_cast<RenderViewHostImpl*>(
[email protected]2db9bd72012-04-13 20:20:56868 web_contents_->GetRenderViewHost())->Send(
[email protected]9f76c1e2012-03-05 15:15:58869 new ViewMsg_TempCrashWithData(url));
[email protected]b69934e2011-10-29 02:51:52870 return content::NAVIGATION_TYPE_NAV_IGNORE;
[email protected]e9ba4472008-09-14 15:42:43871 }
[email protected]10f417c52011-12-28 21:04:23872 NavigationEntryImpl* existing_entry = entries_[existing_entry_index].get();
[email protected]e9ba4472008-09-14 15:42:43873
[email protected]2905f742011-10-13 03:51:58874 if (!content::PageTransitionIsMainFrame(params.transition)) {
[email protected]e6035c22010-05-25 16:15:52875 // All manual subframes would get new IDs and were handled above, so we
876 // know this is auto. Since the current page was found in the navigation
877 // entry list, we're guaranteed to have a last committed entry.
878 DCHECK(GetLastCommittedEntry());
[email protected]610cbb82011-10-18 16:35:08879 return content::NAVIGATION_TYPE_AUTO_SUBFRAME;
[email protected]e6035c22010-05-25 16:15:52880 }
881
882 // Anything below here we know is a main frame navigation.
[email protected]e9ba4472008-09-14 15:42:43883 if (pending_entry_ &&
[email protected]e9ba4472008-09-14 15:42:43884 existing_entry != pending_entry_ &&
[email protected]36fc0392011-12-25 03:59:51885 pending_entry_->GetPageID() == -1 &&
[email protected]230c0012011-04-08 16:27:24886 existing_entry == GetLastCommittedEntry()) {
[email protected]e9ba4472008-09-14 15:42:43887 // In this case, we have a pending entry for a URL but WebCore didn't do a
888 // new navigation. This happens when you press enter in the URL bar to
889 // reload. We will create a pending entry, but WebKit will convert it to
890 // a reload since it's the same page and not create a new entry for it
891 // (the user doesn't want to have a new back/forward entry when they do
[email protected]230c0012011-04-08 16:27:24892 // this). If this matches the last committed entry, we want to just ignore
893 // the pending entry and go back to where we were (the "existing entry").
[email protected]610cbb82011-10-18 16:35:08894 return content::NAVIGATION_TYPE_SAME_PAGE;
[email protected]e9ba4472008-09-14 15:42:43895 }
896
[email protected]fc60f222008-12-18 17:36:54897 // Any toplevel navigations with the same base (minus the reference fragment)
898 // are in-page navigations. We weeded out subframe navigations above. Most of
899 // the time this doesn't matter since WebKit doesn't tell us about subframe
900 // navigations that don't actually navigate, but it can happen when there is
901 // an encoding override (it always sends a navigation request).
[email protected]36fc0392011-12-25 03:59:51902 if (AreURLsInPageNavigation(existing_entry->GetURL(), params.url))
[email protected]610cbb82011-10-18 16:35:08903 return content::NAVIGATION_TYPE_IN_PAGE;
[email protected]fc60f222008-12-18 17:36:54904
[email protected]e9ba4472008-09-14 15:42:43905 // Since we weeded out "new" navigations above, we know this is an existing
[email protected]4c27ba82008-09-24 16:49:09906 // (back/forward) navigation.
[email protected]610cbb82011-10-18 16:35:08907 return content::NAVIGATION_TYPE_EXISTING_PAGE;
[email protected]e9ba4472008-09-14 15:42:43908}
909
[email protected]d202a7c2012-01-04 07:53:47910bool NavigationControllerImpl::IsRedirect(
[email protected]09b8f82f2009-06-16 20:22:11911 const ViewHostMsg_FrameNavigate_Params& params) {
912 // For main frame transition, we judge by params.transition.
913 // Otherwise, by params.redirects.
[email protected]2905f742011-10-13 03:51:58914 if (content::PageTransitionIsMainFrame(params.transition)) {
915 return content::PageTransitionIsRedirect(params.transition);
[email protected]09b8f82f2009-06-16 20:22:11916 }
917 return params.redirects.size() > 1;
918}
919
[email protected]d202a7c2012-01-04 07:53:47920void NavigationControllerImpl::RendererDidNavigateToNewPage(
[email protected]befd8d822009-07-01 04:51:47921 const ViewHostMsg_FrameNavigate_Params& params, bool* did_replace_entry) {
[email protected]10f417c52011-12-28 21:04:23922 NavigationEntryImpl* new_entry;
[email protected]f1eb87a2011-05-06 17:49:41923 bool update_virtual_url;
[email protected]e9ba4472008-09-14 15:42:43924 if (pending_entry_) {
925 // TODO(brettw) this assumes that the pending entry is appropriate for the
926 // new page that was just loaded. I don't think this is necessarily the
[email protected]49bd30e62011-03-22 20:12:59927 // case! We should have some more tracking to know for sure.
[email protected]10f417c52011-12-28 21:04:23928 new_entry = new NavigationEntryImpl(*pending_entry_);
[email protected]e9ba4472008-09-14 15:42:43929
930 // Don't use the page type from the pending entry. Some interstitial page
931 // may have set the type to interstitial. Once we commit, however, the page
932 // type must always be normal.
[email protected]66fdbd52011-10-18 17:08:53933 new_entry->set_page_type(content::PAGE_TYPE_NORMAL);
[email protected]f1eb87a2011-05-06 17:49:41934 update_virtual_url = new_entry->update_virtual_url_with_url();
[email protected]e9ba4472008-09-14 15:42:43935 } else {
[email protected]10f417c52011-12-28 21:04:23936 new_entry = new NavigationEntryImpl;
[email protected]f1eb87a2011-05-06 17:49:41937 // When navigating to a new page, give the browser URL handler a chance to
938 // update the virtual URL based on the new URL. For example, this is needed
939 // to show chrome://bookmarks/#1 when the bookmarks webui extension changes
940 // the URL.
941 update_virtual_url = true;
[email protected]e9ba4472008-09-14 15:42:43942 }
943
[email protected]ad23a092011-12-28 07:02:04944 new_entry->SetURL(params.url);
[email protected]f1eb87a2011-05-06 17:49:41945 if (update_virtual_url)
[email protected]38178a42009-12-17 18:58:32946 UpdateVirtualURLToURL(new_entry, params.url);
[email protected]022af742011-12-28 18:37:25947 new_entry->SetReferrer(params.referrer);
[email protected]36fc0392011-12-25 03:59:51948 new_entry->SetPageID(params.page_id);
[email protected]022af742011-12-28 18:37:25949 new_entry->SetTransitionType(params.transition);
[email protected]b6583592012-01-25 19:52:33950 new_entry->set_site_instance(
[email protected]2db9bd72012-04-13 20:20:56951 static_cast<SiteInstanceImpl*>(web_contents_->GetSiteInstance()));
[email protected]36fc0392011-12-25 03:59:51952 new_entry->SetHasPostData(params.is_post);
[email protected]86cd9472012-02-03 19:51:05953 new_entry->SetPostID(params.post_id);
[email protected]7c16976c2012-08-04 02:38:23954 new_entry->SetOriginalRequestURL(params.original_request_url);
[email protected]bf70edce2012-06-20 22:32:22955 new_entry->SetIsOverridingUserAgent(params.is_overriding_user_agent);
[email protected]e9ba4472008-09-14 15:42:43956
[email protected]befd8d822009-07-01 04:51:47957 InsertOrReplaceEntry(new_entry, *did_replace_entry);
[email protected]e9ba4472008-09-14 15:42:43958}
959
[email protected]d202a7c2012-01-04 07:53:47960void NavigationControllerImpl::RendererDidNavigateToExistingPage(
[email protected]e9ba4472008-09-14 15:42:43961 const ViewHostMsg_FrameNavigate_Params& params) {
962 // We should only get here for main frame navigations.
[email protected]2905f742011-10-13 03:51:58963 DCHECK(content::PageTransitionIsMainFrame(params.transition));
[email protected]e9ba4472008-09-14 15:42:43964
965 // This is a back/forward navigation. The existing page for the ID is
[email protected]4c27ba82008-09-24 16:49:09966 // guaranteed to exist by ClassifyNavigation, and we just need to update it
967 // with new information from the renderer.
[email protected]2db9bd72012-04-13 20:20:56968 int entry_index = GetEntryIndexWithPageID(web_contents_->GetSiteInstance(),
[email protected]7f0005a2009-04-15 03:25:11969 params.page_id);
[email protected]e9ba4472008-09-14 15:42:43970 DCHECK(entry_index >= 0 &&
971 entry_index < static_cast<int>(entries_.size()));
[email protected]10f417c52011-12-28 21:04:23972 NavigationEntryImpl* entry = entries_[entry_index].get();
[email protected]e9ba4472008-09-14 15:42:43973
974 // The URL may have changed due to redirects. The site instance will normally
975 // be the same except during session restore, when no site instance will be
976 // assigned.
[email protected]ad23a092011-12-28 07:02:04977 entry->SetURL(params.url);
[email protected]38178a42009-12-17 18:58:32978 if (entry->update_virtual_url_with_url())
979 UpdateVirtualURLToURL(entry, params.url);
[email protected]e9ba4472008-09-14 15:42:43980 DCHECK(entry->site_instance() == NULL ||
[email protected]2db9bd72012-04-13 20:20:56981 entry->site_instance() == web_contents_->GetSiteInstance());
[email protected]b6583592012-01-25 19:52:33982 entry->set_site_instance(
[email protected]2db9bd72012-04-13 20:20:56983 static_cast<SiteInstanceImpl*>(web_contents_->GetSiteInstance()));
[email protected]e9ba4472008-09-14 15:42:43984
[email protected]36fc0392011-12-25 03:59:51985 entry->SetHasPostData(params.is_post);
[email protected]86cd9472012-02-03 19:51:05986 entry->SetPostID(params.post_id);
[email protected]d5a49e52010-01-08 03:01:41987
[email protected]e9ba4472008-09-14 15:42:43988 // The entry we found in the list might be pending if the user hit
989 // back/forward/reload. This load should commit it (since it's already in the
[email protected]49bd30e62011-03-22 20:12:59990 // list, we can just discard the pending pointer). We should also discard the
991 // pending entry if it corresponds to a different navigation, since that one
992 // is now likely canceled. If it is not canceled, we will treat it as a new
993 // navigation when it arrives, which is also ok.
[email protected]e9ba4472008-09-14 15:42:43994 //
995 // Note that we need to use the "internal" version since we don't want to
996 // actually change any other state, just kill the pointer.
[email protected]49bd30e62011-03-22 20:12:59997 if (pending_entry_)
[email protected]cbab76d2008-10-13 22:42:47998 DiscardNonCommittedEntriesInternal();
[email protected]40bcc302009-03-02 20:50:39999
[email protected]80858db52009-10-15 00:35:181000 // If a transient entry was removed, the indices might have changed, so we
1001 // have to query the entry index again.
1002 last_committed_entry_index_ =
[email protected]2db9bd72012-04-13 20:20:561003 GetEntryIndexWithPageID(web_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:431004}
1005
[email protected]d202a7c2012-01-04 07:53:471006void NavigationControllerImpl::RendererDidNavigateToSamePage(
[email protected]e9ba4472008-09-14 15:42:431007 const ViewHostMsg_FrameNavigate_Params& params) {
1008 // This mode implies we have a pending entry that's the same as an existing
[email protected]4c27ba82008-09-24 16:49:091009 // entry for this page ID. This entry is guaranteed to exist by
1010 // ClassifyNavigation. All we need to do is update the existing entry.
[email protected]10f417c52011-12-28 21:04:231011 NavigationEntryImpl* existing_entry = GetEntryWithPageID(
[email protected]2db9bd72012-04-13 20:20:561012 web_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:431013
1014 // We assign the entry's unique ID to be that of the new one. Since this is
1015 // always the result of a user action, we want to dismiss infobars, etc. like
1016 // a regular user-initiated navigation.
[email protected]36fc0392011-12-25 03:59:511017 existing_entry->set_unique_id(pending_entry_->GetUniqueID());
[email protected]e9ba4472008-09-14 15:42:431018
[email protected]a0e69262009-06-03 19:08:481019 // The URL may have changed due to redirects.
[email protected]38178a42009-12-17 18:58:321020 if (existing_entry->update_virtual_url_with_url())
1021 UpdateVirtualURLToURL(existing_entry, params.url);
[email protected]ad23a092011-12-28 07:02:041022 existing_entry->SetURL(params.url);
[email protected]a0e69262009-06-03 19:08:481023
[email protected]cbab76d2008-10-13 22:42:471024 DiscardNonCommittedEntries();
[email protected]e9ba4472008-09-14 15:42:431025}
1026
[email protected]d202a7c2012-01-04 07:53:471027void NavigationControllerImpl::RendererDidNavigateInPage(
[email protected]befd8d822009-07-01 04:51:471028 const ViewHostMsg_FrameNavigate_Params& params, bool* did_replace_entry) {
[email protected]2905f742011-10-13 03:51:581029 DCHECK(content::PageTransitionIsMainFrame(params.transition)) <<
[email protected]e9ba4472008-09-14 15:42:431030 "WebKit should only tell us about in-page navs for the main frame.";
1031 // We're guaranteed to have an entry for this one.
[email protected]10f417c52011-12-28 21:04:231032 NavigationEntryImpl* existing_entry = GetEntryWithPageID(
[email protected]2db9bd72012-04-13 20:20:561033 web_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:431034
1035 // Reference fragment navigation. We're guaranteed to have the last_committed
1036 // entry and it will be the same page as the new navigation (minus the
[email protected]d466b8a2011-07-15 21:48:031037 // reference fragments, of course). We'll update the URL of the existing
1038 // entry without pruning the forward history.
[email protected]ad23a092011-12-28 07:02:041039 existing_entry->SetURL(params.url);
[email protected]d466b8a2011-07-15 21:48:031040 if (existing_entry->update_virtual_url_with_url())
1041 UpdateVirtualURLToURL(existing_entry, params.url);
[email protected]ccbe04e2010-03-17 17:58:431042
1043 // This replaces the existing entry since the page ID didn't change.
1044 *did_replace_entry = true;
[email protected]d466b8a2011-07-15 21:48:031045
1046 if (pending_entry_)
1047 DiscardNonCommittedEntriesInternal();
1048
1049 // If a transient entry was removed, the indices might have changed, so we
1050 // have to query the entry index again.
1051 last_committed_entry_index_ =
[email protected]2db9bd72012-04-13 20:20:561052 GetEntryIndexWithPageID(web_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:431053}
1054
[email protected]d202a7c2012-01-04 07:53:471055void NavigationControllerImpl::RendererDidNavigateNewSubframe(
[email protected]e9ba4472008-09-14 15:42:431056 const ViewHostMsg_FrameNavigate_Params& params) {
[email protected]2905f742011-10-13 03:51:581057 if (content::PageTransitionStripQualifier(params.transition) ==
1058 content::PAGE_TRANSITION_AUTO_SUBFRAME) {
[email protected]09b8f82f2009-06-16 20:22:111059 // This is not user-initiated. Ignore.
1060 return;
1061 }
[email protected]09b8f82f2009-06-16 20:22:111062
[email protected]e9ba4472008-09-14 15:42:431063 // Manual subframe navigations just get the current entry cloned so the user
1064 // can go back or forward to it. The actual subframe information will be
1065 // stored in the page state for each of those entries. This happens out of
1066 // band with the actual navigations.
[email protected]4c27ba82008-09-24 16:49:091067 DCHECK(GetLastCommittedEntry()) << "ClassifyNavigation should guarantee "
1068 << "that a last committed entry exists.";
[email protected]10f417c52011-12-28 21:04:231069 NavigationEntryImpl* new_entry = new NavigationEntryImpl(
1070 *NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry()));
[email protected]36fc0392011-12-25 03:59:511071 new_entry->SetPageID(params.page_id);
[email protected]672eba292009-05-13 13:22:451072 InsertOrReplaceEntry(new_entry, false);
[email protected]e9ba4472008-09-14 15:42:431073}
1074
[email protected]d202a7c2012-01-04 07:53:471075bool NavigationControllerImpl::RendererDidNavigateAutoSubframe(
[email protected]e9ba4472008-09-14 15:42:431076 const ViewHostMsg_FrameNavigate_Params& params) {
1077 // We're guaranteed to have a previously committed entry, and we now need to
1078 // handle navigation inside of a subframe in it without creating a new entry.
1079 DCHECK(GetLastCommittedEntry());
1080
1081 // Handle the case where we're navigating back/forward to a previous subframe
1082 // navigation entry. This is case "2." in NAV_AUTO_SUBFRAME comment in the
1083 // header file. In case "1." this will be a NOP.
1084 int entry_index = GetEntryIndexWithPageID(
[email protected]2db9bd72012-04-13 20:20:561085 web_contents_->GetSiteInstance(),
[email protected]e9ba4472008-09-14 15:42:431086 params.page_id);
1087 if (entry_index < 0 ||
1088 entry_index >= static_cast<int>(entries_.size())) {
1089 NOTREACHED();
1090 return false;
1091 }
1092
1093 // Update the current navigation entry in case we're going back/forward.
1094 if (entry_index != last_committed_entry_index_) {
[email protected]e9ba4472008-09-14 15:42:431095 last_committed_entry_index_ = entry_index;
[email protected]e9ba4472008-09-14 15:42:431096 return true;
1097 }
1098 return false;
1099}
1100
[email protected]d202a7c2012-01-04 07:53:471101int NavigationControllerImpl::GetIndexOfEntry(
[email protected]10f417c52011-12-28 21:04:231102 const NavigationEntryImpl* entry) const {
[email protected]765b35502008-08-21 00:51:201103 const NavigationEntries::const_iterator i(std::find(
1104 entries_.begin(),
1105 entries_.end(),
1106 entry));
1107 return (i == entries_.end()) ? -1 : static_cast<int>(i - entries_.begin());
1108}
1109
[email protected]d202a7c2012-01-04 07:53:471110bool NavigationControllerImpl::IsURLInPageNavigation(const GURL& url) const {
[email protected]10f417c52011-12-28 21:04:231111 NavigationEntry* last_committed = GetLastCommittedEntry();
[email protected]e9ba4472008-09-14 15:42:431112 if (!last_committed)
1113 return false;
[email protected]36fc0392011-12-25 03:59:511114 return AreURLsInPageNavigation(last_committed->GetURL(), url);
[email protected]e9ba4472008-09-14 15:42:431115}
1116
[email protected]d202a7c2012-01-04 07:53:471117void NavigationControllerImpl::CopyStateFrom(
[email protected]c5eed492012-01-04 17:07:501118 const NavigationController& temp) {
[email protected]d202a7c2012-01-04 07:53:471119 const NavigationControllerImpl& source =
1120 static_cast<const NavigationControllerImpl&>(temp);
[email protected]ce3fa3c2009-04-20 19:55:571121 // Verify that we look new.
[email protected]a26023822011-12-29 00:23:551122 DCHECK(GetEntryCount() == 0 && !GetPendingEntry());
[email protected]ce3fa3c2009-04-20 19:55:571123
[email protected]a26023822011-12-29 00:23:551124 if (source.GetEntryCount() == 0)
[email protected]ce3fa3c2009-04-20 19:55:571125 return; // Nothing new to do.
1126
1127 needs_reload_ = true;
[email protected]a26023822011-12-29 00:23:551128 InsertEntriesFrom(source, source.GetEntryCount());
[email protected]ce3fa3c2009-04-20 19:55:571129
[email protected]d1198fd2012-08-13 22:50:191130 for (SessionStorageNamespaceMap::const_iterator it =
1131 source.session_storage_namespace_map_.begin();
1132 it != source.session_storage_namespace_map_.end();
1133 ++it) {
1134 SessionStorageNamespaceImpl* source_namespace =
1135 static_cast<SessionStorageNamespaceImpl*>(it->second.get());
1136 session_storage_namespace_map_.insert(
1137 make_pair(it->first, source_namespace->Clone()));
1138 }
[email protected]4e6419c2010-01-15 04:50:341139
[email protected]5e369672009-11-03 23:48:301140 FinishRestore(source.last_committed_entry_index_, false);
[email protected]91854cd2012-01-10 19:43:571141
1142 // Copy the max page id map from the old tab to the new tab. This ensures
1143 // that new and existing navigations in the tab's current SiteInstances
1144 // are identified properly.
[email protected]2db9bd72012-04-13 20:20:561145 web_contents_->CopyMaxPageIDsFrom(source.web_contents());
[email protected]ce3fa3c2009-04-20 19:55:571146}
1147
[email protected]d202a7c2012-01-04 07:53:471148void NavigationControllerImpl::CopyStateFromAndPrune(
[email protected]c5eed492012-01-04 17:07:501149 NavigationController* temp) {
[email protected]d202a7c2012-01-04 07:53:471150 NavigationControllerImpl* source =
1151 static_cast<NavigationControllerImpl*>(temp);
[email protected]9e1ad4b2011-08-14 16:49:191152 // The SiteInstance and page_id of the last committed entry needs to be
1153 // remembered at this point, in case there is only one committed entry
[email protected]91854cd2012-01-10 19:43:571154 // and it is pruned. We use a scoped_refptr to ensure the SiteInstance
1155 // can't be freed during this time period.
[email protected]10f417c52011-12-28 21:04:231156 NavigationEntryImpl* last_committed =
1157 NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry());
[email protected]91854cd2012-01-10 19:43:571158 scoped_refptr<SiteInstance> site_instance(
1159 last_committed ? last_committed->site_instance() : NULL);
[email protected]36fc0392011-12-25 03:59:511160 int32 minimum_page_id = last_committed ? last_committed->GetPageID() : -1;
[email protected]91854cd2012-01-10 19:43:571161 int32 max_page_id = last_committed ?
[email protected]2db9bd72012-04-13 20:20:561162 web_contents_->GetMaxPageIDForSiteInstance(site_instance.get()) : -1;
[email protected]9e1ad4b2011-08-14 16:49:191163
[email protected]e1cd5452010-08-26 18:03:251164 // This code is intended for use when the last entry is the active entry.
[email protected]a26023822011-12-29 00:23:551165 DCHECK(
1166 (transient_entry_index_ != -1 &&
[email protected]91854cd2012-01-10 19:43:571167 transient_entry_index_ == GetEntryCount() - 1) ||
[email protected]a26023822011-12-29 00:23:551168 (pending_entry_ && (pending_entry_index_ == -1 ||
1169 pending_entry_index_ == GetEntryCount() - 1)) ||
1170 (!pending_entry_ && last_committed_entry_index_ == GetEntryCount() - 1));
[email protected]e1cd5452010-08-26 18:03:251171
1172 // Remove all the entries leaving the active entry.
1173 PruneAllButActive();
1174
[email protected]944822b2012-03-02 20:57:251175 // We now have zero or one entries. Ensure that adding the entries from
1176 // source won't put us over the limit.
1177 DCHECK(GetEntryCount() == 0 || GetEntryCount() == 1);
1178 if (GetEntryCount() > 0)
1179 source->PruneOldestEntryIfFull();
1180
[email protected]47e020a2010-10-15 14:43:371181 // Insert the entries from source. Don't use source->GetCurrentEntryIndex as
[email protected]e1cd5452010-08-26 18:03:251182 // we don't want to copy over the transient entry.
[email protected]47e020a2010-10-15 14:43:371183 int max_source_index = source->pending_entry_index_ != -1 ?
1184 source->pending_entry_index_ : source->last_committed_entry_index_;
[email protected]e1cd5452010-08-26 18:03:251185 if (max_source_index == -1)
[email protected]a26023822011-12-29 00:23:551186 max_source_index = source->GetEntryCount();
[email protected]e1cd5452010-08-26 18:03:251187 else
1188 max_source_index++;
[email protected]47e020a2010-10-15 14:43:371189 InsertEntriesFrom(*source, max_source_index);
[email protected]e1cd5452010-08-26 18:03:251190
1191 // Adjust indices such that the last entry and pending are at the end now.
[email protected]a26023822011-12-29 00:23:551192 last_committed_entry_index_ = GetEntryCount() - 1;
[email protected]e1cd5452010-08-26 18:03:251193 if (pending_entry_index_ != -1)
[email protected]a26023822011-12-29 00:23:551194 pending_entry_index_ = GetEntryCount() - 1;
[email protected]e1cd5452010-08-26 18:03:251195 if (transient_entry_index_ != -1) {
1196 // There's a transient entry. In this case we want the last committed to
1197 // point to the previous entry.
[email protected]a26023822011-12-29 00:23:551198 transient_entry_index_ = GetEntryCount() - 1;
[email protected]e1cd5452010-08-26 18:03:251199 if (last_committed_entry_index_ != -1)
1200 last_committed_entry_index_--;
1201 }
[email protected]796931a92011-08-10 01:32:141202
[email protected]2db9bd72012-04-13 20:20:561203 web_contents_->SetHistoryLengthAndPrune(site_instance.get(),
[email protected]9e1ad4b2011-08-14 16:49:191204 max_source_index,
1205 minimum_page_id);
[email protected]91854cd2012-01-10 19:43:571206
1207 // Copy the max page id map from the old tab to the new tab. This ensures
1208 // that new and existing navigations in the tab's current SiteInstances
1209 // are identified properly.
[email protected]2db9bd72012-04-13 20:20:561210 web_contents_->CopyMaxPageIDsFrom(source->web_contents());
[email protected]91854cd2012-01-10 19:43:571211
1212 // If there is a last committed entry, be sure to include it in the new
1213 // max page ID map.
1214 if (max_page_id > -1) {
[email protected]2db9bd72012-04-13 20:20:561215 web_contents_->UpdateMaxPageIDForSiteInstance(site_instance.get(),
[email protected]91854cd2012-01-10 19:43:571216 max_page_id);
1217 }
[email protected]e1cd5452010-08-26 18:03:251218}
1219
[email protected]d202a7c2012-01-04 07:53:471220void NavigationControllerImpl::PruneAllButActive() {
[email protected]97b6c4f2010-09-27 19:31:261221 if (transient_entry_index_ != -1) {
1222 // There is a transient entry. Prune up to it.
[email protected]a26023822011-12-29 00:23:551223 DCHECK_EQ(GetEntryCount() - 1, transient_entry_index_);
[email protected]77d8d622010-12-15 10:30:121224 entries_.erase(entries_.begin(), entries_.begin() + transient_entry_index_);
[email protected]97b6c4f2010-09-27 19:31:261225 transient_entry_index_ = 0;
1226 last_committed_entry_index_ = -1;
1227 pending_entry_index_ = -1;
1228 } else if (!pending_entry_) {
1229 // There's no pending entry. Leave the last entry (if there is one).
[email protected]a26023822011-12-29 00:23:551230 if (!GetEntryCount())
[email protected]97b6c4f2010-09-27 19:31:261231 return;
1232
[email protected]77d8d622010-12-15 10:30:121233 DCHECK(last_committed_entry_index_ >= 0);
1234 entries_.erase(entries_.begin(),
1235 entries_.begin() + last_committed_entry_index_);
1236 entries_.erase(entries_.begin() + 1, entries_.end());
[email protected]97b6c4f2010-09-27 19:31:261237 last_committed_entry_index_ = 0;
1238 } else if (pending_entry_index_ != -1) {
[email protected]77d8d622010-12-15 10:30:121239 entries_.erase(entries_.begin(), entries_.begin() + pending_entry_index_);
1240 entries_.erase(entries_.begin() + 1, entries_.end());
[email protected]97b6c4f2010-09-27 19:31:261241 pending_entry_index_ = 0;
1242 last_committed_entry_index_ = 0;
[email protected]97b6c4f2010-09-27 19:31:261243 } else {
1244 // There is a pending_entry, but it's not in entries_.
1245 pending_entry_index_ = -1;
1246 last_committed_entry_index_ = -1;
[email protected]77d8d622010-12-15 10:30:121247 entries_.clear();
[email protected]97b6c4f2010-09-27 19:31:261248 }
1249
[email protected]2db9bd72012-04-13 20:20:561250 if (web_contents_->GetInterstitialPage()) {
[email protected]97b6c4f2010-09-27 19:31:261251 // Normally the interstitial page hides itself if the user doesn't proceeed.
1252 // This would result in showing a NavigationEntry we just removed. Set this
1253 // so the interstitial triggers a reload if the user doesn't proceed.
[email protected]2db9bd72012-04-13 20:20:561254 static_cast<InterstitialPageImpl*>(web_contents_->GetInterstitialPage())->
[email protected]cadaec52012-02-08 21:53:131255 set_reload_on_dont_proceed(true);
[email protected]97b6c4f2010-09-27 19:31:261256 }
[email protected]97b6c4f2010-09-27 19:31:261257}
1258
[email protected]d1198fd2012-08-13 22:50:191259void NavigationControllerImpl::SetSessionStorageNamespace(
1260 const std::string& partition_id,
1261 content::SessionStorageNamespace* session_storage_namespace) {
1262 if (!session_storage_namespace)
1263 return;
1264
1265 // We can't overwrite an existing SessionStorage without violating spec.
1266 // Attempts to do so may give a tab access to another tab's session storage
1267 // so die hard on an error.
1268 bool successful_insert = session_storage_namespace_map_.insert(
1269 make_pair(partition_id,
1270 static_cast<SessionStorageNamespaceImpl*>(
1271 session_storage_namespace)))
1272 .second;
1273 CHECK(successful_insert) << "Cannot replace existing SessionStorageNamespace";
1274}
1275
[email protected]d202a7c2012-01-04 07:53:471276void NavigationControllerImpl::SetMaxRestoredPageID(int32 max_id) {
[email protected]71fde352011-12-29 03:29:561277 max_restored_page_id_ = max_id;
1278}
1279
[email protected]d202a7c2012-01-04 07:53:471280int32 NavigationControllerImpl::GetMaxRestoredPageID() const {
[email protected]71fde352011-12-29 03:29:561281 return max_restored_page_id_;
[email protected]a26023822011-12-29 00:23:551282}
1283
1284SessionStorageNamespace*
[email protected]d1198fd2012-08-13 22:50:191285NavigationControllerImpl::GetSessionStorageNamespace(
1286 content::SiteInstance* instance) {
1287 std::string partition_id;
1288 if (instance) {
1289 // TODO(ajwong): When GetDefaultSessionStorageNamespace() goes away, remove
1290 // this if statement so |instance| must not be NULL.
1291 partition_id =
1292 GetContentClient()->browser()->GetStoragePartitionIdForSiteInstance(
1293 browser_context_, instance);
1294 }
1295
1296 SessionStorageNamespaceMap::const_iterator it =
1297 session_storage_namespace_map_.find(partition_id);
1298 if (it != session_storage_namespace_map_.end())
1299 return it->second.get();
1300
1301 // Create one if no one has accessed session storage for this partition yet.
1302 SessionStorageNamespaceImpl* session_storage_namespace =
1303 new SessionStorageNamespaceImpl(
1304 static_cast<DOMStorageContextImpl*>(
1305 BrowserContext::GetDOMStorageContextByPartitionId(
1306 browser_context_, partition_id)));
1307 session_storage_namespace_map_[partition_id] = session_storage_namespace;
1308
1309 return session_storage_namespace;
1310}
1311
1312SessionStorageNamespace*
1313NavigationControllerImpl::GetDefaultSessionStorageNamespace() {
1314 // TODO(ajwong): Remove if statement in GetSessionStorageNamespace().
1315 return GetSessionStorageNamespace(NULL);
1316}
1317
1318const SessionStorageNamespaceMap&
1319NavigationControllerImpl::GetSessionStorageNamespaceMap() const {
1320 return session_storage_namespace_map_;
[email protected]a26023822011-12-29 00:23:551321}
[email protected]d202a7c2012-01-04 07:53:471322
1323bool NavigationControllerImpl::NeedsReload() const {
[email protected]71fde352011-12-29 03:29:561324 return needs_reload_;
1325}
[email protected]a26023822011-12-29 00:23:551326
[email protected]d202a7c2012-01-04 07:53:471327void NavigationControllerImpl::RemoveEntryAtIndexInternal(int index) {
[email protected]a26023822011-12-29 00:23:551328 DCHECK(index < GetEntryCount());
[email protected]6a13a6c2011-12-20 21:47:121329 DCHECK(index != last_committed_entry_index_);
[email protected]43032342011-03-21 14:10:311330
1331 DiscardNonCommittedEntries();
1332
1333 entries_.erase(entries_.begin() + index);
[email protected]6a13a6c2011-12-20 21:47:121334 if (last_committed_entry_index_ > index)
[email protected]43032342011-03-21 14:10:311335 last_committed_entry_index_--;
1336}
1337
[email protected]d202a7c2012-01-04 07:53:471338void NavigationControllerImpl::DiscardNonCommittedEntries() {
[email protected]cbab76d2008-10-13 22:42:471339 bool transient = transient_entry_index_ != -1;
1340 DiscardNonCommittedEntriesInternal();
initial.commit09911bf2008-07-26 23:55:291341
[email protected]cbab76d2008-10-13 22:42:471342 // If there was a transient entry, invalidate everything so the new active
1343 // entry state is shown.
1344 if (transient) {
[email protected]2db9bd72012-04-13 20:20:561345 web_contents_->NotifyNavigationStateChanged(kInvalidateAll);
[email protected]cbab76d2008-10-13 22:42:471346 }
initial.commit09911bf2008-07-26 23:55:291347}
1348
[email protected]d202a7c2012-01-04 07:53:471349NavigationEntry* NavigationControllerImpl::GetPendingEntry() const {
[email protected]022af742011-12-28 18:37:251350 return pending_entry_;
1351}
1352
[email protected]d202a7c2012-01-04 07:53:471353int NavigationControllerImpl::GetPendingEntryIndex() const {
[email protected]a26023822011-12-29 00:23:551354 return pending_entry_index_;
1355}
1356
[email protected]d202a7c2012-01-04 07:53:471357void NavigationControllerImpl::InsertOrReplaceEntry(NavigationEntryImpl* entry,
1358 bool replace) {
[email protected]36fc0392011-12-25 03:59:511359 DCHECK(entry->GetTransitionType() != content::PAGE_TRANSITION_AUTO_SUBFRAME);
[email protected]765b35502008-08-21 00:51:201360
1361 // Copy the pending entry's unique ID to the committed entry.
1362 // I don't know if pending_entry_index_ can be other than -1 here.
[email protected]10f417c52011-12-28 21:04:231363 const NavigationEntryImpl* const pending_entry =
1364 (pending_entry_index_ == -1) ?
1365 pending_entry_ : entries_[pending_entry_index_].get();
[email protected]765b35502008-08-21 00:51:201366 if (pending_entry)
[email protected]36fc0392011-12-25 03:59:511367 entry->set_unique_id(pending_entry->GetUniqueID());
[email protected]765b35502008-08-21 00:51:201368
[email protected]cbab76d2008-10-13 22:42:471369 DiscardNonCommittedEntriesInternal();
[email protected]765b35502008-08-21 00:51:201370
1371 int current_size = static_cast<int>(entries_.size());
1372
[email protected]765b35502008-08-21 00:51:201373 if (current_size > 0) {
[email protected]672eba292009-05-13 13:22:451374 // Prune any entries which are in front of the current entry.
1375 // Also prune the current entry if we are to replace the current entry.
[email protected]47dcbdc2011-05-27 15:08:311376 // last_committed_entry_index_ must be updated here since calls to
1377 // NotifyPrunedEntries() below may re-enter and we must make sure
1378 // last_committed_entry_index_ is not left in an invalid state.
1379 if (replace)
1380 --last_committed_entry_index_;
1381
[email protected]c12bf1a12008-09-17 16:28:491382 int num_pruned = 0;
[email protected]47dcbdc2011-05-27 15:08:311383 while (last_committed_entry_index_ < (current_size - 1)) {
[email protected]c12bf1a12008-09-17 16:28:491384 num_pruned++;
[email protected]765b35502008-08-21 00:51:201385 entries_.pop_back();
1386 current_size--;
1387 }
[email protected]c12bf1a12008-09-17 16:28:491388 if (num_pruned > 0) // Only notify if we did prune something.
1389 NotifyPrunedEntries(this, false, num_pruned);
[email protected]765b35502008-08-21 00:51:201390 }
1391
[email protected]944822b2012-03-02 20:57:251392 PruneOldestEntryIfFull();
[email protected]765b35502008-08-21 00:51:201393
[email protected]10f417c52011-12-28 21:04:231394 entries_.push_back(linked_ptr<NavigationEntryImpl>(entry));
[email protected]765b35502008-08-21 00:51:201395 last_committed_entry_index_ = static_cast<int>(entries_.size()) - 1;
[email protected]e9ba4472008-09-14 15:42:431396
1397 // This is a new page ID, so we need everybody to know about it.
[email protected]2db9bd72012-04-13 20:20:561398 web_contents_->UpdateMaxPageID(entry->GetPageID());
initial.commit09911bf2008-07-26 23:55:291399}
1400
[email protected]944822b2012-03-02 20:57:251401void NavigationControllerImpl::PruneOldestEntryIfFull() {
1402 if (entries_.size() >= max_entry_count()) {
1403 DCHECK_EQ(max_entry_count(), entries_.size());
1404 DCHECK(last_committed_entry_index_ > 0);
1405 RemoveEntryAtIndex(0);
1406 NotifyPrunedEntries(this, true, 1);
1407 }
1408}
1409
[email protected]d202a7c2012-01-04 07:53:471410void NavigationControllerImpl::NavigateToPendingEntry(ReloadType reload_type) {
[email protected]72097fd02010-01-21 23:36:011411 needs_reload_ = false;
1412
[email protected]83c2e232011-10-07 21:36:461413 // If we were navigating to a slow-to-commit page, and the user performs
1414 // a session history navigation to the last committed page, RenderViewHost
1415 // will force the throbber to start, but WebKit will essentially ignore the
1416 // navigation, and won't send a message to stop the throbber. To prevent this
1417 // from happening, we drop the navigation here and stop the slow-to-commit
1418 // page from loading (which would normally happen during the navigation).
1419 if (pending_entry_index_ != -1 &&
1420 pending_entry_index_ == last_committed_entry_index_ &&
1421 (entries_[pending_entry_index_]->restore_type() ==
[email protected]10f417c52011-12-28 21:04:231422 NavigationEntryImpl::RESTORE_NONE) &&
[email protected]36fc0392011-12-25 03:59:511423 (entries_[pending_entry_index_]->GetTransitionType() &
[email protected]2905f742011-10-13 03:51:581424 content::PAGE_TRANSITION_FORWARD_BACK)) {
[email protected]2db9bd72012-04-13 20:20:561425 web_contents_->Stop();
[email protected]6a13a6c2011-12-20 21:47:121426
1427 // If an interstitial page is showing, we want to close it to get back
1428 // to what was showing before.
[email protected]2db9bd72012-04-13 20:20:561429 if (web_contents_->GetInterstitialPage())
1430 web_contents_->GetInterstitialPage()->DontProceed();
[email protected]6a13a6c2011-12-20 21:47:121431
[email protected]83c2e232011-10-07 21:36:461432 DiscardNonCommittedEntries();
1433 return;
1434 }
1435
[email protected]6a13a6c2011-12-20 21:47:121436 // If an interstitial page is showing, the previous renderer is blocked and
1437 // cannot make new requests. Unblock (and disable) it to allow this
1438 // navigation to succeed. The interstitial will stay visible until the
1439 // resulting DidNavigate.
[email protected]2db9bd72012-04-13 20:20:561440 if (web_contents_->GetInterstitialPage()) {
1441 static_cast<InterstitialPageImpl*>(web_contents_->GetInterstitialPage())->
[email protected]cadaec52012-02-08 21:53:131442 CancelForNavigation();
1443 }
[email protected]6a13a6c2011-12-20 21:47:121444
initial.commit09911bf2008-07-26 23:55:291445 // For session history navigations only the pending_entry_index_ is set.
1446 if (!pending_entry_) {
[email protected]4bf3522c2010-08-19 21:00:201447 DCHECK_NE(pending_entry_index_, -1);
[email protected]765b35502008-08-21 00:51:201448 pending_entry_ = entries_[pending_entry_index_].get();
initial.commit09911bf2008-07-26 23:55:291449 }
1450
[email protected]2db9bd72012-04-13 20:20:561451 if (!web_contents_->NavigateToPendingEntry(reload_type))
[email protected]cbab76d2008-10-13 22:42:471452 DiscardNonCommittedEntries();
[email protected]77362eb2011-08-01 17:18:381453
1454 // If the entry is being restored and doesn't have a SiteInstance yet, fill
1455 // it in now that we know. This allows us to find the entry when it commits.
1456 // This works for browser-initiated navigations. We handle renderer-initiated
[email protected]2db9bd72012-04-13 20:20:561457 // navigations to restored entries in WebContentsImpl::OnGoToEntryAtOffset.
[email protected]77362eb2011-08-01 17:18:381458 if (pending_entry_ && !pending_entry_->site_instance() &&
[email protected]10f417c52011-12-28 21:04:231459 pending_entry_->restore_type() != NavigationEntryImpl::RESTORE_NONE) {
[email protected]b6583592012-01-25 19:52:331460 pending_entry_->set_site_instance(static_cast<SiteInstanceImpl*>(
[email protected]2db9bd72012-04-13 20:20:561461 web_contents_->GetPendingSiteInstance()));
[email protected]10f417c52011-12-28 21:04:231462 pending_entry_->set_restore_type(NavigationEntryImpl::RESTORE_NONE);
[email protected]77362eb2011-08-01 17:18:381463 }
initial.commit09911bf2008-07-26 23:55:291464}
1465
[email protected]d202a7c2012-01-04 07:53:471466void NavigationControllerImpl::NotifyNavigationEntryCommitted(
[email protected]93f230e02011-06-01 14:40:001467 content::LoadCommittedDetails* details) {
[email protected]df1af242009-05-01 00:11:401468 details->entry = GetActiveEntry();
[email protected]6c2381d2011-10-19 02:52:531469 content::NotificationDetails notification_details =
1470 content::Details<content::LoadCommittedDetails>(details);
[email protected]df1af242009-05-01 00:11:401471
[email protected]2db9bd72012-04-13 20:20:561472 // We need to notify the ssl_manager_ before the web_contents_ so the
[email protected]df1af242009-05-01 00:11:401473 // location bar will have up-to-date information about the security style
1474 // when it wants to draw. See http://crbug.com/11157
1475 ssl_manager_.DidCommitProvisionalLoad(notification_details);
1476
initial.commit09911bf2008-07-26 23:55:291477 // TODO(pkasting): http://b/1113079 Probably these explicit notification paths
1478 // should be removed, and interested parties should just listen for the
1479 // notification below instead.
[email protected]2db9bd72012-04-13 20:20:561480 web_contents_->NotifyNavigationStateChanged(kInvalidateAll);
initial.commit09911bf2008-07-26 23:55:291481
[email protected]ad50def52011-10-19 23:17:071482 content::NotificationService::current()->Notify(
[email protected]432115822011-07-10 15:52:271483 content::NOTIFICATION_NAV_ENTRY_COMMITTED,
[email protected]c5eed492012-01-04 17:07:501484 content::Source<NavigationController>(this),
[email protected]df1af242009-05-01 00:11:401485 notification_details);
initial.commit09911bf2008-07-26 23:55:291486}
1487
initial.commit09911bf2008-07-26 23:55:291488// static
[email protected]d202a7c2012-01-04 07:53:471489size_t NavigationControllerImpl::max_entry_count() {
[email protected]9b51970d2011-12-09 23:10:231490 if (max_entry_count_for_testing_ != kMaxEntryCountForTestingNotSet)
1491 return max_entry_count_for_testing_;
1492 return content::kMaxSessionHistoryEntries;
1493}
1494
[email protected]d202a7c2012-01-04 07:53:471495void NavigationControllerImpl::SetActive(bool is_active) {
[email protected]ee613922009-09-02 20:38:221496 if (is_active && needs_reload_)
1497 LoadIfNecessary();
initial.commit09911bf2008-07-26 23:55:291498}
1499
[email protected]d202a7c2012-01-04 07:53:471500void NavigationControllerImpl::LoadIfNecessary() {
initial.commit09911bf2008-07-26 23:55:291501 if (!needs_reload_)
1502 return;
1503
initial.commit09911bf2008-07-26 23:55:291504 // Calling Reload() results in ignoring state, and not loading.
1505 // Explicitly use NavigateToPendingEntry so that the renderer uses the
1506 // cached state.
1507 pending_entry_index_ = last_committed_entry_index_;
[email protected]1ccb3568d2010-02-19 10:51:161508 NavigateToPendingEntry(NO_RELOAD);
initial.commit09911bf2008-07-26 23:55:291509}
1510
[email protected]d202a7c2012-01-04 07:53:471511void NavigationControllerImpl::NotifyEntryChanged(const NavigationEntry* entry,
1512 int index) {
[email protected]8286f51a2011-05-31 17:39:131513 content::EntryChangedDetails det;
[email protected]534e54b2008-08-13 15:40:091514 det.changed_entry = entry;
1515 det.index = index;
[email protected]ad50def52011-10-19 23:17:071516 content::NotificationService::current()->Notify(
[email protected]432115822011-07-10 15:52:271517 content::NOTIFICATION_NAV_ENTRY_CHANGED,
[email protected]c5eed492012-01-04 17:07:501518 content::Source<NavigationController>(this),
[email protected]6c2381d2011-10-19 02:52:531519 content::Details<content::EntryChangedDetails>(&det));
initial.commit09911bf2008-07-26 23:55:291520}
1521
[email protected]d202a7c2012-01-04 07:53:471522void NavigationControllerImpl::FinishRestore(int selected_index,
1523 bool from_last_session) {
[email protected]a26023822011-12-29 00:23:551524 DCHECK(selected_index >= 0 && selected_index < GetEntryCount());
[email protected]5e369672009-11-03 23:48:301525 ConfigureEntriesForRestore(&entries_, from_last_session);
initial.commit09911bf2008-07-26 23:55:291526
[email protected]71fde352011-12-29 03:29:561527 SetMaxRestoredPageID(static_cast<int32>(GetEntryCount()));
initial.commit09911bf2008-07-26 23:55:291528
1529 last_committed_entry_index_ = selected_index;
initial.commit09911bf2008-07-26 23:55:291530}
[email protected]765b35502008-08-21 00:51:201531
[email protected]d202a7c2012-01-04 07:53:471532void NavigationControllerImpl::DiscardNonCommittedEntriesInternal() {
[email protected]765b35502008-08-21 00:51:201533 if (pending_entry_index_ == -1)
1534 delete pending_entry_;
1535 pending_entry_ = NULL;
1536 pending_entry_index_ = -1;
[email protected]cbab76d2008-10-13 22:42:471537
1538 DiscardTransientEntry();
1539}
1540
[email protected]d202a7c2012-01-04 07:53:471541void NavigationControllerImpl::DiscardTransientEntry() {
[email protected]cbab76d2008-10-13 22:42:471542 if (transient_entry_index_ == -1)
1543 return;
[email protected]a0e69262009-06-03 19:08:481544 entries_.erase(entries_.begin() + transient_entry_index_);
[email protected]80858db52009-10-15 00:35:181545 if (last_committed_entry_index_ > transient_entry_index_)
1546 last_committed_entry_index_--;
[email protected]cbab76d2008-10-13 22:42:471547 transient_entry_index_ = -1;
[email protected]765b35502008-08-21 00:51:201548}
1549
[email protected]d202a7c2012-01-04 07:53:471550int NavigationControllerImpl::GetEntryIndexWithPageID(
[email protected]7f0005a2009-04-15 03:25:111551 SiteInstance* instance, int32 page_id) const {
[email protected]765b35502008-08-21 00:51:201552 for (int i = static_cast<int>(entries_.size()) - 1; i >= 0; --i) {
[email protected]7f0005a2009-04-15 03:25:111553 if ((entries_[i]->site_instance() == instance) &&
[email protected]36fc0392011-12-25 03:59:511554 (entries_[i]->GetPageID() == page_id))
[email protected]765b35502008-08-21 00:51:201555 return i;
1556 }
1557 return -1;
1558}
[email protected]cbab76d2008-10-13 22:42:471559
[email protected]d202a7c2012-01-04 07:53:471560NavigationEntry* NavigationControllerImpl::GetTransientEntry() const {
[email protected]cbab76d2008-10-13 22:42:471561 if (transient_entry_index_ == -1)
1562 return NULL;
1563 return entries_[transient_entry_index_].get();
1564}
[email protected]e1cd5452010-08-26 18:03:251565
[email protected]d202a7c2012-01-04 07:53:471566void NavigationControllerImpl::InsertEntriesFrom(
1567 const NavigationControllerImpl& source,
[email protected]e1cd5452010-08-26 18:03:251568 int max_index) {
[email protected]a26023822011-12-29 00:23:551569 DCHECK_LE(max_index, source.GetEntryCount());
[email protected]e1cd5452010-08-26 18:03:251570 size_t insert_index = 0;
1571 for (int i = 0; i < max_index; i++) {
1572 // When cloning a tab, copy all entries except interstitial pages
[email protected]ad23a092011-12-28 07:02:041573 if (source.entries_[i].get()->GetPageType() !=
[email protected]66fdbd52011-10-18 17:08:531574 content::PAGE_TYPE_INTERSTITIAL) {
[email protected]e1cd5452010-08-26 18:03:251575 entries_.insert(entries_.begin() + insert_index++,
[email protected]10f417c52011-12-28 21:04:231576 linked_ptr<NavigationEntryImpl>(
1577 new NavigationEntryImpl(*source.entries_[i])));
[email protected]e1cd5452010-08-26 18:03:251578 }
1579 }
1580}