Convert //cc from scoped_ptr to std::unique_ptr.

cc/output/overlay_unittest.cc

Index: cc/output/overlay_unittest.cc
diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc
index 8697685cccf2bac4a3fd61f0a34e1b794feb3ffc..3cc09a3b20b234068df3d70952be1da7dcf8cbcf 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -6,6 +6,7 @@
 
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "cc/base/region.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/gl_renderer.h"
@@ -63,8 +64,8 @@ class SingleOverlayValidator : public OverlayCandidateValidator {
  public:
   void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
     strategies->push_back(
-        make_scoped_ptr(new OverlayStrategySingleOnTop(this)));
-    strategies->push_back(make_scoped_ptr(new OverlayStrategyUnderlay(this)));
+        base::WrapUnique(new OverlayStrategySingleOnTop(this)));
+    strategies->push_back(base::WrapUnique(new OverlayStrategyUnderlay(this)));
   }
   bool AllowCALayerOverlays() override { return false; }
   void CheckOverlaySupport(OverlayCandidateList* surfaces) override {
@@ -105,14 +106,14 @@ class SingleOnTopOverlayValidator : public SingleOverlayValidator {
  public:
   void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
     strategies->push_back(
-        make_scoped_ptr(new OverlayStrategySingleOnTop(this)));
+        base::WrapUnique(new OverlayStrategySingleOnTop(this)));
   }
 };
 
 class UnderlayOverlayValidator : public SingleOverlayValidator {
  public:
   void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
-    strategies->push_back(make_scoped_ptr(new OverlayStrategyUnderlay(this)));
+    strategies->push_back(base::WrapUnique(new OverlayStrategyUnderlay(this)));
   }
 };
 
@@ -171,17 +172,17 @@ class OverlayOutputSurface : public OutputSurface {
   unsigned bind_framebuffer_count() const { return bind_framebuffer_count_; }
 
  private:
-  scoped_ptr<OverlayCandidateValidator> overlay_candidate_validator_;
+  std::unique_ptr<OverlayCandidateValidator> overlay_candidate_validator_;
   bool is_displayed_as_overlay_plane_;
   unsigned bind_framebuffer_count_ = 0;
 };
 
-scoped_ptr<RenderPass> CreateRenderPass() {
+std::unique_ptr<RenderPass> CreateRenderPass() {
   RenderPassId id(1, 0);
   gfx::Rect output_rect(0, 0, 256, 256);
   bool has_transparent_background = true;
 
-  scoped_ptr<RenderPass> pass = RenderPass::Create();
+  std::unique_ptr<RenderPass> pass = RenderPass::Create();
   pass->SetAll(id,
                output_rect,
                output_rect,
@@ -199,7 +200,7 @@ ResourceId CreateResource(ResourceProvider* resource_provider,
   TextureMailbox mailbox =
       TextureMailbox(gpu::Mailbox::Generate(), gpu::SyncToken(), GL_TEXTURE_2D,
                      size, is_overlay_candidate, false);
-  scoped_ptr<SingleReleaseCallbackImpl> release_callback =
+  std::unique_ptr<SingleReleaseCallbackImpl> release_callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&MailboxReleased));
 
   return resource_provider->CreateResourceFromTextureMailbox(
@@ -350,11 +351,11 @@ class OverlayTest : public testing::Test {
   }
 
   scoped_refptr<TestContextProvider> provider_;
-  scoped_ptr<OverlayOutputSurface> output_surface_;
+  std::unique_ptr<OverlayOutputSurface> output_surface_;
   FakeOutputSurfaceClient client_;
-  scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
-  scoped_ptr<ResourceProvider> resource_provider_;
-  scoped_ptr<OverlayProcessor> overlay_processor_;
+  std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
+  std::unique_ptr<ResourceProvider> resource_provider_;
+  std::unique_ptr<OverlayProcessor> overlay_processor_;
   gfx::Rect damage_rect_;
 };
 
@@ -378,19 +379,20 @@ TEST(OverlayTest, OverlaysProcessorHasStrategy) {
   EXPECT_TRUE(output_surface.BindToClient(&client));
   output_surface.SetOverlayCandidateValidator(new SingleOverlayValidator);
 
-  scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
+  std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
-  scoped_ptr<ResourceProvider> resource_provider = FakeResourceProvider::Create(
-      &output_surface, shared_bitmap_manager.get());
+  std::unique_ptr<ResourceProvider> resource_provider =
+      FakeResourceProvider::Create(&output_surface,
+                                   shared_bitmap_manager.get());
 
-  scoped_ptr<DefaultOverlayProcessor> overlay_processor(
+  std::unique_ptr<DefaultOverlayProcessor> overlay_processor(
       new DefaultOverlayProcessor(&output_surface));
   overlay_processor->Initialize();
   EXPECT_GE(2U, overlay_processor->GetStrategyCount());
 }
 
 TEST_F(SingleOverlayOnTopTest, SuccessfulOverlay) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   TextureDrawQuad* original_quad =
       CreateFullscreenCandidateQuad(resource_provider_.get(),
                                     pass->shared_quad_state_list.back(),
@@ -425,7 +427,7 @@ TEST_F(SingleOverlayOnTopTest, SuccessfulOverlay) {
 }
 
 TEST_F(SingleOverlayOnTopTest, DamageRect) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
@@ -455,7 +457,7 @@ TEST_F(SingleOverlayOnTopTest, DamageRect) {
 }
 
 TEST_F(SingleOverlayOnTopTest, NoCandidates) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
@@ -477,7 +479,7 @@ TEST_F(SingleOverlayOnTopTest, NoCandidates) {
 }
 
 TEST_F(SingleOverlayOnTopTest, OccludedCandidates) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
@@ -504,7 +506,7 @@ TEST_F(SingleOverlayOnTopTest, OccludedCandidates) {
 
 // Test with multiple render passes.
 TEST_F(SingleOverlayOnTopTest, MultipleRenderPasses) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
@@ -524,7 +526,7 @@ TEST_F(SingleOverlayOnTopTest, MultipleRenderPasses) {
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectPremultipliedAlpha) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   TextureDrawQuad* quad =
       CreateFullscreenCandidateQuad(resource_provider_.get(),
                                     pass->shared_quad_state_list.back(),
@@ -539,7 +541,7 @@ TEST_F(SingleOverlayOnTopTest, RejectPremultipliedAlpha) {
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectBlending) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   TextureDrawQuad* quad =
       CreateFullscreenCandidateQuad(resource_provider_.get(),
                                     pass->shared_quad_state_list.back(),
@@ -554,7 +556,7 @@ TEST_F(SingleOverlayOnTopTest, RejectBlending) {
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectBackgroundColor) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   TextureDrawQuad* quad =
       CreateFullscreenCandidateQuad(resource_provider_.get(),
                                     pass->shared_quad_state_list.back(),
@@ -569,7 +571,7 @@ TEST_F(SingleOverlayOnTopTest, RejectBackgroundColor) {
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectBlendMode) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
@@ -583,7 +585,7 @@ TEST_F(SingleOverlayOnTopTest, RejectBlendMode) {
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectOpacity) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
@@ -597,7 +599,7 @@ TEST_F(SingleOverlayOnTopTest, RejectOpacity) {
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectNonAxisAlignedTransform) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
@@ -612,7 +614,7 @@ TEST_F(SingleOverlayOnTopTest, RejectNonAxisAlignedTransform) {
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowClipped) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
@@ -630,7 +632,7 @@ TEST_F(SingleOverlayOnTopTest, AllowVerticalFlip) {
   gfx::Rect rect = kOverlayRect;
   rect.set_width(rect.width() / 2);
   rect.Offset(0, -rect.height());
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(), rect);
   pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(2.0f,
@@ -648,7 +650,7 @@ TEST_F(SingleOverlayOnTopTest, AllowHorizontalFlip) {
   gfx::Rect rect = kOverlayRect;
   rect.set_height(rect.height() / 2);
   rect.Offset(-rect.width(), 0);
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(), rect);
   pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(-1.0f,
@@ -666,7 +668,7 @@ TEST_F(SingleOverlayOnTopTest, AllowHorizontalFlip) {
 TEST_F(SingleOverlayOnTopTest, AllowPositiveScaleTransform) {
   gfx::Rect rect = kOverlayRect;
   rect.set_width(rect.width() / 2);
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(), rect);
   pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(2.0f,
@@ -681,7 +683,7 @@ TEST_F(SingleOverlayOnTopTest, AllowPositiveScaleTransform) {
 TEST_F(SingleOverlayOnTopTest, Allow90DegreeRotation) {
   gfx::Rect rect = kOverlayRect;
   rect.Offset(0, -rect.height());
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(), rect);
   pass->shared_quad_state_list.back()
@@ -698,7 +700,7 @@ TEST_F(SingleOverlayOnTopTest, Allow90DegreeRotation) {
 TEST_F(SingleOverlayOnTopTest, Allow180DegreeRotation) {
   gfx::Rect rect = kOverlayRect;
   rect.Offset(-rect.width(), -rect.height());
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(), rect);
   pass->shared_quad_state_list.back()
@@ -715,7 +717,7 @@ TEST_F(SingleOverlayOnTopTest, Allow180DegreeRotation) {
 TEST_F(SingleOverlayOnTopTest, Allow270DegreeRotation) {
   gfx::Rect rect = kOverlayRect;
   rect.Offset(-rect.width(), 0);
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(), rect);
   pass->shared_quad_state_list.back()
@@ -730,7 +732,7 @@ TEST_F(SingleOverlayOnTopTest, Allow270DegreeRotation) {
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowNotTopIfNotOccluded) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateOpaqueQuadAt(resource_provider_.get(),
                      pass->shared_quad_state_list.back(), pass.get(),
                      kOverlayTopLeftRect);
@@ -747,7 +749,7 @@ TEST_F(SingleOverlayOnTopTest, AllowNotTopIfNotOccluded) {
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowTransparentOnTop) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
   shared_state->opacity = 0.f;
   CreateSolidColorQuadAt(shared_state, SK_ColorBLACK, pass.get(),
@@ -765,7 +767,7 @@ TEST_F(SingleOverlayOnTopTest, AllowTransparentOnTop) {
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowTransparentColorOnTop) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateSolidColorQuadAt(pass->shared_quad_state_list.back(),
                          SK_ColorTRANSPARENT, pass.get(),
                          kOverlayBottomRightRect);
@@ -781,7 +783,7 @@ TEST_F(SingleOverlayOnTopTest, AllowTransparentColorOnTop) {
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectOpaqueColorOnTop) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
   shared_state->opacity = 0.5f;
   CreateSolidColorQuadAt(shared_state, SK_ColorBLACK, pass.get(),
@@ -799,7 +801,7 @@ TEST_F(SingleOverlayOnTopTest, RejectOpaqueColorOnTop) {
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectTransparentColorOnTopWithoutBlending) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
   CreateSolidColorQuadAt(shared_state, SK_ColorTRANSPARENT, pass.get(),
                          kOverlayBottomRightRect)->opaque_rect =
@@ -815,7 +817,7 @@ TEST_F(SingleOverlayOnTopTest, RejectTransparentColorOnTopWithoutBlending) {
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectVideoSwapTransform) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateVideoQuad(resource_provider_.get(),
                                      pass->shared_quad_state_list.back(),
                                      pass.get(), kSwapTransform);
@@ -828,7 +830,7 @@ TEST_F(SingleOverlayOnTopTest, RejectVideoSwapTransform) {
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowVideoXMirrorTransform) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateVideoQuad(resource_provider_.get(),
                                      pass->shared_quad_state_list.back(),
                                      pass.get(), kXMirrorTransform);
@@ -841,7 +843,7 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoXMirrorTransform) {
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowVideoBothMirrorTransform) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateVideoQuad(resource_provider_.get(),
                                      pass->shared_quad_state_list.back(),
                                      pass.get(), kBothMirrorTransform);
@@ -854,7 +856,7 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoBothMirrorTransform) {
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowVideoNormalTransform) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateVideoQuad(resource_provider_.get(),
                                      pass->shared_quad_state_list.back(),
                                      pass.get(), kNormalTransform);
@@ -867,7 +869,7 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoNormalTransform) {
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowVideoYMirrorTransform) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateVideoQuad(resource_provider_.get(),
                                      pass->shared_quad_state_list.back(),
                                      pass.get(), kYMirrorTransform);
@@ -880,7 +882,7 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoYMirrorTransform) {
 }
 
 TEST_F(UnderlayTest, OverlayLayerUnderMainLayer) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
   CreateCandidateQuadAt(resource_provider_.get(),
@@ -899,7 +901,7 @@ TEST_F(UnderlayTest, OverlayLayerUnderMainLayer) {
 }
 
 TEST_F(UnderlayTest, AllowOnTop) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
@@ -919,7 +921,7 @@ TEST_F(UnderlayTest, AllowOnTop) {
 
 // The first time an underlay is scheduled its damage must not be subtracted.
 TEST_F(UnderlayTest, InitialUnderlayDamageNotSubtracted) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
@@ -938,7 +940,7 @@ TEST_F(UnderlayTest, InitialUnderlayDamageNotSubtracted) {
 // subtracted the second time.
 TEST_F(UnderlayTest, DamageSubtractedForConsecutiveIdenticalUnderlays) {
   for (int i = 0; i < 2; ++i) {
-    scoped_ptr<RenderPass> pass = CreateRenderPass();
+    std::unique_ptr<RenderPass> pass = CreateRenderPass();
     CreateFullscreenCandidateQuad(resource_provider_.get(),
                                   pass->shared_quad_state_list.back(),
                                   pass.get());
@@ -965,7 +967,7 @@ TEST_F(UnderlayTest, DamageSubtractedForConsecutiveIdenticalUnderlays) {
 TEST_F(UnderlayTest, DamageNotSubtractedForNonIdenticalConsecutiveUnderlays) {
   gfx::Rect overlay_rects[] = {kOverlayBottomRightRect, kOverlayRect};
   for (int i = 0; i < 2; ++i) {
-    scoped_ptr<RenderPass> pass = CreateRenderPass();
+    std::unique_ptr<RenderPass> pass = CreateRenderPass();
 
     CreateCandidateQuadAt(resource_provider_.get(),
                           pass->shared_quad_state_list.back(), pass.get(),
@@ -984,7 +986,7 @@ TEST_F(UnderlayTest, DamageNotSubtractedForNonIdenticalConsecutiveUnderlays) {
 
 TEST_F(UnderlayTest, DamageNotSubtractedWhenQuadsAboveOverlap) {
   for (int i = 0; i < 2; ++i) {
-    scoped_ptr<RenderPass> pass = CreateRenderPass();
+    std::unique_ptr<RenderPass> pass = CreateRenderPass();
     // Add an overlapping quad above the candidate.
     CreateFullscreenOpaqueQuad(resource_provider_.get(),
                                pass->shared_quad_state_list.back(), pass.get());
@@ -1005,7 +1007,7 @@ TEST_F(UnderlayTest, DamageNotSubtractedWhenQuadsAboveOverlap) {
 
 TEST_F(UnderlayTest, DamageSubtractedWhenQuadsAboveDontOverlap) {
   for (int i = 0; i < 2; ++i) {
-    scoped_ptr<RenderPass> pass = CreateRenderPass();
+    std::unique_ptr<RenderPass> pass = CreateRenderPass();
     // Add a non-overlapping quad above the candidate.
     CreateOpaqueQuadAt(resource_provider_.get(),
                        pass->shared_quad_state_list.back(), pass.get(),
@@ -1038,7 +1040,7 @@ OverlayCandidateList BackbufferOverlayList(const RenderPass* root_render_pass) {
 }
 
 TEST_F(CALayerOverlayTest, AllowNonAxisAlignedTransform) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
@@ -1058,7 +1060,7 @@ TEST_F(CALayerOverlayTest, AllowNonAxisAlignedTransform) {
 }
 
 TEST_F(CALayerOverlayTest, ThreeDTransform) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
@@ -1081,7 +1083,7 @@ TEST_F(CALayerOverlayTest, ThreeDTransform) {
 }
 
 TEST_F(CALayerOverlayTest, AllowContainingClip) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
@@ -1101,7 +1103,7 @@ TEST_F(CALayerOverlayTest, AllowContainingClip) {
 }
 
 TEST_F(CALayerOverlayTest, NontrivialClip) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
@@ -1123,7 +1125,7 @@ TEST_F(CALayerOverlayTest, NontrivialClip) {
 }
 
 TEST_F(CALayerOverlayTest, SkipTransparent) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
@@ -1215,11 +1217,9 @@ class GLRendererWithOverlaysTest : public testing::Test {
     if (use_validator)
       output_surface_->SetOverlayCandidateValidator(new SingleOverlayValidator);
 
-    renderer_ =
-        make_scoped_ptr(new OverlayInfoRendererGL(&renderer_client_,
-                                                  &settings_,
-                                                  output_surface_.get(),
-                                                  resource_provider_.get()));
+    renderer_ = base::WrapUnique(new OverlayInfoRendererGL(
+        &renderer_client_, &settings_, output_surface_.get(),
+        resource_provider_.get()));
   }
 
   void SwapBuffers() {
@@ -1237,10 +1237,10 @@ class GLRendererWithOverlaysTest : public testing::Test {
 
   RendererSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
-  scoped_ptr<OverlayOutputSurface> output_surface_;
+  std::unique_ptr<OverlayOutputSurface> output_surface_;
   FakeRendererClient renderer_client_;
-  scoped_ptr<ResourceProvider> resource_provider_;
-  scoped_ptr<OverlayInfoRendererGL> renderer_;
+  std::unique_ptr<ResourceProvider> resource_provider_;
+  std::unique_ptr<OverlayInfoRendererGL> renderer_;
   scoped_refptr<TestContextProvider> provider_;
   MockOverlayScheduler scheduler_;
 };
@@ -1251,7 +1251,7 @@ TEST_F(GLRendererWithOverlaysTest, OverlayQuadNotDrawn) {
   renderer_->set_expect_overlays(true);
   gfx::Rect viewport_rect(16, 16);
 
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
 
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(),
@@ -1290,7 +1290,7 @@ TEST_F(GLRendererWithOverlaysTest, OccludedQuadInUnderlay) {
   renderer_->set_expect_overlays(true);
   gfx::Rect viewport_rect(16, 16);
 
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
 
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
@@ -1330,7 +1330,7 @@ TEST_F(GLRendererWithOverlaysTest, NoValidatorNoOverlay) {
   renderer_->set_expect_overlays(false);
   gfx::Rect viewport_rect(16, 16);
 
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
 
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
@@ -1364,7 +1364,7 @@ TEST_F(GLRendererWithOverlaysTest, OccludedQuadNotDrawnWhenPartialSwapEnabled) {
   renderer_->set_expect_overlays(true);
   gfx::Rect viewport_rect(16, 16);
 
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
 
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
@@ -1395,7 +1395,7 @@ TEST_F(GLRendererWithOverlaysTest, OccludedQuadNotDrawnWhenEmptySwapAllowed) {
   renderer_->set_expect_overlays(true);
   gfx::Rect viewport_rect(16, 16);
 
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
 
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
@@ -1431,7 +1431,7 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturnedWithDelay) {
   ResourceId resource3 =
       CreateResource(resource_provider_.get(), gfx::Size(32, 32), true);
 
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));
 
@@ -1554,7 +1554,7 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturnedAtSwapComplete) {
   ResourceId resource3 =
       CreateResource(resource_provider_.get(), gfx::Size(32, 32), true);
 
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));