cc: Make LayerAnimationController keep state for clearing scroll delta

cc/animation/layer_animation_controller.h

 // Copyright 2012 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_LAYER_ANIMATION_CONTROLLER_H_
 #define CC_ANIMATION_LAYER_ANIMATION_CONTROLLER_H_
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
@@ skipping 121 matching lines @@
 
   bool HasOnlyTranslationTransforms() const;
 
   bool AnimationsPreserveAxisAlignment() 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(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
+  // layer'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_;
+  }
+
   bool needs_to_start_animations_for_testing() {
     return needs_to_start_animations_;
   }
 
  protected:
   friend class base::RefCounted<LayerAnimationController>;
 
   explicit LayerAnimationController(int id);
   virtual ~LayerAnimationController();
 
  private:
   typedef base::hash_set<int> TargetProperties;
 
   void PushNewAnimationsToImplThread(
       LayerAnimationController* controller_impl) const;
   void RemoveAnimationsCompletedOnMainThread(
       LayerAnimationController* controller_impl) const;
-  void PushPropertiesToImplThread(
-      LayerAnimationController* controller_impl) const;
+  void PushPropertiesToImplThread(LayerAnimationController* controller_impl);
 
   void StartAnimations(base::TimeTicks monotonic_time);
   void PromoteStartedAnimations(base::TimeTicks monotonic_time,
                                 AnimationEventsVector* events);
   void MarkFinishedAnimations(base::TimeTicks monotonic_time);
   void MarkAnimationsForDeletion(base::TimeTicks monotonic_time,
                                  AnimationEventsVector* events);
   void PurgeAnimationsMarkedForDeletion();
 
   void TickAnimations(base::TimeTicks monotonic_time);
@@ skipping 13 matching lines @@
   void NotifyObserversFilterAnimated(const FilterOperations& filter,
                                      bool notify_active_observers,
                                      bool notify_pending_observers);
   void NotifyObserversScrollOffsetAnimated(
       const gfx::ScrollOffset& scroll_offset,
       bool notify_active_observers,
       bool notify_pending_observers);
 
   void NotifyObserversAnimationWaitingForDeletion();
 
-  void NotifyObserversScrollOffsetAnimationRemoved();
-
   bool HasValueObserver();
   bool HasActiveValueObserver();
 
   AnimationRegistrar* registrar_;
   int id_;
   ScopedPtrVector<Animation> animations_;
 
   // This is used to ensure that we don't spam the registrar.
   bool is_active_;
 
   base::TimeTicks last_tick_time_;
 
   ObserverList<LayerAnimationValueObserver> value_observers_;
   ObserverList<LayerAnimationEventObserver> event_observers_;
 
   LayerAnimationValueProvider* value_provider_;
 
   AnimationDelegate* layer_animation_delegate_;
 
   // 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_;
+
   DISALLOW_COPY_AND_ASSIGN(LayerAnimationController);
 };
 
 }  // namespace cc
 
 #endif  // CC_ANIMATION_LAYER_ANIMATION_CONTROLLER_H_