cc: Unify context losing machinery

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 1971 matching lines @@
         endTest();
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestManySurfaces)
 
-// A loseOutputSurface(1) should lead to a didRecreateOutputSurface(true)
+// Losing the context should lead to a didRecreateOutputSurface(true).
 class LayerTreeHostTestSetSingleLostContext : public LayerTreeHostTest {
 public:
     LayerTreeHostTestSetSingleLostContext()
+        : m_context3d(NULL)
+        , m_timesToLose(1)
+        , m_timesToLoseDuringDraw(1)
     {
     }
 
+    virtual scoped_ptr<OutputSurface> createOutputSurface() OVERRIDE
+    {
+        scoped_ptr<CompositorFakeWebGraphicsContext3DWithTextureTracking> context3d =
+                CompositorFakeWebGraphicsContext3DWithTextureTracking::create(WebKit::WebGraphicsContext3D::Attributes());
+        m_context3d = context3d.get();
+        return FakeOutputSurface::Create3d(context3d.PassAs<WebKit::WebGraphicsContext3D>()).PassAs<OutputSurface>();
+    }
+
     virtual void beginTest() OVERRIDE
     {
         postSetNeedsCommitToMainThread();
     }
 
-    virtual void didCommitAndDrawFrame() OVERRIDE
+    virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
-        m_layerTreeHost->loseOutputSurface(1);
+        if (!m_timesToLose)
+            return;
+        m_context3d->loseContext();
+        m_context3d = NULL;
+        --m_timesToLose;
+    }
+
+    virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
+    {
+        // Lose during commit first, then during draw.
+        if (m_timesToLose || !m_timesToLoseDuringDraw || !m_context3d)
+            return;
+        m_context3d->loseContext();
+        m_context3d = NULL;
+        --m_timesToLoseDuringDraw;
     }
 
     virtual void didRecreateOutputSurface(bool succeeded) OVERRIDE
     {
         EXPECT_TRUE(succeeded);
-        endTest();
+        if (!m_timesToLose && !m_timesToLoseDuringDraw)
+            endTest();
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
+
+private:
+    FakeWebGraphicsContext3D* m_context3d;
+    int m_timesToLose;
+    int m_timesToLoseDuringDraw;
 };
 
-TEST_F(LayerTreeHostTestSetSingleLostContext, runMultiThread)
-{
-    runTest(true);
-}
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetSingleLostContext)
 
-// A loseOutputSurface(10) should lead to a didRecreateOutputSurface(false), and
+// Failing to recreate the context should lead to a didRecreateOutputSurface(false) and
 // a finishAllRendering() should not hang.
 class LayerTreeHostTestSetRepeatedLostContext : public LayerTreeHostTest {
 public:
     LayerTreeHostTestSetRepeatedLostContext()
+        : m_context3d(NULL)
+        , m_timesToLose(1)
+        , m_timesToFailCreate(0)
     {
     }
 
+    virtual scoped_ptr<OutputSurface> createOutputSurface() OVERRIDE
+    {
+        if (m_timesToFailCreate) {
+            --m_timesToFailCreate;
+            return scoped_ptr<OutputSurface>();
+        }
+
+        scoped_ptr<CompositorFakeWebGraphicsContext3DWithTextureTracking> context3d =
+                CompositorFakeWebGraphicsContext3DWithTextureTracking::create(WebKit::WebGraphicsContext3D::Attributes());
+        m_context3d = context3d.get();
+        return FakeOutputSurface::Create3d(context3d.PassAs<WebKit::WebGraphicsContext3D>()).PassAs<OutputSurface>();
+    }
+
     virtual void beginTest() OVERRIDE
     {
         postSetNeedsCommitToMainThread();
     }
 
-    virtual void didCommitAndDrawFrame() OVERRIDE
+    virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
-        m_layerTreeHost->loseOutputSurface(10);
+        if (!m_timesToLose)
+            return;
+        m_context3d->loseContext();
+        m_context3d = NULL;
+        --m_timesToLose;
+
+        m_timesToFailCreate = 10;
     }
 
     virtual void didRecreateOutputSurface(bool succeeded) OVERRIDE
     {
         EXPECT_FALSE(succeeded);
         m_layerTreeHost->finishAllRendering();
         endTest();
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
+
+private:
+    FakeWebGraphicsContext3D* m_context3d;
+    int m_timesToLose;
+    int m_timesToFailCreate;
 };
 
-TEST_F(LayerTreeHostTestSetRepeatedLostContext, runMultiThread)
-{
-    runTest(true);
-}
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetRepeatedLostContext)
 
 class LayerTreeHostTestFractionalScroll : public LayerTreeHostTest {
 public:
     LayerTreeHostTestFractionalScroll()
         : m_scrollAmount(1.75, 0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
@@ skipping 790 matching lines @@
 {
     runTest(true);
 }
 
 class LayerTreeHostTestLostContextAfterEvictTextures : public LayerTreeHostTest {
 public:
     LayerTreeHostTestLostContextAfterEvictTextures()
         : m_layer(EvictionTestLayer::create())
         , m_implForEvictTextures(0)
         , m_numCommits(0)
+        , m_context3d(NULL)
     {
     }
 
+    virtual scoped_ptr<OutputSurface> createOutputSurface() OVERRIDE
+    {
+        scoped_ptr<CompositorFakeWebGraphicsContext3DWithTextureTracking> context3d =
+                CompositorFakeWebGraphicsContext3DWithTextureTracking::create(WebKit::WebGraphicsContext3D::Attributes());
+        m_context3d = context3d.get();
+        return FakeOutputSurface::Create3d(context3d.PassAs<WebKit::WebGraphicsContext3D>()).PassAs<OutputSurface>();
+    }
+
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setRootLayer(m_layer);
         m_layerTreeHost->setViewportSize(gfx::Size(10, 20), gfx::Size(10, 20));
 
         gfx::Transform identityMatrix;
         setLayerPropertiesForTesting(m_layer.get(), 0, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(10, 20), true);
 
         postSetNeedsCommitToMainThread();
     }
 
-    void postEvictTextures()
+    void loseContextAndPostEvictTextures()
     {
         if (implThread()) {
+            implThread()->postTask(base::Bind(&FakeWebGraphicsContext3D::loseContext,
+                                              base::Unretained(m_context3d)));
             implThread()->postTask(base::Bind(&LayerTreeHostTestLostContextAfterEvictTextures::evictTexturesOnImplThread,
                                               base::Unretained(this)));
         } else {
             DebugScopedSetImplThread impl(proxy());
+            m_context3d->loseContext();
             evictTexturesOnImplThread();
         }
     }
 
     void evictTexturesOnImplThread()
     {
         DCHECK(m_implForEvictTextures);
         m_implForEvictTextures->enforceManagedMemoryPolicy(ManagedMemoryPolicy(0));
     }
 
     // Commit 1: Just commit and draw normally, then at the end, set ourselves
     // invisible (to prevent a commit that would recreate textures after
-    // eviction, before the context recovery), and post a task that will evict
-    // textures, then cause the context to be lost, and then set ourselves
+    // eviction, before the context recovery). Then lose the graphics context
+    // and post a task that will evict textures. Finally, set ourselves
     // visible again (to allow commits, since that's what causes context
     // recovery in single thread).
     virtual void didCommitAndDrawFrame() OVERRIDE
     {
         ++m_numCommits;
         switch (m_numCommits) {
         case 1:
             EXPECT_TRUE(m_layer->haveBackingTexture());
             m_layerTreeHost->setVisible(false);
-            postEvictTextures();
-            m_layerTreeHost->loseOutputSurface(1);
+            loseContextAndPostEvictTextures();
             m_layerTreeHost->setVisible(true);
             break;
         default:
             break;
         }
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         m_implForEvictTextures = impl;
     }
 
     virtual void didRecreateOutputSurface(bool succeeded) OVERRIDE
     {
         EXPECT_TRUE(succeeded);
         endTest();
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
 private:
     FakeContentLayerClient m_client;
     scoped_refptr<EvictionTestLayer> m_layer;
     LayerTreeHostImpl* m_implForEvictTextures;
     int m_numCommits;
+    FakeWebGraphicsContext3D* m_context3d;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestLostContextAfterEvictTextures)
 
 class CompositorFakeWebGraphicsContext3DWithEndQueryCausingLostContext : public CompositorFakeWebGraphicsContext3D {
 public:
     static scoped_ptr<CompositorFakeWebGraphicsContext3DWithEndQueryCausingLostContext> create(Attributes attrs)
     {
         return make_scoped_ptr(new CompositorFakeWebGraphicsContext3DWithEndQueryCausingLostContext(attrs));
     }
@@ skipping 461 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