Use SkJpegEncoder in WebKit platform

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.
 
 #ifndef CanvasAsyncBlobCreator_h
 #define CanvasAsyncBlobCreator_h
 
 #include <memory>
 #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 "platform/wtf/Vector.h"
 #include "platform/wtf/text/WTFString.h"
 #include "public/platform/WebTraceLocation.h"
+#include "third_party/skia/include/encode/SkEncoder.h"
 
 namespace blink {
 
 class Document;
-class JPEGImageEncoderState;
-class PNGImageEncoderState;
 
 class CORE_EXPORT CanvasAsyncBlobCreator
     : public GarbageCollectedFinalized<CanvasAsyncBlobCreator> {
  public:
   static CanvasAsyncBlobCreator* Create(
       DOMUint8ClampedArray* unpremultiplied_rgba_image_data,
       const String& mime_type,
       const IntSize&,
       BlobCallback*,
       double start_time,
@@ skipping 40 matching lines @@
 
  protected:
   CanvasAsyncBlobCreator(DOMUint8ClampedArray* data,
                          MimeType,
                          const IntSize&,
                          BlobCallback*,
                          double,
                          Document*,
                          ScriptPromiseResolver*);
   // Methods are virtual for unit testing
-  virtual void ScheduleInitiatePngEncoding();
-  virtual void ScheduleInitiateJpegEncoding(const double&);
-  virtual void IdleEncodeRowsPng(double deadline_seconds);
-  virtual void IdleEncodeRowsJpeg(double deadline_seconds);
+  virtual void ScheduleInitiateEncoding(double quality);
+  virtual void IdleEncodeRows(double deadline_seconds);
   virtual void PostDelayedTaskToCurrentThread(const WebTraceLocation&,
                                               std::unique_ptr<WTF::Closure>,
                                               double delay_ms);
   virtual void SignalAlternativeCodePathFinishedForTesting() {}
   virtual void CreateBlobAndReturnResult();
   virtual void CreateNullAndReturnResult();
 
-  void InitiatePngEncoding(double deadline_seconds);
-  void InitiateJpegEncoding(const double& quality, double deadline_seconds);
+  void InitiateEncoding(double quality, double deadline_seconds);
   IdleTaskStatus idle_task_status_;
 
  private:
   friend class CanvasAsyncBlobCreatorTest;
 
   void Dispose();
 
-  std::unique_ptr<PNGImageEncoderState> png_encoder_state_;
-  std::unique_ptr<JPEGImageEncoderState> jpeg_encoder_state_;
   Member<DOMUint8ClampedArray> data_;
+  std::unique_ptr<SkEncoder> encoder_;

[f(malita), 2017/05/15 19:53:26]

For encapsulation, I wonder if it'd make sense to have a thin wrapper for
SkEncoder + VectorWStream.  How about something like

  class ImageEncoder {
    ImageEncoder(...);

    encodeRows(...);

    encode(...);
  }

Then I think we could hide VectorWStream and some of the initialization
boilerplate.

WDYT?

[msarett1, 2017/05/15 23:49:08]

I wrote a wrapper class, let me know if it is along the lines you were thinking.

I think it is nice to encapsulate VectorWStream.

I intentionally didn't encapsulate SkImageInfo or the Options.  The flexibility
provided by the SkImageInfo (and some of the Options) is part of the motivation
for this change.

Though I could see an argument to encapulate some of the Options that I am just
filling in with the old Chrome defaults... 

   std::unique_ptr<Vector<unsigned char>> encoded_image_;
+  std::unique_ptr<SkWStream> dst_;
   int num_rows_completed_;
   Member<Document> document_;
 
-  const IntSize size_;
-  size_t pixel_row_stride_;
+  SkPixmap src_data_;
   const MimeType mime_type_;
   double start_time_;
   double schedule_initiate_start_time_;
   double elapsed_time_;
 
   ToBlobFunctionType function_type_;
 
   // Used when CanvasAsyncBlobCreator runs on main thread only
   Member<ParentFrameTaskRunners> parent_frame_task_runner_;
 
   // Used for HTMLCanvasElement only
   Member<BlobCallback> callback_;
 
   // Used for OffscreenCanvas only
   Member<ScriptPromiseResolver> script_promise_resolver_;
 
-  // PNG
-  bool InitializePngStruct();
-  void ForceEncodeRowsPngOnCurrentThread();  // Similar to idleEncodeRowsPng
-                                             // without deadline
-
-  // JPEG
-  bool InitializeJpegStruct(double quality);
-  void ForceEncodeRowsJpegOnCurrentThread();  // Similar to idleEncodeRowsJpeg
-                                              // without
-                                              // deadline
+  // PNG, JPEG
+  bool InitializeEncoder(double quality);
+  void ForceEncodeRowsOnCurrentThread();  // Similar to IdleEncodeRows
+                                          // without deadline
 
   // WEBP
   void EncodeImageOnEncoderThread(double quality);
 
   void IdleTaskStartTimeoutEvent(double quality);
   void IdleTaskCompleteTimeoutEvent();
 };
 
 }  // namespace blink
 
 #endif  // CanvasAsyncBlobCreator_h