CC: Stop TimingFunction inheriting from AnimationCurve.

cc/animation/keyframed_animation_curve.cc

 // Copyright 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 <algorithm>
 
 #include "cc/animation/keyframed_animation_curve.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/box_f.h"
 
@@ skipping 22 matching lines @@
 float GetProgress(double t, size_t i, const Keyframes& keyframes) {
   float progress =
       static_cast<float>((t - keyframes[i]->Time()) /
                          (keyframes[i + 1]->Time() - keyframes[i]->Time()));
 
   if (keyframes[i]->timing_function())
     progress = keyframes[i]->timing_function()->GetValue(progress);
   return progress;
 }
 
-scoped_ptr<TimingFunction> CloneTimingFunction(
-    const TimingFunction* timing_function) {
-  DCHECK(timing_function);
-  scoped_ptr<AnimationCurve> curve(timing_function->Clone());
-  return scoped_ptr<TimingFunction>(
-      static_cast<TimingFunction*>(curve.release()));
-}
-
 }  // namespace
 
 Keyframe::Keyframe(double time, scoped_ptr<TimingFunction> timing_function)
     : time_(time),
       timing_function_(timing_function.Pass()) {}
 
 Keyframe::~Keyframe() {}
 
 double Keyframe::Time() const {
   return time_;
@@ skipping 13 matching lines @@
     : Keyframe(time, timing_function.Pass()),
       value_(value) {}
 
 ColorKeyframe::~ColorKeyframe() {}
 
 SkColor ColorKeyframe::Value() const { return value_; }
 
 scoped_ptr<ColorKeyframe> ColorKeyframe::Clone() const {
   scoped_ptr<TimingFunction> func;
   if (timing_function())
-    func = CloneTimingFunction(timing_function());
+    func = timing_function()->Clone();
   return ColorKeyframe::Create(Time(), Value(), func.Pass());
 }
 
 scoped_ptr<FloatKeyframe> FloatKeyframe::Create(
     double time,
     float value,
     scoped_ptr<TimingFunction> timing_function) {
   return make_scoped_ptr(
       new FloatKeyframe(time, value, timing_function.Pass()));
 }
 
 FloatKeyframe::FloatKeyframe(double time,
                              float value,
                              scoped_ptr<TimingFunction> timing_function)
     : Keyframe(time, timing_function.Pass()),
       value_(value) {}
 
 FloatKeyframe::~FloatKeyframe() {}
 
 float FloatKeyframe::Value() const {
   return value_;
 }
 
 scoped_ptr<FloatKeyframe> FloatKeyframe::Clone() const {
   scoped_ptr<TimingFunction> func;
   if (timing_function())
-    func = CloneTimingFunction(timing_function());
+    func = timing_function()->Clone();
   return FloatKeyframe::Create(Time(), Value(), func.Pass());
 }
 
 scoped_ptr<TransformKeyframe> TransformKeyframe::Create(
     double time,
     const TransformOperations& value,
     scoped_ptr<TimingFunction> timing_function) {
   return make_scoped_ptr(
       new TransformKeyframe(time, value, timing_function.Pass()));
 }
 
 TransformKeyframe::TransformKeyframe(double time,
                                      const TransformOperations& value,
                                      scoped_ptr<TimingFunction> timing_function)
     : Keyframe(time, timing_function.Pass()),
       value_(value) {}
 
 TransformKeyframe::~TransformKeyframe() {}
 
 const TransformOperations& TransformKeyframe::Value() const {
   return value_;
 }
 
 scoped_ptr<TransformKeyframe> TransformKeyframe::Clone() const {
   scoped_ptr<TimingFunction> func;
   if (timing_function())
-    func = CloneTimingFunction(timing_function());
+    func = timing_function()->Clone();
   return TransformKeyframe::Create(Time(), Value(), func.Pass());
 }
 
 scoped_ptr<FilterKeyframe> FilterKeyframe::Create(
     double time,
     const FilterOperations& value,
     scoped_ptr<TimingFunction> timing_function) {
   return make_scoped_ptr(
       new FilterKeyframe(time, value, timing_function.Pass()));
 }
 
 FilterKeyframe::FilterKeyframe(double time,
                                const FilterOperations& value,
                                scoped_ptr<TimingFunction> timing_function)
     : Keyframe(time, timing_function.Pass()),
       value_(value) {}
 
 FilterKeyframe::~FilterKeyframe() {}
 
 const FilterOperations& FilterKeyframe::Value() const {
   return value_;
 }
 
 scoped_ptr<FilterKeyframe> FilterKeyframe::Clone() const {
   scoped_ptr<TimingFunction> func;
   if (timing_function())
-    func = CloneTimingFunction(timing_function());
+    func = timing_function()->Clone();
   return FilterKeyframe::Create(Time(), Value(), func.Pass());
 }
 
 scoped_ptr<KeyframedColorAnimationCurve> KeyframedColorAnimationCurve::
     Create() {
   return make_scoped_ptr(new KeyframedColorAnimationCurve);
 }
 
 KeyframedColorAnimationCurve::KeyframedColorAnimationCurve() {}
 
@@ skipping 236 matching lines @@
 bool KeyframedFilterAnimationCurve::HasFilterThatMovesPixels() const {
   for (size_t i = 0; i < keyframes_.size(); ++i) {
     if (keyframes_[i]->Value().HasFilterThatMovesPixels()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace cc