[SharedArrayBuffer] Prevent SharedArrayBuffer being used in Web APIs

third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp

Index: third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp
diff --git a/third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp b/third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp
index a3da846049bfe5db49feaba7ced2aecc5124e88d..2e4d08e3517505ff324c0dfa3537013d9e1ef600 100644
--- a/third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp
+++ b/third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp
@@ -248,17 +248,18 @@ void WebGL2RenderingContextBase::initializeNewContext() {
   WebGLRenderingContextBase::initializeNewContext();
 }
 
-void WebGL2RenderingContextBase::bufferData(GLenum target,
-                                            DOMArrayBufferView* srcData,
-                                            GLenum usage,
-                                            GLuint srcOffset,
-                                            GLuint length) {
+void WebGL2RenderingContextBase::bufferData(
+    GLenum target,
+    const NotShared<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)) {
+  if (!validateSubSourceAndGetData(srcData.view(), srcOffset, length,
+                                   &subBaseAddress, &subByteLength)) {
     synthesizeGLError(GL_INVALID_VALUE, "bufferData",
                       "srcOffset + length too large");
     return;
@@ -278,23 +279,25 @@ void WebGL2RenderingContextBase::bufferData(GLenum target,
   WebGLRenderingContextBase::bufferData(target, data, usage);
 }
 
-void WebGL2RenderingContextBase::bufferData(GLenum target,
-                                            DOMArrayBufferView* data,
-                                            GLenum usage) {
+void WebGL2RenderingContextBase::bufferData(
+    GLenum target,
+    const NotShared<DOMArrayBufferView>& data,
+    GLenum usage) {
   WebGLRenderingContextBase::bufferData(target, data, usage);
 }
 
-void WebGL2RenderingContextBase::bufferSubData(GLenum target,
-                                               GLintptr dstByteOffset,
-                                               DOMArrayBufferView* srcData,
-                                               GLuint srcOffset,
-                                               GLuint length) {
+void WebGL2RenderingContextBase::bufferSubData(
+    GLenum target,
+    GLintptr dstByteOffset,
+    const NotShared<DOMArrayBufferView>& srcData,
+    GLuint srcOffset,
+    GLuint length) {
   if (isContextLost())
     return;
   void* subBaseAddress = nullptr;
   long long subByteLength = 0;
-  if (!validateSubSourceAndGetData(srcData, srcOffset, length, &subBaseAddress,
-                                   &subByteLength)) {
+  if (!validateSubSourceAndGetData(srcData.view(), srcOffset, length,
+                                   &subBaseAddress, &subByteLength)) {
     synthesizeGLError(GL_INVALID_VALUE, "bufferSubData",
                       "srcOffset + length too large");
     return;
@@ -365,16 +368,17 @@ void WebGL2RenderingContextBase::copyBufferSubData(GLenum readTarget,
       static_cast<GLintptr>(writeOffset), static_cast<GLsizeiptr>(size));
 }
 
-void WebGL2RenderingContextBase::getBufferSubData(GLenum target,
-                                                  long long srcByteOffset,
-                                                  DOMArrayBufferView* dstData,
-                                                  GLuint dstOffset,
-                                                  GLuint length) {
+void WebGL2RenderingContextBase::getBufferSubData(
+    GLenum target,
+    long long srcByteOffset,
+    const NotShared<DOMArrayBufferView>& dstData,
+    GLuint dstOffset,
+    GLuint length) {
   WebGLBuffer* sourceBuffer = nullptr;
   void* destinationDataPtr = nullptr;
   long long destinationByteLength = 0;
   const char* message = validateGetBufferSubData(
-      __FUNCTION__, target, srcByteOffset, dstData, dstOffset, length,
+      __FUNCTION__, target, srcByteOffset, dstData.view(), dstOffset, length,
       &sourceBuffer, &destinationDataPtr, &destinationByteLength);
   if (message) {
     // If there was a GL error, it was already synthesized in
@@ -765,13 +769,14 @@ void WebGL2RenderingContextBase::pixelStorei(GLenum pname, GLint param) {
   contextGL()->PixelStorei(pname, param);
 }
 
-void WebGL2RenderingContextBase::readPixels(GLint x,
-                                            GLint y,
-                                            GLsizei width,
-                                            GLsizei height,
-                                            GLenum format,
-                                            GLenum type,
-                                            DOMArrayBufferView* pixels) {
+void WebGL2RenderingContextBase::readPixels(
+    GLint x,
+    GLint y,
+    GLsizei width,
+    GLsizei height,
+    GLenum format,
+    GLenum type,
+    const NotShared<DOMArrayBufferView>& pixels) {
   if (isContextLost())
     return;
   if (m_boundPixelPackBuffer.get()) {
@@ -780,17 +785,18 @@ void WebGL2RenderingContextBase::readPixels(GLint x,
     return;
   }
 
-  readPixelsHelper(x, y, width, height, format, type, pixels, 0);
+  readPixelsHelper(x, y, width, height, format, type, pixels.view(), 0);
 }
 
-void WebGL2RenderingContextBase::readPixels(GLint x,
-                                            GLint y,
-                                            GLsizei width,
-                                            GLsizei height,
-                                            GLenum format,
-                                            GLenum type,
-                                            DOMArrayBufferView* pixels,
-                                            GLuint offset) {
+void WebGL2RenderingContextBase::readPixels(
+    GLint x,
+    GLint y,
+    GLsizei width,
+    GLsizei height,
+    GLenum format,
+    GLenum type,
+    const NotShared<DOMArrayBufferView>& pixels,
+    GLuint offset) {
   if (isContextLost())
     return;
   if (m_boundPixelPackBuffer.get()) {
@@ -799,7 +805,7 @@ void WebGL2RenderingContextBase::readPixels(GLint x,
     return;
   }
 
-  readPixelsHelper(x, y, width, height, format, type, pixels, offset);
+  readPixelsHelper(x, y, width, height, format, type, pixels.view(), offset);
 }
 
 void WebGL2RenderingContextBase::readPixels(GLint x,
@@ -1142,15 +1148,16 @@ void WebGL2RenderingContextBase::texSubImage2D(GLenum target,
                              reinterpret_cast<const void*>(offset));
 }
 
-void WebGL2RenderingContextBase::texImage2D(GLenum target,
-                                            GLint level,
-                                            GLint internalformat,
-                                            GLsizei width,
-                                            GLsizei height,
-                                            GLint border,
-                                            GLenum format,
-                                            GLenum type,
-                                            DOMArrayBufferView* data) {
+void WebGL2RenderingContextBase::texImage2D(
+    GLenum target,
+    GLint level,
+    GLint internalformat,
+    GLsizei width,
+    GLsizei height,
+    GLint border,
+    GLenum format,
+    GLenum type,
+    const NotShared<DOMArrayBufferView>& data) {
   if (isContextLost())
     return;
   if (m_boundPixelUnpackBuffer) {
@@ -1162,16 +1169,17 @@ void WebGL2RenderingContextBase::texImage2D(GLenum target,
                                         height, border, format, type, data);
 }
 
-void WebGL2RenderingContextBase::texImage2D(GLenum target,
-                                            GLint level,
-                                            GLint internalformat,
-                                            GLsizei width,
-                                            GLsizei height,
-                                            GLint border,
-                                            GLenum format,
-                                            GLenum type,
-                                            DOMArrayBufferView* data,
-                                            GLuint srcOffset) {
+void WebGL2RenderingContextBase::texImage2D(
+    GLenum target,
+    GLint level,
+    GLint internalformat,
+    GLsizei width,
+    GLsizei height,
+    GLint border,
+    GLenum format,
+    GLenum type,
+    const NotShared<DOMArrayBufferView>& data,
+    GLuint srcOffset) {
   if (isContextLost())
     return;
   if (m_boundPixelUnpackBuffer) {
@@ -1181,7 +1189,7 @@ void WebGL2RenderingContextBase::texImage2D(GLenum target,
   }
   texImageHelperDOMArrayBufferView(TexImage2D, target, level, internalformat,
                                    width, height, 1, border, format, type, 0, 0,
-                                   0, data, NullNotReachable, srcOffset);
+                                   0, data.view(), NullNotReachable, srcOffset);
 }
 
 void WebGL2RenderingContextBase::texImage2D(GLenum target,
@@ -1385,15 +1393,16 @@ void WebGL2RenderingContextBase::texImage2D(GLenum target,
                                         type, imageBitMap, exceptionState);
 }
 
-void WebGL2RenderingContextBase::texSubImage2D(GLenum target,
-                                               GLint level,
-                                               GLint xoffset,
-                                               GLint yoffset,
-                                               GLsizei width,
-                                               GLsizei height,
-                                               GLenum format,
-                                               GLenum type,
-                                               DOMArrayBufferView* pixels) {
+void WebGL2RenderingContextBase::texSubImage2D(
+    GLenum target,
+    GLint level,
+    GLint xoffset,
+    GLint yoffset,
+    GLsizei width,
+    GLsizei height,
+    GLenum format,
+    GLenum type,
+    const NotShared<DOMArrayBufferView>& pixels) {
   if (isContextLost())
     return;
   if (m_boundPixelUnpackBuffer) {
@@ -1405,16 +1414,17 @@ void WebGL2RenderingContextBase::texSubImage2D(GLenum target,
                                            width, height, format, type, pixels);
 }
 
-void WebGL2RenderingContextBase::texSubImage2D(GLenum target,
-                                               GLint level,
-                                               GLint xoffset,
-                                               GLint yoffset,
-                                               GLsizei width,
-                                               GLsizei height,
-                                               GLenum format,
-                                               GLenum type,
-                                               DOMArrayBufferView* pixels,
-                                               GLuint srcOffset) {
+void WebGL2RenderingContextBase::texSubImage2D(
+    GLenum target,
+    GLint level,
+    GLint xoffset,
+    GLint yoffset,
+    GLsizei width,
+    GLsizei height,
+    GLenum format,
+    GLenum type,
+    const NotShared<DOMArrayBufferView>& pixels,
+    GLuint srcOffset) {
   if (isContextLost())
     return;
   if (m_boundPixelUnpackBuffer) {
@@ -1422,9 +1432,9 @@ void WebGL2RenderingContextBase::texSubImage2D(GLenum target,
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  texImageHelperDOMArrayBufferView(TexSubImage2D, target, level, 0, width,
-                                   height, 1, 0, format, type, xoffset, yoffset,
-                                   0, pixels, NullNotReachable, srcOffset);
+  texImageHelperDOMArrayBufferView(
+      TexSubImage2D, target, level, 0, width, height, 1, 0, format, type,
+      xoffset, yoffset, 0, pixels.view(), NullNotReachable, srcOffset);
 }
 
 void WebGL2RenderingContextBase::texSubImage2D(GLenum target,
@@ -1655,32 +1665,34 @@ void WebGL2RenderingContextBase::texStorage3D(GLenum target,
                             depth);
 }
 
-void WebGL2RenderingContextBase::texImage3D(GLenum target,
-                                            GLint level,
-                                            GLint internalformat,
-                                            GLsizei width,
-                                            GLsizei height,
-                                            GLsizei depth,
-                                            GLint border,
-                                            GLenum format,
-                                            GLenum type,
-                                            DOMArrayBufferView* pixels) {
+void WebGL2RenderingContextBase::texImage3D(
+    GLenum target,
+    GLint level,
+    GLint internalformat,
+    GLsizei width,
+    GLsizei height,
+    GLsizei depth,
+    GLint border,
+    GLenum format,
+    GLenum type,
+    const NotShared<DOMArrayBufferView>& pixels) {
   texImageHelperDOMArrayBufferView(TexImage3D, target, level, internalformat,
                                    width, height, depth, border, format, type,
-                                   0, 0, 0, pixels, NullAllowed, 0);
+                                   0, 0, 0, pixels.view(), NullAllowed, 0);
 }
 
-void WebGL2RenderingContextBase::texImage3D(GLenum target,
-                                            GLint level,
-                                            GLint internalformat,
-                                            GLsizei width,
-                                            GLsizei height,
-                                            GLsizei depth,
-                                            GLint border,
-                                            GLenum format,
-                                            GLenum type,
-                                            DOMArrayBufferView* pixels,
-                                            GLuint srcOffset) {
+void WebGL2RenderingContextBase::texImage3D(
+    GLenum target,
+    GLint level,
+    GLint internalformat,
+    GLsizei width,
+    GLsizei height,
+    GLsizei depth,
+    GLint border,
+    GLenum format,
+    GLenum type,
+    const NotShared<DOMArrayBufferView>& pixels,
+    GLuint srcOffset) {
   if (isContextLost())
     return;
   if (m_boundPixelUnpackBuffer) {
@@ -1690,7 +1702,7 @@ void WebGL2RenderingContextBase::texImage3D(GLenum target,
   }
   texImageHelperDOMArrayBufferView(
       TexImage3D, target, level, internalformat, width, height, depth, border,
-      format, type, 0, 0, 0, pixels, NullNotReachable, srcOffset);
+      format, type, 0, 0, 0, pixels.view(), NullNotReachable, srcOffset);
 }
 
 void WebGL2RenderingContextBase::texImage3D(GLenum target,
@@ -1840,18 +1852,19 @@ void WebGL2RenderingContextBase::texImage3D(GLenum target,
                             m_unpackImageHeight, exceptionState);
 }
 
-void WebGL2RenderingContextBase::texSubImage3D(GLenum target,
-                                               GLint level,
-                                               GLint xoffset,
-                                               GLint yoffset,
-                                               GLint zoffset,
-                                               GLsizei width,
-                                               GLsizei height,
-                                               GLsizei depth,
-                                               GLenum format,
-                                               GLenum type,
-                                               DOMArrayBufferView* pixels,
-                                               GLuint srcOffset) {
+void WebGL2RenderingContextBase::texSubImage3D(
+    GLenum target,
+    GLint level,
+    GLint xoffset,
+    GLint yoffset,
+    GLint zoffset,
+    GLsizei width,
+    GLsizei height,
+    GLsizei depth,
+    GLenum format,
+    GLenum type,
+    const NotShared<DOMArrayBufferView>& pixels,
+    GLuint srcOffset) {
   if (isContextLost())
     return;
   if (m_boundPixelUnpackBuffer) {
@@ -1861,7 +1874,7 @@ void WebGL2RenderingContextBase::texSubImage3D(GLenum target,
   }
   texImageHelperDOMArrayBufferView(
       TexSubImage3D, target, level, 0, width, height, depth, 0, format, type,
-      xoffset, yoffset, zoffset, pixels, NullNotReachable, srcOffset);
+      xoffset, yoffset, zoffset, pixels.view(), NullNotReachable, srcOffset);
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(GLenum target,
@@ -2051,7 +2064,7 @@ void WebGL2RenderingContextBase::compressedTexImage2D(
     GLsizei width,
     GLsizei height,
     GLint border,
-    DOMArrayBufferView* data) {
+    const NotShared<DOMArrayBufferView>& data) {
   if (isContextLost())
     return;
   if (m_boundPixelUnpackBuffer) {
@@ -2070,7 +2083,7 @@ void WebGL2RenderingContextBase::compressedTexImage2D(
     GLsizei width,
     GLsizei height,
     GLint border,
-    DOMArrayBufferView* data,
+    const NotShared<DOMArrayBufferView>& data,
     GLuint srcOffset,
     GLuint srcLengthOverride) {
   if (isContextLost())
@@ -2084,21 +2097,21 @@ void WebGL2RenderingContextBase::compressedTexImage2D(
     return;
   if (!validateCompressedTexFormat("compressedTexImage2D", internalformat))
     return;
-  if (srcOffset > data->byteLength()) {
+  if (srcOffset > data.view()->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) {
+    srcLengthOverride = data.view()->byteLength() - srcOffset;
+  } else if (srcLengthOverride > data.view()->byteLength() - srcOffset) {
     synthesizeGLError(GL_INVALID_VALUE, "compressedTexImage2D",
                       "srcLengthOverride is out of range");
     return;
   }
   contextGL()->CompressedTexImage2D(
       target, level, internalformat, width, height, border, srcLengthOverride,
-      static_cast<uint8_t*>(data->baseAddress()) + srcOffset);
+      static_cast<uint8_t*>(data.view()->baseAddress()) + srcOffset);
 }
 
 void WebGL2RenderingContextBase::compressedTexImage2D(GLenum target,
@@ -2129,7 +2142,7 @@ void WebGL2RenderingContextBase::compressedTexSubImage2D(
     GLsizei width,
     GLsizei height,
     GLenum format,
-    DOMArrayBufferView* data) {
+    const NotShared<DOMArrayBufferView>& data) {
   if (isContextLost())
     return;
   if (m_boundPixelUnpackBuffer) {
@@ -2149,7 +2162,7 @@ void WebGL2RenderingContextBase::compressedTexSubImage2D(
     GLsizei width,
     GLsizei height,
     GLenum format,
-    DOMArrayBufferView* data,
+    const NotShared<DOMArrayBufferView>& data,
     GLuint srcOffset,
     GLuint srcLengthOverride) {
   if (isContextLost())
@@ -2163,21 +2176,21 @@ void WebGL2RenderingContextBase::compressedTexSubImage2D(
     return;
   if (!validateCompressedTexFormat("compressedTexSubImage2D", format))
     return;
-  if (srcOffset > data->byteLength()) {
+  if (srcOffset > data.view()->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) {
+    srcLengthOverride = data.view()->byteLength() - srcOffset;
+  } else if (srcLengthOverride > data.view()->byteLength() - srcOffset) {
     synthesizeGLError(GL_INVALID_VALUE, "compressedTexImage2D",
                       "srcLengthOverride is out of range");
     return;
   }
   contextGL()->CompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, srcLengthOverride,
-      static_cast<uint8_t*>(data->baseAddress()) + srcOffset);
+      static_cast<uint8_t*>(data.view()->baseAddress()) + srcOffset);
 }
 
 void WebGL2RenderingContextBase::compressedTexSubImage2D(GLenum target,
@@ -2209,7 +2222,7 @@ void WebGL2RenderingContextBase::compressedTexImage3D(
     GLsizei height,
     GLsizei depth,
     GLint border,
-    DOMArrayBufferView* data,
+    const NotShared<DOMArrayBufferView>& data,
     GLuint srcOffset,
     GLuint srcLengthOverride) {
   if (isContextLost())
@@ -2223,14 +2236,14 @@ void WebGL2RenderingContextBase::compressedTexImage3D(
     return;
   if (!validateCompressedTexFormat("compressedTexImage3D", internalformat))
     return;
-  if (srcOffset > data->byteLength()) {
+  if (srcOffset > data.view()->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) {
+    srcLengthOverride = data.view()->byteLength() - srcOffset;
+  } else if (srcLengthOverride > data.view()->byteLength() - srcOffset) {
     synthesizeGLError(GL_INVALID_VALUE, "compressedTexImage3D",
                       "srcLengthOverride is out of range");
     return;
@@ -2238,7 +2251,7 @@ void WebGL2RenderingContextBase::compressedTexImage3D(
   contextGL()->CompressedTexImage3D(
       target, level, internalformat, width, height, depth, border,
       srcLengthOverride,
-      static_cast<uint8_t*>(data->baseAddress()) + srcOffset);
+      static_cast<uint8_t*>(data.view()->baseAddress()) + srcOffset);
 }
 
 void WebGL2RenderingContextBase::compressedTexImage3D(GLenum target,
@@ -2272,7 +2285,7 @@ void WebGL2RenderingContextBase::compressedTexSubImage3D(
     GLsizei height,
     GLsizei depth,
     GLenum format,
-    DOMArrayBufferView* data,
+    const NotShared<DOMArrayBufferView>& data,
     GLuint srcOffset,
     GLuint srcLengthOverride) {
   if (isContextLost())
@@ -2286,14 +2299,14 @@ void WebGL2RenderingContextBase::compressedTexSubImage3D(
     return;
   if (!validateCompressedTexFormat("compressedTexSubImage3D", format))
     return;
-  if (srcOffset > data->byteLength()) {
+  if (srcOffset > data.view()->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) {
+    srcLengthOverride = data.view()->byteLength() - srcOffset;
+  } else if (srcLengthOverride > data.view()->byteLength() - srcOffset) {
     synthesizeGLError(GL_INVALID_VALUE, "compressedTexSubImage3D",
                       "srcLengthOverride is out of range");
     return;
@@ -2301,7 +2314,7 @@ void WebGL2RenderingContextBase::compressedTexSubImage3D(
   contextGL()->CompressedTexSubImage3D(
       target, level, xoffset, yoffset, zoffset, width, height, depth, format,
       srcLengthOverride,
-      static_cast<uint8_t*>(data->baseAddress()) + srcOffset);
+      static_cast<uint8_t*>(data.view()->baseAddress()) + srcOffset);
 }
 
 void WebGL2RenderingContextBase::compressedTexSubImage3D(GLenum target,
@@ -2777,17 +2790,17 @@ void WebGL2RenderingContextBase::uniform4uiv(
 void WebGL2RenderingContextBase::uniformMatrix2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    DOMFloat32Array* v,
+    const NotShared<DOMFloat32Array>& v,
     GLuint srcOffset,
     GLuint srcLength) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose,
-                                       v, 4, srcOffset, srcLength))
+                                       v.view(), 4, srcOffset, srcLength))
     return;
   contextGL()->UniformMatrix2fv(
       location->location(),
-      (srcLength ? srcLength : (v->length() - srcOffset)) >> 2, transpose,
-      v->data() + srcOffset);
+      (srcLength ? srcLength : (v.view()->length() - srcOffset)) >> 2,
+      transpose, v.view()->data() + srcOffset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2fv(
@@ -2810,17 +2823,17 @@ void WebGL2RenderingContextBase::uniformMatrix2fv(
 void WebGL2RenderingContextBase::uniformMatrix3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    DOMFloat32Array* v,
+    const NotShared<DOMFloat32Array>& v,
     GLuint srcOffset,
     GLuint srcLength) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose,
-                                       v, 9, srcOffset, srcLength))
+                                       v.view(), 9, srcOffset, srcLength))
     return;
   contextGL()->UniformMatrix3fv(
       location->location(),
-      (srcLength ? srcLength : (v->length() - srcOffset)) / 9, transpose,
-      v->data() + srcOffset);
+      (srcLength ? srcLength : (v.view()->length() - srcOffset)) / 9, transpose,
+      v.view()->data() + srcOffset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3fv(
@@ -2843,17 +2856,17 @@ void WebGL2RenderingContextBase::uniformMatrix3fv(
 void WebGL2RenderingContextBase::uniformMatrix4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    DOMFloat32Array* v,
+    const NotShared<DOMFloat32Array>& v,
     GLuint srcOffset,
     GLuint srcLength) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose,
-                                       v, 16, srcOffset, srcLength))
+                                       v.view(), 16, srcOffset, srcLength))
     return;
   contextGL()->UniformMatrix4fv(
       location->location(),
-      (srcLength ? srcLength : (v->length() - srcOffset)) >> 4, transpose,
-      v->data() + srcOffset);
+      (srcLength ? srcLength : (v.view()->length() - srcOffset)) >> 4,
+      transpose, v.view()->data() + srcOffset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4fv(
@@ -2876,18 +2889,17 @@ void WebGL2RenderingContextBase::uniformMatrix4fv(
 void WebGL2RenderingContextBase::uniformMatrix2x3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    DOMFloat32Array* value,
+    const NotShared<DOMFloat32Array>& value,
     GLuint srcOffset,
     GLuint srcLength) {
-  if (isContextLost() ||
-      !validateUniformMatrixParameters("uniformMatrix2x3fv", location,
-                                       transpose, value, 6, srcOffset,
-                                       srcLength))
+  if (isContextLost() || !validateUniformMatrixParameters(
+                             "uniformMatrix2x3fv", location, transpose,
+                             value.view(), 6, srcOffset, srcLength))
     return;
   contextGL()->UniformMatrix2x3fv(
       location->location(),
-      (srcLength ? srcLength : (value->length() - srcOffset)) / 6, transpose,
-      value->data() + srcOffset);
+      (srcLength ? srcLength : (value.view()->length() - srcOffset)) / 6,
+      transpose, value.view()->data() + srcOffset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2x3fv(
@@ -2910,18 +2922,17 @@ void WebGL2RenderingContextBase::uniformMatrix2x3fv(
 void WebGL2RenderingContextBase::uniformMatrix3x2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    DOMFloat32Array* value,
+    const NotShared<DOMFloat32Array>& value,
     GLuint srcOffset,
     GLuint srcLength) {
-  if (isContextLost() ||
-      !validateUniformMatrixParameters("uniformMatrix3x2fv", location,
-                                       transpose, value, 6, srcOffset,
-                                       srcLength))
+  if (isContextLost() || !validateUniformMatrixParameters(
+                             "uniformMatrix3x2fv", location, transpose,
+                             value.view(), 6, srcOffset, srcLength))
     return;
   contextGL()->UniformMatrix3x2fv(
       location->location(),
-      (srcLength ? srcLength : (value->length() - srcOffset)) / 6, transpose,
-      value->data() + srcOffset);
+      (srcLength ? srcLength : (value.view()->length() - srcOffset)) / 6,
+      transpose, value.view()->data() + srcOffset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3x2fv(
@@ -2944,18 +2955,17 @@ void WebGL2RenderingContextBase::uniformMatrix3x2fv(
 void WebGL2RenderingContextBase::uniformMatrix2x4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    DOMFloat32Array* value,
+    const NotShared<DOMFloat32Array>& value,
     GLuint srcOffset,
     GLuint srcLength) {
-  if (isContextLost() ||
-      !validateUniformMatrixParameters("uniformMatrix2x4fv", location,
-                                       transpose, value, 8, srcOffset,
-                                       srcLength))
+  if (isContextLost() || !validateUniformMatrixParameters(
+                             "uniformMatrix2x4fv", location, transpose,
+                             value.view(), 8, srcOffset, srcLength))
     return;
   contextGL()->UniformMatrix2x4fv(
       location->location(),
-      (srcLength ? srcLength : (value->length() - srcOffset)) >> 3, transpose,
-      value->data() + srcOffset);
+      (srcLength ? srcLength : (value.view()->length() - srcOffset)) >> 3,
+      transpose, value.view()->data() + srcOffset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2x4fv(
@@ -2978,18 +2988,17 @@ void WebGL2RenderingContextBase::uniformMatrix2x4fv(
 void WebGL2RenderingContextBase::uniformMatrix4x2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    DOMFloat32Array* value,
+    const NotShared<DOMFloat32Array>& value,
     GLuint srcOffset,
     GLuint srcLength) {
-  if (isContextLost() ||
-      !validateUniformMatrixParameters("uniformMatrix4x2fv", location,
-                                       transpose, value, 8, srcOffset,
-                                       srcLength))
+  if (isContextLost() || !validateUniformMatrixParameters(
+                             "uniformMatrix4x2fv", location, transpose,
+                             value.view(), 8, srcOffset, srcLength))
     return;
   contextGL()->UniformMatrix4x2fv(
       location->location(),
-      (srcLength ? srcLength : (value->length() - srcOffset)) >> 3, transpose,
-      value->data() + srcOffset);
+      (srcLength ? srcLength : (value.view()->length() - srcOffset)) >> 3,
+      transpose, value.view()->data() + srcOffset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4x2fv(
@@ -3012,18 +3021,17 @@ void WebGL2RenderingContextBase::uniformMatrix4x2fv(
 void WebGL2RenderingContextBase::uniformMatrix3x4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    DOMFloat32Array* value,
+    const NotShared<DOMFloat32Array>& value,
     GLuint srcOffset,
     GLuint srcLength) {
-  if (isContextLost() ||
-      !validateUniformMatrixParameters("uniformMatrix3x4fv", location,
-                                       transpose, value, 12, srcOffset,
-                                       srcLength))
+  if (isContextLost() || !validateUniformMatrixParameters(
+                             "uniformMatrix3x4fv", location, transpose,
+                             value.view(), 12, srcOffset, srcLength))
     return;
   contextGL()->UniformMatrix3x4fv(
       location->location(),
-      (srcLength ? srcLength : (value->length() - srcOffset)) / 12, transpose,
-      value->data() + srcOffset);
+      (srcLength ? srcLength : (value.view()->length() - srcOffset)) / 12,
+      transpose, value.view()->data() + srcOffset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3x4fv(
@@ -3046,18 +3054,17 @@ void WebGL2RenderingContextBase::uniformMatrix3x4fv(
 void WebGL2RenderingContextBase::uniformMatrix4x3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    DOMFloat32Array* value,
+    const NotShared<DOMFloat32Array>& value,
     GLuint srcOffset,
     GLuint srcLength) {
-  if (isContextLost() ||
-      !validateUniformMatrixParameters("uniformMatrix4x3fv", location,
-                                       transpose, value, 12, srcOffset,
-                                       srcLength))
+  if (isContextLost() || !validateUniformMatrixParameters(
+                             "uniformMatrix4x3fv", location, transpose,
+                             value.view(), 12, srcOffset, srcLength))
     return;
   contextGL()->UniformMatrix4x3fv(
       location->location(),
-      (srcLength ? srcLength : (value->length() - srcOffset)) / 12, transpose,
-      value->data() + srcOffset);
+      (srcLength ? srcLength : (value.view()->length() - srcOffset)) / 12,
+      transpose, value.view()->data() + srcOffset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4x3fv(
@@ -3176,7 +3183,7 @@ void WebGL2RenderingContextBase::uniform4iv(
 void WebGL2RenderingContextBase::uniformMatrix2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    DOMFloat32Array* v) {
+    const NotShared<DOMFloat32Array>& v) {
   WebGLRenderingContextBase::uniformMatrix2fv(location, transpose, v);
 }
 
@@ -3190,7 +3197,7 @@ void WebGL2RenderingContextBase::uniformMatrix2fv(
 void WebGL2RenderingContextBase::uniformMatrix3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    DOMFloat32Array* v) {
+    const NotShared<DOMFloat32Array>& v) {
   WebGLRenderingContextBase::uniformMatrix3fv(location, transpose, v);
 }
 
@@ -3204,7 +3211,7 @@ void WebGL2RenderingContextBase::uniformMatrix3fv(
 void WebGL2RenderingContextBase::uniformMatrix4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    DOMFloat32Array* v) {
+    const NotShared<DOMFloat32Array>& v) {
   WebGLRenderingContextBase::uniformMatrix4fv(location, transpose, v);
 }
 
@@ -3226,15 +3233,16 @@ void WebGL2RenderingContextBase::vertexAttribI4i(GLuint index,
   setVertexAttribType(index, Int32ArrayType);
 }
 
-void WebGL2RenderingContextBase::vertexAttribI4iv(GLuint index,
-                                                  const DOMInt32Array* v) {
+void WebGL2RenderingContextBase::vertexAttribI4iv(
+    GLuint index,
+    const NotShared<const DOMInt32Array>& v) {
   if (isContextLost())
     return;
-  if (!v || v->length() < 4) {
+  if (!v.view() || v.view()->length() < 4) {
     synthesizeGLError(GL_INVALID_VALUE, "vertexAttribI4iv", "invalid array");
     return;
   }
-  contextGL()->VertexAttribI4iv(index, v->data());
+  contextGL()->VertexAttribI4iv(index, v.view()->data());
   setVertexAttribType(index, Int32ArrayType);
 }
 
@@ -3261,15 +3269,16 @@ void WebGL2RenderingContextBase::vertexAttribI4ui(GLuint index,
   setVertexAttribType(index, Uint32ArrayType);
 }
 
-void WebGL2RenderingContextBase::vertexAttribI4uiv(GLuint index,
-                                                   const DOMUint32Array* v) {
+void WebGL2RenderingContextBase::vertexAttribI4uiv(
+    GLuint index,
+    const NotShared<const DOMUint32Array>& v) {
   if (isContextLost())
     return;
-  if (!v || v->length() < 4) {
+  if (!v.view() || v.view()->length() < 4) {
     synthesizeGLError(GL_INVALID_VALUE, "vertexAttribI4uiv", "invalid array");
     return;
   }
-  contextGL()->VertexAttribI4uiv(index, v->data());
+  contextGL()->VertexAttribI4uiv(index, v.view()->data());
   setVertexAttribType(index, Uint32ArrayType);
 }
 
@@ -3482,14 +3491,15 @@ WebGLTexture* WebGL2RenderingContextBase::validateTexImageBinding(
   return validateTexture2DBinding(funcName, target);
 }
 
-void WebGL2RenderingContextBase::clearBufferiv(GLenum buffer,
-                                               GLint drawbuffer,
-                                               DOMInt32Array* value) {
+void WebGL2RenderingContextBase::clearBufferiv(
+    GLenum buffer,
+    GLint drawbuffer,
+    const NotShared<DOMInt32Array>& value) {
   if (isContextLost() ||
-      !validateClearBuffer("clearBufferiv", buffer, value->length()))
+      !validateClearBuffer("clearBufferiv", buffer, value.view()->length()))
     return;
 
-  contextGL()->ClearBufferiv(buffer, drawbuffer, value->data());
+  contextGL()->ClearBufferiv(buffer, drawbuffer, value.view()->data());
 }
 
 void WebGL2RenderingContextBase::clearBufferiv(GLenum buffer,
@@ -3502,14 +3512,15 @@ void WebGL2RenderingContextBase::clearBufferiv(GLenum buffer,
   contextGL()->ClearBufferiv(buffer, drawbuffer, value.data());
 }
 
-void WebGL2RenderingContextBase::clearBufferuiv(GLenum buffer,
-                                                GLint drawbuffer,
-                                                DOMUint32Array* value) {
+void WebGL2RenderingContextBase::clearBufferuiv(
+    GLenum buffer,
+    GLint drawbuffer,
+    const NotShared<DOMUint32Array>& value) {
   if (isContextLost() ||
-      !validateClearBuffer("clearBufferuiv", buffer, value->length()))
+      !validateClearBuffer("clearBufferuiv", buffer, value.view()->length()))
     return;
 
-  contextGL()->ClearBufferuiv(buffer, drawbuffer, value->data());
+  contextGL()->ClearBufferuiv(buffer, drawbuffer, value.view()->data());
 }
 
 void WebGL2RenderingContextBase::clearBufferuiv(GLenum buffer,
@@ -3522,14 +3533,15 @@ void WebGL2RenderingContextBase::clearBufferuiv(GLenum buffer,
   contextGL()->ClearBufferuiv(buffer, drawbuffer, value.data());
 }
 
-void WebGL2RenderingContextBase::clearBufferfv(GLenum buffer,
-                                               GLint drawbuffer,
-                                               DOMFloat32Array* value) {
+void WebGL2RenderingContextBase::clearBufferfv(
+    GLenum buffer,
+    GLint drawbuffer,
+    const NotShared<DOMFloat32Array>& value) {
   if (isContextLost() ||
-      !validateClearBuffer("clearBufferfv", buffer, value->length()))
+      !validateClearBuffer("clearBufferfv", buffer, value.view()->length()))
     return;
 
-  contextGL()->ClearBufferfv(buffer, drawbuffer, value->data());
+  contextGL()->ClearBufferfv(buffer, drawbuffer, value.view()->data());
 }
 
 void WebGL2RenderingContextBase::clearBufferfv(GLenum buffer,