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

services/ui/public/cpp/window_tree_client.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 "services/ui/public/cpp/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 156 matching lines @@
 
 void WindowTreeClient::WaitForEmbed() {
   DCHECK(roots_.empty());
   // OnEmbed() is the first function called.
   binding_.WaitForIncomingMethodCall();
   // TODO(sky): deal with pipe being closed before we get OnEmbed().
 }
 
 void WindowTreeClient::DestroyWindow(Window* window) {
   DCHECK(tree_);
-  const uint32_t change_id = ScheduleInFlightChange(base::WrapUnique(
-      new CrashInFlightChange(window, ChangeType::DELETE_WINDOW)));
+  const uint32_t change_id = ScheduleInFlightChange(
+      base::MakeUnique<CrashInFlightChange>(window, ChangeType::DELETE_WINDOW));
   tree_->DeleteWindow(change_id, server_id(window));
 }
 
 void WindowTreeClient::AddChild(Window* parent, Id child_id) {
   DCHECK(tree_);
   const uint32_t change_id = ScheduleInFlightChange(
-      base::WrapUnique(new CrashInFlightChange(parent, ChangeType::ADD_CHILD)));
+      base::MakeUnique<CrashInFlightChange>(parent, ChangeType::ADD_CHILD));
   tree_->AddWindow(change_id, parent->server_id(), child_id);
 }
 
 void WindowTreeClient::RemoveChild(Window* parent, Id child_id) {
   DCHECK(tree_);
-  const uint32_t change_id = ScheduleInFlightChange(base::WrapUnique(
-      new CrashInFlightChange(parent, ChangeType::REMOVE_CHILD)));
+  const uint32_t change_id = ScheduleInFlightChange(
+      base::MakeUnique<CrashInFlightChange>(parent, ChangeType::REMOVE_CHILD));
   tree_->RemoveWindowFromParent(change_id, child_id);
 }
 
 void WindowTreeClient::AddTransientWindow(Window* window,
                                               Id transient_window_id) {
   DCHECK(tree_);
-  const uint32_t change_id = ScheduleInFlightChange(base::WrapUnique(
-      new CrashInFlightChange(window, ChangeType::ADD_TRANSIENT_WINDOW)));
+  const uint32_t change_id =
+      ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
+          window, ChangeType::ADD_TRANSIENT_WINDOW));
   tree_->AddTransientWindow(change_id, server_id(window), transient_window_id);
 }
 
 void WindowTreeClient::RemoveTransientWindowFromParent(Window* window) {
   DCHECK(tree_);
   const uint32_t change_id =
-      ScheduleInFlightChange(base::WrapUnique(new CrashInFlightChange(
-          window, ChangeType::REMOVE_TRANSIENT_WINDOW_FROM_PARENT)));
+      ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
+          window, ChangeType::REMOVE_TRANSIENT_WINDOW_FROM_PARENT));
   tree_->RemoveTransientWindowFromParent(change_id, server_id(window));
 }
 
 void WindowTreeClient::SetModal(Window* window) {
   DCHECK(tree_);
-  const uint32_t change_id = ScheduleInFlightChange(
-      base::WrapUnique(new InFlightSetModalChange(window)));
+  const uint32_t change_id =
+      ScheduleInFlightChange(base::MakeUnique<InFlightSetModalChange>(window));
   tree_->SetModal(change_id, server_id(window));
 }
 
 void WindowTreeClient::Reorder(Window* window,
                                    Id relative_window_id,
                                    mojom::OrderDirection direction) {
   DCHECK(tree_);
   const uint32_t change_id = ScheduleInFlightChange(
-      base::WrapUnique(new CrashInFlightChange(window, ChangeType::REORDER)));
+      base::MakeUnique<CrashInFlightChange>(window, ChangeType::REORDER));
   tree_->ReorderWindow(change_id, server_id(window), relative_window_id,
                        direction);
 }
 
 bool WindowTreeClient::OwnsWindow(Window* window) const {
   // Windows created via CreateTopLevelWindow() are not owned by us, but have
   // our client id.
   return HiWord(server_id(window)) == client_id_ &&
          roots_.count(window) == 0;
 }
 
 void WindowTreeClient::SetBounds(Window* window,
                                  const gfx::Rect& old_bounds,
                                  const gfx::Rect& bounds) {
   DCHECK(tree_);
   const uint32_t change_id = ScheduleInFlightChange(
-      base::WrapUnique(new InFlightBoundsChange(window, old_bounds)));
+      base::MakeUnique<InFlightBoundsChange>(window, old_bounds));
   tree_->SetWindowBounds(change_id, server_id(window), bounds);
 }
 
 void WindowTreeClient::SetCapture(Window* window) {
   // In order for us to get here we had to have exposed a window, which implies
   // we got a client.
   DCHECK(tree_);
   if (capture_window_ == window)
     return;
   const uint32_t change_id = ScheduleInFlightChange(
-      base::WrapUnique(new InFlightCaptureChange(this, capture_window_)));
+      base::MakeUnique<InFlightCaptureChange>(this, capture_window_));
   tree_->SetCapture(change_id, server_id(window));
   LocalSetCapture(window);
 }
 
 void WindowTreeClient::ReleaseCapture(Window* window) {
   // In order for us to get here we had to have exposed a window, which implies
   // we got a client.
   DCHECK(tree_);
   if (capture_window_ != window)
     return;
   const uint32_t change_id = ScheduleInFlightChange(
-      base::WrapUnique(new InFlightCaptureChange(this, window)));
+      base::MakeUnique<InFlightCaptureChange>(this, window));
   tree_->ReleaseCapture(change_id, server_id(window));
   LocalSetCapture(nullptr);
 }
 
 void WindowTreeClient::SetClientArea(
     Id window_id,
     const gfx::Insets& client_area,
     const std::vector<gfx::Rect>& additional_client_areas) {
   DCHECK(tree_);
   tree_->SetClientArea(window_id, client_area, additional_client_areas);
 }
 
 void WindowTreeClient::SetHitTestMask(Id window_id, const gfx::Rect& mask) {
   DCHECK(tree_);
   tree_->SetHitTestMask(window_id, mask);
 }
 
 void WindowTreeClient::ClearHitTestMask(Id window_id) {
   DCHECK(tree_);
   tree_->SetHitTestMask(window_id, base::nullopt);
 }
 
 void WindowTreeClient::SetFocus(Window* window) {
   // In order for us to get here we had to have exposed a window, which implies
   // we got a client.
   DCHECK(tree_);
   const uint32_t change_id = ScheduleInFlightChange(
-      base::WrapUnique(new InFlightFocusChange(this, focused_window_)));
+      base::MakeUnique<InFlightFocusChange>(this, focused_window_));
   tree_->SetFocus(change_id, window ? server_id(window) : 0);
   LocalSetFocus(window);
 }
 
 void WindowTreeClient::SetCanFocus(Id window_id, bool can_focus) {
   DCHECK(tree_);
   tree_->SetCanFocus(window_id, can_focus);
 }
 
 void WindowTreeClient::SetPredefinedCursor(Id window_id,
                                            ui::mojom::Cursor cursor_id) {
   DCHECK(tree_);
 
   Window* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
   // We make an inflight change thing here.
-  const uint32_t change_id = ScheduleInFlightChange(base::WrapUnique(
-      new InFlightPredefinedCursorChange(window, window->predefined_cursor())));
+  const uint32_t change_id =
+      ScheduleInFlightChange(base::MakeUnique<InFlightPredefinedCursorChange>(
+          window, window->predefined_cursor()));
   tree_->SetPredefinedCursor(change_id, window_id, cursor_id);
 }
 
 void WindowTreeClient::SetVisible(Window* window, bool visible) {
   DCHECK(tree_);
   const uint32_t change_id = ScheduleInFlightChange(
-      base::WrapUnique(new InFlightVisibleChange(window, !visible)));
+      base::MakeUnique<InFlightVisibleChange>(window, !visible));
   tree_->SetWindowVisibility(change_id, server_id(window), visible);
 }
 
 void WindowTreeClient::SetOpacity(Window* window, float opacity) {
   DCHECK(tree_);
   const uint32_t change_id = ScheduleInFlightChange(
-      base::WrapUnique(new InFlightOpacityChange(window, window->opacity())));
+      base::MakeUnique<InFlightOpacityChange>(window, window->opacity()));
   tree_->SetWindowOpacity(change_id, server_id(window), opacity);
 }
 
 void WindowTreeClient::SetProperty(Window* window,
                                        const std::string& name,
                                        mojo::Array<uint8_t> data) {
   DCHECK(tree_);
 
   mojo::Array<uint8_t> old_value(nullptr);
   if (window->HasSharedProperty(name))
     old_value = mojo::Array<uint8_t>::From(window->properties_[name]);
 
   const uint32_t change_id = ScheduleInFlightChange(
-      base::WrapUnique(new InFlightPropertyChange(window, name, old_value)));
+      base::MakeUnique<InFlightPropertyChange>(window, name, old_value));
   tree_->SetWindowProperty(change_id, server_id(window), mojo::String(name),
                            std::move(data));
 }
 
 void WindowTreeClient::SetWindowTextInputState(
     Id window_id,
     mojo::TextInputStatePtr state) {
   DCHECK(tree_);
   tree_->SetWindowTextInputState(window_id, std::move(state));
 }
@@ skipping 138 matching lines @@
 Window* WindowTreeClient::NewWindowImpl(
     NewWindowType type,
     const Window::SharedProperties* properties) {
   DCHECK(tree_);
   Window* window =
       new Window(this, MakeTransportId(client_id_, next_window_id_++));
   if (properties)
     window->properties_ = *properties;
   AddWindow(window);
 
-  const uint32_t change_id = ScheduleInFlightChange(base::WrapUnique(
-      new CrashInFlightChange(window, type == NewWindowType::CHILD
-                                          ? ChangeType::NEW_WINDOW
-                                          : ChangeType::NEW_TOP_LEVEL_WINDOW)));
+  const uint32_t change_id =
+      ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
+          window, type == NewWindowType::CHILD
+                      ? ChangeType::NEW_WINDOW
+                      : ChangeType::NEW_TOP_LEVEL_WINDOW));
   mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties;
   if (properties) {
     transport_properties =
         mojo::Map<mojo::String, mojo::Array<uint8_t>>::From(*properties);
   }
   if (type == NewWindowType::CHILD) {
     tree_->NewWindow(change_id, server_id(window),
                      std::move(transport_properties));
   } else {
     roots_.insert(window);
@@ skipping 752 matching lines @@
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   if (window_manager_internal_client_) {
     window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
         server_id(window), offset.x(), offset.y(), hit_area);
   }
 }
 
 }  // namespace ui