Revert of [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 75537ecfd015b93967cb8641dcb77d6c448065d0..47eae64de91e1ac45dbb06d051642e99d936729a 100644
--- a/third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp
+++ b/third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp
@@ -248,17 +248,16 @@
   WebGLRenderingContextBase::InitializeNewContext();
 }
 
-void WebGL2RenderingContextBase::bufferData(
-    GLenum target,
-    NotShared<DOMArrayBufferView> src_data,
-    GLenum usage,
-    GLuint src_offset,
-    GLuint length) {
+void WebGL2RenderingContextBase::bufferData(GLenum target,
+                                            DOMArrayBufferView* src_data,
+                                            GLenum usage,
+                                            GLuint src_offset,
+                                            GLuint length) {
   if (isContextLost())
     return;
   void* sub_base_address = nullptr;
   long long sub_byte_length = 0;
-  if (!ValidateSubSourceAndGetData(src_data.View(), src_offset, length,
+  if (!ValidateSubSourceAndGetData(src_data, src_offset, length,
                                    &sub_base_address, &sub_byte_length)) {
     SynthesizeGLError(GL_INVALID_VALUE, "bufferData",
                       "srcOffset + length too large");
@@ -280,22 +279,21 @@
 }
 
 void WebGL2RenderingContextBase::bufferData(GLenum target,
-                                            NotShared<DOMArrayBufferView> data,
+                                            DOMArrayBufferView* data,
                                             GLenum usage) {
   WebGLRenderingContextBase::bufferData(target, data, usage);
 }
 
-void WebGL2RenderingContextBase::bufferSubData(
-    GLenum target,
-    GLintptr dst_byte_offset,
-    NotShared<DOMArrayBufferView> src_data,
-    GLuint src_offset,
-    GLuint length) {
+void WebGL2RenderingContextBase::bufferSubData(GLenum target,
+                                               GLintptr dst_byte_offset,
+                                               DOMArrayBufferView* src_data,
+                                               GLuint src_offset,
+                                               GLuint length) {
   if (isContextLost())
     return;
   void* sub_base_address = nullptr;
   long long sub_byte_length = 0;
-  if (!ValidateSubSourceAndGetData(src_data.View(), src_offset, length,
+  if (!ValidateSubSourceAndGetData(src_data, src_offset, length,
                                    &sub_base_address, &sub_byte_length)) {
     SynthesizeGLError(GL_INVALID_VALUE, "bufferSubData",
                       "srcOffset + length too large");
@@ -367,18 +365,17 @@
       static_cast<GLintptr>(write_offset), static_cast<GLsizeiptr>(size));
 }
 
-void WebGL2RenderingContextBase::getBufferSubData(
-    GLenum target,
-    long long src_byte_offset,
-    NotShared<DOMArrayBufferView> dst_data,
-    GLuint dst_offset,
-    GLuint length) {
+void WebGL2RenderingContextBase::getBufferSubData(GLenum target,
+                                                  long long src_byte_offset,
+                                                  DOMArrayBufferView* dst_data,
+                                                  GLuint dst_offset,
+                                                  GLuint length) {
   WebGLBuffer* source_buffer = nullptr;
   void* destination_data_ptr = nullptr;
   long long destination_byte_length = 0;
   const char* message = ValidateGetBufferSubData(
-      __FUNCTION__, target, src_byte_offset, dst_data.View(), dst_offset,
-      length, &source_buffer, &destination_data_ptr, &destination_byte_length);
+      __FUNCTION__, target, src_byte_offset, dst_data, dst_offset, length,
+      &source_buffer, &destination_data_ptr, &destination_byte_length);
   if (message) {
     // If there was a GL error, it was already synthesized in
     // validateGetBufferSubData, so it's not done here.
@@ -752,14 +749,13 @@
   ContextGL()->PixelStorei(pname, param);
 }
 
-void WebGL2RenderingContextBase::readPixels(
-    GLint x,
-    GLint y,
-    GLsizei width,
-    GLsizei height,
-    GLenum format,
-    GLenum type,
-    NotShared<DOMArrayBufferView> pixels) {
+void WebGL2RenderingContextBase::readPixels(GLint x,
+                                            GLint y,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLenum format,
+                                            GLenum type,
+                                            DOMArrayBufferView* pixels) {
   if (isContextLost())
     return;
   if (bound_pixel_pack_buffer_.Get()) {
@@ -768,18 +764,17 @@
     return;
   }
 
-  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,
-    NotShared<DOMArrayBufferView> pixels,
-    GLuint offset) {
+  ReadPixelsHelper(x, y, width, height, format, type, pixels, 0);
+}
+
+void WebGL2RenderingContextBase::readPixels(GLint x,
+                                            GLint y,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLenum format,
+                                            GLenum type,
+                                            DOMArrayBufferView* pixels,
+                                            GLuint offset) {
   if (isContextLost())
     return;
   if (bound_pixel_pack_buffer_.Get()) {
@@ -788,7 +783,7 @@
     return;
   }
 
-  ReadPixelsHelper(x, y, width, height, format, type, pixels.View(), offset);
+  ReadPixelsHelper(x, y, width, height, format, type, pixels, offset);
 }
 
 void WebGL2RenderingContextBase::readPixels(GLint x,
@@ -1130,27 +1125,6 @@
                              reinterpret_cast<const void*>(offset));
 }
 
-void WebGL2RenderingContextBase::texImage2D(
-    GLenum target,
-    GLint level,
-    GLint internalformat,
-    GLsizei width,
-    GLsizei height,
-    GLint border,
-    GLenum format,
-    GLenum type,
-    NotShared<DOMArrayBufferView> data) {
-  if (isContextLost())
-    return;
-  if (bound_pixel_unpack_buffer_) {
-    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,
@@ -1159,8 +1133,7 @@
                                             GLint border,
                                             GLenum format,
                                             GLenum type,
-                                            NotShared<DOMArrayBufferView> data,
-                                            GLuint src_offset) {
+                                            DOMArrayBufferView* data) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
@@ -1168,9 +1141,30 @@
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  TexImageHelperDOMArrayBufferView(
-      kTexImage2D, target, level, internalformat, width, height, 1, border,
-      format, type, 0, 0, 0, data.View(), kNullNotReachable, src_offset);
+  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 src_offset) {
+  if (isContextLost())
+    return;
+  if (bound_pixel_unpack_buffer_) {
+    SynthesizeGLError(GL_INVALID_OPERATION, "texImage2D",
+                      "a buffer is bound to PIXEL_UNPACK_BUFFER");
+    return;
+  }
+  TexImageHelperDOMArrayBufferView(kTexImage2D, target, level, internalformat,
+                                   width, height, 1, border, format, type, 0, 0,
+                                   0, data, kNullNotReachable, src_offset);
 }
 
 void WebGL2RenderingContextBase::texImage2D(GLenum target,
@@ -1374,16 +1368,15 @@
                                         type, image_bit_map, exception_state);
 }
 
-void WebGL2RenderingContextBase::texSubImage2D(
-    GLenum target,
-    GLint level,
-    GLint xoffset,
-    GLint yoffset,
-    GLsizei width,
-    GLsizei height,
-    GLenum format,
-    GLenum type,
-    NotShared<DOMArrayBufferView> pixels) {
+void WebGL2RenderingContextBase::texSubImage2D(GLenum target,
+                                               GLint level,
+                                               GLint xoffset,
+                                               GLint yoffset,
+                                               GLsizei width,
+                                               GLsizei height,
+                                               GLenum format,
+                                               GLenum type,
+                                               DOMArrayBufferView* pixels) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
@@ -1395,17 +1388,16 @@
                                            width, height, format, type, pixels);
 }
 
-void WebGL2RenderingContextBase::texSubImage2D(
-    GLenum target,
-    GLint level,
-    GLint xoffset,
-    GLint yoffset,
-    GLsizei width,
-    GLsizei height,
-    GLenum format,
-    GLenum type,
-    NotShared<DOMArrayBufferView> pixels,
-    GLuint src_offset) {
+void WebGL2RenderingContextBase::texSubImage2D(GLenum target,
+                                               GLint level,
+                                               GLint xoffset,
+                                               GLint yoffset,
+                                               GLsizei width,
+                                               GLsizei height,
+                                               GLenum format,
+                                               GLenum type,
+                                               DOMArrayBufferView* pixels,
+                                               GLuint src_offset) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
@@ -1413,9 +1405,9 @@
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
-  TexImageHelperDOMArrayBufferView(
-      kTexSubImage2D, target, level, 0, width, height, 1, 0, format, type,
-      xoffset, yoffset, 0, pixels.View(), kNullNotReachable, src_offset);
+  TexImageHelperDOMArrayBufferView(kTexSubImage2D, target, level, 0, width,
+                                   height, 1, 0, format, type, xoffset, yoffset,
+                                   0, pixels, kNullNotReachable, src_offset);
 }
 
 void WebGL2RenderingContextBase::texSubImage2D(GLenum target,
@@ -1656,34 +1648,32 @@
                             depth);
 }
 
-void WebGL2RenderingContextBase::texImage3D(
-    GLenum target,
-    GLint level,
-    GLint internalformat,
-    GLsizei width,
-    GLsizei height,
-    GLsizei depth,
-    GLint border,
-    GLenum format,
-    GLenum type,
-    NotShared<DOMArrayBufferView> pixels) {
+void WebGL2RenderingContextBase::texImage3D(GLenum target,
+                                            GLint level,
+                                            GLint internalformat,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLsizei depth,
+                                            GLint border,
+                                            GLenum format,
+                                            GLenum type,
+                                            DOMArrayBufferView* pixels) {
   TexImageHelperDOMArrayBufferView(kTexImage3D, target, level, internalformat,
                                    width, height, depth, border, format, type,
-                                   0, 0, 0, pixels.View(), kNullAllowed, 0);
-}
-
-void WebGL2RenderingContextBase::texImage3D(
-    GLenum target,
-    GLint level,
-    GLint internalformat,
-    GLsizei width,
-    GLsizei height,
-    GLsizei depth,
-    GLint border,
-    GLenum format,
-    GLenum type,
-    NotShared<DOMArrayBufferView> pixels,
-    GLuint src_offset) {
+                                   0, 0, 0, pixels, kNullAllowed, 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 src_offset) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
@@ -1693,7 +1683,7 @@
   }
   TexImageHelperDOMArrayBufferView(
       kTexImage3D, target, level, internalformat, width, height, depth, border,
-      format, type, 0, 0, 0, pixels.View(), kNullNotReachable, src_offset);
+      format, type, 0, 0, 0, pixels, kNullNotReachable, src_offset);
 }
 
 void WebGL2RenderingContextBase::texImage3D(GLenum target,
@@ -1844,19 +1834,18 @@
                             unpack_image_height_, exception_state);
 }
 
-void WebGL2RenderingContextBase::texSubImage3D(
-    GLenum target,
-    GLint level,
-    GLint xoffset,
-    GLint yoffset,
-    GLint zoffset,
-    GLsizei width,
-    GLsizei height,
-    GLsizei depth,
-    GLenum format,
-    GLenum type,
-    NotShared<DOMArrayBufferView> pixels,
-    GLuint src_offset) {
+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 src_offset) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
@@ -1866,7 +1855,7 @@
   }
   TexImageHelperDOMArrayBufferView(
       kTexSubImage3D, target, level, 0, width, height, depth, 0, format, type,
-      xoffset, yoffset, zoffset, pixels.View(), kNullNotReachable, src_offset);
+      xoffset, yoffset, zoffset, pixels, kNullNotReachable, src_offset);
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(GLenum target,
@@ -2061,7 +2050,7 @@
     GLsizei width,
     GLsizei height,
     GLint border,
-    NotShared<DOMArrayBufferView> data) {
+    DOMArrayBufferView* data) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
@@ -2080,7 +2069,7 @@
     GLsizei width,
     GLsizei height,
     GLint border,
-    NotShared<DOMArrayBufferView> data,
+    DOMArrayBufferView* data,
     GLuint src_offset,
     GLuint src_length_override) {
   if (isContextLost())
@@ -2094,21 +2083,21 @@
     return;
   if (!ValidateCompressedTexFormat("compressedTexImage2D", internalformat))
     return;
-  if (src_offset > data.View()->byteLength()) {
+  if (src_offset > data->byteLength()) {
     SynthesizeGLError(GL_INVALID_VALUE, "compressedTexImage2D",
                       "srcOffset is out of range");
     return;
   }
   if (src_length_override == 0) {
-    src_length_override = data.View()->byteLength() - src_offset;
-  } else if (src_length_override > data.View()->byteLength() - src_offset) {
+    src_length_override = data->byteLength() - src_offset;
+  } else if (src_length_override > data->byteLength() - src_offset) {
     SynthesizeGLError(GL_INVALID_VALUE, "compressedTexImage2D",
                       "srcLengthOverride is out of range");
     return;
   }
   ContextGL()->CompressedTexImage2D(
       target, level, internalformat, width, height, border, src_length_override,
-      static_cast<uint8_t*>(data.View()->BaseAddress()) + src_offset);
+      static_cast<uint8_t*>(data->BaseAddress()) + src_offset);
 }
 
 void WebGL2RenderingContextBase::compressedTexImage2D(GLenum target,
@@ -2139,7 +2128,7 @@
     GLsizei width,
     GLsizei height,
     GLenum format,
-    NotShared<DOMArrayBufferView> data) {
+    DOMArrayBufferView* data) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
@@ -2159,7 +2148,7 @@
     GLsizei width,
     GLsizei height,
     GLenum format,
-    NotShared<DOMArrayBufferView> data,
+    DOMArrayBufferView* data,
     GLuint src_offset,
     GLuint src_length_override) {
   if (isContextLost())
@@ -2173,14 +2162,14 @@
     return;
   if (!ValidateCompressedTexFormat("compressedTexSubImage2D", format))
     return;
-  if (src_offset > data.View()->byteLength()) {
+  if (src_offset > data->byteLength()) {
     SynthesizeGLError(GL_INVALID_VALUE, "compressedTexSubImage2D",
                       "srcOffset is out of range");
     return;
   }
   if (src_length_override == 0) {
-    src_length_override = data.View()->byteLength() - src_offset;
-  } else if (src_length_override > data.View()->byteLength() - src_offset) {
+    src_length_override = data->byteLength() - src_offset;
+  } else if (src_length_override > data->byteLength() - src_offset) {
     SynthesizeGLError(GL_INVALID_VALUE, "compressedTexImage2D",
                       "srcLengthOverride is out of range");
     return;
@@ -2188,7 +2177,7 @@
   ContextGL()->CompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format,
       src_length_override,
-      static_cast<uint8_t*>(data.View()->BaseAddress()) + src_offset);
+      static_cast<uint8_t*>(data->BaseAddress()) + src_offset);
 }
 
 void WebGL2RenderingContextBase::compressedTexSubImage2D(GLenum target,
@@ -2220,7 +2209,7 @@
     GLsizei height,
     GLsizei depth,
     GLint border,
-    NotShared<DOMArrayBufferView> data,
+    DOMArrayBufferView* data,
     GLuint src_offset,
     GLuint src_length_override) {
   if (isContextLost())
@@ -2234,14 +2223,14 @@
     return;
   if (!ValidateCompressedTexFormat("compressedTexImage3D", internalformat))
     return;
-  if (src_offset > data.View()->byteLength()) {
+  if (src_offset > data->byteLength()) {
     SynthesizeGLError(GL_INVALID_VALUE, "compressedTexImage3D",
                       "srcOffset is out of range");
     return;
   }
   if (src_length_override == 0) {
-    src_length_override = data.View()->byteLength() - src_offset;
-  } else if (src_length_override > data.View()->byteLength() - src_offset) {
+    src_length_override = data->byteLength() - src_offset;
+  } else if (src_length_override > data->byteLength() - src_offset) {
     SynthesizeGLError(GL_INVALID_VALUE, "compressedTexImage3D",
                       "srcLengthOverride is out of range");
     return;
@@ -2249,7 +2238,7 @@
   ContextGL()->CompressedTexImage3D(
       target, level, internalformat, width, height, depth, border,
       src_length_override,
-      static_cast<uint8_t*>(data.View()->BaseAddress()) + src_offset);
+      static_cast<uint8_t*>(data->BaseAddress()) + src_offset);
 }
 
 void WebGL2RenderingContextBase::compressedTexImage3D(GLenum target,
@@ -2283,7 +2272,7 @@
     GLsizei height,
     GLsizei depth,
     GLenum format,
-    NotShared<DOMArrayBufferView> data,
+    DOMArrayBufferView* data,
     GLuint src_offset,
     GLuint src_length_override) {
   if (isContextLost())
@@ -2297,14 +2286,14 @@
     return;
   if (!ValidateCompressedTexFormat("compressedTexSubImage3D", format))
     return;
-  if (src_offset > data.View()->byteLength()) {
+  if (src_offset > data->byteLength()) {
     SynthesizeGLError(GL_INVALID_VALUE, "compressedTexSubImage3D",
                       "srcOffset is out of range");
     return;
   }
   if (src_length_override == 0) {
-    src_length_override = data.View()->byteLength() - src_offset;
-  } else if (src_length_override > data.View()->byteLength() - src_offset) {
+    src_length_override = data->byteLength() - src_offset;
+  } else if (src_length_override > data->byteLength() - src_offset) {
     SynthesizeGLError(GL_INVALID_VALUE, "compressedTexSubImage3D",
                       "srcLengthOverride is out of range");
     return;
@@ -2312,7 +2301,7 @@
   ContextGL()->CompressedTexSubImage3D(
       target, level, xoffset, yoffset, zoffset, width, height, depth, format,
       src_length_override,
-      static_cast<uint8_t*>(data.View()->BaseAddress()) + src_offset);
+      static_cast<uint8_t*>(data->BaseAddress()) + src_offset);
 }
 
 void WebGL2RenderingContextBase::compressedTexSubImage3D(GLenum target,
@@ -2795,17 +2784,17 @@
 void WebGL2RenderingContextBase::uniformMatrix2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> v,
+    DOMFloat32Array* v,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix2fv", location, transpose,
-                                       v.View(), 4, src_offset, src_length))
+                                       v, 4, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix2fv(
       location->Location(),
-      (src_length ? src_length : (v.View()->length() - src_offset)) >> 2,
-      transpose, v.View()->Data() + src_offset);
+      (src_length ? src_length : (v->length() - src_offset)) >> 2, transpose,
+      v->Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2fv(
@@ -2827,17 +2816,17 @@
 void WebGL2RenderingContextBase::uniformMatrix3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> v,
+    DOMFloat32Array* v,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix3fv", location, transpose,
-                                       v.View(), 9, src_offset, src_length))
+                                       v, 9, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix3fv(
       location->Location(),
-      (src_length ? src_length : (v.View()->length() - src_offset)) / 9,
-      transpose, v.View()->Data() + src_offset);
+      (src_length ? src_length : (v->length() - src_offset)) / 9, transpose,
+      v->Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3fv(
@@ -2859,17 +2848,17 @@
 void WebGL2RenderingContextBase::uniformMatrix4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> v,
+    DOMFloat32Array* v,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix4fv", location, transpose,
-                                       v.View(), 16, src_offset, src_length))
+                                       v, 16, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix4fv(
       location->Location(),
-      (src_length ? src_length : (v.View()->length() - src_offset)) >> 4,
-      transpose, v.View()->Data() + src_offset);
+      (src_length ? src_length : (v->length() - src_offset)) >> 4, transpose,
+      v->Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4fv(
@@ -2891,17 +2880,17 @@
 void WebGL2RenderingContextBase::uniformMatrix2x3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> value,
+    DOMFloat32Array* value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
-                             "uniformMatrix2x3fv", location, transpose,
-                             value.View(), 6, src_offset, src_length))
+                             "uniformMatrix2x3fv", location, transpose, value,
+                             6, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix2x3fv(
       location->Location(),
-      (src_length ? src_length : (value.View()->length() - src_offset)) / 6,
-      transpose, value.View()->Data() + src_offset);
+      (src_length ? src_length : (value->length() - src_offset)) / 6, transpose,
+      value->Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2x3fv(
@@ -2924,17 +2913,17 @@
 void WebGL2RenderingContextBase::uniformMatrix3x2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> value,
+    DOMFloat32Array* value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
-                             "uniformMatrix3x2fv", location, transpose,
-                             value.View(), 6, src_offset, src_length))
+                             "uniformMatrix3x2fv", location, transpose, value,
+                             6, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix3x2fv(
       location->Location(),
-      (src_length ? src_length : (value.View()->length() - src_offset)) / 6,
-      transpose, value.View()->Data() + src_offset);
+      (src_length ? src_length : (value->length() - src_offset)) / 6, transpose,
+      value->Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3x2fv(
@@ -2957,17 +2946,17 @@
 void WebGL2RenderingContextBase::uniformMatrix2x4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> value,
+    DOMFloat32Array* value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
-                             "uniformMatrix2x4fv", location, transpose,
-                             value.View(), 8, src_offset, src_length))
+                             "uniformMatrix2x4fv", location, transpose, value,
+                             8, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix2x4fv(
       location->Location(),
-      (src_length ? src_length : (value.View()->length() - src_offset)) >> 3,
-      transpose, value.View()->Data() + src_offset);
+      (src_length ? src_length : (value->length() - src_offset)) >> 3,
+      transpose, value->Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2x4fv(
@@ -2990,17 +2979,17 @@
 void WebGL2RenderingContextBase::uniformMatrix4x2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> value,
+    DOMFloat32Array* value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
-                             "uniformMatrix4x2fv", location, transpose,
-                             value.View(), 8, src_offset, src_length))
+                             "uniformMatrix4x2fv", location, transpose, value,
+                             8, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix4x2fv(
       location->Location(),
-      (src_length ? src_length : (value.View()->length() - src_offset)) >> 3,
-      transpose, value.View()->Data() + src_offset);
+      (src_length ? src_length : (value->length() - src_offset)) >> 3,
+      transpose, value->Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4x2fv(
@@ -3023,17 +3012,17 @@
 void WebGL2RenderingContextBase::uniformMatrix3x4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> value,
+    DOMFloat32Array* value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
-                             "uniformMatrix3x4fv", location, transpose,
-                             value.View(), 12, src_offset, src_length))
+                             "uniformMatrix3x4fv", location, transpose, value,
+                             12, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix3x4fv(
       location->Location(),
-      (src_length ? src_length : (value.View()->length() - src_offset)) / 12,
-      transpose, value.View()->Data() + src_offset);
+      (src_length ? src_length : (value->length() - src_offset)) / 12,
+      transpose, value->Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3x4fv(
@@ -3056,17 +3045,17 @@
 void WebGL2RenderingContextBase::uniformMatrix4x3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> value,
+    DOMFloat32Array* value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
-                             "uniformMatrix4x3fv", location, transpose,
-                             value.View(), 12, src_offset, src_length))
+                             "uniformMatrix4x3fv", location, transpose, value,
+                             12, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix4x3fv(
       location->Location(),
-      (src_length ? src_length : (value.View()->length() - src_offset)) / 12,
-      transpose, value.View()->Data() + src_offset);
+      (src_length ? src_length : (value->length() - src_offset)) / 12,
+      transpose, value->Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4x3fv(
@@ -3185,7 +3174,7 @@
 void WebGL2RenderingContextBase::uniformMatrix2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> v) {
+    DOMFloat32Array* v) {
   WebGLRenderingContextBase::uniformMatrix2fv(location, transpose, v);
 }
 
@@ -3199,7 +3188,7 @@
 void WebGL2RenderingContextBase::uniformMatrix3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> v) {
+    DOMFloat32Array* v) {
   WebGLRenderingContextBase::uniformMatrix3fv(location, transpose, v);
 }
 
@@ -3213,7 +3202,7 @@
 void WebGL2RenderingContextBase::uniformMatrix4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> v) {
+    DOMFloat32Array* v) {
   WebGLRenderingContextBase::uniformMatrix4fv(location, transpose, v);
 }
 
@@ -3235,16 +3224,15 @@
   SetVertexAttribType(index, kInt32ArrayType);
 }
 
-void WebGL2RenderingContextBase::vertexAttribI4iv(
-    GLuint index,
-    NotShared<const DOMInt32Array> v) {
-  if (isContextLost())
-    return;
-  if (!v.View() || v.View()->length() < 4) {
+void WebGL2RenderingContextBase::vertexAttribI4iv(GLuint index,
+                                                  const DOMInt32Array* v) {
+  if (isContextLost())
+    return;
+  if (!v || v->length() < 4) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttribI4iv", "invalid array");
     return;
   }
-  ContextGL()->VertexAttribI4iv(index, v.View()->Data());
+  ContextGL()->VertexAttribI4iv(index, v->Data());
   SetVertexAttribType(index, kInt32ArrayType);
 }
 
@@ -3271,16 +3259,15 @@
   SetVertexAttribType(index, kUint32ArrayType);
 }
 
-void WebGL2RenderingContextBase::vertexAttribI4uiv(
-    GLuint index,
-    NotShared<const DOMUint32Array> v) {
-  if (isContextLost())
-    return;
-  if (!v.View() || v.View()->length() < 4) {
+void WebGL2RenderingContextBase::vertexAttribI4uiv(GLuint index,
+                                                   const DOMUint32Array* v) {
+  if (isContextLost())
+    return;
+  if (!v || v->length() < 4) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttribI4uiv", "invalid array");
     return;
   }
-  ContextGL()->VertexAttribI4uiv(index, v.View()->Data());
+  ContextGL()->VertexAttribI4uiv(index, v->Data());
   SetVertexAttribType(index, kUint32ArrayType);
 }
 
@@ -3498,12 +3485,12 @@
 
 void WebGL2RenderingContextBase::clearBufferiv(GLenum buffer,
                                                GLint drawbuffer,
-                                               NotShared<DOMInt32Array> value) {
+                                               DOMInt32Array* value) {
   if (isContextLost() ||
-      !ValidateClearBuffer("clearBufferiv", buffer, value.View()->length()))
-    return;
-
-  ContextGL()->ClearBufferiv(buffer, drawbuffer, value.View()->Data());
+      !ValidateClearBuffer("clearBufferiv", buffer, value->length()))
+    return;
+
+  ContextGL()->ClearBufferiv(buffer, drawbuffer, value->Data());
 }
 
 void WebGL2RenderingContextBase::clearBufferiv(GLenum buffer,
@@ -3516,15 +3503,14 @@
   ContextGL()->ClearBufferiv(buffer, drawbuffer, value.Data());
 }
 
-void WebGL2RenderingContextBase::clearBufferuiv(
-    GLenum buffer,
-    GLint drawbuffer,
-    NotShared<DOMUint32Array> value) {
+void WebGL2RenderingContextBase::clearBufferuiv(GLenum buffer,
+                                                GLint drawbuffer,
+                                                DOMUint32Array* value) {
   if (isContextLost() ||
-      !ValidateClearBuffer("clearBufferuiv", buffer, value.View()->length()))
-    return;
-
-  ContextGL()->ClearBufferuiv(buffer, drawbuffer, value.View()->Data());
+      !ValidateClearBuffer("clearBufferuiv", buffer, value->length()))
+    return;
+
+  ContextGL()->ClearBufferuiv(buffer, drawbuffer, value->Data());
 }
 
 void WebGL2RenderingContextBase::clearBufferuiv(GLenum buffer,
@@ -3537,15 +3523,14 @@
   ContextGL()->ClearBufferuiv(buffer, drawbuffer, value.Data());
 }
 
-void WebGL2RenderingContextBase::clearBufferfv(
-    GLenum buffer,
-    GLint drawbuffer,
-    NotShared<DOMFloat32Array> value) {
+void WebGL2RenderingContextBase::clearBufferfv(GLenum buffer,
+                                               GLint drawbuffer,
+                                               DOMFloat32Array* value) {
   if (isContextLost() ||
-      !ValidateClearBuffer("clearBufferfv", buffer, value.View()->length()))
-    return;
-
-  ContextGL()->ClearBufferfv(buffer, drawbuffer, value.View()->Data());
+      !ValidateClearBuffer("clearBufferfv", buffer, value->length()))
+    return;
+
+  ContextGL()->ClearBufferfv(buffer, drawbuffer, value->Data());
 }
 
 void WebGL2RenderingContextBase::clearBufferfv(GLenum buffer,