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

cc/output/gl_renderer_unittest.cc

 // Copyright 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 "cc/output/gl_renderer.h"
 
 #include <stdint.h>
 
 #include <set>
 
@@ skipping 334 matching lines @@
 class GLRendererWithDefaultHarnessTest : public GLRendererTest {
  protected:
   GLRendererWithDefaultHarnessTest() {
     output_surface_ =
         FakeOutputSurface::Create3d(TestWebGraphicsContext3D::Create());
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     resource_provider_ = FakeResourceProvider::Create(
         output_surface_.get(), shared_bitmap_manager_.get());
-    renderer_ = base::WrapUnique(new FakeRendererGL(
-        &settings_, output_surface_.get(), resource_provider_.get()));
+    renderer_ = base::MakeUnique<FakeRendererGL>(
+        &settings_, output_surface_.get(), resource_provider_.get());
     renderer_->Initialize();
     renderer_->SetVisible(true);
   }
 
   void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); }
 
   RendererSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   std::unique_ptr<FakeOutputSurface> output_surface_;
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
@@ skipping 1505 matching lines @@
       .WillOnce(::testing::Return(true));
   EXPECT_CALL(*processor->strategy_, Attempt(_, _, _)).Times(0);
   DrawFrame(&renderer, viewport_rect);
 }
 
 class SingleOverlayOnTopProcessor : public OverlayProcessor {
  public:
   class SingleOverlayValidator : public OverlayCandidateValidator {
    public:
     void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
-      strategies->push_back(
-          base::WrapUnique(new OverlayStrategySingleOnTop(this)));
-      strategies->push_back(
-          base::WrapUnique(new OverlayStrategyUnderlay(this)));
+      strategies->push_back(base::MakeUnique<OverlayStrategySingleOnTop>(this));
+      strategies->push_back(base::MakeUnique<OverlayStrategyUnderlay>(this));
     }
 
     bool AllowCALayerOverlays() override { return false; }
 
     void CheckOverlaySupport(OverlayCandidateList* surfaces) override {
       ASSERT_EQ(1U, surfaces->size());
       OverlayCandidate& candidate = surfaces->back();
       candidate.overlay_handled = true;
     }
   };
 
   explicit SingleOverlayOnTopProcessor(OutputSurface* surface)
       : OverlayProcessor(surface) {}
 
   void Initialize() override {
     strategies_.push_back(
-        base::WrapUnique(new OverlayStrategySingleOnTop(&validator_)));
+        base::MakeUnique<OverlayStrategySingleOnTop>(&validator_));
   }
 
   SingleOverlayValidator validator_;
 };
 
 class WaitSyncTokenCountingContext : public TestWebGraphicsContext3D {
  public:
   MOCK_METHOD1(waitSyncToken, void(const GLbyte* sync_token));
 };
 
@@ skipping 231 matching lines @@
   EXPECT_CALL(*context_support_ptr_, AnyClientsVisible())
       .WillOnce(Return(false));
   EXPECT_CALL(*context_provider_, DeleteCachedResources());
   EXPECT_CALL(*context_support_ptr_, SetAggressivelyFreeResources(true));
   renderer_->SetVisible(false);
   Mock::VerifyAndClearExpectations(context_support_ptr_);
 }
 
 }  // namespace
 }  // namespace cc