Implement WebGL2's uniform*() with sub source.

third_party/WebKit/Source/modules/webgl/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 5628 matching lines @@
     return;
   }
 
   contextGL()->Uniform1f(location->location(), x);
 }
 
 void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location,
                                            const FlexibleFloat32ArrayView& v) {
   if (isContextLost() ||
       !validateUniformParameters<WTF::Float32Array>("uniform1fv", location, v,
-                                                    1))
+                                                    1, 0, v.length()))
     return;
 
   contextGL()->Uniform1fv(location->location(), v.length(),
                           v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location,
                                            Vector<GLfloat>& v) {
   if (isContextLost() ||
-      !validateUniformParameters("uniform1fv", location, v.data(), v.size(), 1))
+      !validateUniformParameters("uniform1fv", location, v.data(), v.size(), 1,
+                                 0, v.size()))
     return;
 
   contextGL()->Uniform1fv(location->location(), v.size(), v.data());
 }
 
 void WebGLRenderingContextBase::uniform1i(const WebGLUniformLocation* location,
                                           GLint x) {
   if (isContextLost() || !location)
     return;
 
   if (location->program() != m_currentProgram) {
     synthesizeGLError(GL_INVALID_OPERATION, "uniform1i",
                       "location not for current program");
     return;
   }
 
   contextGL()->Uniform1i(location->location(), x);
 }
 
 void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location,
                                            const FlexibleInt32ArrayView& v) {
   if (isContextLost() ||
-      !validateUniformParameters<WTF::Int32Array>("uniform1iv", location, v, 1))
+      !validateUniformParameters<WTF::Int32Array>("uniform1iv", location, v, 1,
+                                                  0, v.length()))
     return;
 
   contextGL()->Uniform1iv(location->location(), v.length(),
                           v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location,
                                            Vector<GLint>& v) {
   if (isContextLost() ||
-      !validateUniformParameters("uniform1iv", location, v.data(), v.size(), 1))
+      !validateUniformParameters("uniform1iv", location, v.data(), v.size(), 1,
+                                 0, v.size()))
     return;
 
   contextGL()->Uniform1iv(location->location(), v.size(), v.data());
 }
 
 void WebGLRenderingContextBase::uniform2f(const WebGLUniformLocation* location,
                                           GLfloat x,
                                           GLfloat y) {
   if (isContextLost() || !location)
     return;
 
   if (location->program() != m_currentProgram) {
     synthesizeGLError(GL_INVALID_OPERATION, "uniform2f",
                       "location not for current program");
     return;
   }
 
   contextGL()->Uniform2f(location->location(), x, y);
 }
 
 void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location,
                                            const FlexibleFloat32ArrayView& v) {
   if (isContextLost() ||
       !validateUniformParameters<WTF::Float32Array>("uniform2fv", location, v,
-                                                    2))
+                                                    2, 0, v.length()))
     return;
 
   contextGL()->Uniform2fv(location->location(), v.length() >> 1,
                           v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location,
                                            Vector<GLfloat>& v) {
   if (isContextLost() ||
-      !validateUniformParameters("uniform2fv", location, v.data(), v.size(), 2))
+      !validateUniformParameters("uniform2fv", location, v.data(), v.size(), 2,
+                                 0, v.size()))
     return;
 
   contextGL()->Uniform2fv(location->location(), v.size() >> 1, v.data());
 }
 
 void WebGLRenderingContextBase::uniform2i(const WebGLUniformLocation* location,
                                           GLint x,
                                           GLint y) {
   if (isContextLost() || !location)
     return;
 
   if (location->program() != m_currentProgram) {
     synthesizeGLError(GL_INVALID_OPERATION, "uniform2i",
                       "location not for current program");
     return;
   }
 
   contextGL()->Uniform2i(location->location(), x, y);
 }
 
 void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location,
                                            const FlexibleInt32ArrayView& v) {
   if (isContextLost() ||
-      !validateUniformParameters<WTF::Int32Array>("uniform2iv", location, v, 2))
+      !validateUniformParameters<WTF::Int32Array>("uniform2iv", location, v, 2,
+                                                  0, v.length()))
     return;
 
   contextGL()->Uniform2iv(location->location(), v.length() >> 1,
                           v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location,
                                            Vector<GLint>& v) {
   if (isContextLost() ||
-      !validateUniformParameters("uniform2iv", location, v.data(), v.size(), 2))
+      !validateUniformParameters("uniform2iv", location, v.data(), v.size(), 2,
+                                 0, v.size()))
     return;
 
   contextGL()->Uniform2iv(location->location(), v.size() >> 1, v.data());
 }
 
 void WebGLRenderingContextBase::uniform3f(const WebGLUniformLocation* location,
                                           GLfloat x,
                                           GLfloat y,
                                           GLfloat z) {
   if (isContextLost() || !location)
     return;
 
   if (location->program() != m_currentProgram) {
     synthesizeGLError(GL_INVALID_OPERATION, "uniform3f",
                       "location not for current program");
     return;
   }
 
   contextGL()->Uniform3f(location->location(), x, y, z);
 }
 
 void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location,
                                            const FlexibleFloat32ArrayView& v) {
   if (isContextLost() ||
       !validateUniformParameters<WTF::Float32Array>("uniform3fv", location, v,
-                                                    3))
+                                                    3, 0, v.length()))
     return;
 
   contextGL()->Uniform3fv(location->location(), v.length() / 3,
                           v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location,
                                            Vector<GLfloat>& v) {
   if (isContextLost() ||
-      !validateUniformParameters("uniform3fv", location, v.data(), v.size(), 3))
+      !validateUniformParameters("uniform3fv", location, v.data(), v.size(), 3,
+                                 0, v.size()))
     return;
 
   contextGL()->Uniform3fv(location->location(), v.size() / 3, v.data());
 }
 
 void WebGLRenderingContextBase::uniform3i(const WebGLUniformLocation* location,
                                           GLint x,
                                           GLint y,
                                           GLint z) {
   if (isContextLost() || !location)
     return;
 
   if (location->program() != m_currentProgram) {
     synthesizeGLError(GL_INVALID_OPERATION, "uniform3i",
                       "location not for current program");
     return;
   }
 
   contextGL()->Uniform3i(location->location(), x, y, z);
 }
 
 void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location,
                                            const FlexibleInt32ArrayView& v) {
   if (isContextLost() ||
-      !validateUniformParameters<WTF::Int32Array>("uniform3iv", location, v, 3))
+      !validateUniformParameters<WTF::Int32Array>("uniform3iv", location, v, 3,
+                                                  0, v.length()))
     return;
 
   contextGL()->Uniform3iv(location->location(), v.length() / 3,
                           v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location,
                                            Vector<GLint>& v) {
   if (isContextLost() ||
-      !validateUniformParameters("uniform3iv", location, v.data(), v.size(), 3))
+      !validateUniformParameters("uniform3iv", location, v.data(), v.size(), 3,
+                                 0, v.size()))
     return;
 
   contextGL()->Uniform3iv(location->location(), v.size() / 3, v.data());
 }
 
 void WebGLRenderingContextBase::uniform4f(const WebGLUniformLocation* location,
                                           GLfloat x,
                                           GLfloat y,
                                           GLfloat z,
                                           GLfloat w) {
   if (isContextLost() || !location)
     return;
 
   if (location->program() != m_currentProgram) {
     synthesizeGLError(GL_INVALID_OPERATION, "uniform4f",
                       "location not for current program");
     return;
   }
 
   contextGL()->Uniform4f(location->location(), x, y, z, w);
 }
 
 void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location,
                                            const FlexibleFloat32ArrayView& v) {
   if (isContextLost() ||
       !validateUniformParameters<WTF::Float32Array>("uniform4fv", location, v,
-                                                    4))
+                                                    4, 0, v.length()))
     return;
 
   contextGL()->Uniform4fv(location->location(), v.length() >> 2,
                           v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location,
                                            Vector<GLfloat>& v) {
   if (isContextLost() ||
-      !validateUniformParameters("uniform4fv", location, v.data(), v.size(), 4))
+      !validateUniformParameters("uniform4fv", location, v.data(), v.size(), 4,
+                                 0, v.size()))
     return;
 
   contextGL()->Uniform4fv(location->location(), v.size() >> 2, v.data());
 }
 
 void WebGLRenderingContextBase::uniform4i(const WebGLUniformLocation* location,
                                           GLint x,
                                           GLint y,
                                           GLint z,
                                           GLint w) {
   if (isContextLost() || !location)
     return;
 
   if (location->program() != m_currentProgram) {
     synthesizeGLError(GL_INVALID_OPERATION, "uniform4i",
                       "location not for current program");
     return;
   }
 
   contextGL()->Uniform4i(location->location(), x, y, z, w);
 }
 
 void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location,
                                            const FlexibleInt32ArrayView& v) {
   if (isContextLost() ||
-      !validateUniformParameters<WTF::Int32Array>("uniform4iv", location, v, 4))
+      !validateUniformParameters<WTF::Int32Array>("uniform4iv", location, v, 4,
+                                                  0, v.length()))
     return;
 
   contextGL()->Uniform4iv(location->location(), v.length() >> 2,
                           v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location,
                                            Vector<GLint>& v) {
   if (isContextLost() ||
-      !validateUniformParameters("uniform4iv", location, v.data(), v.size(), 4))
+      !validateUniformParameters("uniform4iv", location, v.data(), v.size(), 4,
+                                 0, v.size()))
     return;
 
   contextGL()->Uniform4iv(location->location(), v.size() >> 2, v.data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     DOMFloat32Array* v) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose,
-                                       v, 4))
+                                       v, 4, 0, v->length()))
     return;
   contextGL()->UniformMatrix2fv(location->location(), v->length() >> 2,
                                 transpose, v->data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& v) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose,
-                                       v.data(), v.size(), 4))
+                                       v.data(), v.size(), 4, 0, v.size()))
     return;
   contextGL()->UniformMatrix2fv(location->location(), v.size() >> 2, transpose,
                                 v.data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     DOMFloat32Array* v) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose,
-                                       v, 9))
+                                       v, 9, 0, v->length()))
     return;
   contextGL()->UniformMatrix3fv(location->location(), v->length() / 9,
                                 transpose, v->data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& v) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose,
-                                       v.data(), v.size(), 9))
+                                       v.data(), v.size(), 9, 0, v.size()))
     return;
   contextGL()->UniformMatrix3fv(location->location(), v.size() / 9, transpose,
                                 v.data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     DOMFloat32Array* v) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose,
-                                       v, 16))
+                                       v, 16, 0, v->length()))
     return;
   contextGL()->UniformMatrix4fv(location->location(), v->length() >> 4,
                                 transpose, v->data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& v) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose,
-                                       v.data(), v.size(), 16))
+                                       v.data(), v.size(), 16, 0, v.size()))
     return;
   contextGL()->UniformMatrix4fv(location->location(), v.size() >> 4, transpose,
                                 v.data());
 }
 
 void WebGLRenderingContextBase::useProgram(WebGLProgram* program) {
   bool deleted;
   if (!checkObjectToBeBound("useProgram", program, deleted))
     return;
   if (deleted)
@@ skipping 1164 matching lines @@
       return true;
     default:
       synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid capability");
       return false;
   }
 }
 
 bool WebGLRenderingContextBase::validateUniformParameters(
     const char* functionName,
     const WebGLUniformLocation* location,
-    DOMFloat32Array* v,
-    GLsizei requiredMinSize) {
-  if (!v) {
-    synthesizeGLError(GL_INVALID_VALUE, functionName, "no array");
-    return false;
-  }
-  return validateUniformMatrixParameters(
-      functionName, location, false, v->data(), v->length(), requiredMinSize);
-}
-
-bool WebGLRenderingContextBase::validateUniformParameters(
-    const char* functionName,
-    const WebGLUniformLocation* location,
-    DOMInt32Array* v,
-    GLsizei requiredMinSize) {
-  if (!v) {
-    synthesizeGLError(GL_INVALID_VALUE, functionName, "no array");
-    return false;
-  }
-  return validateUniformMatrixParameters(
-      functionName, location, false, v->data(), v->length(), requiredMinSize);
-}
-
-bool WebGLRenderingContextBase::validateUniformParameters(
-    const char* functionName,
-    const WebGLUniformLocation* location,
     void* v,
     GLsizei size,
-    GLsizei requiredMinSize) {
+    GLsizei requiredMinSize,
+    GLuint srcOffset,
+    GLuint srcLength) {
   return validateUniformMatrixParameters(functionName, location, false, v, size,
-                                         requiredMinSize);
+                                         requiredMinSize, srcOffset, srcLength);
 }
 
 bool WebGLRenderingContextBase::validateUniformMatrixParameters(
     const char* functionName,
     const WebGLUniformLocation* location,
     GLboolean transpose,
     DOMFloat32Array* v,
-    GLsizei requiredMinSize) {
+    GLsizei requiredMinSize,
+    GLuint srcOffset,
+    GLuint srcLength) {
   if (!v) {
     synthesizeGLError(GL_INVALID_VALUE, functionName, "no array");
     return false;
   }
   return validateUniformMatrixParameters(functionName, location, transpose,
                                          v->data(), v->length(),
-                                         requiredMinSize);
+                                         requiredMinSize, srcOffset, srcLength);
 }
 
 bool WebGLRenderingContextBase::validateUniformMatrixParameters(
     const char* functionName,
     const WebGLUniformLocation* location,
     GLboolean transpose,
     void* v,
     GLsizei size,
-    GLsizei requiredMinSize) {
+    GLsizei requiredMinSize,
+    GLuint srcOffset,
+    GLuint srcLength) {
+  DCHECK(size >= 0 && requiredMinSize > 0);
   if (!location)
     return false;
   if (location->program() != m_currentProgram) {
     synthesizeGLError(GL_INVALID_OPERATION, functionName,
                       "location is not from current program");
     return false;
   }
   if (!v) {
     synthesizeGLError(GL_INVALID_VALUE, functionName, "no array");
     return false;
   }
   if (transpose && !isWebGL2OrHigher()) {
     synthesizeGLError(GL_INVALID_VALUE, functionName, "transpose not FALSE");
     return false;
   }
-  if (size < requiredMinSize || (size % requiredMinSize)) {
+  if (srcOffset >= static_cast<GLuint>(size)) {
+    synthesizeGLError(GL_INVALID_VALUE, functionName, "invalid srcOffset");
+    return false;
+  }
+  GLsizei actualSize = size - srcOffset;
+  if (srcLength > 0) {
+    if (srcLength > static_cast<GLuint>(actualSize)) {
+      synthesizeGLError(GL_INVALID_VALUE, functionName,
+                        "invalid srcOffset + srcLength");
+      return false;
+    }
+    actualSize = srcLength;
+  }
+  if (actualSize < requiredMinSize || (actualSize % requiredMinSize)) {
     synthesizeGLError(GL_INVALID_VALUE, functionName, "invalid size");
     return false;
   }
   return true;
 }
 
 WebGLBuffer* WebGLRenderingContextBase::validateBufferDataTarget(
     const char* functionName,
     GLenum target) {
   WebGLBuffer* buffer = nullptr;
@@ skipping 555 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(offscreenCanvas());
 }
 
 }  // namespace blink