Implementing promise-based commit for driving OffscreenCanvas animations

third_party/WebKit/Source/modules/offscreencanvas2d/OffscreenCanvasRenderingContext2D.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/offscreencanvas2d/OffscreenCanvasRenderingContext2D.h"
 
 #include "bindings/modules/v8/OffscreenCanvasRenderingContext2DOrWebGLRenderingContextOrWebGL2RenderingContext.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/frame/Settings.h"
 #include "core/workers/WorkerGlobalScope.h"
@@ skipping 25 matching lines @@
       toWorkerGlobalScope(executionContext)->workerSettings();
   if (workerSettings && workerSettings->disableReadingFromCanvas())
     canvas->setDisableReadingFromCanvasTrue();
 }
 
 DEFINE_TRACE(OffscreenCanvasRenderingContext2D) {
   CanvasRenderingContext::trace(visitor);
   BaseRenderingContext2D::trace(visitor);
 }
 
-void OffscreenCanvasRenderingContext2D::commit(ScriptState* scriptState,
-                                               ExceptionState& exceptionState) {
+ScriptPromise OffscreenCanvasRenderingContext2D::commit(
+    ScriptState* scriptState,
+    ExceptionState& exceptionState) {
   UseCounter::Feature feature = UseCounter::OffscreenCanvasCommit2D;
   UseCounter::count(scriptState->getExecutionContext(), feature);
-  if (!getOffscreenCanvas()->hasPlaceholderCanvas()) {
+  if (!offscreenCanvas()->hasPlaceholderCanvas()) {
     // If an OffscreenCanvas has no associated canvas Id, it indicates that
     // it is not an OffscreenCanvas created by transfering control from html
     // canvas.
     exceptionState.throwDOMException(InvalidStateError,
                                      "Commit() was called on a context whose "
                                      "OffscreenCanvas is not associated with a "
                                      "canvas element.");
-    return;
+    return exceptionState.reject(scriptState);
   }
-  double commitStartTime = WTF::monotonicallyIncreasingTime();
-  RefPtr<StaticBitmapImage> image = transferToStaticBitmapImage();
-  getOffscreenCanvas()->getOrCreateFrameDispatcher()->dispatchFrame(
-      std::move(image), commitStartTime);
+
+  bool isWebGLSoftwareRendering = false;
+  return offscreenCanvas()->commit(transferToStaticBitmapImage(),
+                                   isWebGLSoftwareRendering, scriptState);
 }
 
 // BaseRenderingContext2D implementation
 bool OffscreenCanvasRenderingContext2D::originClean() const {
-  return getOffscreenCanvas()->originClean();
+  return offscreenCanvas()->originClean();
 }
 
 void OffscreenCanvasRenderingContext2D::setOriginTainted() {
-  return getOffscreenCanvas()->setOriginTainted();
+  return offscreenCanvas()->setOriginTainted();
 }
 
 bool OffscreenCanvasRenderingContext2D::wouldTaintOrigin(
     CanvasImageSource* source,
     ExecutionContext* executionContext) {
   if (executionContext->isWorkerGlobalScope()) {
     // We only support passing in ImageBitmap and OffscreenCanvases as source
     // images in drawImage() or createPattern() in a OffscreenCanvas2d in
     // worker.
     DCHECK(source->isImageBitmap() || source->isOffscreenCanvas());
   }
 
   return CanvasRenderingContext::wouldTaintOrigin(
       source, executionContext->getSecurityOrigin());
 }
 
 int OffscreenCanvasRenderingContext2D::width() const {
-  return getOffscreenCanvas()->width();
+  return offscreenCanvas()->width();
 }
 
 int OffscreenCanvasRenderingContext2D::height() const {
-  return getOffscreenCanvas()->height();
+  return offscreenCanvas()->height();
 }
 
 bool OffscreenCanvasRenderingContext2D::hasImageBuffer() const {
   return !!m_imageBuffer;
 }
 
 void OffscreenCanvasRenderingContext2D::reset() {
   m_imageBuffer = nullptr;
   BaseRenderingContext2D::reset();
 }
@@ skipping 68 matching lines @@
 }
 
 ImageData* OffscreenCanvasRenderingContext2D::toImageData(
     SnapshotReason reason) const {
   if (!imageBuffer())
     return nullptr;
   sk_sp<SkImage> snapshot =
       m_imageBuffer->newSkImageSnapshot(PreferNoAcceleration, reason);
   ImageData* imageData = nullptr;
   if (snapshot) {
-    imageData = ImageData::create(this->getOffscreenCanvas()->size());
+    imageData = ImageData::create(offscreenCanvas()->size());
     SkImageInfo imageInfo =
         SkImageInfo::Make(this->width(), this->height(), kRGBA_8888_SkColorType,
                           kUnpremul_SkAlphaType);
     snapshot->readPixels(imageInfo, imageData->data()->data(),
                          imageInfo.minRowBytes(), 0, 0);
   }
   return imageData;
 }
 
 void OffscreenCanvasRenderingContext2D::setOffscreenCanvasGetContextResult(
@@ skipping 55 matching lines @@
 }
 
 bool OffscreenCanvasRenderingContext2D::isContextLost() const {
   return false;
 }
 
 bool OffscreenCanvasRenderingContext2D::isPaintable() const {
   return this->imageBuffer();
 }
 }