Use an auxiliary list of animation controllers.

cc/layer_tree_host.h

 // Copyright 2011 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_TREE_HOST_H_
 #define CC_LAYER_TREE_HOST_H_
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/cancelable_callback.h"
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
 #include "cc/animation_events.h"
+#include "cc/animation_registrar.h"
 #include "cc/cc_export.h"
 #include "cc/graphics_context.h"
 #include "cc/layer_tree_host_client.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/occlusion_tracker.h"
 #include "cc/prioritized_resource_manager.h"
 #include "cc/proxy.h"
 #include "cc/rate_limiter.h"
 #include "cc/rendering_stats.h"
 #include "cc/scoped_ptr_vector.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/rect.h"
 
 #if defined(COMPILER_GCC)
 namespace BASE_HASH_NAMESPACE {
 template<>
 struct hash<WebKit::WebGraphicsContext3D*> {
   size_t operator()(WebKit::WebGraphicsContext3D* ptr) const {
     return hash<size_t>()(reinterpret_cast<size_t>(ptr));
   }
 };
 } // namespace BASE_HASH_NAMESPACE
+
+namespace BASE_HASH_NAMESPACE {
+template<>
+struct hash<cc::LayerAnimationController*> {
+  size_t operator()(cc::LayerAnimationController* ptr) const {
+    return hash<size_t>()(reinterpret_cast<size_t>(ptr));
+  }
+};
+} // namespace BASE_HASH_NAMESPACE
 #endif // COMPILER
 
 namespace cc {
 
 class FontAtlas;
 class Layer;
 class LayerTreeHostImpl;
 class LayerTreeHostImplClient;
 class PrioritizedResourceManager;
 class ResourceUpdateQueue;
@@ skipping 43 matching lines @@
     bool usingPartialSwap;
     bool usingAcceleratedPainting;
     bool usingSetVisibility;
     bool usingSwapCompleteCallback;
     bool usingGpuMemoryManager;
     bool usingDiscardFramebuffer;
     bool usingEglImage;
     int maxTextureSize;
 };
 
-class CC_EXPORT LayerTreeHost : public RateLimiterClient {
+class CC_EXPORT LayerTreeHost : public RateLimiterClient,
+                                public AnimationRegistrar {
 public:
     static scoped_ptr<LayerTreeHost> create(LayerTreeHostClient*, const LayerTreeSettings&, scoped_ptr<Thread> implThread);
     virtual ~LayerTreeHost();
 
     void setSurfaceReady();
 
     // Returns true if any LayerTreeHost is alive.
     static bool anyLayerTreeHostInstanceExists();
 
     static bool needsFilterContext() { return s_needsFilterContext; }
@@ skipping 55 matching lines @@
     // Test only hook
     void loseContext(int numTimes);
 
     void setNeedsAnimate();
     // virtual for testing
     virtual void setNeedsCommit();
     void setNeedsRedraw();
     bool commitRequested() const;
 
     void setAnimationEvents(scoped_ptr<AnimationEventsVector>, base::Time wallClockTime);
-    virtual void didAddAnimation();
 
     Layer* rootLayer() { return m_rootLayer.get(); }
     const Layer* rootLayer() const { return m_rootLayer.get(); }
     void setRootLayer(scoped_refptr<Layer>);
 
     const LayerTreeSettings& settings() const { return m_settings; }
 
     void setViewportSize(const gfx::Size& layoutViewportSize, const gfx::Size& deviceViewportSize);
 
     const gfx::Size& layoutViewportSize() const { return m_layoutViewportSize; }
@@ skipping 36 matching lines @@
     void setFontAtlas(scoped_ptr<FontAtlas>);
 
     HeadsUpDisplayLayer* hudLayer() const { return m_hudLayer.get(); }
 
     Proxy* proxy() const { return m_proxy.get(); }
 
 protected:
     LayerTreeHost(LayerTreeHostClient*, const LayerTreeSettings&);
     bool initialize(scoped_ptr<Thread> implThread);
 
+    // AnimationRegistar implementation.

[nduca, 2012/12/04 05:40:26]

so, walk me through the benefit of this being LTH rather than ref-counted
global?

+    virtual void Register(LayerAnimationController*) OVERRIDE;
+    virtual void Unregister(LayerAnimationController*) OVERRIDE;
+
 private:
     typedef std::vector<scoped_refptr<Layer> > LayerList;
+    typedef base::hash_set<LayerAnimationController*> AnimationControllerSet;
 
     void initializeRenderer();
 
     void update(Layer*, ResourceUpdateQueue&, const OcclusionTracker*);
     bool paintLayerContents(const LayerList&, ResourceUpdateQueue&);
     bool paintMasksForRenderSurface(Layer*, ResourceUpdateQueue&);
 
     void updateLayers(Layer*, ResourceUpdateQueue&);
     void triggerPrepaint();
 
     void prioritizeTextures(const LayerList&, OverdrawMetrics&); 
     void setPrioritiesForSurfaces(size_t surfaceMemoryBytes);
     void setPrioritiesForLayers(const LayerList&);
     size_t calculateMemoryForRenderSurfaces(const LayerList& updateList);
 
     void animateLayers(base::TimeTicks monotonicTime);
     bool animateLayersRecursive(Layer* current, base::TimeTicks time);
     void setAnimationEventsRecursive(const AnimationEventsVector&, Layer*, base::Time wallClockTime);
 
     void createHUDLayerIfNeeded();
 
     bool m_animating;
-    bool m_needsAnimateLayers;
 
     base::CancelableClosure m_prepaintCallback;
 
     LayerTreeHostClient* m_client;
     scoped_ptr<Proxy> m_proxy;
 
     int m_commitNumber;
     RenderingStats m_renderingStats;
 
     bool m_rendererInitialized;
@@ skipping 24 matching lines @@
     bool m_triggerIdleUpdates;
 
     SkColor m_backgroundColor;
     bool m_hasTransparentBackground;
 
     typedef ScopedPtrVector<PrioritizedResource> TextureList;
     size_t m_partialTextureUpdateRequests;
 
     static bool s_needsFilterContext;
 
+    AnimationControllerSet m_activeAnimationControllers;
+
     DISALLOW_COPY_AND_ASSIGN(LayerTreeHost);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYER_TREE_HOST_H_