Only commit cookie changes in prerenders after a prerender is shown

net/cookies/cookie_monster.h

 // Copyright (c) 2012 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_COOKIES_COOKIE_MONSTER_H_
 #define NET_COOKIES_COOKIE_MONSTER_H_
 
 #include <deque>
@@ skipping 289 matching lines @@
   void ValidateMap(int arg);
 
   // Determines if the scheme of the URL is a scheme that cookies will be
   // stored for.
   bool IsCookieableScheme(const std::string& scheme);
 
   // The default list of schemes the cookie monster can handle.
   static const char* kDefaultCookieableSchemes[];
   static const int kDefaultCookieableSchemesCount;
 
+  // Copies all keys for the given |key| to another cookie monster |other|.
+  // Both |other| and |this| must be loaded for this operation to succeed.
+  // Furthermore, there may not be any cookies stored in |other| for |key|.
+  // Returns false if any of these conditions is not met.
+  bool CopyCookiesForKeyToOtherCookieMonster(std::string key,
+                                             CookieMonster* other);
+
+  // Find the key (for lookup in cookies_) based on the given domain.
+  // See comment on keys before the CookieMap typedef.
+  std::string GetKey(const std::string& domain) const;
+
+  bool loaded();
+
  private:
   // For queueing the cookie monster calls.
   class CookieMonsterTask;
   template <typename Result> class DeleteTask;
   class DeleteAllCreatedBetweenTask;
   class DeleteAllCreatedBetweenForHostTask;
   class DeleteAllForHostTask;
   class DeleteAllTask;
   class DeleteCookieTask;
   class DeleteCanonicalCookieTask;
@@ skipping 128 matching lines @@
   // Called by all non-static functions to ensure that the cookies store has
   // been initialized. This is not done during creating so it doesn't block
   // the window showing.
   // Note: this method should always be called with lock_ held.
   void InitIfNecessary() {
     if (!initialized_) {
       if (store_.get()) {
         InitStore();
       } else {
         loaded_ = true;
+        ReportLoaded();
       }
       initialized_ = true;
     }
   }
 
   // Initializes the backing store and reads existing cookies from it.
   // Should only be called by InitIfNecessary().
   void InitStore();
 
+  // Reports to the delegate that the cookie monster was loaded.
+  void ReportLoaded();
+
   // Stores cookies loaded from the backing store and invokes any deferred
   // calls. |beginning_time| should be the moment PersistentCookieStore::Load
   // was invoked and is used for reporting histogram_time_blocked_on_load_.
   // See PersistentCookieStore::Load for details on the contents of cookies.
   void OnLoaded(base::TimeTicks beginning_time,
                 const std::vector<CanonicalCookie*>& cookies);
 
   // Stores cookies loaded from the backing store and invokes the deferred
   // task(s) pending loading of cookies associated with the domain key
   // (eTLD+1). Called when all cookies for the domain key(eTLD+1) have been
@@ skipping 92 matching lines @@
                             const CookieMapItPair& itpair,
                             std::vector<CookieMap::iterator>* cookie_its);
 
   // Helper for GarbageCollect(). Deletes all cookies in the range specified by
   // [|it_begin|, |it_end|). Returns the number of cookies deleted.
   int GarbageCollectDeleteRange(const base::Time& current,
                                 DeletionCause cause,
                                 CookieItVector::iterator cookie_its_begin,
                                 CookieItVector::iterator cookie_its_end);
 
-  // Find the key (for lookup in cookies_) based on the given domain.
-  // See comment on keys before the CookieMap typedef.
-  std::string GetKey(const std::string& domain) const;
-
   bool HasCookieableScheme(const GURL& url);
 
   // Statistics support
 
   // This function should be called repeatedly, and will record
   // statistics if a sufficient time period has passed.
   void RecordPeriodicStats(const base::Time& current_time);
 
   // Initialize the above variables; should only be called from
   // the constructor.
@@ skipping 120 matching lines @@
   // added, and |cause| will be set to CHANGE_COOKIE_EXPLICIT.
   //
   // As a special case, note that updating a cookie's properties is implemented
   // as a two step process: the cookie to be updated is first removed entirely,
   // generating a notification with cause CHANGE_COOKIE_OVERWRITE.  Afterwards,
   // a new cookie is written with the updated values, generating a notification
   // with cause CHANGE_COOKIE_EXPLICIT.
   virtual void OnCookieChanged(const CanonicalCookie& cookie,
                                bool removed,
                                ChangeCause cause) = 0;
+  // Indicates that the cookie store has fully loaded.
+  virtual void OnLoaded() = 0;
+
  protected:
   friend class base::RefCountedThreadSafe<CookieMonsterDelegate>;
   virtual ~CookieMonsterDelegate() {}
 };
 
 typedef base::RefCountedThreadSafe<CookieMonster::PersistentCookieStore>
     RefcountedPersistentCookieStore;
 
 class NET_EXPORT CookieMonster::PersistentCookieStore
     : public RefcountedPersistentCookieStore {
@@ skipping 29 matching lines @@
   virtual ~PersistentCookieStore() {}
 
  private:
   friend class base::RefCountedThreadSafe<PersistentCookieStore>;
   DISALLOW_COPY_AND_ASSIGN(PersistentCookieStore);
 };
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_MONSTER_H_