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

base/metrics/histogram.h

 // 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).
 
 // It supports calls to accumulate either time intervals (which are processed
 // as integral number of milliseconds), or arbitrary integral units.
@@ skipping 378 matching lines @@
                                        base::TimeDelta maximum,
                                        size_t bucket_count,
                                        int32 flags);
 
   // Time call for use with DHISTOGRAM*.
   // Returns TimeTicks::Now() in debug and TimeTicks() in release build.
   static TimeTicks DebugNow();
 
   static void InitializeBucketRanges(Sample minimum,
                                      Sample maximum,
-                                     size_t bucket_count,
                                      BucketRanges* ranges);
 
   // This constant if for FindCorruption. Since snapshots of histograms are
   // taken asynchronously relative to sampling, and our counting code currently
   // does not prevent race conditions, it is pretty likely that we'll catch a
   // redundant count that doesn't match the sample count.  We allow for a
   // certain amount of slop before flagging this as an inconsistency. Even with
   // an inconsistency, we'll snapshot it again (for UMA in about a half hour),
   // so we'll eventually get the data, if it was not the result of a corruption.
   static const int kCommonRaceBasedCountMismatch;
 
   // Check to see if bucket ranges, counts and tallies in the snapshot are
   // consistent with the bucket ranges and checksums in our histogram.  This can
   // produce a false-alarm if a race occurred in the reading of the data during
   // a SnapShot process, but should otherwise be false at all times (unless we
   // have memory over-writes, or DRAM failures).
   virtual int FindCorruption(const HistogramSamples& samples) const OVERRIDE;
 
   //----------------------------------------------------------------------------
   // Accessors for factory constuction, serialization and testing.
   //----------------------------------------------------------------------------
   Sample declared_min() const { return declared_min_; }
   Sample declared_max() const { return declared_max_; }
   virtual Sample ranges(size_t i) const;
-  virtual size_t bucket_count() const;
+  virtual size_t BucketCount() const;
   const BucketRanges* bucket_ranges() const { return bucket_ranges_; }
 
   // This function validates histogram construction arguments. It returns false
   // if some of the arguments are totally bad.
   // Note. Currently it allow some bad input, e.g. 0 as minimum, but silently
   // converts it to good input: 1.
   // TODO(kaiwang): Be more restrict and return false for any bad input, and
   // make this a readonly validating function.
   static bool InspectConstructionArguments(const std::string& name,
                                            Sample* minimum,
                                            Sample* maximum,
                                            size_t* bucket_count);
 
   // HistogramBase implementation:
   virtual HistogramType GetHistogramType() const OVERRIDE;
   virtual bool HasConstructionArguments(Sample minimum,
                                         Sample maximum,
                                         size_t bucket_count) const OVERRIDE;
   virtual void Add(Sample value) OVERRIDE;
   virtual scoped_ptr<HistogramSamples> SnapshotSamples() const OVERRIDE;
   virtual void AddSamples(const HistogramSamples& samples) OVERRIDE;
   virtual bool AddSamplesFromPickle(PickleIterator* iter) OVERRIDE;
   virtual void WriteHTMLGraph(std::string* output) const OVERRIDE;
   virtual void WriteAscii(std::string* output) const OVERRIDE;
 
  protected:
-  // |bucket_count| and |ranges| should contain the underflow and overflow
-  // buckets. See top comments for example.
+  // |ranges| should contain the underflow and overflow buckets. See top
+  // comments for example.
   Histogram(const std::string& name,
             Sample minimum,
             Sample maximum,
-            size_t bucket_count,
             const BucketRanges* ranges);
 
   virtual ~Histogram();
 
   // HistogramBase implementation:
   virtual bool SerializeInfoImpl(Pickle* pickle) const OVERRIDE;
 
   // Method to override to skip the display of the i'th bucket if it's empty.
   virtual bool PrintEmptyBucket(size_t index) const;
 
@@ skipping 47 matching lines @@
   // WriteJSON calls these.
   virtual void GetParameters(DictionaryValue* params) const OVERRIDE;
 
   virtual void GetCountAndBucketData(Count* count,
                                      int64* sum,
                                      ListValue* buckets) const OVERRIDE;
 
   // Does not own this object. Should get from StatisticsRecorder.
   const BucketRanges* bucket_ranges_;
 
-  Sample declared_min_;  // Less than this goes into counts_[0]
-  Sample declared_max_;  // Over this goes into counts_[bucket_count_ - 1].
-  size_t bucket_count_;  // Dimension of counts_[].
+  Sample declared_min_;  // Less than this goes into the first bucket.
+  Sample declared_max_;  // Over this goes into the last bucket.
 
   // Finally, provide the state that changes with the addition of each new
   // sample.
   scoped_ptr<SampleVector> samples_;
 
   DISALLOW_COPY_AND_ASSIGN(Histogram);
 };
 
 //------------------------------------------------------------------------------
 
@@ skipping 29 matching lines @@
   static HistogramBase* FactoryGetWithRangeDescription(
       const std::string& name,
       Sample minimum,
       Sample maximum,
       size_t bucket_count,
       int32 flags,
       const DescriptionPair descriptions[]);
 
   static void InitializeBucketRanges(Sample minimum,
                                      Sample maximum,
-                                     size_t bucket_count,
                                      BucketRanges* ranges);
 
   // Overridden from Histogram:
   virtual HistogramType GetHistogramType() const OVERRIDE;
 
  protected:
   LinearHistogram(const std::string& name,
                   Sample minimum,
                   Sample maximum,
-                  size_t bucket_count,
                   const BucketRanges* ranges);
 
   virtual double GetBucketSize(Count current, size_t i) const OVERRIDE;
 
   // If we have a description for a bucket, then return that.  Otherwise
   // let parent class provide a (numeric) description.
   virtual const std::string GetAsciiBucketRange(size_t i) const OVERRIDE;
 
   // Skip printing of name for numeric range if we have a name (and if this is
   // an empty bucket).
@@ skipping 73 matching lines @@
   static bool ValidateCustomRanges(const std::vector<Sample>& custom_ranges);
   static BucketRanges* CreateBucketRangesFromCustomRanges(
       const std::vector<Sample>& custom_ranges);
 
   DISALLOW_COPY_AND_ASSIGN(CustomHistogram);
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_HISTOGRAM_H_