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

Source/core/html/canvas/WebGLRenderingContext.cpp

 /*
  * Copyright (C) 2009 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 66 matching lines @@
 #include <wtf/OwnArrayPtr.h>
 #include <wtf/PassOwnArrayPtr.h>
 #include <wtf/text/StringBuilder.h>
 #include <wtf/Uint16Array.h>
 #include <wtf/Uint32Array.h>
 
 namespace WebCore {
 
 const double secondsBetweenRestoreAttempts = 1.0;
 const int maxGLErrorsAllowedToConsole = 256;
+const int maxGLActiveContexts = 16;
+
+Vector<WebGLRenderingContext*>& WebGLRenderingContext::activeContexts()
+{
+    DEFINE_STATIC_LOCAL(Vector<WebGLRenderingContext*>, activeContexts, ());
+    return activeContexts;
+}
+
+Vector<WebGLRenderingContext*>& WebGLRenderingContext::forciblyEvictedContexts()
+{
+    DEFINE_STATIC_LOCAL(Vector<WebGLRenderingContext*>, forciblyEvictedContexts, ());
+    return forciblyEvictedContexts;
+}
+
+void WebGLRenderingContext::forciblyLoseOldestContext(const String& reason)
+{
+    if (activeContexts().size()) {
+        WebGLRenderingContext* oldestActiveContext = activeContexts().first();
+        activeContexts().remove(0);
+
+        oldestActiveContext->printWarningToConsole(reason);
+
+        // This will call deactivateContext once the context has actually been lost.
+        oldestActiveContext->forceLostContext(WebGLRenderingContext::SyntheticLostContext);
+    }
+}
+
+IntSize WebGLRenderingContext::oldestContextSize()
+{
+    IntSize size;
+
+    if (activeContexts().size()) {
+        WebGLRenderingContext* oldestActiveContext = activeContexts().first();
+        size.setWidth(oldestActiveContext->drawingBufferWidth());
+        size.setHeight(oldestActiveContext->drawingBufferHeight());
+    }
+
+    return size;
+}
+
+void WebGLRenderingContext::activateContext(WebGLRenderingContext* context)
+{
+    if (!activeContexts().contains(context))
+        activeContexts().append(context);
+
+    if (activeContexts().size() > maxGLActiveContexts)
+        forciblyLoseOldestContext("WARNING: Too many active WebGL contexts. Oldest context will be lost.");
+}
+
+void WebGLRenderingContext::deactivateContext(WebGLRenderingContext* context, bool addToEvictedList)
+{
+    size_t position = activeContexts().find(context);
+    if (position != WTF::notFound)
+        activeContexts().remove(position);
+
+    if (addToEvictedList && !forciblyEvictedContexts().contains(context))
+        forciblyEvictedContexts().append(context);
+}
+
+void WebGLRenderingContext::willDestroyContext(WebGLRenderingContext* context)
+{
+    size_t position = forciblyEvictedContexts().find(context);
+    if (position != WTF::notFound)
+        forciblyEvictedContexts().remove(position);
+
+    deactivateContext(context, false);
+
+    // Try to re-enable the oldest inactive contexts.
+    while(activeContexts().size() < maxGLActiveContexts && forciblyEvictedContexts().size()) {
+        WebGLRenderingContext* evictedContext = forciblyEvictedContexts().first();
+        if (!evictedContext->m_restoreAllowed) {
+            forciblyEvictedContexts().remove(0);
+            continue;
+        }
+
+        IntSize desiredSize = evictedContext->m_drawingBuffer->adjustSize(evictedContext->clampedCanvasSize());
+
+        // If there's room in the pixel budget for this context, restore it.
+        if (!desiredSize.isEmpty()) {
+            forciblyEvictedContexts().remove(0);
+            evictedContext->forceRestoreContext();
+            activeContexts().append(evictedContext);
+        }
+        break;
+    }
+}
+
+class WebGLRenderingContextEvictionManager : public ContextEvictionManager {
+public:
+    void forciblyLoseOldestContext(const String& reason) {
+        WebGLRenderingContext::forciblyLoseOldestContext(reason);
+    };
+    IntSize oldestContextSize() {
+        return WebGLRenderingContext::oldestContextSize();
+    };
+};
 
 namespace {
 
     class ScopedDrawingBufferBinder {
     public:
         ScopedDrawingBufferBinder(DrawingBuffer* drawingBuffer, WebGLFramebuffer* framebufferBinding)
             : m_drawingBuffer(drawingBuffer)
             , m_framebufferBinding(framebufferBinding)
         {
             // Commit DrawingBuffer if needed (e.g., for multisampling)
@@ skipping 370 matching lines @@
 {
     ASSERT(m_context);
     ScriptWrappable::init(this);
 
     m_contextGroup = WebGLContextGroup::create();
     m_contextGroup->addContext(this);
 
     m_maxViewportDims[0] = m_maxViewportDims[1] = 0;
     m_context->getIntegerv(GraphicsContext3D::MAX_VIEWPORT_DIMS, m_maxViewportDims);
 
+    RefPtr<WebGLRenderingContextEvictionManager> contextEvictionManager = adoptRef(new WebGLRenderingContextEvictionManager());
+
     // Create the DrawingBuffer and initialize the platform layer.
     DrawingBuffer::PreserveDrawingBuffer preserve = m_attributes.preserveDrawingBuffer ? DrawingBuffer::Preserve : DrawingBuffer::Discard;
-    m_drawingBuffer = DrawingBuffer::create(m_context.get(), clampedCanvasSize(), preserve);
+    m_drawingBuffer = DrawingBuffer::create(m_context.get(), clampedCanvasSize(), preserve, contextEvictionManager.release());
 
     if (!m_drawingBuffer->isZeroSized()) {
         m_drawingBuffer->bind();
         setupFlags();
         initializeNewContext();
     }
 }
 
 void WebGLRenderingContext::initializeNewContext()
 {
@@ skipping 66 matching lines @@
 
     IntSize canvasSize = clampedCanvasSize();
     m_drawingBuffer->reset(canvasSize);
 
     m_context->reshape(canvasSize.width(), canvasSize.height());
     m_context->viewport(0, 0, canvasSize.width(), canvasSize.height());
     m_context->scissor(0, 0, canvasSize.width(), canvasSize.height());
 
     m_context->setContextLostCallback(adoptPtr(new WebGLRenderingContextLostCallback(this)));
     m_context->setErrorMessageCallback(adoptPtr(new WebGLRenderingContextErrorMessageCallback(this)));
+
+    activateContext(this);
 }
 
 void WebGLRenderingContext::setupFlags()
 {
     ASSERT(m_context);
 
     Page* p = canvas()->document()->page();
     if (p)
         m_synthesizedErrorsToConsole = p->settings()->webGLErrorsToConsoleEnabled();
 
@@ skipping 40 matching lines @@
       m_textureUnits[i].m_texture2DBinding = 0;
       m_textureUnits[i].m_textureCubeMapBinding = 0;
     }
 
     m_blackTexture2D = 0;
     m_blackTextureCubeMap = 0;
 
     detachAndRemoveAllObjects();
     destroyGraphicsContext3D();
     m_contextGroup->removeContext(this);
+
+    willDestroyContext(this);
 }
 
 void WebGLRenderingContext::destroyGraphicsContext3D()
 {
     // The drawing buffer holds a context reference. It must also be destroyed
     // in order for the context to be released.
     m_drawingBuffer.clear();
 
     if (m_context) {
         m_context->setContextLostCallback(nullptr);
@@ skipping 5098 matching lines @@
         m_context->vertexAttribPointer(0, state.size, state.type, state.normalized, state.originalStride, state.offset);
     }
     m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, objectOrZero(m_boundArrayBuffer.get()));
 }
 
 void WebGLRenderingContext::dispatchContextLostEvent(Timer<WebGLRenderingContext>*)
 {
     RefPtr<WebGLContextEvent> event = WebGLContextEvent::create(eventNames().webglcontextlostEvent, false, true, "");
     canvas()->dispatchEvent(event);
     m_restoreAllowed = event->defaultPrevented();
+    deactivateContext(this, m_contextLostMode != RealLostContext && m_restoreAllowed);
     if (m_contextLostMode == RealLostContext && m_restoreAllowed)
         m_restoreTimer.startOneShot(0);
 }
 
 void WebGLRenderingContext::maybeRestoreContext(Timer<WebGLRenderingContext>*)
 {
     ASSERT(m_contextLost);
     if (!m_contextLost)
         return;
 
@@ skipping 56 matching lines @@
     RefPtr<GraphicsContext3D> context(GraphicsContext3D::create(m_attributes, hostWindow));
     if (!context) {
         if (m_contextLostMode == RealLostContext)
             m_restoreTimer.startOneShot(secondsBetweenRestoreAttempts);
         else
             // This likely shouldn't happen but is the best way to report it to the WebGL app.
             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "", "error restoring context");
         return;
     }
 
+    RefPtr<WebGLRenderingContextEvictionManager> contextEvictionManager = adoptRef(new WebGLRenderingContextEvictionManager());
+
     // Construct a new drawing buffer with the new GraphicsContext3D.
     m_drawingBuffer->clear();
     DrawingBuffer::PreserveDrawingBuffer preserve = m_attributes.preserveDrawingBuffer ? DrawingBuffer::Preserve : DrawingBuffer::Discard;
-    m_drawingBuffer = DrawingBuffer::create(context.get(), clampedCanvasSize(), preserve);
+    m_drawingBuffer = DrawingBuffer::create(context.get(), clampedCanvasSize(), preserve, contextEvictionManager.release());
 
     if (m_drawingBuffer->isZeroSized())
         return;
 
     m_drawingBuffer->bind();
 
     m_context = context;
     m_contextLost = false;
     setupFlags();
     initializeNewContext();
@@ skipping 154 matching lines @@
 bool WebGLRenderingContext::supportsDrawBuffers()
 {
     if (!m_drawBuffersWebGLRequirementsChecked) {
         m_drawBuffersWebGLRequirementsChecked = true;
         m_drawBuffersSupported = EXTDrawBuffers::supported(this);
     }
     return m_drawBuffersSupported;
 }
 
 } // namespace WebCore