[SharedArrayBuffer] Add "AllowShared" extended attribute, used for WebGL

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 <memory>
 #include "bindings/modules/v8/WebGLAny.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
@@ skipping 55 matching lines @@
     byte_offset = sub_offset * type_size;
   }
   CheckedNumeric<long long> total = byte_offset;
   total += byte_length;
   if (!total.IsValid() || total.ValueOrDie() > view->byteLength()) {
     return false;
   }
   if (!byte_length) {
     byte_length = view->byteLength() - byte_offset;
   }
-  uint8_t* data = static_cast<uint8_t*>(view->BaseAddress());
+  uint8_t* data = static_cast<uint8_t*>(view->BaseAddressMaybeShared());
   data += byte_offset;
   *out_base_address = data;
   *out_byte_length = byte_length;
   return true;
 }
 
 }  // namespace
 
 // These enums are from manual pages for glTexStorage2D/glTexStorage3D.
 const GLenum kSupportedInternalFormatsStorage[] = {
@@ skipping 156 matching lines @@
   unpack_image_height_ = 0;
   unpack_skip_pixels_ = 0;
   unpack_skip_rows_ = 0;
   unpack_skip_images_ = 0;
 
   WebGLRenderingContextBase::InitializeNewContext();
 }
 
 void WebGL2RenderingContextBase::bufferData(
     GLenum target,
-    NotShared<DOMArrayBufferView> src_data,
+    MaybeShared<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,
                                    &sub_base_address, &sub_byte_length)) {
     SynthesizeGLError(GL_INVALID_VALUE, "bufferData",
                       "srcOffset + length too large");
     return;
   }
   BufferDataImpl(target, sub_byte_length, sub_base_address, 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,
-                                            NotShared<DOMArrayBufferView> data,
-                                            GLenum usage) {
+void WebGL2RenderingContextBase::bufferData(
+    GLenum target,
+    MaybeShared<DOMArrayBufferView> data,
+    GLenum usage) {
   WebGLRenderingContextBase::bufferData(target, data, usage);
 }
 
 void WebGL2RenderingContextBase::bufferSubData(
     GLenum target,
     GLintptr dst_byte_offset,
-    NotShared<DOMArrayBufferView> src_data,
+    MaybeShared<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,
                                    &sub_base_address, &sub_byte_length)) {
     SynthesizeGLError(GL_INVALID_VALUE, "bufferSubData",
                       "srcOffset + length too large");
@@ skipping 61 matching lines @@
     write_buffer->SetInitialTarget(read_buffer->GetInitialTarget());
 
   ContextGL()->CopyBufferSubData(
       read_target, write_target, static_cast<GLintptr>(read_offset),
       static_cast<GLintptr>(write_offset), static_cast<GLsizeiptr>(size));
 }
 
 void WebGL2RenderingContextBase::getBufferSubData(
     GLenum target,
     long long src_byte_offset,
-    NotShared<DOMArrayBufferView> dst_data,
+    MaybeShared<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);
   if (message) {
     // If there was a GL error, it was already synthesized in
@@ skipping 368 matching lines @@
   ContextGL()->PixelStorei(pname, param);
 }
 
 void WebGL2RenderingContextBase::readPixels(
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height,
     GLenum format,
     GLenum type,
-    NotShared<DOMArrayBufferView> pixels) {
+    MaybeShared<DOMArrayBufferView> pixels) {
   if (isContextLost())
     return;
   if (bound_pixel_pack_buffer_.Get()) {
     SynthesizeGLError(GL_INVALID_OPERATION, "readPixels",
                       "PIXEL_PACK buffer should not be bound");
     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,
+    MaybeShared<DOMArrayBufferView> pixels,
     GLuint offset) {
   if (isContextLost())
     return;
   if (bound_pixel_pack_buffer_.Get()) {
     SynthesizeGLError(GL_INVALID_OPERATION, "readPixels",
                       "PIXEL_PACK buffer should not be bound");
     return;
   }
 
   ReadPixelsHelper(x, y, width, height, format, type, pixels.View(), offset);
@@ skipping 340 matching lines @@
 
 void WebGL2RenderingContextBase::texImage2D(
     GLenum target,
     GLint level,
     GLint internalformat,
     GLsizei width,
     GLsizei height,
     GLint border,
     GLenum format,
     GLenum type,
-    NotShared<DOMArrayBufferView> data) {
+    MaybeShared<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,
-                                            GLsizei width,
-                                            GLsizei height,
-                                            GLint border,
-                                            GLenum format,
-                                            GLenum type,
-                                            NotShared<DOMArrayBufferView> data,
-                                            GLuint src_offset) {
+void WebGL2RenderingContextBase::texImage2D(
+    GLenum target,
+    GLint level,
+    GLint internalformat,
+    GLsizei width,
+    GLsizei height,
+    GLint border,
+    GLenum format,
+    GLenum type,
+    MaybeShared<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.View(), kNullNotReachable, src_offset);
@@ skipping 219 matching lines @@
 
 void WebGL2RenderingContextBase::texSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
     GLenum type,
-    NotShared<DOMArrayBufferView> pixels) {
+    MaybeShared<DOMArrayBufferView> pixels) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     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,
-    NotShared<DOMArrayBufferView> pixels,
+    MaybeShared<DOMArrayBufferView> pixels,
     GLuint src_offset) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texSubImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   TexImageHelperDOMArrayBufferView(
       kTexSubImage2D, target, level, 0, width, height, 1, 0, format, type,
@@ skipping 255 matching lines @@
 void WebGL2RenderingContextBase::texImage3D(
     GLenum target,
     GLint level,
     GLint internalformat,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLint border,
     GLenum format,
     GLenum type,
-    NotShared<DOMArrayBufferView> pixels) {
+    MaybeShared<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,
+    MaybeShared<DOMArrayBufferView> pixels,
     GLuint src_offset) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texImage3D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   TexImageHelperDOMArrayBufferView(
       kTexImage3D, target, level, internalformat, width, height, depth, border,
@@ skipping 161 matching lines @@
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLenum format,
     GLenum type,
-    NotShared<DOMArrayBufferView> pixels,
+    MaybeShared<DOMArrayBufferView> pixels,
     GLuint src_offset) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texSubImage3D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   TexImageHelperDOMArrayBufferView(
       kTexSubImage3D, target, level, 0, width, height, depth, 0, format, type,
@@ skipping 194 matching lines @@
                                  width, height);
 }
 
 void WebGL2RenderingContextBase::compressedTexImage2D(
     GLenum target,
     GLint level,
     GLenum internalformat,
     GLsizei width,
     GLsizei height,
     GLint border,
-    NotShared<DOMArrayBufferView> data) {
+    MaybeShared<DOMArrayBufferView> data) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     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,
-    NotShared<DOMArrayBufferView> data,
+    MaybeShared<DOMArrayBufferView> data,
     GLuint src_offset,
     GLuint src_length_override) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     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 (src_offset > data.View()->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) {
     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.View()->BaseAddressMaybeShared()) +
+          src_offset);
 }
 
 void WebGL2RenderingContextBase::compressedTexImage2D(GLenum target,
                                                       GLint level,
                                                       GLenum internalformat,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLint border,
                                                       GLsizei image_size,
                                                       GLintptr offset) {
@@ skipping 10 matching lines @@
 }
 
 void WebGL2RenderingContextBase::compressedTexSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
-    NotShared<DOMArrayBufferView> data) {
+    MaybeShared<DOMArrayBufferView> data) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     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,
-    NotShared<DOMArrayBufferView> data,
+    MaybeShared<DOMArrayBufferView> data,
     GLuint src_offset,
     GLuint src_length_override) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     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 (src_offset > data.View()->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) {
     SynthesizeGLError(GL_INVALID_VALUE, "compressedTexImage2D",
                       "srcLengthOverride is out of range");
     return;
   }
   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.View()->BaseAddressMaybeShared()) +
+          src_offset);
 }
 
 void WebGL2RenderingContextBase::compressedTexSubImage2D(GLenum target,
                                                          GLint level,
                                                          GLint xoffset,
                                                          GLint yoffset,
                                                          GLsizei width,
                                                          GLsizei height,
                                                          GLenum format,
                                                          GLsizei image_size,
@@ skipping 11 matching lines @@
 }
 
 void WebGL2RenderingContextBase::compressedTexImage3D(
     GLenum target,
     GLint level,
     GLenum internalformat,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLint border,
-    NotShared<DOMArrayBufferView> data,
+    MaybeShared<DOMArrayBufferView> data,
     GLuint src_offset,
     GLuint src_length_override) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     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 (src_offset > data.View()->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) {
     SynthesizeGLError(GL_INVALID_VALUE, "compressedTexImage3D",
                       "srcLengthOverride is out of range");
     return;
   }
   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.View()->BaseAddressMaybeShared()) +
+          src_offset);
 }
 
 void WebGL2RenderingContextBase::compressedTexImage3D(GLenum target,
                                                       GLint level,
                                                       GLenum internalformat,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLsizei depth,
                                                       GLint border,
                                                       GLsizei image_size,
@@ 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,
-    NotShared<DOMArrayBufferView> data,
+    MaybeShared<DOMArrayBufferView> data,
     GLuint src_offset,
     GLuint src_length_override) {
   if (isContextLost())
     return;
   if (bound_pixel_unpack_buffer_) {
     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 (src_offset > data.View()->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) {
     SynthesizeGLError(GL_INVALID_VALUE, "compressedTexSubImage3D",
                       "srcLengthOverride is out of range");
     return;
   }
   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.View()->BaseAddressMaybeShared()) +
+          src_offset);
 }
 
 void WebGL2RenderingContextBase::compressedTexSubImage3D(GLenum target,
                                                          GLint level,
                                                          GLint xoffset,
                                                          GLint yoffset,
                                                          GLint zoffset,
                                                          GLsizei width,
                                                          GLsizei height,
                                                          GLsizei depth,
@@ skipping 462 matching lines @@
 
   ContextGL()->Uniform4uiv(
       location->Location(),
       (src_length ? src_length : (value.size() - src_offset)) >> 2,
       value.Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> v,
+    MaybeShared<DOMFloat32Array> v,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix2fv", location, transpose,
                                        v.View(), 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);
+      transpose, v.View()->DataMaybeShared() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& v,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
                              "uniformMatrix2fv", location, transpose, v.Data(),
                              v.size(), 4, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix2fv(
       location->Location(),
       (src_length ? src_length : (v.size() - src_offset)) >> 2, transpose,
       v.Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> v,
+    MaybeShared<DOMFloat32Array> v,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix3fv", location, transpose,
                                        v.View(), 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);
+      transpose, v.View()->DataMaybeShared() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& v,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
                              "uniformMatrix3fv", location, transpose, v.Data(),
                              v.size(), 9, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix3fv(
       location->Location(),
       (src_length ? src_length : (v.size() - src_offset)) / 9, transpose,
       v.Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> v,
+    MaybeShared<DOMFloat32Array> v,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix4fv", location, transpose,
                                        v.View(), 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);
+      transpose, v.View()->DataMaybeShared() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& v,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
                              "uniformMatrix4fv", location, transpose, v.Data(),
                              v.size(), 16, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix4fv(
       location->Location(),
       (src_length ? src_length : (v.size() - src_offset)) >> 4, transpose,
       v.Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2x3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> value,
+    MaybeShared<DOMFloat32Array> value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
                              "uniformMatrix2x3fv", location, transpose,
                              value.View(), 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);
+      transpose, value.View()->DataMaybeShared() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2x3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix2x3fv", location,
                                        transpose, value.Data(), value.size(), 6,
                                        src_offset, src_length))
     return;
   ContextGL()->UniformMatrix2x3fv(
       location->Location(),
       (src_length ? src_length : (value.size() - src_offset)) / 6, transpose,
       value.Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3x2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> value,
+    MaybeShared<DOMFloat32Array> value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
                              "uniformMatrix3x2fv", location, transpose,
                              value.View(), 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);
+      transpose, value.View()->DataMaybeShared() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3x2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix3x2fv", location,
                                        transpose, value.Data(), value.size(), 6,
                                        src_offset, src_length))
     return;
   ContextGL()->UniformMatrix3x2fv(
       location->Location(),
       (src_length ? src_length : (value.size() - src_offset)) / 6, transpose,
       value.Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2x4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> value,
+    MaybeShared<DOMFloat32Array> value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
                              "uniformMatrix2x4fv", location, transpose,
                              value.View(), 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);
+      transpose, value.View()->DataMaybeShared() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2x4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix2x4fv", location,
                                        transpose, value.Data(), value.size(), 8,
                                        src_offset, src_length))
     return;
   ContextGL()->UniformMatrix2x4fv(
       location->Location(),
       (src_length ? src_length : (value.size() - src_offset)) >> 3, transpose,
       value.Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4x2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> value,
+    MaybeShared<DOMFloat32Array> value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
                              "uniformMatrix4x2fv", location, transpose,
                              value.View(), 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);
+      transpose, value.View()->DataMaybeShared() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4x2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix4x2fv", location,
                                        transpose, value.Data(), value.size(), 8,
                                        src_offset, src_length))
     return;
   ContextGL()->UniformMatrix4x2fv(
       location->Location(),
       (src_length ? src_length : (value.size() - src_offset)) >> 3, transpose,
       value.Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3x4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> value,
+    MaybeShared<DOMFloat32Array> value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
                              "uniformMatrix3x4fv", location, transpose,
                              value.View(), 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);
+      transpose, value.View()->DataMaybeShared() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3x4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix3x4fv", location,
                                        transpose, value.Data(), value.size(),
                                        12, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix3x4fv(
       location->Location(),
       (src_length ? src_length : (value.size() - src_offset)) / 12, transpose,
       value.Data() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4x3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> value,
+    MaybeShared<DOMFloat32Array> value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
                              "uniformMatrix4x3fv", location, transpose,
                              value.View(), 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);
+      transpose, value.View()->DataMaybeShared() + src_offset);
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4x3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& value,
     GLuint src_offset,
     GLuint src_length) {
   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,
-    NotShared<DOMFloat32Array> v) {
+    MaybeShared<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,
-    NotShared<DOMFloat32Array> v) {
+    MaybeShared<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,
-    NotShared<DOMFloat32Array> v) {
+    MaybeShared<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, kInt32ArrayType);
 }
 
 void WebGL2RenderingContextBase::vertexAttribI4iv(
     GLuint index,
-    NotShared<const DOMInt32Array> v) {
+    MaybeShared<const DOMInt32Array> v) {
   if (isContextLost())
     return;
   if (!v.View() || v.View()->length() < 4) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttribI4iv", "invalid array");
     return;
   }
-  ContextGL()->VertexAttribI4iv(index, v.View()->Data());
+  ContextGL()->VertexAttribI4iv(index, v.View()->DataMaybeShared());
   SetVertexAttribType(index, kInt32ArrayType);
 }
 
 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, kInt32ArrayType);
 }
 
 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, kUint32ArrayType);
 }
 
 void WebGL2RenderingContextBase::vertexAttribI4uiv(
     GLuint index,
-    NotShared<const DOMUint32Array> v) {
+    MaybeShared<const DOMUint32Array> v) {
   if (isContextLost())
     return;
   if (!v.View() || v.View()->length() < 4) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttribI4uiv", "invalid array");
     return;
   }
-  ContextGL()->VertexAttribI4uiv(index, v.View()->Data());
+  ContextGL()->VertexAttribI4uiv(index, v.View()->DataMaybeShared());
   SetVertexAttribType(index, kUint32ArrayType);
 }
 
 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 205 matching lines @@
     const char* func_name,
     TexImageFunctionID function_id,
     GLenum target) {
   if (function_id == kTexImage3D || function_id == kTexSubImage3D)
     return ValidateTexture3DBinding(func_name, target);
   return ValidateTexture2DBinding(func_name, target);
 }
 
 void WebGL2RenderingContextBase::clearBufferiv(GLenum buffer,
                                                GLint drawbuffer,
-                                               NotShared<DOMInt32Array> value,
+                                               MaybeShared<DOMInt32Array> value,
                                                GLuint src_offset) {
   if (isContextLost() ||
       !ValidateClearBuffer("clearBufferiv", buffer, value.View()->length(),
                            src_offset))
     return;
 
   ContextGL()->ClearBufferiv(buffer, drawbuffer,
-                             value.View()->Data() + src_offset);
+                             value.View()->DataMaybeShared() + src_offset);
 }
 
 void WebGL2RenderingContextBase::clearBufferiv(GLenum buffer,
                                                GLint drawbuffer,
                                                const Vector<GLint>& value,
                                                GLuint src_offset) {
   if (isContextLost() ||
       !ValidateClearBuffer("clearBufferiv", buffer, value.size(), src_offset))
     return;
 
   ContextGL()->ClearBufferiv(buffer, drawbuffer, value.Data() + src_offset);
 }
 
-void WebGL2RenderingContextBase::clearBufferuiv(GLenum buffer,
-                                                GLint drawbuffer,
-                                                NotShared<DOMUint32Array> value,
-                                                GLuint src_offset) {
+void WebGL2RenderingContextBase::clearBufferuiv(
+    GLenum buffer,
+    GLint drawbuffer,
+    MaybeShared<DOMUint32Array> value,
+    GLuint src_offset) {
   if (isContextLost() ||
       !ValidateClearBuffer("clearBufferuiv", buffer, value.View()->length(),
                            src_offset))
     return;
 
   ContextGL()->ClearBufferuiv(buffer, drawbuffer,
-                              value.View()->Data() + src_offset);
+                              value.View()->DataMaybeShared() + src_offset);
 }
 
 void WebGL2RenderingContextBase::clearBufferuiv(GLenum buffer,
                                                 GLint drawbuffer,
                                                 const Vector<GLuint>& value,
                                                 GLuint src_offset) {
   if (isContextLost() ||
       !ValidateClearBuffer("clearBufferuiv", buffer, value.size(), src_offset))
     return;
 
   ContextGL()->ClearBufferuiv(buffer, drawbuffer, value.Data() + src_offset);
 }
 
-void WebGL2RenderingContextBase::clearBufferfv(GLenum buffer,
-                                               GLint drawbuffer,
-                                               NotShared<DOMFloat32Array> value,
-                                               GLuint src_offset) {
+void WebGL2RenderingContextBase::clearBufferfv(
+    GLenum buffer,
+    GLint drawbuffer,
+    MaybeShared<DOMFloat32Array> value,
+    GLuint src_offset) {
   if (isContextLost() ||
       !ValidateClearBuffer("clearBufferfv", buffer, value.View()->length(),
                            src_offset))
     return;
 
   ContextGL()->ClearBufferfv(buffer, drawbuffer,
-                             value.View()->Data() + src_offset);
+                             value.View()->DataMaybeShared() + src_offset);
 }
 
 void WebGL2RenderingContextBase::clearBufferfv(GLenum buffer,
                                                GLint drawbuffer,
                                                const Vector<GLfloat>& value,
                                                GLuint src_offset) {
   if (isContextLost() ||
       !ValidateClearBuffer("clearBufferfv", buffer, value.size(), src_offset))
     return;
 
@@ skipping 2132 matching lines @@
 
 void WebGL2RenderingContextBase::
     DrawingBufferClientRestorePixelUnpackBufferBinding() {
   if (!ContextGL())
     return;
   ContextGL()->BindBuffer(GL_PIXEL_UNPACK_BUFFER,
                           ObjectOrZero(bound_pixel_unpack_buffer_.Get()));
 }
 
 }  // namespace blink