Add Finch experiment to cookie monster.

content/browser/net/sqlite_persistent_cookie_store.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.
 
 #include "content/browser/net/sqlite_persistent_cookie_store.h"
 
 #include <list>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 413 matching lines @@
   if (!db->Execute("CREATE INDEX IF NOT EXISTS domain ON cookies(host_key)"))
     return false;
 
   return true;
 }
 
 }  // namespace
 
 void SQLitePersistentCookieStore::Backend::Load(
     const LoadedCallback& loaded_callback) {
-  // This function should be called only once per instance.
-  DCHECK(!db_.get());
   PostBackgroundTask(FROM_HERE, base::Bind(
       &Backend::LoadAndNotifyInBackground, this,
       loaded_callback, base::Time::Now()));
 }
 
 void SQLitePersistentCookieStore::Backend::LoadCookiesForKey(
     const std::string& key,
     const LoadedCallback& loaded_callback) {
   {
     base::AutoLock locked(metrics_lock_);
@@ skipping 16 matching lines @@
   UMA_HISTOGRAM_CUSTOM_TIMES(
       "Cookie.TimeLoadDBQueueWait",
       base::Time::Now() - posted_at,
       base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(1),
       50);
 
   if (!InitializeDatabase()) {
     PostClientTask(FROM_HERE, base::Bind(
         &Backend::CompleteLoadInForeground, this, loaded_callback, false));
   } else {
+    if (!restore_old_session_cookies_)
+      DeleteSessionCookiesOnStartup();

[erikwright (departed), 2015/04/07 22:37:09]

Isn't this ineffective here? I would think it should be called from
FinishedLoadingCookies, or (if you follow my next suggestion to make it take a
key) at the end of ChainLoadCookies?

     ChainLoadCookies(loaded_callback);
   }
 }
 
 void SQLitePersistentCookieStore::Backend::LoadKeyAndNotifyInBackground(
     const std::string& key,
     const LoadedCallback& loaded_callback,
     const base::Time& posted_at) {
   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
   IncrementTimeDelta increment(&cookie_load_duration_);
 
   UMA_HISTOGRAM_CUSTOM_TIMES(
       "Cookie.TimeKeyLoadDBQueueWait",
       base::Time::Now() - posted_at,
       base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(1),
       50);
 
   bool success = false;
   if (InitializeDatabase()) {
+    if (!restore_old_session_cookies_)
+      DeleteSessionCookiesOnStartup();

[erikwright (departed), 2015/04/07 22:37:09]

This makes me think that, in fact, we have a bug as follows:

* Domain X is loaded.
* A session cookie for domain X is received and stored.
* Some other domains are loaded, completing the load.
* All session cookies are deleted.

This would only delete them from disk (not memory) so the only user-visible
problem is after a session restore.

Your change doesn't cause the bug, just changes the mechanism somewhat.

ideally, DeleteSessionClookiesOnStartup should take a domain key and restrict
its operation to that key.

[erikchen, 2015/04/08 17:44:26]

I agree that the previous behavior was incorrect. 

I don't understand why you want to DeleteSessionClookiesOnStartup() by
individual keys. I moved the call into InitializeDatabase(), so it happens
exactly once, immediately after startup, before any cookies are loaded into
memory. That prevents it from deleting session cookies from the current session,
and also ensures that memory/database are in sync.

     std::map<std::string, std::set<std::string> >::iterator
       it = keys_to_load_.find(key);
     if (it != keys_to_load_.end()) {
       success = LoadCookiesForDomains(it->second);
       keys_to_load_.erase(it);
     } else {
       success = true;
     }
   }
 
@@ skipping 760 matching lines @@
     LOG(WARNING) << "Failed to post task from " << origin.ToString()
                  << " to client_task_runner_.";
   }
 }
 
 void SQLitePersistentCookieStore::Backend::FinishedLoadingCookies(
     const LoadedCallback& loaded_callback,
     bool success) {
   PostClientTask(FROM_HERE, base::Bind(&Backend::CompleteLoadInForeground, this,
                                        loaded_callback, success));
-  if (success && !restore_old_session_cookies_)
-    DeleteSessionCookiesOnStartup();
 }
 
 SQLitePersistentCookieStore::SQLitePersistentCookieStore(
     const base::FilePath& path,
     const scoped_refptr<base::SequencedTaskRunner>& client_task_runner,
     const scoped_refptr<base::SequencedTaskRunner>& background_task_runner,
     bool restore_old_session_cookies,
     storage::SpecialStoragePolicy* special_storage_policy,
     net::CookieCryptoDelegate* crypto_delegate)
     : backend_(new Backend(path,
@@ skipping 103 matching lines @@
         (config.session_cookie_mode ==
          CookieStoreConfig::RESTORED_SESSION_COOKIES)) {
       cookie_monster->SetPersistSessionCookies(true);
     }
   }
 
   return cookie_monster;
 }
 
 }  // namespace content