Ref count layer animation controllers.

cc/layer_tree_host_impl.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_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "base/json/json_writer.h"
+#include "base/stl_util.h"
 #include "cc/append_quads_data.h"
 #include "cc/damage_tracker.h"
 #include "cc/debug_rect_history.h"
 #include "cc/delay_based_time_source.h"
 #include "cc/delegating_renderer.h"
 #include "cc/frame_rate_counter.h"
 #include "cc/gl_renderer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/layer_iterator.h"
 #include "cc/layer_tree_host.h"
@@ skipping 190 matching lines @@
     , m_debugState(settings.initialDebugState)
     , m_deviceScaleFactor(1)
     , m_visible(true)
     , m_contentsTexturesPurged(false)
     , m_managedMemoryPolicy(PrioritizedResourceManager::defaultMemoryAllocationLimit(),
                             PriorityCalculator::allowEverythingCutoff(),
                             0,
                             PriorityCalculator::allowNothingCutoff())
     , m_backgroundColor(0)
     , m_hasTransparentBackground(false)
-    , m_needsAnimateLayers(false)
     , m_needsUpdateDrawProperties(false)
     , m_pinchGestureActive(false)
     , m_fpsCounter(FrameRateCounter::create(m_proxy->hasImplThread()))
     , m_debugRectHistory(DebugRectHistory::create())
     , m_numImplThreadScrolls(0)
     , m_numMainThreadScrolls(0)
     , m_cumulativeNumLayersDrawn(0)
     , m_cumulativeNumMissingTiles(0)
     , m_lastSentMemoryVisibleBytes(0)
     , m_lastSentMemoryVisibleAndNearbyBytes(0)
     , m_lastSentMemoryUseBytes(0)
 {
     DCHECK(m_proxy->isImplThread());
     didVisibilityChange(this, m_visible);
 
     // TODO(nduca): For now, assume we have an active tree. This will be removed
     // in future patches.
     m_activeTree = LayerTreeImpl::create(this);
 }
 
 LayerTreeHostImpl::~LayerTreeHostImpl()
 {
     DCHECK(m_proxy->isImplThread());
     TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
 
-    if (rootLayer())
+    if (rootLayer()) {
         clearRenderSurfaces();
+        // The layer trees must be destroyed before the layer tree host. We've
+        // made a contract with our animation controllers that the registrar
+        // will outlive them, and we must make good.
+        m_activeTree.reset();
+        m_pendingTree.reset();
+    }
 }
 
 void LayerTreeHostImpl::beginCommit()
 {
 }
 
 void LayerTreeHostImpl::commitComplete()
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::commitComplete");
 
@@ skipping 352 matching lines @@
     if (drawFrame)
         occlusionTracker.overdrawMetrics().recordMetrics(this);
 
     removeRenderPasses(CullRenderPassesWithNoQuads(), frame);
     m_renderer->decideRenderPassAllocationsForFrame(frame.renderPasses);
     removeRenderPasses(CullRenderPassesWithCachedTextures(*m_renderer), frame);
 
     return drawFrame;
 }
 
-void LayerTreeHostImpl::animateLayersRecursive(LayerImpl* current, base::TimeTicks monotonicTime, base::Time wallClockTime, AnimationEventsVector* events, bool& didAnimate, bool& needsAnimateLayers)
-{
-    bool subtreeNeedsAnimateLayers = false;
-
-    LayerAnimationController* currentController = current->layerAnimationController();
-
-    bool hadActiveAnimation = currentController->hasActiveAnimation();
-    double monotonicTimeSeconds = (monotonicTime - base::TimeTicks()).InSecondsF();
-    currentController->animate(monotonicTimeSeconds, events);
-    bool startedAnimation = events->size() > 0;
-
-    // We animated if we either ticked a running animation, or started a new animation.
-    if (hadActiveAnimation || startedAnimation)
-        didAnimate = true;
-
-    // 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) {
-        bool childNeedsAnimateLayers = false;
-        animateLayersRecursive(current->children()[i], monotonicTime, wallClockTime, events, didAnimate, childNeedsAnimateLayers);
-        if (childNeedsAnimateLayers)
-            subtreeNeedsAnimateLayers = true;
-    }
-
-    needsAnimateLayers = subtreeNeedsAnimateLayers;
-}
-
 void LayerTreeHostImpl::setBackgroundTickingEnabled(bool enabled)
 {
     // Lazily create the timeSource adapter so that we can vary the interval for testing.
     if (!m_timeSourceClientAdapter)
         m_timeSourceClientAdapter = LayerTreeHostImplTimeSourceAdapter::create(this, DelayBasedTimeSource::create(lowFrequencyAnimationInterval(), m_proxy->currentThread()));
 
     m_timeSourceClientAdapter->setActive(enabled);
 }
 
 gfx::Size LayerTreeHostImpl::contentSize() const
@@ skipping 365 matching lines @@
         return;
     m_visible = visible;
     didVisibilityChange(this, m_visible);
     enforceManagedMemoryPolicy(m_managedMemoryPolicy);
 
     if (!m_renderer)
         return;
 
     m_renderer->setVisible(visible);
 
-    setBackgroundTickingEnabled(!m_visible && m_needsAnimateLayers);
+    setBackgroundTickingEnabled(!m_visible && !m_activeAnimationControllers.empty());
 }
 
 bool LayerTreeHostImpl::initializeRenderer(scoped_ptr<OutputSurface> outputSurface)
 {
     // Since we will create a new resource provider, we cannot continue to use
     // the old resources (i.e. renderSurfaces and texture IDs). Clear them
     // before we destroy the old resource provider.
     if (rootLayer()) {
         clearRenderSurfaces();
         sendDidLoseOutputSurfaceRecursive(rootLayer());
@@ skipping 539 matching lines @@
     setNeedsUpdateDrawProperties();
 
     if (m_pageScaleAnimation->isAnimationCompleteAtTime(monotonicTime)) {
         m_pageScaleAnimation.reset();
         m_client->setNeedsCommitOnImplThread();
     }
 }
 
 void LayerTreeHostImpl::animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)
 {
-    if (!m_settings.acceleratedAnimationEnabled || !m_needsAnimateLayers || !rootLayer())
+    if (!m_settings.acceleratedAnimationEnabled || m_activeAnimationControllers.empty() || !rootLayer())
         return;
 
     TRACE_EVENT0("cc", "LayerTreeHostImpl::animateLayers");
 
+    double monotonicSeconds = (monotonicTime - base::TimeTicks()).InSecondsF();
+
     scoped_ptr<AnimationEventsVector> events(make_scoped_ptr(new AnimationEventsVector));
-
-    bool didAnimate = false;
-    animateLayersRecursive(rootLayer(), monotonicTime, wallClockTime, events.get(), didAnimate, m_needsAnimateLayers);
+    AnimationControllerMap copy = m_activeAnimationControllers;
+    for (AnimationControllerMap::iterator iter = copy.begin(); iter != copy.end(); ++iter)
+        (*iter).second->animate(monotonicSeconds, events.get());
 
     if (!events->empty())
         m_client->postAnimationEventsToMainThreadOnImplThread(events.Pass(), wallClockTime);
 
-    if (didAnimate) {
-        m_client->setNeedsRedrawOnImplThread();
-        setNeedsUpdateDrawProperties();
-    }
-
-    setBackgroundTickingEnabled(!m_visible && m_needsAnimateLayers);
+    m_client->setNeedsRedrawOnImplThread();
+    setNeedsUpdateDrawProperties();
+    setBackgroundTickingEnabled(!m_visible && !m_activeAnimationControllers.empty());
 }
 
 base::TimeDelta LayerTreeHostImpl::lowFrequencyAnimationInterval() const
 {
     return base::TimeDelta::FromSeconds(1);
 }
 
 void LayerTreeHostImpl::sendDidLoseOutputSurfaceRecursive(LayerImpl* current)
 {
     DCHECK(current);
@@ skipping 110 matching lines @@
 
     ScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], time);
 }
 
+scoped_refptr<LayerAnimationController> LayerTreeHostImpl::GetAnimationControllerForId(int id)
+{
+    scoped_refptr<LayerAnimationController> toReturn;
+    if (!ContainsKey(m_allAnimationControllers, id)) {
+        toReturn = LayerAnimationController::create(id);
+        toReturn->setAnimationRegistrar(this);
+        m_allAnimationControllers[id] = toReturn.get();
+    } else
+        toReturn = m_allAnimationControllers[id];
+    return toReturn;
+}
+
+void LayerTreeHostImpl::DidActivateAnimationController(LayerAnimationController* controller) {
+    m_activeAnimationControllers[controller->id()] = controller;
+}
+
+void LayerTreeHostImpl::DidDeactivateAnimationController(LayerAnimationController* controller) {
+    if (ContainsKey(m_activeAnimationControllers, controller->id()))
+        m_activeAnimationControllers.erase(controller->id());
+}
+
+void LayerTreeHostImpl::RegisterAnimationController(LayerAnimationController* controller) {
+    m_allAnimationControllers[controller->id()] = controller;
+}
+
+void LayerTreeHostImpl::UnregisterAnimationController(LayerAnimationController* controller) {
+    if (ContainsKey(m_allAnimationControllers, controller->id()))
+        m_allAnimationControllers.erase(controller->id());
+    DidDeactivateAnimationController(controller);
+}
+
 }  // namespace cc