Convert //base to use std::unique_ptr

base/metrics/sparse_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.
 
 #include "base/metrics/sparse_histogram.h"
 
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/metrics/metrics_hashes.h"
 #include "base/metrics/persistent_histogram_allocator.h"
 #include "base/metrics/persistent_sample_map.h"
 #include "base/metrics/sample_map.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/pickle.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 
 namespace base {
@@ skipping 11 matching lines @@
   PersistentHistogramAllocator::ImportGlobalHistograms();
 
   HistogramBase* histogram = StatisticsRecorder::FindHistogram(name);
   if (!histogram) {
     // Try to create the histogram using a "persistent" allocator. As of
     // 2016-02-25, the availability of such is controlled by a base::Feature
     // that is off by default. If the allocator doesn't exist or if
     // allocating from it fails, code below will allocate the histogram from
     // the process heap.
     PersistentMemoryAllocator::Reference histogram_ref = 0;
-    scoped_ptr<HistogramBase> tentative_histogram;
+    std::unique_ptr<HistogramBase> tentative_histogram;
     PersistentHistogramAllocator* allocator =
         PersistentHistogramAllocator::GetGlobalAllocator();
     if (allocator) {
       tentative_histogram = allocator->AllocateHistogram(
           SPARSE_HISTOGRAM, name, 0, 0, nullptr, flags, &histogram_ref);
     }
 
     // Handle the case where no persistent allocator is present or the
     // persistent allocation fails (perhaps because it is full).
     if (!tentative_histogram) {
@@ skipping 21 matching lines @@
     ReportHistogramActivity(*histogram, HISTOGRAM_CREATED);
   } else {
     ReportHistogramActivity(*histogram, HISTOGRAM_LOOKUP);
   }
 
   DCHECK_EQ(SPARSE_HISTOGRAM, histogram->GetHistogramType());
   return histogram;
 }
 
 // static
-scoped_ptr<HistogramBase> SparseHistogram::PersistentCreate(
+std::unique_ptr<HistogramBase> SparseHistogram::PersistentCreate(
     PersistentMemoryAllocator* allocator,
     const std::string& name,
     HistogramSamples::Metadata* meta,
     HistogramSamples::Metadata* logged_meta) {
-  return make_scoped_ptr(
+  return WrapUnique(
       new SparseHistogram(allocator, name, meta, logged_meta));
 }
 
 SparseHistogram::~SparseHistogram() {}
 
 uint64_t SparseHistogram::name_hash() const {
   return samples_->id();
 }
 
 HistogramType SparseHistogram::GetHistogramType() const {
@@ skipping 18 matching lines @@
     return;
   }
   {
     base::AutoLock auto_lock(lock_);
     samples_->Accumulate(value, count);
   }
 
   FindAndRunCallback(value);
 }
 
-scoped_ptr<HistogramSamples> SparseHistogram::SnapshotSamples() const {
-  scoped_ptr<SampleMap> snapshot(new SampleMap(name_hash()));
+std::unique_ptr<HistogramSamples> SparseHistogram::SnapshotSamples() const {
+  std::unique_ptr<SampleMap> snapshot(new SampleMap(name_hash()));
 
   base::AutoLock auto_lock(lock_);
   snapshot->Add(*samples_);
   return std::move(snapshot);
 }
 
-scoped_ptr<HistogramSamples> SparseHistogram::SnapshotDelta() {
-  scoped_ptr<SampleMap> snapshot(new SampleMap(name_hash()));
+std::unique_ptr<HistogramSamples> SparseHistogram::SnapshotDelta() {
+  std::unique_ptr<SampleMap> snapshot(new SampleMap(name_hash()));
   base::AutoLock auto_lock(lock_);
   snapshot->Add(*samples_);
 
   // Subtract what was previously logged and update that information.
   snapshot->Subtract(*logged_samples_);
   logged_samples_->Add(*snapshot);
   return std::move(snapshot);
 }
 
 void SparseHistogram::AddSamples(const HistogramSamples& samples) {
@@ skipping 66 matching lines @@
 void SparseHistogram::GetCountAndBucketData(Count* count,
                                             int64_t* sum,
                                             ListValue* buckets) const {
   // TODO(kaiwang): Implement. (See HistogramBase::WriteJSON.)
 }
 
 void SparseHistogram::WriteAsciiImpl(bool graph_it,
                                      const std::string& newline,
                                      std::string* output) const {
   // Get a local copy of the data so we are consistent.
-  scoped_ptr<HistogramSamples> snapshot = SnapshotSamples();
+  std::unique_ptr<HistogramSamples> snapshot = SnapshotSamples();
   Count total_count = snapshot->TotalCount();
   double scaled_total_count = total_count / 100.0;
 
   WriteAsciiHeader(total_count, output);
   output->append(newline);
 
   // Determine how wide the largest bucket range is (how many digits to print),
   // so that we'll be able to right-align starts for the graphical bars.
   // Determine which bucket has the largest sample count so that we can
   // normalize the graphical bar-width relative to that sample count.
   Count largest_count = 0;
   Sample largest_sample = 0;
-  scoped_ptr<SampleCountIterator> it = snapshot->Iterator();
+  std::unique_ptr<SampleCountIterator> it = snapshot->Iterator();
   while (!it->Done()) {
     Sample min;
     Sample max;
     Count count;
     it->Get(&min, &max, &count);
     if (min > largest_sample)
       largest_sample = min;
     if (count > largest_count)
       largest_count = count;
     it->Next();
@@ skipping 26 matching lines @@
                                        std::string* output) const {
   StringAppendF(output,
                 "Histogram: %s recorded %d samples",
                 histogram_name().c_str(),
                 total_count);
   if (flags() & ~kHexRangePrintingFlag)
     StringAppendF(output, " (flags = 0x%x)", flags() & ~kHexRangePrintingFlag);
 }
 
 }  // namespace base