WebGL: Refactor active context management.

Source/core/html/canvas/WebGLRenderingContextBase.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 100 matching lines @@
         return;
 
     WebGLRenderingContextBase* candidate = activeContexts()[candidateID];
 
     // This context could belong to a dead page and the last JavaScript reference has already
     // been lost. Garbage collection might be triggered in the middle of this function, for
     // example, printWarningToConsole() causes an upcall to JavaScript.
     // Must make sure that the context is not deleted until the call stack unwinds.
     RefPtrWillBeRawPtr<WebGLRenderingContextBase> protect(candidate);
 
-    activeContexts().remove(candidateID);
-
     candidate->printWarningToConsole(reason);
     InspectorInstrumentation::didFireWebGLWarning(candidate->canvas());
 
     // This will call deactivateContext once the context has actually been lost.
     candidate->forceLostContext(WebGLRenderingContextBase::SyntheticLostContext);
 }
 
 size_t WebGLRenderingContextBase::oldestContextIndex()
 {
     if (!activeContexts().size())
         return maxGLActiveContexts;
 
     WebGLRenderingContextBase* candidate = activeContexts().first();
-    blink::WebGraphicsContext3D* candidateWGC3D = candidate->isContextLost() ? 0 : candidate->webContext();
+    ASSERT(!candidate->isContextLost());
     size_t candidateID = 0;
     for (size_t ii = 1; ii < activeContexts().size(); ++ii) {
         WebGLRenderingContextBase* context = activeContexts()[ii];
-        blink::WebGraphicsContext3D* contextWGC3D = context->isContextLost() ? 0 : context->webContext();
-        if (contextWGC3D && candidateWGC3D && contextWGC3D->lastFlushID() < candidateWGC3D->lastFlushID()) {
+        ASSERT(!context->isContextLost());
+        if (context->webContext()->lastFlushID() < candidate->webContext()->lastFlushID()) {
             candidate = context;
             candidateID = ii;
         }
     }
 
     return candidateID;
 }
 
 IntSize WebGLRenderingContextBase::oldestContextSize()
 {
@@ skipping 10 matching lines @@
 }
 
 void WebGLRenderingContextBase::activateContext(WebGLRenderingContextBase* context)
 {
     unsigned removedContexts = 0;
     while (activeContexts().size() >= maxGLActiveContexts && removedContexts < maxGLActiveContexts) {
         forciblyLoseOldestContext("WARNING: Too many active WebGL contexts. Oldest context will be lost.");
         removedContexts++;
     }
 
+    ASSERT(!context->isContextLost());
     if (!activeContexts().contains(context))
         activeContexts().append(context);
 }
 
-void WebGLRenderingContextBase::deactivateContext(WebGLRenderingContextBase* context, bool addToEvictedList)
+void WebGLRenderingContextBase::deactivateContext(WebGLRenderingContextBase* context)
 {
     size_t position = activeContexts().find(context);
     if (position != WTF::kNotFound)
         activeContexts().remove(position);
+}
 
-    if (addToEvictedList && !forciblyEvictedContexts().contains(context))
+void WebGLRenderingContextBase::addToEvictedList(WebGLRenderingContextBase* context)
+{
+    ASSERT(context->m_restoreAllowed);
+    if (!forciblyEvictedContexts().contains(context))
         forciblyEvictedContexts().append(context);
 }
 
 void WebGLRenderingContextBase::willDestroyContext(WebGLRenderingContextBase* context)
 {
     size_t position = forciblyEvictedContexts().find(context);
     if (position != WTF::kNotFound)
         forciblyEvictedContexts().remove(position);
 
-    deactivateContext(context, false);
+    deactivateContext(context);
 
     // Try to re-enable the oldest inactive contexts.
     while(activeContexts().size() < maxGLActiveContexts && forciblyEvictedContexts().size()) {
         WebGLRenderingContextBase* evictedContext = forciblyEvictedContexts().first();
-        if (!evictedContext->m_restoreAllowed) {
-            forciblyEvictedContexts().remove(0);
-            continue;
-        }
-
+        ASSERT(evictedContext->m_restoreAllowed);
         IntSize desiredSize = DrawingBuffer::adjustSize(evictedContext->clampedCanvasSize(), IntSize(), evictedContext->m_maxTextureSize);
 
         // 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) {
         WebGLRenderingContextBase::forciblyLoseOldestContext(reason);
     };
@@ skipping 4002 matching lines @@
 
     if (mode != RealLostContext)
         destroyContext();
 
     ConsoleDisplayPreference display = (mode == RealLostContext) ? DisplayInConsole: DontDisplayInConsole;
     synthesizeGLError(GC3D_CONTEXT_LOST_WEBGL, "loseContext", "context lost", display);
 
     // Don't allow restoration unless the context lost event has both been
     // dispatched and its default behavior prevented.
     m_restoreAllowed = false;
+    deactivateContext(this);
 
     // Always defer the dispatch of the context lost event, to implement
     // the spec behavior of queueing a task.
     m_dispatchContextLostEventTimer.startOneShot(0, FROM_HERE);
 }
 
 void WebGLRenderingContextBase::forceRestoreContext()
 {
     if (!isContextLost()) {
         synthesizeGLError(GL_INVALID_OPERATION, "restoreContext", "context not lost");
@@ skipping 1196 matching lines @@
     attribValue.initValue();
     for (int ii = 0; ii < expectedSize; ++ii)
         attribValue.value[ii] = v[ii];
 }
 
 void WebGLRenderingContextBase::dispatchContextLostEvent(Timer<WebGLRenderingContextBase>*)
 {
     RefPtrWillBeRawPtr<WebGLContextEvent> event = WebGLContextEvent::create(EventTypeNames::webglcontextlost, false, true, "");
     canvas()->dispatchEvent(event);
     m_restoreAllowed = event->defaultPrevented();
-    deactivateContext(this, m_contextLostMode != RealLostContext && m_restoreAllowed);
-    if ((m_contextLostMode == RealLostContext || m_contextLostMode == AutoRecoverSyntheticLostContext) && m_restoreAllowed)
-        m_restoreTimer.startOneShot(0, FROM_HERE);
+    if (m_restoreAllowed) {
+        if ((m_contextLostMode == RealLostContext || m_contextLostMode == AutoRecoverSyntheticLostContext)) {
+            m_restoreTimer.startOneShot(0, FROM_HERE);
+        } else {
+            addToEvictedList(this);
+        }
+    }
 }
 
 void WebGLRenderingContextBase::maybeRestoreContext(Timer<WebGLRenderingContextBase>*)
 {
     ASSERT(isContextLost());
 
     // The rendering context is not restored unless the default behavior of the
     // webglcontextlost event was prevented earlier.
     //
     // Because of the way m_restoreTimer is set up for real vs. synthetic lost
@@ skipping 234 matching lines @@
         if (m_textureUnits[i].m_texture2DBinding
             || m_textureUnits[i].m_textureCubeMapBinding) {
             m_onePlusMaxNonDefaultTextureUnit = i + 1;
             return;
         }
     }
     m_onePlusMaxNonDefaultTextureUnit = 0;
 }
 
 } // namespace WebCore