Lose/restore WebGL contexts if multisampling blackist status changes at runtime.

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 432 matching lines @@
                 advance();
                 break;
             }
 
             // Swallow all other characters. Unclear whether we may
             // want or need to just emit a space per character to try
             // to preserve column numbers for debugging purposes.
             break;
         }
     }
+
+    GraphicsContext3D::Attributes adjustAttributes(const GraphicsContext3D::Attributes attributes, Settings* settings)
+    {
+        GraphicsContext3D::Attributes adjustedAttributes = attributes;
+        if (adjustedAttributes.antialias) {
+            if (settings && !settings->openGLMultisamplingEnabled())
+                adjustedAttributes.antialias = false;
+        }
+
+        return adjustedAttributes;
+    }
 } // namespace anonymous
 
 class WebGLRenderingContextLostCallback : public GraphicsContext3D::ContextLostCallback {
     WTF_MAKE_FAST_ALLOCATED;
 public:
     explicit WebGLRenderingContextLostCallback(WebGLRenderingContext* cb) : m_context(cb) { }
     virtual void onContextLost() { m_context->forceLostContext(WebGLRenderingContext::RealLostContext); }
     virtual ~WebGLRenderingContextLostCallback() {}
 private:
     WebGLRenderingContext* m_context;
@@ skipping 21 matching lines @@
         return nullptr;
     Settings* settings = frame->settings();
 
     // 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;
     }
 
-    GraphicsContext3D::Attributes attributes = attrs ? attrs->attributes() : GraphicsContext3D::Attributes();
-
-    if (attributes.antialias) {
-        if (settings && !settings->openGLMultisamplingEnabled())
-            attributes.antialias = false;
-    }
-
-    attributes.noExtensions = true;
-    attributes.shareResources = true;
-    attributes.preferDiscreteGPU = true;
-    attributes.topDocumentURL = document->topDocument()->url();
+    GraphicsContext3D::Attributes requestedAttributes = attrs ? attrs->attributes() : GraphicsContext3D::Attributes();
+    GraphicsContext3D::Attributes attributes = adjustAttributes(requestedAttributes, settings);
 
     RefPtr<GraphicsContext3D> context(GraphicsContext3D::create(attributes));
 
     if (!context || !context->makeContextCurrent()) {
         canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Could not create a WebGL context."));
         return nullptr;
     }
 
     Extensions3D* extensions = context->getExtensions();
     if (extensions->supports("GL_EXT_debug_marker"))
         extensions->pushGroupMarkerEXT("WebGLRenderingContext");
 
-    OwnPtr<WebGLRenderingContext> renderingContext = adoptPtr(new WebGLRenderingContext(canvas, context, attributes));
+    OwnPtr<WebGLRenderingContext> renderingContext = adoptPtr(new WebGLRenderingContext(canvas, context, attributes, requestedAttributes));
     renderingContext->suspendIfNeeded();
 
     if (renderingContext->m_drawingBuffer->isZeroSized()) {
         canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Could not create a WebGL context."));
         return nullptr;
     }
 
     return renderingContext.release();
 }
 
-WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, PassRefPtr<GraphicsContext3D> context,
-                                             GraphicsContext3D::Attributes attributes)
+WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, PassRefPtr<GraphicsContext3D> context, GraphicsContext3D::Attributes attributes, GraphicsContext3D::Attributes requestedAttributes)
     : CanvasRenderingContext(passedCanvas)
     , ActiveDOMObject(passedCanvas->document())
     , m_context(context)
     , m_drawingBuffer(0)
     , m_dispatchContextLostEventTimer(this, &WebGLRenderingContext::dispatchContextLostEvent)
     , m_restoreAllowed(false)
     , m_restoreTimer(this, &WebGLRenderingContext::maybeRestoreContext)
     , m_videoCache(4)
     , m_contextLost(false)
     , m_contextLostMode(SyntheticLostContext)
     , m_attributes(attributes)
+    , m_requestedAttributes(requestedAttributes)
     , m_synthesizedErrorsToConsole(true)
     , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)
+    , m_multisamplingAllowed(false)
+    , m_multisamplingObserverHost(0)
 {
     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);
 
@@ skipping 85 matching lines @@
     m_context->setErrorMessageCallback(adoptPtr(new WebGLRenderingContextErrorMessageCallback(this)));
 
     activateContext(this);
 }
 
 void WebGLRenderingContext::setupFlags()
 {
     ASSERT(m_context);
 
     Page* p = canvas()->document()->page();
-    if (p)
+    if (p) {
         m_synthesizedErrorsToConsole = p->settings()->webGLErrorsToConsoleEnabled();
 
+        if (!m_multisamplingObserverHost && m_requestedAttributes.antialias) {
+            m_multisamplingAllowed = m_drawingBuffer->multisample();
+            m_multisamplingObserverHost = p;

[Ken Russell (switch to Gerrit), 2013/05/09 00:17:13]

Is it necessary to cache the Page like this? Would it work to make the same
chain of calls in the destructor, or is it too late (is the Page no longer
referenceable)?

+            m_multisamplingObserverHost->addMultisamplingChangedObserver(this);
+        }
+    }
+
     m_isGLES2NPOTStrict = !m_context->getExtensions()->isEnabled("GL_OES_texture_npot");
     m_isDepthStencilSupported = m_context->getExtensions()->isEnabled("GL_OES_packed_depth_stencil");
     m_isRobustnessEXTSupported = m_context->getExtensions()->isEnabled("GL_EXT_robustness");
 }
 
 bool WebGLRenderingContext::allowPrivilegedExtensions() const
 {
     Page* p = canvas()->document()->page();
     if (p && p->settings())
         return p->settings()->privilegedWebGLExtensionsEnabled();
@@ skipping 23 matching lines @@
       m_textureUnits[i].m_textureCubeMapBinding = 0;
     }
 
     m_blackTexture2D = 0;
     m_blackTextureCubeMap = 0;
 
     detachAndRemoveAllObjects();
     destroyGraphicsContext3D();
     m_contextGroup->removeContext(this);
 
+    if (m_multisamplingObserverHost)
+        m_multisamplingObserverHost->removeMultisamplingChangedObserver(this);
+
     willDestroyContext(this);
 }
 
 void WebGLRenderingContext::destroyGraphicsContext3D()
 {
     m_contextLost = true;
 
     // The drawing buffer holds a context reference. It must also be destroyed
     // in order for the context to be released.
     m_drawingBuffer->releaseResources();
@@ skipping 4522 matching lines @@
     for (int ii = 0; ii < expectedSize; ++ii)
         attribValue.value[ii] = v[ii];
 }
 
 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)
+    if ((m_contextLostMode == RealLostContext || m_contextLostMode == AutoRecoverSyntheticLostContext) && m_restoreAllowed)
         m_restoreTimer.startOneShot(0);
 }
 
 void WebGLRenderingContext::maybeRestoreContext(Timer<WebGLRenderingContext>*)
 {
     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
     // context events, we don't have to worry about this test short-circuiting
     // the retry loop for real context lost events.
     if (!m_restoreAllowed)
         return;
 
     Document* document = canvas()->document();
     if (!document)
         return;
     Frame* frame = document->frame();
     if (!frame)
         return;
 
-    if (!frame->loader()->client()->allowWebGL(frame->settings() && frame->settings()->webGLEnabled()))
+    Settings* settings = frame->settings();
+
+    if (!frame->loader()->client()->allowWebGL(settings && settings->webGLEnabled()))
         return;
 
+    // Reset the context attributes back to the requested attributes and re-apply restrictions
+    m_attributes = adjustAttributes(m_requestedAttributes, settings);
+
     RefPtr<GraphicsContext3D> context(GraphicsContext3D::create(m_attributes));
+
     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());
@@ skipping 169 matching lines @@
     ExceptionCode ec;
     bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_framebufferBinding.get(), ec);
 }
 
 void WebGLRenderingContext::restoreCurrentTexture2D()
 {
     ExceptionCode ec;
     bindTexture(GraphicsContext3D::TEXTURE_2D, m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get(), ec);
 }
 
+void WebGLRenderingContext::multisamplingChanged(bool enabled)
+{
+    if (m_multisamplingAllowed != enabled) {
+        m_multisamplingAllowed = enabled;
+        forceLostContext(WebGLRenderingContext::AutoRecoverSyntheticLostContext);
+    }
+}
+
 } // namespace WebCore