CC Animation: Introduce some dirty flags to optimize PushProperties on commit

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 254 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));
+  AddAnimationToElementAnimations(animations.get(), std::move(animation_fixed));
   animations->PushPropertiesTo(animations_impl.get());
   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));
+  AddAnimationToElementAnimations(animations.get(), std::move(animation));
   animations->PushPropertiesTo(animations_impl.get());
   EXPECT_VECTOR2DF_EQ(provider_initial_value,
                       animations_impl->GetAnimationById(animation2_id)
                           ->curve()
                           ->ToScrollOffsetAnimationCurve()
                           ->GetValue(base::TimeDelta()));
 }
 
 class TestAnimationDelegateThatDestroysPlayer : public TestAnimationDelegate {
  public:
@@ skipping 269 matching lines @@
   EXPECT_EQ(0.3f,
             client_impl_.GetOpacity(element_id_, ElementListType::ACTIVE));
 
   EXPECT_EQ(kInitialTickTime,
             animations->GetAnimationById(animation_id)->start_time());
   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));
+  PauseAnimationInElementAnimations(animations.get(), 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());
   animations_impl->ActivateAnimations();
 
   // Advance time so it stays within the first range.
   time += TimeDelta::FromMilliseconds(10);
   animations->Animate(time);
@@ skipping 66 matching lines @@
 
   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());
   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]);
 
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   animations->UpdateState(true, nullptr);
 
-  EXPECT_FALSE(host_->animation_waiting_for_deletion());
-  EXPECT_FALSE(host_impl_->animation_waiting_for_deletion());
+  EXPECT_FALSE(host_->needs_push_properties());
+  EXPECT_FALSE(host_impl_->needs_push_properties());
 
   events = host_impl_->CreateEvents();
   animations_impl->Animate(kInitialTickTime +
                            TimeDelta::FromMilliseconds(2000));
   animations_impl->UpdateState(true, events.get());
 
-  EXPECT_TRUE(host_impl_->animation_waiting_for_deletion());
+  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(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_->animation_waiting_for_deletion());
+  EXPECT_TRUE(host_->needs_push_properties());
 
   animations->PushPropertiesTo(animations_impl.get());
 
   // 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->has_any_animation());
   EXPECT_FALSE(animations_impl->has_any_animation());
 }
@@ skipping 23 matching lines @@
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   auto events = host_impl_->CreateEvents();
 
   std::unique_ptr<Animation> to_add(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       1, TargetProperty::OPACITY));
 
   EXPECT_FALSE(animations->needs_to_start_animations_for_testing());
-  animations->AddAnimation(std::move(to_add));
+  AddAnimationToElementAnimations(animations.get(), std::move(to_add));
   EXPECT_TRUE(animations->needs_to_start_animations_for_testing());
   animations->Animate(kInitialTickTime);
   EXPECT_FALSE(animations->needs_to_start_animations_for_testing());
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->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);
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
@@ skipping 19 matching lines @@
   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));
-  animations->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations.get(), std::move(animation));
 
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->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);
 
@@ skipping 28 matching lines @@
   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)));
 
   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));
+  AddAnimationToElementAnimations(animations.get(), std::move(animation));
 
   client_impl_.SetScrollOffsetForAnimation(initial_value);
   animations->PushPropertiesTo(animations_impl.get());
   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)
@@ skipping 60 matching lines @@
   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);
-  animations_impl->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(animation));
 
   animations_impl->Animate(kInitialTickTime);
   animations_impl->UpdateState(true, events.get());
   EXPECT_TRUE(animations_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);
 
@@ skipping 94 matching lines @@
   gfx::ScrollOffset initial_value(500.f, 100.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)));
 
   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));
+  AddAnimationToElementAnimations(animations.get(), std::move(animation));
 
   client_.SetScrollOffsetForAnimation(initial_value);
   animations->PushPropertiesTo(animations_impl.get());
   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)
@@ skipping 69 matching lines @@
   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);
-  animations->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations.get(), std::move(animation));
   animations->PushPropertiesTo(animations_impl.get());
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
   EXPECT_FALSE(animations_impl->scroll_offset_animation_was_interrupted());
 
-  animations->RemoveAnimation(animation_id);
+  RemoveAnimationFromElementAnimations(animations.get(), animation_id);
   EXPECT_TRUE(animations->scroll_offset_animation_was_interrupted());
 
   animations->PushPropertiesTo(animations_impl.get());
   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));
+  AddAnimationToElementAnimations(animations.get(), std::move(animation));
   animations->PushPropertiesTo(animations_impl.get());
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
   EXPECT_FALSE(animations_impl->scroll_offset_animation_was_interrupted());
 
-  animations->RemoveAnimation(animation_id);
+  RemoveAnimationFromElementAnimations(animations.get(), animation_id);
   EXPECT_TRUE(animations->scroll_offset_animation_was_interrupted());
 
   animations->PushPropertiesTo(animations_impl.get());
   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());
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
   EXPECT_FALSE(animations_impl->scroll_offset_animation_was_interrupted());
 
-  animations->RemoveAnimation(animation_id);
+  RemoveAnimationFromElementAnimations(animations.get(), animation_id);
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
 
   animations->PushPropertiesTo(animations_impl.get());
   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());
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
   EXPECT_FALSE(animations_impl->scroll_offset_animation_was_interrupted());
 
-  animations->RemoveAnimation(animation_id);
+  RemoveAnimationFromElementAnimations(animations.get(), animation_id);
   EXPECT_FALSE(animations->scroll_offset_animation_was_interrupted());
 
   animations->PushPropertiesTo(animations_impl.get());
   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());
 }
 
@@ skipping 17 matching lines @@
   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);
   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);
-  animations_impl->AddAnimation(std::move(to_add));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(to_add));
 
   EXPECT_FALSE(delegate.started());
   EXPECT_FALSE(delegate.finished());
 
   animations_impl->Animate(kInitialTickTime);
   animations_impl->UpdateState(true, events.get());
 
   EXPECT_TRUE(delegate.started());
   EXPECT_FALSE(delegate.finished());
 
@@ skipping 57 matching lines @@
 
   auto events = host_impl_->CreateEvents();
 
   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.
-  animations->AddAnimation(std::move(to_add));
+  AddAnimationToElementAnimations(animations.get(), std::move(to_add));
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   animations->UpdateState(true, events.get());
@@ skipping 66 matching lines @@
       1, TargetProperty::OPACITY));
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->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));
   animations->AbortAnimations(TargetProperty::OPACITY);
-  animations->AddAnimation(std::move(to_add));
+  AddAnimationToElementAnimations(animations.get(), std::move(to_add));
 
   // Since the previous animation was aborted, the new animation should start
   // right in this call to animate.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_EQ(1.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1500));
   animations->UpdateState(true, events.get());
   EXPECT_EQ(0.5f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
@@ skipping 85 matching lines @@
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   auto events = host_impl_->CreateEvents();
 
   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);
-  animations->AddAnimation(std::move(to_add));
+  AddAnimationToElementAnimations(animations.get(), std::move(to_add));
 
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1250));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_EQ(0.25f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1750));
@@ skipping 25 matching lines @@
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   auto events = host_impl_->CreateEvents();
 
   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);
-  animations->AddAnimation(std::move(to_add));
+  AddAnimationToElementAnimations(animations.get(), std::move(to_add));
 
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_EQ(0.f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1250));
   animations->UpdateState(true, events.get());
   EXPECT_TRUE(animations->HasActiveAnimation());
   EXPECT_EQ(0.25f, client_.GetOpacity(element_id_, ElementListType::ACTIVE));
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1750));
@@ skipping 116 matching lines @@
 
   scoped_refptr<ElementAnimations> animations = element_animations();
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   auto events = host_impl_->CreateEvents();
 
   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);
-  animations->AddAnimation(std::move(to_add));
+  AddAnimationToElementAnimations(animations.get(), std::move(to_add));
+  // AddAnimationToElementAnimations(animations.get(), std::move(to_add));
 
   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());
   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) {
   CreateTestLayer(true, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   auto events = host_impl_->CreateEvents();
 
   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);
-  animations->AddAnimation(std::move(first_animation));
+  AddAnimationToElementAnimations(animations.get(), std::move(first_animation));
 
   animations->Animate(kInitialTickTime);
   animations->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);
-  animations->AddAnimation(std::move(second_animation));
+  AddAnimationToElementAnimations(animations.get(),
+                                  std::move(second_animation));
 
   // Animate but don't UpdateState.
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));
 
   animations->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));
   events = host_impl_->CreateEvents();
   animations->UpdateState(true, events.get());
 
   // Should have one STARTED event and one FINISHED event.
   EXPECT_EQ(2u, events->events_.size());
@@ skipping 90 matching lines @@
 
   TransformOperations operations1;
   curve1->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
   operations1.AppendTranslate(10.0, 15.0, 0.0);
   curve1->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations1, nullptr));
 
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve1), 1, 1, TargetProperty::TRANSFORM));
-  animations_impl->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(animation));
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve2(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations2;
   curve2->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations2, nullptr));
   operations2.AppendScale(2.0, 3.0, 4.0);
   curve2->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations2, nullptr));
 
   animation =
       Animation::Create(std::move(curve2), 2, 2, TargetProperty::TRANSFORM);
-  animations_impl->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(animation));
 
   gfx::BoxF box(1.f, 2.f, -1.f, 3.f, 4.f, 5.f);
   gfx::BoxF bounds;
 
   EXPECT_TRUE(animations_impl->TransformAnimationBoundsForBox(box, &bounds));
   EXPECT_EQ(gfx::BoxF(1.f, 2.f, -4.f, 13.f, 19.f, 20.f).ToString(),
             bounds.ToString());
 
   animations_impl->GetAnimationById(1)->SetRunState(Animation::FINISHED,
                                                     TicksFromSecondsF(0.0));
@@ skipping 15 matching lines @@
   TransformOperations operations3;
   gfx::Transform transform3;
   transform3.Scale3d(1.0, 2.0, 3.0);
   curve3->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations3, nullptr));
   operations3.AppendMatrix(transform3);
   curve3->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations3, nullptr));
   animation =
       Animation::Create(std::move(curve3), 3, 3, TargetProperty::TRANSFORM);
-  animations_impl->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(animation));
   EXPECT_FALSE(animations_impl->TransformAnimationBoundsForBox(box, &bounds));
 }
 
 // Tests that AbortAnimations aborts all animations targeting the specified
 // property.
 TEST_F(ElementAnimationsTest, AbortAnimations) {
   CreateTestLayer(false, false);
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
@@ skipping 47 matching lines @@
   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);
 
   animations->PushPropertiesTo(animations_impl.get());
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id));
 
-  animations->AbortAnimations(TargetProperty::OPACITY);
+  AbortAnimationsInElementAnimations(animations.get(), TargetProperty::OPACITY,
+                                     false);
   EXPECT_EQ(Animation::ABORTED,
             animations->GetAnimation(TargetProperty::OPACITY)->run_state());
-  EXPECT_FALSE(host_->animation_waiting_for_deletion());
-  EXPECT_FALSE(host_impl_->animation_waiting_for_deletion());
+  EXPECT_FALSE(host_->needs_push_properties());
+  EXPECT_FALSE(host_impl_->needs_push_properties());
 
   animations->Animate(kInitialTickTime);
   animations->UpdateState(true, nullptr);
-  EXPECT_FALSE(host_->animation_waiting_for_deletion());
+  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_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());
   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_->animation_waiting_for_deletion());
-  EXPECT_FALSE(host_impl_->animation_waiting_for_deletion());
+  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(host_impl_->animation_waiting_for_deletion());
+  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_->animation_waiting_for_deletion());
+  EXPECT_TRUE(host_->needs_push_properties());
   EXPECT_EQ(Animation::WAITING_FOR_DELETION,
             animations->GetAnimation(TargetProperty::OPACITY)->run_state());
 
   animations->PushPropertiesTo(animations_impl.get());
   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
@@ skipping 17 matching lines @@
   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);
   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));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(animation));
 
   animations->PushPropertiesTo(animations_impl.get());
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(animations_impl->GetAnimationById(animation_id));
 
   const bool needs_completion = true;
-  animations_impl->AbortAnimations(TargetProperty::SCROLL_OFFSET,
-                                   needs_completion);
+  AbortAnimationsInElementAnimations(
+      animations_impl.get(), TargetProperty::SCROLL_OFFSET, needs_completion);
   EXPECT_EQ(Animation::ABORTED_BUT_NEEDS_COMPLETION,
             animations_impl->GetAnimation(TargetProperty::SCROLL_OFFSET)
                 ->run_state());
-  EXPECT_FALSE(host_->animation_waiting_for_deletion());
-  EXPECT_FALSE(host_impl_->animation_waiting_for_deletion());
+  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_->animation_waiting_for_deletion());
+  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());
 
   animations->NotifyAnimationTakeover(events->events_[0]);
   EXPECT_TRUE(delegate.takeover());
+  // TODO(ymalik): How does it work?
+  animations->SetNeedsPushProperties();

[loyso (OOO), 2016/08/22 07:48:27]

It notifies blink about takover and then suddenly expects the animation to be
deleted.
What code causes this deletion in real case?

[ymalik, 2016/08/22 14:40:01]

The purpose of the Takeover notification is to continue an impl-only scroll
offset animation on the MT. We need this for cases where a main thread scrolling
reason gets added while an impl-only scroll offset animation is in progress (see
crbug.com/581875).

On the impl-side, an animation is put into the ABORTED_BUT_NEEDS_COMPLETION
state
(https://cs.chromium.org/chromium/src/cc/animation/element_animations.cc?rcl=0...).
Then, it is marked for deletion during the next call to
ElementAnimation::UpdateState
(https://cs.chromium.org/chromium/src/cc/animation/element_animations.cc?rcl=0...).

On the mt-side, when we get a Takeover message, the old animation curve is
passed on to blink's ScrollAnimator, and we finish the animation on the MT.

 
+  EXPECT_TRUE(animations->needs_push_properties());
   animations->PushPropertiesTo(animations_impl.get());
   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();
   CreateImplTimelineAndPlayer();
 
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   auto events = host_impl_->CreateEvents();
 
   const int group_id = 1;
 
   // Add two animations with the same group id but different durations.
   std::unique_ptr<Animation> first_animation(Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(2.0)), 1,
       group_id, TargetProperty::TRANSFORM));
   first_animation->set_is_controlling_instance_for_test(true);
-  animations_impl->AddAnimation(std::move(first_animation));
+  AddAnimationToElementAnimations(animations_impl.get(),
+                                  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);
-  animations_impl->AddAnimation(std::move(second_animation));
+  AddAnimationToElementAnimations(animations_impl.get(),
+                                  std::move(second_animation));
 
   animations_impl->Animate(kInitialTickTime);
   animations_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 = host_impl_->CreateEvents();
@@ skipping 29 matching lines @@
 
   scoped_refptr<ElementAnimations> animations_impl = element_animations_impl();
 
   auto events = host_impl_->CreateEvents();
 
   // Add two animations with the same group id.
   std::unique_ptr<Animation> first_animation(CreateAnimation(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1.0)), 1,
       TargetProperty::TRANSFORM));
   first_animation->set_is_controlling_instance_for_test(true);
-  animations_impl->AddAnimation(std::move(first_animation));
+  AddAnimationToElementAnimations(animations_impl.get(),
+                                  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);
-  animations_impl->AddAnimation(std::move(second_animation));
+  AddAnimationToElementAnimations(animations_impl.get(),
+                                  std::move(second_animation));
 
   animations_impl->Animate(kInitialTickTime);
   animations_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);
 
   animations_impl->AbortAnimations(TargetProperty::OPACITY);
@@ skipping 33 matching lines @@
 
   TransformOperations operations1;
   curve1->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
   operations1.AppendTranslate(10.0, 15.0, 0.0);
   curve1->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations1, nullptr));
 
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve1), 2, 2, TargetProperty::TRANSFORM));
-  animations_impl->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(animation));
 
   // Translations don't affect scale.
   EXPECT_FALSE(animations_impl->HasAnimationThatAffectsScale());
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve2(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations2;
   curve2->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations2, nullptr));
   operations2.AppendScale(2.0, 3.0, 4.0);
   curve2->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations2, nullptr));
 
   animation =
       Animation::Create(std::move(curve2), 3, 3, TargetProperty::TRANSFORM);
-  animations_impl->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(animation));
 
   EXPECT_TRUE(animations_impl->HasAnimationThatAffectsScale());
 
   animations_impl->GetAnimationById(3)->SetRunState(Animation::FINISHED,
                                                     TicksFromSecondsF(0.0));
 
   // Only unfinished animations should be considered by
   // HasAnimationThatAffectsScale.
   EXPECT_FALSE(animations_impl->HasAnimationThatAffectsScale());
 }
@@ skipping 25 matching lines @@
 
   TransformOperations operations1;
   curve1->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
   operations1.AppendTranslate(10.0, 15.0, 0.0);
   curve1->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations1, nullptr));
 
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve1), 2, 2, TargetProperty::TRANSFORM));
-  animations_impl->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(animation));
 
   // The only transform animation we've added is a translation.
   EXPECT_TRUE(
       animations_impl->HasOnlyTranslationTransforms(ElementListType::ACTIVE));
   EXPECT_TRUE(
       animations_impl->HasOnlyTranslationTransforms(ElementListType::PENDING));
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve2(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations2;
   curve2->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations2, nullptr));
   operations2.AppendScale(2.0, 3.0, 4.0);
   curve2->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations2, nullptr));
 
   animation =
       Animation::Create(std::move(curve2), 3, 3, TargetProperty::TRANSFORM);
   animation->set_affects_active_elements(false);
-  animations_impl->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(animation));
 
   // A scale animation is not a translation.
   EXPECT_FALSE(
       animations_impl->HasOnlyTranslationTransforms(ElementListType::PENDING));
   EXPECT_TRUE(
       animations_impl->HasOnlyTranslationTransforms(ElementListType::ACTIVE));
 
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(
       animations_impl->HasOnlyTranslationTransforms(ElementListType::PENDING));
@@ skipping 30 matching lines @@
   TransformOperations operations1;
   operations1.AppendScale(2.0, 3.0, 4.0);
   curve1->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
   TransformOperations operations2;
   curve1->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations2, nullptr));
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve1), 1, 1, TargetProperty::TRANSFORM));
   animation->set_affects_active_elements(false);
-  animations_impl->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(animation));
 
   float start_scale = 0.f;
   EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::PENDING,
                                                    &start_scale));
   EXPECT_EQ(4.f, start_scale);
   EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::ACTIVE,
                                                    &start_scale));
   EXPECT_EQ(0.f, start_scale);
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::PENDING,
                                                    &start_scale));
   EXPECT_EQ(4.f, start_scale);
   EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::ACTIVE,
                                                    &start_scale));
   EXPECT_EQ(4.f, start_scale);
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve2(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations3;
   curve2->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations3, nullptr));
   operations3.AppendScale(6.0, 5.0, 4.0);
   curve2->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations3, nullptr));
 
-  animations_impl->RemoveAnimation(1);
+  RemoveAnimationFromElementAnimations(animations_impl.get(), 1);
   animation =
       Animation::Create(std::move(curve2), 2, 2, TargetProperty::TRANSFORM);
 
   // Reverse Direction
   animation->set_direction(Animation::Direction::REVERSE);
   animation->set_affects_active_elements(false);
-  animations_impl->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(animation));
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve3(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations4;
   operations4.AppendScale(5.0, 3.0, 1.0);
   curve3->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations4, nullptr));
   TransformOperations operations5;
   curve3->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations5, nullptr));
 
   animation =
       Animation::Create(std::move(curve3), 3, 3, TargetProperty::TRANSFORM);
   animation->set_affects_active_elements(false);
-  animations_impl->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(animation));
 
   EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::PENDING,
                                                    &start_scale));
   EXPECT_EQ(6.f, start_scale);
   EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::ACTIVE,
                                                    &start_scale));
   EXPECT_EQ(0.f, start_scale);
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(animations_impl->AnimationStartScale(ElementListType::PENDING,
@@ skipping 37 matching lines @@
   TransformOperations operations1;
   curve1->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
   operations1.AppendScale(2.0, 3.0, 4.0);
   curve1->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations1, nullptr));
 
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve1), 1, 1, TargetProperty::TRANSFORM));
   animation->set_affects_active_elements(false);
-  animations_impl->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(animation));
 
   EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
                                                   &max_scale));
   EXPECT_EQ(4.f, max_scale);
   EXPECT_TRUE(
       animations_impl->MaximumTargetScale(ElementListType::ACTIVE, &max_scale));
   EXPECT_EQ(0.f, max_scale);
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
                                                   &max_scale));
   EXPECT_EQ(4.f, max_scale);
   EXPECT_TRUE(
       animations_impl->MaximumTargetScale(ElementListType::ACTIVE, &max_scale));
   EXPECT_EQ(4.f, max_scale);
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve2(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations2;
   curve2->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations2, nullptr));
   operations2.AppendScale(6.0, 5.0, 4.0);
   curve2->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations2, nullptr));
 
   animation =
       Animation::Create(std::move(curve2), 2, 2, TargetProperty::TRANSFORM);
   animation->set_affects_active_elements(false);
-  animations_impl->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(animation));
 
   EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
                                                   &max_scale));
   EXPECT_EQ(6.f, max_scale);
   EXPECT_TRUE(
       animations_impl->MaximumTargetScale(ElementListType::ACTIVE, &max_scale));
   EXPECT_EQ(4.f, max_scale);
 
   animations_impl->ActivateAnimations();
   EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
                                                   &max_scale));
   EXPECT_EQ(6.f, max_scale);
   EXPECT_TRUE(
       animations_impl->MaximumTargetScale(ElementListType::ACTIVE, &max_scale));
   EXPECT_EQ(6.f, max_scale);
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve3(
       KeyframedTransformAnimationCurve::Create());
 
   TransformOperations operations3;
   curve3->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations3, nullptr));
   operations3.AppendPerspective(6.0);
   curve3->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations3, nullptr));
 
   animation =
       Animation::Create(std::move(curve3), 3, 3, TargetProperty::TRANSFORM);
   animation->set_affects_active_elements(false);
-  animations_impl->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations_impl.get(), std::move(animation));
 
   EXPECT_FALSE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
                                                    &max_scale));
   EXPECT_TRUE(
       animations_impl->MaximumTargetScale(ElementListType::ACTIVE, &max_scale));
   EXPECT_EQ(6.f, max_scale);
 
   animations_impl->ActivateAnimations();
   EXPECT_FALSE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
                                                    &max_scale));
@@ skipping 29 matching lines @@
   curve1->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), operations1, nullptr));
   TransformOperations operations2;
   operations2.AppendScale(4.0, 5.0, 6.0);
   curve1->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operations2, nullptr));
 
   std::unique_ptr<Animation> animation_owned(
       Animation::Create(std::move(curve1), 1, 1, TargetProperty::TRANSFORM));
   Animation* animation = animation_owned.get();
-  animations_impl->AddAnimation(std::move(animation_owned));
+  AddAnimationToElementAnimations(animations_impl.get(),
+                                  std::move(animation_owned));
 
   float max_scale = 0.f;
 
   EXPECT_GT(animation->playback_rate(), 0.0);
 
   // NORMAL direction with positive playback rate.
   animation->set_direction(Animation::Direction::NORMAL);
   EXPECT_TRUE(animations_impl->MaximumTargetScale(ElementListType::PENDING,
                                                   &max_scale));
   EXPECT_EQ(6.f, max_scale);
@@ skipping 294 matching lines @@
   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);
+  RemoveAnimationFromElementAnimations(animations.get(), animation_id);
   EXPECT_FALSE(client_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::ACTIVE));
 
   animations->PushPropertiesTo(animations_impl.get());
   EXPECT_FALSE(client_impl_.GetHasPotentialTransformAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetTransformIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
@@ skipping 197 matching lines @@
   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);
+  RemoveAnimationFromElementAnimations(animations.get(), animation_id);
   EXPECT_FALSE(client_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetOpacityIsCurrentlyAnimating(element_id_,
                                                       ElementListType::ACTIVE));
 
   animations->PushPropertiesTo(animations_impl.get());
   EXPECT_FALSE(client_impl_.GetHasPotentialOpacityAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetOpacityIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
@@ skipping 196 matching lines @@
   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);
+  RemoveAnimationFromElementAnimations(animations.get(), animation_id);
   EXPECT_FALSE(client_.GetHasPotentialFilterAnimation(element_id_,
                                                       ElementListType::ACTIVE));
   EXPECT_FALSE(client_.GetFilterIsCurrentlyAnimating(element_id_,
                                                      ElementListType::ACTIVE));
 
   animations->PushPropertiesTo(animations_impl.get());
   EXPECT_FALSE(client_impl_.GetHasPotentialFilterAnimation(
       element_id_, ElementListType::PENDING));
   EXPECT_FALSE(client_impl_.GetFilterIsCurrentlyAnimating(
       element_id_, ElementListType::PENDING));
@@ skipping 139 matching lines @@
             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(
+  RemoveAnimationFromElementAnimations(
+      animations.get(),
       animations->GetAnimation(TargetProperty::OPACITY)->id());
   animations->PushPropertiesTo(animations_impl.get());
 
   // 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));
@@ skipping 26 matching lines @@
   const int first_animation_id = AddOpacityTransitionToElementAnimations(
       animations.get(), 1, 0.f, 1.f, true);
 
   animations->PushPropertiesTo(animations_impl.get());
   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(
+  RemoveAnimationFromElementAnimations(
+      animations.get(),
       animations->GetAnimation(TargetProperty::OPACITY)->id());
   const int second_animation_id = AddOpacityTransitionToElementAnimations(
       animations.get(), 1, 1.f, 0.5f, true);
   animations->PushPropertiesTo(animations_impl.get());
 
   // 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)
@@ skipping 50 matching lines @@
   AttachTimelinePlayerLayer();
 
   scoped_refptr<ElementAnimations> animations = element_animations();
 
   // 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);
 
-  animations->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations.get(), std::move(animation));
   animations->Animate(kInitialTickTime);
   EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::PENDING));
   EXPECT_FALSE(animations->IsCurrentlyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::ACTIVE));
   animations->UpdateState(true, nullptr);
   EXPECT_TRUE(animations->HasActiveAnimation());
 
   EXPECT_TRUE(animations->IsCurrentlyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::PENDING));
@@ skipping 53 matching lines @@
 
   // 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);
 
-  animations->AddAnimation(std::move(animation));
+  AddAnimationToElementAnimations(animations.get(), std::move(animation));
 
   animations->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(animations->IsPotentiallyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::PENDING));
   EXPECT_FALSE(animations->IsPotentiallyAnimatingProperty(
       TargetProperty::OPACITY, ElementListType::ACTIVE));
@@ skipping 47 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