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 696 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()) {
+    return offscreenCanvas()->commit(nullptr, false, 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 6644 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