Implement buffer{Sub}Data overloads with sub source.

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/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
@@ skipping 23 matching lines @@
 
 namespace blink {
 
 namespace {
 
 GLsync syncObjectOrZero(const WebGLSync* object)
 {
     return object ? object->object() : nullptr;
 }
 
+size_t getViewTypeSize(WTF::ArrayBufferView::ViewType viewType)
+{
+    switch (viewType) {
+    case WTF::ArrayBufferView::TypeInt8:
+    case WTF::ArrayBufferView::TypeUint8:
+    case WTF::ArrayBufferView::TypeUint8Clamped:
+        return 1;
+    case WTF::ArrayBufferView::TypeInt16:
+    case WTF::ArrayBufferView::TypeUint16:
+        return 2;
+    case WTF::ArrayBufferView::TypeInt32:
+    case WTF::ArrayBufferView::TypeUint32:
+    case WTF::ArrayBufferView::TypeFloat32:
+        return 4;
+    case WTF::ArrayBufferView::TypeFloat64:
+        return 8;
+    case WTF::ArrayBufferView::TypeDataView:
+        return 1;
+    default:
+        NOTREACHED();
+        return 0;
+    }
+}
+
+bool validateSubSourceAndGetData(DOMArrayBufferView* view, GLuint subOffset, GLuint subLength, void** outBaseAddress, long long* outByteLength)
+{
+    // This is guaranteed to be non-null by DOM.
+    DCHECK(view);
+
+    size_t typeSize = getViewTypeSize(view->type());
+    DCHECK_GE(8u, typeSize);
+    long long byteLength = 0;
+    if (subLength) {
+        // type size is at most 8, so no overflow.
+        byteLength = subLength * typeSize;
+    }
+    long long byteOffset = 0;
+    if (subOffset) {
+        // type size is at most 8, so no overflow.
+        byteOffset = subOffset * typeSize;
+    }
+    CheckedInt<long long> total = byteOffset;
+    total += byteLength;
+    if (!total.isValid() || total.value() > view->byteLength()) {
+        return false;
+    }
+    if (!byteLength) {
+        byteLength = view->byteLength() - byteOffset;
+    }
+    uint8_t* data = static_cast<uint8_t*>(view->baseAddress());
+    data += byteOffset;
+    *outBaseAddress = data;
+    *outByteLength = byteLength;
+    return true;
+}
+
 } // namespace
 
 // These enums are from manual pages for glTexStorage2D/glTexStorage3D.
 const GLenum kSupportedInternalFormatsStorage[] = {
     GL_R8,
     GL_R8_SNORM,
     GL_R16F,
     GL_R32F,
     GL_R8UI,
     GL_R8I,
@@ skipping 122 matching lines @@
     m_packSkipRows = 0;
     m_unpackRowLength = 0;
     m_unpackImageHeight = 0;
     m_unpackSkipPixels = 0;
     m_unpackSkipRows = 0;
     m_unpackSkipImages = 0;
 
     WebGLRenderingContextBase::initializeNewContext();
 }
 
+void WebGL2RenderingContextBase::bufferData(GLenum target, DOMArrayBufferView* srcData, GLenum usage, GLuint srcOffset, GLuint length)
+{
+    if (isContextLost())
+        return;
+    void* subBaseAddress = nullptr;
+    long long subByteLength = 0;
+    if (!validateSubSourceAndGetData(srcData, srcOffset, length, &subBaseAddress, &subByteLength)) {
+        synthesizeGLError(GL_INVALID_VALUE, "bufferData", "srcOffset + length too large");
+        return;
+    }
+    bufferDataImpl(target, subByteLength, subBaseAddress, usage);
+}
+
+void WebGL2RenderingContextBase::bufferData(GLenum target, long long size, GLenum usage)
+{
+    WebGLRenderingContextBase::bufferData(target, size, usage);
+}
+
+void WebGL2RenderingContextBase::bufferData(GLenum target, DOMArrayBuffer* data, GLenum usage)
+{
+    WebGLRenderingContextBase::bufferData(target, data, usage);
+}
+
+void WebGL2RenderingContextBase::bufferData(GLenum target, DOMArrayBufferView* data, GLenum usage)
+{
+    WebGLRenderingContextBase::bufferData(target, data, usage);
+}
+
+void WebGL2RenderingContextBase::bufferSubData(GLenum target, GLintptr dstByteOffset, DOMArrayBufferView* srcData, GLuint srcOffset, GLuint length)
+{
+    if (isContextLost())
+        return;
+    void* subBaseAddress = nullptr;
+    long long subByteLength = 0;
+    if (!validateSubSourceAndGetData(srcData, srcOffset, length, &subBaseAddress, &subByteLength)) {
+        synthesizeGLError(GL_INVALID_VALUE, "bufferSubData", "srcOffset + length too large");
+        return;
+    }
+    bufferSubDataImpl(target, dstByteOffset, subByteLength, subBaseAddress);
+}
+
+void WebGL2RenderingContextBase::bufferSubData(GLenum target, long long offset, DOMArrayBuffer* data)
+{
+    WebGLRenderingContextBase::bufferSubData(target, offset, data);
+}
+
+void WebGL2RenderingContextBase::bufferSubData(GLenum target, long long offset, const FlexibleArrayBufferView& data)
+{
+    WebGLRenderingContextBase::bufferSubData(target, offset, data);
+}
+
 void WebGL2RenderingContextBase::copyBufferSubData(GLenum readTarget, GLenum writeTarget, long long readOffset, long long writeOffset, long long size)
 {
     if (isContextLost())
         return;
 
     if (!validateValueFitNonNegInt32("copyBufferSubData", "readOffset", readOffset)
         || !validateValueFitNonNegInt32("copyBufferSubData", "writeOffset", writeOffset)
         || !validateValueFitNonNegInt32("copyBufferSubData", "size", size)) {
         return;
     }
@@ skipping 16 matching lines @@
         synthesizeGLError(GL_INVALID_OPERATION, "copyBufferSubData", "Cannot copy into an element buffer destination from a non-element buffer source");
         return;
     }
 
     if (writeBuffer->getInitialTarget() == 0)
         writeBuffer->setInitialTarget(readBuffer->getInitialTarget());
 
     contextGL()->CopyBufferSubData(readTarget, writeTarget, static_cast<GLintptr>(readOffset), static_cast<GLintptr>(writeOffset), static_cast<GLsizeiptr>(size));
 }
 
-void WebGL2RenderingContextBase::getBufferSubData(GLenum target, long long offset, DOMArrayBuffer* returnedData)
+void WebGL2RenderingContextBase::getBufferSubData(GLenum target, long long srcByteOffset, DOMArrayBufferView* dstData, GLuint dstOffset, GLuint length)
 {
+    const char* funcName = "getBufferSubData";
     if (isContextLost())
         return;
-
-    if (!returnedData) {
-        synthesizeGLError(GL_INVALID_VALUE, "getBufferSubData", "ArrayBuffer cannot be null");
+    if (!validateValueFitNonNegInt32(funcName, "srcByteOffset", srcByteOffset)) {
+        return;
+    }
+    WebGLBuffer* buffer = validateBufferDataTarget(funcName, target);
+    if (!buffer)
+        return;
+    void* subBaseAddress = nullptr;
+    long long subByteLength = 0;
+    if (!validateSubSourceAndGetData(dstData, dstOffset, length, &subBaseAddress, &subByteLength)) {
+        synthesizeGLError(GL_INVALID_VALUE, funcName, "buffer overflow");
         return;
     }
 
-    if (!validateValueFitNonNegInt32("getBufferSubData", "offset", offset)) {
-        return;
-    }
-
-    WebGLBuffer* buffer = validateBufferDataTarget("getBufferSubData", target);
-    if (!buffer)
-        return;
-    if (offset + returnedData->byteLength() > buffer->getSize()) {
-        synthesizeGLError(GL_INVALID_VALUE, "getBufferSubData", "buffer overflow");
-        return;
-    }
-
-    void* mappedData = contextGL()->MapBufferRange(target, static_cast<GLintptr>(offset), returnedData->byteLength(), GL_MAP_READ_BIT);
+    void* mappedData = contextGL()->MapBufferRange(target, static_cast<GLintptr>(srcByteOffset), subByteLength, GL_MAP_READ_BIT);
 
     if (!mappedData)
         return;
 
-    memcpy(returnedData->data(), mappedData, returnedData->byteLength());
+    memcpy(subBaseAddress, mappedData, subByteLength);
 
     contextGL()->UnmapBuffer(target);
 }
 
+void WebGL2RenderingContextBase::getBufferSubData(GLenum target, long long srcByteOffset, DOMArrayBuffer* dstData)
+{
+    const char* funcName = "getBufferSubData";
+    if (isContextLost())
+        return;
+
+    if (!dstData) {
+        synthesizeGLError(GL_INVALID_VALUE, funcName, "ArrayBuffer can not be null");
+        return;
+    }
+    if (!validateValueFitNonNegInt32(funcName, "srcByteOffset", srcByteOffset)) {
+        return;
+    }
+    WebGLBuffer* buffer = validateBufferDataTarget(funcName, target);
+    if (!buffer)
+        return;
+    if (srcByteOffset + dstData->byteLength() > buffer->getSize()) {
+        synthesizeGLError(GL_INVALID_VALUE, funcName, "buffer overflow");
+        return;
+    }
+
+    void* mappedData = contextGL()->MapBufferRange(target, static_cast<GLintptr>(srcByteOffset), dstData->byteLength(), GL_MAP_READ_BIT);
+    if (!mappedData)
+        return;
+    memcpy(dstData->data(), mappedData, dstData->byteLength());
+    contextGL()->UnmapBuffer(target);
+}
+
 void WebGL2RenderingContextBase::blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
     if (isContextLost())
         return;
 
     contextGL()->BlitFramebufferCHROMIUM(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 bool WebGL2RenderingContextBase::validateTexFuncLayer(const char* functionName, GLenum texTarget, GLint layer)
 {
@@ skipping 3097 matching lines @@
     params.skipPixels = m_unpackSkipPixels;
     params.skipRows = m_unpackSkipRows;
     if (dimension == Tex3D) {
         params.imageHeight = m_unpackImageHeight;
         params.skipImages = m_unpackSkipImages;
     }
     return params;
 }
 
 } // namespace blink