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

cc/animation/element_animations.h

 // 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.
 
 #ifndef CC_ANIMATION_ELEMENT_ANIMATIONS_H_
 #define CC_ANIMATION_ELEMENT_ANIMATIONS_H_
 
 #include <bitset>
 #include <memory>
 #include <vector>
@@ skipping 160 matching lines @@
   // the removed animation. This is to provide the illusion of synchronicity to
   // JS that simultaneously removes an animation and sets the scroll offset.
   bool scroll_offset_animation_was_interrupted() const {
     return scroll_offset_animation_was_interrupted_;
   }
 
   bool needs_to_start_animations_for_testing() {
     return needs_to_start_animations_;
   }
 
+  void SetNeedsPushProperties();
+  bool needs_push_properties() const { return needs_push_properties_; }
+
  private:
   friend class base::RefCounted<ElementAnimations>;
 
   ElementAnimations();
   ~ElementAnimations();
 
   // A set of target properties. TargetProperty must be 0-based enum.
   using TargetProperties =
       std::bitset<TargetProperty::LAST_TARGET_PROPERTY + 1>;
 
@@ skipping 23 matching lines @@
                                    bool notify_pending_elements);
   void NotifyClientTransformAnimated(const gfx::Transform& transform,
                                      bool notify_active_elements,
                                      bool notify_pending_elements);
   void NotifyClientFilterAnimated(const FilterOperations& filter,
                                   bool notify_active_elements,
                                   bool notify_pending_elements);
   void NotifyClientScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset,
                                         bool notify_active_elements,
                                         bool notify_pending_elements);
-
-  void NotifyClientAnimationWaitingForDeletion();
-
   void NotifyClientAnimationChanged(
       TargetProperty::Type property,
       ElementListType list_type,
       bool notify_elements_about_potential_animation,
       bool notify_elements_about_running_animation);
 
   void UpdateClientAnimationState(TargetProperty::Type property);
 
   void OnFilterAnimated(ElementListType list_type,
                         const FilterOperations& filters);
   void OnOpacityAnimated(ElementListType list_type, float opacity);
   void OnTransformAnimated(ElementListType list_type,
                            const gfx::Transform& transform);
   void OnScrollOffsetAnimated(ElementListType list_type,
                               const gfx::ScrollOffset& scroll_offset);
-  void OnAnimationWaitingForDeletion();
   void IsAnimatingChanged(ElementListType list_type,
                           TargetProperty::Type property,
                           AnimationChangeType change_type,
                           bool is_animating);
   gfx::ScrollOffset ScrollOffsetForAnimation() const;
 
   void NotifyPlayersAnimationStarted(base::TimeTicks monotonic_time,
                                      TargetProperty::Type target_property,
                                      int group);
   void NotifyPlayersAnimationFinished(base::TimeTicks monotonic_time,
                                       TargetProperty::Type target_property,
                                       int group);
   void NotifyPlayersAnimationAborted(base::TimeTicks monotonic_time,
                                      TargetProperty::Type target_property,
                                      int group);
+  void NotifyPlayersAnimationWaitingForDeletion();
   void NotifyPlayersAnimationPropertyUpdate(const AnimationEvent& event);
   void NotifyPlayersAnimationTakeover(base::TimeTicks monotonic_time,
                                       TargetProperty::Type target_property,
                                       double animation_start_time,
                                       std::unique_ptr<AnimationCurve> curve);
 
   std::unique_ptr<PlayersList> players_list_;
   AnimationHost* animation_host_;
   ElementId element_id_;
   std::vector<std::unique_ptr<Animation>> animations_;
 
   // This is used to ensure that we don't spam the animation host.
   bool is_active_;
 
   base::TimeTicks last_tick_time_;
 
   bool has_element_in_active_list_;
   bool has_element_in_pending_list_;
 
   // Only try to start animations when new animations are added or when the
   // previous attempt at starting animations failed to start all animations.
   bool needs_to_start_animations_;
 
   bool scroll_offset_animation_was_interrupted_;
 
+  bool needs_push_properties_;
+
   struct PropertyAnimationState {
     bool currently_running_for_active_elements = false;
     bool currently_running_for_pending_elements = false;
     bool potentially_animating_for_active_elements = false;
     bool potentially_animating_for_pending_elements = false;
     void Clear() {
       currently_running_for_active_elements = false;
       currently_running_for_pending_elements = false;
       potentially_animating_for_active_elements = false;
       potentially_animating_for_pending_elements = false;
     }
   };
 
   struct PropertyAnimationState filter_animation_state_;
   struct PropertyAnimationState opacity_animation_state_;
   struct PropertyAnimationState transform_animation_state_;
 
   DISALLOW_COPY_AND_ASSIGN(ElementAnimations);
 };
 
 }  // namespace cc
 
 #endif  // CC_ANIMATION_ELEMENT_ANIMATIONS_H_