Revert of [SharedArrayBuffer] Prevent SharedArrayBuffer being used in Web APIs

third_party/WebKit/Source/modules/webgl/WebGLGetBufferSubDataAsync.cpp

 // Copyright 2016 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 "modules/webgl/WebGLGetBufferSubDataAsync.h"
 
 #include "core/dom/DOMException.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "modules/webgl/WebGL2RenderingContextBase.h"
@@ skipping 18 matching lines @@
 }
 
 const char* WebGLGetBufferSubDataAsync::ExtensionName() {
   return "WEBGL_get_buffer_sub_data_async";
 }
 
 ScriptPromise WebGLGetBufferSubDataAsync::getBufferSubDataAsync(
     ScriptState* script_state,
     GLenum target,
     GLintptr src_byte_offset,
-    NotShared<DOMArrayBufferView> dst_data,
+    DOMArrayBufferView* dst_data,
     GLuint dst_offset,
     GLuint length) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
   WebGLExtensionScopedContext scoped(this);
   if (scoped.IsLost()) {
     DOMException* exception =
         DOMException::Create(kInvalidStateError, "context lost");
     resolver->Reject(exception);
     return promise;
   }
 
   WebGL2RenderingContextBase* context = nullptr;
   {
     WebGLRenderingContextBase* context_base = scoped.Context();
     DCHECK_GE(context_base->Version(), 2u);
     context = static_cast<WebGL2RenderingContextBase*>(context_base);
   }
 
   WebGLBuffer* source_buffer = nullptr;
   void* destination_data_ptr = nullptr;
   long long destination_byte_length = 0;
   const char* message = context->ValidateGetBufferSubData(
-      __FUNCTION__, target, src_byte_offset, dst_data.View(), dst_offset,
-      length, &source_buffer, &destination_data_ptr, &destination_byte_length);
+      __FUNCTION__, target, src_byte_offset, dst_data, dst_offset, length,
+      &source_buffer, &destination_data_ptr, &destination_byte_length);
   if (message) {
     // If there was a GL error, it was already synthesized in
     // validateGetBufferSubData, so it's not done here.
     DOMException* exception = DOMException::Create(kInvalidStateError, message);
     resolver->Reject(exception);
     return promise;
   }
 
   message = context->ValidateGetBufferSubDataBounds(
       __FUNCTION__, source_buffer, src_byte_offset, destination_byte_length);
   if (message) {
     // If there was a GL error, it was already synthesized in
     // validateGetBufferSubDataBounds, so it's not done here.
     DOMException* exception = DOMException::Create(kInvalidStateError, message);
     resolver->Reject(exception);
     return promise;
   }
 
   // If the length of the copy is zero, this is a no-op.
   if (!destination_byte_length) {
-    resolver->Resolve(dst_data.View());
+    resolver->Resolve(dst_data);
     return promise;
   }
 
   GLuint query_id;
   context->ContextGL()->GenQueriesEXT(1, &query_id);
   context->ContextGL()->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM, query_id);
   void* mapped_data = context->ContextGL()->GetBufferSubDataAsyncCHROMIUM(
       target, src_byte_offset, destination_byte_length);
   context->ContextGL()->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM);
   if (!mapped_data) {
     DOMException* exception =
         DOMException::Create(kInvalidStateError, "Out of memory");
     resolver->Reject(exception);
     return promise;
   }
 
   auto callback_object = new WebGLGetBufferSubDataAsyncCallback(
-      context, resolver, mapped_data, query_id, dst_data.View(),
-      destination_data_ptr, destination_byte_length);
+      context, resolver, mapped_data, query_id, dst_data, destination_data_ptr,
+      destination_byte_length);
   context->RegisterGetBufferSubDataAsyncCallback(callback_object);
   auto callback = WTF::Bind(&WebGLGetBufferSubDataAsyncCallback::Resolve,
                             WrapPersistent(callback_object));
   context->GetDrawingBuffer()->ContextProvider()->SignalQuery(
       query_id, ConvertToBaseCallback(std::move(callback)));
 
   return promise;
 }
 
 WebGLGetBufferSubDataAsyncCallback::WebGLGetBufferSubDataAsyncCallback(
@@ skipping 49 matching lines @@
   context_->UnregisterGetBufferSubDataAsyncCallback(this);
 }
 
 DEFINE_TRACE(WebGLGetBufferSubDataAsyncCallback) {
   visitor->Trace(context_);
   visitor->Trace(promise_resolver_);
   visitor->Trace(destination_array_buffer_view_);
 }
 
 }  // namespace blink