Adding Blink bindings for WebGL 2

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 2448 matching lines @@
         return WebGLAny(scriptState, m_unpackPremultiplyAlpha);
     case GC3D_UNPACK_COLORSPACE_CONVERSION_WEBGL:
         return WebGLAny(scriptState, m_unpackColorspaceConversion);
     case GL_VENDOR:
         return WebGLAny(scriptState, String("WebKit"));
     case GL_VERSION:
         return WebGLAny(scriptState, "WebGL 1.0 (" + String(webContext()->getString(GL_VERSION)) + ")");
     case GL_VIEWPORT:
         return getWebGLIntArrayParameter(scriptState, pname);
     case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES: // OES_standard_derivatives
-        if (extensionEnabled(OESStandardDerivativesName))
+        if (extensionEnabled(OESStandardDerivativesName) || version() > 1)

[Ken Russell (switch to Gerrit), 2015/02/03 01:23:25]

Could you add a private isVersion2OrHigher() helper just to make searching for
all these instances easier? I have a feeling we may need to revisit the call
sites at least for those extensions which affect the behavior of the shader
compiler.

             return getUnsignedIntParameter(scriptState, GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES);
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, OES_standard_derivatives not enabled");
         return ScriptValue::createNull(scriptState);
     case WebGLDebugRendererInfo::UNMASKED_RENDERER_WEBGL:
         if (extensionEnabled(WebGLDebugRendererInfoName))
             return WebGLAny(scriptState, webContext()->getString(GL_RENDERER));
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");
         return ScriptValue::createNull(scriptState);
     case WebGLDebugRendererInfo::UNMASKED_VENDOR_WEBGL:
         if (extensionEnabled(WebGLDebugRendererInfoName))
             return WebGLAny(scriptState, webContext()->getString(GL_VENDOR));
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");
         return ScriptValue::createNull(scriptState);
     case GL_VERTEX_ARRAY_BINDING_OES: // OES_vertex_array_object
-        if (extensionEnabled(OESVertexArrayObjectName)) {
+        if (extensionEnabled(OESVertexArrayObjectName) || version() > 1) {
             if (!m_boundVertexArrayObject->isDefaultObject())
                 return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_boundVertexArrayObject.get()));
             return ScriptValue::createNull(scriptState);
         }
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, OES_vertex_array_object not enabled");
         return ScriptValue::createNull(scriptState);
     case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic
-        if (extensionEnabled(EXTTextureFilterAnisotropicName))
+        if (extensionEnabled(EXTTextureFilterAnisotropicName) || version() > 1)
             return getUnsignedIntParameter(scriptState, GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT);
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, EXT_texture_filter_anisotropic not enabled");
         return ScriptValue::createNull(scriptState);
     case GL_MAX_COLOR_ATTACHMENTS_EXT: // EXT_draw_buffers BEGIN
-        if (extensionEnabled(WebGLDrawBuffersName))
+        if (extensionEnabled(WebGLDrawBuffersName) || version() > 1)
             return WebGLAny(scriptState, maxColorAttachments());
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_draw_buffers not enabled");
         return ScriptValue::createNull(scriptState);
     case GL_MAX_DRAW_BUFFERS_EXT:
-        if (extensionEnabled(WebGLDrawBuffersName))
+        if (extensionEnabled(WebGLDrawBuffersName) || version() > 1)
             return WebGLAny(scriptState, maxDrawBuffers());
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_draw_buffers not enabled");
         return ScriptValue::createNull(scriptState);
     default:
-        if (extensionEnabled(WebGLDrawBuffersName)
+        if ((extensionEnabled(WebGLDrawBuffersName) || version() > 1)
             && pname >= GL_DRAW_BUFFER0_EXT
             && pname < static_cast<GLenum>(GL_DRAW_BUFFER0_EXT + maxDrawBuffers())) {
             GLint value = GL_NONE;
             if (m_framebufferBinding)
                 value = m_framebufferBinding->getDrawBuffer(pname);
             else // emulated backbuffer
                 value = m_backDrawBuffer;
             return WebGLAny(scriptState, value);
         }
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name");
@@ skipping 171 matching lines @@
     case GL_TEXTURE_MAG_FILTER:
     case GL_TEXTURE_MIN_FILTER:
     case GL_TEXTURE_WRAP_S:
     case GL_TEXTURE_WRAP_T:
         {
             GLint value = 0;
             webContext()->getTexParameteriv(target, pname, &value);
             return WebGLAny(scriptState, static_cast<unsigned>(value));
         }
     case GL_TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic
-        if (extensionEnabled(EXTTextureFilterAnisotropicName)) {
+        if (extensionEnabled(EXTTextureFilterAnisotropicName) || version() > 1) {
             GLfloat value = 0.f;
             webContext()->getTexParameterfv(target, pname, &value);
             return WebGLAny(scriptState, value);
         }
         synthesizeGLError(GL_INVALID_ENUM, "getTexParameter", "invalid parameter name, EXT_texture_filter_anisotropic not enabled");
         return ScriptValue::createNull(scriptState);
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getTexParameter", "invalid parameter name");
         return ScriptValue::createNull(scriptState);
     }
@@ skipping 167 matching lines @@
 ScriptValue WebGLRenderingContextBase::getVertexAttrib(ScriptState* scriptState, GLuint index, GLenum pname)
 {
     if (isContextLost())
         return ScriptValue::createNull(scriptState);
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "getVertexAttrib", "index out of range");
         return ScriptValue::createNull(scriptState);
     }
     const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);
 
-    if (extensionEnabled(ANGLEInstancedArraysName) && pname == GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE)
+    if ((extensionEnabled(ANGLEInstancedArraysName) || version() > 1)
+        && pname == GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE)
         return WebGLAny(scriptState, state.divisor);
 
     switch (pname) {
     case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
         if (!state.bufferBinding || !state.bufferBinding->object())
             return ScriptValue::createNull(scriptState);
         return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(state.bufferBinding.get()));
     case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
         return WebGLAny(scriptState, state.enabled);
     case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
@@ skipping 27 matching lines @@
 void WebGLRenderingContextBase::hint(GLenum target, GLenum mode)
 {
     if (isContextLost())
         return;
     bool isValid = false;
     switch (target) {
     case GL_GENERATE_MIPMAP_HINT:
         isValid = true;
         break;
     case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES: // OES_standard_derivatives
-        if (extensionEnabled(OESStandardDerivativesName))
+        if (extensionEnabled(OESStandardDerivativesName) || version() > 1)
             isValid = true;
         break;
     }
     if (!isValid) {
         synthesizeGLError(GL_INVALID_ENUM, "hint", "invalid target");
         return;
     }
     webContext()->hint(target, mode);
 }
 
@@ skipping 813 matching lines @@
         break;
     case GL_TEXTURE_WRAP_S:
     case GL_TEXTURE_WRAP_T:
         if ((isFloat && paramf != GL_CLAMP_TO_EDGE && paramf != GL_MIRRORED_REPEAT && paramf != GL_REPEAT)
             || (!isFloat && parami != GL_CLAMP_TO_EDGE && parami != GL_MIRRORED_REPEAT && parami != GL_REPEAT)) {
             synthesizeGLError(GL_INVALID_ENUM, "texParameter", "invalid parameter");
             return;
         }
         break;
     case GL_TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic
-        if (!extensionEnabled(EXTTextureFilterAnisotropicName)) {
+        if (!extensionEnabled(EXTTextureFilterAnisotropicName) || version() > 1) {
             synthesizeGLError(GL_INVALID_ENUM, "texParameter", "invalid parameter, EXT_texture_filter_anisotropic not enabled");
             return;
         }
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "texParameter", "invalid parameter name");
         return;
     }
     if (isFloat) {
         tex->setParameterf(pname, paramf);
@@ skipping 820 matching lines @@
     default:
         notImplemented();
     }
     return WebGLAny(scriptState, DOMInt32Array::create(value, length));
 }
 
 void WebGLRenderingContextBase::handleTextureCompleteness(const char* functionName, bool prepareToDraw)
 {
     // All calling functions check isContextLost, so a duplicate check is not needed here.
     bool resetActiveUnit = false;
-    WebGLTexture::TextureExtensionFlag flag = static_cast<WebGLTexture::TextureExtensionFlag>((extensionEnabled(OESTextureFloatLinearName) ? WebGLTexture::TextureFloatLinearExtensionEnabled : 0)
-        | (extensionEnabled(OESTextureHalfFloatLinearName) ? WebGLTexture::TextureHalfFloatLinearExtensionEnabled : 0));
+    WebGLTexture::TextureExtensionFlag flag = static_cast<WebGLTexture::TextureExtensionFlag>(((extensionEnabled(OESTextureFloatLinearName) || version() > 1) ? WebGLTexture::TextureFloatLinearExtensionEnabled : 0)
+        | ((extensionEnabled(OESTextureHalfFloatLinearName) || version() > 1) ? WebGLTexture::TextureHalfFloatLinearExtensionEnabled : 0));
     for (unsigned ii = 0; ii < m_onePlusMaxNonDefaultTextureUnit; ++ii) {
         if ((m_textureUnits[ii].m_texture2DBinding.get() && m_textureUnits[ii].m_texture2DBinding->needToUseBlackTexture(flag))
             || (m_textureUnits[ii].m_textureCubeMapBinding.get() && m_textureUnits[ii].m_textureCubeMapBinding->needToUseBlackTexture(flag))) {
             if (ii != m_activeTextureUnit) {
                 webContext()->activeTexture(GL_TEXTURE0 + ii);
                 resetActiveUnit = true;
             } else if (resetActiveUnit) {
                 webContext()->activeTexture(GL_TEXTURE0 + ii);
                 resetActiveUnit = false;
             }
@@ skipping 131 matching lines @@
 {
     switch (format) {
     case GL_ALPHA:
     case GL_LUMINANCE:
     case GL_LUMINANCE_ALPHA:
     case GL_RGB:
     case GL_RGBA:
         break;
     case GL_DEPTH_STENCIL_OES:
     case GL_DEPTH_COMPONENT:
-        if (extensionEnabled(WebGLDepthTextureName))
+        if (extensionEnabled(WebGLDepthTextureName) || version() > 1)
             break;
         synthesizeGLError(GL_INVALID_ENUM, functionName, "depth texture formats not enabled");
         return false;
     case GL_SRGB_EXT:
     case GL_SRGB_ALPHA_EXT:
         if (extensionEnabled(EXTsRGBName))
             break;
         synthesizeGLError(GL_INVALID_ENUM, functionName, "sRGB texture formats not enabled");
         return false;
     default:
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid texture format");
         return false;
     }
 
     switch (type) {
     case GL_UNSIGNED_BYTE:
     case GL_UNSIGNED_SHORT_5_6_5:
     case GL_UNSIGNED_SHORT_4_4_4_4:
     case GL_UNSIGNED_SHORT_5_5_5_1:
         break;
     case GL_FLOAT:
-        if (extensionEnabled(OESTextureFloatName))
+        if (extensionEnabled(OESTextureFloatName) || version() > 1)
             break;
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid texture type");
         return false;
     case GL_HALF_FLOAT_OES:
-        if (extensionEnabled(OESTextureHalfFloatName))
+        if (extensionEnabled(OESTextureHalfFloatName) || version() > 1)
             break;
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid texture type");
         return false;
     case GL_UNSIGNED_INT:
     case GL_UNSIGNED_INT_24_8_OES:
     case GL_UNSIGNED_SHORT:
-        if (extensionEnabled(WebGLDepthTextureName))
+        if (extensionEnabled(WebGLDepthTextureName) || version() > 1)
             break;
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid texture type");
         return false;
     default:
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid texture type");
         return false;
     }
 
     // Verify that the combination of format and type is supported.
     switch (format) {
@@ skipping 474 matching lines @@
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid target");
         return false;
     }
     switch (attachment) {
     case GL_COLOR_ATTACHMENT0:
     case GL_DEPTH_ATTACHMENT:
     case GL_STENCIL_ATTACHMENT:
     case GC3D_DEPTH_STENCIL_ATTACHMENT_WEBGL:
         break;
     default:
-        if (extensionEnabled(WebGLDrawBuffersName)
+        if ((extensionEnabled(WebGLDrawBuffersName) || version() > 1)
             && attachment > GL_COLOR_ATTACHMENT0
             && attachment < static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + maxColorAttachments()))
             break;
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid attachment");
         return false;
     }
     return true;
 }
 
 bool WebGLRenderingContextBase::validateBlendEquation(const char* functionName, GLenum mode)
@@ skipping 205 matching lines @@
         return false;
 
     if (!validateStencilSettings(functionName))
         return false;
 
     switch (type) {
     case GL_UNSIGNED_BYTE:
     case GL_UNSIGNED_SHORT:
         break;
     case GL_UNSIGNED_INT:
-        if (extensionEnabled(OESElementIndexUintName))
+        if (extensionEnabled(OESElementIndexUintName) || version() > 1)
             break;
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid type");
         return false;
     default:
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid type");
         return false;
     }
 
     if (count < 0) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "count < 0");
@@ skipping 315 matching lines @@
 }
 
 IntSize WebGLRenderingContextBase::clampedCanvasSize()
 {
     return IntSize(clamp(canvas()->width(), 1, m_maxViewportDims[0]),
                    clamp(canvas()->height(), 1, m_maxViewportDims[1]));
 }
 
 GLint WebGLRenderingContextBase::maxDrawBuffers()
 {
-    if (isContextLost() || !extensionEnabled(WebGLDrawBuffersName))
+    if (isContextLost() || !(extensionEnabled(WebGLDrawBuffersName) || version() > 1))
         return 0;
     if (!m_maxDrawBuffers)
         webContext()->getIntegerv(GL_MAX_DRAW_BUFFERS_EXT, &m_maxDrawBuffers);
     if (!m_maxColorAttachments)
         webContext()->getIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &m_maxColorAttachments);
     // WEBGL_draw_buffers requires MAX_COLOR_ATTACHMENTS >= MAX_DRAW_BUFFERS.
     return std::min(m_maxDrawBuffers, m_maxColorAttachments);
 }
 
 GLint WebGLRenderingContextBase::maxColorAttachments()
 {
-    if (isContextLost() || !extensionEnabled(WebGLDrawBuffersName))
+    if (isContextLost() || !(extensionEnabled(WebGLDrawBuffersName) || version() > 1))
         return 0;
     if (!m_maxColorAttachments)
         webContext()->getIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &m_maxColorAttachments);
     return m_maxColorAttachments;
 }
 
 void WebGLRenderingContextBase::setBackDrawBuffer(GLenum buf)
 {
     m_backDrawBuffer = buf;
 }
@@ skipping 97 matching lines @@
     return m_sharedWebGraphicsContext3D ? m_sharedWebGraphicsContext3D->drawingBuffer() : 0;
 }
 #else
 DrawingBuffer* WebGLRenderingContextBase::drawingBuffer() const
 {
     return m_drawingBuffer.get();
 }
 #endif
 
 } // namespace blink