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

cc/animation/scroll_offset_animation_curve.cc

 // Copyright 2013 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/animation/scroll_offset_animation_curve.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/time_util.h"
 #include "ui/gfx/animation/tween.h"
 
 using DurationBehavior = cc::ScrollOffsetAnimationCurve::DurationBehavior;
 
 const double kConstantDuration = 9.0;
 const double kDurationDivisor = 60.0;
 
 const double kInverseDeltaRampStartPx = 120.0;
@@ skipping 35 matching lines @@
                    kInverseDeltaMinDuration),
           kInverseDeltaMaxDuration);
       break;
     default:
       NOTREACHED();
   }
   return base::TimeDelta::FromMicroseconds(duration / kDurationDivisor *
                                            base::Time::kMicrosecondsPerSecond);
 }
 
-static scoped_ptr<TimingFunction> EaseOutWithInitialVelocity(double velocity) {
+static std::unique_ptr<TimingFunction> EaseOutWithInitialVelocity(
+    double velocity) {
   // Clamp velocity to a sane value.
   velocity = std::min(std::max(velocity, -1000.0), 1000.0);
 
   // Based on EaseInOutTimingFunction::Create with first control point scaled.
   const double x1 = 0.42;
   const double y1 = velocity * x1;
   return CubicBezierTimingFunction::Create(x1, y1, 0.58, 1);
 }
 
 }  // namespace
 
-scoped_ptr<ScrollOffsetAnimationCurve> ScrollOffsetAnimationCurve::Create(
+std::unique_ptr<ScrollOffsetAnimationCurve> ScrollOffsetAnimationCurve::Create(
     const gfx::ScrollOffset& target_value,
-    scoped_ptr<TimingFunction> timing_function,
+    std::unique_ptr<TimingFunction> timing_function,
     DurationBehavior duration_behavior) {
-  return make_scoped_ptr(new ScrollOffsetAnimationCurve(
+  return base::WrapUnique(new ScrollOffsetAnimationCurve(
       target_value, std::move(timing_function), duration_behavior));
 }
 
 ScrollOffsetAnimationCurve::ScrollOffsetAnimationCurve(
     const gfx::ScrollOffset& target_value,
-    scoped_ptr<TimingFunction> timing_function,
+    std::unique_ptr<TimingFunction> timing_function,
     DurationBehavior duration_behavior)
     : target_value_(target_value),
       timing_function_(std::move(timing_function)),
       duration_behavior_(duration_behavior),
       has_set_initial_value_(false) {}
 
 ScrollOffsetAnimationCurve::~ScrollOffsetAnimationCurve() {}
 
 void ScrollOffsetAnimationCurve::SetInitialValue(
     const gfx::ScrollOffset& initial_value) {
@@ skipping 27 matching lines @@
 }
 
 base::TimeDelta ScrollOffsetAnimationCurve::Duration() const {
   return total_animation_duration_;
 }
 
 AnimationCurve::CurveType ScrollOffsetAnimationCurve::Type() const {
   return SCROLL_OFFSET;
 }
 
-scoped_ptr<AnimationCurve> ScrollOffsetAnimationCurve::Clone() const {
+std::unique_ptr<AnimationCurve> ScrollOffsetAnimationCurve::Clone() const {
   return CloneToScrollOffsetAnimationCurve();
 }
 
-scoped_ptr<ScrollOffsetAnimationCurve>
+std::unique_ptr<ScrollOffsetAnimationCurve>
 ScrollOffsetAnimationCurve::CloneToScrollOffsetAnimationCurve() const {
-  scoped_ptr<TimingFunction> timing_function(
+  std::unique_ptr<TimingFunction> timing_function(
       static_cast<TimingFunction*>(timing_function_->Clone().release()));
-  scoped_ptr<ScrollOffsetAnimationCurve> curve_clone =
+  std::unique_ptr<ScrollOffsetAnimationCurve> curve_clone =
       Create(target_value_, std::move(timing_function), duration_behavior_);
   curve_clone->initial_value_ = initial_value_;
   curve_clone->total_animation_duration_ = total_animation_duration_;
   curve_clone->last_retarget_ = last_retarget_;
   curve_clone->has_set_initial_value_ = has_set_initial_value_;
   return curve_clone;
 }
 
 static double VelocityBasedDurationBound(gfx::Vector2dF old_delta,
                                          double old_normalized_velocity,
@@ skipping 58 matching lines @@
       (MaximumDimension(old_delta) / MaximumDimension(new_delta));
 
   initial_value_ = current_position;
   target_value_ = new_target;
   total_animation_duration_ = base::TimeDelta::FromSecondsD(t + new_duration);
   last_retarget_ = base::TimeDelta::FromSecondsD(t);
   timing_function_ = EaseOutWithInitialVelocity(new_normalized_velocity);
 }
 
 }  // namespace cc