Convert //base to use std::unique_ptr

base/trace_event/process_memory_dump.cc

 // Copyright 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.
 
 #include "base/trace_event/process_memory_dump.h"
 
 #include <errno.h>
+
 #include <vector>
 
+#include "base/memory/ptr_util.h"
 #include "base/process/process_metrics.h"
 #include "base/trace_event/process_memory_totals.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "build/build_config.h"
 
 #if defined(OS_IOS)
 #include <sys/sysctl.h>
 #endif
 
 #if defined(OS_POSIX)
@@ skipping 55 matching lines @@
   size_t total_resident_size = 0;
   bool failure = false;
 
   // An array as large as number of pages in memory segment needs to be passed
   // to the query function. To avoid allocating a large array, the given block
   // of memory is split into chunks of size |kMaxChunkSize|.
   const size_t kMaxChunkSize = 8 * 1024 * 1024;
   size_t max_vec_size =
       GetSystemPageCount(std::min(mapped_size, kMaxChunkSize), page_size);
 #if defined(OS_MACOSX) || defined(OS_IOS)
-  scoped_ptr<char[]> vec(new char[max_vec_size]);
+  std::unique_ptr<char[]> vec(new char[max_vec_size]);
 #elif defined(OS_WIN)
-  scoped_ptr<PSAPI_WORKING_SET_EX_INFORMATION[]> vec(
+  std::unique_ptr<PSAPI_WORKING_SET_EX_INFORMATION[]> vec(
       new PSAPI_WORKING_SET_EX_INFORMATION[max_vec_size]);
 #elif defined(OS_POSIX)
-  scoped_ptr<unsigned char[]> vec(new unsigned char[max_vec_size]);
+  std::unique_ptr<unsigned char[]> vec(new unsigned char[max_vec_size]);
 #endif
 
   while (offset < mapped_size) {
     uintptr_t chunk_start = (start_pointer + offset);
     const size_t chunk_size = std::min(mapped_size - offset, kMaxChunkSize);
     const size_t page_count = GetSystemPageCount(chunk_size, page_size);
     size_t resident_page_count = 0;
 
 #if defined(OS_MACOSX) || defined(OS_IOS)
     // mincore in MAC does not fail with EAGAIN.
@@ skipping 46 matching lines @@
     scoped_refptr<MemoryDumpSessionState> session_state)
     : has_process_totals_(false),
       has_process_mmaps_(false),
       session_state_(std::move(session_state)) {}
 
 ProcessMemoryDump::~ProcessMemoryDump() {}
 
 MemoryAllocatorDump* ProcessMemoryDump::CreateAllocatorDump(
     const std::string& absolute_name) {
   return AddAllocatorDumpInternal(
-      make_scoped_ptr(new MemoryAllocatorDump(absolute_name, this)));
+      base::WrapUnique(new MemoryAllocatorDump(absolute_name, this)));
 }
 
 MemoryAllocatorDump* ProcessMemoryDump::CreateAllocatorDump(
     const std::string& absolute_name,
     const MemoryAllocatorDumpGuid& guid) {
   return AddAllocatorDumpInternal(
-      make_scoped_ptr(new MemoryAllocatorDump(absolute_name, this, guid)));
+      base::WrapUnique(new MemoryAllocatorDump(absolute_name, this, guid)));
 }
 
 MemoryAllocatorDump* ProcessMemoryDump::AddAllocatorDumpInternal(
-    scoped_ptr<MemoryAllocatorDump> mad) {
+    std::unique_ptr<MemoryAllocatorDump> mad) {
   auto insertion_result = allocator_dumps_.insert(
       std::make_pair(mad->absolute_name(), std::move(mad)));
   DCHECK(insertion_result.second) << "Duplicate name: " << mad->absolute_name();
   return insertion_result.first->second.get();
 }
 
 MemoryAllocatorDump* ProcessMemoryDump::GetAllocatorDump(
     const std::string& absolute_name) const {
   auto it = allocator_dumps_.find(absolute_name);
   return it == allocator_dumps_.end() ? nullptr : it->second.get();
@@ skipping 28 matching lines @@
   mad->set_flags(MemoryAllocatorDump::Flags::WEAK);
   return mad;
 }
 
 MemoryAllocatorDump* ProcessMemoryDump::GetSharedGlobalAllocatorDump(
     const MemoryAllocatorDumpGuid& guid) const {
   return GetAllocatorDump(GetSharedGlobalAllocatorDumpName(guid));
 }
 
 void ProcessMemoryDump::AddHeapDump(const std::string& absolute_name,
-                                    scoped_ptr<TracedValue> heap_dump) {
+                                    std::unique_ptr<TracedValue> heap_dump) {
   DCHECK_EQ(0ul, heap_dumps_.count(absolute_name));
   heap_dumps_[absolute_name] = std::move(heap_dump);
 }
 
 void ProcessMemoryDump::Clear() {
   if (has_process_totals_) {
     process_totals_.Clear();
     has_process_totals_ = false;
   }
 
@@ skipping 83 matching lines @@
 
 void ProcessMemoryDump::AddSuballocation(const MemoryAllocatorDumpGuid& source,
                                          const std::string& target_node_name) {
   std::string child_mad_name = target_node_name + "/__" + source.ToString();
   MemoryAllocatorDump* target_child_mad = CreateAllocatorDump(child_mad_name);
   AddOwnershipEdge(source, target_child_mad->guid());
 }
 
 }  // namespace trace_event
 }  // namespace base