Expose WEBGL_debug_renderer_info through a chromium finch experiment.

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 606 matching lines @@
     registerExtension<WebGLCompressedTexturePVRTC>(m_webglCompressedTexturePVRTC, PrefixedExtension, webkitPrefix);
     registerExtension<WebGLCompressedTextureS3TC>(m_webglCompressedTextureS3TC, PrefixedExtension, bothPrefixes);
     registerExtension<WebGLDepthTexture>(m_webglDepthTexture, PrefixedExtension, bothPrefixes);
     registerExtension<WebGLLoseContext>(m_webglLoseContext, ApprovedExtension, bothPrefixes);
 
     // Register draft extensions.
     registerExtension<EXTFragDepth>(m_extFragDepth, DraftExtension);
     registerExtension<WebGLDrawBuffers>(m_webglDrawBuffers, DraftExtension);
 
     // Register privileged extensions.
-    registerExtension<WebGLDebugRendererInfo>(m_webglDebugRendererInfo, PrivilegedExtension);
+    registerExtension<WebGLDebugRendererInfo>(m_webglDebugRendererInfo, WebGLDebugRendererInfoExtension);

[Ken Russell (switch to Gerrit), 2013/10/29 23:00:17]

Would it work to use the argument (PrivilegedExtension |
WebGLDebugRendererInfoExtension) here? That might avoid the special-case test of
allowPrivilegedExtensions() in
WebGLRenderingContext::allowWebGLDebugRendererInfo below.

[Zhenyao Mo, 2013/10/29 23:05:52]

That's what I did in the first try, but it will complicate the logic, because it
will fail the test of allowPrivilegedExtensions() in general (unless it's
privileged code) and not be exposed.

     registerExtension<WebGLDebugShaders>(m_webglDebugShaders, PrivilegedExtension);
 }
 
 void WebGLRenderingContext::initializeNewContext()
 {
     ASSERT(!isContextLost());
     m_needsUpdate = true;
     m_markedCanvasDirty = false;
     m_activeTextureUnit = 0;
     m_packAlignment = 4;
@@ skipping 83 matching lines @@
     m_isDepthStencilSupported = m_context->extensions()->isEnabled("GL_OES_packed_depth_stencil");
 }
 
 bool WebGLRenderingContext::allowPrivilegedExtensions() const
 {
     if (Page* p = canvas()->document().page())
         return p->settings().privilegedWebGLExtensionsEnabled();
     return false;
 }
 
+bool WebGLRenderingContext::allowWebGLDebugRendererInfo() const
+{
+    if (allowPrivilegedExtensions())
+        return true;
+    Frame* frame = canvas()->document().frame();
+    return frame && frame->loader().client()->allowWebGLDebugRendererInfo();
+}
+
 void WebGLRenderingContext::addCompressedTextureFormat(GC3Denum format)
 {
     if (!m_compressedTextureFormats.contains(format))
         m_compressedTextureFormats.append(format);
 }
 
 void WebGLRenderingContext::removeAllCompressedTextureFormats()
 {
     m_compressedTextureFormats.clear();
 }
@@ skipping 1429 matching lines @@
 }
 
 PassRefPtr<WebGLExtension> WebGLRenderingContext::getExtension(const String& name)
 {
     if (isContextLost())
         return 0;
 
     for (size_t i = 0; i < m_extensions.size(); ++i) {
         ExtensionTracker* tracker = m_extensions[i];
         if (tracker->matchesNameWithPrefixes(name)) {
+            if (tracker->webglDebugRendererInfo() && !allowWebGLDebugRendererInfo())
+                return 0;
             if (tracker->privileged() && !allowPrivilegedExtensions())
                 return 0;
             if (tracker->draft() && !RuntimeEnabledFeatures::webGLDraftExtensionsEnabled())
                 return 0;
             if (!tracker->supported(this))
                 return 0;
             return tracker->getExtension(this);
         }
     }
 
@@ skipping 433 matching lines @@
 }
 
 Vector<String> WebGLRenderingContext::getSupportedExtensions()
 {
     Vector<String> result;
     if (isContextLost())
         return result;
 
     for (size_t i = 0; i < m_extensions.size(); ++i) {
         ExtensionTracker* tracker = m_extensions[i];
+        if (tracker->webglDebugRendererInfo() && !allowWebGLDebugRendererInfo())
+            continue;
         if (tracker->privileged() && !allowPrivilegedExtensions())
             continue;
         if (tracker->draft() && !RuntimeEnabledFeatures::webGLDraftExtensionsEnabled())
             continue;
         if (tracker->supported(this))
             result.append(String(tracker->prefixed()  ? "WEBKIT_" : "") + tracker->extensionName());
     }
 
     return result;
 }
@@ skipping 2972 matching lines @@
         if (m_textureUnits[i].m_texture2DBinding
             || m_textureUnits[i].m_textureCubeMapBinding) {
             m_onePlusMaxNonDefaultTextureUnit = i + 1;
             return;
         }
     }
     m_onePlusMaxNonDefaultTextureUnit = 0;
 }
 
 } // namespace WebCore