Remove root layer specialness in calculateDrawTransforms

cc/layer_tree_host_unittest.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 "config.h"
 
 #include "cc/layer_tree_host.h"
 
 #include "base/synchronization/lock.h"
 #include "cc/content_layer.h"
@@ skipping 636 matching lines @@
 // a while, we do eventually force a draw.
 class LayerTreeHostTestCheckerboardDoesNotStarveDraws : public LayerTreeHostTest {
 public:
     LayerTreeHostTestCheckerboardDoesNotStarveDraws()
         : m_startedAnimating(false)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
-        postAddAnimationToMainThread();
+        postAddAnimationToMainThread(m_layerTreeHost->rootLayer());
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
     virtual void animateLayers(LayerTreeHostImpl* layerTreeHostImpl, double monotonicTime) OVERRIDE
     {
         m_startedAnimating = true;
     }
@@ skipping 22 matching lines @@
 // Ensures that animations continue to be ticked when we are backgrounded.
 class LayerTreeHostTestTickAnimationWhileBackgrounded : public LayerTreeHostTest {
 public:
     LayerTreeHostTestTickAnimationWhileBackgrounded()
         : m_numAnimates(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
-        postAddAnimationToMainThread();
+        postAddAnimationToMainThread(m_layerTreeHost->rootLayer());
     }
 
     // Use willAnimateLayers to set visible false before the animation runs and
     // causes a commit, so we block the second visible animate in single-thread
     // mode.
     virtual void willAnimateLayers(LayerTreeHostImpl* layerTreeHostImpl, double monotonicTime) OVERRIDE
     {
         if (m_numAnimates < 2) {
             if (!m_numAnimates) {
                 // We have a long animation running. It should continue to tick even if we are not visible.
@@ skipping 17 matching lines @@
 
 // Ensures that animations continue to be ticked when we are backgrounded.
 class LayerTreeHostTestAddAnimationWithTimingFunction : public LayerTreeHostTest {
 public:
     LayerTreeHostTestAddAnimationWithTimingFunction()
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
-        postAddAnimationToMainThread();
+        postAddAnimationToMainThread(m_layerTreeHost->rootLayer());
     }
 
     virtual void animateLayers(LayerTreeHostImpl* layerTreeHostImpl, double monotonicTime) OVERRIDE
     {
         const ActiveAnimation* animation = m_layerTreeHost->rootLayer()->layerAnimationController()->getActiveAnimation(0, ActiveAnimation::Opacity);
         if (!animation)
             return;
         const FloatAnimationCurve* curve = animation->curve()->toFloatAnimationCurve();
         float startOpacity = curve->getValue(0);
         float endOpacity = curve->getValue(curve->duration());
         float linearlyInterpolatedOpacity = 0.25 * endOpacity + 0.75 * startOpacity;
         double time = curve->duration() * 0.25;
         // If the linear timing function associated with this animation was not picked up,
         // then the linearly interpolated opacity would be different because of the
         // default ease timing function.
         EXPECT_FLOAT_EQ(linearlyInterpolatedOpacity, curve->getValue(time));
         endTest();
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
 private:
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestAddAnimationWithTimingFunction)
 
-// Ensures that when opacity is being animated, this value does not cause the subtree to be skipped.
-class LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity : public LayerTreeHostTest {
-public:
-    LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity()
-    {
-    }
-
-    virtual void beginTest() OVERRIDE
-    {
-        m_layerTreeHost->rootLayer()->setDrawOpacity(1);
-        m_layerTreeHost->setViewportSize(IntSize(10, 10), IntSize(10, 10));
-        m_layerTreeHost->rootLayer()->setOpacity(0);
-        postAddAnimationToMainThread();
-    }
-
-    virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
-    {
-        // If the subtree was skipped when preparing to draw, the layer's draw opacity
-        // will not have been updated. It should be set to 0 due to the animation.
-        // Without the animation, the layer will be skipped since it has zero opacity.
-        EXPECT_EQ(0, m_layerTreeHost->rootLayer()->drawOpacity());
-        endTest();
-    }
-
-    virtual void afterTest() OVERRIDE
-    {
-    }
-};
-
-TEST_F(LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity, runMultiThread)
-{
-    runTest(true);
-}
-
 // Ensures that main thread animations have their start times synchronized with impl thread animations.
 class LayerTreeHostTestSynchronizeAnimationStartTimes : public LayerTreeHostTest {
 public:
     LayerTreeHostTestSynchronizeAnimationStartTimes()
         : m_layerTreeHostImpl(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
-        postAddAnimationToMainThread();
+        postAddAnimationToMainThread(m_layerTreeHost->rootLayer());
     }
 
     // This is guaranteed to be called before LayerTreeHostImpl::animateLayers.
     virtual void willAnimateLayers(LayerTreeHostImpl* layerTreeHostImpl, double monotonicTime) OVERRIDE
     {
         m_layerTreeHostImpl = layerTreeHostImpl;
     }
 
     virtual void notifyAnimationStarted(double time) OVERRIDE
     {
@@ skipping 414 matching lines @@
 private:
     TestOpacityChangeLayerDelegate m_testOpacityChangeDelegate;
     scoped_refptr<ContentLayerWithUpdateTracking> m_updateCheckLayer;
 };
 
 TEST_F(LayerTreeHostTestOpacityChange, runMultiThread)
 {
     runTest(true);
 }
 
+// Ensures that when opacity is being animated, this value does not cause the subtree to be skipped.
+class LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity : public LayerTreeHostTest {
+public:
+    LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity()
+        : m_testOpacityChangeDelegate(this)
+        , m_updateCheckLayer(ContentLayerWithUpdateTracking::create(&m_testOpacityChangeDelegate))
+    {
+    }
+
+    virtual void beginTest() OVERRIDE
+    {
+        m_layerTreeHost->setViewportSize(IntSize(10, 10), IntSize(10, 10));
+        m_layerTreeHost->rootLayer()->addChild(m_updateCheckLayer);
+        m_updateCheckLayer->setOpacity(0);
+        m_updateCheckLayer->setDrawOpacity(0);
+        postAddAnimationToMainThread(m_updateCheckLayer.get());
+    }
+
+    virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
+    {
+        endTest();
+    }
+
+    virtual void afterTest() OVERRIDE
+    {
+        // update() should have been called once, proving that the layer was not skipped.
+        EXPECT_EQ(1, m_updateCheckLayer->paintContentsCount());
+
+        // clear m_updateCheckLayer so LayerTreeHost dies.
+        m_updateCheckLayer = NULL;
+    }
+
+private:
+    TestOpacityChangeLayerDelegate m_testOpacityChangeDelegate;
+    scoped_refptr<ContentLayerWithUpdateTracking> m_updateCheckLayer;
+};
+
+TEST_F(LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity, runMultiThread)
+{
+    runTest(true);
+}
+
 class MockContentLayerClient : public ContentLayerClient {
 public:
     bool drawsContent() const { return true; }
     MOCK_CONST_METHOD0(preserves3D, bool());
     void paintContents(SkCanvas*, const IntRect&, FloatRect&) OVERRIDE { }
     void notifySyncRequired() { }
 };
 
 class NoScaleContentLayer : public ContentLayer {
 public:
@@ skipping 1921 matching lines @@
     int m_numCommitComplete;
     int m_numDrawLayers;
 };
 
 TEST_F(LayerTreeHostTestContinuousAnimate, runMultiThread)
 {
     runTest(true);
 }
 
 } // namespace