Histogram - Checks to cacth corruption in bucket ranges

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"
 
 #include <math.h>
 
 #include <algorithm>
 #include <string>
 
+#include "base/compiler_specific.h"
+#include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/pickle.h"
+#include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/lock.h"
 
 using std::string;
 using std::vector;
 
 namespace base {
 
 typedef HistogramBase::Count Count;
 typedef HistogramBase::Sample Sample;
@@ skipping 92 matching lines @@
     int i;
     if (!iter->ReadInt(&i))
       return false;
     counts_.push_back(i);
     count += i;
   }
   DCHECK_EQ(count, redundant_count_);
   return count == redundant_count_;
 }
 
+// TODO(rtenneti): delete this code after debugging.
+void CheckCorruption(const Histogram& histogram) {
+  const std::string& histogram_name = histogram.histogram_name();
+  char histogram_name_buf[128];
+  base::strlcpy(histogram_name_buf,
+                histogram_name.c_str(),
+                arraysize(histogram_name_buf));
+  base::debug::Alias(histogram_name_buf);
+
+  Sample previous_range = -1;  // Bottom range is always 0.
+  for (size_t index = 0; index < histogram.bucket_count(); ++index) {
+    int new_range = histogram.ranges(index);
+    if (previous_range >= new_range) {
+      CHECK(false);  // Crash for the bucket order corruption.
+    }
+    previous_range = new_range;
+  }
+
+  if (!histogram.bucket_ranges()->HasValidChecksum()) {
+    CHECK(false);  // Crash for the checksum corruption.
+  }
+}
+
 Histogram* Histogram::FactoryGet(const string& name,
                                  Sample minimum,
                                  Sample maximum,
                                  size_t bucket_count,
                                  int32 flags) {
   bool valid_arguments =
       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);
 
     Histogram* tentative_histogram =
         new Histogram(name, minimum, maximum, bucket_count, registered_ranges);
     tentative_histogram->SetFlags(flags);
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
+  // TODO(rtenneti): delete this code after debugging.
+  CheckCorruption(*histogram);
 
   CHECK_EQ(HISTOGRAM, histogram->histogram_type());
   CHECK(histogram->HasConstructionArguments(minimum, maximum, bucket_count));
   return histogram;
 }
 
 Histogram* Histogram::FactoryTimeGet(const string& name,
                                      TimeDelta minimum,
                                      TimeDelta maximum,
                                      size_t bucket_count,
@@ skipping 532 matching lines @@
     const BucketRanges* registered_ranges =
         StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
 
     LinearHistogram* tentative_histogram =
         new LinearHistogram(name, minimum, maximum, bucket_count,
                             registered_ranges);
     tentative_histogram->SetFlags(flags);
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
+  // TODO(rtenneti): delete this code after debugging.
+  CheckCorruption(*histogram);
 
   CHECK_EQ(LINEAR_HISTOGRAM, histogram->histogram_type());
   CHECK(histogram->HasConstructionArguments(minimum, maximum, bucket_count));
   return histogram;
 }
 
 Histogram* LinearHistogram::FactoryTimeGet(const string& name,
                                            TimeDelta minimum,
                                            TimeDelta maximum,
                                            size_t bucket_count,
@@ skipping 71 matching lines @@
     LinearHistogram::InitializeBucketRanges(1, 2, 3, ranges);
     const BucketRanges* registered_ranges =
         StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
 
     BooleanHistogram* tentative_histogram =
         new BooleanHistogram(name, registered_ranges);
     tentative_histogram->SetFlags(flags);
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
+  // TODO(rtenneti): delete this code after debugging.
+  CheckCorruption(*histogram);
 
   CHECK_EQ(BOOLEAN_HISTOGRAM, histogram->histogram_type());
   return histogram;
 }
 
 Histogram::ClassType BooleanHistogram::histogram_type() const {
   return BOOLEAN_HISTOGRAM;
 }
 
 void BooleanHistogram::AddBoolean(bool value) {
@@ skipping 20 matching lines @@
         StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
 
     // To avoid racy destruction at shutdown, the following will be leaked.
     CustomHistogram* tentative_histogram =
         new CustomHistogram(name, registered_ranges);
     tentative_histogram->SetFlags(flags);
 
     histogram =
         StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
   }
+  // TODO(rtenneti): delete this code after debugging.
+  CheckCorruption(*histogram);
 
   CHECK_EQ(histogram->histogram_type(), CUSTOM_HISTOGRAM);
   return histogram;
 }
 
 Histogram::ClassType CustomHistogram::histogram_type() const {
   return CUSTOM_HISTOGRAM;
 }
 
 // static
@@ skipping 67 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