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

cc/trees/tree_synchronizer_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/trees/tree_synchronizer.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/format_macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host.h"
 #include "cc/test/fake_rendering_stats_instrumentation.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/task_runner_provider.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 class MockLayerImpl : public LayerImpl {
  public:
-  static scoped_ptr<MockLayerImpl> Create(LayerTreeImpl* tree_impl,
-                                          int layer_id) {
-    return make_scoped_ptr(new MockLayerImpl(tree_impl, layer_id));
+  static std::unique_ptr<MockLayerImpl> Create(LayerTreeImpl* tree_impl,
+                                               int layer_id) {
+    return base::WrapUnique(new MockLayerImpl(tree_impl, layer_id));
   }
   ~MockLayerImpl() override {
     if (layer_impl_destruction_list_)
       layer_impl_destruction_list_->push_back(id());
   }
 
   void SetLayerImplDestructionList(std::vector<int>* list) {
     layer_impl_destruction_list_ = list;
   }
 
  private:
   MockLayerImpl(LayerTreeImpl* tree_impl, int layer_id)
       : LayerImpl(tree_impl, layer_id), layer_impl_destruction_list_(NULL) {}
 
   std::vector<int>* layer_impl_destruction_list_;
 };
 
 class MockLayer : public Layer {
  public:
   static scoped_refptr<MockLayer> Create(
       std::vector<int>* layer_impl_destruction_list) {
     return make_scoped_refptr(new MockLayer(layer_impl_destruction_list));
   }
 
-  scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl) override {
+  std::unique_ptr<LayerImpl> CreateLayerImpl(
+      LayerTreeImpl* tree_impl) override {
     return MockLayerImpl::Create(tree_impl, layer_id_);
   }
 
   void PushPropertiesTo(LayerImpl* layer_impl) override {
     Layer::PushPropertiesTo(layer_impl);
 
     MockLayerImpl* mock_layer_impl = static_cast<MockLayerImpl*>(layer_impl);
     mock_layer_impl->SetLayerImplDestructionList(layer_impl_destruction_list_);
   }
 
@@ skipping 93 matching lines @@
 
 class TreeSynchronizerTest : public testing::Test {
  public:
   TreeSynchronizerTest()
       : client_(FakeLayerTreeHostClient::DIRECT_3D),
         host_(FakeLayerTreeHost::Create(&client_, &task_graph_runner_)) {}
 
  protected:
   FakeLayerTreeHostClient client_;
   TestTaskGraphRunner task_graph_runner_;
-  scoped_ptr<FakeLayerTreeHost> host_;
+  std::unique_ptr<FakeLayerTreeHost> host_;
 
   bool is_equal(ScrollTree::ScrollOffsetMap map,
                 ScrollTree::ScrollOffsetMap other) {
     if (map.size() != other.size())
       return false;
     for (auto& map_entry : map) {
       if (other.find(map_entry.first) == other.end())
         return false;
       SyncedScrollOffset& from_map = *map_entry.second.get();
       SyncedScrollOffset& from_other = *other[map_entry.first].get();
@@ skipping 343 matching lines @@
   host_->active_tree()->ClearLayers();
 }
 
 TEST_F(TreeSynchronizerTest, SynchronizeScrollParent) {
   LayerTreeSettings settings;
   FakeImplTaskRunnerProvider task_runner_provider;
   FakeRenderingStatsInstrumentation stats_instrumentation;
   FakeLayerTreeHostImplClient impl_client;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
-  scoped_ptr<LayerTreeHostImpl> host_impl = LayerTreeHostImpl::Create(
+  std::unique_ptr<LayerTreeHostImpl> host_impl = LayerTreeHostImpl::Create(
       settings, &impl_client, &task_runner_provider, &stats_instrumentation,
       &shared_bitmap_manager, nullptr, &task_graph_runner, 0);
 
   scoped_refptr<Layer> layer_tree_root = Layer::Create();
   scoped_refptr<Layer> scroll_parent = Layer::Create();
   layer_tree_root->AddChild(scroll_parent);
   layer_tree_root->AddChild(Layer::Create());
   layer_tree_root->AddChild(Layer::Create());
 
   host_->SetRootLayer(layer_tree_root);
@@ skipping 40 matching lines @@
   }
 }
 
 TEST_F(TreeSynchronizerTest, SynchronizeClipParent) {
   LayerTreeSettings settings;
   FakeImplTaskRunnerProvider task_runner_provider;
   FakeRenderingStatsInstrumentation stats_instrumentation;
   FakeLayerTreeHostImplClient impl_client;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
-  scoped_ptr<LayerTreeHostImpl> host_impl = LayerTreeHostImpl::Create(
+  std::unique_ptr<LayerTreeHostImpl> host_impl = LayerTreeHostImpl::Create(
       settings, &impl_client, &task_runner_provider, &stats_instrumentation,
       &shared_bitmap_manager, nullptr, &task_graph_runner, 0);
 
   scoped_refptr<Layer> layer_tree_root = Layer::Create();
   scoped_refptr<Layer> clip_parent = Layer::Create();
   scoped_refptr<Layer> intervening = Layer::Create();
   scoped_refptr<Layer> clip_child1 = Layer::Create();
   scoped_refptr<Layer> clip_child2 = Layer::Create();
   layer_tree_root->AddChild(clip_parent);
   clip_parent->AddChild(intervening);
@@ skipping 155 matching lines @@
 
   // Set ScrollOffset active delta: gfx::ScrollOffset(10, 10)
   LayerImpl* scroll_layer_impl =
       host_impl->active_tree()->LayerById(scroll_layer->id());
   ScrollTree& scroll_tree =
       host_impl->active_tree()->property_trees()->scroll_tree;
   scroll_tree.SetScrollOffset(scroll_layer_impl->id(),
                               gfx::ScrollOffset(20, 30));
 
   // Pull ScrollOffset delta for main thread, and change offset on main thread
-  scoped_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet());
+  std::unique_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet());
   scroll_tree.CollectScrollDeltas(scroll_info.get());
   host_->proxy()->SetNeedsCommit();
   host_->ApplyScrollAndScale(scroll_info.get());
   EXPECT_EQ(gfx::ScrollOffset(20, 30), scroll_layer->scroll_offset());
   scroll_layer->SetScrollOffset(gfx::ScrollOffset(100, 100));
 
   // More update to ScrollOffset active delta: gfx::ScrollOffset(20, 20)
   scroll_tree.SetScrollOffset(scroll_layer_impl->id(),
                               gfx::ScrollOffset(40, 50));
   host_impl->active_tree()->SetCurrentlyScrollingLayer(scroll_layer_impl);
@@ skipping 13 matching lines @@
   scroll_offset_map[scroll_layer->id()]->PullDeltaForMainThread();
   scroll_offset_map[scroll_layer->id()]->SetCurrent(gfx::ScrollOffset(40, 50));
   scroll_offset_map[scroll_layer->id()]->PushFromMainThread(
       gfx::ScrollOffset(100, 100));
   scroll_offset_map[scroll_layer->id()]->PushPendingToActive();
   EXPECT_TRUE(is_equal(scroll_offset_map, scroll_tree.scroll_offset_map()));
 }
 
 }  // namespace
 }  // namespace cc