Implement tex{Sub}Image{2|3}D with ArrayBufferView 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 4106 matching lines @@
     case TexSubImage3D:
         return "texSubImage3D";
     case TexImage3D:
         return "texImage3D";
     default: // Adding default to prevent compile error
         return "";
     }
 }
 
 void WebGLRenderingContextBase::texImageHelperDOMArrayBufferView(TexImageFunctionID functionID,
-    GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border,
-    GLenum format, GLenum type, GLsizei depth, GLint xoffset, GLint yoffset, GLint zoffset, DOMArrayBufferView* pixels)
+    GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth,
+    GLint border, GLenum format, GLenum type, GLint xoffset, GLint yoffset, GLint zoffset,
+    DOMArrayBufferView* pixels, NullDisposition nullDisposition, GLuint srcOffset)
 {
     const char* funcName = getTexImageFunctionName(functionID);
     if (isContextLost())
         return;
     if (!validateTexImageBinding(funcName, functionID, target))
         return;
     TexImageFunctionType functionType;
     if (functionID == TexImage2D || functionID == TexImage3D)
         functionType = TexImage;
     else
         functionType = TexSubImage;
     if (!validateTexFunc(funcName, functionType, SourceArrayBufferView, target, level, internalformat, width, height, depth, border, format, type, xoffset, yoffset, zoffset))
         return;
     TexImageDimension sourceType;
     if (functionID == TexImage2D || functionID == TexSubImage2D)
         sourceType = Tex2D;
     else
         sourceType = Tex3D;
-    switch (functionID) {
-    case TexImage2D:
-    case TexImage3D:
-        if (!validateTexFuncData(funcName, sourceType, level, width, height, depth, format, type, pixels, NullAllowed))
-            return;
-        break;
-    case TexSubImage2D:
-    case TexSubImage3D:
-        if (!validateTexFuncData(funcName, sourceType, level, width, height, depth, format, type, pixels, NullNotAllowed))
-            return;
+    if (!validateTexFuncData(funcName, sourceType, level, width, height, depth, format, type, pixels, nullDisposition, srcOffset))
+        return;
+    uint8_t* data = reinterpret_cast<uint8_t*>(pixels ? pixels->baseAddress() : 0);
+    if (srcOffset) {
+        DCHECK(pixels);
+        // No need to check overflow because validateTexFuncData() already did.
+        data += srcOffset * pixels->typeSize();
     }
-    void* data = pixels ? pixels->baseAddress() : 0;
     Vector<uint8_t> tempData;
     bool changeUnpackAlignment = false;
     if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
         if (sourceType == Tex2D) {
             if (!WebGLImageConversion::extractTextureData(width, height, format, type, m_unpackAlignment, m_unpackFlipY, m_unpackPremultiplyAlpha, data, tempData))
                 return;
             data = tempData.data();
         }
         changeUnpackAlignment = true;
     }
@@ skipping 14 matching lines @@
     else if (functionID == TexSubImage2D)
         contextGL()->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data);
     if (changeUnpackAlignment)
         restoreUnpackParameters();
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target, GLint level, GLint internalformat,
     GLsizei width, GLsizei height, GLint border,
     GLenum format, GLenum type, DOMArrayBufferView* pixels)
 {
-    texImageHelperDOMArrayBufferView(TexImage2D, target, level, internalformat, width, height, border, format, type, 1, 0, 0, 0, pixels);
+    texImageHelperDOMArrayBufferView(TexImage2D, target, level, internalformat, width, height, 1, border, format, type, 0, 0, 0, pixels, NullAllowed, 0);
 }
 
 void WebGLRenderingContextBase::texImageHelperImageData(TexImageFunctionID functionID,
     GLenum target, GLint level, GLint internalformat, GLint border, GLenum format,
     GLenum type, GLsizei depth, GLint xoffset, GLint yoffset, GLint zoffset, ImageData* pixels)
 {
     const char* funcName = getTexImageFunctionName(functionID);
     if (isContextLost())
         return;
     if (!pixels) {
@@ skipping 432 matching lines @@
 
 void WebGLRenderingContextBase::texParameteri(GLenum target, GLenum pname, GLint param)
 {
     texParameter(target, pname, 0, param, false);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLsizei width, GLsizei height,
     GLenum format, GLenum type, DOMArrayBufferView* pixels)
 {
-    texImageHelperDOMArrayBufferView(TexSubImage2D, target, level, 0, width, height, 0, format, type, 1, xoffset, yoffset, 0, pixels);
+    texImageHelperDOMArrayBufferView(TexSubImage2D, target, level, 0, width, height, 1, 0, format, type, xoffset, yoffset, 0, pixels, NullNotAllowed, 0);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLenum format, GLenum type, ImageData* pixels)
 {
     texImageHelperImageData(TexSubImage2D, target, level, 0, 0, format, type, 1, xoffset, yoffset, 0, pixels);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLenum format, GLenum type, HTMLImageElement* image, ExceptionState& exceptionState)
@@ skipping 1016 matching lines @@
         return false;
 
     if (border) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "border != 0");
         return false;
     }
 
     return true;
 }
 
-bool WebGLRenderingContextBase::validateTexFuncData(const char* functionName, TexImageDimension texDimension, GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, DOMArrayBufferView* pixels, NullDisposition disposition)
+bool WebGLRenderingContextBase::validateTexFuncData(const char* functionName, TexImageDimension texDimension, GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, DOMArrayBufferView* pixels, NullDisposition disposition, GLuint srcOffset)
 {
     // All calling functions check isContextLost, so a duplicate check is not needed here.
     if (!pixels) {
+        DCHECK(disposition != NullNotReachable);

[tkent, 2016/08/25 01:52:40]

DCHECK_NE(disposition, NullNotReachable)

[Zhenyao Mo, 2016/08/25 01:59:12]

Done.

         if (disposition == NullAllowed)
             return true;
         synthesizeGLError(GL_INVALID_VALUE, functionName, "no pixels");
         return false;
     }
 
     if (!validateSettableTexFormat(functionName, format))
         return false;
 
     switch (type) {
@@ skipping 61 matching lines @@
     default:
         ASSERT_NOT_REACHED();
     }
 
     unsigned totalBytesRequired, skipBytes;
     GLenum error = WebGLImageConversion::computeImageSizeInBytes(format, type, width, height, depth, getUnpackPixelStoreParams(texDimension), &totalBytesRequired, 0, &skipBytes);
     if (error != GL_NO_ERROR) {
         synthesizeGLError(error, functionName, "invalid texture dimensions");
         return false;
     }
-    if (pixels->byteLength() < totalBytesRequired + skipBytes) {
+    CheckedInt<uint32_t> total = srcOffset;
+    total *= pixels->typeSize();
+    total += totalBytesRequired;
+    total += skipBytes;
+    if (!total.isValid() || pixels->byteLength() < total.value()) {
         synthesizeGLError(GL_INVALID_OPERATION, functionName, "ArrayBufferView not big enough for request");
         return false;
     }
     return true;
 }
 
 bool WebGLRenderingContextBase::validateCompressedTexFormat(const char* functionName, GLenum format)
 {
     if (!m_compressedTextureFormats.contains(format)) {
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid format");
@@ skipping 712 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(HTMLCanvasElementOrOffscreenCanvas& result) const
 {
     if (canvas())
         result.setHTMLCanvasElement(canvas());
     else
         result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 } // namespace blink