[SharedArrayBuffer] Prevent SharedArrayBuffer being used in Web APIs

third_party/WebKit/Source/core/geometry/DOMMatrixReadOnly.cpp

 // Copyright 2014 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/geometry/DOMMatrixReadOnly.h"
 
 #include "bindings/core/v8/V8ObjectBuilder.h"
 #include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSToLengthConversionData.h"
 #include "core/css/CSSValueList.h"
@@ skipping 97 matching lines @@
   if (sequence.size() != 6 && sequence.size() != 16) {
     exception_state.ThrowTypeError(
         "The sequence must contain 6 elements for a 2D matrix or 16 elements "
         "for a 3D matrix.");
     return nullptr;
   }
   return new DOMMatrixReadOnly(sequence, sequence.size());
 }
 
 DOMMatrixReadOnly* DOMMatrixReadOnly::fromFloat32Array(
-    DOMFloat32Array* float32_array,
+    NotShared<DOMFloat32Array> float32_array,
     ExceptionState& exception_state) {
-  if (float32_array->length() != 6 && float32_array->length() != 16) {
+  if (float32_array.View()->length() != 6 &&
+      float32_array.View()->length() != 16) {
     exception_state.ThrowTypeError(
         "The sequence must contain 6 elements for a 2D matrix or 16 elements a "
         "for 3D matrix.");
     return nullptr;
   }
-  return new DOMMatrixReadOnly(float32_array->Data(), float32_array->length());
+  return new DOMMatrixReadOnly(float32_array.View()->Data(),
+                               float32_array.View()->length());
 }
 
 DOMMatrixReadOnly* DOMMatrixReadOnly::fromFloat64Array(
-    DOMFloat64Array* float64_array,
+    NotShared<DOMFloat64Array> float64_array,
     ExceptionState& exception_state) {
-  if (float64_array->length() != 6 && float64_array->length() != 16) {
+  if (float64_array.View()->length() != 6 &&
+      float64_array.View()->length() != 16) {
     exception_state.ThrowTypeError(
         "The sequence must contain 6 elements for a 2D matrix or 16 elements "
         "for a 3D matrix.");
     return nullptr;
   }
-  return new DOMMatrixReadOnly(float64_array->Data(), float64_array->length());
+  return new DOMMatrixReadOnly(float64_array.View()->Data(),
+                               float64_array.View()->length());
 }
 
 DOMMatrixReadOnly* DOMMatrixReadOnly::fromMatrix(
     DOMMatrixInit& other,
     ExceptionState& exception_state) {
   if (!ValidateAndFixup(other, exception_state)) {
     DCHECK(exception_state.HadException());
     return nullptr;
   }
 
@@ skipping 119 matching lines @@
              point.w() * m44();
   return DOMPoint::Create(x, y, z, w);
 }
 
 DOMMatrixReadOnly::DOMMatrixReadOnly(const TransformationMatrix& matrix,
                                      bool is2d) {
   matrix_ = TransformationMatrix::Create(matrix);
   is2d_ = is2d;
 }
 
-DOMFloat32Array* DOMMatrixReadOnly::toFloat32Array() const {
+NotShared<DOMFloat32Array> DOMMatrixReadOnly::toFloat32Array() const {
   float array[] = {
       static_cast<float>(matrix_->M11()), static_cast<float>(matrix_->M12()),
       static_cast<float>(matrix_->M13()), static_cast<float>(matrix_->M14()),
       static_cast<float>(matrix_->M21()), static_cast<float>(matrix_->M22()),
       static_cast<float>(matrix_->M23()), static_cast<float>(matrix_->M24()),
       static_cast<float>(matrix_->M31()), static_cast<float>(matrix_->M32()),
       static_cast<float>(matrix_->M33()), static_cast<float>(matrix_->M34()),
       static_cast<float>(matrix_->M41()), static_cast<float>(matrix_->M42()),
       static_cast<float>(matrix_->M43()), static_cast<float>(matrix_->M44())};
 
-  return DOMFloat32Array::Create(array, 16);
+  return NotShared<DOMFloat32Array>(DOMFloat32Array::Create(array, 16));
 }
 
-DOMFloat64Array* DOMMatrixReadOnly::toFloat64Array() const {
+NotShared<DOMFloat64Array> DOMMatrixReadOnly::toFloat64Array() const {
   double array[] = {
       matrix_->M11(), matrix_->M12(), matrix_->M13(), matrix_->M14(),
       matrix_->M21(), matrix_->M22(), matrix_->M23(), matrix_->M24(),
       matrix_->M31(), matrix_->M32(), matrix_->M33(), matrix_->M34(),
       matrix_->M41(), matrix_->M42(), matrix_->M43(), matrix_->M44()};
 
-  return DOMFloat64Array::Create(array, 16);
+  return NotShared<DOMFloat64Array>(DOMFloat64Array::Create(array, 16));
 }
 
 const String DOMMatrixReadOnly::toString() const {
   std::stringstream stream;
   if (is2D()) {
     stream << "matrix(" << a() << ", " << b() << ", " << c() << ", " << d()
            << ", " << e() << ", " << f();
   } else {
     stream << "matrix3d(" << m11() << ", " << m12() << ", " << m13() << ", "
            << m14() << ", " << m21() << ", " << m22() << ", " << m23() << ", "
@@ skipping 79 matching lines @@
 
   matrix_->MakeIdentity();
   operations.Apply(FloatSize(0, 0), *matrix_);
 
   is2d_ = !operations.Has3DOperation();
 
   return;
 }
 
 }  // namespace blink