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

chrome/browser/sessions/session_service.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_service.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <vector>
 
+#include "base/command_line.h"
 #include "base/file_util.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/extensions/extension_tab_helper.h"
+#include "chrome/browser/net/chrome_cookie_notification_details.h"
+#include "chrome/browser/net/sqlite_persistent_cookie_store.h"
+#include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/sessions/session_backend.h"
 #include "chrome/browser/sessions/session_command.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser_init.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/browser/tab_contents/navigation_details.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/tab_contents.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
-#include "content/public/browser/notification_details.h"
+#include "net/base/cookie_monster.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/app_controller_cppsafe_mac.h"
 #endif
 
 using base::Time;
 
 // Identifier for commands written to file.
 static const SessionCommand::id_type kCommandSetTabWindow = 0;
 // OBSOLETE Superseded by kCommandSetWindowBounds3.
@@ skipping 13 matching lines @@
     kCommandTabNavigationPathPrunedFromFront = 11;
 static const SessionCommand::id_type kCommandSetPinnedState = 12;
 static const SessionCommand::id_type kCommandSetExtensionAppID = 13;
 static const SessionCommand::id_type kCommandSetWindowBounds3 = 14;
 
 // Every kWritesPerReset commands triggers recreating the file.
 static const int kWritesPerReset = 250;
 
 namespace {
 
+const FilePath::CharType kSessionCookiesDatabaseName[] =
+    FILE_PATH_LITERAL("SessionCookies");
+
 // The callback from GetLastSession is internally routed to SessionService
 // first and then the caller. This is done so that the SessionWindows can be
 // recreated from the SessionCommands and the SessionWindows passed to the
 // caller. The following class is used for this.
 class InternalSessionRequest
     : public BaseSessionService::InternalGetCommandsRequest {
  public:
   InternalSessionRequest(
       CallbackType* callback,
       SessionService::SessionCallback* real_callback)
@@ skipping 51 matching lines @@
 
 typedef IDAndIndexPayload TabNavigationPathPrunedFromFrontPayload;
 
 struct PinnedStatePayload {
   SessionID::id_type tab_id;
   bool pinned_state;
 };
 
 }  // namespace
 
+// |SessionService::SessionCookieStore| stores session cookies in a
+// |CookieMonster| and restores them. The constructor should be called in the
+// UI thread, and all other functions should be called in the IO thread.
+class SessionService::SessionCookieStore
+    : public base::RefCountedThreadSafe<
+          SessionCookieStore,
+          content::BrowserThread::DeleteOnIOThread> {
+ public:
+  typedef base::Callback<void()> CookieOperationCallback;
+
+  explicit SessionCookieStore(const FilePath& path)
+      : path_(path) {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&SessionCookieStore::InitializeOnIOThread, this));
+  }
+
+  ~SessionCookieStore() {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  }
+
+  void RestoreSessionCookies(
+      net::URLRequestContextGetter* url_request_context_getter) {
+    net::CookieMonster* real_cookie_monster =
+        url_request_context_getter->GetURLRequestContext()->cookie_store()->
+        GetCookieMonster();
+    real_cookie_monster->MergeSessionCookies(session_cookie_monster_);
+  }
+
+  void ForgetSessionCookies() {
+    session_cookie_monster_->DeleteAllAsync(
+        net::CookieMonster::DeleteCallback());
+  }
+
+  class CanonicalCookieWrapper :
+      public base::RefCountedThreadSafe<CanonicalCookieWrapper> {
+   public:
+    explicit CanonicalCookieWrapper(
+        const net::CookieMonster::CanonicalCookie* cookie)
+        : cookie_(new net::CookieMonster::CanonicalCookie(*cookie)) {}
+    ~CanonicalCookieWrapper() {}
+
+    scoped_ptr<net::CookieMonster::CanonicalCookie> cookie_;
+  };
+
+  void AddSessionCookie(CanonicalCookieWrapper* wrapper) {
+    // Set the cookie as permanent so that |session_cookie_monster_| syncs it
+    // to its backend store.
+    wrapper->cookie_->SetPersistent(true);
+    net::CookieList cookie_list;
+    cookie_list.push_back(*(wrapper->cookie_));
+    session_cookie_monster_->InitializeFrom(cookie_list);
+  }
+
+  void RemoveSessionCookie(CanonicalCookieWrapper* wrapper,
+                           const CookieOperationCallback& callback) {
+    session_cookie_monster_->DeleteCanonicalCookieAsync(
+        *(wrapper->cookie_),
+        base::Bind(&SessionCookieStore::OnCookieDeleted,
+                   this,
+                   callback));
+  }
+
+ private:
+  void InitializeOnIOThread() {
+    session_cookie_store_ = new SQLitePersistentCookieStore(path_);
+    session_cookie_monster_ =
+        new net::CookieMonster(session_cookie_store_.get(), NULL);
+  }
+
+  void OnCookieDeleted(const CookieOperationCallback& callback,
+                       bool success) {
+    if (!callback.is_null()) {
+      content::BrowserThread::PostTask(
+          content::BrowserThread::UI, FROM_HERE,
+          base::Bind(&SessionCookieStore::InvokeCallback, this, callback));
+    }
+  }
+
+  void InvokeCallback(const CookieOperationCallback& callback) {
+    callback.Run();
+  }
+
+  FilePath path_;
+  scoped_refptr<SQLitePersistentCookieStore> session_cookie_store_;
+  scoped_refptr<net::CookieMonster> session_cookie_monster_;
+};
+
 // SessionService -------------------------------------------------------------
 
 SessionService::SessionService(Profile* profile)
     : BaseSessionService(SESSION_RESTORE, profile, FilePath()),
       has_open_trackable_browsers_(false),
       move_on_new_browser_(false),
       save_delay_in_millis_(base::TimeDelta::FromMilliseconds(2500)),
       save_delay_in_mins_(base::TimeDelta::FromMinutes(10)),
-      save_delay_in_hrs_(base::TimeDelta::FromHours(8)) {
+      save_delay_in_hrs_(base::TimeDelta::FromHours(8)),
+      enable_restore_session_data_(
+          CommandLine::ForCurrentProcess()->HasSwitch(
+              switches::kEnableRestoreSessionState)) {
   Init();
 }
 
 SessionService::SessionService(const FilePath& save_path)
     : BaseSessionService(SESSION_RESTORE, NULL, save_path),
       has_open_trackable_browsers_(false),
       move_on_new_browser_(false),
       save_delay_in_millis_(base::TimeDelta::FromMilliseconds(2500)),
       save_delay_in_mins_(base::TimeDelta::FromMinutes(10)),
-      save_delay_in_hrs_(base::TimeDelta::FromHours(8)) {
+      save_delay_in_hrs_(base::TimeDelta::FromHours(8)),
+      enable_restore_session_data_(
+          CommandLine::ForCurrentProcess()->HasSwitch(
+              switches::kEnableRestoreSessionState)) {
   Init();
 }
 
 SessionService::~SessionService() {
   Save();
 }
 
 bool SessionService::RestoreIfNecessary(const std::vector<GURL>& urls_to_open) {
   return RestoreIfNecessary(urls_to_open, NULL);
 }
 
 void SessionService::ResetFromCurrentBrowsers() {
   ScheduleReset();
 }
 
 void SessionService::MoveCurrentSessionToLastSession() {
   pending_tab_close_ids_.clear();
   window_closing_ids_.clear();
   pending_window_close_ids_.clear();
 
   Save();
 
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(
+          &SessionCookieStore::ForgetSessionCookies,
+          session_cookie_store_));
+
   if (!backend_thread()) {
     backend()->MoveCurrentSessionToLastSession();
   } else {
     backend_thread()->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
         backend(), &SessionBackend::MoveCurrentSessionToLastSession));
   }
 }
 
 void SessionService::SetTabWindow(const SessionID& window_id,
                                   const SessionID& tab_id) {
@@ skipping 265 matching lines @@
     RecordSessionUpdateHistogramData(
         chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
         &last_updated_save_time_);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
         content::Source<Profile>(profile()),
         content::NotificationService::NoDetails());
   }
 }
 
+void SessionService::RestoreOrResetSessionState(bool restore) {
+  // Schedule the restoring or deletion of the session cookies in the IO
+  // thread. |RestoreSessionCookies| (or |ForgetSessionCookies|) will be
+  // executed be done before any cookies are served, since the cookies will be
+  // served on the IO thread.
+  if (!session_cookie_store_.get())
+    return;
+
+  bool restore_session_cookies = enable_restore_session_data_ &&
+                                 restore &&
+                                 profile();
+  if (restore_session_cookies) {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(
+            &SessionCookieStore::RestoreSessionCookies,
+            session_cookie_store_,
+            make_scoped_refptr(profile()->GetRequestContext())));
+  } else {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(
+            &SessionCookieStore::ForgetSessionCookies,
+            session_cookie_store_));
+  }
+}
+
 void SessionService::Init() {
   // Register for the notifications we're interested in.
   registrar_.Add(this, content::NOTIFICATION_TAB_PARENTED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_TAB_CLOSED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_NAV_LIST_PRUNED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_CHANGED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_OPENED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(
       this, chrome::NOTIFICATION_TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED,
       content::NotificationService::AllSources());
+  if (enable_restore_session_data_ && profile()) {
+    registrar_.Add(
+        this, chrome::NOTIFICATION_COOKIE_CHANGED,
+        content::Source<Profile>(profile()));
+    session_cookie_store_ = new SessionCookieStore(
+        profile()->GetPath().Append(kSessionCookiesDatabaseName));
+  }
 }
 
 bool SessionService::ShouldNewWindowStartSession() {
   if (!has_open_trackable_browsers_ && !BrowserInit::InProcessStartup() &&
       !SessionRestore::IsRestoring()
 #if defined(OS_MACOSX)
       // OSX has a fairly different idea of application lifetime than the
       // other platforms. We need to check that we aren't opening a window
       // from the dock or the menubar.
       && !app_controller_mac::IsOpeningNewWindow()
@@ skipping 148 matching lines @@
       if (extension_tab_helper->extension_app()) {
         RestoreTabHelper* helper =
             extension_tab_helper->tab_contents_wrapper()->restore_tab_helper();
         SetTabExtensionAppID(helper->window_id(),
                              helper->session_id(),
                              extension_tab_helper->extension_app()->id());
       }
       break;
     }
 
+    case chrome::NOTIFICATION_COOKIE_CHANGED: {
+      if (enable_restore_session_data_ && session_cookie_store_.get()) {
+        ChromeCookieDetails* cookie_details =
+            content::Details<ChromeCookieDetails>(details).ptr();
+        if (!cookie_details->cookie->IsPersistent()) {
+          scoped_refptr<SessionCookieStore::CanonicalCookieWrapper> cookie =
+              new SessionCookieStore::CanonicalCookieWrapper(
+                  cookie_details->cookie);
+          if (cookie_details->removed) {
+            content::BrowserThread::PostTask(
+                content::BrowserThread::IO, FROM_HERE,
+                base::Bind(
+                    &SessionCookieStore::RemoveSessionCookie,
+                    session_cookie_store_,
+                    cookie,
+                    SessionCookieStore::CookieOperationCallback()));
+          } else {
+            content::BrowserThread::PostTask(
+                content::BrowserThread::IO, FROM_HERE,
+                base::Bind(
+                    &SessionCookieStore::AddSessionCookie,
+                    session_cookie_store_,
+                    cookie));
+          }
+        }
+      }
+      break;
+    }
+
     default:
       NOTREACHED();
   }
 }
 
 void SessionService::SetTabExtensionAppID(
     const SessionID& window_id,
     const SessionID& tab_id,
     const std::string& extension_app_id) {
   if (!ShouldTrackChangesToWindow(window_id))
@@ skipping 870 matching lines @@
       50);
   if (use_long_period) {
     std::string long_name_("SessionRestore.SaveLongPeriod");
     UMA_HISTOGRAM_CUSTOM_TIMES(long_name_,
         delta,
         save_delay_in_mins_,
         save_delay_in_hrs_,
         50);
   }
 }