cc: Support animating scroll offset

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 12 matching lines @@
 }
 
 namespace cc {
 
 class Animation;
 class AnimationDelegate;
 class AnimationRegistrar;
 class FilterOperations;
 class KeyframeValueList;
 class LayerAnimationValueObserver;
+class LayerAnimationValueProvider;
 
 class CC_EXPORT LayerAnimationController
     : public base::RefCounted<LayerAnimationController> {
  public:
   static scoped_refptr<LayerAnimationController> Create(int id);
 
   int id() const { return id_; }
 
   void AddAnimation(scoped_ptr<Animation> animation);
   void PauseAnimation(int animation_id, double time_offset);
@@ skipping 45 matching lines @@
                                double wall_clock_time);
   void NotifyAnimationAborted(const AnimationEvent& event);
   void NotifyAnimationPropertyUpdate(const AnimationEvent& event);
 
   void AddValueObserver(LayerAnimationValueObserver* observer);
   void RemoveValueObserver(LayerAnimationValueObserver* observer);
 
   void AddEventObserver(LayerAnimationEventObserver* observer);
   void RemoveEventObserver(LayerAnimationEventObserver* observer);
 
+  void set_value_provider(LayerAnimationValueProvider* provider) {
+    value_provider_ = provider;
+  }
+
+  void remove_value_provider(LayerAnimationValueProvider* provider) {

[Ian Vollick, 2013/11/29 15:29:29]

Why not just set_value_provider(NULL)?

[ajuma, 2013/11/29 21:18:41]

The issue is that a LayerImpl might not know whether it's the value provider for
its LayerAnimationController. Only active layers act as value providers.
LayerImpl checks IsActive before setting itself up as a value provider. Doing
the same thing for de-registering seems more fragile, since IsActive works by
checking if the LayerImpl's tree is the same as LayerTreeHostImpl's active_tree.
If, in the future, we allowed a LayerTreeHostImpl to throw away its active tree
and create a  new one, and if the old active tree's destruction sequence
happened after LayerTreeHostImpl's active tree pointer had been reset, relying
on the IsActive check when destroying would lead to incorrect behavior here.

[Ian Vollick, 2013/12/02 21:23:32]

Thanks for the explanation.

+    if (value_provider_ == provider)
+      value_provider_ = NULL;
+  }
+
   void set_layer_animation_delegate(AnimationDelegate* delegate) {
     layer_animation_delegate_ = delegate;
   }
 
   bool AnimatedBoundsForBox(const gfx::BoxF& box, gfx::BoxF* bounds);
 
  protected:
   friend class base::RefCounted<LayerAnimationController>;
 
   explicit LayerAnimationController(int id);
@@ skipping 21 matching lines @@
 
   enum UpdateActivationType {
     NormalActivation,
     ForceActivation
   };
   void UpdateActivation(UpdateActivationType type);
 
   void NotifyObserversOpacityAnimated(float opacity);
   void NotifyObserversTransformAnimated(const gfx::Transform& transform);
   void NotifyObserversFilterAnimated(const FilterOperations& filter);
+  void NotifyObserversScrollOffsetAnimated(gfx::Vector2dF scroll_offset);
 
   void NotifyObserversAnimationWaitingForDeletion();
 
   bool HasValueObserver();
   bool HasActiveValueObserver();
 
   AnimationRegistrar* registrar_;
   int id_;
   ScopedPtrVector<Animation> active_animations_;
 
   // This is used to ensure that we don't spam the registrar.
   bool is_active_;
 
   double last_tick_time_;
 
   ObserverList<LayerAnimationValueObserver> value_observers_;
   ObserverList<LayerAnimationEventObserver> event_observers_;
 
+  LayerAnimationValueProvider* value_provider_;
+
   AnimationDelegate* layer_animation_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerAnimationController);
 };
 
 }  // namespace cc
 
 #endif  // CC_ANIMATION_LAYER_ANIMATION_CONTROLLER_H_