Cleanup histogram classes mixing SetFlags into FactoryGet arguments...

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 26 matching lines @@
 
 #include "base/lock.h"
 #include "base/ref_counted.h"
 #include "base/logging.h"
 #include "base/time.h"
 
 //------------------------------------------------------------------------------
 // Provide easy general purpose histogram in a macro, just like stats counters.
 // The first four macros use 50 buckets.
 
-#define HISTOGRAM_TIMES(name, sample) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), base::TimeDelta::FromMilliseconds(1), \
-        base::TimeDelta::FromSeconds(10), 50); \
-    counter->AddTime(sample); \
-  } while (0)
+#define HISTOGRAM_TIMES(name, sample) HISTOGRAM_CUSTOM_TIMES( \
+    name, sample, base::TimeDelta::FromMilliseconds(1), \
+    base::TimeDelta::FromSeconds(10), 50)
 
-#define HISTOGRAM_COUNTS(name, sample) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), 1, 1000000, 50); \
+#define HISTOGRAM_COUNTS(name, sample) HISTOGRAM_CUSTOM_COUNTS( \
+    name, sample, 1, 1000000, 50)
+
+#define HISTOGRAM_COUNTS_100(name, sample) HISTOGRAM_CUSTOM_COUNTS( \
+    name, sample, 1, 100, 50)
+
+#define HISTOGRAM_COUNTS_10000(name, sample) HISTOGRAM_CUSTOM_COUNTS( \
+    name, sample, 1, 10000, 50)
+
+#define HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count) do { \
+    static scoped_refptr<Histogram> counter = Histogram::FactoryGet( \
+        name, min, max, bucket_count, Histogram::kNoFlags); \
     counter->Add(sample); \
   } while (0)
 
-#define HISTOGRAM_COUNTS_100(name, sample) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), 1, 100, 50); \
-    counter->Add(sample); \
-  } while (0)
-
-#define HISTOGRAM_COUNTS_10000(name, sample) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), 1, 10000, 50); \
-    counter->Add(sample); \
-  } while (0)
-
-#define HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), min, max, bucket_count); \
-    counter->Add(sample); \
-  } while (0)
-
-#define HISTOGRAM_PERCENTAGE(name, under_one_hundred) do { \
-    static scoped_refptr<Histogram> counter = \
-        LinearHistogram::LinearHistogramFactoryGet(\
-            (name), 1, 100, 101); \
-    counter->Add(under_one_hundred); \
-  } while (0)
+#define HISTOGRAM_PERCENTAGE(name, under_one_hundred) \
+    HISTOGRAM_ENUMERATION(name, under_one_hundred, 101)
 
 // For folks that need real specific times, use this to select a precise range
 // of times you want plotted, and the number of buckets you want used.
 #define HISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), min, max, bucket_count); \
+    static scoped_refptr<Histogram> counter = Histogram::FactoryGet( \
+        name, min, max, bucket_count, Histogram::kNoFlags); \
     counter->AddTime(sample); \
   } while (0)
 
 // DO NOT USE THIS.  It is being phased out, in favor of HISTOGRAM_CUSTOM_TIMES.
 #define HISTOGRAM_CLIPPED_TIMES(name, sample, min, max, bucket_count) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), min, max, bucket_count); \
+    static scoped_refptr<Histogram> counter = Histogram::FactoryGet( \
+        name, min, max, bucket_count, Histogram::kNoFlags); \
     if ((sample) < (max)) counter->AddTime(sample); \
   } while (0)
 
-//------------------------------------------------------------------------------
-// This macro set is for a histogram that can support both addition and removal
-// of samples. It should be used to render the accumulated asset allocation
-// of some samples.  For example, it can sample memory allocation sizes, and
-// memory releases (as negative samples).
-// To simplify the interface, only non-zero values can be sampled, with positive
-// numbers indicating addition, and negative numbers implying dimunition
-// (removal).
-// Note that the underlying ThreadSafeHistogram() uses locking to ensure that
-// counts are precise (no chance of losing an addition or removal event, due to
-// multithread racing). This precision is required to prevent missed-counts from
-// resulting in drift, as the calls to Remove() for a given value should always
-// be equal in number or fewer than the corresponding calls to Add().
+// Support histograming of an enumerated value.  The samples should always be
+// less than boundary_value.
 
-#define ASSET_HISTOGRAM_COUNTS(name, sample) do { \
-    static scoped_refptr<Histogram> counter = \
-        ThreadSafeHistogram::ThreadSafeHistogramFactoryGet(\
-            (name), 1, 1000000, 50); \
-    if (0 == sample) break; \
-    if (sample >= 0) \
-      counter->Add(sample); \
-    else\
-      counter->Remove(-sample); \
+#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 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 DASSET_HISTOGRAM_COUNTS(name, sample) ASSET_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)
+    HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count)
+#define DHISTOGRAM_ENUMERATION(name, sample, boundary_value) \
+    HISTOGRAM_ENUMERATION(name, sample, boundary_value)
 
 #else  // NDEBUG
 
 #define DHISTOGRAM_TIMES(name, sample) do {} while (0)
 #define DHISTOGRAM_COUNTS(name, sample) do {} while (0)
-#define DASSET_HISTOGRAM_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)
-
+    do {} while (0)
+#define DHISTOGRAM_ENUMERATION(name, sample, boundary_value) 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.
 
-static const int kUmaTargetedHistogramFlag = 0x1;
+#define UMA_HISTOGRAM_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES( \
+    name, sample, base::TimeDelta::FromMilliseconds(1), \
+    base::TimeDelta::FromSeconds(10), 50)
 
-// This indicates the histogram is pickled to be sent across an IPC Channel.
-// If we observe this flag during unpickle method, then we are running in a
-// single process mode.
-static const int kIPCSerializationSourceFlag = 1 << 4;
+#define UMA_HISTOGRAM_MEDIUM_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES( \
+    name, sample, base::TimeDelta::FromMilliseconds(10), \
+    base::TimeDelta::FromMinutes(3), 50)
 
-// Some histograms aren't currently destroyed.  Until such users properly
-// decref those histograms, we will mark there histograms as planned to leak so
-// that we can catch any user that directly tries to call delete "directly"
-// rather than using the reference counting features that should take care of
-// this.
-// TODO(jar): Make this flag unnecessary!
-static const int kPlannedLeakFlag = 1 << 5;
+// Use this macro when times can routinely be much longer than 10 seconds.
+#define UMA_HISTOGRAM_LONG_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES( \
+    name, sample, base::TimeDelta::FromMilliseconds(1), \
+    base::TimeDelta::FromHours(1), 50)
 
-#define UMA_HISTOGRAM_TIMES(name, sample) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), base::TimeDelta::FromMilliseconds(1), \
-        base::TimeDelta::FromSeconds(10), 50); \
-    counter->SetFlags(kUmaTargetedHistogramFlag); \
+#define UMA_HISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) do { \
+    static scoped_refptr<Histogram> counter = Histogram::FactoryGet( \
+        name, min, max, bucket_count, Histogram::kUmaTargetedHistogramFlag); \
     counter->AddTime(sample); \
   } while (0)
 
-#define UMA_HISTOGRAM_MEDIUM_TIMES(name, sample) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), base::TimeDelta::FromMilliseconds(10), \
-        base::TimeDelta::FromMinutes(3), 50); \
-    counter->SetFlags(kUmaTargetedHistogramFlag); \
-    counter->AddTime(sample); \
-  } while (0)
-
-// Use this macro when times can routinely be much longer than 10 seconds.
-#define UMA_HISTOGRAM_LONG_TIMES(name, sample) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), base::TimeDelta::FromMilliseconds(1), \
-        base::TimeDelta::FromHours(1), 50); \
-    counter->SetFlags(kUmaTargetedHistogramFlag); \
-    counter->AddTime(sample); \
-  } while (0)
-
-#define UMA_HISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), min, max, bucket_count); \
-    counter->SetFlags(kUmaTargetedHistogramFlag); \
-    counter->AddTime(sample); \
-  } while (0)
-
+// DO NOT USE THIS.  It is being phased out, in favor of HISTOGRAM_CUSTOM_TIMES.
 #define UMA_HISTOGRAM_CLIPPED_TIMES(name, sample, min, max, bucket_count) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), min, max, bucket_count); \
-    counter->SetFlags(kUmaTargetedHistogramFlag); \
+    static scoped_refptr<Histogram> counter = Histogram::FactoryGet( \
+        name, min, max, bucket_count, Histogram::kUmaTargetedHistogramFlag); \
     if ((sample) < (max)) counter->AddTime(sample); \
   } while (0)
 
-#define UMA_HISTOGRAM_COUNTS(name, sample) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), 1, 1000000, 50); \
-    counter->SetFlags(kUmaTargetedHistogramFlag); \
+#define UMA_HISTOGRAM_COUNTS(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS( \
+    name, sample, 1, 1000000, 50)
+
+#define UMA_HISTOGRAM_COUNTS_100(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS( \
+    name, sample, 1, 100, 50)
+
+#define UMA_HISTOGRAM_COUNTS_10000(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS( \
+    name, sample, 1, 10000, 50)
+
+#define UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count) do { \
+    static scoped_refptr<Histogram> counter = Histogram::FactoryGet( \
+        name, min, max, bucket_count, Histogram::kUmaTargetedHistogramFlag); \
     counter->Add(sample); \
   } while (0)
 
-#define UMA_HISTOGRAM_COUNTS_100(name, sample) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), 1, 100, 50); \
-    counter->SetFlags(kUmaTargetedHistogramFlag); \
+#define UMA_HISTOGRAM_MEMORY_KB(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS( \
+    name, sample, 1000, 500000, 50)
+
+#define UMA_HISTOGRAM_MEMORY_MB(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS( \
+    name, sample, 1, 1000, 50)
+
+#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 { \
+    DCHECK(sample < boundary_value); \
+    static scoped_refptr<Histogram> counter = LinearHistogram::FactoryGet( \
+        name, 1, boundary_value, boundary_value + 1, \
+        Histogram::kUmaTargetedHistogramFlag); \
     counter->Add(sample); \
   } while (0)
 
-#define UMA_HISTOGRAM_COUNTS_10000(name, sample) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), 1, 10000, 50); \
-    counter->SetFlags(kUmaTargetedHistogramFlag); \
-    counter->Add(sample); \
-  } while (0)
-
-#define UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), min, max, bucket_count); \
-    counter->SetFlags(kUmaTargetedHistogramFlag); \
-    counter->Add(sample); \
-  } while (0)
-
-#define UMA_HISTOGRAM_MEMORY_KB(name, sample) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), 1000, 500000, 50); \
-    counter->SetFlags(kUmaTargetedHistogramFlag); \
-    counter->Add(sample); \
-  } while (0)
-
-#define UMA_HISTOGRAM_MEMORY_MB(name, sample) do { \
-    static scoped_refptr<Histogram> counter = Histogram::HistogramFactoryGet(\
-        (name), 1, 1000, 50); \
-    counter->SetFlags(kUmaTargetedHistogramFlag); \
-    counter->Add(sample); \
-  } while (0)
-
-#define UMA_HISTOGRAM_PERCENTAGE(name, under_one_hundred) do { \
-    static scoped_refptr<Histogram> counter = \
-        LinearHistogram::LinearHistogramFactoryGet(\
-            (name), 1, 100, 101); \
-    counter->SetFlags(kUmaTargetedHistogramFlag); \
-    counter->Add(under_one_hundred); \
-  } while (0)
 
 //------------------------------------------------------------------------------
 
 class Pickle;
 class Histogram;
 class LinearHistogram;
 class BooleanHistogram;
-class ThreadSafeHistogram;
 
 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;
 
-  static const int kHexRangePrintingFlag;
-
   /* These enums are meant to facilitate deserialization of renderer histograms
      into the browser. */
   enum ClassType {
     HISTOGRAM,
     LINEAR_HISTOGRAM,
     BOOLEAN_HISTOGRAM,
-    THREAD_SAFE_HISTOGRAM,
     NOT_VALID_IN_RENDERER
   };
 
   enum BucketLayout {
     EXPONENTIAL,
     LINEAR
   };
 
+  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
+    // histogram!).
+    kIPCSerializationSourceFlag = 0x10,
+
+    kHexRangePrintingFlag = 0x8000,  // Fancy bucket-naming supported.
+  };
+
   struct DescriptionPair {
     Sample sample;
     const char* description;  // Null means end of a list of pairs.
   };
 
   //----------------------------------------------------------------------------
   // Statistic values, developed over the life of the histogram.
 
   class SampleSet {
    public:
@@ skipping 24 matching lines @@
     Counts counts_;
 
     // Save simple stats locally.  Note that this MIGHT get done in base class
     // without shared memory at some point.
     int64 sum_;         // sum of samples.
     int64 square_sum_;  // sum of squares of samples.
   };
   //----------------------------------------------------------------------------
   // minimum should start from 1. 0 is invalid as a minimum. 0 is an implicit
   // default underflow bucket.
-  static scoped_refptr<Histogram> HistogramFactoryGet(const std::string& name,
-      Sample minimum, Sample maximum, size_t bucket_count);
-  static scoped_refptr<Histogram> HistogramFactoryGet(const std::string& name,
-      base::TimeDelta minimum, base::TimeDelta maximum, size_t bucket_count);
+  static scoped_refptr<Histogram> FactoryGet(const std::string& name,
+      Sample minimum, Sample maximum, size_t bucket_count, Flags flags);
+  static scoped_refptr<Histogram> FactoryGet(const std::string& name,
+      base::TimeDelta minimum, base::TimeDelta maximum, size_t bucket_count,
+      Flags flags);
 
   void Add(int value);
 
   // This method is an interface, used only by BooleanHistogram.
   virtual void AddBoolean(bool value) { DCHECK(false); }
 
   // Accept a TimeDelta to increment.
   void AddTime(base::TimeDelta time) {
     Add(static_cast<int>(time.InMilliseconds()));
   }
 
   void AddSampleSet(const SampleSet& sample);
 
-  // This method is an interface, used only by ThreadSafeHistogram.
-  virtual void Remove(int value) { DCHECK(false); }
-
   // This method is an interface, used only by LinearHistogram.
   virtual void SetRangeDescriptions(const DescriptionPair descriptions[])
       { DCHECK(false); }
 
   // The following methods provide graphical histogram displays.
   void WriteHTMLGraph(std::string* output) const;
   void WriteAscii(bool graph_it, const std::string& newline,
                   std::string* output) const;
 
   // Support generic flagging of Histograms.
   // 0x1 Currently used to mark this histogram to be recorded by UMA..
   // 0x8000 means print ranges in hex.
-  void SetFlags(int flags) { flags_ |= flags; }
-  void ClearFlags(int flags) { flags_ &= ~flags; }
+  void SetFlags(Flags flags) { flags_ = static_cast<Flags> (flags_ | flags); }
+  void ClearFlags(Flags flags) { flags_ = static_cast<Flags>(flags_ & ~flags); }
   int flags() const { return flags_; }
 
   // 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.
@@ skipping 108 matching lines @@
   // named instances will  be coalesced cross-project TODO(jar).
   // If a user needs one histogram name to be called by several places in a
   // single process, a central function should be defined by teh user, which
   // defins the single declared instance of the named histogram.
   const std::string histogram_name_;
   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_[].
 
   // Flag the histogram for recording by UMA via metric_services.h.
-  int flags_;
+  Flags flags_;
 
   // For each index, show the least value that can be stored in the
   // corresponding bucket. We also append one extra element in this array,
   // containing kSampleType_MAX, to make calculations easy.
   // The dimension of ranges_ is bucket_count + 1.
   Ranges ranges_;
 
   // Finally, provide the state that changes with the addition of each new
   // sample.
   SampleSet sample_;
 
   DISALLOW_COPY_AND_ASSIGN(Histogram);
 };
 
 //------------------------------------------------------------------------------
 
 // LinearHistogram is a more traditional histogram, with evenly spaced
 // buckets.
 class LinearHistogram : public Histogram {
  public:
   virtual ClassType histogram_type() const { return LINEAR_HISTOGRAM; }
 
   // 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[]);
 
   /* minimum should start from 1. 0 is as minimum is invalid. 0 is an implicit
      default underflow bucket. */
-  static scoped_refptr<Histogram> LinearHistogramFactoryGet(
-      const std::string& name, Sample minimum, Sample maximum,
-      size_t bucket_count);
-  static scoped_refptr<Histogram> LinearHistogramFactoryGet(
-      const std::string& name, base::TimeDelta minimum,
-      base::TimeDelta maximum, size_t bucket_count);
+  static scoped_refptr<Histogram> FactoryGet(const std::string& name,
+      Sample minimum, Sample maximum, size_t bucket_count, Flags flags);
+  static scoped_refptr<Histogram> FactoryGet(const std::string& name,
+      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() {}
 
@@ skipping 17 matching lines @@
   BucketDescriptionMap bucket_description_;
 
   DISALLOW_COPY_AND_ASSIGN(LinearHistogram);
 };
 
 //------------------------------------------------------------------------------
 
 // BooleanHistogram is a histogram for booleans.
 class BooleanHistogram : public LinearHistogram {
  public:
-  static scoped_refptr<Histogram> BooleanHistogramFactoryGet(
-      const std::string& name);
+  static scoped_refptr<Histogram> FactoryGet(const std::string& name,
+      Flags flags);
 
   virtual ClassType histogram_type() const { return BOOLEAN_HISTOGRAM; }
 
   virtual void AddBoolean(bool value) { Add(value ? 1 : 0); }
 
  private:
   explicit BooleanHistogram(const std::string& name)
-    : LinearHistogram(name, 1, 2, 3) {
+      : LinearHistogram(name, 1, 2, 3) {
   }
 
   DISALLOW_COPY_AND_ASSIGN(BooleanHistogram);
 };
 
 //------------------------------------------------------------------------------
-// This section provides implementation for ThreadSafeHistogram.
-//------------------------------------------------------------------------------
-
-class ThreadSafeHistogram : public Histogram {
- public:
-  static scoped_refptr<Histogram> ThreadSafeHistogramFactoryGet(
-      const std::string& name, Sample minimum, Sample maximum,
-      size_t bucket_count);
-
-  virtual ClassType histogram_type() const { return THREAD_SAFE_HISTOGRAM; }
-
-  // Provide the analog to Add()
-  virtual void Remove(int value);
-
- protected:
-  ThreadSafeHistogram(const std::string& name, Sample minimum,
-                      Sample maximum, size_t bucket_count);
-
-  virtual ~ThreadSafeHistogram() {}
-
-  // Provide locked versions to get precise counts.
-  virtual void Accumulate(Sample value, Count count, size_t index);
-
-  virtual void SnapshotSample(SampleSet* sample) const;
-
- private:
-  mutable Lock lock_;
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadSafeHistogram);
-};
-
-//------------------------------------------------------------------------------
 // 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 43 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_