Make CookieStore no longer threadsafe.

net/extras/sqlite/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 "net/extras/sqlite/sqlite_persistent_cookie_store.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 163 matching lines @@
   // Loads cookies for the domain key (eTLD+1) on background runner.
   void LoadKeyAndNotifyInBackground(const std::string& domains,
                                     const LoadedCallback& loaded_callback,
                                     const base::Time& posted_at);
 
   // Notifies the CookieMonster when loading completes for a specific domain key
   // or for all domain keys. Triggers the callback and passes it all cookies
   // that have been loaded from DB since last IO notification.
   void Notify(const LoadedCallback& loaded_callback, bool load_success);
 
+  // Flushes (Commits) pending operations on the background runner, and invokes
+  // |callback| on the client thread when done.
+  void FlushAndNotifyInBackground(const base::Closure& callback);
+
   // Sends notification when the entire store is loaded, and reports metrics
   // for the total time to load and aggregated results from any priority loads
   // that occurred.
   void CompleteLoadInForeground(const LoadedCallback& loaded_callback,
                                 bool load_success);
 
   // Sends notification when a single priority load completes. Updates priority
   // load metric data. The data is sent only after the final load completes.
   void CompleteLoadForKeyInForeground(const LoadedCallback& loaded_callback,
                                       bool load_success,
@@ skipping 307 matching lines @@
     }
   }
 
   PostClientTask(
       FROM_HERE,
       base::Bind(
           &SQLitePersistentCookieStore::Backend::CompleteLoadForKeyInForeground,
           this, loaded_callback, success, posted_at));
 }
 
+void SQLitePersistentCookieStore::Backend::FlushAndNotifyInBackground(
+    const base::Closure& callback) {

[Mike West, 2016/03/01 13:59:28]

Combining these makes good sense, thank you.

+  Commit();
+  if (!callback.is_null())
+    PostClientTask(FROM_HERE, callback);
+}
+
 void SQLitePersistentCookieStore::Backend::CompleteLoadForKeyInForeground(
     const LoadedCallback& loaded_callback,
     bool load_success,
     const ::Time& requested_at) {
   DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
 
   UMA_HISTOGRAM_CUSTOM_TIMES("Cookie.TimeKeyLoadTotalWait",
                              base::Time::Now() - requested_at,
                              base::TimeDelta::FromMilliseconds(1),
                              base::TimeDelta::FromMinutes(1), 50);
@@ skipping 631 matching lines @@
     }
   }
   bool succeeded = transaction.Commit();
   UMA_HISTOGRAM_ENUMERATION("Cookie.BackingStoreUpdateResults",
                             succeeded ? 0 : 1, 2);
 }
 
 void SQLitePersistentCookieStore::Backend::Flush(
     const base::Closure& callback) {
   DCHECK(!background_task_runner_->RunsTasksOnCurrentThread());
-  PostBackgroundTask(FROM_HERE, base::Bind(&Backend::Commit, this));
-
-  if (!callback.is_null()) {
-    // We want the completion task to run immediately after Commit() returns.
-    // Posting it from here means there is less chance of another task getting
-    // onto the message queue first, than if we posted it from Commit() itself.
-    PostBackgroundTask(FROM_HERE, callback);
-  }
+  PostBackgroundTask(FROM_HERE, base::Bind(&Backend::FlushAndNotifyInBackground,
+                                           this, callback));
 }
 
 // Fire off a close message to the background runner.  We could still have a
 // pending commit timer or Load operations holding references on us, but if/when
 // this fires we will already have been cleaned up and it will be ignored.
 void SQLitePersistentCookieStore::Backend::Close(
     const base::Closure& callback) {
   if (background_task_runner_->RunsTasksOnCurrentThread()) {
     InternalBackgroundClose(callback);
   } else {
@@ skipping 170 matching lines @@
     backend_->Close(callback);
 
     // We release our reference to the Backend, though it will probably still
     // have a reference if the background runner has not run
     // Backend::InternalBackgroundClose() yet.
     backend_ = nullptr;
   }
 }
 
 void SQLitePersistentCookieStore::Load(const LoadedCallback& loaded_callback) {
+  DCHECK(!loaded_callback.is_null());
   if (backend_)
     backend_->Load(loaded_callback);
   else
     loaded_callback.Run(std::vector<CanonicalCookie*>());
 }
 
 void SQLitePersistentCookieStore::LoadCookiesForKey(
     const std::string& key,
     const LoadedCallback& loaded_callback) {
+  DCHECK(!loaded_callback.is_null());
   if (backend_)
     backend_->LoadCookiesForKey(key, loaded_callback);
   else
     loaded_callback.Run(std::vector<CanonicalCookie*>());
 }
 
 void SQLitePersistentCookieStore::AddCookie(const CanonicalCookie& cc) {
   if (backend_)
     backend_->AddCookie(cc);
 }
@@ skipping 16 matching lines @@
 void SQLitePersistentCookieStore::Flush(const base::Closure& callback) {
   if (backend_)
     backend_->Flush(callback);
 }
 
 SQLitePersistentCookieStore::~SQLitePersistentCookieStore() {
   Close(base::Closure());
 }
 
 }  // namespace net