Finalize a CL originally by departed intern ycxiao@ that detaches the loading of cookies from the...

net/base/cookie_monster.cc

 // Copyright (c) 2011 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 30 matching lines @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "net/base/cookie_monster.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_canon.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domain.h"
 
 using base::Time;
@@ skipping 348 matching lines @@
   }
 }
 
 }  // namespace
 
 // static
 bool CookieMonster::enable_file_scheme_ = false;
 
 CookieMonster::CookieMonster(PersistentCookieStore* store, Delegate* delegate)
     : initialized_(false),
+      loaded_(false),
       expiry_and_key_scheme_(expiry_and_key_default_),
       store_(store),
       last_access_threshold_(
           TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)),
       delegate_(delegate),
       last_statistic_record_time_(Time::Now()),
       keep_expired_cookies_(false) {
   InitializeHistograms();
   SetDefaultCookieableSchemes();
 }
 
 CookieMonster::CookieMonster(PersistentCookieStore* store,
                              Delegate* delegate,
                              int last_access_threshold_milliseconds)
     : initialized_(false),
+      loaded_(false),
       expiry_and_key_scheme_(expiry_and_key_default_),
       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) {
   InitializeHistograms();
   SetDefaultCookieableSchemes();
 }
@@ skipping 113 matching lines @@
   // the following check would be reasonable:
   // NOTREACHED() << "Cookie exploded expiration failed: " << time_string;
 
   return Time();
 }
 
 bool CookieMonster::DomainIsHostOnly(const std::string& domain_string) {
   return (domain_string.empty() || domain_string[0] != '.');
 }
 
+// Task classes for queueing the coming request.
+
+class CookieMonster::CookieMonsterTask
+    : public base::RefCountedThreadSafe<CookieMonsterTask> {
+ public:
+  // Runs the task and invokes the client callback on the thread that
+  // originally constructed the task.
+  virtual void Run() = 0;
+
+ protected:
+  explicit CookieMonsterTask(CookieMonster* cookie_monster);
+  virtual ~CookieMonsterTask();
+
+  // Invokes the callback immediately, if the current thread is the one
+  // that originated the task, or queues the callback for execution on the
+  // appropriate thread. Maintains a reference to this CookieMonsterTask
+  // instance until the callback completes.
+  void InvokeCallback(base::Closure callback);
+
+  CookieMonster* cookie_monster() {
+    return cookie_monster_;
+  }
+
+  friend class base::RefCountedThreadSafe<CookieMonsterTask>;
+
+ private:
+  CookieMonster* cookie_monster_;
+  scoped_refptr<base::MessageLoopProxy> thread_;
+
+  DISALLOW_COPY_AND_ASSIGN(CookieMonsterTask);
+};
+
+CookieMonster::CookieMonsterTask::CookieMonsterTask(
+    CookieMonster* cookie_monster)
+    : cookie_monster_(cookie_monster),
+      thread_(base::MessageLoopProxy::current()) { }
+
+CookieMonster::CookieMonsterTask::~CookieMonsterTask() { }
+
+// Unfortunately, one cannot re-bind a Callback with parameters into a closure.
+// Therefore, the closure passed to InvokeCallback is a clumsy binding of
+// Callback::Run on a wrapped Callback instance. Since Callback is not
+// reference counted, we bind to an instance that is a member of the
+// CookieMonsterTask subclass. Then, we cannot simply post the callback to a
+// message loop because the underlying instance may be destroyed (along with the
+// CookieMonsterTask instance) in the interim. Therefore, we post a callback
+// bound to the CookieMonsterTask, which *is* reference counted (thus preventing
+// destruction of the original callback), and which invokes the closure (which
+// invokes the original callback with the returned data).
+void CookieMonster::CookieMonsterTask::InvokeCallback(base::Closure callback) {
+  if (thread_->BelongsToCurrentThread()) {
+    callback.Run();
+  } else {
+    thread_->PostTask(FROM_HERE, base::Bind(
+        &CookieMonster::CookieMonsterTask::InvokeCallback, this, callback));
+  }
+}
+
+// Task class for SetCookieWithDetails call.
+class CookieMonster::SetCookieWithDetailsTask
+    : public CookieMonster::CookieMonsterTask {
+ public:
+  SetCookieWithDetailsTask(
+      CookieMonster* cookie_monster,
+      const GURL& url, const std::string& name, const std::string& value,
+      const std::string& domain, const std::string& path,
+      const base::Time& expiration_time, bool secure, bool http_only,
+      const CookieMonster::SetCookiesCallback& callback)
+      : CookieMonsterTask(cookie_monster),
+        url_(url),
+        name_(name),
+        value_(value),
+        domain_(domain),
+        path_(path),
+        expiration_time_(expiration_time),
+        secure_(secure),
+        http_only_(http_only),
+        callback_(callback) { }
+
+  virtual void Run() OVERRIDE;
+
+ private:
+  GURL url_;
+  std::string name_;
+  std::string value_;
+  std::string domain_;
+  std::string path_;
+  base::Time expiration_time_;
+  bool secure_;
+  bool http_only_;
+  CookieMonster::SetCookiesCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(SetCookieWithDetailsTask);
+};
+
+void CookieMonster::SetCookieWithDetailsTask::Run() {
+  bool success = this->cookie_monster()->
+      SetCookieWithDetails(url_, name_, value_, domain_, path_,
+                           expiration_time_, secure_, http_only_);
+  if (!callback_.is_null()) {
+    this->InvokeCallback(base::Bind(&CookieMonster::SetCookiesCallback::Run,
+                                    base::Unretained(&callback_), success));
+  }
+}
+
+// Task class for GetAllCookies call.
+class CookieMonster::GetAllCookiesTask
+    : public CookieMonster::CookieMonsterTask {
+ public:
+  GetAllCookiesTask(CookieMonster* cookie_monster,
+                    const CookieMonster::GetCookieListCallback& callback)
+      : CookieMonsterTask(cookie_monster),
+        callback_(callback) { }
+
+  virtual void Run() OVERRIDE;
+
+ private:
+  CookieMonster::GetCookieListCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(GetAllCookiesTask);
+};
+
+void CookieMonster::GetAllCookiesTask::Run() {
+  if (!callback_.is_null()) {
+    CookieList cookies = this->cookie_monster()->GetAllCookies();
+    this->InvokeCallback(base::Bind(&CookieMonster::GetCookieListCallback::Run,
+                                    base::Unretained(&callback_), cookies));
+    }
+}
+
+// Task class for GetAllCookiesForURLWithOptions call.
+class CookieMonster::GetAllCookiesForURLWithOptionsTask
+    : public CookieMonster::CookieMonsterTask {
+ public:
+  GetAllCookiesForURLWithOptionsTask(
+      CookieMonster* cookie_monster,
+      const GURL& url,
+      const CookieOptions& options,
+      const CookieMonster::GetCookieListCallback& callback)
+      : CookieMonsterTask(cookie_monster),
+        url_(url),
+        options_(options),
+        callback_(callback) { }
+
+  virtual void Run() OVERRIDE;
+
+ private:
+  GURL url_;
+  CookieOptions options_;
+  CookieMonster::GetCookieListCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(GetAllCookiesForURLWithOptionsTask);
+};
+
+void CookieMonster::GetAllCookiesForURLWithOptionsTask::Run() {
+  if (!callback_.is_null()) {
+    CookieList cookies = this->cookie_monster()->
+        GetAllCookiesForURLWithOptions(url_, options_);
+    this->InvokeCallback(base::Bind(&CookieMonster::GetCookieListCallback::Run,
+                                    base::Unretained(&callback_), cookies));
+  }
+}
+
+// Task class for DeleteAll call.
+class CookieMonster::DeleteAllTask : public CookieMonster::CookieMonsterTask {
+ public:
+  DeleteAllTask(CookieMonster* cookie_monster,
+                const CookieMonster::DeleteCallback& callback)
+      : CookieMonsterTask(cookie_monster),
+        callback_(callback) { }
+
+  virtual void Run() OVERRIDE;
+
+ private:
+  CookieMonster::DeleteCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeleteAllTask);
+};
+
+void CookieMonster::DeleteAllTask::Run() {
+  int num_deleted = this->cookie_monster()->DeleteAll(true);
+  if (!callback_.is_null()) {
+    this->InvokeCallback(base::Bind(&CookieMonster::DeleteCallback::Run,
+                                    base::Unretained(&callback_), num_deleted));
+  }
+}
+
+// Task class for DeleteAllCreatedBetween call.
+class CookieMonster::DeleteAllCreatedBetweenTask
+    : public CookieMonster::CookieMonsterTask {
+ public:
+  DeleteAllCreatedBetweenTask(
+      CookieMonster* cookie_monster,
+      const Time& delete_begin,
+      const Time& delete_end,
+      const CookieMonster::DeleteCallback& callback)
+      : CookieMonsterTask(cookie_monster),
+        delete_begin_(delete_begin),
+        delete_end_(delete_end),
+        callback_(callback) { }
+
+  virtual void Run() OVERRIDE;
+
+ private:
+  Time delete_begin_;
+  Time delete_end_;
+  CookieMonster::DeleteCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeleteAllCreatedBetweenTask);
+};
+
+void CookieMonster::DeleteAllCreatedBetweenTask::Run() {
+  int num_deleted = this->cookie_monster()->
+      DeleteAllCreatedBetween(delete_begin_, delete_end_);
+  if (!callback_.is_null()) {
+    this->InvokeCallback(base::Bind(&CookieMonster::DeleteCallback::Run,
+                                    base::Unretained(&callback_), num_deleted));
+  }
+}
+
+// Task class for DeleteAllForHost call.
+class CookieMonster::DeleteAllForHostTask
+    : public CookieMonster::CookieMonsterTask {
+ public:
+  DeleteAllForHostTask(CookieMonster* cookie_monster,
+                       const GURL& url,
+                       const CookieMonster::DeleteCallback& callback)
+      : CookieMonsterTask(cookie_monster),
+        url_(url),
+        callback_(callback) { }
+
+  virtual void Run() OVERRIDE;
+
+ private:
+  GURL url_;
+  CookieMonster::DeleteCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeleteAllForHostTask);
+};
+
+void CookieMonster::DeleteAllForHostTask::Run() {
+  int num_deleted = this->cookie_monster()->DeleteAllForHost(url_);
+  if (!callback_.is_null()) {
+    this->InvokeCallback(base::Bind(&CookieMonster::DeleteCallback::Run,
+                                    base::Unretained(&callback_), num_deleted));
+  }
+}
+
+// Task class for DeleteCanonicalCookie call.
+class CookieMonster::DeleteCanonicalCookieTask
+    : public CookieMonster::CookieMonsterTask {
+ public:
+  DeleteCanonicalCookieTask(
+      CookieMonster* cookie_monster,
+      const CookieMonster::CanonicalCookie& cookie,
+      const CookieMonster::DeleteCookieCallback& callback)
+      : CookieMonsterTask(cookie_monster),
+        cookie_(cookie),
+        callback_(callback) { }
+
+  virtual void Run() OVERRIDE;
+
+ private:
+  CookieMonster::CanonicalCookie cookie_;
+  CookieMonster::DeleteCookieCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeleteCanonicalCookieTask);
+};
+
+void CookieMonster::DeleteCanonicalCookieTask::Run() {
+  bool result = this->cookie_monster()->DeleteCanonicalCookie(cookie_);
+  if (!callback_.is_null()) {
+    this->InvokeCallback(base::Bind(&CookieMonster::DeleteCookieCallback::Run,
+                                    base::Unretained(&callback_), result));
+  }
+}
+
+// Task class for SetCookieWithOptions call.
+class CookieMonster::SetCookieWithOptionsTask
+    : public CookieMonster::CookieMonsterTask {
+ public:
+  SetCookieWithOptionsTask(CookieMonster* cookie_monster,
+                           const GURL& url,
+                           const std::string& cookie_line,
+                           const CookieOptions& options,
+                           const CookieMonster::SetCookiesCallback& callback)
+      : CookieMonsterTask(cookie_monster),
+        url_(url),
+        cookie_line_(cookie_line),
+        options_(options),
+        callback_(callback) { }
+
+  virtual void Run() OVERRIDE;
+
+ private:
+  GURL url_;
+  std::string cookie_line_;
+  CookieOptions options_;
+  CookieMonster::SetCookiesCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(SetCookieWithOptionsTask);
+};
+
+void CookieMonster::SetCookieWithOptionsTask::Run() {
+  bool result = this->cookie_monster()->
+      SetCookieWithOptions(url_, cookie_line_, options_);
+  if (!callback_.is_null()) {
+    this->InvokeCallback(base::Bind(&CookieMonster::SetCookiesCallback::Run,
+                                    base::Unretained(&callback_), result));
+  }
+}
+
+// Task class for GetCookiesWithOptions call.
+class CookieMonster::GetCookiesWithOptionsTask
+    : public CookieMonster::CookieMonsterTask {
+ public:
+  GetCookiesWithOptionsTask(CookieMonster* cookie_monster,
+                            GURL url,
+                            const CookieOptions& options,
+                            const CookieMonster::GetCookiesCallback& callback)
+      : CookieMonsterTask(cookie_monster),
+        url_(url),
+        options_(options),
+        callback_(callback) { }
+
+  virtual void Run() OVERRIDE;
+
+ private:
+  GURL url_;
+  CookieOptions options_;
+  CookieMonster::GetCookiesCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(GetCookiesWithOptionsTask);
+};
+
+void CookieMonster::GetCookiesWithOptionsTask::Run() {
+  std::string cookie = this->cookie_monster()->
+      GetCookiesWithOptions(url_, options_);
+  if (!callback_.is_null()) {
+    this->InvokeCallback(base::Bind(&CookieMonster::GetCookiesCallback::Run,
+                                    base::Unretained(&callback_), cookie));
+  }
+}
+
+// Task class for GetCookiesWithInfo call.
+class CookieMonster::GetCookiesWithInfoTask
+    : public CookieMonster::CookieMonsterTask {
+ public:
+  GetCookiesWithInfoTask(CookieMonster* cookie_monster,
+                         const GURL& url,
+                         const CookieOptions& options,
+                         const CookieMonster::GetCookieInfoCallback& callback)
+      : CookieMonsterTask(cookie_monster),
+        url_(url),
+        options_(options),
+        callback_(callback) { }
+
+  virtual void Run() OVERRIDE;
+
+ private:
+  GURL url_;
+  CookieOptions options_;
+  CookieMonster::GetCookieInfoCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(GetCookiesWithInfoTask);
+};
+
+void CookieMonster::GetCookiesWithInfoTask::Run() {
+  if (!callback_.is_null()) {
+    std::string cookie_line;
+    std::vector<CookieMonster::CookieInfo> cookie_infos;
+    this->cookie_monster()->
+        GetCookiesWithInfo(url_, options_, &cookie_line, &cookie_infos);
+    this->InvokeCallback(base::Bind(&CookieMonster::GetCookieInfoCallback::Run,
+                                    base::Unretained(&callback_),
+                                    cookie_line, cookie_infos));
+  }
+}
+
+// Task class for DeleteCookie call.
+class CookieMonster::DeleteCookieTask
+    : public CookieMonster::CookieMonsterTask {
+ public:
+  DeleteCookieTask(CookieMonster* cookie_monster,
+                   GURL url,
+                   const std::string& cookie_name,
+                   const base::Closure& callback)
+      : CookieMonsterTask(cookie_monster),
+        url_(url),
+        cookie_name_(cookie_name),
+        callback_(callback) { }
+
+  virtual void Run() OVERRIDE;
+
+ private:
+  GURL url_;
+  std::string cookie_name_;
+  base::Closure callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeleteCookieTask);
+};
+
+void CookieMonster::DeleteCookieTask::Run() {
+  this->cookie_monster()->DeleteCookie(url_, cookie_name_);
+  if (!callback_.is_null()) {
+    this->InvokeCallback(callback_);
+  }
+}
+
+// Asynchronous CookieMonster API
+
+void CookieMonster::SetCookieWithDetailsAsync(
+    const GURL& url, const std::string& name, const std::string& value,
+    const std::string& domain, const std::string& path,
+    const base::Time& expiration_time, bool secure, bool http_only,
+    const SetCookiesCallback& callback) {
+  scoped_refptr<SetCookieWithDetailsTask> task =
+      new SetCookieWithDetailsTask(this, url, name, value, domain, path,
+                                   expiration_time, secure, http_only,
+                                   callback);
+
+  DoCookieTask(task);
+}
+
+void CookieMonster::GetAllCookiesAsync(const GetCookieListCallback& callback) {
+  scoped_refptr<GetAllCookiesTask> task =
+      new GetAllCookiesTask(this, callback);
+
+  DoCookieTask(task);
+}
+
+
+void CookieMonster::GetAllCookiesForURLWithOptionsAsync(
+    const GURL& url,
+    const CookieOptions& options,
+    const GetCookieListCallback& callback) {
+  scoped_refptr<GetAllCookiesForURLWithOptionsTask> task =
+      new GetAllCookiesForURLWithOptionsTask(this, url, options, callback);
+
+  DoCookieTask(task);
+}
+
+void CookieMonster::GetAllCookiesForURLAsync(
+    const GURL& url, const GetCookieListCallback& callback) {
+  CookieOptions options;
+  options.set_include_httponly();
+  scoped_refptr<GetAllCookiesForURLWithOptionsTask> task =
+      new GetAllCookiesForURLWithOptionsTask(this, url, options, callback);
+
+  DoCookieTask(task);
+}
+
+void CookieMonster::DeleteAllAsync(const DeleteCallback& callback) {
+  scoped_refptr<DeleteAllTask> task =
+      new DeleteAllTask(this, callback);
+
+  DoCookieTask(task);
+}
+
+void CookieMonster::DeleteAllCreatedBetweenAsync(
+    const Time& delete_begin, const Time& delete_end,
+    const DeleteCallback& callback) {
+  scoped_refptr<DeleteAllCreatedBetweenTask> task =
+      new DeleteAllCreatedBetweenTask(this, delete_begin, delete_end,
+                                      callback);
+
+  DoCookieTask(task);
+}
+
+void CookieMonster::DeleteAllForHostAsync(
+    const GURL& url, const DeleteCallback& callback) {
+  scoped_refptr<DeleteAllForHostTask> task =
+      new DeleteAllForHostTask(this, url, callback);
+
+  DoCookieTask(task);
+}
+
+void CookieMonster::DeleteCanonicalCookieAsync(
+    const CanonicalCookie& cookie,
+    const DeleteCookieCallback& callback) {
+  scoped_refptr<DeleteCanonicalCookieTask> task =
+      new DeleteCanonicalCookieTask(this, cookie, callback);
+
+  DoCookieTask(task);
+}
+
+void CookieMonster::SetCookieWithOptionsAsync(
+    const GURL& url,
+    const std::string& cookie_line,
+    const CookieOptions& options,
+    const SetCookiesCallback& callback) {
+  scoped_refptr<SetCookieWithOptionsTask> task =
+      new SetCookieWithOptionsTask(this, url, cookie_line, options, callback);
+
+  DoCookieTask(task);
+}
+
+void CookieMonster::GetCookiesWithOptionsAsync(
+    const GURL& url,
+    const CookieOptions& options,
+    const GetCookiesCallback& callback) {
+  scoped_refptr<GetCookiesWithOptionsTask> task =
+      new GetCookiesWithOptionsTask(this, url, options, callback);
+
+  DoCookieTask(task);
+}
+
+void CookieMonster::GetCookiesWithInfoAsync(
+    const GURL& url,
+    const CookieOptions& options,
+    const GetCookieInfoCallback& callback) {
+  scoped_refptr<GetCookiesWithInfoTask> task =
+      new GetCookiesWithInfoTask(this, url, options, callback);
+
+  DoCookieTask(task);
+}
+
+void CookieMonster::DeleteCookieAsync(const GURL& url,
+                                      const std::string& cookie_name,
+                                      const base::Closure& callback) {
+  scoped_refptr<DeleteCookieTask> task =
+      new DeleteCookieTask(this, url, cookie_name, callback);
+
+  DoCookieTask(task);
+}
+
+void CookieMonster::DoCookieTask(
+    const scoped_refptr<CookieMonsterTask>& task_item) {
+  InitIfNecessary();
+
+  {
+    base::AutoLock autolock(lock_);
+    if (!loaded_) {
+      queue_.push(task_item);
+      return;
+    }
+  }
+
+  task_item->Run();
+}
+
 bool CookieMonster::SetCookieWithDetails(
     const GURL& url, const std::string& name, const std::string& value,
     const std::string& domain, const std::string& path,
     const base::Time& expiration_time, bool secure, bool http_only) {
   base::AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url))
     return false;
 
-  InitIfNecessary();
-
   Time creation_time = CurrentTime();
   last_time_seen_ = creation_time;
 
   // TODO(abarth): Take these values as parameters.
   std::string mac_key;
   std::string mac_algorithm;
 
   scoped_ptr<CanonicalCookie> cc;
   cc.reset(CanonicalCookie::Create(
       url, name, value, domain, path,
       mac_key, mac_algorithm,
       creation_time, expiration_time,
       secure, http_only));
 
   if (!cc.get())
     return false;
 
   CookieOptions options;
   options.set_include_httponly();
   return SetCanonicalCookie(&cc, creation_time, options);
 }
 
-void CookieMonster::SetCookieWithDetailsAsync(
-    const GURL& url, const std::string& name, const std::string& value,
-    const std::string& domain, const std::string& path,
-    const base::Time& expiration_time, bool secure, bool http_only,
-    const SetCookiesCallback& callback) {
-  bool success_ = SetCookieWithDetails(url, name, value, domain, path,
-                                       expiration_time, secure, http_only);
-  if (!callback.is_null())
-    callback.Run(success_);
-}
-
 bool CookieMonster::InitializeFrom(const CookieList& list) {
   base::AutoLock autolock(lock_);
   InitIfNecessary();
   for (net::CookieList::const_iterator iter = list.begin();
            iter != list.end(); ++iter) {
     scoped_ptr<net::CookieMonster::CanonicalCookie> cookie;
     cookie.reset(new net::CookieMonster::CanonicalCookie(*iter));
     net::CookieOptions options;
     options.set_include_httponly();
     if (!SetCanonicalCookie(&cookie, cookie->CreationDate(),
                                              options)) {
       return false;
     }
   }
   return true;
 }
 
 CookieList CookieMonster::GetAllCookies() {
   base::AutoLock autolock(lock_);
-  InitIfNecessary();
 
   // This function is being called to scrape the cookie list for management UI
   // or similar.  We shouldn't show expired cookies in this list since it will
   // just be confusing to users, and this function is called rarely enough (and
   // is already slow enough) that it's OK to take the time to garbage collect
   // the expired cookies now.
   //
   // Note that this does not prune cookies to be below our limits (if we've
   // exceeded them) the way that calling GarbageCollect() would.
   GarbageCollectExpired(Time::Now(),
@@ skipping 10 matching lines @@
 
   CookieList cookie_list;
   cookie_list.reserve(cookie_ptrs.size());
   for (std::vector<CanonicalCookie*>::const_iterator it = cookie_ptrs.begin();
        it != cookie_ptrs.end(); ++it)
     cookie_list.push_back(**it);
 
   return cookie_list;
 }
 
-void CookieMonster::GetAllCookiesAsync(const GetCookieListCallback& callback) {
-  if (!callback.is_null())
-    callback.Run(GetAllCookies());
-}
-
 CookieList CookieMonster::GetAllCookiesForURLWithOptions(
     const GURL& url,
     const CookieOptions& options) {
   base::AutoLock autolock(lock_);
-  InitIfNecessary();
 
   std::vector<CanonicalCookie*> cookie_ptrs;
   FindCookiesForHostAndDomain(url, options, false, &cookie_ptrs);
   std::sort(cookie_ptrs.begin(), cookie_ptrs.end(), CookieSorter);
 
   CookieList cookies;
   for (std::vector<CanonicalCookie*>::const_iterator it = cookie_ptrs.begin();
        it != cookie_ptrs.end(); it++)
     cookies.push_back(**it);
 
   return cookies;
 }
 
-void CookieMonster::GetAllCookiesForURLWithOptionsAsync(
-    const GURL& url,
-    const CookieOptions& options,
-    const GetCookieListCallback& callback) {
-  if (!callback.is_null())
-    callback.Run(GetAllCookiesForURLWithOptions(url, options));
-}
-
 CookieList CookieMonster::GetAllCookiesForURL(const GURL& url) {
   CookieOptions options;
   options.set_include_httponly();
 
   return GetAllCookiesForURLWithOptions(url, options);
 }
 
-void CookieMonster::GetAllCookiesForURLAsync(
-    const GURL& url, const GetCookieListCallback& callback) {
-  if (!callback.is_null())
-    callback.Run(GetAllCookiesForURL(url));
-}
-
 int CookieMonster::DeleteAll(bool sync_to_store) {
   base::AutoLock autolock(lock_);
-  if (sync_to_store)
-    InitIfNecessary();
 
   int num_deleted = 0;
   for (CookieMap::iterator it = cookies_.begin(); it != cookies_.end();) {
     CookieMap::iterator curit = it;
     ++it;
     InternalDeleteCookie(curit, sync_to_store,
                          sync_to_store ? DELETE_COOKIE_EXPLICIT :
                              DELETE_COOKIE_DONT_RECORD /* Destruction. */);
     ++num_deleted;
   }
 
   return num_deleted;
 }
 
 int CookieMonster::DeleteAllCreatedBetween(const Time& delete_begin,
-                                           const Time& delete_end,
-                                           bool sync_to_store) {
+                                           const Time& delete_end) {
   base::AutoLock autolock(lock_);
-  InitIfNecessary();
 
   int num_deleted = 0;
   for (CookieMap::iterator it = cookies_.begin(); it != cookies_.end();) {
     CookieMap::iterator curit = it;
     CanonicalCookie* cc = curit->second;
     ++it;
 
     if (cc->CreationDate() >= delete_begin &&
         (delete_end.is_null() || cc->CreationDate() < delete_end)) {
-      InternalDeleteCookie(curit, sync_to_store, DELETE_COOKIE_EXPLICIT);
+      InternalDeleteCookie(curit,
+                           true,  /*sync_to_store*/
+                           DELETE_COOKIE_EXPLICIT);
       ++num_deleted;
     }
   }
 
   return num_deleted;
 }
 
-void CookieMonster::DeleteAllCreatedBetweenAsync(
-    const Time& delete_begin, const Time& delete_end,
-    bool sync_to_store,
-    const DeleteCallback& callback) {
-  int num_deleted = DeleteAllCreatedBetween(
-      delete_begin, delete_end, sync_to_store);
-  if (!callback.is_null())
-    callback.Run(num_deleted);
-}
-
 int CookieMonster::DeleteAllForHost(const GURL& url) {
   base::AutoLock autolock(lock_);
-  InitIfNecessary();
 
   if (!HasCookieableScheme(url))
     return 0;
 
   const std::string scheme(url.scheme());
   const std::string host(url.host());
 
   // We store host cookies in the store by their canonical host name;
   // domain cookies are stored with a leading ".".  So this is a pretty
   // simple lookup and per-cookie delete.
   int num_deleted = 0;
   for (CookieMapItPair its = cookies_.equal_range(GetKey(host));
        its.first != its.second;) {
     CookieMap::iterator curit = its.first;
     ++its.first;
 
     const CanonicalCookie* const cc = curit->second;
 
     // Delete only on a match as a host cookie.
     if (cc->IsHostCookie() && cc->IsDomainMatch(scheme, host)) {
       num_deleted++;
 
       InternalDeleteCookie(curit, true, DELETE_COOKIE_EXPLICIT);
     }
   }
   return num_deleted;
 }
 
-void CookieMonster::DeleteAllForHostAsync(
-    const GURL& url, const DeleteCallback& callback) {
-  int num_deleted = DeleteAllForHost(url);
-  if (!callback.is_null())
-    callback.Run(num_deleted);
-}
-
 bool CookieMonster::DeleteCanonicalCookie(const CanonicalCookie& cookie) {
   base::AutoLock autolock(lock_);
-  InitIfNecessary();
 
   for (CookieMapItPair its = cookies_.equal_range(GetKey(cookie.Domain()));
        its.first != its.second; ++its.first) {
     // The creation date acts as our unique index...
     if (its.first->second->CreationDate() == cookie.CreationDate()) {
       InternalDeleteCookie(its.first, true, DELETE_COOKIE_EXPLICIT);
       return true;
     }
   }
   return false;
 }
 
-void CookieMonster::DeleteCanonicalCookieAsync(
-    const CanonicalCookie& cookie,
-    const DeleteCookieCallback& callback) {
-  bool result = DeleteCanonicalCookie(cookie);
-  if (!callback.is_null())
-    callback.Run(result);
-}
-
 void CookieMonster::SetCookieableSchemes(
     const char* schemes[], size_t num_schemes) {
   base::AutoLock autolock(lock_);
 
   // Cookieable Schemes must be set before first use of function.
   DCHECK(!initialized_);
 
   cookieable_schemes_.clear();
   cookieable_schemes_.insert(cookieable_schemes_.end(),
                              schemes, schemes + num_schemes);
@@ skipping 28 matching lines @@
 
 bool CookieMonster::SetCookieWithOptions(const GURL& url,
                                          const std::string& cookie_line,
                                          const CookieOptions& options) {
   base::AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url)) {
     return false;
   }
 
-  InitIfNecessary();
-
   return SetCookieWithCreationTimeAndOptions(url, cookie_line, Time(), options);
 }
 
-void CookieMonster::SetCookieWithOptionsAsync(
-    const GURL& url,
-    const std::string& cookie_line,
-    const CookieOptions& options,
-    const SetCookiesCallback& callback) {
-  bool result = SetCookieWithOptions(url, cookie_line, options);
-    if (!callback.is_null())
-      callback.Run(result);
-}
-
 std::string CookieMonster::GetCookiesWithOptions(const GURL& url,
                                                  const CookieOptions& options) {
   base::AutoLock autolock(lock_);
-  InitIfNecessary();
 
   if (!HasCookieableScheme(url))
     return std::string();
 
   TimeTicks start_time(TimeTicks::Now());
 
   std::vector<CanonicalCookie*> cookies;
   FindCookiesForHostAndDomain(url, options, true, &cookies);
   std::sort(cookies.begin(), cookies.end(), CookieSorter);
 
   std::string cookie_line = BuildCookieLine(cookies);
 
   histogram_time_get_->AddTime(TimeTicks::Now() - start_time);
 
   VLOG(kVlogGetCookies) << "GetCookies() result: " << cookie_line;
 
   return cookie_line;
 }
 
-void CookieMonster::GetCookiesWithOptionsAsync(
-    const GURL& url, const CookieOptions& options,
-    const GetCookiesCallback& callback) {
-  std::string cookie = GetCookiesWithOptions(url, options);
-  if (!callback.is_null())
-    callback.Run(cookie);
-}
-
 void CookieMonster::GetCookiesWithInfo(const GURL& url,
                                        const CookieOptions& options,
                                        std::string* cookie_line,
                                        std::vector<CookieInfo>* cookie_infos) {
   DCHECK(cookie_line->empty());
   DCHECK(cookie_infos->empty());
 
   base::AutoLock autolock(lock_);
-  InitIfNecessary();
 
   if (!HasCookieableScheme(url))
     return;
 
   TimeTicks start_time(TimeTicks::Now());
 
   std::vector<CanonicalCookie*> cookies;
   FindCookiesForHostAndDomain(url, options, true, &cookies);
   std::sort(cookies.begin(), cookies.end(), CookieSorter);
   *cookie_line = BuildCookieLine(cookies);
 
   histogram_time_get_->AddTime(TimeTicks::Now() - start_time);
 
   TimeTicks mac_start_time = TimeTicks::Now();
   BuildCookieInfoList(cookies, cookie_infos);
   histogram_time_mac_->AddTime(TimeTicks::Now() - mac_start_time);
 }
 
-void CookieMonster::GetCookiesWithInfoAsync(
-    const GURL& url,
-    const CookieOptions& options,
-    const GetCookieInfoCallback& callback) {
-  std::string cookie_line;
-  std::vector<CookieInfo> cookie_infos;
-  GetCookiesWithInfo(url, options, &cookie_line, &cookie_infos);
-
-  if (!callback.is_null())
-    callback.Run(&cookie_line, &cookie_infos);
-}
-
 void CookieMonster::DeleteCookie(const GURL& url,
                                  const std::string& cookie_name) {
   base::AutoLock autolock(lock_);
-  InitIfNecessary();
 
   if (!HasCookieableScheme(url))
     return;
 
   CookieOptions options;
   options.set_include_httponly();
   // Get the cookies for this host and its domain(s).
   std::vector<CanonicalCookie*> cookies;
   FindCookiesForHostAndDomain(url, options, true, &cookies);
   std::set<CanonicalCookie*> matching_cookies;
 
   for (std::vector<CanonicalCookie*>::const_iterator it = cookies.begin();
        it != cookies.end(); ++it) {
     if ((*it)->Name() != cookie_name)
       continue;
     if (url.path().find((*it)->Path()))
       continue;
     matching_cookies.insert(*it);
   }
 
   for (CookieMap::iterator it = cookies_.begin(); it != cookies_.end();) {
     CookieMap::iterator curit = it;
     ++it;
     if (matching_cookies.find(curit->second) != matching_cookies.end()) {
       InternalDeleteCookie(curit, true, DELETE_COOKIE_EXPLICIT);
     }
   }
 }
 
-void CookieMonster::DeleteCookieAsync(const GURL& url,
-                                      const std::string& cookie_name,
-                                      const base::Closure& callback) {
-  DeleteCookie(url, cookie_name);
-  if (!callback.is_null())
-    callback.Run();
-}
-
 CookieMonster* CookieMonster::GetCookieMonster() {
   return this;
 }
 
 CookieMonster::~CookieMonster() {
   DeleteAll(false);
 }
 
 bool CookieMonster::SetCookieWithCreationTime(const GURL& url,
                                               const std::string& cookie_line,
                                               const base::Time& creation_time) {
+  DCHECK(!store_) << "This method is only to be used by unit-tests.";
   base::AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url)) {
     return false;
   }
 
   InitIfNecessary();
   return SetCookieWithCreationTimeAndOptions(url, cookie_line, creation_time,
                                              CookieOptions());
 }
 
 void CookieMonster::InitStore() {
   DCHECK(store_) << "Store must exist to initialize";
 
-  TimeTicks beginning_time(TimeTicks::Now());
+  // 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_load_->AddTime(TimeTicks::Now() - beginning_time);
+
+  // Invoke the task queue of cookie request.
+  InvokeQueue();
+}
+
+void CookieMonster::StoreLoadedCookies(
+    const std::vector<CanonicalCookie*>& cookies) {
   // Initialize the store and sync in any saved persistent cookies.  We don't
   // care if it's expired, insert it so it can be garbage collected, removed,
   // and sync'd.
-  std::vector<CanonicalCookie*> cookies;
-  // Reserve space for the maximum amount of cookies a database should have.
-  // This prevents multiple vector growth / copies as we append cookies.
-  cookies.reserve(kMaxCookies);
-  store_->Load(&cookies);
+  base::AutoLock autolock(lock_);
 
   // Avoid ever letting cookies with duplicate creation times into the store;
   // that way we don't have to worry about what sections of code are safe
   // to call while it's in that state.
   std::set<int64> creation_times;
 
   // Presumably later than any access time in the store.
   Time earliest_access_time;
 
   for (std::vector<CanonicalCookie*>::const_iterator it = cookies.begin();
@@ skipping 18 matching lines @@
       delete (*it);
     }
   }
   earliest_access_time_= earliest_access_time;
 
   // After importing cookies from the PersistentCookieStore, verify that
   // none of our other constraints are violated.
   //
   // In particular, the backing store might have given us duplicate cookies.
   EnsureCookiesMapIsValid();
+}
 
-  histogram_time_load_->AddTime(TimeTicks::Now() - beginning_time);
+void CookieMonster::InvokeQueue() {
+  while (true) {
+    scoped_refptr<CookieMonsterTask> request_task;
+    {
+      base::AutoLock autolock(lock_);
+      if (queue_.empty()) {
+        loaded_ = true;
+        break;
+      }
+      request_task = queue_.front();
+      queue_.pop();
+    }
+    request_task->Run();
+  }
 }
 
 void CookieMonster::EnsureCookiesMapIsValid() {
   lock_.AssertAcquired();
 
   int num_duplicates_trimmed = 0;
 
   // Iterate through all the of the cookies, grouped by host.
   CookieMap::iterator prev_range_end = cookies_.begin();
   while (prev_range_end != cookies_.end()) {
@@ skipping 80 matching lines @@
         signature.name.c_str(),
         signature.domain.c_str(),
         signature.path.c_str());
 
     // Remove all the cookies identified by |dupes|. It is valid to delete our
     // list of iterators one at a time, since |cookies_| is a multimap (they
     // don't invalidate existing iterators following deletion).
     for (CookieSet::iterator dupes_it = dupes.begin();
          dupes_it != dupes.end();
          ++dupes_it) {
-      InternalDeleteCookie(*dupes_it, true /*sync_to_store*/,
+      InternalDeleteCookie(*dupes_it, true,
                            DELETE_COOKIE_DUPLICATE_IN_BACKING_STORE);
     }
   }
   DCHECK_EQ(num_duplicates, num_duplicates_found);
 
   return num_duplicates;
 }
 
 // Note: file must be the last scheme.
 const char* CookieMonster::kDefaultCookieableSchemes[] =
@@ skipping 633 matching lines @@
   if (!pairs_.empty()) {
     is_valid_ = true;
     SetupAttributes();
   }
 }
 
 CookieMonster::ParsedCookie::~ParsedCookie() {
 }
 
 // Returns true if |c| occurs in |chars|
-// TODO maybe make this take an iterator, could check for end also?
+// TODO(erikwright): maybe make this take an iterator, could check for end also?
 static inline bool CharIsA(const char c, const char* chars) {
   return strchr(chars, c) != NULL;
 }
 // Seek the iterator to the first occurrence of a character in |chars|.
 // Returns true if it hit the end, false otherwise.
 static inline bool SeekTo(std::string::const_iterator* it,
                           const std::string::const_iterator& end,
                           const char* chars) {
   for (; *it != end && !CharIsA(**it, chars); ++(*it)) {}
   return *it == end;
@@ skipping 135 matching lines @@
 // Parse all token/value pairs and populate pairs_.
 void CookieMonster::ParsedCookie::ParseTokenValuePairs(
     const std::string& cookie_line) {
   pairs_.clear();
 
   // Ok, here we go.  We should be expecting to be starting somewhere
   // before the cookie line, not including any header name...
   std::string::const_iterator start = cookie_line.begin();
   std::string::const_iterator it = start;
 
-  // TODO Make sure we're stripping \r\n in the network code.  Then we
-  // can log any unexpected terminators.
+  // TODO(erikwright): Make sure we're stripping \r\n in the network code.
+  // Then we can log any unexpected terminators.
   std::string::const_iterator end = FindFirstTerminator(cookie_line);
 
   for (int pair_num = 0; pair_num < kMaxPairs && it != end; ++pair_num) {
     TokenValuePair pair;
 
     std::string::const_iterator token_start, token_end;
     if (!ParseToken(&it, end, &token_start, &token_end))
       break;
 
     if (it == end || *it != '=') {
@@ skipping 309 matching lines @@
 std::string CookieMonster::CanonicalCookie::DebugString() const {
   return base::StringPrintf(
       "name: %s value: %s domain: %s path: %s creation: %"
       PRId64,
       name_.c_str(), value_.c_str(),
       domain_.c_str(), path_.c_str(),
       static_cast<int64>(creation_date_.ToTimeT()));
 }
 
 }  // namespace