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

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 36 matching lines @@
 #ifndef NDEBUG
 #include "wtf/RefCountedLeakCounter.h"
 #endif
 
 namespace blink {
 
 namespace {
 
 const float s_resourceAdjustedRatio = 0.5;
 
+// Drawing buffers with more pixels than this will be explicitly checked for out of memory errors upon creation
+const int s_largeBufferSize = 4096 * 4096;
+
 DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, drawingBufferCounter, ("DrawingBuffer"));
 
 class ScopedTextureUnit0BindingRestorer {
 public:
     ScopedTextureUnit0BindingRestorer(WebGraphicsContext3D* context, GLenum activeTextureUnit, Platform3DObject textureUnitZeroId)
         : m_context(context)
         , m_oldActiveTextureUnit(activeTextureUnit)
         , m_oldTextureUnitZeroId(textureUnitZeroId)
     {
         m_context->activeTexture(GL_TEXTURE0);
     }
     ~ScopedTextureUnit0BindingRestorer()
     {
         m_context->bindTexture(GL_TEXTURE_2D, m_oldTextureUnitZeroId);
         m_context->activeTexture(m_oldActiveTextureUnit);
     }
 
 private:
     WebGraphicsContext3D* m_context;
     GLenum m_oldActiveTextureUnit;
     Platform3DObject m_oldTextureUnitZeroId;
 };
 
+class ScopedConditionalErrorCache {
+public:
+    ScopedConditionalErrorCache(WebGraphicsContext3D* context, bool active)
+        : m_context(context)
+        , m_active(active)
+    {
+        if (m_active) {
+            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.

[Ken Russell (switch to Gerrit), 2015/04/07 22:18:00]

This won't affect the behavior of the product, only debug builds -- it would be
safer to explicitly check a loop variable.

+                ASSERT(m_cachedErrors.size() < 100);
+            }
+        }
+    }
+
+    ~ScopedConditionalErrorCache()
+    {
+        while (m_cachedErrors.size()) {
+            m_context->synthesizeGLError(m_cachedErrors.first());
+            m_cachedErrors.remove(0);
+        }
+    }
+
+    bool consumeErrorIf(GLenum error)
+    {
+        if (m_active) {
+            GLenum nextError = m_context->getError();
+            if (error == GL_NO_ERROR)
+                return false;
+
+            if (nextError == error)
+                return true;
+
+            m_cachedErrors.append(nextError);
+        }
+        return false;
+    }
+
+private:
+    WebGraphicsContext3D* m_context;
+    bool m_active;
+    Vector<GLenum> m_cachedErrors;
+};
+
+bool isLargeBuffer(const IntSize& size)
+{
+    return s_largeBufferSize <= size.width() * size.height();
+}
+
 } // 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) {
+        ScopedConditionalErrorCache errorCache(m_context.get(), isLargeBuffer(size));
+
         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.consumeErrorIf(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;
+
+    ScopedConditionalErrorCache errorCache(m_context.get(), isLargeBuffer(size));
 
     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.consumeErrorIf(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)
 {
+    ScopedConditionalErrorCache errorCache(m_context.get(), isLargeBuffer(size));
+
     if (RuntimeEnabledFeatures::webGLImageChromiumEnabled()) {
         deleteChromiumImageForTexture(info);
 
         info->imageId = m_context->createGpuMemoryBufferImageCHROMIUM(size.width(), size.height(), GL_RGBA, GC3D_SCANOUT_CHROMIUM);
+
+        if (errorCache.consumeErrorIf(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.consumeErrorIf(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