[SharedArrayBuffer] Prevent SharedArrayBuffer being used in Web APIs

third_party/WebKit/Source/core/html/Float32ImageData.cpp

 // Copyright 2017 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 "core/html/Float32ImageData.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/V8Float32Array.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/frame/ImageBitmap.h"
@@ skipping 34 matching lines @@
 
 Float32ImageData* Float32ImageData::create(const IntSize& size) {
   if (!Float32ImageData::validateConstructorArguments(kParamSize, &size))
     return nullptr;
   DOMFloat32Array* dataArray =
       Float32ImageData::allocateAndValidateFloat32Array(4 * size.width() *
                                                         size.height());
   return dataArray ? new Float32ImageData(size, dataArray) : nullptr;
 }
 
-Float32ImageData* Float32ImageData::create(const IntSize& size,
-                                           DOMFloat32Array* dataArray) {
+Float32ImageData* Float32ImageData::create(
+    const IntSize& size,
+    const MaybeShared<DOMFloat32Array>& maybeShared) {
+  if (!ImageData::validateDataArgumentIsNotShared(maybeShared, nullptr))
+    return nullptr;
+  DOMFloat32Array* data = maybeShared.viewNotShared();
   if (!Float32ImageData::validateConstructorArguments(kParamSize | kParamData,
-                                                      &size, 0, 0, dataArray))
+                                                      &size, 0, 0, data))
     return nullptr;
-  return new Float32ImageData(size, dataArray);
+  return new Float32ImageData(size, data);
 }
 
 Float32ImageData* Float32ImageData::create(unsigned width,
                                            unsigned height,
                                            ExceptionState& exceptionState) {
   if (!Float32ImageData::validateConstructorArguments(
           kParamWidth | kParamHeight, nullptr, width, height, nullptr, nullptr,
           &exceptionState))
     return nullptr;
   DOMFloat32Array* dataArray =
       Float32ImageData::allocateAndValidateFloat32Array(4 * width * height,
                                                         &exceptionState);
   return dataArray ? new Float32ImageData(IntSize(width, height), dataArray)
                    : nullptr;
 }
 
-Float32ImageData* Float32ImageData::create(DOMFloat32Array* data,
-                                           unsigned width,
-                                           ExceptionState& exceptionState) {
+Float32ImageData* Float32ImageData::create(
+    const MaybeShared<DOMFloat32Array>& maybeShared,
+    unsigned width,
+    ExceptionState& exceptionState) {
+  if (!ImageData::validateDataArgumentIsNotShared(maybeShared, &exceptionState))
+    return nullptr;
+  DOMFloat32Array* data = maybeShared.viewNotShared();
   if (!Float32ImageData::validateConstructorArguments(kParamData | kParamWidth,
                                                       nullptr, width, 0, data,
                                                       nullptr, &exceptionState))
     return nullptr;
   unsigned height = data->length() / (width * 4);
   return new Float32ImageData(IntSize(width, height), data);
 }
 
-Float32ImageData* Float32ImageData::create(DOMFloat32Array* data,
-                                           unsigned width,
-                                           unsigned height,
-                                           ExceptionState& exceptionState) {
+Float32ImageData* Float32ImageData::create(
+    const MaybeShared<DOMFloat32Array>& maybeShared,
+    unsigned width,
+    unsigned height,
+    ExceptionState& exceptionState) {
+  if (!ImageData::validateDataArgumentIsNotShared(maybeShared, nullptr))
+    return nullptr;
+  DOMFloat32Array* data = maybeShared.viewNotShared();
   if (!Float32ImageData::validateConstructorArguments(
           kParamData | kParamWidth | kParamHeight, nullptr, width, height, data,
           nullptr, &exceptionState))
     return nullptr;
   return new Float32ImageData(IntSize(width, height), data);
 }
 
 Float32ImageData* Float32ImageData::create(unsigned width,
                                            unsigned height,
                                            String colorSpace,
                                            ExceptionState& exceptionState) {
   if (!Float32ImageData::validateConstructorArguments(
           kParamWidth | kParamHeight | kParamColorSpace, nullptr, width, height,
           nullptr, &colorSpace, &exceptionState))
     return nullptr;
 
   DOMFloat32Array* dataArray =
       Float32ImageData::allocateAndValidateFloat32Array(4 * width * height,
                                                         &exceptionState);
   return dataArray ? new Float32ImageData(IntSize(width, height), dataArray,
                                           colorSpace)
                    : nullptr;
 }
 
-Float32ImageData* Float32ImageData::create(DOMFloat32Array* data,
-                                           unsigned width,
-                                           String colorSpace,
-                                           ExceptionState& exceptionState) {
+Float32ImageData* Float32ImageData::create(
+    const MaybeShared<DOMFloat32Array>& maybeShared,
+    unsigned width,
+    String colorSpace,
+    ExceptionState& exceptionState) {
+  if (!ImageData::validateDataArgumentIsNotShared(maybeShared, nullptr))
+    return nullptr;
+  DOMFloat32Array* data = maybeShared.viewNotShared();
   if (!Float32ImageData::validateConstructorArguments(
           kParamData | kParamWidth | kParamColorSpace, nullptr, width, 0, data,
           &colorSpace, &exceptionState))
     return nullptr;
   unsigned height = data->length() / (width * 4);
   return new Float32ImageData(IntSize(width, height), data, colorSpace);
 }
 
-Float32ImageData* Float32ImageData::create(DOMFloat32Array* data,
-                                           unsigned width,
-                                           unsigned height,
-                                           String colorSpace,
-                                           ExceptionState& exceptionState) {
+Float32ImageData* Float32ImageData::create(
+    const MaybeShared<DOMFloat32Array>& maybeShared,
+    unsigned width,
+    unsigned height,
+    String colorSpace,
+    ExceptionState& exceptionState) {
+  if (!ImageData::validateDataArgumentIsNotShared(maybeShared, nullptr))
+    return nullptr;
+  DOMFloat32Array* data = maybeShared.viewNotShared();
   if (!Float32ImageData::validateConstructorArguments(
           kParamData | kParamWidth | kParamHeight | kParamColorSpace, nullptr,
           width, height, data, &colorSpace, &exceptionState))
     return nullptr;
   return new Float32ImageData(IntSize(width, height), data, colorSpace);
 }
 
 v8::Local<v8::Object> Float32ImageData::associateWithWrapper(
     v8::Isolate* isolate,
     const WrapperTypeInfo* wrapperType,
@@ skipping 21 matching lines @@
     : m_size(size),
       m_colorSpace(ImageData::getImageDataColorSpace(colorSpaceName)),
       m_data(dataArray) {
   DCHECK_GE(size.width(), 0);
   DCHECK_GE(size.height(), 0);
   SECURITY_CHECK(static_cast<unsigned>(size.width() * size.height() * 4) <=
                  m_data->length());
 }
 
 }  // namespace blink