bindings: Adds DOMArrayBuffer, etc. as thin wrappers for ArrayBuffer, etc.

Source/core/html/canvas/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 10 matching lines @@
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/html/canvas/WebGLRenderingContextBase.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
+#include "core/dom/DOMArrayBuffer.h"
+#include "core/dom/DOMTypedArray.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/fetch/ImageResource.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "core/html/canvas/ANGLEInstancedArrays.h"
 #include "core/html/canvas/EXTBlendMinMax.h"
@@ skipping 36 matching lines @@
 #include "core/rendering/RenderBox.h"
 #include "platform/CheckedInt.h"
 #include "platform/NotImplemented.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/gpu/AcceleratedImageBufferSurface.h"
 #include "platform/graphics/gpu/DrawingBuffer.h"
 #include "public/platform/Platform.h"
-
 #include "wtf/PassOwnPtr.h"
-#include "wtf/Uint32Array.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 const double secondsBetweenRestoreAttempts = 1.0;
 const int maxGLErrorsAllowedToConsole = 256;
 const unsigned maxGLActiveContexts = 16;
 
 // FIXME: Oilpan: static vectors to heap allocated WebGLRenderingContextBase objects
 // are kept here. This relies on the WebGLRenderingContextBase finalization to
@@ skipping 1156 matching lines @@
 {
     if (isContextLost())
         return;
     if (!size) {
         synthesizeGLError(GL_INVALID_VALUE, "bufferData", "size == 0");
         return;
     }
     bufferDataImpl(target, size, 0, usage);
 }
 
-void WebGLRenderingContextBase::bufferData(GLenum target, ArrayBuffer* data, GLenum usage)
+void WebGLRenderingContextBase::bufferData(GLenum target, DOMArrayBuffer* data, GLenum usage)
 {
     if (isContextLost())
         return;
     if (!data) {
         synthesizeGLError(GL_INVALID_VALUE, "bufferData", "no data");
         return;
     }
     bufferDataImpl(target, data->byteLength(), data->data(), usage);
 }
 
-void WebGLRenderingContextBase::bufferData(GLenum target, ArrayBufferView* data, GLenum usage)
+void WebGLRenderingContextBase::bufferData(GLenum target, DOMArrayBufferView* data, GLenum usage)
 {
     if (isContextLost())
         return;
     if (!data) {
         synthesizeGLError(GL_INVALID_VALUE, "bufferData", "no data");
         return;
     }
     bufferDataImpl(target, data->byteLength(), data->baseAddress(), usage);
 }
 
 void WebGLRenderingContextBase::bufferSubDataImpl(GLenum target, long long offset, GLsizeiptr size, const void* data)
 {
     WebGLBuffer* buffer = validateBufferDataTarget("bufferSubData", target);
     if (!buffer)
         return;
     if (!validateValueFitNonNegInt32("bufferSubData", "offset", offset))
         return;
     if (!data)
         return;
 
     webContext()->bufferSubData(target, static_cast<GLintptr>(offset), size, data);
 }
 
-void WebGLRenderingContextBase::bufferSubData(GLenum target, long long offset, ArrayBuffer* data)
+void WebGLRenderingContextBase::bufferSubData(GLenum target, long long offset, DOMArrayBuffer* data)
 {
     if (isContextLost())
         return;
     if (!data)
         return;
     bufferSubDataImpl(target, offset, data->byteLength(), data->data());
 }
 
-void WebGLRenderingContextBase::bufferSubData(GLenum target, long long offset, ArrayBufferView* data)
+void WebGLRenderingContextBase::bufferSubData(GLenum target, long long offset, DOMArrayBufferView* data)
 {
     if (isContextLost())
         return;
     if (!data)
         return;
     bufferSubDataImpl(target, offset, data->byteLength(), data->baseAddress());
 }
 
 GLenum WebGLRenderingContextBase::checkFramebufferStatus(GLenum target)
 {
@@ skipping 79 matching lines @@
     webContext()->colorMask(red, green, blue, alpha);
 }
 
 void WebGLRenderingContextBase::compileShader(WebGLShader* shader)
 {
     if (isContextLost() || !validateWebGLObject("compileShader", shader))
         return;
     webContext()->compileShader(objectOrZero(shader));
 }
 
-void WebGLRenderingContextBase::compressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, ArrayBufferView* data)
+void WebGLRenderingContextBase::compressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, DOMArrayBufferView* data)
 {
     if (isContextLost())
         return;
     if (!validateTexFuncLevel("compressedTexImage2D", target, level))
         return;
 
     if (!validateCompressedTexFormat(internalformat)) {
         synthesizeGLError(GL_INVALID_ENUM, "compressedTexImage2D", "invalid internalformat");
         return;
     }
@@ skipping 13 matching lines @@
         if (level && WebGLTexture::isNPOT(width, height)) {
             synthesizeGLError(GL_INVALID_VALUE, "compressedTexImage2D", "level > 0 not power of 2");
             return;
         }
     }
     webContext()->compressedTexImage2D(target, level, internalformat, width, height,
         border, data->byteLength(), data->baseAddress());
     tex->setLevelInfo(target, level, internalformat, width, height, GL_UNSIGNED_BYTE);
 }
 
-void WebGLRenderingContextBase::compressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, ArrayBufferView* data)
+void WebGLRenderingContextBase::compressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, DOMArrayBufferView* data)
 {
     if (isContextLost())
         return;
     if (!validateTexFuncLevel("compressedTexSubImage2D", target, level))
         return;
     if (!validateCompressedTexFormat(format)) {
         synthesizeGLError(GL_INVALID_ENUM, "compressedTexSubImage2D", "invalid format");
         return;
     }
     if (!validateCompressedTexFuncData("compressedTexSubImage2D", width, height, format, data))
@@ skipping 833 matching lines @@
         return getUnsignedIntParameter(pname);
     case GL_BLEND_SRC_RGB:
         return getUnsignedIntParameter(pname);
     case GL_BLUE_BITS:
         return getIntParameter(pname);
     case GL_COLOR_CLEAR_VALUE:
         return getWebGLFloatArrayParameter(pname);
     case GL_COLOR_WRITEMASK:
         return getBooleanArrayParameter(pname);
     case GL_COMPRESSED_TEXTURE_FORMATS:
-        return WebGLGetInfo(Uint32Array::create(m_compressedTextureFormats.data(), m_compressedTextureFormats.size()));
+        return WebGLGetInfo(DOMUint32Array::create(m_compressedTextureFormats.data(), m_compressedTextureFormats.size()));
     case GL_CULL_FACE:
         return getBooleanParameter(pname);
     case GL_CULL_FACE_MODE:
         return getUnsignedIntParameter(pname);
     case GL_CURRENT_PROGRAM:
         return WebGLGetInfo(PassRefPtrWillBeRawPtr<WebGLProgram>(m_currentProgram.get()));
     case GL_DEPTH_BITS:
         if (!m_framebufferBinding && !m_requestedAttributes->depth())
             return WebGLGetInfo(intZero);
         return getIntParameter(pname);
@@ skipping 491 matching lines @@
                     // Can't handle this type
                     synthesizeGLError(GL_INVALID_VALUE, "getUniform", "unhandled type");
                     return WebGLGetInfo();
                 }
                 switch (baseType) {
                 case GL_FLOAT: {
                     GLfloat value[16] = {0};
                     webContext()->getUniformfv(objectOrZero(program), location, value);
                     if (length == 1)
                         return WebGLGetInfo(value[0]);
-                    return WebGLGetInfo(Float32Array::create(value, length));
+                    return WebGLGetInfo(DOMFloat32Array::create(value, length));
                 }
                 case GL_INT: {
                     GLint value[4] = {0};
                     webContext()->getUniformiv(objectOrZero(program), location, value);
                     if (length == 1)
                         return WebGLGetInfo(value[0]);
-                    return WebGLGetInfo(Int32Array::create(value, length));
+                    return WebGLGetInfo(DOMInt32Array::create(value, length));
                 }
                 case GL_BOOL: {
                     GLint value[4] = {0};
                     webContext()->getUniformiv(objectOrZero(program), location, value);
                     if (length > 1) {
                         bool boolValue[16] = {0};
                         for (unsigned j = 0; j < length; j++)
                             boolValue[j] = static_cast<bool>(value[j]);
                         return WebGLGetInfo(boolValue, length);
                     }
@@ skipping 52 matching lines @@
         return WebGLGetInfo(state.enabled);
     case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
         return WebGLGetInfo(state.normalized);
     case GL_VERTEX_ATTRIB_ARRAY_SIZE:
         return WebGLGetInfo(state.size);
     case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
         return WebGLGetInfo(state.originalStride);
     case GL_VERTEX_ATTRIB_ARRAY_TYPE:
         return WebGLGetInfo(state.type);
     case GL_CURRENT_VERTEX_ATTRIB:
-        return WebGLGetInfo(Float32Array::create(m_vertexAttribValue[index].value, 4));
+        return WebGLGetInfo(DOMFloat32Array::create(m_vertexAttribValue[index].value, 4));
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getVertexAttrib", "invalid parameter name");
         return WebGLGetInfo();
     }
 }
 
 long long WebGLRenderingContextBase::getVertexAttribOffset(GLuint index, GLenum pname)
 {
     if (isContextLost())
         return 0;
@@ skipping 156 matching lines @@
     }
 }
 
 void WebGLRenderingContextBase::polygonOffset(GLfloat factor, GLfloat units)
 {
     if (isContextLost())
         return;
     webContext()->polygonOffset(factor, units);
 }
 
-void WebGLRenderingContextBase::readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, ArrayBufferView* pixels)
+void WebGLRenderingContextBase::readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, DOMArrayBufferView* pixels)
 {
     if (isContextLost())
         return;
     // Due to WebGL's same-origin restrictions, it is not possible to
     // taint the origin using the WebGL API.
     ASSERT(canvas()->originClean());
     // Validate input parameters.
     if (!pixels) {
         synthesizeGLError(GL_INVALID_VALUE, "readPixels", "no destination ArrayBufferView");
         return;
@@ skipping 373 matching lines @@
     }
 
     IntRect srcRect(IntPoint(), image->size());
     IntRect destRect(0, 0, size.width(), size.height());
     buf->context()->drawImage(image, destRect, srcRect);
     return buf->copyImage(ImageBuffer::fastCopyImageMode());
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target, GLint level, GLenum internalformat,
     GLsizei width, GLsizei height, GLint border,
-    GLenum format, GLenum type, ArrayBufferView* pixels, ExceptionState& exceptionState)
+    GLenum format, GLenum type, DOMArrayBufferView* pixels, ExceptionState& exceptionState)
 {
     if (isContextLost() || !validateTexFuncData("texImage2D", level, width, height, format, type, pixels, NullAllowed)
         || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceArrayBufferView, target, level, internalformat, width, height, border, format, type, 0, 0))
         return;
     void* data = pixels ? pixels->baseAddress() : 0;
     Vector<uint8_t> tempData;
     bool changeUnpackAlignment = false;
     if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
         if (!WebGLImageConversion::extractTextureData(width, height, format, type, m_unpackAlignment, m_unpackFlipY, m_unpackPremultiplyAlpha, data, tempData))
             return;
@@ skipping 236 matching lines @@
 
     if (m_unpackAlignment != 1)
         webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
     texSubImage2DBase(target, level, xoffset, yoffset, imageExtractor.imageWidth(), imageExtractor.imageHeight(), format, type,  needConversion ? data.data() : imagePixelData, exceptionState);
     if (m_unpackAlignment != 1)
         webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLsizei width, GLsizei height,
-    GLenum format, GLenum type, ArrayBufferView* pixels, ExceptionState& exceptionState)
+    GLenum format, GLenum type, DOMArrayBufferView* pixels, ExceptionState& exceptionState)
 {
     if (isContextLost() || !validateTexFuncData("texSubImage2D", level, width, height, format, type, pixels, NullNotAllowed)
         || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceArrayBufferView, target, level, format, width, height, 0, format, type, xoffset, yoffset))
         return;
     void* data = pixels->baseAddress();
     Vector<uint8_t> tempData;
     bool changeUnpackAlignment = false;
     if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
         if (!WebGLImageConversion::extractTextureData(width, height, format, type,
                                            m_unpackAlignment,
@@ skipping 85 matching lines @@
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform1f", "location not for current program");
         return;
     }
 
     webContext()->uniform1f(location->location(), x);
 }
 
-void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location, Float32Array* v)
+void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location, DOMFloat32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform1fv", location, v, 1))
         return;
 
     webContext()->uniform1fv(location->location(), v->length(), v->data());
 }
 
 void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location, GLfloat* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform1fv", location, v, size, 1))
         return;
 
     webContext()->uniform1fv(location->location(), size, v);
 }
 
 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;
     }
 
     webContext()->uniform1i(location->location(), x);
 }
 
-void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location, Int32Array* v)
+void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location, DOMInt32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform1iv", location, v, 1))
         return;
 
     webContext()->uniform1iv(location->location(), v->length(), v->data());
 }
 
 void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location, GLint* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform1iv", location, v, size, 1))
         return;
 
     webContext()->uniform1iv(location->location(), size, v);
 }
 
 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;
     }
 
     webContext()->uniform2f(location->location(), x, y);
 }
 
-void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location, Float32Array* v)
+void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location, DOMFloat32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform2fv", location, v, 2))
         return;
 
     webContext()->uniform2fv(location->location(), v->length() >> 1, v->data());
 }
 
 void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location, GLfloat* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform2fv", location, v, size, 2))
         return;
 
     webContext()->uniform2fv(location->location(), size >> 1, v);
 }
 
 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;
     }
 
     webContext()->uniform2i(location->location(), x, y);
 }
 
-void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location, Int32Array* v)
+void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location, DOMInt32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform2iv", location, v, 2))
         return;
 
     webContext()->uniform2iv(location->location(), v->length() >> 1, v->data());
 }
 
 void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location, GLint* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform2iv", location, v, size, 2))
         return;
 
     webContext()->uniform2iv(location->location(), size >> 1, v);
 }
 
 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;
     }
 
     webContext()->uniform3f(location->location(), x, y, z);
 }
 
-void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location, Float32Array* v)
+void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location, DOMFloat32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform3fv", location, v, 3))
         return;
 
     webContext()->uniform3fv(location->location(), v->length() / 3, v->data());
 }
 
 void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location, GLfloat* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform3fv", location, v, size, 3))
         return;
 
     webContext()->uniform3fv(location->location(), size / 3, v);
 }
 
 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;
     }
 
     webContext()->uniform3i(location->location(), x, y, z);
 }
 
-void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location, Int32Array* v)
+void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location, DOMInt32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform3iv", location, v, 3))
         return;
 
     webContext()->uniform3iv(location->location(), v->length() / 3, v->data());
 }
 
 void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location, GLint* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform3iv", location, v, size, 3))
         return;
 
     webContext()->uniform3iv(location->location(), size / 3, v);
 }
 
 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;
     }
 
     webContext()->uniform4f(location->location(), x, y, z, w);
 }
 
-void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location, Float32Array* v)
+void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location, DOMFloat32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform4fv", location, v, 4))
         return;
 
     webContext()->uniform4fv(location->location(), v->length() >> 2, v->data());
 }
 
 void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location, GLfloat* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform4fv", location, v, size, 4))
         return;
 
     webContext()->uniform4fv(location->location(), size >> 2, v);
 }
 
 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;
     }
 
     webContext()->uniform4i(location->location(), x, y, z, w);
 }
 
-void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location, Int32Array* v)
+void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location, DOMInt32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform4iv", location, v, 4))
         return;
 
     webContext()->uniform4iv(location->location(), v->length() >> 2, v->data());
 }
 
 void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location, GLint* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform4iv", location, v, size, 4))
         return;
 
     webContext()->uniform4iv(location->location(), size >> 2, v);
 }
 
-void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GLboolean transpose, Float32Array* v)
+void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GLboolean transpose, DOMFloat32Array* v)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, 4))
         return;
     webContext()->uniformMatrix2fv(location->location(), v->length() >> 2, transpose, v->data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GLboolean transpose, GLfloat* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, size, 4))
         return;
     webContext()->uniformMatrix2fv(location->location(), size >> 2, transpose, v);
 }
 
-void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GLboolean transpose, Float32Array* v)
+void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GLboolean transpose, DOMFloat32Array* v)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, 9))
         return;
     webContext()->uniformMatrix3fv(location->location(), v->length() / 9, transpose, v->data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GLboolean transpose, GLfloat* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, size, 9))
         return;
     webContext()->uniformMatrix3fv(location->location(), size / 9, transpose, v);
 }
 
-void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GLboolean transpose, Float32Array* v)
+void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GLboolean transpose, DOMFloat32Array* v)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, 16))
         return;
     webContext()->uniformMatrix4fv(location->location(), v->length() >> 4, transpose, v->data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GLboolean transpose, GLfloat* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, size, 16))
         return;
@@ skipping 26 matching lines @@
     if (isContextLost() || !validateWebGLObject("validateProgram", program))
         return;
     webContext()->validateProgram(objectOrZero(program));
 }
 
 void WebGLRenderingContextBase::vertexAttrib1f(GLuint index, GLfloat v0)
 {
     vertexAttribfImpl("vertexAttrib1f", index, 1, v0, 0.0f, 0.0f, 1.0f);
 }
 
-void WebGLRenderingContextBase::vertexAttrib1fv(GLuint index, Float32Array* v)
+void WebGLRenderingContextBase::vertexAttrib1fv(GLuint index, DOMFloat32Array* v)
 {
     vertexAttribfvImpl("vertexAttrib1fv", index, v, 1);
 }
 
 void WebGLRenderingContextBase::vertexAttrib1fv(GLuint index, GLfloat* v, GLsizei size)
 {
     vertexAttribfvImpl("vertexAttrib1fv", index, v, size, 1);
 }
 
 void WebGLRenderingContextBase::vertexAttrib2f(GLuint index, GLfloat v0, GLfloat v1)
 {
     vertexAttribfImpl("vertexAttrib2f", index, 2, v0, v1, 0.0f, 1.0f);
 }
 
-void WebGLRenderingContextBase::vertexAttrib2fv(GLuint index, Float32Array* v)
+void WebGLRenderingContextBase::vertexAttrib2fv(GLuint index, DOMFloat32Array* v)
 {
     vertexAttribfvImpl("vertexAttrib2fv", index, v, 2);
 }
 
 void WebGLRenderingContextBase::vertexAttrib2fv(GLuint index, GLfloat* v, GLsizei size)
 {
     vertexAttribfvImpl("vertexAttrib2fv", index, v, size, 2);
 }
 
 void WebGLRenderingContextBase::vertexAttrib3f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2)
 {
     vertexAttribfImpl("vertexAttrib3f", index, 3, v0, v1, v2, 1.0f);
 }
 
-void WebGLRenderingContextBase::vertexAttrib3fv(GLuint index, Float32Array* v)
+void WebGLRenderingContextBase::vertexAttrib3fv(GLuint index, DOMFloat32Array* v)
 {
     vertexAttribfvImpl("vertexAttrib3fv", index, v, 3);
 }
 
 void WebGLRenderingContextBase::vertexAttrib3fv(GLuint index, GLfloat* v, GLsizei size)
 {
     vertexAttribfvImpl("vertexAttrib3fv", index, v, size, 3);
 }
 
 void WebGLRenderingContextBase::vertexAttrib4f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
     vertexAttribfImpl("vertexAttrib4f", index, 4, v0, v1, v2, v3);
 }
 
-void WebGLRenderingContextBase::vertexAttrib4fv(GLuint index, Float32Array* v)
+void WebGLRenderingContextBase::vertexAttrib4fv(GLuint index, DOMFloat32Array* v)
 {
     vertexAttribfvImpl("vertexAttrib4fv", index, v, 4);
 }
 
 void WebGLRenderingContextBase::vertexAttrib4fv(GLuint index, GLfloat* v, GLsizei size)
 {
     vertexAttribfvImpl("vertexAttrib4fv", index, v, size, 4);
 }
 
 void WebGLRenderingContextBase::vertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, long long offset)
@@ skipping 253 matching lines @@
     case GL_DEPTH_RANGE:
         length = 2;
         break;
     case GL_BLEND_COLOR:
     case GL_COLOR_CLEAR_VALUE:
         length = 4;
         break;
     default:
         notImplemented();
     }
-    return WebGLGetInfo(Float32Array::create(value, length));
+    return WebGLGetInfo(DOMFloat32Array::create(value, length));
 }
 
 WebGLGetInfo WebGLRenderingContextBase::getWebGLIntArrayParameter(GLenum pname)
 {
     GLint value[4] = {0};
     if (!isContextLost())
         webContext()->getIntegerv(pname, value);
     unsigned length = 0;
     switch (pname) {
     case GL_MAX_VIEWPORT_DIMS:
         length = 2;
         break;
     case GL_SCISSOR_BOX:
     case GL_VIEWPORT:
         length = 4;
         break;
     default:
         notImplemented();
     }
-    return WebGLGetInfo(Int32Array::create(value, length));
+    return WebGLGetInfo(DOMInt32Array::create(value, length));
 }
 
 void WebGLRenderingContextBase::handleTextureCompleteness(const char* functionName, bool prepareToDraw)
 {
     // All calling functions check isContextLost, so a duplicate check is not needed here.
     bool resetActiveUnit = false;
     WebGLTexture::TextureExtensionFlag flag = static_cast<WebGLTexture::TextureExtensionFlag>((extensionEnabled(OESTextureFloatLinearName) ? WebGLTexture::TextureFloatLinearExtensionEnabled : 0)
         | (extensionEnabled(OESTextureHalfFloatLinearName) ? WebGLTexture::TextureHalfFloatLinearExtensionEnabled : 0));
     for (unsigned ii = 0; ii < m_onePlusMaxNonDefaultTextureUnit; ++ii) {
         if ((m_textureUnits[ii].m_texture2DBinding.get() && m_textureUnits[ii].m_texture2DBinding->needToUseBlackTexture(flag))
@@ skipping 337 matching lines @@
     }
 
     if (border) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "border != 0");
         return false;
     }
 
     return true;
 }
 
-bool WebGLRenderingContextBase::validateTexFuncData(const char* functionName, GLint level, GLsizei width, GLsizei height, GLenum format, GLenum type, ArrayBufferView* pixels, NullDisposition disposition)
+bool WebGLRenderingContextBase::validateTexFuncData(const char* functionName, GLint level, GLsizei width, GLsizei height, GLenum format, GLenum type, DOMArrayBufferView* pixels, NullDisposition disposition)
 {
     // All calling functions check isContextLost, so a duplicate check is not needed here.
     if (!pixels) {
         if (disposition == NullAllowed)
             return true;
         synthesizeGLError(GL_INVALID_VALUE, functionName, "no pixels");
         return false;
     }
 
     if (!validateTexFuncFormatAndType(functionName, format, type, level))
@@ skipping 18 matching lines @@
         break;
     case GL_FLOAT: // OES_texture_float
         if (pixels->type() != ArrayBufferView::TypeFloat32) {
             synthesizeGLError(GL_INVALID_OPERATION, functionName, "type FLOAT but ArrayBufferView not Float32Array");
             return false;
         }
         break;
     case GL_HALF_FLOAT_OES: // OES_texture_half_float
         // As per the specification, ArrayBufferView should be null or a Uint16Array when
         // OES_texture_half_float is enabled.
-        if (pixels && pixels->type() != ArrayBufferView::TypeUint16) {
+        if (pixels->type() != ArrayBufferView::TypeUint16) {
             synthesizeGLError(GL_INVALID_OPERATION, functionName, "type HALF_FLOAT_OES but ArrayBufferView is not NULL and not Uint16Array");
             return false;
         }
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
     unsigned totalBytesRequired;
     GLenum error = WebGLImageConversion::computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &totalBytesRequired, 0);
@@ skipping 13 matching lines @@
         return false;
     }
     return true;
 }
 
 bool WebGLRenderingContextBase::validateCompressedTexFormat(GLenum format)
 {
     return m_compressedTextureFormats.contains(format);
 }
 
-bool WebGLRenderingContextBase::validateCompressedTexFuncData(const char* functionName, GLsizei width, GLsizei height, GLenum format, ArrayBufferView* pixels)
+bool WebGLRenderingContextBase::validateCompressedTexFuncData(const char* functionName, GLsizei width, GLsizei height, GLenum format, DOMArrayBufferView* pixels)
 {
     if (!pixels) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "no pixels");
         return false;
     }
     if (width < 0 || height < 0) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "width or height < 0");
         return false;
     }
 
@@ skipping 292 matching lines @@
     case GL_SAMPLE_COVERAGE:
     case GL_SCISSOR_TEST:
     case GL_STENCIL_TEST:
         return true;
     default:
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid capability");
         return false;
     }
 }
 
-bool WebGLRenderingContextBase::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, Float32Array* v, GLsizei requiredMinSize)
+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, Int32Array* v, GLsizei 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)
 {
     return validateUniformMatrixParameters(functionName, location, false, v, size, requiredMinSize);
 }
 
-bool WebGLRenderingContextBase::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GLboolean transpose, Float32Array* v, GLsizei requiredMinSize)
+bool WebGLRenderingContextBase::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GLboolean transpose, DOMFloat32Array* v, GLsizei requiredMinSize)
 {
     if (!v) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "no array");
         return false;
     }
     return validateUniformMatrixParameters(functionName, location, transpose, v->data(), v->length(), requiredMinSize);
 }
 
 bool WebGLRenderingContextBase::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GLboolean transpose, void* v, GLsizei size, GLsizei requiredMinSize)
 {
@@ skipping 202 matching lines @@
         webContext()->vertexAttrib4f(index, v0, v1, v2, v3);
         break;
     }
     VertexAttribValue& attribValue = m_vertexAttribValue[index];
     attribValue.value[0] = v0;
     attribValue.value[1] = v1;
     attribValue.value[2] = v2;
     attribValue.value[3] = v3;
 }
 
-void WebGLRenderingContextBase::vertexAttribfvImpl(const char* functionName, GLuint index, Float32Array* v, GLsizei expectedSize)
+void WebGLRenderingContextBase::vertexAttribfvImpl(const char* functionName, GLuint index, DOMFloat32Array* v, GLsizei expectedSize)
 {
     if (isContextLost())
         return;
     if (!v) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "no array");
         return;
     }
     vertexAttribfvImpl(functionName, index, v->data(), v->length(), expectedSize);
 }
 
@@ skipping 336 matching lines @@
     return m_sharedWebGraphicsContext3D ? m_sharedWebGraphicsContext3D->drawingBuffer() : 0;
 }
 #else
 DrawingBuffer* WebGLRenderingContextBase::drawingBuffer() const
 {
     return m_drawingBuffer.get();
 }
 #endif
 
 } // namespace blink