Implementing promise-based commit for driving OffscreenCanvas animations

third_party/WebKit/Source/core/offscreencanvas/OffscreenCanvas.h

 // 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.
 
 #ifndef OffscreenCanvas_h
 #define OffscreenCanvas_h
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "core/events/EventTarget.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/canvas/CanvasImageSource.h"
 #include "core/offscreencanvas/ImageEncodeOptions.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/OffscreenCanvasFrameDispatcher.h"
 #include "platform/heap/Handle.h"
 #include <memory>
 
 namespace blink {
 
 class CanvasContextCreationAttributes;
 class ImageBitmap;
 class
     OffscreenCanvasRenderingContext2DOrWebGLRenderingContextOrWebGL2RenderingContext;
 typedef OffscreenCanvasRenderingContext2DOrWebGLRenderingContextOrWebGL2RenderingContext
     OffscreenRenderingContext;
 
-class CORE_EXPORT OffscreenCanvas final : public EventTargetWithInlineData,
-                                          public CanvasImageSource,
-                                          public ImageBitmapSource {
+class CORE_EXPORT OffscreenCanvas final
+    : public EventTargetWithInlineData,
+      public CanvasImageSource,
+      public ImageBitmapSource,
+      public OffscreenCanvasFrameDispatcherClient {
   DEFINE_WRAPPERTYPEINFO();
+  USING_PRE_FINALIZER(OffscreenCanvas, dispose);
 
  public:
   static OffscreenCanvas* create(unsigned width, unsigned height);
-  ~OffscreenCanvas() override {}
+  ~OffscreenCanvas() override;
+  void dispose();
 
   // IDL attributes
   unsigned width() const { return m_size.width(); }
   unsigned height() const { return m_size.height(); }
   void setWidth(unsigned);
   void setHeight(unsigned);
 
   // API Methods
   ImageBitmap* transferToImageBitmap(ScriptState*, ExceptionState&);
   ScriptPromise convertToBlob(ScriptState*,
@@ skipping 19 matching lines @@
   CanvasRenderingContext* renderingContext() { return m_context; }
 
   static void registerRenderingContextFactory(
       std::unique_ptr<CanvasRenderingContextFactory>);
 
   bool originClean() const;
   void setOriginTainted() { m_originClean = false; }
   // TODO(crbug.com/630356): apply the flag to WebGL context as well
   void setDisableReadingFromCanvasTrue() { m_disableReadingFromCanvas = true; }
 
-  OffscreenCanvasFrameDispatcher* getOrCreateFrameDispatcher();
-
   void setFrameSinkId(uint32_t clientId, uint32_t sinkId) {
     m_clientId = clientId;
     m_sinkId = sinkId;
   }
   uint32_t clientId() const { return m_clientId; }
   uint32_t sinkId() const { return m_sinkId; }
 
   void setExecutionContext(ExecutionContext* context) {
     m_executionContext = context;
   }
 
+  ScriptPromise commit(RefPtr<StaticBitmapImage>,
+                       bool isWebGLSoftwareRendering,
+                       ScriptState*);
+
+  void detachContext() { m_context = nullptr; }
+
+  // OffscreenCanvasFrameDispatcherClient implementation
+  void beginFrame() final;
+
   // EventTarget implementation
   const AtomicString& interfaceName() const final {
     return EventTargetNames::OffscreenCanvas;
   }
   ExecutionContext* getExecutionContext() const {
     return m_executionContext.get();
   }
 
   // ImageBitmapSource implementation
   IntSize bitmapSourceSize() const final;
@@ skipping 15 matching lines @@
   }
   bool isOpaque() const final;
   bool isAccelerated() const final;
   int sourceWidth() final { return width(); }
   int sourceHeight() final { return height(); }
 
   DECLARE_VIRTUAL_TRACE();
 
  private:
   explicit OffscreenCanvas(const IntSize&);
-
+  OffscreenCanvasFrameDispatcher* getOrCreateFrameDispatcher();
+  void doCommit(RefPtr<StaticBitmapImage>, bool isWebGLSoftwareRendering);
   using ContextFactoryVector =
       Vector<std::unique_ptr<CanvasRenderingContextFactory>>;
   static ContextFactoryVector& renderingContextFactories();
   static CanvasRenderingContextFactory* getRenderingContextFactory(int);
 
   Member<CanvasRenderingContext> m_context;
   WeakMember<ExecutionContext> m_executionContext;
 
   enum {
     kNoPlaceholderCanvas = -1,  // DOMNodeIds starts from 0, using -1 to
                                 // indicate no associated canvas element.
   };
   int m_placeholderCanvasId = kNoPlaceholderCanvas;
 
   IntSize m_size;
   bool m_isNeutered = false;
 
-  bool m_originClean;
+  bool m_originClean = true;
   bool m_disableReadingFromCanvas = false;
 
   bool isPaintable() const;
 
   std::unique_ptr<OffscreenCanvasFrameDispatcher> m_frameDispatcher;
   // cc::FrameSinkId is broken into two integer components as this can be used

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

This comment for uint32_t m_clientId is broken into two parts.

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

Oop. Bad rebase.  Done.

+  Member<ScriptPromiseResolver> m_commitPromiseResolver;
+  RefPtr<StaticBitmapImage> m_overdrawFrame;
+  bool m_overdrawFrameIsWebGLSoftwareRendering = false;
   // in transfer of OffscreenCanvas across threads
   // If this object is not created via
   // HTMLCanvasElement.transferControlToOffscreen(),
   // then the following members would remain as initialized zero values.
   uint32_t m_clientId = 0;
   uint32_t m_sinkId = 0;
 };
 
 }  // namespace blink
 
 #endif  // OffscreenCanvas_h