Add Finch experiment to cookie monster.

net/cookies/cookie_monster.cc

 // 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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
@@ skipping 37 matching lines @@
 #include <functional>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_util.h"
 #include "net/cookies/parsed_cookie.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 // In steady state, most cookie requests can be satisfied by the in memory
-// cookie monster store.  However, if a request comes in during the initial
-// cookie load, it must be delayed until that load completes. That is done by
-// queueing it on CookieMonster::tasks_pending_ and running it when notification
-// of cookie load completion is received via CookieMonster::OnLoaded. This
-// callback is passed to the persistent store from CookieMonster::InitStore(),
-// which is called on the first operation invoked on the CookieMonster.
+// cookie monster store. If the cookie request cannot be satisfied by the in
+// memory store, the relevant cookies must be fetched from the persistent
+// store. The task is queued in CookieMonster::tasks_pending_ if it requires
+// all cookies to be loaded from the backend, or tasks_pending_for_key_ if it
+// only requires all cookies associated with an eTLD+1.
 //
 // On the browser critical paths (e.g. for loading initial web pages in a
 // session restore) it may take too long to wait for the full load. If a cookie
 // request is for a specific URL, DoCookieTaskForURL is called, which triggers a
 // priority load if the key is not loaded yet by calling PersistentCookieStore
 // :: LoadCookiesForKey. The request is queued in
 // CookieMonster::tasks_pending_for_key_ and executed upon receiving
 // notification of key load completion via CookieMonster::OnKeyLoaded(). If
 // multiple requests for the same eTLD+1 are received before key load
 // completion, only the first request calls
 // PersistentCookieStore::LoadCookiesForKey, all subsequent requests are queued
 // in CookieMonster::tasks_pending_for_key_ and executed upon receiving
 // notification of key load completion triggered by the first request for the
 // same eTLD+1.
 
 static const int kMinutesInTenYears = 10 * 365 * 24 * 60;
 
+namespace {
+
+const char kFetchWhenNecessaryName[] = "FetchWhenNecessary";
+const char kAlwaysFetchName[] = "AlwaysFetch";
+const char kCookieMonsterFetchStrategyName[] = "CookieMonsterFetchStrategy";
+
+}  // namespace
+
 namespace net {
 
 // See comments at declaration of these variables in cookie_monster.h
 // for details.
 const size_t CookieMonster::kDomainMaxCookies = 180;
 const size_t CookieMonster::kDomainPurgeCookies = 30;
 const size_t CookieMonster::kMaxCookies = 3300;
 const size_t CookieMonster::kPurgeCookies = 300;
 
 const size_t CookieMonster::kDomainCookiesQuotaLow = 30;
@@ skipping 217 matching lines @@
               const CanonicalCookie& cookie,
               bool removed) {
   proxy->PostTask(FROM_HERE, base::Bind(callback, cookie, removed));
 }
 
 }  // namespace
 
 CookieMonster::CookieMonster(PersistentCookieStore* store,
                              CookieMonsterDelegate* delegate)
     : initialized_(false),
-      loaded_(false),
+      started_fetching_all_cookies_(false),
+      finished_fetching_all_cookies_(false),
+      fetch_strategy_(kUnknownFetch),
       store_(store),
       last_access_threshold_(
           TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)),
       delegate_(delegate),
       last_statistic_record_time_(Time::Now()),
       keep_expired_cookies_(false),
       persist_session_cookies_(false) {
   InitializeHistograms();
   SetDefaultCookieableSchemes();
 }
 
 CookieMonster::CookieMonster(PersistentCookieStore* store,
                              CookieMonsterDelegate* delegate,
                              int last_access_threshold_milliseconds)
     : initialized_(false),
-      loaded_(false),
+      started_fetching_all_cookies_(false),
+      finished_fetching_all_cookies_(false),
+      fetch_strategy_(kUnknownFetch),
       store_(store),
       last_access_threshold_(base::TimeDelta::FromMilliseconds(
           last_access_threshold_milliseconds)),
       delegate_(delegate),
       last_statistic_record_time_(base::Time::Now()),
       keep_expired_cookies_(false),
       persist_session_cookies_(false) {
   InitializeHistograms();
   SetDefaultCookieableSchemes();
 }
@@ skipping 725 matching lines @@
   scoped_refptr<DeleteSessionCookiesTask> task =
       new DeleteSessionCookiesTask(this, callback);
 
   DoCookieTask(task);
 }
 
 void CookieMonster::DoCookieTask(
     const scoped_refptr<CookieMonsterTask>& task_item) {
   {
     base::AutoLock autolock(lock_);
-    InitIfNecessary();
-    if (!loaded_) {
+    MarkCookieStoreAsInitialized();
+    FetchAllCookiesIfNecessary();
+    if (!finished_fetching_all_cookies_ && store_.get()) {
       tasks_pending_.push(task_item);
       return;
     }
   }
 
   task_item->Run();
 }
 
 void CookieMonster::DoCookieTaskForURL(
     const scoped_refptr<CookieMonsterTask>& task_item,
     const GURL& url) {
   {
     base::AutoLock autolock(lock_);
-    InitIfNecessary();
+    MarkCookieStoreAsInitialized();
+    if (ShouldFetchAllCookiesWhenFetchingAnyCookie())
+      FetchAllCookiesIfNecessary();
     // If cookies for the requested domain key (eTLD+1) have been loaded from DB
     // then run the task, otherwise load from DB.
-    if (!loaded_) {
+    if (!finished_fetching_all_cookies_ && store_.get()) {
       // Checks if the domain key has been loaded.
       std::string key(
           cookie_util::GetEffectiveDomain(url.scheme(), url.host()));
       if (keys_loaded_.find(key) == keys_loaded_.end()) {
         std::map<std::string,
                  std::deque<scoped_refptr<CookieMonsterTask>>>::iterator it =
             tasks_pending_for_key_.find(key);
         if (it == tasks_pending_for_key_.end()) {
           store_->LoadCookiesForKey(
               key, base::Bind(&CookieMonster::OnKeyLoaded, this, key));
@@ skipping 37 matching lines @@
     return false;
 
   CookieOptions options;
   options.set_include_httponly();
   options.set_include_first_party_only();
   return SetCanonicalCookie(&cc, creation_time, options);
 }
 
 bool CookieMonster::ImportCookies(const CookieList& list) {
   base::AutoLock autolock(lock_);
-  InitIfNecessary();
+  MarkCookieStoreAsInitialized();
+  if (ShouldFetchAllCookiesWhenFetchingAnyCookie())
+    FetchAllCookiesIfNecessary();
   for (net::CookieList::const_iterator iter = list.begin(); iter != list.end();
        ++iter) {
     scoped_ptr<CanonicalCookie> cookie(new CanonicalCookie(*iter));
     net::CookieOptions options;
     options.set_include_httponly();
     options.set_include_first_party_only();
     if (!SetCanonicalCookie(&cookie, cookie->CreationDate(), options))
       return false;
   }
   return true;
@@ skipping 285 matching lines @@
 bool CookieMonster::SetCookieWithCreationTime(const GURL& url,
                                               const std::string& cookie_line,
                                               const base::Time& creation_time) {
   DCHECK(!store_.get()) << "This method is only to be used by unit-tests.";
   base::AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url)) {
     return false;
   }
 
-  InitIfNecessary();
+  MarkCookieStoreAsInitialized();
+  if (ShouldFetchAllCookiesWhenFetchingAnyCookie())
+    FetchAllCookiesIfNecessary();
+
   return SetCookieWithCreationTimeAndOptions(url, cookie_line, creation_time,
                                              CookieOptions());
 }
 
-void CookieMonster::InitStore() {
+void CookieMonster::MarkCookieStoreAsInitialized() {
+  initialized_ = true;
+}
+
+void CookieMonster::FetchAllCookiesIfNecessary() {
+  if (store_.get() && !started_fetching_all_cookies_) {
+    started_fetching_all_cookies_ = true;
+    FetchAllCookies();
+  }
+}
+
+bool CookieMonster::ShouldFetchAllCookiesWhenFetchingAnyCookie() {
+  if (fetch_strategy_ == kUnknownFetch) {
+    const std::string group_name =
+        base::FieldTrialList::FindFullName(kCookieMonsterFetchStrategyName);
+    if (group_name == kFetchWhenNecessaryName) {
+      fetch_strategy_ = kFetchWhenNecessary;
+    } else if (group_name == kAlwaysFetchName) {
+      fetch_strategy_ = kAlwaysFetch;
+    } else {
+      // The logic in the conditional is redundant, but it makes trials of
+      // the Finch experiment more explicit.
+      fetch_strategy_ = kAlwaysFetch;
+    }
+  }
+
+  return fetch_strategy_ == kAlwaysFetch;
+}
+
+void CookieMonster::FetchAllCookies() {
   DCHECK(store_.get()) << "Store must exist to initialize";
+  DCHECK(!finished_fetching_all_cookies_)
+      << "All cookies have already been fetched.";
 
   // We bind in the current time so that we can report the wall-clock time for
   // loading cookies.
   store_->Load(base::Bind(&CookieMonster::OnLoaded, this, TimeTicks::Now()));
 }
 
 void CookieMonster::OnLoaded(TimeTicks beginning_time,
                              const std::vector<CanonicalCookie*>& cookies) {
   StoreLoadedCookies(cookies);
   histogram_time_blocked_on_load_->AddTime(TimeTicks::Now() - beginning_time);
@@ skipping 94 matching lines @@
   // since they are expected to be much fewer than total DB.
   EnsureCookiesMapIsValid();
 }
 
 void CookieMonster::InvokeQueue() {
   while (true) {
     scoped_refptr<CookieMonsterTask> request_task;
     {
       base::AutoLock autolock(lock_);
       if (tasks_pending_.empty()) {
-        loaded_ = true;
+        finished_fetching_all_cookies_ = true;
         creation_times_.clear();
         keys_loaded_.clear();
         break;
       }
       request_task = tasks_pending_.front();
       tasks_pending_.pop();
     }
     request_task->Run();
   }
 }
@@ skipping 765 matching lines @@
        it != hook_map_.end(); ++it) {
     std::pair<GURL, std::string> key = it->first;
     if (cookie.IncludeForRequestURL(key.first, opts) &&
         cookie.Name() == key.second) {
       it->second->Notify(cookie, removed);
     }
   }
 }
 
 }  // namespace net