Implementing promise-based commit for driving OffscreenCanvas animations

third_party/WebKit/Source/core/offscreencanvas/OffscreenCanvas.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 "core/offscreencanvas/OffscreenCanvas.h"
 
 #include "core/dom/ExceptionCode.h"
 #include "core/fileapi/Blob.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/ImageData.h"
 #include "core/html/canvas/CanvasAsyncBlobCreator.h"
 #include "core/html/canvas/CanvasContextCreationAttributes.h"
 #include "core/html/canvas/CanvasRenderingContext.h"
 #include "core/html/canvas/CanvasRenderingContextFactory.h"
 #include "platform/graphics/Image.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/OffscreenCanvasFrameDispatcherImpl.h"
 #include "platform/graphics/StaticBitmapImage.h"
 #include "platform/image-encoders/ImageEncoderUtils.h"
 #include "wtf/MathExtras.h"
 #include <memory>
 
 namespace blink {
 
-OffscreenCanvas::OffscreenCanvas(const IntSize& size)
-    : m_size(size), m_originClean(true) {}
+OffscreenCanvas::OffscreenCanvas(const IntSize& size) : m_size(size) {}
 
 OffscreenCanvas* OffscreenCanvas::create(unsigned width, unsigned height) {
   return new OffscreenCanvas(
       IntSize(clampTo<int>(width), clampTo<int>(height)));
 }
 
+OffscreenCanvas::~OffscreenCanvas() {}
+
+void OffscreenCanvas::dispose() {
+  if (m_context) {
+    m_context->detachOffscreenCanvas();
+    m_context = nullptr;
+  }
+  if (m_commitPromiseResolver) {
+    // keepAliveWhilePending() guarantees the promise resolver is never
+    // GC-ed before the OffscreenCanvas
+    m_commitPromiseResolver->reject();
+    m_commitPromiseResolver.clear();
+  }
+}
+
 void OffscreenCanvas::setWidth(unsigned width) {
   IntSize newSize = m_size;
   newSize.setWidth(clampTo<int>(width));
   setSize(newSize);
 }
 
 void OffscreenCanvas::setHeight(unsigned height) {
   IntSize newSize = m_size;
   newSize.setHeight(clampTo<int>(height));
   setSize(newSize);
@@ skipping 163 matching lines @@
 bool OffscreenCanvas::isAccelerated() const {
   return m_context && m_context->isAccelerated();
 }
 
 OffscreenCanvasFrameDispatcher* OffscreenCanvas::getOrCreateFrameDispatcher() {
   if (!m_frameDispatcher) {
     // The frame dispatcher connects the current thread of OffscreenCanvas
     // (either main or worker) to the browser process and remains unchanged
     // throughout the lifetime of this OffscreenCanvas.
     m_frameDispatcher = WTF::wrapUnique(new OffscreenCanvasFrameDispatcherImpl(
-        m_clientId, m_sinkId, m_placeholderCanvasId, m_size.width(),
+        this, m_clientId, m_sinkId, m_placeholderCanvasId, m_size.width(),
         m_size.height()));
   }
   return m_frameDispatcher.get();
 }
 
+ScriptPromise OffscreenCanvas::commit(RefPtr<StaticBitmapImage> image,
+                                      bool isWebGLSoftwareRendering,
+                                      ScriptState* scriptState) {
+  if (m_commitPromiseResolver) {
+    m_overdrawFrame = std::move(image);

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

I'm wondering if you need to store the scriptState for the overdraw frame as
well. Will the scriptState ever change from frame to frame?

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

The overdraw frame does not generate a promise (the commit call re-returns the
previous promise), so we have no use for the scriptState.

+    m_overdrawFrameIsWebGLSoftwareRendering = isWebGLSoftwareRendering;
+  } else {
+    m_overdrawFrame = nullptr;
+    m_commitPromiseResolver = ScriptPromiseResolver::create(scriptState);
+    m_commitPromiseResolver->keepAliveWhilePending();
+    doCommit(std::move(image), isWebGLSoftwareRendering);
+  }
+  return m_commitPromiseResolver->promise();
+}
+
+void OffscreenCanvas::doCommit(RefPtr<StaticBitmapImage> image,
+                               bool isWebGLSoftwareRendering) {
+  double commitStartTime = WTF::monotonicallyIncreasingTime();
+  getOrCreateFrameDispatcher()->dispatchFrame(std::move(image), commitStartTime,
+                                              isWebGLSoftwareRendering);
+}
+
+void OffscreenCanvas::beginFrame() {
+  if (m_overdrawFrame) {
+    // if we have an overdraw backlog, push the frame from the backlog
+    // first and save the promise resolution for later.
+    doCommit(std::move(m_overdrawFrame),
+             m_overdrawFrameIsWebGLSoftwareRendering);

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

Hmmmm...After you doCommit on the overdrawFrame, do you need to set
m_overdrawFrame to be null? If not, when the next beginFrame() starts, will you
repeat doCommit on the same frame?

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

std::move already takes care of that. 

+  } else if (m_commitPromiseResolver) {
+    m_commitPromiseResolver->resolve();

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

So you only resolve the promiseResolver when there is no more overdraw frame?
(as this is else if)

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

Exactly. As long as there is a backlog, we do not need to be triggering new
frames.

+    m_commitPromiseResolver.clear();
+  }
+}
+
 ScriptPromise OffscreenCanvas::convertToBlob(ScriptState* scriptState,
                                              const ImageEncodeOptions& options,
                                              ExceptionState& exceptionState) {
   if (this->isNeutered()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      "OffscreenCanvas object is detached.");
     return exceptionState.reject(scriptState);
   }
 
   if (!this->originClean()) {
@@ skipping 32 matching lines @@
       document, resolver);
 
   asyncCreator->scheduleAsyncBlobCreation(options.quality());
 
   return resolver->promise();
 }
 
 DEFINE_TRACE(OffscreenCanvas) {
   visitor->trace(m_context);
   visitor->trace(m_executionContext);
+  visitor->trace(m_commitPromiseResolver);
   EventTargetWithInlineData::trace(visitor);
 }
 
 }  // namespace blink