Use an auxiliary list of animation controllers.

cc/layer_tree_host.cc

 // 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.
 
 #include "cc/layer_tree_host.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
+#include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "cc/font_atlas.h"
 #include "cc/heads_up_display_layer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_iterator.h"
 #include "cc/layer_tree_host_client.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/layer_tree_host_impl.h"
@@ skipping 150 matching lines @@
 scoped_ptr<LayerTreeHost> LayerTreeHost::create(LayerTreeHostClient* client, const LayerTreeSettings& settings, scoped_ptr<Thread> implThread)
 {
     scoped_ptr<LayerTreeHost> layerTreeHost(new LayerTreeHost(client, settings));
     if (!layerTreeHost->initialize(implThread.Pass()))
         return scoped_ptr<LayerTreeHost>();
     return layerTreeHost.Pass();
 }
 
 LayerTreeHost::LayerTreeHost(LayerTreeHostClient* client, const LayerTreeSettings& settings)
     : m_animating(false)
-    , m_needsAnimateLayers(false)
     , m_needsFullTreeSync(true)
     , m_client(client)
     , m_commitNumber(0)
     , m_renderingStats()
     , m_rendererInitialized(false)
     , m_outputSurfaceLost(false)
     , m_numTimesRecreateShouldFail(0)
     , m_numFailedRecreateAttempts(0)
     , m_settings(settings)
     , m_debugState(settings.initialDebugState)
@@ skipping 37 matching lines @@
     if (m_rootLayer)
         m_rootLayer->setLayerTreeHost(0);
     DCHECK(m_proxy);
     DCHECK(m_proxy->isMainThread());
     TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
     m_proxy->stop();
     numLayerTreeInstances--;
     RateLimiterMap::iterator it = m_rateLimiters.begin();
     if (it != m_rateLimiters.end())
         it->second->stop();
+
+    if (m_rootLayer)
+        m_rootLayer = 0;
 }
 
 void LayerTreeHost::setSurfaceReady()
 {
     m_proxy->setSurfaceReady();
 }
 
 void LayerTreeHost::initializeRenderer()
 {
     TRACE_EVENT0("cc", "LayerTreeHost::initializeRenderer");
@@ skipping 132 matching lines @@
         TRACE_EVENT0("cc", "LayerTreeHost::pushPropertiesRecursive");
         pushPropertiesRecursive(rootLayer(), hostImpl->rootLayer());
     }
     m_needsFullTreeSync = false;
 
     if (m_rootLayer && m_hudLayer)
         hostImpl->activeTree()->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(LayerTreeHostCommon::findLayerInSubtree(hostImpl->rootLayer(), m_hudLayer->id())));
     else
         hostImpl->activeTree()->set_hud_layer(0);
 
-    // We may have added an animation during the tree sync. This will cause both layer tree hosts
-    // to visit their controllers.
-    if (rootLayer() && m_needsAnimateLayers)
-        hostImpl->setNeedsAnimateLayers();
-
     hostImpl->activeTree()->set_source_frame_number(commitNumber());
     hostImpl->setViewportSize(layoutViewportSize(), deviceViewportSize());
     hostImpl->setDeviceScaleFactor(deviceScaleFactor());
     hostImpl->setPageScaleFactorAndLimits(m_pageScaleFactor, m_minPageScaleFactor, m_maxPageScaleFactor);
     hostImpl->setBackgroundColor(m_backgroundColor);
     hostImpl->setHasTransparentBackground(m_hasTransparentBackground);
     hostImpl->setDebugState(m_debugState);
 
     m_commitNumber++;
 }
@@ skipping 113 matching lines @@
 {
     return m_proxy->commitRequested();
 }
 
 void LayerTreeHost::setAnimationEvents(scoped_ptr<AnimationEventsVector> events, base::Time wallClockTime)
 {
     DCHECK(m_proxy->isMainThread());
     setAnimationEventsRecursive(*events.get(), m_rootLayer.get(), wallClockTime);
 }
 
-void LayerTreeHost::didAddAnimation()
-{
-    m_needsAnimateLayers = true;
-    m_proxy->didAddAnimation();
-}
-
 void LayerTreeHost::setRootLayer(scoped_refptr<Layer> rootLayer)
 {
     if (m_rootLayer == rootLayer)
         return;
 
     if (m_rootLayer)
         m_rootLayer->setLayerTreeHost(0);
     m_rootLayer = rootLayer;
     if (m_rootLayer)
         m_rootLayer->setLayerTreeHost(this);
@@ skipping 382 matching lines @@
 {
     if (deviceScaleFactor ==  m_deviceScaleFactor)
         return;
     m_deviceScaleFactor = deviceScaleFactor;
 
     setNeedsCommit();
 }
 
 void LayerTreeHost::animateLayers(base::TimeTicks time)
 {
-    if (!m_settings.acceleratedAnimationEnabled || !m_needsAnimateLayers)
+    if (!m_settings.acceleratedAnimationEnabled || m_activeAnimationControllers.empty())
         return;
 
     TRACE_EVENT0("cc", "LayerTreeHostImpl::animateLayers");
-    m_needsAnimateLayers = animateLayersRecursive(m_rootLayer.get(), time);
-}
 
-bool LayerTreeHost::animateLayersRecursive(Layer* current, base::TimeTicks time)
-{
-    if (!current)
-        return false;
+    double monotonicTime = (time - base::TimeTicks()).InSecondsF();
 
-    bool subtreeNeedsAnimateLayers = false;
-    LayerAnimationController* currentController = current->layerAnimationController();
-    double monotonicTime = (time - base::TimeTicks()).InSecondsF();
-    currentController->animate(monotonicTime, 0);
-
-    // If the current controller still has an active animation, we must continue animating layers.
-    if (currentController->hasActiveAnimation())
-         subtreeNeedsAnimateLayers = true;
-
-    for (size_t i = 0; i < current->children().size(); ++i) {
-        if (animateLayersRecursive(current->children()[i].get(), time))
-            subtreeNeedsAnimateLayers = true;
-    }
-
-    return subtreeNeedsAnimateLayers;
+    AnimationControllerSet copy = m_activeAnimationControllers;
+    for (AnimationControllerSet::iterator iter = copy.begin(); iter != copy.end(); ++iter)
+        (*iter)->animate(monotonicTime, 0);
 }
 
 void LayerTreeHost::setAnimationEventsRecursive(const AnimationEventsVector& events, Layer* layer, base::Time wallClockTime)
 {
     if (!layer)
         return;
 
     for (size_t eventIndex = 0; eventIndex < events.size(); ++eventIndex) {
         if (layer->id() == events[eventIndex].layerId) {
             if (events[eventIndex].type == AnimationEvent::Started)
                 layer->notifyAnimationStarted(events[eventIndex], wallClockTime.ToDoubleT());
             else
                 layer->notifyAnimationFinished(wallClockTime.ToDoubleT());
         }
     }
 
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
+void LayerTreeHost::DidActivateAnimationController(LayerAnimationController* controller) {
+    // Controllers register themselves when they have new animations. We need
+    // to commit in this case.
+    setNeedsCommit();
+    m_activeAnimationControllers.insert(controller);
+}
+
+void LayerTreeHost::DidDeactivateAnimationController(LayerAnimationController* controller) {
+    if (ContainsKey(m_activeAnimationControllers, controller))
+        m_activeAnimationControllers.erase(controller);
+}
+
+void LayerTreeHost::RegisterAnimationController(LayerAnimationController* controller) {
+#if !defined(NDEBUG)
+    m_allAnimationControllers.insert(controller);
+#endif
+}
+
+void LayerTreeHost::UnregisterAnimationController(LayerAnimationController* controller) {
+#if !defined(NDEBUG)
+    if (ContainsKey(m_allAnimationControllers, controller))
+        m_allAnimationControllers.erase(controller);
+#endif
+    DidDeactivateAnimationController(controller);
+}
+
 }  // namespace cc