Ref count layer animation controllers.

cc/test/layer_tree_test_common.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/test/layer_tree_test_common.h"
 
 #include "base/stl_util.h"
 #include "cc/active_animation.h"
 #include "cc/content_layer.h"
 #include "cc/font_atlas.h"
@@ skipping 101 matching lines @@
 void MockLayerTreeHostImpl::drawLayers(FrameData& frame)
 {
     LayerTreeHostImpl::drawLayers(frame);
     m_testHooks->drawLayersOnThread(this);
 }
 
 void MockLayerTreeHostImpl::animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)
 {
     m_testHooks->willAnimateLayers(this, monotonicTime);
     LayerTreeHostImpl::animateLayers(monotonicTime, wallClockTime);
-    m_testHooks->animateLayers(this, monotonicTime);
+    bool hasUnfinishedAnimation = false;
+    LayerTreeHostImpl::AnimationControllerMap::const_iterator iter = activeAnimationControllers().begin();
+    for (; iter != activeAnimationControllers().end(); ++iter) {
+        if (iter->second->hasActiveAnimation()) {
+            hasUnfinishedAnimation = true;
+            break;
+        }
+    }
+    m_testHooks->animateLayers(this, monotonicTime, hasUnfinishedAnimation);
 }
 
 base::TimeDelta MockLayerTreeHostImpl::lowFrequencyAnimationInterval() const
 {
     return base::TimeDelta::FromMilliseconds(16);
 }
 
 MockLayerTreeHostImpl::MockLayerTreeHostImpl(TestHooks* testHooks, const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
     : LayerTreeHostImpl(settings, client, proxy)
     , m_testHooks(testHooks)
@@ skipping 16 matching lines @@
         layerTreeHost->rootLayer()->setLayerAnimationDelegate(testHooks);
 
         return layerTreeHost.Pass();
     }
 
     virtual scoped_ptr<cc::LayerTreeHostImpl> createLayerTreeHostImpl(cc::LayerTreeHostImplClient* client)
     {
         return MockLayerTreeHostImpl::create(m_testHooks, settings(), client, proxy()).PassAs<cc::LayerTreeHostImpl>();
     }
 
-    virtual void didAddAnimation() OVERRIDE
-    {
-        LayerTreeHost::didAddAnimation();
-        m_testHooks->didAddAnimation();
-    }
-
     virtual void setNeedsCommit() OVERRIDE
     {
         if (!m_testStarted)
             return;
         LayerTreeHost::setNeedsCommit();
     }
 
+    virtual void DidActivateAnimationController(cc::LayerAnimationController* controller) OVERRIDE
+    {
+        LayerTreeHost::DidActivateAnimationController(controller);
+        m_testHooks->didAddAnimation();
+    }
+
     void setTestStarted(bool started) { m_testStarted = started; }
 
     virtual void didDeferCommit() OVERRIDE
     {
         m_testHooks->didDeferCommit();
     }
 
 private:
     MockLayerTreeHost(TestHooks* testHooks, cc::LayerTreeHostClient* client, const cc::LayerTreeSettings& settings)
         : LayerTreeHost(client, settings)
@@ skipping 146 matching lines @@
 void ThreadedTest::postSetNeedsRedrawToMainThread()
 {
     m_mainThreadProxy->postTask(FROM_HERE, base::Bind(&ThreadedTest::dispatchSetNeedsRedraw, base::Unretained(this)));
 }
 
 void ThreadedTest::postSetVisibleToMainThread(bool visible)
 {
     m_mainThreadProxy->postTask(FROM_HERE, base::Bind(&ThreadedTest::dispatchSetVisible, base::Unretained(this), visible));
 }
 
-void ThreadedTest::postDidAddAnimationToMainThread()
-{
-    m_mainThreadProxy->postTask(FROM_HERE, base::Bind(&ThreadedTest::dispatchDidAddAnimation, base::Unretained(this)));
-}
-
 void ThreadedTest::doBeginTest()
 {
     m_client = ThreadedMockLayerTreeHostClient::create(this);
 
     scoped_refptr<Layer> rootLayer = Layer::create();
     scoped_ptr<cc::Thread> implCCThread(NULL);
     if (m_implThread)
         implCCThread = cc::ThreadImpl::createForDifferentThread(m_implThread->message_loop_proxy());
     m_layerTreeHost = MockLayerTreeHost::create(this, m_client.get(), rootLayer, m_settings, implCCThread.Pass());
     ASSERT_TRUE(m_layerTreeHost.get());
@@ skipping 109 matching lines @@
         m_layerTreeHost->setVisible(visible);
 }
 
 void ThreadedTest::dispatchComposite()
 {
     m_scheduled = false;
     if (m_layerTreeHost.get() && !m_finished)
         m_layerTreeHost->composite();
 }
 
-void ThreadedTest::dispatchDidAddAnimation()
-{
-    DCHECK(!proxy() || proxy()->isMainThread());
-
-    if (m_finished)
-        return;
-
-    if (m_layerTreeHost.get())
-        m_layerTreeHost->didAddAnimation();
-}
-
 void ThreadedTest::runTest(bool threaded)
 {
     if (threaded) {
         m_implThread.reset(new base::Thread("ThreadedTest"));
         ASSERT_TRUE(m_implThread->Start());
     }
 
     m_mainCCThread = cc::ThreadImpl::createForCurrentThread();
     m_mainThreadProxy = ScopedThreadProxy::create(m_mainCCThread.get());
 
@@ skipping 12 matching lines @@
     ASSERT_FALSE(m_layerTreeHost.get());
     m_client.reset();
     if (m_timedOut) {
         FAIL() << "Test timed out";
         return;
     }
     afterTest();
 }
 
 }  // namespace cc