Make cc::animation::TrimTimeToCurrentIteration,cc::AnimationCurve::Duration use TimeTicks/TimeDelta

cc/test/animation_test_common.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 "cc/test/animation_test_common.h"
 
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/transform_operations.h"
@@ skipping 106 matching lines @@
 
   scoped_ptr<Animation> animation(Animation::Create(
       curve.Pass(), id, AnimationIdProvider::NextGroupId(), Animation::Filter));
   animation->set_needs_synchronized_start_time(true);
 
   target->AddAnimation(animation.Pass());
   return id;
 }
 
 FakeFloatAnimationCurve::FakeFloatAnimationCurve()
-    : duration_(1.0) {}
+    : duration_(base::TimeDelta::FromSecondsD(1.0)) {
+}
 
 FakeFloatAnimationCurve::FakeFloatAnimationCurve(double duration)
-    : duration_(duration) {}
+    : duration_(base::TimeDelta::FromSecondsD(duration)) {
+}
 
 FakeFloatAnimationCurve::~FakeFloatAnimationCurve() {}
 
-double FakeFloatAnimationCurve::Duration() const {
+base::TimeDelta FakeFloatAnimationCurve::Duration() const {
   return duration_;
 }
 
 float FakeFloatAnimationCurve::GetValue(double now) const {
   return 0.0f;
 }
 
 scoped_ptr<AnimationCurve> FakeFloatAnimationCurve::Clone() const {
   return make_scoped_ptr(new FakeFloatAnimationCurve);
 }
 
 FakeTransformTransition::FakeTransformTransition(double duration)
-    : duration_(duration) {}
+    : duration_(base::TimeDelta::FromSecondsD(duration)) {
+}
 
 FakeTransformTransition::~FakeTransformTransition() {}
 
-double FakeTransformTransition::Duration() const {
+base::TimeDelta FakeTransformTransition::Duration() const {
   return duration_;
 }
 
 gfx::Transform FakeTransformTransition::GetValue(double time) const {
   return gfx::Transform();
 }
 
 bool FakeTransformTransition::AnimatedBoundsForBox(const gfx::BoxF& box,
                                                    gfx::BoxF* bounds) const {
   return false;
 }
 
 bool FakeTransformTransition::AffectsScale() const { return false; }
 
 bool FakeTransformTransition::IsTranslation() const { return true; }
 
 bool FakeTransformTransition::MaximumTargetScale(bool forward_direction,
                                                  float* max_scale) const {
   *max_scale = 1.f;
   return true;
 }
 
 scoped_ptr<AnimationCurve> FakeTransformTransition::Clone() const {
   return make_scoped_ptr(new FakeTransformTransition(*this));
 }
 
-
 FakeFloatTransition::FakeFloatTransition(double duration, float from, float to)
-    : duration_(duration), from_(from), to_(to) {}
+    : duration_(base::TimeDelta::FromSecondsD(duration)), from_(from), to_(to) {
+}
 
 FakeFloatTransition::~FakeFloatTransition() {}
 
-double FakeFloatTransition::Duration() const {
+base::TimeDelta FakeFloatTransition::Duration() const {
   return duration_;
 }
 
 float FakeFloatTransition::GetValue(double time) const {
-  time /= duration_;
+  time /= duration_.InSecondsF();
   if (time >= 1.0)
     time = 1.0;
   return (1.0 - time) * from_ + time * to_;
 }
 
 FakeLayerAnimationValueObserver::FakeLayerAnimationValueObserver()
     : opacity_(0.0f),
       animation_waiting_for_deletion_(false) {}
 
 FakeLayerAnimationValueObserver::~FakeLayerAnimationValueObserver() {}
@@ skipping 137 matching lines @@
                              double duration,
                              float start_brightness,
                              float end_brightness) {
   return AddAnimatedFilter(layer->layer_animation_controller(),
                            duration,
                            start_brightness,
                            end_brightness);
 }
 
 }  // namespace cc