[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 @@
   pack_skip_rows_ = 0;
   unpack_row_length_ = 0;
   unpack_image_height_ = 0;
   unpack_skip_pixels_ = 0;
   unpack_skip_rows_ = 0;
   unpack_skip_images_ = 0;
 
   WebGLRenderingContextBase::InitializeNewContext();
 }
 
-void WebGL2RenderingContextBase::bufferData(GLenum target,
-                                            DOMArrayBufferView* src_data,
-                                            GLenum usage,
-                                            GLuint src_offset,
-                                            GLuint length) {
+void WebGL2RenderingContextBase::bufferData(
+    GLenum target,
+    NotShared<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, src_offset, length,
+  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,
-                                            DOMArrayBufferView* data,
+                                            NotShared<DOMArrayBufferView> data,
                                             GLenum usage) {
   WebGLRenderingContextBase::bufferData(target, data, usage);
 }
 
-void WebGL2RenderingContextBase::bufferSubData(GLenum target,
-                                               GLintptr dst_byte_offset,
-                                               DOMArrayBufferView* src_data,
-                                               GLuint src_offset,
-                                               GLuint length) {
+void WebGL2RenderingContextBase::bufferSubData(
+    GLenum target,
+    GLintptr dst_byte_offset,
+    NotShared<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, src_offset, length,
+  if (!ValidateSubSourceAndGetData(src_data.View(), src_offset, length,
                                    &sub_base_address, &sub_byte_length)) {
     SynthesizeGLError(GL_INVALID_VALUE, "bufferSubData",
                       "srcOffset + length too large");
     return;
   }
   BufferSubDataImpl(target, dst_byte_offset, sub_byte_length, sub_base_address);
 }
 
 void WebGL2RenderingContextBase::bufferSubData(GLenum target,
                                                long long offset,
@@ skipping 51 matching lines @@
   }
 
   if (write_buffer->GetInitialTarget() == 0)
     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,
-                                                  DOMArrayBufferView* dst_data,
-                                                  GLuint dst_offset,
-                                                  GLuint length) {
+void WebGL2RenderingContextBase::getBufferSubData(
+    GLenum target,
+    long long src_byte_offset,
+    NotShared<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, dst_offset, length,
-      &source_buffer, &destination_data_ptr, &destination_byte_length);
+      __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
     // validateGetBufferSubData, so it's not done here.
     return;
   }
 
   // If the length of the copy is zero, this is a no-op.
   if (!destination_byte_length) {
     return;
   }
@@ skipping 353 matching lines @@
     case GL_UNPACK_SKIP_IMAGES:
       unpack_skip_images_ = 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,
+    NotShared<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, 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,
+    NotShared<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, 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 321 matching lines @@
                        xoffset, 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,
+    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,
                                             GLsizei width,
                                             GLsizei height,
                                             GLint border,
                                             GLenum format,
                                             GLenum type,
-                                            DOMArrayBufferView* data,
+                                            NotShared<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);
+  TexImageHelperDOMArrayBufferView(
+      kTexImage2D, target, level, internalformat, width, height, 1, border,
+      format, type, 0, 0, 0, data.View(), kNullNotReachable, src_offset);
 }
 
 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 (bound_pixel_unpack_buffer_) {
     SynthesizeGLError(GL_INVALID_OPERATION, "texImage2D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   WebGLRenderingContextBase::texImage2D(target, level, internalformat, format,
                                         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,
-                                               DOMArrayBufferView* pixels) {
+void WebGL2RenderingContextBase::texSubImage2D(
+    GLenum target,
+    GLint level,
+    GLint xoffset,
+    GLint yoffset,
+    GLsizei width,
+    GLsizei height,
+    GLenum format,
+    GLenum type,
+    NotShared<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,
-                                               DOMArrayBufferView* pixels,
-                                               GLuint src_offset) {
+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) {
   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, xoffset, yoffset,
-                                   0, pixels, kNullNotReachable, src_offset);
+  TexImageHelperDOMArrayBufferView(
+      kTexSubImage2D, target, level, 0, width, height, 1, 0, format, type,
+      xoffset, yoffset, 0, pixels.View(), kNullNotReachable, src_offset);
 }
 
 void WebGL2RenderingContextBase::texSubImage2D(GLenum target,
                                                GLint level,
                                                GLint xoffset,
                                                GLint yoffset,
                                                GLsizei width,
                                                GLsizei height,
                                                GLenum format,
                                                GLenum type,
@@ skipping 220 matching lines @@
                                               GLsizei depth) {
   if (isContextLost() ||
       !ValidateTexStorage("texStorage3D", target, levels, internalformat, width,
                           height, depth, kTexStorageType3D))
     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,
+    NotShared<DOMArrayBufferView> pixels) {
   TexImageHelperDOMArrayBufferView(kTexImage3D, target, level, internalformat,
                                    width, height, depth, border, format, type,
-                                   0, 0, 0, pixels, kNullAllowed, 0);
+                                   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,
-                                            DOMArrayBufferView* pixels,
-                                            GLuint src_offset) {
+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) {
   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,
-      format, type, 0, 0, 0, pixels, kNullNotReachable, src_offset);
+      format, type, 0, 0, 0, pixels.View(), kNullNotReachable, src_offset);
 }
 
 void WebGL2RenderingContextBase::texImage3D(GLenum target,
                                             GLint level,
                                             GLint internalformat,
                                             GLsizei width,
                                             GLsizei height,
                                             GLsizei depth,
                                             GLint border,
                                             GLenum format,
@@ skipping 130 matching lines @@
     SynthesizeGLError(GL_INVALID_OPERATION, "texImage3D",
                       "a buffer is bound to PIXEL_UNPACK_BUFFER");
     return;
   }
   TexImageHelperImageBitmap(kTexImage3D, target, level, internalformat, format,
                             type, 0, 0, 0, bitmap,
                             GetTextureSourceSubRectangle(width, height), depth,
                             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,
-                                               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,
+    NotShared<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,
-      xoffset, yoffset, zoffset, pixels, kNullNotReachable, src_offset);
+      xoffset, yoffset, zoffset, pixels.View(), kNullNotReachable, src_offset);
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(GLenum target,
                                                GLint level,
                                                GLint xoffset,
                                                GLint yoffset,
                                                GLint zoffset,
                                                GLsizei width,
                                                GLsizei height,
                                                GLsizei depth,
@@ skipping 174 matching lines @@
                                  width, height);
 }
 
 void WebGL2RenderingContextBase::compressedTexImage2D(
     GLenum target,
     GLint level,
     GLenum internalformat,
     GLsizei width,
     GLsizei height,
     GLint border,
-    DOMArrayBufferView* data) {
+    NotShared<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,
-    DOMArrayBufferView* data,
+    NotShared<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->byteLength()) {
+  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->byteLength() - src_offset;
-  } else if (src_length_override > data->byteLength() - src_offset) {
+    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->BaseAddress()) + src_offset);
+      static_cast<uint8_t*>(data.View()->BaseAddress()) + 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,
-    DOMArrayBufferView* data) {
+    NotShared<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,
-    DOMArrayBufferView* data,
+    NotShared<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->byteLength()) {
+  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->byteLength() - src_offset;
-  } else if (src_length_override > data->byteLength() - src_offset) {
+    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->BaseAddress()) + src_offset);
+      static_cast<uint8_t*>(data.View()->BaseAddress()) + 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,
-    DOMArrayBufferView* data,
+    NotShared<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->byteLength()) {
+  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->byteLength() - src_offset;
-  } else if (src_length_override > data->byteLength() - src_offset) {
+    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->BaseAddress()) + src_offset);
+      static_cast<uint8_t*>(data.View()->BaseAddress()) + 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,
-    DOMArrayBufferView* data,
+    NotShared<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->byteLength()) {
+  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->byteLength() - src_offset;
-  } else if (src_length_override > data->byteLength() - src_offset) {
+    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->BaseAddress()) + src_offset);
+      static_cast<uint8_t*>(data.View()->BaseAddress()) + 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,
-    DOMFloat32Array* v,
+    NotShared<DOMFloat32Array> v,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix2fv", location, transpose,
-                                       v, 4, src_offset, src_length))
+                                       v.View(), 4, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix2fv(
       location->Location(),
-      (src_length ? src_length : (v->length() - src_offset)) >> 2, transpose,
-      v->Data() + src_offset);
+      (src_length ? src_length : (v.View()->length() - src_offset)) >> 2,
+      transpose, v.View()->Data() + 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,
-    DOMFloat32Array* v,
+    NotShared<DOMFloat32Array> v,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix3fv", location, transpose,
-                                       v, 9, src_offset, src_length))
+                                       v.View(), 9, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix3fv(
       location->Location(),
-      (src_length ? src_length : (v->length() - src_offset)) / 9, transpose,
-      v->Data() + src_offset);
+      (src_length ? src_length : (v.View()->length() - src_offset)) / 9,
+      transpose, v.View()->Data() + 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,
-    DOMFloat32Array* v,
+    NotShared<DOMFloat32Array> v,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix4fv", location, transpose,
-                                       v, 16, src_offset, src_length))
+                                       v.View(), 16, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix4fv(
       location->Location(),
-      (src_length ? src_length : (v->length() - src_offset)) >> 4, transpose,
-      v->Data() + src_offset);
+      (src_length ? src_length : (v.View()->length() - src_offset)) >> 4,
+      transpose, v.View()->Data() + 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,
-    DOMFloat32Array* value,
+    NotShared<DOMFloat32Array> value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
-                             "uniformMatrix2x3fv", location, transpose, value,
-                             6, src_offset, src_length))
+                             "uniformMatrix2x3fv", location, transpose,
+                             value.View(), 6, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix2x3fv(
       location->Location(),
-      (src_length ? src_length : (value->length() - src_offset)) / 6, transpose,
-      value->Data() + src_offset);
+      (src_length ? src_length : (value.View()->length() - src_offset)) / 6,
+      transpose, value.View()->Data() + 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,
-    DOMFloat32Array* value,
+    NotShared<DOMFloat32Array> value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
-                             "uniformMatrix3x2fv", location, transpose, value,
-                             6, src_offset, src_length))
+                             "uniformMatrix3x2fv", location, transpose,
+                             value.View(), 6, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix3x2fv(
       location->Location(),
-      (src_length ? src_length : (value->length() - src_offset)) / 6, transpose,
-      value->Data() + src_offset);
+      (src_length ? src_length : (value.View()->length() - src_offset)) / 6,
+      transpose, value.View()->Data() + 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,
-    DOMFloat32Array* value,
+    NotShared<DOMFloat32Array> value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
-                             "uniformMatrix2x4fv", location, transpose, value,
-                             8, src_offset, src_length))
+                             "uniformMatrix2x4fv", location, transpose,
+                             value.View(), 8, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix2x4fv(
       location->Location(),
-      (src_length ? src_length : (value->length() - src_offset)) >> 3,
-      transpose, value->Data() + src_offset);
+      (src_length ? src_length : (value.View()->length() - src_offset)) >> 3,
+      transpose, value.View()->Data() + 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,
-    DOMFloat32Array* value,
+    NotShared<DOMFloat32Array> value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
-                             "uniformMatrix4x2fv", location, transpose, value,
-                             8, src_offset, src_length))
+                             "uniformMatrix4x2fv", location, transpose,
+                             value.View(), 8, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix4x2fv(
       location->Location(),
-      (src_length ? src_length : (value->length() - src_offset)) >> 3,
-      transpose, value->Data() + src_offset);
+      (src_length ? src_length : (value.View()->length() - src_offset)) >> 3,
+      transpose, value.View()->Data() + 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,
-    DOMFloat32Array* value,
+    NotShared<DOMFloat32Array> value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
-                             "uniformMatrix3x4fv", location, transpose, value,
-                             12, src_offset, src_length))
+                             "uniformMatrix3x4fv", location, transpose,
+                             value.View(), 12, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix3x4fv(
       location->Location(),
-      (src_length ? src_length : (value->length() - src_offset)) / 12,
-      transpose, value->Data() + src_offset);
+      (src_length ? src_length : (value.View()->length() - src_offset)) / 12,
+      transpose, value.View()->Data() + 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,
-    DOMFloat32Array* value,
+    NotShared<DOMFloat32Array> value,
     GLuint src_offset,
     GLuint src_length) {
   if (isContextLost() || !ValidateUniformMatrixParameters(
-                             "uniformMatrix4x3fv", location, transpose, value,
-                             12, src_offset, src_length))
+                             "uniformMatrix4x3fv", location, transpose,
+                             value.View(), 12, src_offset, src_length))
     return;
   ContextGL()->UniformMatrix4x3fv(
       location->Location(),
-      (src_length ? src_length : (value->length() - src_offset)) / 12,
-      transpose, value->Data() + src_offset);
+      (src_length ? src_length : (value.View()->length() - src_offset)) / 12,
+      transpose, value.View()->Data() + 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,
-    DOMFloat32Array* v) {
+    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) {
+    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) {
+    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, kInt32ArrayType);
 }
 
-void WebGL2RenderingContextBase::vertexAttribI4iv(GLuint index,
-                                                  const DOMInt32Array* v) {
+void WebGL2RenderingContextBase::vertexAttribI4iv(
+    GLuint index,
+    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, 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,
-                                                   const DOMUint32Array* v) {
+void WebGL2RenderingContextBase::vertexAttribI4uiv(
+    GLuint index,
+    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, 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 197 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,
-                                               DOMInt32Array* value) {
+                                               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,
+    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,
+    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 2131 matching lines @@
 
 void WebGL2RenderingContextBase::
     DrawingBufferClientRestorePixelUnpackBufferBinding() {
   if (!ContextGL())
     return;
   ContextGL()->BindBuffer(GL_PIXEL_UNPACK_BUFFER,
                           ObjectOrZero(bound_pixel_unpack_buffer_.Get()));
 }
 
 }  // namespace blink