Convert //base to use std::unique_ptr

base/metrics/persistent_memory_allocator.h

 // Copyright (c) 2015 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.
 
 #ifndef BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
 #define BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
 
 #include <stdint.h>
+
 #include <atomic>
+#include <memory>
 
 #include "base/atomicops.h"
 #include "base/base_export.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
 
 namespace base {
 
 class HistogramBase;
 class MemoryMappedFile;
 class SharedMemory;
 
 // Simple allocator for pieces of a memory block that may be persistent
 // to some storage or shared across multiple processes. This class resides
@@ skipping 288 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(LocalPersistentMemoryAllocator);
 };
 
 
 // This allocator takes a shared-memory object and performs allocation from
 // it. The memory must be previously mapped via Map() or MapAt(). The allocator
 // takes ownership of the memory object.
 class BASE_EXPORT SharedPersistentMemoryAllocator
     : public PersistentMemoryAllocator {
  public:
-  SharedPersistentMemoryAllocator(scoped_ptr<SharedMemory> memory, uint64_t id,
-                                  base::StringPiece name, bool read_only);
+  SharedPersistentMemoryAllocator(std::unique_ptr<SharedMemory> memory,
+                                  uint64_t id,
+                                  base::StringPiece name,
+                                  bool read_only);
   ~SharedPersistentMemoryAllocator() override;
 
   SharedMemory* shared_memory() { return shared_memory_.get(); }
 
   // Ensure that the memory isn't so invalid that it won't crash when passing it
   // to the allocator. This doesn't guarantee the data is valid, just that it
   // won't cause the program to abort. The existing IsCorrupt() call will handle
   // the rest.
   static bool IsSharedMemoryAcceptable(const SharedMemory& memory);
 
  private:
-  scoped_ptr<SharedMemory> shared_memory_;
+  std::unique_ptr<SharedMemory> shared_memory_;
 
   DISALLOW_COPY_AND_ASSIGN(SharedPersistentMemoryAllocator);
 };
 
 
 // This allocator takes a memory-mapped file object and performs allocation
 // from it. The allocator takes ownership of the file object. Only read access
 // is provided due to limitions of the MemoryMappedFile class.
 class BASE_EXPORT FilePersistentMemoryAllocator
     : public PersistentMemoryAllocator {
  public:
-  FilePersistentMemoryAllocator(scoped_ptr<MemoryMappedFile> file, uint64_t id,
+  FilePersistentMemoryAllocator(std::unique_ptr<MemoryMappedFile> file,
+                                uint64_t id,
                                 base::StringPiece name);
   ~FilePersistentMemoryAllocator() override;
 
   // Ensure that the file isn't so invalid that it won't crash when passing it
   // to the allocator. This doesn't guarantee the file is valid, just that it
   // won't cause the program to abort. The existing IsCorrupt() call will handle
   // the rest.
   static bool IsFileAcceptable(const MemoryMappedFile& file);
 
  private:
-  scoped_ptr<MemoryMappedFile> mapped_file_;
+  std::unique_ptr<MemoryMappedFile> mapped_file_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePersistentMemoryAllocator);
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_