implement getBufferSubDataAsync prototype

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

 // 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.
 
 #include "modules/webgl/WebGL2RenderingContextBase.h"
 
 #include "bindings/modules/v8/WebGLAny.h"
+#include "core/dom/DOMException.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
+#include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "modules/webgl/WebGLActiveInfo.h"
 #include "modules/webgl/WebGLBuffer.h"
 #include "modules/webgl/WebGLFenceSync.h"
 #include "modules/webgl/WebGLFramebuffer.h"
 #include "modules/webgl/WebGLProgram.h"
 #include "modules/webgl/WebGLQuery.h"
 #include "modules/webgl/WebGLRenderbuffer.h"
 #include "modules/webgl/WebGLSampler.h"
 #include "modules/webgl/WebGLSync.h"
@@ skipping 157 matching lines @@
   m_boundCopyWriteBuffer = nullptr;
   m_boundPixelPackBuffer = nullptr;
   m_boundPixelUnpackBuffer = nullptr;
   m_boundTransformFeedbackBuffer = nullptr;
   m_boundUniformBuffer = nullptr;
 
   m_currentBooleanOcclusionQuery = nullptr;
   m_currentTransformFeedbackPrimitivesWrittenQuery = nullptr;
 }
 
+void WebGL2RenderingContextBase::destroyContext() {
+  for (auto& callback : m_getBufferSubDataAsyncCallbacks) {
+    callback->destroy();
+  }
+  m_getBufferSubDataAsyncCallbacks.clear();
+
+  WebGLRenderingContextBase::destroyContext();
+}
+
 void WebGL2RenderingContextBase::initializeNewContext() {
   ASSERT(!isContextLost());
   ASSERT(drawingBuffer());
 
   m_readFramebufferBinding = nullptr;
 
   m_boundCopyReadBuffer = nullptr;
   m_boundCopyWriteBuffer = nullptr;
   m_boundPixelPackBuffer = nullptr;
   m_boundPixelUnpackBuffer = nullptr;
@@ skipping 179 matching lines @@
                                   subByteLength, GL_MAP_READ_BIT);
 
   if (!mappedData)
     return;
 
   memcpy(subBaseAddress, mappedData, subByteLength);
 
   contextGL()->UnmapBuffer(target);
 }
 
+WebGL2RenderingContextBase::GetBufferSubDataAsyncCallback::
+    GetBufferSubDataAsyncCallback(WebGL2RenderingContextBase* context,
+                                  DOMArrayBufferView* dstData,
+                                  ScriptPromiseResolver* resolver,
+                                  void* subBaseAddress,
+                                  void* mappedData,
+                                  long long subByteLength)
+    : context(context),
+      dstData(dstData),
+      resolver(resolver),
+      subBaseAddress(subBaseAddress),
+      mappedData(mappedData),
+      subByteLength(subByteLength) {}
+
+void WebGL2RenderingContextBase::GetBufferSubDataAsyncCallback::destroy() {
+  context->contextGL()->FreeSharedMemory(mappedData);
+  mappedData = nullptr;
+  DOMException* exception =
+      DOMException::create(InvalidStateError, "context lost or destroyed");
+  this->resolver->reject(exception);
+}
+
+void WebGL2RenderingContextBase::GetBufferSubDataAsyncCallback::resolve(
+    GetBufferSubDataAsyncCallback* self) {
+  if (!self->context || !self->mappedData) {
+    DOMException* exception =
+        DOMException::create(InvalidStateError, "context lost or destroyed");
+    self->resolver->reject(exception);
+    return;
+  }
+  if (self->dstData->buffer()->isNeutered()) {
+    // XXX: should this set a GL error? No, according to current spec draft.
+    DOMException* exception = DOMException::create(
+        InvalidStateError, "ArrayBufferView became invalid asynchronously");
+    self->resolver->reject(exception);
+    return;
+  }
+  memcpy(self->subBaseAddress, self->mappedData, self->subByteLength);
+  // XXX: What would happen if the DOM was suspended when the promise
+  // became resolved? Could another JS task happen between the memcpy
+  // and the promise resolution task?
+  self->resolver->resolve(self->dstData);

[adamk, 2016/10/07 23:00:43]

My knowledge of the Blink event loop is a little rusty (it predates the
scheduler), but it definitely looks like other JS tasks could run, since
ScriptPromiseResolver::resume calls m_timer.startOneShot() in order to kick off
the actual resolution. I don't see how that could guarantee that other JS tasks
haven't been enqueued first.

[yhirano, 2016/10/12 09:32:02]

When the window is suspended, ScriptPromiseResolver will wait for window to be
resumed. Otherwise, ScriptPromiseResolver will call actual resolve()
immediately, but the callbacks attached to the promise will be called later.

[tyoshino (SeeGerritForStatus), 2016/10/12 10:00:39]

As this looked related to promises, I asked yhirano@ to review this.

What do you want to guarantee? Please point the algorithm in
https://github.com/KhronosGroup/WebGL/pull/2079/files if any.

+
+  self->destroy();
+  self->context->unregisterGetBufferSubDataAsyncCallback(self);
+}
+
+ScriptPromise WebGL2RenderingContextBase::getBufferSubDataAsync(
+    ScriptState* scriptState,
+    GLenum target,
+    GLintptr srcByteOffset,
+    DOMArrayBufferView* dstData,
+    GLuint dstOffset,
+    GLuint length) {
+  ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+  ScriptPromise promise = resolver->promise();
+
+  const char* funcName = "getBufferSubDataAsync";
+  if (isContextLost()) {
+    DOMException* exception =
+        DOMException::create(InvalidStateError, "context lost");
+    resolver->reject(exception);
+    return promise;
+  }
+  if (!validateValueFitNonNegInt32(funcName, "srcByteOffset", srcByteOffset)) {
+    DOMException* exception =
+        DOMException::create(InvalidStateError, "invalid value: srcByteOffset");
+    resolver->reject(exception);
+    return promise;
+  }
+  if (target == GL_TRANSFORM_FEEDBACK_BUFFER && m_transformFeedbackBinding) {
+    // XXX: is this restriction enforced in the original getBufferSubData? Does it need to be added there, or can it be removed here?
+    synthesizeGLError(GL_INVALID_OPERATION, funcName,
+                      "targeted transform feedback buffer is bound");
+    DOMException* exception = DOMException::create(
+        InvalidStateError,
+        "invalid operation: targeted transform feedback buffer is bound");
+    resolver->reject(exception);
+    return promise;
+  }
+  WebGLBuffer* buffer = validateBufferDataTarget(funcName, target);
+  if (!buffer) {
+    DOMException* exception = DOMException::create(
+        InvalidStateError, "invalid operation: no buffer bound to target");
+    resolver->reject(exception);
+    return promise;
+  }
+
+  void* subBaseAddress = nullptr;
+  long long subByteLength = 0;
+  if (!validateSubSourceAndGetData(dstData, dstOffset, length, &subBaseAddress,
+                                   &subByteLength)) {
+    synthesizeGLError(GL_INVALID_VALUE, funcName,
+                      "dstOffset and length out of bounds of dstData");
+    DOMException* exception =
+        DOMException::create(InvalidStateError,
+                             "invalid value: dstOffset and length "
+                             "out of bounds of dstData");
+    resolver->reject(exception);
+    return promise;
+  }
+  if (subByteLength == 0) {
+    resolver->resolve(dstData);
+    return promise;
+  }
+
+  CheckedNumeric<long long> dstEnd = subByteLength;
+  dstEnd += srcByteOffset;
+  if (!dstEnd.IsValid() || dstEnd.ValueOrDie() > buffer->getSize()) {
+    synthesizeGLError(
+        GL_INVALID_VALUE, funcName,
+        "offset + numBytes would extend beyond the end of buffer");
+    DOMException* exception =
+        DOMException::create(InvalidStateError,
+                             "invalid value: offset + numBytes would extend "
+                             "beyond the end of buffer");
+    resolver->reject(exception);
+    return promise;
+  }
+
+  GLuint queryID;
+  contextGL()->GenQueriesEXT(1, &queryID);
+  contextGL()->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM, queryID);
+  void* mappedData = contextGL()->GetBufferSubDataAsyncCHROMIUM(
+      target, srcByteOffset, subByteLength);
+  if (!mappedData) {
+    DOMException* exception =
+        DOMException::create(InvalidStateError, "out of memory");
+    resolver->reject(exception);
+    return promise;
+  }
+  contextGL()->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM);
+
+  auto callbackObject = adoptRef(new GetBufferSubDataAsyncCallback(
+      this, dstData, resolver, subBaseAddress, mappedData, subByteLength));
+  registerGetBufferSubDataAsyncCallback(callbackObject.get());
+  auto callback =
+      WTF::bind(&GetBufferSubDataAsyncCallback::resolve, callbackObject);
+  drawingBuffer()->contextProvider()->signalQuery(
+      queryID, convertToBaseCallback(std::move(callback)));
+  contextGL()->DeleteQueriesEXT(1, &queryID);
+
+  return promise;
+}
+
+void WebGL2RenderingContextBase::registerGetBufferSubDataAsyncCallback(
+    GetBufferSubDataAsyncCallback* callback) {
+  m_getBufferSubDataAsyncCallbacks.insert(callback);
+}
+
+void WebGL2RenderingContextBase::unregisterGetBufferSubDataAsyncCallback(
+    GetBufferSubDataAsyncCallback* callback) {
+  m_getBufferSubDataAsyncCallbacks.erase(callback);
+}
+
 void WebGL2RenderingContextBase::blitFramebuffer(GLint srcX0,
                                                  GLint srcY0,
                                                  GLint srcX1,
                                                  GLint srcY1,
                                                  GLint dstX0,
                                                  GLint dstY0,
                                                  GLint dstX1,
                                                  GLint dstY1,
                                                  GLbitfield mask,
                                                  GLenum filter) {
@@ skipping 4090 matching lines @@
   params.skipPixels = m_unpackSkipPixels;
   params.skipRows = m_unpackSkipRows;
   if (dimension == Tex3D) {
     params.imageHeight = m_unpackImageHeight;
     params.skipImages = m_unpackSkipImages;
   }
   return params;
 }
 
 }  // namespace blink