[SharedArrayBuffer] Prevent SharedArrayBuffer being used in Web APIs

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 230 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) {
+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;
   }
   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) {
+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;
   }
   bufferSubDataImpl(target, dstByteOffset, subByteLength, subBaseAddress);
 }
 
 void WebGL2RenderingContextBase::bufferSubData(GLenum target,
                                                long long offset,
                                                DOMArrayBuffer* data) {
@@ skipping 50 matching lines @@
   }
 
   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 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
     // validateGetBufferSubData, so it's not done here.
     return;
   }
 
   // If the length of the copy is zero, this is a no-op.
   if (!destinationByteLength) {
     return;
@@ skipping 370 matching lines @@
     case GL_UNPACK_SKIP_IMAGES:
       m_unpackSkipImages = param;
       break;
     default:
       WebGLRenderingContextBase::pixelStorei(pname, param);
       return;
   }
   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()) {
     synthesizeGLError(GL_INVALID_OPERATION, "readPixels",
                       "PIXEL_PACK buffer should not be bound");
     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()) {
     synthesizeGLError(GL_INVALID_OPERATION, "readPixels",
                       "PIXEL_PACK buffer should not be bound");
     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,
                                             GLint y,
                                             GLsizei width,
                                             GLsizei height,
                                             GLenum format,
                                             GLenum type,
                                             long long offset) {
   if (isContextLost())
@@ skipping 322 matching lines @@
                        yoffset, 0))
     return;
   if (!validateValueFitNonNegInt32("texSubImage2D", "offset", offset))
     return;
 
   contextGL()->TexSubImage2D(target, level, xoffset, yoffset, width, height,
                              format, type,
                              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) {
     synthesizeGLError(GL_INVALID_OPERATION, "texImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   WebGLRenderingContextBase::texImage2D(target, level, internalformat, width,
                                         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) {
     synthesizeGLError(GL_INVALID_OPERATION, "texImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   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,
                                             GLint level,
                                             GLint internalformat,
                                             GLsizei width,
                                             GLsizei height,
                                             GLint border,
                                             GLenum format,
                                             GLenum type,
@@ skipping 183 matching lines @@
     return;
   if (m_boundPixelUnpackBuffer) {
     synthesizeGLError(GL_INVALID_OPERATION, "texImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   WebGLRenderingContextBase::texImage2D(target, level, internalformat, format,
                                         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) {
     synthesizeGLError(GL_INVALID_OPERATION, "texSubImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   WebGLRenderingContextBase::texSubImage2D(target, level, xoffset, yoffset,
                                            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) {
     synthesizeGLError(GL_INVALID_OPERATION, "texSubImage2D",
                       "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,
                                                GLint level,
                                                GLint xoffset,
                                                GLint yoffset,
                                                GLsizei width,
                                                GLsizei height,
                                                GLenum format,
                                                GLenum type,
@@ skipping 210 matching lines @@
                                               GLsizei depth) {
   if (isContextLost() ||
       !validateTexStorage("texStorage3D", target, levels, internalformat, width,
                           height, depth, TexStorageType3D))
     return;
 
   contextGL()->TexStorage3D(target, levels, internalformat, width, height,
                             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) {
     synthesizeGLError(GL_INVALID_OPERATION, "texImage3D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   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,
                                             GLint level,
                                             GLint internalformat,
                                             GLsizei width,
                                             GLsizei height,
                                             GLsizei depth,
                                             GLint border,
                                             GLenum format,
@@ skipping 129 matching lines @@
     synthesizeGLError(GL_INVALID_OPERATION, "texImage3D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   texImageHelperImageBitmap(TexImage3D, target, level, internalformat, format,
                             type, 0, 0, 0, bitmap,
                             getTextureSourceSubRectangle(width, height), depth,
                             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) {
     synthesizeGLError(GL_INVALID_OPERATION, "texSubImage3D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   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,
                                                GLint level,
                                                GLint xoffset,
                                                GLint yoffset,
                                                GLint zoffset,
                                                GLsizei width,
                                                GLsizei height,
                                                GLsizei depth,
@@ skipping 169 matching lines @@
                                  width, height);
 }
 
 void WebGL2RenderingContextBase::compressedTexImage2D(
     GLenum target,
     GLint level,
     GLenum internalformat,
     GLsizei width,
     GLsizei height,
     GLint border,
-    DOMArrayBufferView* data) {
+    const NotShared<DOMArrayBufferView>& data) {
   if (isContextLost())
     return;
   if (m_boundPixelUnpackBuffer) {
     synthesizeGLError(GL_INVALID_OPERATION, "compressedTexImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   WebGLRenderingContextBase::compressedTexImage2D(target, level, internalformat,
                                                   width, height, border, data);
 }
 
 void WebGL2RenderingContextBase::compressedTexImage2D(
     GLenum target,
     GLint level,
     GLenum internalformat,
     GLsizei width,
     GLsizei height,
     GLint border,
-    DOMArrayBufferView* data,
+    const NotShared<DOMArrayBufferView>& data,
     GLuint srcOffset,
     GLuint srcLengthOverride) {
   if (isContextLost())
     return;
   if (m_boundPixelUnpackBuffer) {
     synthesizeGLError(GL_INVALID_OPERATION, "compressedTexImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   if (!validateTexture2DBinding("compressedTexImage2D", target))
     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,
                                                       GLint level,
                                                       GLenum internalformat,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLint border,
                                                       GLsizei imageSize,
                                                       GLintptr offset) {
@@ skipping 10 matching lines @@
 }
 
 void WebGL2RenderingContextBase::compressedTexSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
-    DOMArrayBufferView* data) {
+    const NotShared<DOMArrayBufferView>& data) {
   if (isContextLost())
     return;
   if (m_boundPixelUnpackBuffer) {
     synthesizeGLError(GL_INVALID_OPERATION, "compressedTexSubImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   WebGLRenderingContextBase::compressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, data);
 }
 
 void WebGL2RenderingContextBase::compressedTexSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
-    DOMArrayBufferView* data,
+    const NotShared<DOMArrayBufferView>& data,
     GLuint srcOffset,
     GLuint srcLengthOverride) {
   if (isContextLost())
     return;
   if (m_boundPixelUnpackBuffer) {
     synthesizeGLError(GL_INVALID_OPERATION, "compressedTexSubImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   if (!validateTexture2DBinding("compressedTexSubImage2D", target))
     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,
                                                          GLint level,
                                                          GLint xoffset,
                                                          GLint yoffset,
                                                          GLsizei width,
                                                          GLsizei height,
                                                          GLenum format,
                                                          GLsizei imageSize,
@@ skipping 11 matching lines @@
 }
 
 void WebGL2RenderingContextBase::compressedTexImage3D(
     GLenum target,
     GLint level,
     GLenum internalformat,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLint border,
-    DOMArrayBufferView* data,
+    const NotShared<DOMArrayBufferView>& data,
     GLuint srcOffset,
     GLuint srcLengthOverride) {
   if (isContextLost())
     return;
   if (m_boundPixelUnpackBuffer) {
     synthesizeGLError(GL_INVALID_OPERATION, "compressedTexImage3D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   if (!validateTexture3DBinding("compressedTexImage3D", target))
     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;
   }
   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,
                                                       GLint level,
                                                       GLenum internalformat,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLsizei depth,
                                                       GLint border,
                                                       GLsizei imageSize,
@@ skipping 13 matching lines @@
 void WebGL2RenderingContextBase::compressedTexSubImage3D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLenum format,
-    DOMArrayBufferView* data,
+    const NotShared<DOMArrayBufferView>& data,
     GLuint srcOffset,
     GLuint srcLengthOverride) {
   if (isContextLost())
     return;
   if (m_boundPixelUnpackBuffer) {
     synthesizeGLError(GL_INVALID_OPERATION, "compressedTexSubImage3D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   if (!validateTexture3DBinding("compressedTexSubImage3D", target))
     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;
   }
   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,
                                                          GLint level,
                                                          GLint xoffset,
                                                          GLint yoffset,
                                                          GLint zoffset,
                                                          GLsizei width,
                                                          GLsizei height,
                                                          GLsizei depth,
@@ skipping 455 matching lines @@
 
   contextGL()->Uniform4uiv(
       location->location(),
       (srcLength ? srcLength : (value.size() - srcOffset)) >> 2,
       value.data() + srcOffset);
 }
 
 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(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& v,
     GLuint srcOffset,
     GLuint srcLength) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose,
                                        v.data(), v.size(), 4, srcOffset,
                                        srcLength))
     return;
   contextGL()->UniformMatrix2fv(
       location->location(),
       (srcLength ? srcLength : (v.size() - srcOffset)) >> 2, transpose,
       v.data() + srcOffset);
 }
 
 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(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& v,
     GLuint srcOffset,
     GLuint srcLength) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose,
                                        v.data(), v.size(), 9, srcOffset,
                                        srcLength))
     return;
   contextGL()->UniformMatrix3fv(
       location->location(),
       (srcLength ? srcLength : (v.size() - srcOffset)) / 9, transpose,
       v.data() + srcOffset);
 }
 
 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(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& v,
     GLuint srcOffset,
     GLuint srcLength) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose,
                                        v.data(), v.size(), 16, srcOffset,
                                        srcLength))
     return;
   contextGL()->UniformMatrix4fv(
       location->location(),
       (srcLength ? srcLength : (v.size() - srcOffset)) >> 4, transpose,
       v.data() + srcOffset);
 }
 
 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(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& value,
     GLuint srcOffset,
     GLuint srcLength) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix2x3fv", location,
                                        transpose, value.data(), value.size(), 6,
                                        srcOffset, srcLength))
     return;
   contextGL()->UniformMatrix2x3fv(
       location->location(),
       (srcLength ? srcLength : (value.size() - srcOffset)) / 6, transpose,
       value.data() + srcOffset);
 }
 
 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(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& value,
     GLuint srcOffset,
     GLuint srcLength) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix3x2fv", location,
                                        transpose, value.data(), value.size(), 6,
                                        srcOffset, srcLength))
     return;
   contextGL()->UniformMatrix3x2fv(
       location->location(),
       (srcLength ? srcLength : (value.size() - srcOffset)) / 6, transpose,
       value.data() + srcOffset);
 }
 
 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(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& value,
     GLuint srcOffset,
     GLuint srcLength) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix2x4fv", location,
                                        transpose, value.data(), value.size(), 8,
                                        srcOffset, srcLength))
     return;
   contextGL()->UniformMatrix2x4fv(
       location->location(),
       (srcLength ? srcLength : (value.size() - srcOffset)) >> 3, transpose,
       value.data() + srcOffset);
 }
 
 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(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& value,
     GLuint srcOffset,
     GLuint srcLength) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix4x2fv", location,
                                        transpose, value.data(), value.size(), 8,
                                        srcOffset, srcLength))
     return;
   contextGL()->UniformMatrix4x2fv(
       location->location(),
       (srcLength ? srcLength : (value.size() - srcOffset)) >> 3, transpose,
       value.data() + srcOffset);
 }
 
 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(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& value,
     GLuint srcOffset,
     GLuint srcLength) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix3x4fv", location,
                                        transpose, value.data(), value.size(),
                                        12, srcOffset, srcLength))
     return;
   contextGL()->UniformMatrix3x4fv(
       location->location(),
       (srcLength ? srcLength : (value.size() - srcOffset)) / 12, transpose,
       value.data() + srcOffset);
 }
 
 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(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& value,
     GLuint srcOffset,
     GLuint srcLength) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix4x3fv", location,
@@ skipping 98 matching lines @@
 
 void WebGL2RenderingContextBase::uniform4iv(
     const WebGLUniformLocation* location,
     Vector<GLint>& v) {
   WebGLRenderingContextBase::uniform4iv(location, v);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    DOMFloat32Array* v) {
+    const NotShared<DOMFloat32Array>& v) {
   WebGLRenderingContextBase::uniformMatrix2fv(location, transpose, v);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& v) {
   WebGLRenderingContextBase::uniformMatrix2fv(location, transpose, v);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    DOMFloat32Array* v) {
+    const NotShared<DOMFloat32Array>& v) {
   WebGLRenderingContextBase::uniformMatrix3fv(location, transpose, v);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& v) {
   WebGLRenderingContextBase::uniformMatrix3fv(location, transpose, v);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    DOMFloat32Array* v) {
+    const NotShared<DOMFloat32Array>& v) {
   WebGLRenderingContextBase::uniformMatrix4fv(location, transpose, v);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& v) {
   WebGLRenderingContextBase::uniformMatrix4fv(location, transpose, v);
 }
 
 void WebGL2RenderingContextBase::vertexAttribI4i(GLuint index,
                                                  GLint x,
                                                  GLint y,
                                                  GLint z,
                                                  GLint w) {
   if (isContextLost())
     return;
   contextGL()->VertexAttribI4i(index, x, y, z, w);
   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);
 }
 
 void WebGL2RenderingContextBase::vertexAttribI4iv(GLuint index,
                                                   const Vector<GLint>& v) {
   if (isContextLost())
     return;
   if (v.size() < 4) {
     synthesizeGLError(GL_INVALID_VALUE, "vertexAttribI4iv", "invalid array");
     return;
   }
   contextGL()->VertexAttribI4iv(index, v.data());
   setVertexAttribType(index, Int32ArrayType);
 }
 
 void WebGL2RenderingContextBase::vertexAttribI4ui(GLuint index,
                                                   GLuint x,
                                                   GLuint y,
                                                   GLuint z,
                                                   GLuint w) {
   if (isContextLost())
     return;
   contextGL()->VertexAttribI4ui(index, x, y, z, w);
   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);
 }
 
 void WebGL2RenderingContextBase::vertexAttribI4uiv(GLuint index,
                                                    const Vector<GLuint>& v) {
   if (isContextLost())
     return;
   if (v.size() < 4) {
     synthesizeGLError(GL_INVALID_VALUE, "vertexAttribI4uiv", "invalid array");
     return;
@@ skipping 192 matching lines @@
 
 WebGLTexture* WebGL2RenderingContextBase::validateTexImageBinding(
     const char* funcName,
     TexImageFunctionID functionID,
     GLenum target) {
   if (functionID == TexImage3D || functionID == TexSubImage3D)
     return validateTexture3DBinding(funcName, target);
   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,
                                                GLint drawbuffer,
                                                const Vector<GLint>& value) {
   if (isContextLost() ||
       !validateClearBuffer("clearBufferiv", buffer, value.size()))
     return;
 
   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,
                                                 GLint drawbuffer,
                                                 const Vector<GLuint>& value) {
   if (isContextLost() ||
       !validateClearBuffer("clearBufferuiv", buffer, value.size()))
     return;
 
   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,
                                                GLint drawbuffer,
                                                const Vector<GLfloat>& value) {
   if (isContextLost() ||
       !validateClearBuffer("clearBufferfv", buffer, value.size()))
     return;
 
   contextGL()->ClearBufferfv(buffer, drawbuffer, value.data());
@@ skipping 2124 matching lines @@
 
 void WebGL2RenderingContextBase::
     DrawingBufferClientRestorePixelUnpackBufferBinding() {
   if (!contextGL())
     return;
   contextGL()->BindBuffer(GL_PIXEL_UNPACK_BUFFER,
                           objectOrZero(m_boundPixelUnpackBuffer.get()));
 }
 
 }  // namespace blink