Initial commit of CookieMonster statistics.

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 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 "base/basictypes.h"
 #include "base/format_macros.h"
-#include "base/histogram.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.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"
 #include "net/base/registry_controlled_domain.h"
 
 // #define COOKIE_LOGGING_ENABLED
 #ifdef COOKIE_LOGGING_ENABLED
 #define COOKIE_DLOG(severity) DLOG_IF(INFO, 1)
 #else
 #define COOKIE_DLOG(severity) DLOG_IF(INFO, 0)
 #endif
 
 using base::Time;
 using base::TimeDelta;
 
+static const int kMinutesInTenYears = 10 * 365 * 24 * 60;
+
 namespace net {
 
 namespace {
 
 // 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.
 const size_t kNumCookiesPerHost      = 70;  // ~50 cookies
@@ skipping 22 matching lines @@
 // static
 void CookieMonster::EnableFileScheme() {
   enable_file_scheme_ = true;
 }
 
 CookieMonster::CookieMonster(PersistentCookieStore* store, Delegate* delegate)
     : initialized_(false),
       store_(store),
       last_access_threshold_(
           TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)),
-      delegate_(delegate) {
+      delegate_(delegate),
+      last_statistic_record_time_(Time::Now()) {
   SetDefaultCookieableSchemes();
 }
 
 CookieMonster::~CookieMonster() {
   DeleteAll(false);
 }
 
 void CookieMonster::InitStore() {
   DCHECK(store_) << "Store must exist to initialize";
 
@@ skipping 110 matching lines @@
                                key.c_str(),
                                signature.first.c_str(),
                                signature.second.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 (CookieList::iterator dupes_it = dupes.begin();
          dupes_it != dupes.end();
          ++dupes_it) {
-      InternalDeleteCookie(*dupes_it, true /*sync_to_store*/);
+      InternalDeleteCookie(*dupes_it, true /*sync_to_store*/,
+                           kDeleteCookieDuplicateInBackingStore);
     }
   }
 
   return num_duplicates;
 }
 
 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 403 matching lines @@
   if (DeleteAnyEquivalentCookie(cookie_domain, **cc,
                                 options.exclude_httponly())) {
     COOKIE_DLOG(INFO) << "SetCookie() not clobbering httponly cookie";
     return false;
   }
 
   COOKIE_DLOG(INFO) << "SetCookie() cc: " << (*cc)->DebugString();
 
   // Realize that we might be setting an expired cookie, and the only point
   // was to delete the cookie which we've already done.
-  if (!(*cc)->IsExpired(creation_time))
+  if (!(*cc)->IsExpired(creation_time)) {
+    UMA_HISTOGRAM_CUSTOM_COUNTS(
+        "net.CookieExpirationDurationMinutes",
+        ((*cc)->ExpiryDate() - creation_time).InMinutes(),
+        1, kMinutesInTenYears, 50);
     InternalInsertCookie(cookie_domain, cc->release(), true);
+  }
 
   // We assume that hopefully setting a cookie will be less common than
   // querying a cookie.  Since setting a cookie can put us over our limits,
   // make sure that we garbage collect...  We can also make the assumption that
   // if a cookie was set, in the common case it will be used soon after,
   // and we will purge the expired cookies in GetCookies().
   GarbageCollect(creation_time, cookie_domain);
 
   return true;
 }
@@ skipping 14 matching lines @@
   lock_.AssertAcquired();
 
   // 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;
 
+  UMA_HISTOGRAM_CUSTOM_COUNTS(
+      "net.CookieBetweenAccessIntervalMinutes",
+      (current - cc->LastAccessDate()).InMinutes(),
+      1, kMinutesInTenYears, 50);
+
   cc->SetLastAccessDate(current);
   if (cc->IsPersistent() && store_)
     store_->UpdateCookieAccessTime(*cc);
 }
 
 void CookieMonster::InternalDeleteCookie(CookieMap::iterator it,
-                                         bool sync_to_store) {
+                                         bool sync_to_store,
+                                         DeletionCause deletion_cause) {
   lock_.AssertAcquired();
 
+  UMA_HISTOGRAM_ENUMERATION("net.CookieDeletionCause", deletion_cause,
+                            kDeleteCookieLastEntry);
+
   CanonicalCookie* cc = it->second;
   COOKIE_DLOG(INFO) << "InternalDeleteCookie() cc: " << cc->DebugString();
   if (cc->IsPersistent() && store_ && sync_to_store)
     store_->DeleteCookie(*cc);
   if (delegate_.get())
     delegate_->OnCookieChanged(it->first, *cc, true);
   cookies_.erase(it);
   delete cc;
 }
 
@@ skipping 11 matching lines @@
     ++its.first;
 
     if (ecc.IsEquivalent(*cc)) {
       // We should never have more than one equivalent cookie, since they should
       // overwrite each other.
       CHECK(!found_equivalent_cookie) <<
           "Duplicate equivalent cookies found, cookie store is corrupted.";
       if (skip_httponly && cc->IsHttpOnly()) {
         skipped_httponly = true;
       } else {
-        InternalDeleteCookie(curit, true);
+        InternalDeleteCookie(curit, true, kDeleteCookieOverwrite);
       }
       found_equivalent_cookie = true;
     }
   }
   return skipped_httponly;
 }
 
 int CookieMonster::GarbageCollect(const Time& current,
                                   const std::string& key) {
   lock_.AssertAcquired();
@@ skipping 42 matching lines @@
 
   // If the range still has too many cookies, delete the least recently used.
   if (cookie_its.size() > num_max) {
     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;
 
     std::partial_sort(cookie_its.begin(), cookie_its.begin() + num_purge,
                       cookie_its.end(), LRUCookieSorter);
-    for (size_t i = 0; i < num_purge; ++i)
-      InternalDeleteCookie(cookie_its[i], true);
+    for (size_t i = 0; i < num_purge; ++i) {
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "net.CookieEvictedLastAccessMinutes",
+          (current - cookie_its[i]->second->LastAccessDate()).InMinutes(),
+          1, kMinutesInTenYears, 50);
+      InternalDeleteCookie(cookie_its[i], true, kDeleteCookieEvicted);
+    }
 
     num_deleted += num_purge;
   }
 
   return num_deleted;
 }
 
 int CookieMonster::GarbageCollectExpired(
     const Time& current,
     const CookieMapItPair& itpair,
     std::vector<CookieMap::iterator>* cookie_its) {
   lock_.AssertAcquired();
 
   int num_deleted = 0;
   for (CookieMap::iterator it = itpair.first, end = itpair.second; it != end;) {
     CookieMap::iterator curit = it;
     ++it;
 
     if (curit->second->IsExpired(current)) {
-      InternalDeleteCookie(curit, true);
+      InternalDeleteCookie(curit, true, kDeleteCookieExpired);
       ++num_deleted;
     } else if (cookie_its) {
       cookie_its->push_back(curit);
     }
   }
 
   return num_deleted;
 }
 
 int CookieMonster::DeleteAll(bool sync_to_store) {
   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);
+    InternalDeleteCookie(curit, sync_to_store,
+                         sync_to_store ? kDeleteCookieExplicit :
+                             kDeleteCookieDontRecord /* Destruction. */);
     ++num_deleted;
   }
 
   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;
   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);
+      InternalDeleteCookie(curit, sync_to_store, kDeleteCookieExplicit);
       ++num_deleted;
     }
   }
 
   return num_deleted;
 }
 
 int CookieMonster::DeleteAllCreatedAfter(const Time& delete_begin,
                                          bool sync_to_store) {
   return DeleteAllCreatedBetween(delete_begin, Time(), sync_to_store);
 }
 
 int CookieMonster::DeleteAllForURL(const GURL& url,
                                    bool sync_to_store) {
   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);
+    InternalDeleteCookie(curit, sync_to_store, kDeleteCookieExplicit);
   }
   return num_deleted;
 }
 
 bool CookieMonster::DeleteCookie(const std::string& domain,
                                  const CanonicalCookie& cookie,
                                  bool sync_to_store) {
   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);
+      InternalDeleteCookie(its.first, sync_to_store, kDeleteCookieExplicit);
       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,
@@ skipping 73 matching lines @@
     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);
+    if (matching_cookies.find(curit->second) != matching_cookies.end()) {
+      InternalDeleteCookie(curit, true, kDeleteCookieExplicit);
+    }
   }
 }
 
 CookieMonster::CookieList CookieMonster::GetAllCookies() {
   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
@@ skipping 21 matching lines @@
 }
 
 void CookieMonster::FindCookiesForHostAndDomain(
     const GURL& url,
     const CookieOptions& options,
     std::vector<CanonicalCookie*>* cookies) {
   lock_.AssertAcquired();
 
   const Time current_time(CurrentTime());
 
+  // Probe to save statistics relatively frequently.  We do it here rather
+  // than in the set path as many websites won't set cookies, and we
+  // want to collect statistics whenever the browser's being used.
+  RecordPeriodicStats(current_time);
+
   // Query for the full host, For example: 'a.c.blah.com'.
   std::string key(url.host());
   FindCookiesForKey(key, url, options, current_time, cookies);
 
   // See if we can search for domain cookies, i.e. if the host has a TLD + 1.
   const std::string domain(GetEffectiveDomain(url.scheme(), key));
   if (domain.empty())
     return;
   DCHECK_LE(domain.length(), key.length());
   DCHECK_EQ(0, key.compare(key.length() - domain.length(), domain.length(),
@@ skipping 22 matching lines @@
   bool secure = url.SchemeIsSecure();
 
   for (CookieMapItPair its = cookies_.equal_range(key);
        its.first != its.second; ) {
     CookieMap::iterator curit = its.first;
     CanonicalCookie* cc = curit->second;
     ++its.first;
 
     // If the cookie is expired, delete it.
     if (cc->IsExpired(current)) {
-      InternalDeleteCookie(curit, true);
+      InternalDeleteCookie(curit, true, kDeleteCookieExpired);
       continue;
     }
 
     // Filter out HttpOnly cookies, per options.
     if (options.exclude_httponly() && cc->IsHttpOnly())
       continue;
 
     // Filter out secure cookies unless we're https.
     if (!secure && cc->IsSecure())
       continue;
@@ skipping 54 matching lines @@
   DCHECK_EQ(0, key.compare(key.length() - domain.length(), domain.length(),
                            domain));
   for (key = "." + key; key.length() > domain.length(); ) {
     FindRawCookies(key, secure, url.path(), &cookie_list);
     const size_t next_dot = key.find('.', 1);  // Skip over leading dot.
     key.erase(0, next_dot);
   }
   return cookie_list;
 }
 
+// Test to see if stats should be recorded, and record them if so.
+// The goal here is to get sampling for the average browser-hour of
+// activity.  We won't take samples when the web isn't being surfed,
+// and when the web is being surfed, we'll take samples about every
+// kRecordStatisticsIntervalSeconds.
+// last_statistic_record_time_ is initialized to Now() rather than null
+// in the constructor so that we won't take statistics right after
+// startup, to avoid bias from browsers that are started but not used.
+void CookieMonster::RecordPeriodicStats(const base::Time &current_time) {
+  const base::TimeDelta kRecordStatisticsIntervalTime(
+      base::TimeDelta::FromSeconds(kRecordStatisticsIntervalSeconds));
+
+  if (current_time - last_statistic_record_time_ >
+      kRecordStatisticsIntervalTime) {
+    UMA_HISTOGRAM_CUSTOM_COUNTS("net.CookieCount", cookies_.size(),
+                                1, 4000, 50);
+    last_statistic_record_time_ = current_time;
+  }
+}
+
 CookieMonster::ParsedCookie::ParsedCookie(const std::string& cookie_line)
     : is_valid_(false),
       path_index_(0),
       domain_index_(0),
       expires_index_(0),
       maxage_index_(0),
       secure_index_(0),
       httponly_index_(0) {
 
   if (cookie_line.size() > kMaxCookieSize) {
@@ skipping 346 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