cc: Force layer tree tests to go idle before exiting.

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 "cc/layer_tree_host.h"
 
 #include "base/synchronization/lock.h"
 #include "cc/content_layer.h"
 #include "cc/content_layer_client.h"
 #include "cc/layer_impl.h"
@@ skipping 265 matching lines @@
 TEST_F(LayerTreeHostTestSetNeedsRedraw, runMultiThread)
 {
     runTest(true);
 }
 
 // If the layerTreeHost says it can't draw, then we should not try to draw.
 class LayerTreeHostTestCanDrawBlocksDrawing : public LayerTreeHostTest {
 public:
     LayerTreeHostTestCanDrawBlocksDrawing()
         : m_numCommits(0)
+        , m_done(false)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         postSetNeedsCommitToMainThread();
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
+        if (m_done)
+            return;
         // Only the initial draw should bring us here.
         EXPECT_TRUE(impl->canDraw());
         EXPECT_EQ(0, impl->activeTree()->source_frame_number());
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
+        if (m_done)
+            return;
         if (m_numCommits >= 1) {
             // After the first commit, we should not be able to draw.
             EXPECT_FALSE(impl->canDraw());
         }
     }
 
     virtual void didCommit() OVERRIDE
     {
         m_numCommits++;
         if (m_numCommits == 1) {
             // Make the viewport empty so the host says it can't draw.
             m_layerTreeHost->setViewportSize(gfx::Size(0, 0), gfx::Size(0, 0));
-
+        } else if (m_numCommits == 2) {
             char pixels[4];
             m_layerTreeHost->compositeAndReadback(static_cast<void*>(&pixels), gfx::Rect(0, 0, 1, 1));
-        } else if (m_numCommits == 2) {
-            m_layerTreeHost->setNeedsRedraw();
-            m_layerTreeHost->setNeedsCommit();
-        } else
+        } else if (m_numCommits == 3) {
+            postSetNeedsRedrawToMainThread();
+            postSetNeedsCommitToMainThread();
+        } else if (m_numCommits == 4) {
+            // Let it draw so we go idle and end the test.
+            m_layerTreeHost->setViewportSize(gfx::Size(1, 1), gfx::Size(1, 1));
+            m_done = true;
             endTest();
+        }
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
 private:
     int m_numCommits;
+    bool m_done;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestCanDrawBlocksDrawing)
 
 // beginLayerWrite should prevent draws from executing until a commit occurs
 class LayerTreeHostTestWriteLayersRedraw : public LayerTreeHostTest {
 public:
     LayerTreeHostTestWriteLayersRedraw()
         : m_numCommits(0)
         , m_numDraws(0)
@@ skipping 49 matching lines @@
     virtual void beginTest() OVERRIDE
     {
         postSetNeedsCommitToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
     {
         m_numCommits++;
         if (m_numCommits == 2)
             endTest();
-        else {
+        else if (m_numCommits < 2) {
             postSetVisibleToMainThread(false);
             postSetVisibleToMainThread(true);
             postAcquireLayerTextures();
             postSetNeedsCommitToMainThread();
         }
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
@@ skipping 90 matching lines @@
     }
 
     virtual void beginTest() OVERRIDE
     {
         postSetNeedsCommitToMainThread();
     }
 
     virtual void animate(base::TimeTicks monotonicTime) OVERRIDE
     {
         // We skip the first commit becasue its the commit that populates the
-        // impl thread with a tree.
-        if (!m_numCommits)
+        // impl thread with a tree. After the second commit, the test is done.
+        if (m_numCommits != 1)
             return;
 
         m_layerTreeHost->setNeedsAnimate();
         // Right now, commitRequested is going to be true, because during
         // beginFrame, we force commitRequested to true to prevent requests from
         // hitting the impl thread. But, when the next didCommit happens, we should
         // verify that commitRequested has gone back to false.
     }
+
     virtual void didCommit() OVERRIDE
     {
         if (!m_numCommits) {
             EXPECT_FALSE(m_layerTreeHost->commitRequested());
             m_layerTreeHost->setNeedsAnimate();
             EXPECT_FALSE(m_layerTreeHost->commitRequested());
-            m_numCommits++;
         }
 
         // Verifies that the setNeedsAnimate we made in ::animate did not
         // trigger commitRequested.
         EXPECT_FALSE(m_layerTreeHost->commitRequested());
         endTest();
+        m_numCommits++;
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
 private:
     int m_numCommits;
 };
 
@@ skipping 199 matching lines @@
             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));
+
+        const ActiveAnimation* animationImpl = layerTreeHostImpl->rootLayer()->layerAnimationController()->getActiveAnimation(0, ActiveAnimation::Opacity);
+
+        m_layerTreeHost->rootLayer()->layerAnimationController()->removeAnimation(animation->id());
+        layerTreeHostImpl->rootLayer()->layerAnimationController()->removeAnimation(animationImpl->id());
         endTest();
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
 private:
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestAddAnimationWithTimingFunction)
 
 // Ensures that main thread animations have their start times synchronized with impl thread animations.
 class LayerTreeHostTestSynchronizeAnimationStartTimes : public LayerTreeHostTest {
 public:
     LayerTreeHostTestSynchronizeAnimationStartTimes()
-        : m_layerTreeHostImpl(0)
+        : m_mainStartTime(-1)
+        , m_implStartTime(-1)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         postAddAnimationToMainThread(m_layerTreeHost->rootLayer());
     }
 
-    // This is guaranteed to be called before CCLayerTreeHostImpl::animateLayers.
-    virtual void willAnimateLayers(LayerTreeHostImpl* layerTreeHostImpl, base::TimeTicks monotonicTime) OVERRIDE
-    {
-        m_layerTreeHostImpl = layerTreeHostImpl;
-    }
-
     virtual void notifyAnimationStarted(double time) OVERRIDE
     {
-        EXPECT_TRUE(m_layerTreeHostImpl);
+        LayerAnimationController* controller = m_layerTreeHost->rootLayer()->layerAnimationController();
+        ActiveAnimation* animation = controller->getActiveAnimation(0, ActiveAnimation::Opacity);
+        m_mainStartTime = animation->startTime();
+        controller->removeAnimation(animation->id());
 
-        LayerAnimationController* controllerImpl = m_layerTreeHostImpl->rootLayer()->layerAnimationController();
-        LayerAnimationController* controller = m_layerTreeHost->rootLayer()->layerAnimationController();
-        ActiveAnimation* animationImpl = controllerImpl->getActiveAnimation(0, ActiveAnimation::Opacity);
+        if (m_implStartTime > 0)
+            endTest();
+    }
+
+    virtual void animateLayers(LayerTreeHostImpl* impl, base::TimeTicks monotonicTime)
+    {
+        LayerAnimationController* controller = impl->rootLayer()->layerAnimationController();
         ActiveAnimation* animation = controller->getActiveAnimation(0, ActiveAnimation::Opacity);
+        if (!animation)
+            return;
 
-        EXPECT_EQ(animationImpl->startTime(), animation->startTime());
+        m_implStartTime = animation->startTime();
+        controller->removeAnimation(animation->id());
 
-        endTest();
+        if (m_mainStartTime > 0)
+            endTest();
     }
 
     virtual void afterTest() OVERRIDE
     {
+        EXPECT_FLOAT_EQ(m_implStartTime, m_mainStartTime);
     }
 
 private:
-    LayerTreeHostImpl* m_layerTreeHostImpl;
+    double m_mainStartTime;
+    double m_implStartTime;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSynchronizeAnimationStartTimes)
 
 // Ensures that main thread animations have their start times synchronized with impl thread animations.
 class LayerTreeHostTestAnimationFinishedEvents : public LayerTreeHostTest {
 public:
     LayerTreeHostTestAnimationFinishedEvents()
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         postAddInstantAnimationToMainThread();
     }
 
     virtual void notifyAnimationFinished(double time) OVERRIDE
     {
+        const ActiveAnimation* animation = m_layerTreeHost->rootLayer()->layerAnimationController()->getActiveAnimation(0, ActiveAnimation::Opacity);
+        m_layerTreeHost->rootLayer()->layerAnimationController()->removeAnimation(animation->id());
         endTest();
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
 private:
 };
 
@@ skipping 548 matching lines @@
         m_rootLayer = NULL;
         m_childLayer = NULL;
     }
 
 private:
     FakeContentLayerClient m_client;
     scoped_refptr<NoScaleContentLayer> m_rootLayer;
     scoped_refptr<ContentLayer> m_childLayer;
 };
 
-// http://crbug.com/164851.
-TEST_F(LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers, FLAKY_runMultiThread)
+TEST_F(LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers, runMultiThread)
 {
     runTest(true);
 }
 
 // Verify atomicity of commits and reuse of textures.
 class LayerTreeHostTestAtomicCommit : public LayerTreeHostTest {
 public:
     LayerTreeHostTestAtomicCommit()
         : m_layer(ContentLayerWithUpdateTracking::create(&m_client))
     {
         // Make sure partial texture updates are turned off.
         m_settings.maxPartialTextureUpdates = 0;
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setRootLayer(m_layer);
         m_layerTreeHost->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
 
         ASSERT_TRUE(m_layerTreeHost->initializeRendererIfNeeded());
         ResourceUpdateQueue queue;
         m_layerTreeHost->updateLayers(queue, std::numeric_limits<size_t>::max());
         postSetNeedsCommitToMainThread();
-        postSetNeedsRedrawToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         CompositorFakeWebGraphicsContext3DWithTextureTracking* context = static_cast<CompositorFakeWebGraphicsContext3DWithTextureTracking*>(impl->outputSurface()->Context3D());
 
         switch (impl->activeTree()->source_frame_number()) {
         case 0:
             // Number of textures should be one.
             ASSERT_EQ(1, context->numTextures());
             // Number of textures used for commit should be one.
             EXPECT_EQ(1, context->numUsedTextures());
             // Verify that used texture is correct.
             EXPECT_TRUE(context->usedTexture(context->texture(0)));
 
             context->resetUsedTextures();
+            postSetNeedsCommitToMainThread();
             break;
         case 1:
             // Number of textures should be two as the first texture
             // is used by impl thread and cannot by used for update.
             ASSERT_EQ(2, context->numTextures());
             // Number of textures used for commit should still be one.
             EXPECT_EQ(1, context->numUsedTextures());
             // First texture should not have been used.
             EXPECT_FALSE(context->usedTexture(context->texture(0)));
             // New texture should have been used.
             EXPECT_TRUE(context->usedTexture(context->texture(1)));
 
             context->resetUsedTextures();
+            postSetNeedsCommitToMainThread();
+            break;
+        case 2:
+            endTest();
             break;
         default:
             NOTREACHED();
             break;
         }
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         CompositorFakeWebGraphicsContext3DWithTextureTracking* context = static_cast<CompositorFakeWebGraphicsContext3DWithTextureTracking*>(impl->outputSurface()->Context3D());
 
         // Number of textures used for draw should always be one.
         EXPECT_EQ(1, context->numUsedTextures());
-
-        if (impl->activeTree()->source_frame_number() < 1) {
-            context->resetUsedTextures();
-            postSetNeedsCommitToMainThread();
-            postSetNeedsRedrawToMainThread();
-        } else
-            endTest();
+        context->resetUsedTextures();
     }
 
     virtual void layout() OVERRIDE
     {
         m_layer->setNeedsDisplay();
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
@@ skipping 37 matching lines @@
         m_layerTreeHost->setViewportSize(gfx::Size(10, 20), gfx::Size(10, 20));
 
         gfx::Transform identityMatrix;
         setLayerPropertiesForTesting(m_parent.get(), 0, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(10, 20), true);
         setLayerPropertiesForTesting(m_child.get(), m_parent.get(), identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 10), gfx::Size(10, 10), false);
 
         ASSERT_TRUE(m_layerTreeHost->initializeRendererIfNeeded());
         ResourceUpdateQueue queue;
         m_layerTreeHost->updateLayers(queue, std::numeric_limits<size_t>::max());
         postSetNeedsCommitToMainThread();
-        postSetNeedsRedrawToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         CompositorFakeWebGraphicsContext3DWithTextureTracking* context = static_cast<CompositorFakeWebGraphicsContext3DWithTextureTracking*>(impl->outputSurface()->Context3D());
 
         switch (impl->activeTree()->source_frame_number()) {
         case 0:
             // Number of textures should be two.
             ASSERT_EQ(2, context->numTextures());
             // Number of textures used for commit should be two.
             EXPECT_EQ(2, context->numUsedTextures());
             // Verify that used textures are correct.
             EXPECT_TRUE(context->usedTexture(context->texture(0)));
             EXPECT_TRUE(context->usedTexture(context->texture(1)));
 
             context->resetUsedTextures();
+            postSetNeedsCommitToMainThread();
             break;
         case 1:
             // Number of textures used for commit should still be two.
             EXPECT_EQ(2, context->numUsedTextures());
             // First two textures should not have been used.
             EXPECT_FALSE(context->usedTexture(context->texture(0)));
             EXPECT_FALSE(context->usedTexture(context->texture(1)));
             // New textures should have been used.
             EXPECT_TRUE(context->usedTexture(context->texture(2)));
             EXPECT_TRUE(context->usedTexture(context->texture(3)));
 
             context->resetUsedTextures();
+            postSetNeedsCommitToMainThread();
             break;
         case 2:
             // Number of textures used for commit should still be two.
             EXPECT_EQ(2, context->numUsedTextures());
 
             context->resetUsedTextures();
+            postSetNeedsCommitToMainThread();
             break;
         case 3:
             // No textures should be used for commit.
             EXPECT_EQ(0, context->numUsedTextures());
 
             context->resetUsedTextures();
+            postSetNeedsCommitToMainThread();
             break;
         case 4:
             // Number of textures used for commit should be one.
             EXPECT_EQ(1, context->numUsedTextures());
 
             context->resetUsedTextures();
+            postSetNeedsCommitToMainThread();
+            break;
+        case 5:
+            endTest();
             break;
         default:
             NOTREACHED();
             break;
         }
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         CompositorFakeWebGraphicsContext3DWithTextureTracking* context = static_cast<CompositorFakeWebGraphicsContext3DWithTextureTracking*>(impl->outputSurface()->Context3D());
 
         // Number of textures used for drawing should two except for frame 4
         // where the viewport only contains one layer.
         if (impl->activeTree()->source_frame_number() == 3)
             EXPECT_EQ(1, context->numUsedTextures());
         else
             EXPECT_EQ(2, context->numUsedTextures());
 
-        if (impl->activeTree()->source_frame_number() < 4) {
-            context->resetUsedTextures();
-            postSetNeedsCommitToMainThread();
-            postSetNeedsRedrawToMainThread();
-        } else
-            endTest();
+        context->resetUsedTextures();
     }
 
     virtual void layout() OVERRIDE
     {
         switch (m_numCommits++) {
         case 0:
         case 1:
             m_parent->setNeedsDisplay();
             m_child->setNeedsDisplay();
             break;
         case 2:
             // Damage part of layers.
             m_parent->setNeedsDisplayRect(gfx::RectF(0, 0, 5, 5));
             m_child->setNeedsDisplayRect(gfx::RectF(0, 0, 5, 5));
             break;
         case 3:
             m_child->setNeedsDisplay();
             m_layerTreeHost->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
             break;
         case 4:
             m_layerTreeHost->setViewportSize(gfx::Size(10, 20), gfx::Size(10, 20));
             break;
+        case 5:
+            break;
         default:
             NOTREACHED();
             break;
         }
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
@@ skipping 1388 matching lines @@
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
         m_layerTreeHost->rootLayer()->setBounds(gfx::Size(10, 10));
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void didCommit() OVERRIDE
     {
+        if (m_numDrawLayers == 2)
+            return;
         postSetNeedsCommitToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
     {
         if (m_numDrawLayers == 1)
             m_numCommitComplete++;
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
@@ skipping 37 matching lines @@
         m_contentLayer->setPosition(gfx::PointF(0, 0));
         m_contentLayer->setAnchorPoint(gfx::PointF(0, 0));
         m_contentLayer->setIsDrawable(true);
         m_layerTreeHost->rootLayer()->addChild(m_contentLayer);
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void didCommit() OVERRIDE
     {
+        if (m_numDrawLayers == 2)
+            return;
         m_contentLayer->setNeedsDisplay();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
     {
         if (m_numDrawLayers == 1)
             m_numCommitComplete++;
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
@@ skipping 75 matching lines @@
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
         m_layerTreeHost->rootLayer()->setBounds(gfx::Size(10, 10));
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void animate(base::TimeTicks) OVERRIDE
     {
+        if (m_numDrawLayers == 2)
+            return;
         m_layerTreeHost->setNeedsAnimate();
     }
 
     virtual void layout() OVERRIDE
     {
         m_layerTreeHost->rootLayer()->setNeedsDisplay();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
     {
@@ skipping 194 matching lines @@
     LayerTreeSettings settings;
     settings.maxPartialTextureUpdates = 4;
 
     scoped_ptr<LayerTreeHost> host = LayerTreeHost::create(&client, settings, scoped_ptr<Thread>());
     EXPECT_TRUE(host->initializeRendererIfNeeded());
     EXPECT_EQ(0u, host->settings().maxPartialTextureUpdates);
 }
 
 }  // namespace
 }  // namespace cc