[SharedArrayBuffer] Prevent SharedArrayBuffer being used in Web APIs

third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.h

 // 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.
 
 #ifndef WebGL2RenderingContextBase_h
 #define WebGL2RenderingContextBase_h
 
 #include "bindings/core/v8/TraceWrapperMember.h"
 #include "modules/webgl/WebGLExtension.h"
 #include "modules/webgl/WebGLRenderingContextBase.h"
@@ skipping 13 matching lines @@
 class WebGLSync;
 class WebGLTransformFeedback;
 class WebGLUniformLocation;
 class WebGLVertexArrayObject;
 
 class WebGL2RenderingContextBase : public WebGLRenderingContextBase {
  public:
   void destroyContext() override;
 
   /* Buffer objects */
-  void bufferData(GLenum, DOMArrayBufferView*, GLenum, GLuint, GLuint);
-  void bufferSubData(GLenum, GLintptr, DOMArrayBufferView*, GLuint, GLuint);
+  void bufferData(GLenum,
+                  const NotShared<DOMArrayBufferView>&,
+                  GLenum,
+                  GLuint,
+                  GLuint);
+  void bufferSubData(GLenum,
+                     GLintptr,
+                     const NotShared<DOMArrayBufferView>&,
+                     GLuint,
+                     GLuint);
   // Have to re-declare/re-define the following buffer{Sub}Data functions from
   // base class.  This is because the above buffer{Sub}Data() hides the name
   // from base class.
   void bufferData(GLenum target, long long size, GLenum usage);
   void bufferData(GLenum target, DOMArrayBuffer* data, GLenum usage);
-  void bufferData(GLenum target, DOMArrayBufferView* data, GLenum usage);
+  void bufferData(GLenum target,
+                  const NotShared<DOMArrayBufferView>& data,
+                  GLenum usage);
   void bufferSubData(GLenum target, long long offset, DOMArrayBuffer* data);
   void bufferSubData(GLenum target,
                      long long offset,
                      const FlexibleArrayBufferView& data);
 
   void copyBufferSubData(GLenum, GLenum, long long, long long, long long);
-  void getBufferSubData(GLenum, long long, DOMArrayBufferView*, GLuint, GLuint);
+  void getBufferSubData(GLenum,
+                        long long,
+                        const NotShared<DOMArrayBufferView>&,
+                        GLuint,
+                        GLuint);
 
   void registerGetBufferSubDataAsyncCallback(
       WebGLGetBufferSubDataAsyncCallback*);
   void unregisterGetBufferSubDataAsyncCallback(
       WebGLGetBufferSubDataAsyncCallback*);
 
   /* Framebuffer objects */
   bool validateTexFuncLayer(const char*, GLenum texTarget, GLint layer);
   void blitFramebuffer(GLint,
                        GLint,
@@ skipping 83 matching lines @@
                   ImageBitmap*,
                   ExceptionState&);
   void texImage2D(GLenum,
                   GLint,
                   GLint,
                   GLsizei,
                   GLsizei,
                   GLint,
                   GLenum,
                   GLenum,
-                  DOMArrayBufferView*,
+                  const NotShared<DOMArrayBufferView>&,
                   GLuint);
 
   void texSubImage2D(GLenum,
                      GLint,
                      GLint,
                      GLint,
                      GLsizei,
                      GLsizei,
                      GLenum,
                      GLenum,
@@ skipping 48 matching lines @@
                      ImageBitmap*,
                      ExceptionState&);
   void texSubImage2D(GLenum,
                      GLint,
                      GLint,
                      GLint,
                      GLsizei,
                      GLsizei,
                      GLenum,
                      GLenum,
-                     DOMArrayBufferView*,
+                     const NotShared<DOMArrayBufferView>&,
                      GLuint);
 
   // Have to re-declare/re-define the following tex{Sub}Image2D functions from
   // base class.  This is because the above tex{Sub}Image2D() hides the name
   // from base class.
   void texImage2D(GLenum, GLint, GLint, GLenum, GLenum, ImageData*);
   void texImage2D(GLenum,
                   GLint,
                   GLint,
                   GLenum,
@@ skipping 59 matching lines @@
   void texStorage3D(GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei);
   void texImage3D(GLenum,
                   GLint,
                   GLint,
                   GLsizei,
                   GLsizei,
                   GLsizei,
                   GLint,
                   GLenum,
                   GLenum,
-                  DOMArrayBufferView*);
+                  const NotShared<DOMArrayBufferView>&);
   void texImage3D(GLenum,
                   GLint,
                   GLint,
                   GLsizei,
                   GLsizei,
                   GLsizei,
                   GLint,
                   GLenum,
                   GLenum,
-                  DOMArrayBufferView*,
+                  const NotShared<DOMArrayBufferView>&,
                   GLuint);
   void texImage3D(GLenum,
                   GLint,
                   GLint,
                   GLsizei,
                   GLsizei,
                   GLsizei,
                   GLint,
                   GLenum,
                   GLenum,
@@ skipping 55 matching lines @@
   void texSubImage3D(GLenum,
                      GLint,
                      GLint,
                      GLint,
                      GLint,
                      GLsizei,
                      GLsizei,
                      GLsizei,
                      GLenum,
                      GLenum,
-                     DOMArrayBufferView*,
+                     const NotShared<DOMArrayBufferView>&,
                      GLuint);
   void texSubImage3D(GLenum,
                      GLint,
                      GLint,
                      GLint,
                      GLint,
                      GLsizei,
                      GLsizei,
                      GLsizei,
                      GLenum,
@@ skipping 60 matching lines @@
                      ExceptionState&);
 
   void texImage2D(GLenum,
                   GLint,
                   GLint,
                   GLsizei,
                   GLsizei,
                   GLint,
                   GLenum,
                   GLenum,
-                  DOMArrayBufferView*);
+                  const NotShared<DOMArrayBufferView>&);
   void texSubImage2D(GLenum,
                      GLint,
                      GLint,
                      GLint,
                      GLsizei,
                      GLsizei,
                      GLenum,
                      GLenum,
-                     DOMArrayBufferView*);
+                     const NotShared<DOMArrayBufferView>&);
 
   void copyTexSubImage3D(GLenum,
                          GLint,
                          GLint,
                          GLint,
                          GLint,
                          GLint,
                          GLint,
                          GLsizei,
                          GLsizei);
 
   void compressedTexImage2D(GLenum target,
                             GLint level,
                             GLenum internalformat,
                             GLsizei width,
                             GLsizei height,
                             GLint border,
-                            DOMArrayBufferView* data,
+                            const NotShared<DOMArrayBufferView>& data,
                             GLuint srcOffset,
                             GLuint srcLengthOverride);
   void compressedTexSubImage2D(GLenum target,
                                GLint level,
                                GLint xoffset,
                                GLint yoffset,
                                GLsizei width,
                                GLsizei height,
                                GLenum format,
-                               DOMArrayBufferView* data,
+                               const NotShared<DOMArrayBufferView>& data,
                                GLuint srcOffset,
                                GLuint srcLengthOverride);
   void compressedTexImage3D(GLenum,
                             GLint,
                             GLenum,
                             GLsizei,
                             GLsizei,
                             GLsizei,
                             GLint,
-                            DOMArrayBufferView*,
+                            const NotShared<DOMArrayBufferView>&,
                             GLuint,
                             GLuint);
   void compressedTexSubImage3D(GLenum,
                                GLint,
                                GLint,
                                GLint,
                                GLint,
                                GLsizei,
                                GLsizei,
                                GLsizei,
                                GLenum,
-                               DOMArrayBufferView*,
+                               const NotShared<DOMArrayBufferView>&,
                                GLuint,
                                GLuint);
   void compressedTexImage2D(GLenum target,
                             GLint level,
                             GLenum internalformat,
                             GLsizei width,
                             GLsizei height,
                             GLint border,
                             GLsizei imageSize,
                             GLintptr offset);
@@ skipping 29 matching lines @@
 
   // Have to re-declare/re-define the following compressedTex{Sub}Image2D
   // functions from the base class. This is because the above
   // compressedTex{Sub}Image2D() hide the name from base class.
   void compressedTexImage2D(GLenum target,
                             GLint level,
                             GLenum internalformat,
                             GLsizei width,
                             GLsizei height,
                             GLint border,
-                            DOMArrayBufferView* data);
+                            const NotShared<DOMArrayBufferView>& data);
   void compressedTexSubImage2D(GLenum target,
                                GLint level,
                                GLint xoffset,
                                GLint yoffset,
                                GLsizei width,
                                GLsizei height,
                                GLenum format,
-                               DOMArrayBufferView* data);
+                               const NotShared<DOMArrayBufferView>& data);
 
   /* Programs and shaders */
   GLint getFragDataLocation(WebGLProgram*, const String&);
 
   /* Uniforms and attributes */
   void uniform1ui(const WebGLUniformLocation*, GLuint);
   void uniform2ui(const WebGLUniformLocation*, GLuint, GLuint);
   void uniform3ui(const WebGLUniformLocation*, GLuint, GLuint, GLuint);
   void uniform4ui(const WebGLUniformLocation*, GLuint, GLuint, GLuint, GLuint);
   void uniform1fv(const WebGLUniformLocation*,
@@ skipping 75 matching lines @@
   void uniform4uiv(const WebGLUniformLocation*,
                    const FlexibleUint32ArrayView&,
                    GLuint,
                    GLuint);
   void uniform4uiv(const WebGLUniformLocation*,
                    Vector<GLuint>&,
                    GLuint,
                    GLuint);
   void uniformMatrix2fv(const WebGLUniformLocation*,
                         GLboolean,
-                        DOMFloat32Array*,
+                        const NotShared<DOMFloat32Array>&,
                         GLuint,
                         GLuint);
   void uniformMatrix2fv(const WebGLUniformLocation*,
                         GLboolean,
                         Vector<GLfloat>&,
                         GLuint,
                         GLuint);
   void uniformMatrix3fv(const WebGLUniformLocation*,
                         GLboolean,
-                        DOMFloat32Array*,
+                        const NotShared<DOMFloat32Array>&,
                         GLuint,
                         GLuint);
   void uniformMatrix3fv(const WebGLUniformLocation*,
                         GLboolean,
                         Vector<GLfloat>&,
                         GLuint,
                         GLuint);
   void uniformMatrix4fv(const WebGLUniformLocation*,
                         GLboolean,
-                        DOMFloat32Array*,
+                        const NotShared<DOMFloat32Array>&,
                         GLuint,
                         GLuint);
   void uniformMatrix4fv(const WebGLUniformLocation*,
                         GLboolean,
                         Vector<GLfloat>&,
                         GLuint,
                         GLuint);
   void uniformMatrix2x3fv(const WebGLUniformLocation*,
                           GLboolean,
-                          DOMFloat32Array*,
+                          const NotShared<DOMFloat32Array>&,
                           GLuint,
                           GLuint);
   void uniformMatrix2x3fv(const WebGLUniformLocation*,
                           GLboolean,
                           Vector<GLfloat>&,
                           GLuint,
                           GLuint);
   void uniformMatrix3x2fv(const WebGLUniformLocation*,
                           GLboolean,
-                          DOMFloat32Array*,
+                          const NotShared<DOMFloat32Array>&,
                           GLuint,
                           GLuint);
   void uniformMatrix3x2fv(const WebGLUniformLocation*,
                           GLboolean,
                           Vector<GLfloat>&,
                           GLuint,
                           GLuint);
   void uniformMatrix2x4fv(const WebGLUniformLocation*,
                           GLboolean,
-                          DOMFloat32Array*,
+                          const NotShared<DOMFloat32Array>&,
                           GLuint,
                           GLuint);
   void uniformMatrix2x4fv(const WebGLUniformLocation*,
                           GLboolean,
                           Vector<GLfloat>&,
                           GLuint,
                           GLuint);
   void uniformMatrix4x2fv(const WebGLUniformLocation*,
                           GLboolean,
-                          DOMFloat32Array*,
+                          const NotShared<DOMFloat32Array>&,
                           GLuint,
                           GLuint);
   void uniformMatrix4x2fv(const WebGLUniformLocation*,
                           GLboolean,
                           Vector<GLfloat>&,
                           GLuint,
                           GLuint);
   void uniformMatrix3x4fv(const WebGLUniformLocation*,
                           GLboolean,
-                          DOMFloat32Array*,
+                          const NotShared<DOMFloat32Array>&,
                           GLuint,
                           GLuint);
   void uniformMatrix3x4fv(const WebGLUniformLocation*,
                           GLboolean,
                           Vector<GLfloat>&,
                           GLuint,
                           GLuint);
   void uniformMatrix4x3fv(const WebGLUniformLocation*,
                           GLboolean,
-                          DOMFloat32Array*,
+                          const NotShared<DOMFloat32Array>&,
                           GLuint,
                           GLuint);
   void uniformMatrix4x3fv(const WebGLUniformLocation*,
                           GLboolean,
                           Vector<GLfloat>&,
                           GLuint,
                           GLuint);
   // Have to re-declare/re-define the following uniform*()
   // functions from the base class. This is because the above
   // uniform*() hide the name from base class.
   void uniform1fv(const WebGLUniformLocation*, const FlexibleFloat32ArrayView&);
   void uniform1fv(const WebGLUniformLocation*, Vector<GLfloat>&);
   void uniform2fv(const WebGLUniformLocation*, const FlexibleFloat32ArrayView&);
   void uniform2fv(const WebGLUniformLocation*, Vector<GLfloat>&);
   void uniform3fv(const WebGLUniformLocation*, const FlexibleFloat32ArrayView&);
   void uniform3fv(const WebGLUniformLocation*, Vector<GLfloat>&);
   void uniform4fv(const WebGLUniformLocation*, const FlexibleFloat32ArrayView&);
   void uniform4fv(const WebGLUniformLocation*, Vector<GLfloat>&);
   void uniform1iv(const WebGLUniformLocation*, const FlexibleInt32ArrayView&);
   void uniform1iv(const WebGLUniformLocation*, Vector<GLint>&);
   void uniform2iv(const WebGLUniformLocation*, const FlexibleInt32ArrayView&);
   void uniform2iv(const WebGLUniformLocation*, Vector<GLint>&);
   void uniform3iv(const WebGLUniformLocation*, const FlexibleInt32ArrayView&);
   void uniform3iv(const WebGLUniformLocation*, Vector<GLint>&);
   void uniform4iv(const WebGLUniformLocation*, const FlexibleInt32ArrayView&);
   void uniform4iv(const WebGLUniformLocation*, Vector<GLint>&);
   void uniformMatrix2fv(const WebGLUniformLocation*,
                         GLboolean transpose,
-                        DOMFloat32Array* value);
+                        const NotShared<DOMFloat32Array>& value);
   void uniformMatrix2fv(const WebGLUniformLocation*,
                         GLboolean transpose,
                         Vector<GLfloat>& value);
   void uniformMatrix3fv(const WebGLUniformLocation*,
                         GLboolean transpose,
-                        DOMFloat32Array* value);
+                        const NotShared<DOMFloat32Array>& value);
   void uniformMatrix3fv(const WebGLUniformLocation*,
                         GLboolean transpose,
                         Vector<GLfloat>& value);
   void uniformMatrix4fv(const WebGLUniformLocation*,
                         GLboolean transpose,
-                        DOMFloat32Array* value);
+                        const NotShared<DOMFloat32Array>& value);
   void uniformMatrix4fv(const WebGLUniformLocation*,
                         GLboolean transpose,
                         Vector<GLfloat>& value);
 
   void vertexAttribI4i(GLuint, GLint, GLint, GLint, GLint);
-  void vertexAttribI4iv(GLuint, const DOMInt32Array*);
+  void vertexAttribI4iv(GLuint, const NotShared<const DOMInt32Array>&);
   void vertexAttribI4iv(GLuint, const Vector<GLint>&);
   void vertexAttribI4ui(GLuint, GLuint, GLuint, GLuint, GLuint);
-  void vertexAttribI4uiv(GLuint, const DOMUint32Array*);
+  void vertexAttribI4uiv(GLuint, const NotShared<const DOMUint32Array>&);
   void vertexAttribI4uiv(GLuint, const Vector<GLuint>&);
   void vertexAttribIPointer(GLuint index,
                             GLint size,
                             GLenum type,
                             GLsizei stride,
                             long long offset);
 
   /* Writing to the drawing buffer */
   void vertexAttribDivisor(GLuint, GLuint);
   void drawArraysInstanced(GLenum, GLint, GLsizei, GLsizei);
   void drawElementsInstanced(GLenum, GLsizei, GLenum, long long, GLsizei);
   void drawRangeElements(GLenum mode,
                          GLuint start,
                          GLuint end,
                          GLsizei count,
                          GLenum type,
                          long long offset);
 
   /* Multiple Render Targets */
   void drawBuffers(const Vector<GLenum>&);
-  void clearBufferiv(GLenum, GLint, DOMInt32Array*);
+  void clearBufferiv(GLenum, GLint, const NotShared<DOMInt32Array>&);
   void clearBufferiv(GLenum, GLint, const Vector<GLint>&);
-  void clearBufferuiv(GLenum, GLint, DOMUint32Array*);
+  void clearBufferuiv(GLenum, GLint, const NotShared<DOMUint32Array>&);
   void clearBufferuiv(GLenum, GLint, const Vector<GLuint>&);
-  void clearBufferfv(GLenum, GLint, DOMFloat32Array*);
+  void clearBufferfv(GLenum, GLint, const NotShared<DOMFloat32Array>&);
   void clearBufferfv(GLenum, GLint, const Vector<GLfloat>&);
   void clearBufferfi(GLenum, GLint, GLfloat, GLint);
 
   /* Query Objects */
   WebGLQuery* createQuery();
   void deleteQuery(WebGLQuery*);
   GLboolean isQuery(WebGLQuery*);
   void beginQuery(GLenum, WebGLQuery*);
   void endQuery(GLenum);
   ScriptValue getQuery(ScriptState*, GLenum, GLenum);
@@ skipping 54 matching lines @@
   GLboolean isVertexArray(WebGLVertexArrayObject*);
   void bindVertexArray(WebGLVertexArrayObject*);
 
   /* Reading */
   void readPixels(GLint x,
                   GLint y,
                   GLsizei width,
                   GLsizei height,
                   GLenum format,
                   GLenum type,
-                  DOMArrayBufferView* pixels,
+                  const NotShared<DOMArrayBufferView>& pixels,
                   GLuint offset);
   void readPixels(GLint x,
                   GLint y,
                   GLsizei width,
                   GLsizei height,
                   GLenum format,
                   GLenum type,
                   long long offset);
 
   /* WebGLRenderingContextBase overrides */
   void initializeNewContext() override;
   void bindFramebuffer(GLenum target, WebGLFramebuffer*) override;
   void deleteFramebuffer(WebGLFramebuffer*) override;
   ScriptValue getParameter(ScriptState*, GLenum pname) override;
   ScriptValue getTexParameter(ScriptState*,
                               GLenum target,
                               GLenum pname) override;
   ScriptValue getFramebufferAttachmentParameter(ScriptState*,
                                                 GLenum target,
                                                 GLenum attachment,
                                                 GLenum pname) override;
   void pixelStorei(GLenum pname, GLint param) override;
   void readPixels(GLint x,
                   GLint y,
                   GLsizei width,
                   GLsizei height,
                   GLenum format,
                   GLenum type,
-                  DOMArrayBufferView* pixels) override;
+                  const NotShared<DOMArrayBufferView>& pixels) override;
   void restoreCurrentFramebuffer() override;
 
   DECLARE_VIRTUAL_TRACE();
   DECLARE_VIRTUAL_TRACE_WRAPPERS();
 
  protected:
   friend class V8WebGL2RenderingContext;
   friend class WebGLGetBufferSubDataAsync;
 
   WebGL2RenderingContextBase(
@@ skipping 166 matching lines @@
                   context,
                   context->is3d() &&
                       WebGLRenderingContextBase::getWebGLVersion(context) >= 2,
                   context.is3d() &&
                       WebGLRenderingContextBase::getWebGLVersion(&context) >=
                           2);
 
 }  // namespace blink
 
 #endif