CC::LayerAnimationController should use TimeTicks and

TimeDelta to represent time.

As of now complete CC/animation code uses double type
for time durations. This patch replaces  double with
TimeTicks where time stamps is used and TimeDeltas
where offset is used.

BUG=178171

Review URL: https://codereview.chromium.org/231133002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@270718 0039d316-1c4b-4281-b951-d872f2087c98

16 files changed, 490 insertions, 439 deletions

diff --git a/cc/animation/animation.cc b/cc/animation/animation.cc
index 2e924ac..4adb88a 100644
--- a/cc/animation/animation.cc
+++ b/cc/animation/animation.cc
@@ -64,14 +64,10 @@ Animation::Animation(scoped_ptr<AnimationCurve> curve,
       target_property_(target_property),
       run_state_(WaitingForTargetAvailability),
       iterations_(1),
-      start_time_(0),
       direction_(Normal),
-      time_offset_(0),
       needs_synchronized_start_time_(false),
       received_finished_event_(false),
       suspended_(false),
-      pause_time_(0),
-      total_paused_time_(0),
       is_controlling_instance_(false),
       is_impl_only_(false),
       affects_active_observers_(true),
@@ -80,10 +76,11 @@ Animation::Animation(scoped_ptr<AnimationCurve> curve,
 
 Animation::~Animation() {
   if (run_state_ == Running || run_state_ == Paused)
-    SetRunState(Aborted, 0);
+    SetRunState(Aborted, base::TimeTicks());
 }
 
-void Animation::SetRunState(RunState run_state, double monotonic_time) {
+void Animation::SetRunState(RunState run_state,
+                            base::TimeTicks monotonic_time) {
   if (suspended_)
     return;
 
@@ -108,7 +105,7 @@ void Animation::SetRunState(RunState run_state, double monotonic_time) {
   const char* old_run_state_name = s_runStateNames[run_state_];
 
   if (run_state == Running && run_state_ == Paused)
-    total_paused_time_ += monotonic_time - pause_time_;
+    total_paused_time_ += (monotonic_time - pause_time_);
   else if (run_state == Paused)
     pause_time_ = monotonic_time;
   run_state_ = run_state;
@@ -134,33 +131,32 @@ void Animation::SetRunState(RunState run_state, double monotonic_time) {
                        TRACE_STR_COPY(state_buffer));
 }
 
-void Animation::Suspend(double monotonic_time) {
+void Animation::Suspend(base::TimeTicks monotonic_time) {
   SetRunState(Paused, monotonic_time);
   suspended_ = true;
 }
 
-void Animation::Resume(double monotonic_time) {
+void Animation::Resume(base::TimeTicks monotonic_time) {
   suspended_ = false;
   SetRunState(Running, monotonic_time);
 }
 
-bool Animation::IsFinishedAt(double monotonic_time) const {
+bool Animation::IsFinishedAt(base::TimeTicks monotonic_time) const {
   if (is_finished())
     return true;
 
   if (needs_synchronized_start_time_)
     return false;
 
-  return run_state_ == Running &&
-         iterations_ >= 0 &&
-         iterations_ * curve_->Duration() <= (monotonic_time -
-                                              start_time() -
-                                              total_paused_time_ +
-                                              time_offset_);
+  return run_state_ == Running && iterations_ >= 0 &&
+         iterations_ * curve_->Duration() <=
+             (monotonic_time + time_offset_ - start_time_ - total_paused_time_)
+                 .InSecondsF();
 }
 
-double Animation::TrimTimeToCurrentIteration(double monotonic_time) const {
-  double trimmed = monotonic_time + time_offset_;
+double Animation::TrimTimeToCurrentIteration(
+    base::TimeTicks monotonic_time) const {
+  base::TimeTicks trimmed = monotonic_time + time_offset_;
 
   // If we're paused, time is 'stuck' at the pause time.
   if (run_state_ == Paused)
@@ -168,16 +164,18 @@ double Animation::TrimTimeToCurrentIteration(double monotonic_time) const {
 
   // Returned time should always be relative to the start time and should
   // subtract all time spent paused.
-  trimmed -= start_time_ + total_paused_time_;
+  trimmed -= (start_time_ - base::TimeTicks()) + total_paused_time_;
 
   // If we're just starting or we're waiting on receiving a start time,
   // time is 'stuck' at the initial state.
   if ((run_state_ == Starting && !has_set_start_time()) ||
       needs_synchronized_start_time())
-    trimmed = time_offset_;
+    trimmed = base::TimeTicks() + time_offset_;
+
+  double trimmed_in_seconds = (trimmed - base::TimeTicks()).InSecondsF();
 
   // Return 0 if we are before the start of the animation
-  if (trimmed < 0)
+  if (trimmed_in_seconds < 0)
     return 0;
 
   // Always return zero if we have no iterations.
@@ -190,7 +188,8 @@ double Animation::TrimTimeToCurrentIteration(double monotonic_time) const {
 
   // check if we are past active interval
   bool is_past_total_duration =
-      (iterations_ > 0 && trimmed >= curve_->Duration() * iterations_);
+      (iterations_ > 0 &&
+       trimmed_in_seconds >= curve_->Duration() * iterations_);
 
   // We need to know the current iteration if we're alternating.
   int iteration = 0;
@@ -198,12 +197,12 @@ double Animation::TrimTimeToCurrentIteration(double monotonic_time) const {
   // If we are past the active interval, return iteration duration.
   if (is_past_total_duration) {
     iteration = iterations_ - 1;
-    trimmed = curve_->Duration();
+    trimmed_in_seconds = curve_->Duration();
   } else {
-    iteration = static_cast<int>(trimmed / curve_->Duration());
+    iteration = static_cast<int>(trimmed_in_seconds / curve_->Duration());
     // Calculate x where trimmed = x + n * curve_->Duration() for some positive
     // integer n.
-    trimmed = fmod(trimmed, curve_->Duration());
+    trimmed_in_seconds = fmod(trimmed_in_seconds, curve_->Duration());
   }
 
   // check if we are running the animation in reverse direction for the current
@@ -214,9 +213,9 @@ double Animation::TrimTimeToCurrentIteration(double monotonic_time) const {
 
   // if we are running the animation in reverse direction, reverse the result
   if (reverse)
-    return curve_->Duration() - trimmed;
+    return curve_->Duration() - trimmed_in_seconds;
 
-  return trimmed;
+  return trimmed_in_seconds;
 }
 
 scoped_ptr<Animation> Animation::CloneAndInitialize(
diff --git a/cc/animation/animation.h b/cc/animation/animation.h
index e4476ff..02bb2c6 100644
--- a/cc/animation/animation.h
+++ b/cc/animation/animation.h
@@ -7,6 +7,7 @@
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/time/time.h"
 #include "cc/base/cc_export.h"
 
 namespace cc {
@@ -62,7 +63,7 @@ class CC_EXPORT Animation {
   TargetProperty target_property() const { return target_property_; }
 
   RunState run_state() const { return run_state_; }
-  void SetRunState(RunState run_state, double monotonic_time);
+  void SetRunState(RunState run_state, base::TimeTicks monotonic_time);
 
   // This is the number of times that the animation will play. If this
   // value is zero the animation will not play. If it is negative, then
@@ -70,20 +71,25 @@ class CC_EXPORT Animation {
   int iterations() const { return iterations_; }
   void set_iterations(int n) { iterations_ = n; }
 
-  double start_time() const { return start_time_; }
-  void set_start_time(double monotonic_time) { start_time_ = monotonic_time; }
-  bool has_set_start_time() const { return !!start_time_; }
+  base::TimeTicks start_time() const { return start_time_; }
 
-  double time_offset() const { return time_offset_; }
-  void set_time_offset(double monotonic_time) { time_offset_ = monotonic_time; }
+  void set_start_time(base::TimeTicks monotonic_time) {
+    start_time_ = monotonic_time;
+  }
+  bool has_set_start_time() const { return !start_time_.is_null(); }
+
+  base::TimeDelta time_offset() const { return time_offset_; }
+  void set_time_offset(base::TimeDelta monotonic_time) {
+    time_offset_ = monotonic_time;
+  }
 
-  void Suspend(double monotonic_time);
-  void Resume(double monotonic_time);
+  void Suspend(base::TimeTicks monotonic_time);
+  void Resume(base::TimeTicks monotonic_time);
 
   Direction direction() { return direction_; }
   void set_direction(Direction direction) { direction_ = direction; }
 
-  bool IsFinishedAt(double monotonic_time) const;
+  bool IsFinishedAt(base::TimeTicks monotonic_time) const;
   bool is_finished() const {
     return run_state_ == Finished ||
         run_state_ == Aborted ||
@@ -114,9 +120,10 @@ class CC_EXPORT Animation {
 
   // Takes the given absolute time, and using the start time and the number
   // of iterations, returns the relative time in the current iteration.
-  double TrimTimeToCurrentIteration(double monotonic_time) const;
+  double TrimTimeToCurrentIteration(base::TimeTicks monotonic_time) const;
 
   scoped_ptr<Animation> CloneAndInitialize(RunState initial_run_state) const;
+
   bool is_controlling_instance() const { return is_controlling_instance_; }
 
   void PushPropertiesTo(Animation* other) const;
@@ -155,14 +162,14 @@ class CC_EXPORT Animation {
   TargetProperty target_property_;
   RunState run_state_;
   int iterations_;
-  double start_time_;
+  base::TimeTicks start_time_;
   Direction direction_;
 
   // The time offset effectively pushes the start of the animation back in time.
   // This is used for resuming paused animations -- an animation is added with a
   // non-zero time offset, causing the animation to skip ahead to the desired
   // point in time.
-  double time_offset_;
+  base::TimeDelta time_offset_;
 
   bool needs_synchronized_start_time_;
   bool received_finished_event_;
@@ -176,8 +183,8 @@ class CC_EXPORT Animation {
   // spent while paused. This is not included in AnimationState since it
   // there is absolutely no need for clients of this controller to know
   // about these values.
-  double pause_time_;
-  double total_paused_time_;
+  base::TimeTicks pause_time_;
+  base::TimeDelta total_paused_time_;
 
   // Animations lead dual lives. An active animation will be conceptually owned
   // by two controllers, one on the impl thread and one on the main. In reality,
diff --git a/cc/animation/animation_events.cc b/cc/animation/animation_events.cc
index 95b0e07..40a9031 100644
--- a/cc/animation/animation_events.cc
+++ b/cc/animation/animation_events.cc
@@ -10,7 +10,7 @@ AnimationEvent::AnimationEvent(AnimationEvent::Type type,
                                int layer_id,
                                int group_id,
                                Animation::TargetProperty target_property,
-                               double monotonic_time)
+                               base::TimeTicks monotonic_time)
     : type(type),
       layer_id(layer_id),
       group_id(group_id),
diff --git a/cc/animation/animation_events.h b/cc/animation/animation_events.h
index e0cf736..e40ca3f 100644
--- a/cc/animation/animation_events.h
+++ b/cc/animation/animation_events.h
@@ -21,13 +21,13 @@ struct CC_EXPORT AnimationEvent {
                  int layer_id,
                  int group_id,
                  Animation::TargetProperty target_property,
-                 double monotonic_time);
+                 base::TimeTicks monotonic_time);
 
   Type type;
   int layer_id;
   int group_id;
   Animation::TargetProperty target_property;
-  double monotonic_time;
+  base::TimeTicks monotonic_time;
   bool is_impl_only;
   float opacity;
   gfx::Transform transform;
diff --git a/cc/animation/animation_unittest.cc b/cc/animation/animation_unittest.cc
index 7768cebf..1d4b8f7 100644
--- a/cc/animation/animation_unittest.cc
+++ b/cc/animation/animation_unittest.cc
@@ -11,6 +11,13 @@
 namespace cc {
 namespace {
 
+using base::TimeDelta;
+
+static base::TimeTicks TicksFromSecondsF(double seconds) {
+  return base::TimeTicks::FromInternalValue(seconds *
+                                            base::Time::kMicrosecondsPerSecond);
+}
+
 scoped_ptr<Animation> CreateAnimation(int iterations, double duration) {
   scoped_ptr<Animation> to_return(Animation::Create(
       make_scoped_ptr(
@@ -28,367 +35,370 @@ scoped_ptr<Animation> CreateAnimation(int iterations) {
 
 TEST(AnimationTest, TrimTimeZeroIterations) {
   scoped_ptr<Animation> anim(CreateAnimation(0));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(-1.0));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(1.0));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(-1.0)));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
 }
 
 TEST(AnimationTest, TrimTimeOneIteration) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(-1.0));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(1.0));
-  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(2.0));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(-1.0)));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(2.0)));
 }
 
 TEST(AnimationTest, TrimTimeInfiniteIterations) {
   scoped_ptr<Animation> anim(CreateAnimation(-1));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(0.5));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(1.0));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(1.5));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.5)));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.5)));
 }
 
 TEST(AnimationTest, TrimTimeReverse) {
   scoped_ptr<Animation> anim(CreateAnimation(-1));
   anim->set_direction(Animation::Reverse);
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(0));
-  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(0.25));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(0.5));
-  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(0.75));
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(1.0));
-  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(1.25));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0)));
+  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.25)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.5)));
+  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.75)));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.25)));
 }
 
 TEST(AnimationTest, TrimTimeAlternateInfiniteIterations) {
   scoped_ptr<Animation> anim(CreateAnimation(-1));
   anim->set_direction(Animation::Alternate);
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(0.25));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(0.5));
-  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(0.75));
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(1.0));
-  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(1.25));
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.25)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.5)));
+  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.75)));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.25)));
 }
 
 TEST(AnimationTest, TrimTimeAlternateOneIteration) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
   anim->set_direction(Animation::Alternate);
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(0.25));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(0.5));
-  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(0.75));
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(1.0));
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(1.25));
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.25)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.5)));
+  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.75)));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.25)));
 }
 
 TEST(AnimationTest, TrimTimeAlternateTwoIterations) {
   scoped_ptr<Animation> anim(CreateAnimation(2));
   anim->set_direction(Animation::Alternate);
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(0.25));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(0.5));
-  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(0.75));
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(1.0));
-  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(1.25));
-  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(1.75));
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(2.0));
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(2.25));
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.25)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.5)));
+  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.75)));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.25)));
+  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.75)));
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(2.0)));
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(2.25)));
 }
 
 TEST(AnimationTest, TrimTimeAlternateReverseInfiniteIterations) {
   scoped_ptr<Animation> anim(CreateAnimation(-1));
   anim->set_direction(Animation::AlternateReverse);
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(0.25));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(0.5));
-  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(0.75));
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(1.0));
-  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(1.25));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.25)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.5)));
+  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.75)));
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.25)));
 }
 
 TEST(AnimationTest, TrimTimeAlternateReverseOneIteration) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
   anim->set_direction(Animation::AlternateReverse);
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(0.25));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(0.5));
-  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(0.75));
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(1.0));
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(1.25));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.25)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.5)));
+  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.75)));
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.25)));
 }
 
 TEST(AnimationTest, TrimTimeAlternateReverseTwoIterations) {
   scoped_ptr<Animation> anim(CreateAnimation(2));
   anim->set_direction(Animation::AlternateReverse);
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(0.25));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(0.5));
-  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(0.75));
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(1.0));
-  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(1.25));
-  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(1.75));
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(2.0));
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(2.25));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.25)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.5)));
+  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.75)));
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.25)));
+  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.75)));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(2.0)));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(2.25)));
 }
 
 TEST(AnimationTest, TrimTimeStartTime) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
-  anim->set_start_time(4);
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(4.0));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(4.5));
-  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(5.0));
-  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(6.0));
+  anim->set_start_time(TicksFromSecondsF(4));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(4.0)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(4.5)));
+  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(5.0)));
+  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(6.0)));
 }
 
 TEST(AnimationTest, TrimTimeStartTimeReverse) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
-  anim->set_start_time(4);
+  anim->set_start_time(TicksFromSecondsF(4));
   anim->set_direction(Animation::Reverse);
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(4.0));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(4.5));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(5.0));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(6.0));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(4.0)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(4.5)));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(5.0)));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(6.0)));
 }
 
 TEST(AnimationTest, TrimTimeTimeOffset) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
-  anim->set_time_offset(4);
-  anim->set_start_time(4);
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(0.5));
-  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(1.0));
-  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(1.0));
+  anim->set_time_offset(TimeDelta::FromMilliseconds(4000));
+  anim->set_start_time(TicksFromSecondsF(4));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.5)));
+  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
 }
 
 TEST(AnimationTest, TrimTimeTimeOffsetReverse) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
-  anim->set_time_offset(4);
-  anim->set_start_time(4);
+  anim->set_time_offset(TimeDelta::FromMilliseconds(4000));
+  anim->set_start_time(TicksFromSecondsF(4));
   anim->set_direction(Animation::Reverse);
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(0.5));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(1.0));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(1.0));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.5)));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
 }
 
 TEST(AnimationTest, TrimTimeNegativeTimeOffset) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
-  anim->set_time_offset(-4);
+  anim->set_time_offset(TimeDelta::FromMilliseconds(-4000));
 
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(4.0));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(4.5));
-  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(5.0));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(4.0)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(4.5)));
+  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(5.0)));
 }
 
 TEST(AnimationTest, TrimTimeNegativeTimeOffsetReverse) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
-  anim->set_time_offset(-4);
+  anim->set_time_offset(TimeDelta::FromMilliseconds(-4000));
   anim->set_direction(Animation::Reverse);
 
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(4.0));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(4.5));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(5.0));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(4.0)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(4.5)));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(5.0)));
 }
 
 TEST(AnimationTest, TrimTimePauseResume) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
-  anim->SetRunState(Animation::Running, 0.0);
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(0.5));
-  anim->SetRunState(Animation::Paused, 0.5);
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(1024.0));
-  anim->SetRunState(Animation::Running, 1024.0);
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(1024.0));
-  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(1024.5));
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(0.0));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.5)));
+  anim->SetRunState(Animation::Paused, TicksFromSecondsF(0.5));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1024.0)));
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(1024.0));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1024.0)));
+  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1024.5)));
 }
 
 TEST(AnimationTest, TrimTimePauseResumeReverse) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
   anim->set_direction(Animation::Reverse);
-  anim->SetRunState(Animation::Running, 0.0);
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(0.5));
-  anim->SetRunState(Animation::Paused, 0.25);
-  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(1024.0));
-  anim->SetRunState(Animation::Running, 1024.0);
-  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(1024.0));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(1024.75));
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(0.0));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.5)));
+  anim->SetRunState(Animation::Paused, TicksFromSecondsF(0.25));
+  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1024.0)));
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(1024.0));
+  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1024.0)));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1024.75)));
 }
 
 TEST(AnimationTest, TrimTimeSuspendResume) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
-  anim->SetRunState(Animation::Running, 0.0);
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(0.5));
-  anim->Suspend(0.5);
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(1024.0));
-  anim->Resume(1024);
-  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(1024.0));
-  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(1024.5));
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(0.0));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.5)));
+  anim->Suspend(TicksFromSecondsF(0.5));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1024.0)));
+  anim->Resume(TicksFromSecondsF(1024));
+  EXPECT_EQ(0.5, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1024.0)));
+  EXPECT_EQ(1, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1024.5)));
 }
 
 TEST(AnimationTest, TrimTimeSuspendResumeReverse) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
   anim->set_direction(Animation::Reverse);
-  anim->SetRunState(Animation::Running, 0.0);
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(0.25));
-  anim->Suspend(0.75);
-  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(1024.0));
-  anim->Resume(1024);
-  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(1024.0));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(1024.25));
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(0.0));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0.75, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.25)));
+  anim->Suspend(TicksFromSecondsF(0.75));
+  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1024.0)));
+  anim->Resume(TicksFromSecondsF(1024));
+  EXPECT_EQ(0.25, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1024.0)));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1024.25)));
 }
 
 TEST(AnimationTest, TrimTimeZeroDuration) {
   scoped_ptr<Animation> anim(CreateAnimation(0, 0));
-  anim->SetRunState(Animation::Running, 0.0);
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(-1.0));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(1.0));
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(0.0));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(-1.0)));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
 }
 
 TEST(AnimationTest, TrimTimeStarting) {
   scoped_ptr<Animation> anim(CreateAnimation(1, 5.0));
-  anim->SetRunState(Animation::Starting, 0.0);
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(-1.0));
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(1.0));
-  anim->set_time_offset(2.0);
-  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(-1.0));
-  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(1.0));
-  anim->set_start_time(1.0);
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(-1.0));
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(1.0));
-  EXPECT_EQ(3.0, anim->TrimTimeToCurrentIteration(2.0));
+  anim->SetRunState(Animation::Starting, TicksFromSecondsF(0.0));
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(-1.0)));
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  anim->set_time_offset(TimeDelta::FromMilliseconds(2000));
+  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(-1.0)));
+  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  anim->set_start_time(TicksFromSecondsF(1.0));
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(-1.0)));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  EXPECT_EQ(3.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(2.0)));
 }
 
 TEST(AnimationTest, TrimTimeNeedsSynchronizedStartTime) {
   scoped_ptr<Animation> anim(CreateAnimation(1, 5.0));
-  anim->SetRunState(Animation::Running, 0.0);
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(0.0));
   anim->set_needs_synchronized_start_time(true);
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(-1.0));
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(1.0));
-  anim->set_time_offset(2.0);
-  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(-1.0));
-  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(1.0));
-  anim->set_start_time(1.0);
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(-1.0)));
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(0.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  anim->set_time_offset(TimeDelta::FromMilliseconds(2000));
+  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(-1.0)));
+  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  anim->set_start_time(TicksFromSecondsF(1.0));
   anim->set_needs_synchronized_start_time(false);
-  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(0.0));
-  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(1.0));
-  EXPECT_EQ(3.0, anim->TrimTimeToCurrentIteration(2.0));
+  EXPECT_EQ(1.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(0.0)));
+  EXPECT_EQ(2.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(1.0)));
+  EXPECT_EQ(3.0, anim->TrimTimeToCurrentIteration(TicksFromSecondsF(2.0)));
 }
 
 TEST(AnimationTest, IsFinishedAtZeroIterations) {
   scoped_ptr<Animation> anim(CreateAnimation(0));
-  anim->SetRunState(Animation::Running, 0.0);
-  EXPECT_FALSE(anim->IsFinishedAt(-1.0));
-  EXPECT_TRUE(anim->IsFinishedAt(0.0));
-  EXPECT_TRUE(anim->IsFinishedAt(1.0));
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(0.0));
+  EXPECT_FALSE(anim->IsFinishedAt(TicksFromSecondsF(-1.0)));
+  EXPECT_TRUE(anim->IsFinishedAt(TicksFromSecondsF(0.0)));
+  EXPECT_TRUE(anim->IsFinishedAt(TicksFromSecondsF(1.0)));
 }
 
 TEST(AnimationTest, IsFinishedAtOneIteration) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
-  anim->SetRunState(Animation::Running, 0.0);
-  EXPECT_FALSE(anim->IsFinishedAt(-1.0));
-  EXPECT_FALSE(anim->IsFinishedAt(0.0));
-  EXPECT_TRUE(anim->IsFinishedAt(1.0));
-  EXPECT_TRUE(anim->IsFinishedAt(2.0));
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(0.0));
+  EXPECT_FALSE(anim->IsFinishedAt(TicksFromSecondsF(-1.0)));
+  EXPECT_FALSE(anim->IsFinishedAt(TicksFromSecondsF(0.0)));
+  EXPECT_TRUE(anim->IsFinishedAt(TicksFromSecondsF(1.0)));
+  EXPECT_TRUE(anim->IsFinishedAt(TicksFromSecondsF(2.0)));
 }
 
 TEST(AnimationTest, IsFinishedAtInfiniteIterations) {
   scoped_ptr<Animation> anim(CreateAnimation(-1));
-  anim->SetRunState(Animation::Running, 0.0);
-  EXPECT_FALSE(anim->IsFinishedAt(0.0));
-  EXPECT_FALSE(anim->IsFinishedAt(0.5));
-  EXPECT_FALSE(anim->IsFinishedAt(1.0));
-  EXPECT_FALSE(anim->IsFinishedAt(1.5));
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(0.0));
+  EXPECT_FALSE(anim->IsFinishedAt(TicksFromSecondsF(0.0)));
+  EXPECT_FALSE(anim->IsFinishedAt(TicksFromSecondsF(0.5)));
+  EXPECT_FALSE(anim->IsFinishedAt(TicksFromSecondsF(1.0)));
+  EXPECT_FALSE(anim->IsFinishedAt(TicksFromSecondsF(1.5)));
 }
 
 TEST(AnimationTest, IsFinishedNegativeTimeOffset) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
-  anim->set_time_offset(-0.5);
-  anim->SetRunState(Animation::Running, 0.0);
+  anim->set_time_offset(TimeDelta::FromMilliseconds(-500));
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(0.0));
 
-  EXPECT_FALSE(anim->IsFinishedAt(-1.0));
-  EXPECT_FALSE(anim->IsFinishedAt(0.0));
-  EXPECT_FALSE(anim->IsFinishedAt(0.5));
-  EXPECT_FALSE(anim->IsFinishedAt(1.0));
-  EXPECT_TRUE(anim->IsFinishedAt(1.5));
-  EXPECT_TRUE(anim->IsFinishedAt(2.0));
-  EXPECT_TRUE(anim->IsFinishedAt(2.5));
+  EXPECT_FALSE(anim->IsFinishedAt(TicksFromSecondsF(-1.0)));
+  EXPECT_FALSE(anim->IsFinishedAt(TicksFromSecondsF(0.0)));
+  EXPECT_FALSE(anim->IsFinishedAt(TicksFromSecondsF(0.5)));
+  EXPECT_FALSE(anim->IsFinishedAt(TicksFromSecondsF(1.0)));
+  EXPECT_TRUE(anim->IsFinishedAt(TicksFromSecondsF(1.5)));
+  EXPECT_TRUE(anim->IsFinishedAt(TicksFromSecondsF(2.0)));
+  EXPECT_TRUE(anim->IsFinishedAt(TicksFromSecondsF(2.5)));
 }
 
 TEST(AnimationTest, IsFinishedPositiveTimeOffset) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
-  anim->set_time_offset(0.5);
-  anim->SetRunState(Animation::Running, 0.0);
+  anim->set_time_offset(TimeDelta::FromMilliseconds(500));
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(0.0));
 
-  EXPECT_FALSE(anim->IsFinishedAt(-1.0));
-  EXPECT_FALSE(anim->IsFinishedAt(0.0));
-  EXPECT_TRUE(anim->IsFinishedAt(0.5));
-  EXPECT_TRUE(anim->IsFinishedAt(1.0));
+  EXPECT_FALSE(anim->IsFinishedAt(TicksFromSecondsF(-1.0)));
+  EXPECT_FALSE(anim->IsFinishedAt(TicksFromSecondsF(0.0)));
+  EXPECT_TRUE(anim->IsFinishedAt(TicksFromSecondsF(0.5)));
+  EXPECT_TRUE(anim->IsFinishedAt(TicksFromSecondsF(1.0)));
 }
 
 TEST(AnimationTest, IsFinishedAtNotRunning) {
   scoped_ptr<Animation> anim(CreateAnimation(0));
-  anim->SetRunState(Animation::Running, 0.0);
-  EXPECT_TRUE(anim->IsFinishedAt(0.0));
-  anim->SetRunState(Animation::Paused, 0.0);
-  EXPECT_FALSE(anim->IsFinishedAt(0.0));
-  anim->SetRunState(Animation::WaitingForTargetAvailability, 0.0);
-  EXPECT_FALSE(anim->IsFinishedAt(0.0));
-  anim->SetRunState(Animation::Finished, 0.0);
-  EXPECT_TRUE(anim->IsFinishedAt(0.0));
-  anim->SetRunState(Animation::Aborted, 0.0);
-  EXPECT_TRUE(anim->IsFinishedAt(0.0));
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(0.0));
+  EXPECT_TRUE(anim->IsFinishedAt(TicksFromSecondsF(0.0)));
+  anim->SetRunState(Animation::Paused, TicksFromSecondsF(0.0));
+  EXPECT_FALSE(anim->IsFinishedAt(TicksFromSecondsF(0.0)));
+  anim->SetRunState(Animation::WaitingForTargetAvailability,
+                    TicksFromSecondsF(0.0));
+  EXPECT_FALSE(anim->IsFinishedAt(TicksFromSecondsF(0.0)));
+  anim->SetRunState(Animation::Finished, TicksFromSecondsF(0.0));
+  EXPECT_TRUE(anim->IsFinishedAt(TicksFromSecondsF(0.0)));
+  anim->SetRunState(Animation::Aborted, TicksFromSecondsF(0.0));
+  EXPECT_TRUE(anim->IsFinishedAt(TicksFromSecondsF(0.0)));
 }
 
 TEST(AnimationTest, IsFinished) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
-  anim->SetRunState(Animation::Running, 0.0);
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(0.0));
   EXPECT_FALSE(anim->is_finished());
-  anim->SetRunState(Animation::Paused, 0.0);
+  anim->SetRunState(Animation::Paused, TicksFromSecondsF(0.0));
   EXPECT_FALSE(anim->is_finished());
-  anim->SetRunState(Animation::WaitingForTargetAvailability, 0.0);
+  anim->SetRunState(Animation::WaitingForTargetAvailability,
+                    TicksFromSecondsF(0.0));
   EXPECT_FALSE(anim->is_finished());
-  anim->SetRunState(Animation::Finished, 0.0);
+  anim->SetRunState(Animation::Finished, TicksFromSecondsF(0.0));
   EXPECT_TRUE(anim->is_finished());
-  anim->SetRunState(Animation::Aborted, 0.0);
+  anim->SetRunState(Animation::Aborted, TicksFromSecondsF(0.0));
   EXPECT_TRUE(anim->is_finished());
 }
 
 TEST(AnimationTest, IsFinishedNeedsSynchronizedStartTime) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
-  anim->SetRunState(Animation::Running, 2.0);
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(2.0));
   EXPECT_FALSE(anim->is_finished());
-  anim->SetRunState(Animation::Paused, 2.0);
+  anim->SetRunState(Animation::Paused, TicksFromSecondsF(2.0));
   EXPECT_FALSE(anim->is_finished());
-  anim->SetRunState(Animation::WaitingForTargetAvailability, 2.0);
+  anim->SetRunState(Animation::WaitingForTargetAvailability,
+                    TicksFromSecondsF(2.0));
   EXPECT_FALSE(anim->is_finished());
-  anim->SetRunState(Animation::Finished, 0.0);
+  anim->SetRunState(Animation::Finished, TicksFromSecondsF(0.0));
   EXPECT_TRUE(anim->is_finished());
-  anim->SetRunState(Animation::Aborted, 0.0);
+  anim->SetRunState(Animation::Aborted, TicksFromSecondsF(0.0));
   EXPECT_TRUE(anim->is_finished());
 }
 
 TEST(AnimationTest, RunStateChangesIgnoredWhileSuspended) {
   scoped_ptr<Animation> anim(CreateAnimation(1));
-  anim->Suspend(0);
+  anim->Suspend(TicksFromSecondsF(0));
   EXPECT_EQ(Animation::Paused, anim->run_state());
-  anim->SetRunState(Animation::Running, 0.0);
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(0.0));
   EXPECT_EQ(Animation::Paused, anim->run_state());
-  anim->Resume(0);
-  anim->SetRunState(Animation::Running, 0.0);
+  anim->Resume(TicksFromSecondsF(0));
+  anim->SetRunState(Animation::Running, TicksFromSecondsF(0.0));
   EXPECT_EQ(Animation::Running, anim->run_state());
 }
 
diff --git a/cc/animation/layer_animation_controller.cc b/cc/animation/layer_animation_controller.cc
index 58b26d7..ddbf35a 100644
--- a/cc/animation/layer_animation_controller.cc
+++ b/cc/animation/layer_animation_controller.cc
@@ -24,7 +24,6 @@ LayerAnimationController::LayerAnimationController(int id)
     : registrar_(0),
       id_(id),
       is_active_(false),
-      last_tick_time_(0),
       value_provider_(NULL),
       layer_animation_delegate_(NULL),
       needs_to_start_animations_(false) {
@@ -41,7 +40,7 @@ scoped_refptr<LayerAnimationController> LayerAnimationController::Create(
 }
 
 void LayerAnimationController::PauseAnimation(int animation_id,
-                                              double time_offset) {
+                                              base::TimeDelta time_offset) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->id() == animation_id) {
       animations_[i]->SetRunState(Animation::Paused,
@@ -123,8 +122,8 @@ void LayerAnimationController::PushAnimationUpdatesTo(
   UpdateActivation(NormalActivation);
 }
 
-void LayerAnimationController::Animate(double monotonic_time) {
-  DCHECK(monotonic_time);
+void LayerAnimationController::Animate(base::TimeTicks monotonic_time) {
+  DCHECK(!monotonic_time.is_null());
   if (!HasValueObserver())
     return;
 
@@ -135,7 +134,7 @@ void LayerAnimationController::Animate(double monotonic_time) {
 }
 
 void LayerAnimationController::AccumulatePropertyUpdates(
-    double monotonic_time,
+    base::TimeTicks monotonic_time,
     AnimationEventsVector* events) {
   if (!events)
     return;
@@ -206,7 +205,7 @@ void LayerAnimationController::UpdateState(bool start_ready_animations,
   if (!HasActiveValueObserver())
     return;
 
-  DCHECK(last_tick_time_);
+  DCHECK(last_tick_time_ != base::TimeTicks());
   if (start_ready_animations)
     PromoteStartedAnimations(last_tick_time_, events);
 
@@ -304,15 +303,12 @@ void LayerAnimationController::SetAnimationRegistrar(
 
 void LayerAnimationController::NotifyAnimationStarted(
     const AnimationEvent& event) {
-  base::TimeTicks monotonic_time = base::TimeTicks::FromInternalValue(
-      event.monotonic_time * base::Time::kMicrosecondsPerSecond);
   if (event.is_impl_only) {
     FOR_EACH_OBSERVER(LayerAnimationEventObserver, event_observers_,
                       OnAnimationStarted(event));
     if (layer_animation_delegate_)
-      layer_animation_delegate_->NotifyAnimationStarted(monotonic_time,
+      layer_animation_delegate_->NotifyAnimationStarted(event.monotonic_time,
                                                         event.target_property);
-
     return;
   }
 
@@ -328,7 +324,7 @@ void LayerAnimationController::NotifyAnimationStarted(
                         OnAnimationStarted(event));
       if (layer_animation_delegate_)
         layer_animation_delegate_->NotifyAnimationStarted(
-            monotonic_time, event.target_property);
+            event.monotonic_time, event.target_property);
 
       return;
     }
@@ -337,11 +333,9 @@ void LayerAnimationController::NotifyAnimationStarted(
 
 void LayerAnimationController::NotifyAnimationFinished(
     const AnimationEvent& event) {
-  base::TimeTicks monotonic_time = base::TimeTicks::FromInternalValue(
-      event.monotonic_time * base::Time::kMicrosecondsPerSecond);
   if (event.is_impl_only) {
     if (layer_animation_delegate_)
-      layer_animation_delegate_->NotifyAnimationFinished(monotonic_time,
+      layer_animation_delegate_->NotifyAnimationFinished(event.monotonic_time,
                                                          event.target_property);
     return;
   }
@@ -352,7 +346,7 @@ void LayerAnimationController::NotifyAnimationFinished(
       animations_[i]->set_received_finished_event(true);
       if (layer_animation_delegate_)
         layer_animation_delegate_->NotifyAnimationFinished(
-            monotonic_time, event.target_property);
+            event.monotonic_time, event.target_property);
 
       return;
     }
@@ -602,7 +596,7 @@ void LayerAnimationController::PushPropertiesToImplThread(
   }
 }
 
-void LayerAnimationController::StartAnimations(double monotonic_time) {
+void LayerAnimationController::StartAnimations(base::TimeTicks monotonic_time) {
   DCHECK(needs_to_start_animations_);
   needs_to_start_animations_ = false;
   // First collect running properties affecting each type of observer.
@@ -677,7 +671,7 @@ void LayerAnimationController::StartAnimations(double monotonic_time) {
 }
 
 void LayerAnimationController::PromoteStartedAnimations(
-    double monotonic_time,
+    base::TimeTicks monotonic_time,
     AnimationEventsVector* events) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->run_state() == Animation::Starting &&
@@ -699,7 +693,8 @@ void LayerAnimationController::PromoteStartedAnimations(
   }
 }
 
-void LayerAnimationController::MarkFinishedAnimations(double monotonic_time) {
+void LayerAnimationController::MarkFinishedAnimations(
+    base::TimeTicks monotonic_time) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->IsFinishedAt(monotonic_time) &&
         animations_[i]->run_state() != Animation::Aborted &&
@@ -709,7 +704,8 @@ void LayerAnimationController::MarkFinishedAnimations(double monotonic_time) {
 }
 
 void LayerAnimationController::MarkAnimationsForDeletion(
-    double monotonic_time, AnimationEventsVector* events) {
+    base::TimeTicks monotonic_time,
+    AnimationEventsVector* events) {
   bool marked_animations_for_deletions = false;
 
   // Non-aborted animations are marked for deletion after a corresponding
@@ -796,7 +792,7 @@ void LayerAnimationController::PurgeAnimationsMarkedForDeletion() {
                     animations_.end());
 }
 
-void LayerAnimationController::TickAnimations(double monotonic_time) {
+void LayerAnimationController::TickAnimations(base::TimeTicks monotonic_time) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->run_state() == Animation::Starting ||
         animations_[i]->run_state() == Animation::Running ||
diff --git a/cc/animation/layer_animation_controller.h b/cc/animation/layer_animation_controller.h
index bf54a14..72f4c46 100644
--- a/cc/animation/layer_animation_controller.h
+++ b/cc/animation/layer_animation_controller.h
@@ -40,7 +40,7 @@ class CC_EXPORT LayerAnimationController
   int id() const { return id_; }
 
   void AddAnimation(scoped_ptr<Animation> animation);
-  void PauseAnimation(int animation_id, double time_offset);
+  void PauseAnimation(int animation_id, base::TimeDelta time_offset);
   void RemoveAnimation(int animation_id);
   void RemoveAnimation(int animation_id,
                        Animation::TargetProperty target_property);
@@ -52,8 +52,8 @@ class CC_EXPORT LayerAnimationController
   virtual void PushAnimationUpdatesTo(
       LayerAnimationController* controller_impl);
 
-  void Animate(double monotonic_time);
-  void AccumulatePropertyUpdates(double monotonic_time,
+  void Animate(base::TimeTicks monotonic_time);
+  void AccumulatePropertyUpdates(base::TimeTicks monotonic_time,
                                  AnimationEventsVector* events);
 
   void UpdateState(bool start_ready_animations,
@@ -152,15 +152,15 @@ class CC_EXPORT LayerAnimationController
   void PushPropertiesToImplThread(
       LayerAnimationController* controller_impl) const;
 
-  void StartAnimations(double monotonic_time);
-  void PromoteStartedAnimations(double monotonic_time,
+  void StartAnimations(base::TimeTicks monotonic_time);
+  void PromoteStartedAnimations(base::TimeTicks monotonic_time,
                                 AnimationEventsVector* events);
-  void MarkFinishedAnimations(double monotonic_time);
-  void MarkAnimationsForDeletion(double monotonic_time,
+  void MarkFinishedAnimations(base::TimeTicks monotonic_time);
+  void MarkAnimationsForDeletion(base::TimeTicks monotonic_time,
                                  AnimationEventsVector* events);
   void PurgeAnimationsMarkedForDeletion();
 
-  void TickAnimations(double monotonic_time);
+  void TickAnimations(base::TimeTicks monotonic_time);
 
   enum UpdateActivationType {
     NormalActivation,
@@ -193,7 +193,7 @@ class CC_EXPORT LayerAnimationController
   // This is used to ensure that we don't spam the registrar.
   bool is_active_;
 
-  double last_tick_time_;
+  base::TimeTicks last_tick_time_;
 
   ObserverList<LayerAnimationValueObserver> value_observers_;
   ObserverList<LayerAnimationEventObserver> event_observers_;
diff --git a/cc/animation/layer_animation_controller_unittest.cc b/cc/animation/layer_animation_controller_unittest.cc
index e172f72..15efdf0 100644
--- a/cc/animation/layer_animation_controller_unittest.cc
+++ b/cc/animation/layer_animation_controller_unittest.cc
@@ -20,10 +20,18 @@
 namespace cc {
 namespace {
 
+using base::TimeDelta;
+using base::TimeTicks;
+
+static base::TimeTicks TicksFromSecondsF(double seconds) {
+  return base::TimeTicks::FromInternalValue(seconds *
+                                            base::Time::kMicrosecondsPerSecond);
+}
+
 // A LayerAnimationController cannot be ticked at 0.0, since an animation
 // with start time 0.0 is treated as an animation whose start time has
 // not yet been set.
-const double kInitialTickTime = 1.0;
+const TimeTicks kInitialTickTime = TicksFromSecondsF(1.0);
 
 scoped_ptr<Animation> CreateAnimation(scoped_ptr<AnimationCurve> curve,
                                       int id,
@@ -98,7 +106,7 @@ TEST(LayerAnimationControllerTest, DoNotClobberStartTimes) {
                                           Animation::Opacity)->start_time());
 
   // Start the animation on the main thread. Should not affect the start time.
-  controller->Animate(kInitialTickTime + 0.5);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller->UpdateState(true, NULL);
   EXPECT_EQ(controller->GetAnimation(group_id,
                                      Animation::Opacity)->start_time(),
@@ -119,7 +127,7 @@ TEST(LayerAnimationControllerTest, UseSpecifiedStartTimes) {
   AddOpacityTransitionToController(controller.get(), 1, 0, 1, false);
   int group_id = controller->GetAnimation(Animation::Opacity)->group();
 
-  const double start_time = 123;
+  const TimeTicks start_time = TicksFromSecondsF(123);
   controller->GetAnimation(Animation::Opacity)->set_start_time(start_time);
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
@@ -147,7 +155,7 @@ TEST(LayerAnimationControllerTest, UseSpecifiedStartTimes) {
                                           Animation::Opacity)->start_time());
 
   // Start the animation on the main thread. Should not affect the start time.
-  controller->Animate(kInitialTickTime + 0.5);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller->UpdateState(true, NULL);
   EXPECT_EQ(start_time,
             controller->GetAnimation(group_id,
@@ -201,18 +209,19 @@ TEST(LayerAnimationControllerTest, Activation) {
   EXPECT_EQ(1u, registrar->active_animation_controllers().size());
   EXPECT_EQ(1u, registrar_impl->active_animation_controllers().size());
 
-  controller->Animate(kInitialTickTime + 0.5);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller->UpdateState(true, NULL);
   EXPECT_EQ(1u, registrar->active_animation_controllers().size());
 
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, NULL);
   EXPECT_EQ(Animation::Finished,
             controller->GetAnimation(Animation::Opacity)->run_state());
   EXPECT_EQ(1u, registrar->active_animation_controllers().size());
 
   events.reset(new AnimationEventsVector);
-  controller_impl->Animate(kInitialTickTime + 1.5);
+  controller_impl->Animate(kInitialTickTime +
+                           TimeDelta::FromMilliseconds(1500));
   controller_impl->UpdateState(true, events.get());
 
   EXPECT_EQ(Animation::WaitingForDeletion,
@@ -222,7 +231,7 @@ TEST(LayerAnimationControllerTest, Activation) {
 
   EXPECT_EQ(1u, events->size());
   controller->NotifyAnimationFinished((*events)[0]);
-  controller->Animate(kInitialTickTime + 1.5);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1500));
   controller->UpdateState(true, NULL);
 
   EXPECT_EQ(Animation::WaitingForDeletion,
@@ -279,7 +288,9 @@ TEST(LayerAnimationControllerTest, SyncPause) {
                                      Animation::Opacity)->run_state());
 
   // Pause the main-thread animation.
-  controller->PauseAnimation(animation_id, kInitialTickTime + 1.0);
+  controller->PauseAnimation(
+      animation_id,
+      TimeDelta::FromMilliseconds(1000) + TimeDelta::FromMilliseconds(1000));
   EXPECT_EQ(Animation::Paused,
             controller->GetAnimation(group_id,
                                      Animation::Opacity)->run_state());
@@ -357,7 +368,7 @@ TEST(LayerAnimationControllerTest, AnimationsAreDeleted) {
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
 
-  controller_impl->Animate(kInitialTickTime + 0.5);
+  controller_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller_impl->UpdateState(true, events.get());
 
   // There should be a Started event for the animation.
@@ -365,14 +376,15 @@ TEST(LayerAnimationControllerTest, AnimationsAreDeleted) {
   EXPECT_EQ(AnimationEvent::Started, (*events)[0].type);
   controller->NotifyAnimationStarted((*events)[0]);
 
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, NULL);
 
   EXPECT_FALSE(dummy.animation_waiting_for_deletion());
   EXPECT_FALSE(dummy_impl.animation_waiting_for_deletion());
 
   events.reset(new AnimationEventsVector);
-  controller_impl->Animate(kInitialTickTime + 2.0);
+  controller_impl->Animate(kInitialTickTime +
+                           TimeDelta::FromMilliseconds(2000));
   controller_impl->UpdateState(true, events.get());
 
   EXPECT_TRUE(dummy_impl.animation_waiting_for_deletion());
@@ -387,7 +399,7 @@ TEST(LayerAnimationControllerTest, AnimationsAreDeleted) {
 
   controller->NotifyAnimationFinished((*events)[0]);
 
-  controller->Animate(kInitialTickTime + 3.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
   controller->UpdateState(true, NULL);
   EXPECT_TRUE(dummy.animation_waiting_for_deletion());
 
@@ -437,7 +449,7 @@ TEST(LayerAnimationControllerTest, TrivialTransition) {
   // A non-impl-only animation should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1.f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -469,7 +481,8 @@ TEST(LayerAnimationControllerTest, TrivialTransitionOnImpl) {
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_EQ(0.f, start_opacity_event->opacity);
 
-  controller_impl->Animate(kInitialTickTime + 1.0);
+  controller_impl->Animate(kInitialTickTime +
+                           TimeDelta::FromMilliseconds(1000));
   controller_impl->UpdateState(true, events.get());
   EXPECT_EQ(1.f, dummy_impl.opacity());
   EXPECT_FALSE(controller_impl->HasActiveAnimation());
@@ -523,7 +536,8 @@ TEST(LayerAnimationControllerTest, TrivialTransformOnImpl) {
   gfx::Transform expected_transform;
   expected_transform.Translate(delta_x, delta_y);
 
-  controller_impl->Animate(kInitialTickTime + 1.0);
+  controller_impl->Animate(kInitialTickTime +
+                           TimeDelta::FromMilliseconds(1000));
   controller_impl->UpdateState(true, events.get());
   EXPECT_EQ(expected_transform, dummy_impl.transform());
   EXPECT_FALSE(controller_impl->HasActiveAnimation());
@@ -566,7 +580,7 @@ TEST(LayerAnimationControllerTest, FilterTransition) {
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  controller->Animate(kInitialTickTime + 0.5);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1u, dummy.filters().size());
   EXPECT_EQ(FilterOperation::CreateBrightnessFilter(1.5f),
@@ -574,7 +588,7 @@ TEST(LayerAnimationControllerTest, FilterTransition) {
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(end_filters, dummy.filters());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -620,7 +634,8 @@ TEST(LayerAnimationControllerTest, FilterTransitionOnImplOnly) {
   EXPECT_EQ(start_filters, start_filter_event->filters);
   EXPECT_TRUE(start_filter_event->is_impl_only);
 
-  controller_impl->Animate(kInitialTickTime + 1.0);
+  controller_impl->Animate(kInitialTickTime +
+                           TimeDelta::FromMilliseconds(1000));
   controller_impl->UpdateState(true, events.get());
   EXPECT_EQ(end_filters, dummy_impl.filters());
   EXPECT_FALSE(controller_impl->HasActiveAnimation());
@@ -664,11 +679,14 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransition) {
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
   EXPECT_TRUE(controller_impl->GetAnimation(Animation::ScrollOffset));
-  double duration = controller_impl->GetAnimation(
-      Animation::ScrollOffset)->curve()->Duration();
-
+  double duration_in_seconds =
+      controller_impl->GetAnimation(Animation::ScrollOffset)
+          ->curve()
+          ->Duration();
+  TimeDelta duration = TimeDelta::FromMicroseconds(
+      duration_in_seconds * base::Time::kMicrosecondsPerSecond);
   EXPECT_EQ(
-      duration,
+      duration_in_seconds,
       controller->GetAnimation(Animation::ScrollOffset)->curve()->Duration());
 
   controller->Animate(kInitialTickTime);
@@ -685,12 +703,12 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransition) {
   EXPECT_FALSE(event);
 
   controller->NotifyAnimationStarted((*events)[0]);
-  controller->Animate(kInitialTickTime + duration/2.0);
+  controller->Animate(kInitialTickTime + duration / 2);
   controller->UpdateState(true, NULL);
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(200.f, 250.f), dummy.scroll_offset());
 
-  controller_impl->Animate(kInitialTickTime + duration/2.0);
+  controller_impl->Animate(kInitialTickTime + duration / 2);
   controller_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(200.f, 250.f),
                       dummy_impl.scroll_offset());
@@ -743,11 +761,12 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionNoImplProvider) {
   controller->PushAnimationUpdatesTo(controller_impl.get());
   controller_impl->ActivateAnimations();
   EXPECT_TRUE(controller_impl->GetAnimation(Animation::ScrollOffset));
-  double duration = controller_impl->GetAnimation(
-      Animation::ScrollOffset)->curve()->Duration();
-
+  double duration_in_seconds =
+      controller_impl->GetAnimation(Animation::ScrollOffset)
+          ->curve()
+          ->Duration();
   EXPECT_EQ(
-      duration,
+      duration_in_seconds,
       controller->GetAnimation(Animation::ScrollOffset)->curve()->Duration());
 
   controller->Animate(kInitialTickTime);
@@ -763,13 +782,16 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionNoImplProvider) {
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
+  TimeDelta duration = TimeDelta::FromMicroseconds(
+      duration_in_seconds * base::Time::kMicrosecondsPerSecond);
+
   controller->NotifyAnimationStarted((*events)[0]);
-  controller->Animate(kInitialTickTime + duration/2.0);
+  controller->Animate(kInitialTickTime + duration / 2);
   controller->UpdateState(true, NULL);
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(400.f, 150.f), dummy.scroll_offset());
 
-  controller_impl->Animate(kInitialTickTime + duration/2.0);
+  controller_impl->Animate(kInitialTickTime + duration / 2);
   controller_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(400.f, 150.f),
                       dummy_impl.scroll_offset());
@@ -804,7 +826,7 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionOnImplOnly) {
           target_value,
           EaseInOutTimingFunction::Create().Pass()));
   curve->SetInitialValue(initial_value);
-  double duration = curve->Duration();
+  double duration_in_seconds = curve->Duration();
 
   scoped_ptr<Animation> animation(Animation::Create(
       curve.PassAs<AnimationCurve>(), 1, 0, Animation::ScrollOffset));
@@ -819,7 +841,10 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionOnImplOnly) {
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  controller_impl->Animate(kInitialTickTime + duration/2.0);
+  TimeDelta duration = TimeDelta::FromMicroseconds(
+      duration_in_seconds * base::Time::kMicrosecondsPerSecond);
+
+  controller_impl->Animate(kInitialTickTime + duration / 2);
   controller_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(200.f, 250.f),
                       dummy_impl.scroll_offset());
@@ -841,13 +866,13 @@ class FakeAnimationDelegate : public AnimationDelegate {
         finished_(false) {}
 
   virtual void NotifyAnimationStarted(
-      base::TimeTicks monotonic_time,
+      TimeTicks monotonic_time,
       Animation::TargetProperty target_property) OVERRIDE {
     started_ = true;
   }
 
   virtual void NotifyAnimationFinished(
-      base::TimeTicks monotonic_time,
+      TimeTicks monotonic_time,
       Animation::TargetProperty target_property) OVERRIDE {
     finished_ = true;
   }
@@ -902,7 +927,8 @@ TEST(LayerAnimationControllerTest,
   EXPECT_TRUE(delegate.started());
 
   events.reset(new AnimationEventsVector);
-  controller_impl->Animate(kInitialTickTime + 1.0);
+  controller_impl->Animate(kInitialTickTime +
+                           TimeDelta::FromMilliseconds(1000));
   controller_impl->UpdateState(true, events.get());
 
   // We should receive 2 events (a finished notification and a property update).
@@ -943,19 +969,23 @@ TEST(LayerAnimationControllerTest,
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 2.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
 
   // Send the synchronized start time.
-  controller->NotifyAnimationStarted(AnimationEvent(
-      AnimationEvent::Started, 0, 1, Animation::Opacity, kInitialTickTime + 2));
-  controller->Animate(kInitialTickTime + 5.0);
+  controller->NotifyAnimationStarted(
+      AnimationEvent(AnimationEvent::Started,
+                     0,
+                     1,
+                     Animation::Opacity,
+                     kInitialTickTime + TimeDelta::FromMilliseconds(2000)));
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(5000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1.f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -992,15 +1022,15 @@ TEST(LayerAnimationControllerTest, TrivialQueuing) {
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.0);
 
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   EXPECT_TRUE(controller->needs_to_start_animations_for_testing());
   controller->UpdateState(true, events.get());
   EXPECT_FALSE(controller->needs_to_start_animations_for_testing());
 
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(1.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 2.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0.5f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -1033,11 +1063,11 @@ TEST(LayerAnimationControllerTest, Interrupt) {
 
   // Since the previous animation was aborted, the new animation should start
   // right in this call to animate.
-  controller->Animate(kInitialTickTime + 0.5);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(1.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.5);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1500));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0.5f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -1070,13 +1100,13 @@ TEST(LayerAnimationControllerTest, ScheduleTogetherWhenAPropertyIsBlocked) {
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0.f, dummy.opacity());
   EXPECT_TRUE(controller->HasActiveAnimation());
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, events.get());
   // Should not have started the float transition yet.
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
   // The float animation should have started at time 1 and should be done.
-  controller->Animate(kInitialTickTime + 2.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1.f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -1115,7 +1145,7 @@ TEST(LayerAnimationControllerTest, ScheduleTogetherWithAnAnimWaiting) {
   // The opacity animation should have finished at time 1, but the group
   // of animations with id 1 don't finish until time 2 because of the length
   // of the transform animation.
-  controller->Animate(kInitialTickTime + 2.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   controller->UpdateState(true, events.get());
   // Should not have started the float transition yet.
   EXPECT_TRUE(controller->HasActiveAnimation());
@@ -1123,7 +1153,7 @@ TEST(LayerAnimationControllerTest, ScheduleTogetherWithAnAnimWaiting) {
 
   // The second opacity animation should start at time 2 and should be done by
   // time 3.
-  controller->Animate(kInitialTickTime + 3.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0.5f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -1149,29 +1179,29 @@ TEST(LayerAnimationControllerTest, TrivialLooping) {
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.25);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1250));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.25f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.75);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1750));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 2.25);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2250));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.25f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 2.75);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2750));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 3.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
   controller->UpdateState(true, events.get());
   EXPECT_FALSE(controller->HasActiveAnimation());
   EXPECT_EQ(1.f, dummy.opacity());
 
   // Just be extra sure.
-  controller->Animate(kInitialTickTime + 4.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(4000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1.f, dummy.opacity());
 }
@@ -1197,27 +1227,29 @@ TEST(LayerAnimationControllerTest, InfiniteLooping) {
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.25);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1250));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.25f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.75);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1750));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
 
-  controller->Animate(kInitialTickTime + 1073741824.25);
+  controller->Animate(kInitialTickTime +
+                      TimeDelta::FromMilliseconds(1073741824250));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.25f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1073741824.75);
+  controller->Animate(kInitialTickTime +
+                      TimeDelta::FromMilliseconds(1073741824750));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
 
   EXPECT_TRUE(controller->GetAnimation(id, Animation::Opacity));
   controller->GetAnimation(id, Animation::Opacity)->SetRunState(
-      Animation::Aborted, kInitialTickTime + 0.75);
+      Animation::Aborted, kInitialTickTime + TimeDelta::FromMilliseconds(750));
   EXPECT_FALSE(controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
 }
@@ -1241,29 +1273,30 @@ TEST(LayerAnimationControllerTest, PauseResume) {
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 0.5);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.5f, dummy.opacity());
 
   EXPECT_TRUE(controller->GetAnimation(id, Animation::Opacity));
   controller->GetAnimation(id, Animation::Opacity)->SetRunState(
-      Animation::Paused, kInitialTickTime + 0.5);
+      Animation::Paused, kInitialTickTime + TimeDelta::FromMilliseconds(500));
 
-  controller->Animate(kInitialTickTime + 1024.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1024000));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.5f, dummy.opacity());
 
   EXPECT_TRUE(controller->GetAnimation(id, Animation::Opacity));
-  controller->GetAnimation(id, Animation::Opacity)->SetRunState(
-      Animation::Running, kInitialTickTime + 1024);
-
-  controller->Animate(kInitialTickTime + 1024.25);
+  controller->GetAnimation(id, Animation::Opacity)
+      ->SetRunState(Animation::Running,
+                    kInitialTickTime + TimeDelta::FromMilliseconds(1024000));
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1024250));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1024.5);
+
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1024500));
   controller->UpdateState(true, events.get());
   EXPECT_FALSE(controller->HasActiveAnimation());
   EXPECT_EQ(1.f, dummy.opacity());
@@ -1296,19 +1329,19 @@ TEST(LayerAnimationControllerTest, AbortAGroupedAnimation) {
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.5f, dummy.opacity());
 
   EXPECT_TRUE(controller->GetAnimation(id, Animation::Opacity));
   controller->GetAnimation(id, Animation::Opacity)->SetRunState(
-      Animation::Aborted, kInitialTickTime + 1.0);
-  controller->Animate(kInitialTickTime + 1.0);
+      Animation::Aborted, kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(1.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 2.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(!controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
@@ -1372,9 +1405,9 @@ TEST(LayerAnimationControllerTest, SkipUpdateState) {
       Animation::Opacity));
 
   // Animate but don't UpdateState.
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
 
-  controller->Animate(kInitialTickTime + 2.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   events.reset(new AnimationEventsVector);
   controller->UpdateState(true, events.get());
 
@@ -1386,7 +1419,7 @@ TEST(LayerAnimationControllerTest, SkipUpdateState) {
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
 
-  controller->Animate(kInitialTickTime + 3.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
   controller->UpdateState(true, events.get());
 
   // The float tranisition should now be done.
@@ -1423,7 +1456,7 @@ TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {
   // With only a pending observer, the animation should progress to the
   // Starting state and get ticked at its starting point, but should not
   // progress to Running.
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0u, events->size());
   EXPECT_EQ(Animation::Starting,
@@ -1432,7 +1465,7 @@ TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {
 
   // Even when already in the Starting state, the animation should stay
   // there, and shouldn't be ticked past its starting point.
-  controller->Animate(kInitialTickTime + 2.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0u, events->size());
   EXPECT_EQ(Animation::Starting,
@@ -1443,7 +1476,7 @@ TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {
 
   // Now that an active observer has been added, the animation should still
   // initially tick at its starting point, but should now progress to Running.
-  controller->Animate(kInitialTickTime + 3.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1u, events->size());
   EXPECT_EQ(Animation::Running,
@@ -1452,7 +1485,7 @@ TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {
   EXPECT_EQ(0.5f, dummy.opacity());
 
   // The animation should now tick past its starting point.
-  controller->Animate(kInitialTickTime + 3.5);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3500));
   EXPECT_NE(0.5f, pending_dummy.opacity());
   EXPECT_NE(0.5f, dummy.opacity());
 }
@@ -1497,7 +1530,7 @@ TEST(LayerAnimationControllerTest, TransformAnimationBounds) {
             bounds.ToString());
 
   controller_impl->GetAnimation(1, Animation::Transform)
-      ->SetRunState(Animation::Finished, 0.0);
+      ->SetRunState(Animation::Finished, TicksFromSecondsF(0.0));
 
   // Only the unfinished animation should affect the animated bounds.
   EXPECT_TRUE(controller_impl->TransformAnimationBoundsForBox(box, &bounds));
@@ -1505,7 +1538,7 @@ TEST(LayerAnimationControllerTest, TransformAnimationBounds) {
             bounds.ToString());
 
   controller_impl->GetAnimation(2, Animation::Transform)
-      ->SetRunState(Animation::Finished, 0.0);
+      ->SetRunState(Animation::Finished, TicksFromSecondsF(0.0));
 
   // There are no longer any running animations.
   EXPECT_FALSE(controller_impl->HasTransformAnimationThatInflatesBounds());
@@ -1560,7 +1593,7 @@ TEST(LayerAnimationControllerTest, AbortAnimations) {
 
   controller->Animate(kInitialTickTime);
   controller->UpdateState(true, NULL);
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   controller->UpdateState(true, NULL);
 
   EXPECT_EQ(Animation::Finished,
@@ -1662,7 +1695,7 @@ TEST(LayerAnimationControllerTest, ImplThreadAbortedAnimationGetsDeleted) {
   EXPECT_EQ(Animation::Aborted,
             controller->GetAnimation(Animation::Opacity)->run_state());
 
-  controller->Animate(kInitialTickTime + 0.5);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller->UpdateState(true, NULL);
   EXPECT_TRUE(dummy.animation_waiting_for_deletion());
   EXPECT_EQ(Animation::WaitingForDeletion,
@@ -1703,7 +1736,8 @@ TEST(LayerAnimationControllerTest, FinishedEventsForGroup) {
   EXPECT_EQ(AnimationEvent::Started, (*events)[1].type);
 
   events.reset(new AnimationEventsVector);
-  controller_impl->Animate(kInitialTickTime + 1.0);
+  controller_impl->Animate(kInitialTickTime +
+                           TimeDelta::FromMilliseconds(1000));
   controller_impl->UpdateState(true, events.get());
 
   // The opacity animation should be finished, but should not have generated
@@ -1715,7 +1749,8 @@ TEST(LayerAnimationControllerTest, FinishedEventsForGroup) {
             controller_impl->GetAnimation(1,
                                           Animation::Transform)->run_state());
 
-  controller_impl->Animate(kInitialTickTime + 2.0);
+  controller_impl->Animate(kInitialTickTime +
+                           TimeDelta::FromMilliseconds(2000));
   controller_impl->UpdateState(true, events.get());
 
   // Both animations should have generated Finished events.
@@ -1756,7 +1791,8 @@ TEST(LayerAnimationControllerTest, FinishedAndAbortedEventsForGroup) {
   controller_impl->AbortAnimations(Animation::Opacity);
 
   events.reset(new AnimationEventsVector);
-  controller_impl->Animate(kInitialTickTime + 1.0);
+  controller_impl->Animate(kInitialTickTime +
+                           TimeDelta::FromMilliseconds(1000));
   controller_impl->UpdateState(true, events.get());
 
   // We should have exactly 2 events: a Finished event for the tranform
@@ -1816,7 +1852,7 @@ TEST(LayerAnimationControllerTest, HasAnimationThatAffectsScale) {
   EXPECT_TRUE(controller_impl->HasAnimationThatAffectsScale());
 
   controller_impl->GetAnimation(3, Animation::Transform)
-      ->SetRunState(Animation::Finished, 0.0);
+      ->SetRunState(Animation::Finished, TicksFromSecondsF(0.0));
 
   // Only unfinished animations should be considered by
   // HasAnimationThatAffectsScale.
@@ -1872,7 +1908,7 @@ TEST(LayerAnimationControllerTest, HasOnlyTranslationTransforms) {
   EXPECT_FALSE(controller_impl->HasOnlyTranslationTransforms());
 
   controller_impl->GetAnimation(3, Animation::Transform)
-      ->SetRunState(Animation::Finished, 0.0);
+      ->SetRunState(Animation::Finished, TicksFromSecondsF(0.0));
 
   // Only unfinished animations should be considered by
   // HasOnlyTranslationTransforms.
@@ -1938,9 +1974,9 @@ TEST(LayerAnimationControllerTest, MaximumScale) {
   EXPECT_FALSE(controller_impl->MaximumScale(&max_scale));
 
   controller_impl->GetAnimation(3, Animation::Transform)
-      ->SetRunState(Animation::Finished, 0.0);
+      ->SetRunState(Animation::Finished, TicksFromSecondsF(0.0));
   controller_impl->GetAnimation(2, Animation::Transform)
-      ->SetRunState(Animation::Finished, 0.0);
+      ->SetRunState(Animation::Finished, TicksFromSecondsF(0.0));
 
   // Only unfinished animations should be considered by
   // MaximumScale.
@@ -2001,7 +2037,8 @@ TEST(LayerAnimationControllerTest, NewlyPushedAnimationWaitsForActivation) {
   EXPECT_TRUE(controller_impl->GetAnimation(group_id, Animation::Opacity)
                   ->affects_active_observers());
 
-  controller_impl->Animate(kInitialTickTime + 1.0);
+  controller_impl->Animate(kInitialTickTime +
+                           TimeDelta::FromMilliseconds(1000));
   controller_impl->UpdateState(true, events.get());
 
   // Since the animation has been activated, it should have reached the
@@ -2062,7 +2099,7 @@ TEST(LayerAnimationControllerTest, ActivationBetweenAnimateAndUpdateState) {
       Animation::Running,
       controller_impl->GetAnimation(group_id, Animation::Opacity)->run_state());
 
-  controller_impl->Animate(kInitialTickTime + 0.5);
+  controller_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
 
   // Both observers should have been ticked.
   EXPECT_EQ(0.75f, pending_dummy_impl.opacity());
@@ -2112,7 +2149,7 @@ TEST(LayerAnimationControllerTest, PushedDeletedAnimationWaitsForActivation) {
   EXPECT_TRUE(controller_impl->GetAnimation(group_id, Animation::Opacity)
                   ->affects_active_observers());
 
-  controller_impl->Animate(kInitialTickTime + 0.5);
+  controller_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller_impl->UpdateState(true, events.get());
 
   // Only the active observer should have been ticked.
@@ -2174,7 +2211,7 @@ TEST(LayerAnimationControllerTest, StartAnimationsAffectingDifferentObservers) {
                                              Animation::Opacity)
                    ->affects_active_observers());
 
-  controller_impl->Animate(kInitialTickTime + 0.5);
+  controller_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   controller_impl->UpdateState(true, events.get());
 
   // The original animation should still be running, and the new animation
@@ -2204,7 +2241,8 @@ TEST(LayerAnimationControllerTest, StartAnimationsAffectingDifferentObservers) {
                                             Animation::Opacity)
                   ->affects_active_observers());
 
-  controller_impl->Animate(kInitialTickTime + 1.0);
+  controller_impl->Animate(kInitialTickTime +
+                           TimeDelta::FromMilliseconds(1000));
   controller_impl->UpdateState(true, events.get());
 
   // The new animation should be running, and the active observer should have
diff --git a/cc/animation/scroll_offset_animation_curve.cc b/cc/animation/scroll_offset_animation_curve.cc
index ecba43f..a7283b8 100644
--- a/cc/animation/scroll_offset_animation_curve.cc
+++ b/cc/animation/scroll_offset_animation_curve.cc
@@ -25,9 +25,8 @@ scoped_ptr<ScrollOffsetAnimationCurve> ScrollOffsetAnimationCurve::Create(
 ScrollOffsetAnimationCurve::ScrollOffsetAnimationCurve(
     const gfx::Vector2dF& target_value,
     scoped_ptr<TimingFunction> timing_function)
-    : target_value_(target_value),
-      duration_(0.0),
-      timing_function_(timing_function.Pass()) {}
+    : target_value_(target_value), timing_function_(timing_function.Pass()) {
+}
 
 ScrollOffsetAnimationCurve::~ScrollOffsetAnimationCurve() {}
 
@@ -43,17 +42,21 @@ void ScrollOffsetAnimationCurve::SetInitialValue(
   float delta_x = std::abs(target_value_.x() - initial_value_.x());
   float delta_y = std::abs(target_value_.y() - initial_value_.y());
   float max_delta = std::max(delta_x, delta_y);
-  duration_ = std::sqrt(max_delta)/kDurationDivisor;
+  duration_ = base::TimeDelta::FromMicroseconds(
+      (std::sqrt(max_delta) / kDurationDivisor) *
+      base::Time::kMicrosecondsPerSecond);
 }
 
 gfx::Vector2dF ScrollOffsetAnimationCurve::GetValue(double t) const {
+  double duration = duration_.InSecondsF();
+
   if (t <= 0)
     return initial_value_;
 
-  if (t >= duration_)
+  if (t >= duration)
     return target_value_;
 
-  double progress = timing_function_->GetValue(t / duration_);
+  double progress = (timing_function_->GetValue(t / duration));
   return gfx::Vector2dF(gfx::Tween::FloatValueBetween(
                             progress, initial_value_.x(), target_value_.x()),
                         gfx::Tween::FloatValueBetween(
@@ -61,7 +64,7 @@ gfx::Vector2dF ScrollOffsetAnimationCurve::GetValue(double t) const {
 }
 
 double ScrollOffsetAnimationCurve::Duration() const {
-  return duration_;
+  return duration_.InSecondsF();
 }
 
 AnimationCurve::CurveType ScrollOffsetAnimationCurve::Type() const {
diff --git a/cc/animation/scroll_offset_animation_curve.h b/cc/animation/scroll_offset_animation_curve.h
index 0d45cf2..543ae37 100644
--- a/cc/animation/scroll_offset_animation_curve.h
+++ b/cc/animation/scroll_offset_animation_curve.h
@@ -6,6 +6,7 @@
 #define CC_ANIMATION_SCROLL_OFFSET_ANIMATION_CURVE_H_
 
 #include "base/memory/scoped_ptr.h"
+#include "base/time/time.h"
 #include "cc/animation/animation_curve.h"
 #include "cc/base/cc_export.h"
 
@@ -35,7 +36,7 @@ class CC_EXPORT ScrollOffsetAnimationCurve : public AnimationCurve {
 
   gfx::Vector2dF initial_value_;
   gfx::Vector2dF target_value_;
-  double duration_;
+  base::TimeDelta duration_;
 
   scoped_ptr<TimingFunction> timing_function_;
 
diff --git a/cc/input/page_scale_animation.cc b/cc/input/page_scale_animation.cc
index 7df0244..23bf21b 100644
--- a/cc/input/page_scale_animation.cc
+++ b/cc/input/page_scale_animation.cc
@@ -40,6 +40,9 @@ gfx::Vector2dF InterpolateBetween(const gfx::Vector2dF& start,
 
 namespace cc {
 
+using base::TimeTicks;
+using base::TimeDelta;
+
 scoped_ptr<PageScaleAnimation> PageScaleAnimation::Create(
     const gfx::Vector2dF& start_scroll_offset,
     float start_page_scale_factor,
@@ -66,9 +69,8 @@ PageScaleAnimation::PageScaleAnimation(
       target_anchor_(),
       viewport_size_(viewport_size),
       root_layer_size_(root_layer_size),
-      start_time_(-1.0),
-      duration_(0.0),
-      timing_function_(timing_function.Pass()) {}
+      timing_function_(timing_function.Pass()) {
+}
 
 PageScaleAnimation::~PageScaleAnimation() {}
 
@@ -78,7 +80,7 @@ void PageScaleAnimation::ZoomTo(const gfx::Vector2dF& target_scroll_offset,
   target_page_scale_factor_ = target_page_scale_factor;
   target_scroll_offset_ = target_scroll_offset;
   ClampTargetScrollOffset();
-  duration_ = duration;
+  duration_ = TimeDelta::FromSecondsD(duration);
 
   if (start_page_scale_factor_ == target_page_scale_factor) {
     start_anchor_ = start_scroll_offset_;
@@ -97,7 +99,7 @@ void PageScaleAnimation::ZoomWithAnchor(const gfx::Vector2dF& anchor,
                                         double duration) {
   start_anchor_ = anchor;
   target_page_scale_factor_ = target_page_scale_factor;
-  duration_ = duration;
+  duration_ = TimeDelta::FromSecondsD(duration);
 
   // We start zooming out from the anchor tapped by the user. But if
   // the target scale is impossible to attain without hitting the root layer
@@ -163,36 +165,37 @@ gfx::SizeF PageScaleAnimation::ViewportSizeAt(float interp) const {
 }
 
 bool PageScaleAnimation::IsAnimationStarted() const {
-  return start_time_ >= 0;
+  return start_time_ > base::TimeTicks();
 }
 
-void PageScaleAnimation::StartAnimation(double time) {
-  DCHECK_GT(0, start_time_);
+void PageScaleAnimation::StartAnimation(base::TimeTicks time) {
+  DCHECK(start_time_.is_null());
   start_time_ = time;
 }
 
-gfx::Vector2dF PageScaleAnimation::ScrollOffsetAtTime(double time) const {
-  DCHECK_GE(start_time_, 0);
+gfx::Vector2dF PageScaleAnimation::ScrollOffsetAtTime(
+    base::TimeTicks time) const {
+  DCHECK(!start_time_.is_null());
   return ScrollOffsetAt(InterpAtTime(time));
 }
 
-float PageScaleAnimation::PageScaleFactorAtTime(double time) const {
-  DCHECK_GE(start_time_, 0);
+float PageScaleAnimation::PageScaleFactorAtTime(base::TimeTicks time) const {
+  DCHECK(!start_time_.is_null());
   return PageScaleFactorAt(InterpAtTime(time));
 }
 
-bool PageScaleAnimation::IsAnimationCompleteAtTime(double time) const {
-  DCHECK_GE(start_time_, 0);
+bool PageScaleAnimation::IsAnimationCompleteAtTime(base::TimeTicks time) const {
+  DCHECK(!start_time_.is_null());
   return time >= end_time();
 }
 
-float PageScaleAnimation::InterpAtTime(double time) const {
-  DCHECK_GE(start_time_, 0);
-  DCHECK_GE(time, start_time_);
-  if (IsAnimationCompleteAtTime(time))
+float PageScaleAnimation::InterpAtTime(base::TimeTicks monotonic_time) const {
+  DCHECK(!start_time_.is_null());
+  DCHECK(monotonic_time >= start_time_);
+  if (IsAnimationCompleteAtTime(monotonic_time))
     return 1.f;
-
-  const double normalized_time = (time - start_time_) / duration_;
+  const double normalized_time =
+      (monotonic_time - start_time_).InSecondsF() / duration_.InSecondsF();
   return timing_function_->GetValue(normalized_time);
 }
 
diff --git a/cc/input/page_scale_animation.h b/cc/input/page_scale_animation.h
index c7856e1..c997c56 100644
--- a/cc/input/page_scale_animation.h
+++ b/cc/input/page_scale_animation.h
@@ -7,10 +7,12 @@
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/time/time.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/vector2d_f.h"
 
 namespace cc {
+
 class TimingFunction;
 
 // A small helper class that does the math for zoom animations, primarily for
@@ -52,19 +54,19 @@ class PageScaleAnimation {
   // These should be called before the first frame of animation to initialize
   // the start time. StartAnimation should only be called once after creation.
   bool IsAnimationStarted() const;
-  void StartAnimation(double time);
+  void StartAnimation(base::TimeTicks time);
 
   // Call these functions while the animation is in progress to output the
   // current state.
-  gfx::Vector2dF ScrollOffsetAtTime(double time) const;
-  float PageScaleFactorAtTime(double time) const;
-  bool IsAnimationCompleteAtTime(double time) const;
+  gfx::Vector2dF ScrollOffsetAtTime(base::TimeTicks time) const;
+  float PageScaleFactorAtTime(base::TimeTicks time) const;
+  bool IsAnimationCompleteAtTime(base::TimeTicks time) const;
 
   // The following methods return state which is invariant throughout the
   // course of the animation.
-  double start_time() const { return start_time_; }
-  double duration() const { return duration_; }
-  double end_time() const { return start_time_ + duration_; }
+  base::TimeTicks start_time() const { return start_time_; }
+  base::TimeDelta duration() const { return duration_; }
+  base::TimeTicks end_time() const { return start_time_ + duration_; }
   gfx::Vector2dF target_scroll_offset() const { return target_scroll_offset_; }
   float target_page_scale_factor() const { return target_page_scale_factor_; }
 
@@ -82,7 +84,7 @@ class PageScaleAnimation {
 
   gfx::SizeF StartViewportSize() const;
   gfx::SizeF TargetViewportSize() const;
-  float InterpAtTime(double time) const;
+  float InterpAtTime(base::TimeTicks time) const;
   gfx::SizeF ViewportSizeAt(float interp) const;
   gfx::Vector2dF ScrollOffsetAt(float interp) const;
   gfx::Vector2dF AnchorAt(float interp) const;
@@ -100,8 +102,8 @@ class PageScaleAnimation {
   gfx::SizeF viewport_size_;
   gfx::SizeF root_layer_size_;
 
-  double start_time_;
-  double duration_;
+  base::TimeTicks start_time_;
+  base::TimeDelta duration_;
 
   scoped_ptr<TimingFunction> timing_function_;
 
diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index b746798..91664fa 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -10,6 +10,7 @@
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
+#include "base/time/time.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/keyframed_animation_curve.h"
@@ -1119,7 +1120,8 @@ bool Layer::AddAnimation(scoped_ptr <Animation> animation) {
 }
 
 void Layer::PauseAnimation(int animation_id, double time_offset) {
-  layer_animation_controller_->PauseAnimation(animation_id, time_offset);
+  layer_animation_controller_->PauseAnimation(
+      animation_id, base::TimeDelta::FromSecondsD(time_offset));
   SetNeedsCommit();
 }
 
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index d9cab33..e284014 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -1150,15 +1150,13 @@ scoped_ptr<base::Value> LayerTreeHost::AsValue() const {
   return state.PassAs<base::Value>();
 }
 
-void LayerTreeHost::AnimateLayers(base::TimeTicks time) {
+void LayerTreeHost::AnimateLayers(base::TimeTicks monotonic_time) {
   if (!settings_.accelerated_animation_enabled ||
       animation_registrar_->active_animation_controllers().empty())
     return;
 
   TRACE_EVENT0("cc", "LayerTreeHost::AnimateLayers");
 
-  double monotonic_time = (time - base::TimeTicks()).InSecondsF();
-
   AnimationRegistrar::AnimationControllerMap copy =
       animation_registrar_->active_animation_controllers();
   for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 4a846ec..b51d6f9 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -2770,26 +2770,21 @@ void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks monotonic_time) {
   if (!page_scale_animation_)
     return;
 
-  // TODO(ajuma): http://crbug.com/178171 - Animations use double for monotonic
-  // time.
-  double monotonic_time_for_cc_animations =
-      (monotonic_time - base::TimeTicks()).InSecondsF();
   gfx::Vector2dF scroll_total = active_tree_->TotalScrollOffset();
 
   if (!page_scale_animation_->IsAnimationStarted())
-    page_scale_animation_->StartAnimation(monotonic_time_for_cc_animations);
+    page_scale_animation_->StartAnimation(monotonic_time);
 
-  active_tree_->SetPageScaleDelta(page_scale_animation_->PageScaleFactorAtTime(
-                                      monotonic_time_for_cc_animations) /
-                                  active_tree_->page_scale_factor());
-  gfx::Vector2dF next_scroll = page_scale_animation_->ScrollOffsetAtTime(
-      monotonic_time_for_cc_animations);
+  active_tree_->SetPageScaleDelta(
+      page_scale_animation_->PageScaleFactorAtTime(monotonic_time) /
+      active_tree_->page_scale_factor());
+  gfx::Vector2dF next_scroll =
+      page_scale_animation_->ScrollOffsetAtTime(monotonic_time);
 
   ScrollViewportBy(next_scroll - scroll_total);
   SetNeedsRedraw();
 
-  if (page_scale_animation_->IsAnimationCompleteAtTime(
-          monotonic_time_for_cc_animations)) {
+  if (page_scale_animation_->IsAnimationCompleteAtTime(monotonic_time)) {
     page_scale_animation_.reset();
     client_->SetNeedsCommitOnImplThread();
     client_->RenewTreePriority();
@@ -2819,17 +2814,12 @@ void LayerTreeHostImpl::AnimateLayers(base::TimeTicks monotonic_time) {
     return;
 
   TRACE_EVENT0("cc", "LayerTreeHostImpl::AnimateLayers");
-
-  // TODO(ajuma): http://crbug.com/178171 - Animations use double for monotonic
-  // time.
-  double monotonic_time_for_cc_animations =
-      (monotonic_time - base::TimeTicks()).InSecondsF();
   AnimationRegistrar::AnimationControllerMap copy =
       animation_registrar_->active_animation_controllers();
   for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
        iter != copy.end();
        ++iter)
-    (*iter).second->Animate(monotonic_time_for_cc_animations);
+    (*iter).second->Animate(monotonic_time);
 
   SetNeedsAnimate();
 }
diff --git a/cc/trees/layer_tree_host_unittest_animation.cc b/cc/trees/layer_tree_host_unittest_animation.cc
index 8e11556..9e02822 100644
--- a/cc/trees/layer_tree_host_unittest_animation.cc
+++ b/cc/trees/layer_tree_host_unittest_animation.cc
@@ -568,7 +568,8 @@ class LayerTreeHostAnimationTestSynchronizeAnimationStartTimes
         layer_animation_controller();
     Animation* animation =
         controller->GetAnimation(Animation::Opacity);
-    main_start_time_ = animation->start_time();
+    main_start_time_ =
+        (animation->start_time() - base::TimeTicks()).InSecondsF();
     controller->RemoveAnimation(animation->id());
 
     if (impl_start_time_ > 0.0)
@@ -586,7 +587,8 @@ class LayerTreeHostAnimationTestSynchronizeAnimationStartTimes
     if (!animation)
       return;
 
-    impl_start_time_ = animation->start_time();
+    impl_start_time_ =
+        (animation->start_time() - base::TimeTicks()).InSecondsF();
     controller->RemoveAnimation(animation->id());
 
     if (main_start_time_ > 0.0)
@@ -1367,10 +1369,10 @@ class LayerTreeHostAnimationTestAddAnimationAfterAnimating
         int id = ((*iter).second->id());
         if (id == host_impl->RootLayer()->id()) {
           Animation* anim = (*iter).second->GetAnimation(Animation::Transform);
-          EXPECT_GT(anim->start_time(), 0);
+          EXPECT_GT((anim->start_time() - base::TimeTicks()).InSecondsF(), 0);
         } else if (id == host_impl->RootLayer()->children()[0]->id()) {
           Animation* anim = (*iter).second->GetAnimation(Animation::Opacity);
-          EXPECT_GT(anim->start_time(), 0);
+          EXPECT_GT((anim->start_time() - base::TimeTicks()).InSecondsF(), 0);
         }
       }
     }