blob: 4202b735e0d5b411fb442a35ce43c9e17fed24c3 [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
[email protected]c5b88d82012-10-06 17:03:337#include "base/bind.h"
initial.commit09911bf2008-07-26 23:55:298#include "base/file_util.h"
9#include "base/logging.h"
[email protected]b69934e2011-10-29 02:51:5210#include "base/string_number_conversions.h" // Temporary
initial.commit09911bf2008-07-26 23:55:2911#include "base/string_util.h"
[email protected]b689fce72009-03-17 22:45:3412#include "base/time.h"
[email protected]252cad62010-08-18 18:33:5713#include "base/utf_string_conversions.h"
[email protected]825b1662012-03-12 19:07:3114#include "content/browser/browser_url_handler_impl.h"
[email protected]b9535422012-02-09 01:47:5915#include "content/browser/child_process_security_policy_impl.h"
[email protected]1ea3c792012-04-17 01:25:0416#include "content/browser/dom_storage/dom_storage_context_impl.h"
17#include "content/browser/dom_storage/session_storage_namespace_impl.h"
[email protected]b3c41c0b2012-03-06 15:48:3218#include "content/browser/renderer_host/render_view_host_impl.h" // Temporary
[email protected]b6583592012-01-25 19:52:3319#include "content/browser/site_instance_impl.h"
[email protected]f9e4dae2012-04-10 21:26:3720#include "content/browser/web_contents/debug_urls.h"
21#include "content/browser/web_contents/interstitial_page_impl.h"
22#include "content/browser/web_contents/navigation_entry_impl.h"
[email protected]93ddb3c2012-04-11 21:44:2923#include "content/browser/web_contents/web_contents_impl.h"
[email protected]0aed2f52011-03-23 18:06:3624#include "content/common/view_messages.h"
[email protected]ccb797302011-12-15 16:55:1125#include "content/public/browser/browser_context.h"
[email protected]d1198fd2012-08-13 22:50:1926#include "content/public/browser/content_browser_client.h"
[email protected]d9083482012-01-06 00:38:4627#include "content/public/browser/invalidate_type.h"
[email protected]5b96836f2011-12-22 07:39:0028#include "content/public/browser/navigation_details.h"
[email protected]7f6f44c2011-12-14 13:23:3829#include "content/public/browser/notification_service.h"
[email protected]0d6e9bd2011-10-18 04:29:1630#include "content/public/browser/notification_types.h"
[email protected]4c3a23582012-08-18 08:54:3431#include "content/public/browser/storage_partition.h"
[email protected]7f6f44c2011-12-14 13:23:3832#include "content/public/browser/user_metrics.h"
[email protected]674bc592011-12-20 23:00:4233#include "content/public/browser/web_contents_delegate.h"
[email protected]d1198fd2012-08-13 22:50:1934#include "content/public/common/content_client.h"
[email protected]7f6f44c2011-12-14 13:23:3835#include "content/public/common/content_constants.h"
[email protected]d1ef81d2012-07-24 11:39:3636#include "content/public/common/url_constants.h"
[email protected]a23de8572009-06-03 02:16:3237#include "net/base/escape.h"
[email protected]31682282010-01-15 18:05:1638#include "net/base/mime_util.h"
[email protected]7f070d42011-03-09 20:25:3239#include "net/base/net_util.h"
[email protected]bb0e79472012-10-23 04:36:3440#include "webkit/glue/glue_serialize.h"
initial.commit09911bf2008-07-26 23:55:2941
[email protected]8ff00d72012-10-23 19:12:2142namespace content {
[email protected]e9ba4472008-09-14 15:42:4343namespace {
44
[email protected]93f230e02011-06-01 14:40:0045const int kInvalidateAll = 0xFFFFFFFF;
[email protected]8030f012009-09-25 18:09:3746
[email protected]e9ba4472008-09-14 15:42:4347// Invoked when entries have been pruned, or removed. For example, if the
48// current entries are [google, digg, yahoo], with the current entry google,
49// and the user types in cnet, then digg and yahoo are pruned.
[email protected]d202a7c2012-01-04 07:53:4750void NotifyPrunedEntries(NavigationControllerImpl* nav_controller,
[email protected]c12bf1a12008-09-17 16:28:4951 bool from_front,
52 int count) {
[email protected]8ff00d72012-10-23 19:12:2153 PrunedDetails details;
[email protected]c12bf1a12008-09-17 16:28:4954 details.from_front = from_front;
55 details.count = count;
[email protected]8ff00d72012-10-23 19:12:2156 NotificationService::current()->Notify(
57 NOTIFICATION_NAV_LIST_PRUNED,
58 Source<NavigationController>(nav_controller),
59 Details<PrunedDetails>(&details));
[email protected]e9ba4472008-09-14 15:42:4360}
61
62// Ensure the given NavigationEntry has a valid state, so that WebKit does not
63// get confused if we navigate back to it.
[email protected]40bcc302009-03-02 20:50:3964//
[email protected]e9ba4472008-09-14 15:42:4365// An empty state is treated as a new navigation by WebKit, which would mean
66// losing the navigation entries and generating a new navigation entry after
67// this one. We don't want that. To avoid this we create a valid state which
68// WebKit will not treat as a new navigation.
[email protected]10f417c52011-12-28 21:04:2369void SetContentStateIfEmpty(NavigationEntryImpl* entry) {
[email protected]36fc0392011-12-25 03:59:5170 if (entry->GetContentState().empty()) {
71 entry->SetContentState(
72 webkit_glue::CreateHistoryStateForURL(entry->GetURL()));
[email protected]e9ba4472008-09-14 15:42:4373 }
74}
75
[email protected]2ca1ea662012-10-04 02:26:3676NavigationEntryImpl::RestoreType ControllerRestoreTypeToEntryType(
77 NavigationController::RestoreType type) {
78 switch (type) {
79 case NavigationController::RESTORE_CURRENT_SESSION:
80 return NavigationEntryImpl::RESTORE_CURRENT_SESSION;
81 case NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY:
82 return NavigationEntryImpl::RESTORE_LAST_SESSION_EXITED_CLEANLY;
83 case NavigationController::RESTORE_LAST_SESSION_CRASHED:
84 return NavigationEntryImpl::RESTORE_LAST_SESSION_CRASHED;
85 }
86 NOTREACHED();
87 return NavigationEntryImpl::RESTORE_CURRENT_SESSION;
88}
89
[email protected]e9ba4472008-09-14 15:42:4390// Configure all the NavigationEntries in entries for restore. This resets
91// the transition type to reload and makes sure the content state isn't empty.
92void ConfigureEntriesForRestore(
[email protected]10f417c52011-12-28 21:04:2393 std::vector<linked_ptr<NavigationEntryImpl> >* entries,
[email protected]2ca1ea662012-10-04 02:26:3694 NavigationController::RestoreType type) {
[email protected]e9ba4472008-09-14 15:42:4395 for (size_t i = 0; i < entries->size(); ++i) {
96 // Use a transition type of reload so that we don't incorrectly increase
97 // the typed count.
[email protected]8ff00d72012-10-23 19:12:2198 (*entries)[i]->SetTransitionType(PAGE_TRANSITION_RELOAD);
[email protected]2ca1ea662012-10-04 02:26:3699 (*entries)[i]->set_restore_type(ControllerRestoreTypeToEntryType(type));
[email protected]e9ba4472008-09-14 15:42:43100 // NOTE(darin): This code is only needed for backwards compat.
101 SetContentStateIfEmpty((*entries)[i].get());
102 }
103}
104
105// See NavigationController::IsURLInPageNavigation for how this works and why.
[email protected]ce760d742012-08-30 22:31:10106bool AreURLsInPageNavigation(const GURL& existing_url,
107 const GURL& new_url,
108 bool renderer_says_in_page) {
109 if (existing_url == new_url)
110 return renderer_says_in_page;
111
112 if (!new_url.has_ref()) {
[email protected]192d8c5e2010-02-23 07:26:32113 // TODO(jcampan): what about when navigating back from a ref URL to the top
114 // non ref URL? Nothing is loaded in that case but we return false here.
115 // The user could also navigate from the ref URL to the non ref URL by
116 // entering the non ref URL in the location bar or through a bookmark, in
117 // which case there would be a load. I am not sure if the non-load/load
118 // scenarios can be differentiated with the TransitionType.
[email protected]e9ba4472008-09-14 15:42:43119 return false;
[email protected]192d8c5e2010-02-23 07:26:32120 }
[email protected]e9ba4472008-09-14 15:42:43121
122 url_canon::Replacements<char> replacements;
123 replacements.ClearRef();
124 return existing_url.ReplaceComponents(replacements) ==
125 new_url.ReplaceComponents(replacements);
126}
127
[email protected]bf70edce2012-06-20 22:32:22128// Determines whether or not we should be carrying over a user agent override
129// between two NavigationEntries.
[email protected]8ff00d72012-10-23 19:12:21130bool ShouldKeepOverride(const NavigationEntry* last_entry) {
[email protected]bf70edce2012-06-20 22:32:22131 return last_entry && last_entry->GetIsOverridingUserAgent();
132}
133
[email protected]e9ba4472008-09-14 15:42:43134} // namespace
135
[email protected]d202a7c2012-01-04 07:53:47136// NavigationControllerImpl ----------------------------------------------------
initial.commit09911bf2008-07-26 23:55:29137
[email protected]9b51970d2011-12-09 23:10:23138const size_t kMaxEntryCountForTestingNotSet = -1;
139
[email protected]765b35502008-08-21 00:51:20140// static
[email protected]d202a7c2012-01-04 07:53:47141size_t NavigationControllerImpl::max_entry_count_for_testing_ =
[email protected]9b51970d2011-12-09 23:10:23142 kMaxEntryCountForTestingNotSet;
[email protected]765b35502008-08-21 00:51:20143
[email protected]cdcb1dee2012-01-04 00:46:20144 // Should Reload check for post data? The default is true, but is set to false
145// when testing.
146static bool g_check_for_repost = true;
initial.commit09911bf2008-07-26 23:55:29147
[email protected]71fde352011-12-29 03:29:56148// static
[email protected]cdcb1dee2012-01-04 00:46:20149NavigationEntry* NavigationController::CreateNavigationEntry(
[email protected]71fde352011-12-29 03:29:56150 const GURL& url,
[email protected]cdcb1dee2012-01-04 00:46:20151 const Referrer& referrer,
152 PageTransition transition,
[email protected]71fde352011-12-29 03:29:56153 bool is_renderer_initiated,
154 const std::string& extra_headers,
[email protected]cdcb1dee2012-01-04 00:46:20155 BrowserContext* browser_context) {
[email protected]71fde352011-12-29 03:29:56156 // Allow the browser URL handler to rewrite the URL. This will, for example,
157 // remove "view-source:" from the beginning of the URL to get the URL that
158 // will actually be loaded. This real URL won't be shown to the user, just
159 // used internally.
160 GURL loaded_url(url);
161 bool reverse_on_redirect = false;
[email protected]825b1662012-03-12 19:07:31162 BrowserURLHandlerImpl::GetInstance()->RewriteURLIfNecessary(
[email protected]71fde352011-12-29 03:29:56163 &loaded_url, browser_context, &reverse_on_redirect);
164
165 NavigationEntryImpl* entry = new NavigationEntryImpl(
166 NULL, // The site instance for tabs is sent on navigation
[email protected]2db9bd72012-04-13 20:20:56167 // (WebContents::GetSiteInstance).
[email protected]71fde352011-12-29 03:29:56168 -1,
169 loaded_url,
170 referrer,
171 string16(),
172 transition,
173 is_renderer_initiated);
174 entry->SetVirtualURL(url);
175 entry->set_user_typed_url(url);
176 entry->set_update_virtual_url_with_url(reverse_on_redirect);
177 entry->set_extra_headers(extra_headers);
178 return entry;
179}
180
[email protected]cdcb1dee2012-01-04 00:46:20181// static
182void NavigationController::DisablePromptOnRepost() {
183 g_check_for_repost = false;
184}
185
[email protected]c5b88d82012-10-06 17:03:33186base::Time NavigationControllerImpl::TimeSmoother::GetSmoothedTime(
187 base::Time t) {
188 // If |t| is between the water marks, we're in a run of duplicates
189 // or just getting out of it, so increase the high-water mark to get
190 // a time that probably hasn't been used before and return it.
191 if (low_water_mark_ <= t && t <= high_water_mark_) {
192 high_water_mark_ += base::TimeDelta::FromMicroseconds(1);
193 return high_water_mark_;
194 }
195
196 // Otherwise, we're clear of the last duplicate run, so reset the
197 // water marks.
198 low_water_mark_ = high_water_mark_ = t;
199 return t;
200}
201
[email protected]d202a7c2012-01-04 07:53:47202NavigationControllerImpl::NavigationControllerImpl(
[email protected]2db9bd72012-04-13 20:20:56203 WebContentsImpl* web_contents,
[email protected]d1198fd2012-08-13 22:50:19204 BrowserContext* browser_context)
[email protected]3d7474ff2011-07-27 17:47:37205 : browser_context_(browser_context),
[email protected]765b35502008-08-21 00:51:20206 pending_entry_(NULL),
207 last_committed_entry_index_(-1),
208 pending_entry_index_(-1),
[email protected]cbab76d2008-10-13 22:42:47209 transient_entry_index_(-1),
[email protected]2db9bd72012-04-13 20:20:56210 web_contents_(web_contents),
initial.commit09911bf2008-07-26 23:55:29211 max_restored_page_id_(-1),
[email protected]5d063842009-05-15 04:08:24212 ALLOW_THIS_IN_INITIALIZER_LIST(ssl_manager_(this)),
[email protected]38b8f4e2009-09-24 19:44:57213 needs_reload_(false),
[email protected]27ba81c2012-08-21 17:04:09214 is_initial_navigation_(true),
[email protected]c5b88d82012-10-06 17:03:33215 pending_reload_(NO_RELOAD),
216 get_timestamp_callback_(base::Bind(&base::Time::Now)) {
[email protected]3d7474ff2011-07-27 17:47:37217 DCHECK(browser_context_);
initial.commit09911bf2008-07-26 23:55:29218}
219
[email protected]d202a7c2012-01-04 07:53:47220NavigationControllerImpl::~NavigationControllerImpl() {
[email protected]cbab76d2008-10-13 22:42:47221 DiscardNonCommittedEntriesInternal();
initial.commit09911bf2008-07-26 23:55:29222}
223
[email protected]d202a7c2012-01-04 07:53:47224WebContents* NavigationControllerImpl::GetWebContents() const {
[email protected]2db9bd72012-04-13 20:20:56225 return web_contents_;
[email protected]fbc5e5f92012-01-02 06:08:32226}
227
[email protected]d202a7c2012-01-04 07:53:47228BrowserContext* NavigationControllerImpl::GetBrowserContext() const {
[email protected]a26023822011-12-29 00:23:55229 return browser_context_;
230}
231
[email protected]d202a7c2012-01-04 07:53:47232void NavigationControllerImpl::SetBrowserContext(
233 BrowserContext* browser_context) {
[email protected]cdcb1dee2012-01-04 00:46:20234 browser_context_ = browser_context;
235}
236
[email protected]d202a7c2012-01-04 07:53:47237void NavigationControllerImpl::Restore(
[email protected]5e369672009-11-03 23:48:30238 int selected_navigation,
[email protected]2ca1ea662012-10-04 02:26:36239 RestoreType type,
[email protected]10f417c52011-12-28 21:04:23240 std::vector<NavigationEntry*>* entries) {
[email protected]ce3fa3c2009-04-20 19:55:57241 // Verify that this controller is unused and that the input is valid.
[email protected]a26023822011-12-29 00:23:55242 DCHECK(GetEntryCount() == 0 && !GetPendingEntry());
[email protected]ce3fa3c2009-04-20 19:55:57243 DCHECK(selected_navigation >= 0 &&
[email protected]03838e22011-06-06 15:27:14244 selected_navigation < static_cast<int>(entries->size()));
[email protected]ce3fa3c2009-04-20 19:55:57245
[email protected]ce3fa3c2009-04-20 19:55:57246 needs_reload_ = true;
[email protected]ad23a092011-12-28 07:02:04247 for (size_t i = 0; i < entries->size(); ++i) {
[email protected]10f417c52011-12-28 21:04:23248 NavigationEntryImpl* entry =
249 NavigationEntryImpl::FromNavigationEntry((*entries)[i]);
250 entries_.push_back(linked_ptr<NavigationEntryImpl>(entry));
[email protected]ad23a092011-12-28 07:02:04251 }
[email protected]03838e22011-06-06 15:27:14252 entries->clear();
[email protected]ce3fa3c2009-04-20 19:55:57253
254 // And finish the restore.
[email protected]2ca1ea662012-10-04 02:26:36255 FinishRestore(selected_navigation, type);
[email protected]ce3fa3c2009-04-20 19:55:57256}
257
[email protected]d202a7c2012-01-04 07:53:47258void NavigationControllerImpl::Reload(bool check_for_repost) {
[email protected]1ccb3568d2010-02-19 10:51:16259 ReloadInternal(check_for_repost, RELOAD);
260}
[email protected]d202a7c2012-01-04 07:53:47261void NavigationControllerImpl::ReloadIgnoringCache(bool check_for_repost) {
[email protected]1ccb3568d2010-02-19 10:51:16262 ReloadInternal(check_for_repost, RELOAD_IGNORING_CACHE);
263}
[email protected]7c16976c2012-08-04 02:38:23264void NavigationControllerImpl::ReloadOriginalRequestURL(bool check_for_repost) {
265 ReloadInternal(check_for_repost, RELOAD_ORIGINAL_REQUEST_URL);
266}
[email protected]1ccb3568d2010-02-19 10:51:16267
[email protected]d202a7c2012-01-04 07:53:47268void NavigationControllerImpl::ReloadInternal(bool check_for_repost,
269 ReloadType reload_type) {
[email protected]669e0ba2012-08-30 23:57:36270 if (transient_entry_index_ != -1) {
271 // If an interstitial is showing, treat a reload as a navigation to the
272 // transient entry's URL.
[email protected]8ff00d72012-10-23 19:12:21273 NavigationEntryImpl* active_entry =
[email protected]669e0ba2012-08-30 23:57:36274 NavigationEntryImpl::FromNavigationEntry(GetActiveEntry());
275 if (!active_entry)
276 return;
277 LoadURL(active_entry->GetURL(),
[email protected]8ff00d72012-10-23 19:12:21278 Referrer(),
279 PAGE_TRANSITION_RELOAD,
[email protected]669e0ba2012-08-30 23:57:36280 active_entry->extra_headers());
[email protected]cbab76d2008-10-13 22:42:47281 return;
[email protected]669e0ba2012-08-30 23:57:36282 }
[email protected]cbab76d2008-10-13 22:42:47283
284 DiscardNonCommittedEntriesInternal();
initial.commit09911bf2008-07-26 23:55:29285 int current_index = GetCurrentEntryIndex();
[email protected]106a0812010-03-18 00:15:12286 // If we are no where, then we can't reload. TODO(darin): We should add a
287 // CanReload method.
288 if (current_index == -1) {
289 return;
290 }
291
[email protected]cdcb1dee2012-01-04 00:46:20292 if (g_check_for_repost && check_for_repost &&
[email protected]36fc0392011-12-25 03:59:51293 GetEntryAtIndex(current_index)->GetHasPostData()) {
[email protected]a3a1d142008-12-19 00:42:30294 // The user is asking to reload a page with POST data. Prompt to make sure
[email protected]b5bb35f2009-02-05 20:17:07295 // they really want to do this. If they do, the dialog will call us back
296 // with check_for_repost = false.
[email protected]8ff00d72012-10-23 19:12:21297 NotificationService::current()->Notify(
298 NOTIFICATION_REPOST_WARNING_SHOWN,
299 Source<NavigationController>(this),
300 NotificationService::NoDetails());
[email protected]965bb092010-04-09 11:59:02301
[email protected]106a0812010-03-18 00:15:12302 pending_reload_ = reload_type;
[email protected]2db9bd72012-04-13 20:20:56303 web_contents_->Activate();
304 web_contents_->GetDelegate()->ShowRepostFormWarningDialog(web_contents_);
initial.commit09911bf2008-07-26 23:55:29305 } else {
[email protected]cbab76d2008-10-13 22:42:47306 DiscardNonCommittedEntriesInternal();
[email protected]765b35502008-08-21 00:51:20307
[email protected]bcd904482012-02-01 01:54:22308 NavigationEntryImpl* entry = entries_[current_index].get();
309 SiteInstanceImpl* site_instance = entry->site_instance();
310 DCHECK(site_instance);
[email protected]c3b3d952012-01-31 12:52:26311
[email protected]bcd904482012-02-01 01:54:22312 // If we are reloading an entry that no longer belongs to the current
313 // site instance (for example, refreshing a page for just installed app),
314 // the reload must happen in a new process.
315 // The new entry must have a new page_id and site instance, so it behaves
316 // as new navigation (which happens to clear forward history).
[email protected]7e58cb272012-03-30 21:22:30317 // Tabs that are discarded due to low memory conditions may not have a site
318 // instance, and should not be treated as a cross-site reload.
319 if (site_instance &&
320 site_instance->HasWrongProcessForURL(entry->GetURL())) {
[email protected]bcd904482012-02-01 01:54:22321 // Create a navigation entry that resembles the current one, but do not
[email protected]688aa65c62012-09-28 04:32:22322 // copy page id, site instance, content state, or timestamp.
[email protected]bcd904482012-02-01 01:54:22323 NavigationEntryImpl* nav_entry = NavigationEntryImpl::FromNavigationEntry(
324 CreateNavigationEntry(
325 entry->GetURL(), entry->GetReferrer(), entry->GetTransitionType(),
326 false, entry->extra_headers(), browser_context_));
[email protected]c3b3d952012-01-31 12:52:26327
[email protected]11535962012-02-09 21:02:10328 // Mark the reload type as NO_RELOAD, so navigation will not be considered
329 // a reload in the renderer.
330 reload_type = NavigationController::NO_RELOAD;
331
[email protected]e2caa032012-11-15 23:29:18332 nav_entry->set_should_replace_entry(true);
[email protected]bcd904482012-02-01 01:54:22333 pending_entry_ = nav_entry;
334 } else {
335 pending_entry_index_ = current_index;
336
337 // The title of the page being reloaded might have been removed in the
338 // meanwhile, so we need to revert to the default title upon reload and
339 // invalidate the previously cached title (SetTitle will do both).
340 // See Chromium issue 96041.
341 entries_[pending_entry_index_]->SetTitle(string16());
342
[email protected]8ff00d72012-10-23 19:12:21343 entries_[pending_entry_index_]->SetTransitionType(PAGE_TRANSITION_RELOAD);
[email protected]bcd904482012-02-01 01:54:22344 }
345
[email protected]1ccb3568d2010-02-19 10:51:16346 NavigateToPendingEntry(reload_type);
initial.commit09911bf2008-07-26 23:55:29347 }
348}
349
[email protected]d202a7c2012-01-04 07:53:47350void NavigationControllerImpl::CancelPendingReload() {
[email protected]106a0812010-03-18 00:15:12351 DCHECK(pending_reload_ != NO_RELOAD);
352 pending_reload_ = NO_RELOAD;
353}
354
[email protected]d202a7c2012-01-04 07:53:47355void NavigationControllerImpl::ContinuePendingReload() {
[email protected]106a0812010-03-18 00:15:12356 if (pending_reload_ == NO_RELOAD) {
357 NOTREACHED();
358 } else {
359 ReloadInternal(false, pending_reload_);
[email protected]965bb092010-04-09 11:59:02360 pending_reload_ = NO_RELOAD;
[email protected]106a0812010-03-18 00:15:12361 }
362}
363
[email protected]d202a7c2012-01-04 07:53:47364bool NavigationControllerImpl::IsInitialNavigation() {
[email protected]27ba81c2012-08-21 17:04:09365 return is_initial_navigation_;
[email protected]c70f9b82010-04-21 07:31:11366}
367
[email protected]d202a7c2012-01-04 07:53:47368NavigationEntryImpl* NavigationControllerImpl::GetEntryWithPageID(
[email protected]b6583592012-01-25 19:52:33369 SiteInstance* instance, int32 page_id) const {
[email protected]7f0005a2009-04-15 03:25:11370 int index = GetEntryIndexWithPageID(instance, page_id);
[email protected]765b35502008-08-21 00:51:20371 return (index != -1) ? entries_[index].get() : NULL;
372}
373
[email protected]d202a7c2012-01-04 07:53:47374void NavigationControllerImpl::LoadEntry(NavigationEntryImpl* entry) {
[email protected]419a0572011-04-18 22:21:46375 // Don't navigate to URLs disabled by policy. This prevents showing the URL
376 // on the Omnibar when it is also going to be blocked by
377 // ChildProcessSecurityPolicy::CanRequestURL.
[email protected]b9535422012-02-09 01:47:59378 ChildProcessSecurityPolicyImpl* policy =
379 ChildProcessSecurityPolicyImpl::GetInstance();
[email protected]36fc0392011-12-25 03:59:51380 if (policy->IsDisabledScheme(entry->GetURL().scheme()) ||
381 policy->IsDisabledScheme(entry->GetVirtualURL().scheme())) {
[email protected]419a0572011-04-18 22:21:46382 VLOG(1) << "URL not loaded because the scheme is blocked by policy: "
[email protected]36fc0392011-12-25 03:59:51383 << entry->GetURL();
[email protected]419a0572011-04-18 22:21:46384 delete entry;
385 return;
386 }
387
[email protected]765b35502008-08-21 00:51:20388 // When navigating to a new page, we don't know for sure if we will actually
389 // end up leaving the current page. The new page load could for example
390 // result in a download or a 'no content' response (e.g., a mailto: URL).
[email protected]cbab76d2008-10-13 22:42:47391 DiscardNonCommittedEntriesInternal();
[email protected]765b35502008-08-21 00:51:20392 pending_entry_ = entry;
[email protected]8ff00d72012-10-23 19:12:21393 NotificationService::current()->Notify(
394 NOTIFICATION_NAV_ENTRY_PENDING,
395 Source<NavigationController>(this),
396 Details<NavigationEntry>(entry));
[email protected]1ccb3568d2010-02-19 10:51:16397 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20398}
399
[email protected]d202a7c2012-01-04 07:53:47400NavigationEntry* NavigationControllerImpl::GetActiveEntry() const {
[email protected]cbab76d2008-10-13 22:42:47401 if (transient_entry_index_ != -1)
402 return entries_[transient_entry_index_].get();
403 if (pending_entry_)
404 return pending_entry_;
405 return GetLastCommittedEntry();
[email protected]765b35502008-08-21 00:51:20406}
407
[email protected]d202a7c2012-01-04 07:53:47408NavigationEntry* NavigationControllerImpl::GetVisibleEntry() const {
[email protected]867e1f92011-08-30 19:01:19409 if (transient_entry_index_ != -1)
410 return entries_[transient_entry_index_].get();
[email protected]e47ae9472011-10-13 19:48:34411 // Only return the pending_entry for new (non-history), browser-initiated
412 // navigations, in order to prevent URL spoof attacks.
413 // Ideally we would also show the pending entry's URL for new renderer-
414 // initiated navigations with no last committed entry (e.g., a link opening
415 // in a new tab), but an attacker can insert content into the about:blank
416 // page while the pending URL loads in that case.
417 if (pending_entry_ &&
[email protected]36fc0392011-12-25 03:59:51418 pending_entry_->GetPageID() == -1 &&
[email protected]e47ae9472011-10-13 19:48:34419 !pending_entry_->is_renderer_initiated())
[email protected]867e1f92011-08-30 19:01:19420 return pending_entry_;
421 return GetLastCommittedEntry();
422}
423
[email protected]d202a7c2012-01-04 07:53:47424int NavigationControllerImpl::GetCurrentEntryIndex() const {
[email protected]cbab76d2008-10-13 22:42:47425 if (transient_entry_index_ != -1)
426 return transient_entry_index_;
[email protected]765b35502008-08-21 00:51:20427 if (pending_entry_index_ != -1)
428 return pending_entry_index_;
429 return last_committed_entry_index_;
430}
431
[email protected]d202a7c2012-01-04 07:53:47432NavigationEntry* NavigationControllerImpl::GetLastCommittedEntry() const {
[email protected]765b35502008-08-21 00:51:20433 if (last_committed_entry_index_ == -1)
434 return NULL;
435 return entries_[last_committed_entry_index_].get();
436}
437
[email protected]d202a7c2012-01-04 07:53:47438bool NavigationControllerImpl::CanViewSource() const {
[email protected]31682282010-01-15 18:05:16439 bool is_supported_mime_type = net::IsSupportedNonImageMimeType(
[email protected]2db9bd72012-04-13 20:20:56440 web_contents_->GetContentsMimeType().c_str());
[email protected]10f417c52011-12-28 21:04:23441 NavigationEntry* active_entry = GetActiveEntry();
[email protected]31682282010-01-15 18:05:16442 return active_entry && !active_entry->IsViewSourceMode() &&
[email protected]2db9bd72012-04-13 20:20:56443 is_supported_mime_type && !web_contents_->GetInterstitialPage();
[email protected]31682282010-01-15 18:05:16444}
445
[email protected]d202a7c2012-01-04 07:53:47446int NavigationControllerImpl::GetLastCommittedEntryIndex() const {
[email protected]a26023822011-12-29 00:23:55447 return last_committed_entry_index_;
448}
449
[email protected]d202a7c2012-01-04 07:53:47450int NavigationControllerImpl::GetEntryCount() const {
[email protected]944822b2012-03-02 20:57:25451 DCHECK(entries_.size() <= max_entry_count());
[email protected]a26023822011-12-29 00:23:55452 return static_cast<int>(entries_.size());
453}
454
[email protected]d202a7c2012-01-04 07:53:47455NavigationEntry* NavigationControllerImpl::GetEntryAtIndex(
[email protected]022af742011-12-28 18:37:25456 int index) const {
457 return entries_.at(index).get();
458}
459
[email protected]d202a7c2012-01-04 07:53:47460NavigationEntry* NavigationControllerImpl::GetEntryAtOffset(
[email protected]022af742011-12-28 18:37:25461 int offset) const {
[email protected]9ba14052012-06-22 23:50:03462 int index = GetIndexForOffset(offset);
[email protected]a26023822011-12-29 00:23:55463 if (index < 0 || index >= GetEntryCount())
[email protected]765b35502008-08-21 00:51:20464 return NULL;
465
466 return entries_[index].get();
467}
468
[email protected]9ba14052012-06-22 23:50:03469int NavigationControllerImpl::GetIndexForOffset(int offset) const {
470 return (transient_entry_index_ != -1) ?
471 transient_entry_index_ + offset :
472 last_committed_entry_index_ + offset;
473}
474
[email protected]d202a7c2012-01-04 07:53:47475bool NavigationControllerImpl::CanGoBack() const {
[email protected]765b35502008-08-21 00:51:20476 return entries_.size() > 1 && GetCurrentEntryIndex() > 0;
477}
478
[email protected]d202a7c2012-01-04 07:53:47479bool NavigationControllerImpl::CanGoForward() const {
[email protected]765b35502008-08-21 00:51:20480 int index = GetCurrentEntryIndex();
481 return index >= 0 && index < (static_cast<int>(entries_.size()) - 1);
482}
483
[email protected]9ba14052012-06-22 23:50:03484bool NavigationControllerImpl::CanGoToOffset(int offset) const {
485 int index = GetIndexForOffset(offset);
486 return index >= 0 && index < GetEntryCount();
487}
488
[email protected]d202a7c2012-01-04 07:53:47489void NavigationControllerImpl::GoBack() {
[email protected]765b35502008-08-21 00:51:20490 if (!CanGoBack()) {
491 NOTREACHED();
492 return;
493 }
494
495 // Base the navigation on where we are now...
496 int current_index = GetCurrentEntryIndex();
497
[email protected]cbab76d2008-10-13 22:42:47498 DiscardNonCommittedEntries();
[email protected]765b35502008-08-21 00:51:20499
500 pending_entry_index_ = current_index - 1;
[email protected]022af742011-12-28 18:37:25501 entries_[pending_entry_index_]->SetTransitionType(
[email protected]8ff00d72012-10-23 19:12:21502 PageTransitionFromInt(
[email protected]36fc0392011-12-25 03:59:51503 entries_[pending_entry_index_]->GetTransitionType() |
[email protected]8ff00d72012-10-23 19:12:21504 PAGE_TRANSITION_FORWARD_BACK));
[email protected]1ccb3568d2010-02-19 10:51:16505 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20506}
507
[email protected]d202a7c2012-01-04 07:53:47508void NavigationControllerImpl::GoForward() {
[email protected]765b35502008-08-21 00:51:20509 if (!CanGoForward()) {
510 NOTREACHED();
511 return;
512 }
513
[email protected]cbab76d2008-10-13 22:42:47514 bool transient = (transient_entry_index_ != -1);
515
[email protected]765b35502008-08-21 00:51:20516 // Base the navigation on where we are now...
517 int current_index = GetCurrentEntryIndex();
518
[email protected]cbab76d2008-10-13 22:42:47519 DiscardNonCommittedEntries();
[email protected]765b35502008-08-21 00:51:20520
[email protected]cbab76d2008-10-13 22:42:47521 pending_entry_index_ = current_index;
522 // If there was a transient entry, we removed it making the current index
523 // the next page.
524 if (!transient)
525 pending_entry_index_++;
526
[email protected]022af742011-12-28 18:37:25527 entries_[pending_entry_index_]->SetTransitionType(
[email protected]8ff00d72012-10-23 19:12:21528 PageTransitionFromInt(
[email protected]36fc0392011-12-25 03:59:51529 entries_[pending_entry_index_]->GetTransitionType() |
[email protected]8ff00d72012-10-23 19:12:21530 PAGE_TRANSITION_FORWARD_BACK));
[email protected]1ccb3568d2010-02-19 10:51:16531 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20532}
533
[email protected]d202a7c2012-01-04 07:53:47534void NavigationControllerImpl::GoToIndex(int index) {
[email protected]765b35502008-08-21 00:51:20535 if (index < 0 || index >= static_cast<int>(entries_.size())) {
536 NOTREACHED();
537 return;
538 }
539
[email protected]cbab76d2008-10-13 22:42:47540 if (transient_entry_index_ != -1) {
541 if (index == transient_entry_index_) {
542 // Nothing to do when navigating to the transient.
543 return;
544 }
545 if (index > transient_entry_index_) {
546 // Removing the transient is goint to shift all entries by 1.
547 index--;
548 }
549 }
550
551 DiscardNonCommittedEntries();
[email protected]765b35502008-08-21 00:51:20552
553 pending_entry_index_ = index;
[email protected]022af742011-12-28 18:37:25554 entries_[pending_entry_index_]->SetTransitionType(
[email protected]8ff00d72012-10-23 19:12:21555 PageTransitionFromInt(
[email protected]36fc0392011-12-25 03:59:51556 entries_[pending_entry_index_]->GetTransitionType() |
[email protected]8ff00d72012-10-23 19:12:21557 PAGE_TRANSITION_FORWARD_BACK));
[email protected]1ccb3568d2010-02-19 10:51:16558 NavigateToPendingEntry(NO_RELOAD);
[email protected]765b35502008-08-21 00:51:20559}
560
[email protected]d202a7c2012-01-04 07:53:47561void NavigationControllerImpl::GoToOffset(int offset) {
[email protected]9ba14052012-06-22 23:50:03562 if (!CanGoToOffset(offset))
[email protected]765b35502008-08-21 00:51:20563 return;
564
[email protected]9ba14052012-06-22 23:50:03565 GoToIndex(GetIndexForOffset(offset));
[email protected]765b35502008-08-21 00:51:20566}
567
[email protected]d202a7c2012-01-04 07:53:47568void NavigationControllerImpl::RemoveEntryAtIndex(int index) {
[email protected]6a13a6c2011-12-20 21:47:12569 if (index == last_committed_entry_index_)
570 return;
571
[email protected]43032342011-03-21 14:10:31572 RemoveEntryAtIndexInternal(index);
[email protected]cbab76d2008-10-13 22:42:47573}
574
[email protected]d202a7c2012-01-04 07:53:47575void NavigationControllerImpl::UpdateVirtualURLToURL(
[email protected]10f417c52011-12-28 21:04:23576 NavigationEntryImpl* entry, const GURL& new_url) {
[email protected]38178a42009-12-17 18:58:32577 GURL new_virtual_url(new_url);
[email protected]825b1662012-03-12 19:07:31578 if (BrowserURLHandlerImpl::GetInstance()->ReverseURLRewrite(
[email protected]36fc0392011-12-25 03:59:51579 &new_virtual_url, entry->GetVirtualURL(), browser_context_)) {
580 entry->SetVirtualURL(new_virtual_url);
[email protected]38178a42009-12-17 18:58:32581 }
582}
583
[email protected]d202a7c2012-01-04 07:53:47584void NavigationControllerImpl::AddTransientEntry(NavigationEntryImpl* entry) {
[email protected]cbab76d2008-10-13 22:42:47585 // Discard any current transient entry, we can only have one at a time.
586 int index = 0;
587 if (last_committed_entry_index_ != -1)
588 index = last_committed_entry_index_ + 1;
589 DiscardTransientEntry();
[email protected]10f417c52011-12-28 21:04:23590 entries_.insert(
591 entries_.begin() + index, linked_ptr<NavigationEntryImpl>(entry));
[email protected]e1cd5452010-08-26 18:03:25592 transient_entry_index_ = index;
[email protected]2db9bd72012-04-13 20:20:56593 web_contents_->NotifyNavigationStateChanged(kInvalidateAll);
[email protected]cbab76d2008-10-13 22:42:47594}
595
[email protected]d202a7c2012-01-04 07:53:47596void NavigationControllerImpl::LoadURL(
[email protected]6c6b02d2011-09-02 03:36:47597 const GURL& url,
[email protected]8ff00d72012-10-23 19:12:21598 const Referrer& referrer,
599 PageTransition transition,
[email protected]6c6b02d2011-09-02 03:36:47600 const std::string& extra_headers) {
[email protected]cf002332012-08-14 19:17:47601 LoadURLParams params(url);
602 params.referrer = referrer;
603 params.transition_type = transition;
604 params.extra_headers = extra_headers;
605 LoadURLWithParams(params);
606}
607
608void NavigationControllerImpl::LoadURLWithParams(const LoadURLParams& params) {
[email protected]8ff00d72012-10-23 19:12:21609 if (HandleDebugURL(params.url, params.transition_type))
[email protected]8bf1048012012-02-08 01:22:18610 return;
611
[email protected]cf002332012-08-14 19:17:47612 // Checks based on params.load_type.
613 switch (params.load_type) {
614 case LOAD_TYPE_DEFAULT:
615 break;
616 case LOAD_TYPE_BROWSER_INITIATED_HTTP_POST:
617 if (!params.url.SchemeIs(chrome::kHttpScheme) &&
618 !params.url.SchemeIs(chrome::kHttpsScheme)) {
619 NOTREACHED() << "Http post load must use http(s) scheme.";
620 return;
621 }
622 break;
623 case LOAD_TYPE_DATA:
624 if (!params.url.SchemeIs(chrome::kDataScheme)) {
625 NOTREACHED() << "Data load must use data scheme.";
626 return;
627 }
628 break;
629 default:
630 NOTREACHED();
631 break;
632 };
[email protected]e47ae9472011-10-13 19:48:34633
[email protected]e47ae9472011-10-13 19:48:34634 // The user initiated a load, we don't need to reload anymore.
635 needs_reload_ = false;
636
[email protected]cf002332012-08-14 19:17:47637 bool override = false;
638 switch (params.override_user_agent) {
639 case UA_OVERRIDE_INHERIT:
640 override = ShouldKeepOverride(GetLastCommittedEntry());
641 break;
642 case UA_OVERRIDE_TRUE:
643 override = true;
644 break;
645 case UA_OVERRIDE_FALSE:
646 override = false;
647 break;
648 default:
649 NOTREACHED();
650 break;
[email protected]d1ef81d2012-07-24 11:39:36651 }
652
[email protected]d1ef81d2012-07-24 11:39:36653 NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
654 CreateNavigationEntry(
[email protected]cf002332012-08-14 19:17:47655 params.url,
656 params.referrer,
657 params.transition_type,
658 params.is_renderer_initiated,
659 params.extra_headers,
[email protected]d1ef81d2012-07-24 11:39:36660 browser_context_));
[email protected]e2caa032012-11-15 23:29:18661 if (params.is_cross_site_redirect)
662 entry->set_should_replace_entry(true);
[email protected]cf002332012-08-14 19:17:47663 entry->SetIsOverridingUserAgent(override);
664 entry->set_transferred_global_request_id(
665 params.transferred_global_request_id);
[email protected]d1ef81d2012-07-24 11:39:36666
[email protected]cf002332012-08-14 19:17:47667 switch (params.load_type) {
668 case LOAD_TYPE_DEFAULT:
669 break;
670 case LOAD_TYPE_BROWSER_INITIATED_HTTP_POST:
671 entry->SetHasPostData(true);
672 entry->SetBrowserInitiatedPostData(
673 params.browser_initiated_post_data);
674 break;
675 case LOAD_TYPE_DATA:
676 entry->SetBaseURLForDataURL(params.base_url_for_data_url);
677 entry->SetVirtualURL(params.virtual_url_for_data_url);
[email protected]951a64832012-10-11 16:26:37678 entry->SetCanLoadLocalResources(params.can_load_local_resources);
[email protected]cf002332012-08-14 19:17:47679 break;
680 default:
681 NOTREACHED();
682 break;
683 };
[email protected]132e281a2012-07-31 18:32:44684
685 LoadEntry(entry);
686}
687
[email protected]d202a7c2012-01-04 07:53:47688void NavigationControllerImpl::DocumentLoadedInFrame() {
[email protected]27ba81c2012-08-21 17:04:09689 is_initial_navigation_ = false;
[email protected]09b8f82f2009-06-16 20:22:11690}
691
[email protected]d202a7c2012-01-04 07:53:47692bool NavigationControllerImpl::RendererDidNavigate(
[email protected]e9ba4472008-09-14 15:42:43693 const ViewHostMsg_FrameNavigate_Params& params,
[email protected]8ff00d72012-10-23 19:12:21694 LoadCommittedDetails* details) {
[email protected]4bf3522c2010-08-19 21:00:20695
[email protected]0e8db942008-09-24 21:21:48696 // Save the previous state before we clobber it.
697 if (GetLastCommittedEntry()) {
[email protected]36fc0392011-12-25 03:59:51698 details->previous_url = GetLastCommittedEntry()->GetURL();
[email protected]a26023822011-12-29 00:23:55699 details->previous_entry_index = GetLastCommittedEntryIndex();
[email protected]0e8db942008-09-24 21:21:48700 } else {
701 details->previous_url = GURL();
702 details->previous_entry_index = -1;
703 }
[email protected]ecd9d8702008-08-28 22:10:17704
[email protected]77362eb2011-08-01 17:18:38705 // If we have a pending entry at this point, it should have a SiteInstance.
706 // Restored entries start out with a null SiteInstance, but we should have
707 // assigned one in NavigateToPendingEntry.
708 DCHECK(pending_entry_index_ == -1 || pending_entry_->site_instance());
[email protected]e9ba4472008-09-14 15:42:43709
[email protected]bcd904482012-02-01 01:54:22710 // If we are doing a cross-site reload, we need to replace the existing
711 // navigation entry, not add another entry to the history. This has the side
712 // effect of removing forward browsing history, if such existed.
[email protected]e2caa032012-11-15 23:29:18713 // Or if we are doing a cross-site redirect navigation,
714 // we will do a similar thing.
[email protected]4ac5fbe2012-09-01 02:19:59715 details->did_replace_entry =
[email protected]e2caa032012-11-15 23:29:18716 pending_entry_ && pending_entry_->should_replace_entry();
[email protected]bcd904482012-02-01 01:54:22717
[email protected]192d8c5e2010-02-23 07:26:32718 // is_in_page must be computed before the entry gets committed.
[email protected]ce760d742012-08-30 22:31:10719 details->is_in_page = IsURLInPageNavigation(
720 params.url, params.was_within_same_page);
[email protected]192d8c5e2010-02-23 07:26:32721
[email protected]e9ba4472008-09-14 15:42:43722 // Do navigation-type specific actions. These will make and commit an entry.
[email protected]0e8db942008-09-24 21:21:48723 details->type = ClassifyNavigation(params);
[email protected]4bf3522c2010-08-19 21:00:20724
[email protected]0e8db942008-09-24 21:21:48725 switch (details->type) {
[email protected]8ff00d72012-10-23 19:12:21726 case NAVIGATION_TYPE_NEW_PAGE:
[email protected]4ac5fbe2012-09-01 02:19:59727 RendererDidNavigateToNewPage(params, details->did_replace_entry);
[email protected]e9ba4472008-09-14 15:42:43728 break;
[email protected]8ff00d72012-10-23 19:12:21729 case NAVIGATION_TYPE_EXISTING_PAGE:
[email protected]e9ba4472008-09-14 15:42:43730 RendererDidNavigateToExistingPage(params);
731 break;
[email protected]8ff00d72012-10-23 19:12:21732 case NAVIGATION_TYPE_SAME_PAGE:
[email protected]e9ba4472008-09-14 15:42:43733 RendererDidNavigateToSamePage(params);
734 break;
[email protected]8ff00d72012-10-23 19:12:21735 case NAVIGATION_TYPE_IN_PAGE:
[email protected]4ac5fbe2012-09-01 02:19:59736 RendererDidNavigateInPage(params, &details->did_replace_entry);
[email protected]e9ba4472008-09-14 15:42:43737 break;
[email protected]8ff00d72012-10-23 19:12:21738 case NAVIGATION_TYPE_NEW_SUBFRAME:
[email protected]e9ba4472008-09-14 15:42:43739 RendererDidNavigateNewSubframe(params);
740 break;
[email protected]8ff00d72012-10-23 19:12:21741 case NAVIGATION_TYPE_AUTO_SUBFRAME:
[email protected]e9ba4472008-09-14 15:42:43742 if (!RendererDidNavigateAutoSubframe(params))
743 return false;
744 break;
[email protected]8ff00d72012-10-23 19:12:21745 case NAVIGATION_TYPE_NAV_IGNORE:
[email protected]20d1c992011-04-12 21:17:49746 // If a pending navigation was in progress, this canceled it. We should
747 // discard it and make sure it is removed from the URL bar. After that,
748 // there is nothing we can do with this navigation, so we just return to
[email protected]e9ba4472008-09-14 15:42:43749 // the caller that nothing has happened.
[email protected]20d1c992011-04-12 21:17:49750 if (pending_entry_) {
751 DiscardNonCommittedEntries();
[email protected]8ff00d72012-10-23 19:12:21752 web_contents_->NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
[email protected]20d1c992011-04-12 21:17:49753 }
[email protected]e9ba4472008-09-14 15:42:43754 return false;
755 default:
756 NOTREACHED();
[email protected]765b35502008-08-21 00:51:20757 }
758
[email protected]688aa65c62012-09-28 04:32:22759 // At this point, we know that the navigation has just completed, so
760 // record the time.
761 //
762 // TODO(akalin): Use "sane time" as described in
763 // http://www.chromium.org/developers/design-documents/sane-time .
[email protected]c5b88d82012-10-06 17:03:33764 base::Time timestamp =
765 time_smoother_.GetSmoothedTime(get_timestamp_callback_.Run());
766 DVLOG(1) << "Navigation finished at (smoothed) timestamp "
[email protected]688aa65c62012-09-28 04:32:22767 << timestamp.ToInternalValue();
768
[email protected]e9ba4472008-09-14 15:42:43769 // All committed entries should have nonempty content state so WebKit doesn't
770 // get confused when we go back to them (see the function for details).
[email protected]0f38dc4552011-02-25 11:24:00771 DCHECK(!params.content_state.empty());
[email protected]10f417c52011-12-28 21:04:23772 NavigationEntryImpl* active_entry =
773 NavigationEntryImpl::FromNavigationEntry(GetActiveEntry());
[email protected]688aa65c62012-09-28 04:32:22774 active_entry->SetTimestamp(timestamp);
[email protected]36fc0392011-12-25 03:59:51775 active_entry->SetContentState(params.content_state);
[email protected]132e281a2012-07-31 18:32:44776 // No longer needed since content state will hold the post data if any.
777 active_entry->SetBrowserInitiatedPostData(NULL);
778
[email protected]e47ae9472011-10-13 19:48:34779 // Once committed, we do not need to track if the entry was initiated by
780 // the renderer.
781 active_entry->set_is_renderer_initiated(false);
782
[email protected]49bd30e62011-03-22 20:12:59783 // The active entry's SiteInstance should match our SiteInstance.
[email protected]2db9bd72012-04-13 20:20:56784 DCHECK(active_entry->site_instance() == web_contents_->GetSiteInstance());
[email protected]49bd30e62011-03-22 20:12:59785
[email protected]e9ba4472008-09-14 15:42:43786 // Now prep the rest of the details for the notification and broadcast.
[email protected]0f38dc4552011-02-25 11:24:00787 details->entry = active_entry;
[email protected]2905f742011-10-13 03:51:58788 details->is_main_frame =
[email protected]8ff00d72012-10-23 19:12:21789 PageTransitionIsMainFrame(params.transition);
[email protected]f072d2ce2008-09-17 17:16:24790 details->serialized_security_info = params.security_info;
[email protected]2e39d2e2009-02-19 18:41:31791 details->http_status_code = params.http_status_code;
[email protected]93f230e02011-06-01 14:40:00792 NotifyNavigationEntryCommitted(details);
initial.commit09911bf2008-07-26 23:55:29793
[email protected]e9ba4472008-09-14 15:42:43794 return true;
initial.commit09911bf2008-07-26 23:55:29795}
796
[email protected]8ff00d72012-10-23 19:12:21797NavigationType NavigationControllerImpl::ClassifyNavigation(
[email protected]e9ba4472008-09-14 15:42:43798 const ViewHostMsg_FrameNavigate_Params& params) const {
[email protected]e9ba4472008-09-14 15:42:43799 if (params.page_id == -1) {
[email protected]eef9de32009-09-23 17:19:46800 // The renderer generates the page IDs, and so if it gives us the invalid
801 // page ID (-1) we know it didn't actually navigate. This happens in a few
802 // cases:
803 //
804 // - If a page makes a popup navigated to about blank, and then writes
805 // stuff like a subframe navigated to a real page. We'll get the commit
806 // for the subframe, but there won't be any commit for the outer page.
807 //
808 // - We were also getting these for failed loads (for example, bug 21849).
809 // The guess is that we get a "load commit" for the alternate error page,
810 // but that doesn't affect the page ID, so we get the "old" one, which
811 // could be invalid. This can also happen for a cross-site transition
812 // that causes us to swap processes. Then the error page load will be in
813 // a new process with no page IDs ever assigned (and hence a -1 value),
814 // yet the navigation controller still might have previous pages in its
815 // list.
816 //
817 // In these cases, there's nothing we can do with them, so ignore.
[email protected]8ff00d72012-10-23 19:12:21818 return NAVIGATION_TYPE_NAV_IGNORE;
[email protected]e9ba4472008-09-14 15:42:43819 }
820
[email protected]2db9bd72012-04-13 20:20:56821 if (params.page_id > web_contents_->GetMaxPageID()) {
[email protected]e9ba4472008-09-14 15:42:43822 // Greater page IDs than we've ever seen before are new pages. We may or may
823 // not have a pending entry for the page, and this may or may not be the
824 // main frame.
[email protected]8ff00d72012-10-23 19:12:21825 if (PageTransitionIsMainFrame(params.transition))
826 return NAVIGATION_TYPE_NEW_PAGE;
[email protected]4c27ba82008-09-24 16:49:09827
828 // When this is a new subframe navigation, we should have a committed page
829 // for which it's a suframe in. This may not be the case when an iframe is
830 // navigated on a popup navigated to about:blank (the iframe would be
831 // written into the popup by script on the main page). For these cases,
832 // there isn't any navigation stuff we can do, so just ignore it.
833 if (!GetLastCommittedEntry())
[email protected]8ff00d72012-10-23 19:12:21834 return NAVIGATION_TYPE_NAV_IGNORE;
[email protected]4c27ba82008-09-24 16:49:09835
836 // Valid subframe navigation.
[email protected]8ff00d72012-10-23 19:12:21837 return NAVIGATION_TYPE_NEW_SUBFRAME;
[email protected]e9ba4472008-09-14 15:42:43838 }
839
840 // Now we know that the notification is for an existing page. Find that entry.
841 int existing_entry_index = GetEntryIndexWithPageID(
[email protected]2db9bd72012-04-13 20:20:56842 web_contents_->GetSiteInstance(),
[email protected]e9ba4472008-09-14 15:42:43843 params.page_id);
844 if (existing_entry_index == -1) {
845 // The page was not found. It could have been pruned because of the limit on
846 // back/forward entries (not likely since we'll usually tell it to navigate
847 // to such entries). It could also mean that the renderer is smoking crack.
848 NOTREACHED();
[email protected]485e8232011-07-24 18:03:46849
850 // Because the unknown entry has committed, we risk showing the wrong URL in
851 // release builds. Instead, we'll kill the renderer process to be safe.
852 LOG(ERROR) << "terminating renderer for bad navigation: " << params.url;
[email protected]8ff00d72012-10-23 19:12:21853 RecordAction(UserMetricsAction("BadMessageTerminate_NC"));
[email protected]b69934e2011-10-29 02:51:52854
[email protected]7ec6f382011-11-11 01:28:17855 // Temporary code so we can get more information. Format:
[email protected]8c380582011-12-02 03:16:10856 // http://url/foo.html#page1#max3#frame1#ids:2_Nx,1_1x,3_2
857 std::string temp = params.url.spec();
[email protected]7ec6f382011-11-11 01:28:17858 temp.append("#page");
[email protected]b69934e2011-10-29 02:51:52859 temp.append(base::IntToString(params.page_id));
[email protected]7ec6f382011-11-11 01:28:17860 temp.append("#max");
[email protected]2db9bd72012-04-13 20:20:56861 temp.append(base::IntToString(web_contents_->GetMaxPageID()));
[email protected]7ec6f382011-11-11 01:28:17862 temp.append("#frame");
863 temp.append(base::IntToString(params.frame_id));
864 temp.append("#ids");
865 for (int i = 0; i < static_cast<int>(entries_.size()); ++i) {
[email protected]8c380582011-12-02 03:16:10866 // Append entry metadata (e.g., 3_7x):
867 // 3: page_id
868 // 7: SiteInstance ID, or N for null
869 // x: appended if not from the current SiteInstance
[email protected]36fc0392011-12-25 03:59:51870 temp.append(base::IntToString(entries_[i]->GetPageID()));
[email protected]8c380582011-12-02 03:16:10871 temp.append("_");
872 if (entries_[i]->site_instance())
[email protected]b6583592012-01-25 19:52:33873 temp.append(base::IntToString(entries_[i]->site_instance()->GetId()));
[email protected]7ec6f382011-11-11 01:28:17874 else
[email protected]8c380582011-12-02 03:16:10875 temp.append("N");
[email protected]2db9bd72012-04-13 20:20:56876 if (entries_[i]->site_instance() != web_contents_->GetSiteInstance())
[email protected]7ec6f382011-11-11 01:28:17877 temp.append("x");
878 temp.append(",");
[email protected]b69934e2011-10-29 02:51:52879 }
880 GURL url(temp);
[email protected]9f76c1e2012-03-05 15:15:58881 static_cast<RenderViewHostImpl*>(
[email protected]2db9bd72012-04-13 20:20:56882 web_contents_->GetRenderViewHost())->Send(
[email protected]9f76c1e2012-03-05 15:15:58883 new ViewMsg_TempCrashWithData(url));
[email protected]8ff00d72012-10-23 19:12:21884 return NAVIGATION_TYPE_NAV_IGNORE;
[email protected]e9ba4472008-09-14 15:42:43885 }
[email protected]10f417c52011-12-28 21:04:23886 NavigationEntryImpl* existing_entry = entries_[existing_entry_index].get();
[email protected]e9ba4472008-09-14 15:42:43887
[email protected]8ff00d72012-10-23 19:12:21888 if (!PageTransitionIsMainFrame(params.transition)) {
[email protected]e6035c22010-05-25 16:15:52889 // All manual subframes would get new IDs and were handled above, so we
890 // know this is auto. Since the current page was found in the navigation
891 // entry list, we're guaranteed to have a last committed entry.
892 DCHECK(GetLastCommittedEntry());
[email protected]8ff00d72012-10-23 19:12:21893 return NAVIGATION_TYPE_AUTO_SUBFRAME;
[email protected]e6035c22010-05-25 16:15:52894 }
895
896 // Anything below here we know is a main frame navigation.
[email protected]e9ba4472008-09-14 15:42:43897 if (pending_entry_ &&
[email protected]e9ba4472008-09-14 15:42:43898 existing_entry != pending_entry_ &&
[email protected]36fc0392011-12-25 03:59:51899 pending_entry_->GetPageID() == -1 &&
[email protected]230c0012011-04-08 16:27:24900 existing_entry == GetLastCommittedEntry()) {
[email protected]e9ba4472008-09-14 15:42:43901 // In this case, we have a pending entry for a URL but WebCore didn't do a
902 // new navigation. This happens when you press enter in the URL bar to
903 // reload. We will create a pending entry, but WebKit will convert it to
904 // a reload since it's the same page and not create a new entry for it
905 // (the user doesn't want to have a new back/forward entry when they do
[email protected]230c0012011-04-08 16:27:24906 // this). If this matches the last committed entry, we want to just ignore
907 // the pending entry and go back to where we were (the "existing entry").
[email protected]8ff00d72012-10-23 19:12:21908 return NAVIGATION_TYPE_SAME_PAGE;
[email protected]e9ba4472008-09-14 15:42:43909 }
910
[email protected]fc60f222008-12-18 17:36:54911 // Any toplevel navigations with the same base (minus the reference fragment)
912 // are in-page navigations. We weeded out subframe navigations above. Most of
913 // the time this doesn't matter since WebKit doesn't tell us about subframe
914 // navigations that don't actually navigate, but it can happen when there is
915 // an encoding override (it always sends a navigation request).
[email protected]4ac5fbe2012-09-01 02:19:59916 if (AreURLsInPageNavigation(existing_entry->GetURL(), params.url,
917 params.was_within_same_page)) {
[email protected]8ff00d72012-10-23 19:12:21918 return NAVIGATION_TYPE_IN_PAGE;
[email protected]4ac5fbe2012-09-01 02:19:59919 }
[email protected]fc60f222008-12-18 17:36:54920
[email protected]e9ba4472008-09-14 15:42:43921 // Since we weeded out "new" navigations above, we know this is an existing
[email protected]4c27ba82008-09-24 16:49:09922 // (back/forward) navigation.
[email protected]8ff00d72012-10-23 19:12:21923 return NAVIGATION_TYPE_EXISTING_PAGE;
[email protected]e9ba4472008-09-14 15:42:43924}
925
[email protected]d202a7c2012-01-04 07:53:47926bool NavigationControllerImpl::IsRedirect(
[email protected]09b8f82f2009-06-16 20:22:11927 const ViewHostMsg_FrameNavigate_Params& params) {
928 // For main frame transition, we judge by params.transition.
929 // Otherwise, by params.redirects.
[email protected]8ff00d72012-10-23 19:12:21930 if (PageTransitionIsMainFrame(params.transition)) {
931 return PageTransitionIsRedirect(params.transition);
[email protected]09b8f82f2009-06-16 20:22:11932 }
933 return params.redirects.size() > 1;
934}
935
[email protected]d202a7c2012-01-04 07:53:47936void NavigationControllerImpl::RendererDidNavigateToNewPage(
[email protected]4ac5fbe2012-09-01 02:19:59937 const ViewHostMsg_FrameNavigate_Params& params, bool replace_entry) {
[email protected]10f417c52011-12-28 21:04:23938 NavigationEntryImpl* new_entry;
[email protected]f1eb87a2011-05-06 17:49:41939 bool update_virtual_url;
[email protected]e9ba4472008-09-14 15:42:43940 if (pending_entry_) {
941 // TODO(brettw) this assumes that the pending entry is appropriate for the
942 // new page that was just loaded. I don't think this is necessarily the
[email protected]49bd30e62011-03-22 20:12:59943 // case! We should have some more tracking to know for sure.
[email protected]10f417c52011-12-28 21:04:23944 new_entry = new NavigationEntryImpl(*pending_entry_);
[email protected]e9ba4472008-09-14 15:42:43945
946 // Don't use the page type from the pending entry. Some interstitial page
947 // may have set the type to interstitial. Once we commit, however, the page
948 // type must always be normal.
[email protected]8ff00d72012-10-23 19:12:21949 new_entry->set_page_type(PAGE_TYPE_NORMAL);
[email protected]f1eb87a2011-05-06 17:49:41950 update_virtual_url = new_entry->update_virtual_url_with_url();
[email protected]e9ba4472008-09-14 15:42:43951 } else {
[email protected]10f417c52011-12-28 21:04:23952 new_entry = new NavigationEntryImpl;
[email protected]f8f93eb2012-09-25 03:06:24953
954 // Find out whether the new entry needs to update its virtual URL on URL
955 // change and set up the entry accordingly. This is needed to correctly
956 // update the virtual URL when replaceState is called after a pushState.
957 GURL url = params.url;
958 bool needs_update = false;
959 BrowserURLHandlerImpl::GetInstance()->RewriteURLIfNecessary(
960 &url, browser_context_, &needs_update);
961 new_entry->set_update_virtual_url_with_url(needs_update);
962
[email protected]f1eb87a2011-05-06 17:49:41963 // When navigating to a new page, give the browser URL handler a chance to
964 // update the virtual URL based on the new URL. For example, this is needed
965 // to show chrome://bookmarks/#1 when the bookmarks webui extension changes
966 // the URL.
[email protected]f8f93eb2012-09-25 03:06:24967 update_virtual_url = needs_update;
[email protected]e9ba4472008-09-14 15:42:43968 }
969
[email protected]ad23a092011-12-28 07:02:04970 new_entry->SetURL(params.url);
[email protected]f1eb87a2011-05-06 17:49:41971 if (update_virtual_url)
[email protected]38178a42009-12-17 18:58:32972 UpdateVirtualURLToURL(new_entry, params.url);
[email protected]022af742011-12-28 18:37:25973 new_entry->SetReferrer(params.referrer);
[email protected]36fc0392011-12-25 03:59:51974 new_entry->SetPageID(params.page_id);
[email protected]022af742011-12-28 18:37:25975 new_entry->SetTransitionType(params.transition);
[email protected]b6583592012-01-25 19:52:33976 new_entry->set_site_instance(
[email protected]2db9bd72012-04-13 20:20:56977 static_cast<SiteInstanceImpl*>(web_contents_->GetSiteInstance()));
[email protected]36fc0392011-12-25 03:59:51978 new_entry->SetHasPostData(params.is_post);
[email protected]86cd9472012-02-03 19:51:05979 new_entry->SetPostID(params.post_id);
[email protected]7c16976c2012-08-04 02:38:23980 new_entry->SetOriginalRequestURL(params.original_request_url);
[email protected]bf70edce2012-06-20 22:32:22981 new_entry->SetIsOverridingUserAgent(params.is_overriding_user_agent);
[email protected]e9ba4472008-09-14 15:42:43982
[email protected]4ac5fbe2012-09-01 02:19:59983 InsertOrReplaceEntry(new_entry, replace_entry);
[email protected]e9ba4472008-09-14 15:42:43984}
985
[email protected]d202a7c2012-01-04 07:53:47986void NavigationControllerImpl::RendererDidNavigateToExistingPage(
[email protected]e9ba4472008-09-14 15:42:43987 const ViewHostMsg_FrameNavigate_Params& params) {
988 // We should only get here for main frame navigations.
[email protected]8ff00d72012-10-23 19:12:21989 DCHECK(PageTransitionIsMainFrame(params.transition));
[email protected]e9ba4472008-09-14 15:42:43990
991 // This is a back/forward navigation. The existing page for the ID is
[email protected]4c27ba82008-09-24 16:49:09992 // guaranteed to exist by ClassifyNavigation, and we just need to update it
993 // with new information from the renderer.
[email protected]2db9bd72012-04-13 20:20:56994 int entry_index = GetEntryIndexWithPageID(web_contents_->GetSiteInstance(),
[email protected]7f0005a2009-04-15 03:25:11995 params.page_id);
[email protected]e9ba4472008-09-14 15:42:43996 DCHECK(entry_index >= 0 &&
997 entry_index < static_cast<int>(entries_.size()));
[email protected]10f417c52011-12-28 21:04:23998 NavigationEntryImpl* entry = entries_[entry_index].get();
[email protected]e9ba4472008-09-14 15:42:43999
[email protected]5ccd4dc2012-10-24 02:28:141000 // The URL may have changed due to redirects.
[email protected]ad23a092011-12-28 07:02:041001 entry->SetURL(params.url);
[email protected]38178a42009-12-17 18:58:321002 if (entry->update_virtual_url_with_url())
1003 UpdateVirtualURLToURL(entry, params.url);
[email protected]5ccd4dc2012-10-24 02:28:141004
1005 // The redirected to page should not inherit the favicon from the previous
1006 // page.
1007 if (PageTransitionIsRedirect(params.transition))
[email protected]91a4ff82012-10-29 20:29:481008 entry->GetFavicon() = FaviconStatus();
[email protected]5ccd4dc2012-10-24 02:28:141009
1010 // The site instance will normally be the same except during session restore,
1011 // when no site instance will be assigned.
[email protected]e9ba4472008-09-14 15:42:431012 DCHECK(entry->site_instance() == NULL ||
[email protected]2db9bd72012-04-13 20:20:561013 entry->site_instance() == web_contents_->GetSiteInstance());
[email protected]b6583592012-01-25 19:52:331014 entry->set_site_instance(
[email protected]2db9bd72012-04-13 20:20:561015 static_cast<SiteInstanceImpl*>(web_contents_->GetSiteInstance()));
[email protected]e9ba4472008-09-14 15:42:431016
[email protected]36fc0392011-12-25 03:59:511017 entry->SetHasPostData(params.is_post);
[email protected]86cd9472012-02-03 19:51:051018 entry->SetPostID(params.post_id);
[email protected]d5a49e52010-01-08 03:01:411019
[email protected]e9ba4472008-09-14 15:42:431020 // The entry we found in the list might be pending if the user hit
1021 // back/forward/reload. This load should commit it (since it's already in the
[email protected]49bd30e62011-03-22 20:12:591022 // list, we can just discard the pending pointer). We should also discard the
1023 // pending entry if it corresponds to a different navigation, since that one
1024 // is now likely canceled. If it is not canceled, we will treat it as a new
1025 // navigation when it arrives, which is also ok.
[email protected]e9ba4472008-09-14 15:42:431026 //
1027 // Note that we need to use the "internal" version since we don't want to
1028 // actually change any other state, just kill the pointer.
[email protected]6eebaab2012-11-15 04:39:491029 DiscardNonCommittedEntriesInternal();
[email protected]40bcc302009-03-02 20:50:391030
[email protected]80858db52009-10-15 00:35:181031 // If a transient entry was removed, the indices might have changed, so we
1032 // have to query the entry index again.
1033 last_committed_entry_index_ =
[email protected]2db9bd72012-04-13 20:20:561034 GetEntryIndexWithPageID(web_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:431035}
1036
[email protected]d202a7c2012-01-04 07:53:471037void NavigationControllerImpl::RendererDidNavigateToSamePage(
[email protected]e9ba4472008-09-14 15:42:431038 const ViewHostMsg_FrameNavigate_Params& params) {
1039 // This mode implies we have a pending entry that's the same as an existing
[email protected]4c27ba82008-09-24 16:49:091040 // entry for this page ID. This entry is guaranteed to exist by
1041 // ClassifyNavigation. All we need to do is update the existing entry.
[email protected]10f417c52011-12-28 21:04:231042 NavigationEntryImpl* existing_entry = GetEntryWithPageID(
[email protected]2db9bd72012-04-13 20:20:561043 web_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:431044
1045 // We assign the entry's unique ID to be that of the new one. Since this is
1046 // always the result of a user action, we want to dismiss infobars, etc. like
1047 // a regular user-initiated navigation.
[email protected]36fc0392011-12-25 03:59:511048 existing_entry->set_unique_id(pending_entry_->GetUniqueID());
[email protected]e9ba4472008-09-14 15:42:431049
[email protected]a0e69262009-06-03 19:08:481050 // The URL may have changed due to redirects.
[email protected]38178a42009-12-17 18:58:321051 if (existing_entry->update_virtual_url_with_url())
1052 UpdateVirtualURLToURL(existing_entry, params.url);
[email protected]ad23a092011-12-28 07:02:041053 existing_entry->SetURL(params.url);
[email protected]a0e69262009-06-03 19:08:481054
[email protected]cbab76d2008-10-13 22:42:471055 DiscardNonCommittedEntries();
[email protected]e9ba4472008-09-14 15:42:431056}
1057
[email protected]d202a7c2012-01-04 07:53:471058void NavigationControllerImpl::RendererDidNavigateInPage(
[email protected]befd8d822009-07-01 04:51:471059 const ViewHostMsg_FrameNavigate_Params& params, bool* did_replace_entry) {
[email protected]8ff00d72012-10-23 19:12:211060 DCHECK(PageTransitionIsMainFrame(params.transition)) <<
[email protected]e9ba4472008-09-14 15:42:431061 "WebKit should only tell us about in-page navs for the main frame.";
1062 // We're guaranteed to have an entry for this one.
[email protected]10f417c52011-12-28 21:04:231063 NavigationEntryImpl* existing_entry = GetEntryWithPageID(
[email protected]2db9bd72012-04-13 20:20:561064 web_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:431065
1066 // Reference fragment navigation. We're guaranteed to have the last_committed
1067 // entry and it will be the same page as the new navigation (minus the
[email protected]d466b8a2011-07-15 21:48:031068 // reference fragments, of course). We'll update the URL of the existing
1069 // entry without pruning the forward history.
[email protected]ad23a092011-12-28 07:02:041070 existing_entry->SetURL(params.url);
[email protected]d466b8a2011-07-15 21:48:031071 if (existing_entry->update_virtual_url_with_url())
1072 UpdateVirtualURLToURL(existing_entry, params.url);
[email protected]ccbe04e2010-03-17 17:58:431073
1074 // This replaces the existing entry since the page ID didn't change.
1075 *did_replace_entry = true;
[email protected]d466b8a2011-07-15 21:48:031076
[email protected]6eebaab2012-11-15 04:39:491077 DiscardNonCommittedEntriesInternal();
[email protected]d466b8a2011-07-15 21:48:031078
1079 // If a transient entry was removed, the indices might have changed, so we
1080 // have to query the entry index again.
1081 last_committed_entry_index_ =
[email protected]2db9bd72012-04-13 20:20:561082 GetEntryIndexWithPageID(web_contents_->GetSiteInstance(), params.page_id);
[email protected]e9ba4472008-09-14 15:42:431083}
1084
[email protected]d202a7c2012-01-04 07:53:471085void NavigationControllerImpl::RendererDidNavigateNewSubframe(
[email protected]e9ba4472008-09-14 15:42:431086 const ViewHostMsg_FrameNavigate_Params& params) {
[email protected]8ff00d72012-10-23 19:12:211087 if (PageTransitionStripQualifier(params.transition) ==
1088 PAGE_TRANSITION_AUTO_SUBFRAME) {
[email protected]09b8f82f2009-06-16 20:22:111089 // This is not user-initiated. Ignore.
1090 return;
1091 }
[email protected]09b8f82f2009-06-16 20:22:111092
[email protected]e9ba4472008-09-14 15:42:431093 // Manual subframe navigations just get the current entry cloned so the user
1094 // can go back or forward to it. The actual subframe information will be
1095 // stored in the page state for each of those entries. This happens out of
1096 // band with the actual navigations.
[email protected]4c27ba82008-09-24 16:49:091097 DCHECK(GetLastCommittedEntry()) << "ClassifyNavigation should guarantee "
1098 << "that a last committed entry exists.";
[email protected]10f417c52011-12-28 21:04:231099 NavigationEntryImpl* new_entry = new NavigationEntryImpl(
1100 *NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry()));
[email protected]36fc0392011-12-25 03:59:511101 new_entry->SetPageID(params.page_id);
[email protected]672eba292009-05-13 13:22:451102 InsertOrReplaceEntry(new_entry, false);
[email protected]e9ba4472008-09-14 15:42:431103}
1104
[email protected]d202a7c2012-01-04 07:53:471105bool NavigationControllerImpl::RendererDidNavigateAutoSubframe(
[email protected]e9ba4472008-09-14 15:42:431106 const ViewHostMsg_FrameNavigate_Params& params) {
1107 // We're guaranteed to have a previously committed entry, and we now need to
1108 // handle navigation inside of a subframe in it without creating a new entry.
1109 DCHECK(GetLastCommittedEntry());
1110
1111 // Handle the case where we're navigating back/forward to a previous subframe
1112 // navigation entry. This is case "2." in NAV_AUTO_SUBFRAME comment in the
1113 // header file. In case "1." this will be a NOP.
1114 int entry_index = GetEntryIndexWithPageID(
[email protected]2db9bd72012-04-13 20:20:561115 web_contents_->GetSiteInstance(),
[email protected]e9ba4472008-09-14 15:42:431116 params.page_id);
1117 if (entry_index < 0 ||
1118 entry_index >= static_cast<int>(entries_.size())) {
1119 NOTREACHED();
1120 return false;
1121 }
1122
1123 // Update the current navigation entry in case we're going back/forward.
1124 if (entry_index != last_committed_entry_index_) {
[email protected]e9ba4472008-09-14 15:42:431125 last_committed_entry_index_ = entry_index;
[email protected]e9ba4472008-09-14 15:42:431126 return true;
1127 }
1128 return false;
1129}
1130
[email protected]d202a7c2012-01-04 07:53:471131int NavigationControllerImpl::GetIndexOfEntry(
[email protected]10f417c52011-12-28 21:04:231132 const NavigationEntryImpl* entry) const {
[email protected]765b35502008-08-21 00:51:201133 const NavigationEntries::const_iterator i(std::find(
1134 entries_.begin(),
1135 entries_.end(),
1136 entry));
1137 return (i == entries_.end()) ? -1 : static_cast<int>(i - entries_.begin());
1138}
1139
[email protected]ce760d742012-08-30 22:31:101140bool NavigationControllerImpl::IsURLInPageNavigation(
1141 const GURL& url, bool renderer_says_in_page) const {
[email protected]10f417c52011-12-28 21:04:231142 NavigationEntry* last_committed = GetLastCommittedEntry();
[email protected]ce760d742012-08-30 22:31:101143 return last_committed && AreURLsInPageNavigation(
1144 last_committed->GetURL(), url, renderer_says_in_page);
[email protected]e9ba4472008-09-14 15:42:431145}
1146
[email protected]d202a7c2012-01-04 07:53:471147void NavigationControllerImpl::CopyStateFrom(
[email protected]c5eed492012-01-04 17:07:501148 const NavigationController& temp) {
[email protected]d202a7c2012-01-04 07:53:471149 const NavigationControllerImpl& source =
1150 static_cast<const NavigationControllerImpl&>(temp);
[email protected]ce3fa3c2009-04-20 19:55:571151 // Verify that we look new.
[email protected]a26023822011-12-29 00:23:551152 DCHECK(GetEntryCount() == 0 && !GetPendingEntry());
[email protected]ce3fa3c2009-04-20 19:55:571153
[email protected]a26023822011-12-29 00:23:551154 if (source.GetEntryCount() == 0)
[email protected]ce3fa3c2009-04-20 19:55:571155 return; // Nothing new to do.
1156
1157 needs_reload_ = true;
[email protected]a26023822011-12-29 00:23:551158 InsertEntriesFrom(source, source.GetEntryCount());
[email protected]ce3fa3c2009-04-20 19:55:571159
[email protected]d1198fd2012-08-13 22:50:191160 for (SessionStorageNamespaceMap::const_iterator it =
1161 source.session_storage_namespace_map_.begin();
1162 it != source.session_storage_namespace_map_.end();
1163 ++it) {
1164 SessionStorageNamespaceImpl* source_namespace =
1165 static_cast<SessionStorageNamespaceImpl*>(it->second.get());
1166 session_storage_namespace_map_.insert(
1167 make_pair(it->first, source_namespace->Clone()));
1168 }
[email protected]4e6419c2010-01-15 04:50:341169
[email protected]2ca1ea662012-10-04 02:26:361170 FinishRestore(source.last_committed_entry_index_, RESTORE_CURRENT_SESSION);
[email protected]91854cd2012-01-10 19:43:571171
1172 // Copy the max page id map from the old tab to the new tab. This ensures
1173 // that new and existing navigations in the tab's current SiteInstances
1174 // are identified properly.
[email protected]2db9bd72012-04-13 20:20:561175 web_contents_->CopyMaxPageIDsFrom(source.web_contents());
[email protected]ce3fa3c2009-04-20 19:55:571176}
1177
[email protected]d202a7c2012-01-04 07:53:471178void NavigationControllerImpl::CopyStateFromAndPrune(
[email protected]c5eed492012-01-04 17:07:501179 NavigationController* temp) {
[email protected]d202a7c2012-01-04 07:53:471180 NavigationControllerImpl* source =
1181 static_cast<NavigationControllerImpl*>(temp);
[email protected]9e1ad4b2011-08-14 16:49:191182 // The SiteInstance and page_id of the last committed entry needs to be
1183 // remembered at this point, in case there is only one committed entry
[email protected]91854cd2012-01-10 19:43:571184 // and it is pruned. We use a scoped_refptr to ensure the SiteInstance
1185 // can't be freed during this time period.
[email protected]10f417c52011-12-28 21:04:231186 NavigationEntryImpl* last_committed =
1187 NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry());
[email protected]91854cd2012-01-10 19:43:571188 scoped_refptr<SiteInstance> site_instance(
1189 last_committed ? last_committed->site_instance() : NULL);
[email protected]36fc0392011-12-25 03:59:511190 int32 minimum_page_id = last_committed ? last_committed->GetPageID() : -1;
[email protected]91854cd2012-01-10 19:43:571191 int32 max_page_id = last_committed ?
[email protected]2db9bd72012-04-13 20:20:561192 web_contents_->GetMaxPageIDForSiteInstance(site_instance.get()) : -1;
[email protected]9e1ad4b2011-08-14 16:49:191193
[email protected]e1cd5452010-08-26 18:03:251194 // This code is intended for use when the last entry is the active entry.
[email protected]a26023822011-12-29 00:23:551195 DCHECK(
1196 (transient_entry_index_ != -1 &&
[email protected]91854cd2012-01-10 19:43:571197 transient_entry_index_ == GetEntryCount() - 1) ||
[email protected]a26023822011-12-29 00:23:551198 (pending_entry_ && (pending_entry_index_ == -1 ||
1199 pending_entry_index_ == GetEntryCount() - 1)) ||
1200 (!pending_entry_ && last_committed_entry_index_ == GetEntryCount() - 1));
[email protected]e1cd5452010-08-26 18:03:251201
1202 // Remove all the entries leaving the active entry.
1203 PruneAllButActive();
1204
[email protected]944822b2012-03-02 20:57:251205 // We now have zero or one entries. Ensure that adding the entries from
1206 // source won't put us over the limit.
1207 DCHECK(GetEntryCount() == 0 || GetEntryCount() == 1);
1208 if (GetEntryCount() > 0)
1209 source->PruneOldestEntryIfFull();
1210
[email protected]47e020a2010-10-15 14:43:371211 // Insert the entries from source. Don't use source->GetCurrentEntryIndex as
[email protected]e1cd5452010-08-26 18:03:251212 // we don't want to copy over the transient entry.
[email protected]47e020a2010-10-15 14:43:371213 int max_source_index = source->pending_entry_index_ != -1 ?
1214 source->pending_entry_index_ : source->last_committed_entry_index_;
[email protected]e1cd5452010-08-26 18:03:251215 if (max_source_index == -1)
[email protected]a26023822011-12-29 00:23:551216 max_source_index = source->GetEntryCount();
[email protected]e1cd5452010-08-26 18:03:251217 else
1218 max_source_index++;
[email protected]47e020a2010-10-15 14:43:371219 InsertEntriesFrom(*source, max_source_index);
[email protected]e1cd5452010-08-26 18:03:251220
1221 // Adjust indices such that the last entry and pending are at the end now.
[email protected]a26023822011-12-29 00:23:551222 last_committed_entry_index_ = GetEntryCount() - 1;
[email protected]e1cd5452010-08-26 18:03:251223 if (pending_entry_index_ != -1)
[email protected]a26023822011-12-29 00:23:551224 pending_entry_index_ = GetEntryCount() - 1;
[email protected]e1cd5452010-08-26 18:03:251225 if (transient_entry_index_ != -1) {
1226 // There's a transient entry. In this case we want the last committed to
1227 // point to the previous entry.
[email protected]a26023822011-12-29 00:23:551228 transient_entry_index_ = GetEntryCount() - 1;
[email protected]e1cd5452010-08-26 18:03:251229 if (last_committed_entry_index_ != -1)
1230 last_committed_entry_index_--;
1231 }
[email protected]796931a92011-08-10 01:32:141232
[email protected]2db9bd72012-04-13 20:20:561233 web_contents_->SetHistoryLengthAndPrune(site_instance.get(),
[email protected]9e1ad4b2011-08-14 16:49:191234 max_source_index,
1235 minimum_page_id);
[email protected]91854cd2012-01-10 19:43:571236
1237 // Copy the max page id map from the old tab to the new tab. This ensures
1238 // that new and existing navigations in the tab's current SiteInstances
1239 // are identified properly.
[email protected]2db9bd72012-04-13 20:20:561240 web_contents_->CopyMaxPageIDsFrom(source->web_contents());
[email protected]91854cd2012-01-10 19:43:571241
1242 // If there is a last committed entry, be sure to include it in the new
1243 // max page ID map.
1244 if (max_page_id > -1) {
[email protected]2db9bd72012-04-13 20:20:561245 web_contents_->UpdateMaxPageIDForSiteInstance(site_instance.get(),
[email protected]91854cd2012-01-10 19:43:571246 max_page_id);
1247 }
[email protected]e1cd5452010-08-26 18:03:251248}
1249
[email protected]d202a7c2012-01-04 07:53:471250void NavigationControllerImpl::PruneAllButActive() {
[email protected]97b6c4f2010-09-27 19:31:261251 if (transient_entry_index_ != -1) {
1252 // There is a transient entry. Prune up to it.
[email protected]a26023822011-12-29 00:23:551253 DCHECK_EQ(GetEntryCount() - 1, transient_entry_index_);
[email protected]77d8d622010-12-15 10:30:121254 entries_.erase(entries_.begin(), entries_.begin() + transient_entry_index_);
[email protected]97b6c4f2010-09-27 19:31:261255 transient_entry_index_ = 0;
1256 last_committed_entry_index_ = -1;
1257 pending_entry_index_ = -1;
1258 } else if (!pending_entry_) {
1259 // There's no pending entry. Leave the last entry (if there is one).
[email protected]a26023822011-12-29 00:23:551260 if (!GetEntryCount())
[email protected]97b6c4f2010-09-27 19:31:261261 return;
1262
[email protected]77d8d622010-12-15 10:30:121263 DCHECK(last_committed_entry_index_ >= 0);
1264 entries_.erase(entries_.begin(),
1265 entries_.begin() + last_committed_entry_index_);
1266 entries_.erase(entries_.begin() + 1, entries_.end());
[email protected]97b6c4f2010-09-27 19:31:261267 last_committed_entry_index_ = 0;
1268 } else if (pending_entry_index_ != -1) {
[email protected]77d8d622010-12-15 10:30:121269 entries_.erase(entries_.begin(), entries_.begin() + pending_entry_index_);
1270 entries_.erase(entries_.begin() + 1, entries_.end());
[email protected]97b6c4f2010-09-27 19:31:261271 pending_entry_index_ = 0;
1272 last_committed_entry_index_ = 0;
[email protected]97b6c4f2010-09-27 19:31:261273 } else {
1274 // There is a pending_entry, but it's not in entries_.
1275 pending_entry_index_ = -1;
1276 last_committed_entry_index_ = -1;
[email protected]77d8d622010-12-15 10:30:121277 entries_.clear();
[email protected]97b6c4f2010-09-27 19:31:261278 }
1279
[email protected]2db9bd72012-04-13 20:20:561280 if (web_contents_->GetInterstitialPage()) {
[email protected]97b6c4f2010-09-27 19:31:261281 // Normally the interstitial page hides itself if the user doesn't proceeed.
1282 // This would result in showing a NavigationEntry we just removed. Set this
1283 // so the interstitial triggers a reload if the user doesn't proceed.
[email protected]2db9bd72012-04-13 20:20:561284 static_cast<InterstitialPageImpl*>(web_contents_->GetInterstitialPage())->
[email protected]cadaec52012-02-08 21:53:131285 set_reload_on_dont_proceed(true);
[email protected]97b6c4f2010-09-27 19:31:261286 }
[email protected]97b6c4f2010-09-27 19:31:261287}
1288
[email protected]d1198fd2012-08-13 22:50:191289void NavigationControllerImpl::SetSessionStorageNamespace(
1290 const std::string& partition_id,
[email protected]8ff00d72012-10-23 19:12:211291 SessionStorageNamespace* session_storage_namespace) {
[email protected]d1198fd2012-08-13 22:50:191292 if (!session_storage_namespace)
1293 return;
1294
1295 // We can't overwrite an existing SessionStorage without violating spec.
1296 // Attempts to do so may give a tab access to another tab's session storage
1297 // so die hard on an error.
1298 bool successful_insert = session_storage_namespace_map_.insert(
1299 make_pair(partition_id,
1300 static_cast<SessionStorageNamespaceImpl*>(
1301 session_storage_namespace)))
1302 .second;
1303 CHECK(successful_insert) << "Cannot replace existing SessionStorageNamespace";
1304}
1305
[email protected]d202a7c2012-01-04 07:53:471306void NavigationControllerImpl::SetMaxRestoredPageID(int32 max_id) {
[email protected]71fde352011-12-29 03:29:561307 max_restored_page_id_ = max_id;
1308}
1309
[email protected]d202a7c2012-01-04 07:53:471310int32 NavigationControllerImpl::GetMaxRestoredPageID() const {
[email protected]71fde352011-12-29 03:29:561311 return max_restored_page_id_;
[email protected]a26023822011-12-29 00:23:551312}
1313
1314SessionStorageNamespace*
[email protected]8ff00d72012-10-23 19:12:211315NavigationControllerImpl::GetSessionStorageNamespace(SiteInstance* instance) {
[email protected]d1198fd2012-08-13 22:50:191316 std::string partition_id;
1317 if (instance) {
1318 // TODO(ajwong): When GetDefaultSessionStorageNamespace() goes away, remove
1319 // this if statement so |instance| must not be NULL.
1320 partition_id =
[email protected]e94bbcb2012-09-07 05:33:571321 GetContentClient()->browser()->GetStoragePartitionIdForSite(
[email protected]77ab17312012-09-28 15:34:591322 browser_context_, instance->GetSiteURL());
[email protected]d1198fd2012-08-13 22:50:191323 }
1324
1325 SessionStorageNamespaceMap::const_iterator it =
1326 session_storage_namespace_map_.find(partition_id);
1327 if (it != session_storage_namespace_map_.end())
1328 return it->second.get();
1329
1330 // Create one if no one has accessed session storage for this partition yet.
[email protected]4c3a23582012-08-18 08:54:341331 //
1332 // TODO(ajwong): Should this use the |partition_id| directly rather than
1333 // re-lookup via |instance|? http://crbug.com/142685
[email protected]8ff00d72012-10-23 19:12:211334 StoragePartition* partition =
[email protected]4c3a23582012-08-18 08:54:341335 BrowserContext::GetStoragePartition(browser_context_, instance);
[email protected]d1198fd2012-08-13 22:50:191336 SessionStorageNamespaceImpl* session_storage_namespace =
1337 new SessionStorageNamespaceImpl(
1338 static_cast<DOMStorageContextImpl*>(
[email protected]4c3a23582012-08-18 08:54:341339 partition->GetDOMStorageContext()));
[email protected]d1198fd2012-08-13 22:50:191340 session_storage_namespace_map_[partition_id] = session_storage_namespace;
1341
1342 return session_storage_namespace;
1343}
1344
1345SessionStorageNamespace*
1346NavigationControllerImpl::GetDefaultSessionStorageNamespace() {
1347 // TODO(ajwong): Remove if statement in GetSessionStorageNamespace().
1348 return GetSessionStorageNamespace(NULL);
1349}
1350
1351const SessionStorageNamespaceMap&
1352NavigationControllerImpl::GetSessionStorageNamespaceMap() const {
1353 return session_storage_namespace_map_;
[email protected]a26023822011-12-29 00:23:551354}
[email protected]d202a7c2012-01-04 07:53:471355
1356bool NavigationControllerImpl::NeedsReload() const {
[email protected]71fde352011-12-29 03:29:561357 return needs_reload_;
1358}
[email protected]a26023822011-12-29 00:23:551359
[email protected]d202a7c2012-01-04 07:53:471360void NavigationControllerImpl::RemoveEntryAtIndexInternal(int index) {
[email protected]a26023822011-12-29 00:23:551361 DCHECK(index < GetEntryCount());
[email protected]6a13a6c2011-12-20 21:47:121362 DCHECK(index != last_committed_entry_index_);
[email protected]43032342011-03-21 14:10:311363
1364 DiscardNonCommittedEntries();
1365
1366 entries_.erase(entries_.begin() + index);
[email protected]6a13a6c2011-12-20 21:47:121367 if (last_committed_entry_index_ > index)
[email protected]43032342011-03-21 14:10:311368 last_committed_entry_index_--;
1369}
1370
[email protected]d202a7c2012-01-04 07:53:471371void NavigationControllerImpl::DiscardNonCommittedEntries() {
[email protected]cbab76d2008-10-13 22:42:471372 bool transient = transient_entry_index_ != -1;
1373 DiscardNonCommittedEntriesInternal();
initial.commit09911bf2008-07-26 23:55:291374
[email protected]cbab76d2008-10-13 22:42:471375 // If there was a transient entry, invalidate everything so the new active
1376 // entry state is shown.
1377 if (transient) {
[email protected]2db9bd72012-04-13 20:20:561378 web_contents_->NotifyNavigationStateChanged(kInvalidateAll);
[email protected]cbab76d2008-10-13 22:42:471379 }
initial.commit09911bf2008-07-26 23:55:291380}
1381
[email protected]d202a7c2012-01-04 07:53:471382NavigationEntry* NavigationControllerImpl::GetPendingEntry() const {
[email protected]022af742011-12-28 18:37:251383 return pending_entry_;
1384}
1385
[email protected]d202a7c2012-01-04 07:53:471386int NavigationControllerImpl::GetPendingEntryIndex() const {
[email protected]a26023822011-12-29 00:23:551387 return pending_entry_index_;
1388}
1389
[email protected]d202a7c2012-01-04 07:53:471390void NavigationControllerImpl::InsertOrReplaceEntry(NavigationEntryImpl* entry,
1391 bool replace) {
[email protected]8ff00d72012-10-23 19:12:211392 DCHECK(entry->GetTransitionType() != PAGE_TRANSITION_AUTO_SUBFRAME);
[email protected]765b35502008-08-21 00:51:201393
1394 // Copy the pending entry's unique ID to the committed entry.
1395 // I don't know if pending_entry_index_ can be other than -1 here.
[email protected]10f417c52011-12-28 21:04:231396 const NavigationEntryImpl* const pending_entry =
1397 (pending_entry_index_ == -1) ?
1398 pending_entry_ : entries_[pending_entry_index_].get();
[email protected]765b35502008-08-21 00:51:201399 if (pending_entry)
[email protected]36fc0392011-12-25 03:59:511400 entry->set_unique_id(pending_entry->GetUniqueID());
[email protected]765b35502008-08-21 00:51:201401
[email protected]cbab76d2008-10-13 22:42:471402 DiscardNonCommittedEntriesInternal();
[email protected]765b35502008-08-21 00:51:201403
1404 int current_size = static_cast<int>(entries_.size());
1405
[email protected]765b35502008-08-21 00:51:201406 if (current_size > 0) {
[email protected]672eba292009-05-13 13:22:451407 // Prune any entries which are in front of the current entry.
1408 // Also prune the current entry if we are to replace the current entry.
[email protected]47dcbdc2011-05-27 15:08:311409 // last_committed_entry_index_ must be updated here since calls to
1410 // NotifyPrunedEntries() below may re-enter and we must make sure
1411 // last_committed_entry_index_ is not left in an invalid state.
1412 if (replace)
1413 --last_committed_entry_index_;
1414
[email protected]c12bf1a12008-09-17 16:28:491415 int num_pruned = 0;
[email protected]47dcbdc2011-05-27 15:08:311416 while (last_committed_entry_index_ < (current_size - 1)) {
[email protected]c12bf1a12008-09-17 16:28:491417 num_pruned++;
[email protected]765b35502008-08-21 00:51:201418 entries_.pop_back();
1419 current_size--;
1420 }
[email protected]c12bf1a12008-09-17 16:28:491421 if (num_pruned > 0) // Only notify if we did prune something.
1422 NotifyPrunedEntries(this, false, num_pruned);
[email protected]765b35502008-08-21 00:51:201423 }
1424
[email protected]944822b2012-03-02 20:57:251425 PruneOldestEntryIfFull();
[email protected]765b35502008-08-21 00:51:201426
[email protected]10f417c52011-12-28 21:04:231427 entries_.push_back(linked_ptr<NavigationEntryImpl>(entry));
[email protected]765b35502008-08-21 00:51:201428 last_committed_entry_index_ = static_cast<int>(entries_.size()) - 1;
[email protected]e9ba4472008-09-14 15:42:431429
1430 // This is a new page ID, so we need everybody to know about it.
[email protected]2db9bd72012-04-13 20:20:561431 web_contents_->UpdateMaxPageID(entry->GetPageID());
initial.commit09911bf2008-07-26 23:55:291432}
1433
[email protected]944822b2012-03-02 20:57:251434void NavigationControllerImpl::PruneOldestEntryIfFull() {
1435 if (entries_.size() >= max_entry_count()) {
1436 DCHECK_EQ(max_entry_count(), entries_.size());
1437 DCHECK(last_committed_entry_index_ > 0);
1438 RemoveEntryAtIndex(0);
1439 NotifyPrunedEntries(this, true, 1);
1440 }
1441}
1442
[email protected]d202a7c2012-01-04 07:53:471443void NavigationControllerImpl::NavigateToPendingEntry(ReloadType reload_type) {
[email protected]72097fd02010-01-21 23:36:011444 needs_reload_ = false;
1445
[email protected]83c2e232011-10-07 21:36:461446 // If we were navigating to a slow-to-commit page, and the user performs
1447 // a session history navigation to the last committed page, RenderViewHost
1448 // will force the throbber to start, but WebKit will essentially ignore the
1449 // navigation, and won't send a message to stop the throbber. To prevent this
1450 // from happening, we drop the navigation here and stop the slow-to-commit
1451 // page from loading (which would normally happen during the navigation).
1452 if (pending_entry_index_ != -1 &&
1453 pending_entry_index_ == last_committed_entry_index_ &&
1454 (entries_[pending_entry_index_]->restore_type() ==
[email protected]10f417c52011-12-28 21:04:231455 NavigationEntryImpl::RESTORE_NONE) &&
[email protected]36fc0392011-12-25 03:59:511456 (entries_[pending_entry_index_]->GetTransitionType() &
[email protected]8ff00d72012-10-23 19:12:211457 PAGE_TRANSITION_FORWARD_BACK)) {
[email protected]2db9bd72012-04-13 20:20:561458 web_contents_->Stop();
[email protected]6a13a6c2011-12-20 21:47:121459
1460 // If an interstitial page is showing, we want to close it to get back
1461 // to what was showing before.
[email protected]2db9bd72012-04-13 20:20:561462 if (web_contents_->GetInterstitialPage())
1463 web_contents_->GetInterstitialPage()->DontProceed();
[email protected]6a13a6c2011-12-20 21:47:121464
[email protected]83c2e232011-10-07 21:36:461465 DiscardNonCommittedEntries();
1466 return;
1467 }
1468
[email protected]6a13a6c2011-12-20 21:47:121469 // If an interstitial page is showing, the previous renderer is blocked and
1470 // cannot make new requests. Unblock (and disable) it to allow this
1471 // navigation to succeed. The interstitial will stay visible until the
1472 // resulting DidNavigate.
[email protected]2db9bd72012-04-13 20:20:561473 if (web_contents_->GetInterstitialPage()) {
1474 static_cast<InterstitialPageImpl*>(web_contents_->GetInterstitialPage())->
[email protected]cadaec52012-02-08 21:53:131475 CancelForNavigation();
1476 }
[email protected]6a13a6c2011-12-20 21:47:121477
initial.commit09911bf2008-07-26 23:55:291478 // For session history navigations only the pending_entry_index_ is set.
1479 if (!pending_entry_) {
[email protected]4bf3522c2010-08-19 21:00:201480 DCHECK_NE(pending_entry_index_, -1);
[email protected]765b35502008-08-21 00:51:201481 pending_entry_ = entries_[pending_entry_index_].get();
initial.commit09911bf2008-07-26 23:55:291482 }
1483
[email protected]2db9bd72012-04-13 20:20:561484 if (!web_contents_->NavigateToPendingEntry(reload_type))
[email protected]cbab76d2008-10-13 22:42:471485 DiscardNonCommittedEntries();
[email protected]77362eb2011-08-01 17:18:381486
1487 // If the entry is being restored and doesn't have a SiteInstance yet, fill
1488 // it in now that we know. This allows us to find the entry when it commits.
1489 // This works for browser-initiated navigations. We handle renderer-initiated
[email protected]2db9bd72012-04-13 20:20:561490 // navigations to restored entries in WebContentsImpl::OnGoToEntryAtOffset.
[email protected]77362eb2011-08-01 17:18:381491 if (pending_entry_ && !pending_entry_->site_instance() &&
[email protected]10f417c52011-12-28 21:04:231492 pending_entry_->restore_type() != NavigationEntryImpl::RESTORE_NONE) {
[email protected]b6583592012-01-25 19:52:331493 pending_entry_->set_site_instance(static_cast<SiteInstanceImpl*>(
[email protected]2db9bd72012-04-13 20:20:561494 web_contents_->GetPendingSiteInstance()));
[email protected]10f417c52011-12-28 21:04:231495 pending_entry_->set_restore_type(NavigationEntryImpl::RESTORE_NONE);
[email protected]77362eb2011-08-01 17:18:381496 }
initial.commit09911bf2008-07-26 23:55:291497}
1498
[email protected]d202a7c2012-01-04 07:53:471499void NavigationControllerImpl::NotifyNavigationEntryCommitted(
[email protected]8ff00d72012-10-23 19:12:211500 LoadCommittedDetails* details) {
[email protected]df1af242009-05-01 00:11:401501 details->entry = GetActiveEntry();
[email protected]8ff00d72012-10-23 19:12:211502 NotificationDetails notification_details =
1503 Details<LoadCommittedDetails>(details);
[email protected]df1af242009-05-01 00:11:401504
[email protected]2db9bd72012-04-13 20:20:561505 // We need to notify the ssl_manager_ before the web_contents_ so the
[email protected]df1af242009-05-01 00:11:401506 // location bar will have up-to-date information about the security style
1507 // when it wants to draw. See http://crbug.com/11157
1508 ssl_manager_.DidCommitProvisionalLoad(notification_details);
1509
initial.commit09911bf2008-07-26 23:55:291510 // TODO(pkasting): http://b/1113079 Probably these explicit notification paths
1511 // should be removed, and interested parties should just listen for the
1512 // notification below instead.
[email protected]2db9bd72012-04-13 20:20:561513 web_contents_->NotifyNavigationStateChanged(kInvalidateAll);
initial.commit09911bf2008-07-26 23:55:291514
[email protected]8ff00d72012-10-23 19:12:211515 NotificationService::current()->Notify(
1516 NOTIFICATION_NAV_ENTRY_COMMITTED,
1517 Source<NavigationController>(this),
[email protected]df1af242009-05-01 00:11:401518 notification_details);
initial.commit09911bf2008-07-26 23:55:291519}
1520
initial.commit09911bf2008-07-26 23:55:291521// static
[email protected]d202a7c2012-01-04 07:53:471522size_t NavigationControllerImpl::max_entry_count() {
[email protected]9b51970d2011-12-09 23:10:231523 if (max_entry_count_for_testing_ != kMaxEntryCountForTestingNotSet)
1524 return max_entry_count_for_testing_;
[email protected]8ff00d72012-10-23 19:12:211525 return kMaxSessionHistoryEntries;
[email protected]9b51970d2011-12-09 23:10:231526}
1527
[email protected]d202a7c2012-01-04 07:53:471528void NavigationControllerImpl::SetActive(bool is_active) {
[email protected]ee613922009-09-02 20:38:221529 if (is_active && needs_reload_)
1530 LoadIfNecessary();
initial.commit09911bf2008-07-26 23:55:291531}
1532
[email protected]d202a7c2012-01-04 07:53:471533void NavigationControllerImpl::LoadIfNecessary() {
initial.commit09911bf2008-07-26 23:55:291534 if (!needs_reload_)
1535 return;
1536
initial.commit09911bf2008-07-26 23:55:291537 // Calling Reload() results in ignoring state, and not loading.
1538 // Explicitly use NavigateToPendingEntry so that the renderer uses the
1539 // cached state.
1540 pending_entry_index_ = last_committed_entry_index_;
[email protected]1ccb3568d2010-02-19 10:51:161541 NavigateToPendingEntry(NO_RELOAD);
initial.commit09911bf2008-07-26 23:55:291542}
1543
[email protected]d202a7c2012-01-04 07:53:471544void NavigationControllerImpl::NotifyEntryChanged(const NavigationEntry* entry,
1545 int index) {
[email protected]8ff00d72012-10-23 19:12:211546 EntryChangedDetails det;
[email protected]534e54b2008-08-13 15:40:091547 det.changed_entry = entry;
1548 det.index = index;
[email protected]8ff00d72012-10-23 19:12:211549 NotificationService::current()->Notify(
1550 NOTIFICATION_NAV_ENTRY_CHANGED,
1551 Source<NavigationController>(this),
1552 Details<EntryChangedDetails>(&det));
initial.commit09911bf2008-07-26 23:55:291553}
1554
[email protected]d202a7c2012-01-04 07:53:471555void NavigationControllerImpl::FinishRestore(int selected_index,
[email protected]2ca1ea662012-10-04 02:26:361556 RestoreType type) {
[email protected]a26023822011-12-29 00:23:551557 DCHECK(selected_index >= 0 && selected_index < GetEntryCount());
[email protected]2ca1ea662012-10-04 02:26:361558 ConfigureEntriesForRestore(&entries_, type);
initial.commit09911bf2008-07-26 23:55:291559
[email protected]71fde352011-12-29 03:29:561560 SetMaxRestoredPageID(static_cast<int32>(GetEntryCount()));
initial.commit09911bf2008-07-26 23:55:291561
1562 last_committed_entry_index_ = selected_index;
initial.commit09911bf2008-07-26 23:55:291563}
[email protected]765b35502008-08-21 00:51:201564
[email protected]d202a7c2012-01-04 07:53:471565void NavigationControllerImpl::DiscardNonCommittedEntriesInternal() {
[email protected]765b35502008-08-21 00:51:201566 if (pending_entry_index_ == -1)
1567 delete pending_entry_;
1568 pending_entry_ = NULL;
1569 pending_entry_index_ = -1;
[email protected]cbab76d2008-10-13 22:42:471570
1571 DiscardTransientEntry();
1572}
1573
[email protected]d202a7c2012-01-04 07:53:471574void NavigationControllerImpl::DiscardTransientEntry() {
[email protected]cbab76d2008-10-13 22:42:471575 if (transient_entry_index_ == -1)
1576 return;
[email protected]a0e69262009-06-03 19:08:481577 entries_.erase(entries_.begin() + transient_entry_index_);
[email protected]80858db52009-10-15 00:35:181578 if (last_committed_entry_index_ > transient_entry_index_)
1579 last_committed_entry_index_--;
[email protected]cbab76d2008-10-13 22:42:471580 transient_entry_index_ = -1;
[email protected]765b35502008-08-21 00:51:201581}
1582
[email protected]d202a7c2012-01-04 07:53:471583int NavigationControllerImpl::GetEntryIndexWithPageID(
[email protected]7f0005a2009-04-15 03:25:111584 SiteInstance* instance, int32 page_id) const {
[email protected]765b35502008-08-21 00:51:201585 for (int i = static_cast<int>(entries_.size()) - 1; i >= 0; --i) {
[email protected]7f0005a2009-04-15 03:25:111586 if ((entries_[i]->site_instance() == instance) &&
[email protected]36fc0392011-12-25 03:59:511587 (entries_[i]->GetPageID() == page_id))
[email protected]765b35502008-08-21 00:51:201588 return i;
1589 }
1590 return -1;
1591}
[email protected]cbab76d2008-10-13 22:42:471592
[email protected]d202a7c2012-01-04 07:53:471593NavigationEntry* NavigationControllerImpl::GetTransientEntry() const {
[email protected]cbab76d2008-10-13 22:42:471594 if (transient_entry_index_ == -1)
1595 return NULL;
1596 return entries_[transient_entry_index_].get();
1597}
[email protected]e1cd5452010-08-26 18:03:251598
[email protected]d202a7c2012-01-04 07:53:471599void NavigationControllerImpl::InsertEntriesFrom(
1600 const NavigationControllerImpl& source,
[email protected]e1cd5452010-08-26 18:03:251601 int max_index) {
[email protected]a26023822011-12-29 00:23:551602 DCHECK_LE(max_index, source.GetEntryCount());
[email protected]e1cd5452010-08-26 18:03:251603 size_t insert_index = 0;
1604 for (int i = 0; i < max_index; i++) {
1605 // When cloning a tab, copy all entries except interstitial pages
[email protected]ad23a092011-12-28 07:02:041606 if (source.entries_[i].get()->GetPageType() !=
[email protected]8ff00d72012-10-23 19:12:211607 PAGE_TYPE_INTERSTITIAL) {
[email protected]e1cd5452010-08-26 18:03:251608 entries_.insert(entries_.begin() + insert_index++,
[email protected]10f417c52011-12-28 21:04:231609 linked_ptr<NavigationEntryImpl>(
1610 new NavigationEntryImpl(*source.entries_[i])));
[email protected]e1cd5452010-08-26 18:03:251611 }
1612 }
1613}
[email protected]c5b88d82012-10-06 17:03:331614
1615void NavigationControllerImpl::SetGetTimestampCallbackForTest(
1616 const base::Callback<base::Time()>& get_timestamp_callback) {
1617 get_timestamp_callback_ = get_timestamp_callback;
1618}
[email protected]8ff00d72012-10-23 19:12:211619
1620} // namespace content