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

cc/tiles/tile_manager_perftest.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 53 matching lines @@
     completed_tasks_.clear();
   }
   ResourceFormat GetResourceFormat(bool must_support_alpha) const override {
     return RGBA_8888;
   }
   bool GetResourceRequiresSwizzle(bool must_support_alpha) const override {
     return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha));
   }
 
   // Overridden from TileTaskClient:
-  scoped_ptr<RasterBuffer> AcquireBufferForRaster(
+  std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
       const Resource* resource,
       uint64_t new_content_id,
       uint64_t previous_content_id) override {
     return nullptr;
   }
-  void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override {}
+  void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override {}
 
  private:
   TileTask::Vector completed_tasks_;
 };
 base::LazyInstance<FakeTileTaskRunnerImpl> g_fake_tile_task_runner =
     LAZY_INSTANCE_INITIALIZER;
 
 class TileManagerPerfTest : public testing::Test {
  public:
   TileManagerPerfTest()
@@ skipping 68 matching lines @@
     ActivateTree();
     SetupPendingTree(pending_raster_source);
   }
 
   void SetupPendingTree(scoped_refptr<RasterSource> raster_source) {
     host_impl_.CreatePendingTree();
     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
     // Clear recycled tree.
     pending_tree->ClearLayers();
 
-    scoped_ptr<FakePictureLayerImpl> pending_layer =
+    std::unique_ptr<FakePictureLayerImpl> pending_layer =
         FakePictureLayerImpl::CreateWithRasterSource(pending_tree, id_,
                                                      raster_source);
     pending_layer->SetDrawsContent(true);
     pending_layer->SetForceRenderSurface(true);
     pending_tree->SetRootLayer(std::move(pending_layer));
     pending_tree->BuildPropertyTreesForTesting();
 
     pending_root_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
   }
 
   void RunRasterQueueConstructTest(const std::string& test_name,
                                    int layer_count) {
     TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
                                  SMOOTHNESS_TAKES_PRIORITY,
                                  NEW_CONTENT_TAKES_PRIORITY};
     int priority_count = 0;
 
     std::vector<FakePictureLayerImpl*> layers = CreateLayers(layer_count, 10);
     for (const auto& layer : layers)
       layer->UpdateTiles();
 
     timer_.Reset();
     do {
-      scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
-          priorities[priority_count], RasterTilePriorityQueue::Type::ALL));
+      std::unique_ptr<RasterTilePriorityQueue> queue(
+          host_impl_.BuildRasterQueue(priorities[priority_count],
+                                      RasterTilePriorityQueue::Type::ALL));
       priority_count = (priority_count + 1) % arraysize(priorities);
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
     perf_test::PrintResult("tile_manager_raster_tile_queue_construct",
                            "",
                            test_name,
                            timer_.LapsPerSecond(),
                            "runs/s",
                            true);
   }
 
   void RunRasterQueueConstructAndIterateTest(const std::string& test_name,
                                              int layer_count,
                                              int tile_count) {
     TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
                                  SMOOTHNESS_TAKES_PRIORITY,
                                  NEW_CONTENT_TAKES_PRIORITY};
 
     std::vector<FakePictureLayerImpl*> layers = CreateLayers(layer_count, 100);
     for (const auto& layer : layers)
       layer->UpdateTiles();
 
     int priority_count = 0;
     timer_.Reset();
     do {
       int count = tile_count;
-      scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
-          priorities[priority_count], RasterTilePriorityQueue::Type::ALL));
+      std::unique_ptr<RasterTilePriorityQueue> queue(
+          host_impl_.BuildRasterQueue(priorities[priority_count],
+                                      RasterTilePriorityQueue::Type::ALL));
       while (count--) {
         ASSERT_FALSE(queue->IsEmpty());
         ASSERT_TRUE(queue->Top().tile());
         queue->Pop();
       }
       priority_count = (priority_count + 1) % arraysize(priorities);
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
     perf_test::PrintResult(
@@ skipping 16 matching lines @@
     for (const auto& layer : layers) {
       layer->UpdateTiles();
       for (size_t i = 0; i < layer->num_tilings(); ++i) {
         tile_manager()->InitializeTilesWithResourcesForTesting(
             layer->tilings()->tiling_at(i)->AllTilesForTesting());
       }
     }
 
     timer_.Reset();
     do {
-      scoped_ptr<EvictionTilePriorityQueue> queue(
+      std::unique_ptr<EvictionTilePriorityQueue> queue(
           host_impl_.BuildEvictionQueue(priorities[priority_count]));
       priority_count = (priority_count + 1) % arraysize(priorities);
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
     perf_test::PrintResult("tile_manager_eviction_tile_queue_construct",
                            "",
                            test_name,
                            timer_.LapsPerSecond(),
                            "runs/s",
@@ skipping 14 matching lines @@
       layer->UpdateTiles();
       for (size_t i = 0; i < layer->num_tilings(); ++i) {
         tile_manager()->InitializeTilesWithResourcesForTesting(
             layer->tilings()->tiling_at(i)->AllTilesForTesting());
       }
     }
 
     timer_.Reset();
     do {
       int count = tile_count;
-      scoped_ptr<EvictionTilePriorityQueue> queue(
+      std::unique_ptr<EvictionTilePriorityQueue> queue(
           host_impl_.BuildEvictionQueue(priorities[priority_count]));
       while (count--) {
         ASSERT_FALSE(queue->IsEmpty());
         ASSERT_TRUE(queue->Top().tile());
         queue->Pop();
       }
       priority_count = (priority_count + 1) % arraysize(priorities);
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
@@ skipping 36 matching lines @@
     std::vector<FakePictureLayerImpl*> layers;
 
     // Pending layer counts as one layer.
     layers.push_back(pending_root_layer_);
     int next_id = id_ + 1;
 
     // Create the rest of the layers as children of the root layer.
     scoped_refptr<FakeRasterSource> raster_source =
         FakeRasterSource::CreateFilled(layer_bounds);
     while (static_cast<int>(layers.size()) < layer_count) {
-      scoped_ptr<FakePictureLayerImpl> layer =
+      std::unique_ptr<FakePictureLayerImpl> layer =
           FakePictureLayerImpl::CreateWithRasterSource(
               host_impl_.pending_tree(), next_id, raster_source);
       layer->SetBounds(layer_bounds);
       layer->SetDrawsContent(true);
       layers.push_back(layer.get());
       pending_root_layer_->AddChild(std::move(layer));
       ++next_id;
     }
 
     // Property trees need to be rebuilt because layers were added above.
@@ skipping 46 matching lines @@
 
  protected:
   GlobalStateThatImpactsTilePriority global_state_;
 
   TestSharedBitmapManager shared_bitmap_manager_;
   TestTaskGraphRunner task_graph_runner_;
   TileMemoryLimitPolicy memory_limit_policy_;
   int max_tiles_;
   int id_;
   FakeImplTaskRunnerProvider task_runner_provider_;
-  scoped_ptr<OutputSurface> output_surface_;
+  std::unique_ptr<OutputSurface> output_surface_;
   FakeLayerTreeHostImpl host_impl_;
   FakePictureLayerImpl* pending_root_layer_;
   FakePictureLayerImpl* active_root_layer_;
   LapTimer timer_;
   LayerTreeSettings settings_;
 };
 
 TEST_F(TileManagerPerfTest, PrepareTiles) {
   RunPrepareTilesTest("2_100", 2, 100);
   RunPrepareTilesTest("2_500", 2, 500);
@@ skipping 43 matching lines @@
   RunEvictionQueueConstructAndIterateTest("10_64", 10, 64);
   RunEvictionQueueConstructAndIterateTest("10_128", 10, 128);
   RunEvictionQueueConstructAndIterateTest("50_16", 50, 16);
   RunEvictionQueueConstructAndIterateTest("50_32", 50, 32);
   RunEvictionQueueConstructAndIterateTest("50_64", 50, 64);
   RunEvictionQueueConstructAndIterateTest("50_128", 50, 128);
 }
 
 }  // namespace
 }  // namespace cc