Fix overflow when logging MaxInt32 to a sparse histogram.

base/metrics/sample_vector.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.
 
 #include "base/metrics/sample_vector.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/persistent_memory_allocator.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 
 // This SampleVector makes use of the single-sample embedded in the base
 // HistogramSamples class. If the count is non-zero then there is guaranteed
 // (within the bounds of "eventual consistency") to be no allocated external
 // storage. Once the full counts storage is allocated, the single-sample must
 // be extracted and disabled.
 
 namespace base {
@@ skipping 33 matching lines @@
       return;
     }
 
     // Need real storage to store both what was in the single-sample plus the
     // parameter information.
     MountCountsStorageAndMoveSingleSample();
   }
 
   // Handle the multi-sample case.
   subtle::NoBarrier_AtomicIncrement(&counts()[bucket_index], count);
-  IncreaseSumAndCount(static_cast<int64_t>(count) * value, count);
+  IncreaseSumAndCount(strict_cast<int64_t>(count) * value, count);
 }
 
 Count SampleVectorBase::GetCount(Sample value) const {
   return GetCountAtIndex(GetBucketIndex(value));
 }
 
 Count SampleVectorBase::TotalCount() const {
   // Handle the single-sample case.
   SingleSample sample = single_sample().Load();
   if (sample.count != 0)
@@ skipping 50 matching lines @@
 }
 
 bool SampleVectorBase::AddSubtractImpl(SampleCountIterator* iter,
                                        HistogramSamples::Operator op) {
   // Stop now if there's nothing to do.
   if (iter->Done())
     return true;
 
   // Get the first value and its index.
   HistogramBase::Sample min;
-  HistogramBase::Sample max;
+  int64_t max;
   HistogramBase::Count count;
   iter->Get(&min, &max, &count);
   size_t dest_index = GetBucketIndex(min);
 
   // The destination must be a superset of the source meaning that though the
   // incoming ranges will find an exact match, the incoming bucket-index, if
   // it exists, may be offset from the destination bucket-index. Calculate
   // that offset of the passed iterator; there are are no overflow checks
   // because 2's compliment math will work it out in the end.
   //
@@ skipping 239 matching lines @@
   return index_ >= counts_size_;
 }
 
 void SampleVectorIterator::Next() {
   DCHECK(!Done());
   index_++;
   SkipEmptyBuckets();
 }
 
 void SampleVectorIterator::Get(HistogramBase::Sample* min,
-                               HistogramBase::Sample* max,
+                               int64_t* max,
                                HistogramBase::Count* count) const {
   DCHECK(!Done());
   if (min != NULL)
     *min = bucket_ranges_->range(index_);
   if (max != NULL)
-    *max = bucket_ranges_->range(index_ + 1);
+    *max = strict_cast<int64_t>(bucket_ranges_->range(index_ + 1));
   if (count != NULL)
     *count = subtle::NoBarrier_Load(&counts_[index_]);
 }
 
 bool SampleVectorIterator::GetBucketIndex(size_t* index) const {
   DCHECK(!Done());
   if (index != NULL)
     *index = index_;
   return true;
 }
 
 void SampleVectorIterator::SkipEmptyBuckets() {
   if (Done())
     return;
 
   while (index_ < counts_size_) {
     if (subtle::NoBarrier_Load(&counts_[index_]) != 0)
       return;
     index_++;
   }
 }
 
 }  // namespace base