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 1433 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);

[Zhenyao Mo, 2015/12/29 22:04:04]

When you remove the above validation, then you ended up caching the wrong here
info if some args are invalid.

[yunchao, 2015/12/30 01:02:11]

Yeah, that's true. But Chromium will report error/failure soon in command
buffer. So the web developers will know that their app have some bugs. The wrong
data cached here will not be used then. I think this is OK. In my opinion, we
need to make sure that intentional or unintentional wrong parameter(s) will
trigger appropriate error. And it should not lead to some security problem(crash
the browser, memory leak, etc). WDYT?

I think we would have the similar cases when we do code-refactoring for other
APIs. 

     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) {
@@ skipping 1955 matching lines @@
 
     WebGLSampler* sampler = m_samplerUnits[unit];
 
     if (sampler)
         return sampler->getSamplerState();
 
     return WebGLRenderingContextBase::getTextureUnitSamplerState(target, unit);
 }
 
 } // namespace blink