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

net/base/cookie_monster.h

 // 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.
 
 // Brought to you by the letter D and the number 2.
 
 #ifndef NET_BASE_COOKIE_MONSTER_H_
 #define NET_BASE_COOKIE_MONSTER_H_
 #pragma once
 
@@ skipping 257 matching lines @@
       const CookieOptions& options,
       const GetCookieInfoCallback& callback) OVERRIDE;
 
   // Deletes all cookies with that might apply to |url| that has |cookie_name|.
   virtual void DeleteCookieAsync(
       const GURL& url, const std::string& cookie_name,
       const base::Closure& callback) OVERRIDE;
 
   virtual CookieMonster* GetCookieMonster() OVERRIDE;
 
+  // Enables writing session cookies into the cookie database.
+  void SetPersistSessionCookies(bool persist_session_cookies);
+
+  // Protects session cookies from deletion on shutdown.
+  void SaveSessionCookies();
+
+  // Merges restored session cookies with other cookies.
+  void RestoreOldSessionCookies();
+
+  // Discards restored session cookies.
+  void DiscardOldSessionCookies();
+
   // Debugging method to perform various validation checks on the map.
   // Currently just checking that there are no null CanonicalCookie pointers
   // in the map.
   // Argument |arg| is to allow retaining of arbitrary data if the CHECKs
   // in the function trip.  TODO(rdsmith):Remove hack.
   void ValidateMap(int arg);
 
   // The default list of schemes the cookie monster can handle.
   static const char* kDefaultCookieableSchemes[];
   static const int kDefaultCookieableSchemesCount;
@@ skipping 57 matching lines @@
 
     // Cookies evicted during domain level garbage collection that
     // were accessed more recently than kSafeFromGlobalPurgeDays
     // (and thus would have been preserved by global garbage collection).
     DELETE_COOKIE_EVICTED_DOMAIN_POST_SAFE,
 
     // A common idiom is to remove a cookie by overwriting it with an
     // already-expired expiration date. This captures that case.
     DELETE_COOKIE_EXPIRED_OVERWRITE,
 
+    // Old session cookies can be explicitly deleted, and they also get
+    // automatically deleted when trying to read / write them.
+    DELETE_COOKIE_OLD_SESSION_COOKIE,
+
     DELETE_COOKIE_LAST_ENTRY
   };
 
   // Cookie garbage collection thresholds.  Based off of the Mozilla defaults.
   // When the number of cookies gets to k{Domain,}MaxCookies
   // purge down to k{Domain,}MaxCookies - k{Domain,}PurgeCookies.
   // It might seem scary to have a high purge value, but really it's not.
   // You just make sure that you increase the max to cover the increase
   // in purge, and we would have been purging the same amount of cookies.
   // We're just going through the garbage collection process less often.
@@ skipping 145 matching lines @@
   // the CookieMap typedef for details.
   // NOTE: There should never be more than a single matching equivalent cookie.
   bool DeleteAnyEquivalentCookie(const std::string& key,
                                  const CanonicalCookie& ecc,
                                  bool skip_httponly,
                                  bool already_expired);
 
   // Takes ownership of *cc.
   void InternalInsertCookie(const std::string& key,
                             CanonicalCookie* cc,
-                            bool sync_to_store);
+                            bool sync_to_store,
+                            bool notify);
 
   // Helper function that sets cookies with more control.
   // Not exposed as we don't want callers to have the ability
   // to specify (potentially duplicate) creation times.
   bool SetCookieWithCreationTimeAndOptions(const GURL& url,
                                            const std::string& cookie_line,
                                            const base::Time& creation_time,
                                            const CookieOptions& options);
 
   // Helper function that sets a canonical cookie, deleting equivalents and
@@ skipping 135 matching lines @@
   std::vector<std::string> cookieable_schemes_;
 
   scoped_refptr<Delegate> delegate_;
 
   // Lock for thread-safety
   base::Lock lock_;
 
   base::Time last_statistic_record_time_;
 
   bool keep_expired_cookies_;
+  bool persist_session_cookies_;
+
+  // Describes what to do with old session cookies.
+  enum SessionCookieBehavior {
+    // Keep old session cookies separate, don't return them when cookies are
+    // read.
+    SESSION_COOKIES_UNDECIDED,
+    // Merge old session cookies in and treat them as normal cookies.
+    SESSION_COOKIES_MERGE,
+    // Discard old session cookies.
+    SESSION_COOKIES_DELETE
+  };
+  SessionCookieBehavior old_session_cookie_behavior_;
 
   static bool enable_file_scheme_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieMonster);
 };
 
 class NET_EXPORT CookieMonster::CanonicalCookie {
  public:
 
   // These constructors do no validation or canonicalization of their inputs;
@@ skipping 62 matching lines @@
   bool IsSecure() const { return secure_; }
   bool IsHttpOnly() const { return httponly_; }
   bool IsDomainCookie() const {
     return !domain_.empty() && domain_[0] == '.'; }
   bool IsHostCookie() const { return !IsDomainCookie(); }
 
   bool IsExpired(const base::Time& current) {
     return has_expires_ && current >= expiry_date_;
   }
 
+  bool IsOldSessionCookie() const {
+    return is_old_session_cookie_;
+  }
+
+  void SetIsOldSessionCookie(bool is_old_session_cookie) {
+    is_old_session_cookie_ = is_old_session_cookie;
+  }
+
   // Are the cookies considered equivalent in the eyes of RFC 2965.
   // The RFC says that name must match (case-sensitive), domain must
   // match (case insensitive), and path must match (case sensitive).
   // For the case insensitive domain compare, we rely on the domain
   // having been canonicalized (in
   // GetCookieDomainWithString->CanonicalizeHost).
   bool IsEquivalent(const CanonicalCookie& ecc) const {
     // It seems like it would make sense to take secure and httponly into
     // account, but the RFC doesn't specify this.
     // NOTE: Keep this logic in-sync with TrimDuplicateCookiesForHost().
@@ skipping 34 matching lines @@
   std::string path_;
   std::string mac_key_;  // TODO(abarth): Persist to disk.
   std::string mac_algorithm_;  // TODO(abarth): Persist to disk.
   base::Time creation_date_;
   base::Time expiry_date_;
   base::Time last_access_date_;
   bool secure_;
   bool httponly_;
   bool has_expires_;
   bool is_persistent_;
+  bool is_old_session_cookie_;
 };
 
 class CookieMonster::Delegate
     : public base::RefCountedThreadSafe<CookieMonster::Delegate> {
  public:
   // The publicly relevant reasons a cookie might be changed.
   enum ChangeCause {
     // The cookie was changed directly by a consumer's action.
     CHANGE_COOKIE_EXPLICIT,
     // The cookie was automatically removed due to an insert operation that
@@ skipping 155 matching lines @@
   virtual void UpdateCookieAccessTime(const CanonicalCookie& cc) = 0;
   virtual void DeleteCookie(const CanonicalCookie& cc) = 0;
 
   // Sets the value of the user preference whether the persistent storage
   // must be deleted upon destruction.
   virtual void SetClearLocalStateOnExit(bool clear_local_state) = 0;
 
   // Flush the store and post the given Task when complete.
   virtual void Flush(Task* completion_task) = 0;
 
+  virtual void DeleteSessionCookies() = 0;
+
  protected:
   PersistentCookieStore() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PersistentCookieStore);
 };
 
 class CookieList : public std::vector<CookieMonster::CanonicalCookie> {
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_COOKIE_MONSTER_H_