Add offset arguments to readPixels and compressedTex* per WebGL 2.0 spec.

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/dom/DOMException.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
@@ skipping 893 matching lines @@
                                             GLenum type,
                                             DOMArrayBufferView* pixels) {
   if (isContextLost())
     return;
   if (m_boundPixelPackBuffer.get()) {
     synthesizeGLError(GL_INVALID_OPERATION, "readPixels",
                       "PIXEL_PACK buffer should not be bound");
     return;
   }
 
-  WebGLRenderingContextBase::readPixels(x, y, width, height, format, type,
-                                        pixels);
+  readPixelsHelper(x, y, width, height, format, type, pixels, 0);
 }
 
 void WebGL2RenderingContextBase::readPixels(GLint x,
+                                            GLint y,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLenum format,
+                                            GLenum type,
+                                            DOMArrayBufferView* pixels,
+                                            GLuint offset) {
+  if (isContextLost())
+    return;
+  if (m_boundPixelPackBuffer.get()) {
+    synthesizeGLError(GL_INVALID_OPERATION, "readPixels",
+                      "PIXEL_PACK buffer should not be bound");
+    return;
+  }
+
+  readPixelsHelper(x, y, width, height, format, type, pixels, offset);
+}
+
+void WebGL2RenderingContextBase::readPixels(GLint x,
                                             GLint y,
                                             GLsizei width,
                                             GLsizei height,
                                             GLenum format,
                                             GLenum type,
                                             long long offset) {
   if (isContextLost())
     return;
 
   // Due to WebGL's same-origin restrictions, it is not possible to
@@ skipping 1005 matching lines @@
   WebGLFramebuffer* readFramebufferBinding = nullptr;
   if (!validateReadBufferAndGetInfo("copyTexSubImage3D",
                                     readFramebufferBinding))
     return;
   clearIfComposited();
   ScopedDrawingBufferBinder binder(drawingBuffer(), readFramebufferBinding);
   contextGL()->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y,
                                  width, height);
 }
 
+void WebGL2RenderingContextBase::compressedTexImage2D(
+    GLenum target,
+    GLint level,
+    GLenum internalformat,
+    GLsizei width,
+    GLsizei height,
+    GLint border,
+    DOMArrayBufferView* data) {
+  WebGLRenderingContextBase::compressedTexImage2D(target, level, internalformat,
+                                                  width, height, border, data);
+}
+
+void WebGL2RenderingContextBase::compressedTexImage2D(
+    GLenum target,
+    GLint level,
+    GLenum internalformat,
+    GLsizei width,
+    GLsizei height,
+    GLint border,
+    DOMArrayBufferView* data,
+    GLuint srcOffset,
+    GLuint srcLengthOverride) {
+  if (isContextLost())
+    return;
+  if (!validateTexture2DBinding("compressedTexImage2D", target))
+    return;
+  if (!validateCompressedTexFormat("compressedTexImage2D", internalformat))
+    return;
+  if (srcOffset > data->byteLength()) {
+    synthesizeGLError(GL_INVALID_VALUE, "compressedTexImage2D",
+                      "srcOffset is out of range");
+    return;
+  }
+  if (srcLengthOverride == 0) {
+    srcLengthOverride = data->byteLength() - srcOffset;
+  } else if (srcLengthOverride > data->byteLength() - srcOffset) {
+    synthesizeGLError(GL_INVALID_VALUE, "compressedTexImage2D",
+                      "srcLengthOverride is out of range");
+  }
+  contextGL()->CompressedTexImage2D(
+      target, level, internalformat, width, height, border, srcLengthOverride,
+      static_cast<uint8_t*>(data->baseAddress()) + srcOffset);
+}
+
+void WebGL2RenderingContextBase::compressedTexSubImage2D(
+    GLenum target,
+    GLint level,
+    GLint xoffset,
+    GLint yoffset,
+    GLsizei width,
+    GLsizei height,
+    GLenum format,
+    DOMArrayBufferView* data) {
+  WebGLRenderingContextBase::compressedTexSubImage2D(
+      target, level, xoffset, yoffset, width, height, format, data);
+}
+
+void WebGL2RenderingContextBase::compressedTexSubImage2D(
+    GLenum target,
+    GLint level,
+    GLint xoffset,
+    GLint yoffset,
+    GLsizei width,
+    GLsizei height,
+    GLenum format,
+    DOMArrayBufferView* data,
+    GLuint srcOffset,
+    GLuint srcLengthOverride) {
+  if (isContextLost())
+    return;
+  if (!validateTexture2DBinding("compressedTexSubImage2D", target))
+    return;
+  if (!validateCompressedTexFormat("compressedTexSubImage2D", format))
+    return;
+  if (srcOffset > data->byteLength()) {
+    synthesizeGLError(GL_INVALID_VALUE, "compressedTexSubImage2D",
+                      "srcOffset is out of range");
+    return;
+  }
+  if (srcLengthOverride == 0) {
+    srcLengthOverride = data->byteLength() - srcOffset;
+  } else if (srcLengthOverride > data->byteLength() - srcOffset) {
+    synthesizeGLError(GL_INVALID_VALUE, "compressedTexImage2D",
+                      "srcLengthOverride is out of range");
+  }
+  contextGL()->CompressedTexSubImage2D(
+      target, level, xoffset, yoffset, width, height, format, srcLengthOverride,
+      static_cast<uint8_t*>(data->baseAddress()) + srcOffset);
+}
+
 void WebGL2RenderingContextBase::compressedTexImage3D(
     GLenum target,
     GLint level,
     GLenum internalformat,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLint border,
-    DOMArrayBufferView* data) {
+    DOMArrayBufferView* data,
+    GLuint srcOffset,
+    GLuint srcLengthOverride) {
   if (isContextLost())
     return;
   if (!validateTexture3DBinding("compressedTexImage3D", target))
     return;
   if (!validateCompressedTexFormat("compressedTexImage3D", internalformat))
     return;
-  contextGL()->CompressedTexImage3D(target, level, internalformat, width,
-                                    height, depth, border, data->byteLength(),
-                                    data->baseAddress());
+  if (srcOffset > data->byteLength()) {
+    synthesizeGLError(GL_INVALID_VALUE, "compressedTexImage3D",
+                      "srcOffset is out of range");
+    return;
+  }
+  if (srcLengthOverride == 0) {
+    srcLengthOverride = data->byteLength() - srcOffset;
+  } else if (srcLengthOverride > data->byteLength() - srcOffset) {
+    synthesizeGLError(GL_INVALID_VALUE, "compressedTexImage3D",
+                      "srcLengthOverride is out of range");
+  }
+  contextGL()->CompressedTexImage3D(
+      target, level, internalformat, width, height, depth, border,
+      srcLengthOverride,
+      static_cast<uint8_t*>(data->baseAddress()) + srcOffset);
 }
 
 void WebGL2RenderingContextBase::compressedTexSubImage3D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLenum format,
-    DOMArrayBufferView* data) {
+    DOMArrayBufferView* data,
+    GLuint srcOffset,
+    GLuint srcLengthOverride) {
   if (isContextLost())
     return;
   if (!validateTexture3DBinding("compressedTexSubImage3D", target))
     return;
   if (!validateCompressedTexFormat("compressedTexSubImage3D", format))
     return;
-  contextGL()->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset,
-                                       width, height, depth, format,
-                                       data->byteLength(), data->baseAddress());
+  if (srcOffset > data->byteLength()) {
+    synthesizeGLError(GL_INVALID_VALUE, "compressedTexSubImage3D",
+                      "srcOffset is out of range");
+    return;
+  }
+  if (srcLengthOverride == 0) {
+    srcLengthOverride = data->byteLength() - srcOffset;
+  } else if (srcLengthOverride > data->byteLength() - srcOffset) {
+    synthesizeGLError(GL_INVALID_VALUE, "compressedTexSubImage3D",
+                      "srcLengthOverride is out of range");
+  }
+  contextGL()->CompressedTexSubImage3D(
+      target, level, xoffset, yoffset, zoffset, width, height, depth, format,
+      srcLengthOverride,
+      static_cast<uint8_t*>(data->baseAddress()) + srcOffset);
 }
 
 GLint WebGL2RenderingContextBase::getFragDataLocation(WebGLProgram* program,
                                                       const String& name) {
   if (isContextLost() || !validateWebGLObject("getFragDataLocation", program))
     return -1;
 
   return contextGL()->GetFragDataLocation(objectOrZero(program),
                                           name.utf8().data());
 }
@@ skipping 2831 matching lines @@
 
 void WebGL2RenderingContextBase::
     DrawingBufferClientRestorePixelUnpackBufferBinding() {
   if (!contextGL())
     return;
   contextGL()->BindBuffer(GL_PIXEL_UNPACK_BUFFER,
                           objectOrZero(m_boundPixelUnpackBuffer.get()));
 }
 
 }  // namespace blink