Remove the old synchronous CookieMonster API.

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/metrics/histogram.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_canon.h"
 #include "net/base/net_util.h"
@@ skipping 351 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] != '.');
 }
 
+
+
+void InvokeSetCookiesCallbackOnOtherThread(

[erikwright (departed), 2011/08/11 13:58:24]

These functions should not be needed if you define CookieMonsterTask as
described in my review of the .h file.

[ycxiao, 2011/08/12 02:35:24]

Since callback is not reference counted thread safe, if I use
PostTask(base::Bind(&***Task, base::Unretained(callback_))), the callback_ may
be deleted before execution.

I need these functions to post the passing callback to the caller thread. 

+    const CookieMonster::SetCookiesCallback& callback,
+    bool success) {
+  if (!callback.is_null())
+    callback.Run(success);
+}
+
+void InvokeGetCookieListCallbackOnOtherThread(
+    const CookieMonster::GetCookieListCallback& callback,
+    const CookieList& cookies) {
+  if (!callback.is_null())
+    callback.Run(cookies);
+}
+
+void InvokeDeleteCallbackOnOtherThread(
+    const CookieMonster::DeleteCallback& callback,
+    int num_deleted) {
+  if (!callback.is_null())
+    callback.Run(num_deleted);
+}
+
+void InvokeGetCookiesCallbackOnOtherThread(
+    const CookieMonster::GetCookiesCallback& callback,
+    const std::string& cookie) {
+  if (!callback.is_null())
+    callback.Run(cookie);
+}
+
+void InvokeGetCookieInfoCallbackOnOtherThread(
+    const CookieMonster::GetCookieInfoCallback& callback,
+    const std::string& cookie_line,
+    const std::vector<CookieStore::CookieInfo>& cookie_infos) {
+  if (!callback.is_null()) {
+    std::string line = cookie_line;
+    std::vector<CookieStore::CookieInfo> info =  cookie_infos;
+    callback.Run(&line, &info);
+  }
+}
+
+// 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) {
+  GURL gurl = url;
+  CookieAPIParameters parameters;
+  parameters.url = &gurl;
+  parameters.name = name;
+  parameters.value = value;
+  parameters.domain = domain;
+  parameters.path =path;
+  parameters.expiration_time = expiration_time;
+  parameters.secure = secure;
+  parameters.http_only = http_only;
+
+  scoped_refptr<base::MessageLoopProxy> thread(
+      base::MessageLoopProxy::CreateForCurrentThread());
+  base::Closure task = base::Bind(&CookieMonster::SetCookieWithDetailsTask,
+                                  this, callback, parameters, thread);
+  DoCookieTask(task);
+}
+
+void CookieMonster::GetAllCookiesAsync(const GetCookieListCallback& callback) {
+  scoped_refptr<base::MessageLoopProxy> thread(
+      base::MessageLoopProxy::CreateForCurrentThread());
+  base::Closure task = base::Bind(&CookieMonster::GetAllCookiesTask,
+                                  this, callback, thread);
+  DoCookieTask(task);
+}
+
+
+void CookieMonster::GetAllCookiesForURLWithOptionsAsync(
+    const GURL& url,
+    const CookieOptions& options,
+    const GetCookieListCallback& callback) {
+  GURL gurl = url;
+  CookieAPIParameters parameters;
+  parameters.url = &gurl;
+  parameters.options = options;
+
+  scoped_refptr<base::MessageLoopProxy> thread(
+      base::MessageLoopProxy::CreateForCurrentThread());
+  base::Closure task =
+      base::Bind(&CookieMonster::GetAllCookiesForURLWithOptionsTask,
+                 this, callback, parameters, thread);
+  DoCookieTask(task);
+}
+
+void CookieMonster::GetAllCookiesForURLAsync(
+    const GURL& url, const GetCookieListCallback& callback) {
+  GURL gurl = url;
+  CookieAPIParameters parameters;
+  parameters.url = &gurl;
+
+  scoped_refptr<base::MessageLoopProxy> thread(
+      base::MessageLoopProxy::CreateForCurrentThread());
+  base::Closure task = base::Bind(&CookieMonster::GetAllCookiesForURLTask,
+                                  this, callback, parameters, thread);
+  DoCookieTask(task);
+}
+
+void CookieMonster::DeleteAllAsync(bool sync_to_store,
+                                   const DeleteCallback& callback) {
+  CookieAPIParameters parameters;
+  parameters.sync_to_store = sync_to_store;
+
+  scoped_refptr<base::MessageLoopProxy> thread(
+      base::MessageLoopProxy::CreateForCurrentThread());
+  base::Closure task = base::Bind(&CookieMonster::DeleteAllTask,
+                                  this, callback, parameters, thread);
+  DoCookieTask(task);
+}
+
+void CookieMonster::DeleteAllCreatedBetweenAsync(
+    const Time& delete_begin, const Time& delete_end,
+    bool sync_to_store,
+    const DeleteCallback& callback) {
+  CookieAPIParameters parameters;
+  parameters.delete_begin = delete_begin;
+  parameters.delete_end = delete_end;
+  parameters.sync_to_store = sync_to_store;
+
+  scoped_refptr<base::MessageLoopProxy> thread(
+      base::MessageLoopProxy::CreateForCurrentThread());
+  base::Closure task = base::Bind(&CookieMonster::DeleteAllCreatedBetweenTask,
+                                  this, callback, parameters, thread);
+  DoCookieTask(task);
+}
+
+void CookieMonster::DeleteAllForHostAsync(
+    const GURL& url, const DeleteCallback& callback) {
+  GURL gurl = url;
+  CookieAPIParameters parameters;
+  parameters.url = &gurl;
+
+  scoped_refptr<base::MessageLoopProxy> thread(
+      base::MessageLoopProxy::CreateForCurrentThread());
+  base::Closure task = base::Bind(&CookieMonster::DeleteAllForHostTask,
+                                  this, callback, parameters, thread);
+  DoCookieTask(task);
+}
+
+void CookieMonster::DeleteCanonicalCookieAsync(
+    const CanonicalCookie& cookie,
+    const DeleteCookieCallback& callback) {
+  CanonicalCookie delete_cookie = cookie;
+  CookieAPIParameters parameters;
+  parameters.cookie = &delete_cookie;
+
+  scoped_refptr<base::MessageLoopProxy> thread(
+      base::MessageLoopProxy::CreateForCurrentThread());
+  base::Closure task = base::Bind(&CookieMonster::DeleteCanonicalCookieTask,
+                                  this, callback, parameters, thread);
+  DoCookieTask(task);
+}
+
+void CookieMonster::SetCookieWithOptionsAsync(
+    const GURL& url,
+    const std::string& cookie_line,
+    const CookieOptions& options,
+    const SetCookiesCallback& callback) {
+  GURL gurl = url;
+  CookieAPIParameters parameters;
+  parameters.url = &gurl;
+  parameters.cookie_line = cookie_line;
+  parameters.options = options;
+
+  scoped_refptr<base::MessageLoopProxy> thread(
+      base::MessageLoopProxy::CreateForCurrentThread());
+  base::Closure task = base::Bind(&CookieMonster::SetCookieWithOptionsTask,
+                                  this, callback, parameters, thread);
+  DoCookieTask(task);
+}
+
+void CookieMonster::GetCookiesWithOptionsAsync(
+    const GURL& url, const CookieOptions& options,
+    const GetCookiesCallback& callback) {
+  GURL gurl = url;
+  CookieAPIParameters parameters;
+  parameters.url = &gurl;
+  parameters.options = options;
+
+  scoped_refptr<base::MessageLoopProxy> thread(
+      base::MessageLoopProxy::CreateForCurrentThread());
+  base::Closure task = base::Bind(&CookieMonster::GetCookiesWithOptionsTask,
+                                  this, callback, parameters, thread);
+  DoCookieTask(task);
+}
+
+void CookieMonster::GetCookiesWithInfoAsync(
+    const GURL& url,
+    const CookieOptions& options,
+    const GetCookieInfoCallback& callback) {
+  GURL gurl = url;
+  CookieAPIParameters parameters;
+  parameters.url = &gurl;
+  parameters.options = options;
+
+  scoped_refptr<base::MessageLoopProxy> thread(
+      base::MessageLoopProxy::CreateForCurrentThread());
+  base::Closure task = base::Bind(&CookieMonster::GetCookiesWithInfoTask,
+                                  this, callback, parameters, thread);
+  DoCookieTask(task);
+}
+
+void CookieMonster::DeleteCookieAsync(const GURL& url,
+                                      const std::string& cookie_name,
+                                      const base::Closure& callback) {
+  GURL gurl = url;
+  CookieAPIParameters parameters;
+  parameters.url = &gurl;
+  parameters.name = cookie_name;
+
+  scoped_refptr<base::MessageLoopProxy> thread(
+      base::MessageLoopProxy::CreateForCurrentThread());
+  base::Closure task = base::Bind(&CookieMonster::DeleteCookieTask,
+                                  this, callback, parameters, thread);
+  DoCookieTask(task);
+}
+
+void CookieMonster::DoCookieTask(const base::Closure& task) {

[erikwright (departed), 2011/08/11 13:58:24]

We discussed offline a more minimal use of locking.

[ycxiao, 2011/08/12 02:35:24]

Done.

+  DCHECK(!task.is_null());
+  InitIfNecessary();
+  base::AutoLock autolock(lock_);
+  if (loaded_) {
+    task.Run();
+  } else {
+    queue_.push_back(task);
+  }
+}
+
+void CookieMonster::SetCookieWithDetailsTask(

[erikwright (departed), 2011/08/11 13:58:24]

See comments in .h file regarding CookieMonsterTask.

[ycxiao, 2011/08/12 02:35:24]

Done.

+    const SetCookiesCallback& callback,
+    const CookieAPIParameters& para,
+    scoped_refptr<base::MessageLoopProxy> thread) {
+  bool success = SetCookieWithDetails(
+      *para.url, para.name, para.value, para.domain, para.path,
+      para.expiration_time, para.secure, para.http_only);
+  if (!callback.is_null()) {
+    if (thread->BelongsToCurrentThread()) {
+      base::AutoUnlock autounlock(lock_);
+      callback.Run(success);
+    } else {
+      thread->PostTask(
+          FROM_HERE, base::Bind(&InvokeSetCookiesCallbackOnOtherThread,
+                                callback, success));
+    }
+  }
+}
+
+void CookieMonster::GetAllCookiesTask(
+    const GetCookieListCallback& callback,
+    scoped_refptr<base::MessageLoopProxy> thread) {
+  if (!callback.is_null()) {
+    CookieList cookies = GetAllCookies();
+    if (thread->BelongsToCurrentThread()) {
+      base::AutoUnlock autounlock(lock_);
+      callback.Run(cookies);
+    } else {
+      thread->PostTask(
+          FROM_HERE, base::Bind(&InvokeGetCookieListCallbackOnOtherThread,
+                                callback, cookies));
+    }
+  }
+}
+
+void CookieMonster::GetAllCookiesForURLWithOptionsTask(
+    const GetCookieListCallback& callback,
+    const CookieAPIParameters& para,
+    scoped_refptr<base::MessageLoopProxy> thread) {
+  if (!callback.is_null()) {
+    CookieList cookies = GetAllCookiesForURLWithOptions(
+        *para.url, para.options);
+    if (thread->BelongsToCurrentThread()) {
+      base::AutoUnlock autounlock(lock_);
+      callback.Run(cookies);
+    } else {
+      thread->PostTask(
+          FROM_HERE, base::Bind(&InvokeGetCookieListCallbackOnOtherThread,
+                                callback, cookies));
+    }
+  }
+}
+
+void CookieMonster::GetAllCookiesForURLTask(
+    const GetCookieListCallback& callback,
+    const CookieAPIParameters& para,
+    scoped_refptr<base::MessageLoopProxy> thread) {
+  if (!callback.is_null()) {
+    CookieList cookies = GetAllCookiesForURL(*para.url);
+    if (thread->BelongsToCurrentThread()) {
+      base::AutoUnlock autounlock(lock_);
+      callback.Run(cookies);
+    } else {
+      thread->PostTask(
+          FROM_HERE, base::Bind(&InvokeGetCookieListCallbackOnOtherThread,
+                                callback, cookies));
+    }
+  }
+}
+
+void CookieMonster::DeleteAllTask(
+    const DeleteCallback& callback,
+    const CookieAPIParameters& para,
+    scoped_refptr<base::MessageLoopProxy> thread) {
+  int num_deleted = DeleteAll(para.sync_to_store);
+  if (!callback.is_null()) {
+    if (thread->BelongsToCurrentThread()) {
+      base::AutoUnlock autounlock(lock_);
+      callback.Run(num_deleted);
+    } else {
+      thread->PostTask(
+          FROM_HERE, base::Bind(&InvokeDeleteCallbackOnOtherThread,
+                                callback, num_deleted));
+    }
+  }
+}
+
+void CookieMonster::DeleteAllCreatedBetweenTask(
+    const DeleteCallback& callback,
+    const CookieAPIParameters& para,
+    scoped_refptr<base::MessageLoopProxy> thread) {
+  int num_deleted = DeleteAllCreatedBetween(
+      para.delete_begin, para.delete_end, para.sync_to_store);
+  if (!callback.is_null()) {
+    if (thread->BelongsToCurrentThread()) {
+      base::AutoUnlock autounlock(lock_);
+      callback.Run(num_deleted);
+    } else {
+      thread->PostTask(
+          FROM_HERE, base::Bind(&InvokeDeleteCallbackOnOtherThread,
+                                callback, num_deleted));
+    }
+  }
+}
+
+void CookieMonster::DeleteAllForHostTask(
+    const DeleteCallback& callback,
+    const CookieAPIParameters& para,
+    scoped_refptr<base::MessageLoopProxy> thread) {
+  int num_deleted = DeleteAllForHost(*para.url);
+  if (!callback.is_null()) {
+    if (thread->BelongsToCurrentThread()) {
+      base::AutoUnlock autounlock(lock_);
+      callback.Run(num_deleted);
+    } else {
+      thread->PostTask(
+          FROM_HERE, base::Bind(&InvokeDeleteCallbackOnOtherThread,
+                                callback, num_deleted));
+    }
+  }
+}
+
+void CookieMonster::DeleteCanonicalCookieTask(
+    const DeleteCookieCallback& callback,
+    const CookieAPIParameters& para,
+    scoped_refptr<base::MessageLoopProxy> thread) {
+  bool result = DeleteCanonicalCookie(*para.cookie);
+  if (!callback.is_null()) {
+    if (thread->BelongsToCurrentThread()) {
+      base::AutoUnlock autounlock(lock_);
+      callback.Run(result);
+    } else {
+      thread->PostTask(
+          FROM_HERE, base::Bind(&InvokeSetCookiesCallbackOnOtherThread,
+                                callback, result));
+    }
+  }
+}
+
+void CookieMonster::SetCookieWithOptionsTask(
+    const SetCookiesCallback& callback,
+    const CookieAPIParameters& para,
+    scoped_refptr<base::MessageLoopProxy> thread) {
+  bool result = SetCookieWithOptions(*para.url, para.cookie_line, para.options);
+  if (!callback.is_null()) {
+    if (thread->BelongsToCurrentThread()) {
+      base::AutoUnlock autounlock(lock_);
+      callback.Run(result);
+    } else {
+      thread->PostTask(
+          FROM_HERE, base::Bind(&InvokeSetCookiesCallbackOnOtherThread,
+                                callback, result));
+    }
+  }
+}
+
+void CookieMonster::GetCookiesWithOptionsTask(
+    const GetCookiesCallback& callback,
+    const CookieAPIParameters& para,
+    scoped_refptr<base::MessageLoopProxy> thread) {
+  std::string cookie = GetCookiesWithOptions(*para.url, para.options);
+  if (!callback.is_null()) {
+    if (thread->BelongsToCurrentThread()) {
+      base::AutoUnlock autounlock(lock_);
+      callback.Run(cookie);
+    } else {
+      thread->PostTask(
+          FROM_HERE, base::Bind(&InvokeGetCookiesCallbackOnOtherThread,
+                                callback, cookie));
+    }
+  }
+}
+
+void CookieMonster::GetCookiesWithInfoTask(
+    const GetCookieInfoCallback& callback,
+    const CookieAPIParameters& para,
+    scoped_refptr<base::MessageLoopProxy> thread) {
+  if (!callback.is_null()) {
+    std::string cookie_line;
+    std::vector<CookieInfo> cookie_infos;
+    GetCookiesWithInfo(*para.url, para.options, &cookie_line, &cookie_infos);
+    if (thread->BelongsToCurrentThread()) {
+      base::AutoUnlock autounlock(lock_);
+      callback.Run(&cookie_line, &cookie_infos);
+    } else {
+      thread->PostTask(
+          FROM_HERE, base::Bind(&InvokeGetCookieInfoCallbackOnOtherThread,
+                                callback, cookie_line, cookie_infos));
+    }
+  }
+}
+
+void CookieMonster::DeleteCookieTask(
+    const base::Closure& callback,
+    const CookieAPIParameters& para,
+    scoped_refptr<base::MessageLoopProxy> thread) {
+  DeleteCookie(*para.url, para.name);
+  if (!callback.is_null()) {
+    if (thread->BelongsToCurrentThread()) {
+      base::AutoUnlock autounlock(lock_);
+      callback.Run();
+    } else {
+      thread->PostTask(FROM_HERE, callback);
+    }
+  }
+}
+
 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_);
+  lock_.AssertAcquired();
 
   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(CookieMonster* cookie_monster) {
-  net::CookieList list = cookie_monster->GetAllCookies();
-
+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();
+  lock_.AssertAcquired();
 
   // 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();
+  lock_.AssertAcquired();
 
   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();
+  lock_.AssertAcquired();
 
   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) {
-  base::AutoLock autolock(lock_);
-  InitIfNecessary();
+  lock_.AssertAcquired();
 
   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);
       ++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();
+  lock_.AssertAcquired();
 
   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();
+  lock_.AssertAcquired();
 
   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 22 matching lines @@
   base::AutoLock autolock(lock_);
   if (initialized_ && store_)
     store_->Flush(completion_task);
   else if (completion_task)
     MessageLoop::current()->PostTask(FROM_HERE, completion_task);
 }
 
 bool CookieMonster::SetCookieWithOptions(const GURL& url,
                                          const std::string& cookie_line,
                                          const CookieOptions& options) {
-  base::AutoLock autolock(lock_);
+  lock_.AssertAcquired();
 
   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();
+  lock_.AssertAcquired();
 
   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();
+  lock_.AssertAcquired();
 
   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();
+  lock_.AssertAcquired();
 
   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() {
+  base::AutoLock autolock(lock_);
   DeleteAll(false);
 }
 
 bool CookieMonster::SetCookieWithCreationTime(const GURL& url,
                                               const std::string& cookie_line,
                                               const base::Time& creation_time) {
+  // Only for CookieMonster unit test usage.

[erikwright (departed), 2011/08/11 13:58:24]

DCHECK(!store_) << "This method is only to be used by unit-tests.";

[ycxiao, 2011/08/12 02:35:24]

Done.

+  DCHECK(!store_);
   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";
+  store_->Load(base::Bind(&CookieMonster::OnLoaded, this));
+}
 
-  TimeTicks beginning_time(TimeTicks::Now());
-
+void CookieMonster::OnLoaded(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_);
+  TimeTicks beginning_time(TimeTicks::Now());
 
   // 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 20 matching lines @@
   }
   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);
+
+  // Invoke the task queue of cookie request.
+  InvokeQueue();
+}
+
+void CookieMonster::InvokeQueue() {

[erikwright (departed), 2011/08/11 13:58:24]

Refer to offline discussion about minimal lock holding.

[ycxiao, 2011/08/12 02:35:24]

Done.

+  while (true) {
+    if (queue_.empty()) {
+      loaded_ = true;
+      break;
+    }
+    queue_.front().Run();
+    queue_.pop_front();
+  }
 }
 
 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 1065 matching lines @@
 #if defined(ENABLE_PERSISTENT_SESSION_COOKIES)
   // Mobile apps can sometimes be shut down without any warning, so the session
   // cookie has to be persistent and given a default expiration time.
   expiry_date_ = base::Time::Now() +
       base::TimeDelta::FromDays(kPersistentSessionCookieExpiryInDays);
   has_expires_ = true;
 #endif
 }
 
 CookieMonster::CanonicalCookie* CookieMonster::CanonicalCookie::Create(
+    const GURL& url,
+    const ParsedCookie& pc) {
+  if (!pc.IsValid()) {
+    return NULL;
+  }
+
+  std::string domain_string;
+  if (!GetCookieDomain(url, pc, &domain_string)) {
+    return NULL;
+  }
+  std::string path_string = CanonPath(url, pc);
+  std::string mac_key = pc.HasMACKey() ? pc.MACKey() : std::string();
+  std::string mac_algorithm = pc.HasMACAlgorithm() ?
+      pc.MACAlgorithm() : std::string();
+  Time creation_time = Time::Now();
+  Time expiration_time;
+  if (pc.HasExpires())
+    expiration_time =  net::CookieMonster::ParseCookieTime(pc.Expires());
+
+  return (Create(url, pc.Name(), pc.Value(), domain_string, path_string,
+                 mac_key, mac_algorithm, creation_time, expiration_time,
+                 pc.IsSecure(), pc.IsHttpOnly()));
+}
+
+CookieMonster::CanonicalCookie* CookieMonster::CanonicalCookie::Create(
       const GURL& url,
       const std::string& name,
       const std::string& value,
       const std::string& domain,
       const std::string& path,
       const std::string& mac_key,
       const std::string& mac_algorithm,
       const base::Time& creation,
       const base::Time& expiration,
       bool secure,
@@ skipping 111 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