Replace scoped_ptr with std::unique_ptr in //ui

ui/compositor/layer_animation_element.cc

 // Copyright (c) 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 "ui/compositor/layer_animation_element.h"
 
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
@@ skipping 91 matching lines @@
     return true;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->transform = interpolated_transform_->Interpolate(1.0f);
   }
 
   void OnAbort(LayerAnimationDelegate* delegate) override {}
 
  private:
-  scoped_ptr<InterpolatedTransform> interpolated_transform_;
+  std::unique_ptr<InterpolatedTransform> interpolated_transform_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedTransformTransition);
 };
 
 // BoundsTransition ------------------------------------------------------------
 
 class BoundsTransition : public LayerAnimationElement {
  public:
   BoundsTransition(const gfx::Rect& target, base::TimeDelta duration)
       : LayerAnimationElement(BOUNDS, duration),
@@ skipping 240 matching lines @@
     }
   }
 
   void RequestEffectiveStart(LayerAnimationDelegate* delegate) override {
     DCHECK(animation_group_id());
     if (!IsThreaded()) {
       set_effective_start_time(requested_start_time());
       return;
     }
     set_effective_start_time(base::TimeTicks());
-    scoped_ptr<cc::Animation> animation = CreateCCAnimation();
+    std::unique_ptr<cc::Animation> animation = CreateCCAnimation();
     animation->set_needs_synchronized_start_time(true);
 
     LayerThreadedAnimationDelegate* threaded =
         delegate->GetThreadedAnimationDelegate();
     DCHECK(threaded);
     threaded->AddThreadedAnimation(std::move(animation));
   }
 
   virtual void OnEnd(LayerAnimationDelegate* delegate) = 0;
 
-  virtual scoped_ptr<cc::Animation> CreateCCAnimation() = 0;
+  virtual std::unique_ptr<cc::Animation> CreateCCAnimation() = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ThreadedLayerAnimationElement);
 };
 
 // ThreadedOpacityTransition ---------------------------------------------------
 
 class ThreadedOpacityTransition : public ThreadedLayerAnimationElement {
  public:
   ThreadedOpacityTransition(float target, base::TimeDelta duration)
@@ skipping 15 matching lines @@
           gfx::Tween::CalculateValue(tween_type(), last_progressed_fraction()),
               start_,
               target_));
     }
   }
 
   void OnEnd(LayerAnimationDelegate* delegate) override {
     delegate->SetOpacityFromAnimation(target_);
   }
 
-  scoped_ptr<cc::Animation> CreateCCAnimation() override {
-    scoped_ptr<cc::AnimationCurve> animation_curve(
-        new FloatAnimationCurveAdapter(tween_type(),
-                                       start_,
-                                       target_,
+  std::unique_ptr<cc::Animation> CreateCCAnimation() override {
+    std::unique_ptr<cc::AnimationCurve> animation_curve(
+        new FloatAnimationCurveAdapter(tween_type(), start_, target_,
                                        duration()));
-    scoped_ptr<cc::Animation> animation(cc::Animation::Create(
+    std::unique_ptr<cc::Animation> animation(cc::Animation::Create(
         std::move(animation_curve), animation_id(), animation_group_id(),
         cc::TargetProperty::OPACITY));
     return animation;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->opacity = target_;
   }
 
  private:
@@ skipping 26 matching lines @@
           gfx::Tween::CalculateValue(tween_type(), last_progressed_fraction()),
           start_,
           target_));
     }
   }
 
   void OnEnd(LayerAnimationDelegate* delegate) override {
     delegate->SetTransformFromAnimation(target_);
   }
 
-  scoped_ptr<cc::Animation> CreateCCAnimation() override {
-    scoped_ptr<cc::AnimationCurve> animation_curve(
-        new TransformAnimationCurveAdapter(tween_type(),
-                                           start_,
-                                           target_,
+  std::unique_ptr<cc::Animation> CreateCCAnimation() override {
+    std::unique_ptr<cc::AnimationCurve> animation_curve(
+        new TransformAnimationCurveAdapter(tween_type(), start_, target_,
                                            duration()));
-    scoped_ptr<cc::Animation> animation(cc::Animation::Create(
+    std::unique_ptr<cc::Animation> animation(cc::Animation::Create(
         std::move(animation_curve), animation_id(), animation_group_id(),
         cc::TargetProperty::TRANSFORM));
     return animation;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->transform = target_;
   }
 
  private:
@@ skipping 50 matching lines @@
     if (delegate && Started()) {
       ThreadedLayerAnimationElement::OnAbort(delegate);
       delegate->SetTransformFromAnimation(ComputeCurrentTransform());
     }
   }
 
   void OnEnd(LayerAnimationDelegate* delegate) override {
     delegate->SetTransformFromAnimation(computed_target_transform_);
   }
 
-  scoped_ptr<cc::Animation> CreateCCAnimation() override {
-    scoped_ptr<cc::Animation> animation(cc::Animation::Create(
+  std::unique_ptr<cc::Animation> CreateCCAnimation() override {
+    std::unique_ptr<cc::Animation> animation(cc::Animation::Create(
         animation_curve_->Clone(), animation_id(), animation_group_id(),
         cc::TargetProperty::TRANSFORM));
     return animation;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->transform = computed_target_transform_;
   }
 
  private:
@@ skipping 21 matching lines @@
     DCHECK(properties & TRANSFORM);
     return static_cast<T>(element);
   }
 
   gfx::Transform effective_start_;
   gfx::Transform computed_target_transform_;
 
   const gfx::Transform base_transform_;
   gfx::Transform base_target_;
 
-  scoped_ptr<cc::AnimationCurve> animation_curve_;
+  std::unique_ptr<cc::AnimationCurve> animation_curve_;
 
   const ThreadedTransformTransition* const uninverted_transition_;
 
   DISALLOW_COPY_AND_ASSIGN(InverseTransformTransition);
 };
 
 }  // namespace
 
 // LayerAnimationElement::TargetValue ------------------------------------------
 
@@ skipping 241 matching lines @@
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateColorElement(
     SkColor color,
     base::TimeDelta duration) {
   return new ColorTransition(color, duration);
 }
 
 }  // namespace ui