Histogram type support in HistogramBase and remove SetRangeDescription function

base/metrics/histogram.cc

 // 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).
 // See header file for details and examples.
 
 #include "base/metrics/histogram.h"
@@ skipping 10 matching lines @@
 #include "base/metrics/statistics_recorder.h"
 #include "base/pickle.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/values.h"
 
 using std::string;
 using std::vector;
 
-namespace {
-
-std::string ClassTypeToString(base::Histogram::ClassType type) {
-  switch(type) {
-    case base::Histogram::HISTOGRAM:
-      return "HISTOGRAM";
-      break;
-    case base::Histogram::LINEAR_HISTOGRAM:
-      return "LINEAR_HISTOGRAM";
-      break;
-    case base::Histogram::BOOLEAN_HISTOGRAM:
-      return "BOOLEAN_HISTOGRAM";
-      break;
-    case base::Histogram::CUSTOM_HISTOGRAM:
-      return "CUSTOM_HISTOGRAM";
-      break;
-    default:
-      NOTREACHED();
-      break;
-  }
-  return "UNKNOWN";
-}
-
-}  // namespace
-
 namespace base {
 
 typedef HistogramBase::Count Count;
 typedef HistogramBase::Sample Sample;
 
 // static
 const size_t Histogram::kBucketCount_MAX = 16384u;
 
 // TODO(rtenneti): delete this code after debugging.
 void CheckCorruption(const Histogram& histogram, bool new_histogram) {
@@ skipping 39 matching lines @@
         new Histogram(name, minimum, maximum, bucket_count, registered_ranges);
     CheckCorruption(*tentative_histogram, true);
 
     tentative_histogram->SetFlags(flags);
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
   // TODO(rtenneti): delete this code after debugging.
   CheckCorruption(*histogram, false);
 
-  CHECK_EQ(HISTOGRAM, histogram->histogram_type());
+  CHECK_EQ(HISTOGRAM, histogram->GetHistogramType());
   CHECK(histogram->HasConstructionArguments(minimum, maximum, bucket_count));
   return histogram;
 }
 
 Histogram* Histogram::FactoryTimeGet(const string& name,
                                      TimeDelta minimum,
                                      TimeDelta maximum,
                                      size_t bucket_count,
                                      int32 flags) {
   return FactoryGet(name, minimum.InMilliseconds(), maximum.InMilliseconds(),
@@ skipping 53 matching lines @@
 }
 
 void Histogram::AddSamples(const HistogramSamples& samples) {
   samples_->Add(samples);
 }
 
 bool Histogram::AddSamplesFromPickle(PickleIterator* iter) {
   return samples_->AddFromPickle(iter);
 }
 
-void Histogram::SetRangeDescriptions(const DescriptionPair descriptions[]) {
-  DCHECK(false);
-}
-
 // static
 string Histogram::SerializeHistogramInfo(const Histogram& histogram,
                                          const HistogramSamples& snapshot) {
-  DCHECK_NE(NOT_VALID_IN_RENDERER, histogram.histogram_type());

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

Please double-check with Jim that this is ok to remove, as I don't know the
history for why it was added in the first place.

   DCHECK(histogram.bucket_ranges()->HasValidChecksum());
 
   Pickle pickle;
   pickle.WriteString(histogram.histogram_name());
   pickle.WriteInt(histogram.declared_min());
   pickle.WriteInt(histogram.declared_max());
   pickle.WriteUInt64(histogram.bucket_count());
   pickle.WriteUInt32(histogram.bucket_ranges()->checksum());
-  pickle.WriteInt(histogram.histogram_type());
+  pickle.WriteInt(histogram.GetHistogramType());
   pickle.WriteInt(histogram.flags());
 
   histogram.SerializeRanges(&pickle);
 
   snapshot.Serialize(&pickle);
 
   return string(static_cast<const char*>(pickle.data()), pickle.size());
 }
 
 // static
@@ skipping 28 matching lines @@
   // Since these fields may have come from an untrusted renderer, do additional
   // checks above and beyond those in Histogram::Initialize()
   if (declared_max <= 0 || declared_min <= 0 || declared_max < declared_min ||
       INT_MAX / sizeof(Count) <= bucket_count || bucket_count < 2) {
     DLOG(ERROR) << "Values error decoding Histogram: " << histogram_name;
     return false;
   }
 
   Flags flags = static_cast<Flags>(pickle_flags & ~kIPCSerializationSourceFlag);
 
-  DCHECK_NE(NOT_VALID_IN_RENDERER, histogram_type);
-
   Histogram* render_histogram(NULL);
 
   if (histogram_type == HISTOGRAM) {
     render_histogram = Histogram::FactoryGet(
         histogram_name, declared_min, declared_max, bucket_count, flags);
   } else if (histogram_type == LINEAR_HISTOGRAM) {
     render_histogram = LinearHistogram::FactoryGet(
         histogram_name, declared_min, declared_max, bucket_count, flags);
   } else if (histogram_type == BOOLEAN_HISTOGRAM) {
     render_histogram = BooleanHistogram::FactoryGet(histogram_name, flags);
   } else if (histogram_type == CUSTOM_HISTOGRAM) {
     vector<Sample> sample_ranges(bucket_count);
     if (!CustomHistogram::DeserializeRanges(&iter, &sample_ranges)) {
       DLOG(ERROR) << "Pickle error decoding ranges: " << histogram_name;
       return false;
     }
     render_histogram =
         CustomHistogram::FactoryGet(histogram_name, sample_ranges, flags);
   } else {
     DLOG(ERROR) << "Error Deserializing Histogram Unknown histogram_type: "
                 << histogram_type;
     return false;
   }
 
   DCHECK_EQ(render_histogram->declared_min(), declared_min);
   DCHECK_EQ(render_histogram->declared_max(), declared_max);
   DCHECK_EQ(render_histogram->bucket_count(), bucket_count);
-  DCHECK_EQ(render_histogram->histogram_type(), histogram_type);
+  DCHECK_EQ(render_histogram->GetHistogramType(), histogram_type);
 
   if (render_histogram->bucket_ranges()->checksum() != range_checksum) {
     return false;
   }
 
   if (render_histogram->flags() & kIPCSerializationSourceFlag) {
     DVLOG(1) << "Single process mode, histogram observed and not copied: "
              << histogram_name;
     return true;
   }
@@ skipping 31 matching lines @@
     } else {
       DCHECK_GT(0, delta);
       UMA_HISTOGRAM_COUNTS("Histogram.InconsistentCountLow", -delta);
       if (-delta > kCommonRaceBasedCountMismatch)
         inconsistencies |= COUNT_LOW_ERROR;
     }
   }
   return static_cast<Inconsistencies>(inconsistencies);
 }
 
-Histogram::ClassType Histogram::histogram_type() const {
-  return HISTOGRAM;
-}
-
 Sample Histogram::ranges(size_t i) const {
   return bucket_ranges_->range(i);
 }
 
 size_t Histogram::bucket_count() const {
   return bucket_count_;
 }
 
 // static
 bool Histogram::InspectConstructionArguments(const string& name,
@@ skipping 17 matching lines @@
 
   if (*minimum >= *maximum)
     return false;
   if (*bucket_count < 3)
     return false;
   if (*bucket_count > static_cast<size_t>(*maximum - *minimum + 2))
     return false;
   return true;
 }
 
+HistogramType Histogram::GetHistogramType() const {
+  return HISTOGRAM;
+}
+
 bool Histogram::HasConstructionArguments(Sample minimum,
                                          Sample maximum,
                                          size_t bucket_count) const {
   return ((minimum == declared_min_) && (maximum == declared_max_) &&
           (bucket_count == bucket_count_));
 }
 
 void Histogram::Add(int value) {
   DCHECK_EQ(0, ranges(0));
   DCHECK_EQ(kSampleType_MAX, ranges(bucket_count_));
@@ skipping 206 matching lines @@
   int x_remainder = k_line_length - x_count;
 
   while (0 < x_count--)
     output->append("-");
   output->append("O");
   while (0 < x_remainder--)
     output->append(" ");
 }
 
 void Histogram::GetParameters(DictionaryValue* params) const {
-  params->SetString("type", ClassTypeToString(histogram_type()));
+  params->SetString("type", HistogramTypeName(GetHistogramType()));
   params->SetInteger("min", declared_min());
   params->SetInteger("max", declared_max());
   params->SetInteger("bucket_count", static_cast<int>(bucket_count()));
 }
 
 void Histogram::GetCountAndBucketData(Count* count, ListValue* buckets) const {
   scoped_ptr<SampleVector> snapshot = SnapshotSampleVector();
   *count = snapshot->TotalCount();
   size_t index = 0;
   for (size_t i = 0; i < bucket_count(); ++i) {
@@ skipping 15 matching lines @@
 // buckets.
 //------------------------------------------------------------------------------
 
 LinearHistogram::~LinearHistogram() {}
 
 Histogram* LinearHistogram::FactoryGet(const string& name,
                                        Sample minimum,
                                        Sample maximum,
                                        size_t bucket_count,
                                        int32 flags) {
+  return FactoryGetWithRangeDescription(
+      name, minimum, maximum, bucket_count, flags, NULL);
+}
+
+Histogram* LinearHistogram::FactoryTimeGet(const string& name,
+                                           TimeDelta minimum,
+                                           TimeDelta maximum,
+                                           size_t bucket_count,
+                                           int32 flags) {
+  return FactoryGet(name, minimum.InMilliseconds(), maximum.InMilliseconds(),
+                    bucket_count, flags);
+}
+
+Histogram* LinearHistogram::FactoryGetWithRangeDescription(
+      const std::string& name,
+      Sample minimum,
+      Sample maximum,
+      size_t bucket_count,
+      int32 flags,
+      const DescriptionPair descriptions[]) {
   bool valid_arguments = Histogram::InspectConstructionArguments(
       name, &minimum, &maximum, &bucket_count);
   DCHECK(valid_arguments);
 
   Histogram* histogram = StatisticsRecorder::FindHistogram(name);
   if (!histogram) {
     // To avoid racy destruction at shutdown, the following will be leaked.
     BucketRanges* ranges = new BucketRanges(bucket_count + 1);
     InitializeBucketRanges(minimum, maximum, bucket_count, ranges);
     const BucketRanges* registered_ranges =
         StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
 
     LinearHistogram* tentative_histogram =
         new LinearHistogram(name, minimum, maximum, bucket_count,
                             registered_ranges);
     CheckCorruption(*tentative_histogram, true);
 
+    // Set range descriptions.
+    if (descriptions != NULL) {

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

nit: This is usually written as "if (descriptions)"

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

Done.

+      for (int i =0; descriptions[i].description; ++i) {

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

nit: "=0" -> "= 0"

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

Done.

+        tentative_histogram->bucket_description_[descriptions[i].sample] =
+            descriptions[i].description;
+      }
+    }
+
     tentative_histogram->SetFlags(flags);
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
   // TODO(rtenneti): delete this code after debugging.
   CheckCorruption(*histogram, false);
 
-  CHECK_EQ(LINEAR_HISTOGRAM, histogram->histogram_type());
+  CHECK_EQ(LINEAR_HISTOGRAM, histogram->GetHistogramType());
   CHECK(histogram->HasConstructionArguments(minimum, maximum, bucket_count));
   return histogram;
 }
 
-Histogram* LinearHistogram::FactoryTimeGet(const string& name,
-                                           TimeDelta minimum,
-                                           TimeDelta maximum,
-                                           size_t bucket_count,
-                                           int32 flags) {
-  return FactoryGet(name, minimum.InMilliseconds(), maximum.InMilliseconds(),
-                    bucket_count, flags);
-}
-
-Histogram::ClassType LinearHistogram::histogram_type() const {
+HistogramType LinearHistogram::GetHistogramType() 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;
-  }
-}
-
 LinearHistogram::LinearHistogram(const string& name,
                                  Sample minimum,
                                  Sample maximum,
                                  size_t bucket_count,
                                  const BucketRanges* ranges)
     : Histogram(name, minimum, maximum, bucket_count, ranges) {
 }
 
 double LinearHistogram::GetBucketSize(Count current, size_t i) const {
   DCHECK_GT(ranges(i + 1), ranges(i));
@@ skipping 50 matching lines @@
         new BooleanHistogram(name, registered_ranges);
     CheckCorruption(*tentative_histogram, true);
 
     tentative_histogram->SetFlags(flags);
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
   // TODO(rtenneti): delete this code after debugging.
   CheckCorruption(*histogram, false);
 
-  CHECK_EQ(BOOLEAN_HISTOGRAM, histogram->histogram_type());
+  CHECK_EQ(BOOLEAN_HISTOGRAM, histogram->GetHistogramType());
   return histogram;
 }
 
-Histogram::ClassType BooleanHistogram::histogram_type() const {
+HistogramType BooleanHistogram::GetHistogramType() const {
   return BOOLEAN_HISTOGRAM;
 }
 
 void BooleanHistogram::AddBoolean(bool value) {
   Add(value ? 1 : 0);
 }
 
 BooleanHistogram::BooleanHistogram(const string& name,
                                    const BucketRanges* ranges)
     : LinearHistogram(name, 1, 2, 3, ranges) {}
@@ skipping 19 matching lines @@
     CheckCorruption(*tentative_histogram, true);
 
     tentative_histogram->SetFlags(flags);
 
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
   // TODO(rtenneti): delete this code after debugging.
   CheckCorruption(*histogram, false);
 
-  CHECK_EQ(histogram->histogram_type(), CUSTOM_HISTOGRAM);
+  CHECK_EQ(histogram->GetHistogramType(), CUSTOM_HISTOGRAM);
   return histogram;
 }
 
-Histogram::ClassType CustomHistogram::histogram_type() const {
+HistogramType CustomHistogram::GetHistogramType() const {
   return CUSTOM_HISTOGRAM;
 }
 
 // static
 vector<Sample> CustomHistogram::ArrayToCustomRanges(
     const Sample* values, size_t num_values) {
   vector<Sample> all_values;
   for (size_t i = 0; i < num_values; ++i) {
     Sample value = values[i];
     all_values.push_back(value);
@@ skipping 61 matching lines @@
 
   BucketRanges* bucket_ranges = new BucketRanges(ranges.size());
   for (size_t i = 0; i < ranges.size(); i++) {
     bucket_ranges->set_range(i, ranges[i]);
   }
   bucket_ranges->ResetChecksum();
   return bucket_ranges;
 }
 
 }  // namespace base