[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 1607 matching lines @@
   ScopedFramebufferRestorer restorer(this);
   int width, height;
   WTF::ArrayBufferContents contents;
   if (!drawingBuffer()->paintRenderingResultsToImageData(
           width, height, sourceBuffer, contents))
     return nullptr;
   DOMArrayBuffer* imageDataPixels = DOMArrayBuffer::create(contents);
 
   return ImageData::create(
       IntSize(width, height),
-      DOMUint8ClampedArray::create(imageDataPixels, 0,
-                                   imageDataPixels->byteLength()));
+      NotShared<DOMUint8ClampedArray>(DOMUint8ClampedArray::create(
+          imageDataPixels, 0, imageDataPixels->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 318 matching lines @@
                                            GLenum usage) {
   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,
-                                           DOMArrayBufferView* data,
-                                           GLenum usage) {
+void WebGLRenderingContextBase::bufferData(
+    GLenum target,
+    const NotShared<DOMArrayBufferView>& data,
+    GLenum usage) {
   if (isContextLost())
     return;
-  DCHECK(data);
-  bufferDataImpl(target, data->byteLength(), data->baseAddress(), usage);
+  DCHECK(data.view());
+  bufferDataImpl(target, data.view()->byteLength(), data.view()->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 @@
   m_colorMask[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,
-                                                     DOMArrayBufferView* data) {
+void WebGLRenderingContextBase::compressedTexImage2D(
+    GLenum target,
+    GLint level,
+    GLenum internalformat,
+    GLsizei width,
+    GLsizei height,
+    GLint border,
+    const NotShared<DOMArrayBufferView>& data) {
   if (isContextLost())
     return;
   if (!validateTexture2DBinding("compressedTexImage2D", target))
     return;
   if (!validateCompressedTexFormat("compressedTexImage2D", internalformat))
     return;
   contextGL()->CompressedTexImage2D(target, level, internalformat, width,
-                                    height, border, data->byteLength(),
-                                    data->baseAddress());
+                                    height, border, data.view()->byteLength(),
+                                    data.view()->baseAddress());
 }
 
 void WebGLRenderingContextBase::compressedTexSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
-    DOMArrayBufferView* data) {
+    const NotShared<DOMArrayBufferView>& data) {
   if (isContextLost())
     return;
   if (!validateTexture2DBinding("compressedTexSubImage2D", target))
     return;
   if (!validateCompressedTexFormat("compressedTexSubImage2D", format))
     return;
-  contextGL()->CompressedTexSubImage2D(target, level, xoffset, yoffset, width,
-                                       height, format, data->byteLength(),
-                                       data->baseAddress());
+  contextGL()->CompressedTexSubImage2D(
+      target, level, xoffset, yoffset, width, height, format,
+      data.view()->byteLength(), data.view()->baseAddress());
 }
 
 bool WebGLRenderingContextBase::validateSettableTexFormat(
     const char* functionName,
     GLenum format) {
   if (isWebGL2OrHigher())
     return true;
 
   if (WebGLImageConversion::getChannelBitsByFormat(format) &
       WebGLImageConversion::ChannelDepthStencil) {
@@ skipping 1963 matching lines @@
   }
   if (bufferSize <
       static_cast<long long>(totalBytesRequired + totalSkipBytes)) {
     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,
-                                           DOMArrayBufferView* pixels) {
-  readPixelsHelper(x, y, width, height, format, type, pixels, 0);
+void WebGLRenderingContextBase::readPixels(
+    GLint x,
+    GLint y,
+    GLsizei width,
+    GLsizei height,
+    GLenum format,
+    GLenum type,
+    const NotShared<DOMArrayBufferView>& pixels) {
+  readPixelsHelper(x, y, width, height, format, type, pixels.view(), 0);
 }
 
 void WebGLRenderingContextBase::readPixelsHelper(GLint x,
                                                  GLint y,
                                                  GLsizei width,
                                                  GLsizei height,
                                                  GLenum format,
                                                  GLenum type,
                                                  DOMArrayBufferView* pixels,
                                                  GLuint offset) {
@@ skipping 584 matching lines @@
   ScopedUnpackParametersResetRestore temporaryResetUnpack(
       this, changeUnpackAlignment);
   if (functionID == TexImage2D)
     texImage2DBase(target, level, internalformat, width, height, border, format,
                    type, data);
   else if (functionID == TexSubImage2D)
     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,
-                                           DOMArrayBufferView* pixels) {
+void WebGLRenderingContextBase::texImage2D(
+    GLenum target,
+    GLint level,
+    GLint internalformat,
+    GLsizei width,
+    GLsizei height,
+    GLint border,
+    GLenum format,
+    GLenum type,
+    const NotShared<DOMArrayBufferView>& pixels) {
   texImageHelperDOMArrayBufferView(TexImage2D, target, level, internalformat,
                                    width, height, 1, border, format, type, 0, 0,
-                                   0, pixels, NullAllowed, 0);
+                                   0, pixels.view(), NullAllowed, 0);
 }
 
 void WebGLRenderingContextBase::texImageHelperImageData(
     TexImageFunctionID functionID,
     GLenum target,
     GLint level,
     GLint internalformat,
     GLint border,
     GLenum format,
     GLenum type,
@@ skipping 792 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,
-                                              DOMArrayBufferView* pixels) {
+void WebGLRenderingContextBase::texSubImage2D(
+    GLenum target,
+    GLint level,
+    GLint xoffset,
+    GLint yoffset,
+    GLsizei width,
+    GLsizei height,
+    GLenum format,
+    GLenum type,
+    const NotShared<DOMArrayBufferView>& pixels) {
   texImageHelperDOMArrayBufferView(TexSubImage2D, target, level, 0, width,
                                    height, 1, 0, format, type, xoffset, yoffset,
-                                   0, pixels, NullNotAllowed, 0);
+                                   0, pixels.view(), NullNotAllowed, 0);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLenum format,
                                               GLenum type,
                                               ImageData* pixels) {
   texImageHelperImageData(TexSubImage2D, target, level, 0, 0, format, type, 1,
@@ skipping 341 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,
-    DOMFloat32Array* v) {
+    const NotShared<DOMFloat32Array>& v) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose,
-                                       v, 4, 0, v->length()))
+                                       v.view(), 4, 0, v.view()->length()))
     return;
-  contextGL()->UniformMatrix2fv(location->location(), v->length() >> 2,
-                                transpose, v->data());
+  contextGL()->UniformMatrix2fv(location->location(), v.view()->length() >> 2,
+                                transpose, v.view()->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,
-    DOMFloat32Array* v) {
+    const NotShared<DOMFloat32Array>& v) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose,
-                                       v, 9, 0, v->length()))
+                                       v.view(), 9, 0, v.view()->length()))
     return;
-  contextGL()->UniformMatrix3fv(location->location(), v->length() / 9,
-                                transpose, v->data());
+  contextGL()->UniformMatrix3fv(location->location(), v.view()->length() / 9,
+                                transpose, v.view()->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,
-    DOMFloat32Array* v) {
+    const NotShared<DOMFloat32Array>& v) {
   if (isContextLost() ||
       !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose,
-                                       v, 16, 0, v->length()))
+                                       v.view(), 16, 0, v.view()->length()))
     return;
-  contextGL()->UniformMatrix4fv(location->location(), v->length() >> 4,
-                                transpose, v->data());
+  contextGL()->UniformMatrix4fv(location->location(), v.view()->length() >> 4,
+                                transpose, v.view()->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 @@
     m_vertexAttribType[index] = type;
 }
 
 void WebGLRenderingContextBase::vertexAttrib1f(GLuint index, GLfloat v0) {
   if (isContextLost())
     return;
   contextGL()->VertexAttrib1f(index, v0);
   setVertexAttribType(index, Float32ArrayType);
 }
 
-void WebGLRenderingContextBase::vertexAttrib1fv(GLuint index,
-                                                const DOMFloat32Array* v) {
+void WebGLRenderingContextBase::vertexAttrib1fv(
+    GLuint index,
+    const NotShared<const DOMFloat32Array>& v) {
   if (isContextLost())
     return;
-  if (!v || v->length() < 1) {
+  if (!v.view() || v.view()->length() < 1) {
     synthesizeGLError(GL_INVALID_VALUE, "vertexAttrib1fv", "invalid array");
     return;
   }
-  contextGL()->VertexAttrib1fv(index, v->data());
+  contextGL()->VertexAttrib1fv(index, v.view()->data());
   setVertexAttribType(index, Float32ArrayType);
 }
 
 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, Float32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib2f(GLuint index,
                                                GLfloat v0,
                                                GLfloat v1) {
   if (isContextLost())
     return;
   contextGL()->VertexAttrib2f(index, v0, v1);
   setVertexAttribType(index, Float32ArrayType);
 }
 
-void WebGLRenderingContextBase::vertexAttrib2fv(GLuint index,
-                                                const DOMFloat32Array* v) {
+void WebGLRenderingContextBase::vertexAttrib2fv(
+    GLuint index,
+    const NotShared<const DOMFloat32Array>& v) {
   if (isContextLost())
     return;
-  if (!v || v->length() < 2) {
+  if (!v.view() || v.view()->length() < 2) {
     synthesizeGLError(GL_INVALID_VALUE, "vertexAttrib2fv", "invalid array");
     return;
   }
-  contextGL()->VertexAttrib2fv(index, v->data());
+  contextGL()->VertexAttrib2fv(index, v.view()->data());
   setVertexAttribType(index, Float32ArrayType);
 }
 
 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, Float32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib3f(GLuint index,
                                                GLfloat v0,
                                                GLfloat v1,
                                                GLfloat v2) {
   if (isContextLost())
     return;
   contextGL()->VertexAttrib3f(index, v0, v1, v2);
   setVertexAttribType(index, Float32ArrayType);
 }
 
-void WebGLRenderingContextBase::vertexAttrib3fv(GLuint index,
-                                                const DOMFloat32Array* v) {
+void WebGLRenderingContextBase::vertexAttrib3fv(
+    GLuint index,
+    const NotShared<const DOMFloat32Array>& v) {
   if (isContextLost())
     return;
-  if (!v || v->length() < 3) {
+  if (!v.view() || v.view()->length() < 3) {
     synthesizeGLError(GL_INVALID_VALUE, "vertexAttrib3fv", "invalid array");
     return;
   }
-  contextGL()->VertexAttrib3fv(index, v->data());
+  contextGL()->VertexAttrib3fv(index, v.view()->data());
   setVertexAttribType(index, Float32ArrayType);
 }
 
 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, Float32ArrayType);
 }
 
 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, Float32ArrayType);
 }
 
-void WebGLRenderingContextBase::vertexAttrib4fv(GLuint index,
-                                                const DOMFloat32Array* v) {
+void WebGLRenderingContextBase::vertexAttrib4fv(
+    GLuint index,
+    const NotShared<const DOMFloat32Array>& v) {
   if (isContextLost())
     return;
-  if (!v || v->length() < 4) {
+  if (!v.view() || v.view()->length() < 4) {
     synthesizeGLError(GL_INVALID_VALUE, "vertexAttrib4fv", "invalid array");
     return;
   }
-  contextGL()->VertexAttrib4fv(index, v->data());
+  contextGL()->VertexAttrib4fv(index, v.view()->data());
   setVertexAttribType(index, Float32ArrayType);
 }
 
 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 1650 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(offscreenCanvas());
 }
 
 }  // namespace blink