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

components/exo/wayland/server.cc

 // Copyright 2015 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 "components/exo/wayland/server.h"
 
 #include <grp.h>
 #include <linux/input.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 716 matching lines @@
 // linux_dmabuf_interface:
 
 void linux_dmabuf_destroy(wl_client* client, wl_resource* resource) {
   wl_resource_destroy(resource);
 }
 
 void linux_dmabuf_create_params(wl_client* client,
                                 wl_resource* resource,
                                 uint32_t id) {
   std::unique_ptr<LinuxBufferParams> linux_buffer_params =
-      base::WrapUnique(new LinuxBufferParams(GetUserDataAs<Display>(resource)));
+      base::MakeUnique<LinuxBufferParams>(GetUserDataAs<Display>(resource));
 
   wl_resource* linux_buffer_params_resource =
       wl_resource_create(client, &zwp_linux_buffer_params_v1_interface, 1, id);
 
   SetImplementation(linux_buffer_params_resource,
                     &linux_buffer_params_implementation,
                     std::move(linux_buffer_params));
 }
 
 const struct zwp_linux_dmabuf_v1_interface linux_dmabuf_implementation = {
@@ skipping 362 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(WaylandPrimaryDisplayObserver);
 };
 
 const uint32_t output_version = 2;
 
 void bind_output(wl_client* client, void* data, uint32_t version, uint32_t id) {
   wl_resource* resource = wl_resource_create(
       client, &wl_output_interface, std::min(version, output_version), id);
 
-  SetImplementation(
-      resource, nullptr,
-      base::WrapUnique(new WaylandPrimaryDisplayObserver(resource)));
+  SetImplementation(resource, nullptr,
+                    base::MakeUnique<WaylandPrimaryDisplayObserver>(resource));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // xdg_surface_interface:
 
 int XdgResizeComponent(uint32_t edges) {
   switch (edges) {
     case XDG_SURFACE_RESIZE_EDGE_TOP:
       return HTTOP;
     case XDG_SURFACE_RESIZE_EDGE_BOTTOM:
@@ skipping 767 matching lines @@
 
 void bind_remote_shell(wl_client* client,
                        void* data,
                        uint32_t version,
                        uint32_t id) {
   wl_resource* resource =
       wl_resource_create(client, &zwp_remote_shell_v1_interface,
                          std::min(version, remote_shell_version), id);
 
   SetImplementation(resource, &remote_shell_implementation,
-                    base::WrapUnique(new WaylandRemoteShell(
-                        static_cast<Display*>(data), resource)));
+                    base::MakeUnique<WaylandRemoteShell>(
+                        static_cast<Display*>(data), resource));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // zwp_vsync_timing_v1_interface:
 
 // Implements VSync timing interface by monitoring a compositor for updates
 // to VSync parameters.
 class VSyncTiming : public ui::CompositorVSyncManager::Observer {
  public:
   ~VSyncTiming() { vsync_manager_->RemoveObserver(this); }
@@ skipping 528 matching lines @@
 
 const struct wl_touch_interface touch_implementation = {touch_release};
 
 ////////////////////////////////////////////////////////////////////////////////
 // wl_seat_interface:
 
 void seat_get_pointer(wl_client* client, wl_resource* resource, uint32_t id) {
   wl_resource* pointer_resource = wl_resource_create(
       client, &wl_pointer_interface, wl_resource_get_version(resource), id);
 
-  SetImplementation(pointer_resource, &pointer_implementation,
-                    base::WrapUnique(new Pointer(
-                        new WaylandPointerDelegate(pointer_resource))));
+  SetImplementation(
+      pointer_resource, &pointer_implementation,
+      base::MakeUnique<Pointer>(new WaylandPointerDelegate(pointer_resource)));
 }
 
 void seat_get_keyboard(wl_client* client, wl_resource* resource, uint32_t id) {
 #if defined(USE_XKBCOMMON)
   uint32_t version = wl_resource_get_version(resource);
   wl_resource* keyboard_resource =
       wl_resource_create(client, &wl_keyboard_interface, version, id);
 
   SetImplementation(keyboard_resource, &keyboard_implementation,
-                    base::WrapUnique(new Keyboard(
-                        new WaylandKeyboardDelegate(keyboard_resource))));
+                    base::MakeUnique<Keyboard>(
+                        new WaylandKeyboardDelegate(keyboard_resource)));
 
   // TODO(reveman): Keep repeat info synchronized with chromium and the host OS.
   if (version >= WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION)
     wl_keyboard_send_repeat_info(keyboard_resource, 40, 500);
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
 void seat_get_touch(wl_client* client, wl_resource* resource, uint32_t id) {
   wl_resource* touch_resource = wl_resource_create(
       client, &wl_touch_interface, wl_resource_get_version(resource), id);
 
   SetImplementation(
       touch_resource, &touch_implementation,
-      base::WrapUnique(new Touch(new WaylandTouchDelegate(touch_resource))));
+      base::MakeUnique<Touch>(new WaylandTouchDelegate(touch_resource)));
 }
 
 void seat_release(wl_client* client, wl_resource* resource) {
   wl_resource_destroy(resource);
 }
 
 const struct wl_seat_interface seat_implementation = {
     seat_get_pointer, seat_get_keyboard, seat_get_touch, seat_release};
 
 const uint32_t seat_version = 5;
@@ skipping 124 matching lines @@
   if (surface->GetProperty(kSurfaceHasViewportKey)) {
     wl_resource_post_error(resource, WP_VIEWPORTER_ERROR_VIEWPORT_EXISTS,
                            "a viewport for that surface already exists");
     return;
   }
 
   wl_resource* viewport_resource = wl_resource_create(
       client, &wp_viewport_interface, wl_resource_get_version(resource), id);
 
   SetImplementation(viewport_resource, &viewport_implementation,
-                    base::WrapUnique(new Viewport(surface)));
+                    base::MakeUnique<Viewport>(surface));
 }
 
 const struct wp_viewporter_interface viewporter_implementation = {
     viewporter_destroy, viewporter_get_viewport};
 
 void bind_viewporter(wl_client* client,
                      void* data,
                      uint32_t version,
                      uint32_t id) {
   wl_resource* resource =
@@ skipping 68 matching lines @@
   if (surface->GetProperty(kSurfaceHasSecurityKey)) {
     wl_resource_post_error(resource, ZWP_SECURE_OUTPUT_V1_ERROR_SECURITY_EXISTS,
                            "a security object for that surface already exists");
     return;
   }
 
   wl_resource* security_resource =
       wl_resource_create(client, &zwp_security_v1_interface, 1, id);
 
   SetImplementation(security_resource, &security_implementation,
-                    base::WrapUnique(new Security(surface)));
+                    base::MakeUnique<Security>(surface));
 }
 
 const struct zwp_secure_output_v1_interface secure_output_implementation = {
     secure_output_destroy, secure_output_get_security};
 
 void bind_secure_output(wl_client* client,
                         void* data,
                         uint32_t version,
                         uint32_t id) {
   wl_resource* resource =
@@ skipping 96 matching lines @@
     wl_resource_post_error(resource,
                            ZWP_ALPHA_COMPOSITING_V1_ERROR_BLENDING_EXISTS,
                            "a blending object for that surface already exists");
     return;
   }
 
   wl_resource* blending_resource =
       wl_resource_create(client, &zwp_blending_v1_interface, 1, id);
 
   SetImplementation(blending_resource, &blending_implementation,
-                    base::WrapUnique(new Blending(surface)));
+                    base::MakeUnique<Blending>(surface));
 }
 
 const struct zwp_alpha_compositing_v1_interface
     alpha_compositing_implementation = {alpha_compositing_destroy,
                                         alpha_compositing_get_blending};
 
 void bind_alpha_compositing(wl_client* client,
                             void* data,
                             uint32_t version,
                             uint32_t id) {
@@ skipping 64 matching lines @@
                               wl_resource* resource,
                               uint32_t id,
                               wl_resource* seat) {
   wl_resource* gamepad_resource = wl_resource_create(
       client, &zwp_gamepad_v1_interface, wl_resource_get_version(resource), id);
 
   base::Thread* gaming_input_thread = GetUserDataAs<base::Thread>(resource);
 
   SetImplementation(
       gamepad_resource, &gamepad_implementation,
-      base::WrapUnique(new Gamepad(new WaylandGamepadDelegate(gamepad_resource),
-                                   gaming_input_thread->task_runner().get())));
+      base::MakeUnique<Gamepad>(new WaylandGamepadDelegate(gamepad_resource),
+                                gaming_input_thread->task_runner().get()));
 }
 
 const struct zwp_gaming_input_v1_interface gaming_input_implementation = {
     gaming_input_get_gamepad};
 
 void bind_gaming_input(wl_client* client,
                        void* data,
                        uint32_t version,
                        uint32_t id) {
   wl_resource* resource =
@@ skipping 63 matching lines @@
 
 void stylus_get_pointer_stylus(wl_client* client,
                                wl_resource* resource,
                                uint32_t id,
                                wl_resource* pointer_resource) {
   Pointer* pointer = GetUserDataAs<Pointer>(pointer_resource);
 
   wl_resource* stylus_resource =
       wl_resource_create(client, &zwp_pointer_stylus_v1_interface, 1, id);
 
-  SetImplementation(stylus_resource, &pointer_stylus_implementation,
-                    base::WrapUnique(new WaylandPointerStylusDelegate(
-                        stylus_resource, pointer)));
+  SetImplementation(
+      stylus_resource, &pointer_stylus_implementation,
+      base::MakeUnique<WaylandPointerStylusDelegate>(stylus_resource, pointer));
 }
 
 const struct zwp_stylus_v1_interface stylus_implementation = {
     stylus_get_pointer_stylus};
 
 void bind_stylus(wl_client* client, void* data, uint32_t version, uint32_t id) {
   wl_resource* resource =
       wl_resource_create(client, &zwp_stylus_v1_interface, version, id);
   wl_resource_set_implementation(resource, &stylus_implementation, data,
                                  nullptr);
@@ skipping 105 matching lines @@
   DCHECK(event_loop);
   wl_event_loop_dispatch(event_loop, timeout.InMilliseconds());
 }
 
 void Server::Flush() {
   wl_display_flush_clients(wl_display_.get());
 }
 
 }  // namespace wayland
 }  // namespace exo