Convert //base to use std::unique_ptr

base/metrics/persistent_histogram_allocator.cc

 // Copyright 2016 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/persistent_histogram_allocator.h"
 
+#include <memory>
+
 #include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/synchronization/lock.h"
 
 // TODO(bcwhite): Order these methods to match the header file. The current
 // order is only temporary in order to aid review of the transition from
 // a non-class implementation.
@@ skipping 20 matching lines @@
 // The object held here will obviously not be destructed at process exit
 // but that's best since PersistentMemoryAllocator objects (that underlie
 // PersistentHistogramAllocator objects) are explicitly forbidden from doing
 // anything essential at exit anyway due to the fact that they depend on data
 // managed elsewhere and which could be destructed first.
 PersistentHistogramAllocator* g_allocator;
 
 // Take an array of range boundaries and create a proper BucketRanges object
 // which is returned to the caller. A return of nullptr indicates that the
 // passed boundaries are invalid.
-scoped_ptr<BucketRanges> CreateRangesFromData(
+std::unique_ptr<BucketRanges> CreateRangesFromData(
     HistogramBase::Sample* ranges_data,
     uint32_t ranges_checksum,
     size_t count) {
   // To avoid racy destruction at shutdown, the following may be leaked.
-  scoped_ptr<BucketRanges> ranges(new BucketRanges(count));
+  std::unique_ptr<BucketRanges> ranges(new BucketRanges(count));
   DCHECK_EQ(count, ranges->size());
   for (size_t i = 0; i < count; ++i) {
     if (i > 0 && ranges_data[i] <= ranges_data[i - 1])
       return nullptr;
     ranges->set_range(i, ranges_data[i]);
   }
 
   ranges->ResetChecksum();
   if (ranges->checksum() != ranges_checksum)
     return nullptr;
@@ skipping 37 matching lines @@
   HistogramSamples::Metadata samples_metadata;
   HistogramSamples::Metadata logged_metadata;
 
   // Space for the histogram name will be added during the actual allocation
   // request. This must be the last field of the structure. A zero-size array
   // or a "flexible" array would be preferred but is not (yet) valid C++.
   char name[1];
 };
 
 PersistentHistogramAllocator::PersistentHistogramAllocator(
-    scoped_ptr<PersistentMemoryAllocator> memory)
+    std::unique_ptr<PersistentMemoryAllocator> memory)
     : memory_allocator_(std::move(memory)) {}
 
 PersistentHistogramAllocator::~PersistentHistogramAllocator() {}
 
 void PersistentHistogramAllocator::CreateIterator(Iterator* iter) {
   memory_allocator_->CreateIterator(&iter->memory_iter);
 }
 
 void PersistentHistogramAllocator::CreateTrackingHistograms(StringPiece name) {
   memory_allocator_->CreateTrackingHistograms(name);
@@ skipping 43 matching lines @@
 // static
 void PersistentHistogramAllocator::RecordCreateHistogramResult(
     CreateHistogramResultType result) {
   HistogramBase* result_histogram = GetCreateHistogramResultHistogram();
   if (result_histogram)
     result_histogram->Add(result);
 }
 
 // static
 void PersistentHistogramAllocator::SetGlobalAllocator(
-    scoped_ptr<PersistentHistogramAllocator> allocator) {
+    std::unique_ptr<PersistentHistogramAllocator> allocator) {
   // Releasing or changing an allocator is extremely dangerous because it
   // likely has histograms stored within it. If the backing memory is also
   // also released, future accesses to those histograms will seg-fault.
   CHECK(!g_allocator);
   g_allocator = allocator.release();
 
   size_t existing = StatisticsRecorder::GetHistogramCount();
   DLOG_IF(WARNING, existing)
       << existing
       << " histograms were created before persistence was enabled.";
 }
 
 // static
 PersistentHistogramAllocator*
 PersistentHistogramAllocator::GetGlobalAllocator() {
   return g_allocator;
 }
 
 // static
-scoped_ptr<PersistentHistogramAllocator>
+std::unique_ptr<PersistentHistogramAllocator>
 PersistentHistogramAllocator::ReleaseGlobalAllocatorForTesting() {
   PersistentHistogramAllocator* histogram_allocator = g_allocator;
   if (!histogram_allocator)
     return nullptr;
   PersistentMemoryAllocator* memory_allocator =
       histogram_allocator->memory_allocator();
 
   // Before releasing the memory, it's necessary to have the Statistics-
   // Recorder forget about the histograms contained therein; otherwise,
   // some operations will try to access them and the released memory.
@@ skipping 14 matching lines @@
       // If that memory segment were to be deleted, future calls to create
       // persistent histograms would crash. To avoid this, have the test call
       // the method GetCreateHistogramResultHistogram() *before* setting
       // the (temporary) memory allocator via SetGlobalAllocator() so that
       // histogram is instead allocated from the process heap.
       DCHECK_NE(kResultHistogram, histogram_data->name);
     }
   }
 
   g_allocator = nullptr;
-  return make_scoped_ptr(histogram_allocator);
+  return base::WrapUnique(histogram_allocator);
 };
 
 // static
 void PersistentHistogramAllocator::CreateGlobalAllocatorOnPersistentMemory(
     void* base,
     size_t size,
     size_t page_size,
     uint64_t id,
     StringPiece name) {
-  SetGlobalAllocator(make_scoped_ptr(new PersistentHistogramAllocator(
-      make_scoped_ptr(new PersistentMemoryAllocator(
-          base, size, page_size, id, name, false)))));
+  SetGlobalAllocator(base::WrapUnique(new PersistentHistogramAllocator(
+      base::WrapUnique(new PersistentMemoryAllocator(base, size, page_size, id,
+                                                     name, false)))));
 }
 
 // static
 void PersistentHistogramAllocator::CreateGlobalAllocatorOnLocalMemory(
     size_t size,
     uint64_t id,
     StringPiece name) {
-  SetGlobalAllocator(make_scoped_ptr(new PersistentHistogramAllocator(
-      make_scoped_ptr(new LocalPersistentMemoryAllocator(size, id, name)))));
+  SetGlobalAllocator(base::WrapUnique(new PersistentHistogramAllocator(
+      base::WrapUnique(new LocalPersistentMemoryAllocator(size, id, name)))));
 }
 
 // static
 void PersistentHistogramAllocator::CreateGlobalAllocatorOnSharedMemory(
     size_t size,
     const SharedMemoryHandle& handle) {
-  scoped_ptr<SharedMemory> shm(new SharedMemory(handle, /*readonly=*/false));
+  std::unique_ptr<SharedMemory> shm(
+      new SharedMemory(handle, /*readonly=*/false));
   if (!shm->Map(size)) {
     NOTREACHED();
     return;
   }
 
-  SetGlobalAllocator(make_scoped_ptr(new PersistentHistogramAllocator(
-      make_scoped_ptr(new SharedPersistentMemoryAllocator(
+  SetGlobalAllocator(base::WrapUnique(new PersistentHistogramAllocator(
+      base::WrapUnique(new SharedPersistentMemoryAllocator(
           std::move(shm), 0, StringPiece(), /*readonly=*/false)))));
 }
 
 // static
-scoped_ptr<HistogramBase> PersistentHistogramAllocator::CreateHistogram(
+std::unique_ptr<HistogramBase> PersistentHistogramAllocator::CreateHistogram(
     PersistentHistogramData* histogram_data_ptr) {
   if (!histogram_data_ptr) {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_INVALID_METADATA_POINTER);
     NOTREACHED();
     return nullptr;
   }
 
   // Sparse histograms are quite different so handle them as a special case.
   if (histogram_data_ptr->histogram_type == SPARSE_HISTOGRAM) {
-    scoped_ptr<HistogramBase> histogram = SparseHistogram::PersistentCreate(
-        memory_allocator(), histogram_data_ptr->name,
-        &histogram_data_ptr->samples_metadata,
-        &histogram_data_ptr->logged_metadata);
+    std::unique_ptr<HistogramBase> histogram =
+        SparseHistogram::PersistentCreate(memory_allocator(),
+                                          histogram_data_ptr->name,
+                                          &histogram_data_ptr->samples_metadata,
+                                          &histogram_data_ptr->logged_metadata);
     DCHECK(histogram);
     histogram->SetFlags(histogram_data_ptr->flags);
     RecordCreateHistogramResult(CREATE_HISTOGRAM_SUCCESS);
     return histogram;
   }
 
   // Copy the histogram_data to local storage because anything in persistent
   // memory cannot be trusted as it could be changed at any moment by a
   // malicious actor that shares access. The contents of histogram_data are
   // validated below; the local copy is to ensure that the contents cannot
@@ skipping 11 matching lines @@
   size_t allocated_bytes =
       memory_allocator_->GetAllocSize(histogram_data.ranges_ref);
   if (!ranges_data || histogram_data.bucket_count < 2 ||
       histogram_data.bucket_count >= max_buckets ||
       allocated_bytes < required_bytes) {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_INVALID_RANGES_ARRAY);
     NOTREACHED();
     return nullptr;
   }
 
-  scoped_ptr<const BucketRanges> created_ranges =
+  std::unique_ptr<const BucketRanges> created_ranges =
       CreateRangesFromData(ranges_data, histogram_data.ranges_checksum,
                            histogram_data.bucket_count + 1);
   if (!created_ranges) {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_INVALID_RANGES_ARRAY);
     NOTREACHED();
     return nullptr;
   }
   const BucketRanges* ranges =
       StatisticsRecorder::RegisterOrDeleteDuplicateRanges(
           created_ranges.release());
@@ skipping 11 matching lines @@
     return nullptr;
   }
 
   // After the main "counts" array is a second array using for storing what
   // was previously logged. This is used to calculate the "delta" during
   // snapshot operations.
   HistogramBase::AtomicCount* logged_data =
       counts_data + histogram_data.bucket_count;
 
   std::string name(histogram_data_ptr->name);
-  scoped_ptr<HistogramBase> histogram;
+  std::unique_ptr<HistogramBase> histogram;
   switch (histogram_data.histogram_type) {
     case HISTOGRAM:
       histogram = Histogram::PersistentCreate(
           name, histogram_data.minimum, histogram_data.maximum, ranges,
           counts_data, logged_data, histogram_data.bucket_count,
           &histogram_data_ptr->samples_metadata,
           &histogram_data_ptr->logged_metadata);
       DCHECK(histogram);
       break;
     case LINEAR_HISTOGRAM:
@@ skipping 26 matching lines @@
     DCHECK_EQ(histogram_data.histogram_type, histogram->GetHistogramType());
     histogram->SetFlags(histogram_data.flags);
     RecordCreateHistogramResult(CREATE_HISTOGRAM_SUCCESS);
   } else {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_UNKNOWN_TYPE);
   }
 
   return histogram;
 }
 
-scoped_ptr<HistogramBase> PersistentHistogramAllocator::GetHistogram(
+std::unique_ptr<HistogramBase> PersistentHistogramAllocator::GetHistogram(
     Reference ref) {
   // Unfortunately, the histogram "pickle" methods cannot be used as part of
   // the persistance because the deserialization methods always create local
   // count data (while these must reference the persistent counts) and always
   // add it to the local list of known histograms (while these may be simple
   // references to histograms in other processes).
   PersistentHistogramData* histogram_data =
       memory_allocator_->GetAsObject<PersistentHistogramData>(
           ref, kTypeIdHistogram);
   size_t length = memory_allocator_->GetAllocSize(ref);
   if (!histogram_data ||
       reinterpret_cast<char*>(histogram_data)[length - 1] != '\0') {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_INVALID_METADATA);
     NOTREACHED();
     return nullptr;
   }
   return CreateHistogram(histogram_data);
 }
 
-scoped_ptr<HistogramBase>
+std::unique_ptr<HistogramBase>
 PersistentHistogramAllocator::GetNextHistogramWithIgnore(Iterator* iter,
                                                          Reference ignore) {
   PersistentMemoryAllocator::Reference ref;
   uint32_t type_id;
   while ((ref = memory_allocator_->GetNextIterable(&iter->memory_iter,
                                                    &type_id)) != 0) {
     if (ref == ignore)
       continue;
     if (type_id == kTypeIdHistogram)
       return GetHistogram(ref);
   }
   return nullptr;
 }
 
 void PersistentHistogramAllocator::FinalizeHistogram(Reference ref,
                                                      bool registered) {
   // If the created persistent histogram was registered then it needs to
   // be marked as "iterable" in order to be found by other processes.
   if (registered)
     memory_allocator_->MakeIterable(ref);
   // If it wasn't registered then a race condition must have caused
   // two to be created. The allocator does not support releasing the
   // acquired memory so just change the type to be empty.
   else
     memory_allocator_->SetType(ref, 0);
 }
 
-scoped_ptr<HistogramBase> PersistentHistogramAllocator::AllocateHistogram(
+std::unique_ptr<HistogramBase> PersistentHistogramAllocator::AllocateHistogram(
     HistogramType histogram_type,
     const std::string& name,
     int minimum,
     int maximum,
     const BucketRanges* bucket_ranges,
     int32_t flags,
     Reference* ref_ptr) {
   // If the allocator is corrupt, don't waste time trying anything else.
   // This also allows differentiating on the dashboard between allocations
   // failed due to a corrupt allocator and the number of process instances
@@ skipping 59 matching lines @@
       histogram_data = nullptr;  // Clear this for proper handling below.
     }
   }
 
   if (histogram_data) {
     // Create the histogram using resources in persistent memory. This ends up
     // resolving the "ref" values stored in histogram_data instad of just
     // using what is already known above but avoids duplicating the switch
     // statement here and serves as a double-check that everything is
     // correct before commiting the new histogram to persistent space.
-    scoped_ptr<HistogramBase> histogram = CreateHistogram(histogram_data);
+    std::unique_ptr<HistogramBase> histogram = CreateHistogram(histogram_data);
     DCHECK(histogram);
     if (ref_ptr != nullptr)
       *ref_ptr = histogram_ref;
 
     // By storing the reference within the allocator to this histogram, the
     // next import (which will happen before the next histogram creation)
     // will know to skip it. See also the comment in ImportGlobalHistograms().
     subtle::NoBarrier_Store(&last_created_, histogram_ref);
     return histogram;
   }
@@ skipping 33 matching lines @@
     // Skip the import if it's the histogram that was last created. Should a
     // race condition cause the "last created" to be overwritten before it
     // is recognized here then the histogram will be created and be ignored
     // when it is detected as a duplicate by the statistics-recorder. This
     // simple check reduces the time of creating persistent histograms by
     // about 40%.
     Reference last_created =
         subtle::NoBarrier_Load(&g_allocator->last_created_);
 
     while (true) {
-      scoped_ptr<HistogramBase> histogram =
+      std::unique_ptr<HistogramBase> histogram =
           g_allocator->GetNextHistogramWithIgnore(&iter, last_created);
       if (!histogram)
         break;
       StatisticsRecorder::RegisterOrDeleteDuplicate(histogram.release());
     }
   }
 }
 
 }  // namespace base