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

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 4342 matching lines @@
       compositor_context_provider = first_context_provider_;
     } else {
       EXPECT_FALSE(second_context_provider_);
       second_context_provider_ = TestContextProvider::Create();
       compositor_context_provider = second_context_provider_;
     }
 
     auto output_surface =
         FakeOutputSurface::Create3d(std::move(compositor_context_provider));
     output_surface->SetMemoryPolicyToSetAtBind(
-        base::WrapUnique(new ManagedMemoryPolicy(
+        base::MakeUnique<ManagedMemoryPolicy>(
             second_context_provider_.get() ? second_output_surface_memory_limit_
                                            : first_output_surface_memory_limit_,
             gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
-            ManagedMemoryPolicy::kDefaultNumResourcesLimit)));
+            ManagedMemoryPolicy::kDefaultNumResourcesLimit));
     return std::move(output_surface);
   }
 
   void SetupTree() override {
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
     layer_tree()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
@@ skipping 101 matching lines @@
 class PinnedLayerTreeSwapPromise : public LayerTreeHostTest {
  protected:
   void BeginTest() override {
     PostSetNextCommitForcesRedrawToMainThread();
     PostSetNeedsCommitToMainThread();
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     int frame = host_impl->active_tree()->source_frame_number();
     if (frame == -1) {
-      host_impl->active_tree()->QueuePinnedSwapPromise(base::WrapUnique(
-          new TestSwapPromise(&pinned_active_swap_promise_result_)));
+      host_impl->active_tree()->QueuePinnedSwapPromise(
+          base::MakeUnique<TestSwapPromise>(
+              &pinned_active_swap_promise_result_));
       host_impl->pending_tree()->QueueSwapPromise(
-          base::WrapUnique(new TestSwapPromise(&pending_swap_promise_result_)));
+          base::MakeUnique<TestSwapPromise>(&pending_swap_promise_result_));
       host_impl->active_tree()->QueueSwapPromise(
-          base::WrapUnique(new TestSwapPromise(&active_swap_promise_result_)));
+          base::MakeUnique<TestSwapPromise>(&active_swap_promise_result_));
     }
   }
 
   void DisplayDidDrawAndSwapOnThread() override { EndTest(); }
 
   void AfterTest() override {
     // The pending swap promise should activate and swap.
     EXPECT_TRUE(pending_swap_promise_result_.did_activate_called);
     EXPECT_TRUE(pending_swap_promise_result_.did_swap_called);
 
@@ skipping 130 matching lines @@
     MainThreadTaskRunner()->PostTask(
         FROM_HERE, base::Bind(&LayerTreeHostTestKeepSwapPromise::ChangeFrame,
                               base::Unretained(this)));
   }
 
   void ChangeFrame() {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         layer_->SetBounds(gfx::Size(10, 11));
         layer_tree_host()->QueueSwapPromise(
-            base::WrapUnique(new TestSwapPromise(&swap_promise_result_)));
+            base::MakeUnique<TestSwapPromise>(&swap_promise_result_));
         break;
       case 2:
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   void WillActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
@@ skipping 94 matching lines @@
     EXPECT_FALSE(swap_promise_result_.did_swap_called);
     host_impl->BlockNotifyReadyToActivateForTesting(false);
   }
 
   void ChangeFrame() {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Make no changes so that we abort the next commit caused by queuing
         // the swap promise.
         layer_tree_host()->QueueSwapPromise(
-            base::WrapUnique(new TestSwapPromise(&swap_promise_result_)));
+            base::MakeUnique<TestSwapPromise>(&swap_promise_result_));
         layer_tree_host()->SetNeedsUpdateLayers();
         break;
       case 2:
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
@@ skipping 2254 matching lines @@
  private:
   FakeContentLayerClient client_;
   const gfx::Size viewport_size_;
   const gfx::Size large_image_size_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(GpuRasterizationSucceedsWithLargeImage);
 
 }  // namespace
 }  // namespace cc