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

cc/layers/layer_unittest.cc

 // Copyright 2011 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/layer.h"
 
 #include <stddef.h>
 
 #include "base/thread_task_runner_handle.h"
 #include "cc/animation/animation_host.h"
@@ skipping 798 matching lines @@
     ASSERT_EQ(1u, layer_dest_b->children().size());
     layer_dest_c = layer_dest_b->children()[0];
     EXPECT_EQ(layer_src_c->id(), layer_dest_c->id());
     EXPECT_EQ(99, layer_dest_c->transform_tree_index_);
 
     layer_dest_root->SetLayerTreeHost(nullptr);
   }
 
   TestTaskGraphRunner task_graph_runner_;
   FakeLayerTreeHostClient fake_client_;
-  scoped_ptr<FakeLayerTreeHost> layer_tree_host_;
+  std::unique_ptr<FakeLayerTreeHost> layer_tree_host_;
 };
 
 namespace {
 
 class MockLayerTreeHost : public LayerTreeHost {
  public:
   MockLayerTreeHost(LayerTreeHostSingleThreadClient* single_thread_client,
                     LayerTreeHost::InitParams* params)
       : LayerTreeHost(params, CompositorMode::SINGLE_THREADED) {
     InitializeSingleThreaded(single_thread_client,
@@ skipping 92 matching lines @@
 
     VerifyTestTreeInitialState();
   }
 
   FakeImplTaskRunnerProvider task_runner_provider_;
   TestSharedBitmapManager shared_bitmap_manager_;
   TestTaskGraphRunner task_graph_runner_;
   FakeLayerTreeHostImpl host_impl_;
 
   FakeLayerTreeHostClient fake_client_;
-  scoped_ptr<StrictMock<MockLayerTreeHost>> layer_tree_host_;
+  std::unique_ptr<StrictMock<MockLayerTreeHost>> layer_tree_host_;
   scoped_refptr<Layer> parent_;
   scoped_refptr<Layer> child1_;
   scoped_refptr<Layer> child2_;
   scoped_refptr<Layer> child3_;
   scoped_refptr<Layer> grand_child1_;
   scoped_refptr<Layer> grand_child2_;
   scoped_refptr<Layer> grand_child3_;
 
   scoped_refptr<AnimationTimeline> timeline_impl_;
 
@@ skipping 23 matching lines @@
 
   layer_tree_host_->SetRootLayer(root);
   root->AddChild(child);
   root->AddChild(child2);
   child->AddChild(grand_child);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
   child->SetForceRenderSurface(true);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
   child2->SetScrollParent(grand_child.get());
   SkXfermode::Mode arbitrary_blend_mode = SkXfermode::kMultiply_Mode;
-  scoped_ptr<LayerImpl> root_impl =
+  std::unique_ptr<LayerImpl> root_impl =
       LayerImpl::Create(host_impl_.active_tree(), root->id());
-  scoped_ptr<LayerImpl> child_impl =
+  std::unique_ptr<LayerImpl> child_impl =
       LayerImpl::Create(host_impl_.active_tree(), child->id());
-  scoped_ptr<LayerImpl> child2_impl =
+  std::unique_ptr<LayerImpl> child2_impl =
       LayerImpl::Create(host_impl_.active_tree(), child2->id());
-  scoped_ptr<LayerImpl> grand_child_impl =
+  std::unique_ptr<LayerImpl> grand_child_impl =
       LayerImpl::Create(host_impl_.active_tree(), grand_child->id());
-  scoped_ptr<LayerImpl> dummy_layer1_impl =
+  std::unique_ptr<LayerImpl> dummy_layer1_impl =
       LayerImpl::Create(host_impl_.active_tree(), dummy_layer1->id());
-  scoped_ptr<LayerImpl> dummy_layer2_impl =
+  std::unique_ptr<LayerImpl> dummy_layer2_impl =
       LayerImpl::Create(host_impl_.active_tree(), dummy_layer2->id());
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(1);
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetMaskLayer(dummy_layer1.get()));
   EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
       root->PushPropertiesTo(root_impl.get());
       child->PushPropertiesTo(child_impl.get());
       child2->PushPropertiesTo(child2_impl.get());
       grand_child->PushPropertiesTo(grand_child_impl.get());
       dummy_layer1->PushPropertiesTo(dummy_layer1_impl.get()));
@@ skipping 676 matching lines @@
 
   // The above tests should not have caused a change to the needs_display flag.
   EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
 
   // As layers are removed from the tree, they will cause a tree sync.
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times((AnyNumber()));
 }
 
 TEST_F(LayerTest, PushPropertiesAccumulatesUpdateRect) {
   scoped_refptr<Layer> test_layer = Layer::Create();
-  scoped_ptr<LayerImpl> impl_layer =
+  std::unique_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
                                   layer_tree_host_->SetRootLayer(test_layer));
 
   host_impl_.active_tree()->SetRootLayer(std::move(impl_layer));
   LayerImpl* impl_layer_ptr = host_impl_.active_tree()->LayerById(1);
   test_layer->SetNeedsDisplayRect(gfx::Rect(5, 5));
   test_layer->PushPropertiesTo(impl_layer_ptr);
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 5.f, 5.f),
@@ skipping 11 matching lines @@
   host_impl_.active_tree()->ResetAllChangeTracking(
       PropertyTrees::ResetFlags::ALL_TREES);
   test_layer->SetNeedsDisplayRect(gfx::Rect(10, 10, 5, 5));
   test_layer->PushPropertiesTo(impl_layer_ptr);
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(10.f, 10.f, 5.f, 5.f),
                        impl_layer_ptr->update_rect());
 }
 
 TEST_F(LayerTest, PushPropertiesCausesLayerPropertyChangedForTransform) {
   scoped_refptr<Layer> test_layer = Layer::Create();
-  scoped_ptr<LayerImpl> impl_layer =
+  std::unique_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
                                   layer_tree_host_->SetRootLayer(test_layer));
 
   gfx::Transform transform;
   transform.Rotate(45.0);
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetTransform(transform));
 
   EXPECT_FALSE(impl_layer->LayerPropertyChanged());
 
   test_layer->PushPropertiesTo(impl_layer.get());
 
   EXPECT_TRUE(impl_layer->LayerPropertyChanged());
 }
 
 TEST_F(LayerTest, PushPropertiesCausesLayerPropertyChangedForOpacity) {
   scoped_refptr<Layer> test_layer = Layer::Create();
-  scoped_ptr<LayerImpl> impl_layer =
+  std::unique_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
                                   layer_tree_host_->SetRootLayer(test_layer));
 
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetOpacity(0.5f));
 
   EXPECT_FALSE(impl_layer->LayerPropertyChanged());
 
   test_layer->PushPropertiesTo(impl_layer.get());
@@ skipping 31 matching lines @@
 
   child->SetReplicaLayer(replica_replacement.get());
   EXPECT_EQ(nullptr, replica->parent());
   EXPECT_EQ(child.get(), replica_replacement->parent());
 
   EXPECT_EQ(replica.get(), replica->mask_layer()->parent());
 }
 
 TEST_F(LayerTest, CheckTransformIsInvertible) {
   scoped_refptr<Layer> layer = Layer::Create();
-  scoped_ptr<LayerImpl> impl_layer =
+  std::unique_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(1);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(layer);
 
   EXPECT_TRUE(layer->transform_is_invertible());
 
   gfx::Transform singular_transform;
   singular_transform.Scale3d(
       SkDoubleToMScalar(1.0), SkDoubleToMScalar(1.0), SkDoubleToMScalar(0.0));
@@ skipping 10 matching lines @@
   layer->SetTransform(rotation_transform);
   layer->PushPropertiesTo(impl_layer.get());
   EXPECT_TRUE(layer->transform_is_invertible());
   EXPECT_TRUE(impl_layer->transform_is_invertible());
 
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 }
 
 TEST_F(LayerTest, TransformIsInvertibleAnimation) {
   scoped_refptr<Layer> layer = Layer::Create();
-  scoped_ptr<LayerImpl> impl_layer =
+  std::unique_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(1);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(layer);
 
   EXPECT_TRUE(layer->transform_is_invertible());
 
   gfx::Transform singular_transform;
   singular_transform.Scale3d(
       SkDoubleToMScalar(1.0), SkDoubleToMScalar(1.0), SkDoubleToMScalar(0.0));
@@ skipping 13 matching lines @@
   EXPECT_FALSE(layer->transform_is_invertible());
   EXPECT_FALSE(impl_layer->transform_is_invertible());
 
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 }
 
 class LayerTreeHostFactory {
  public:
   LayerTreeHostFactory() : client_(FakeLayerTreeHostClient::DIRECT_3D) {}
 
-  scoped_ptr<LayerTreeHost> Create() { return Create(LayerTreeSettings()); }
+  std::unique_ptr<LayerTreeHost> Create() {
+    return Create(LayerTreeSettings());
+  }
 
-  scoped_ptr<LayerTreeHost> Create(LayerTreeSettings settings) {
+  std::unique_ptr<LayerTreeHost> Create(LayerTreeSettings settings) {
     LayerTreeHost::InitParams params;
     params.client = &client_;
     params.shared_bitmap_manager = &shared_bitmap_manager_;
     params.task_graph_runner = &task_graph_runner_;
     params.gpu_memory_buffer_manager = &gpu_memory_buffer_manager_;
     params.settings = &settings;
     params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
     return LayerTreeHost::CreateSingleThreaded(&client_, &params);
   }
 
@@ skipping 29 matching lines @@
   // Set up a detached tree of layers. The host pointer should be nil for these
   // layers.
   parent->AddChild(child);
   child->SetMaskLayer(mask.get());
   child->SetReplicaLayer(replica.get());
   replica->SetMaskLayer(replica_mask.get());
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(), nullptr);
 
   LayerTreeHostFactory factory;
-  scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
+  std::unique_ptr<LayerTreeHost> layer_tree_host = factory.Create();
   // Setting the root layer should set the host pointer for all layers in the
   // tree.
   layer_tree_host->SetRootLayer(parent.get());
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(), layer_tree_host.get());
 
   // Clearing the root layer should also clear out the host pointers for all
   // layers in the tree.
   layer_tree_host->SetRootLayer(nullptr);
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(), nullptr);
 }
 
 TEST_F(LayerLayerTreeHostTest, AddingLayerSubtree) {
   scoped_refptr<Layer> parent = Layer::Create();
   LayerTreeHostFactory factory;
-  scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
+  std::unique_ptr<LayerTreeHost> layer_tree_host = factory.Create();
 
   layer_tree_host->SetRootLayer(parent.get());
 
   EXPECT_EQ(parent->layer_tree_host(), layer_tree_host.get());
 
   // Adding a subtree to a layer already associated with a host should set the
   // host pointer on all layers in that subtree.
   scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<Layer> grand_child = Layer::Create();
   child->AddChild(grand_child);
@@ skipping 19 matching lines @@
   scoped_refptr<Layer> replica = Layer::Create();
   scoped_refptr<Layer> replica_mask = Layer::Create();
 
   // Same setup as the previous test.
   parent->AddChild(child);
   child->SetMaskLayer(mask.get());
   child->SetReplicaLayer(replica.get());
   replica->SetMaskLayer(replica_mask.get());
 
   LayerTreeHostFactory factory;
-  scoped_ptr<LayerTreeHost> first_layer_tree_host = factory.Create();
+  std::unique_ptr<LayerTreeHost> first_layer_tree_host = factory.Create();
   first_layer_tree_host->SetRootLayer(parent.get());
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(),
                                        first_layer_tree_host.get());
 
   // Now re-root the tree to a new host (simulating what we do on a context lost
   // event). This should update the host pointers for all layers in the tree.
-  scoped_ptr<LayerTreeHost> second_layer_tree_host = factory.Create();
+  std::unique_ptr<LayerTreeHost> second_layer_tree_host = factory.Create();
   second_layer_tree_host->SetRootLayer(parent.get());
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(),
                                        second_layer_tree_host.get());
 
   second_layer_tree_host->SetRootLayer(nullptr);
 }
 
 TEST_F(LayerLayerTreeHostTest, ChangeHostInSubtree) {
   scoped_refptr<Layer> first_parent = Layer::Create();
   scoped_refptr<Layer> first_child = Layer::Create();
   scoped_refptr<Layer> second_parent = Layer::Create();
   scoped_refptr<Layer> second_child = Layer::Create();
   scoped_refptr<Layer> second_grand_child = Layer::Create();
 
   // First put all children under the first parent and set the first host.
   first_parent->AddChild(first_child);
   second_child->AddChild(second_grand_child);
   first_parent->AddChild(second_child);
 
   LayerTreeHostFactory factory;
-  scoped_ptr<LayerTreeHost> first_layer_tree_host = factory.Create();
+  std::unique_ptr<LayerTreeHost> first_layer_tree_host = factory.Create();
   first_layer_tree_host->SetRootLayer(first_parent.get());
 
   AssertLayerTreeHostMatchesForSubtree(first_parent.get(),
                                        first_layer_tree_host.get());
 
   // Now reparent the subtree starting at second_child to a layer in a different
   // tree.
-  scoped_ptr<LayerTreeHost> second_layer_tree_host = factory.Create();
+  std::unique_ptr<LayerTreeHost> second_layer_tree_host = factory.Create();
   second_layer_tree_host->SetRootLayer(second_parent.get());
 
   second_parent->AddChild(second_child);
 
   // The moved layer and its children should point to the new host.
   EXPECT_EQ(second_layer_tree_host.get(), second_child->layer_tree_host());
   EXPECT_EQ(second_layer_tree_host.get(),
             second_grand_child->layer_tree_host());
 
   // Test over, cleanup time.
   first_layer_tree_host->SetRootLayer(nullptr);
   second_layer_tree_host->SetRootLayer(nullptr);
 }
 
 TEST_F(LayerLayerTreeHostTest, ReplaceMaskAndReplicaLayer) {
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> mask = Layer::Create();
   scoped_refptr<Layer> replica = Layer::Create();
   scoped_refptr<Layer> mask_child = Layer::Create();
   scoped_refptr<Layer> replica_child = Layer::Create();
   scoped_refptr<Layer> mask_replacement = Layer::Create();
   scoped_refptr<Layer> replica_replacement = Layer::Create();
 
   parent->SetMaskLayer(mask.get());
   parent->SetReplicaLayer(replica.get());
   mask->AddChild(mask_child);
   replica->AddChild(replica_child);
 
   LayerTreeHostFactory factory;
-  scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
+  std::unique_ptr<LayerTreeHost> layer_tree_host = factory.Create();
   layer_tree_host->SetRootLayer(parent.get());
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(), layer_tree_host.get());
 
   // Replacing the mask should clear out the old mask's subtree's host pointers.
   parent->SetMaskLayer(mask_replacement.get());
   EXPECT_EQ(nullptr, mask->layer_tree_host());
   EXPECT_EQ(nullptr, mask_child->layer_tree_host());
 
   // Same for replacing a replica layer.
   parent->SetReplicaLayer(replica_replacement.get());
   EXPECT_EQ(nullptr, replica->layer_tree_host());
   EXPECT_EQ(nullptr, replica_child->layer_tree_host());
 
   // Test over, cleanup time.
   layer_tree_host->SetRootLayer(nullptr);
 }
 
 TEST_F(LayerLayerTreeHostTest, DestroyHostWithNonNullRootLayer) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
   root->AddChild(child);
   LayerTreeHostFactory factory;
-  scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
+  std::unique_ptr<LayerTreeHost> layer_tree_host = factory.Create();
   layer_tree_host->SetRootLayer(root);
 }
 
 TEST_F(LayerTest, SafeOpaqueBackgroundColor) {
   LayerTreeHostFactory factory;
-  scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
+  std::unique_ptr<LayerTreeHost> layer_tree_host = factory.Create();
 
   scoped_refptr<Layer> layer = Layer::Create();
   layer_tree_host->SetRootLayer(layer);
 
   for (int contents_opaque = 0; contents_opaque < 2; ++contents_opaque) {
     for (int layer_opaque = 0; layer_opaque < 2; ++layer_opaque) {
       for (int host_opaque = 0; host_opaque < 2; ++host_opaque) {
         layer->SetContentsOpaque(!!contents_opaque);
         layer->SetBackgroundColor(layer_opaque ? SK_ColorRED
                                                : SK_ColorTRANSPARENT);
@@ skipping 56 matching lines @@
   EXPECT_EQ(0, root_layer->NumDescendantsThatDrawContent());
   root_layer->AddChild(becomes_not_draws_content);
   EXPECT_EQ(0, root_layer->NumDescendantsThatDrawContent());
 
   becomes_draws_content->SetIsDrawable(true);
   root_layer->AddChild(becomes_draws_content);
   EXPECT_EQ(1, root_layer->NumDescendantsThatDrawContent());
 }
 
 void ReceiveCopyOutputResult(int* result_count,
-                             scoped_ptr<CopyOutputResult> result) {
+                             std::unique_ptr<CopyOutputResult> result) {
   ++(*result_count);
 }
 
 TEST_F(LayerTest, DedupesCopyOutputRequestsBySource) {
   scoped_refptr<Layer> layer = Layer::Create();
   int result_count = 0;
 
   // Create identical requests without the source being set, and expect the
   // layer does not abort either one.
-  scoped_ptr<CopyOutputRequest> request = CopyOutputRequest::CreateRequest(
+  std::unique_ptr<CopyOutputRequest> request = CopyOutputRequest::CreateRequest(
       base::Bind(&ReceiveCopyOutputResult, &result_count));
   layer->RequestCopyOfOutput(std::move(request));
   EXPECT_EQ(0, result_count);
   request = CopyOutputRequest::CreateRequest(
       base::Bind(&ReceiveCopyOutputResult, &result_count));
   layer->RequestCopyOfOutput(std::move(request));
   EXPECT_EQ(0, result_count);
 
   // When the layer is destroyed, expect both requests to be aborted.
   layer = nullptr;
@@ skipping 332 matching lines @@
 TEST_F(LayerSerializationTest, AllMembersChanged) {
   RunAllMembersChangedTest();
 }
 
 TEST_F(LayerSerializationTest, ScrollAndClipLayers) {
   RunScrollAndClipLayersTest();
 }
 
 TEST_F(LayerTest, ElementIdAndMutablePropertiesArePushed) {
   scoped_refptr<Layer> test_layer = Layer::Create();
-  scoped_ptr<LayerImpl> impl_layer =
+  std::unique_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
                                   layer_tree_host_->SetRootLayer(test_layer));
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(2);
 
   test_layer->SetElementId(2);
   test_layer->SetMutableProperties(MutableProperty::kTransform);
 
   EXPECT_EQ(0lu, impl_layer->element_id());
   EXPECT_EQ(MutableProperty::kNone, impl_layer->mutable_properties());
 
   test_layer->PushPropertiesTo(impl_layer.get());
 
   EXPECT_EQ(2lu, impl_layer->element_id());
   EXPECT_EQ(MutableProperty::kTransform, impl_layer->mutable_properties());
 }
 
 }  // namespace
 }  // namespace cc