CC Animation: Move animations_ from ElementAnimations to AnimationPlayer.

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_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
@@ skipping 43 matching lines @@
   timeline_->AttachPlayer(player_);
   player_->AttachElement(element_id_);
 
   scoped_refptr<ElementAnimations> element_animations =
       player_->element_animations();
   EXPECT_TRUE(element_animations);
 
   EXPECT_TRUE(element_animations->has_element_in_active_list());
   EXPECT_FALSE(element_animations->has_element_in_pending_list());
 
-  host_->PushPropertiesTo(host_impl_);
+  PushProperties();
 
   GetImplTimelineAndPlayerByID();
 
   scoped_refptr<ElementAnimations> element_animations_impl =
       player_impl_->element_animations();
   EXPECT_TRUE(element_animations_impl);
 
   EXPECT_FALSE(element_animations_impl->has_element_in_active_list());
   EXPECT_TRUE(element_animations_impl->has_element_in_pending_list());
 
   // Create the layer in the impl active tree.
   client_impl_.RegisterElement(element_id_, ElementListType::ACTIVE);
   EXPECT_TRUE(element_animations_impl->has_element_in_active_list());
   EXPECT_TRUE(element_animations_impl->has_element_in_pending_list());
 
   EXPECT_TRUE(
       client_impl_.IsElementInList(element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(
       client_impl_.IsElementInList(element_id_, ElementListType::PENDING));
 
   // kill layer on main thread.
   client_.UnregisterElement(element_id_, ElementListType::ACTIVE);
   EXPECT_EQ(element_animations, player_->element_animations());
   EXPECT_FALSE(element_animations->has_element_in_active_list());
   EXPECT_FALSE(element_animations->has_element_in_pending_list());
 
   // Sync doesn't detach LayerImpl.
-  host_->PushPropertiesTo(host_impl_);
+  PushProperties();
   EXPECT_EQ(element_animations_impl, player_impl_->element_animations());
   EXPECT_TRUE(element_animations_impl->has_element_in_active_list());
   EXPECT_TRUE(element_animations_impl->has_element_in_pending_list());
 
   // Kill layer on impl thread in pending tree.
   client_impl_.UnregisterElement(element_id_, ElementListType::PENDING);
   EXPECT_EQ(element_animations_impl, player_impl_->element_animations());
   EXPECT_TRUE(element_animations_impl->has_element_in_active_list());
   EXPECT_FALSE(element_animations_impl->has_element_in_pending_list());
 
   // Kill layer on impl thread in active tree.
   client_impl_.UnregisterElement(element_id_, ElementListType::ACTIVE);
   EXPECT_EQ(element_animations_impl, player_impl_->element_animations());
   EXPECT_FALSE(element_animations_impl->has_element_in_active_list());
   EXPECT_FALSE(element_animations_impl->has_element_in_pending_list());
 
   // Sync doesn't change anything.
-  host_->PushPropertiesTo(host_impl_);
+  PushProperties();
   EXPECT_EQ(element_animations_impl, player_impl_->element_animations());
   EXPECT_FALSE(element_animations_impl->has_element_in_active_list());
   EXPECT_FALSE(element_animations_impl->has_element_in_pending_list());
 
   player_->DetachElement();
   EXPECT_FALSE(player_->element_animations());
 
   // Release ptrs now to test the order of destruction.
   ReleaseRefPtrs();
 }
 
 TEST_F(ElementAnimationsTest, AttachToNotYetCreatedLayer) {
   host_->AddAnimationTimeline(timeline_);
   timeline_->AttachPlayer(player_);
 
-  host_->PushPropertiesTo(host_impl_);
-
+  PushProperties();
   GetImplTimelineAndPlayerByID();
 
   player_->AttachElement(element_id_);
 
   scoped_refptr<ElementAnimations> element_animations =
       player_->element_animations();
   EXPECT_TRUE(element_animations);
 
   EXPECT_FALSE(element_animations->has_element_in_active_list());
   EXPECT_FALSE(element_animations->has_element_in_pending_list());
 
-  host_->PushPropertiesTo(host_impl_);
+  PushProperties();
 
   scoped_refptr<ElementAnimations> element_animations_impl =
       player_impl_->element_animations();
   EXPECT_TRUE(element_animations_impl);
 
   EXPECT_FALSE(element_animations_impl->has_element_in_active_list());
   EXPECT_FALSE(element_animations_impl->has_element_in_pending_list());
 
   // Create layer.
   client_.RegisterElement(element_id_, ElementListType::ACTIVE);
@@ skipping 26 matching lines @@
   timeline_->AttachPlayer(player1);
   timeline_->AttachPlayer(player2);
 
   // Attach players to the same layer.
   player1->AttachElement(element_id_);
   player2->AttachElement(element_id_);
 
   EXPECT_EQ(element_animations, player1->element_animations());
   EXPECT_EQ(element_animations, player2->element_animations());
 
-  host_->PushPropertiesTo(host_impl_);
+  PushProperties();
   GetImplTimelineAndPlayerByID();
 
   scoped_refptr<ElementAnimations> element_animations_impl =
       player_impl_->element_animations();
   EXPECT_TRUE(element_animations_impl);
 
   int list_size_before = 0;
   ElementAnimations::PlayersList::Iterator it(
       &element_animations_impl->players_list());
   AnimationPlayer* player;
   while ((player = it.GetNext()) != nullptr) {
     EXPECT_TRUE(timeline_->GetPlayerById(player->id()));
     ++list_size_before;
   }
   EXPECT_EQ(3, list_size_before);
 
   player2->DetachElement();
   EXPECT_FALSE(player2->element_animations());
   EXPECT_EQ(element_animations, player_->element_animations());
   EXPECT_EQ(element_animations, player1->element_animations());
 
-  host_->PushPropertiesTo(host_impl_);
+  PushProperties();
   EXPECT_EQ(element_animations_impl, player_impl_->element_animations());
 
   int list_size_after = 0;
   it = ElementAnimations::PlayersList::Iterator(
       &element_animations_impl->players_list());
   while ((player = it.GetNext()) != nullptr) {
     EXPECT_TRUE(timeline_->GetPlayerById(player->id()));
     ++list_size_after;
   }
   EXPECT_EQ(2, list_size_after);
 }
 
 TEST_F(ElementAnimationsTest, SyncNewAnimation) {
-  auto animations_impl = ElementAnimations::Create();
-  animations_impl->set_has_element_in_active_list(true);
+  CreateTestLayer(true, false);
+  AttachTimelinePlayerLayer();
+  CreateImplTimelineAndPlayer();
 
-  auto animations = ElementAnimations::Create();
-  animations->set_has_element_in_active_list(true);
+  scoped_refptr<ElementAnimations> animations = element_animations();
+  scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   EXPECT_FALSE(animations_impl->GetAnimation(TargetProperty::OPACITY));
 
   EXPECT_FALSE(animations->needs_to_start_animations_for_testing());
   EXPECT_FALSE(animations_impl->needs_to_start_animations_for_testing());
 
   int animation_id =
-      AddOpacityTransitionToElementAnimations(animations.get(), 1, 0, 1, false);
+      AddOpacityTransitionToPlayer(player_.get(), 1, 0, 1, false);
   EXPECT_TRUE(animations->needs_to_start_animations_for_testing());
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   EXPECT_TRUE(animations_impl->needs_to_start_animations_for_testing());
   animations_impl->ActivateAnimations();
 
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             animations_impl->GetAnimationById(animation_id)->run_state());
 }
 
 TEST_F(ElementAnimationsTest,
        SyncScrollOffsetAnimationRespectsHasSetInitialValue) {
@@ skipping 18 matching lines @@
   // Animation with initial value set.
   std::unique_ptr<ScrollOffsetAnimationCurve> curve_fixed(
       ScrollOffsetAnimationCurve::Create(
           target_value, CubicBezierTimingFunction::CreatePreset(
                             CubicBezierTimingFunction::EaseType::EASE_IN_OUT)));
   curve_fixed->SetInitialValue(initial_value);
   const int animation1_id = 1;
   std::unique_ptr<Animation> animation_fixed(Animation::Create(
       std::move(curve_fixed), animation1_id, 0, TargetProperty::SCROLL_OFFSET));
   animations->AddAnimation(std::move(animation_fixed));
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   EXPECT_VECTOR2DF_EQ(initial_value,
                       animations_impl->GetAnimationById(animation1_id)
                           ->curve()
                           ->ToScrollOffsetAnimationCurve()
                           ->GetValue(base::TimeDelta()));
 
   // Animation without initial value set.
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurve::Create(
           target_value, CubicBezierTimingFunction::CreatePreset(
                             CubicBezierTimingFunction::EaseType::EASE_IN_OUT)));
   const int animation2_id = 2;
   std::unique_ptr<Animation> animation(Animation::Create(
       std::move(curve), animation2_id, 0, TargetProperty::SCROLL_OFFSET));
   animations->AddAnimation(std::move(animation));
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   EXPECT_VECTOR2DF_EQ(provider_initial_value,
                       animations_impl->GetAnimationById(animation2_id)
                           ->curve()
                           ->ToScrollOffsetAnimationCurve()
                           ->GetValue(base::TimeDelta()));
 }
 
 class TestAnimationDelegateThatDestroysPlayer : public TestAnimationDelegate {
  public:
   TestAnimationDelegateThatDestroysPlayer() {}
@@ skipping 24 matching lines @@
 // passes if it doesn't crash.
 TEST_F(ElementAnimationsTest, AddedPlayerIsDestroyed) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   TestAnimationDelegateThatDestroysPlayer delegate;
-  {
-    scoped_refptr<AnimationPlayer> player =
-        AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
-    delegate.setTimelineAndPlayer(timeline_, player);
 
-    timeline_->AttachPlayer(player);
-    player->AttachElement(element_id_);
-    player->set_animation_delegate(&delegate);
-  }
+  scoped_refptr<AnimationPlayer> player2 =
+      AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
+  delegate.setTimelineAndPlayer(timeline_, player2);
 
-  int animation_id = AddOpacityTransitionToElementAnimations(
-      animations.get(), 1.0, 0.f, 1.f, false);
+  timeline_->AttachPlayer(player2);
+  player2->AttachElement(element_id_);
+  player2->set_animation_delegate(&delegate);
 
-  animations->PushPropertiesTo(animations_impl.get());
+  int animation_id =
+      AddOpacityTransitionToPlayer(player2.get(), 1.0, 0.f, 1.f, false);
+
+  PushProperties();
+
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id));
 
   animations_impl->Animate(kInitialTickTime);
 
   auto events = host_impl_->CreateEvents();
   animations_impl->UpdateState(true, events.get());
   EXPECT_EQ(1u, events->events_.size());
   EXPECT_EQ(AnimationEvent::STARTED, events->events_[0].type);
 
@@ skipping 10 matching lines @@
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   EXPECT_FALSE(animations_impl->GetAnimation(TargetProperty::OPACITY));
 
   int animation_id =
       AddOpacityTransitionToElementAnimations(animations.get(), 1, 0, 1, false);
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
 
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             animations_impl->GetAnimationById(animation_id)->run_state());
 
   auto events = host_impl_->CreateEvents();
   animations_impl->Animate(kInitialTickTime);
   animations_impl->UpdateState(true, events.get());
 
@@ skipping 17 matching lines @@
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   int animation_id =
       AddOpacityTransitionToElementAnimations(animations.get(), 1, 0, 1, false);
 
   const TimeTicks start_time = TicksFromSecondsF(123);
   animations->GetAnimation(TargetProperty::OPACITY)->set_start_time(start_time);
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
 
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             animations_impl->GetAnimationById(animation_id)->run_state());
 
   auto events = host_impl_->CreateEvents();
   animations_impl->Animate(kInitialTickTime);
   animations_impl->UpdateState(true, events.get());
 
@@ skipping 33 matching lines @@
   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());
 
   AddOpacityTransitionToElementAnimations(animations.get(), 1, 0, 1, false);
   // The main thread animations should now be active.
   EXPECT_EQ(1u, host->active_element_animations_for_testing().size());
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_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());
 
   animations_impl->Animate(kInitialTickTime);
   animations_impl->UpdateState(true, events.get());
   EXPECT_EQ(1u, events->events_.size());
   animations->NotifyAnimationStarted(events->events_[0]);
 
@@ skipping 25 matching lines @@
   EXPECT_EQ(1u, events->events_.size());
   animations->NotifyAnimationFinished(events->events_[0]);
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1500));
   animations->UpdateState(true, nullptr);
 
   EXPECT_EQ(Animation::WAITING_FOR_DELETION,
             animations->GetAnimation(TargetProperty::OPACITY)->run_state());
   // The main thread animations should have de-activated.
   EXPECT_EQ(0u, host->active_element_animations_for_testing().size());
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations->HasAnyAnimation());
   EXPECT_FALSE(animations_impl->HasAnyAnimation());
   EXPECT_EQ(0u, host->active_element_animations_for_testing().size());
   EXPECT_EQ(0u, host_impl->active_element_animations_for_testing().size());
 }
 
 TEST_F(ElementAnimationsTest, SyncPause) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   EXPECT_FALSE(animations_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 = AddOpacityStepsToElementAnimations(
       animations.get(), duration, 0.2f, 0.4f, 2);
 
   // Set start offset to be at the beginning of the second range.
   animations->GetAnimationById(animation_id)
       ->set_time_offset(TimeDelta::FromSecondsD(1.01));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
 
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             animations_impl->GetAnimationById(animation_id)->run_state());
 
   TimeTicks time = kInitialTickTime;
 
   // Start the animations on each animations.
   auto events = host_impl_->CreateEvents();
@@ skipping 19 matching lines @@
   EXPECT_EQ(kInitialTickTime,
             animations_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.
   animations->PauseAnimation(animation_id, TimeDelta::FromSecondsD(1.5));
   EXPECT_EQ(Animation::PAUSED,
             animations->GetAnimationById(animation_id)->run_state());
 
   // The pause run state change should make it to the impl thread animations.
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
 
   // Advance time so it stays within the first range.
   time += TimeDelta::FromMilliseconds(10);
   animations->Animate(time);
   animations_impl->Animate(time);
 
   EXPECT_EQ(Animation::PAUSED,
             animations_impl->GetAnimationById(animation_id)->run_state());
 
@@ skipping 11 matching lines @@
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   auto events = host_impl_->CreateEvents();
 
   EXPECT_FALSE(animations_impl->GetAnimation(TargetProperty::OPACITY));
 
   int animation_id =
       AddOpacityTransitionToElementAnimations(animations.get(), 1, 0, 1, false);
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
 
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             animations_impl->GetAnimationById(animation_id)->run_state());
 
   events = host_impl_->CreateEvents();
   animations_impl->Animate(kInitialTickTime);
   animations_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.
   animations->NotifyAnimationStarted(events->events_[0]);
 
   // Complete animation on impl thread.
   events = host_impl_->CreateEvents();
   animations_impl->Animate(kInitialTickTime + TimeDelta::FromSeconds(1));
   animations_impl->UpdateState(true, events.get());
   EXPECT_EQ(1u, events->events_.size());
   EXPECT_EQ(AnimationEvent::FINISHED, events->events_[0].type);
 
   animations->NotifyAnimationFinished(events->events_[0]);
 
   animations->Animate(kInitialTickTime + TimeDelta::FromSeconds(2));
   animations->UpdateState(true, nullptr);
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations->GetAnimationById(animation_id));
   EXPECT_FALSE(animations_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();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   auto events = host_impl_->CreateEvents();
 
   AddOpacityTransitionToElementAnimations(animations.get(), 1.0, 0.0f, 1.0f,
                                           false);
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, nullptr);
   EXPECT_TRUE(animations->needs_push_properties());
-  animations->PushPropertiesTo(animations_impl.get());
+
+  PushProperties();
+  EXPECT_FALSE(animations->needs_push_properties());
+
+  EXPECT_FALSE(host_->needs_push_properties());
+  EXPECT_FALSE(host_impl_->needs_push_properties());
+
   animations_impl->ActivateAnimations();
 
   animations_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   animations_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);
   animations->NotifyAnimationStarted(events->events_[0]);
 
@@ skipping 17 matching lines @@
   // Neither animations should have deleted the animation yet.
   EXPECT_TRUE(animations->GetAnimation(TargetProperty::OPACITY));
   EXPECT_TRUE(animations_impl->GetAnimation(TargetProperty::OPACITY));
 
   animations->NotifyAnimationFinished(events->events_[0]);
 
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));
   animations->UpdateState(true, nullptr);
   EXPECT_TRUE(host_->needs_push_properties());
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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(animations->HasAnyAnimation());
   EXPECT_FALSE(animations_impl->HasAnyAnimation());
 }
 
 // Tests that transitioning opacity from 0 to 1 works as expected.
@@ skipping 113 matching lines @@
       ScrollOffsetAnimationCurve::Create(
           target_value, CubicBezierTimingFunction::CreatePreset(
                             CubicBezierTimingFunction::EaseType::EASE_IN_OUT)));
 
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve), 1, 0, TargetProperty::SCROLL_OFFSET));
   animation->set_needs_synchronized_start_time(true);
   animations->AddAnimation(std::move(animation));
 
   client_impl_.SetScrollOffsetForAnimation(initial_value);
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(animations_impl->GetAnimation(TargetProperty::SCROLL_OFFSET));
   TimeDelta duration =
       animations_impl->GetAnimation(TargetProperty::SCROLL_OFFSET)
           ->curve()
           ->Duration();
   EXPECT_EQ(duration, animations->GetAnimation(TargetProperty::SCROLL_OFFSET)
                           ->curve()
                           ->Duration());
 
@@ skipping 175 matching lines @@
       ScrollOffsetAnimationCurve::Create(
           target_value, CubicBezierTimingFunction::CreatePreset(
                             CubicBezierTimingFunction::EaseType::EASE_IN_OUT)));
 
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve), 1, 0, TargetProperty::SCROLL_OFFSET));
   animation->set_needs_synchronized_start_time(true);
   animations->AddAnimation(std::move(animation));
 
   client_.SetScrollOffsetForAnimation(initial_value);
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(animations_impl->GetAnimation(TargetProperty::SCROLL_OFFSET));
   TimeDelta duration =
       animations_impl->GetAnimation(TargetProperty::SCROLL_OFFSET)
           ->curve()
           ->Duration();
   EXPECT_EQ(duration, animations->GetAnimation(TargetProperty::SCROLL_OFFSET)
                           ->curve()
                           ->Duration());
 
@@ skipping 67 matching lines @@
   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);
   animations->AddAnimation(std::move(animation));
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
   EXPECT_FALSE(animations_impl->scroll_offset_animation_was_interrupted());
 
   animations->RemoveAnimation(animation_id);
   EXPECT_TRUE(animations->scroll_offset_animation_was_interrupted());
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   EXPECT_TRUE(animations_impl->scroll_offset_animation_was_interrupted());
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
 
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations_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);
   animations->AddAnimation(std::move(animation));
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
   EXPECT_FALSE(animations_impl->scroll_offset_animation_was_interrupted());
 
   animations->RemoveAnimation(animation_id);
   EXPECT_TRUE(animations->scroll_offset_animation_was_interrupted());
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   EXPECT_TRUE(animations_impl->scroll_offset_animation_was_interrupted());
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
 
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations_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 =
       AddAnimatedTransformToElementAnimations(animations.get(), 1.0, 1, 2);
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
   EXPECT_FALSE(animations_impl->scroll_offset_animation_was_interrupted());
 
   animations->RemoveAnimation(animation_id);
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   EXPECT_FALSE(animations_impl->scroll_offset_animation_was_interrupted());
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
 
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations_impl->scroll_offset_animation_was_interrupted());
 
   animation_id =
       AddAnimatedFilterToElementAnimations(animations.get(), 1.0, 0.1f, 0.2f);
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
   EXPECT_FALSE(animations_impl->scroll_offset_animation_was_interrupted());
 
   animations->RemoveAnimation(animation_id);
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   EXPECT_FALSE(animations_impl->scroll_offset_animation_was_interrupted());
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
 
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations_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,
@@ skipping 55 matching lines @@
 
   TestAnimationDelegate delegate;
   player_->set_animation_delegate(&delegate);
 
   int animation_id =
       AddOpacityTransitionToElementAnimations(animations.get(), 1, 0, 1, false);
 
   const TimeTicks start_time = TicksFromSecondsF(123);
   animations->GetAnimation(TargetProperty::OPACITY)->set_start_time(start_time);
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
 
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             animations_impl->GetAnimationById(animation_id)->run_state());
 
   auto events = host_impl_->CreateEvents();
   animations_impl->Animate(kInitialTickTime);
   animations_impl->UpdateState(true, events.get());
 
@@ skipping 403 matching lines @@
 
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
   Animation* active_animation =
       animations->GetAnimation(TargetProperty::OPACITY);
   EXPECT_TRUE(active_animation);
   EXPECT_TRUE(active_animation->needs_synchronized_start_time());
 
   EXPECT_TRUE(animations->needs_push_properties());
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
 
   active_animation = animations_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) {
@@ skipping 232 matching lines @@
 
 // An animation aborted on the main thread should get deleted on both threads.
 TEST_F(ElementAnimationsTest, MainThreadAbortedAnimationGetsDeleted) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
-  int animation_id = AddOpacityTransitionToElementAnimations(
-      animations.get(), 1.0, 0.f, 1.f, false);
+  int animation_id =
+      AddOpacityTransitionToPlayer(player_.get(), 1.0, 0.f, 1.f, false);
+  EXPECT_TRUE(host_->needs_push_properties());
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
+
   animations_impl->ActivateAnimations();
+
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id));
+  EXPECT_FALSE(host_->needs_push_properties());
 
   animations->AbortAnimations(TargetProperty::OPACITY);
   EXPECT_EQ(Animation::ABORTED,
             animations->GetAnimation(TargetProperty::OPACITY)->run_state());
-  EXPECT_FALSE(host_->needs_push_properties());
-  EXPECT_FALSE(host_impl_->needs_push_properties());
+  EXPECT_TRUE(host_->needs_push_properties());
 
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, nullptr);
-  EXPECT_FALSE(host_->needs_push_properties());
   EXPECT_EQ(Animation::ABORTED,
             animations->GetAnimation(TargetProperty::OPACITY)->run_state());
 
   EXPECT_TRUE(animations->needs_push_properties());
-  animations->PushPropertiesTo(animations_impl.get());
+  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());
+
   EXPECT_FALSE(animations->GetAnimationById(animation_id));
   EXPECT_FALSE(animations_impl->GetAnimationById(animation_id));
 }
 
 // An animation aborted on the impl thread should get deleted on both threads.
 TEST_F(ElementAnimationsTest, ImplThreadAbortedAnimationGetsDeleted) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   TestAnimationDelegate delegate;
   player_->set_animation_delegate(&delegate);
 
   int animation_id = AddOpacityTransitionToElementAnimations(
       animations.get(), 1.0, 0.f, 1.f, false);
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
+  EXPECT_FALSE(host_->needs_push_properties());
+
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id));
 
   animations_impl->AbortAnimations(TargetProperty::OPACITY);
   EXPECT_EQ(
       Animation::ABORTED,
       animations_impl->GetAnimation(TargetProperty::OPACITY)->run_state());
-  EXPECT_FALSE(host_->needs_push_properties());
-  EXPECT_FALSE(host_impl_->needs_push_properties());
+  EXPECT_TRUE(host_impl_->needs_push_properties());
+  EXPECT_TRUE(player_impl_->needs_push_properties());
 
   auto events = host_impl_->CreateEvents();
   animations_impl->Animate(kInitialTickTime);
   animations_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,
       animations_impl->GetAnimation(TargetProperty::OPACITY)->run_state());
 
   animations->NotifyAnimationAborted(events->events_[0]);
   EXPECT_EQ(Animation::ABORTED,
             animations->GetAnimation(TargetProperty::OPACITY)->run_state());
   EXPECT_TRUE(delegate.aborted());
 
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   animations->UpdateState(true, nullptr);
   EXPECT_TRUE(host_->needs_push_properties());
   EXPECT_EQ(Animation::WAITING_FOR_DELETION,
             animations->GetAnimation(TargetProperty::OPACITY)->run_state());
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
+
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations->GetAnimationById(animation_id));
   EXPECT_FALSE(animations_impl->GetAnimationById(animation_id));
 }
 
 // Test that an impl-only scroll offset animation that needs to be completed on
 // the main thread gets deleted.
 TEST_F(ElementAnimationsTest, ImplThreadTakeoverAnimationGetsDeleted) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
@@ skipping 15 matching lines @@
       ScrollOffsetAnimationCurve::Create(
           target_value, CubicBezierTimingFunction::CreatePreset(
                             CubicBezierTimingFunction::EaseType::EASE_IN_OUT)));
   curve->SetInitialValue(initial_value);
   std::unique_ptr<Animation> animation(Animation::Create(
       std::move(curve), animation_id, 0, TargetProperty::SCROLL_OFFSET));
   animation->set_start_time(TicksFromSecondsF(123));
   animation->set_is_impl_only(true);
   animations_impl->AddAnimation(std::move(animation));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
+  EXPECT_FALSE(host_->needs_push_properties());
+
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id));
 
   const bool needs_completion = true;
   animations_impl->AbortAnimations(TargetProperty::SCROLL_OFFSET,
                                    needs_completion);
+  EXPECT_TRUE(host_impl_->needs_push_properties());
   EXPECT_EQ(Animation::ABORTED_BUT_NEEDS_COMPLETION,
             animations_impl->GetAnimation(TargetProperty::SCROLL_OFFSET)
                 ->run_state());
-  EXPECT_FALSE(host_->needs_push_properties());
-  EXPECT_FALSE(host_impl_->needs_push_properties());
 
   auto events = host_impl_->CreateEvents();
   animations_impl->Animate(kInitialTickTime);
   animations_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,
             animations_impl->GetAnimation(TargetProperty::SCROLL_OFFSET)
                 ->run_state());
 
   // MT receives the event to take over.
   animations->NotifyAnimationTakeover(events->events_[0]);
   EXPECT_TRUE(delegate.takeover());
 
   // AnimationPlayer::NotifyAnimationTakeover requests SetNeedsPushProperties
   // to purge CT animations marked for deletion.
   EXPECT_TRUE(animations->needs_push_properties());
 
   // ElementAnimations::PurgeAnimationsMarkedForDeletion call happens only in
   // ElementAnimations::PushPropertiesTo.
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
+
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations->GetAnimationById(animation_id));
   EXPECT_FALSE(animations_impl->GetAnimationById(animation_id));
 }
 
 // Ensure that we only generate FINISHED events for animations in a group
 // once all animations in that group are finished.
 TEST_F(ElementAnimationsTest, FinishedEventsForGroup) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
@@ skipping 570 matching lines @@
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   auto events = host_impl_->CreateEvents();
 
   EXPECT_FALSE(animations->needs_to_start_animations_for_testing());
   int animation_id = AddOpacityTransitionToElementAnimations(
       animations.get(), 1, 0.5f, 1.f, false);
   EXPECT_TRUE(animations->needs_to_start_animations_for_testing());
 
   EXPECT_FALSE(animations_impl->needs_to_start_animations_for_testing());
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   EXPECT_TRUE(animations_impl->needs_to_start_animations_for_testing());
 
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             animations_impl->GetAnimationById(animation_id)->run_state());
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
                   ->affects_pending_elements());
   EXPECT_FALSE(animations_impl->GetAnimationById(animation_id)
                    ->affects_active_elements());
 
@@ skipping 38 matching lines @@
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   auto events = host_impl_->CreateEvents();
 
   const int animation_id = AddOpacityTransitionToElementAnimations(
       animations.get(), 1, 0.5f, 1.f, true);
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
 
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id));
   EXPECT_EQ(Animation::WAITING_FOR_TARGET_AVAILABILITY,
             animations_impl->GetAnimationById(animation_id)->run_state());
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
                   ->affects_pending_elements());
   EXPECT_FALSE(animations_impl->GetAnimationById(animation_id)
                    ->affects_active_elements());
 
   animations_impl->Animate(kInitialTickTime);
@@ skipping 49 matching lines @@
   EXPECT_FALSE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   // Case 1: An animation that's allowed to run until its finish point.
   AddAnimatedTransformToElementAnimations(animations.get(), 1.0, 1, 1);
   EXPECT_TRUE(client_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
 
   animations_impl->ActivateAnimations();
@@ skipping 13 matching lines @@
   events->events_.clear();
 
   // Finish the animation.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   animations->UpdateState(true, nullptr);
   EXPECT_FALSE(client_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
@@ skipping 11 matching lines @@
       element_id_, ElementListType::ACTIVE));
 
   // Case 2: An animation that's removed before it finishes.
   int animation_id =
       AddAnimatedTransformToElementAnimations(animations.get(), 10.0, 2, 2);
   EXPECT_TRUE(client_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   animations_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(2000));
   animations_impl->UpdateState(true, events.get());
 
   animations->NotifyAnimationStarted(events->events_[0]);
   events->events_.clear();
 
   animations->RemoveAnimation(animation_id);
   EXPECT_FALSE(client_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
 
   animations_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 =
       AddAnimatedTransformToElementAnimations(animations.get(), 10.0, 3, 3);
   EXPECT_TRUE(client_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
 
   animations_impl->ActivateAnimations();
@@ skipping 30 matching lines @@
       element_id_, ElementListType::ACTIVE));
 
   // Case 4 : An animation that's not in effect.
   animation_id =
       AddAnimatedTransformToElementAnimations(animations.get(), 1.0, 1, 6);
   animations->GetAnimationById(animation_id)
       ->set_time_offset(base::TimeDelta::FromMilliseconds(-10000));
   animations->GetAnimationById(animation_id)
       ->set_fill_mode(Animation::FillMode::NONE);
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
 
   animations_impl->ActivateAnimations();
@@ skipping 27 matching lines @@
       element_id_, ElementListType::ACTIVE));
 
   // Case 1: An animation that's allowed to run until its finish point.
   AddOpacityTransitionToElementAnimations(animations.get(), 1.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));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
 
   animations_impl->ActivateAnimations();
@@ skipping 13 matching lines @@
   events->events_.clear();
 
   // Finish the animation.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   animations->UpdateState(true, nullptr);
   EXPECT_FALSE(client_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetOpacityIsCurrentlyAnimating(element_id_,
                                                       ElementListType::ACTIVE));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
@@ skipping 11 matching lines @@
       element_id_, ElementListType::ACTIVE));
 
   // Case 2: An animation that's removed before it finishes.
   int animation_id = AddOpacityTransitionToElementAnimations(
       animations.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));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   animations_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(2000));
   animations_impl->UpdateState(true, events.get());
 
   animations->NotifyAnimationStarted(events->events_[0]);
   events->events_.clear();
 
   animations->RemoveAnimation(animation_id);
   EXPECT_FALSE(client_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetOpacityIsCurrentlyAnimating(element_id_,
                                                       ElementListType::ACTIVE));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
 
   animations_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 = AddOpacityTransitionToElementAnimations(
       animations.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));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
 
   animations_impl->ActivateAnimations();
@@ skipping 30 matching lines @@
                                                       ElementListType::ACTIVE));
 
   // Case 4 : An animation that's not in effect.
   animation_id = AddOpacityTransitionToElementAnimations(
       animations.get(), 1.0, 0.f, 0.5f, false /*use_timing_function*/);
   animations->GetAnimationById(animation_id)
       ->set_time_offset(base::TimeDelta::FromMilliseconds(-10000));
   animations->GetAnimationById(animation_id)
       ->set_fill_mode(Animation::FillMode::NONE);
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
 
   animations_impl->ActivateAnimations();
@@ skipping 26 matching lines @@
   EXPECT_FALSE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   // Case 1: An animation that's allowed to run until its finish point.
   AddAnimatedFilterToElementAnimations(animations.get(), 1.0, 0.f, 1.f);
   EXPECT_TRUE(client_.GetHasPotentialFilterAnimation(element_id_,
                                                      ElementListType::ACTIVE));
   EXPECT_TRUE(client_.GetFilterIsCurrentlyAnimating(element_id_,
                                                     ElementListType::ACTIVE));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
 
   animations_impl->ActivateAnimations();
@@ skipping 13 matching lines @@
   events->events_.clear();
 
   // Finish the animation.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   animations->UpdateState(true, nullptr);
   EXPECT_FALSE(client_.GetHasPotentialFilterAnimation(element_id_,
                                                       ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetFilterIsCurrentlyAnimating(element_id_,
                                                      ElementListType::ACTIVE));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
@@ skipping 11 matching lines @@
       element_id_, ElementListType::ACTIVE));
 
   // Case 2: An animation that's removed before it finishes.
   int animation_id =
       AddAnimatedFilterToElementAnimations(animations.get(), 10.0, 0.f, 1.f);
   EXPECT_TRUE(client_.GetHasPotentialFilterAnimation(element_id_,
                                                      ElementListType::ACTIVE));
   EXPECT_TRUE(client_.GetFilterIsCurrentlyAnimating(element_id_,
                                                     ElementListType::ACTIVE));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_TRUE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   animations_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(2000));
   animations_impl->UpdateState(true, events.get());
 
   animations->NotifyAnimationStarted(events->events_[0]);
   events->events_.clear();
 
   animations->RemoveAnimation(animation_id);
   EXPECT_FALSE(client_.GetHasPotentialFilterAnimation(element_id_,
                                                       ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetFilterIsCurrentlyAnimating(element_id_,
                                                      ElementListType::ACTIVE));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
 
   animations_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 =
       AddAnimatedFilterToElementAnimations(animations.get(), 10.0, 0.f, 0.5f);
   EXPECT_TRUE(client_.GetHasPotentialFilterAnimation(element_id_,
                                                      ElementListType::ACTIVE));
   EXPECT_TRUE(client_.GetFilterIsCurrentlyAnimating(element_id_,
                                                     ElementListType::ACTIVE));
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
 
   animations_impl->ActivateAnimations();
@@ skipping 30 matching lines @@
                                                      ElementListType::ACTIVE));
 
   // Case 4 : An animation that's not in effect.
   animation_id =
       AddAnimatedFilterToElementAnimations(animations.get(), 1.0, 0.f, 0.5f);
   animations->GetAnimationById(animation_id)
       ->set_time_offset(base::TimeDelta::FromMilliseconds(-10000));
   animations->GetAnimationById(animation_id)
       ->set_fill_mode(Animation::FillMode::NONE);
 
-  animations->PushPropertiesTo(animations_impl.get());
+  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));
 
   animations_impl->ActivateAnimations();
@@ skipping 41 matching lines @@
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   auto events = host_impl_->CreateEvents();
 
   const int animation_id = AddOpacityTransitionToElementAnimations(
       animations.get(), 1, 0.5f, 1.f, true);
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
   animations_impl->Animate(kInitialTickTime);
   animations_impl->UpdateState(true, events.get());
   EXPECT_EQ(Animation::RUNNING,
             animations_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(animations_impl->GetAnimationById(animation_id)
                   ->affects_pending_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
                   ->affects_active_elements());
 
   // Delete the animation on the main-thread animations.
   animations->RemoveAnimation(
       animations->GetAnimation(TargetProperty::OPACITY)->id());
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
 
   // The animation should no longer affect pending elements.
   EXPECT_FALSE(animations_impl->GetAnimationById(animation_id)
                    ->affects_pending_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id)
                   ->affects_active_elements());
 
   animations_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   animations_impl->UpdateState(true, events.get());
 
@@ skipping 17 matching lines @@
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   auto events = host_impl_->CreateEvents();
 
   const int first_animation_id = AddOpacityTransitionToElementAnimations(
       animations.get(), 1, 0.f, 1.f, true);
 
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
   animations_impl->ActivateAnimations();
   animations_impl->Animate(kInitialTickTime);
   animations_impl->UpdateState(true, events.get());
 
   // Remove the first animation from the main-thread animations, and add a
   // new animation affecting the same property.
   animations->RemoveAnimation(
       animations->GetAnimation(TargetProperty::OPACITY)->id());
   const int second_animation_id = AddOpacityTransitionToElementAnimations(
       animations.get(), 1, 1.f, 0.5f, true);
-  animations->PushPropertiesTo(animations_impl.get());
+  PushProperties();
 
   // The original animation should only affect active elements, and the new
   // animation should only affect pending elements.
   EXPECT_FALSE(animations_impl->GetAnimationById(first_animation_id)
                    ->affects_pending_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(first_animation_id)
                   ->affects_active_elements());
   EXPECT_TRUE(animations_impl->GetAnimationById(second_animation_id)
                   ->affects_pending_elements());
   EXPECT_FALSE(animations_impl->GetAnimationById(second_animation_id)
@@ skipping 188 matching lines @@
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::ACTIVE));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::PENDING));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::ACTIVE));
 }
 
 }  // namespace
 }  // namespace cc