Removed arbitrary 4096 size limit on WebGL canvas backbuffers, Take 2

Source/platform/graphics/gpu/DrawingBuffer.cpp

 /*
  * Copyright (c) 2010, 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 59 matching lines @@
         m_context->bindTexture(GL_TEXTURE_2D, m_oldTextureUnitZeroId);
         m_context->activeTexture(m_oldActiveTextureUnit);
     }
 
 private:
     WebGraphicsContext3D* m_context;
     GLenum m_oldActiveTextureUnit;
     Platform3DObject m_oldTextureUnitZeroId;
 };
 
+class ScopedErrorCache {
+public:
+    ScopedErrorCache(WebGraphicsContext3D* context)
+        : m_context(context)
+    {
+        GLenum error = m_context->getError();
+        while (error != GL_NO_ERROR) {
+            m_cachedErrors.append(error);
+            error = m_context->getError();
+            // Avoid infinite looping if glGetError is behaving badly.
+            ASSERT(m_cachedErrors.size() < 100);
+        }
+    }
+
+    ~ScopedErrorCache()
+    {
+        while (m_cachedErrors.size()) {
+            m_context->synthesizeGLError(m_cachedErrors.first());
+            m_cachedErrors.remove(0);
+        }
+    }
+
+    // Check for a GLerror but keep it in the cache
+    GLenum peekError()
+    {
+        GLenum error = m_context->getError();
+        if (error != GL_NO_ERROR) {
+            m_cachedErrors.append(error);
+        }
+        return error;
+    }
+
+private:
+    WebGraphicsContext3D* m_context;
+    Vector<GLenum> m_cachedErrors;
+};
+
 } // namespace
 
 PassRefPtr<DrawingBuffer> DrawingBuffer::create(PassOwnPtr<WebGraphicsContext3D> context, const IntSize& size, PreserveDrawingBuffer preserve, WebGraphicsContext3D::Attributes requestedAttributes)
 {
     ASSERT(context);
     OwnPtr<Extensions3DUtil> extensionsUtil = Extensions3DUtil::create(context.get());
     if (!extensionsUtil) {
         // This might be the first time we notice that the WebGraphicsContext3D is lost.
         return nullptr;
     }
@@ skipping 523 matching lines @@
     }
 }
 
 bool DrawingBuffer::resizeFramebuffer(const IntSize& size)
 {
     // resize regular FBO
     m_context->bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
 
     m_context->bindTexture(GL_TEXTURE_2D, m_colorBuffer.textureId);
 
-    allocateTextureMemory(&m_colorBuffer, size);
+    if (!allocateTextureMemory(&m_colorBuffer, size))
+        return false;
 
     if (m_multisampleMode == ImplicitResolve)
         m_context->framebufferTexture2DMultisampleEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_colorBuffer.textureId, 0, m_sampleCount);
     else
         m_context->framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_colorBuffer.textureId, 0);
 
     m_context->bindTexture(GL_TEXTURE_2D, 0);
 
-    if (m_multisampleMode != ExplicitResolve)
-        resizeDepthStencil(size);
+    if (m_multisampleMode != ExplicitResolve) {
+        if (!resizeDepthStencil(size))
+            return false;
+    }
     if (m_context->checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
         return false;
 
     return true;
 }
 
 bool DrawingBuffer::resizeMultisampleFramebuffer(const IntSize& size)
 {
     if (m_multisampleMode == ExplicitResolve) {
+        ScopedErrorCache errorCache(m_context.get());
+
         m_context->bindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
 
         m_context->bindRenderbuffer(GL_RENDERBUFFER, m_multisampleColorBuffer);
         m_context->renderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, m_internalRenderbufferFormat, size.width(), size.height());
 
-        if (m_context->getError() == GL_OUT_OF_MEMORY)
+        if (errorCache.peekError() == GL_OUT_OF_MEMORY)
             return false;
 
         m_context->framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_multisampleColorBuffer);
-        resizeDepthStencil(size);
+        if (!resizeDepthStencil(size))
+            return false;
         if (m_context->checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
             return false;
     }
 
     return true;
 }
 
-void DrawingBuffer::resizeDepthStencil(const IntSize& size)
+bool DrawingBuffer::resizeDepthStencil(const IntSize& size)
 {
     if (!m_requestedAttributes.depth && !m_requestedAttributes.stencil)
-        return;
+        return true;
+
+    ScopedErrorCache errorCache(m_context.get());
 
     if (m_packedDepthStencilExtensionSupported) {
         if (!m_depthStencilBuffer)
             m_depthStencilBuffer = m_context->createRenderbuffer();
         m_context->bindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer);
         if (m_multisampleMode == ImplicitResolve)
             m_context->renderbufferStorageMultisampleEXT(GL_RENDERBUFFER, m_sampleCount, GL_DEPTH24_STENCIL8_OES, size.width(), size.height());
         else if (m_multisampleMode == ExplicitResolve)
             m_context->renderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, GL_DEPTH24_STENCIL8_OES, size.width(), size.height());
         else
@@ skipping 20 matching lines @@
             if (m_multisampleMode == ImplicitResolve)
                 m_context->renderbufferStorageMultisampleEXT(GL_RENDERBUFFER, m_sampleCount, GL_STENCIL_INDEX8, size.width(), size.height());
             else if (m_multisampleMode == ExplicitResolve)
                 m_context->renderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, GL_STENCIL_INDEX8, size.width(), size.height());
             else
                 m_context->renderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, size.width(), size.height());
             m_context->framebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_stencilBuffer);
         }
     }
     m_context->bindRenderbuffer(GL_RENDERBUFFER, 0);
+
+    if (errorCache.peekError() == GL_OUT_OF_MEMORY)
+        return false;
+
+    return true;
 }
 
 
 
 void DrawingBuffer::clearFramebuffers(GLbitfield clearMask)
 {
     // We will clear the multisample FBO, but we also need to clear the non-multisampled buffer.
     if (m_multisampleFBO) {
         m_context->bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
         m_context->clear(GL_COLOR_BUFFER_BIT);
@@ skipping 242 matching lines @@
         memcpy(rowA, scanline, rowBytes);
     }
 }
 
 void DrawingBuffer::texImage2DResourceSafe(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLint unpackAlignment)
 {
     ASSERT(unpackAlignment == 1 || unpackAlignment == 2 || unpackAlignment == 4 || unpackAlignment == 8);
     m_context->texImage2D(target, level, internalformat, width, height, border, format, type, 0);
 }
 
-void DrawingBuffer::allocateTextureMemory(TextureInfo* info, const IntSize& size)
+bool DrawingBuffer::allocateTextureMemory(TextureInfo* info, const IntSize& size)
 {
+    ScopedErrorCache errorCache(m_context.get());

[piman, 2015/04/06 22:35:10]

drive-by: this sounds pretty unfortunate to do (many!) sync round trips to the
GPU process... This will hit on every webgl page load as well as on every canvas
resize. Each resizeFramebuffer will typically involve 4 to 6 round trips (at
least one for each ScopedErrorCache constructor, one for each peekError, a pair
of these for the resolved texture, the depth RB and possibly the multisampled
RB).

Could this be done by either:
1- limiting the error checks to "large" textures (if 4096x4096 were ok before,
they should still be)
2- identifying the GPUs which exhibit the bad behavior and add a workaround to
limit their max texture size to 4096
3- at the very very minimum, a single pair of round trips?

+
     if (RuntimeEnabledFeatures::webGLImageChromiumEnabled()) {
         deleteChromiumImageForTexture(info);
 
         info->imageId = m_context->createGpuMemoryBufferImageCHROMIUM(size.width(), size.height(), GL_RGBA, GC3D_SCANOUT_CHROMIUM);
+
+        if (errorCache.peekError() == GL_OUT_OF_MEMORY)
+            return false;
+
         if (info->imageId) {
             m_context->bindTexImage2DCHROMIUM(GL_TEXTURE_2D, info->imageId);
-            return;
+            return true;
         }
     }
 
     texImage2DResourceSafe(GL_TEXTURE_2D, 0, m_internalColorFormat, size.width(), size.height(), 0, m_colorFormat, GL_UNSIGNED_BYTE);
+
+    if (errorCache.peekError() == GL_OUT_OF_MEMORY)
+        return false;
+
+    return true;
 }
 
 void DrawingBuffer::deleteChromiumImageForTexture(TextureInfo* info)
 {
     if (info->imageId) {
         m_context->releaseTexImage2DCHROMIUM(GL_TEXTURE_2D, info->imageId);
         m_context->destroyImageCHROMIUM(info->imageId);
         info->imageId = 0;
     }
 }
 
 } // namespace blink