Remove WebGL CHROMIUM image fallback logic.

third_party/WebKit/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 34 matching lines @@
 #include "wtf/RefPtr.h"
 
 using testing::Test;
 using testing::_;
 
 namespace blink {
 
 namespace {
 
 // The target to use when binding a texture to a Chromium image.
-GLenum imageTextureTarget()
+GLenum imageCHROMIUMTextureTarget()
 {
 #if OS(MACOSX)
     return GC3D_TEXTURE_RECTANGLE_ARB;
 #else
     return GL_TEXTURE_2D;
 #endif
 }
 
 // The target to use when preparing a mailbox texture.
-GLenum drawingBufferTextureTarget(bool allowImageChromium)
+GLenum drawingBufferTextureTarget()
 {
-    if (RuntimeEnabledFeatures::webGLImageChromiumEnabled() && allowImageChromium)
-        return imageTextureTarget();
+    if (RuntimeEnabledFeatures::webGLImageChromiumEnabled())
+        return imageCHROMIUMTextureTarget();
     return GL_TEXTURE_2D;
 }
 
 } // namespace
 
 class GLES2InterfaceForTests : public gpu::gles2::GLES2InterfaceStub {
 public:
     void BindTexture(GLenum target, GLuint texture) override
     {
         if (target != m_boundTextureTarget && texture == 0)
@@ skipping 37 matching lines @@
 
     void GenMailboxCHROMIUM(GLbyte* mailbox) override
     {
         ++m_currentMailboxByte;
         WebExternalTextureMailbox temp;
         memset(mailbox, m_currentMailboxByte, sizeof(temp.name));
     }
 
     void ProduceTextureDirectCHROMIUM(GLuint texture, GLenum target, const GLbyte* mailbox) override
     {
-        ASSERT_EQ(target, drawingBufferTextureTarget(m_allowImageChromium));
-        ASSERT_TRUE(m_textureSizes.contains(texture));
-        m_mostRecentlyProducedSize = m_textureSizes.get(texture);
+        ASSERT_EQ(target, drawingBufferTextureTarget());
+
+        if (!m_createImageChromiumFail) {
+            ASSERT_TRUE(m_textureSizes.contains(texture));
+            m_mostRecentlyProducedSize = m_textureSizes.get(texture);
+        }
     }
 
     void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
     {
         if (target == GL_TEXTURE_2D && !level) {
             m_textureSizes.set(m_boundTexture, IntSize(width, height));
         }
     }
 
     GLuint CreateGpuMemoryBufferImageCHROMIUM(GLsizei width, GLsizei height, GLenum internalformat, GLenum usage) override
     {
-        if (!m_allowImageChromium)
-            return false;
+        if (m_createImageChromiumFail)
+            return 0;
         m_imageSizes.set(m_currentImageId, IntSize(width, height));
         return m_currentImageId++;
     }
 
     MOCK_METHOD1(DestroyImageMock, void(GLuint imageId));
     void DestroyImageCHROMIUM(GLuint imageId)
     {
         m_imageSizes.remove(imageId);
         // No textures should be bound to this.
         ASSERT(m_imageToTextureMap.find(imageId) == m_imageToTextureMap.end());
         m_imageSizes.remove(imageId);
         DestroyImageMock(imageId);
     }
 
     MOCK_METHOD1(BindTexImage2DMock, void(GLint imageId));
     void BindTexImage2DCHROMIUM(GLenum target, GLint imageId)
     {
-        if (target == imageTextureTarget()) {
+        if (target == imageCHROMIUMTextureTarget()) {
             m_textureSizes.set(m_boundTexture, m_imageSizes.find(imageId)->value);
             m_imageToTextureMap.set(imageId, m_boundTexture);
             BindTexImage2DMock(imageId);
         }
     }
 
     MOCK_METHOD1(ReleaseTexImage2DMock, void(GLint imageId));
     void ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId)
     {
-        if (target == imageTextureTarget()) {
+        if (target == imageCHROMIUMTextureTarget()) {
             m_imageSizes.set(m_currentImageId, IntSize());
             m_imageToTextureMap.remove(imageId);
             ReleaseTexImage2DMock(imageId);
         }
     }
 
     void GenSyncTokenCHROMIUM(GLuint64 fenceSync, GLbyte* syncToken) override
     {
         memcpy(syncToken, &fenceSync, sizeof(fenceSync));
     }
 
     void GenTextures(GLsizei n, GLuint* textures) override
     {
         static GLuint id = 1;
         for (GLsizei i = 0; i < n; ++i)
             textures[i] = id++;
     }
 
     GLuint boundTexture() const { return m_boundTexture; }
     GLuint boundTextureTarget() const { return m_boundTextureTarget; }
     GLuint mostRecentlyWaitedSyncToken() const { return m_mostRecentlyWaitedSyncToken; }
     GLuint nextImageIdToBeCreated() const { return m_currentImageId; }
     IntSize mostRecentlyProducedSize() const { return m_mostRecentlyProducedSize; }
-    bool allowImageChromium() const { return m_allowImageChromium; }
 
-    void setAllowImageChromium(bool allow) { m_allowImageChromium = allow; }
+    void setCreateImageChromiumFail(bool fail) { m_createImageChromiumFail = fail; }
 
 private:
     GLuint m_boundTexture = 0;
     GLuint m_boundTextureTarget = 0;
     GLuint m_mostRecentlyWaitedSyncToken = 0;
     GLbyte m_currentMailboxByte = 0;
     IntSize m_mostRecentlyProducedSize;
-    bool m_allowImageChromium = true;
+    bool m_createImageChromiumFail = false;
     GLuint m_currentImageId = 1;
     HashMap<GLuint, IntSize> m_textureSizes;
     HashMap<GLuint, IntSize> m_imageSizes;
     HashMap<GLuint, GLuint> m_imageToTextureMap;
 };
 
 static const int initialWidth = 100;
 static const int initialHeight = 100;
 static const int alternateHeight = 50;
 
@@ skipping 358 matching lines @@
     m_drawingBuffer->mailboxReleased(mailbox, false);
 
     EXPECT_CALL(*m_gl, DestroyImageMock(m_imageId5)).Times(1);
     EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(m_imageId5)).Times(1);
     EXPECT_CALL(*m_gl, DestroyImageMock(m_imageId4)).Times(1);
     EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(m_imageId4)).Times(1);
     m_drawingBuffer->beginDestruction();
     testing::Mock::VerifyAndClearExpectations(m_gl);
 }
 
+TEST_F(DrawingBufferImageChromiumTest, allocationFailure)
+{
+    WebExternalTextureMailbox mailboxes[3];
+
+    // Request a mailbox. An image should already be created. Everything works
+    // as expected.
+    EXPECT_CALL(*m_gl, BindTexImage2DMock(_)).Times(1);
+    IntSize initialSize(initialWidth, initialHeight);
+    m_drawingBuffer->markContentsChanged();
+    EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailboxes[0], 0));
+    EXPECT_TRUE(mailboxes[0].allowOverlay);
+    testing::Mock::VerifyAndClearExpectations(m_gl);
+
+    // Force image CHROMIUM creation failure. Request another mailbox. It should
+    // still be provided, but this time with allowOverlay = false.
+    m_gl->setCreateImageChromiumFail(true);
+    m_drawingBuffer->markContentsChanged();
+    EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailboxes[1], 0));
+    EXPECT_FALSE(mailboxes[1].allowOverlay);
+
+    // Check that if image CHROMIUM starts working again, mailboxes are
+    // correctly created with allowOverlay = true.
+    EXPECT_CALL(*m_gl, BindTexImage2DMock(_)).Times(1);
+    m_gl->setCreateImageChromiumFail(false);
+    m_drawingBuffer->markContentsChanged();
+    EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailboxes[2], 0));
+    EXPECT_TRUE(mailboxes[2].allowOverlay);
+    testing::Mock::VerifyAndClearExpectations(m_gl);
+
+    for (int i = 0; i < 3; ++i)
+        m_drawingBuffer->mailboxReleased(mailboxes[i], false);
+
+    EXPECT_CALL(*m_gl, DestroyImageMock(_)).Times(3);
+    EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(_)).Times(3);
+    m_drawingBuffer->beginDestruction();
+    testing::Mock::VerifyAndClearExpectations(m_gl);
+}
+
 class DepthStencilTrackingGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
 public:
     void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) override
     {
         switch (attachment) {
         case GL_DEPTH_ATTACHMENT:
             m_depthAttachment = renderbuffer;
             break;
         case GL_STENCIL_ATTACHMENT:
             m_stencilAttachment = renderbuffer;
@@ skipping 141 matching lines @@
     m_drawingBuffer->mailboxReleased(mailbox);
     // m_drawingBuffer deletes mailbox immediately when hidden.
 
     GLuint waitSyncToken = 0;
     memcpy(&waitSyncToken, mailbox.syncToken, sizeof(waitSyncToken));
     EXPECT_EQ(waitSyncToken, m_gl->mostRecentlyWaitedSyncToken());
 
     m_drawingBuffer->beginDestruction();
 }
 
-class DrawingBufferImageChromiumFallbackTest : public DrawingBufferTest {
-protected:
-    void SetUp() override
-    {
-        OwnPtr<GLES2InterfaceForTests> gl = adoptPtr(new GLES2InterfaceForTests);
-        gl->setAllowImageChromium(false);
-        m_gl = gl.get();
-        OwnPtr<WebGraphicsContext3DProviderForTests> provider = adoptPtr(new WebGraphicsContext3DProviderForTests(std::move(gl)));
-        RuntimeEnabledFeatures::setWebGLImageChromiumEnabled(true);
-        m_drawingBuffer = DrawingBufferForTests::create(std::move(provider),
-            IntSize(initialWidth, initialHeight), DrawingBuffer::Preserve);
-    }
-
-    void TearDown() override
-    {
-        RuntimeEnabledFeatures::setWebGLImageChromiumEnabled(false);
-    }
-};
-
-TEST_F(DrawingBufferImageChromiumFallbackTest, verifyImageChromiumFallback)
-{
-    WebExternalTextureMailbox mailbox;
-
-    IntSize initialSize(initialWidth, initialHeight);
-    m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->prepareMailbox(&mailbox, 0));
-    EXPECT_EQ(initialSize, m_gl->mostRecentlyProducedSize());
-    EXPECT_FALSE(mailbox.allowOverlay);
-
-    m_drawingBuffer->mailboxReleased(mailbox, false);
-    m_drawingBuffer->beginDestruction();
-}
-
 } // namespace blink