Implement Asynchronous image encoding for Canvas.toBlob

Source/core/html/HTMLCanvasElement.cpp

 /*
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 28 matching lines @@
 #include "core/frame/Settings.h"
 #include "core/html/ImageData.h"
 #include "core/html/canvas/CanvasContextCreationAttributes.h"
 #include "core/html/canvas/CanvasFontCache.h"
 #include "core/html/canvas/CanvasRenderingContext.h"
 #include "core/html/canvas/CanvasRenderingContextFactory.h"
 #include "core/layout/LayoutHTMLCanvas.h"
 #include "core/paint/DeprecatedPaintLayer.h"
 #include "platform/MIMETypeRegistry.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "platform/Task.h"
+#include "platform/ThreadSafeFunctional.h"
 #include "platform/graphics/Canvas2DImageBufferSurface.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/RecordingImageBufferSurface.h"
 #include "platform/graphics/StaticBitmapImage.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/gpu/AcceleratedImageBufferSurface.h"
 #include "platform/transforms/AffineTransform.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTraceLocation.h"
-#include "wtf/Functional.h"
 #include <math.h>
 #include <v8.h>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 namespace {
 
 // These values come from the WhatWG spec.
 const int DefaultWidth = 300;
 const int DefaultHeight = 150;
 
 // Firefox limits width/height to 32767 pixels, but slows down dramatically before it
 // reaches that limit. We limit by area instead, giving us larger maximum dimensions,
 // in exchange for a smaller maximum canvas size.
 const int MaxCanvasArea = 32768 * 8192; // Maximum canvas area in CSS pixels
 
 // In Skia, we will also limit width/height to 32767.
 const int MaxSkiaDim = 32767; // Maximum width/height in CSS pixels.
 
+// A default value of quality argument for toDataURL and toBlob
+// It is in an invalid range (outside 0.0 - 1.0) so that it will not be misinterpreted as a user-input value
+const int InvalidQualityValue = -1.0;
+
 bool canCreateImageBuffer(const IntSize& size)
 {
     if (size.isEmpty())
         return false;
     if (size.width() * size.height() > MaxCanvasArea)
         return false;
     if (size.width() > MaxSkiaDim || size.height() > MaxSkiaDim)
         return false;
     return true;
 }
@@ skipping 412 matching lines @@
     ASSERT(m_context->is2d());
     RefPtr<SkImage> snapshot = buffer()->newSkImageSnapshot();
     if (snapshot) {
         SkImageInfo imageInfo = SkImageInfo::Make(width(), height(), kRGBA_8888_SkColorType, kUnpremul_SkAlphaType);
         snapshot->readPixels(imageInfo, imageData->data()->data(), imageInfo.minRowBytes(), 0, 0);
     }
 
     return imageData;
 }
 
-String HTMLCanvasElement::toDataURLInternal(const String& mimeType, const double* quality, SourceDrawingBuffer sourceBuffer) const
+String HTMLCanvasElement::toDataURLInternal(const String& mimeType, const double& quality, SourceDrawingBuffer sourceBuffer) const
 {
     if (!isPaintable())
         return String("data:,");
 
     String encodingMimeType = toEncodingMimeType(mimeType);
 
     ImageData* imageData = toImageData(sourceBuffer);
     ScopedDisposal<ImageData> disposer(imageData);
 
     return ImageDataBuffer(imageData->size(), imageData->data()->data()).toDataURL(encodingMimeType, quality);
 }
 
 String HTMLCanvasElement::toDataURL(const String& mimeType, const ScriptValue& qualityArgument, ExceptionState& exceptionState) const
 {
     if (!originClean()) {
         exceptionState.throwSecurityError("Tainted canvases may not be exported.");
         return String();
     }
-    double quality;
-    double* qualityPtr = nullptr;
+    double quality = InvalidQualityValue;
     if (!qualityArgument.isEmpty()) {
         v8::Local<v8::Value> v8Value = qualityArgument.v8Value();
         if (v8Value->IsNumber()) {
             quality = v8Value.As<v8::Number>()->Value();
-            qualityPtr = &quality;
         }
     }
-    return toDataURLInternal(mimeType, qualityPtr, BackBuffer);
+    return toDataURLInternal(mimeType, quality, BackBuffer);
 }
 
-void HTMLCanvasElement::toBlob(FileCallback* callback, const String& mimeType, const ScriptValue& qualityArgument, ExceptionState& exceptionState) const
+void HTMLCanvasElement::encodeImageAsync(DOMUint8ClampedArray* imageData, IntSize imageSize, FileCallback* callback, const String& mimeType, double quality)
+{
+    OwnPtr<Vector<char>> encodedImage(adoptPtr(new Vector<char>()));
+
+    if (!ImageDataBuffer(imageSize, imageData->data()).encodeImage(mimeType, quality, encodedImage.get())) {

[Justin Novosad, 2015/09/21 16:51:56]

Do we know that all of the encoders are thread safe? It would be a good idea to
add a test that verifies that each of the encoders can be invoked concurrently
on the main thread and on the "Async toBlob" thread.  To do this, you should
create a test the fires off a series of toBlob calls, then do a series of calls
toDataURL, wait for the toBlob calls to finish. Validate that all the blobs and
dataURLs are correct.  If there are any race conditions in the encoder code,
this test will flake, and TSAN is likely to catch it. You should have a version
of the test for each of the supported codecs.

+        Platform::current()->mainThread()->taskRunner()->postTask(FROM_HERE, bind(&FileCallback::handleEvent, callback, nullptr));
+    } else {
+        Platform::current()->mainThread()->taskRunner()->postTask(FROM_HERE, threadSafeBind(&HTMLCanvasElement::createBlobAndCall, AllowCrossThreadAccess(this), encodedImage.release(), mimeType, AllowCrossThreadAccess(callback)));
+    }
+}
+
+void HTMLCanvasElement::createBlobAndCall(PassOwnPtr<Vector<char>> encodedImage, const String& mimeType, FileCallback* callback)
+{
+    // The main thread takes ownership of encoded image vector
+    OwnPtr<Vector<char>> enc(encodedImage);
+
+    File* resultBlob = File::create(enc->data(), enc->size(), mimeType);
+    Platform::current()->mainThread()->taskRunner()->postTask(FROM_HERE, bind(&FileCallback::handleEvent, callback, resultBlob));
+}
+
+void HTMLCanvasElement::toBlob(FileCallback* callback, const String& mimeType, const ScriptValue& qualityArgument, ExceptionState& exceptionState)
 {
     if (!originClean()) {
         exceptionState.throwSecurityError("Tainted canvases may not be exported.");
         return;
     }
 
-    File* resultBlob = nullptr;
     if (!isPaintable()) {
         // If the canvas element's bitmap has no pixels
+        Platform::current()->mainThread()->taskRunner()->postTask(FROM_HERE, bind(&FileCallback::handleEvent, callback, nullptr));
         return;
     }
 
-    double quality;
-    double* qualityPtr = nullptr;
+    double quality = InvalidQualityValue;
     if (!qualityArgument.isEmpty()) {
         v8::Local<v8::Value> v8Value = qualityArgument.v8Value();
         if (v8Value->IsNumber()) {
             quality = v8Value.As<v8::Number>()->Value();
-            qualityPtr = &quality;
         }
     }
 
     String encodingMimeType = toEncodingMimeType(mimeType);
 
     ImageData* imageData = toImageData(BackBuffer);
+    // ImageData object will be disposed on leaving stack scope; only imageData->data and imageData->size are passed to m_thread
     ScopedDisposal<ImageData> disposer(imageData);
 
-    // Perform image encoding
-    Vector<char> encodedImage;
-    ImageDataBuffer(imageData->size(), imageData->data()->data()).encodeImage(encodingMimeType, qualityPtr, &encodedImage);
-    resultBlob = File::create(encodedImage.data(), encodedImage.size(), encodingMimeType);
+    // Add a ref to keep image data alive until completion of encoding
+    RefPtr<DOMUint8ClampedArray> imageDataRef(imageData->data());
 
-    Platform::current()->mainThread()->taskRunner()->postTask(FROM_HERE, bind(&FileCallback::handleEvent, callback, resultBlob));
+    if (!m_thread) {
+        m_thread = adoptPtr(Platform::current()->createThread("Async toBlob"));

[Justin Novosad, 2015/09/21 16:51:55]

These threads are created on a per canvas basis, which is not a great. Ideally
we should have a managed pool of async task threads (topic to be brought up at
scheduler summit), but for now, we could just implement this in a way that
shares a single "Async toBlob" thread between all the canvases, to prevent a
thread explosion.  I could easily imagine a case where toBlob is called on a
temporary canvas element, repatedly which would tie thread clean-up to the
v8heap garbage collection, which could easily get out of hand.

+    }
+    m_thread->taskRunner()->postTask(FROM_HERE, new Task(threadSafeBind(&HTMLCanvasElement::encodeImageAsync, AllowCrossThreadAccess(this), AllowCrossThreadAccess(imageDataRef.release().leakRef()), imageData->size(), AllowCrossThreadAccess(callback), encodingMimeType, quality)));
 }
 
 SecurityOrigin* HTMLCanvasElement::securityOrigin() const
 {
     return document().securityOrigin();
 }
 
 bool HTMLCanvasElement::originClean() const
 {
     if (document().settings() && document().settings()->disableReadingFromCanvas())
@@ skipping 355 matching lines @@
 {
     return FloatSize(width(), height());
 }
 
 bool HTMLCanvasElement::isOpaque() const
 {
     return m_context && !m_context->hasAlpha();
 }
 
 } // blink