Cleanup histogram classes mixing SetFlags into FactoryGet arguments...

base/histogram.cc

 // 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).
 // See header file for details and examples.
 
 #include "base/histogram.h"
 
 #include <math.h>
 #include <string>
 
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/string_util.h"
 
 using base::TimeDelta;
 
 typedef Histogram::Count Count;
 
-// static
-const int Histogram::kHexRangePrintingFlag = 0x8000;
-
-scoped_refptr<Histogram> Histogram::HistogramFactoryGet(
-    const std::string& name, Sample minimum, Sample maximum,
-    size_t bucket_count) {
+scoped_refptr<Histogram> Histogram::FactoryGet(const std::string& name,
+    Sample minimum, Sample maximum, size_t bucket_count, Flags flags) {
   scoped_refptr<Histogram> histogram(NULL);
 
   // Defensive code.
   if (minimum <= 0)
     minimum = 1;
   if (maximum >= kSampleType_MAX)
     maximum = kSampleType_MAX - 1;
 
   if (StatisticsRecorder::FindHistogram(name, &histogram)) {
     DCHECK(histogram.get() != NULL);
   } else {
     histogram = new Histogram(name, minimum, maximum, bucket_count);
     scoped_refptr<Histogram> registered_histogram(NULL);
     StatisticsRecorder::FindHistogram(name, &registered_histogram);
     // Allow a NULL return to mean that the StatisticsRecorder was not started.
     if (registered_histogram.get() != NULL &&
         registered_histogram.get() != histogram.get())
       histogram = registered_histogram;
   }
 
   DCHECK(HISTOGRAM == histogram->histogram_type());
   DCHECK(histogram->HasConstructorArguments(minimum, maximum, bucket_count));
+  histogram->SetFlags(flags);
   return histogram;
 }
 
-scoped_refptr<Histogram> Histogram::HistogramFactoryGet(
-    const std::string& name, base::TimeDelta minimum, base::TimeDelta maximum,
-    size_t bucket_count) {
-  return HistogramFactoryGet(name,
-      minimum.InMilliseconds(), maximum.InMilliseconds(), bucket_count);
+scoped_refptr<Histogram> Histogram::FactoryGet(const std::string& name,
+    base::TimeDelta minimum, base::TimeDelta maximum, size_t bucket_count,
+    Flags flags) {
+  return FactoryGet(name, minimum.InMilliseconds(), maximum.InMilliseconds(),
+                    bucket_count, flags);
 }
 
 Histogram::Histogram(const std::string& name, Sample minimum,
                      Sample maximum, size_t bucket_count)
   : histogram_name_(name),
     declared_min_(minimum),
     declared_max_(maximum),
     bucket_count_(bucket_count),
-    flags_(0),
+    flags_(kNoFlags),
     ranges_(bucket_count + 1, 0),
     sample_() {
   Initialize();
 }
 
 Histogram::Histogram(const std::string& name, TimeDelta minimum,
                      TimeDelta maximum, size_t bucket_count)
   : histogram_name_(name),
     declared_min_(static_cast<int> (minimum.InMilliseconds())),
     declared_max_(static_cast<int> (maximum.InMilliseconds())),
     bucket_count_(bucket_count),
-    flags_(0),
+    flags_(kNoFlags),
     ranges_(bucket_count + 1, 0),
     sample_() {
   Initialize();
 }
 
 Histogram::~Histogram() {
-  DCHECK(!(kPlannedLeakFlag & flags_));
   if (StatisticsRecorder::dump_on_exit()) {
     std::string output;
     WriteAscii(true, "\n", &output);
     LOG(INFO) << output;
   }
 
   // Just to make sure most derived class did this properly...
   DCHECK(ValidateBucketRanges());
 }
 
@@ skipping 80 matching lines @@
     WriteAsciiBucketContext(past, current, remaining, i, output);
     output->append(newline);
     past += current;
   }
   DCHECK(past == sample_count);
 }
 
 bool Histogram::ValidateBucketRanges() const {
   // Standard assertions that all bucket ranges should satisfy.
   DCHECK(ranges_.size() == bucket_count_ + 1);
-  DCHECK(0 == ranges_[0]);
+  DCHECK_EQ(0, ranges_[0]);
   DCHECK(declared_min() == ranges_[1]);
   DCHECK(declared_max() == ranges_[bucket_count_ - 1]);
   DCHECK(kSampleType_MAX == ranges_[bucket_count_]);
   return true;
 }
 
 void Histogram::Initialize() {
   sample_.Resize(*this);
   if (declared_min_ <= 0)
     declared_min_ = 1;
   if (declared_max_ >= kSampleType_MAX)
     declared_max_ = kSampleType_MAX - 1;
-  DCHECK(declared_min_ > 0);  // We provide underflow bucket.
+  DCHECK_GT(declared_min_, 0);  // We provide underflow bucket.
   DCHECK(declared_min_ <= declared_max_);
-  DCHECK(1 < bucket_count_);
+  DCHECK_LT(1u, bucket_count_);
   size_t maximal_bucket_count = declared_max_ - declared_min_ + 2;
   DCHECK(bucket_count_ <= maximal_bucket_count);
-  DCHECK(0 == ranges_[0]);
+  DCHECK_EQ(0, ranges_[0]);
   ranges_[bucket_count_] = kSampleType_MAX;
   InitializeBucketRange();
   DCHECK(ValidateBucketRanges());
   StatisticsRecorder::Register(this);
 }
 
 // Calculate what range of values are held in each bucket.
 // We have to be careful that we don't pick a ratio between starting points in
 // consecutive buckets that is sooo small, that the integer bounds are the same
 // (effectively making one bucket get no values).  We need to avoid:
@@ skipping 107 matching lines @@
 }
 
 void Histogram::WriteAsciiHeader(const SampleSet& snapshot,
                                  Count sample_count,
                                  std::string* output) const {
   StringAppendF(output,
                 "Histogram: %s recorded %d samples",
                 histogram_name().c_str(),
                 sample_count);
   if (0 == sample_count) {
-    DCHECK(0 == snapshot.sum());
+    DCHECK_EQ(0, snapshot.sum());
   } else {
     double average = static_cast<float>(snapshot.sum()) / sample_count;
     double variance = static_cast<float>(snapshot.square_sum())/sample_count
                       - average * average;
     double standard_deviation = sqrt(variance);
 
     StringAppendF(output,
                   ", average = %.1f, standard deviation = %.1f",
                   average, standard_deviation);
   }
@@ skipping 65 matching lines @@
       return false;
   }
 
   Pickle pickle(histogram_info.data(),
                 static_cast<int>(histogram_info.size()));
   void* iter = NULL;
   size_t bucket_count;
   int declared_min;
   int declared_max;
   int histogram_type;
-  int flags;
+  int pickle_flags;
   std::string histogram_name;
   SampleSet sample;
 
   if (!pickle.ReadString(&iter, &histogram_name) ||
       !pickle.ReadInt(&iter, &declared_min) ||
       !pickle.ReadInt(&iter, &declared_max) ||
       !pickle.ReadSize(&iter, &bucket_count) ||
       !pickle.ReadInt(&iter, &histogram_type) ||
-      !pickle.ReadInt(&iter, &flags) ||
+      !pickle.ReadInt(&iter, &pickle_flags) ||
       !sample.Histogram::SampleSet::Deserialize(&iter, pickle)) {
     LOG(ERROR) << "Picke error decoding Histogram: " << histogram_name;
     return false;
   }
+  Flags flags = static_cast<Flags>(pickle_flags & ~kIPCSerializationSourceFlag);
 
   DCHECK(histogram_type != NOT_VALID_IN_RENDERER);
 
   scoped_refptr<Histogram> render_histogram(NULL);
 
   if (histogram_type ==  HISTOGRAM) {
-    render_histogram = Histogram::HistogramFactoryGet(
-        histogram_name, declared_min, declared_max, bucket_count);
+    render_histogram = Histogram::FactoryGet(
+        histogram_name, declared_min, declared_max, bucket_count, flags);
   } else if (histogram_type == LINEAR_HISTOGRAM) {
-    render_histogram = LinearHistogram::LinearHistogramFactoryGet(
-        histogram_name, declared_min, declared_max, bucket_count);
+    render_histogram = LinearHistogram::FactoryGet(
+        histogram_name, declared_min, declared_max, bucket_count, flags);
   } else if (histogram_type == BOOLEAN_HISTOGRAM) {
-    render_histogram = BooleanHistogram::BooleanHistogramFactoryGet(
-        histogram_name);
-  } else if (histogram_type == THREAD_SAFE_HISTOGRAM) {
-    render_histogram =
-        ThreadSafeHistogram::ThreadSafeHistogramFactoryGet(
-            histogram_name, declared_min, declared_max, bucket_count);
+    render_histogram = BooleanHistogram::FactoryGet(histogram_name, flags);
   } else {
     LOG(ERROR) << "Error Deserializing Histogram Unknown histogram_type: " <<
         histogram_type;
     return false;
   }
 
   DCHECK(declared_min == render_histogram->declared_min());
   DCHECK(declared_max == render_histogram->declared_max());
   DCHECK(bucket_count == render_histogram->bucket_count());
   DCHECK(histogram_type == render_histogram->histogram_type());
 
   if (render_histogram->flags() & kIPCSerializationSourceFlag) {
     DLOG(INFO) << "Single process mode, histogram observed and not copied: " <<
         histogram_name;
   } else {
+    DCHECK(flags == (flags & render_histogram->flags()));
     render_histogram->AddSampleSet(sample);
-    render_histogram->SetFlags(flags & ~kIPCSerializationSourceFlag
-                               & ~kPlannedLeakFlag);
   }
 
   return true;
 }
 
 //------------------------------------------------------------------------------
 // Methods for the Histogram::SampleSet class
 //------------------------------------------------------------------------------
 
 Histogram::SampleSet::SampleSet()
@@ skipping 10 matching lines @@
   DCHECK(counts_.size() == histogram.bucket_count());
 }
 
 
 void Histogram::SampleSet::Accumulate(Sample value,  Count count,
                                       size_t index) {
   DCHECK(count == 1 || count == -1);
   counts_[index] += count;
   sum_ += count * value;
   square_sum_ += (count * value) * static_cast<int64>(value);
-  DCHECK(counts_[index] >= 0);
-  DCHECK(sum_ >= 0);
-  DCHECK(square_sum_ >= 0);
+  DCHECK_GE(counts_[index], 0);
+  DCHECK_GE(sum_, 0);
+  DCHECK_GE(square_sum_, 0);
 }
 
 Count Histogram::SampleSet::TotalCount() const {
   Count total = 0;
   for (Counts::const_iterator it = counts_.begin();
        it != counts_.end();
        ++it) {
     total += *it;
   }
   return total;
 }
 
 void Histogram::SampleSet::Add(const SampleSet& other) {
   DCHECK(counts_.size() == other.counts_.size());
   sum_ += other.sum_;
   square_sum_ += other.square_sum_;
   for (size_t index = 0; index < counts_.size(); ++index)
     counts_[index] += other.counts_[index];
 }
 
 void Histogram::SampleSet::Subtract(const SampleSet& other) {
   DCHECK(counts_.size() == other.counts_.size());
   // Note: Race conditions in snapshotting a sum or square_sum may lead to
   // (temporary) negative values when snapshots are later combined (and deltas
   // calculated).  As a result, we don't currently CHCEK() for positive values.
   sum_ -= other.sum_;
   square_sum_ -= other.square_sum_;
   for (size_t index = 0; index < counts_.size(); ++index) {
     counts_[index] -= other.counts_[index];
-    DCHECK(counts_[index] >= 0);
+    DCHECK_GE(counts_[index], 0);
   }
 }
 
 bool Histogram::SampleSet::Serialize(Pickle* pickle) const {
   pickle->WriteInt64(sum_);
   pickle->WriteInt64(square_sum_);
   pickle->WriteSize(counts_.size());
 
   for (size_t index = 0; index < counts_.size(); ++index) {
     pickle->WriteInt(counts_[index]);
   }
 
   return true;
 }
 
 bool Histogram::SampleSet::Deserialize(void** iter, const Pickle& pickle) {
-  DCHECK(counts_.size() == 0);
-  DCHECK(sum_ == 0);
-  DCHECK(square_sum_ == 0);
+  DCHECK_EQ(counts_.size(), 0u);
+  DCHECK_EQ(sum_, 0);
+  DCHECK_EQ(square_sum_, 0);
 
   size_t counts_size;
 
   if (!pickle.ReadInt64(iter, &sum_) ||
       !pickle.ReadInt64(iter, &square_sum_) ||
       !pickle.ReadSize(iter, &counts_size)) {
     return false;
   }
 
   if (counts_size <= 0)
     return false;
 
   counts_.resize(counts_size, 0);
   for (size_t index = 0; index < counts_size; ++index) {
     if (!pickle.ReadInt(iter, &counts_[index])) {
       return false;
     }
   }
 
   return true;
 }
 
 //------------------------------------------------------------------------------
 // LinearHistogram: This histogram uses a traditional set of evenly spaced
 // buckets.
 //------------------------------------------------------------------------------
 
-scoped_refptr<Histogram> LinearHistogram::LinearHistogramFactoryGet(
+scoped_refptr<Histogram> LinearHistogram::FactoryGet(
     const std::string& name, Sample minimum, Sample maximum,
-    size_t bucket_count) {
+    size_t bucket_count, Flags flags) {
   scoped_refptr<Histogram> histogram(NULL);
 
   if (minimum <= 0)
     minimum = 1;
   if (maximum >= kSampleType_MAX)
     maximum = kSampleType_MAX - 1;
 
   if (StatisticsRecorder::FindHistogram(name, &histogram)) {
     DCHECK(histogram.get() != NULL);
   } else {
     histogram = new LinearHistogram(name, minimum, maximum, bucket_count);
     scoped_refptr<Histogram> registered_histogram(NULL);
     StatisticsRecorder::FindHistogram(name, &registered_histogram);
     if (registered_histogram.get() != NULL &&
         registered_histogram.get() != histogram.get())
       histogram = registered_histogram;
   }
 
   DCHECK(LINEAR_HISTOGRAM == histogram->histogram_type());
   DCHECK(histogram->HasConstructorArguments(minimum, maximum, bucket_count));
-
+  histogram->SetFlags(flags);
   return histogram;
 }
 
-scoped_refptr<Histogram> LinearHistogram::LinearHistogramFactoryGet(
-    const std::string& name, base::TimeDelta minimum, base::TimeDelta maximum,
-    size_t bucket_count) {
-  return LinearHistogramFactoryGet(name, minimum.InMilliseconds(),
-      maximum.InMilliseconds(), bucket_count);
+scoped_refptr<Histogram> LinearHistogram::FactoryGet(const std::string& name,
+    base::TimeDelta minimum, base::TimeDelta maximum, size_t bucket_count,
+    Flags flags) {
+  return FactoryGet(name, minimum.InMilliseconds(), maximum.InMilliseconds(),
+                    bucket_count, flags);
 }
 
 LinearHistogram::LinearHistogram(const std::string& name, Sample minimum,
     Sample maximum, size_t bucket_count)
     : Histogram(name, minimum >= 1 ? minimum : 1, maximum, bucket_count) {
   InitializeBucketRange();
   DCHECK(ValidateBucketRanges());
 }
 
 LinearHistogram::LinearHistogram(const std::string& name,
@@ skipping 20 matching lines @@
     return Histogram::GetAsciiBucketRange(i);
   return it->second;
 }
 
 bool LinearHistogram::PrintEmptyBucket(size_t index) const {
   return bucket_description_.find(ranges(index)) == bucket_description_.end();
 }
 
 
 void LinearHistogram::InitializeBucketRange() {
-  DCHECK(0 < declared_min());  // 0 is the underflow bucket here.
+  DCHECK_LT(0, declared_min());  // 0 is the underflow bucket here.
   double min = declared_min();
   double max = declared_max();
   size_t i;
   for (i = 1; i < bucket_count(); ++i) {
     double linear_range = (min * (bucket_count() -1 - i) + max * (i - 1)) /
                           (bucket_count() - 2);
     SetBucketRange(i, static_cast<int> (linear_range + 0.5));
   }
 }
 
 double LinearHistogram::GetBucketSize(Count current, size_t i) const {
   DCHECK(ranges(i + 1) > ranges(i));
   // Adjacent buckets with different widths would have "surprisingly" many (few)
   // samples in a histogram if we didn't normalize this way.
   double denominator = ranges(i + 1) - ranges(i);
   return current/denominator;
 }
 
 //------------------------------------------------------------------------------
 // This section provides implementation for BooleanHistogram.
 //------------------------------------------------------------------------------
 
-scoped_refptr<Histogram> BooleanHistogram::BooleanHistogramFactoryGet(
-    const std::string& name) {
+scoped_refptr<Histogram> BooleanHistogram::FactoryGet(const std::string& name,
+                                                      Flags flags) {
   scoped_refptr<Histogram> histogram(NULL);
 
   if (StatisticsRecorder::FindHistogram(name, &histogram)) {
     DCHECK(histogram.get() != NULL);
   } else {
     histogram = new BooleanHistogram(name);
     scoped_refptr<Histogram> registered_histogram(NULL);
     StatisticsRecorder::FindHistogram(name, &registered_histogram);
     if (registered_histogram.get() != NULL &&
         registered_histogram.get() != histogram.get())
       histogram = registered_histogram;
   }
 
   DCHECK(BOOLEAN_HISTOGRAM == histogram->histogram_type());
-
+  histogram->SetFlags(flags);
   return histogram;
 }
 
-//------------------------------------------------------------------------------
-// This section provides implementation for ThreadSafeHistogram.
-//------------------------------------------------------------------------------
-
-scoped_refptr<Histogram> ThreadSafeHistogram::ThreadSafeHistogramFactoryGet(
-    const std::string& name, Sample minimum, Sample maximum,
-    size_t bucket_count) {
-  scoped_refptr<Histogram> histogram(NULL);
-
-  if (minimum <= 0)
-    minimum = 1;
-  if (maximum >= kSampleType_MAX)
-    maximum = kSampleType_MAX - 1;
-
-  if (StatisticsRecorder::FindHistogram(name, &histogram)) {
-    DCHECK(histogram.get() != NULL);
-  } else {
-    histogram = new ThreadSafeHistogram(name, minimum, maximum, bucket_count);
-    scoped_refptr<Histogram> registered_histogram(NULL);
-    StatisticsRecorder::FindHistogram(name, &registered_histogram);
-    if (registered_histogram.get() != NULL &&
-        registered_histogram.get() != histogram.get())
-      histogram = registered_histogram;
-  }
-
-  DCHECK(THREAD_SAFE_HISTOGRAM == histogram->histogram_type());
-  DCHECK(histogram->HasConstructorArguments(minimum, maximum, bucket_count));
-  return histogram;
-}
-
-ThreadSafeHistogram::ThreadSafeHistogram(const std::string& name,
-     Sample minimum, Sample maximum, size_t bucket_count)
-    : Histogram(name, minimum, maximum, bucket_count),
-      lock_() {
-  }
-
-void ThreadSafeHistogram::Remove(int value) {
-  if (value >= kSampleType_MAX)
-    value = kSampleType_MAX - 1;
-  size_t index = BucketIndex(value);
-  Accumulate(value, -1, index);
-}
-
-void ThreadSafeHistogram::Accumulate(Sample value, Count count, size_t index) {
-  AutoLock lock(lock_);
-  Histogram::Accumulate(value, count, index);
-}
-
-void ThreadSafeHistogram::SnapshotSample(SampleSet* sample) const {
-  AutoLock lock(lock_);
-  Histogram::SnapshotSample(sample);
-};
-
 
 //------------------------------------------------------------------------------
 // The next section handles global (central) support for all histograms, as well
 // as startup/teardown of this service.
 //------------------------------------------------------------------------------
 
 // This singleton instance should be started during the single threaded portion
 // of main(), and hence it is not thread safe.  It initializes globals to
 // provide support for all future calls.
 StatisticsRecorder::StatisticsRecorder() {
@@ skipping 99 matching lines @@
 
 // static
 void StatisticsRecorder::GetHistogramsForRenderer(Histograms* output) {
   if (!histograms_)
     return;
   AutoLock auto_lock(*lock_);
   for (HistogramMap::iterator it = histograms_->begin();
        histograms_->end() != it;
        ++it) {
     scoped_refptr<Histogram> histogram = it->second;
-    if (!(histogram->flags() & kIPCSerializationSourceFlag))
-      histogram->SetFlags(kIPCSerializationSourceFlag);
+    if (!(histogram->flags() & Histogram::kIPCSerializationSourceFlag))
+      histogram->SetFlags(Histogram::kIPCSerializationSourceFlag);
     output->push_back(histogram);
   }
 }
 
 bool StatisticsRecorder::FindHistogram(const std::string& name,
                                        scoped_refptr<Histogram>* histogram) {
   if (!histograms_)
     return false;
   AutoLock auto_lock(*lock_);
   HistogramMap::iterator it = histograms_->find(name);
@@ skipping 14 matching lines @@
       snapshot->push_back(it->second);
   }
 }
 
 // static
 StatisticsRecorder::HistogramMap* StatisticsRecorder::histograms_ = NULL;
 // static
 Lock* StatisticsRecorder::lock_ = NULL;
 // static
 bool StatisticsRecorder::dump_on_exit_ = false;