SessionRestore: Store session cookies and restore them if chrome crashes or auto-restarts.

chrome/browser/sessions/session_restore.cc

 // Copyright (c) 2011 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/session_restore.h"
 
 #include <algorithm>
 #include <list>
 #include <set>
 #include <vector>
@@ skipping 388 matching lines @@
 // SessionRestoreImpl is responsible for fetching the set of tabs to create
 // from SessionService. SessionRestoreImpl deletes itself when done.
 
 class SessionRestoreImpl : public content::NotificationObserver {
  public:
   SessionRestoreImpl(Profile* profile,
                      Browser* browser,
                      bool synchronous,
                      bool clobber_existing_tab,
                      bool always_create_tabbed_browser,
+                     bool restore_session_state,
                      const std::vector<GURL>& urls_to_open)
       : profile_(profile),
         browser_(browser),
         synchronous_(synchronous),
         clobber_existing_tab_(clobber_existing_tab),
         always_create_tabbed_browser_(always_create_tabbed_browser),
+        restore_session_state_(restore_session_state),
         urls_to_open_(urls_to_open),
         restore_started_(base::TimeTicks::Now()) {
     // When asynchronous its possible for there to be no windows. To make sure
     // Chrome doesn't prematurely exit AddRef the process. We'll release in the
     // destructor when restore is done.
     g_browser_process->AddRefModule();
   }
 
   Browser* Restore() {
     SessionService* session_service =
         SessionServiceFactory::GetForProfile(profile_);
     DCHECK(session_service);
+
+    session_service->RestoreOrResetSessionState(restore_session_state_);
+
     SessionService::SessionCallback* callback =
         NewCallback(this, &SessionRestoreImpl::OnGotSession);
     session_service->GetLastSession(&request_consumer_, callback);
 
     if (synchronous_) {
       bool old_state = MessageLoop::current()->NestableTasksAllowed();
       MessageLoop::current()->SetNestableTasksAllowed(true);
       MessageLoop::current()->Run();
       MessageLoop::current()->SetNestableTasksAllowed(old_state);
       Browser* browser = ProcessSessionWindows(&windows_);
@@ skipping 344 matching lines @@
   const bool synchronous_;
 
   // See description of CLOBBER_CURRENT_TAB.
   const bool clobber_existing_tab_;
 
   // If true and there is an error or there are no windows to restore, we
   // create a tabbed browser anyway. This is used on startup to make sure at
   // at least one window is created.
   const bool always_create_tabbed_browser_;
 
+  // See description of RESTORE_SESSION_STATE.
+  const bool restore_session_state_;
+
   // Set of URLs to open in addition to those restored from the session.
   std::vector<GURL> urls_to_open_;
 
   // Used to get the session.
   CancelableRequestConsumer request_consumer_;
 
   // Responsible for loading the tabs.
   scoped_ptr<TabLoader> tab_loader_;
 
   // When synchronous we run a nested message loop. To avoid creating windows
@@ skipping 29 matching lines @@
     NOTREACHED();
     return NULL;
   }
   restoring = true;
   profile->set_restored_last_session(true);
   // SessionRestoreImpl takes care of deleting itself when done.
   SessionRestoreImpl* restorer = new SessionRestoreImpl(
       profile, browser, (behavior & SYNCHRONOUS) != 0,
       (behavior & CLOBBER_CURRENT_TAB) != 0,
       (behavior & ALWAYS_CREATE_TABBED_BROWSER) != 0,
+      (behavior & RESTORE_SESSION_STATE) != 0,
       urls_to_open);
   return restorer->Restore();
 }
 
 // static
 void SessionRestore::RestoreForeignSessionWindows(
     Profile* profile,
     std::vector<const SessionWindow*>::const_iterator begin,
     std::vector<const SessionWindow*>::const_iterator end) {
   // Create a SessionRestore object to eventually restore the tabs.
   std::vector<GURL> gurls;
   SessionRestoreImpl restorer(profile,
-      static_cast<Browser*>(NULL), true, false, true, gurls);
+      static_cast<Browser*>(NULL), true, false, true, false, gurls);
   restorer.RestoreForeignSession(begin, end);
 }
 
 // static
 void SessionRestore::RestoreForeignSessionTab(Profile* profile,
     const SessionTab& tab) {
   // Create a SessionRestore object to eventually restore the tabs.
   std::vector<GURL> gurls;
   SessionRestoreImpl restorer(profile,
-      static_cast<Browser*>(NULL), true, false, true, gurls);
+      static_cast<Browser*>(NULL), true, false, true, false, gurls);
   restorer.RestoreForeignTab(tab);
 }
 
 // static
 bool SessionRestore::IsRestoring() {
   return restoring;
 }