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 12 matching lines @@
   UpdateActivation(NORMAL_ACTIVATION);
   switch (target_property) {
     case TargetProperty::TRANSFORM:
     case TargetProperty::OPACITY:
     case TargetProperty::FILTER:
       UpdateClientAnimationState(target_property);
       break;
     default:
       break;
   }
+  SetNeedsPushProperties();
 }
 
 void ElementAnimations::Animate(base::TimeTicks monotonic_time) {
   DCHECK(!monotonic_time.is_null());
   if (!has_element_in_active_list() && !has_element_in_pending_list())
     return;
 
   if (needs_to_start_animations_)
     StartAnimations(monotonic_time);
   TickAnimations(monotonic_time);
@@ skipping 709 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 156 matching lines @@
 
 void ElementAnimations::PauseAnimation(int animation_id,
                                        base::TimeDelta time_offset) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->id() == animation_id) {
       animations_[i]->SetRunState(Animation::PAUSED,
                                   time_offset + animations_[i]->start_time() +
                                       animations_[i]->time_offset());
     }
   }
+  SetNeedsPushProperties();
 }
 
 void ElementAnimations::RemoveAnimation(int animation_id) {
   bool removed_transform_animation = false;
   bool removed_opacity_animation = false;
   bool removed_filter_animation = false;
   // Since we want to use the animations that we're going to remove, we need to
   // use a stable_parition here instead of remove_if. Remove_if leaves the
   // removed items in an unspecified state.
   auto animations_to_remove = std::stable_partition(
@@ skipping 17 matching lines @@
   }
 
   animations_.erase(animations_to_remove, animations_.end());
   UpdateActivation(NORMAL_ACTIVATION);
   if (removed_transform_animation)
     UpdateClientAnimationState(TargetProperty::TRANSFORM);
   if (removed_opacity_animation)
     UpdateClientAnimationState(TargetProperty::OPACITY);
   if (removed_filter_animation)
     UpdateClientAnimationState(TargetProperty::FILTER);
+
+  SetNeedsPushProperties();
 }
 
 void ElementAnimations::AbortAnimation(int animation_id) {
   if (Animation* animation = GetAnimationById(animation_id)) {
     if (!animation->is_finished()) {
       animation->SetRunState(Animation::ABORTED, last_tick_time_);
       switch (animation->target_property()) {
         case TargetProperty::TRANSFORM:
         case TargetProperty::OPACITY:
         case TargetProperty::FILTER:
           UpdateClientAnimationState(animation->target_property());
           break;
         default:
           break;
       }
     }
   }
+
+  SetNeedsPushProperties();
 }
 
 void ElementAnimations::AbortAnimations(TargetProperty::Type target_property,
                                         bool needs_completion) {
   if (needs_completion)
     DCHECK(target_property == TargetProperty::SCROLL_OFFSET);
 
   bool aborted_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->target_property() == target_property &&
@@ skipping 13 matching lines @@
     switch (target_property) {
       case TargetProperty::TRANSFORM:
       case TargetProperty::OPACITY:
       case TargetProperty::FILTER:
         UpdateClientAnimationState(target_property);
         break;
       default:
         break;
     }
   }
+
+  SetNeedsPushProperties();
 }
 
 Animation* ElementAnimations::GetAnimation(
     TargetProperty::Type target_property) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     size_t index = animations_.size() - i - 1;
     if (animations_[index]->target_property() == target_property)
       return animations_[index].get();
   }
   return nullptr;
@@ skipping 36 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