[UMA] Remove redundant bucket_count variable from base::Histogram.

base/metrics/histogram.cc

 // Copyright (c) 2012 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 79 matching lines @@
                                      size_t bucket_count,
                                      int32 flags) {
   bool valid_arguments =
       InspectConstructionArguments(name, &minimum, &maximum, &bucket_count);
   DCHECK(valid_arguments);
 
   HistogramBase* histogram = StatisticsRecorder::FindHistogram(name);
   if (!histogram) {
     // To avoid racy destruction at shutdown, the following will be leaked.
     BucketRanges* ranges = new BucketRanges(bucket_count + 1);
-    InitializeBucketRanges(minimum, maximum, bucket_count, ranges);
+    InitializeBucketRanges(minimum, maximum, ranges);
     const BucketRanges* registered_ranges =
         StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
 
     Histogram* tentative_histogram =
-        new Histogram(name, minimum, maximum, bucket_count, registered_ranges);
+        new Histogram(name, minimum, maximum, registered_ranges);
 
     tentative_histogram->SetFlags(flags);
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
 
   DCHECK_EQ(HISTOGRAM, histogram->GetHistogramType());
   CHECK(histogram->HasConstructionArguments(minimum, maximum, bucket_count));
   return histogram;
 }
@@ skipping 20 matching lines @@
 // 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.
 //
 // static
 void Histogram::InitializeBucketRanges(Sample minimum,
                                        Sample maximum,
-                                       size_t bucket_count,
                                        BucketRanges* ranges) {
-  DCHECK_EQ(ranges->size(), bucket_count + 1);
   double log_max = log(static_cast<double>(maximum));
   double log_ratio;
   double log_next;
   size_t bucket_index = 1;
   Sample current = minimum;
   ranges->set_range(bucket_index, current);
+  size_t bucket_count = ranges->BucketCount();
   while (bucket_count > ++bucket_index) {
     double log_current;
     log_current = log(static_cast<double>(current));
     // Calculate the count'th root of the range.
     log_ratio = (log_max - log_current) / (bucket_count - bucket_index);
     // See where the next bucket would start.
     log_next = log_current + log_ratio;
     Sample next;
     next = static_cast<int>(floor(exp(log_next) + 0.5));
     if (next > current)
       current = next;
     else
       ++current;  // Just do a narrow bucket, and keep trying.
     ranges->set_range(bucket_index, current);
   }
-  ranges->set_range(ranges->size() - 1, HistogramBase::kSampleType_MAX);
+  ranges->set_range(ranges->BucketCount(), HistogramBase::kSampleType_MAX);
   ranges->ResetChecksum();
 }
 
 // static
 const int Histogram::kCommonRaceBasedCountMismatch = 5;
 
 int Histogram::FindCorruption(const HistogramSamples& samples) const {
   int inconsistencies = NO_INCONSISTENCIES;
   Sample previous_range = -1;  // Bottom range is always 0.
-  for (size_t index = 0; index < bucket_count(); ++index) {
+  for (size_t index = 0; index < BucketCount(); ++index) {
     int new_range = ranges(index);
     if (previous_range >= new_range)
       inconsistencies |= BUCKET_ORDER_ERROR;
     previous_range = new_range;
   }
 
   if (!bucket_ranges()->HasValidChecksum())
     inconsistencies |= RANGE_CHECKSUM_ERROR;
 
   int64 delta64 = samples.redundant_count() - samples.TotalCount();
@@ skipping 12 matching lines @@
         inconsistencies |= COUNT_LOW_ERROR;
     }
   }
   return inconsistencies;
 }
 
 Sample Histogram::ranges(size_t i) const {
   return bucket_ranges_->range(i);
 }
 
-size_t Histogram::bucket_count() const {
-  return bucket_count_;
+size_t Histogram::BucketCount() const {
+  return bucket_ranges_->BucketCount();
 }
 
 // static
 bool Histogram::InspectConstructionArguments(const string& name,
                                              Sample* minimum,
                                              Sample* maximum,
                                              size_t* bucket_count) {
   // Defensive code for backward compatibility.
   if (*minimum < 1) {
     DVLOG(1) << "Histogram: " << name << " has bad minimum: " << *minimum;
@@ skipping 19 matching lines @@
 }
 
 HistogramType Histogram::GetHistogramType() const {
   return HISTOGRAM;
 }
 
 bool Histogram::HasConstructionArguments(Sample minimum,
                                          Sample maximum,
                                          size_t bucket_count) const {
   return ((minimum == declared_min_) && (maximum == declared_max_) &&
-          (bucket_count == bucket_count_));
+          (bucket_count == BucketCount()));
 }
 
 void Histogram::Add(int value) {
   DCHECK_EQ(0, ranges(0));
-  DCHECK_EQ(kSampleType_MAX, ranges(bucket_count_));
+  DCHECK_EQ(kSampleType_MAX, ranges(BucketCount()));
 
   if (value > kSampleType_MAX - 1)
     value = kSampleType_MAX - 1;
   if (value < 0)
     value = 0;
   samples_->Accumulate(value, 1);
 }
 
 scoped_ptr<HistogramSamples> Histogram::SnapshotSamples() const {
   return SnapshotSampleVector().PassAs<HistogramSamples>();
@@ skipping 18 matching lines @@
 void Histogram::WriteAscii(string* output) const {
   WriteAsciiImpl(true, "\n", output);
 }
 
 bool Histogram::SerializeInfoImpl(Pickle* pickle) const {
   DCHECK(bucket_ranges()->HasValidChecksum());
   return pickle->WriteString(histogram_name()) &&
       pickle->WriteInt(flags()) &&
       pickle->WriteInt(declared_min()) &&
       pickle->WriteInt(declared_max()) &&
-      pickle->WriteUInt64(bucket_count()) &&
+      pickle->WriteUInt64(BucketCount()) &&
       pickle->WriteUInt32(bucket_ranges()->checksum());
 }
 
 Histogram::Histogram(const string& name,
                      Sample minimum,
                      Sample maximum,
-                     size_t bucket_count,
                      const BucketRanges* ranges)
   : HistogramBase(name),
     bucket_ranges_(ranges),
     declared_min_(minimum),
-    declared_max_(maximum),
-    bucket_count_(bucket_count) {
+    declared_max_(maximum) {
   if (ranges)
     samples_.reset(new SampleVector(ranges));
 }
 
 Histogram::~Histogram() {
 }
 
 bool Histogram::PrintEmptyBucket(size_t index) const {
   return true;
 }
@@ skipping 61 matching lines @@
   WriteAsciiHeader(*snapshot, sample_count, output);
   output->append(newline);
 
   // Prepare to normalize graphical rendering of bucket contents.
   double max_size = 0;
   if (graph_it)
     max_size = GetPeakBucketSize(*snapshot);
 
   // Calculate space needed to print bucket range numbers.  Leave room to print
   // nearly the largest bucket range without sliding over the histogram.
-  size_t largest_non_empty_bucket = bucket_count() - 1;
+  size_t largest_non_empty_bucket = BucketCount() - 1;
   while (0 == snapshot->GetCountAtIndex(largest_non_empty_bucket)) {
     if (0 == largest_non_empty_bucket)
       break;  // All buckets are empty.
     --largest_non_empty_bucket;
   }
 
   // Calculate largest print width needed for any of our bucket range displays.
   size_t print_width = 1;
-  for (size_t i = 0; i < bucket_count(); ++i) {
+  for (size_t i = 0; i < BucketCount(); ++i) {
     if (snapshot->GetCountAtIndex(i)) {
       size_t width = GetAsciiBucketRange(i).size() + 1;
       if (width > print_width)
         print_width = width;
     }
   }
 
   int64 remaining = sample_count;
   int64 past = 0;
   // Output the actual histogram graph.
-  for (size_t i = 0; i < bucket_count(); ++i) {
+  for (size_t i = 0; i < BucketCount(); ++i) {
     Count current = snapshot->GetCountAtIndex(i);
     if (!current && !PrintEmptyBucket(i))
       continue;
     remaining -= current;
     string range = GetAsciiBucketRange(i);
     output->append(range);
     for (size_t j = 0; range.size() + j < print_width + 1; ++j)
       output->push_back(' ');
-    if (0 == current && i < bucket_count() - 1 &&
+    if (0 == current && i < BucketCount() - 1 &&
         0 == snapshot->GetCountAtIndex(i + 1)) {
-      while (i < bucket_count() - 1 &&
+      while (i < BucketCount() - 1 &&
              0 == snapshot->GetCountAtIndex(i + 1)) {
         ++i;
       }
       output->append("... ");
       output->append(newline);
       continue;  // No reason to plot emptiness.
     }
     double current_size = GetBucketSize(current, i);
     if (graph_it)
       WriteAsciiBucketGraph(current_size, max_size, output);
     WriteAsciiBucketContext(past, current, remaining, i, output);
     output->append(newline);
     past += current;
   }
   DCHECK_EQ(sample_count, past);
 }
 
 double Histogram::GetPeakBucketSize(const SampleVector& samples) const {
   double max = 0;
-  for (size_t i = 0; i < bucket_count() ; ++i) {
+  for (size_t i = 0; i < BucketCount() ; ++i) {
     double current_size = GetBucketSize(samples.GetCountAtIndex(i), i);
     if (current_size > max)
       max = current_size;
   }
   return max;
 }
 
 void Histogram::WriteAsciiHeader(const SampleVector& samples,
                                  Count sample_count,
                                  string* output) const {
@@ skipping 22 matching lines @@
   if (0 < i) {
     double percentage = past / scaled_sum;
     StringAppendF(output, " {%3.1f%%}", percentage);
   }
 }
 
 void Histogram::GetParameters(DictionaryValue* params) const {
   params->SetString("type", HistogramTypeToString(GetHistogramType()));
   params->SetInteger("min", declared_min());
   params->SetInteger("max", declared_max());
-  params->SetInteger("bucket_count", static_cast<int>(bucket_count()));
+  params->SetInteger("bucket_count", static_cast<int>(BucketCount()));
 }
 
 void Histogram::GetCountAndBucketData(Count* count,
                                       int64* sum,
                                       ListValue* buckets) const {
   scoped_ptr<SampleVector> snapshot = SnapshotSampleVector();
   *count = snapshot->TotalCount();
   *sum = snapshot->sum();
   size_t index = 0;
-  for (size_t i = 0; i < bucket_count(); ++i) {
+  for (size_t i = 0; i < BucketCount(); ++i) {
     Sample count = snapshot->GetCountAtIndex(i);
     if (count > 0) {
       scoped_ptr<DictionaryValue> bucket_value(new DictionaryValue());
       bucket_value->SetInteger("low", ranges(i));
-      if (i != bucket_count() - 1)
+      if (i != BucketCount() - 1)
         bucket_value->SetInteger("high", ranges(i + 1));
       bucket_value->SetInteger("count", count);
       buckets->Set(index, bucket_value.release());
       ++index;
     }
   }
 }
 
 //------------------------------------------------------------------------------
 // LinearHistogram: This histogram uses a traditional set of evenly spaced
@@ skipping 28 matching lines @@
       int32 flags,
       const DescriptionPair descriptions[]) {
   bool valid_arguments = Histogram::InspectConstructionArguments(
       name, &minimum, &maximum, &bucket_count);
   DCHECK(valid_arguments);
 
   HistogramBase* histogram = StatisticsRecorder::FindHistogram(name);
   if (!histogram) {
     // To avoid racy destruction at shutdown, the following will be leaked.
     BucketRanges* ranges = new BucketRanges(bucket_count + 1);
-    InitializeBucketRanges(minimum, maximum, bucket_count, ranges);
+    InitializeBucketRanges(minimum, maximum, ranges);
     const BucketRanges* registered_ranges =
         StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
 
     LinearHistogram* tentative_histogram =
-        new LinearHistogram(name, minimum, maximum, bucket_count,
-                            registered_ranges);
+        new LinearHistogram(name, minimum, maximum, registered_ranges);
 
     // Set range descriptions.
     if (descriptions) {
       for (int i = 0; descriptions[i].description; ++i) {
         tentative_histogram->bucket_description_[descriptions[i].sample] =
             descriptions[i].description;
       }
     }
 
     tentative_histogram->SetFlags(flags);
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
 
   DCHECK_EQ(LINEAR_HISTOGRAM, histogram->GetHistogramType());
   CHECK(histogram->HasConstructionArguments(minimum, maximum, bucket_count));
   return histogram;
 }
 
 HistogramType LinearHistogram::GetHistogramType() const {
   return LINEAR_HISTOGRAM;
 }
 
 LinearHistogram::LinearHistogram(const string& name,
                                  Sample minimum,
                                  Sample maximum,
-                                 size_t bucket_count,
                                  const BucketRanges* ranges)
-    : Histogram(name, minimum, maximum, bucket_count, ranges) {
+    : Histogram(name, minimum, maximum, ranges) {
 }
 
 double LinearHistogram::GetBucketSize(Count current, size_t i) const {
   DCHECK_GT(ranges(i + 1), ranges(i));
   // Adjacent buckets with different widths would have "surprisingly" many (few)
   // samples in a histogram if we didn't normalize this way.
   double denominator = ranges(i + 1) - ranges(i);
   return current/denominator;
 }
 
 const string LinearHistogram::GetAsciiBucketRange(size_t i) const {
   int range = ranges(i);
   BucketDescriptionMap::const_iterator it = bucket_description_.find(range);
   if (it == bucket_description_.end())
     return Histogram::GetAsciiBucketRange(i);
   return it->second;
 }
 
 bool LinearHistogram::PrintEmptyBucket(size_t index) const {
   return bucket_description_.find(ranges(index)) == bucket_description_.end();
 }
 
 // static
 void LinearHistogram::InitializeBucketRanges(Sample minimum,
                                              Sample maximum,
-                                             size_t bucket_count,
                                              BucketRanges* ranges) {
-  DCHECK_EQ(ranges->size(), bucket_count + 1);
   double min = minimum;
   double max = maximum;
-  size_t i;
-  for (i = 1; i < bucket_count; ++i) {
+  size_t bucket_count = ranges->BucketCount();
+  for (size_t i = 1; i < bucket_count; ++i) {
     double linear_range =
-        (min * (bucket_count -1 - i) + max * (i - 1)) / (bucket_count - 2);
+        (min * (bucket_count - 1 - i) + max * (i - 1)) / (bucket_count - 2);
     ranges->set_range(i, static_cast<Sample>(linear_range + 0.5));
   }
-  ranges->set_range(ranges->size() - 1, HistogramBase::kSampleType_MAX);
+  ranges->set_range(ranges->BucketCount(), HistogramBase::kSampleType_MAX);
   ranges->ResetChecksum();
 }
 
 // static
 HistogramBase* LinearHistogram::DeserializeInfoImpl(PickleIterator* iter) {
   string histogram_name;
   int flags;
   int declared_min;
   int declared_max;
   uint64 bucket_count;
@@ skipping 15 matching lines @@
 
 //------------------------------------------------------------------------------
 // This section provides implementation for BooleanHistogram.
 //------------------------------------------------------------------------------
 
 HistogramBase* BooleanHistogram::FactoryGet(const string& name, int32 flags) {
   HistogramBase* histogram = StatisticsRecorder::FindHistogram(name);
   if (!histogram) {
     // To avoid racy destruction at shutdown, the following will be leaked.
     BucketRanges* ranges = new BucketRanges(4);
-    LinearHistogram::InitializeBucketRanges(1, 2, 3, ranges);
+    LinearHistogram::InitializeBucketRanges(1, 2, ranges);
     const BucketRanges* registered_ranges =
         StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
 
     BooleanHistogram* tentative_histogram =
         new BooleanHistogram(name, registered_ranges);
 
     tentative_histogram->SetFlags(flags);
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
 
   DCHECK_EQ(BOOLEAN_HISTOGRAM, histogram->GetHistogramType());
   return histogram;
 }
 
 HistogramType BooleanHistogram::GetHistogramType() const {
   return BOOLEAN_HISTOGRAM;
 }
 
 BooleanHistogram::BooleanHistogram(const string& name,
                                    const BucketRanges* ranges)
-    : LinearHistogram(name, 1, 2, 3, ranges) {}
+    : LinearHistogram(name, 1, 2, ranges) {}
 
 HistogramBase* BooleanHistogram::DeserializeInfoImpl(PickleIterator* iter) {
   string histogram_name;
   int flags;
   int declared_min;
   int declared_max;
   uint64 bucket_count;
   uint32 range_checksum;
 
   if (!ReadHistogramArguments(iter, &histogram_name, &flags, &declared_min,
@@ skipping 55 matching lines @@
     // values, FactoryGet will take care of removing them.
     all_values.push_back(value + 1);
   }
   return all_values;
 }
 
 CustomHistogram::CustomHistogram(const string& name,
                                  const BucketRanges* ranges)
     : Histogram(name,
                 ranges->range(1),
-                ranges->range(ranges->size() - 2),
-                ranges->size() - 1,
+                ranges->range(ranges->BucketCount() - 1),
                 ranges) {}
 
 bool CustomHistogram::SerializeInfoImpl(Pickle* pickle) const {
   if (!Histogram::SerializeInfoImpl(pickle))
     return false;
 
   // Serialize ranges. First and last ranges are alwasy 0 and INT_MAX, so don't
   // write them.
-  for (size_t i = 1; i < bucket_ranges()->size() - 1; ++i) {
+  for (size_t i = 1; i < bucket_ranges()->BucketCount(); ++i) {
     if (!pickle->WriteInt(bucket_ranges()->range(i)))
       return false;
   }
   return true;
 }
 
 double CustomHistogram::GetBucketSize(Count current, size_t i) const {
   return 1;
 }
 
@@ skipping 54 matching lines @@
 
   BucketRanges* bucket_ranges = new BucketRanges(ranges.size());
   for (size_t i = 0; i < ranges.size(); i++) {
     bucket_ranges->set_range(i, ranges[i]);
   }
   bucket_ranges->ResetChecksum();
   return bucket_ranges;
 }
 
 }  // namespace base