Break out histogram counter variables as CookieMonster instance variables.

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 95 matching lines @@
   enable_file_scheme_ = true;
 }
 
 CookieMonster::CookieMonster(PersistentCookieStore* store, Delegate* delegate)
     : initialized_(false),
       store_(store),
       last_access_threshold_(
           TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)),
       delegate_(delegate),
       last_statistic_record_time_(Time::Now()) {
+  InitializeHistograms();
   SetDefaultCookieableSchemes();
 }
 
 CookieMonster::~CookieMonster() {
   DeleteAll(false);
 }
 
+// Initialize all histogram counter variables used in this class.
+//
+// Normal histogram usage involves using the macros defined in
+// histogram.h, which automatically takes care of declaring these
+// variables (as statics), initializing them, and accumulating into
+// them, all from a single entry point.  Unfortunately, that solution
+// doesn't work for the CookieMonster, as it's vulnerable to races between
+// separate threads executing the same functions and hence initializing the
+// same static variables.  There isn't a race danger in the histogram
+// accumulation calls; they are written to be resilient to simultaneous
+// calls from multiple threads.
+//
+// The solution taken here is to have per-CookieMonster instance
+// variables that are constructed during CookieMonster construction.
+// Note that these variables refer to the same underlying histogram,
+// so we still race (but safely) with other CookieMonster instances
+// for accumulation.
+//
+// To do this we've expanded out the individual histogram macros calls,
+// with declarations of the variables in the class decl, initialization here
+// (done from the class constructor) and direct calls to the accumulation
+// methods where needed.  The specific histogram macro calls on which the
+// initialization is based are included in comments below.
+void CookieMonster::InitializeHistograms() {
+  // From UMA_HISTOGRAM_CUSTOM_COUNTS
+  histogram_expiration_duration_minutes_ = Histogram::FactoryGet(
+      "net.CookieExpirationDurationMinutes",
+      1, kMinutesInTenYears, 50,
+      Histogram::kUmaTargetedHistogramFlag);
+  histogram_between_access_interval_minutes_ = Histogram::FactoryGet(
+      "net.CookieBetweenAccessIntervalMinutes",
+      1, kMinutesInTenYears, 50,
+      Histogram::kUmaTargetedHistogramFlag);
+  histogram_evicted_last_access_minutes_ = Histogram::FactoryGet(
+      "net.CookieEvictedLastAccessMinutes",
+      1, kMinutesInTenYears, 50,
+      Histogram::kUmaTargetedHistogramFlag);
+  histogram_count_  = Histogram::FactoryGet(
+      "net.CookieCount", 1, 4000, 50,
+      Histogram::kUmaTargetedHistogramFlag);
+
+  // From UMA_HISTOGRAM_COUNTS_10000 & UMA_HISTOGRAM_CUSTOM_COUNTS
+  histogram_number_duplicate_db_cookies_ = Histogram::FactoryGet(
+      "Net.NumDuplicateCookiesInDb", 1, 10000, 50,
+      Histogram::kUmaTargetedHistogramFlag);
+
+  // From UMA_HISTOGRAM_ENUMERATION
+  histogram_cookie_deletion_cause_ = LinearHistogram::FactoryGet(
+      "net.CookieDeletionCause", 1,
+      DELETE_COOKIE_LAST_ENTRY, DELETE_COOKIE_LAST_ENTRY + 1,
+      Histogram::kUmaTargetedHistogramFlag);
+}
+
 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);
@@ skipping 22 matching lines @@
     const std::string key = cur_range_begin->first;  // Keep a copy.
     CookieMap::iterator cur_range_end = cookies_.upper_bound(key);
     prev_range_end = cur_range_end;
 
     // Ensure no equivalent cookies for this host.
     num_duplicates_trimmed +=
         TrimDuplicateCookiesForHost(key, cur_range_begin, cur_range_end);
   }
 
   // Record how many duplicates were found in the database.
-  UMA_HISTOGRAM_COUNTS_10000("Net.NumDuplicateCookiesInDb",
-                             num_duplicates_trimmed);
+  // See InitializeHistograms() for details.
+  histogram_cookie_deletion_cause_->Add(num_duplicates_trimmed);
 
   // TODO(eroman): Should also verify that there are no cookies with the same
   // creation time, since that is assumed to be unique by the rest of the code.
 }
 
 // Our strategy to find duplicates is:
 // (1) Build a map from (cookiename, cookiepath) to
 //     {list of cookies with this signature, sorted by creation time}.
 // (2) For each list with more than 1 entry, keep the cookie having the
 //     most recent creation time, and delete the others.
@@ skipping 512 matching lines @@
                                 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)) {
-    UMA_HISTOGRAM_CUSTOM_COUNTS(
-        "net.CookieExpirationDurationMinutes",
-        ((*cc)->ExpiryDate() - creation_time).InMinutes(),
-        1, kMinutesInTenYears, 50);
+    // See InitializeHistograms() for details.
+    histogram_expiration_duration_minutes_->Add(
+        ((*cc)->ExpiryDate() - creation_time).InMinutes());
     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);
 
@@ skipping 16 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);
+  // See InitializeHistograms() for details.
+  histogram_between_access_interval_minutes_->Add(
+      (current - cc->LastAccessDate()).InMinutes());
 
   cc->SetLastAccessDate(current);
   if (cc->IsPersistent() && store_)
     store_->UpdateCookieAccessTime(*cc);
 }
 
 void CookieMonster::InternalDeleteCookie(CookieMap::iterator it,
                                          bool sync_to_store,
                                          DeletionCause deletion_cause) {
   lock_.AssertAcquired();
 
-  UMA_HISTOGRAM_ENUMERATION("net.CookieDeletionCause", deletion_cause,
-                            DELETE_COOKIE_LAST_ENTRY);
+  // See InitializeHistograms() for details.
+  histogram_cookie_deletion_cause_->Add(deletion_cause);
 
   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 76 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) {
-      UMA_HISTOGRAM_CUSTOM_COUNTS(
-          "net.CookieEvictedLastAccessMinutes",
-          (current - cookie_its[i]->second->LastAccessDate()).InMinutes(),
-          1, kMinutesInTenYears, 50);
+      // See InitializeHistograms() for details.
+      histogram_evicted_last_access_minutes_->Add(
+          (current - cookie_its[i]->second->LastAccessDate()).InMinutes());
       InternalDeleteCookie(cookie_its[i], true, DELETE_COOKIE_EVICTED);
     }
 
     num_deleted += num_purge;
   }
 
   return num_deleted;
 }
 
 int CookieMonster::GarbageCollectExpired(
@@ skipping 361 matching lines @@
 // 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);
+    // See InitializeHistograms() for details.
+    histogram_count_->Add(cookies_.size());
     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),
@@ skipping 375 matching lines @@
 
 std::string CookieMonster::CanonicalCookie::DebugString() const {
   return 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