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

content/renderer/pepper/content_renderer_pepper_host_factory.cc

 // Copyright (c) 2012 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/renderer/pepper/content_renderer_pepper_host_factory.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 105 matching lines @@
   PepperPluginInstanceImpl* instance_impl =
       host_->GetPluginInstanceImpl(instance);
   if (!instance_impl->render_frame())
     return nullptr;
 
   // Public interfaces.
   switch (message.type()) {
     case PpapiHostMsg_Compositor_Create::ID: {
       if (!CanUseCompositorAPI(host_, instance))
         return nullptr;
-      return base::WrapUnique(
-          new PepperCompositorHost(host_, instance, resource));
+      return base::MakeUnique<PepperCompositorHost>(host_, instance, resource);
     }
     case PpapiHostMsg_FileRef_CreateForFileAPI::ID: {
       PP_Resource file_system;
       std::string internal_path;
       if (!UnpackMessage<PpapiHostMsg_FileRef_CreateForFileAPI>(
               message, &file_system, &internal_path)) {
         NOTREACHED();
         return nullptr;
       }
-      return base::WrapUnique(new PepperFileRefRendererHost(
-          host_, instance, resource, file_system, internal_path));
+      return base::MakeUnique<PepperFileRefRendererHost>(
+          host_, instance, resource, file_system, internal_path);
     }
     case PpapiHostMsg_FileSystem_Create::ID: {
       PP_FileSystemType file_system_type;
       if (!UnpackMessage<PpapiHostMsg_FileSystem_Create>(message,
                                                          &file_system_type)) {
         NOTREACHED();
         return nullptr;
       }
-      return base::WrapUnique(new PepperFileSystemHost(
-          host_, instance, resource, file_system_type));
+      return base::MakeUnique<PepperFileSystemHost>(host_, instance, resource,
+                                                    file_system_type);
     }
     case PpapiHostMsg_Graphics2D_Create::ID: {
       PP_Size size;
       PP_Bool is_always_opaque;
       if (!UnpackMessage<PpapiHostMsg_Graphics2D_Create>(
               message, &size, &is_always_opaque)) {
         NOTREACHED();
         return nullptr;
       }
       ppapi::PPB_ImageData_Shared::ImageDataType image_type =
           ppapi::PPB_ImageData_Shared::PLATFORM;
 #if defined(OS_WIN)
       // If Win32K lockdown mitigations are enabled for Windows 8 and beyond
       // we use the SIMPLE image data type as the PLATFORM image data type
       // calls GDI functions to create DIB sections etc which fail in Win32K
       // lockdown mode.
       // TODO(ananta)
       // Look into whether this causes a loss of functionality. From cursory
       // testing things seem to work well.
       if (IsWin32kRendererLockdownEnabled())
         image_type = ppapi::PPB_ImageData_Shared::SIMPLE;
 #endif
       scoped_refptr<PPB_ImageData_Impl> image_data(new PPB_ImageData_Impl(
           instance, image_type));
       return base::WrapUnique(PepperGraphics2DHost::Create(
           host_, instance, resource, size, is_always_opaque, image_data));
     }
     case PpapiHostMsg_URLLoader_Create::ID:
-      return base::WrapUnique(
-          new PepperURLLoaderHost(host_, false, instance, resource));
+      return base::MakeUnique<PepperURLLoaderHost>(host_, false, instance,
+                                                   resource);
     case PpapiHostMsg_VideoDecoder_Create::ID:
-      return base::WrapUnique(
-          new PepperVideoDecoderHost(host_, instance, resource));
+      return base::MakeUnique<PepperVideoDecoderHost>(host_, instance,
+                                                      resource);
     case PpapiHostMsg_VideoEncoder_Create::ID:
-      return base::WrapUnique(
-          new PepperVideoEncoderHost(host_, instance, resource));
+      return base::MakeUnique<PepperVideoEncoderHost>(host_, instance,
+                                                      resource);
     case PpapiHostMsg_WebSocket_Create::ID:
-      return base::WrapUnique(
-          new PepperWebSocketHost(host_, instance, resource));
+      return base::MakeUnique<PepperWebSocketHost>(host_, instance, resource);
 #if defined(ENABLE_WEBRTC)
     case PpapiHostMsg_MediaStreamVideoTrack_Create::ID:
-      return base::WrapUnique(
-          new PepperMediaStreamVideoTrackHost(host_, instance, resource));
+      return base::MakeUnique<PepperMediaStreamVideoTrackHost>(host_, instance,
+                                                               resource);
     // These private MediaStream interfaces are exposed as if they were public
     // so they can be used by NaCl plugins. However, they are available only
     // for whitelisted apps.
     case PpapiHostMsg_VideoDestination_Create::ID:
       if (CanUseMediaStreamAPI(host_, instance))
-        return base::WrapUnique(
-            new PepperVideoDestinationHost(host_, instance, resource));
+        return base::MakeUnique<PepperVideoDestinationHost>(host_, instance,
+                                                            resource);
     case PpapiHostMsg_VideoSource_Create::ID:
       if (CanUseMediaStreamAPI(host_, instance))
-        return base::WrapUnique(
-            new PepperVideoSourceHost(host_, instance, resource));
+        return base::MakeUnique<PepperVideoSourceHost>(host_, instance,
+                                                       resource);
 #endif  // defined(ENABLE_WEBRTC)
   }
 
   // Dev interfaces.
   if (GetPermissions().HasPermission(ppapi::PERMISSION_DEV)) {
     switch (message.type()) {
       case PpapiHostMsg_AudioEncoder_Create::ID:
-        return base::WrapUnique(
-            new PepperAudioEncoderHost(host_, instance, resource));
+        return base::MakeUnique<PepperAudioEncoderHost>(host_, instance,
+                                                        resource);
       case PpapiHostMsg_AudioInput_Create::ID:
-        return base::WrapUnique(
-            new PepperAudioInputHost(host_, instance, resource));
+        return base::MakeUnique<PepperAudioInputHost>(host_, instance,
+                                                      resource);
       case PpapiHostMsg_FileChooser_Create::ID:
-        return base::WrapUnique(
-            new PepperFileChooserHost(host_, instance, resource));
+        return base::MakeUnique<PepperFileChooserHost>(host_, instance,
+                                                       resource);
       case PpapiHostMsg_VideoCapture_Create::ID: {
         std::unique_ptr<PepperVideoCaptureHost> host(
             new PepperVideoCaptureHost(host_, instance, resource));
         return host->Init() ? std::move(host) : nullptr;
       }
     }
   }
 
   // Permissions of the following interfaces are available for whitelisted apps
   // which may not have access to the other private interfaces.
   if (message.type() == PpapiHostMsg_CameraDevice_Create::ID) {
     if (!GetPermissions().HasPermission(ppapi::PERMISSION_PRIVATE) &&
         !CanUseCameraDeviceAPI(host_, instance))
       return nullptr;
     std::unique_ptr<PepperCameraDeviceHost> host(
         new PepperCameraDeviceHost(host_, instance, resource));
     return host->Init() ? std::move(host) : nullptr;
   }
 
   return nullptr;
 }
 
 const ppapi::PpapiPermissions&
 ContentRendererPepperHostFactory::GetPermissions() const {
   return host_->GetPpapiHost()->permissions();
 }
 
 }  // namespace content