LayerTreeHost::SetAnimationEvents should use AnimationRegistrar

cc/animation/layer_animation_controller_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/animation/layer_animation_controller.h"
 
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/transform_operations.h"
@@ skipping 11 matching lines @@
 scoped_ptr<Animation> CreateAnimation(scoped_ptr<AnimationCurve> curve,
                                       int id,
                                       Animation::TargetProperty property) {
   return Animation::Create(curve.Pass(), 0, id, property);
 }
 
 TEST(LayerAnimationControllerTest, SyncNewAnimation) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
-  controller_impl->AddObserver(&dummy_impl);
+  controller_impl->AddValueObserver(&dummy_impl);
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   EXPECT_FALSE(controller_impl->GetAnimation(0, Animation::Opacity));
 
   AddOpacityTransitionToController(controller, 1, 0, 1, false);
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
 
   EXPECT_TRUE(controller_impl->GetAnimation(0, Animation::Opacity));
   EXPECT_EQ(Animation::WaitingForTargetAvailability,
             controller_impl->GetAnimation(0, Animation::Opacity)->run_state());
 }
 
 // If an animation is started on the impl thread before it is ticked on the main
 // thread, we must be sure to respect the synchronized start time.
 TEST(LayerAnimationControllerTest, DoNotClobberStartTimes) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
-  controller_impl->AddObserver(&dummy_impl);
+  controller_impl->AddValueObserver(&dummy_impl);
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   EXPECT_FALSE(controller_impl->GetAnimation(0, Animation::Opacity));
 
   AddOpacityTransitionToController(controller, 1, 0, 1, false);
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
 
   EXPECT_TRUE(controller_impl->GetAnimation(0, Animation::Opacity));
   EXPECT_EQ(Animation::WaitingForTargetAvailability,
             controller_impl->GetAnimation(0, Animation::Opacity)->run_state());
 
   AnimationEventsVector events;
   controller_impl->Animate(1.0);
   controller_impl->UpdateState(&events);
 
   // Synchronize the start times.
   EXPECT_EQ(1u, events.size());
-  controller->OnAnimationStarted(events[0]);
+  controller->NotifyAnimationStarted(events[0], 0.0);
   EXPECT_EQ(controller->GetAnimation(0, Animation::Opacity)->start_time(),
             controller_impl->GetAnimation(0, Animation::Opacity)->start_time());
 
   // Start the animation on the main thread. Should not affect the start time.
   controller->Animate(1.5);
   controller->UpdateState(NULL);
   EXPECT_EQ(controller->GetAnimation(0, Animation::Opacity)->start_time(),
             controller_impl->GetAnimation(0, Animation::Opacity)->start_time());
 }
 
 TEST(LayerAnimationControllerTest, SyncPauseAndResume) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
-  controller_impl->AddObserver(&dummy_impl);
+  controller_impl->AddValueObserver(&dummy_impl);
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   EXPECT_FALSE(controller_impl->GetAnimation(0, Animation::Opacity));
 
   AddOpacityTransitionToController(controller, 1, 0, 1, false);
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
 
   EXPECT_TRUE(controller_impl->GetAnimation(0, Animation::Opacity));
   EXPECT_EQ(Animation::WaitingForTargetAvailability,
             controller_impl->GetAnimation(0, Animation::Opacity)->run_state());
@@ skipping 27 matching lines @@
   // The pause run state change should make it to the impl thread controller.
   controller->PushAnimationUpdatesTo(controller_impl.get());
   EXPECT_EQ(Animation::Running,
             controller_impl->GetAnimation(0, Animation::Opacity)->run_state());
 }
 
 TEST(LayerAnimationControllerTest, DoNotSyncFinishedAnimation) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
-  controller_impl->AddObserver(&dummy_impl);
+  controller_impl->AddValueObserver(&dummy_impl);
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   EXPECT_FALSE(controller_impl->GetAnimation(0, Animation::Opacity));
 
   int animation_id =
       AddOpacityTransitionToController(controller, 1, 0, 1, false);
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
 
   EXPECT_TRUE(controller_impl->GetAnimation(0, Animation::Opacity));
   EXPECT_EQ(Animation::WaitingForTargetAvailability,
             controller_impl->GetAnimation(0, Animation::Opacity)->run_state());
 
   // Notify main thread controller that the animation has started.
   AnimationEvent animation_started_event(
       AnimationEvent::Started, 0, 0, Animation::Opacity, 0);
-  controller->OnAnimationStarted(animation_started_event);
+  controller->NotifyAnimationStarted(animation_started_event, 0.0);
 
   // Force animation to complete on impl thread.
   controller_impl->RemoveAnimation(animation_id);
 
   EXPECT_FALSE(controller_impl->GetAnimation(animation_id, Animation::Opacity));
 
   controller->PushAnimationUpdatesTo(controller_impl.get());
 
   // Even though the main thread has a 'new' animation, it should not be pushed
   // because the animation has already completed on the impl thread.
   EXPECT_FALSE(controller_impl->GetAnimation(animation_id, Animation::Opacity));
 }
 
+// Ensure that a finished animation is eventually deleted by both the
+// main-thread and the impl-thread controllers.
+TEST(LayerAnimationControllerTest, AnimationsAreDeleted) {
+  FakeLayerAnimationValueObserver dummy;
+  FakeLayerAnimationValueObserver dummy_impl;
+  scoped_ptr<AnimationEventsVector> events(
+      make_scoped_ptr(new AnimationEventsVector));
+  scoped_refptr<LayerAnimationController> controller(
+      LayerAnimationController::Create(0));
+  scoped_refptr<LayerAnimationController> controller_impl(
+      LayerAnimationController::Create(0));
+  controller->AddValueObserver(&dummy);
+  controller_impl->AddValueObserver(&dummy_impl);
+
+  AddOpacityTransitionToController(controller, 1.0, 0.0f, 1.0f, false);
+  controller->Animate(0.0);
+  controller->UpdateState(NULL);
+  controller->PushAnimationUpdatesTo(controller_impl.get());
+
+  controller_impl->Animate(0.5);
+  controller_impl->UpdateState(events.get());
+
+  // There should be a Started event for the animation.
+  EXPECT_EQ(1u, events->size());
+  EXPECT_EQ(AnimationEvent::Started, (*events)[0].type);
+  controller->NotifyAnimationStarted((*events)[0], 0.0);
+
+  controller->Animate(1.0);
+  controller->UpdateState(NULL);
+
+  events.reset(new AnimationEventsVector);
+  controller_impl->Animate(2.0);
+  controller_impl->UpdateState(events.get());
+
+  // There should be a Finished event for the animation.
+  EXPECT_EQ(1u, events->size());
+  EXPECT_EQ(AnimationEvent::Finished, (*events)[0].type);
+
+  // Neither controller should have deleted the animation yet.
+  EXPECT_TRUE(controller->GetAnimation(Animation::Opacity));
+  EXPECT_TRUE(controller_impl->GetAnimation(Animation::Opacity));
+
+  controller->NotifyAnimationFinished((*events)[0], 0.0);
+
+  controller->Animate(3.0);
+  controller->UpdateState(NULL);
+
+  controller->PushAnimationUpdatesTo(controller_impl.get());
+
+  // Both controllers should now have deleted the animation.
+  EXPECT_FALSE(controller->has_any_animation());
+  EXPECT_FALSE(controller_impl->has_any_animation());
+}

[Ian Vollick, 2013/04/04 18:38:58]

Great test!

+
+TEST(LayerAnimationControllerTest, TransferAnimationsTo) {
+  scoped_refptr<LayerAnimationController> controller(
+      LayerAnimationController::Create(0));
+  scoped_refptr<LayerAnimationController> other_controller(
+      LayerAnimationController::Create(1));
+
+  int opacity_animation_id =
+      AddOpacityTransitionToController(controller, 1.0, 0.0f, 1.0f, false);
+
+  int transform_animation_id =
+      AddAnimatedTransformToController(controller, 1.0, 10, 10);
+
+  controller->TransferAnimationsTo(other_controller);
+
+  // Ensure both animations have been transfered.

[Ian Vollick, 2013/04/04 18:38:58]

Can you also confirm that the run states are identical? (To ensure that this
behaves differently than ReplaceImplThreadAnimations).

[ajuma, 2013/04/05 14:38:18]

Done.

+  EXPECT_FALSE(controller->has_any_animation());
+  EXPECT_EQ(other_controller->GetAnimation(Animation::Opacity)->id(),
+            opacity_animation_id);
+  EXPECT_EQ(other_controller->GetAnimation(Animation::Transform)->id(),
+            transform_animation_id);
+}
+
 // Tests that transitioning opacity from 0 to 1 works as expected.
 
 static const AnimationEvent* GetMostRecentPropertyUpdateEvent(
     const AnimationEventsVector* events) {
   const AnimationEvent* event = 0;
   for (size_t i = 0; i < events->size(); ++i)
     if ((*events)[i].type == AnimationEvent::PropertyUpdate)
       event = &(*events)[i];
 
   return event;
 }
 
 TEST(LayerAnimationControllerTest, TrivialTransition) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
       1,
       Animation::Opacity));
 
   controller->AddAnimation(to_add.Pass());
   controller->Animate(0.0);
   controller->UpdateState(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(1.0);
   controller->UpdateState(events.get());
   EXPECT_EQ(1.f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 }
 
 TEST(LayerAnimationControllerTest, TrivialTransitionOnImpl) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
-  controller_impl->AddObserver(&dummy_impl);
+  controller_impl->AddValueObserver(&dummy_impl);
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
       1,
       Animation::Opacity));
   to_add->set_is_impl_only(true);
 
   controller_impl->AddAnimation(to_add.Pass());
   controller_impl->Animate(0.0);
   controller_impl->UpdateState(events.get());
@@ skipping 13 matching lines @@
       GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_EQ(1.f, end_opacity_event->opacity);
 }
 
 TEST(LayerAnimationControllerTest, TrivialTransformOnImpl) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
-  controller_impl->AddObserver(&dummy_impl);
+  controller_impl->AddValueObserver(&dummy_impl);
 
   // Choose different values for x and y to avoid coincidental values in the
   // observed transforms.
   const float delta_x = 3;
   const float delta_y = 4;
 
   scoped_ptr<KeyframedTransformAnimationCurve> curve(
       KeyframedTransformAnimationCurve::Create());
 
   // Create simple Transform animation.
@@ skipping 35 matching lines @@
 
 // Tests animations that are waiting for a synchronized start time do not
 // finish.
 TEST(LayerAnimationControllerTest,
      AnimationsWaitingForStartTimeDoNotFinishIfTheyWaitLongerToStartThanTheirDuration) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
       1,
       Animation::Opacity));
   to_add->set_needs_synchronized_start_time(true);
 
   // We should pause at the first keyframe indefinitely waiting for that
   // animation to start.
   controller->AddAnimation(to_add.Pass());
   controller->Animate(0.0);
   controller->UpdateState(events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
   controller->Animate(1.0);
   controller->UpdateState(events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
   controller->Animate(2.0);
   controller->UpdateState(events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
 
   // Send the synchronized start time.
-  controller->OnAnimationStarted(AnimationEvent(
-      AnimationEvent::Started, 0, 1, Animation::Opacity, 2));
+  controller->NotifyAnimationStarted(
+      AnimationEvent(AnimationEvent::Started, 0, 1, Animation::Opacity, 2),
+      0.0);
   controller->Animate(5.0);
   controller->UpdateState(events.get());
   EXPECT_EQ(1.f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
 // Tests that two queued animations affecting the same property run in sequence.
 TEST(LayerAnimationControllerTest, TrivialQueuing) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
       1,
       Animation::Opacity));
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(
           new FakeFloatTransition(1.0, 1.f, 0.5f)).Pass(),
       2,
       Animation::Opacity));
@@ skipping 12 matching lines @@
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
 // Tests interrupting a transition with another transition.
 TEST(LayerAnimationControllerTest, Interrupt) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
       1,
       Animation::Opacity));
   controller->Animate(0.0);
   controller->UpdateState(events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
   EXPECT_EQ(0.f, dummy.opacity());
 
   scoped_ptr<Animation> to_add(CreateAnimation(
@@ skipping 17 matching lines @@
 }
 
 // Tests scheduling two animations to run together when only one property is
 // free.
 TEST(LayerAnimationControllerTest, ScheduleTogetherWhenAPropertyIsBlocked) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1)).Pass(),
       1,
       Animation::Transform));
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1)).Pass(),
       2,
       Animation::Transform));
   controller->AddAnimation(CreateAnimation(
@@ skipping 19 matching lines @@
 
 // Tests scheduling two animations to run together with different lengths and
 // another animation queued to start when the shorter animation finishes (should
 // wait for both to finish).
 TEST(LayerAnimationControllerTest, ScheduleTogetherWithAnAnimWaiting) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(2)).Pass(),
       1,
       Animation::Transform));
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
       1,
       Animation::Opacity));
   controller->AddAnimation(CreateAnimation(
@@ skipping 24 matching lines @@
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
 // Tests scheduling an animation to start in the future.
 TEST(LayerAnimationControllerTest, ScheduleAnimation) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
       1,
       Animation::Opacity));
   to_add->SetRunState(Animation::WaitingForStartTime, 0);
   to_add->set_start_time(1.f);
   controller->AddAnimation(to_add.Pass());
 
   controller->Animate(0.0);
@@ skipping 12 matching lines @@
 
 // Tests scheduling an animation to start in the future that's interrupting a
 // running animation.
 TEST(LayerAnimationControllerTest,
      ScheduledAnimationInterruptsRunningAnimation) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)).Pass(),
       1,
       Animation::Opacity));
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(
           new FakeFloatTransition(1.0, 0.5f, 0.f)).Pass(),
       2,
@@ skipping 23 matching lines @@
 
 // Tests scheduling an animation to start in the future that interrupts a
 // running animation and there is yet another animation queued to start later.
 TEST(LayerAnimationControllerTest,
      ScheduledAnimationInterruptsRunningAnimationWithAnimInQueue) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)).Pass(),
       1,
       Animation::Opacity));
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(
           new FakeFloatTransition(2.0, 0.5f, 0.f)).Pass(),
       2,
@@ skipping 32 matching lines @@
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
 // Test that a looping animation loops and for the correct number of iterations.
 TEST(LayerAnimationControllerTest, TrivialLooping) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
       1,
       Animation::Opacity));
   to_add->set_iterations(3);
   controller->AddAnimation(to_add.Pass());
 
   controller->Animate(0.0);
   controller->UpdateState(events.get());
@@ skipping 26 matching lines @@
   EXPECT_EQ(1.f, dummy.opacity());
 }
 
 // Test that an infinitely looping animation does indeed go until aborted.
 TEST(LayerAnimationControllerTest, InfiniteLooping) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   const int id = 1;
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
       id,
       Animation::Opacity));
   to_add->set_iterations(-1);
   controller->AddAnimation(to_add.Pass());
 
   controller->Animate(0.0);
@@ skipping 25 matching lines @@
   EXPECT_EQ(0.75f, dummy.opacity());
 }
 
 // Test that pausing and resuming work as expected.
 TEST(LayerAnimationControllerTest, PauseResume) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   const int id = 1;
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
       id,
       Animation::Opacity));
 
   controller->Animate(0.0);
   controller->UpdateState(events.get());
   EXPECT_TRUE(controller->HasActiveAnimation());
@@ skipping 25 matching lines @@
   EXPECT_FALSE(controller->HasActiveAnimation());
   EXPECT_EQ(1.f, dummy.opacity());
 }
 
 TEST(LayerAnimationControllerTest, AbortAGroupedAnimation) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   const int id = 1;
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1)).Pass(),
       id,
       Animation::Transform));
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)).Pass(),
       id,
       Animation::Opacity));
@@ skipping 22 matching lines @@
   controller->Animate(2.0);
   controller->UpdateState(events.get());
   EXPECT_TRUE(!controller->HasActiveAnimation());
   EXPECT_EQ(0.75f, dummy.opacity());
 }
 
 TEST(LayerAnimationControllerTest, ForceSyncWhenSynchronizedStartTimeNeeded) {
   FakeLayerAnimationValueObserver dummy_impl;
   scoped_refptr<LayerAnimationController> controller_impl(
       LayerAnimationController::Create(0));
-  controller_impl->AddObserver(&dummy_impl);
+  controller_impl->AddValueObserver(&dummy_impl);
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   scoped_ptr<Animation> to_add(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)).Pass(),
       0,
       Animation::Opacity));
   to_add->set_needs_synchronized_start_time(true);
   controller->AddAnimation(to_add.Pass());
 
   controller->Animate(0.0);
   controller->UpdateState(events.get());
@@ skipping 12 matching lines @@
             active_animation->run_state());
 }
 
 // Tests that skipping a call to UpdateState works as expected.
 TEST(LayerAnimationControllerTest, SkipUpdateState) {
   scoped_ptr<AnimationEventsVector> events(
       make_scoped_ptr(new AnimationEventsVector));
   FakeLayerAnimationValueObserver dummy;
   scoped_refptr<LayerAnimationController> controller(
       LayerAnimationController::Create(0));
-  controller->AddObserver(&dummy);
+  controller->AddValueObserver(&dummy);
 
   controller->AddAnimation(CreateAnimation(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1)).Pass(),
       1,
       Animation::Transform));
 
   controller->Animate(0.0);
   controller->UpdateState(events.get());
 
   controller->AddAnimation(CreateAnimation(
@@ skipping 19 matching lines @@
   controller->Animate(3.0);
   controller->UpdateState(events.get());
 
   // The float tranisition should now be done.
   EXPECT_EQ(1.f, dummy.opacity());
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
 }  // namespace
 }  // namespace cc