Re-write many calls to WrapUnique() with MakeUnique()

base/debug/activity_tracker.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/debug/activity_tracker.h"
 
 #include "base/debug/stack_trace.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
@@ skipping 463 matching lines @@
 
   // Create and map the file into memory and make it globally available.
   std::unique_ptr<MemoryMappedFile> mapped_file(new MemoryMappedFile());
   bool success =
       mapped_file->Initialize(File(file_path,
                                    File::FLAG_CREATE_ALWAYS | File::FLAG_READ |
                                    File::FLAG_WRITE | File::FLAG_SHARE_DELETE),
                               {0, static_cast<int64_t>(size)},
                               MemoryMappedFile::READ_WRITE_EXTEND);
   DCHECK(success);
-  CreateWithAllocator(WrapUnique(new FilePersistentMemoryAllocator(
-                          std::move(mapped_file), size, id, name, false)),
+  CreateWithAllocator(MakeUnique<FilePersistentMemoryAllocator>(
+                          std::move(mapped_file), size, id, name, false),
                       stack_depth);
 }
 #endif  // !defined(OS_NACL)
 
 // static
 void GlobalActivityTracker::CreateWithLocalMemory(size_t size,
                                                   uint64_t id,
                                                   StringPiece name,
                                                   int stack_depth) {
   CreateWithAllocator(
-      WrapUnique(new LocalPersistentMemoryAllocator(size, id, name)),
-      stack_depth);
+      MakeUnique<LocalPersistentMemoryAllocator>(size, id, name), stack_depth);
 }
 
 ThreadActivityTracker* GlobalActivityTracker::CreateTrackerForCurrentThread() {
   DCHECK(!this_thread_tracker_.Get());
 
   PersistentMemoryAllocator::Reference mem_reference = 0;
   void* mem_base = nullptr;
 
   // Get the current count of available memories, acquiring the array values.
   int count = available_memories_count_.load(std::memory_order_acquire);
@@ skipping 262 matching lines @@
     const base::Process* process)
     : GlobalActivityTracker::ScopedThreadActivity(
           nullptr,
           Activity::ACT_PROCESS_WAIT,
           ActivityData::ForProcess(process->Pid()),
           /*lock_allowed=*/true) {}
 #endif
 
 }  // namespace debug
 }  // namespace base