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

cc/layers/picture_layer_impl_unittest.cc

 // Copyright 2013 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/layers/picture_layer_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 211 matching lines @@
                                 const Region& invalidation) {
     host_impl_.CreatePendingTree();
     host_impl_.pending_tree()->PushPageScaleFromMainThread(1.f, 0.00001f,
                                                            100000.f);
     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
     pending_tree->SetDeviceScaleFactor(
         host_impl_.active_tree()->device_scale_factor());
 
     // Steal from the recycled tree if possible.
     LayerImpl* pending_root = pending_tree->root_layer();
-    scoped_ptr<FakePictureLayerImpl> pending_layer;
+    std::unique_ptr<FakePictureLayerImpl> pending_layer;
     DCHECK(!pending_root || pending_root->id() == root_id_);
     if (!pending_root) {
-      scoped_ptr<LayerImpl> new_pending_root =
+      std::unique_ptr<LayerImpl> new_pending_root =
           LayerImpl::Create(pending_tree, root_id_);
       pending_layer = FakePictureLayerImpl::Create(pending_tree, id_);
       if (!tile_size.IsEmpty())
         pending_layer->set_fixed_tile_size(tile_size);
       pending_layer->SetDrawsContent(true);
       pending_layer->SetScrollClipLayer(new_pending_root->id());
       pending_root = new_pending_root.get();
       pending_tree->SetRootLayer(std::move(new_pending_root));
     } else {
       pending_layer.reset(static_cast<FakePictureLayerImpl*>(
@@ skipping 140 matching lines @@
     // copy this over to the pending tree inside SetupPendingTreeInternal.
     host_impl_.active_tree()->SetDeviceScaleFactor(device_scale_factor);
   }
 
  protected:
   void TestQuadsForSolidColor(bool test_for_solid);
 
   FakeImplTaskRunnerProvider task_runner_provider_;
   TestSharedBitmapManager shared_bitmap_manager_;
   TestTaskGraphRunner task_graph_runner_;
-  scoped_ptr<OutputSurface> output_surface_;
+  std::unique_ptr<OutputSurface> output_surface_;
   FakeLayerTreeHostImpl host_impl_;
   int root_id_;
   int id_;
   FakePictureLayerImpl* pending_layer_;
   FakePictureLayerImpl* old_pending_layer_;
   FakePictureLayerImpl* active_layer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PictureLayerImplTest);
 };
 
 class NoLowResPictureLayerImplTest : public PictureLayerImplTest {
  public:
   NoLowResPictureLayerImplTest()
       : PictureLayerImplTest(NoLowResTilingsSettings()) {}
 };
 
 TEST_F(PictureLayerImplTest, TileGridAlignment) {
   // Layer to span 4 raster tiles in x and in y
   LayerTreeSettings settings;
   gfx::Size layer_size(settings.default_tile_size.width() * 7 / 2,
                        settings.default_tile_size.height() * 7 / 2);
 
   scoped_refptr<FakeRasterSource> pending_raster_source =
       FakeRasterSource::CreateFilled(layer_size);
 
   // Create an active recording source, but make sure it's not solid.
-  scoped_ptr<FakeRecordingSource> active_recording_source =
+  std::unique_ptr<FakeRecordingSource> active_recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_size);
   active_recording_source->SetLayerBounds(layer_size);
   active_recording_source->add_draw_rect(gfx::Rect(layer_size));
   active_recording_source->add_draw_rect(
       gfx::Rect(0, 0, layer_size.width() - 1, layer_size.height() - 1));
   active_recording_source->Rerecord();
   scoped_refptr<FakeRasterSource> active_raster_source =
       FakeRasterSource::CreateFromRecordingSource(active_recording_source.get(),
                                                   false);
 
@@ skipping 852 matching lines @@
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
   EXPECT_EQ(active_layer_->LowResTiling()->contents_scale(),
             contents_scale * low_res_factor);
   EXPECT_FALSE(pending_layer_->LowResTiling());
   EXPECT_EQ(active_layer_->num_tilings(), 2u);
   EXPECT_EQ(pending_layer_->num_tilings(), 1u);
 
   // Mask layers dont create low res since they always fit on one tile.
-  scoped_ptr<FakePictureLayerImpl> mask =
+  std::unique_ptr<FakePictureLayerImpl> mask =
       FakePictureLayerImpl::CreateMaskWithRasterSource(
           host_impl_.pending_tree(), 3, pending_raster_source);
   mask->SetBounds(layer_bounds);
   mask->SetDrawsContent(true);
   pending_layer_->SetMaskLayer(std::move(mask));
   pending_layer_->SetHasRenderSurface(true);
   RebuildPropertyTreesOnPendingTree();
   host_impl_.pending_tree()->UpdateDrawProperties(false);
 
   FakePictureLayerImpl* mask_raw =
       static_cast<FakePictureLayerImpl*>(pending_layer_->mask_layer());
   SetupDrawPropertiesAndUpdateTiles(
       mask_raw, contents_scale, device_scale, page_scale,
       maximum_animation_scale, starting_animation_scale, animating_transform);
   EXPECT_EQ(mask_raw->HighResTiling()->contents_scale(), contents_scale);
   EXPECT_EQ(mask_raw->num_tilings(), 1u);
 }
 
 TEST_F(PictureLayerImplTest, HugeMasksGetScaledDown) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size layer_bounds(1000, 1000);
 
   scoped_refptr<FakeRasterSource> valid_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   SetupPendingTree(valid_raster_source);
 
-  scoped_ptr<FakePictureLayerImpl> mask_ptr =
+  std::unique_ptr<FakePictureLayerImpl> mask_ptr =
       FakePictureLayerImpl::CreateMaskWithRasterSource(
           host_impl_.pending_tree(), 3, valid_raster_source);
   mask_ptr->SetBounds(layer_bounds);
   mask_ptr->SetDrawsContent(true);
   pending_layer_->SetMaskLayer(std::move(mask_ptr));
   pending_layer_->SetForceRenderSurface(true);
 
   RebuildPropertyTreesOnPendingTree();
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   bool update_lcd_text = false;
@@ skipping 108 matching lines @@
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size layer_bounds(1000, 1000);
 
   SetInitialDeviceScaleFactor(1.3f);
 
   scoped_refptr<FakeRasterSource> valid_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   SetupPendingTree(valid_raster_source);
 
-  scoped_ptr<FakePictureLayerImpl> mask_ptr =
+  std::unique_ptr<FakePictureLayerImpl> mask_ptr =
       FakePictureLayerImpl::CreateMaskWithRasterSource(
           host_impl_.pending_tree(), 3, valid_raster_source);
   mask_ptr->SetBounds(layer_bounds);
   mask_ptr->SetDrawsContent(true);
   pending_layer_->SetMaskLayer(std::move(mask_ptr));
   pending_layer_->SetForceRenderSurface(true);
 
   RebuildPropertyTreesOnPendingTree();
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   bool update_lcd_text = false;
@@ skipping 67 matching lines @@
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
             host_impl_.settings().default_tile_size.ToString());
 
   Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
             tile->content_rect().size().ToString());
 
   ResetTilingsAndRasterScales();
 
   // Change the max texture size on the output surface context.
-  scoped_ptr<TestWebGraphicsContext3D> context =
+  std::unique_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   context->set_max_texture_size(140);
   host_impl_.DidLoseOutputSurface();
-  scoped_ptr<OutputSurface> new_output_surface =
+  std::unique_ptr<OutputSurface> new_output_surface =
       FakeOutputSurface::Create3d(std::move(context));
   host_impl_.SetVisible(true);
   host_impl_.InitializeRenderer(new_output_surface.get());
   output_surface_ = std::move(new_output_surface);
 
   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, 0.f,
                                     false);
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
@@ skipping 15 matching lines @@
   EXPECT_EQ(gfx::Size(512, 512).ToString(),
             host_impl_.settings().max_untiled_layer_size.ToString());
 
   // There should be a single tile since the layer is small.
   PictureLayerTiling* high_res_tiling = active_layer_->tilings()->tiling_at(0);
   EXPECT_EQ(1u, high_res_tiling->AllTilesForTesting().size());
 
   ResetTilingsAndRasterScales();
 
   // Change the max texture size on the output surface context.
-  scoped_ptr<TestWebGraphicsContext3D> context =
+  std::unique_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   context->set_max_texture_size(140);
   host_impl_.DidLoseOutputSurface();
-  scoped_ptr<OutputSurface> new_output_surface =
+  std::unique_ptr<OutputSurface> new_output_surface =
       FakeOutputSurface::Create3d(std::move(context));
   host_impl_.SetVisible(true);
   host_impl_.InitializeRenderer(new_output_surface.get());
   output_surface_ = std::move(new_output_surface);
 
   SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, 0.f,
                                     false);
   ASSERT_LE(1u, active_layer_->tilings()->num_tilings());
 
   active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
   // There should be more than one tile since the max texture size won't cover
   // the layer.
   high_res_tiling = active_layer_->tilings()->tiling_at(0);
   EXPECT_LT(1u, high_res_tiling->AllTilesForTesting().size());
 
   // Verify the tiles are not larger than the context's max texture size.
   Tile* tile = active_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_GE(140, tile->content_rect().width());
   EXPECT_GE(140, tile->content_rect().height());
 }
 
 TEST_F(PictureLayerImplTest, DisallowTileDrawQuads) {
-  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
 
   gfx::Size layer_bounds(1300, 1900);
   gfx::Rect layer_rect(layer_bounds);
 
   gfx::Rect layer_invalidation(150, 200, 30, 180);
   SetupDefaultTreesWithInvalidation(layer_bounds, layer_invalidation);
 
   active_layer_->SetContentsOpaque(true);
   active_layer_->draw_properties().visible_layer_rect = gfx::Rect(layer_bounds);
 
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_RESOURCELESS_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   ASSERT_EQ(1u, render_pass->quad_list.size());
   EXPECT_EQ(DrawQuad::PICTURE_CONTENT,
             render_pass->quad_list.front()->material);
   EXPECT_EQ(render_pass->quad_list.front()->rect, layer_rect);
   EXPECT_EQ(render_pass->quad_list.front()->opaque_rect, layer_rect);
   EXPECT_EQ(render_pass->quad_list.front()->visible_rect, layer_rect);
 }
 
 TEST_F(PictureLayerImplTest, ResourcelessPartialRecording) {
-  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
 
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(700, 650);
   gfx::Rect layer_rect(layer_bounds);
   SetInitialDeviceScaleFactor(2.f);
 
   gfx::Rect recorded_viewport(20, 30, 40, 50);
   scoped_refptr<FakeRasterSource> active_raster_source =
       FakeRasterSource::CreatePartiallyFilled(layer_bounds, recorded_viewport);
 
@@ skipping 16 matching lines @@
   ASSERT_EQ(1U, render_pass->quad_list.size());
   EXPECT_EQ(DrawQuad::PICTURE_CONTENT,
             render_pass->quad_list.front()->material);
   const DrawQuad* quad = render_pass->quad_list.front();
   EXPECT_EQ(quad_visible, quad->rect);
   EXPECT_EQ(quad_visible, quad->opaque_rect);
   EXPECT_EQ(quad_visible, quad->visible_rect);
 }
 
 TEST_F(PictureLayerImplTest, ResourcelessEmptyRecording) {
-  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
 
   gfx::Size layer_bounds(700, 650);
   scoped_refptr<FakeRasterSource> active_raster_source =
       FakeRasterSource::CreatePartiallyFilled(layer_bounds, gfx::Rect());
   SetupPendingTree(active_raster_source);
   ActivateTree();
 
   active_layer_->SetContentsOpaque(true);
   active_layer_->draw_properties().visible_layer_rect = gfx::Rect(layer_bounds);
 
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_RESOURCELESS_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   EXPECT_EQ(0U, render_pass->quad_list.size());
 }
 
 TEST_F(PictureLayerImplTest, SolidColorLayerHasVisibleFullCoverage) {
-  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
 
   gfx::Size layer_bounds(1500, 1500);
   gfx::Rect visible_rect(250, 250, 1000, 1000);
 
   scoped_refptr<FakeRasterSource> pending_raster_source =
       FakeRasterSource::CreateFilledSolidColor(layer_bounds);
   scoped_refptr<FakeRasterSource> active_raster_source =
       FakeRasterSource::CreateFilledSolidColor(layer_bounds);
 
   SetupTrees(pending_raster_source, active_raster_source);
@@ skipping 50 matching lines @@
   EXPECT_EQ(viewport,
             pending_layer_->viewport_rect_for_tile_priority_in_content_space());
 
   base::TimeTicks time_ticks;
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   pending_layer_->UpdateTiles();
 
   int num_visible = 0;
   int num_offscreen = 0;
 
-  scoped_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
+  std::unique_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), false));
   for (; !queue->IsEmpty(); queue->Pop()) {
     const PrioritizedTile& prioritized_tile = queue->Top();
     DCHECK(prioritized_tile.tile());
     if (prioritized_tile.priority().distance_to_visible == 0.f) {
       EXPECT_TRUE(prioritized_tile.tile()->required_for_activation());
       num_visible++;
     } else {
       EXPECT_FALSE(prioritized_tile.tile()->required_for_activation());
       num_offscreen++;
@@ skipping 62 matching lines @@
   }
 
   EXPECT_GT(num_inside, 0);
   EXPECT_GT(num_outside, 0);
 
   // Activate and draw active layer.
   host_impl_.ActivateSyncTree();
   host_impl_.active_tree()->UpdateDrawProperties(update_lcd_text);
   active_layer_->draw_properties().visible_layer_rect = visible_layer_rect;
 
-  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   // All tiles in activation rect is ready to draw.
   EXPECT_EQ(0u, data.num_missing_tiles);
   EXPECT_EQ(0u, data.num_incomplete_tiles);
   EXPECT_FALSE(active_layer_->only_used_low_res_last_append_quads());
 }
 
 TEST_F(PictureLayerImplTest, HighResTileIsComplete) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
 
   scoped_refptr<FakeRasterSource> pending_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
 
   SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
   ActivateTree();
 
   // All high res tiles have resources.
   std::vector<Tile*> tiles =
       active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
 
-  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   // All high res tiles drew, nothing was incomplete.
   EXPECT_EQ(9u, render_pass->quad_list.size());
   EXPECT_EQ(0u, data.num_missing_tiles);
   EXPECT_EQ(0u, data.num_incomplete_tiles);
   EXPECT_FALSE(active_layer_->only_used_low_res_last_append_quads());
 }
 
 TEST_F(PictureLayerImplTest, HighResTileIsIncomplete) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
 
   scoped_refptr<FakeRasterSource> pending_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
   ActivateTree();
 
-  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   EXPECT_EQ(1u, render_pass->quad_list.size());
   EXPECT_EQ(1u, data.num_missing_tiles);
   EXPECT_EQ(0u, data.num_incomplete_tiles);
   EXPECT_TRUE(active_layer_->only_used_low_res_last_append_quads());
 }
 
 TEST_F(PictureLayerImplTest, HighResTileIsIncompleteLowResComplete) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
 
   scoped_refptr<FakeRasterSource> pending_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
   ActivateTree();
 
   std::vector<Tile*> low_tiles =
       active_layer_->tilings()->tiling_at(1)->AllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(low_tiles);
 
-  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   EXPECT_EQ(1u, render_pass->quad_list.size());
   EXPECT_EQ(0u, data.num_missing_tiles);
   EXPECT_EQ(1u, data.num_incomplete_tiles);
   EXPECT_TRUE(active_layer_->only_used_low_res_last_append_quads());
 }
@@ skipping 13 matching lines @@
   std::vector<Tile*> high_tiles =
       active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
   high_tiles.erase(high_tiles.begin());
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(high_tiles);
 
   // All low res tiles have resources.
   std::vector<Tile*> low_tiles =
       active_layer_->tilings()->tiling_at(1)->AllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(low_tiles);
 
-  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   // The missing high res tile was replaced by a low res tile.
   EXPECT_EQ(9u, render_pass->quad_list.size());
   EXPECT_EQ(0u, data.num_missing_tiles);
   EXPECT_EQ(1u, data.num_incomplete_tiles);
   EXPECT_FALSE(active_layer_->only_used_low_res_last_append_quads());
@@ skipping 32 matching lines @@
   // Both tilings still exist.
   ASSERT_GE(active_layer_->tilings()->num_tilings(), 2u);
   EXPECT_EQ(2.f, active_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_EQ(1.f, active_layer_->tilings()->tiling_at(1)->contents_scale());
 
   // All high res tiles have resources.
   std::vector<Tile*> high_tiles =
       active_layer_->HighResTiling()->AllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(high_tiles);
 
-  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   // All high res tiles drew, and the one ideal res tile drew.
   ASSERT_GT(render_pass->quad_list.size(), 9u);
   EXPECT_EQ(gfx::SizeF(99.f, 99.f),
             TileDrawQuad::MaterialCast(render_pass->quad_list.front())
                 ->tex_coord_rect.size());
@@ skipping 12 matching lines @@
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
   gfx::Rect recorded_viewport(0, 0, 150, 150);
 
   scoped_refptr<FakeRasterSource> pending_raster_source =
       FakeRasterSource::CreatePartiallyFilled(layer_bounds, recorded_viewport);
   SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
   ActivateTree();
 
-  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   EXPECT_EQ(1u, render_pass->quad_list.size());
   EXPECT_EQ(1u, data.num_missing_tiles);
   EXPECT_EQ(0u, data.num_incomplete_tiles);
   EXPECT_EQ(40000, data.checkerboarded_visible_content_area);
   EXPECT_EQ(17500, data.checkerboarded_no_recording_content_area);
@@ skipping 168 matching lines @@
 }
 
 TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {
   gfx::Size layer_bounds(400, 400);
   scoped_refptr<FakeRasterSource> pending_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
 
   host_impl_.CreatePendingTree();
   LayerTreeImpl* pending_tree = host_impl_.pending_tree();
 
-  scoped_ptr<FakePictureLayerImpl> pending_layer =
+  std::unique_ptr<FakePictureLayerImpl> pending_layer =
       FakePictureLayerImpl::CreateWithRasterSource(pending_tree, id_,
                                                    pending_raster_source);
   pending_layer->SetDrawsContent(true);
   pending_tree->SetRootLayer(std::move(pending_layer));
 
   pending_layer_ = static_cast<FakePictureLayerImpl*>(
       host_impl_.pending_tree()->LayerById(id_));
 
   // Set some state on the pending layer, make sure it is not clobbered
   // by a sync from the active layer.  This could happen because if the
@@ skipping 642 matching lines @@
 
   SetupPendingTree(pending_raster_source);
   EXPECT_EQ(1u, pending_layer_->num_tilings());
 
   std::set<Tile*> unique_tiles;
   bool reached_prepaint = false;
   int non_ideal_tile_count = 0u;
   int low_res_tile_count = 0u;
   int high_res_tile_count = 0u;
   int high_res_now_tiles = 0u;
-  scoped_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
+  std::unique_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), false));
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     TilePriority priority = prioritized_tile.priority();
 
     EXPECT_TRUE(prioritized_tile.tile());
 
     // Non-high res tiles only get visible tiles. Also, prepaint should only
     // come at the end of the iteration.
     if (priority.resolution != HIGH_RESOLUTION) {
@@ skipping 18 matching lines @@
   EXPECT_EQ(0, non_ideal_tile_count);
   EXPECT_EQ(0, low_res_tile_count);
 
   // With layer size being 1000x1000 and default tile size 256x256, we expect to
   // see 4 now tiles out of 16 total high res tiles.
   EXPECT_EQ(16, high_res_tile_count);
   EXPECT_EQ(4, high_res_now_tiles);
   EXPECT_EQ(low_res_tile_count + high_res_tile_count + non_ideal_tile_count,
             static_cast<int>(unique_tiles.size()));
 
-  scoped_ptr<TilingSetRasterQueueRequired> required_queue(
+  std::unique_ptr<TilingSetRasterQueueRequired> required_queue(
       new TilingSetRasterQueueRequired(
           pending_layer_->picture_layer_tiling_set(),
           RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW));
   EXPECT_TRUE(required_queue->IsEmpty());
 
   required_queue.reset(new TilingSetRasterQueueRequired(
       pending_layer_->picture_layer_tiling_set(),
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
   EXPECT_FALSE(required_queue->IsEmpty());
   int required_for_activation_count = 0;
@@ skipping 67 matching lines @@
 
   gfx::Size layer_bounds(1000, 1000);
 
   scoped_refptr<FakeRasterSource> pending_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
 
   SetupPendingTree(pending_raster_source);
   ActivateTree();
   EXPECT_EQ(2u, active_layer_->num_tilings());
 
-  scoped_ptr<TilingSetRasterQueueRequired> queue(
+  std::unique_ptr<TilingSetRasterQueueRequired> queue(
       new TilingSetRasterQueueRequired(
           active_layer_->picture_layer_tiling_set(),
           RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW));
   EXPECT_FALSE(queue->IsEmpty());
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     EXPECT_TRUE(prioritized_tile.tile()->required_for_draw());
     EXPECT_FALSE(prioritized_tile.tile()->draw_info().IsReadyToDraw());
     queue->Pop();
   }
 
   queue.reset(new TilingSetRasterQueueRequired(
       active_layer_->picture_layer_tiling_set(),
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
   EXPECT_TRUE(queue->IsEmpty());
 }
 
 TEST_F(PictureLayerImplTest, TilingSetRasterQueueRequiredNoHighRes) {
   scoped_refptr<FakeRasterSource> pending_raster_source =
       FakeRasterSource::CreateFilledSolidColor(gfx::Size(1024, 1024));
 
   SetupPendingTree(pending_raster_source);
   EXPECT_FALSE(
       pending_layer_->picture_layer_tiling_set()->FindTilingWithResolution(
           HIGH_RESOLUTION));
 
-  scoped_ptr<TilingSetRasterQueueRequired> queue(
+  std::unique_ptr<TilingSetRasterQueueRequired> queue(
       new TilingSetRasterQueueRequired(
           pending_layer_->picture_layer_tiling_set(),
           RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
   EXPECT_TRUE(queue->IsEmpty());
 }
 
 TEST_F(PictureLayerImplTest, TilingSetEvictionQueue) {
   gfx::Size layer_bounds(1000, 1000);
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
 
@@ skipping 34 matching lines @@
     }
   }
 
   // Sanity checks.
   EXPECT_EQ(16u, all_tiles.size());
   EXPECT_EQ(16u, all_tiles_set.size());
   EXPECT_GT(number_of_marked_tiles, 1u);
   EXPECT_GT(number_of_unmarked_tiles, 1u);
 
   // Tiles don't have resources yet.
-  scoped_ptr<TilingSetEvictionQueue> queue(
+  std::unique_ptr<TilingSetEvictionQueue> queue(
       new TilingSetEvictionQueue(pending_layer_->picture_layer_tiling_set()));
   EXPECT_TRUE(queue->IsEmpty());
 
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
 
   std::set<Tile*> unique_tiles;
   float expected_scales[] = {low_res_factor, 1.f};
   size_t scale_index = 0;
   bool reached_visible = false;
   PrioritizedTile last_tile;
@@ skipping 539 matching lines @@
                                     1.3f,  // ideal contents scale
                                     2.7f,  // device scale
                                     3.2f,  // page scale
                                     1.f,   // maximum animation scale
                                     0.f,   // starting animation scale
                                     false);
   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, SharedQuadStateContainsMaxTilingScale) {
-  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
 
   gfx::Size layer_bounds(1000, 2000);
   host_impl_.SetViewportSize(gfx::Size(10000, 20000));
   SetupDefaultTrees(layer_bounds);
 
   ResetTilingsAndRasterScales();
   SetupDrawPropertiesAndUpdateTiles(active_layer_, 2.5f, 1.f, 1.f, 1.f, 0.f,
                                     false);
 
   float max_contents_scale = active_layer_->MaximumTilingContentsScale();
@@ skipping 64 matching lines @@
   gfx::Size tile_size(host_impl_.settings().default_tile_size);
   size_t memory_limit = max_tiles * 4 * tile_size.width() * tile_size.height();
   size_t resource_limit = max_tiles;
   ManagedMemoryPolicy policy(memory_limit,
                              gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
                              resource_limit);
   host_impl_.SetMemoryPolicy(policy);
   host_impl_.SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
   host_impl_.PrepareTiles();
 
-  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_HARDWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   // Even when OOM, quads should be produced, and should be different material
   // from quads with resource.
   EXPECT_LT(max_tiles, render_pass->quad_list.size());
   EXPECT_EQ(DrawQuad::Material::TILED_CONTENT,
             render_pass->quad_list.front()->material);
@@ skipping 11 matching lines @@
   OcclusionTrackingPictureLayerImplTest()
       : PictureLayerImplTest(OcclusionTrackingSettings()) {}
 
   void VerifyEvictionConsidersOcclusion(FakePictureLayerImpl* layer,
                                         WhichTree tree,
                                         size_t expected_occluded_tile_count,
                                         int source_line) {
     size_t occluded_tile_count = 0u;
     PrioritizedTile last_tile;
 
-    scoped_ptr<TilingSetEvictionQueue> queue(
+    std::unique_ptr<TilingSetEvictionQueue> queue(
         new TilingSetEvictionQueue(layer->picture_layer_tiling_set()));
     while (!queue->IsEmpty()) {
       PrioritizedTile prioritized_tile = queue->Top();
       Tile* tile = prioritized_tile.tile();
       if (!last_tile.tile())
         last_tile = prioritized_tile;
 
       // The only way we will encounter an occluded tile after an unoccluded
       // tile is if the priorty bin decreased, the tile is required for
       // activation, or the scale changed.
@@ skipping 33 matching lines @@
   gfx::PointF occluding_layer_position(310.f, 0.f);
 
   host_impl_.SetViewportSize(viewport_size);
 
   scoped_refptr<FakeRasterSource> pending_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
 
   // No occlusion.
   int unoccluded_tile_count = 0;
-  scoped_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
+  std::unique_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), false));
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     Tile* tile = prioritized_tile.tile();
 
     // Occluded tiles should not be iterated over.
     EXPECT_FALSE(prioritized_tile.is_occluded());
 
     // Some tiles may not be visible (i.e. outside the viewport). The rest are
     // visible and at least partially unoccluded, verified by the above expect.
@@ skipping 525 matching lines @@
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
   gfx::Rect layer_rect(layer_bounds);
 
   FakeContentLayerClient client;
   client.set_bounds(layer_bounds);
   scoped_refptr<PictureLayer> layer = PictureLayer::Create(&client);
   FakeLayerTreeHostClient host_client(FakeLayerTreeHostClient::DIRECT_3D);
   TestTaskGraphRunner task_graph_runner;
-  scoped_ptr<FakeLayerTreeHost> host =
+  std::unique_ptr<FakeLayerTreeHost> host =
       FakeLayerTreeHost::Create(&host_client, &task_graph_runner);
   host->SetRootLayer(layer);
   RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
 
   int frame_number = 0;
 
   client.set_fill_with_nonsolid_color(!test_for_solid);
 
   Region invalidation(layer_rect);
   recording_source->UpdateAndExpandInvalidation(
@@ skipping 10 matching lines @@
     EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
   } else {
     ASSERT_TRUE(active_layer_->tilings());
     ASSERT_GT(active_layer_->tilings()->num_tilings(), 0u);
     std::vector<Tile*> tiles =
         active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
     EXPECT_FALSE(tiles.empty());
     host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
   }
 
-  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   DrawQuad::Material expected = test_for_solid
                                     ? DrawQuad::Material::SOLID_COLOR
                                     : DrawQuad::Material::TILED_CONTENT;
   EXPECT_EQ(expected, render_pass->quad_list.front()->material);
 }
@@ skipping 11 matching lines @@
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
   gfx::Rect layer_rect(layer_bounds);
 
   FakeContentLayerClient client;
   client.set_bounds(layer_bounds);
   scoped_refptr<PictureLayer> layer = PictureLayer::Create(&client);
   FakeLayerTreeHostClient host_client(FakeLayerTreeHostClient::DIRECT_3D);
   TestTaskGraphRunner task_graph_runner;
-  scoped_ptr<FakeLayerTreeHost> host =
+  std::unique_ptr<FakeLayerTreeHost> host =
       FakeLayerTreeHost::Create(&host_client, &task_graph_runner);
   host->SetRootLayer(layer);
   RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
 
   int frame_number = 0;
 
   client.set_fill_with_nonsolid_color(true);
 
   recording_source->SetNeedsDisplayRect(layer_rect);
   Region invalidation1;
@@ skipping 315 matching lines @@
 
 class TileSizeTest : public PictureLayerImplTest {
  public:
   TileSizeTest() : PictureLayerImplTest(TileSizeSettings()) {}
 };
 
 TEST_F(TileSizeTest, TileSizes) {
   host_impl_.CreatePendingTree();
 
   LayerTreeImpl* pending_tree = host_impl_.pending_tree();
-  scoped_ptr<FakePictureLayerImpl> layer =
+  std::unique_ptr<FakePictureLayerImpl> layer =
       FakePictureLayerImpl::Create(pending_tree, id_);
 
   host_impl_.SetViewportSize(gfx::Size(1000, 1000));
   gfx::Size result;
 
   host_impl_.SetContentIsSuitableForGpuRasterization(true);
   host_impl_.SetHasGpuRasterizationTrigger(false);
   EXPECT_EQ(host_impl_.gpu_rasterization_status(),
             GpuRasterizationStatus::OFF_VIEWPORT);
 
@@ skipping 122 matching lines @@
   // New low res tiling.
   EXPECT_TRUE(tilings->tiling_at(2)->may_contain_low_resolution_tiles());
 
   // This tiling will be high res now, it won't contain low res content since it
   // was all destroyed.
   EXPECT_FALSE(tilings->tiling_at(1)->may_contain_low_resolution_tiles());
 }
 
 }  // namespace
 }  // namespace cc