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

content/browser/compositor/gpu_process_transport_factory.cc

 // Copyright 2014 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/compositor/gpu_process_transport_factory.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 451 matching lines @@
       vulkan_surface.reset();
     } else {
       display_output_surface = std::move(vulkan_surface);
     }
   }
 #endif
 
   if (!display_output_surface) {
     if (!create_gpu_output_surface) {
       display_output_surface =
-          base::WrapUnique(new SoftwareBrowserCompositorOutputSurface(
+          base::MakeUnique<SoftwareBrowserCompositorOutputSurface>(
               CreateSoftwareOutputDevice(compositor.get()),
-              compositor->vsync_manager(), begin_frame_source.get()));
+              compositor->vsync_manager(), begin_frame_source.get());
     } else {
       DCHECK(context_provider);
       const auto& capabilities = context_provider->ContextCapabilities();
       if (data->surface_handle == gpu::kNullSurfaceHandle) {
         display_output_surface =
-            base::WrapUnique(new OffscreenBrowserCompositorOutputSurface(
+            base::MakeUnique<OffscreenBrowserCompositorOutputSurface>(
                 context_provider, compositor->vsync_manager(),
                 begin_frame_source.get(),
-                std::unique_ptr<display_compositor::
-                                    CompositorOverlayCandidateValidator>()));
+                std::unique_ptr<
+                    display_compositor::CompositorOverlayCandidateValidator>());
       } else if (capabilities.surfaceless) {
 #if defined(OS_MACOSX)
-        display_output_surface = base::WrapUnique(new GpuOutputSurfaceMac(
+        display_output_surface = base::MakeUnique<GpuOutputSurfaceMac>(
             context_provider, data->surface_handle, compositor->vsync_manager(),
             begin_frame_source.get(),
             CreateOverlayCandidateValidator(compositor->widget()),
-            GetGpuMemoryBufferManager()));
+            GetGpuMemoryBufferManager());
 #else
         display_output_surface =
-            base::WrapUnique(new GpuSurfacelessBrowserCompositorOutputSurface(
+            base::MakeUnique<GpuSurfacelessBrowserCompositorOutputSurface>(
                 context_provider, data->surface_handle,
                 compositor->vsync_manager(), begin_frame_source.get(),
                 CreateOverlayCandidateValidator(compositor->widget()),
                 GL_TEXTURE_2D, GL_RGB, ui::DisplaySnapshot::PrimaryFormat(),
-                GetGpuMemoryBufferManager()));
+                GetGpuMemoryBufferManager());
 #endif
       } else {
         std::unique_ptr<display_compositor::CompositorOverlayCandidateValidator>
             validator;
         const bool use_mus = IsUsingMus();
 #if !defined(OS_MACOSX)
         // Overlays are only supported on surfaceless output surfaces on Mac.
         if (!use_mus)
           validator = CreateOverlayCandidateValidator(compositor->widget());
 #endif
         if (!use_mus) {
           display_output_surface =
-              base::WrapUnique(new GpuBrowserCompositorOutputSurface(
+              base::MakeUnique<GpuBrowserCompositorOutputSurface>(
                   context_provider, compositor->vsync_manager(),
-                  begin_frame_source.get(), std::move(validator)));
+                  begin_frame_source.get(), std::move(validator));
         } else {
 #if defined(USE_AURA)
           display_output_surface =
-              base::WrapUnique(new MusBrowserCompositorOutputSurface(
+              base::MakeUnique<MusBrowserCompositorOutputSurface>(
                   compositor->window(), context_provider,
                   compositor->vsync_manager(), begin_frame_source.get(),
-                  std::move(validator)));
+                  std::move(validator));
 #else
           NOTREACHED();
 #endif
         }
       }
     }
   }
 
   data->display_output_surface = display_output_surface.get();
   data->begin_frame_source = begin_frame_source.get();
@@ skipping 342 matching lines @@
       shared_vulkan_context_provider_ =
           cc::VulkanInProcessContextProvider::Create();
     }
 
     shared_vulkan_context_provider_initialized_ = true;
   }
   return shared_vulkan_context_provider_;
 }
 
 }  // namespace content