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

cc/animation/element_animations.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 <stddef.h>
 
 #include <algorithm>
 
@@ skipping 15 matching lines @@
 }
 
 ElementAnimations::ElementAnimations()
     : players_list_(new PlayersList()),
       animation_host_(),
       element_id_(),
       is_active_(false),
       has_element_in_active_list_(false),
       has_element_in_pending_list_(false),
       needs_to_start_animations_(false),
-      scroll_offset_animation_was_interrupted_(false) {}
+      scroll_offset_animation_was_interrupted_(false),
+      needs_push_properties_(false) {}
 
 ElementAnimations::~ElementAnimations() {}
 
 void ElementAnimations::SetAnimationHost(AnimationHost* host) {
   animation_host_ = host;
 }
 
 void ElementAnimations::SetElementId(ElementId element_id) {
   element_id_ = element_id;
 }
@@ skipping 68 matching lines @@
 }
 
 void ElementAnimations::RemovePlayer(AnimationPlayer* player) {
   players_list_->RemoveObserver(player);
 }
 
 bool ElementAnimations::IsEmpty() const {
   return !players_list_->might_have_observers();
 }
 
+void ElementAnimations::SetNeedsPushProperties() {
+  needs_push_properties_ = true;
+}
+
 void ElementAnimations::PushPropertiesTo(
     scoped_refptr<ElementAnimations> element_animations_impl) {
   DCHECK_NE(this, element_animations_impl);
+
+  if (!needs_push_properties_)
+    return;
+  needs_push_properties_ = false;
+
   if (!has_any_animation() && !element_animations_impl->has_any_animation())
     return;
   MarkAbortedAnimationsForDeletion(element_animations_impl.get());
   PurgeAnimationsMarkedForDeletion();
   PushNewAnimationsToImplThread(element_animations_impl.get());
 
   // Remove finished impl side animations only after pushing,
   // and only after the animations are deleted on the main thread
   // this insures we will never push an animation twice.
   RemoveAnimationsCompletedOnMainThread(element_animations_impl.get());
@@ skipping 741 matching lines @@
           else
             events->events_.push_back(finished_event);
         }
         animations_[animation_index]->SetRunState(
             Animation::WAITING_FOR_DELETION, monotonic_time);
       }
       marked_animations_for_deletions = true;
     }
   }
   if (marked_animations_for_deletions)
-    NotifyClientAnimationWaitingForDeletion();
+    NotifyPlayersAnimationWaitingForDeletion();
 }
 
 void ElementAnimations::MarkAbortedAnimationsForDeletion(
     ElementAnimations* element_animations_impl) const {
   bool aborted_transform_animation = false;
   bool aborted_opacity_animation = false;
   bool aborted_filter_animation = false;
   auto& animations_impl = element_animations_impl->animations_;
   for (const auto& animation_impl : animations_impl) {
     // If the animation has been aborted on the main thread, mark it for
@@ skipping 158 matching lines @@
 void ElementAnimations::NotifyClientScrollOffsetAnimated(
     const gfx::ScrollOffset& scroll_offset,
     bool notify_active_elements,
     bool notify_pending_elements) {
   if (notify_active_elements && has_element_in_active_list())
     OnScrollOffsetAnimated(ElementListType::ACTIVE, scroll_offset);
   if (notify_pending_elements && has_element_in_pending_list())
     OnScrollOffsetAnimated(ElementListType::PENDING, scroll_offset);
 }
 
-void ElementAnimations::NotifyClientAnimationWaitingForDeletion() {
-  OnAnimationWaitingForDeletion();
-}
-
 void ElementAnimations::NotifyClientAnimationChanged(
     TargetProperty::Type property,
     ElementListType list_type,
     bool notify_elements_about_potential_animation,
     bool notify_elements_about_running_animation) {
   struct PropertyAnimationState* animation_state = nullptr;
   switch (property) {
     case TargetProperty::OPACITY:
       animation_state = &opacity_animation_state_;
       break;
@@ skipping 299 matching lines @@
 void ElementAnimations::OnScrollOffsetAnimated(
     ElementListType list_type,
     const gfx::ScrollOffset& scroll_offset) {
   DCHECK(element_id());
   DCHECK(animation_host());
   DCHECK(animation_host()->mutator_host_client());
   animation_host()->mutator_host_client()->SetElementScrollOffsetMutated(
       element_id(), list_type, scroll_offset);
 }
 
-void ElementAnimations::OnAnimationWaitingForDeletion() {
-  // TODO(loyso): Invalidate AnimationHost::SetNeedsPushProperties here.
-  // But we always do PushProperties in AnimationHost for now. crbug.com/604280
-  DCHECK(animation_host());
-  animation_host()->OnAnimationWaitingForDeletion();
-}
-
 void ElementAnimations::IsAnimatingChanged(ElementListType list_type,
                                            TargetProperty::Type property,
                                            AnimationChangeType change_type,
                                            bool is_animating) {
   if (!element_id())
     return;
   DCHECK(animation_host());
   if (animation_host()->mutator_host_client()) {
     switch (property) {
       case TargetProperty::OPACITY:
@@ skipping 46 matching lines @@
 void ElementAnimations::NotifyPlayersAnimationAborted(
     base::TimeTicks monotonic_time,
     TargetProperty::Type target_property,
     int group) {
   ElementAnimations::PlayersList::Iterator it(players_list_.get());
   AnimationPlayer* player;
   while ((player = it.GetNext()) != nullptr)
     player->NotifyAnimationAborted(monotonic_time, target_property, group);
 }
 
+void ElementAnimations::NotifyPlayersAnimationWaitingForDeletion() {
+  ElementAnimations::PlayersList::Iterator it(players_list_.get());
+  AnimationPlayer* player;
+  while ((player = it.GetNext()) != nullptr)
+    player->NotifyAnimationWaitingForDeletion();
+}
+
 void ElementAnimations::NotifyPlayersAnimationTakeover(
     base::TimeTicks monotonic_time,
     TargetProperty::Type target_property,
     double animation_start_time,
     std::unique_ptr<AnimationCurve> curve) {
   DCHECK(curve);
   ElementAnimations::PlayersList::Iterator it(players_list_.get());
   AnimationPlayer* player;
   while ((player = it.GetNext()) != nullptr) {
     std::unique_ptr<AnimationCurve> animation_curve = curve->Clone();
     player->NotifyAnimationTakeover(monotonic_time, target_property,
                                     animation_start_time,
                                     std::move(animation_curve));
   }
 }
 
 gfx::ScrollOffset ElementAnimations::ScrollOffsetForAnimation() const {
   if (animation_host()) {
     DCHECK(animation_host()->mutator_host_client());
     return animation_host()->mutator_host_client()->GetScrollOffsetForAnimation(
         element_id());
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc