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

cc/animation/animation_player.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_ANIMATION_PLAYER_H_
 #define CC_ANIMATION_ANIMATION_PLAYER_H_
 
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/animation_export.h"
 #include "cc/animation/element_animations.h"
 #include "cc/trees/element_id.h"
 
 namespace cc {
 
 class AnimationDelegate;
+class AnimationEvents;
 class AnimationHost;
 class AnimationTimeline;
 struct AnimationEvent;
 struct PropertyAnimationState;
 
 // An AnimationPlayer owns all animations to be run on particular CC Layer.
 // Multiple AnimationPlayers can be attached to one layer. In this case,
 // they share common ElementAnimations so the
 // ElementAnimations-to-Layer relationship is 1:1.
 // For now, the blink logic is responsible for handling of conflicting
@@ skipping 36 matching lines @@
 
   void AddAnimation(std::unique_ptr<Animation> animation);
   void PauseAnimation(int animation_id, double time_offset);
   void RemoveAnimation(int animation_id);
   void AbortAnimation(int animation_id);
   void AbortAnimations(TargetProperty::Type target_property,
                        bool needs_completion);
 
   void PushPropertiesTo(AnimationPlayer* player_impl);
 
+  void Animate(base::TimeTicks monotonic_time);
+  void UpdateState(bool start_ready_animations, AnimationEvents* events);
+
+  void UpdateActivation(ActivationType type);
+  void Deactivate();
+
   // AnimationDelegate routing.
   bool NotifyAnimationStarted(const AnimationEvent& event);
   bool NotifyAnimationFinished(const AnimationEvent& event);
   bool NotifyAnimationAborted(const AnimationEvent& event);
   void NotifyAnimationTakeover(const AnimationEvent& event);
   bool NotifyAnimationFinishedForTesting(TargetProperty::Type target_property,
                                          int group_id);
 
   // Returns true if there are any animations that have neither finished nor
   // aborted.
@@ skipping 57 matching lines @@
   // Returns the active animation animating the given property that is either
   // running, or is next to run, if such an animation exists.
   Animation* GetAnimation(TargetProperty::Type target_property) const;
 
   // Returns the active animation for the given unique animation id.
   Animation* GetAnimationById(int animation_id) const;
 
   void GetPropertyAnimationState(PropertyAnimationState* pending_state,
                                  PropertyAnimationState* active_state) 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_;
+  }
+
  private:
   friend class base::RefCounted<AnimationPlayer>;
 
   explicit AnimationPlayer(int id);
   ~AnimationPlayer();
 
   void SetNeedsCommit();
 
   void RegisterPlayer();
   void UnregisterPlayer();
@@ skipping 23 matching lines @@
 
   int id_;
   ElementId element_id_;
   bool needs_push_properties_;
   base::TimeTicks last_tick_time_;
 
   // 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_;
 
+  // This is used to ensure that we don't spam the animation host.
+  bool is_active_;
+
+  bool scroll_offset_animation_was_interrupted_;
+
   DISALLOW_COPY_AND_ASSIGN(AnimationPlayer);
 };
 
 }  // namespace cc
 
 #endif  // CC_ANIMATION_ANIMATION_PLAYER_H_