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

base/metrics/sample_vector.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.
 
 #include "base/metrics/sample_vector.h"
 
 #include "base/logging.h"
 #include "base/metrics/bucket_ranges.h"
 
 using std::vector;
 
 namespace base {
 
 typedef HistogramBase::Count Count;
 typedef HistogramBase::Sample Sample;
 
 SampleVector::SampleVector(const BucketRanges* bucket_ranges)
-    : counts_(bucket_ranges->size() - 1),
+    : counts_(bucket_ranges->bucket_count()),
       bucket_ranges_(bucket_ranges) {
-  CHECK_GE(bucket_ranges_->size(), 2u);
+  CHECK_GE(bucket_ranges_->bucket_count(), 1u);
 }
 
 SampleVector::~SampleVector() {}
 
 void SampleVector::Accumulate(Sample value, Count count) {
   size_t bucket_index = GetBucketIndex(value);
   counts_[bucket_index] += count;
   IncreaseSum(count * value);
   IncreaseRedundantCount(count);
 }
@@ skipping 45 matching lines @@
       return false;
     }
   }
 
   return iter->Done();
 }
 
 // Use simple binary search.  This is very general, but there are better
 // approaches if we knew that the buckets were linearly distributed.
 size_t SampleVector::GetBucketIndex(Sample value) const {
-  size_t bucket_count = bucket_ranges_->size() - 1;
+  size_t bucket_count = bucket_ranges_->bucket_count();
   CHECK_GE(bucket_count, 1u);
   CHECK_GE(value, bucket_ranges_->range(0));
   CHECK_LT(value, bucket_ranges_->range(bucket_count));
 
   size_t under = 0;
   size_t over = bucket_count;
   size_t mid;
   do {
     DCHECK_GE(over, under);
     mid = under + (over - under)/2;
     if (mid == under)
       break;
     if (bucket_ranges_->range(mid) <= value)
       under = mid;
     else
       over = mid;
   } while (true);
 
   DCHECK_LE(bucket_ranges_->range(mid), value);
   CHECK_GT(bucket_ranges_->range(mid + 1), value);
   return mid;
 }
 
 SampleVectorIterator::SampleVectorIterator(const vector<Count>* counts,
                                            const BucketRanges* bucket_ranges)
     : counts_(counts),
       bucket_ranges_(bucket_ranges),
       index_(0) {
-  CHECK_GT(bucket_ranges_->size(), counts_->size());
+  CHECK_GE(bucket_ranges_->bucket_count(), counts_->size());
   SkipEmptyBuckets();
 }
 
 SampleVectorIterator::~SampleVectorIterator() {}
 
 bool SampleVectorIterator::Done() const {
   return index_ >= counts_->size();
 }
 
 void SampleVectorIterator::Next() {
@@ skipping 26 matching lines @@
     return;
 
   while (index_ < counts_->size()) {
     if ((*counts_)[index_] != 0)
       return;
     index_++;
   }
 }
 
 }  // namespace base