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

Source/WebCore/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/Uint16Array.h>
 #include <wtf/Uint32Array.h>
 #include <wtf/text/StringBuilder.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::inactiveContexts()
+{
+    DEFINE_STATIC_LOCAL(Vector<WebGLRenderingContext*>, inactiveContexts, ());
+    return inactiveContexts;
+}
+
+void WebGLRenderingContext::forceLostOldestContext()
+{
+    if(activeContexts().size()) {

[Ken Russell (switch to Gerrit), 2013/04/16 02:57:52]

Add space between if and ( everywhere please.

+        WebGLRenderingContext* oldestActiveContext = activeContexts().first();
+        activeContexts().remove(0);

[Ken Russell (switch to Gerrit), 2013/04/16 02:57:52]

The implicit assumption here is that contexts' age equals creation order. It
would be better to sort them by actual use. I think that
cleanupAfterGraphicsCall can be used to (relatively cheaply) track which is the
most recently accessed context. Perhaps it can increment a static variable and
store the result inside the context. Then they can be properly ranked.

+
+        // This will call deactivateContext once the context has actually been lost
+        oldestActiveContext->forceLostContext(WebGLRenderingContext::SyntheticLostContext);
+    }
+}
+
+void WebGLRenderingContext::activateContext(WebGLRenderingContext* context)
+{
+    if(!activeContexts().contains(context))
+        activeContexts().append(context);
+
+    if(activeContexts().size() > maxGLActiveContexts)
+        forceLostOldestContext();
+}
+
+void WebGLRenderingContext::deactivateContext(WebGLRenderingContext* context, bool addToInactiveList)
+{
+    size_t position = activeContexts().find(context);
+    if(position != WTF::notFound)
+        activeContexts().remove(position);
+
+    if(addToInactiveList && !inactiveContexts().contains(context))
+        inactiveContexts().append(context);
+}
+
+void WebGLRenderingContext::removeContext(WebGLRenderingContext* context)
+{
+    size_t position = inactiveContexts().find(context);
+    if(position != WTF::notFound)
+        inactiveContexts().remove(position);
+
+    deactivateContext(context, false);
+
+    // Try to re-enable the oldest inactive contexts
+    while(activeContexts().size() < maxGLActiveContexts && inactiveContexts().size() > 0) {
+        WebGLRenderingContext* oldestInactiveContext = inactiveContexts().first();
+        inactiveContexts().remove(0);
+
+        if(oldestInactiveContext->m_restoreAllowed) {

[Ken Russell (switch to Gerrit), 2013/04/16 02:57:52]

If restoration isn't allowed, we lose track of oldestInactiveContext. Maybe this
is OK because the intent is that contexts with m_restoreAllowed == false never
show up in the inactive context list anyway? Is that a strong enough guarantee
that an assert is desired?

+            oldestInactiveContext->forceRestoreContext();
+            activeContexts().append(oldestInactiveContext);
+        }
+    }
+}
 
 namespace {
 
     class ScopedDrawingBufferBinder {
     public:
         ScopedDrawingBufferBinder(DrawingBuffer* drawingBuffer, WebGLFramebuffer* framebufferBinding)
             : m_drawingBuffer(drawingBuffer)
             , m_framebufferBinding(framebufferBinding)
         {
             // Commit DrawingBuffer if needed (e.g., for multisampling)
@@ skipping 303 matching lines @@
 };
 
 PassOwnPtr<WebGLRenderingContext> WebGLRenderingContext::create(HTMLCanvasElement* canvas, WebGLContextAttributes* attrs)
 {
     Document* document = canvas->document();
     Frame* frame = document->frame();
     if (!frame)
         return nullptr;
     Settings* settings = frame->settings();
 
-    // The FrameLoaderClient might creation of a new WebGL context despite the page settings; in
+    // The FrameLoaderClient might block creation of a new WebGL context despite the page settings; in
     // particular, if WebGL contexts were lost one or more times via the GL_ARB_robustness extension.
     if (!frame->loader()->client()->allowWebGL(settings && settings->webGLEnabled())) {
         canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Web page was not allowed to create a WebGL context."));
         return nullptr;
     }
 
     HostWindow* hostWindow = document->view()->root()->hostWindow();
     GraphicsContext3D::Attributes attributes = attrs ? attrs->attributes() : GraphicsContext3D::Attributes();
 
     if (attributes.antialias) {
@@ skipping 137 matching lines @@
     IntSize canvasSize = clampedCanvasSize();
     if (m_drawingBuffer)
         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);
+
+    removeContext(this);
 }
 
 void WebGLRenderingContext::destroyGraphicsContext3D()
 {
     // The drawing buffer holds a context reference. It must also be destroyed
     // in order for the context to be released.
     if (m_drawingBuffer)
         m_drawingBuffer.clear();
 
     if (m_context) {
@@ skipping 3986 matching lines @@
                 frame->loader()->client()->didLoseWebGLContext(m_context->getExtensions()->getGraphicsResetStatusARB());
         }
     }
 
     detachAndRemoveAllObjects();
 
     if (m_drawingBuffer) {
         // Make absolutely sure we do not refer to an already-deleted texture or framebuffer.
         m_drawingBuffer->setTexture2DBinding(0);
         m_drawingBuffer->setFramebufferBinding(0);
+        m_drawingBuffer->clear();
     }
 
     // There is no direct way to clear errors from a GL implementation and
     // looping until getError() becomes NO_ERROR might cause an infinite loop if
     // the driver or context implementation had a bug. So, loop a reasonably
     // large number of times to clear any existing errors.
     for (int i = 0; i < 100; ++i) {
         if (m_context->getError() == GraphicsContext3D::NO_ERROR)
             break;
     }
@@ skipping 1143 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_restoreAllowed);

[Ken Russell (switch to Gerrit), 2013/04/16 02:57:52]

This doesn't seem right. If a context receives a RealLostContext, then it
shouldn't be added to the inactive list, should it? It's going to be reactivated
later via a different mechanism.

     if (m_contextLostMode == RealLostContext && m_restoreAllowed)
         m_restoreTimer.startOneShot(0);
 }
 
 void WebGLRenderingContext::maybeRestoreContext(Timer<WebGLRenderingContext>*)
 {
     ASSERT(m_contextLost);
     if (!m_contextLost)
         return;
 
@@ skipping 148 matching lines @@
 
 void WebGLRenderingContext::synthesizeGLError(GC3Denum error, const char* functionName, const char* description, ConsoleDisplayPreference display)
 {
     if (m_synthesizedErrorsToConsole && display == DisplayInConsole) {
       String str = String("WebGL: ") + GetErrorString(error) +  ": " + String(functionName) + ": " + String(description);
       printGLErrorToConsole(str);
     }
     m_context->synthesizeGLError(error);
 }
 
-
 void WebGLRenderingContext::printGLWarningToConsole(const char* functionName, const char* description)
 {
     if (m_synthesizedErrorsToConsole) {
         String str = String("WebGL: ") + String(functionName) + ": " + String(description);
         printGLErrorToConsole(str);
     }
 }
 
 void WebGLRenderingContext::applyStencilTest()
 {
@@ skipping 64 matching lines @@
 bool WebGLRenderingContext::supportsDrawBuffers()
 {
     if (!m_drawBuffersWebGLRequirementsChecked) {
         m_drawBuffersWebGLRequirementsChecked = true;
         m_drawBuffersSupported = EXTDrawBuffers::supported(this);
     }
     return m_drawBuffersSupported;
 }
 
 } // namespace WebCore