Use an auxiliary list of animation controllers.

cc/layer.h

 // Copyright 2010 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_LAYER_H_
 #define CC_LAYER_H_
 
 #include <public/WebFilterOperations.h>
 #include <string>
 #include <vector>
@@ skipping 25 matching lines @@
 class LayerImpl;
 class LayerTreeHost;
 class PriorityCalculator;
 class ResourceUpdateQueue;
 class ScrollbarLayer;
 struct AnimationEvent;
 struct RenderingStats;
 
 // Base class for composited layers. Special layer types are derived from
 // this class.
-class CC_EXPORT Layer : public base::RefCounted<Layer>, public LayerAnimationControllerClient {
+class CC_EXPORT Layer : public base::RefCounted<Layer> {
 public:
     typedef std::vector<scoped_refptr<Layer> > LayerList;
 
     static scoped_refptr<Layer> create();
 
-    // LayerAnimationControllerClient implementation
-    virtual int id() const OVERRIDE;
-    virtual void setOpacityFromAnimation(float) OVERRIDE;
-    virtual float opacity() const OVERRIDE;
-    virtual void setTransformFromAnimation(const gfx::Transform&) OVERRIDE;
-    // A layer's transform operates layer space. That is, entirely in logical,
-    // non-page-scaled pixels (that is, they have page zoom baked in, but not page scale).
-    // The root layer is a special case -- it operates in physical pixels.
-    virtual const gfx::Transform& transform() const OVERRIDE;
+    int id() const;
 
     Layer* rootLayer();
     Layer* parent() { return m_parent; }
     const Layer* parent() const { return m_parent; }
     void addChild(scoped_refptr<Layer>);
     void insertChild(scoped_refptr<Layer>, size_t index);
     void replaceChild(Layer* reference, scoped_refptr<Layer> newLayer);
     void removeFromParent();
     void removeAllChildren();
     void setChildren(const LayerList&);
@@ skipping 20 matching lines @@
 
     void setMaskLayer(Layer*);
     Layer* maskLayer() { return m_maskLayer.get(); }
     const Layer* maskLayer() const { return m_maskLayer.get(); }
 
     virtual void setNeedsDisplayRect(const gfx::RectF& dirtyRect);
     void setNeedsDisplay() { setNeedsDisplayRect(gfx::RectF(gfx::PointF(), bounds())); }
     virtual bool needsDisplay() const;
 
     void setOpacity(float);
+    float opacity() const;
     bool opacityIsAnimating() const;
 
     void setFilters(const WebKit::WebFilterOperations&);
     const WebKit::WebFilterOperations& filters() const { return m_filters; }
 
     void setFilter(const skia::RefPtr<SkImageFilter>& filter);
     skia::RefPtr<SkImageFilter> filter() const { return m_filter; }
 
     // Background filters are filters applied to what is behind this layer, when they are viewed through non-opaque
     // regions in this layer. They are used through the WebLayer interface, and are not exposed to HTML.
     void setBackgroundFilters(const WebKit::WebFilterOperations&);
     const WebKit::WebFilterOperations& backgroundFilters() const { return m_backgroundFilters; }
 
     virtual void setContentsOpaque(bool);
     bool contentsOpaque() const { return m_contentsOpaque; }
 
     void setPosition(const gfx::PointF&);
     gfx::PointF position() const { return m_position; }
 
     void setIsContainerForFixedPositionLayers(bool);
     bool isContainerForFixedPositionLayers() const { return m_isContainerForFixedPositionLayers; }
 
     void setFixedToContainerLayer(bool);
     bool fixedToContainerLayer() const { return m_fixedToContainerLayer; }
 
     void setSublayerTransform(const gfx::Transform&);
     const gfx::Transform& sublayerTransform() const { return m_sublayerTransform; }
 
     void setTransform(const gfx::Transform&);
+    const gfx::Transform& transform() const;
     bool transformIsAnimating() const;
 
     DrawProperties<Layer, RenderSurface>& drawProperties() { return m_drawProperties; }
     const DrawProperties<Layer, RenderSurface>& drawProperties() const { return m_drawProperties; }
 
     // The following are shortcut accessors to get various information from m_drawProperties
     const gfx::Transform& drawTransform() const { return m_drawProperties.target_space_transform; }
     const gfx::Transform& screenSpaceTransform() const { return m_drawProperties.screen_space_transform; }
     float drawOpacity() const { return m_drawProperties.opacity; }
     bool drawOpacityIsAnimating() const { return m_drawProperties.opacity_is_animating; }
@@ skipping 119 matching lines @@
     virtual void setTexturePriorities(const PriorityCalculator&) { }
 
     bool addAnimation(scoped_ptr<ActiveAnimation>);
     void pauseAnimation(int animationId, double timeOffset);
     void removeAnimation(int animationId);
 
     void suspendAnimations(double monotonicTime);
     void resumeAnimations(double monotonicTime);
 
     LayerAnimationController* layerAnimationController() { return m_layerAnimationController.get(); }
-    void setLayerAnimationController(scoped_ptr<LayerAnimationController>);
-    scoped_ptr<LayerAnimationController> releaseLayerAnimationController();
+    void setLayerAnimationController(scoped_refptr<LayerAnimationController>);
+    scoped_refptr<LayerAnimationController> releaseLayerAnimationController();
 
     void setLayerAnimationDelegate(WebKit::WebAnimationDelegate* layerAnimationDelegate) { m_layerAnimationDelegate = layerAnimationDelegate; }
 
     bool hasActiveAnimation() const;
 
     virtual void notifyAnimationStarted(const AnimationEvent&, double wallClockTime);
     virtual void notifyAnimationFinished(double wallClockTime);
 
     virtual Region visibleContentOpaqueRegion() const;
 
@@ skipping 45 matching lines @@
     void removeChild(Layer*);
 
     LayerList m_children;
     Layer* m_parent;
 
     // Layer instances have a weak pointer to their LayerTreeHost.
     // This pointer value is nil when a Layer is not in a tree and is
     // updated via setLayerTreeHost() if a layer moves between trees.
     LayerTreeHost* m_layerTreeHost;
 
-    scoped_ptr<LayerAnimationController> m_layerAnimationController;
+    scoped_refptr<LayerAnimationController> m_layerAnimationController;
 
     // Layer properties.
     gfx::Size m_bounds;
 
     gfx::Vector2d m_scrollOffset;
     gfx::Vector2d m_maxScrollOffset;
     bool m_scrollable;
     bool m_shouldScrollOnMainThread;
     bool m_haveWheelEventHandlers;
     Region m_nonFastScrollableRegion;
     bool m_nonFastScrollableRegionChanged;
     Region m_touchEventHandlerRegion;
     bool m_touchEventHandlerRegionChanged;
     gfx::PointF m_position;
     gfx::PointF m_anchorPoint;
     SkColor m_backgroundColor;
     std::string m_debugName;
-    float m_opacity;
     skia::RefPtr<SkImageFilter> m_filter;
     WebKit::WebFilterOperations m_filters;
     WebKit::WebFilterOperations m_backgroundFilters;
     float m_anchorPointZ;
     bool m_isContainerForFixedPositionLayers;
     bool m_fixedToContainerLayer;
     bool m_isDrawable;
     bool m_masksToBounds;
     bool m_contentsOpaque;
     bool m_doubleSided;
     bool m_useLCDText;
     bool m_preserves3D;
     bool m_useParentBackfaceVisibility;
     bool m_drawCheckerboardForMissingTiles;
     bool m_forceRenderSurface;
 
-    gfx::Transform m_transform;
     gfx::Transform m_sublayerTransform;
 
     // Replica layer used for reflections.
     scoped_refptr<Layer> m_replicaLayer;
 
     // Transient properties.
     float m_rasterScale;
     bool m_automaticallyComputeRasterScale;
     bool m_boundsContainPageScale;
 
     gfx::Transform m_implTransform;
 
     WebKit::WebAnimationDelegate* m_layerAnimationDelegate;
     WebKit::WebLayerScrollClient* m_layerScrollClient;
 
     DrawProperties<Layer, RenderSurface> m_drawProperties;
 };
 
 void sortLayers(std::vector<scoped_refptr<Layer> >::iterator, std::vector<scoped_refptr<Layer> >::iterator, void*);
 
 }  // namespace cc
 
 #endif  // CC_LAYER_H_