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 647 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 965 matching lines @@
   animations->AddAnimation(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.
@@ skipping 243 matching lines @@
   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);
   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 29 matching lines @@
   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);
   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());
 
+  // 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());
   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);
@@ skipping 1644 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