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

content/child/child_shared_bitmap_manager.cc

 // Copyright (c) 2013 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 "content/child/child_shared_bitmap_manager.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 99 matching lines @@
   base::SharedMemoryHandle handle;
   bool send_success =
       sender_->Send(new ChildProcessHostMsg_SyncAllocateSharedBitmap(
           memory_size, id, &handle));
   if (!send_success) {
     // Callers of this method are not prepared to handle failures during
     // shutdown. Exit immediately. This is expected behavior during the Fast
     // Shutdown path, so use EXIT_SUCCESS. https://crbug.com/615121.
     exit(EXIT_SUCCESS);
   }
-  memory = base::WrapUnique(new base::SharedMemory(handle, false));
+  memory = base::MakeUnique<base::SharedMemory>(handle, false);
   if (!memory->Map(memory_size))
     CollectMemoryUsageAndDie(size, memory_size);
 #else
   bool out_of_memory;
   memory = ChildThreadImpl::AllocateSharedMemory(memory_size, sender_.get(),
                                                  &out_of_memory);
   if (!memory) {
     if (out_of_memory) {
       CollectMemoryUsageAndDie(size, memory_size);
     } else {
       // Callers of this method are not prepared to handle failures during
       // shutdown. Exit immediately. This is expected behavior during the Fast
       // Shutdown path, so use EXIT_SUCCESS. https://crbug.com/615121.
       exit(EXIT_SUCCESS);
     }
   }
 
   if (!memory->Map(memory_size))
     CollectMemoryUsageAndDie(size, memory_size);
 
   base::SharedMemoryHandle handle_to_send = memory->handle();
   sender_->Send(new ChildProcessHostMsg_AllocatedSharedBitmap(
       memory_size, handle_to_send, id));
 #endif
-  return base::WrapUnique(
-      new ChildSharedBitmap(sender_, std::move(memory), id));
+  return base::MakeUnique<ChildSharedBitmap>(sender_, std::move(memory), id);
 }
 
 std::unique_ptr<cc::SharedBitmap>
 ChildSharedBitmapManager::GetSharedBitmapFromId(const gfx::Size&,
                                                 const cc::SharedBitmapId&) {
   NOTREACHED();
   return std::unique_ptr<cc::SharedBitmap>();
 }
 
 std::unique_ptr<cc::SharedBitmap>
 ChildSharedBitmapManager::GetBitmapForSharedMemory(base::SharedMemory* mem) {
   cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();
   base::SharedMemoryHandle handle_to_send = mem->handle();
 #if defined(OS_POSIX)
   if (!mem->ShareToProcess(base::GetCurrentProcessHandle(), &handle_to_send))
     return std::unique_ptr<cc::SharedBitmap>();
 #endif
   sender_->Send(new ChildProcessHostMsg_AllocatedSharedBitmap(
       mem->mapped_size(), handle_to_send, id));
 
-  return base::WrapUnique(new ChildSharedBitmap(sender_, mem, id));
+  return base::MakeUnique<ChildSharedBitmap>(sender_, mem, id);
 }
 
 }  // namespace content