Revert of [SharedArrayBuffer] Prevent SharedArrayBuffer being used in Web APIs

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

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 1544 matching lines @@
   ScopedFramebufferRestorer restorer(this);
   int width, height;
   WTF::ArrayBufferContents contents;
   if (!GetDrawingBuffer()->PaintRenderingResultsToImageData(
           width, height, source_buffer, contents))
     return nullptr;
   DOMArrayBuffer* image_data_pixels = DOMArrayBuffer::Create(contents);
 
   return ImageData::Create(
       IntSize(width, height),
-      NotShared<DOMUint8ClampedArray>(DOMUint8ClampedArray::Create(
-          image_data_pixels, 0, image_data_pixels->ByteLength())));
+      DOMUint8ClampedArray::Create(image_data_pixels, 0,
+                                   image_data_pixels->ByteLength()));
 }
 
 void WebGLRenderingContextBase::Reshape(int width, int height) {
   if (isContextLost())
     return;
 
   GLint buffer = 0;
   if (IsWebGL2OrHigher()) {
     // This query returns client side cached binding, so it's trivial.
     // If it changes in the future, such query is heavy and should be avoided.
@@ skipping 319 matching lines @@
   if (isContextLost())
     return;
   if (!data) {
     SynthesizeGLError(GL_INVALID_VALUE, "bufferData", "no data");
     return;
   }
   BufferDataImpl(target, data->ByteLength(), data->Data(), usage);
 }
 
 void WebGLRenderingContextBase::bufferData(GLenum target,
-                                           NotShared<DOMArrayBufferView> data,
+                                           DOMArrayBufferView* data,
                                            GLenum usage) {
   if (isContextLost())
     return;
   DCHECK(data);
-  BufferDataImpl(target, data.View()->byteLength(), data.View()->BaseAddress(),
-                 usage);
+  BufferDataImpl(target, data->byteLength(), data->BaseAddress(), usage);
 }
 
 void WebGLRenderingContextBase::BufferSubDataImpl(GLenum target,
                                                   long long offset,
                                                   GLsizeiptr size,
                                                   const void* data) {
   WebGLBuffer* buffer = ValidateBufferDataTarget("bufferSubData", target);
   if (!buffer)
     return;
   if (!ValidateValueFitNonNegInt32("bufferSubData", "offset", offset))
@@ skipping 146 matching lines @@
   color_mask_[3] = alpha;
   ContextGL()->ColorMask(red, green, blue, alpha);
 }
 
 void WebGLRenderingContextBase::compileShader(WebGLShader* shader) {
   if (isContextLost() || !ValidateWebGLObject("compileShader", shader))
     return;
   ContextGL()->CompileShader(ObjectOrZero(shader));
 }
 
-void WebGLRenderingContextBase::compressedTexImage2D(
-    GLenum target,
-    GLint level,
-    GLenum internalformat,
-    GLsizei width,
-    GLsizei height,
-    GLint border,
-    NotShared<DOMArrayBufferView> data) {
+void WebGLRenderingContextBase::compressedTexImage2D(GLenum target,
+                                                     GLint level,
+                                                     GLenum internalformat,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLint border,
+                                                     DOMArrayBufferView* data) {
   if (isContextLost())
     return;
   if (!ValidateTexture2DBinding("compressedTexImage2D", target))
     return;
   if (!ValidateCompressedTexFormat("compressedTexImage2D", internalformat))
     return;
   ContextGL()->CompressedTexImage2D(target, level, internalformat, width,
-                                    height, border, data.View()->byteLength(),
-                                    data.View()->BaseAddress());
+                                    height, border, data->byteLength(),
+                                    data->BaseAddress());
 }
 
 void WebGLRenderingContextBase::compressedTexSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
-    NotShared<DOMArrayBufferView> data) {
+    DOMArrayBufferView* data) {
   if (isContextLost())
     return;
   if (!ValidateTexture2DBinding("compressedTexSubImage2D", target))
     return;
   if (!ValidateCompressedTexFormat("compressedTexSubImage2D", format))
     return;
-  ContextGL()->CompressedTexSubImage2D(
-      target, level, xoffset, yoffset, width, height, format,
-      data.View()->byteLength(), data.View()->BaseAddress());
+  ContextGL()->CompressedTexSubImage2D(target, level, xoffset, yoffset, width,
+                                       height, format, data->byteLength(),
+                                       data->BaseAddress());
 }
 
 bool WebGLRenderingContextBase::ValidateSettableTexFormat(
     const char* function_name,
     GLenum format) {
   if (IsWebGL2OrHigher())
     return true;
 
   if (WebGLImageConversion::GetChannelBitsByFormat(format) &
       WebGLImageConversion::kChannelDepthStencil) {
@@ skipping 1975 matching lines @@
   }
   if (buffer_size <
       static_cast<long long>(total_bytes_required + total_skip_bytes)) {
     SynthesizeGLError(GL_INVALID_OPERATION, "readPixels",
                       "buffer is not large enough for dimensions");
     return false;
   }
   return true;
 }
 
-void WebGLRenderingContextBase::readPixels(
-    GLint x,
-    GLint y,
-    GLsizei width,
-    GLsizei height,
-    GLenum format,
-    GLenum type,
-    NotShared<DOMArrayBufferView> pixels) {
-  ReadPixelsHelper(x, y, width, height, format, type, pixels.View(), 0);
+void WebGLRenderingContextBase::readPixels(GLint x,
+                                           GLint y,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLenum format,
+                                           GLenum type,
+                                           DOMArrayBufferView* pixels) {
+  ReadPixelsHelper(x, y, width, height, format, type, pixels, 0);
 }
 
 void WebGLRenderingContextBase::ReadPixelsHelper(GLint x,
                                                  GLint y,
                                                  GLsizei width,
                                                  GLsizei height,
                                                  GLenum format,
                                                  GLenum type,
                                                  DOMArrayBufferView* pixels,
                                                  GLuint offset) {
@@ skipping 586 matching lines @@
   ScopedUnpackParametersResetRestore temporary_reset_unpack(
       this, change_unpack_alignment);
   if (function_id == kTexImage2D)
     TexImage2DBase(target, level, internalformat, width, height, border, format,
                    type, data);
   else if (function_id == kTexSubImage2D)
     ContextGL()->TexSubImage2D(target, level, xoffset, yoffset, width, height,
                                format, type, data);
 }
 
-void WebGLRenderingContextBase::texImage2D(
-    GLenum target,
-    GLint level,
-    GLint internalformat,
-    GLsizei width,
-    GLsizei height,
-    GLint border,
-    GLenum format,
-    GLenum type,
-    NotShared<DOMArrayBufferView> pixels) {
+void WebGLRenderingContextBase::texImage2D(GLenum target,
+                                           GLint level,
+                                           GLint internalformat,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLint border,
+                                           GLenum format,
+                                           GLenum type,
+                                           DOMArrayBufferView* pixels) {
   TexImageHelperDOMArrayBufferView(kTexImage2D, target, level, internalformat,
                                    width, height, 1, border, format, type, 0, 0,
-                                   0, pixels.View(), kNullAllowed, 0);
+                                   0, pixels, kNullAllowed, 0);
 }
 
 void WebGLRenderingContextBase::TexImageHelperImageData(
     TexImageFunctionID function_id,
     GLenum target,
     GLint level,
     GLint internalformat,
     GLint border,
     GLenum format,
     GLenum type,
@@ skipping 802 matching lines @@
                                               GLfloat param) {
   TexParameter(target, pname, param, 0, true);
 }
 
 void WebGLRenderingContextBase::texParameteri(GLenum target,
                                               GLenum pname,
                                               GLint param) {
   TexParameter(target, pname, 0, param, false);
 }
 
-void WebGLRenderingContextBase::texSubImage2D(
-    GLenum target,
-    GLint level,
-    GLint xoffset,
-    GLint yoffset,
-    GLsizei width,
-    GLsizei height,
-    GLenum format,
-    GLenum type,
-    NotShared<DOMArrayBufferView> pixels) {
+void WebGLRenderingContextBase::texSubImage2D(GLenum target,
+                                              GLint level,
+                                              GLint xoffset,
+                                              GLint yoffset,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLenum format,
+                                              GLenum type,
+                                              DOMArrayBufferView* pixels) {
   TexImageHelperDOMArrayBufferView(kTexSubImage2D, target, level, 0, width,
                                    height, 1, 0, format, type, xoffset, yoffset,
-                                   0, pixels.View(), kNullNotAllowed, 0);
+                                   0, pixels, kNullNotAllowed, 0);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLenum format,
                                               GLenum type,
                                               ImageData* pixels) {
   TexImageHelperImageData(kTexSubImage2D, target, level, 0, 0, format, type, 1,
@@ skipping 333 matching lines @@
       !ValidateUniformParameters("uniform4iv", location, v.Data(), v.size(), 4,
                                  0, v.size()))
     return;
 
   ContextGL()->Uniform4iv(location->Location(), v.size() >> 2, v.Data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> v) {
+    DOMFloat32Array* v) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix2fv", location, transpose,
-                                       v.View(), 4, 0, v.View()->length()))
+                                       v, 4, 0, v->length()))
     return;
-  ContextGL()->UniformMatrix2fv(location->Location(), v.View()->length() >> 2,
-                                transpose, v.View()->Data());
+  ContextGL()->UniformMatrix2fv(location->Location(), v->length() >> 2,
+                                transpose, v->Data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix2fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& v) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix2fv", location, transpose,
                                        v.Data(), v.size(), 4, 0, v.size()))
     return;
   ContextGL()->UniformMatrix2fv(location->Location(), v.size() >> 2, transpose,
                                 v.Data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> v) {
+    DOMFloat32Array* v) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix3fv", location, transpose,
-                                       v.View(), 9, 0, v.View()->length()))
+                                       v, 9, 0, v->length()))
     return;
-  ContextGL()->UniformMatrix3fv(location->Location(), v.View()->length() / 9,
-                                transpose, v.View()->Data());
+  ContextGL()->UniformMatrix3fv(location->Location(), v->length() / 9,
+                                transpose, v->Data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix3fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& v) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix3fv", location, transpose,
                                        v.Data(), v.size(), 9, 0, v.size()))
     return;
   ContextGL()->UniformMatrix3fv(location->Location(), v.size() / 9, transpose,
                                 v.Data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
-    NotShared<DOMFloat32Array> v) {
+    DOMFloat32Array* v) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix4fv", location, transpose,
-                                       v.View(), 16, 0, v.View()->length()))
+                                       v, 16, 0, v->length()))
     return;
-  ContextGL()->UniformMatrix4fv(location->Location(), v.View()->length() >> 4,
-                                transpose, v.View()->Data());
+  ContextGL()->UniformMatrix4fv(location->Location(), v->length() >> 4,
+                                transpose, v->Data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix4fv(
     const WebGLUniformLocation* location,
     GLboolean transpose,
     Vector<GLfloat>& v) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix4fv", location, transpose,
                                        v.Data(), v.size(), 16, 0, v.size()))
     return;
@@ skipping 35 matching lines @@
     vertex_attrib_type_[index] = type;
 }
 
 void WebGLRenderingContextBase::vertexAttrib1f(GLuint index, GLfloat v0) {
   if (isContextLost())
     return;
   ContextGL()->VertexAttrib1f(index, v0);
   SetVertexAttribType(index, kFloat32ArrayType);
 }
 
-void WebGLRenderingContextBase::vertexAttrib1fv(
-    GLuint index,
-    NotShared<const DOMFloat32Array> v) {
+void WebGLRenderingContextBase::vertexAttrib1fv(GLuint index,
+                                                const DOMFloat32Array* v) {
   if (isContextLost())
     return;
-  if (!v.View() || v.View()->length() < 1) {
+  if (!v || v->length() < 1) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttrib1fv", "invalid array");
     return;
   }
-  ContextGL()->VertexAttrib1fv(index, v.View()->Data());
+  ContextGL()->VertexAttrib1fv(index, v->Data());
   SetVertexAttribType(index, kFloat32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib1fv(GLuint index,
                                                 const Vector<GLfloat>& v) {
   if (isContextLost())
     return;
   if (v.size() < 1) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttrib1fv", "invalid array");
     return;
   }
   ContextGL()->VertexAttrib1fv(index, v.Data());
   SetVertexAttribType(index, kFloat32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib2f(GLuint index,
                                                GLfloat v0,
                                                GLfloat v1) {
   if (isContextLost())
     return;
   ContextGL()->VertexAttrib2f(index, v0, v1);
   SetVertexAttribType(index, kFloat32ArrayType);
 }
 
-void WebGLRenderingContextBase::vertexAttrib2fv(
-    GLuint index,
-    NotShared<const DOMFloat32Array> v) {
+void WebGLRenderingContextBase::vertexAttrib2fv(GLuint index,
+                                                const DOMFloat32Array* v) {
   if (isContextLost())
     return;
-  if (!v.View() || v.View()->length() < 2) {
+  if (!v || v->length() < 2) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttrib2fv", "invalid array");
     return;
   }
-  ContextGL()->VertexAttrib2fv(index, v.View()->Data());
+  ContextGL()->VertexAttrib2fv(index, v->Data());
   SetVertexAttribType(index, kFloat32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib2fv(GLuint index,
                                                 const Vector<GLfloat>& v) {
   if (isContextLost())
     return;
   if (v.size() < 2) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttrib2fv", "invalid array");
     return;
   }
   ContextGL()->VertexAttrib2fv(index, v.Data());
   SetVertexAttribType(index, kFloat32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib3f(GLuint index,
                                                GLfloat v0,
                                                GLfloat v1,
                                                GLfloat v2) {
   if (isContextLost())
     return;
   ContextGL()->VertexAttrib3f(index, v0, v1, v2);
   SetVertexAttribType(index, kFloat32ArrayType);
 }
 
-void WebGLRenderingContextBase::vertexAttrib3fv(
-    GLuint index,
-    NotShared<const DOMFloat32Array> v) {
+void WebGLRenderingContextBase::vertexAttrib3fv(GLuint index,
+                                                const DOMFloat32Array* v) {
   if (isContextLost())
     return;
-  if (!v.View() || v.View()->length() < 3) {
+  if (!v || v->length() < 3) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttrib3fv", "invalid array");
     return;
   }
-  ContextGL()->VertexAttrib3fv(index, v.View()->Data());
+  ContextGL()->VertexAttrib3fv(index, v->Data());
   SetVertexAttribType(index, kFloat32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib3fv(GLuint index,
                                                 const Vector<GLfloat>& v) {
   if (isContextLost())
     return;
   if (v.size() < 3) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttrib3fv", "invalid array");
     return;
   }
   ContextGL()->VertexAttrib3fv(index, v.Data());
   SetVertexAttribType(index, kFloat32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib4f(GLuint index,
                                                GLfloat v0,
                                                GLfloat v1,
                                                GLfloat v2,
                                                GLfloat v3) {
   if (isContextLost())
     return;
   ContextGL()->VertexAttrib4f(index, v0, v1, v2, v3);
   SetVertexAttribType(index, kFloat32ArrayType);
 }
 
-void WebGLRenderingContextBase::vertexAttrib4fv(
-    GLuint index,
-    NotShared<const DOMFloat32Array> v) {
+void WebGLRenderingContextBase::vertexAttrib4fv(GLuint index,
+                                                const DOMFloat32Array* v) {
   if (isContextLost())
     return;
-  if (!v.View() || v.View()->length() < 4) {
+  if (!v || v->length() < 4) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttrib4fv", "invalid array");
     return;
   }
-  ContextGL()->VertexAttrib4fv(index, v.View()->Data());
+  ContextGL()->VertexAttrib4fv(index, v->Data());
   SetVertexAttribType(index, kFloat32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib4fv(GLuint index,
                                                 const Vector<GLfloat>& v) {
   if (isContextLost())
     return;
   if (v.size() < 4) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttrib4fv", "invalid array");
     return;
@@ skipping 1654 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(offscreenCanvas());
 }
 
 }  // namespace blink