CC Animation: Make AnimationPlayer to be a unit of activation.

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 <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
-#include "base/time/time.h"
 #include "cc/animation/animation_export.h"
 #include "cc/trees/element_id.h"
 #include "cc/trees/property_animation_state.h"
 #include "cc/trees/target_property.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 #include "ui/gfx/transform.h"
 
 namespace gfx {
 class BoxF;
 }
 
 namespace cc {
 
-class AnimationEvents;
 class AnimationHost;
 class AnimationPlayer;
 class FilterOperations;
 enum class ElementListType;
 struct AnimationEvent;
 
+enum class ActivationType { NORMAL, FORCE };
+
 // An ElementAnimations owns a list of all AnimationPlayers, attached to
 // the element.
 // This is a CC counterpart for blink::ElementAnimations (in 1:1 relationship).
 // No pointer to/from respective blink::ElementAnimations object for now.
 class CC_ANIMATION_EXPORT ElementAnimations
     : public base::RefCounted<ElementAnimations> {
  public:
   static scoped_refptr<ElementAnimations> Create();
 
   ElementId element_id() const { return element_id_; }
@@ skipping 16 matching lines @@
 
   typedef base::ObserverList<AnimationPlayer> PlayersList;
   const PlayersList& players_list() const { return players_list_; }
 
   // Ensures that the list of active animations on the main thread and the impl
   // thread are kept in sync. This function does not take ownership of the impl
   // thread ElementAnimations.
   void PushPropertiesTo(
       scoped_refptr<ElementAnimations> element_animations_impl) const;
 
-  void Animate(base::TimeTicks monotonic_time);
-
-  void UpdateState(bool start_ready_animations, AnimationEvents* events);
-
-  // Make animations affect active elements if and only if they affect
-  // pending elements. Any animations that no longer affect any elements
-  // are deleted.
-  void ActivateAnimations();
-
   // Returns true if there are any animations that have neither finished nor
   // aborted.
   bool HasActiveAnimation() const;
 
   // Returns true if there are any animations at all to process.
   bool HasAnyAnimation() const;
 
   bool HasAnyAnimationTargetingProperty(TargetProperty::Type property) const;
 
   // Returns true if there is an animation that is either currently animating
@@ skipping 49 matching lines @@
   // Sets |start_scale| to the maximum of starting animation scale along any
   // dimension at any destination in active animations. Returns false if the
   // starting scale cannot be computed.
   bool AnimationStartScale(ElementListType list_type, float* start_scale) const;
 
   // Sets |max_scale| to the maximum scale along any dimension at any
   // destination in active animations. Returns false if the maximum scale cannot
   // be computed.
   bool MaximumTargetScale(ElementListType list_type, float* max_scale) const;
 
-  // When a scroll animation is removed on the main thread, its compositor
-  // thread counterpart continues producing scroll deltas until activation.
-  // These scroll deltas need to be cleared at activation, so that the active
-  // element's scroll offset matches the offset provided by the main thread
-  // rather than a combination of this offset and scroll deltas produced by
-  // 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_;
-  }
-  void SetScrollOffsetAnimationWasInterrupted();
+  bool ScrollOffsetAnimationWasInterrupted() const;
 
   void SetNeedsPushProperties();
   bool needs_push_properties() const { return needs_push_properties_; }
 
   void UpdateClientAnimationState();
   void SetNeedsUpdateImplClientState();
 
-  void UpdateActivationNormal();
-
   void NotifyClientOpacityAnimated(float opacity,
                                    bool notify_active_elements,
                                    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);
   gfx::ScrollOffset ScrollOffsetForAnimation() const;
 
  private:
   friend class base::RefCounted<ElementAnimations>;
 
   ElementAnimations();
   ~ElementAnimations();
 
-  enum class ActivationType { NORMAL, FORCE };
-  void UpdateActivation(ActivationType type);
-
   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);
 
   static TargetProperties GetPropertiesMaskForAnimationState();
 
+  void UpdateActivation(ActivationType activation_type) const;
+  void Deactivate() const;
+
   PlayersList players_list_;
   AnimationHost* animation_host_;
   ElementId element_id_;
 
-  // 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_;
 
-  mutable bool scroll_offset_animation_was_interrupted_;
-
   mutable bool needs_push_properties_;
 
   PropertyAnimationState active_state_;
   PropertyAnimationState pending_state_;
 
   mutable bool needs_update_impl_client_state_;
 
   DISALLOW_COPY_AND_ASSIGN(ElementAnimations);
 };
 
 }  // namespace cc
 
 #endif  // CC_ANIMATION_ELEMENT_ANIMATIONS_H_