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/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_service.h"
 #include "content/public/browser/notification_details.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.
 // static const SessionCommand::id_type kCommandSetWindowBounds = 1;
 static const SessionCommand::id_type kCommandSetTabIndexInWindow = 2;
 static const SessionCommand::id_type kCommandTabClosed = 3;
 static const SessionCommand::id_type kCommandWindowClosed = 4;
 static const SessionCommand::id_type
     kCommandTabNavigationPathPrunedFromBack = 5;
 static const SessionCommand::id_type kCommandUpdateTabNavigation = 6;
 static const SessionCommand::id_type kCommandSetSelectedNavigationIndex = 7;
 static const SessionCommand::id_type kCommandSetSelectedTabInIndex = 8;
 static const SessionCommand::id_type kCommandSetWindowType = 9;
 // OBSOLETE Superseded by kCommandSetWindowBounds3. Except for data migration.
 // static const SessionCommand::id_type kCommandSetWindowBounds2 = 10;
 static const SessionCommand::id_type
     kCommandTabNavigationPathPrunedFromFront = 11;
 static const SessionCommand::id_type kCommandSetPinnedState = 12;
 static const SessionCommand::id_type kCommandSetExtensionAppID = 13;
 static const SessionCommand::id_type kCommandSetWindowBounds3 = 14;
+static const SessionCommand::id_type kCommandSessionCookieCreated = 15;
 
 // Every kWritesPerReset commands triggers recreating the file.
 static const int kWritesPerReset = 250;
 
 namespace {
 
 // 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.
@@ skipping 55 matching lines @@
 
 typedef IDAndIndexPayload WindowTypePayload;
 
 typedef IDAndIndexPayload TabNavigationPathPrunedFromFrontPayload;
 
 struct PinnedStatePayload {
   SessionID::id_type tab_id;
   bool pinned_state;
 };
 
+struct CookieListHolder : public base::RefCountedThreadSafe<CookieListHolder> {
+  net::CookieList cookie_list;
+};
+
+void RestoreCookies(
+    net::URLRequestContextGetter* url_request_context_getter,
+    CookieListHolder* cookie_list_holder) {
+  net::CookieMonster* cookie_monster =
+      url_request_context_getter->GetURLRequestContext()->cookie_store()->
+      GetCookieMonster();
+  cookie_monster->InitializeFrom(cookie_list_holder->cookie_list);
+}
+
 }  // namespace
 
 // 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)),
@@ skipping 308 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::StoreSessionCookie(
+    const net::CookieMonster::CanonicalCookie* cookie,
+    bool removed) {
+  if (!removed) {
+    Pickle saved_cookie;
+    saved_cookie.WriteString(cookie->Source());
+    saved_cookie.WriteString(cookie->Name());
+    saved_cookie.WriteString(cookie->Value());
+    saved_cookie.WriteString(cookie->Domain());
+    saved_cookie.WriteString(cookie->Path());
+    saved_cookie.WriteString(cookie->MACKey());
+    saved_cookie.WriteString(cookie->MACAlgorithm());
+    saved_cookie.WriteInt64(cookie->CreationDate().ToInternalValue());
+    saved_cookie.WriteInt64(cookie->ExpiryDate().ToInternalValue());
+    saved_cookie.WriteBool(cookie->IsSecure());
+    saved_cookie.WriteBool(cookie->IsHttpOnly());
+    saved_cookie.WriteBool(cookie->IsPersistent());
+    SessionCommand* command = new SessionCommand(kCommandSessionCookieCreated,
+                                                 saved_cookie);
+    ScheduleCommand(command);
+  }
+}
+
 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());
+  registrar_.Add(
+      this, chrome::NOTIFICATION_COOKIE_CHANGED,
+      content::Source<Profile>(profile()));
 }
 
 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 (CommandLine::ForCurrentProcess()->HasSwitch(
+              switches::kEnableRestoreSessionCookies)) {
+        ChromeCookieDetails* cookie_details =
+            content::Details<ChromeCookieDetails>(details).ptr();
+        if (!cookie_details->cookie->IsPersistent()) {
+          StoreSessionCookie(cookie_details->cookie, cookie_details->removed);
+        }
+      }
+      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 279 matching lines @@
   }
 }
 
 bool SessionService::CreateTabsAndWindows(
     const std::vector<SessionCommand*>& data,
     std::map<int, SessionTab*>* tabs,
     std::map<int, SessionWindow*>* windows) {
   // If the file is corrupt (command with wrong size, or unknown command), we
   // still return true and attempt to restore what we we can.
 
+  // Session cookies are collected here and restored all at once.
+  scoped_refptr<CookieListHolder> cookie_list_holder = new CookieListHolder;
+  bool restore_session_cookies = CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableRestoreSessionCookies);
+
   for (std::vector<SessionCommand*>::const_iterator i = data.begin();
        i != data.end(); ++i) {
     const SessionCommand::id_type kCommandSetWindowBounds2 = 10;
     const SessionCommand* command = *i;
 
     switch (command->id()) {
       case kCommandSetTabWindow: {
         SessionID::id_type payload[2];
         if (!command->GetPayload(payload, sizeof(payload)))
           return true;
@@ skipping 153 matching lines @@
         std::string extension_app_id;
         if (!RestoreSetTabExtensionAppIDCommand(
                 *command, &tab_id, &extension_app_id)) {
           return true;
         }
 
         GetTab(tab_id, tabs)->extension_app_id.swap(extension_app_id);
         break;
       }
 
+      case kCommandSessionCookieCreated: {

[jochen (gone - plz use gerrit), 2011/11/15 10:42:14]

does this restore the cookies even if you just re-open the last opened tabs?

I think for now we should only do this for restart for upgrade or on crash

[marja, 2011/11/17 12:54:46]

Done.

+        if (restore_session_cookies) {
+          scoped_ptr<Pickle> pickle(command->PayloadAsPickle());
+          std::string source, name, value, domain, path, mac_key, mac_algorithm;
+          int64 creation_date_internal, expiry_date_internal;
+          bool secure, http_only, persistent;
+          void* iter = NULL;
+          pickle->ReadString(&iter, &source);
+          pickle->ReadString(&iter, &name);
+          pickle->ReadString(&iter, &value);
+          pickle->ReadString(&iter, &domain);
+          pickle->ReadString(&iter, &path);
+          pickle->ReadString(&iter, &mac_key);
+          pickle->ReadString(&iter, &mac_algorithm);
+          pickle->ReadInt64(&iter, &creation_date_internal);
+          pickle->ReadInt64(&iter, &expiry_date_internal);
+          pickle->ReadBool(&iter, &secure);
+          pickle->ReadBool(&iter, &http_only);
+          pickle->ReadBool(&iter, &persistent);
+          scoped_ptr<net::CookieMonster::CanonicalCookie> cc(
+              net::CookieMonster::CanonicalCookie::Create(
+                  GURL(source), name, value, domain, path, mac_key,
+                  mac_algorithm,
+                  base::Time::FromInternalValue(creation_date_internal),
+                  base::Time::FromInternalValue(expiry_date_internal),
+                  secure, http_only, persistent));
+          cookie_list_holder->cookie_list.push_back(*cc);
+          break;
+        }
+      }
+
       default:
         return true;
     }
   }
+
+  if (cookie_list_holder->cookie_list.size() > 0) {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO, FROM_HERE,
+        NewRunnableFunction(&RestoreCookies,
+                            make_scoped_refptr(profile()->GetRequestContext()),
+                            cookie_list_holder));
+  }
+
   return true;
 }
 
 void SessionService::BuildCommandsForTab(
     const SessionID& window_id,
     TabContentsWrapper* tab,
     int index_in_window,
     bool is_pinned,
     std::vector<SessionCommand*>* commands,
     IdToRange* tab_to_available_range) {
@@ skipping 394 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);
   }
 }