Implement convertToBlob() in OffscreenCanvas

third_party/WebKit/Source/core/html/canvas/CanvasAsyncBlobCreator.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.
 
+#include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/CoreExport.h"
 #include "core/dom/DOMTypedArray.h"
 #include "core/fileapi/BlobCallback.h"
 #include "core/workers/ParentFrameTaskRunners.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/heap/Handle.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 #include <memory>
 
 namespace blink {
 
 class Document;
 class JPEGImageEncoderState;
 class PNGImageEncoderState;
 
 class CORE_EXPORT CanvasAsyncBlobCreator
     : public GarbageCollectedFinalized<CanvasAsyncBlobCreator> {
  public:
   static CanvasAsyncBlobCreator* create(

[Justin Novosad, 2016/10/19 19:59:32]

Since the callback and the promise resolver are mutually exclusive, it would be
clearer if we had two separate flavors of create(). The constructor is private
so no need to duplicate it. The main thing is to avoid the use of nullptr
literals at the external call sites, which is bad for readability.

[xlai (Olivia), 2016/10/20 15:58:54]

Done.

       DOMUint8ClampedArray* unpremultipliedRGBAImageData,
       const String& mimeType,
       const IntSize&,
       BlobCallback*,
       double,
-      Document&);
-  void scheduleAsyncBlobCreation(bool canUseIdlePeriodScheduling,
-                                 const double& quality = 0.0);
+      Document*,
+      ScriptPromiseResolver*);
+  void scheduleAsyncBlobCreation(const double& quality);
   virtual ~CanvasAsyncBlobCreator();
   enum MimeType {
     MimeTypePng,
     MimeTypeJpeg,
     MimeTypeWebp,
     NumberOfMimeTypeSupported
   };
   // This enum is used to back an UMA histogram, and should therefore be treated
   // as append-only.
   enum IdleTaskStatus {
     IdleTaskNotStarted,
     IdleTaskStarted,
     IdleTaskCompleted,
     IdleTaskFailed,
     IdleTaskSwitchedToMainThreadTask,

[Justin Novosad, 2016/10/19 19:59:32]

This name is obsolete (not necessarily main thread). Even before the name
"MainThreadTask" was not the best description. Perhaps we should call this
"IdleTaskSwitchedToImmediateTask"

[xlai (Olivia), 2016/10/20 15:58:54]

Done.

     IdleTaskNotSupported,  // Idle tasks are not implemented for some image
                            // types
     IdleTaskCount,         // Should not be seen in production
   };
+
+  enum ToBlobFunctionType {
+    HTMLCanvasToBlobCallback,
+    OffscreenCanvasToBlobPromise,
+    NumberOfToBlobFunctionTypes
+  };
+
   // Methods are virtual for mocking in unit tests
   virtual void signalTaskSwitchInStartTimeoutEventForTesting() {}
   virtual void signalTaskSwitchInCompleteTimeoutEventForTesting() {}
 
   DECLARE_VIRTUAL_TRACE();
 
  protected:
   CanvasAsyncBlobCreator(DOMUint8ClampedArray* data,
                          MimeType,
                          const IntSize&,
                          BlobCallback*,
                          double,
-                         Document&);
+                         Document*,
+                         ScriptPromiseResolver*);
   // Methods are virtual for unit testing
   virtual void scheduleInitiatePngEncoding();
   virtual void scheduleInitiateJpegEncoding(const double&);
   virtual void idleEncodeRowsPng(double deadlineSeconds);
   virtual void idleEncodeRowsJpeg(double deadlineSeconds);
   virtual void postDelayedTaskToMainThread(const WebTraceLocation&,

[Justin Novosad, 2016/10/19 19:59:33]

This also needs to be renamed because it is longer necessarily the Main thread.
Perhaps we could call it the ScriptExecutionThread, or maybe you have a better
idea?

[xlai (Olivia), 2016/10/20 15:58:54]

This function is related to the mechanism of "enforcing toBlob to happen if idle
task is waiting for too long" which has not been implemented in this CL yet.
Maybe we
think of it in the next CL?

                                            std::unique_ptr<WTF::Closure>,
                                            double delayMs);
   virtual void signalAlternativeCodePathFinishedForTesting() {}
-  virtual void createBlobAndInvokeCallback();
-  virtual void createNullAndInvokeCallback();
+  virtual void createBlobAndReturnResult();
+  virtual void createNullAndReturnResult();
 
   void initiatePngEncoding(double deadlineSeconds);
   void initiateJpegEncoding(const double& quality, double deadlineSeconds);
   IdleTaskStatus m_idleTaskStatus;
 
  private:
   friend class CanvasAsyncBlobCreatorTest;
 
   void dispose();
 
   std::unique_ptr<PNGImageEncoderState> m_pngEncoderState;
   std::unique_ptr<JPEGImageEncoderState> m_jpegEncoderState;
   Member<DOMUint8ClampedArray> m_data;
   std::unique_ptr<Vector<unsigned char>> m_encodedImage;
   int m_numRowsCompleted;
   Member<Document> m_document;
 
   const IntSize m_size;
   size_t m_pixelRowStride;
   const MimeType m_mimeType;
-  Member<BlobCallback> m_callback;
   double m_startTime;
   double m_scheduleInitiateStartTime;
   double m_elapsedTime;
+
+  ToBlobFunctionType m_functionType;

[Justin Novosad, 2016/10/19 19:59:33]

This additional state is not necessary, you could just have this: 
bool usingPromise() {
  DCHECK(!m_callback ^ !m_scriptPromiseResolver);
  DCHECK(!m_document == !m_callback);
  return m_scriptPromiseResolver;
}

[xlai (Olivia), 2016/10/20 15:58:54]

I think this additional state is necessary for the UMA histogram. It needs
to distinguish between canvas.toBlob and OffscreenCanvas.convertToBlob with
an explicit enum type.

And also for the unit test.

+
+  // Used for HTMLCanvasElement only
+  Member<BlobCallback> m_callback;
   Member<ParentFrameTaskRunners> m_parentFrameTaskRunner;
 
+  // Used for OffscreenCanvas only
+  Member<ScriptPromiseResolver> m_scriptPromiseResolver;
+
   // PNG
   bool initializePngStruct();
   void
   encodeRowsPngOnMainThread();  // Similar to idleEncodeRowsPng without deadline

[Justin Novosad, 2016/10/19 19:59:33]

Here too, not necessarily MainThread

[xlai (Olivia), 2016/10/20 15:58:54]

This one is not executed in the OffscreenCanvas case in this CL yet.

 
   // JPEG
   bool initializeJpegStruct(double quality);
   void encodeRowsJpegOnMainThread();  // Similar to idleEncodeRowsJpeg without

[Justin Novosad, 2016/10/19 19:59:32]

and here

                                       // deadline
 
   // WEBP
   void encodeImageOnEncoderThread(double quality);
 
   void idleTaskStartTimeoutEvent(double quality);
   void idleTaskCompleteTimeoutEvent();
 };
 
 }  // namespace blink