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

content/browser/renderer_host/media/video_capture_buffer_pool.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/browser/renderer_host/media/video_capture_buffer_pool.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 24 matching lines @@
     set_storage_type(storage_type);
     mapped_size_ =
         media::VideoCaptureFormat(dimensions, 0.0f, format, storage_type)
             .ImageAllocationSize();
     if (!mapped_size_)
       return true;
     return shared_memory_.CreateAndMapAnonymous(mapped_size_);
   }
 
   std::unique_ptr<BufferHandle> GetBufferHandle() override {
-    return base::WrapUnique(new SharedMemBufferHandle(this));
+    return base::MakeUnique<SharedMemBufferHandle>(this);
   }
   bool ShareToProcess(base::ProcessHandle process_handle,
                       base::SharedMemoryHandle* new_handle) override {
     return shared_memory_.ShareToProcess(process_handle, new_handle);
   }
   bool ShareToProcess2(int plane,
                        base::ProcessHandle process_handle,
                        gfx::GpuMemoryBufferHandle* new_handle) override {
     NOTREACHED();
     return false;
@@ skipping 81 matching lines @@
       DLOG_IF(ERROR, !gpu_memory_buffers_[i]) << "Allocating GpuMemoryBuffer";
       if (!gpu_memory_buffers_[i] || !gpu_memory_buffers_[i]->Map())
         return false;
     }
     return true;
   }
 
   std::unique_ptr<BufferHandle> GetBufferHandle() override {
     DCHECK_EQ(gpu_memory_buffers_.size(),
               media::VideoFrame::NumPlanes(pixel_format()));
-    return base::WrapUnique(new GpuMemoryBufferBufferHandle(this));
+    return base::MakeUnique<GpuMemoryBufferBufferHandle>(this);
   }
 
   bool ShareToProcess(base::ProcessHandle process_handle,
                       base::SharedMemoryHandle* new_handle) override {
     NOTREACHED();
     return false;
   }
 
   bool ShareToProcess2(int plane,
                        base::ProcessHandle process_handle,
@@ skipping 67 matching lines @@
   // Owned references to GpuMemoryBuffers.
   std::vector<std::unique_ptr<gfx::GpuMemoryBuffer>> gpu_memory_buffers_;
 };
 
 // static
 std::unique_ptr<VideoCaptureBufferPool::Tracker>
 VideoCaptureBufferPool::Tracker::CreateTracker(
     media::VideoPixelStorage storage) {
   switch (storage) {
     case media::PIXEL_STORAGE_GPUMEMORYBUFFER:
-      return base::WrapUnique(new GpuMemoryBufferTracker());
+      return base::MakeUnique<GpuMemoryBufferTracker>();
     case media::PIXEL_STORAGE_CPU:
-      return base::WrapUnique(new SharedMemTracker());
+      return base::MakeUnique<SharedMemTracker>();
   }
   NOTREACHED();
   return std::unique_ptr<VideoCaptureBufferPool::Tracker>();
 }
 
 VideoCaptureBufferPool::Tracker::~Tracker() {}
 
 VideoCaptureBufferPool::VideoCaptureBufferPool(int count)
     : count_(count),
       next_buffer_id_(0),
@@ skipping 226 matching lines @@
   return buffer_id;
 }
 
 VideoCaptureBufferPool::Tracker* VideoCaptureBufferPool::GetTracker(
     int buffer_id) {
   TrackerMap::const_iterator it = trackers_.find(buffer_id);
   return (it == trackers_.end()) ? NULL : it->second;
 }
 
 }  // namespace content