Synchronize commits at end of JS task

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 <memory>
 #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 "public/platform/Platform.h"
 #include "wtf/MathExtras.h"
-#include <memory>
 
 namespace blink {
 
 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)));
 }
 
@@ skipping 198 matching lines @@
         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) {
   getOrCreateFrameDispatcher()->setNeedsBeginFrame(true);
-  if (m_commitPromiseResolver) {
+
+  if (!m_commitPromiseResolver) {
+    m_commitPromiseResolver = ScriptPromiseResolver::create(scriptState);
+    m_commitPromiseResolver->keepAliveWhilePending();
+
+    m_overdrawFrame = nullptr;

[Justin Novosad, 2017/03/24 17:41:53]

We don't to track m_overdrawFrame anymore.

     if (image) {
+      // We defer the submission of commit frames at the end of JS task
+      m_currentFrame = std::move(image);
+      m_currentFrameIsWebGLSoftwareRendering = isWebGLSoftwareRendering;
+      Platform::current()->currentThread()->addTaskObserver(m_context);
+    }
+  } else if (image) {
+    if (m_currentFrame) {
+      // An override of m_currentFrame can happen when there are multiple
+      // frames committed before JS task finishes.
+      m_currentFrame = std::move(image);
+      m_currentFrameIsWebGLSoftwareRendering = isWebGLSoftwareRendering;
+    } else {
+      // The current frame has been dispatched but the promise is not resolved
+      // yet.
       m_overdrawFrame = std::move(image);
       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::doCommitAtEndOfTask() {

[Justin Novosad, 2017/03/24 17:41:53]

What happens if we reach this point and m_commitPromiseResolver is still
pending?  IMHO, we need to treat m_currentFrame as an overdraw frame in that
case, and postpone the commit until beginFrame().

[xlai (Olivia), 2017/03/24 18:18:52]

Actually, this situation was already handled in the original code. But I think I
used more than enough variables to hold the frames; m_currentFrame can be
reused in the overdraw situation. So I remove the
m_overdrawFrame now.

+  doCommit(std::move(m_currentFrame), m_currentFrameIsWebGLSoftwareRendering);
+  Platform::current()->currentThread()->removeTaskObserver(m_context);
+}
+
 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);
-  } else if (m_commitPromiseResolver) {
+  } else if (!m_currentFrame && m_commitPromiseResolver) {
     m_commitPromiseResolver->resolve();
     m_commitPromiseResolver.clear();
     // We need to tell parent frame to stop sending signals on begin frame to
     // avoid overhead once we resolve the promise.
     // In the case of overdraw frame (if block), we still need to wait for one
     // more frame time to resolve the existing promise.
     getOrCreateFrameDispatcher()->setNeedsBeginFrame(false);
   }
 }
 
@@ skipping 49 matching lines @@
 }
 
 DEFINE_TRACE(OffscreenCanvas) {
   visitor->trace(m_context);
   visitor->trace(m_executionContext);
   visitor->trace(m_commitPromiseResolver);
   EventTargetWithInlineData::trace(visitor);
 }
 
 }  // namespace blink