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

chrome/browser/sessions/tab_restore_service.cc

 // Copyright (c) 2006-2008 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/sessions/tab_restore_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <map>
 
 #include "base/scoped_vector.h"
 #include "base/stl_util-inl.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_command.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 
 using base::Time;
 
 // Entry ----------------------------------------------------------------------
 
 // ID of the next Entry.
 static SessionID::id_type next_entry_id = 1;
 
-TabRestoreService::Entry::Entry() : id(next_entry_id++), type(TAB) {}
+TabRestoreService::Entry::Entry()
+    : id(next_entry_id++),
+      type(TAB),
+      from_last_session(false) {}
 
-TabRestoreService::Entry::Entry(Type type) : id(next_entry_id++), type(type) {}
+TabRestoreService::Entry::Entry(Type type)
+    : id(next_entry_id++),
+      type(type),
+      from_last_session(false) {}
 
 // TabRestoreService ----------------------------------------------------------
 
 // static
 const size_t TabRestoreService::kMaxEntries = 10;
 
 // Identifier for commands written to file.
 // The ordering in the file is as follows:
 // . When the user closes a tab a command of type
 //   kCommandSelectedNavigationInTab is written identifying the tab and
@@ skipping 201 matching lines @@
   entries_.erase(i);
   i = entries_.end();
 
   // |browser| will be NULL in cases where one isn't already available (eg,
   // when invoked on Mac OS X with no windows open). In this case, create a
   // new browser into which we restore the tabs.
   if (entry->type == TAB) {
     Tab* tab = static_cast<Tab*>(entry);
     if (replace_existing_tab && browser) {
       browser->ReplaceRestoredTab(tab->navigations,
-                                  tab->current_navigation_index);
+                                  tab->current_navigation_index,
+                                  tab->from_last_session);
     } else {
       // Use the tab's former browser and index, if available.
       Browser* tab_browser = NULL;
       int tab_index = -1;
       if (tab->has_browser())
         tab_browser = BrowserList::FindBrowserWithID(tab->browser_id);
 
       if (tab_browser) {
         tab_index = tab->tabstrip_index;
       } else {
         tab_browser = Browser::Create(profile());
         if (tab->has_browser()) {
           UpdateTabBrowserIDs(tab->browser_id,
                               tab_browser->session_id().id());
         }
         tab_browser->window()->Show();
       }
 
       if (tab_index < 0 || tab_index > tab_browser->tab_count())
         tab_index = tab_browser->tab_count();
       tab_browser->AddRestoredTab(tab->navigations, tab_index,
                                   tab->current_navigation_index, true,
-                                  tab->pinned);
+                                  tab->pinned, tab->from_last_session);
     }
   } else if (entry->type == WINDOW) {
     const Window* window = static_cast<Window*>(entry);
     browser = Browser::Create(profile());
     for (size_t tab_i = 0; tab_i < window->tabs.size(); ++tab_i) {
       const Tab& tab = window->tabs[tab_i];
       TabContents* restored_tab =
           browser->AddRestoredTab(tab.navigations, browser->tab_count(),
                                   tab.current_navigation_index,
                                   (static_cast<int>(tab_i) ==
                                    window->selected_tab_index),
-                                  tab.pinned);
+                                  tab.pinned, tab.from_last_session);
       if (restored_tab)
         restored_tab->controller().LoadIfNecessary();
     }
     // All the window's tabs had the same former browser_id.
     if (window->tabs[0].has_browser()) {
       UpdateTabBrowserIDs(window->tabs[0].browser_id,
                           browser->session_id().id());
     }
     browser->window()->Show();
   } else {
@@ skipping 563 matching lines @@
     DCHECK(entries_.size() < kMaxEntries);
     STLDeleteContainerPointers(
         staging_entries_.begin() + (kMaxEntries - entries_.size()),
         staging_entries_.end());
     staging_entries_.erase(
         staging_entries_.begin() + (kMaxEntries - entries_.size()),
         staging_entries_.end());
   }
 
   // And add them.
-  for (size_t i = 0; i < staging_entries_.size(); ++i)
+  for (size_t i = 0; i < staging_entries_.size(); ++i) {
+    staging_entries_[i]->from_last_session = true;
     AddEntry(staging_entries_[i], false, false);
+  }
 
   // AddEntry takes ownership of the entry, need to clear out entries so that
   // it doesn't delete them.
   staging_entries_.clear();
 
   // Make it so we rewrite all the tabs. We need to do this otherwise we won't
   // correctly write out the entries when Save is invoked (Save starts from
   // the front, not the end and we just added the entries to the end).
   entries_to_write_ = staging_entries_.size();
 
   PruneAndNotify();
 }
 
 Time TabRestoreService::TimeNow() const {
   return time_factory_ ? time_factory_->TimeNow() : Time::Now();
 }