projects / platform / framework / web / crosswalk.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Update To 11.40.268.0
[platform/framework/web/crosswalk.git] / src / cc / animation / layer_animation_controller_unittest.cc
diff --git a/src/cc/animation/layer_animation_controller_unittest.cc b/src/cc/animation/layer_animation_controller_unittest.cc
index e172f72..49ac0a5 100644 (file)
--- a/src/cc/animation/layer_animation_controller_unittest.cc
+++ b/src/cc/animation/layer_animation_controller_unittest.cc
@@ -14,16 +14,24 @@
 #include "cc/test/animation_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "ui/gfx/box_f.h"
+#include "ui/gfx/geometry/box_f.h"
 #include "ui/gfx/transform.h"
 
 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,8 +106,8 @@ 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->UpdateState(true, NULL);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
+  controller->UpdateState(true, nullptr);
   EXPECT_EQ(controller->GetAnimation(group_id,
                                      Animation::Opacity)->start_time(),
             controller_impl->GetAnimation(group_id,
@@ -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,8 +155,8 @@ 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->UpdateState(true, NULL);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
+  controller->UpdateState(true, nullptr);
   EXPECT_EQ(start_time,
             controller->GetAnimation(group_id,
                                      Animation::Opacity)->start_time());
@@ -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->UpdateState(true, NULL);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
+  controller->UpdateState(true, nullptr);
   EXPECT_EQ(1u, registrar->active_animation_controllers().size());
 
-  controller->Animate(kInitialTickTime + 1.0);
-  controller->UpdateState(true, NULL);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  controller->UpdateState(true, nullptr);
   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,8 +231,8 @@ TEST(LayerAnimationControllerTest, Activation) {
 
   EXPECT_EQ(1u, events->size());
   controller->NotifyAnimationFinished((*events)[0]);
-  controller->Animate(kInitialTickTime + 1.5);
-  controller->UpdateState(true, NULL);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1500));
+  controller->UpdateState(true, nullptr);
 
   EXPECT_EQ(Animation::WaitingForDeletion,
             controller->GetAnimation(Animation::Opacity)->run_state());
@@ -237,8 +246,8 @@ TEST(LayerAnimationControllerTest, Activation) {
   EXPECT_EQ(0u, registrar->active_animation_controllers().size());
   EXPECT_EQ(0u, registrar_impl->active_animation_controllers().size());
 
-  controller->SetAnimationRegistrar(NULL);
-  controller_impl->SetAnimationRegistrar(NULL);
+  controller->SetAnimationRegistrar(nullptr);
+  controller_impl->SetAnimationRegistrar(nullptr);
 }
 
 TEST(LayerAnimationControllerTest, SyncPause) {
@@ -270,7 +279,7 @@ TEST(LayerAnimationControllerTest, SyncPause) {
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, &events);
   controller->Animate(kInitialTickTime);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_EQ(Animation::Running,
             controller_impl->GetAnimation(group_id,
                                           Animation::Opacity)->run_state());
@@ -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());
@@ -353,11 +364,11 @@ TEST(LayerAnimationControllerTest, AnimationsAreDeleted) {
 
   AddOpacityTransitionToController(controller.get(), 1.0, 0.0f, 1.0f, false);
   controller->Animate(kInitialTickTime);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   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->UpdateState(true, NULL);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  controller->UpdateState(true, nullptr);
 
   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,8 +399,8 @@ TEST(LayerAnimationControllerTest, AnimationsAreDeleted) {
 
   controller->NotifyAnimationFinished((*events)[0]);
 
-  controller->Animate(kInitialTickTime + 3.0);
-  controller->UpdateState(true, NULL);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
+  controller->UpdateState(true, nullptr);
   EXPECT_TRUE(dummy.animation_waiting_for_deletion());
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
@@ -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());
@@ -464,16 +476,17 @@ TEST(LayerAnimationControllerTest, TrivialTransitionOnImpl) {
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy_impl.opacity());
-  EXPECT_EQ(2u, events->size());
+  EXPECT_EQ(1u, events->size());
   const AnimationEvent* start_opacity_event =
       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());
-  EXPECT_EQ(4u, events->size());
+  EXPECT_EQ(2u, events->size());
   const AnimationEvent* end_opacity_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_EQ(1.f, end_opacity_event->opacity);
@@ -497,14 +510,12 @@ TEST(LayerAnimationControllerTest, TrivialTransformOnImpl) {
 
   // Create simple Transform animation.
   TransformOperations operations;
-  curve->AddKeyframe(
-      TransformKeyframe::Create(0, operations, scoped_ptr<TimingFunction>()));
+  curve->AddKeyframe(TransformKeyframe::Create(0, operations, nullptr));
   operations.AppendTranslate(delta_x, delta_y, 0);
-  curve->AddKeyframe(
-      TransformKeyframe::Create(1, operations, scoped_ptr<TimingFunction>()));
+  curve->AddKeyframe(TransformKeyframe::Create(1, operations, nullptr));
 
-  scoped_ptr<Animation> animation(Animation::Create(
-      curve.PassAs<AnimationCurve>(), 1, 0, Animation::Transform));
+  scoped_ptr<Animation> animation(
+      Animation::Create(curve.Pass(), 1, 0, Animation::Transform));
   animation->set_is_impl_only(true);
   controller_impl->AddAnimation(animation.Pass());
 
@@ -513,7 +524,7 @@ TEST(LayerAnimationControllerTest, TrivialTransformOnImpl) {
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(gfx::Transform(), dummy_impl.transform());
-  EXPECT_EQ(2u, events->size());
+  EXPECT_EQ(1u, events->size());
   const AnimationEvent* start_transform_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   ASSERT_TRUE(start_transform_event);
@@ -523,11 +534,12 @@ 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());
-  EXPECT_EQ(4u, events->size());
+  EXPECT_EQ(2u, events->size());
   const AnimationEvent* end_transform_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_EQ(expected_transform, end_transform_event->transform);
@@ -547,15 +559,13 @@ TEST(LayerAnimationControllerTest, FilterTransition) {
 
   FilterOperations start_filters;
   start_filters.Append(FilterOperation::CreateBrightnessFilter(1.f));
-  curve->AddKeyframe(
-      FilterKeyframe::Create(0, start_filters, scoped_ptr<TimingFunction>()));
+  curve->AddKeyframe(FilterKeyframe::Create(0, start_filters, nullptr));
   FilterOperations end_filters;
   end_filters.Append(FilterOperation::CreateBrightnessFilter(2.f));
-  curve->AddKeyframe(
-      FilterKeyframe::Create(1, end_filters, scoped_ptr<TimingFunction>()));
+  curve->AddKeyframe(FilterKeyframe::Create(1, end_filters, nullptr));
 
-  scoped_ptr<Animation> animation(Animation::Create(
-      curve.PassAs<AnimationCurve>(), 1, 0, Animation::Filter));
+  scoped_ptr<Animation> animation(
+      Animation::Create(curve.Pass(), 1, 0, Animation::Filter));
   controller->AddAnimation(animation.Pass());
 
   controller->Animate(kInitialTickTime);
@@ -566,7 +576,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 +584,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());
@@ -596,15 +606,13 @@ TEST(LayerAnimationControllerTest, FilterTransitionOnImplOnly) {
   // Create simple Filter animation.
   FilterOperations start_filters;
   start_filters.Append(FilterOperation::CreateBrightnessFilter(1.f));
-  curve->AddKeyframe(
-      FilterKeyframe::Create(0, start_filters, scoped_ptr<TimingFunction>()));
+  curve->AddKeyframe(FilterKeyframe::Create(0, start_filters, nullptr));
   FilterOperations end_filters;
   end_filters.Append(FilterOperation::CreateBrightnessFilter(2.f));
-  curve->AddKeyframe(
-      FilterKeyframe::Create(1, end_filters, scoped_ptr<TimingFunction>()));
+  curve->AddKeyframe(FilterKeyframe::Create(1, end_filters, nullptr));
 
-  scoped_ptr<Animation> animation(Animation::Create(
-      curve.PassAs<AnimationCurve>(), 1, 0, Animation::Filter));
+  scoped_ptr<Animation> animation(
+      Animation::Create(curve.Pass(), 1, 0, Animation::Filter));
   animation->set_is_impl_only(true);
   controller_impl->AddAnimation(animation.Pass());
 
@@ -613,18 +621,19 @@ TEST(LayerAnimationControllerTest, FilterTransitionOnImplOnly) {
   controller_impl->UpdateState(true, events.get());
   EXPECT_TRUE(controller_impl->HasActiveAnimation());
   EXPECT_EQ(start_filters, dummy_impl.filters());
-  EXPECT_EQ(2u, events->size());
+  EXPECT_EQ(1u, events->size());
   const AnimationEvent* start_filter_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_TRUE(start_filter_event);
   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());
-  EXPECT_EQ(4u, events->size());
+  EXPECT_EQ(2u, events->size());
   const AnimationEvent* end_filter_event =
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_TRUE(end_filter_event);
@@ -648,15 +657,15 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransition) {
   controller->AddValueObserver(&dummy);
   controller->set_value_provider(&dummy_provider);
 
-  gfx::Vector2dF initial_value(100.f, 300.f);
-  gfx::Vector2dF target_value(300.f, 200.f);
+  gfx::ScrollOffset initial_value(100.f, 300.f);
+  gfx::ScrollOffset target_value(300.f, 200.f);
   scoped_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurve::Create(
           target_value,
           EaseInOutTimingFunction::Create().Pass()));
 
-  scoped_ptr<Animation> animation(Animation::Create(
-      curve.PassAs<AnimationCurve>(), 1, 0, Animation::ScrollOffset));
+  scoped_ptr<Animation> animation(
+      Animation::Create(curve.Pass(), 1, 0, Animation::ScrollOffset));
   animation->set_needs_synchronized_start_time(true);
   controller->AddAnimation(animation.Pass());
 
@@ -664,15 +673,18 @@ 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);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(initial_value, dummy.scroll_offset());
 
@@ -685,12 +697,12 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransition) {
   EXPECT_FALSE(event);
 
   controller->NotifyAnimationStarted((*events)[0]);
-  controller->Animate(kInitialTickTime + duration/2.0);
-  controller->UpdateState(true, NULL);
+  controller->Animate(kInitialTickTime + duration / 2);
+  controller->UpdateState(true, nullptr);
   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());
@@ -705,7 +717,7 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransition) {
   EXPECT_FALSE(event);
 
   controller->Animate(kInitialTickTime + duration);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_VECTOR2DF_EQ(target_value, dummy.scroll_offset());
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
@@ -727,15 +739,15 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionNoImplProvider) {
   controller->AddValueObserver(&dummy);
   controller->set_value_provider(&dummy_provider);
 
-  gfx::Vector2dF initial_value(500.f, 100.f);
-  gfx::Vector2dF target_value(300.f, 200.f);
+  gfx::ScrollOffset initial_value(500.f, 100.f);
+  gfx::ScrollOffset target_value(300.f, 200.f);
   scoped_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurve::Create(
           target_value,
           EaseInOutTimingFunction::Create().Pass()));
 
-  scoped_ptr<Animation> animation(Animation::Create(
-      curve.PassAs<AnimationCurve>(), 1, 0, Animation::ScrollOffset));
+  scoped_ptr<Animation> animation(
+      Animation::Create(curve.Pass(), 1, 0, Animation::ScrollOffset));
   animation->set_needs_synchronized_start_time(true);
   controller->AddAnimation(animation.Pass());
 
@@ -743,15 +755,16 @@ 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);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(initial_value, dummy.scroll_offset());
 
@@ -763,13 +776,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->UpdateState(true, NULL);
+  controller->Animate(kInitialTickTime + duration / 2);
+  controller->UpdateState(true, nullptr);
   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());
@@ -784,7 +800,7 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionNoImplProvider) {
   EXPECT_FALSE(event);
 
   controller->Animate(kInitialTickTime + duration);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_VECTOR2DF_EQ(target_value, dummy.scroll_offset());
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
@@ -797,17 +813,17 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionOnImplOnly) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
 
-  gfx::Vector2dF initial_value(100.f, 300.f);
-  gfx::Vector2dF target_value(300.f, 200.f);
+  gfx::ScrollOffset initial_value(100.f, 300.f);
+  gfx::ScrollOffset target_value(300.f, 200.f);
   scoped_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurve::Create(
           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));
+  scoped_ptr<Animation> animation(
+      Animation::Create(curve.Pass(), 1, 0, Animation::ScrollOffset));
   animation->set_is_impl_only(true);
   controller_impl->AddAnimation(animation.Pass());
 
@@ -819,7 +835,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());
@@ -840,15 +859,15 @@ class FakeAnimationDelegate : public AnimationDelegate {
       : started_(false),
         finished_(false) {}
 
-  virtual void NotifyAnimationStarted(
-      base::TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE {
+  void NotifyAnimationStarted(TimeTicks monotonic_time,
+                              Animation::TargetProperty target_property,
+                              int group) override {
     started_ = true;
   }
 
-  virtual void NotifyAnimationFinished(
-      base::TimeTicks monotonic_time,
-      Animation::TargetProperty target_property) OVERRIDE {
+  void NotifyAnimationFinished(TimeTicks monotonic_time,
+                               Animation::TargetProperty target_property,
+                               int group) override {
     finished_ = true;
   }
 
@@ -862,21 +881,17 @@ class FakeAnimationDelegate : public AnimationDelegate {
 };
 
 // Tests that impl-only animations lead to start and finished notifications
-// being sent to the main thread controller's animation delegate.
+// on the impl thread controller's animation delegate.
 TEST(LayerAnimationControllerTest,
-     NotificationsForImplOnlyAnimationsAreSentToMainThreadDelegate) {
+     NotificationsForImplOnlyAnimationsAreSentToImplThreadDelegate) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
   controller_impl->AddValueObserver(&dummy_impl);
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
-  FakeLayerAnimationValueObserver dummy;
-  scoped_refptr<LayerAnimationController> controller(
-      LayerAnimationController::Create(0));
-  controller->AddValueObserver(&dummy);
   FakeAnimationDelegate delegate;
-  controller->set_layer_animation_delegate(&delegate);
+  controller_impl->set_layer_animation_delegate(&delegate);
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
@@ -885,37 +900,21 @@ TEST(LayerAnimationControllerTest,
   to_add->set_is_impl_only(true);
   controller_impl->AddAnimation(to_add.Pass());
 
+  EXPECT_FALSE(delegate.started());
+  EXPECT_FALSE(delegate.finished());
+
   controller_impl->Animate(kInitialTickTime);
   controller_impl->UpdateState(true, events.get());
 
-  // We should receive 2 events (a started notification and a property update).
-  EXPECT_EQ(2u, events->size());
-  EXPECT_EQ(AnimationEvent::Started, (*events)[0].type);
-  EXPECT_TRUE((*events)[0].is_impl_only);
-  EXPECT_EQ(AnimationEvent::PropertyUpdate, (*events)[1].type);
-  EXPECT_TRUE((*events)[1].is_impl_only);
-
-  // Passing on the start event to the main thread controller should cause the
-  // delegate to get notified.
-  EXPECT_FALSE(delegate.started());
-  controller->NotifyAnimationStarted((*events)[0]);
   EXPECT_TRUE(delegate.started());
+  EXPECT_FALSE(delegate.finished());
 
   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).
-  EXPECT_EQ(2u, events->size());
-  EXPECT_EQ(AnimationEvent::Finished, (*events)[0].type);
-  EXPECT_TRUE((*events)[0].is_impl_only);
-  EXPECT_EQ(AnimationEvent::PropertyUpdate, (*events)[1].type);
-  EXPECT_TRUE((*events)[1].is_impl_only);
-
-  // Passing on the finished event to the main thread controller should cause
-  // the delegate to get notified.
-  EXPECT_FALSE(delegate.finished());
-  controller->NotifyAnimationFinished((*events)[0]);
+  EXPECT_TRUE(delegate.started());
   EXPECT_TRUE(delegate.finished());
 }
 
@@ -943,19 +942,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 +995,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 +1036,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 +1073,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 +1118,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 +1126,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 +1152,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 +1200,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 +1246,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 +1302,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 +1378,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 +1392,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 +1429,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 +1438,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 +1449,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 +1458,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());
 }
@@ -1465,28 +1471,23 @@ TEST(LayerAnimationControllerTest, TransformAnimationBounds) {
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations1;
-  curve1->AddKeyframe(TransformKeyframe::Create(
-      0.0, operations1, scoped_ptr<TimingFunction>()));
+  curve1->AddKeyframe(TransformKeyframe::Create(0.0, operations1, nullptr));
   operations1.AppendTranslate(10.0, 15.0, 0.0);
-  curve1->AddKeyframe(TransformKeyframe::Create(
-      1.0, operations1, scoped_ptr<TimingFunction>()));
+  curve1->AddKeyframe(TransformKeyframe::Create(1.0, operations1, nullptr));
 
-  scoped_ptr<Animation> animation(Animation::Create(
-      curve1.PassAs<AnimationCurve>(), 1, 1, Animation::Transform));
+  scoped_ptr<Animation> animation(
+      Animation::Create(curve1.Pass(), 1, 1, Animation::Transform));
   controller_impl->AddAnimation(animation.Pass());
 
   scoped_ptr<KeyframedTransformAnimationCurve> curve2(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations2;
-  curve2->AddKeyframe(TransformKeyframe::Create(
-      0.0, operations2, scoped_ptr<TimingFunction>()));
+  curve2->AddKeyframe(TransformKeyframe::Create(0.0, operations2, nullptr));
   operations2.AppendScale(2.0, 3.0, 4.0);
-  curve2->AddKeyframe(TransformKeyframe::Create(
-      1.0, operations2, scoped_ptr<TimingFunction>()));
+  curve2->AddKeyframe(TransformKeyframe::Create(1.0, operations2, nullptr));
 
-  animation = Animation::Create(
-      curve2.PassAs<AnimationCurve>(), 2, 2, Animation::Transform);
+  animation = Animation::Create(curve2.Pass(), 2, 2, Animation::Transform);
   controller_impl->AddAnimation(animation.Pass());
 
   gfx::BoxF box(1.f, 2.f, -1.f, 3.f, 4.f, 5.f);
@@ -1497,7 +1498,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 +1506,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());
@@ -1516,13 +1517,10 @@ TEST(LayerAnimationControllerTest, TransformAnimationBounds) {
   TransformOperations operations3;
   gfx::Transform transform3;
   transform3.Scale3d(1.0, 2.0, 3.0);
-  curve3->AddKeyframe(TransformKeyframe::Create(
-      0.0, operations3, scoped_ptr<TimingFunction>()));
+  curve3->AddKeyframe(TransformKeyframe::Create(0.0, operations3, nullptr));
   operations3.AppendMatrix(transform3);
-  curve3->AddKeyframe(TransformKeyframe::Create(
-      1.0, operations3, scoped_ptr<TimingFunction>()));
-  animation = Animation::Create(
-      curve3.PassAs<AnimationCurve>(), 3, 3, Animation::Transform);
+  curve3->AddKeyframe(TransformKeyframe::Create(1.0, operations3, nullptr));
+  animation = Animation::Create(curve3.Pass(), 3, 3, Animation::Transform);
   controller_impl->AddAnimation(animation.Pass());
   EXPECT_FALSE(controller_impl->TransformAnimationBoundsForBox(box, &bounds));
 }
@@ -1559,9 +1557,9 @@ TEST(LayerAnimationControllerTest, AbortAnimations) {
       Animation::Opacity));
 
   controller->Animate(kInitialTickTime);
-  controller->UpdateState(true, NULL);
-  controller->Animate(kInitialTickTime + 1.0);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  controller->UpdateState(true, nullptr);
 
   EXPECT_EQ(Animation::Finished,
             controller->GetAnimation(1, Animation::Transform)->run_state());
@@ -1614,7 +1612,7 @@ TEST(LayerAnimationControllerTest, MainThreadAbortedAnimationGetsDeleted) {
   EXPECT_FALSE(dummy_impl.animation_waiting_for_deletion());
 
   controller->Animate(kInitialTickTime);
-  controller->UpdateState(true, NULL);
+  controller->UpdateState(true, nullptr);
   EXPECT_TRUE(dummy.animation_waiting_for_deletion());
   EXPECT_EQ(Animation::WaitingForDeletion,
             controller->GetAnimation(Animation::Opacity)->run_state());
@@ -1662,8 +1660,8 @@ TEST(LayerAnimationControllerTest, ImplThreadAbortedAnimationGetsDeleted) {
   EXPECT_EQ(Animation::Aborted,
             controller->GetAnimation(Animation::Opacity)->run_state());
 
-  controller->Animate(kInitialTickTime + 0.5);
-  controller->UpdateState(true, NULL);
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
+  controller->UpdateState(true, nullptr);
   EXPECT_TRUE(dummy.animation_waiting_for_deletion());
   EXPECT_EQ(Animation::WaitingForDeletion,
             controller->GetAnimation(Animation::Opacity)->run_state());
@@ -1703,7 +1701,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 +1714,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 +1756,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
@@ -1786,14 +1787,12 @@ TEST(LayerAnimationControllerTest, HasAnimationThatAffectsScale) {
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations1;
-  curve1->AddKeyframe(TransformKeyframe::Create(
-      0.0, operations1, scoped_ptr<TimingFunction>()));
+  curve1->AddKeyframe(TransformKeyframe::Create(0.0, operations1, nullptr));
   operations1.AppendTranslate(10.0, 15.0, 0.0);
-  curve1->AddKeyframe(TransformKeyframe::Create(
-      1.0, operations1, scoped_ptr<TimingFunction>()));
+  curve1->AddKeyframe(TransformKeyframe::Create(1.0, operations1, nullptr));
 
-  scoped_ptr<Animation> animation(Animation::Create(
-      curve1.PassAs<AnimationCurve>(), 2, 2, Animation::Transform));
+  scoped_ptr<Animation> animation(
+      Animation::Create(curve1.Pass(), 2, 2, Animation::Transform));
   controller_impl->AddAnimation(animation.Pass());
 
   // Translations don't affect scale.
@@ -1803,20 +1802,17 @@ TEST(LayerAnimationControllerTest, HasAnimationThatAffectsScale) {
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations2;
-  curve2->AddKeyframe(TransformKeyframe::Create(
-      0.0, operations2, scoped_ptr<TimingFunction>()));
+  curve2->AddKeyframe(TransformKeyframe::Create(0.0, operations2, nullptr));
   operations2.AppendScale(2.0, 3.0, 4.0);
-  curve2->AddKeyframe(TransformKeyframe::Create(
-      1.0, operations2, scoped_ptr<TimingFunction>()));
+  curve2->AddKeyframe(TransformKeyframe::Create(1.0, operations2, nullptr));
 
-  animation = Animation::Create(
-      curve2.PassAs<AnimationCurve>(), 3, 3, Animation::Transform);
+  animation = Animation::Create(curve2.Pass(), 3, 3, Animation::Transform);
   controller_impl->AddAnimation(animation.Pass());
 
   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.
@@ -1841,14 +1837,12 @@ TEST(LayerAnimationControllerTest, HasOnlyTranslationTransforms) {
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations1;
-  curve1->AddKeyframe(TransformKeyframe::Create(
-      0.0, operations1, scoped_ptr<TimingFunction>()));
+  curve1->AddKeyframe(TransformKeyframe::Create(0.0, operations1, nullptr));
   operations1.AppendTranslate(10.0, 15.0, 0.0);
-  curve1->AddKeyframe(TransformKeyframe::Create(
-      1.0, operations1, scoped_ptr<TimingFunction>()));
+  curve1->AddKeyframe(TransformKeyframe::Create(1.0, operations1, nullptr));
 
-  scoped_ptr<Animation> animation(Animation::Create(
-      curve1.PassAs<AnimationCurve>(), 2, 2, Animation::Transform));
+  scoped_ptr<Animation> animation(
+      Animation::Create(curve1.Pass(), 2, 2, Animation::Transform));
   controller_impl->AddAnimation(animation.Pass());
 
   // The only transform animation we've added is a translation.
@@ -1858,96 +1852,150 @@ TEST(LayerAnimationControllerTest, HasOnlyTranslationTransforms) {
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations2;
-  curve2->AddKeyframe(TransformKeyframe::Create(
-      0.0, operations2, scoped_ptr<TimingFunction>()));
+  curve2->AddKeyframe(TransformKeyframe::Create(0.0, operations2, nullptr));
   operations2.AppendScale(2.0, 3.0, 4.0);
-  curve2->AddKeyframe(TransformKeyframe::Create(
-      1.0, operations2, scoped_ptr<TimingFunction>()));
+  curve2->AddKeyframe(TransformKeyframe::Create(1.0, operations2, nullptr));
 
-  animation = Animation::Create(
-      curve2.PassAs<AnimationCurve>(), 3, 3, Animation::Transform);
+  animation = Animation::Create(curve2.Pass(), 3, 3, Animation::Transform);
   controller_impl->AddAnimation(animation.Pass());
 
   // A scale animation is not a translation.
   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.
   EXPECT_TRUE(controller_impl->HasOnlyTranslationTransforms());
 }
 
-TEST(LayerAnimationControllerTest, MaximumScale) {
+TEST(LayerAnimationControllerTest, MaximumTargetScale) {
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
 
   float max_scale = 0.f;
-  EXPECT_TRUE(controller_impl->MaximumScale(&max_scale));
+  EXPECT_TRUE(controller_impl->MaximumTargetScale(&max_scale));
   EXPECT_EQ(0.f, max_scale);
 
   scoped_ptr<KeyframedTransformAnimationCurve> curve1(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations1;
-  curve1->AddKeyframe(TransformKeyframe::Create(
-      0.0, operations1, scoped_ptr<TimingFunction>()));
+  curve1->AddKeyframe(TransformKeyframe::Create(0.0, operations1, nullptr));
   operations1.AppendScale(2.0, 3.0, 4.0);
-  curve1->AddKeyframe(TransformKeyframe::Create(
-      1.0, operations1, scoped_ptr<TimingFunction>()));
+  curve1->AddKeyframe(TransformKeyframe::Create(1.0, operations1, nullptr));
 
-  scoped_ptr<Animation> animation(Animation::Create(
-      curve1.PassAs<AnimationCurve>(), 1, 1, Animation::Transform));
+  scoped_ptr<Animation> animation(
+      Animation::Create(curve1.Pass(), 1, 1, Animation::Transform));
   controller_impl->AddAnimation(animation.Pass());
 
-  EXPECT_TRUE(controller_impl->MaximumScale(&max_scale));
+  EXPECT_TRUE(controller_impl->MaximumTargetScale(&max_scale));
   EXPECT_EQ(4.f, max_scale);
 
   scoped_ptr<KeyframedTransformAnimationCurve> curve2(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations2;
-  curve2->AddKeyframe(TransformKeyframe::Create(
-      0.0, operations2, scoped_ptr<TimingFunction>()));
+  curve2->AddKeyframe(TransformKeyframe::Create(0.0, operations2, nullptr));
   operations2.AppendScale(6.0, 5.0, 4.0);
-  curve2->AddKeyframe(TransformKeyframe::Create(
-      1.0, operations2, scoped_ptr<TimingFunction>()));
+  curve2->AddKeyframe(TransformKeyframe::Create(1.0, operations2, nullptr));
 
-  animation = Animation::Create(
-      curve2.PassAs<AnimationCurve>(), 2, 2, Animation::Transform);
+  animation = Animation::Create(curve2.Pass(), 2, 2, Animation::Transform);
   controller_impl->AddAnimation(animation.Pass());
 
-  EXPECT_TRUE(controller_impl->MaximumScale(&max_scale));
+  EXPECT_TRUE(controller_impl->MaximumTargetScale(&max_scale));
   EXPECT_EQ(6.f, max_scale);
 
   scoped_ptr<KeyframedTransformAnimationCurve> curve3(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations3;
-  curve3->AddKeyframe(TransformKeyframe::Create(
-      0.0, operations3, scoped_ptr<TimingFunction>()));
+  curve3->AddKeyframe(TransformKeyframe::Create(0.0, operations3, nullptr));
   operations3.AppendPerspective(6.0);
-  curve3->AddKeyframe(TransformKeyframe::Create(
-      1.0, operations3, scoped_ptr<TimingFunction>()));
+  curve3->AddKeyframe(TransformKeyframe::Create(1.0, operations3, nullptr));
 
-  animation = Animation::Create(
-      curve3.PassAs<AnimationCurve>(), 3, 3, Animation::Transform);
+  animation = Animation::Create(curve3.Pass(), 3, 3, Animation::Transform);
   controller_impl->AddAnimation(animation.Pass());
 
-  EXPECT_FALSE(controller_impl->MaximumScale(&max_scale));
+  EXPECT_FALSE(controller_impl->MaximumTargetScale(&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.
-  EXPECT_TRUE(controller_impl->MaximumScale(&max_scale));
+  // MaximumTargetScale.
+  EXPECT_TRUE(controller_impl->MaximumTargetScale(&max_scale));
   EXPECT_EQ(4.f, max_scale);
 }
 
+TEST(LayerAnimationControllerTest, MaximumTargetScaleWithDirection) {
+  scoped_refptr<LayerAnimationController> controller_impl(
+      LayerAnimationController::Create(0));
+
+  scoped_ptr<KeyframedTransformAnimationCurve> curve1(
+      KeyframedTransformAnimationCurve::Create());
+  TransformOperations operations1;
+  operations1.AppendScale(1.0, 2.0, 3.0);
+  curve1->AddKeyframe(TransformKeyframe::Create(0.0, operations1, nullptr));
+  TransformOperations operations2;
+  operations2.AppendScale(4.0, 5.0, 6.0);
+  curve1->AddKeyframe(TransformKeyframe::Create(1.0, operations2, nullptr));
+
+  scoped_ptr<Animation> animation_owned(
+      Animation::Create(curve1.Pass(), 1, 1, Animation::Transform));
+  Animation* animation = animation_owned.get();
+  controller_impl->AddAnimation(animation_owned.Pass());
+
+  float max_scale = 0.f;
+
+  EXPECT_GT(animation->playback_rate(), 0.0);
+
+  // Normal direction with positive playback rate.
+  animation->set_direction(Animation::Normal);
+  EXPECT_TRUE(controller_impl->MaximumTargetScale(&max_scale));
+  EXPECT_EQ(6.f, max_scale);
+
+  // Alternate direction with positive playback rate.
+  animation->set_direction(Animation::Alternate);
+  EXPECT_TRUE(controller_impl->MaximumTargetScale(&max_scale));
+  EXPECT_EQ(6.f, max_scale);
+
+  // Reverse direction with positive playback rate.
+  animation->set_direction(Animation::Reverse);
+  EXPECT_TRUE(controller_impl->MaximumTargetScale(&max_scale));
+  EXPECT_EQ(3.f, max_scale);
+
+  // Alternate reverse direction.
+  animation->set_direction(Animation::Reverse);
+  EXPECT_TRUE(controller_impl->MaximumTargetScale(&max_scale));
+  EXPECT_EQ(3.f, max_scale);
+
+  animation->set_playback_rate(-1.0);
+
+  // Normal direction with negative playback rate.
+  animation->set_direction(Animation::Normal);
+  EXPECT_TRUE(controller_impl->MaximumTargetScale(&max_scale));
+  EXPECT_EQ(3.f, max_scale);
+
+  // Alternate direction with negative playback rate.
+  animation->set_direction(Animation::Alternate);
+  EXPECT_TRUE(controller_impl->MaximumTargetScale(&max_scale));
+  EXPECT_EQ(3.f, max_scale);
+
+  // Reverse direction with negative playback rate.
+  animation->set_direction(Animation::Reverse);
+  EXPECT_TRUE(controller_impl->MaximumTargetScale(&max_scale));
+  EXPECT_EQ(6.f, max_scale);
+
+  // Alternate reverse direction with negative playback rate.
+  animation->set_direction(Animation::Reverse);
+  EXPECT_TRUE(controller_impl->MaximumTargetScale(&max_scale));
+  EXPECT_EQ(6.f, max_scale);
+}
+
 TEST(LayerAnimationControllerTest, NewlyPushedAnimationWaitsForActivation) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
@@ -2001,7 +2049,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,13 +2111,45 @@ 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());
   EXPECT_EQ(0.75f, dummy_impl.opacity());
 }
 
+TEST(LayerAnimationControllerTest, ClippedOpacityValues) {
+  FakeLayerAnimationValueObserver dummy;
+  scoped_refptr<LayerAnimationController> controller(
+      LayerAnimationController::Create(0));
+  controller->AddValueObserver(&dummy);
+
+  AddOpacityTransitionToController(controller.get(), 1, 1.f, 2.f, true);
+
+  controller->Animate(kInitialTickTime);
+  EXPECT_EQ(1.f, dummy.opacity());
+
+  // Opacity values are clipped [0,1]
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  EXPECT_EQ(1.f, dummy.opacity());
+}
+
+TEST(LayerAnimationControllerTest, ClippedNegativeOpacityValues) {
+  FakeLayerAnimationValueObserver dummy;
+  scoped_refptr<LayerAnimationController> controller(
+      LayerAnimationController::Create(0));
+  controller->AddValueObserver(&dummy);
+
+  AddOpacityTransitionToController(controller.get(), 1, 0.f, -2.f, true);
+
+  controller->Animate(kInitialTickTime);
+  EXPECT_EQ(0.f, dummy.opacity());
+
+  // Opacity values are clipped [0,1]
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  EXPECT_EQ(0.f, dummy.opacity());
+}
+
 TEST(LayerAnimationControllerTest, PushedDeletedAnimationWaitsForActivation) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
@@ -2112,7 +2193,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 +2255,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 +2285,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
@@ -2216,5 +2298,51 @@ TEST(LayerAnimationControllerTest, StartAnimationsAffectingDifferentObservers) {
   EXPECT_EQ(1.f, dummy_impl.opacity());
 }
 
+TEST(LayerAnimationControllerTest, TestIsAnimatingProperty) {
+  FakeLayerAnimationValueObserver dummy;
+  scoped_refptr<LayerAnimationController> controller(
+      LayerAnimationController::Create(0));
+  controller->AddValueObserver(&dummy);
+
+  scoped_ptr<Animation> animation(CreateAnimation(
+      scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
+      1,
+      Animation::Opacity));
+  controller->AddAnimation(animation.Pass());
+  controller->Animate(kInitialTickTime);
+  EXPECT_TRUE(controller->IsAnimatingProperty(Animation::Opacity));
+  controller->UpdateState(true, nullptr);
+  EXPECT_TRUE(controller->HasActiveAnimation());
+  EXPECT_TRUE(controller->IsAnimatingProperty(Animation::Opacity));
+  EXPECT_FALSE(controller->IsAnimatingProperty(Animation::Filter));
+  EXPECT_EQ(0.f, dummy.opacity());
+}
+
+TEST(LayerAnimationControllerTest, TestIsAnimatingPropertyTimeOffsetFillMode) {
+  FakeLayerAnimationValueObserver dummy;
+  scoped_refptr<LayerAnimationController> controller(
+      LayerAnimationController::Create(0));
+  controller->AddValueObserver(&dummy);
+
+  scoped_ptr<Animation> animation(CreateAnimation(
+      scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
+      1,
+      Animation::Opacity));
+  animation->set_fill_mode(Animation::FillModeNone);
+  animation->set_time_offset(TimeDelta::FromMilliseconds(-2000));
+  controller->AddAnimation(animation.Pass());
+
+  controller->Animate(kInitialTickTime);
+  controller->UpdateState(true, nullptr);
+  EXPECT_FALSE(controller->IsAnimatingProperty(Animation::Opacity));
+  EXPECT_TRUE(controller->HasActiveAnimation());
+  EXPECT_FALSE(controller->IsAnimatingProperty(Animation::Opacity));
+  EXPECT_FALSE(controller->IsAnimatingProperty(Animation::Filter));
+
+  controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  controller->UpdateState(true, nullptr);
+  EXPECT_TRUE(controller->IsAnimatingProperty(Animation::Opacity));
+}
+
 }  // namespace
 }  // namespace cc
Domain: Web Framework / Uncategorized;