Remove transform feedback validation in Blink

third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/webgl/WebGL2RenderingContextBase.h"
 
 #include "bindings/modules/v8/WebGLAny.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
@@ skipping 1364 matching lines @@
 void WebGL2RenderingContextBase::drawElementsInstanced(GLenum mode, GLsizei count, GLenum type, long long offset, GLsizei instanceCount)
 {
     if (!validateDrawElements("drawElementsInstanced", type, offset))
         return;
 
     if (!m_boundVertexArrayObject->isAllEnabledAttribBufferBound()) {
         synthesizeGLError(GL_INVALID_OPERATION, "drawElementsInstanced", "no buffer is bound to enabled attribute");
         return;
     }
 
-    if (transformFeedbackActive() && !transformFeedbackPaused()) {
-        synthesizeGLError(GL_INVALID_OPERATION, "drawElementsInstanced", "transform feedback is active and not paused");
-        return;
-    }
-
     ScopedRGBEmulationColorMask emulationColorMask(contextGL(), m_colorMask, m_drawingBuffer.get());
     clearIfComposited();
     contextGL()->DrawElementsInstancedANGLE(mode, count, type, reinterpret_cast<void*>(static_cast<intptr_t>(offset)), instanceCount);
     markContextChanged(CanvasChanged);
 }
 
 void WebGL2RenderingContextBase::drawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, long long offset)
 {
     if (!validateDrawElements("drawRangeElements", type, offset))
         return;
 
     if (!m_boundVertexArrayObject->isAllEnabledAttribBufferBound()) {
         synthesizeGLError(GL_INVALID_OPERATION, "drawRangeElements", "no buffer is bound to enabled attribute");
         return;
     }
 
-    if (transformFeedbackActive() && !transformFeedbackPaused()) {
-        synthesizeGLError(GL_INVALID_OPERATION, "drawRangeElements", "transform feedback is active and not paused");
-        return;
-    }
-
     ScopedRGBEmulationColorMask emulationColorMask(contextGL(), m_colorMask, m_drawingBuffer.get());
     clearIfComposited();
     contextGL()->DrawRangeElements(mode, start, end, count, type, reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
     markContextChanged(CanvasChanged);
 }
 
 void WebGL2RenderingContextBase::drawBuffers(const Vector<GLenum>& buffers)
 {
     if (isContextLost())
         return;
@@ skipping 579 matching lines @@
 {
     if (isContextLost())
         return nullptr;
     WebGLTransformFeedback* o = WebGLTransformFeedback::create(this);
     addSharedObject(o);
     return o;
 }
 
 void WebGL2RenderingContextBase::deleteTransformFeedback(WebGLTransformFeedback* feedback)
 {
-    if (transformFeedbackActive()) {
-        synthesizeGLError(GL_INVALID_OPERATION, "deleteTransformFeedback", "transform feedback is active");
-        return;
-    }
     if (feedback == m_transformFeedbackBinding)
         m_transformFeedbackBinding = nullptr;
 
     deleteObject(feedback);
 }
 
 GLboolean WebGL2RenderingContextBase::isTransformFeedback(WebGLTransformFeedback* feedback)
 {
     if (isContextLost() || !feedback)
         return 0;
@@ skipping 12 matching lines @@
     if (deleted) {
         synthesizeGLError(GL_INVALID_OPERATION, "bindTransformFeedback", "attempted to bind a deleted transform feedback object");
         return;
     }
 
     if (target != GL_TRANSFORM_FEEDBACK) {
         synthesizeGLError(GL_INVALID_ENUM, "bindTransformFeedback", "target must be TRANSFORM_FEEDBACK");
         return;
     }
 
-    if (transformFeedbackActive() && !transformFeedbackPaused()) {
-        synthesizeGLError(GL_INVALID_OPERATION, "bindTransformFeedback", "transform feedback is active and not paused");
-        return;
-    }
-
     m_transformFeedbackBinding = feedback;
 
     contextGL()->BindTransformFeedback(target, objectOrZero(feedback));
     if (feedback) {
         feedback->setTarget(target);
         preserveObjectWrapper(scriptState, this, V8HiddenValue::webglMisc(scriptState->isolate()), &m_miscWrappers, static_cast<uint32_t>(PreservedTransformFeedback), feedback);
     }
 
 }
 
 void WebGL2RenderingContextBase::beginTransformFeedback(GLenum primitiveMode)
 {
     if (isContextLost())
         return;
     if (!validateTransformFeedbackPrimitiveMode("beginTransformFeedback", primitiveMode))
         return;
 
-    if (transformFeedbackActive()) {
-        synthesizeGLError(GL_INVALID_OPERATION, "beginTransformFeedback", "transform feedback is active");
-        return;
-    }
-
     contextGL()->BeginTransformFeedback(primitiveMode);
 
-    // TODO(kbr): there are many more reasons BeginTransformFeedback may fail, the most
-    // problematic being "if any binding point used in transform feedback mode does not
-    // have a buffer object bound", and "if no binding points would be used".
-    // crbug.com/448164
-    setTransformFeedbackActive(true);
-
     if (m_currentProgram)
         m_currentProgram->increaseActiveTransformFeedbackCount();
 
     if (m_transformFeedbackBinding)
         m_transformFeedbackBinding->setProgram(m_currentProgram);
 }
 
 void WebGL2RenderingContextBase::endTransformFeedback()
 {
     if (isContextLost())
         return;
 
-    if (!transformFeedbackActive()) {
-        synthesizeGLError(GL_INVALID_OPERATION, "endTransformFeedback", "transform feedback is not active");
-        return;
-    }
-
     contextGL()->EndTransformFeedback();
 
-    setTransformFeedbackPaused(false);
-    setTransformFeedbackActive(false);
-
     if (m_currentProgram)
         m_currentProgram->decreaseActiveTransformFeedbackCount();
 }
 
 void WebGL2RenderingContextBase::transformFeedbackVaryings(WebGLProgram* program, const Vector<String>& varyings, GLenum bufferMode)
 {
     if (isContextLost() || !validateWebGLObject("transformFeedbackVaryings", program))
         return;
 
     switch (bufferMode) {
@@ skipping 52 matching lines @@
     }
 
     return WebGLActiveInfo::create(String(name.get(), length), type, size);
 }
 
 void WebGL2RenderingContextBase::pauseTransformFeedback()
 {
     if (isContextLost())
         return;
 
-    if (!transformFeedbackActive() || transformFeedbackPaused()) {
-        synthesizeGLError(GL_INVALID_OPERATION, "pauseTransformFeedback", "transform feedback is not active or is paused");
-        return;
-    }
-
     contextGL()->PauseTransformFeedback();
-
-    setTransformFeedbackPaused(true);
 }
 
 void WebGL2RenderingContextBase::resumeTransformFeedback()
 {
     if (isContextLost())
         return;
 
-    if (!transformFeedbackActive() || !transformFeedbackPaused()) {
-        synthesizeGLError(GL_INVALID_OPERATION, "resumeTransformFeedback", "transform feedback is not active or is not paused");
-        return;
-    }
-
     if (m_transformFeedbackBinding && m_transformFeedbackBinding->getProgram() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "resumeTransformFeedback", "the program object is not active");
         return;
     }
 
     contextGL()->ResumeTransformFeedback();
-
-    setTransformFeedbackPaused(false);
 }
 
 bool WebGL2RenderingContextBase::validateTransformFeedbackPrimitiveMode(const char* functionName, GLenum primitiveMode)
 {
     switch (primitiveMode) {
     case GL_POINTS:
     case GL_LINES:
     case GL_TRIANGLES:
         return true;
     default:
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid transform feedback primitive mode");
         return false;
     }
 }
 
 void WebGL2RenderingContextBase::bindBufferBase(GLenum target, GLuint index, WebGLBuffer* buffer)
 {
     if (isContextLost())
         return;
     bool deleted;
     if (!checkObjectToBeBound("bindBufferBase", buffer, deleted))
         return;
     if (deleted)
         buffer = 0;
     if (!validateAndUpdateBufferBindBaseTarget("bindBufferBase", target, index, buffer))
         return;
 
-    // ES 3.0.4 spec section 2.15.2 "Transform Feedback Primitive Capture"
-    if (target == GL_TRANSFORM_FEEDBACK_BUFFER && transformFeedbackActive()) {
-        synthesizeGLError(GL_INVALID_OPERATION, "bindBufferBase", "target is TRANSFORM_FEEDBACK_BUFFER and transform feedback is active");
-        return;
-    }
-
     contextGL()->BindBufferBase(target, index, objectOrZero(buffer));
 }
 
 void WebGL2RenderingContextBase::bindBufferRange(GLenum target, GLuint index, WebGLBuffer* buffer, long long offset, long long size)
 {
     if (isContextLost())
         return;
     bool deleted;
     if (!checkObjectToBeBound("bindBufferRange", buffer, deleted))
         return;
     if (deleted)
         buffer = 0;
     if (!validateValueFitNonNegInt32("bindBufferRange", "offset", offset)
         || !validateValueFitNonNegInt32("bindBufferRange", "size", size)) {
         return;
     }
 
-    // ES 3.0.4 spec section 2.15.2 "Transform Feedback Primitive Capture"
-    if (target == GL_TRANSFORM_FEEDBACK_BUFFER && transformFeedbackActive()) {
-        synthesizeGLError(GL_INVALID_OPERATION, "bindBufferRange", "target is TRANSFORM_FEEDBACK_BUFFER and transform feedback is active");
-        return;
-    }
-
     if (!validateAndUpdateBufferBindBaseTarget("bindBufferRange", target, index, buffer))
         return;
 
     contextGL()->BindBufferRange(target, index, objectOrZero(buffer), static_cast<GLintptr>(offset), static_cast<GLsizeiptr>(size));
 }
 
-bool WebGL2RenderingContextBase::transformFeedbackActive() const
-{
-    if (m_transformFeedbackBinding)
-        return m_transformFeedbackBinding->isActive();
-    return false;
-}
-
-bool WebGL2RenderingContextBase::transformFeedbackPaused() const
-{
-    if (m_transformFeedbackBinding)
-        return m_transformFeedbackBinding->isPaused();
-    return false;
-}
-
-void WebGL2RenderingContextBase::setTransformFeedbackActive(bool transformFeedbackActive)
-{
-    if (m_transformFeedbackBinding)
-        m_transformFeedbackBinding->setActive(transformFeedbackActive);
-}
-
-void WebGL2RenderingContextBase::setTransformFeedbackPaused(bool transformFeedbackPaused)
-{
-    if (m_transformFeedbackBinding)
-        m_transformFeedbackBinding->setPaused(transformFeedbackPaused);
-}
-
 ScriptValue WebGL2RenderingContextBase::getIndexedParameter(ScriptState* scriptState, GLenum target, GLuint index)
 {
     if (isContextLost())
         return ScriptValue::createNull(scriptState);
 
     switch (target) {
     case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
         if (index >= m_boundIndexedTransformFeedbackBuffers.size()) {
             synthesizeGLError(GL_INVALID_VALUE, "getIndexedParameter", "index out of range");
             return ScriptValue::createNull(scriptState);
@@ skipping 427 matching lines @@
         return getBooleanParameter(scriptState, pname);
     case GL_SAMPLE_COVERAGE:
         return getBooleanParameter(scriptState, pname);
     case GL_SAMPLER_BINDING:
         return WebGLAny(scriptState, m_samplerUnits[m_activeTextureUnit].get());
     case GL_TEXTURE_BINDING_2D_ARRAY:
         return WebGLAny(scriptState, m_textureUnits[m_activeTextureUnit].m_texture2DArrayBinding.get());
     case GL_TEXTURE_BINDING_3D:
         return WebGLAny(scriptState, m_textureUnits[m_activeTextureUnit].m_texture3DBinding.get());
     case GL_TRANSFORM_FEEDBACK_ACTIVE:
-        return WebGLAny(scriptState, transformFeedbackActive());
+        return getBooleanParameter(scriptState, pname);
     case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
         return WebGLAny(scriptState, m_boundTransformFeedbackBuffer.get());
     case GL_TRANSFORM_FEEDBACK_BINDING:
         return WebGLAny(scriptState, m_transformFeedbackBinding.get());
     case GL_TRANSFORM_FEEDBACK_PAUSED:
-        return WebGLAny(scriptState, transformFeedbackPaused());
+        return getBooleanParameter(scriptState, pname);
     case GL_UNIFORM_BUFFER_BINDING:
         return WebGLAny(scriptState, m_boundUniformBuffer.get());
     case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
         return getIntParameter(scriptState, pname);
     case GL_UNPACK_IMAGE_HEIGHT:
         return getIntParameter(scriptState, pname);
     case GL_UNPACK_ROW_LENGTH:
         return getIntParameter(scriptState, pname);
     case GL_UNPACK_SKIP_IMAGES:
         return getIntParameter(scriptState, pname);
@@ skipping 704 matching lines @@
     params.skipPixels = m_unpackSkipPixels;
     params.skipRows = m_unpackSkipRows;
     if (dimension == Tex3D) {
         params.imageHeight = m_unpackImageHeight;
         params.skipImages = m_unpackSkipImages;
     }
     return params;
 }
 
 } // namespace blink