SampleSet -> HistogramSamples (will be reused by SparseHistogram)

net/disk_cache/stats.cc

 // Copyright (c) 2011 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 "net/disk_cache/stats.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/metrics/histogram_samples.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "net/disk_cache/backend_impl.h"
 
 namespace {
 
 const int32 kDiskSignature = 0xF01427E0;
 
 struct OnDiskStats {
   int32 signature;
@@ skipping 124 matching lines @@
   // It seems impossible to support this histogram for more than one
   // simultaneous objects with the current infrastructure.
   static bool first_time = true;
   if (first_time) {
     first_time = false;
     // ShouldReportAgain() will re-enter this object.
     if (!size_histogram_ && backend->cache_type() == net::DISK_CACHE &&
         backend->ShouldReportAgain()) {
       // Stats may be reused when the cache is re-created, but we want only one
       // histogram at any given time.
-      size_histogram_ =
-          StatsHistogram::FactoryGet("DiskCache.SizeStats");
-      size_histogram_->Init(this);
+      size_histogram_ = StatsHistogram::FactoryGet("DiskCache.SizeStats", this);
     }
   }
 
   return true;
 }
 
 void Stats::ModifyStorageStats(int32 old_size, int32 new_size) {
   // We keep a counter of the data block size on an array where each entry is
   // the adjusted log base 2 of the size. The first entry counts blocks of 256
   // bytes, the second blocks up to 512 bytes, etc. With 20 entries, the last
@@ skipping 91 matching lines @@
   if (i > static_cast<size_t>(kDataSizesLength)) {
     NOTREACHED();
     i = kDataSizesLength;
   }
 
   i -= 17;
   n <<= i;
   return n;
 }
 
-void Stats::Snapshot(StatsHistogram::StatsSamples* samples) const {
-  samples->GetCounts()->resize(kDataSizesLength);
+void Stats::Snapshot(base::HistogramSamples* samples) const {
   for (int i = 0; i < kDataSizesLength; i++) {
     int count = data_sizes_[i];
     if (count < 0)
       count = 0;
-    samples->GetCounts()->at(i) = count;
+    samples->Accumulate(GetBucketRange(i), count);
   }
 }
 
 // The array will be filled this way:
 //  index      size
 //    0       [0, 1024)
 //    1    [1024, 2048)
 //    2    [2048, 4096)
 //    3      [4K, 6K)
 //      ...
@@ skipping 36 matching lines @@
 int Stats::GetRatio(Counters hit, Counters miss) const {
   int64 ratio = GetCounter(hit) * 100;
   if (!ratio)
     return 0;
 
   ratio /= (GetCounter(hit) + GetCounter(miss));
   return static_cast<int>(ratio);
 }
 
 }  // namespace disk_cache