[HTMLCanvasElement.toBlob] Default callback version without scheduler

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 16 matching lines @@
 
 #include "config.h"
 #include "core/html/HTMLCanvasElement.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "core/HTMLNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
+#include "core/fileapi/File.h"
 #include "core/frame/LocalFrame.h"
 #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/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 <math.h>
 #include <v8.h>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 namespace {
 
 // These values come from the WhatWG spec.
@@ skipping 434 matching lines @@
         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);
 }
 
+static void invokeFileCallbackWithBlob(FileCallback* callback, File* blob)
+{
+    callback->handleEvent(blob);
+}
+
 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;
     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);
 }
 
+void HTMLCanvasElement::toBlob(FileCallback* callback, const String& mimeType, const ScriptValue& qualityArgument, ExceptionState& exceptionState) const
+{
+    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
+        return;
+    }
+
+    double quality;
+    if (!qualityArgument.isEmpty()) {
+        v8::Local<v8::Value> v8Value = qualityArgument.v8Value();
+        if (v8Value->IsNumber()) {
+            quality = v8Value.As<v8::Number>()->Value();
+        }
+    }
+
+    String encodingMimeType = toEncodingMimeType(mimeType);
+
+    ImageData* imageData = toImageData(BackBuffer);
+    ScopedDisposal<ImageData> disposer(imageData);
+
+    // Perform image encoding
+    Vector<char> encodedImage;
+    ImageDataBuffer(imageData->size(), imageData->data()->data()).encodeImage(encodingMimeType, &quality, &encodedImage);
+    resultBlob = File::create(encodedImage.data(), encodedImage.size(), encodingMimeType);
+
+    Platform::current()->mainThread()->postTask(FROM_HERE, threadSafeBind(&invokeFileCallbackWithBlob, callback, resultBlob));

[kinuko, 2015/08/26 06:28:30]

nit: if you're posting on from the main thread just using bind() should be fine,
and I think you can also directly bind the callback like:
bink(&FileCallback::handleEvent, callback, resultBlob)

[xlai (Olivia), 2015/08/27 18:41:50]

Done.

+
+}
+
 SecurityOrigin* HTMLCanvasElement::securityOrigin() const
 {
     return document().securityOrigin();
 }
 
 bool HTMLCanvasElement::originClean() const
 {
     if (document().settings() && document().settings()->disableReadingFromCanvas())
         return false;
     return m_originClean;
@@ skipping 347 matching lines @@
 {
     return FloatSize(width(), height());
 }
 
 bool HTMLCanvasElement::isOpaque() const
 {
     return m_context && !m_context->hasAlpha();
 }
 
 } // blink