Changeset 117825 in webkit

Timestamp:

May 21, 2012 3:57:49 PM (12 years ago)

Author:

piman@chromium.org

Message:

Don't force rendering in finishAllRendering
​https://bugs.webkit.org/show_bug.cgi?id=86919

Reviewed by James Robinson.

After we acquire the texture layers on the main thread, we can't draw.
In particular if we destroyed the texture ids used previously by
TextureLayerChromium, drawing before a commit would cause a
bind-after-destroy.

Tested by CCLayerTreeHostTestFinishAllRendering.

• platform/graphics/chromium/cc/CCThreadProxy.cpp:

(WebCore::CCThreadProxy::CCThreadProxy):
(WebCore::CCThreadProxy::finishAllRenderingOnImplThread):
(WebCore::CCThreadProxy::scheduledActionDrawAndSwapInternal):

Location:

trunk/Source

Files:

• WebCore/ChangeLog (modified) (1 diff)
• WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp (modified) (3 diffs)
• WebKit/chromium/tests/CCLayerTreeHostTest.cpp (modified) (8 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-05-21  Antoine Labour  <piman@chromium.org>
+
+        Don't force rendering in finishAllRendering
+        https://bugs.webkit.org/show_bug.cgi?id=86919
+
+        Reviewed by James Robinson.
+
+        After we acquire the texture layers on the main thread, we can't draw.
+        In particular if we destroyed the texture ids used previously by
+        TextureLayerChromium, drawing before a commit would cause a
+        bind-after-destroy.
+
+        Tested by CCLayerTreeHostTestFinishAllRendering.
+
+        * platform/graphics/chromium/cc/CCThreadProxy.cpp:
+        (WebCore::CCThreadProxy::CCThreadProxy):
+        (WebCore::CCThreadProxy::finishAllRenderingOnImplThread):
+        (WebCore::CCThreadProxy::scheduledActionDrawAndSwapInternal):
+
 2012-05-21  Joshua Bell  <jsbell@chromium.org>
 

trunk/Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp

@@ -82 +82 @@
     , m_beginFrameCompletionEventOnImplThread(0)
     , m_readbackRequestOnImplThread(0)
-    , m_finishAllRenderingCompletionEventOnImplThread(0)
     , m_commitCompletionEventOnImplThread(0)
     , m_textureAcquisitionCompletionEventOnImplThread(0)
@@ -432 +431 @@
     TRACE_EVENT("CCThreadProxy::finishAllRenderingOnImplThread", this, 0);
     ASSERT(isImplThread());
-    ASSERT(!m_finishAllRenderingCompletionEventOnImplThread);
-    m_finishAllRenderingCompletionEventOnImplThread = completion;
-
-    m_schedulerOnImplThread->setNeedsForcedRedraw();
+    m_layerTreeHostImpl->finishAllRendering();
+    completion->signal();
 }
 
@@ -666 +663 @@
         result.didSwap = m_layerTreeHostImpl->swapBuffers();
 
-    // Process any finish request
-    if (m_finishAllRenderingCompletionEventOnImplThread) {
-        m_layerTreeHostImpl->finishAllRendering();
-        m_finishAllRenderingCompletionEventOnImplThread->signal();
-        m_finishAllRenderingCompletionEventOnImplThread = 0;
-    }
-
     // Tell the main thread that the the newly-commited frame was drawn.
     if (m_nextFrameIsNewlyCommittedFrameOnImplThread) {

trunk/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp

@@ -50 +50 @@
 #include <gtest/gtest.h>
 #include <public/Platform.h>
+#include <wtf/Locker.h>
 #include <wtf/MainThread.h>
 #include <wtf/PassRefPtr.h>
+#include <wtf/ThreadingPrimitives.h>
 #include <wtf/Vector.h>
 
@@ -81 +83 @@
     virtual void didRecreateContext(bool succeded) { }
     virtual void didCommitAndDrawFrame() { }
+    virtual void scheduleComposite() { }
 
     // Implementation of CCLayerAnimationDelegate
@@ -285 +288 @@
     virtual void scheduleComposite() OVERRIDE
     {
+        m_testHooks->scheduleComposite();
     }
 
@@ -369 +373 @@
         , m_endWhenBeginReturns(false)
         , m_timedOut(false)
-        , m_finished(false) { }
+        , m_finished(false)
+        , m_scheduled(false) { }
 
     void doBeginTest();
+
+    virtual void scheduleComposite()
+    {
+        if (m_scheduled || m_finished)
+            return;
+        m_scheduled = true;
+        callOnMainThread(&CCLayerTreeHostTest::dispatchComposite, this);
+    }
 
     static void onEndTest(void* self)
@@ -487 +500 @@
         if (test->m_layerTreeHost)
             test->m_layerTreeHost->setVisible(false);
+    }
+
+    static void dispatchComposite(void* self)
+    {
+        CCLayerTreeHostTest* test = static_cast<CCLayerTreeHostTest*>(self);
+        test->m_scheduled = false;
+        if (test->m_layerTreeHost && !test->m_finished)
+            test->m_layerTreeHost->composite();
     }
 
@@ -577 +598 @@
     bool m_timedOut;
     bool m_finished;
+    bool m_scheduled;
 
     OwnPtr<WebThread> m_webThread;
@@ -1216 +1238 @@
     virtual void animateLayers(CCLayerTreeHostImpl* layerTreeHostImpl, double monotonicTime)
     {
-        const CCFloatAnimationCurve* curve = m_layerTreeHost->rootLayer()->layerAnimationController()->getActiveAnimation(0, CCActiveAnimation::Opacity)->curve()->toFloatAnimationCurve();
+        const CCActiveAnimation* animation = m_layerTreeHost->rootLayer()->layerAnimationController()->getActiveAnimation(0, CCActiveAnimation::Opacity);
+        if (!animation)
+            return;
+        const CCFloatAnimationCurve* curve = animation->curve()->toFloatAnimationCurve();
         float startOpacity = curve->getValue(0);
         float endOpacity = curve->getValue(curve->duration());
@@ -2645 +2670 @@
 }
 
+class CCLayerTreeHostTestFinishAllRendering : public CCLayerTreeHostTest {
+public:
+    CCLayerTreeHostTestFinishAllRendering()
+        : m_once(false)
+        , m_mutex()
+        , m_drawCount(0)
+    {
+    }
+
+    virtual void beginTest()
+    {
+        m_layerTreeHost->setNeedsRedraw();
+    }
+
+    virtual void didCommitAndDrawFrame()
+    {
+        if (m_once)
+            return;
+        m_once = true;
+        m_layerTreeHost->setNeedsRedraw();
+        m_layerTreeHost->acquireLayerTextures();
+        {
+            Locker<Mutex> lock(m_mutex);
+            m_drawCount = 0;
+        }
+        m_layerTreeHost->finishAllRendering();
+        {
+            Locker<Mutex> lock(m_mutex);
+            EXPECT_EQ(0, m_drawCount);
+        }
+        endTest();
+    }
+
+    virtual void drawLayersOnCCThread(CCLayerTreeHostImpl* impl)
+    {
+        Locker<Mutex> lock(m_mutex);
+        ++m_drawCount;
+    }
+
+    virtual void afterTest()
+    {
+    }
+private:
+
+    bool m_once;
+    Mutex m_mutex;
+    int m_drawCount;
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(CCLayerTreeHostTestFinishAllRendering)
+
 } // namespace