WebGL: Don't destroy mailbox textures in the destructor until they're released.

Source/platform/graphics/gpu/DrawingBufferTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "platform/graphics/gpu/DrawingBuffer.h"
 
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
+#include "platform/graphics/gpu/Extensions3DUtil.h"
 #include "platform/graphics/test/MockWebGraphicsContext3D.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebExternalTextureMailbox.h"
 #include "wtf/RefPtr.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 using namespace WebCore;
 using namespace blink;
@@ skipping 51 matching lines @@
     WebGLId m_boundTexture;
     HashMap<WebGLId, IntSize> m_textureSizes;
     WGC3Dbyte m_currentMailboxByte;
     IntSize m_mostRecentlyProducedSize;
 };
 
 static const int initialWidth = 100;
 static const int initialHeight = 100;
 static const int alternateHeight = 50;
 
+class DrawingBufferForTests : public DrawingBuffer {
+public:
+    static PassRefPtr<DrawingBufferForTests> create(PassOwnPtr<blink::WebGraphicsContext3D> context,
+        const IntSize& size, PreserveDrawingBuffer preserve, PassRefPtr<ContextEvictionManager> contextEvictionManager)
+    {
+        OwnPtr<Extensions3DUtil> extensionsUtil = Extensions3DUtil::create(context.get());
+        RefPtr<DrawingBufferForTests> drawingBuffer =
+            adoptRef(new DrawingBufferForTests(context, extensionsUtil.release(), preserve, contextEvictionManager));
+        if (!drawingBuffer->initialize(size)) {
+            drawingBuffer->beginDestruction();
+            return PassRefPtr<DrawingBufferForTests>();
+        }
+        return drawingBuffer.release();
+    }
+
+    DrawingBufferForTests(PassOwnPtr<blink::WebGraphicsContext3D> context,
+        PassOwnPtr<Extensions3DUtil> extensionsUtil,
+        PreserveDrawingBuffer preserve,
+        PassRefPtr<ContextEvictionManager> contextEvictionManager)
+        : DrawingBuffer(context, extensionsUtil, false /* multisampleExtensionSupported */,
+            false /* packedDepthStencilExtensionSupported */, preserve, contextEvictionManager)
+        , m_live(0)
+    { }
+
+    virtual ~DrawingBufferForTests()
+    {
+        if (m_live)
+            *m_live = false;
+    }
+
+    bool* m_live;
+};
+
 class DrawingBufferTest : public Test {
 protected:
     virtual void SetUp()
     {
         RefPtr<FakeContextEvictionManager> contextEvictionManager = adoptRef(new FakeContextEvictionManager());
         OwnPtr<WebGraphicsContext3DForTests> context = adoptPtr(new WebGraphicsContext3DForTests);
         m_context = context.get();
-        m_drawingBuffer = DrawingBuffer::create(context.release(), IntSize(initialWidth, initialHeight), DrawingBuffer::Preserve, contextEvictionManager.release());
+        m_drawingBuffer = DrawingBufferForTests::create(context.release(),
+            IntSize(initialWidth, initialHeight), DrawingBuffer::Preserve, contextEvictionManager.release());
     }
 
     WebGraphicsContext3DForTests* webContext()
     {
         return m_context;
     }
 
     WebGraphicsContext3DForTests* m_context;
-    RefPtr<DrawingBuffer> m_drawingBuffer;
+    RefPtr<DrawingBufferForTests> m_drawingBuffer;
 };
 
 TEST_F(DrawingBufferTest, testPaintRenderingResultsToCanvas)
 {
     OwnPtr<ImageBufferSurface> imageBufferSurface = adoptPtr(new UnacceleratedImageBufferSurface(IntSize(initialWidth, initialHeight)));
     EXPECT_FALSE(!imageBufferSurface);
     EXPECT_TRUE(imageBufferSurface->isValid());
     OwnPtr<ImageBuffer> imageBuffer = ImageBuffer::create(imageBufferSurface.release());
     EXPECT_FALSE(!imageBuffer);
     EXPECT_FALSE(imageBuffer->isAccelerated());
     EXPECT_FALSE(imageBuffer->bitmap().isNull());
     m_drawingBuffer->paintRenderingResultsToCanvas(imageBuffer.get());
     EXPECT_FALSE(imageBuffer->isAccelerated());
     EXPECT_FALSE(imageBuffer->bitmap().isNull());
+    m_drawingBuffer->beginDestruction();
 }
 
 TEST_F(DrawingBufferTest, verifyResizingProperlyAffectsMailboxes)
 {
     blink::WebExternalTextureMailbox mailbox;
 
     IntSize initialSize(initialWidth, initialHeight);
     IntSize alternateSize(initialWidth, alternateHeight);
 
     // Produce one mailbox at size 100x100.
@@ skipping 17 matching lines @@
     // Prepare another mailbox and verify that it's the correct size.
     m_drawingBuffer->markContentsChanged();
     EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailbox, 0));
     EXPECT_EQ(initialSize, webContext()->mostRecentlyProducedSize());
 
     // Prepare one final mailbox and verify that it's the correct size.
     m_drawingBuffer->mailboxReleased(mailbox);
     m_drawingBuffer->markContentsChanged();
     EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailbox, 0));
     EXPECT_EQ(initialSize, webContext()->mostRecentlyProducedSize());
+    m_drawingBuffer->beginDestruction();
 }
 
+TEST_F(DrawingBufferTest, verifyDestructionCompleteAfterAllMailboxesReleased)
+{
+    bool live = true;
+    m_drawingBuffer->m_live = &live;
+
+    blink::WebExternalTextureMailbox mailbox1;
+    blink::WebExternalTextureMailbox mailbox2;
+    blink::WebExternalTextureMailbox mailbox3;
+
+    IntSize initialSize(initialWidth, initialHeight);
+
+    // Produce mailboxes.
+    m_drawingBuffer->markContentsChanged();
+    EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailbox1, 0));
+    m_drawingBuffer->markContentsChanged();
+    EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailbox2, 0));
+    m_drawingBuffer->markContentsChanged();
+    EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailbox3, 0));
+
+    m_drawingBuffer->markContentsChanged();
+    m_drawingBuffer->mailboxReleased(mailbox1);
+
+    m_drawingBuffer->beginDestruction();
+    EXPECT_EQ(live, true);
+
+    DrawingBufferForTests* weakPointer = m_drawingBuffer.get();
+    m_drawingBuffer.clear();
+    EXPECT_EQ(live, true);
+
+    weakPointer->markContentsChanged();
+    weakPointer->mailboxReleased(mailbox2);
+    EXPECT_EQ(live, true);
+
+    weakPointer->markContentsChanged();
+    weakPointer->mailboxReleased(mailbox3);
+    EXPECT_EQ(live, false);
+}
+
+
 class TextureMailboxWrapper {
 public:
     explicit TextureMailboxWrapper(const blink::WebExternalTextureMailbox& mailbox)
         : m_mailbox(mailbox)
     { }
 
     bool operator==(const TextureMailboxWrapper& other) const
     {
         return !memcmp(m_mailbox.name, other.m_mailbox.name, sizeof(m_mailbox.name));
     }
@@ skipping 34 matching lines @@
 
     // The second recycled mailbox must be 3.
     m_drawingBuffer->markContentsChanged();
     EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&recycledMailbox, 0));
     EXPECT_EQ(TextureMailboxWrapper(mailbox3), TextureMailboxWrapper(recycledMailbox));
 
     // The third recycled mailbox must be 1.
     m_drawingBuffer->markContentsChanged();
     EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&recycledMailbox, 0));
     EXPECT_EQ(TextureMailboxWrapper(mailbox1), TextureMailboxWrapper(recycledMailbox));
+
+    m_drawingBuffer->mailboxReleased(mailbox1);
+    m_drawingBuffer->mailboxReleased(mailbox2);
+    m_drawingBuffer->mailboxReleased(mailbox3);
+    m_drawingBuffer->beginDestruction();
 }
 
 } // namespace