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

chrome/browser/ui/browser_init.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/ui/browser_init.h"
 
 #include <algorithm>   // For max().
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 289 matching lines @@
 
  private:
   virtual ~SessionCrashedInfoBarDelegate();
 
   // ConfirmInfoBarDelegate:
   virtual gfx::Image* GetIcon() const OVERRIDE;
   virtual string16 GetMessageText() const OVERRIDE;
   virtual int GetButtons() const OVERRIDE;
   virtual string16 GetButtonLabel(InfoBarButton button) const OVERRIDE;
   virtual bool Accept() OVERRIDE;
+  virtual void InfoBarDismissed() OVERRIDE;
+  virtual void InfoBarClosing() OVERRIDE;
 
   // The Profile that we restore sessions from.
   Profile* profile_;
+  bool action_taken_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionCrashedInfoBarDelegate);
 };
 
 SessionCrashedInfoBarDelegate::SessionCrashedInfoBarDelegate(
     Profile* profile,
     InfoBarTabHelper* infobar_helper)
     : ConfirmInfoBarDelegate(infobar_helper),
-      profile_(profile) {
+      profile_(profile),
+      action_taken_(false) {
 }
 
 SessionCrashedInfoBarDelegate::~SessionCrashedInfoBarDelegate() {
 }
 
 gfx::Image* SessionCrashedInfoBarDelegate::GetIcon() const {
   return &ResourceBundle::GetSharedInstance().GetNativeImageNamed(
       IDR_INFOBAR_RESTORE_SESSION);
 }
 
 string16 SessionCrashedInfoBarDelegate::GetMessageText() const {
   return l10n_util::GetStringUTF16(IDS_SESSION_CRASHED_VIEW_MESSAGE);
 }
 
 int SessionCrashedInfoBarDelegate::GetButtons() const {
   return BUTTON_OK;
 }
 
 string16 SessionCrashedInfoBarDelegate::GetButtonLabel(
     InfoBarButton button) const {
   DCHECK_EQ(BUTTON_OK, button);
   return l10n_util::GetStringUTF16(IDS_SESSION_CRASHED_VIEW_RESTORE_BUTTON);
 }
 
 bool SessionCrashedInfoBarDelegate::Accept() {
+  action_taken_ = true;
   uint32 behavior = 0;
   Browser* browser = BrowserList::GetLastActiveWithProfile(profile_);
   if (browser && browser->tab_count() == 1
       && browser->GetTabContentsAt(0)->GetURL() ==
       GURL(chrome::kChromeUINewTabURL)) {
     // There is only one tab and its the new tab page, make session restore
     // clobber it.
     behavior = SessionRestore::CLOBBER_CURRENT_TAB;
   }
+  profile_->RestoreSessionState();
   SessionRestore::RestoreSession(
       profile_, browser, behavior, std::vector<GURL>());
   return true;
 }
 
+void SessionCrashedInfoBarDelegate::InfoBarDismissed() {
+  action_taken_ = true;
+  profile_->DiscardSessionState();
+}
+
+void SessionCrashedInfoBarDelegate::InfoBarClosing() {
+  if (!action_taken_)
+    profile_->DiscardSessionState();
+}
 
 // Utility functions ----------------------------------------------------------
 
 bool IncognitoIsForced(const CommandLine& command_line,
                        const PrefService* prefs) {
   IncognitoModePrefs::Availability incognito_avail =
       IncognitoModePrefs::GetAvailability(prefs);
   return incognito_avail != IncognitoModePrefs::DISABLED &&
          (command_line.HasSwitch(switches::kIncognito) ||
           incognito_avail == IncognitoModePrefs::FORCED);
@@ skipping 538 matching lines @@
 
   if (pref.type == SessionStartupPref::LAST) {
     if (!profile_->DidLastSessionExitCleanly() &&
         !command_line_.HasSwitch(switches::kRestoreLastSession)) {
       // The last session crashed. It's possible automatically loading the
       // page will trigger another crash, locking the user out of chrome.
       // To avoid this, don't restore on startup but instead show the crashed
       // infobar.
       return false;
     }
+    if (command_line_.HasSwitch(switches::kEnableRestoreSessionState) &&
+        command_line_.HasSwitch(switches::kRestoreLastSession)) {
+      profile_->RestoreSessionState();
+    } else {
+      profile_->DiscardSessionState();
+    }
 
   uint32 restore_behavior = SessionRestore::SYNCHRONOUS |
                             SessionRestore::ALWAYS_CREATE_TABBED_BROWSER;
 #if defined(OS_MACOSX)
     // On Mac, when restoring a session with no windows, suppress the creation
     // of a new window in the case where the system is launching Chrome via a
     // login item or Lion's resume feature.
     if (base::mac::WasLaunchedAsLoginOrResumeItem()) {
       restore_behavior = restore_behavior &
                          ~SessionRestore::ALWAYS_CREATE_TABBED_BROWSER;
     }
 #endif
 
     Browser* browser = SessionRestore::RestoreSession(profile_,
                                                       NULL,
                                                       restore_behavior,
                                                       urls_to_open);
     AddInfoBarsIfNecessary(browser);
     return true;
+  } else if (profile_->DidLastSessionExitCleanly()) {
+    profile_->DiscardSessionState();
   }
 
   Browser* browser = ProcessSpecifiedURLs(urls_to_open);
   if (!browser)
     return false;
 
   AddInfoBarsIfNecessary(browser);
   return true;
 }
 
@@ skipping 573 matching lines @@
   if (!automation->InitializeChannel(channel_id))
     return false;
   automation->SetExpectedTabCount(expected_tabs);
 
   AutomationProviderList* list = g_browser_process->GetAutomationProviderList();
   DCHECK(list);
   list->AddProvider(automation);
 
   return true;
 }