Histogram type support in HistogramBase and remove SetRangeDescription function

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 343 matching lines @@
 class Histogram;
 class LinearHistogram;
 
 class BASE_EXPORT Histogram : public HistogramBase {
  public:
   // Initialize maximum number of buckets in histograms as 16,384.
   static const size_t kBucketCount_MAX;
 
   typedef std::vector<Count> Counts;
 
-  // These enums are used to facilitate deserialization of renderer histograms
-  // into the browser.
-  enum ClassType {
-    HISTOGRAM,
-    LINEAR_HISTOGRAM,
-    BOOLEAN_HISTOGRAM,
-    CUSTOM_HISTOGRAM,
-    NOT_VALID_IN_RENDERER,
-  };
-
-  enum BucketLayout {
-    EXPONENTIAL,
-    LINEAR,
-    CUSTOM,
-  };
-
   enum Inconsistencies {
     NO_INCONSISTENCIES = 0x0,
     RANGE_CHECKSUM_ERROR = 0x1,
     BUCKET_ORDER_ERROR = 0x2,
     COUNT_HIGH_ERROR = 0x4,
     COUNT_LOW_ERROR = 0x8,
 
     NEVER_EXCEEDED_VALUE = 0x10
   };
 
@@ skipping 36 matching lines @@
   virtual void AddBoolean(bool value);
 
   // Accept a TimeDelta to increment.
   void AddTime(TimeDelta time) {
     Add(static_cast<int>(time.InMilliseconds()));
   }
 
   void AddSamples(const HistogramSamples& samples);
   bool AddSamplesFromPickle(PickleIterator* iter);
 
-  // This method is an interface, used only by LinearHistogram.
-  virtual void SetRangeDescriptions(const DescriptionPair descriptions[]);
-
   // Convenience methods for serializing/deserializing the histograms.
   // Histograms from Renderer process are serialized and sent to the browser.
   // Browser process reconstructs the histogram from the pickled version
   // accumulates the browser-side shadow copy of histograms (that mirror
   // histograms created in the renderer).
 
   // Serialize the given snapshot of a Histogram into a String. Uses
   // Pickle class to flatten the object.
   static std::string SerializeHistogramInfo(const Histogram& histogram,
                                             const HistogramSamples& snapshot);
@@ skipping 15 matching lines @@
   // 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 Inconsistencies FindCorruption(const HistogramSamples& samples) const;
 
   //----------------------------------------------------------------------------
   // Accessors for factory constuction, serialization and testing.
   //----------------------------------------------------------------------------
-  virtual ClassType histogram_type() const;
   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;
   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 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
@@ skipping 101 matching lines @@
                                Sample minimum,
                                Sample maximum,
                                size_t bucket_count,
                                int32 flags);
   static Histogram* FactoryTimeGet(const std::string& name,
                                    TimeDelta minimum,
                                    TimeDelta maximum,
                                    size_t bucket_count,
                                    int32 flags);
 
+  // Create a LinearHistogram and store a list of number/text values for use in
+  // writing the histogram graph. The last element in the array has a NULL in
+  // its "description" field.

[Ilya Sherman, 2012/10/31 00:35:19]

nit: You should document that |descriptions| can be null.

[kaiwang, 2012/10/31 01:12:56]

Done.

+  static Histogram* 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 ClassType histogram_type() const OVERRIDE;
-
-  // Store a list of number/text values for use in rendering the histogram.
-  // The last element in the array has a null in its "description" slot.
-  virtual void SetRangeDescriptions(
-      const DescriptionPair descriptions[]) OVERRIDE;
+  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;
 
@@ skipping 15 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(LinearHistogram);
 };
 
 //------------------------------------------------------------------------------
 
 // BooleanHistogram is a histogram for booleans.
 class BASE_EXPORT BooleanHistogram : public LinearHistogram {
  public:
   static Histogram* FactoryGet(const std::string& name, int32 flags);
 
-  virtual ClassType histogram_type() const OVERRIDE;
+  virtual HistogramType GetHistogramType() const OVERRIDE;
 
   virtual void AddBoolean(bool value) OVERRIDE;
 
  private:
   BooleanHistogram(const std::string& name, const BucketRanges* ranges);
 
   DISALLOW_COPY_AND_ASSIGN(BooleanHistogram);
 };
 
 //------------------------------------------------------------------------------
 
 // CustomHistogram is a histogram for a set of custom integers.
 class BASE_EXPORT CustomHistogram : public Histogram {
  public:
   // |custom_ranges| contains a vector of limits on ranges. Each limit should be
   // > 0 and < kSampleType_MAX. (Currently 0 is still accepted for backward
   // compatibility). The limits can be unordered or contain duplication, but
   // client should not depend on this.
   static Histogram* FactoryGet(const std::string& name,
                                const std::vector<Sample>& custom_ranges,
                                int32 flags);
 
   // Overridden from Histogram:
-  virtual ClassType histogram_type() const OVERRIDE;
+  virtual HistogramType GetHistogramType() const OVERRIDE;
 
   // Helper method for transforming an array of valid enumeration values
   // to the std::vector<int> expected by HISTOGRAM_CUSTOM_ENUMERATION.
   // This function ensures that a guard bucket exists right after any
   // valid sample value (unless the next higher sample is also a valid value),
   // so that invalid samples never fall into the same bucket as valid samples.
   // TODO(kaiwang): Change name to ArrayToCustomEnumRanges.
   static std::vector<Sample> ArrayToCustomRanges(const Sample* values,
                                                  size_t num_values);
 
@@ skipping 13 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_