CC Animation: Make AnimationPlayer to be a unit of activation.

cc/animation/element_animations_unittest.cc

 // Copyright 2015 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/element_animations.h"
 
 #include "cc/animation/animation_delegate.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
@@ skipping 314 matching lines @@
 
   PushProperties();
 
   scoped_refptr<AnimationPlayer> player2_impl =
       timeline_impl_->GetPlayerById(player2_id);
   DCHECK(player2_impl);
 
   player2_impl->ActivateAnimations();
   EXPECT_TRUE(player2_impl->GetAnimationById(animation_id));
 
-  scoped_refptr<ElementAnimations> element_animations_impl =
-      player2_impl->element_animations();
-
-  element_animations_impl_->Animate(kInitialTickTime);
+  player2_impl->Animate(kInitialTickTime);
 
   auto events = CreateEventsForTesting();
-  element_animations_impl_->UpdateState(true, events.get());
+  player2_impl->UpdateState(true, events.get());
   EXPECT_EQ(1u, events->events_.size());
   EXPECT_EQ(AnimationEvent::STARTED, events->events_[0].type);
 
   // The actual detachment happens here, inside the callback
   player2->NotifyAnimationStarted(events->events_[0]);
   EXPECT_TRUE(delegate.started());
 }
 
 // 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_F(ElementAnimationsTest, DoNotClobberStartTimes) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   EXPECT_FALSE(player_impl_->GetAnimation(TargetProperty::OPACITY));
 
   int animation_id =
       AddOpacityTransitionToPlayer(player_.get(), 1, 0, 1, false);
 
   PushProperties();
   player_impl_->ActivateAnimations();
 
   EXPECT_TRUE(player_impl_->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             player_impl_->GetAnimationById(animation_id)->run_state());
 
   auto events = CreateEventsForTesting();
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
 
   // Synchronize the start times.
   EXPECT_EQ(1u, events->events_.size());
   player_->NotifyAnimationStarted(events->events_[0]);
   EXPECT_EQ(player_->GetAnimationById(animation_id)->start_time(),
             player_impl_->GetAnimationById(animation_id)->start_time());
 
   // Start the animation on the main thread. Should not affect the start time.
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(500));
-  element_animations_->UpdateState(true, nullptr);
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
+  player_impl_->UpdateState(true, nullptr);
   EXPECT_EQ(player_->GetAnimationById(animation_id)->start_time(),
             player_impl_->GetAnimationById(animation_id)->start_time());
 }
 
 TEST_F(ElementAnimationsTest, UseSpecifiedStartTimes) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   int animation_id =
       AddOpacityTransitionToPlayer(player_.get(), 1, 0, 1, false);
 
   const TimeTicks start_time = TicksFromSecondsF(123);
   player_->GetAnimation(TargetProperty::OPACITY)->set_start_time(start_time);
 
   PushProperties();
   player_impl_->ActivateAnimations();
 
   EXPECT_TRUE(player_impl_->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             player_impl_->GetAnimationById(animation_id)->run_state());
 
   auto events = CreateEventsForTesting();
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
 
   // Synchronize the start times.
   EXPECT_EQ(1u, events->events_.size());
   player_->NotifyAnimationStarted(events->events_[0]);
 
   EXPECT_EQ(start_time, player_->GetAnimationById(animation_id)->start_time());
   EXPECT_EQ(player_->GetAnimationById(animation_id)->start_time(),
             player_impl_->GetAnimationById(animation_id)->start_time());
 
   // Start the animation on the main thread. Should not affect the start time.
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(500));
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
+  player_->UpdateState(true, nullptr);
   EXPECT_EQ(start_time, player_->GetAnimationById(animation_id)->start_time());
   EXPECT_EQ(player_->GetAnimationById(animation_id)->start_time(),
             player_impl_->GetAnimationById(animation_id)->start_time());
 }
 
 // Tests that animationss activate and deactivate as expected.
 TEST_F(ElementAnimationsTest, Activation) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   AnimationHost* host = client_.host();
   AnimationHost* host_impl = client_impl_.host();
 
   auto events = CreateEventsForTesting();
 
   EXPECT_EQ(1u, host->all_element_animations_for_testing().size());
   EXPECT_EQ(1u, host_impl->all_element_animations_for_testing().size());
 
   // Initially, both animationss should be inactive.
-  EXPECT_EQ(0u, host->active_element_animations_for_testing().size());
-  EXPECT_EQ(0u, host_impl->active_element_animations_for_testing().size());
+  EXPECT_EQ(0u, host->active_players_for_testing().size());
+  EXPECT_EQ(0u, host_impl->active_players_for_testing().size());
 
   AddOpacityTransitionToPlayer(player_.get(), 1, 0, 1, false);
   // The main thread animations should now be active.
-  EXPECT_EQ(1u, host->active_element_animations_for_testing().size());
+  EXPECT_EQ(1u, host->active_players_for_testing().size());
 
   PushProperties();
   player_impl_->ActivateAnimations();
   // Both animationss should now be active.
-  EXPECT_EQ(1u, host->active_element_animations_for_testing().size());
-  EXPECT_EQ(1u, host_impl->active_element_animations_for_testing().size());
+  EXPECT_EQ(1u, host->active_players_for_testing().size());
+  EXPECT_EQ(1u, host_impl->active_players_for_testing().size());
 
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_EQ(1u, events->events_.size());
   player_->NotifyAnimationStarted(events->events_[0]);
 
-  EXPECT_EQ(1u, host->active_element_animations_for_testing().size());
-  EXPECT_EQ(1u, host_impl->active_element_animations_for_testing().size());
+  EXPECT_EQ(1u, host->active_players_for_testing().size());
+  EXPECT_EQ(1u, host_impl->active_players_for_testing().size());
 
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(500));
-  element_animations_->UpdateState(true, nullptr);
-  EXPECT_EQ(1u, host->active_element_animations_for_testing().size());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
+  player_->UpdateState(true, nullptr);
+  EXPECT_EQ(1u, host->active_players_for_testing().size());
 
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_->UpdateState(true, nullptr);
   EXPECT_EQ(Animation::FINISHED,
             player_->GetAnimation(TargetProperty::OPACITY)->run_state());
-  EXPECT_EQ(1u, host->active_element_animations_for_testing().size());
+  EXPECT_EQ(1u, host->active_players_for_testing().size());
 
   events = CreateEventsForTesting();
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(1500));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1500));
+  player_impl_->UpdateState(true, events.get());
 
   EXPECT_EQ(Animation::WAITING_FOR_DELETION,
             player_impl_->GetAnimation(TargetProperty::OPACITY)->run_state());
   // The impl thread animations should have de-activated.
-  EXPECT_EQ(0u, host_impl->active_element_animations_for_testing().size());
+  EXPECT_EQ(0u, host_impl->active_players_for_testing().size());
 
   EXPECT_EQ(1u, events->events_.size());
   player_->NotifyAnimationFinished(events->events_[0]);
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1500));
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1500));
+  player_->UpdateState(true, nullptr);
 
   EXPECT_EQ(Animation::WAITING_FOR_DELETION,
             player_->GetAnimation(TargetProperty::OPACITY)->run_state());
   // The main thread animations should have de-activated.
-  EXPECT_EQ(0u, host->active_element_animations_for_testing().size());
+  EXPECT_EQ(0u, host->active_players_for_testing().size());
 
   PushProperties();
   player_impl_->ActivateAnimations();
   EXPECT_FALSE(player_->has_any_animation());
   EXPECT_FALSE(player_impl_->has_any_animation());
-  EXPECT_EQ(0u, host->active_element_animations_for_testing().size());
-  EXPECT_EQ(0u, host_impl->active_element_animations_for_testing().size());
+  EXPECT_EQ(0u, host->active_players_for_testing().size());
+  EXPECT_EQ(0u, host_impl->active_players_for_testing().size());
 }
 
 TEST_F(ElementAnimationsTest, SyncPause) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   EXPECT_FALSE(player_impl_->GetAnimation(TargetProperty::OPACITY));
 
   // Two steps, three ranges: [0-1) -> 0.2, [1-2) -> 0.3, [2-3] -> 0.4.
   const double duration = 3.0;
   const int animation_id =
       AddOpacityStepsToPlayer(player_.get(), duration, 0.2f, 0.4f, 2);
 
   // Set start offset to be at the beginning of the second range.
   player_->GetAnimationById(animation_id)
       ->set_time_offset(TimeDelta::FromSecondsD(1.01));
 
   PushProperties();
   player_impl_->ActivateAnimations();
 
   EXPECT_TRUE(player_impl_->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             player_impl_->GetAnimationById(animation_id)->run_state());
 
   TimeTicks time = kInitialTickTime;
 
   // Start the animations on each animations.
   auto events = CreateEventsForTesting();
-  element_animations_impl_->Animate(time);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(time);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_EQ(1u, events->events_.size());
 
-  element_animations_->Animate(time);
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(time);
+  player_->UpdateState(true, nullptr);
   player_->NotifyAnimationStarted(events->events_[0]);
 
   EXPECT_EQ(Animation::RUNNING,
             player_impl_->GetAnimationById(animation_id)->run_state());
   EXPECT_EQ(Animation::RUNNING,
             player_->GetAnimationById(animation_id)->run_state());
 
   EXPECT_EQ(0.3f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_EQ(0.3f,
             client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   EXPECT_EQ(kInitialTickTime,
             player_->GetAnimationById(animation_id)->start_time());
   EXPECT_EQ(kInitialTickTime,
             player_impl_->GetAnimationById(animation_id)->start_time());
 
   // Pause the animation at the middle of the second range so the offset
   // delays animation until the middle of the third range.
   player_->PauseAnimation(animation_id, 1.5);
   EXPECT_EQ(Animation::PAUSED,
             player_->GetAnimationById(animation_id)->run_state());
 
   // The pause run state change should make it to the impl thread animations.
   PushProperties();
   player_impl_->ActivateAnimations();
 
   // Advance time so it stays within the first range.
   time += TimeDelta::FromMilliseconds(10);
-  element_animations_->Animate(time);
-  element_animations_impl_->Animate(time);
+  player_->Animate(time);
+  player_impl_->Animate(time);
 
   EXPECT_EQ(Animation::PAUSED,
             player_impl_->GetAnimationById(animation_id)->run_state());
 
   // Opacity value doesn't depend on time if paused at specified time offset.
   EXPECT_EQ(0.4f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_EQ(0.4f,
             client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
@@ skipping 10 matching lines @@
       AddOpacityTransitionToPlayer(player_.get(), 1, 0, 1, false);
 
   PushProperties();
   player_impl_->ActivateAnimations();
 
   EXPECT_TRUE(player_impl_->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             player_impl_->GetAnimationById(animation_id)->run_state());
 
   events = CreateEventsForTesting();
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_EQ(1u, events->events_.size());
   EXPECT_EQ(AnimationEvent::STARTED, events->events_[0].type);
 
   // Notify main thread animations that the animation has started.
   player_->NotifyAnimationStarted(events->events_[0]);
 
   // Complete animation on impl thread.
   events = CreateEventsForTesting();
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromSeconds(1));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromSeconds(1));
+  player_impl_->UpdateState(true, events.get());
   EXPECT_EQ(1u, events->events_.size());
   EXPECT_EQ(AnimationEvent::FINISHED, events->events_[0].type);
 
   player_->NotifyAnimationFinished(events->events_[0]);
 
-  element_animations_->Animate(kInitialTickTime + TimeDelta::FromSeconds(2));
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + TimeDelta::FromSeconds(2));
+  player_->UpdateState(true, nullptr);
 
   PushProperties();
   player_impl_->ActivateAnimations();
   EXPECT_FALSE(player_->GetAnimationById(animation_id));
   EXPECT_FALSE(player_impl_->GetAnimationById(animation_id));
 }
 
 // Ensure that a finished animation is eventually deleted by both the
 // main-thread and the impl-thread animationss.
 TEST_F(ElementAnimationsTest, AnimationsAreDeleted) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   auto events = CreateEventsForTesting();
 
   AddOpacityTransitionToPlayer(player_.get(), 1.0, 0.0f, 1.0f, false);
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, nullptr);
   EXPECT_TRUE(player_->needs_push_properties());
 
   PushProperties();
   EXPECT_FALSE(player_->needs_push_properties());
 
   EXPECT_FALSE(host_->needs_push_properties());
   EXPECT_FALSE(host_impl_->needs_push_properties());
 
   player_impl_->ActivateAnimations();
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(500));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
+  player_impl_->UpdateState(true, events.get());
 
   // There should be a STARTED event for the animation.
   EXPECT_EQ(1u, events->events_.size());
   EXPECT_EQ(AnimationEvent::STARTED, events->events_[0].type);
   player_->NotifyAnimationStarted(events->events_[0]);
 
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_->UpdateState(true, nullptr);
 
   EXPECT_FALSE(host_->needs_push_properties());
   EXPECT_FALSE(host_impl_->needs_push_properties());
 
   events = CreateEventsForTesting();
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(2000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_impl_->UpdateState(true, events.get());
 
   EXPECT_TRUE(host_impl_->needs_push_properties());
 
   // There should be a FINISHED event for the animation.
   EXPECT_EQ(1u, events->events_.size());
   EXPECT_EQ(AnimationEvent::FINISHED, events->events_[0].type);
 
   // Neither animations should have deleted the animation yet.
   EXPECT_TRUE(player_->GetAnimation(TargetProperty::OPACITY));
   EXPECT_TRUE(player_impl_->GetAnimation(TargetProperty::OPACITY));
 
   player_->NotifyAnimationFinished(events->events_[0]);
 
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(3000));
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
+  player_->UpdateState(true, nullptr);
   EXPECT_TRUE(host_->needs_push_properties());
 
   PushProperties();
 
   // Both animationss should now have deleted the animation. The impl animations
   // should have deleted the animation even though activation has not occurred,
   // since the animation was already waiting for deletion when
   // PushPropertiesTo was called.
   EXPECT_FALSE(player_->has_any_animation());
   EXPECT_FALSE(player_impl_->has_any_animation());
@@ skipping 24 matching lines @@
 
   auto events = CreateEventsForTesting();
 
   std::unique_ptr<Animation> to_add(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
 
   EXPECT_FALSE(player_->needs_to_start_animations());
   player_->AddAnimation(std::move(to_add));
   EXPECT_TRUE(player_->needs_to_start_animations());
-  element_animations_->Animate(kInitialTickTime);
+  player_->Animate(kInitialTickTime);
   EXPECT_FALSE(player_->needs_to_start_animations());
-  element_animations_->UpdateState(true, events.get());
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   // A non-impl-only animation should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_->UpdateState(true, events.get());
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(player_->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 }
 
 TEST_F(ElementAnimationsTest, FilterTransition) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
 
   auto events = CreateEventsForTesting();
 
   std::unique_ptr<KeyframedFilterAnimationCurve> curve(
       KeyframedFilterAnimationCurve::Create());
 
   FilterOperations start_filters;
   start_filters.Append(FilterOperation::CreateBrightnessFilter(1.f));
   curve->AddKeyframe(
       FilterKeyframe::Create(base::TimeDelta(), start_filters, nullptr));
   FilterOperations end_filters;
   end_filters.Append(FilterOperation::CreateBrightnessFilter(2.f));
   curve->AddKeyframe(FilterKeyframe::Create(base::TimeDelta::FromSecondsD(1.0),
                                             end_filters, nullptr));
 
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve), 1, 0, TargetProperty::FILTER));
   player_->AddAnimation(std::move(animation));
 
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(start_filters,
             client_.GetFilters(element_id_, ElementListType::ACTIVE));
   // A non-impl-only animation should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(500));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
+  player_->UpdateState(true, events.get());
   EXPECT_EQ(1u,
             client_.GetFilters(element_id_, ElementListType::ACTIVE).size());
   EXPECT_EQ(FilterOperation::CreateBrightnessFilter(1.5f),
             client_.GetFilters(element_id_, ElementListType::ACTIVE).at(0));
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_->UpdateState(true, events.get());
   EXPECT_EQ(end_filters,
             client_.GetFilters(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(player_->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 }
 
 TEST_F(ElementAnimationsTest, ScrollOffsetTransition) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
@@ skipping 17 matching lines @@
   PushProperties();
   player_impl_->ActivateAnimations();
   EXPECT_TRUE(player_impl_->GetAnimation(TargetProperty::SCROLL_OFFSET));
   TimeDelta duration = player_impl_->GetAnimation(TargetProperty::SCROLL_OFFSET)
                            ->curve()
                            ->Duration();
   EXPECT_EQ(duration, player_->GetAnimation(TargetProperty::SCROLL_OFFSET)
                           ->curve()
                           ->Duration());
 
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, nullptr);
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(initial_value,
             client_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_TRUE(player_impl_->HasActiveAnimation());
   EXPECT_EQ(initial_value,
             client_impl_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
   // Scroll offset animations should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   player_->NotifyAnimationStarted(events->events_[0]);
-  element_animations_->Animate(kInitialTickTime + duration / 2);
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + duration / 2);
+  player_->UpdateState(true, nullptr);
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_VECTOR2DF_EQ(
       gfx::Vector2dF(200.f, 250.f),
       client_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime + duration / 2);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + duration / 2);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(
       gfx::Vector2dF(200.f, 250.f),
       client_impl_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  element_animations_impl_->Animate(kInitialTickTime + duration);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + duration);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(target_value, client_impl_.GetScrollOffset(
                                         element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(player_impl_->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  element_animations_->Animate(kInitialTickTime + duration);
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + duration);
+  player_->UpdateState(true, nullptr);
   EXPECT_VECTOR2DF_EQ(target_value, client_.GetScrollOffset(
                                         element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(player_->HasActiveAnimation());
 }
 
 TEST_F(ElementAnimationsTest, ScrollOffsetTransitionOnImplOnly) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   auto events = CreateEventsForTesting();
 
   gfx::ScrollOffset initial_value(100.f, 300.f);
   gfx::ScrollOffset target_value(300.f, 200.f);
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurve::Create(
           target_value, CubicBezierTimingFunction::CreatePreset(
                             CubicBezierTimingFunction::EaseType::EASE_IN_OUT)));
   curve->SetInitialValue(initial_value);
   double duration_in_seconds = curve->Duration().InSecondsF();
 
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve), 1, 0, TargetProperty::SCROLL_OFFSET));
   animation->set_is_impl_only(true);
   player_impl_->AddAnimation(std::move(animation));
 
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_TRUE(player_impl_->HasActiveAnimation());
   EXPECT_EQ(initial_value,
             client_impl_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
   // Scroll offset animations should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   TimeDelta duration = TimeDelta::FromMicroseconds(
       duration_in_seconds * base::Time::kMicrosecondsPerSecond);
 
-  element_animations_impl_->Animate(kInitialTickTime + duration / 2);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + duration / 2);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(
       gfx::Vector2dF(200.f, 250.f),
       client_impl_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  element_animations_impl_->Animate(kInitialTickTime + duration);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + duration);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(target_value, client_impl_.GetScrollOffset(
                                         element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(player_impl_->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 }
 
 // This test verifies that if an animation is added after a layer is animated,
 // it doesn't get promoted to be in the RUNNING state. This prevents cases where
 // a start time gets set on an animation using the stale value of
 // last_tick_time_.
 TEST_F(ElementAnimationsTest, UpdateStateWithoutAnimate) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   auto events = CreateEventsForTesting();
 
   // Add first scroll offset animation.
   AddScrollOffsetAnimationToPlayer(player_impl_.get(),
                                    gfx::ScrollOffset(100.f, 300.f),
                                    gfx::ScrollOffset(100.f, 200.f), true);
 
   // Calling UpdateState after Animate should promote the animation to running
   // state.
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_EQ(
       Animation::RUNNING,
       player_impl_->GetAnimation(TargetProperty::SCROLL_OFFSET)->run_state());
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(1500));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1500));
+  player_impl_->UpdateState(true, events.get());
   EXPECT_EQ(
       Animation::WAITING_FOR_DELETION,
       player_impl_->GetAnimation(TargetProperty::SCROLL_OFFSET)->run_state());
 
   // Add second scroll offset animation.
   AddScrollOffsetAnimationToPlayer(player_impl_.get(),
                                    gfx::ScrollOffset(100.f, 200.f),
                                    gfx::ScrollOffset(100.f, 100.f), true);
 
   // Calling UpdateState without Animate should NOT promote the animation to
   // running state.
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->UpdateState(true, events.get());
   EXPECT_EQ(
       Animation::WAITING_FOR_TARGET_AVAILABILITY,
       player_impl_->GetAnimation(TargetProperty::SCROLL_OFFSET)->run_state());
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(2000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_impl_->UpdateState(true, events.get());
 
   EXPECT_EQ(
       Animation::RUNNING,
       player_impl_->GetAnimation(TargetProperty::SCROLL_OFFSET)->run_state());
   EXPECT_VECTOR2DF_EQ(
       gfx::ScrollOffset(100.f, 200.f),
       client_impl_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
 }
 
 // Ensure that when the impl animations doesn't have a value provider,
@@ skipping 26 matching lines @@
   PushProperties();
   player_impl_->ActivateAnimations();
   EXPECT_TRUE(player_impl_->GetAnimation(TargetProperty::SCROLL_OFFSET));
   TimeDelta duration = player_impl_->GetAnimation(TargetProperty::SCROLL_OFFSET)
                            ->curve()
                            ->Duration();
   EXPECT_EQ(duration, player_->GetAnimation(TargetProperty::SCROLL_OFFSET)
                           ->curve()
                           ->Duration());
 
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, nullptr);
 
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(initial_value,
             client_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
   EXPECT_EQ(gfx::ScrollOffset(), client_impl_.GetScrollOffset(
                                      element_id_, ElementListType::PENDING));
 
-  element_animations_impl_->Animate(kInitialTickTime);
+  player_impl_->Animate(kInitialTickTime);
 
   EXPECT_TRUE(player_impl_->HasActiveAnimation());
   EXPECT_EQ(initial_value, client_impl_.GetScrollOffset(
                                element_id_, ElementListType::PENDING));
 
   CreateTestImplLayer(ElementListType::ACTIVE);
 
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->UpdateState(true, events.get());
   DCHECK_EQ(1UL, events->events_.size());
 
   // Scroll offset animations should not generate property updates.
   const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
   player_->NotifyAnimationStarted(events->events_[0]);
-  element_animations_->Animate(kInitialTickTime + duration / 2);
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + duration / 2);
+  player_->UpdateState(true, nullptr);
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_VECTOR2DF_EQ(
       gfx::Vector2dF(400.f, 150.f),
       client_.GetScrollOffset(element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime + duration / 2);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + duration / 2);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(
       gfx::Vector2dF(400.f, 150.f),
       client_impl_.GetScrollOffset(element_id_, ElementListType::PENDING));
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  element_animations_impl_->Animate(kInitialTickTime + duration);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + duration);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_VECTOR2DF_EQ(target_value, client_impl_.GetScrollOffset(
                                         element_id_, ElementListType::PENDING));
   EXPECT_FALSE(player_impl_->HasActiveAnimation());
   event = GetMostRecentPropertyUpdateEvent(events.get());
   EXPECT_FALSE(event);
 
-  element_animations_->Animate(kInitialTickTime + duration);
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + duration);
+  player_->UpdateState(true, nullptr);
   EXPECT_VECTOR2DF_EQ(target_value, client_.GetScrollOffset(
                                         element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(player_->HasActiveAnimation());
 }
 
 TEST_F(ElementAnimationsTest, ScrollOffsetRemovalClearsScrollDelta) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   auto events = CreateEventsForTesting();
 
   // First test the 1-argument version of RemoveAnimation.
   gfx::ScrollOffset target_value(300.f, 200.f);
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurve::Create(
           target_value, CubicBezierTimingFunction::CreatePreset(
                             CubicBezierTimingFunction::EaseType::EASE_IN_OUT)));
 
   int animation_id = 1;
   std::unique_ptr<Animation> animation(Animation::Create(
       std::move(curve), animation_id, 0, TargetProperty::SCROLL_OFFSET));
   animation->set_needs_synchronized_start_time(true);
   player_->AddAnimation(std::move(animation));
   PushProperties();
-  element_animations_impl_->ActivateAnimations();
-  EXPECT_FALSE(element_animations_->scroll_offset_animation_was_interrupted());
-  EXPECT_FALSE(
-      element_animations_impl_->scroll_offset_animation_was_interrupted());
+  player_impl_->ActivateAnimations();
+  EXPECT_FALSE(player_->scroll_offset_animation_was_interrupted());
+  EXPECT_FALSE(player_impl_->scroll_offset_animation_was_interrupted());
 
   player_->RemoveAnimation(animation_id);
-  EXPECT_TRUE(element_animations_->scroll_offset_animation_was_interrupted());
+  EXPECT_TRUE(player_->scroll_offset_animation_was_interrupted());
 
   PushProperties();
-  EXPECT_TRUE(
-      element_animations_impl_->scroll_offset_animation_was_interrupted());
-  EXPECT_FALSE(element_animations_->scroll_offset_animation_was_interrupted());
+  EXPECT_TRUE(player_impl_->scroll_offset_animation_was_interrupted());
+  EXPECT_FALSE(player_->scroll_offset_animation_was_interrupted());
 
-  element_animations_impl_->ActivateAnimations();
-  EXPECT_FALSE(
-      element_animations_impl_->scroll_offset_animation_was_interrupted());
+  player_impl_->ActivateAnimations();
+  EXPECT_FALSE(player_impl_->scroll_offset_animation_was_interrupted());
 
   // Now, test the 2-argument version of RemoveAnimation.
   curve = ScrollOffsetAnimationCurve::Create(
       target_value, CubicBezierTimingFunction::CreatePreset(
                         CubicBezierTimingFunction::EaseType::EASE_IN_OUT));
   animation = Animation::Create(std::move(curve), animation_id, 0,
                                 TargetProperty::SCROLL_OFFSET);
   animation->set_needs_synchronized_start_time(true);
   player_->AddAnimation(std::move(animation));
   PushProperties();
-  element_animations_impl_->ActivateAnimations();
-  EXPECT_FALSE(element_animations_->scroll_offset_animation_was_interrupted());
-  EXPECT_FALSE(
-      element_animations_impl_->scroll_offset_animation_was_interrupted());
+  player_impl_->ActivateAnimations();
+  EXPECT_FALSE(player_->scroll_offset_animation_was_interrupted());
+  EXPECT_FALSE(player_impl_->scroll_offset_animation_was_interrupted());
 
   player_->RemoveAnimation(animation_id);
-  EXPECT_TRUE(element_animations_->scroll_offset_animation_was_interrupted());
+  EXPECT_TRUE(player_->scroll_offset_animation_was_interrupted());
 
   PushProperties();
-  EXPECT_TRUE(
-      element_animations_impl_->scroll_offset_animation_was_interrupted());
-  EXPECT_FALSE(element_animations_->scroll_offset_animation_was_interrupted());
+  EXPECT_TRUE(player_impl_->scroll_offset_animation_was_interrupted());
+  EXPECT_FALSE(player_->scroll_offset_animation_was_interrupted());
 
-  element_animations_impl_->ActivateAnimations();
-  EXPECT_FALSE(
-      element_animations_impl_->scroll_offset_animation_was_interrupted());
+  player_impl_->ActivateAnimations();
+  EXPECT_FALSE(player_impl_->scroll_offset_animation_was_interrupted());
 
   // Check that removing non-scroll-offset animations does not cause
   // scroll_offset_animation_was_interrupted() to get set.
   animation_id = AddAnimatedTransformToPlayer(player_.get(), 1.0, 1, 2);
   PushProperties();
-  element_animations_impl_->ActivateAnimations();
-  EXPECT_FALSE(element_animations_->scroll_offset_animation_was_interrupted());
-  EXPECT_FALSE(
-      element_animations_impl_->scroll_offset_animation_was_interrupted());
+  player_impl_->ActivateAnimations();
+  EXPECT_FALSE(player_->scroll_offset_animation_was_interrupted());
+  EXPECT_FALSE(player_impl_->scroll_offset_animation_was_interrupted());
 
   player_->RemoveAnimation(animation_id);
-  EXPECT_FALSE(element_animations_->scroll_offset_animation_was_interrupted());
+  EXPECT_FALSE(player_->scroll_offset_animation_was_interrupted());
 
   PushProperties();
-  EXPECT_FALSE(
-      element_animations_impl_->scroll_offset_animation_was_interrupted());
-  EXPECT_FALSE(element_animations_->scroll_offset_animation_was_interrupted());
+  EXPECT_FALSE(player_impl_->scroll_offset_animation_was_interrupted());
+  EXPECT_FALSE(player_->scroll_offset_animation_was_interrupted());
 
-  element_animations_impl_->ActivateAnimations();
-  EXPECT_FALSE(
-      element_animations_impl_->scroll_offset_animation_was_interrupted());
+  player_impl_->ActivateAnimations();
+  EXPECT_FALSE(player_impl_->scroll_offset_animation_was_interrupted());
 
   animation_id = AddAnimatedFilterToPlayer(player_.get(), 1.0, 0.1f, 0.2f);
   PushProperties();
-  element_animations_impl_->ActivateAnimations();
-  EXPECT_FALSE(element_animations_->scroll_offset_animation_was_interrupted());
-  EXPECT_FALSE(
-      element_animations_impl_->scroll_offset_animation_was_interrupted());
+  player_impl_->ActivateAnimations();
+  EXPECT_FALSE(player_->scroll_offset_animation_was_interrupted());
+  EXPECT_FALSE(player_impl_->scroll_offset_animation_was_interrupted());
 
   player_->RemoveAnimation(animation_id);
-  EXPECT_FALSE(element_animations_->scroll_offset_animation_was_interrupted());
+  EXPECT_FALSE(player_->scroll_offset_animation_was_interrupted());
 
   PushProperties();
-  EXPECT_FALSE(
-      element_animations_impl_->scroll_offset_animation_was_interrupted());
-  EXPECT_FALSE(element_animations_->scroll_offset_animation_was_interrupted());
+  EXPECT_FALSE(player_impl_->scroll_offset_animation_was_interrupted());
+  EXPECT_FALSE(player_->scroll_offset_animation_was_interrupted());
 
-  element_animations_impl_->ActivateAnimations();
-  EXPECT_FALSE(
-      element_animations_impl_->scroll_offset_animation_was_interrupted());
+  player_impl_->ActivateAnimations();
+  EXPECT_FALSE(player_impl_->scroll_offset_animation_was_interrupted());
 }
 
 // Tests that impl-only animations lead to start and finished notifications
 // on the impl thread animations's animation delegate.
 TEST_F(ElementAnimationsTest,
        NotificationsForImplOnlyAnimationsAreSentToImplThreadDelegate) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
@@ skipping 11 matching lines @@
   curve->SetInitialValue(initial_value);
   TimeDelta duration = curve->Duration();
   std::unique_ptr<Animation> to_add(
       Animation::Create(std::move(curve), 1, 0, TargetProperty::SCROLL_OFFSET));
   to_add->set_is_impl_only(true);
   player_impl_->AddAnimation(std::move(to_add));
 
   EXPECT_FALSE(delegate.started());
   EXPECT_FALSE(delegate.finished());
 
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
 
   EXPECT_TRUE(delegate.started());
   EXPECT_FALSE(delegate.finished());
 
   events = CreateEventsForTesting();
-  element_animations_impl_->Animate(kInitialTickTime + duration);
+  player_impl_->Animate(kInitialTickTime + duration);
   EXPECT_EQ(duration, player_impl_->GetAnimation(TargetProperty::SCROLL_OFFSET)
                           ->curve()
                           ->Duration());
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->UpdateState(true, events.get());
 
   EXPECT_TRUE(delegate.started());
   EXPECT_TRUE(delegate.finished());
 }
 
 // Tests that specified start times are sent to the main thread delegate
 TEST_F(ElementAnimationsTest, SpecifiedStartTimesAreSentToMainThreadDelegate) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   TestAnimationDelegate delegate;
   player_->set_animation_delegate(&delegate);
 
   int animation_id =
       AddOpacityTransitionToPlayer(player_.get(), 1, 0, 1, false);
 
   const TimeTicks start_time = TicksFromSecondsF(123);
   player_->GetAnimation(TargetProperty::OPACITY)->set_start_time(start_time);
 
   PushProperties();
   player_impl_->ActivateAnimations();
 
   EXPECT_TRUE(player_impl_->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             player_impl_->GetAnimationById(animation_id)->run_state());
 
   auto events = CreateEventsForTesting();
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
 
   // Synchronize the start times.
   EXPECT_EQ(1u, events->events_.size());
   player_->NotifyAnimationStarted(events->events_[0]);
 
   // Validate start time on the main thread delegate.
   EXPECT_EQ(start_time, delegate.start_time());
 }
 
 // Tests animations that are waiting for a synchronized start time do not
 // finish.
 TEST_F(ElementAnimationsTest,
        AnimationsWaitingForStartTimeDoNotFinishIfTheyOutwaitTheirFinish) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   auto events = CreateEventsForTesting();
 
   std::unique_ptr<Animation> to_add(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   to_add->set_needs_synchronized_start_time(true);
 
   // We should pause at the first keyframe indefinitely waiting for that
   // animation to start.
   player_->AddAnimation(std::move(to_add));
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(2000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   // Send the synchronized start time.
   player_->NotifyAnimationStarted(AnimationEvent(
       AnimationEvent::STARTED, ElementId(), 1, TargetProperty::OPACITY,
       kInitialTickTime + TimeDelta::FromMilliseconds(2000)));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(5000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(5000));
+  player_->UpdateState(true, events.get());
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(player_->HasActiveAnimation());
 }
 
 // Tests that two queued animations affecting the same property run in sequence.
 TEST_F(ElementAnimationsTest, TrivialQueuing) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   auto events = CreateEventsForTesting();
 
   EXPECT_FALSE(player_->needs_to_start_animations());
 
   player_->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   player_->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 1.f, 0.5f)),
       2, TargetProperty::OPACITY));
 
   EXPECT_TRUE(player_->needs_to_start_animations());
 
-  element_animations_->Animate(kInitialTickTime);
+  player_->Animate(kInitialTickTime);
 
   // The second animation still needs to be started.
   EXPECT_TRUE(player_->needs_to_start_animations());
 
-  element_animations_->UpdateState(true, events.get());
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   EXPECT_TRUE(player_->needs_to_start_animations());
-  element_animations_->UpdateState(true, events.get());
+  player_->UpdateState(true, events.get());
   EXPECT_FALSE(player_->needs_to_start_animations());
 
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(2000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_->UpdateState(true, events.get());
   EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(player_->HasActiveAnimation());
 }
 
 // Tests interrupting a transition with another transition.
 TEST_F(ElementAnimationsTest, Interrupt) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   auto events = CreateEventsForTesting();
 
   player_->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   std::unique_ptr<Animation> to_add(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 1.f, 0.5f)),
       2, TargetProperty::OPACITY));
   player_->AbortAnimations(TargetProperty::OPACITY, false);
   player_->AddAnimation(std::move(to_add));
 
   // Since the previous animation was aborted, the new animation should start
   // right in this call to animate.
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(500));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1500));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1500));
+  player_->UpdateState(true, events.get());
   EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(player_->HasActiveAnimation());
 }
 
 // Tests scheduling two animations to run together when only one property is
 // free.
 TEST_F(ElementAnimationsTest, ScheduleTogetherWhenAPropertyIsBlocked) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   auto events = CreateEventsForTesting();
 
   player_->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1)), 1,
       TargetProperty::TRANSFORM));
   player_->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1)), 2,
       TargetProperty::TRANSFORM));
   player_->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       2, TargetProperty::OPACITY));
 
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, events.get());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(player_->HasActiveAnimation());
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_->UpdateState(true, events.get());
   // Should not have started the float transition yet.
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   // The float animation should have started at time 1 and should be done.
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(2000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_->UpdateState(true, events.get());
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(player_->HasActiveAnimation());
 }
 
 // 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_F(ElementAnimationsTest, ScheduleTogetherWithAnAnimWaiting) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   auto events = CreateEventsForTesting();
 
   player_->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(2)), 1,
       TargetProperty::TRANSFORM));
   player_->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   player_->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 1.f, 0.5f)),
       2, TargetProperty::OPACITY));
 
   // Animations with id 1 should both start now.
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   // 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.
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(2000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_->UpdateState(true, events.get());
   // Should not have started the float transition yet.
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   // The second opacity animation should start at time 2 and should be done by
   // time 3.
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(3000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
+  player_->UpdateState(true, events.get());
   EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(player_->HasActiveAnimation());
 }
 
 // Test that a looping animation loops and for the correct number of iterations.
 TEST_F(ElementAnimationsTest, TrivialLooping) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   auto events = CreateEventsForTesting();
 
   std::unique_ptr<Animation> to_add(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   to_add->set_iterations(3);
   player_->AddAnimation(std::move(to_add));
 
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1250));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1250));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.25f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1750));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1750));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(2250));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2250));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.25f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(2750));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2750));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(3000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
+  player_->UpdateState(true, events.get());
   EXPECT_FALSE(player_->HasActiveAnimation());
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   // Just be extra sure.
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(4000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(4000));
+  player_->UpdateState(true, events.get());
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 // Test that an infinitely looping animation does indeed go until aborted.
 TEST_F(ElementAnimationsTest, InfiniteLooping) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   auto events = CreateEventsForTesting();
 
   std::unique_ptr<Animation> to_add(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   to_add->set_iterations(-1);
   player_->AddAnimation(std::move(to_add));
 
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1250));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1250));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.25f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1750));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1750));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1073741824250));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime +
+                   TimeDelta::FromMilliseconds(1073741824250));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.25f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1073741824750));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime +
+                   TimeDelta::FromMilliseconds(1073741824750));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   EXPECT_TRUE(player_->GetAnimation(TargetProperty::OPACITY));
   player_->GetAnimation(TargetProperty::OPACITY)
       ->SetRunState(Animation::ABORTED,
                     kInitialTickTime + TimeDelta::FromMilliseconds(750));
   EXPECT_FALSE(player_->HasActiveAnimation());
   EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 // Test that pausing and resuming work as expected.
 TEST_F(ElementAnimationsTest, PauseResume) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   auto events = CreateEventsForTesting();
 
   player_->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
 
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(500));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   EXPECT_TRUE(player_->GetAnimation(TargetProperty::OPACITY));
   player_->GetAnimation(TargetProperty::OPACITY)
       ->SetRunState(Animation::PAUSED,
                     kInitialTickTime + TimeDelta::FromMilliseconds(500));
 
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1024000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1024000));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   EXPECT_TRUE(player_->GetAnimation(TargetProperty::OPACITY));
   player_->GetAnimation(TargetProperty::OPACITY)
       ->SetRunState(Animation::RUNNING,
                     kInitialTickTime + TimeDelta::FromMilliseconds(1024000));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1024250));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1024250));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1024500));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1024500));
+  player_->UpdateState(true, events.get());
   EXPECT_FALSE(player_->HasActiveAnimation());
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, AbortAGroupedAnimation) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   auto events = CreateEventsForTesting();
 
   const int animation_id = 2;
   player_->AddAnimation(Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1)), 1, 1,
       TargetProperty::TRANSFORM));
   player_->AddAnimation(Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)),
       animation_id, 1, TargetProperty::OPACITY));
   player_->AddAnimation(Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 1.f, 0.75f)),
       3, 2, TargetProperty::OPACITY));
 
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   EXPECT_TRUE(player_->GetAnimationById(animation_id));
   player_->GetAnimationById(animation_id)
       ->SetRunState(Animation::ABORTED,
                     kInitialTickTime + TimeDelta::FromMilliseconds(1000));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(2000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(!player_->HasActiveAnimation());
   EXPECT_EQ(0.75f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, PushUpdatesWhenSynchronizedStartTimeNeeded) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   auto events = CreateEventsForTesting();
 
   std::unique_ptr<Animation> to_add(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)),
       0, TargetProperty::OPACITY));
   to_add->set_needs_synchronized_start_time(true);
   player_->AddAnimation(std::move(to_add));
 
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, events.get());
   EXPECT_TRUE(player_->HasActiveAnimation());
   Animation* active_animation = player_->GetAnimation(TargetProperty::OPACITY);
   EXPECT_TRUE(active_animation);
   EXPECT_TRUE(active_animation->needs_synchronized_start_time());
 
   EXPECT_TRUE(player_->needs_push_properties());
   PushProperties();
   player_impl_->ActivateAnimations();
 
   active_animation = player_impl_->GetAnimation(TargetProperty::OPACITY);
   EXPECT_TRUE(active_animation);
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             active_animation->run_state());
 }
 
 // Tests that skipping a call to UpdateState works as expected.
 TEST_F(ElementAnimationsTest, SkipUpdateState) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
 
   auto events = CreateEventsForTesting();
 
   std::unique_ptr<Animation> first_animation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1)), 1,
       TargetProperty::TRANSFORM));
   first_animation->set_is_controlling_instance_for_test(true);
   player_->AddAnimation(std::move(first_animation));
 
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, events.get());
 
   std::unique_ptr<Animation> second_animation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       2, TargetProperty::OPACITY));
   second_animation->set_is_controlling_instance_for_test(true);
   player_->AddAnimation(std::move(second_animation));
 
   // Animate but don't UpdateState.
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
 
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(2000));
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   events = CreateEventsForTesting();
-  element_animations_->UpdateState(true, events.get());
+  player_->UpdateState(true, events.get());
 
   // Should have one STARTED event and one FINISHED event.
   EXPECT_EQ(2u, events->events_.size());
   EXPECT_NE(events->events_[0].type, events->events_[1].type);
 
   // The float transition should still be at its starting point.
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(3000));
-  element_animations_->UpdateState(true, events.get());
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
+  player_->UpdateState(true, events.get());
 
   // The float tranisition should now be done.
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(player_->HasActiveAnimation());
 }
 
 // Tests that an animation animations with only a pending observer gets ticked
 // but doesn't progress animations past the STARTING state.
 TEST_F(ElementAnimationsTest, InactiveObserverGetsTicked) {
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   auto events = CreateEventsForTesting();
 
   const int id = 1;
   player_impl_->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.5f, 1.f)),
       id, TargetProperty::OPACITY));
 
   // Without an observer, the animation shouldn't progress to the STARTING
   // state.
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_EQ(0u, events->events_.size());
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             player_impl_->GetAnimation(TargetProperty::OPACITY)->run_state());
 
   CreateTestImplLayer(ElementListType::PENDING);
 
   // 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.
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(1000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_impl_->UpdateState(true, events.get());
   EXPECT_EQ(0u, events->events_.size());
   EXPECT_EQ(Animation::STARTING,
             player_impl_->GetAnimation(TargetProperty::OPACITY)->run_state());
   EXPECT_EQ(0.5f,
             client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
 
   // Even when already in the STARTING state, the animation should stay
   // there, and shouldn't be ticked past its starting point.
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(2000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_impl_->UpdateState(true, events.get());
   EXPECT_EQ(0u, events->events_.size());
   EXPECT_EQ(Animation::STARTING,
             player_impl_->GetAnimation(TargetProperty::OPACITY)->run_state());
   EXPECT_EQ(0.5f,
             client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
 
   CreateTestImplLayer(ElementListType::ACTIVE);
 
   // Now that an active observer has been added, the animation should still
   // initially tick at its starting point, but should now progress to RUNNING.
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(3000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
+  player_impl_->UpdateState(true, events.get());
   EXPECT_EQ(1u, events->events_.size());
   EXPECT_EQ(Animation::RUNNING,
             player_impl_->GetAnimation(TargetProperty::OPACITY)->run_state());
   EXPECT_EQ(0.5f,
             client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
   EXPECT_EQ(0.5f,
             client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   // The animation should now tick past its starting point.
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(3500));
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3500));
   EXPECT_NE(0.5f,
             client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
   EXPECT_NE(0.5f,
             client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, TransformAnimationBounds) {
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
@@ skipping 80 matching lines @@
   player_->AddAnimation(Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1.0)), 3, 3,
       TargetProperty::TRANSFORM));
   player_->AddAnimation(Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(2.0)), 4, 4,
       TargetProperty::TRANSFORM));
   player_->AddAnimation(Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       5, 5, TargetProperty::OPACITY));
 
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, nullptr);
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_->UpdateState(true, nullptr);
 
   EXPECT_EQ(Animation::FINISHED, player_->GetAnimationById(1)->run_state());
   EXPECT_EQ(Animation::FINISHED, player_->GetAnimationById(2)->run_state());
   EXPECT_EQ(Animation::RUNNING, player_->GetAnimationById(3)->run_state());
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             player_->GetAnimationById(4)->run_state());
   EXPECT_EQ(Animation::RUNNING, player_->GetAnimationById(5)->run_state());
 
   player_->AbortAnimations(TargetProperty::TRANSFORM, false);
 
@@ skipping 20 matching lines @@
   player_impl_->ActivateAnimations();
 
   EXPECT_TRUE(player_impl_->GetAnimationById(animation_id));
   EXPECT_FALSE(host_->needs_push_properties());
 
   player_->AbortAnimations(TargetProperty::OPACITY, false);
   EXPECT_EQ(Animation::ABORTED,
             player_->GetAnimation(TargetProperty::OPACITY)->run_state());
   EXPECT_TRUE(host_->needs_push_properties());
 
-  element_animations_->Animate(kInitialTickTime);
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime);
+  player_->UpdateState(true, nullptr);
   EXPECT_EQ(Animation::ABORTED,
             player_->GetAnimation(TargetProperty::OPACITY)->run_state());
 
   EXPECT_TRUE(player_->needs_push_properties());
   EXPECT_TRUE(player_->needs_push_properties());
   EXPECT_TRUE(host_->needs_push_properties());
 
   PushProperties();
   EXPECT_FALSE(host_->needs_push_properties());
   EXPECT_FALSE(player_->needs_push_properties());
@@ skipping 20 matching lines @@
   player_impl_->ActivateAnimations();
   EXPECT_TRUE(player_impl_->GetAnimationById(animation_id));
 
   player_impl_->AbortAnimations(TargetProperty::OPACITY, false);
   EXPECT_EQ(Animation::ABORTED,
             player_impl_->GetAnimation(TargetProperty::OPACITY)->run_state());
   EXPECT_TRUE(host_impl_->needs_push_properties());
   EXPECT_TRUE(player_impl_->needs_push_properties());
 
   auto events = CreateEventsForTesting();
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_TRUE(host_impl_->needs_push_properties());
   EXPECT_EQ(1u, events->events_.size());
   EXPECT_EQ(AnimationEvent::ABORTED, events->events_[0].type);
   EXPECT_EQ(Animation::WAITING_FOR_DELETION,
             player_impl_->GetAnimation(TargetProperty::OPACITY)->run_state());
 
   player_->NotifyAnimationAborted(events->events_[0]);
   EXPECT_EQ(Animation::ABORTED,
             player_->GetAnimation(TargetProperty::OPACITY)->run_state());
   EXPECT_TRUE(delegate.aborted());
 
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(500));
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
+  player_->UpdateState(true, nullptr);
   EXPECT_TRUE(host_->needs_push_properties());
   EXPECT_EQ(Animation::WAITING_FOR_DELETION,
             player_->GetAnimation(TargetProperty::OPACITY)->run_state());
 
   PushProperties();
 
   player_impl_->ActivateAnimations();
   EXPECT_FALSE(player_->GetAnimationById(animation_id));
   EXPECT_FALSE(player_impl_->GetAnimationById(animation_id));
 }
@@ skipping 31 matching lines @@
   player_impl_->ActivateAnimations();
   EXPECT_TRUE(player_impl_->GetAnimationById(animation_id));
 
   player_impl_->AbortAnimations(TargetProperty::SCROLL_OFFSET, true);
   EXPECT_TRUE(host_impl_->needs_push_properties());
   EXPECT_EQ(
       Animation::ABORTED_BUT_NEEDS_COMPLETION,
       player_impl_->GetAnimation(TargetProperty::SCROLL_OFFSET)->run_state());
 
   auto events = CreateEventsForTesting();
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_TRUE(delegate_impl.finished());
   EXPECT_TRUE(host_impl_->needs_push_properties());
   EXPECT_EQ(1u, events->events_.size());
   EXPECT_EQ(AnimationEvent::TAKEOVER, events->events_[0].type);
   EXPECT_EQ(123, events->events_[0].animation_start_time);
   EXPECT_EQ(
       target_value,
       events->events_[0].curve->ToScrollOffsetAnimationCurve()->target_value());
   EXPECT_EQ(
       Animation::WAITING_FOR_DELETION,
@@ skipping 33 matching lines @@
       group_id, TargetProperty::TRANSFORM));
   first_animation->set_is_controlling_instance_for_test(true);
   player_impl_->AddAnimation(std::move(first_animation));
 
   std::unique_ptr<Animation> second_animation(Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       2, group_id, TargetProperty::OPACITY));
   second_animation->set_is_controlling_instance_for_test(true);
   player_impl_->AddAnimation(std::move(second_animation));
 
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
 
   // Both animations should have started.
   EXPECT_EQ(2u, events->events_.size());
   EXPECT_EQ(AnimationEvent::STARTED, events->events_[0].type);
   EXPECT_EQ(AnimationEvent::STARTED, events->events_[1].type);
 
   events = CreateEventsForTesting();
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(1000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_impl_->UpdateState(true, events.get());
 
   // The opacity animation should be finished, but should not have generated
   // a FINISHED event yet.
   EXPECT_EQ(0u, events->events_.size());
   EXPECT_EQ(Animation::FINISHED,
             player_impl_->GetAnimationById(2)->run_state());
   EXPECT_EQ(Animation::RUNNING, player_impl_->GetAnimationById(1)->run_state());
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(2000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_impl_->UpdateState(true, events.get());
 
   // Both animations should have generated FINISHED events.
   EXPECT_EQ(2u, events->events_.size());
   EXPECT_EQ(AnimationEvent::FINISHED, events->events_[0].type);
   EXPECT_EQ(AnimationEvent::FINISHED, events->events_[1].type);
 }
 
 // Ensure that when a group has a mix of aborted and finished animations,
 // we generate a FINISHED event for the finished animation and an ABORTED
 // event for the aborted animation.
@@ skipping 10 matching lines @@
       TargetProperty::TRANSFORM));
   first_animation->set_is_controlling_instance_for_test(true);
   player_impl_->AddAnimation(std::move(first_animation));
 
   std::unique_ptr<Animation> second_animation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   second_animation->set_is_controlling_instance_for_test(true);
   player_impl_->AddAnimation(std::move(second_animation));
 
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
 
   // Both animations should have started.
   EXPECT_EQ(2u, events->events_.size());
   EXPECT_EQ(AnimationEvent::STARTED, events->events_[0].type);
   EXPECT_EQ(AnimationEvent::STARTED, events->events_[1].type);
 
   player_impl_->AbortAnimations(TargetProperty::OPACITY, false);
 
   events = CreateEventsForTesting();
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(1000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_impl_->UpdateState(true, events.get());
 
   // We should have exactly 2 events: a FINISHED event for the tranform
   // animation, and an ABORTED event for the opacity animation.
   EXPECT_EQ(2u, events->events_.size());
   EXPECT_EQ(AnimationEvent::FINISHED, events->events_[0].type);
   EXPECT_EQ(TargetProperty::TRANSFORM, events->events_[0].target_property);
   EXPECT_EQ(AnimationEvent::ABORTED, events->events_[1].type);
   EXPECT_EQ(TargetProperty::OPACITY, events->events_[1].target_property);
 }
 
@@ skipping 412 matching lines @@
   EXPECT_TRUE(player_impl_->needs_to_start_animations());
 
   EXPECT_TRUE(player_impl_->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             player_impl_->GetAnimationById(animation_id)->run_state());
   EXPECT_TRUE(
       player_impl_->GetAnimationById(animation_id)->affects_pending_elements());
   EXPECT_FALSE(
       player_impl_->GetAnimationById(animation_id)->affects_active_elements());
 
-  element_animations_impl_->Animate(kInitialTickTime);
+  player_impl_->Animate(kInitialTickTime);
   EXPECT_FALSE(player_impl_->needs_to_start_animations());
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->UpdateState(true, events.get());
 
   // Since the animation hasn't been activated, it should still be STARTING
   // rather than RUNNING.
   EXPECT_EQ(Animation::STARTING,
             player_impl_->GetAnimationById(animation_id)->run_state());
 
   // Since the animation hasn't been activated, only the pending observer
   // should have been ticked.
   EXPECT_EQ(0.5f,
             client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
   EXPECT_EQ(0.f, client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   player_impl_->ActivateAnimations();
   EXPECT_TRUE(
       player_impl_->GetAnimationById(animation_id)->affects_pending_elements());
   EXPECT_TRUE(
       player_impl_->GetAnimationById(animation_id)->affects_active_elements());
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(1000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_impl_->UpdateState(true, events.get());
 
   // Since the animation has been activated, it should have reached the
   // RUNNING state and the active observer should start to get ticked.
   EXPECT_EQ(Animation::RUNNING,
             player_impl_->GetAnimationById(animation_id)->run_state());
   EXPECT_EQ(0.5f,
             client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
   EXPECT_EQ(0.5f,
             client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
@@ skipping 11 matching lines @@
   PushProperties();
 
   EXPECT_TRUE(player_impl_->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             player_impl_->GetAnimationById(animation_id)->run_state());
   EXPECT_TRUE(
       player_impl_->GetAnimationById(animation_id)->affects_pending_elements());
   EXPECT_FALSE(
       player_impl_->GetAnimationById(animation_id)->affects_active_elements());
 
-  element_animations_impl_->Animate(kInitialTickTime);
+  player_impl_->Animate(kInitialTickTime);
 
   // Since the animation hasn't been activated, only the pending observer
   // should have been ticked.
   EXPECT_EQ(0.5f,
             client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
   EXPECT_EQ(0.f, client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   player_impl_->ActivateAnimations();
   EXPECT_TRUE(
       player_impl_->GetAnimationById(animation_id)->affects_pending_elements());
   EXPECT_TRUE(
       player_impl_->GetAnimationById(animation_id)->affects_active_elements());
 
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->UpdateState(true, events.get());
 
   // Since the animation has been activated, it should have reached the
   // RUNNING state.
   EXPECT_EQ(Animation::RUNNING,
             player_impl_->GetAnimationById(animation_id)->run_state());
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(500));
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
 
   // Both elements should have been ticked.
   EXPECT_EQ(0.75f,
             client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
   EXPECT_EQ(0.75f,
             client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, ObserverNotifiedWhenTransformAnimationChanges) {
   CreateTestLayer(true, true);
@@ skipping 25 matching lines @@
   PushProperties();
   EXPECT_TRUE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->ActivateAnimations();
+  player_impl_->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
 
   player_->NotifyAnimationStarted(events->events_[0]);
   events->events_.clear();
 
   // Finish the animation.
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_->UpdateState(true, nullptr);
   EXPECT_FALSE(client_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   PushProperties();
 
   // animations_impl hasn't yet ticked at/past the end of the animation.
   EXPECT_TRUE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(1000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_impl_->UpdateState(true, events.get());
   EXPECT_FALSE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   // Case 2: An animation that's removed before it finishes.
@@ skipping 11 matching lines @@
   PushProperties();
   EXPECT_TRUE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->ActivateAnimations();
+  player_impl_->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   // animation1 is in effect currently and animation2 isn't. As the element has
   // atleast one animation that's in effect currently, client should be notified
   // that the transform is currently animating.
   EXPECT_TRUE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(2000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_impl_->UpdateState(true, events.get());
 
   player_->NotifyAnimationStarted(events->events_[0]);
   events->events_.clear();
 
   player_->RemoveAnimation(animation_id);
   player_->RemoveAnimation(animation2_id);
   EXPECT_FALSE(client_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   PushProperties();
   EXPECT_FALSE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->ActivateAnimations();
+  player_impl_->ActivateAnimations();
   EXPECT_FALSE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   // Case 3: An animation that's aborted before it finishes.
   animation_id = AddAnimatedTransformToPlayer(player_.get(), 10.0, 3, 3);
   EXPECT_TRUE(client_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   PushProperties();
   EXPECT_TRUE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->ActivateAnimations();
+  player_impl_->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(2000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_impl_->UpdateState(true, events.get());
 
   player_->NotifyAnimationStarted(events->events_[0]);
   events->events_.clear();
 
   player_impl_->AbortAnimations(TargetProperty::TRANSFORM, false);
   EXPECT_FALSE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(4000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(4000));
+  player_impl_->UpdateState(true, events.get());
 
   element_animations_->NotifyAnimationAborted(events->events_[0]);
   EXPECT_FALSE(client_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   // Case 4 : An animation that's not in effect.
   animation_id = AddAnimatedTransformToPlayer(player_.get(), 1.0, 1, 6);
   player_->GetAnimationById(animation_id)
       ->set_time_offset(base::TimeDelta::FromMilliseconds(-10000));
   player_->GetAnimationById(animation_id)
       ->set_fill_mode(Animation::FillMode::NONE);
 
   PushProperties();
   EXPECT_TRUE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->ActivateAnimations();
+  player_impl_->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, ObserverNotifiedWhenOpacityAnimationChanges) {
   CreateTestLayer(true, true);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
@@ skipping 24 matching lines @@
   PushProperties();
   EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->ActivateAnimations();
+  player_impl_->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
 
   player_->NotifyAnimationStarted(events->events_[0]);
   events->events_.clear();
 
   // Finish the animation.
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_->UpdateState(true, nullptr);
   EXPECT_FALSE(client_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetOpacityIsCurrentlyAnimating(element_id_,
                                                       ElementListType::ACTIVE));
 
   PushProperties();
 
   // animations_impl hasn't yet ticked at/past the end of the animation.
   EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(1000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_impl_->UpdateState(true, events.get());
   EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   // Case 2: An animation that's removed before it finishes.
   int animation_id = AddOpacityTransitionToPlayer(
       player_.get(), 10.0, 0.f, 1.f, false /*use_timing_function*/);
   EXPECT_TRUE(client_.GetHasPotentialOpacityAnimation(element_id_,
                                                       ElementListType::ACTIVE));
   EXPECT_TRUE(client_.GetOpacityIsCurrentlyAnimating(element_id_,
                                                      ElementListType::ACTIVE));
 
   PushProperties();
   EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->ActivateAnimations();
+  player_impl_->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(2000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_impl_->UpdateState(true, events.get());
 
   player_->NotifyAnimationStarted(events->events_[0]);
   events->events_.clear();
 
   player_->RemoveAnimation(animation_id);
   EXPECT_FALSE(client_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetOpacityIsCurrentlyAnimating(element_id_,
                                                       ElementListType::ACTIVE));
 
   PushProperties();
   EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->ActivateAnimations();
+  player_impl_->ActivateAnimations();
   EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   // Case 3: An animation that's aborted before it finishes.
   animation_id = AddOpacityTransitionToPlayer(player_.get(), 10.0, 0.f, 0.5f,
                                               false /*use_timing_function*/);
   EXPECT_TRUE(client_.GetHasPotentialOpacityAnimation(element_id_,
                                                       ElementListType::ACTIVE));
   EXPECT_TRUE(client_.GetOpacityIsCurrentlyAnimating(element_id_,
                                                      ElementListType::ACTIVE));
 
   PushProperties();
   EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->ActivateAnimations();
+  player_impl_->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(2000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_impl_->UpdateState(true, events.get());
 
   player_->NotifyAnimationStarted(events->events_[0]);
   events->events_.clear();
 
   player_impl_->AbortAnimations(TargetProperty::OPACITY, false);
   EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(4000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(4000));
+  player_impl_->UpdateState(true, events.get());
 
   element_animations_->NotifyAnimationAborted(events->events_[0]);
   EXPECT_FALSE(client_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetOpacityIsCurrentlyAnimating(element_id_,
                                                       ElementListType::ACTIVE));
 
   // Case 4 : An animation that's not in effect.
   animation_id = AddOpacityTransitionToPlayer(player_.get(), 1.0, 0.f, 0.5f,
                                               false /*use_timing_function*/);
   player_->GetAnimationById(animation_id)
       ->set_time_offset(base::TimeDelta::FromMilliseconds(-10000));
   player_->GetAnimationById(animation_id)
       ->set_fill_mode(Animation::FillMode::NONE);
 
   PushProperties();
   EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->ActivateAnimations();
+  player_impl_->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, ObserverNotifiedWhenFilterAnimationChanges) {
   CreateTestLayer(true, true);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
@@ skipping 23 matching lines @@
   PushProperties();
   EXPECT_TRUE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->ActivateAnimations();
+  player_impl_->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
 
   player_->NotifyAnimationStarted(events->events_[0]);
   events->events_.clear();
 
   // Finish the animation.
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_->UpdateState(true, nullptr);
   EXPECT_FALSE(client_.GetHasPotentialFilterAnimation(element_id_,
                                                       ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetFilterIsCurrentlyAnimating(element_id_,
                                                      ElementListType::ACTIVE));
 
   PushProperties();
 
   // animations_impl hasn't yet ticked at/past the end of the animation.
   EXPECT_TRUE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(1000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_impl_->UpdateState(true, events.get());
   EXPECT_FALSE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   // Case 2: An animation that's removed before it finishes.
   int animation_id = AddAnimatedFilterToPlayer(player_.get(), 10.0, 0.f, 1.f);
   EXPECT_TRUE(client_.GetHasPotentialFilterAnimation(element_id_,
                                                      ElementListType::ACTIVE));
   EXPECT_TRUE(client_.GetFilterIsCurrentlyAnimating(element_id_,
                                                     ElementListType::ACTIVE));
 
   PushProperties();
   EXPECT_TRUE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->ActivateAnimations();
+  player_impl_->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(2000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_impl_->UpdateState(true, events.get());
 
   player_->NotifyAnimationStarted(events->events_[0]);
   events->events_.clear();
 
   player_->RemoveAnimation(animation_id);
   EXPECT_FALSE(client_.GetHasPotentialFilterAnimation(element_id_,
                                                       ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetFilterIsCurrentlyAnimating(element_id_,
                                                      ElementListType::ACTIVE));
 
   PushProperties();
   EXPECT_FALSE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->ActivateAnimations();
+  player_impl_->ActivateAnimations();
   EXPECT_FALSE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   // Case 3: An animation that's aborted before it finishes.
   animation_id = AddAnimatedFilterToPlayer(player_.get(), 10.0, 0.f, 0.5f);
   EXPECT_TRUE(client_.GetHasPotentialFilterAnimation(element_id_,
                                                      ElementListType::ACTIVE));
   EXPECT_TRUE(client_.GetFilterIsCurrentlyAnimating(element_id_,
                                                     ElementListType::ACTIVE));
 
   PushProperties();
   EXPECT_TRUE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_TRUE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->ActivateAnimations();
+  player_impl_->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(2000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_impl_->UpdateState(true, events.get());
 
   player_->NotifyAnimationStarted(events->events_[0]);
   events->events_.clear();
 
   player_impl_->AbortAnimations(TargetProperty::FILTER, false);
   EXPECT_FALSE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(4000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(4000));
+  player_impl_->UpdateState(true, events.get());
 
   element_animations_->NotifyAnimationAborted(events->events_[0]);
   EXPECT_FALSE(client_.GetHasPotentialFilterAnimation(element_id_,
                                                       ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetFilterIsCurrentlyAnimating(element_id_,
                                                      ElementListType::ACTIVE));
 
   // Case 4 : An animation that's not in effect.
   animation_id = AddAnimatedFilterToPlayer(player_.get(), 1.0, 0.f, 0.5f);
   player_->GetAnimationById(animation_id)
       ->set_time_offset(base::TimeDelta::FromMilliseconds(-10000));
   player_->GetAnimationById(animation_id)
       ->set_fill_mode(Animation::FillMode::NONE);
 
   PushProperties();
   EXPECT_TRUE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  element_animations_impl_->ActivateAnimations();
+  player_impl_->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, ClippedOpacityValues) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   AddOpacityTransitionToPlayer(player_.get(), 1, 1.f, 2.f, true);
 
-  element_animations_->Animate(kInitialTickTime);
+  player_->Animate(kInitialTickTime);
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   // Opacity values are clipped [0,1]
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, ClippedNegativeOpacityValues) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   AddOpacityTransitionToPlayer(player_.get(), 1, 0.f, -2.f, true);
 
-  element_animations_->Animate(kInitialTickTime);
+  player_->Animate(kInitialTickTime);
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   // Opacity values are clipped [0,1]
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1000));
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, PushedDeletedAnimationWaitsForActivation) {
   CreateTestLayer(true, true);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   auto events = CreateEventsForTesting();
 
   const int animation_id =
       AddOpacityTransitionToPlayer(player_.get(), 1, 0.5f, 1.f, true);
 
   PushProperties();
   player_impl_->ActivateAnimations();
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
   EXPECT_EQ(Animation::RUNNING,
             player_impl_->GetAnimationById(animation_id)->run_state());
   EXPECT_EQ(0.5f,
             client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
   EXPECT_EQ(0.5f,
             client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   EXPECT_TRUE(
       player_impl_->GetAnimationById(animation_id)->affects_pending_elements());
   EXPECT_TRUE(
       player_impl_->GetAnimationById(animation_id)->affects_active_elements());
 
   // Delete the animation on the main-thread animations.
   player_->RemoveAnimation(
       player_->GetAnimation(TargetProperty::OPACITY)->id());
   PushProperties();
 
   // The animation should no longer affect pending elements.
   EXPECT_FALSE(
       player_impl_->GetAnimationById(animation_id)->affects_pending_elements());
   EXPECT_TRUE(
       player_impl_->GetAnimationById(animation_id)->affects_active_elements());
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(500));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
+  player_impl_->UpdateState(true, events.get());
 
   // Only the active observer should have been ticked.
   EXPECT_EQ(0.5f,
             client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
   EXPECT_EQ(0.75f,
             client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   player_impl_->ActivateAnimations();
 
   // Activation should cause the animation to be deleted.
   EXPECT_FALSE(player_impl_->has_any_animation());
 }
 
 // Tests that an animation that affects only active elements won't block
 // an animation that affects only pending elements from starting.
 TEST_F(ElementAnimationsTest, StartAnimationsAffectingDifferentObservers) {
   CreateTestLayer(true, true);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   auto events = CreateEventsForTesting();
 
   const int first_animation_id =
       AddOpacityTransitionToPlayer(player_.get(), 1, 0.f, 1.f, true);
 
   PushProperties();
   player_impl_->ActivateAnimations();
-  element_animations_impl_->Animate(kInitialTickTime);
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime);
+  player_impl_->UpdateState(true, events.get());
 
   // Remove the first animation from the main-thread animations, and add a
   // new animation affecting the same property.
   player_->RemoveAnimation(
       player_->GetAnimation(TargetProperty::OPACITY)->id());
   const int second_animation_id =
       AddOpacityTransitionToPlayer(player_.get(), 1, 1.f, 0.5f, true);
   PushProperties();
 
   // The original animation should only affect active elements, and the new
   // animation should only affect pending elements.
   EXPECT_FALSE(player_impl_->GetAnimationById(first_animation_id)
                    ->affects_pending_elements());
   EXPECT_TRUE(player_impl_->GetAnimationById(first_animation_id)
                   ->affects_active_elements());
   EXPECT_TRUE(player_impl_->GetAnimationById(second_animation_id)
                   ->affects_pending_elements());
   EXPECT_FALSE(player_impl_->GetAnimationById(second_animation_id)
                    ->affects_active_elements());
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(500));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
+  player_impl_->UpdateState(true, events.get());
 
   // The original animation should still be running, and the new animation
   // should be starting.
   EXPECT_EQ(Animation::RUNNING,
             player_impl_->GetAnimationById(first_animation_id)->run_state());
   EXPECT_EQ(Animation::STARTING,
             player_impl_->GetAnimationById(second_animation_id)->run_state());
 
   // The active observer should have been ticked by the original animation,
   // and the pending observer should have been ticked by the new animation.
   EXPECT_EQ(1.f,
             client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
   EXPECT_EQ(0.5f,
             client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   player_impl_->ActivateAnimations();
 
   // The original animation should have been deleted, and the new animation
   // should now affect both elements.
   EXPECT_FALSE(player_impl_->GetAnimationById(first_animation_id));
   EXPECT_TRUE(player_impl_->GetAnimationById(second_animation_id)
                   ->affects_pending_elements());
   EXPECT_TRUE(player_impl_->GetAnimationById(second_animation_id)
                   ->affects_active_elements());
 
-  element_animations_impl_->Animate(kInitialTickTime +
-                                    TimeDelta::FromMilliseconds(1000));
-  element_animations_impl_->UpdateState(true, events.get());
+  player_impl_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
+  player_impl_->UpdateState(true, events.get());
 
   // The new animation should be running, and the active observer should have
   // been ticked at the new animation's starting point.
   EXPECT_EQ(Animation::RUNNING,
             player_impl_->GetAnimationById(second_animation_id)->run_state());
   EXPECT_EQ(1.f,
             client_impl_.GetOpacity(element_id_, ElementListType::PENDING));
   EXPECT_EQ(1.f, client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, TestIsCurrentlyAnimatingProperty) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   // Create an animation that initially affects only pending elements.
   std::unique_ptr<Animation> animation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   animation->set_affects_active_elements(false);
 
   player_->AddAnimation(std::move(animation));
-  element_animations_->Animate(kInitialTickTime);
+  player_->Animate(kInitialTickTime);
   EXPECT_TRUE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                     ElementListType::PENDING));
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                      ElementListType::ACTIVE));
-  element_animations_->UpdateState(true, nullptr);
+  player_->UpdateState(true, nullptr);
   EXPECT_TRUE(player_->HasActiveAnimation());
 
   EXPECT_TRUE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                     ElementListType::PENDING));
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                      ElementListType::ACTIVE));
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
                                                      ElementListType::PENDING));
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
                                                      ElementListType::ACTIVE));
 
   player_->ActivateAnimations();
 
   EXPECT_TRUE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                     ElementListType::PENDING));
   EXPECT_TRUE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                     ElementListType::ACTIVE));
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
                                                      ElementListType::PENDING));
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
                                                      ElementListType::ACTIVE));
 
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(10));
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(10));
+  player_->UpdateState(true, nullptr);
 
   EXPECT_TRUE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                     ElementListType::PENDING));
   EXPECT_TRUE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                     ElementListType::ACTIVE));
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
                                                      ElementListType::PENDING));
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
                                                      ElementListType::ACTIVE));
 
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   // Tick past the end of the animation.
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(1100));
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1100));
+  player_->UpdateState(true, nullptr);
 
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                      ElementListType::PENDING));
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                      ElementListType::ACTIVE));
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
                                                      ElementListType::PENDING));
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::FILTER,
                                                      ElementListType::ACTIVE));
 
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, TestIsAnimatingPropertyTimeOffsetFillMode) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   // Create an animation that initially affects only pending elements, and has
   // a start delay of 2 seconds.
   std::unique_ptr<Animation> animation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
   animation->set_fill_mode(Animation::FillMode::NONE);
   animation->set_time_offset(TimeDelta::FromMilliseconds(-2000));
   animation->set_affects_active_elements(false);
 
   player_->AddAnimation(std::move(animation));
 
-  element_animations_->Animate(kInitialTickTime);
+  player_->Animate(kInitialTickTime);
 
   // Since the animation has a start delay, the elements it affects have a
   // potentially running transform animation but aren't currently animating
   // transform.
   EXPECT_TRUE(player_->IsPotentiallyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::PENDING));
   EXPECT_FALSE(player_->IsPotentiallyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::ACTIVE));
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                      ElementListType::PENDING));
@@ skipping 14 matching lines @@
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                      ElementListType::PENDING));
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                      ElementListType::ACTIVE));
   EXPECT_TRUE(player_->HasActiveAnimation());
   EXPECT_FALSE(player_->IsPotentiallyAnimatingProperty(
       TargetProperty::FILTER, ElementListType::PENDING));
   EXPECT_FALSE(player_->IsPotentiallyAnimatingProperty(
       TargetProperty::FILTER, ElementListType::ACTIVE));
 
-  element_animations_->UpdateState(true, nullptr);
+  player_->UpdateState(true, nullptr);
 
   // Tick past the start delay.
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(2000));
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
+  player_->UpdateState(true, nullptr);
   EXPECT_TRUE(player_->IsPotentiallyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::PENDING));
   EXPECT_TRUE(player_->IsPotentiallyAnimatingProperty(TargetProperty::OPACITY,
                                                       ElementListType::ACTIVE));
   EXPECT_TRUE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                     ElementListType::PENDING));
   EXPECT_TRUE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                     ElementListType::ACTIVE));
 
   // After the animaton finishes, the elements it affects have neither a
   // potentially running transform animation nor a currently running transform
   // animation.
-  element_animations_->Animate(kInitialTickTime +
-                               TimeDelta::FromMilliseconds(4000));
-  element_animations_->UpdateState(true, nullptr);
+  player_->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(4000));
+  player_->UpdateState(true, nullptr);
   EXPECT_FALSE(player_->IsPotentiallyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::PENDING));
   EXPECT_FALSE(player_->IsPotentiallyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::ACTIVE));
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                      ElementListType::PENDING));
   EXPECT_FALSE(player_->IsCurrentlyAnimatingProperty(TargetProperty::OPACITY,
                                                      ElementListType::ACTIVE));
 }
 
 TEST_F(ElementAnimationsTest, DestroyTestMainLayerBeforePushProperties) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
-  EXPECT_EQ(0u, host_->active_element_animations_for_testing().size());
+  EXPECT_EQ(0u, host_->active_players_for_testing().size());
 
   player_->AddAnimation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 1.f, 0.5f)),
       2, TargetProperty::OPACITY));
-  EXPECT_EQ(1u, host_->active_element_animations_for_testing().size());
+  EXPECT_EQ(1u, host_->active_players_for_testing().size());
 
   DestroyTestMainLayer();
-  EXPECT_EQ(0u, host_->active_element_animations_for_testing().size());
+  EXPECT_EQ(0u, host_->active_players_for_testing().size());
 
   PushProperties();
-  EXPECT_EQ(0u, host_->active_element_animations_for_testing().size());
-  EXPECT_EQ(0u, host_impl_->active_element_animations_for_testing().size());
+  EXPECT_EQ(0u, host_->active_players_for_testing().size());
+  EXPECT_EQ(0u, host_impl_->active_players_for_testing().size());
 }
 
 }  // namespace
 }  // namespace cc