compositor: Tick the UI animations from cc, instead of from timer callbacks.

ui/compositor/layer.h

 // Copyright (c) 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 UI_COMPOSITOR_LAYER_H_
 #define UI_COMPOSITOR_LAYER_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 269 matching lines @@
   // Note that this _does not_ invalidate any region of this layer; use
   // SchedulePaint() for that.
   void ScheduleDraw();
 
   // Uses damaged rectangles recorded in |damaged_region_| to invalidate the
   // |cc_layer_|.
   void SendDamagedRects();
 
   const SkRegion& damaged_region() const { return damaged_region_; }
 
+  void CompleteAllAnimations();
+
   // Suppresses painting the content by disconnecting |delegate_|.
   void SuppressPaint();
 
   // Notifies the layer that the device scale factor has changed.
   void OnDeviceScaleFactorChanged(float device_scale_factor);
 
   // Requets a copy of the layer's output as a texture or bitmap.
   void RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request);
 
   // ContentLayerClient
@@ skipping 31 matching lines @@
   bool HasPendingThreadedAnimations() {
     return pending_threaded_animations_.size() != 0;
   }
 
   // Triggers a call to SwitchToLayer.
   void SwitchCCLayerForTest();
 
  private:
   friend class LayerOwner;
 
+  void CollectAnimators(std::vector<scoped_refptr<LayerAnimator> >* animators);
+
   // Stacks |child| above or below |other|.  Helper method for StackAbove() and
   // StackBelow().
   void StackRelativeTo(Layer* child, Layer* other, bool above);
 
   bool ConvertPointForAncestor(const Layer* ancestor, gfx::Point* point) const;
   bool ConvertPointFromAncestor(const Layer* ancestor, gfx::Point* point) const;
 
   // Implementation of LayerAnimatorDelegate
   virtual void SetBoundsFromAnimation(const gfx::Rect& bounds) OVERRIDE;
   virtual void SetTransformFromAnimation(
       const gfx::Transform& transform) OVERRIDE;
   virtual void SetOpacityFromAnimation(float opacity) OVERRIDE;
   virtual void SetVisibilityFromAnimation(bool visibility) OVERRIDE;
   virtual void SetBrightnessFromAnimation(float brightness) OVERRIDE;
   virtual void SetGrayscaleFromAnimation(float grayscale) OVERRIDE;
   virtual void SetColorFromAnimation(SkColor color) OVERRIDE;
   virtual void ScheduleDrawForAnimation() OVERRIDE;
   virtual const gfx::Rect& GetBoundsForAnimation() const OVERRIDE;
   virtual gfx::Transform GetTransformForAnimation() const OVERRIDE;
   virtual float GetOpacityForAnimation() const OVERRIDE;
   virtual bool GetVisibilityForAnimation() const OVERRIDE;
   virtual float GetBrightnessForAnimation() const OVERRIDE;
   virtual float GetGrayscaleForAnimation() const OVERRIDE;
   virtual SkColor GetColorForAnimation() const OVERRIDE;
   virtual float GetDeviceScaleFactor() const OVERRIDE;
   virtual void AddThreadedAnimation(
       scoped_ptr<cc::Animation> animation) OVERRIDE;
   virtual void RemoveThreadedAnimation(int animation_id) OVERRIDE;
+  virtual LayerAnimatorCollection* GetLayerAnimatorCollection() OVERRIDE;
 
   // Creates a corresponding composited layer for |type_|.
   void CreateWebLayer();
 
   // Recomputes and sets to |cc_layer_|.
   void RecomputeDrawsContentAndUVRect();
   void RecomputePosition();
 
   // Set all filters which got applied to the layer.
   void SetLayerFilters();
 
   // Set all filters which got applied to the layer background.
   void SetLayerBackgroundFilters();
 
   // Cleanup |cc_layer_| and replaces it with |new_layer|.
   void SwitchToLayer(scoped_refptr<cc::Layer> new_layer);
 
   // We cannot send animations to our cc_layer_ until we have been added to a
   // layer tree. Instead, we hold on to these animations in
   // pending_threaded_animations_, and expect SendPendingThreadedAnimations to
   // be called once we have been added to a tree.
   void SendPendingThreadedAnimations();
 
+  void AddAnimatorsInTreeToCollection(LayerAnimatorCollection* collection);
+  void RemoveAnimatorsInTreeFromCollection(LayerAnimatorCollection* collection);
+
+  // Returns whether the layer has an animating LayerAnimator.
+  bool IsAnimating() const;
+
   const LayerType type_;
 
   Compositor* compositor_;
 
   Layer* parent_;
 
   // This layer's children, in bottom-to-top stacking order.
   std::vector<Layer*> children_;
 
   gfx::Rect bounds_;
@@ skipping 69 matching lines @@
   // The size of the frame or texture in DIP, set when SetShowDelegatedContent
   // or SetTextureMailbox was called.
   gfx::Size frame_size_in_dip_;
 
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_H_