base/ header cleanup. Forward declaration instead of including.

base/histogram.cc

 // Copyright (c) 2006-2010 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"
@@ skipping 66 matching lines @@
   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());
 }
 
+bool Histogram::PrintEmptyBucket(size_t index) const {
+  return true;
+}
+
 void Histogram::Add(int value) {
   if (value >= kSampleType_MAX)
     value = kSampleType_MAX - 1;
   if (value < 0)
     value = 0;
   size_t index = BucketIndex(value);
   DCHECK(value >= ranges(index));
   DCHECK(value < ranges(index + 1));
   Accumulate(value, 1, index);
 }
 
+void Histogram::AddBoolean(bool value) {
+  DCHECK(false);
+}
+
 void Histogram::AddSampleSet(const SampleSet& sample) {
   sample_.Add(sample);
 }
 
+void Histogram::SetRangeDescriptions(const DescriptionPair descriptions[]) {
+  DCHECK(false);
+}
+
 // The following methods provide a graphical histogram display.
 void Histogram::WriteHTMLGraph(std::string* output) const {
   // TBD(jar) Write a nice HTML bar chart, with divs an mouse-overs etc.
   output->append("<PRE>");
   WriteAscii(true, "<br>", output);
   output->append("</PRE>");
 }
 
 void Histogram::WriteAscii(bool graph_it, const std::string& newline,
                            std::string* output) const {
@@ skipping 171 matching lines @@
   sample_.Accumulate(value, count, index);
 }
 
 // Do a safe atomic snapshot of sample data.
 // This implementation assumes we are on a safe single thread.
 void Histogram::SnapshotSample(SampleSet* sample) const {
   // Note locking not done in this version!!!
   *sample = sample_;
 }
 
+bool Histogram::HasConstructorArguments(Sample minimum, Sample maximum,
+                                        size_t bucket_count) {
+  return ((minimum == declared_min_) && (maximum == declared_max_) &&
+          (bucket_count == bucket_count_));
+}
+
+bool Histogram::HasConstructorTimeDeltaArguments(base::TimeDelta minimum,
+                                                 base::TimeDelta maximum,
+                                                 size_t bucket_count) {
+  return ((minimum.InMilliseconds() == declared_min_) &&
+          (maximum.InMilliseconds() == declared_max_) &&
+          (bucket_count == bucket_count_));
+}
+
 //------------------------------------------------------------------------------
 // Accessor methods
 
 void Histogram::SetBucketRange(size_t i, Sample value) {
   DCHECK(bucket_count_ > i);
   ranges_[i] = value;
 }
 
 //------------------------------------------------------------------------------
 // Private methods
@@ skipping 303 matching lines @@
 LinearHistogram::LinearHistogram(const std::string& name,
     TimeDelta minimum, TimeDelta maximum, size_t bucket_count)
     : Histogram(name, minimum >= TimeDelta::FromMilliseconds(1) ?
                                  minimum : TimeDelta::FromMilliseconds(1),
                 maximum, bucket_count) {
   // Do a "better" (different) job at init than a base classes did...
   InitializeBucketRange();
   DCHECK(ValidateBucketRanges());
 }
 
+Histogram::ClassType LinearHistogram::histogram_type() const {
+  return LINEAR_HISTOGRAM;
+}
+
 void LinearHistogram::SetRangeDescriptions(
     const DescriptionPair descriptions[]) {
   for (int i =0; descriptions[i].description; ++i) {
     bucket_description_[descriptions[i].sample] = descriptions[i].description;
   }
 }
 
 const std::string LinearHistogram::GetAsciiBucketRange(size_t i) const {
   int range = ranges(i);
   BucketDescriptionMap::const_iterator it = bucket_description_.find(range);
@@ skipping 38 matching lines @@
   if (!StatisticsRecorder::FindHistogram(name, &histogram)) {
     histogram = new BooleanHistogram(name);
     StatisticsRecorder::FindHistogram(name, &histogram);
   }
 
   DCHECK(BOOLEAN_HISTOGRAM == histogram->histogram_type());
   histogram->SetFlags(flags);
   return histogram;
 }
 
+Histogram::ClassType BooleanHistogram::histogram_type() const {
+  return BOOLEAN_HISTOGRAM;
+}
+
+void BooleanHistogram::AddBoolean(bool value) {
+  Add(value ? 1 : 0);
+}
+
+BooleanHistogram::BooleanHistogram(const std::string& name)
+    : LinearHistogram(name, 1, 2, 3) {
+}
 
 //------------------------------------------------------------------------------
 // CustomHistogram:
 //------------------------------------------------------------------------------
 
 scoped_refptr<Histogram> CustomHistogram::FactoryGet(
     const std::string& name, const std::vector<int>& custom_ranges,
     Flags flags) {
   scoped_refptr<Histogram> histogram(NULL);
 
@@ skipping 15 matching lines @@
     StatisticsRecorder::FindHistogram(name, &histogram);
   }
 
   DCHECK_EQ(histogram->histogram_type(), CUSTOM_HISTOGRAM);
   DCHECK(histogram->HasConstructorArguments(ranges[1], ranges.back(),
                                             ranges.size()));
   histogram->SetFlags(flags);
   return histogram;
 }
 
+Histogram::ClassType CustomHistogram::histogram_type() const {
+  return CUSTOM_HISTOGRAM;
+}
+
 CustomHistogram::CustomHistogram(const std::string& name,
     const std::vector<int>& custom_ranges)
     : Histogram(name, custom_ranges[1], custom_ranges.back(),
                 custom_ranges.size()) {
   DCHECK_GT(custom_ranges.size(), 1u);
   DCHECK_EQ(custom_ranges[0], 0);
   ranges_vector_ = &custom_ranges;
   InitializeBucketRange();
   ranges_vector_ = NULL;
   DCHECK(ValidateBucketRanges());
@@ skipping 141 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;