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

cc/test/animation_timelines_test_common.h

 // Copyright 2015 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.
 
 #ifndef CC_TEST_ANIMATION_TIMELINES_TEST_COMMON_H_
 #define CC_TEST_ANIMATION_TIMELINES_TEST_COMMON_H_
 
+#include <memory>
 #include <unordered_map>
 
-#include "base/memory/scoped_ptr.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_delegate.h"
 #include "cc/animation/animation_host.h"
 #include "cc/trees/mutator_host_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 
 namespace cc {
 
 class TestLayer {
  public:
-  static scoped_ptr<TestLayer> Create();
+  static std::unique_ptr<TestLayer> Create();
 
   void ClearMutatedProperties();
 
   int transform_x() const { return transform_x_; }
   int transform_y() const { return transform_y_; }
 
   void set_transform(int transform_x, int transform_y) {
     transform_x_ = transform_x;
     transform_y_ = transform_y;
     mutated_properties_[TargetProperty::TRANSFORM] = true;
@@ skipping 93 matching lines @@
                                     LayerTreeType tree_type,
                                     float opacity) const;
   void ExpectTransformPropertyMutated(int layer_id,
                                       LayerTreeType tree_type,
                                       int transform_x,
                                       int transform_y) const;
 
   TestLayer* FindTestLayer(int layer_id, LayerTreeType tree_type) const;
 
  private:
-  scoped_ptr<AnimationHost> host_;
+  std::unique_ptr<AnimationHost> host_;
 
-  using LayerIdToTestLayer = std::unordered_map<int, scoped_ptr<TestLayer>>;
+  using LayerIdToTestLayer =
+      std::unordered_map<int, std::unique_ptr<TestLayer>>;
   LayerIdToTestLayer layers_in_active_tree_;
   LayerIdToTestLayer layers_in_pending_tree_;
 
   bool mutators_need_commit_;
 };
 
 class TestAnimationDelegate : public AnimationDelegate {
  public:
   TestAnimationDelegate();
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                               TargetProperty::Type target_property,
                               int group) override;
   void NotifyAnimationFinished(base::TimeTicks monotonic_time,
                                TargetProperty::Type target_property,
                                int group) override;
   void NotifyAnimationAborted(base::TimeTicks monotonic_time,
                               TargetProperty::Type target_property,
                               int group) override {}
   void NotifyAnimationTakeover(base::TimeTicks monotonic_time,
                                TargetProperty::Type target_property,
                                double animation_start_time,
-                               scoped_ptr<AnimationCurve> curve) override {}
+                               std::unique_ptr<AnimationCurve> curve) override {
+  }
   bool started_;
   bool finished_;
 };
 
 class AnimationTimelinesTest : public testing::Test {
  public:
   AnimationTimelinesTest();
   ~AnimationTimelinesTest() override;
 
  protected:
@@ skipping 27 matching lines @@
   scoped_refptr<AnimationTimeline> timeline_;
   scoped_refptr<AnimationPlayer> player_;
 
   scoped_refptr<AnimationTimeline> timeline_impl_;
   scoped_refptr<AnimationPlayer> player_impl_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TEST_ANIMATION_TIMELINES_TEST_COMMON_H_