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

cc/trees/occlusion_tracker_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/trees/occlusion_tracker.h"
 
 #include <stddef.h>
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
@@ skipping 83 matching lines @@
 
   virtual void RunMyTest() = 0;
 
   void TearDown() override { DestroyLayers(); }
 
   TestContentLayerImpl* CreateRoot(const gfx::Transform& transform,
                                    const gfx::PointF& position,
                                    const gfx::Size& bounds) {
     LayerTreeImpl* tree = host_->host_impl()->active_tree();
     int id = next_layer_impl_id_++;
-    scoped_ptr<TestContentLayerImpl> layer(new TestContentLayerImpl(tree, id));
+    std::unique_ptr<TestContentLayerImpl> layer(
+        new TestContentLayerImpl(tree, id));
     TestContentLayerImpl* layer_ptr = layer.get();
     SetProperties(layer_ptr, transform, position, bounds);
 
     host_->host_impl()->active_tree()->SetRootLayer(std::move(layer));
 
     layer_ptr->SetForceRenderSurface(true);
     SetRootLayerOnMainThread(layer_ptr);
 
     return layer_ptr;
   }
 
   LayerImpl* CreateLayer(LayerImpl* parent,
                          const gfx::Transform& transform,
                          const gfx::PointF& position,
                          const gfx::Size& bounds) {
     LayerTreeImpl* tree = host_->host_impl()->active_tree();
     int id = next_layer_impl_id_++;
-    scoped_ptr<LayerImpl> layer = LayerImpl::Create(tree, id);
+    std::unique_ptr<LayerImpl> layer = LayerImpl::Create(tree, id);
     LayerImpl* layer_ptr = layer.get();
     SetProperties(layer_ptr, transform, position, bounds);
     parent->AddChild(std::move(layer));
     return layer_ptr;
   }
 
   LayerImpl* CreateSurface(LayerImpl* parent,
                            const gfx::Transform& transform,
                            const gfx::PointF& position,
                            const gfx::Size& bounds) {
     LayerImpl* layer = CreateLayer(parent, transform, position, bounds);
     layer->SetForceRenderSurface(true);
     return layer;
   }
 
   TestContentLayerImpl* CreateDrawingLayer(LayerImpl* parent,
                                            const gfx::Transform& transform,
                                            const gfx::PointF& position,
                                            const gfx::Size& bounds,
                                            bool opaque) {
     LayerTreeImpl* tree = host_->host_impl()->active_tree();
     int id = next_layer_impl_id_++;
-    scoped_ptr<TestContentLayerImpl> layer(new TestContentLayerImpl(tree, id));
+    std::unique_ptr<TestContentLayerImpl> layer(
+        new TestContentLayerImpl(tree, id));
     TestContentLayerImpl* layer_ptr = layer.get();
     SetProperties(layer_ptr, transform, position, bounds);
 
     if (opaque_layers_) {
       layer_ptr->SetContentsOpaque(opaque);
     } else {
       layer_ptr->SetContentsOpaque(false);
       if (opaque)
         layer_ptr->SetOpaqueContentsRect(gfx::Rect(bounds));
       else
         layer_ptr->SetOpaqueContentsRect(gfx::Rect());
     }
 
     parent->AddChild(std::move(layer));
     return layer_ptr;
   }
 
   LayerImpl* CreateReplicaLayer(LayerImpl* owning_layer,
                                 const gfx::Transform& transform,
                                 const gfx::PointF& position,
                                 const gfx::Size& bounds) {
     LayerTreeImpl* tree = host_->host_impl()->active_tree();
     int id = next_layer_impl_id_++;
-    scoped_ptr<TestContentLayerImpl> layer(new TestContentLayerImpl(tree, id));
+    std::unique_ptr<TestContentLayerImpl> layer(
+        new TestContentLayerImpl(tree, id));
     TestContentLayerImpl* layer_ptr = layer.get();
     SetProperties(layer_ptr, transform, position, bounds);
     SetReplica(owning_layer, std::move(layer));
     return layer_ptr;
   }
 
   LayerImpl* CreateMaskLayer(LayerImpl* owning_layer, const gfx::Size& bounds) {
     LayerTreeImpl* tree = host_->host_impl()->active_tree();
     int id = next_layer_impl_id_++;
-    scoped_ptr<TestContentLayerImpl> layer(new TestContentLayerImpl(tree, id));
+    std::unique_ptr<TestContentLayerImpl> layer(
+        new TestContentLayerImpl(tree, id));
     TestContentLayerImpl* layer_ptr = layer.get();
     SetProperties(layer_ptr, identity_matrix, gfx::PointF(), bounds);
     SetMask(owning_layer, std::move(layer));
     return layer_ptr;
   }
 
   TestContentLayerImpl* CreateDrawingSurface(LayerImpl* parent,
                                              const gfx::Transform& transform,
                                              const gfx::PointF& position,
                                              const gfx::Size& bounds,
                                              bool opaque) {
     TestContentLayerImpl* layer =
         CreateDrawingLayer(parent, transform, position, bounds, opaque);
     layer->SetForceRenderSurface(true);
     return layer;
   }
 
   void DestroyLayers() {
     host_->host_impl()->active_tree()->SetRootLayer(nullptr);
     render_surface_layer_list_impl_.clear();
     replica_layers_.clear();
     mask_layers_.clear();
     ResetLayerIterator();
   }
 
-  void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {}
+  void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {}
 
   void AddCopyRequest(Layer* layer) {
     layer->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
         base::Bind(&OcclusionTrackerTest::CopyOutputCallback,
                    base::Unretained(this))));
   }
 
   void AddCopyRequest(LayerImpl* layer) {
-    std::vector<scoped_ptr<CopyOutputRequest>> requests;
+    std::vector<std::unique_ptr<CopyOutputRequest>> requests;
     requests.push_back(CopyOutputRequest::CreateBitmapRequest(base::Bind(
         &OcclusionTrackerTest::CopyOutputCallback, base::Unretained(this))));
     layer->PassCopyRequests(&requests);
   }
 
   void CalcDrawEtc(TestContentLayerImpl* root) {
     DCHECK(root == root->layer_tree_impl()->root_layer());
 
     // These occlusion tests attach and detach layers in multiple
     // iterations, so rebuild property trees every time.
@@ skipping 65 matching lines @@
 
   void SetProperties(LayerImpl* layer,
                      const gfx::Transform& transform,
                      const gfx::PointF& position,
                      const gfx::Size& bounds) {
     layer->SetTransform(transform);
     layer->SetPosition(position);
     layer->SetBounds(bounds);
   }
 
-  void SetReplica(LayerImpl* owning_layer, scoped_ptr<LayerImpl> layer) {
+  void SetReplica(LayerImpl* owning_layer, std::unique_ptr<LayerImpl> layer) {
     // We need to set parent on replica layer for property tree building.
     layer->SetParent(owning_layer);
     owning_layer->SetReplicaLayer(std::move(layer));
   }
 
-  void SetMask(LayerImpl* owning_layer, scoped_ptr<LayerImpl> layer) {
+  void SetMask(LayerImpl* owning_layer, std::unique_ptr<LayerImpl> layer) {
     owning_layer->SetMaskLayer(std::move(layer));
   }
 
   bool opaque_layers_;
   FakeLayerTreeHostClient client_;
   TestTaskGraphRunner task_graph_runner_;
-  scoped_ptr<FakeLayerTreeHost> host_;
+  std::unique_ptr<FakeLayerTreeHost> host_;
   // These hold ownership of the layers for the duration of the test.
   LayerImplList render_surface_layer_list_impl_;
   LayerIterator layer_iterator_begin_;
   LayerIterator layer_iterator_;
   LayerList replica_layers_;
   LayerList mask_layers_;
   int next_layer_impl_id_;
 };
 
 #define RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName)          \
@@ skipping 2189 matching lines @@
     EXPECT_EQ(gfx::Rect(),
               occlusion.UnoccludedSurfaceContentRect(
                   surface, gfx::Rect(80, 70, 50, 50)));
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestUnoccludedSurfaceQuery)
 
 }  // namespace
 }  // namespace cc