Changes session restore to use a normal load rather than preferring...

chrome/browser/tab_contents/navigation_controller.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/tab_contents/navigation_controller.h"
 
 #include "app/resource_bundle.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 49 matching lines @@
 void SetContentStateIfEmpty(NavigationEntry* entry) {
   if (entry->content_state().empty()) {
     entry->set_content_state(
         webkit_glue::CreateHistoryStateForURL(entry->url()));
   }
 }
 
 // Configure all the NavigationEntries in entries for restore. This resets
 // the transition type to reload and makes sure the content state isn't empty.
 void ConfigureEntriesForRestore(
-    std::vector<linked_ptr<NavigationEntry> >* entries) {
+    std::vector<linked_ptr<NavigationEntry> >* entries,
+    bool from_last_session) {
   for (size_t i = 0; i < entries->size(); ++i) {
     // Use a transition type of reload so that we don't incorrectly increase
     // the typed count.
     (*entries)[i]->set_transition_type(PageTransition::RELOAD);
-    (*entries)[i]->set_restored(true);
+    (*entries)[i]->set_restore_type(from_last_session ?
+        NavigationEntry::RESTORE_LAST_SESSION :
+        NavigationEntry::RESTORE_CURRENT_SESSION);
     // NOTE(darin): This code is only needed for backwards compat.
     SetContentStateIfEmpty((*entries)[i].get());
   }
 }
 
 // See NavigationController::IsURLInPageNavigation for how this works and why.
 bool AreURLsInPageNavigation(const GURL& existing_url, const GURL& new_url) {
   if (existing_url == new_url || !new_url.has_ref())
     return false;
 
@@ skipping 52 matching lines @@
   DiscardNonCommittedEntriesInternal();
 
   NotificationService::current()->Notify(
       NotificationType::TAB_CLOSED,
       Source<NavigationController>(this),
       NotificationService::NoDetails());
 }
 
 void NavigationController::RestoreFromState(
     const std::vector<TabNavigation>& navigations,
-    int selected_navigation) {
+    int selected_navigation,
+    bool from_last_session) {
   // Verify that this controller is unused and that the input is valid.
   DCHECK(entry_count() == 0 && !pending_entry());
   DCHECK(selected_navigation >= 0 &&
          selected_navigation < static_cast<int>(navigations.size()));
 
   // Populate entries_ from the supplied TabNavigations.
   needs_reload_ = true;
   CreateNavigationEntriesFromTabNavigations(navigations, &entries_);
 
   // And finish the restore.
-  FinishRestore(selected_navigation);
+  FinishRestore(selected_navigation, from_last_session);
 }
 
 void NavigationController::Reload(bool check_for_repost) {
   // Reloading a transient entry does nothing.
   if (transient_entry_index_ != -1)
     return;
 
   DiscardNonCommittedEntriesInternal();
   int current_index = GetCurrentEntryIndex();
   if (check_for_repost_ && check_for_repost && current_index != -1 &&
@@ skipping 245 matching lines @@
   }
 
   // Assign the current site instance to any pending entry, so we can find it
   // later by calling GetEntryIndexWithPageID. We only care about this if the
   // pending entry is an existing navigation and not a new one (or else we
   // wouldn't care about finding it with GetEntryIndexWithPageID).
   //
   // TODO(brettw) this seems slightly bogus as we don't really know if the
   // pending entry is what this navigation is for. There is a similar TODO
   // w.r.t. the pending entry in RendererDidNavigateToNewPage.
-  if (pending_entry_index_ >= 0)
+  if (pending_entry_index_ >= 0) {
     pending_entry_->set_site_instance(tab_contents_->GetSiteInstance());
+    pending_entry_->set_restore_type(NavigationEntry::RESTORE_NONE);
+  }
 
   // Do navigation-type specific actions. These will make and commit an entry.
   details->type = ClassifyNavigation(params);
   switch (details->type) {
     case NavigationType::NEW_PAGE:
       RendererDidNavigateToNewPage(params, &(details->did_replace_entry));
       break;
     case NavigationType::EXISTING_PAGE:
       RendererDidNavigateToExistingPage(params);
       break;
@@ skipping 384 matching lines @@
 
   if (source.entry_count() == 0)
     return;  // Nothing new to do.
 
   needs_reload_ = true;
   for (int i = 0; i < source.entry_count(); i++) {
     entries_.push_back(linked_ptr<NavigationEntry>(
         new NavigationEntry(*source.entries_[i])));
   }
 
-  FinishRestore(source.last_committed_entry_index_);
+  FinishRestore(source.last_committed_entry_index_, false);
 }
 
 void NavigationController::DiscardNonCommittedEntries() {
   bool transient = transient_entry_index_ != -1;
   DiscardNonCommittedEntriesInternal();
 
   // If there was a transient entry, invalidate everything so the new active
   // entry state is shown.
   if (transient) {
     tab_contents_->NotifyNavigationStateChanged(kInvalidateAllButShelves);
@@ skipping 109 matching lines @@
 void NavigationController::NotifyEntryChanged(const NavigationEntry* entry,
                                               int index) {
   EntryChangedDetails det;
   det.changed_entry = entry;
   det.index = index;
   NotificationService::current()->Notify(NotificationType::NAV_ENTRY_CHANGED,
                                          Source<NavigationController>(this),
                                          Details<EntryChangedDetails>(&det));
 }
 
-void NavigationController::FinishRestore(int selected_index) {
+void NavigationController::FinishRestore(int selected_index,
+                                         bool from_last_session) {
   DCHECK(selected_index >= 0 && selected_index < entry_count());
-  ConfigureEntriesForRestore(&entries_);
+  ConfigureEntriesForRestore(&entries_, from_last_session);
 
   set_max_restored_page_id(entry_count());
 
   last_committed_entry_index_ = selected_index;
 }
 
 void NavigationController::DiscardNonCommittedEntriesInternal() {
   if (pending_entry_index_ == -1)
     delete pending_entry_;
   pending_entry_ = NULL;
@@ skipping 19 matching lines @@
       return i;
   }
   return -1;
 }
 
 NavigationEntry* NavigationController::GetTransientEntry() const {
   if (transient_entry_index_ == -1)
     return NULL;
   return entries_[transient_entry_index_].get();
 }