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

Source/WebCore/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"
 #include <algorithm>
 #include <public/Platform.h>
 #include <public/WebCompositorSupport.h>
 #include <public/WebExternalTextureLayer.h>
 #include <public/WebGraphicsContext3D.h>
 
 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 int s_maximumResourceUsePixels = 16 * 1024 * 1024;
 static int s_currentResourceUsePixels = 0;
 static const float s_resourceAdjustedRatio = 0.5;
+static const int s_maxScaleAttempts = 3;
 
 static unsigned generateColorTexture(GraphicsContext3D* context, const IntSize& size)
 {
     unsigned offscreenColorTexture = context->createTexture();
     if (!offscreenColorTexture)
         return 0;
 
     context->bindTexture(GraphicsContext3D::TEXTURE_2D, offscreenColorTexture);
     context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR);
     context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR);
@@ skipping 34 matching lines @@
     TRACE_EVENT_INSTANT0("test_gpu", "DrawingBufferCreation");
 
     // We need a separate front and back textures if ...
     m_separateFrontTexture = m_preserveDrawingBuffer == Preserve // ... we have to preserve contents after compositing, which is done with a copy or ...
                              || WebKit::Platform::current()->isThreadedCompositingEnabled(); // ... if we're in threaded mode and need to double buffer.
     initialize(size);
 }
 
 DrawingBuffer::~DrawingBuffer()
 {
+    clear();
+
     if (!m_context)
         return;
 
-    clear();
-
     if (m_layer)
         GraphicsLayerChromium::unregisterContentsLayer(m_layer->layer());
 }
 
 unsigned DrawingBuffer::prepareTexture(WebKit::WebTextureUpdater& updater)
 {
     prepareBackBuffer();
 
     graphicsContext3D()->flush();
     graphicsContext3D()->markLayerComposited();
@@ skipping 128 matching lines @@
     }
     bool packedDepthStencilSupported = extensions->supports("GL_OES_packed_depth_stencil");
     if (packedDepthStencilSupported)
         extensions->ensureEnabled("GL_OES_packed_depth_stencil");
     RefPtr<DrawingBuffer> drawingBuffer = adoptRef(new DrawingBuffer(context, size, multisampleSupported, packedDepthStencilSupported, preserve, alpha));
     return (drawingBuffer->m_context) ? drawingBuffer.release() : 0;
 }
 
 void DrawingBuffer::clear()
 {
-    if (!m_context)
-        return;
+    if (m_context) {
+        m_context->makeContextCurrent();
 
-    m_context->makeContextCurrent();
+        clearPlatformLayer();
 
-    clearPlatformLayer();
+        if (m_colorBuffer)
+            m_context->deleteTexture(m_colorBuffer);
+
+        if (m_frontColorBuffer)
+            m_context->deleteTexture(m_frontColorBuffer);
+
+        if (m_multisampleColorBuffer)
+            m_context->deleteRenderbuffer(m_multisampleColorBuffer);
+
+        if (m_depthStencilBuffer)
+            m_context->deleteRenderbuffer(m_depthStencilBuffer);
+
+        if (m_depthBuffer)
+            m_context->deleteRenderbuffer(m_depthBuffer);
+
+        if (m_stencilBuffer)
+            m_context->deleteRenderbuffer(m_stencilBuffer);
+
+        if (m_multisampleFBO)
+            m_context->deleteFramebuffer(m_multisampleFBO);
+
+        if (m_fbo)
+            m_context->deleteFramebuffer(m_fbo);
+    }
 
     if (!m_size.isEmpty()) {
         s_currentResourceUsePixels -= m_size.width() * m_size.height();
         m_size = IntSize();
     }
 
-    if (m_colorBuffer) {
-        m_context->deleteTexture(m_colorBuffer);
-        m_colorBuffer = 0;
-    }
-
-    if (m_frontColorBuffer) {
-        m_context->deleteTexture(m_frontColorBuffer);
-        m_frontColorBuffer = 0;
-    }
-
-    if (m_multisampleColorBuffer) {
-        m_context->deleteRenderbuffer(m_multisampleColorBuffer);
-        m_multisampleColorBuffer = 0;
-    }
-
-    if (m_depthStencilBuffer) {
-        m_context->deleteRenderbuffer(m_depthStencilBuffer);
-        m_depthStencilBuffer = 0;
-    }
-
-    if (m_depthBuffer) {
-        m_context->deleteRenderbuffer(m_depthBuffer);
-        m_depthBuffer = 0;
-    }
-
-    if (m_stencilBuffer) {
-        m_context->deleteRenderbuffer(m_stencilBuffer);
-        m_stencilBuffer = 0;
-    }
-
-    if (m_multisampleFBO) {
-        m_context->deleteFramebuffer(m_multisampleFBO);
-        m_multisampleFBO = 0;
-    }
-
-    if (m_fbo) {
-        m_context->deleteFramebuffer(m_fbo);
-        m_fbo = 0;
-    }
+    m_colorBuffer = 0;
+    m_frontColorBuffer = 0;
+    m_multisampleColorBuffer = 0;
+    m_depthStencilBuffer = 0;
+    m_depthBuffer = 0;
+    m_stencilBuffer = 0;
+    m_multisampleFBO = 0;
+    m_fbo = 0;
 }
 
 void DrawingBuffer::createSecondaryBuffers()
 {
     // create a multisample FBO
     if (multisample()) {
         m_multisampleFBO = m_context->createFramebuffer();
         m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_multisampleFBO);
         m_multisampleColorBuffer = m_context->createRenderbuffer();
     }
@@ skipping 87 matching lines @@
 
     int maxTextureSize = 0;
     m_context->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &maxTextureSize);
     if (newSize.height() > maxTextureSize || newSize.width() > maxTextureSize) {
         clear();
         return false;
     }
 
     int pixelDelta = newSize.width() * newSize.height();
     int oldSize = 0;
+    bool newBuffer = true;
     if (!m_size.isEmpty()) {
         oldSize = m_size.width() * m_size.height();
         pixelDelta -= oldSize;
+        newBuffer = false;
+    }
+
+    if(newBuffer && s_currentResourceUsePixels == s_maximumResourceUsePixels) {
+        WebGLRenderingContext::forceLostOldestContext();
+        newBuffer = false;
     }
 
     IntSize adjustedSize = newSize;
+    int scaleAttempts = 0;
     if (s_maximumResourceUsePixels) {
         while ((s_currentResourceUsePixels + pixelDelta) > s_maximumResourceUsePixels) {
             adjustedSize.scale(s_resourceAdjustedRatio);
+
+            scaleAttempts++;
+            if(newBuffer && scaleAttempts >= s_maxScaleAttempts) {
+                WebGLRenderingContext::forceLostOldestContext();
+                adjustedSize = newSize;
+                newBuffer = false;
+            }
+
             if (adjustedSize.isEmpty()) {
                 clear();
                 return false;
             }
             pixelDelta = adjustedSize.width() * adjustedSize.height();
             pixelDelta -= oldSize;
         }
      }
 
     const GraphicsContext3D::Attributes& attributes = m_context->getContextAttributes();
@@ skipping 168 matching lines @@
 
 void DrawingBuffer::bind()
 {
     if (!m_context)
         return;
 
     m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_multisampleFBO ? m_multisampleFBO : m_fbo);
 }
 
 } // namespace WebCore