Make CookieMonster NonThreadSafe.

net/base/cookie_monster.cc

 // Copyright (c) 2010 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 531 matching lines @@
     }
   }
 
   // The scheme didn't match any in our whitelist.
   COOKIE_DLOG(WARNING) << "Unsupported cookie scheme: " << url.scheme();
   return false;
 }
 
 void CookieMonster::SetCookieableSchemes(
     const char* schemes[], size_t num_schemes) {
+  DCHECK(CalledOnValidThread());
   AutoLock autolock(lock_);
 
   cookieable_schemes_.clear();
   cookieable_schemes_.insert(cookieable_schemes_.end(),
                              schemes, schemes + num_schemes);
 }
 
 bool CookieMonster::SetCookieWithCreationTimeAndOptions(
     const GURL& url,
     const std::string& cookie_line,
     const Time& creation_time_or_null,
     const CookieOptions& options) {
+  DCHECK(CalledOnValidThread());
   AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url)) {
     return false;
   }
 
   InitIfNecessary();
 
   COOKIE_DLOG(INFO) << "SetCookie() line: " << cookie_line;
 
@@ skipping 35 matching lines @@
     COOKIE_DLOG(WARNING) << "Failed to allocate CanonicalCookie";
     return false;
   }
   return SetCanonicalCookie(&cc, cookie_domain, creation_time, options);
 }
 
 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) {
+  DCHECK(CalledOnValidThread());
 
   // Expect a valid domain attribute with no illegal characters.
   std::string parsed_domain = ParsedCookie::ParseValueString(domain);
   if (parsed_domain != domain)
     return false;
   std::string cookie_domain;
   if (!GetCookieDomainKeyWithString(url, parsed_domain, &cookie_domain))
     return false;
 
   AutoLock autolock(lock_);
@@ skipping 197 matching lines @@
       ++num_deleted;
     } else if (cookie_its) {
       cookie_its->push_back(curit);
     }
   }
 
   return num_deleted;
 }
 
 int CookieMonster::DeleteAll(bool sync_to_store) {
+  DCHECK(CalledOnValidThread());
   AutoLock autolock(lock_);
   InitIfNecessary();
 
   int num_deleted = 0;
   for (CookieMap::iterator it = cookies_.begin(); it != cookies_.end();) {
     CookieMap::iterator curit = it;
     ++it;
     InternalDeleteCookie(curit, sync_to_store);
     ++num_deleted;
   }
 
   return num_deleted;
 }
 
 int CookieMonster::DeleteAllCreatedBetween(const Time& delete_begin,
                                            const Time& delete_end,
                                            bool sync_to_store) {
+  DCHECK(CalledOnValidThread());
   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);
       ++num_deleted;
     }
   }
 
   return num_deleted;
 }
 
 int CookieMonster::DeleteAllCreatedAfter(const Time& delete_begin,
                                          bool sync_to_store) {
+  DCHECK(CalledOnValidThread());
   return DeleteAllCreatedBetween(delete_begin, Time(), sync_to_store);
 }
 
 int CookieMonster::DeleteAllForURL(const GURL& url,
                                    bool sync_to_store) {
+  DCHECK(CalledOnValidThread());
   AutoLock autolock(lock_);
   InitIfNecessary();
 
   CookieList cookies = InternalGetAllCookiesForURL(url);
   int num_deleted = 0;
   for (CookieMap::iterator it = cookies_.begin(); it != cookies_.end();) {
     CookieMap::iterator curit = it;
     ++it;
     InternalDeleteCookie(curit, sync_to_store);
   }
   return num_deleted;
 }
 
 bool CookieMonster::DeleteCookie(const std::string& domain,
                                  const CanonicalCookie& cookie,
                                  bool sync_to_store) {
+  DCHECK(CalledOnValidThread());
   AutoLock autolock(lock_);
   InitIfNecessary();
 
   for (CookieMapItPair its = cookies_.equal_range(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, sync_to_store);
       return true;
     }
   }
   return false;
 }
 
 // Mozilla sorts on the path length (longest first), and then it
 // sorts by creation time (oldest first).
 // The RFC says the sort order for the domain attribute is undefined.
 static bool CookieSorter(CookieMonster::CanonicalCookie* cc1,
                          CookieMonster::CanonicalCookie* cc2) {
   if (cc1->Path().length() == cc2->Path().length())
     return cc1->CreationDate() < cc2->CreationDate();
   return cc1->Path().length() > cc2->Path().length();
 }
 
 bool CookieMonster::SetCookieWithOptions(const GURL& url,
                                          const std::string& cookie_line,
                                          const CookieOptions& options) {
+  DCHECK(CalledOnValidThread());
   return SetCookieWithCreationTimeAndOptions(url, cookie_line, Time(), options);
 }
 
 // Currently our cookie datastructure is based on Mozilla's approach.  We have a
 // hash keyed on the cookie's domain, and for any query we walk down the domain
 // components and probe for cookies until we reach the TLD, where we stop.
 // For example, a.b.blah.com, we would probe
 //   - a.b.blah.com
 //   - .a.b.blah.com (TODO should we check this first or second?)
 //   - .b.blah.com
 //   - .blah.com
 // There are some alternative datastructures we could try, like a
 // search/prefix trie, where we reverse the hostname and query for all
 // keys that are a prefix of our hostname.  I think the hash probing
 // should be fast and simple enough for now.
 std::string CookieMonster::GetCookiesWithOptions(const GURL& url,
                                                  const CookieOptions& options) {
+  DCHECK(CalledOnValidThread());
   AutoLock autolock(lock_);
   InitIfNecessary();
 
   if (!HasCookieableScheme(url)) {
     return std::string();
   }
 
   // Get the cookies for this host and its domain(s).
   std::vector<CanonicalCookie*> cookies;
   FindCookiesForHostAndDomain(url, options, &cookies);
@@ skipping 12 matching lines @@
     cookie_line += (*it)->Value();
   }
 
   COOKIE_DLOG(INFO) << "GetCookies() result: " << cookie_line;
 
   return cookie_line;
 }
 
 void CookieMonster::DeleteCookie(const GURL& url,
                                  const std::string& cookie_name) {
+  DCHECK(CalledOnValidThread());
   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;
@@ skipping 11 matching lines @@
 
   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);
   }
 }
 
 CookieMonster::CookieList CookieMonster::GetAllCookies() {
+  DCHECK(CalledOnValidThread());
   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(),
                         CookieMapItPair(cookies_.begin(), cookies_.end()),
                         NULL);
 
   CookieList cookie_list;
   for (CookieMap::iterator it = cookies_.begin(); it != cookies_.end(); ++it)
     cookie_list.push_back(CookieListPair(it->first, *it->second));
 
   return cookie_list;
 }
 
 CookieMonster::CookieList CookieMonster::GetAllCookiesForURL(const GURL& url) {
+  DCHECK(CalledOnValidThread());
   AutoLock autolock(lock_);
   InitIfNecessary();
 
   return InternalGetAllCookiesForURL(url);
 }
 
 void CookieMonster::FindCookiesForHostAndDomain(
     const GURL& url,
     const CookieOptions& options,
     std::vector<CanonicalCookie*>* cookies) {
@@ skipping 477 matching lines @@
   return true;
 }
 
 std::string CookieMonster::CanonicalCookie::DebugString() const {
   return StringPrintf("name: %s value: %s path: %s creation: %" PRId64,
                       name_.c_str(), value_.c_str(), path_.c_str(),
                       static_cast<int64>(creation_date_.ToTimeT()));
 }
 
 }  // namespace