Limit the number of WebGL contexts that are active at any given time

Source/core/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 21 matching lines @@
 
 #include "DrawingBuffer.h"
 
 #include "CanvasRenderingContext.h"
 #include "Extensions3D.h"
 #include "GraphicsContext3D.h"
 #include "GraphicsContext3DPrivate.h"
 #include "GraphicsLayerChromium.h"
 #include "ImageData.h"
 #include "TraceEvent.h"
+#include "WebGLRenderingContext.h"

[bajones, 2013/04/20 05:19:59]

Ken already pointed out in a different patch review that this violates layering
rules, but I'm not sure what the appropriate approach is to allow this. Include
is currently required to provide access to
WebGLRenderingContext::forciblyLoseOldestContext();

 #include <algorithm>
 #include <public/Platform.h>
 #include <public/WebCompositorSupport.h>
 #include <public/WebExternalTextureLayer.h>
 #include <public/WebGraphicsContext3D.h>
 
 #define USES_MAILBOX 0
 
 using namespace std;
 
 namespace WebCore {
 
 // Global resource ceiling (expressed in terms of pixels) for DrawingBuffer creation and resize.
 // When this limit is set, DrawingBuffer::create() and DrawingBuffer::reset() calls that would
 // exceed the global cap will instead clear the buffer.
 static const int s_maximumResourceUsePixels = 16 * 1024 * 1024;
 static int s_currentResourceUsePixels = 0;
 static const float s_resourceAdjustedRatio = 0.5;
 
+static const bool s_allowContextEvictionOnCreate = true;
+static const int s_maxScaleAttempts = 3;
+
 class ScopedTextureUnit0BindingRestorer {
 public:
     ScopedTextureUnit0BindingRestorer(GraphicsContext3D* context, GC3Denum activeTextureUnit, Platform3DObject textureUnitZeroId)
         : m_context(context)
         , m_oldActiveTextureUnit(activeTextureUnit)
         , m_oldTextureUnitZeroId(textureUnitZeroId)
     {
         m_context->activeTexture(GraphicsContext3D::TEXTURE0);
     }
     ~ScopedTextureUnit0BindingRestorer()
@@ skipping 499 matching lines @@
             if (multisample())
                 m_context->getExtensions()->renderbufferStorageMultisample(GraphicsContext3D::RENDERBUFFER, sampleCount, GraphicsContext3D::STENCIL_INDEX8, size.width(), size.height());
             else 
                 m_context->renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::STENCIL_INDEX8, size.width(), size.height());
             m_context->framebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::STENCIL_ATTACHMENT, GraphicsContext3D::RENDERBUFFER, m_stencilBuffer);
         }
     }
     m_context->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, 0);
 }
 
+
+
 void DrawingBuffer::clearFramebuffers(GC3Dbitfield clearMask)
 {
     m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_multisampleFBO ? m_multisampleFBO : m_fbo);
 
     m_context->clear(clearMask);
 
     // The multisample fbo was just cleared, but we also need to clear the non-multisampled buffer too.
     if (m_multisampleFBO) {
         m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_fbo);
         m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT);
@@ skipping 51 matching lines @@
     // Clamp if the desired size is greater than the maximum texture size for the device.
     int maxTextureSize = 0;
     m_context->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &maxTextureSize);
     if (adjustedSize.height() > maxTextureSize)
         adjustedSize.setHeight(maxTextureSize);
 
     if (adjustedSize.width() > maxTextureSize)
         adjustedSize.setWidth(maxTextureSize);
 
     // Try progressively smaller sizes until we find a size that fits or reach a scale limit.
+    int scaleAttempts = 0;
     while ((s_currentResourceUsePixels + pixelDelta(adjustedSize)) > s_maximumResourceUsePixels) {
+        scaleAttempts++;
+        if(s_maxScaleAttempts > -1 && scaleAttempts > s_maxScaleAttempts)
+            return IntSize();
+
         adjustedSize.scale(s_resourceAdjustedRatio);
 
         if (adjustedSize.isEmpty())
             return IntSize();
     }
+
+    return adjustedSize;
+}
+
+IntSize DrawingBuffer::adjustSizeWithContextEviction(const IntSize& size, bool& evictContext) {
+    IntSize adjustedSize = adjustSize(size);
+    if(!adjustedSize.isEmpty()) {
+        evictContext = false;
+        return adjustedSize; // Buffer fits without evicting a context
+    }
+
+    // Speculatively adjust the pixel budget to see if the buffer would fit should the oldest context be evicted
+    IntSize oldestSize = WebGLRenderingContext::oldestContextSize();
+    int pixelDelta = oldestSize.width() * oldestSize.height();
+
+    s_currentResourceUsePixels -= pixelDelta;
+    adjustedSize = adjustSize(size);
+    s_currentResourceUsePixels += pixelDelta;
+
+    evictContext = !adjustedSize.isEmpty();
     return adjustedSize;
 }
 
 void DrawingBuffer::reset(const IntSize& newSize)
 {
-    IntSize adjustedSize = adjustSize(newSize);
+    IntSize adjustedSize;
+    bool evictContext = false;
+    bool isNewContext = m_size.isEmpty();
+    if (s_allowContextEvictionOnCreate && isNewContext)
+        adjustedSize = adjustSizeWithContextEviction(newSize, evictContext);
+    else
+        adjustSize(newSize);
+
     if (adjustedSize.isEmpty())
         return;
 
+    if (evictContext)
+        WebGLRenderingContext::forciblyLoseOldestContext();
+
     if (adjustedSize != m_size) {
         do {
             // resize multisample FBO
             if (!resizeMultisampleFramebuffer(adjustedSize) || !resizeFramebuffer(adjustedSize)) {
                 adjustedSize.scale(s_resourceAdjustedRatio);
                 continue;
             }
 
 #if OS(DARWIN)
             // FIXME: This can be removed once renderbufferStorageMultisample starts reporting GL_OUT_OF_MEMORY properly on OSX.
@@ skipping 76 matching lines @@
 
 void DrawingBuffer::bind()
 {
     if (!m_context)
         return;
 
     m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_multisampleFBO ? m_multisampleFBO : m_fbo);
 }
 
 } // namespace WebCore