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 278 matching lines @@
                           new NotifyNotDefaultBrowserTask());
 }
 
 
 // SessionCrashedInfoBarDelegate ----------------------------------------------
 
 // A delegate for the InfoBar shown when the previous session has crashed.
 class SessionCrashedInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
   SessionCrashedInfoBarDelegate(Profile* profile,
-                                InfoBarTabHelper* infobar_helper);
+                                InfoBarTabHelper* infobar_helper,
+                                bool session_restore_enabled);
 
  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 session_restore_enabled_;
+  bool action_taken_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionCrashedInfoBarDelegate);
 };
 
 SessionCrashedInfoBarDelegate::SessionCrashedInfoBarDelegate(
     Profile* profile,
-    InfoBarTabHelper* infobar_helper)
+    InfoBarTabHelper* infobar_helper,
+    bool session_restore_enabled)
     : ConfirmInfoBarDelegate(infobar_helper),
-      profile_(profile) {
+      profile_(profile),
+      session_restore_enabled_(session_restore_enabled),
+      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;
   }
+  if (session_restore_enabled_)
+    profile_->RestoreSessionState();
   SessionRestore::RestoreSession(
       profile_, browser, behavior, std::vector<GURL>());
   return true;
 }
 
+void SessionCrashedInfoBarDelegate::InfoBarDismissed() {
+  action_taken_ = true;
+  if (session_restore_enabled_)
+    profile_->DiscardSessionState();
+}
+
+void SessionCrashedInfoBarDelegate::InfoBarClosing() {
+  if (!action_taken_ && session_restore_enabled_)
+    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();
+    }
 
   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;
@@ skipping 157 matching lines @@
 
 void BrowserInit::LaunchWithProfile::AddCrashedInfoBarIfNecessary(
     Browser* browser,
     TabContentsWrapper* tab) {
   // Assume that if the user is launching incognito they were previously
   // running incognito so that we have nothing to restore from.
   if (!profile_->DidLastSessionExitCleanly() && !profile_->IsOffTheRecord()) {
     // The last session didn't exit cleanly. Show an infobar to the user
     // so that they can restore if they want. The delegate deletes itself when
     // it is closed.
+    bool session_restore_enabled =
+        command_line_.HasSwitch(switches::kEnableRestoreSessionState);
     tab->infobar_tab_helper()->AddInfoBar(
-        new SessionCrashedInfoBarDelegate(profile_, tab->infobar_tab_helper()));
+        new SessionCrashedInfoBarDelegate(profile_, tab->infobar_tab_helper(),
+                                          session_restore_enabled));
   }
 }
 
 void BrowserInit::LaunchWithProfile::AddBadFlagsInfoBarIfNecessary(
     TabContentsWrapper* tab) {
   // Unsupported flags for which to display a warning that "stability and
   // security will suffer".
   static const char* kBadFlags[] = {
     // These imply disabling the sandbox.
     switches::kSingleProcess,
@@ skipping 413 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;
 }