No upper cookie limit. Only per host enforced.

net/base/cookie_monster.cc

 // Copyright (c) 2006-2008 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 57 matching lines @@
 
 namespace net {
 
 // Cookie garbage collection thresholds.  Based off of the Mozilla defaults.
 // It might seem scary to have a high purge value, but really it's not.  You
 // just make sure that you increase the max to cover the increase in purge,
 // and we would have been purging the same amount of cookies.  We're just
 // going through the garbage collection process less often.
 static const size_t kNumCookiesPerHost      = 70;  // ~50 cookies
 static const size_t kNumCookiesPerHostPurge = 20;
-static const size_t kNumCookiesTotal        = 1100;  // ~1000 cookies
-static const size_t kNumCookiesTotalPurge   = 100;
 
 // Default minimum delay after updating a cookie's LastAccessDate before we
 // will update it again.
 static const int kDefaultAccessUpdateThresholdSeconds = 60;
 
 // static
 bool CookieMonster::enable_file_scheme_ = false;
 
 // static
 void CookieMonster::EnableFileScheme() {
   enable_file_scheme_ = true;
 }
 
 CookieMonster::CookieMonster()
     : initialized_(false),
       store_(NULL),
       last_access_threshold_(
           TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)) {
 }
 
 CookieMonster::CookieMonster(PersistentCookieStore* store)
     : initialized_(false),
       store_(store),
       last_access_threshold_(
           TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)) {
 }
 
 CookieMonster::~CookieMonster() {
+  GarbageCollectExpired(Time::Now(),
+                        CookieMapItPair(cookies_.begin(), cookies_.end()),
+                        NULL);
   DeleteAll(false);
 }
 
 void CookieMonster::InitStore() {
   DCHECK(store_) << "Store must exist to initialize";
 
   // 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<KeyedCanonicalCookie> 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(kNumCookiesTotal);
   store_->Load(&cookies);
   for (std::vector<KeyedCanonicalCookie>::const_iterator it = cookies.begin();
        it != cookies.end(); ++it) {
     InternalInsertCookie(it->first, it->second, false);
   }
+  GarbageCollectExpired(Time::Now(),
+                        CookieMapItPair(cookies_.begin(), cookies_.end()),
+                        NULL);
 }
 
 // The system resolution is not high enough, so we can have multiple
 // set cookies that result in the same system time.  When this happens, we
 // increment by one Time unit.  Let's hope computers don't get too fast.
 Time CookieMonster::CurrentTime() {
   return std::max(Time::Now(),
       Time::FromInternalValue(last_time_seen_.ToInternalValue() + 1));
 }
 
@@ skipping 429 matching lines @@
                                   const std::string& key) {
   int num_deleted = 0;
 
   // Collect garbage for this key.
   if (cookies_.count(key) > kNumCookiesPerHost) {
     COOKIE_DLOG(INFO) << "GarbageCollect() key: " << key;
     num_deleted += GarbageCollectRange(current, cookies_.equal_range(key),
         kNumCookiesPerHost, kNumCookiesPerHostPurge);
   }
 
-  // Collect garbage for everything.
-  if (cookies_.size() > kNumCookiesTotal) {
-    COOKIE_DLOG(INFO) << "GarbageCollect() everything";
-    num_deleted += GarbageCollectRange(current,
-        CookieMapItPair(cookies_.begin(), cookies_.end()), kNumCookiesTotal,
-        kNumCookiesTotalPurge);
-  }
-
   return num_deleted;
 }
 
 static bool LRUCookieSorter(const CookieMonster::CookieMap::iterator& it1,
                             const CookieMonster::CookieMap::iterator& it2) {
   // Cookies accessed less recently should be deleted first.
   if (it1->second->LastAccessDate() != it2->second->LastAccessDate())
     return it1->second->LastAccessDate() < it2->second->LastAccessDate();
 
   // In rare cases we might have two cookies with identical last access times.
@@ skipping 520 matching lines @@
 }
 
 std::string CookieMonster::CanonicalCookie::DebugString() const {
   return StringPrintf("name: %s value: %s path: %s creation: %llu",
                       name_.c_str(), value_.c_str(), path_.c_str(),
                       creation_date_.ToTimeT());
 }
 
 }  // namespace