CC::Animations should use TimeTicks & TimeDelta to represent time

cc/animation/layer_animation_controller_unittest.cc

Index: cc/animation/layer_animation_controller_unittest.cc
diff --git a/cc/animation/layer_animation_controller_unittest.cc b/cc/animation/layer_animation_controller_unittest.cc
index 4dca3f625689d6d0d45257cc4537b710237264c9..38a9691ac0810d924850b0e451b6cacd43d34a78 100644
--- a/cc/animation/layer_animation_controller_unittest.cc
+++ b/cc/animation/layer_animation_controller_unittest.cc
@@ -24,6 +24,10 @@ namespace {
 // with start time 0.0 is treated as an animation whose start time has
 // not yet been set.
 const double kInitialTickTime = 1.0;

[danakj, 2014/04/09 16:33:03]

why not change this to a TimeTicks?

we should avoid doing double->timeticks all over the unit tests and just work
with timeticks instead?

[ajuma, 2014/04/09 17:37:39]

+1, please change this to TimeTicks. Note that we disallow static initializers
for non-POD types (at least in non-test code; not sure about the rule in test
code), so you'll need a function that returns a TimeTicks (e.g. base::TimeTicks
InitialTickTime()) rather than just a static TimeTicks. 

[Sikugu_, 2014/04/10 14:04:57]

Done.

[Sikugu_, 2014/04/10 14:04:57]

Few calls of animation functions still use double.
Will take care of this as part of the Animation Changes.

+base::TimeTicks GetTimeTicks(double time) {

[danakj, 2014/04/09 16:33:03]

blank line above method definition.

[Sikugu_, 2014/04/10 14:04:57]

Done.

+  return base::TimeTicks::FromInternalValue(time *
+                                            base::Time::kMicrosecondsPerSecond);
+}
 
 scoped_ptr<Animation> CreateAnimation(scoped_ptr<AnimationCurve> curve,
                                       int id,
@@ -79,7 +83,7 @@ TEST(LayerAnimationControllerTest, DoNotClobberStartTimes) {
                                           Animation::Opacity)->run_state());
 
   AnimationEventsVector events;
-  controller_impl->Animate(kInitialTickTime);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime));
   controller_impl->UpdateState(true, &events);
 
   // Synchronize the start times.
@@ -91,7 +95,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(GetTimeTicks(kInitialTickTime + 0.5));
   controller->UpdateState(true, NULL);
   EXPECT_EQ(controller->GetAnimation(group_id,
                                      Animation::Opacity)->start_time(),
@@ -123,7 +127,7 @@ TEST(LayerAnimationControllerTest, UseSpecifiedStartTimes) {
                                           Animation::Opacity)->run_state());
 
   AnimationEventsVector events;
-  controller_impl->Animate(kInitialTickTime);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime));
   controller_impl->UpdateState(true, &events);
 
   // Synchronize the start times.
@@ -139,7 +143,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(GetTimeTicks(kInitialTickTime + 0.5));

[ajuma, 2014/04/09 17:37:39]

Offsets (like 0.5 above) should be TimeDeltas.

[Sikugu_, 2014/04/10 14:04:57]

Done.

   controller->UpdateState(true, NULL);
   EXPECT_EQ(start_time,
             controller->GetAnimation(group_id,
@@ -184,7 +188,7 @@ TEST(LayerAnimationControllerTest, Activation) {
   EXPECT_EQ(1u, registrar->active_animation_controllers().size());
   EXPECT_EQ(1u, registrar_impl->active_animation_controllers().size());
 
-  controller_impl->Animate(kInitialTickTime);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime));
   controller_impl->UpdateState(true, events.get());
   EXPECT_EQ(1u, events->size());
   controller->NotifyAnimationStarted((*events)[0]);
@@ -192,18 +196,18 @@ 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(GetTimeTicks(kInitialTickTime + 0.5));
   controller->UpdateState(true, NULL);
   EXPECT_EQ(1u, registrar->active_animation_controllers().size());
 
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.0));
   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(GetTimeTicks(kInitialTickTime + 1.5));
   controller_impl->UpdateState(true, events.get());
 
   EXPECT_EQ(Animation::WaitingForDeletion,
@@ -213,7 +217,7 @@ TEST(LayerAnimationControllerTest, Activation) {
 
   EXPECT_EQ(1u, events->size());
   controller->NotifyAnimationFinished((*events)[0]);
-  controller->Animate(kInitialTickTime + 1.5);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.5));
   controller->UpdateState(true, NULL);
 
   EXPECT_EQ(Animation::WaitingForDeletion,
@@ -256,9 +260,9 @@ TEST(LayerAnimationControllerTest, SyncPause) {
 
   // Start the animations on each controller.
   AnimationEventsVector events;
-  controller_impl->Animate(kInitialTickTime);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime));
   controller_impl->UpdateState(true, &events);
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, NULL);
   EXPECT_EQ(Animation::Running,
             controller_impl->GetAnimation(group_id,
@@ -268,7 +272,8 @@ TEST(LayerAnimationControllerTest, SyncPause) {
                                      Animation::Opacity)->run_state());
 
   // Pause the main-thread animation.
-  controller->PauseAnimation(animation_id, kInitialTickTime + 1.0);
+  controller->PauseAnimation(animation_id,
+                             GetTimeTicks(kInitialTickTime + 1.0));
   EXPECT_EQ(Animation::Paused,
             controller->GetAnimation(group_id,
                                      Animation::Opacity)->run_state());
@@ -338,11 +343,11 @@ TEST(LayerAnimationControllerTest, AnimationsAreDeleted) {
   controller_impl->AddValueObserver(&dummy_impl);
 
   AddOpacityTransitionToController(controller.get(), 1.0, 0.0f, 1.0f, false);
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, NULL);
   controller->PushAnimationUpdatesTo(controller_impl.get());
 
-  controller_impl->Animate(kInitialTickTime + 0.5);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime + 0.5));
   controller_impl->UpdateState(true, events.get());
 
   // There should be a Started event for the animation.
@@ -350,14 +355,14 @@ TEST(LayerAnimationControllerTest, AnimationsAreDeleted) {
   EXPECT_EQ(AnimationEvent::Started, (*events)[0].type);
   controller->NotifyAnimationStarted((*events)[0]);
 
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.0));
   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(GetTimeTicks(kInitialTickTime + 2.0));
   controller_impl->UpdateState(true, events.get());
 
   EXPECT_TRUE(dummy_impl.animation_waiting_for_deletion());
@@ -372,7 +377,7 @@ TEST(LayerAnimationControllerTest, AnimationsAreDeleted) {
 
   controller->NotifyAnimationFinished((*events)[0]);
 
-  controller->Animate(kInitialTickTime + 3.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 3.0));
   controller->UpdateState(true, NULL);
   EXPECT_TRUE(dummy.animation_waiting_for_deletion());
 
@@ -409,14 +414,14 @@ TEST(LayerAnimationControllerTest, TrivialTransition) {
       Animation::Opacity));
 
   controller->AddAnimation(to_add.Pass());
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
   // 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(GetTimeTicks(kInitialTickTime + 1.0));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1.f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -439,7 +444,7 @@ TEST(LayerAnimationControllerTest, TrivialTransitionOnImpl) {
   to_add->set_is_impl_only(true);
 
   controller_impl->AddAnimation(to_add.Pass());
-  controller_impl->Animate(kInitialTickTime);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime));
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy_impl.opacity());
@@ -448,7 +453,7 @@ TEST(LayerAnimationControllerTest, TrivialTransitionOnImpl) {
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_EQ(0.f, start_opacity_event->opacity);
 
-  controller_impl->Animate(kInitialTickTime + 1.0);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime + 1.0));
   controller_impl->UpdateState(true, events.get());
   EXPECT_EQ(1.f, dummy_impl.opacity());
   EXPECT_FALSE(controller_impl->HasActiveAnimation());
@@ -488,7 +493,7 @@ TEST(LayerAnimationControllerTest, TrivialTransformOnImpl) {
   controller_impl->AddAnimation(animation.Pass());
 
   // Run animation.
-  controller_impl->Animate(kInitialTickTime);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime));
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(gfx::Transform(), dummy_impl.transform());
@@ -502,7 +507,7 @@ TEST(LayerAnimationControllerTest, TrivialTransformOnImpl) {
   gfx::Transform expected_transform;
   expected_transform.Translate(delta_x, delta_y);
 
-  controller_impl->Animate(kInitialTickTime + 1.0);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime + 1.0));
   controller_impl->UpdateState(true, events.get());
   EXPECT_EQ(expected_transform, dummy_impl.transform());
   EXPECT_FALSE(controller_impl->HasActiveAnimation());
@@ -537,7 +542,7 @@ TEST(LayerAnimationControllerTest, FilterTransition) {
       curve.PassAs<AnimationCurve>(), 1, 0, Animation::Filter));
   controller->AddAnimation(animation.Pass());
 
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(start_filters, dummy.filters());
@@ -545,7 +550,7 @@ TEST(LayerAnimationControllerTest, FilterTransition) {
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  controller->Animate(kInitialTickTime + 0.5);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 0.5));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1u, dummy.filters().size());
   EXPECT_EQ(FilterOperation::CreateBrightnessFilter(1.5f),
@@ -553,7 +558,7 @@ TEST(LayerAnimationControllerTest, FilterTransition) {
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.0));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(end_filters, dummy.filters());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -588,7 +593,7 @@ TEST(LayerAnimationControllerTest, FilterTransitionOnImplOnly) {
   controller_impl->AddAnimation(animation.Pass());
 
   // Run animation.
-  controller_impl->Animate(kInitialTickTime);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime));
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(start_filters, dummy_impl.filters());
@@ -599,7 +604,7 @@ 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(GetTimeTicks(kInitialTickTime + 1.0));
   controller_impl->UpdateState(true, events.get());
   EXPECT_EQ(end_filters, dummy_impl.filters());
   EXPECT_FALSE(controller_impl->HasActiveAnimation());
@@ -649,12 +654,12 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransition) {
       duration,
       controller->GetAnimation(Animation::ScrollOffset)->curve()->Duration());
 
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, NULL);
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(initial_value, dummy.scroll_offset());
 
-  controller_impl->Animate(kInitialTickTime);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime));
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(initial_value, dummy_impl.scroll_offset());
@@ -663,26 +668,26 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransition) {
   EXPECT_FALSE(event);
 
   controller->NotifyAnimationStarted((*events)[0]);
-  controller->Animate(kInitialTickTime + duration/2.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + duration / 2.0));
   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(GetTimeTicks(kInitialTickTime + duration / 2.0));
   controller_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(200.f, 250.f),
                       dummy_impl.scroll_offset());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  controller_impl->Animate(kInitialTickTime + duration);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime + duration));
   controller_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(target_value, dummy_impl.scroll_offset());
   EXPECT_FALSE(controller_impl->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  controller->Animate(kInitialTickTime + duration);
+  controller->Animate(GetTimeTicks(kInitialTickTime + duration));
   controller->UpdateState(true, NULL);
   EXPECT_VECTOR2DF_EQ(target_value, dummy.scroll_offset());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -727,12 +732,12 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionNoImplProvider) {
       duration,
       controller->GetAnimation(Animation::ScrollOffset)->curve()->Duration());
 
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, NULL);
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(initial_value, dummy.scroll_offset());
 
-  controller_impl->Animate(kInitialTickTime);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime));
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(initial_value, dummy_impl.scroll_offset());
@@ -741,26 +746,26 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionNoImplProvider) {
   EXPECT_FALSE(event);
 
   controller->NotifyAnimationStarted((*events)[0]);
-  controller->Animate(kInitialTickTime + duration/2.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + duration / 2.0));
   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(GetTimeTicks(kInitialTickTime + duration / 2.0));
   controller_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(400.f, 150.f),
                       dummy_impl.scroll_offset());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  controller_impl->Animate(kInitialTickTime + duration);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime + duration));
   controller_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(target_value, dummy_impl.scroll_offset());
   EXPECT_FALSE(controller_impl->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  controller->Animate(kInitialTickTime + duration);
+  controller->Animate(GetTimeTicks(kInitialTickTime + duration));
   controller->UpdateState(true, NULL);
   EXPECT_VECTOR2DF_EQ(target_value, dummy.scroll_offset());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -788,7 +793,7 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionOnImplOnly) {
   animation->set_is_impl_only(true);
   controller_impl->AddAnimation(animation.Pass());
 
-  controller_impl->Animate(kInitialTickTime);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime));
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(initial_value, dummy_impl.scroll_offset());
@@ -796,14 +801,14 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionOnImplOnly) {
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  controller_impl->Animate(kInitialTickTime + duration/2.0);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime + duration / 2.0));
   controller_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(200.f, 250.f),
                       dummy_impl.scroll_offset());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  controller_impl->Animate(kInitialTickTime + duration);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime + duration));
   controller_impl->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(target_value, dummy_impl.scroll_offset());
   EXPECT_FALSE(controller_impl->HasActiveAnimation());
@@ -862,7 +867,7 @@ TEST(LayerAnimationControllerTest,
   to_add->set_is_impl_only(true);
   controller_impl->AddAnimation(to_add.Pass());
 
-  controller_impl->Animate(kInitialTickTime);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime));
   controller_impl->UpdateState(true, events.get());
 
   // We should receive 2 events (a started notification and a property update).
@@ -879,7 +884,7 @@ TEST(LayerAnimationControllerTest,
   EXPECT_TRUE(delegate.started());
 
   events.reset(new AnimationEventsVector);
-  controller_impl->Animate(kInitialTickTime + 1.0);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime + 1.0));
   controller_impl->UpdateState(true, events.get());
 
   // We should receive 2 events (a finished notification and a property update).
@@ -916,15 +921,15 @@ TEST(LayerAnimationControllerTest,
   // We should pause at the first keyframe indefinitely waiting for that
   // animation to start.
   controller->AddAnimation(to_add.Pass());
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.0));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 2.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 2.0));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
@@ -932,7 +937,7 @@ TEST(LayerAnimationControllerTest,
   // Send the synchronized start time.
   controller->NotifyAnimationStarted(AnimationEvent(
       AnimationEvent::Started, 0, 1, Animation::Opacity, kInitialTickTime + 2));
-  controller->Animate(kInitialTickTime + 5.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 5.0));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1.f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -957,15 +962,15 @@ TEST(LayerAnimationControllerTest, TrivialQueuing) {
       2,
       Animation::Opacity));
 
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.0));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(1.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 2.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 2.0));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0.5f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -983,7 +988,7 @@ TEST(LayerAnimationControllerTest, Interrupt) {
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
       1,
       Animation::Opacity));
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
@@ -998,11 +1003,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(GetTimeTicks(kInitialTickTime + 0.5));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(1.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.5);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.5));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0.5f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -1031,17 +1036,17 @@ TEST(LayerAnimationControllerTest, ScheduleTogetherWhenAPropertyIsBlocked) {
       2,
       Animation::Opacity));
 
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0.f, dummy.opacity());
   EXPECT_TRUE(controller->HasActiveAnimation());
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.0));
   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(GetTimeTicks(kInitialTickTime + 2.0));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1.f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -1073,14 +1078,14 @@ TEST(LayerAnimationControllerTest, ScheduleTogetherWithAnAnimWaiting) {
       Animation::Opacity));
 
   // Animations with id 1 should both start now.
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
   // 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(GetTimeTicks(kInitialTickTime + 2.0));
   controller->UpdateState(true, events.get());
   // Should not have started the float transition yet.
   EXPECT_TRUE(controller->HasActiveAnimation());
@@ -1088,7 +1093,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(GetTimeTicks(kInitialTickTime + 3.0));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0.5f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
@@ -1110,33 +1115,33 @@ TEST(LayerAnimationControllerTest, TrivialLooping) {
   to_add->set_iterations(3);
   controller->AddAnimation(to_add.Pass());
 
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.25);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.25));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.25f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.75);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.75));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 2.25);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 2.25));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.25f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 2.75);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 2.75));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 3.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 3.0));
   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(GetTimeTicks(kInitialTickTime + 4.0));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1.f, dummy.opacity());
 }
@@ -1158,24 +1163,24 @@ TEST(LayerAnimationControllerTest, InfiniteLooping) {
   to_add->set_iterations(-1);
   controller->AddAnimation(to_add.Pass());
 
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.25);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.25));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.25f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.75);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.75));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
 
-  controller->Animate(kInitialTickTime + 1073741824.25);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1073741824.25));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.25f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1073741824.75);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1073741824.75));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
@@ -1202,11 +1207,11 @@ TEST(LayerAnimationControllerTest, PauseResume) {
       id,
       Animation::Opacity));
 
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 0.5);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 0.5));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.5f, dummy.opacity());
@@ -1215,7 +1220,7 @@ TEST(LayerAnimationControllerTest, PauseResume) {
   controller->GetAnimation(id, Animation::Opacity)->SetRunState(
       Animation::Paused, kInitialTickTime + 0.5);
 
-  controller->Animate(kInitialTickTime + 1024.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1024.0));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.5f, dummy.opacity());
@@ -1224,11 +1229,11 @@ TEST(LayerAnimationControllerTest, PauseResume) {
   controller->GetAnimation(id, Animation::Opacity)->SetRunState(
       Animation::Running, kInitialTickTime + 1024);
 
-  controller->Animate(kInitialTickTime + 1024.25);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1024.25));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1024.5);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1024.5));
   controller->UpdateState(true, events.get());
   EXPECT_FALSE(controller->HasActiveAnimation());
   EXPECT_EQ(1.f, dummy.opacity());
@@ -1257,11 +1262,11 @@ TEST(LayerAnimationControllerTest, AbortAGroupedAnimation) {
       2,
       Animation::Opacity));
 
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.0));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.5f, dummy.opacity());
@@ -1269,11 +1274,11 @@ TEST(LayerAnimationControllerTest, AbortAGroupedAnimation) {
   EXPECT_TRUE(controller->GetAnimation(id, Animation::Opacity));
   controller->GetAnimation(id, Animation::Opacity)->SetRunState(
       Animation::Aborted, kInitialTickTime + 1.0);
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.0));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(1.f, dummy.opacity());
-  controller->Animate(kInitialTickTime + 2.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 2.0));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(!controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
@@ -1298,7 +1303,7 @@ TEST(LayerAnimationControllerTest, PushUpdatesWhenSynchronizedStartTimeNeeded) {
   to_add->set_needs_synchronized_start_time(true);
   controller->AddAnimation(to_add.Pass());
 
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   Animation* active_animation = controller->GetAnimation(0, Animation::Opacity);
@@ -1327,7 +1332,7 @@ TEST(LayerAnimationControllerTest, SkipUpdateState) {
       1,
       Animation::Transform));
 
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, events.get());
 
   controller->AddAnimation(CreateAnimation(
@@ -1336,9 +1341,9 @@ TEST(LayerAnimationControllerTest, SkipUpdateState) {
       Animation::Opacity));
 
   // Animate but don't UpdateState.
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.0));
 
-  controller->Animate(kInitialTickTime + 2.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 2.0));
   events.reset(new AnimationEventsVector);
   controller->UpdateState(true, events.get());
 
@@ -1350,7 +1355,7 @@ TEST(LayerAnimationControllerTest, SkipUpdateState) {
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
 
-  controller->Animate(kInitialTickTime + 3.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 3.0));
   controller->UpdateState(true, events.get());
 
   // The float tranisition should now be done.
@@ -1376,7 +1381,7 @@ TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {
 
   // Without an observer, the animation shouldn't progress to the Starting
   // state.
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0u, events->size());
   EXPECT_EQ(Animation::WaitingForTargetAvailability,
@@ -1387,7 +1392,7 @@ TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {
   // With only an inactive 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(GetTimeTicks(kInitialTickTime + 1.0));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0u, events->size());
   EXPECT_EQ(Animation::Starting,
@@ -1396,7 +1401,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(GetTimeTicks(kInitialTickTime + 2.0));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(0u, events->size());
   EXPECT_EQ(Animation::Starting,
@@ -1407,7 +1412,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(GetTimeTicks(kInitialTickTime + 3.0));
   controller->UpdateState(true, events.get());
   EXPECT_EQ(1u, events->size());
   EXPECT_EQ(Animation::Running,
@@ -1416,7 +1421,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(GetTimeTicks(kInitialTickTime + 3.5));
   EXPECT_NE(0.5f, inactive_dummy.opacity());
   EXPECT_NE(0.5f, dummy.opacity());
 }
@@ -1522,9 +1527,9 @@ TEST(LayerAnimationControllerTest, AbortAnimations) {
       5,
       Animation::Opacity));
 
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, NULL);
-  controller->Animate(kInitialTickTime + 1.0);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 1.0));
   controller->UpdateState(true, NULL);
 
   EXPECT_EQ(Animation::Finished,
@@ -1576,7 +1581,7 @@ TEST(LayerAnimationControllerTest, MainThreadAbortedAnimationGetsDeleted) {
   EXPECT_FALSE(dummy.animation_waiting_for_deletion());
   EXPECT_FALSE(dummy_impl.animation_waiting_for_deletion());
 
-  controller->Animate(kInitialTickTime);
+  controller->Animate(GetTimeTicks(kInitialTickTime));
   controller->UpdateState(true, NULL);
   EXPECT_TRUE(dummy.animation_waiting_for_deletion());
   EXPECT_EQ(Animation::WaitingForDeletion,
@@ -1611,7 +1616,7 @@ TEST(LayerAnimationControllerTest, ImplThreadAbortedAnimationGetsDeleted) {
   EXPECT_FALSE(dummy_impl.animation_waiting_for_deletion());
 
   AnimationEventsVector events;
-  controller_impl->Animate(kInitialTickTime);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime));
   controller_impl->UpdateState(true, &events);
   EXPECT_TRUE(dummy_impl.animation_waiting_for_deletion());
   EXPECT_EQ(1u, events.size());
@@ -1623,7 +1628,7 @@ TEST(LayerAnimationControllerTest, ImplThreadAbortedAnimationGetsDeleted) {
   EXPECT_EQ(Animation::Aborted,
             controller->GetAnimation(Animation::Opacity)->run_state());
 
-  controller->Animate(kInitialTickTime + 0.5);
+  controller->Animate(GetTimeTicks(kInitialTickTime + 0.5));
   controller->UpdateState(true, NULL);
   EXPECT_TRUE(dummy.animation_waiting_for_deletion());
   EXPECT_EQ(Animation::WaitingForDeletion,
@@ -1654,7 +1659,7 @@ TEST(LayerAnimationControllerTest, FinishedEventsForGroup) {
       1,
       Animation::Opacity));
 
-  controller_impl->Animate(kInitialTickTime);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime));
   controller_impl->UpdateState(true, events.get());
 
   // Both animations should have started.
@@ -1663,7 +1668,7 @@ TEST(LayerAnimationControllerTest, FinishedEventsForGroup) {
   EXPECT_EQ(AnimationEvent::Started, (*events)[1].type);
 
   events.reset(new AnimationEventsVector);
-  controller_impl->Animate(kInitialTickTime + 1.0);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime + 1.0));
   controller_impl->UpdateState(true, events.get());
 
   // The opacity animation should be finished, but should not have generated
@@ -1675,7 +1680,7 @@ TEST(LayerAnimationControllerTest, FinishedEventsForGroup) {
             controller_impl->GetAnimation(1,
                                           Animation::Transform)->run_state());
 
-  controller_impl->Animate(kInitialTickTime + 2.0);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime + 2.0));
   controller_impl->UpdateState(true, events.get());
 
   // Both animations should have generated Finished events.
@@ -1705,7 +1710,7 @@ TEST(LayerAnimationControllerTest, FinishedAndAbortedEventsForGroup) {
       1,
       Animation::Opacity));
 
-  controller_impl->Animate(kInitialTickTime);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime));
   controller_impl->UpdateState(true, events.get());
 
   // Both animations should have started.
@@ -1716,7 +1721,7 @@ TEST(LayerAnimationControllerTest, FinishedAndAbortedEventsForGroup) {
   controller_impl->AbortAnimations(Animation::Opacity);
 
   events.reset(new AnimationEventsVector);
-  controller_impl->Animate(kInitialTickTime + 1.0);
+  controller_impl->Animate(GetTimeTicks(kInitialTickTime + 1.0));
   controller_impl->UpdateState(true, events.get());
 
   // We should have exactly 2 events: a Finished event for the tranform