Implementing promise-based commit for driving OffscreenCanvas animations

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 694 matching lines @@
 ImageBitmap* WebGLRenderingContextBase::transferToImageBitmapBase(
     ScriptState* scriptState) {
   UseCounter::Feature feature =
       UseCounter::OffscreenCanvasTransferToImageBitmapWebGL;
   UseCounter::count(scriptState->getExecutionContext(), feature);
   if (!drawingBuffer())
     return nullptr;
   return ImageBitmap::create(drawingBuffer()->transferToStaticBitmapImage());
 }
 
-void WebGLRenderingContextBase::commit(ScriptState* scriptState,
-                                       ExceptionState& exceptionState) {
+ScriptPromise WebGLRenderingContextBase::commit(
+    ScriptState* scriptState,
+    ExceptionState& exceptionState) {
   UseCounter::Feature feature = UseCounter::OffscreenCanvasCommitWebGL;
   UseCounter::count(scriptState->getExecutionContext(), feature);
-  if (!getOffscreenCanvas()) {
+  if (!offscreenCanvas()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      "Commit() was called on a rendering "
                                      "context that was not created from an "
                                      "OffscreenCanvas.");
-    return;
+    return exceptionState.reject(scriptState);
   }
   // no HTMLCanvas associated, thrown InvalidStateError
-  if (!getOffscreenCanvas()->hasPlaceholderCanvas()) {
+  if (!offscreenCanvas()->hasPlaceholderCanvas()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      "Commit() was called on a context whose "
                                      "OffscreenCanvas is not associated with a "
                                      "canvas element.");
-    return;
+    return exceptionState.reject(scriptState);
   }
-  if (!drawingBuffer())
-    return;
-  double commitStartTime = WTF::monotonicallyIncreasingTime();
+  if (!drawingBuffer()) {
+    exceptionState.throwDOMException(InvalidStateError,

[xlai (Olivia), 2016/12/21 19:54:25]

Could you add a subtest to OffscreenCanvas-commit-invalid-call.html to validate
this exception?

[Justin Novosad, 2016/12/21 21:15:40]

That is actually really hard to do because it requires faking  some kind of GPU
set-up failure.  This case is really weird because we are forced to return a
promise, and we can't just return a promise that will never be resolved. I think
I was doing the wrong thing here.  I am changing the code to do a silent commit
instead.

+                                     "WebGL context has no drawing buffer.");
+    return exceptionState.reject(scriptState);
+  }
   // TODO(crbug.com/646864): Make commit() work correctly with
   // { preserveDrawingBuffer : true }.
-  getOffscreenCanvas()->getOrCreateFrameDispatcher()->dispatchFrame(
+  return offscreenCanvas()->commit(
       std::move(drawingBuffer()->transferToStaticBitmapImage()),
-      commitStartTime,
-      drawingBuffer()->contextProvider()->isSoftwareRendering());
+      drawingBuffer()->contextProvider()->isSoftwareRendering(), scriptState);
 }
 
 PassRefPtr<Image> WebGLRenderingContextBase::getImage(
     AccelerationHint hint,
     SnapshotReason reason) const {
   if (!drawingBuffer())
     return nullptr;
 
   drawingBuffer()->resolveAndBindForReadAndDraw();
   IntSize size = clampedCanvasSize();
@@ skipping 20 matching lines @@
   // images. See crbug.com/657531.
   ImageData* imageData = nullptr;
   // TODO(ccameron): WebGL should produce sRGB images.
   // https://crbug.com/672299
   if (this->drawingBuffer()) {
     sk_sp<SkImage> snapshot =
         this->drawingBuffer()
             ->transferToStaticBitmapImage()
             ->imageForCurrentFrame(ColorBehavior::transformToGlobalTarget());
     if (snapshot) {
-      imageData = ImageData::create(this->getOffscreenCanvas()->size());
+      imageData = ImageData::create(this->offscreenCanvas()->size());
       SkImageInfo imageInfo = SkImageInfo::Make(
           this->drawingBufferWidth(), this->drawingBufferHeight(),
           kRGBA_8888_SkColorType, kUnpremul_SkAlphaType);
       snapshot->readPixels(imageInfo, imageData->data()->data(),
                            imageInfo.minRowBytes(), 0, 0);
     }
   }
   return imageData;
 }
 
@@ skipping 6583 matching lines @@
     synthesizeGLError(GL_INVALID_FRAMEBUFFER_OPERATION, functionName, reason);
     return false;
   }
 
   return true;
 }
 
 void WebGLRenderingContextBase::dispatchContextLostEvent(TimerBase*) {
   WebGLContextEvent* event = WebGLContextEvent::create(
       EventTypeNames::webglcontextlost, false, true, "");
-  if (getOffscreenCanvas())
-    getOffscreenCanvas()->dispatchEvent(event);
+  if (offscreenCanvas())
+    offscreenCanvas()->dispatchEvent(event);
   else
     canvas()->dispatchEvent(event);
   m_restoreAllowed = event->defaultPrevented();
   if (m_restoreAllowed && !m_isHidden) {
     if (m_autoRecoveryMethod == Auto)
       m_restoreTimer.startOneShot(0, BLINK_FROM_HERE);
   }
 }
 
 void WebGLRenderingContextBase::maybeRestoreContext(TimerBase*) {
@@ skipping 25 matching lines @@
   // enough.
   if (drawingBuffer()) {
     m_drawingBuffer->beginDestruction();
     m_drawingBuffer.clear();
   }
 
   Platform::ContextAttributes attributes =
       toPlatformContextAttributes(creationAttributes(), version());
   Platform::GraphicsInfo glInfo;
   std::unique_ptr<WebGraphicsContext3DProvider> contextProvider;
-  const auto& url = canvas()
-                        ? canvas()->document().topDocument().url()
-                        : getOffscreenCanvas()->getExecutionContext()->url();
+  const auto& url = canvas() ? canvas()->document().topDocument().url()
+                             : offscreenCanvas()->getExecutionContext()->url();
   if (isMainThread()) {
     contextProvider = WTF::wrapUnique(
         Platform::current()->createOffscreenGraphicsContext3DProvider(
             attributes, url, 0, &glInfo));
   } else {
     contextProvider =
         createContextProviderOnWorkerThread(attributes, &glInfo, url);
   }
   RefPtr<DrawingBuffer> buffer;
   if (contextProvider && contextProvider->bindToCurrentThread()) {
@@ skipping 34 matching lines @@
   removeFromEvictedList(this);
 
   setupFlags();
   initializeNewContext();
   markContextChanged(CanvasContextChanged);
   WebGLContextEvent* event = WebGLContextEvent::create(
       EventTypeNames::webglcontextrestored, false, true, "");
   if (canvas())
     canvas()->dispatchEvent(event);
   else
-    getOffscreenCanvas()->dispatchEvent(event);
+    offscreenCanvas()->dispatchEvent(event);
 }
 
 String WebGLRenderingContextBase::ensureNotNull(const String& text) const {
   if (text.isNull())
     return WTF::emptyString();
   return text;
 }
 
 WebGLRenderingContextBase::LRUImageBufferCache::LRUImageBufferCache(
     int capacity)
@@ skipping 105 matching lines @@
   else
     contextGL()->Disable(capability);
 }
 
 IntSize WebGLRenderingContextBase::clampedCanvasSize() const {
   int width, height;
   if (canvas()) {
     width = canvas()->width();
     height = canvas()->height();
   } else {
-    width = getOffscreenCanvas()->width();
-    height = getOffscreenCanvas()->height();
+    width = offscreenCanvas()->width();
+    height = offscreenCanvas()->height();
   }
   return IntSize(clamp(width, 1, m_maxViewportDims[0]),
                  clamp(height, 1, m_maxViewportDims[1]));
 }
 
 GLint WebGLRenderingContextBase::maxDrawBuffers() {
   if (isContextLost() ||
       !(extensionEnabled(WebGLDrawBuffersName) || isWebGL2OrHigher()))
     return 0;
   if (!m_maxDrawBuffers)
@@ skipping 141 matching lines @@
 void WebGLRenderingContextBase::restoreUnpackParameters() {
   if (m_unpackAlignment != 1)
     contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
-    result.setOffscreenCanvas(getOffscreenCanvas());
+    result.setOffscreenCanvas(offscreenCanvas());
 }
 
 }  // namespace blink