Implement convertToBlob() in OffscreenCanvas

third_party/WebKit/Source/modules/offscreencanvas/OffscreenCanvasModules.cpp

 // Copyright 2016 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 "modules/offscreencanvas/OffscreenCanvasModules.h"
 
+#include "core/fileapi/Blob.h"
+#include "core/html/ImageData.h"
+#include "core/html/canvas/CanvasAsyncBlobCreator.h"
 #include "core/html/canvas/CanvasContextCreationAttributes.h"
 #include "core/offscreencanvas/OffscreenCanvas.h"
 #include "modules/offscreencanvas2d/OffscreenCanvasRenderingContext2D.h"
+#include "modules/webgl/WebGLRenderingContextBase.h"
+#include "platform/graphics/StaticBitmapImage.h"
+#include "platform/image-encoders/ImageEncoderUtils.h"
 
 namespace blink {
 
 void OffscreenCanvasModules::getContext(
     ScriptState* scriptState,
     OffscreenCanvas& offscreenCanvas,
     const String& id,
     const CanvasContextCreationAttributes& attributes,
     ExceptionState& exceptionState,
     OffscreenRenderingContext& result) {
   if (offscreenCanvas.isNeutered()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      "OffscreenCanvas object is detached");
     return;
   }
 
   CanvasRenderingContext* context =
       offscreenCanvas.getCanvasRenderingContext(scriptState, id, attributes);
   if (context)
     context->setOffscreenCanvasGetContextResult(result);
 }
 
+ImageData* OffscreenCanvasModules::toImageData(OffscreenCanvas& offscreenCanvas,

[xlai (Olivia), 2016/10/19 18:51:06]

This function requires a higher-level view of OffscreenCanvasRenderingContext2D,
WebglRenderingContextBase and so it is placed in modules/

+                                               SourceDrawingBuffer sourceBuffer,
+                                               SnapshotReason reason) {
+  ImageData* imageData = nullptr;
+  if (!offscreenCanvas.renderingContext())
+    return imageData;
+  if (offscreenCanvas.renderingContext()->is3d()) {
+    // TODO: Furnish toImageData in webgl renderingcontext for jpeg and webp
+    // images. See crbug.com/657531.

[xlai (Olivia), 2016/10/19 18:51:06]

I might be missing something here in converting webgl rendering context to
imagedata, such that only toBlob(png) works and not for jpeg and webp. Will do
it in next patch.

+    WebGLRenderingContextBase* webglContext =
+        toWebGLRenderingContextBase(offscreenCanvas.renderingContext());
+    imageData = ImageData::create(offscreenCanvas.size());
+    if (webglContext->drawingBuffer()) {
+      sk_sp<SkImage> snapshot = webglContext->drawingBuffer()
+                                    ->transferToStaticBitmapImage()
+                                    ->imageForCurrentFrame();
+      if (snapshot) {
+        SkImageInfo imageInfo =
+            SkImageInfo::Make(offscreenCanvas.width(), offscreenCanvas.height(),
+                              kRGBA_8888_SkColorType, kUnpremul_SkAlphaType);
+        snapshot->readPixels(imageInfo, imageData->data()->data(),
+                             imageInfo.minRowBytes(), 0, 0);
+      }
+    }
+    return imageData;
+  }
+
+  if (offscreenCanvas.renderingContext()->is2d()) {
+    OffscreenCanvasRenderingContext2D* context2d =
+        toOffscreenCanvasRenderingContext2D(offscreenCanvas.renderingContext());
+    imageData = ImageData::create(offscreenCanvas.size());
+    if (context2d->imageBuffer()) {
+      sk_sp<SkImage> snapshot = context2d->imageBuffer()->newSkImageSnapshot(
+          PreferNoAcceleration, reason);
+      if (snapshot) {
+        SkImageInfo imageInfo =
+            SkImageInfo::Make(offscreenCanvas.width(), offscreenCanvas.height(),
+                              kRGBA_8888_SkColorType, kUnpremul_SkAlphaType);
+        snapshot->readPixels(imageInfo, imageData->data()->data(),
+                             imageInfo.minRowBytes(), 0, 0);
+      }
+    }
+    return imageData;
+  }
+
+  return nullptr;
+}
+
+ScriptPromise OffscreenCanvasModules::convertToBlob(
+    ScriptState* scriptState,
+    OffscreenCanvas& offscreenCanvas,
+    const ImageEncodeOptions& options,
+    ExceptionState& exceptionState) {
+  if (offscreenCanvas.isNeutered()) {
+    exceptionState.throwDOMException(InvalidStateError,
+                                     "OffscreenCanvas object is detached.");
+    return exceptionState.reject(scriptState);
+  }
+
+  if (!offscreenCanvas.originClean()) {
+    exceptionState.throwSecurityError(
+        "Tainted OffscreenCanvas may not be exported.");
+    return exceptionState.reject(scriptState);
+  }
+
+  if (!offscreenCanvas.isPaintable()) {
+    return ScriptPromise();
+  }
+
+  double startTime = WTF::monotonicallyIncreasingTime();
+  String encodingMimeType = ImageEncoderUtils::toEncodingMimeType(
+      options.type(), ImageEncoderUtils::EncodeReasonConvertToBlobPromise);
+
+  ImageData* imageData =
+      toImageData(offscreenCanvas, BackBuffer, SnapshotReasonUnknown);
+  ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+
+  Document* document =
+      scriptState->getExecutionContext()->isDocument()
+          ? static_cast<Document*>(scriptState->getExecutionContext())
+          : nullptr;
+
+  CanvasAsyncBlobCreator* asyncCreator = CanvasAsyncBlobCreator::create(
+      imageData->data(), encodingMimeType, imageData->size(), nullptr,
+      startTime, document, resolver);
+
+  asyncCreator->scheduleAsyncBlobCreation(options.quality());
+
+  return resolver->promise();
+}
+
 }  // namespace blink