Small cleanup for previous histogram checkin...

base/metrics/histogram.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.
 
 // Histogram is an object that aggregates statistics, and can summarize them in
 // various forms, including ASCII graphical, HTML, and numerically (as a
 // vector of numbers corresponding to each of the aggregating buckets).
 // See header file for details and examples.
 
 #include "base/metrics/histogram.h"
@@ skipping 68 matching lines @@
 
   // Defensive code.
   if (minimum < 1)
     minimum = 1;
   if (maximum > kSampleType_MAX - 1)
     maximum = kSampleType_MAX - 1;
 
   if (!StatisticsRecorder::FindHistogram(name, &histogram)) {
     histogram = new Histogram(name, minimum, maximum, bucket_count);
     histogram->InitializeBucketRange();
-    StatisticsRecorder::Register(&histogram);
+    StatisticsRecorder::RegisterOrDiscardDuplicate(&histogram);
   }
 
   DCHECK_EQ(HISTOGRAM, histogram->histogram_type());
   DCHECK(histogram->HasConstructorArguments(minimum, maximum, bucket_count));
   histogram->SetFlags(flags);
   return histogram;
 }
 
 scoped_refptr<Histogram> Histogram::FactoryTimeGet(const std::string& name,
                                                    TimeDelta minimum,
@@ skipping 308 matching lines @@
   if (StatisticsRecorder::dump_on_exit()) {
     std::string output;
     WriteAscii(true, "\n", &output);
     LOG(INFO) << output;
   }
 
   // Just to make sure most derived class did this properly...
   DCHECK(ValidateBucketRanges());
 }
 
-bool Histogram::PrintEmptyBucket(size_t index) const {
-  return true;
-}
-
 // Calculate what range of values are held in each bucket.
 // We have to be careful that we don't pick a ratio between starting points in
 // consecutive buckets that is sooo small, that the integer bounds are the same
 // (effectively making one bucket get no values).  We need to avoid:
 //   ranges_[i] == ranges_[i + 1]
 // To avoid that, we just do a fine-grained bucket width as far as we need to
 // until we get a ratio that moves us along at least 2 units at a time.  From
 // that bucket onward we do use the exponential growth of buckets.
 void Histogram::InitializeBucketRange() {
   double log_max = log(static_cast<double>(declared_max()));
@@ skipping 15 matching lines @@
       current = next;
     else
       ++current;  // Just do a narrow bucket, and keep trying.
     SetBucketRange(bucket_index, current);
   }
   ResetRangeChecksum();
 
   DCHECK_EQ(bucket_count(), bucket_index);
 }
 
+bool Histogram::PrintEmptyBucket(size_t index) const {
+  return true;
+}
+
 size_t Histogram::BucketIndex(Sample value) const {
   // Use simple binary search.  This is very general, but there are better
   // approaches if we knew that the buckets were linearly distributed.
   DCHECK_LE(ranges(0), value);
   DCHECK_GT(ranges(bucket_count()), value);
   size_t under = 0;
   size_t over = bucket_count();
   size_t mid;
 
   do {
@@ skipping 317 matching lines @@
   if (minimum < 1)
     minimum = 1;
   if (maximum > kSampleType_MAX - 1)
     maximum = kSampleType_MAX - 1;
 
   if (!StatisticsRecorder::FindHistogram(name, &histogram)) {
     LinearHistogram* linear_histogram =
         new LinearHistogram(name, minimum, maximum, bucket_count);
     linear_histogram->InitializeBucketRange();
     histogram = linear_histogram;
-    StatisticsRecorder::Register(&histogram);
+    StatisticsRecorder::RegisterOrDiscardDuplicate(&histogram);
   }
 
   DCHECK_EQ(LINEAR_HISTOGRAM, histogram->histogram_type());
   DCHECK(histogram->HasConstructorArguments(minimum, maximum, bucket_count));
   histogram->SetFlags(flags);
   return histogram;
 }
 
 scoped_refptr<Histogram> LinearHistogram::FactoryTimeGet(
     const std::string& name,
@@ skipping 71 matching lines @@
 //------------------------------------------------------------------------------
 
 scoped_refptr<Histogram> BooleanHistogram::FactoryGet(const std::string& name,
                                                       Flags flags) {
   scoped_refptr<Histogram> histogram(NULL);
 
   if (!StatisticsRecorder::FindHistogram(name, &histogram)) {
     BooleanHistogram* boolean_histogram = new BooleanHistogram(name);
     boolean_histogram->InitializeBucketRange();
     histogram = boolean_histogram;
-    StatisticsRecorder::Register(&histogram);
+    StatisticsRecorder::RegisterOrDiscardDuplicate(&histogram);
   }
 
   DCHECK_EQ(BOOLEAN_HISTOGRAM, histogram->histogram_type());
   histogram->SetFlags(flags);
   return histogram;
 }
 
 Histogram::ClassType BooleanHistogram::histogram_type() const {
   return BOOLEAN_HISTOGRAM;
 }
@@ skipping 26 matching lines @@
     // Note that we pushed a 0 in above, so for defensive code....
     ranges.push_back(1);  // Put in some data so we can index to [1].
   }
 
   DCHECK_LT(ranges.back(), kSampleType_MAX);
 
   if (!StatisticsRecorder::FindHistogram(name, &histogram)) {
     CustomHistogram* custom_histogram = new CustomHistogram(name, ranges);
     custom_histogram->InitializedCustomBucketRange(ranges);
     histogram = custom_histogram;
-    StatisticsRecorder::Register(&histogram);
+    StatisticsRecorder::RegisterOrDiscardDuplicate(&histogram);
   }
 
   DCHECK_EQ(histogram->histogram_type(), CUSTOM_HISTOGRAM);
   DCHECK(histogram->HasConstructorArguments(ranges[1], ranges.back(),
                                             ranges.size()));
   histogram->SetFlags(flags);
   return histogram;
 }
 
 Histogram::ClassType CustomHistogram::histogram_type() const {
@@ skipping 72 matching lines @@
   base::AutoLock auto_lock(*lock_);
   return NULL != histograms_;
 }
 
 // Note: We can't accept a ref_ptr to |histogram| because we *might* not keep a
 // reference, and we are called while in the Histogram constructor. In that
 // scenario, a ref_ptr would have incremented the ref count when the histogram
 // was passed to us, decremented it when we returned, and the instance would be
 // destroyed before assignment (when value was returned by new).
 // static
-void StatisticsRecorder::Register(scoped_refptr<Histogram>* histogram) {
+void StatisticsRecorder::RegisterOrDiscardDuplicate(
+    scoped_refptr<Histogram>* histogram) {
   DCHECK((*histogram)->HasValidRangeChecksum());
   if (lock_ == NULL)
     return;
   base::AutoLock auto_lock(*lock_);
   if (!histograms_)
     return;
   const std::string name = (*histogram)->histogram_name();
   HistogramMap::iterator it = histograms_->find(name);
   // Avoid overwriting a previous registration.
   if (histograms_->end() == it)
@@ skipping 92 matching lines @@
 }
 
 // static
 StatisticsRecorder::HistogramMap* StatisticsRecorder::histograms_ = NULL;
 // static
 base::Lock* StatisticsRecorder::lock_ = NULL;
 // static
 bool StatisticsRecorder::dump_on_exit_ = false;
 
 }  // namespace base