Make Keyframe use TimeTicks/TimeDelta to represent time instead of double.

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"
+#include "cc/base/time_util.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 
 using cc::Animation;
 using cc::AnimationCurve;
 using cc::EaseTimingFunction;
 using cc::FloatKeyframe;
 using cc::KeyframedFloatAnimationCurve;
 using cc::KeyframedTransformAnimationCurve;
 using cc::TimingFunction;
 using cc::TransformKeyframe;
 
 namespace cc {
 
 template <class Target>
 int AddOpacityTransition(Target* target,
                          double duration,
                          float start_opacity,
                          float end_opacity,
                          bool use_timing_function) {
   scoped_ptr<KeyframedFloatAnimationCurve>
       curve(KeyframedFloatAnimationCurve::Create());
 
   scoped_ptr<TimingFunction> func;
   if (!use_timing_function)
     func = EaseTimingFunction::Create();
   if (duration > 0.0)
-    curve->AddKeyframe(FloatKeyframe::Create(0.0, start_opacity, func.Pass()));
-  curve->AddKeyframe(FloatKeyframe::Create(duration, end_opacity, nullptr));
+    curve->AddKeyframe(
+        FloatKeyframe::Create(base::TimeDelta(), start_opacity, func.Pass()));
+  curve->AddKeyframe(FloatKeyframe::Create(
+      base::TimeDelta::FromSecondsD(duration), end_opacity, nullptr));
 
   int id = AnimationIdProvider::NextAnimationId();
 
   scoped_ptr<Animation> animation(
       Animation::Create(curve.Pass(),
                         id,
                         AnimationIdProvider::NextGroupId(),
                         Animation::Opacity));
   animation->set_needs_synchronized_start_time(true);
 
   target->AddAnimation(animation.Pass());
   return id;
 }
 
 template <class Target>
 int AddAnimatedTransform(Target* target,
                          double duration,
                          TransformOperations start_operations,
                          TransformOperations operations) {
   scoped_ptr<KeyframedTransformAnimationCurve>
       curve(KeyframedTransformAnimationCurve::Create());
 
   if (duration > 0.0) {
-    curve->AddKeyframe(
-        TransformKeyframe::Create(0.0, start_operations, nullptr));
+    curve->AddKeyframe(TransformKeyframe::Create(base::TimeDelta(),
+                                                 start_operations, nullptr));
   }
 
-  curve->AddKeyframe(TransformKeyframe::Create(duration, operations, nullptr));
+  curve->AddKeyframe(TransformKeyframe::Create(
+      base::TimeDelta::FromSecondsD(duration), operations, nullptr));
 
   int id = AnimationIdProvider::NextAnimationId();
 
   scoped_ptr<Animation> animation(
       Animation::Create(curve.Pass(),
                         id,
                         AnimationIdProvider::NextGroupId(),
                         Animation::Transform));
   animation->set_needs_synchronized_start_time(true);
 
@@ skipping 21 matching lines @@
                       double duration,
                       float start_brightness,
                       float end_brightness) {
   scoped_ptr<KeyframedFilterAnimationCurve>
       curve(KeyframedFilterAnimationCurve::Create());
 
   if (duration > 0.0) {
     FilterOperations start_filters;
     start_filters.Append(
         FilterOperation::CreateBrightnessFilter(start_brightness));
-    curve->AddKeyframe(FilterKeyframe::Create(0.0, start_filters, nullptr));
+    curve->AddKeyframe(
+        FilterKeyframe::Create(base::TimeDelta(), start_filters, nullptr));
   }
 
   FilterOperations filters;
   filters.Append(FilterOperation::CreateBrightnessFilter(end_brightness));
-  curve->AddKeyframe(FilterKeyframe::Create(duration, filters, nullptr));
+  curve->AddKeyframe(FilterKeyframe::Create(
+      base::TimeDelta::FromSecondsD(duration), filters, nullptr));
 
   int id = AnimationIdProvider::NextAnimationId();
 
   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_(base::TimeDelta::FromSecondsD(1.0)) {
 }
 
 FakeFloatAnimationCurve::FakeFloatAnimationCurve(double duration)
     : duration_(base::TimeDelta::FromSecondsD(duration)) {
 }
 
 FakeFloatAnimationCurve::~FakeFloatAnimationCurve() {}
 
 base::TimeDelta FakeFloatAnimationCurve::Duration() const {
   return duration_;
 }
 
-float FakeFloatAnimationCurve::GetValue(double now) const {
+float FakeFloatAnimationCurve::GetValue(base::TimeDelta now) const {
   return 0.0f;
 }
 
 scoped_ptr<AnimationCurve> FakeFloatAnimationCurve::Clone() const {
   return make_scoped_ptr(new FakeFloatAnimationCurve);
 }
 
 FakeTransformTransition::FakeTransformTransition(double duration)
     : duration_(base::TimeDelta::FromSecondsD(duration)) {
 }
 
 FakeTransformTransition::~FakeTransformTransition() {}
 
 base::TimeDelta FakeTransformTransition::Duration() const {
   return duration_;
 }
 
-gfx::Transform FakeTransformTransition::GetValue(double time) const {
+gfx::Transform FakeTransformTransition::GetValue(base::TimeDelta time) const {
   return gfx::Transform();
 }
 
 bool FakeTransformTransition::AnimatedBoundsForBox(const gfx::BoxF& box,
                                                    gfx::BoxF* bounds) const {
   return false;
 }
 
 bool FakeTransformTransition::AffectsScale() const { return false; }
 
@@ skipping 12 matching lines @@
 FakeFloatTransition::FakeFloatTransition(double duration, float from, float to)
     : duration_(base::TimeDelta::FromSecondsD(duration)), from_(from), to_(to) {
 }
 
 FakeFloatTransition::~FakeFloatTransition() {}
 
 base::TimeDelta FakeFloatTransition::Duration() const {
   return duration_;
 }
 
-float FakeFloatTransition::GetValue(double time) const {
-  time /= duration_.InSecondsF();
-  if (time >= 1.0)
-    time = 1.0;
-  return (1.0 - time) * from_ + time * to_;
+float FakeFloatTransition::GetValue(base::TimeDelta time) const {
+  double progress = TimeUtil::Divide(time, duration_);
+  if (progress >= 1.0)
+    progress = 1.0;
+  return (1.0 - progress) * from_ + progress * to_;
 }
 
 FakeLayerAnimationValueObserver::FakeLayerAnimationValueObserver()
     : opacity_(0.0f),
       animation_waiting_for_deletion_(false) {}
 
 FakeLayerAnimationValueObserver::~FakeLayerAnimationValueObserver() {}
 
 void FakeLayerAnimationValueObserver::OnFilterAnimated(
     const FilterOperations& filters) {
@@ skipping 134 matching lines @@
                              double duration,
                              float start_brightness,
                              float end_brightness) {
   return AddAnimatedFilter(layer->layer_animation_controller(),
                            duration,
                            start_brightness,
                            end_brightness);
 }
 
 }  // namespace cc