Revert 148055 - Move CachedRanges out and add support for checksum.

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 365 matching lines @@
     }
   }
   return static_cast<Inconsistencies>(inconsistencies);
 }
 
 Histogram::ClassType Histogram::histogram_type() const {
   return HISTOGRAM;
 }
 
 Histogram::Sample Histogram::ranges(size_t i) const {
-  return bucket_ranges_->range(i);
+  return cached_ranges_->ranges(i);
 }
 
 size_t Histogram::bucket_count() const {
   return bucket_count_;
 }
 
 // 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!!!
@@ skipping 19 matching lines @@
   return CalculateRangeChecksum() == range_checksum_;
 }
 
 Histogram::Histogram(const std::string& name, Sample minimum,
                      Sample maximum, size_t bucket_count)
   : HistogramBase(name),
     declared_min_(minimum),
     declared_max_(maximum),
     bucket_count_(bucket_count),
     flags_(kNoFlags),
-    bucket_ranges_(new BucketRanges(bucket_count + 1)),
+    cached_ranges_(new CachedRanges(bucket_count + 1, 0)),
     range_checksum_(0),
     sample_() {
   Initialize();
 }
 
 Histogram::Histogram(const std::string& name, TimeDelta minimum,
                      TimeDelta maximum, size_t bucket_count)
   : HistogramBase(name),
     declared_min_(static_cast<int> (minimum.InMilliseconds())),
     declared_max_(static_cast<int> (maximum.InMilliseconds())),
     bucket_count_(bucket_count),
     flags_(kNoFlags),
-    bucket_ranges_(new BucketRanges(bucket_count + 1)),
+    cached_ranges_(new CachedRanges(bucket_count + 1, 0)),
     range_checksum_(0),
     sample_() {
   Initialize();
 }
 
 Histogram::~Histogram() {
   if (StatisticsRecorder::dump_on_exit()) {
     std::string output;
     WriteAsciiImpl(true, "\n", &output);
     DLOG(INFO) << output;
@@ skipping 100 matching lines @@
 
 // Update histogram data with new sample.
 void Histogram::Accumulate(Sample value, Count count, size_t index) {
   // Note locking not done in this version!!!
   sample_.Accumulate(value, count, index);
 }
 
 void Histogram::SetBucketRange(size_t i, Sample value) {
   DCHECK_GT(bucket_count_, i);
   DCHECK_GE(value, 0);
-  bucket_ranges_->set_range(i, value);
+  cached_ranges_->SetBucketRange(i, value);
 }
 
 bool Histogram::ValidateBucketRanges() const {
   // Standard assertions that all bucket ranges should satisfy.
-  DCHECK_EQ(bucket_count_ + 1, bucket_ranges_->size());
+  DCHECK_EQ(bucket_count_ + 1, cached_ranges_->size());
   DCHECK_EQ(0, ranges(0));
   DCHECK_EQ(declared_min(), ranges(1));
   DCHECK_EQ(declared_max(), ranges(bucket_count_ - 1));
   DCHECK_EQ(kSampleType_MAX, ranges(bucket_count_));
   return true;
 }
 
 uint32 Histogram::CalculateRangeChecksum() const {
-  DCHECK_EQ(bucket_ranges_->size(), bucket_count() + 1);
+  DCHECK_EQ(cached_ranges_->size(), bucket_count() + 1);
   // Seed checksum.
-  uint32 checksum = static_cast<uint32>(bucket_ranges_->size());
+  uint32 checksum = static_cast<uint32>(cached_ranges_->size());
   for (size_t index = 0; index < bucket_count(); ++index)
     checksum = Crc32(checksum, ranges(index));
   return checksum;
 }
 
 void Histogram::Initialize() {
   sample_.Resize(*this);
   if (declared_min_ < 1)
     declared_min_ = 1;
   if (declared_max_ > kSampleType_MAX - 1)
     declared_max_ = kSampleType_MAX - 1;
   DCHECK_LE(declared_min_, declared_max_);
   DCHECK_GT(bucket_count_, 1u);
   CHECK_LT(bucket_count_, kBucketCount_MAX);
   size_t maximal_bucket_count = declared_max_ - declared_min_ + 2;
   DCHECK_LE(bucket_count_, maximal_bucket_count);
   DCHECK_EQ(0, ranges(0));
-  bucket_ranges_->set_range(bucket_count_, kSampleType_MAX);
+  cached_ranges_->SetBucketRange(bucket_count_, kSampleType_MAX);
 }
 
 // We generate the CRC-32 using the low order bits to select whether to XOR in
 // the reversed polynomial 0xedb88320L.  This is nice and simple, and allows us
 // to keep the quotient in a uint32.  Since we're not concerned about the nature
 // of corruptions (i.e., we don't care about bit sequencing, since we are
 // handling memory changes, which are more grotesque) so we don't bother to
 // get the CRC correct for big-endian vs little-ending calculations.  All we
 // need is a nice hash, that tends to depend on all the bits of the sample, with
 // very little chance of changes in one place impacting changes in another
@@ skipping 388 matching lines @@
 
 CustomHistogram::CustomHistogram(const std::string& name,
                                  const std::vector<Sample>& 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);
 }
 
 bool CustomHistogram::SerializeRanges(Pickle* pickle) const {
-  for (size_t i = 0; i < bucket_ranges()->size(); ++i) {
-    if (!pickle->WriteInt(bucket_ranges()->range(i)))
+  for (size_t i = 0; i < cached_ranges()->size(); ++i) {
+    if (!pickle->WriteInt(cached_ranges()->ranges(i)))
       return false;
   }
   return true;
 }
 
 // static
 bool CustomHistogram::DeserializeRanges(
     PickleIterator* iter, std::vector<Histogram::Sample>* ranges) {
   for (size_t i = 0; i < ranges->size(); ++i) {
     if (!iter->ReadInt(&(*ranges)[i]))
       return false;
   }
   return true;
 }
 
 void CustomHistogram::InitializedCustomBucketRange(
     const std::vector<Sample>& custom_ranges) {
   DCHECK_GT(custom_ranges.size(), 1u);
   DCHECK_EQ(custom_ranges[0], 0);
   DCHECK_LE(custom_ranges.size(), bucket_count());
   for (size_t index = 0; index < custom_ranges.size(); ++index)
     SetBucketRange(index, custom_ranges[index]);
   ResetRangeChecksum();
 }
 
 double CustomHistogram::GetBucketSize(Count current, size_t i) const {
   return 1;
 }
 
+CachedRanges::CachedRanges(size_t bucket_count, int initial_value)
+    : ranges_(bucket_count, initial_value),
+      range_checksum_(0) {
+}
+
+CachedRanges::~CachedRanges() {
+}
+
+void CachedRanges::SetBucketRange(size_t i, Histogram::Sample value) {
+  DCHECK_LT(i, ranges_.size());
+  DCHECK_GE(value, 0);
+  ranges_[i] = value;
+}
+
+bool CachedRanges::Equals(CachedRanges* other) const {
+  if (range_checksum_ != other->range_checksum_)
+    return false;
+  if (ranges_.size() != other->ranges_.size())
+    return false;
+  for (size_t index = 0; index < ranges_.size(); ++index) {
+    if (ranges_[index] != other->ranges_[index])
+      return false;
+  }
+  return true;
+}
+
 }  // namespace base