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

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 14 matching lines @@
 
 #include "modules/webgl/WebGLRenderingContextBase.h"
 
 #include <memory>
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptWrappableVisitor.h"
 #include "bindings/core/v8/V8BindingMacros.h"
 #include "bindings/modules/v8/HTMLCanvasElementOrOffscreenCanvas.h"
 #include "bindings/modules/v8/WebGLAny.h"
+#include "core/dom/ArrayBufferViewHelpers.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMTypedArray.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/FlexibleArrayBufferView.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/LocalFrameClient.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLCanvasElement.h"
@@ skipping 1852 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,
+                                           MaybeShared<DOMArrayBufferView> data,
                                            GLenum usage) {
   if (isContextLost())
     return;
   DCHECK(data);
-  BufferDataImpl(target, data.View()->byteLength(), data.View()->BaseAddress(),
-                 usage);
+  BufferDataImpl(target, data.View()->byteLength(),
+                 data.View()->BaseAddressMaybeShared(), 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 153 matching lines @@
   ContextGL()->CompileShader(ObjectOrZero(shader));
 }
 
 void WebGLRenderingContextBase::compressedTexImage2D(
     GLenum target,
     GLint level,
     GLenum internalformat,
     GLsizei width,
     GLsizei height,
     GLint border,
-    NotShared<DOMArrayBufferView> data) {
+    MaybeShared<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());
+                                    data.View()->BaseAddressMaybeShared());
 }
 
 void WebGLRenderingContextBase::compressedTexSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
-    NotShared<DOMArrayBufferView> data) {
+    MaybeShared<DOMArrayBufferView> data) {
   if (isContextLost())
     return;
   if (!ValidateTexture2DBinding("compressedTexSubImage2D", target))
     return;
   if (!ValidateCompressedTexFormat("compressedTexSubImage2D", format))
     return;
   ContextGL()->CompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format,
-      data.View()->byteLength(), data.View()->BaseAddress());
+      data.View()->byteLength(), data.View()->BaseAddressMaybeShared());
 }
 
 bool WebGLRenderingContextBase::ValidateSettableTexFormat(
     const char* function_name,
     GLenum format) {
   if (IsWebGL2OrHigher())
     return true;
 
   if (WebGLImageConversion::GetChannelBitsByFormat(format) &
       WebGLImageConversion::kChannelDepthStencil) {
@@ skipping 1982 matching lines @@
   return true;
 }
 
 void WebGLRenderingContextBase::readPixels(
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height,
     GLenum format,
     GLenum type,
-    NotShared<DOMArrayBufferView> pixels) {
+    MaybeShared<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,
@@ skipping 29 matching lines @@
   if (!buffer_size.IsValid()) {
     SynthesizeGLError(GL_INVALID_VALUE, "readPixels",
                       "destination offset out of range");
     return;
   }
   if (!ValidateReadPixelsFuncParameters(width, height, format, type, pixels,
                                         buffer_size.ValueOrDie())) {
     return;
   }
   ClearIfComposited();
-  uint8_t* data = static_cast<uint8_t*>(pixels->BaseAddress()) +
+  uint8_t* data = static_cast<uint8_t*>(pixels->BaseAddressMaybeShared()) +
                   offset_in_bytes.ValueOrDie();
   {
     ScopedDrawingBufferBinder binder(GetDrawingBuffer(), framebuffer);
     ContextGL()->ReadPixels(x, y, width, height, format, type, data);
   }
 }
 
 void WebGLRenderingContextBase::RenderbufferStorageImpl(
     GLenum target,
     GLsizei samples,
@@ skipping 495 matching lines @@
     return;
   TexImageDimension source_type;
   if (function_id == kTexImage2D || function_id == kTexSubImage2D)
     source_type = kTex2D;
   else
     source_type = kTex3D;
   if (!ValidateTexFuncData(func_name, source_type, level, width, height, depth,
                            format, type, pixels, null_disposition, src_offset))
     return;
   uint8_t* data =
-      reinterpret_cast<uint8_t*>(pixels ? pixels->BaseAddress() : 0);
+      reinterpret_cast<uint8_t*>(pixels ? pixels->BaseAddressMaybeShared() : 0);
   if (src_offset) {
     DCHECK(pixels);
     // No need to check overflow because validateTexFuncData() already did.
     data += src_offset * pixels->TypeSize();
   }
   Vector<uint8_t> temp_data;
   bool change_unpack_alignment = false;
   if (data && (unpack_flip_y_ || unpack_premultiply_alpha_)) {
     if (source_type == kTex2D) {
       if (!WebGLImageConversion::ExtractTextureData(
@@ skipping 30 matching lines @@
 
 void WebGLRenderingContextBase::texImage2D(
     GLenum target,
     GLint level,
     GLint internalformat,
     GLsizei width,
     GLsizei height,
     GLint border,
     GLenum format,
     GLenum type,
-    NotShared<DOMArrayBufferView> pixels) {
+    MaybeShared<DOMArrayBufferView> pixels) {
   TexImageHelperDOMArrayBufferView(kTexImage2D, target, level, internalformat,
                                    width, height, 1, border, format, type, 0, 0,
                                    0, pixels.View(), kNullAllowed, 0);
 }
 
 void WebGLRenderingContextBase::TexImageHelperImageData(
     TexImageFunctionID function_id,
     GLenum target,
     GLint level,
     GLint internalformat,
@@ skipping 846 matching lines @@
 
 void WebGLRenderingContextBase::texSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
     GLenum type,
-    NotShared<DOMArrayBufferView> pixels) {
+    MaybeShared<DOMArrayBufferView> pixels) {
   TexImageHelperDOMArrayBufferView(kTexSubImage2D, target, level, 0, width,
                                    height, 1, 0, format, type, xoffset, yoffset,
                                    0, pixels.View(), kNullNotAllowed, 0);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLenum format,
@@ skipping 345 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) {
+    MaybeShared<DOMFloat32Array> v) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix2fv", location, transpose,
                                        v.View(), 4, 0, v.View()->length()))
     return;
   ContextGL()->UniformMatrix2fv(location->Location(), v.View()->length() >> 2,
-                                transpose, v.View()->Data());
+                                transpose, v.View()->DataMaybeShared());
 }
 
 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) {
+    MaybeShared<DOMFloat32Array> v) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix3fv", location, transpose,
                                        v.View(), 9, 0, v.View()->length()))
     return;
   ContextGL()->UniformMatrix3fv(location->Location(), v.View()->length() / 9,
-                                transpose, v.View()->Data());
+                                transpose, v.View()->DataMaybeShared());
 }
 
 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) {
+    MaybeShared<DOMFloat32Array> v) {
   if (isContextLost() ||
       !ValidateUniformMatrixParameters("uniformMatrix4fv", location, transpose,
                                        v.View(), 16, 0, v.View()->length()))
     return;
   ContextGL()->UniformMatrix4fv(location->Location(), v.View()->length() >> 4,
-                                transpose, v.View()->Data());
+                                transpose, v.View()->DataMaybeShared());
 }
 
 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 37 matching lines @@
 
 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) {
+    MaybeShared<const DOMFloat32Array> v) {
   if (isContextLost())
     return;
   if (!v.View() || v.View()->length() < 1) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttrib1fv", "invalid array");
     return;
   }
-  ContextGL()->VertexAttrib1fv(index, v.View()->Data());
+  ContextGL()->VertexAttrib1fv(index, v.View()->DataMaybeShared());
   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) {
+    MaybeShared<const DOMFloat32Array> v) {
   if (isContextLost())
     return;
   if (!v.View() || v.View()->length() < 2) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttrib2fv", "invalid array");
     return;
   }
-  ContextGL()->VertexAttrib2fv(index, v.View()->Data());
+  ContextGL()->VertexAttrib2fv(index, v.View()->DataMaybeShared());
   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) {
+    MaybeShared<const DOMFloat32Array> v) {
   if (isContextLost())
     return;
   if (!v.View() || v.View()->length() < 3) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttrib3fv", "invalid array");
     return;
   }
-  ContextGL()->VertexAttrib3fv(index, v.View()->Data());
+  ContextGL()->VertexAttrib3fv(index, v.View()->DataMaybeShared());
   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) {
+    MaybeShared<const DOMFloat32Array> v) {
   if (isContextLost())
     return;
   if (!v.View() || v.View()->length() < 4) {
     SynthesizeGLError(GL_INVALID_VALUE, "vertexAttrib4fv", "invalid array");
     return;
   }
-  ContextGL()->VertexAttrib4fv(index, v.View()->Data());
+  ContextGL()->VertexAttrib4fv(index, v.View()->DataMaybeShared());
   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 1034 matching lines @@
     GLboolean transpose,
     DOMFloat32Array* v,
     GLsizei required_min_size,
     GLuint src_offset,
     GLuint src_length) {
   if (!v) {
     SynthesizeGLError(GL_INVALID_VALUE, function_name, "no array");
     return false;
   }
   return ValidateUniformMatrixParameters(
-      function_name, location, transpose, v->Data(), v->length(),
+      function_name, location, transpose, v->DataMaybeShared(), v->length(),
       required_min_size, src_offset, src_length);
 }
 
 bool WebGLRenderingContextBase::ValidateUniformMatrixParameters(
     const char* function_name,
     const WebGLUniformLocation* location,
     GLboolean transpose,
     void* v,
     GLsizei size,
     GLsizei required_min_size,
@@ skipping 603 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(offscreenCanvas());
 }
 
 }  // namespace blink