Add Finch experiment to cookie monster.

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 398 matching lines @@
   // of stored cookies. Please do not reorder the list when adding new entries.
   // New items MUST be added at the end of the list, just before
   // COOKIE_TYPE_LAST_ENTRY;
   enum CookieType {
     COOKIE_TYPE_FIRSTPARTYONLY = 0,
     COOKIE_TYPE_HTTPONLY,
     COOKIE_TYPE_SECURE,
     COOKIE_TYPE_LAST_ENTRY
   };
 
+  // The strategy for fetching cookies. Controlled by Finch experiment.
+  enum FetchStrategy {
+    // Fetches all cookies only when they're needed.
+    kFetchWhenNecessary = 0,
+    // Fetches all cookies as soon as any cookie is needed.
+    // This is the default behavior.
+    kAlwaysFetch,
+    // The fetch strategy is not yet determined.
+    kUnknownFetch,
+  };
+
   // The number of days since last access that cookies will not be subject
   // to global garbage collection.
   static const int kSafeFromGlobalPurgeDays;
 
   // Record statistics every kRecordStatisticsIntervalSeconds of uptime.
   static const int kRecordStatisticsIntervalSeconds = 10 * 60;
 
   ~CookieMonster() override;
 
   // The following are synchronous calls to which the asynchronous methods
@@ skipping 39 matching lines @@
   void DeleteCookie(const GURL& url, const std::string& cookie_name);
 
   bool SetCookieWithCreationTime(const GURL& url,
                                  const std::string& cookie_line,
                                  const base::Time& creation_time);
 
   int DeleteSessionCookies();
 
   bool HasCookiesForETLDP1(const std::string& etldp1);
 
-  // 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.
+  // The first access to the cookie store initializes it. This method should be
+  // called before any access to the cookie store.
+  void MarkCookieStoreAsInitialized();
+
+  // Fetches all cookies if the backing store exists and they're not already
+  // being fetched.
   // Note: this method should always be called with lock_ held.
-  void InitIfNecessary() {
-    if (!initialized_) {
-      if (store_.get()) {
-        InitStore();
-      } else {
-        loaded_ = true;
-      }
-      initialized_ = true;
-    }
-  }
+  void FetchAllCookiesIfNecessary();
 
-  // Initializes the backing store and reads existing cookies from it.
-  // Should only be called by InitIfNecessary().
-  void InitStore();
+  // Fetches all cookies from the backing store.
+  // Note: this method should always be called with lock_ held.
+  void FetchAllCookies();
+
+  // Whether all cookies should be fetched as soon as any is requested.
+  bool ShouldFetchAllCookiesWhenFetchingAnyCookie();
 
   // 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
@@ skipping 156 matching lines @@
   base::HistogramBase* histogram_etldp1_count_;
   base::HistogramBase* histogram_domain_per_etldp1_count_;
   base::HistogramBase* histogram_number_duplicate_db_cookies_;
   base::HistogramBase* histogram_cookie_deletion_cause_;
   base::HistogramBase* histogram_cookie_type_;
   base::HistogramBase* histogram_time_mac_;
   base::HistogramBase* histogram_time_blocked_on_load_;
 
   CookieMap cookies_;
 
-  // Indicates whether the cookie store has been initialized. This happens
-  // lazily in InitStoreIfNecessary().
+  // Indicates whether the cookie store has been initialized.
   bool initialized_;
 
-  // Indicates whether loading from the backend store is completed and
-  // calls may be immediately processed.
-  bool loaded_;
+  // Indicates whether the cookie store has started fetching all cookies.
+  bool started_fetching_all_cookies_;
+  // Indicates whether the cookie store has finished fetching all cookies.
+  bool finished_fetching_all_cookies_;
+  // The strategy to use for fetching cookies.
+  FetchStrategy fetch_strategy_;
 
   // List of domain keys that have been loaded from the DB.
   std::set<std::string> keys_loaded_;
 
   // Map of domain keys to their associated task queues. These tasks are blocked
   // until all cookies for the associated domain key eTLD+1 are loaded from the
   // backend store.
   std::map<std::string, std::deque<scoped_refptr<CookieMonsterTask>>>
       tasks_pending_for_key_;
 
@@ skipping 89 matching lines @@
 
 typedef base::RefCountedThreadSafe<CookieMonster::PersistentCookieStore>
     RefcountedPersistentCookieStore;
 
 class NET_EXPORT CookieMonster::PersistentCookieStore
     : public RefcountedPersistentCookieStore {
  public:
   typedef base::Callback<void(const std::vector<CanonicalCookie*>&)>
       LoadedCallback;
 
+  // TODO(erikchen): Depending on the results of the cookie monster Finch
+  // experiment, update the name and description of this method. The behavior
+  // of this method doesn't change, but it has different semantics for the two
+  // different logic paths. See http://crbug.com/473483.
   // Initializes the store and retrieves the existing cookies. This will be
   // called only once at startup. The callback will return all the cookies
   // that are not yet returned to CookieMonster by previous priority loads.
   virtual void Load(const LoadedCallback& loaded_callback) = 0;
 
   // Does a priority load of all cookies for the domain key (eTLD+1). The
   // callback will return all the cookies that are not yet returned by previous
   // loads, which includes cookies for the requested domain key if they are not
   // already returned, plus all cookies that are chain-loaded and not yet
   // returned to CookieMonster.
@@ skipping 15 matching lines @@
   virtual ~PersistentCookieStore() {}
 
  private:
   friend class base::RefCountedThreadSafe<PersistentCookieStore>;
   DISALLOW_COPY_AND_ASSIGN(PersistentCookieStore);
 };
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_MONSTER_H_