Fix overflow when logging MaxInt32 to a sparse histogram.

base/metrics/histogram_samples.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/histogram_samples.h"
 
 #include <limits>
 
 #include "base/compiler_specific.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/numerics/safe_math.h"
 #include "base/pickle.h"
 
 namespace base {
 
 namespace {
 
 // A shorthand constant for the max value of size_t.
 constexpr size_t kSizeMax = std::numeric_limits<size_t>::max();
 
 // A constant stored in an AtomicSingleSample (as_atomic) to indicate that the
 // sample is "disabled" and no further accumulation should be done with it. The
 // value is chosen such that it will be MAX_UINT16 for both |bucket| & |count|,
 // and thus less likely to conflict with real use. Conflicts are explicitly
 // handled in the code but it's worth making them as unlikely as possible.
 constexpr int32_t kDisabledSingleSample = -1;
 
 class SampleCountPickleIterator : public SampleCountIterator {
  public:
   explicit SampleCountPickleIterator(PickleIterator* iter);
 
   bool Done() const override;
   void Next() override;
   void Get(HistogramBase::Sample* min,
-           HistogramBase::Sample* max,
+           int64_t* max,
            HistogramBase::Count* count) const override;
 
  private:
   PickleIterator* const iter_;
 
   HistogramBase::Sample min_;
-  HistogramBase::Sample max_;
+  int64_t max_;
   HistogramBase::Count count_;
   bool is_done_;
 };
 
 SampleCountPickleIterator::SampleCountPickleIterator(PickleIterator* iter)
     : iter_(iter),
       is_done_(false) {
   Next();
 }
 
 bool SampleCountPickleIterator::Done() const {
   return is_done_;
 }
 
 void SampleCountPickleIterator::Next() {
   DCHECK(!Done());
-  if (!iter_->ReadInt(&min_) ||
-      !iter_->ReadInt(&max_) ||
-      !iter_->ReadInt(&count_))
+  if (!iter_->ReadInt(&min_) || !iter_->ReadInt64(&max_) ||
+      !iter_->ReadInt(&count_)) {
     is_done_ = true;
+  }
 }
 
 void SampleCountPickleIterator::Get(HistogramBase::Sample* min,
-                                    HistogramBase::Sample* max,
+                                    int64_t* max,
                                     HistogramBase::Count* count) const {
   DCHECK(!Done());
   *min = min_;
   *max = max_;
   *count = count_;
 }
 
 }  // namespace
 
 static_assert(sizeof(HistogramSamples::AtomicSingleSample) ==
@@ skipping 137 matching lines @@
   DCHECK(success);
 }
 
 bool HistogramSamples::Serialize(Pickle* pickle) const {
   if (!pickle->WriteInt64(sum()))
     return false;
   if (!pickle->WriteInt(redundant_count()))
     return false;
 
   HistogramBase::Sample min;
-  HistogramBase::Sample max;
+  int64_t max;
   HistogramBase::Count count;
   for (std::unique_ptr<SampleCountIterator> it = Iterator(); !it->Done();
        it->Next()) {
     it->Get(&min, &max, &count);
-    if (!pickle->WriteInt(min) ||
-        !pickle->WriteInt(max) ||
-        !pickle->WriteInt(count))
+    if (!pickle->WriteInt(min) || !pickle->WriteInt64(max) ||
+        !pickle->WriteInt(count)) {
       return false;
+    }
   }
   return true;
 }
 
 bool HistogramSamples::AccumulateSingleSample(HistogramBase::Sample value,
                                               HistogramBase::Count count,
                                               size_t bucket) {
   if (single_sample().Accumulate(bucket, count)) {
     // Success. Update the (separate) sum and redundant-count.
-    IncreaseSumAndCount(static_cast<int64_t>(value) * count, count);
+    IncreaseSumAndCount(strict_cast<int64_t>(value) * count, count);
     return true;
   }
   return false;
 }
 
 void HistogramSamples::IncreaseSumAndCount(int64_t sum,
                                            HistogramBase::Count count) {
 #ifdef ARCH_CPU_64_BITS
   subtle::NoBarrier_AtomicIncrement(&meta_->sum, sum);
 #else
   meta_->sum += sum;
 #endif
   subtle::NoBarrier_AtomicIncrement(&meta_->redundant_count, count);
 }
 
 SampleCountIterator::~SampleCountIterator() {}
 
 bool SampleCountIterator::GetBucketIndex(size_t* index) const {
   DCHECK(!Done());
   return false;
 }
 
 SingleSampleIterator::SingleSampleIterator(HistogramBase::Sample min,
-                                           HistogramBase::Sample max,
+                                           int64_t max,
                                            HistogramBase::Count count)
     : SingleSampleIterator(min, max, count, kSizeMax) {}
 
 SingleSampleIterator::SingleSampleIterator(HistogramBase::Sample min,
-                                           HistogramBase::Sample max,
+                                           int64_t max,
                                            HistogramBase::Count count,
                                            size_t bucket_index)
     : min_(min), max_(max), bucket_index_(bucket_index), count_(count) {}
 
 SingleSampleIterator::~SingleSampleIterator() {}
 
 bool SingleSampleIterator::Done() const {
   return count_ == 0;
 }
 
 void SingleSampleIterator::Next() {
   DCHECK(!Done());
   count_ = 0;
 }
 
 void SingleSampleIterator::Get(HistogramBase::Sample* min,
-                               HistogramBase::Sample* max,
+                               int64_t* max,
                                HistogramBase::Count* count) const {
   DCHECK(!Done());
   if (min != nullptr)
     *min = min_;
   if (max != nullptr)
     *max = max_;
   if (count != nullptr)
     *count = count_;
 }
 
 bool SingleSampleIterator::GetBucketIndex(size_t* index) const {
   DCHECK(!Done());
   if (bucket_index_ == kSizeMax)
     return false;
   *index = bucket_index_;
   return true;
 }
 
 }  // namespace base