WebGL: remove validation code for vertexAttribPointer and vertexAttribIPointer

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/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLVideoElement.h"
@@ skipping 1388 matching lines @@
 
     webContext()->vertexAttribI4uiv(index, value);
     VertexAttribValue& attribValue = m_vertexAttribValue[index];
     attribValue.type = Uint32ArrayType;
     attribValue.value.uintValue[0] = value[0];
     attribValue.value.uintValue[1] = value[1];
     attribValue.value.uintValue[2] = value[2];
     attribValue.value.uintValue[3] = value[3];
 }
 
-bool WebGL2RenderingContextBase::validateVertexAttribPointerTypeAndSize(GLenum type, GLint size)
-{
-    switch (type) {
-    case GL_BYTE:
-    case GL_UNSIGNED_BYTE:
-    case GL_SHORT:
-    case GL_UNSIGNED_SHORT:
-    case GL_INT:
-    case GL_UNSIGNED_INT:
-    case GL_FLOAT:
-    case GL_HALF_FLOAT:
-        if (size < 1 || size > 4) {
-            synthesizeGLError(GL_INVALID_VALUE, "vertexAttribPointer", "invalid size");
-            return false;
-        }
-        return true;
-    case GL_INT_2_10_10_10_REV:
-    case GL_UNSIGNED_INT_2_10_10_10_REV:
-        if (size < 1 || size > 4) {
-            synthesizeGLError(GL_INVALID_VALUE, "vertexAttribPointer", "invalid size");
-            return false;
-        }
-        if (size != 4) {
-            synthesizeGLError(GL_INVALID_OPERATION, "vertexAttribPointer", "size != 4");
-            return false;
-        }
-        return true;
-    default:
-        synthesizeGLError(GL_INVALID_ENUM, "vertexAttribPointer", "invalid type");
-        return false;
-    }
-}
-
 void WebGL2RenderingContextBase::vertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, long long offset)
 {
     if (isContextLost())
         return;
-
-    switch (type) {
-    case GL_BYTE:
-    case GL_UNSIGNED_BYTE:
-    case GL_SHORT:
-    case GL_UNSIGNED_SHORT:
-    case GL_INT:
-    case GL_UNSIGNED_INT:
-        break;
-    default:
-        synthesizeGLError(GL_INVALID_ENUM, "vertexAttribIPointer", "invalid type");
-        return;
-    }
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttribIPointer", "index out of range");
         return;
     }
-    if (size < 1 || size > 4 || stride < 0 || stride > 255) {
-        synthesizeGLError(GL_INVALID_VALUE, "vertexAttribIPointer", "bad size or stride");
-        return;
-    }
     if (!validateValueFitNonNegInt32("vertexAttribIPointer", "offset", offset))
         return;
     if (!m_boundArrayBuffer) {
         synthesizeGLError(GL_INVALID_OPERATION, "vertexAttribIPointer", "no bound ARRAY_BUFFER");
         return;
     }
-    unsigned typeSize = sizeInBytes(type);
-    ASSERT((typeSize & (typeSize - 1)) == 0); // Ensure that the value is POT.
-    if ((stride & (typeSize - 1)) || (static_cast<GLintptr>(offset) & (typeSize - 1))) {
-        synthesizeGLError(GL_INVALID_OPERATION, "vertexAttribIPointer", "stride or offset not valid for type");
-        return;
-    }
-    GLsizei bytesPerElement = size * typeSize;
 
-    m_boundVertexArrayObject->setVertexAttribState(index, bytesPerElement, size, type, false, stride, static_cast<GLintptr>(offset), m_boundArrayBuffer);
+    m_boundVertexArrayObject->setArrayBufferForAttrib(index, m_boundArrayBuffer);
     webContext()->vertexAttribIPointer(index, size, type, stride, static_cast<GLintptr>(offset));
 }
 
 /* Writing to the drawing buffer */
 void WebGL2RenderingContextBase::vertexAttribDivisor(GLuint index, GLuint divisor)
 {
     if (isContextLost())
         return;
 
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttribDivisor", "index out of range");
         return;
     }
 
-    m_boundVertexArrayObject->setVertexAttribDivisor(index, divisor);
     webContext()->vertexAttribDivisorANGLE(index, divisor);
 }
 
 void WebGL2RenderingContextBase::drawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
 {
     if (!validateDrawArrays("drawArraysInstanced", mode, first, count))
         return;
 
     if (!validateDrawInstanced("drawArraysInstanced", instanceCount))
         return;
@@ skipping 1940 matching lines @@
 
     WebGLSampler* sampler = m_samplerUnits[unit];
 
     if (sampler)
         return sampler->getSamplerState();
 
     return WebGLRenderingContextBase::getTextureUnitSamplerState(target, unit);
 }
 
 } // namespace blink