Update cookie expiry policy to attempt to avoid deleting "in-use" cookies. S...

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 50 matching lines @@
 #define COOKIE_DLOG(severity) DLOG_IF(INFO, 1)
 #else
 #define COOKIE_DLOG(severity) DLOG_IF(INFO, 0)
 #endif
 
 using base::Time;
 using base::TimeDelta;
 
 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        = 3300;  // ~3000 cookies
-static const size_t kNumCookiesTotalPurge   = 300;
+static const size_t kMaxCookiesPerHost = 50;
+static const size_t kMaxCookiesTotal = 2000;
+static const int kMaxCookieAgeSeconds = 30 * 24 * 60 * 60;  // 30 days
+static const double kPurgeOverageFactor = 1.1;
 
 // 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() {
@@ skipping 21 matching lines @@
 }
 
 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);
+  // This prevents multiple vector growth / copies as we append cookies.  Note
+  // that if we have too many recent cookies, we'll still cross this limit;
+  // however, since std::vector<> grows by 50% when inserting a new element
+  // into a full vector, we should have few of these additional resizes.
+  cookies.reserve(static_cast<int>(kMaxCookiesTotal * kPurgeOverageFactor));
+  store_->Load(&cookies, &least_recent_access_);
   for (std::vector<KeyedCanonicalCookie>::const_iterator it = cookies.begin();
        it != cookies.end(); ++it) {
     InternalInsertCookie(it->first, it->second, false);
   }
 }
 
 void CookieMonster::SetDefaultCookieableSchemes() {
   // Note: file must be the last scheme.
   static const char* kDefaultCookieableSchemes[] = { "http", "https", "file" };
   int num_schemes = enable_file_scheme_ ? 3 : 2;
@@ skipping 375 matching lines @@
        iter != cookies.end(); ++iter)
     SetCookieWithOptions(url, *iter, options);
 }
 
 void CookieMonster::InternalInsertCookie(const std::string& key,
                                          CanonicalCookie* cc,
                                          bool sync_to_store) {
   if (cc->IsPersistent() && store_ && sync_to_store)
     store_->AddCookie(key, *cc);
   cookies_.insert(CookieMap::value_type(key, cc));
+  const Time last_access = cc->LastAccessDate();
+  if (least_recent_access_.is_null() || (last_access < least_recent_access_))
+    least_recent_access_ = last_access;
 }
 
 void CookieMonster::InternalUpdateCookieAccessTime(CanonicalCookie* cc) {
   // Based off the Mozilla code.  When a cookie has been accessed recently,
   // don't bother updating its access time again.  This reduces the number of
   // updates we do during pageload, which in turn reduces the chance our storage
   // backend will hit its batch thresholds and be forced to update.
   const Time current = Time::Now();
   if ((current - cc->LastAccessDate()) < last_access_threshold_)
     return;
 
   cc->SetLastAccessDate(current);
   if (cc->IsPersistent() && store_)
     store_->UpdateCookieAccessTime(*cc);
+  if (least_recent_access_.is_null() || (current < least_recent_access_))
+    least_recent_access_ = current;
 }
 
 void CookieMonster::InternalDeleteCookie(CookieMap::iterator it,
                                          bool sync_to_store) {
   CanonicalCookie* cc = it->second;
   COOKIE_DLOG(INFO) << "InternalDeleteCookie() cc: " << cc->DebugString();
   if (cc->IsPersistent() && store_ && sync_to_store)
     store_->DeleteCookie(*cc);
   cookies_.erase(it);
   delete cc;
@@ skipping 29 matching lines @@
     }
   }
   return skipped_httponly;
 }
 
 int CookieMonster::GarbageCollect(const Time& current,
                                   const std::string& key) {
   int num_deleted = 0;
 
   // Collect garbage for this key.
-  if (cookies_.count(key) > kNumCookiesPerHost) {
+  if (cookies_.count(key) >= (kMaxCookiesPerHost * kPurgeOverageFactor)) {
     COOKIE_DLOG(INFO) << "GarbageCollect() key: " << key;
     num_deleted += GarbageCollectRange(current, cookies_.equal_range(key),
-        kNumCookiesPerHost, kNumCookiesPerHostPurge);
+        kMaxCookiesPerHost, TimeDelta());
   }
 
   // Collect garbage for everything.
-  if (cookies_.size() > kNumCookiesTotal) {
+  if ((cookies_.size() >= (kMaxCookiesTotal * kPurgeOverageFactor)) &&
+      (least_recent_access_.is_null() ||
+       ((current - least_recent_access_) >=
+           TimeDelta::FromSeconds(static_cast<int>(kMaxCookieAgeSeconds *
+               kPurgeOverageFactor))))) {
     COOKIE_DLOG(INFO) << "GarbageCollect() everything";
     num_deleted += GarbageCollectRange(current,
-        CookieMapItPair(cookies_.begin(), cookies_.end()), kNumCookiesTotal,
-        kNumCookiesTotalPurge);
+        CookieMapItPair(cookies_.begin(), cookies_.end()), kMaxCookiesTotal,
+        TimeDelta::FromSeconds(kMaxCookieAgeSeconds));
   }
 
   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.
   // To preserve the stability of the sort, in these cases prefer to delete
   // older cookies over newer ones.  CreationDate() is guaranteed to be unique.
   return it1->second->CreationDate() < it2->second->CreationDate();
 }
 
 int CookieMonster::GarbageCollectRange(const Time& current,
                                        const CookieMapItPair& itpair,
-                                       size_t num_max,
-                                       size_t num_purge) {
+                                       size_t max_cookies,
+                                       const TimeDelta& purge_age) {
   // First, delete anything that's expired.
   std::vector<CookieMap::iterator> cookie_its;
   int num_deleted = GarbageCollectExpired(current, itpair, &cookie_its);
 
   // If the range still has too many cookies, delete the least recently used.
-  if (cookie_its.size() > num_max) {
+  if (cookie_its.size() > max_cookies) {
     COOKIE_DLOG(INFO) << "GarbageCollectRange() Deep Garbage Collect.";
-    // Purge down to (|num_max| - |num_purge|) total cookies.
-    DCHECK(num_purge <= num_max);
-    num_purge += cookie_its.size() - num_max;
+    // Purge down to |max_cookies| total cookies.
+    size_t num_purge = cookie_its.size() - max_cookies;
 
-    std::partial_sort(cookie_its.begin(), cookie_its.begin() + num_purge,
-                      cookie_its.end(), LRUCookieSorter);
-    for (size_t i = 0; i < num_purge; ++i)
+    std::partial_sort(cookie_its.begin(),
+        cookie_its.begin() + std::min(cookie_its.size(), num_purge + 1),
+        cookie_its.end(), LRUCookieSorter);
+    const bool only_purge_old_cookies = (purge_age != TimeDelta());
+    for (size_t i = 0; i < num_purge;) {
+      // Stop purging once we've run out of cookies that are "old enough".
+      if (only_purge_old_cookies &&
+          ((current - cookie_its[i]->second->LastAccessDate()) < purge_age))
+        return num_deleted + i;
+
       InternalDeleteCookie(cookie_its[i], true);
 
+      // Update least_recent_access_ now that we've deleted the LRU cookie.
+      ++i;
+      if (i < cookie_its.size())
+        least_recent_access_ = cookie_its[i]->second->LastAccessDate();
+    }
+
     num_deleted += num_purge;
   }
 
   return num_deleted;
 }
 
 int CookieMonster::GarbageCollectExpired(
     const Time& current,
     const CookieMapItPair& itpair,
     std::vector<CookieMap::iterator>* cookie_its) {
@@ skipping 18 matching lines @@
   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;
   }
 
+  least_recent_access_ = Time();
+
   return num_deleted;
 }
 
 int CookieMonster::DeleteAllCreatedBetween(const Time& delete_begin,
                                            const Time& delete_end,
                                            bool sync_to_store) {
   AutoLock autolock(lock_);
   InitIfNecessary();
 
   int num_deleted = 0;
@@ skipping 445 matching lines @@
   return true;
 }
 
 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