Implement sub source for WebGL2's clearBuffer*().

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 <memory>
 #include "bindings/modules/v8/WebGLAny.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
@@ skipping 3445 matching lines @@
                           "COLOR_ATTACHMENTi_EXT or NONE");
         return;
       }
     }
     framebuffer_binding_->DrawBuffers(buffers);
   }
 }
 
 bool WebGL2RenderingContextBase::ValidateClearBuffer(const char* function_name,
                                                      GLenum buffer,
-                                                     GLsizei size) {
+                                                     GLsizei size,
+                                                     GLuint src_offset) {
+  CheckedNumeric<GLsizei> checked_size(size);
+  checked_size -= src_offset;
+  if (!checked_size.IsValid()) {
+    SynthesizeGLError(GL_INVALID_VALUE, function_name,
+                      "invalid array size / srcOffset");
+    return false;
+  }
   switch (buffer) {
     case GL_COLOR:
-      if (size < 4) {
+      if (checked_size.ValueOrDie() < 4) {
         SynthesizeGLError(GL_INVALID_VALUE, function_name,
-                          "invalid array size");
+                          "invalid array size / srcOffset");
         return false;
       }
       break;
     case GL_DEPTH:
     case GL_STENCIL:
-      if (size < 1) {
+      if (checked_size.ValueOrDie() < 1) {
         SynthesizeGLError(GL_INVALID_VALUE, function_name,
-                          "invalid array size");
+                          "invalid array size / srcOffset");
         return false;
       }
       break;
     default:
       SynthesizeGLError(GL_INVALID_ENUM, function_name, "invalid buffer");
       return false;
   }
   return true;
 }
 
 WebGLTexture* WebGL2RenderingContextBase::ValidateTexImageBinding(
     const char* func_name,
     TexImageFunctionID function_id,
     GLenum target) {
   if (function_id == kTexImage3D || function_id == kTexSubImage3D)
     return ValidateTexture3DBinding(func_name, target);
   return ValidateTexture2DBinding(func_name, target);
 }
 
 void WebGL2RenderingContextBase::clearBufferiv(GLenum buffer,
                                                GLint drawbuffer,
-                                               NotShared<DOMInt32Array> value) {
+                                               NotShared<DOMInt32Array> value,
+                                               GLuint src_offset) {
   if (isContextLost() ||
-      !ValidateClearBuffer("clearBufferiv", buffer, value.View()->length()))
+      !ValidateClearBuffer("clearBufferiv", buffer, value.View()->length(),
+                           src_offset))
     return;
 
-  ContextGL()->ClearBufferiv(buffer, drawbuffer, value.View()->Data());
+  ContextGL()->ClearBufferiv(buffer, drawbuffer,
+                             value.View()->Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::clearBufferiv(GLenum buffer,
                                                GLint drawbuffer,
-                                               const Vector<GLint>& value) {
+                                               const Vector<GLint>& value,
+                                               GLuint src_offset) {
   if (isContextLost() ||
-      !ValidateClearBuffer("clearBufferiv", buffer, value.size()))
+      !ValidateClearBuffer("clearBufferiv", buffer, value.size(), src_offset))
     return;
 
-  ContextGL()->ClearBufferiv(buffer, drawbuffer, value.Data());
-}
-
-void WebGL2RenderingContextBase::clearBufferuiv(
-    GLenum buffer,
-    GLint drawbuffer,
-    NotShared<DOMUint32Array> value) {
-  if (isContextLost() ||
-      !ValidateClearBuffer("clearBufferuiv", buffer, value.View()->length()))
-    return;
-
-  ContextGL()->ClearBufferuiv(buffer, drawbuffer, value.View()->Data());
+  ContextGL()->ClearBufferiv(buffer, drawbuffer, value.Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::clearBufferuiv(GLenum buffer,
                                                 GLint drawbuffer,
-                                                const Vector<GLuint>& value) {
+                                                NotShared<DOMUint32Array> value,
+                                                GLuint src_offset) {
   if (isContextLost() ||
-      !ValidateClearBuffer("clearBufferuiv", buffer, value.size()))
+      !ValidateClearBuffer("clearBufferuiv", buffer, value.View()->length(),
+                           src_offset))
     return;
 
-  ContextGL()->ClearBufferuiv(buffer, drawbuffer, value.Data());
+  ContextGL()->ClearBufferuiv(buffer, drawbuffer,
+                              value.View()->Data() + src_offset);
 }
 
-void WebGL2RenderingContextBase::clearBufferfv(
-    GLenum buffer,
-    GLint drawbuffer,
-    NotShared<DOMFloat32Array> value) {
+void WebGL2RenderingContextBase::clearBufferuiv(GLenum buffer,
+                                                GLint drawbuffer,
+                                                const Vector<GLuint>& value,
+                                                GLuint src_offset) {
   if (isContextLost() ||
-      !ValidateClearBuffer("clearBufferfv", buffer, value.View()->length()))
+      !ValidateClearBuffer("clearBufferuiv", buffer, value.size(), src_offset))
     return;
 
-  ContextGL()->ClearBufferfv(buffer, drawbuffer, value.View()->Data());
+  ContextGL()->ClearBufferuiv(buffer, drawbuffer, value.Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::clearBufferfv(GLenum buffer,
                                                GLint drawbuffer,
-                                               const Vector<GLfloat>& value) {
+                                               NotShared<DOMFloat32Array> value,
+                                               GLuint src_offset) {
   if (isContextLost() ||
-      !ValidateClearBuffer("clearBufferfv", buffer, value.size()))
+      !ValidateClearBuffer("clearBufferfv", buffer, value.View()->length(),
+                           src_offset))
     return;
 
-  ContextGL()->ClearBufferfv(buffer, drawbuffer, value.Data());
+  ContextGL()->ClearBufferfv(buffer, drawbuffer,
+                             value.View()->Data() + src_offset);
+}
+
+void WebGL2RenderingContextBase::clearBufferfv(GLenum buffer,
+                                               GLint drawbuffer,
+                                               const Vector<GLfloat>& value,
+                                               GLuint src_offset) {
+  if (isContextLost() ||
+      !ValidateClearBuffer("clearBufferfv", buffer, value.size(), src_offset))
+    return;
+
+  ContextGL()->ClearBufferfv(buffer, drawbuffer, value.Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::clearBufferfi(GLenum buffer,
                                                GLint drawbuffer,
                                                GLfloat depth,
                                                GLint stencil) {
   if (isContextLost())
     return;
 
   ContextGL()->ClearBufferfi(buffer, drawbuffer, depth, stencil);
@@ skipping 2121 matching lines @@
 
 void WebGL2RenderingContextBase::
     DrawingBufferClientRestorePixelUnpackBufferBinding() {
   if (!ContextGL())
     return;
   ContextGL()->BindBuffer(GL_PIXEL_UNPACK_BUFFER,
                           ObjectOrZero(bound_pixel_unpack_buffer_.Get()));
 }
 
 }  // namespace blink