Extend Histogram class to support custom range definitions...

base/histogram.h

 // Copyright (c) 2006-2008 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 72 matching lines @@
 
 // Support histograming of an enumerated value.  The samples should always be
 // less than boundary_value.
 
 #define HISTOGRAM_ENUMERATION(name, sample, boundary_value) do { \
     static scoped_refptr<Histogram> counter = LinearHistogram::FactoryGet( \
         name, 1, boundary_value, boundary_value + 1, Histogram::kNoFlags); \
     counter->Add(sample); \
   } while (0)
 
+#define HISTOGRAM_CUSTOM_ENUMERATION(name, sample, custom_ranges) do { \
+    static scoped_refptr<Histogram> counter = CustomHistogram::FactoryGet( \
+        name, custom_ranges, Histogram::kNoFlags); \
+    counter->Add(sample); \
+  } while (0)
+
 
 //------------------------------------------------------------------------------
 // Define Debug vs non-debug flavors of macros.
 #ifndef NDEBUG
 
 #define DHISTOGRAM_TIMES(name, sample) HISTOGRAM_TIMES(name, sample)
 #define DHISTOGRAM_COUNTS(name, sample) HISTOGRAM_COUNTS(name, sample)
 #define DHISTOGRAM_PERCENTAGE(name, under_one_hundred) HISTOGRAM_PERCENTAGE(\
     name, under_one_hundred)
 #define DHISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) \
     HISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count)
 #define DHISTOGRAM_CLIPPED_TIMES(name, sample, min, max, bucket_count) \
     HISTOGRAM_CLIPPED_TIMES(name, sample, min, max, bucket_count)
 #define DHISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count) \
     HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count)
 #define DHISTOGRAM_ENUMERATION(name, sample, boundary_value) \
     HISTOGRAM_ENUMERATION(name, sample, boundary_value)
+#define DHISTOGRAM_CUSTOM_ENUMERATION(name, sample, custom_ranges) \
+    HISTOGRAM_CUSTOM_ENUMERATION(name, sample, custom_ranges)
 
 #else  // NDEBUG
 
 #define DHISTOGRAM_TIMES(name, sample) do {} while (0)
 #define DHISTOGRAM_COUNTS(name, sample) do {} while (0)
 #define DHISTOGRAM_PERCENTAGE(name, under_one_hundred) do {} while (0)
 #define DHISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) \
     do {} while (0)
 #define DHISTOGRAM_CLIPPED_TIMES(name, sample, min, max, bucket_count) \
     do {} while (0)
 #define DHISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count) \
     do {} while (0)
 #define DHISTOGRAM_ENUMERATION(name, sample, boundary_value) do {} while (0)
+#define DHISTOGRAM_CUSTOM_ENUMERATION(name, sample, custom_ranges) \
+    do {} while (0)
 
 #endif  // NDEBUG
 
 //------------------------------------------------------------------------------
 // The following macros provide typical usage scenarios for callers that wish
 // to record histogram data, and have the data submitted/uploaded via UMA.
 // Not all systems support such UMA, but if they do, the following macros
 // should work with the service.
 
 #define UMA_HISTOGRAM_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES( \
@@ skipping 46 matching lines @@
 #define UMA_HISTOGRAM_PERCENTAGE(name, under_one_hundred) \
     UMA_HISTOGRAM_ENUMERATION(name, under_one_hundred, 101)
 
 #define UMA_HISTOGRAM_ENUMERATION(name, sample, boundary_value) do { \
     static scoped_refptr<Histogram> counter = LinearHistogram::FactoryGet( \
         name, 1, boundary_value, boundary_value + 1, \
         Histogram::kUmaTargetedHistogramFlag); \
     counter->Add(sample); \
   } while (0)
 
+#define UMA_HISTOGRAM_CUSTOM_ENUMERATION(name, sample, custom_ranges) do { \
+    static scoped_refptr<Histogram> counter = CustomHistogram::FactoryGet( \
+        name, custom_ranges, Histogram::kUmaTargetedHistogramFlag); \
+    counter->Add(sample); \
+  } while (0)
 
 //------------------------------------------------------------------------------
 
-class Pickle;
+class BooleanHistogram;
+class CustomHistogram;
 class Histogram;
 class LinearHistogram;
-class BooleanHistogram;
+class Pickle;
 
 namespace disk_cache {
   class StatsHistogram;
 };  // namespace disk_cache
 
 
 class Histogram : public base::RefCountedThreadSafe<Histogram> {
  public:
   typedef int Sample;  // Used for samples (and ranges of samples).
   typedef int Count;  // Used to count samples in a bucket.
   static const Sample kSampleType_MAX = INT_MAX;
 
   typedef std::vector<Count> Counts;
   typedef std::vector<Sample> Ranges;
 
   /* These enums are meant 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
+    LINEAR,
+    CUSTOM
   };
 
   enum Flags {
     kNoFlags = 0,
     kUmaTargetedHistogramFlag = 0x1,  // Histogram should be UMA uploaded.
 
     // Indicate that the histogram was pickled to be sent across an IPC Channel.
     // If we observe this flag on a histogram being aggregated into after IPC,
     // then we are running in a single process mode, and the aggregation should
     // not take place (as we would be aggregating back into the source
@@ skipping 242 matching lines @@
       base::TimeDelta minimum, base::TimeDelta maximum, size_t bucket_count,
       Flags flags);
 
  protected:
   LinearHistogram(const std::string& name, Sample minimum,
                   Sample maximum, size_t bucket_count);
 
   LinearHistogram(const std::string& name, base::TimeDelta minimum,
                   base::TimeDelta maximum, size_t bucket_count);
 
-  virtual ~LinearHistogram() {}
-
   // Initialize ranges_ mapping.
   virtual void InitializeBucketRange();
   virtual double GetBucketSize(Count current, size_t i) const;
 
   // 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;
 
   // Skip printing of name for numeric range if we have a name (and if this is
   // an empty bucket).
@@ skipping 23 matching lines @@
 
  private:
   explicit BooleanHistogram(const std::string& name)
       : LinearHistogram(name, 1, 2, 3) {
   }
 
   DISALLOW_COPY_AND_ASSIGN(BooleanHistogram);
 };
 
 //------------------------------------------------------------------------------
+
+// CustomHistogram is a histogram for a set of custom integers.
+class CustomHistogram : public Histogram {
+ public:
+  virtual ClassType histogram_type() const { return CUSTOM_HISTOGRAM; }
+
+  static scoped_refptr<Histogram> FactoryGet(const std::string& name,
+      const std::vector<int>& custom_ranges, Flags flags);
+
+ protected:
+  CustomHistogram(const std::string& name,
+                  const std::vector<int>& custom_ranges);
+
+  // Initialize ranges_ mapping.
+  virtual void InitializeBucketRange();
+  virtual double GetBucketSize(Count current, size_t i) const;
+
+ private:
+  // Temporary pointer used during construction/initialization, and then NULLed.
+  const std::vector<int>* ranges_vector_;
+
+  DISALLOW_COPY_AND_ASSIGN(CustomHistogram);
+};
+
+//------------------------------------------------------------------------------
 // StatisticsRecorder handles all histograms in the system.  It provides a
 // general place for histograms to register, and supports a global API for
 // accessing (i.e., dumping, or graphing) the data in all the histograms.
 
 class StatisticsRecorder {
  public:
   typedef std::vector<scoped_refptr<Histogram> > Histograms;
 
   StatisticsRecorder();
 
@@ skipping 39 matching lines @@
   // lock protects access to the above map.
   static Lock* lock_;
 
   // Dump all known histograms to log.
   static bool dump_on_exit_;
 
   DISALLOW_COPY_AND_ASSIGN(StatisticsRecorder);
 };
 
 #endif  // BASE_HISTOGRAM_H_