Blob creation methods for ImageBitmap.

Source/core/page/ImageBitmapFactories.cpp

 /*
  * Copyright (c) 2013, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/page/ImageBitmapFactories.h"
 
 #include "RuntimeEnabledFeatures.h"
 #include "V8ImageBitmap.h"
 #include "bindings/v8/ExceptionState.h"
-#include "core/dom/ExceptionCode.h"
+#include "bindings/v8/ScriptScope.h"
+#include "bindings/v8/ScriptState.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "core/html/canvas/CanvasRenderingContext2D.h"
 #include "core/page/DOMWindow.h"
 #include "core/page/ImageBitmap.h"
+#include "core/platform/SharedBuffer.h"
+#include "core/platform/graphics/BitmapImage.h"
+#include "core/platform/graphics/ImageSource.h"
+#include "core/platform/graphics/skia/NativeImageSkia.h"
 
 namespace WebCore {
 
-namespace ImageBitmapFactories {
-
 static LayoutSize sizeFor(HTMLImageElement* image)
 {
     if (CachedImage* cachedImage = image->cachedImage())
         return cachedImage->imageSizeForRenderer(image->renderer(), 1.0f); // FIXME: Not sure about this.
     return IntSize();
 }
 
 static IntSize sizeFor(HTMLVideoElement* video)
 {
     if (MediaPlayer* player = video->player())
         return player->naturalSize();
     return IntSize();
 }
 
-static ScriptObject resolveImageBitmap(PassRefPtr<ImageBitmap> imageBitmap)
+static ScriptObject fulfillImageBitmap(ScriptExecutionContext* context, PassRefPtr<ImageBitmap> imageBitmap)
 {
     // Promises must be enabled.
     ASSERT(RuntimeEnabledFeatures::promiseEnabled());
-
-    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create();
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(context);
     resolver->fulfill(imageBitmap);
     return resolver->promise();
 }
 
-ScriptObject createImageBitmap(EventTarget* eventTarget, HTMLImageElement* image, ExceptionState& es)
+ScriptObject ImageBitmapFactories::createImageBitmap(EventTarget* eventTarget, HTMLImageElement* image, ExceptionState& es)
 {
     LayoutSize s = sizeFor(image);
     return createImageBitmap(eventTarget, image, 0, 0, s.width(), s.height(), es);
 }
 
-ScriptObject createImageBitmap(EventTarget* eventTarget, HTMLImageElement* image, int sx, int sy, int sw, int sh, ExceptionState& es)
+ScriptObject ImageBitmapFactories::createImageBitmap(EventTarget* eventTarget, HTMLImageElement* image, int sx, int sy, int sw, int sh, ExceptionState& es)
 {
     if (!image) {
         es.throwTypeError();
         return ScriptObject();
     }
     if (!image->cachedImage()) {
         es.throwDOMException(InvalidStateError);
         return ScriptObject();
     }
     if (image->cachedImage()->image()->isSVGImage()) {
         es.throwDOMException(InvalidStateError);
         return ScriptObject();
     }
     if (!sw || !sh) {
         es.throwDOMException(IndexSizeError);
         return ScriptObject();
     }
     if (!image->cachedImage()->image()->hasSingleSecurityOrigin()) {
         es.throwDOMException(SecurityError);
         return ScriptObject();
     }
     if (!image->cachedImage()->passesAccessControlCheck(eventTarget->toDOMWindow()->document()->securityOrigin())
     && eventTarget->toDOMWindow()->document()->securityOrigin()->taintsCanvas(image->src())) {
         es.throwDOMException(SecurityError);
         return ScriptObject();
     }
     // FIXME: make ImageBitmap creation asynchronous crbug.com/258082
-    return resolveImageBitmap(ImageBitmap::create(image, IntRect(sx, sy, sw, sh)));
+    return fulfillImageBitmap(eventTarget->scriptExecutionContext(), ImageBitmap::create(image, IntRect(sx, sy, sw, sh)));
 }
 
-ScriptObject createImageBitmap(EventTarget* eventTarget, HTMLVideoElement* video, ExceptionState& es)
+ScriptObject ImageBitmapFactories::createImageBitmap(EventTarget* eventTarget, HTMLVideoElement* video, ExceptionState& es)
 {
     IntSize s = sizeFor(video);
     return createImageBitmap(eventTarget, video, 0, 0, s.width(), s.height(), es);
 }
 
-ScriptObject createImageBitmap(EventTarget* eventTarget, HTMLVideoElement* video, int sx, int sy, int sw, int sh, ExceptionState& es)
+ScriptObject ImageBitmapFactories::createImageBitmap(EventTarget* eventTarget, HTMLVideoElement* video, int sx, int sy, int sw, int sh, ExceptionState& es)
 {
     if (!video) {
         es.throwTypeError();
         return ScriptObject();
     }
     if (!video->player()) {
         es.throwDOMException(InvalidStateError);
         return ScriptObject();
     }
     if (video->networkState() == HTMLMediaElement::NETWORK_EMPTY) {
@@ skipping 10 matching lines @@
     }
     if (!video->hasSingleSecurityOrigin()) {
         es.throwDOMException(SecurityError);
         return ScriptObject();
     }
     if (!video->player()->didPassCORSAccessCheck() && eventTarget->toDOMWindow()->document()->securityOrigin()->taintsCanvas(video->currentSrc())) {
         es.throwDOMException(SecurityError);
         return ScriptObject();
     }
     // FIXME: make ImageBitmap creation asynchronous crbug.com/258082
-    return resolveImageBitmap(ImageBitmap::create(video, IntRect(sx, sy, sw, sh)));
+    return fulfillImageBitmap(eventTarget->scriptExecutionContext(), ImageBitmap::create(video, IntRect(sx, sy, sw, sh)));
 }
 
-ScriptObject createImageBitmap(EventTarget* eventTarget, CanvasRenderingContext2D* context, ExceptionState& es)
+ScriptObject ImageBitmapFactories::createImageBitmap(EventTarget* eventTarget, CanvasRenderingContext2D* context, ExceptionState& es)
 {
     return createImageBitmap(eventTarget, context->canvas(), es);
 }
 
-ScriptObject createImageBitmap(EventTarget* eventTarget, CanvasRenderingContext2D* context, int sx, int sy, int sw, int sh, ExceptionState& es)
+ScriptObject ImageBitmapFactories::createImageBitmap(EventTarget* eventTarget, CanvasRenderingContext2D* context, int sx, int sy, int sw, int sh, ExceptionState& es)
 {
     return createImageBitmap(eventTarget, context->canvas(), sx, sy, sw, sh, es);
 }
 
-ScriptObject createImageBitmap(EventTarget* eventTarget, HTMLCanvasElement* canvas, ExceptionState& es)
+ScriptObject ImageBitmapFactories::createImageBitmap(EventTarget* eventTarget, HTMLCanvasElement* canvas, ExceptionState& es)
 {
     return createImageBitmap(eventTarget, canvas, 0, 0, canvas->width(), canvas->height(), es);
 }
 
-ScriptObject createImageBitmap(EventTarget* eventTarget, HTMLCanvasElement* canvas, int sx, int sy, int sw, int sh, ExceptionState& es)
+ScriptObject ImageBitmapFactories::createImageBitmap(EventTarget* eventTarget, HTMLCanvasElement* canvas, int sx, int sy, int sw, int sh, ExceptionState& es)
 {
     if (!canvas) {
         es.throwTypeError();
         return ScriptObject();
     }
     if (!canvas->originClean()) {
         es.throwDOMException(InvalidStateError);
         return ScriptObject();
     }
     if (!sw || !sh) {
         es.throwDOMException(IndexSizeError);
         return ScriptObject();
     }
     // FIXME: make ImageBitmap creation asynchronous crbug.com/258082
-    return resolveImageBitmap(ImageBitmap::create(canvas, IntRect(sx, sy, sw, sh)));
+    return fulfillImageBitmap(eventTarget->scriptExecutionContext(), ImageBitmap::create(canvas, IntRect(sx, sy, sw, sh)));
 }
 
-ScriptObject createImageBitmap(EventTarget* eventTarget, ImageData* data, ExceptionState& es)
+ScriptObject ImageBitmapFactories::createImageBitmap(EventTarget* eventTarget, Blob* blob, ExceptionState& es)
+{
+    // Promises must be enabled.
+    ASSERT(RuntimeEnabledFeatures::promiseEnabled());
+
+    if (!blob) {
+        es.throwDOMException(TypeError);
+        return ScriptObject();
+    }
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(eventTarget->scriptExecutionContext());
+    RefPtr<ImageBitmapLoader> loader = ImageBitmapFactories::ImageBitmapLoader::create(eventTarget->toDOMWindow(), resolver, 0);
+    eventTarget->toDOMWindow()->didStartLoading(loader);
+    loader->loadBlobAsync(eventTarget->scriptExecutionContext(), blob);
+    return resolver->promise();
+}
+
+ScriptObject ImageBitmapFactories::createImageBitmap(EventTarget* eventTarget, Blob* blob, int sx, int sy, int sw, int sh, ExceptionState& es)
+{
+    // Promises must be enabled.
+    ASSERT(RuntimeEnabledFeatures::promiseEnabled());
+
+    if (!blob) {
+        es.throwDOMException(TypeError);
+        return ScriptObject();
+    }
+    if (!sw || !sh) {
+        es.throwDOMException(IndexSizeError);
+        return ScriptObject();
+    }
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(eventTarget->scriptExecutionContext());
+    IntRect* cropRect = new IntRect(sx, sy, sw, sh);
+    RefPtr<ImageBitmapLoader> loader = ImageBitmapFactories::ImageBitmapLoader::create(eventTarget->toDOMWindow(), resolver, cropRect);
+    loader->loadBlobAsync(eventTarget->scriptExecutionContext(), blob);
+    return resolver->promise();
+}
+
+ScriptObject ImageBitmapFactories::createImageBitmap(EventTarget* eventTarget, ImageData* data, ExceptionState& es)
 {
     return createImageBitmap(eventTarget, data, 0, 0, data->width(), data->height(), es);
 }
 
-ScriptObject createImageBitmap(EventTarget* eventTarget, ImageData* data, int sx, int sy, int sw, int sh, ExceptionState& es)
+ScriptObject ImageBitmapFactories::createImageBitmap(EventTarget* eventTarget, ImageData* data, int sx, int sy, int sw, int sh, ExceptionState& es)
 {
     if (!data) {
         es.throwTypeError();
         return ScriptObject();
     }
     if (!sw || !sh) {
         es.throwDOMException(IndexSizeError);
         return ScriptObject();
     }
     // FIXME: make ImageBitmap creation asynchronous crbug.com/258082
-    return resolveImageBitmap(ImageBitmap::create(data, IntRect(sx, sy, sw, sh)));
+    return fulfillImageBitmap(eventTarget->scriptExecutionContext(), ImageBitmap::create(data, IntRect(sx, sy, sw, sh)));
 }
 
-ScriptObject createImageBitmap(EventTarget* eventTarget, ImageBitmap* bitmap, ExceptionState& es)
+ScriptObject ImageBitmapFactories::createImageBitmap(EventTarget* eventTarget, ImageBitmap* bitmap, ExceptionState& es)
 {
     return createImageBitmap(eventTarget, bitmap, 0, 0, bitmap->width(), bitmap->height(), es);
 }
 
-ScriptObject createImageBitmap(EventTarget* eventTarget, ImageBitmap* bitmap, int sx, int sy, int sw, int sh, ExceptionState& es)
+ScriptObject ImageBitmapFactories::createImageBitmap(EventTarget* eventTarget, ImageBitmap* bitmap, int sx, int sy, int sw, int sh, ExceptionState& es)
 {
     if (!bitmap) {
         es.throwTypeError();
         return ScriptObject();
     }
     if (!sw || !sh) {
         es.throwDOMException(IndexSizeError);
         return ScriptObject();
     }
     // FIXME: make ImageBitmap creation asynchronous crbug.com/258082
-    return resolveImageBitmap(ImageBitmap::create(bitmap, IntRect(sx, sy, sw, sh)));
+    return fulfillImageBitmap(eventTarget->scriptExecutionContext(), ImageBitmap::create(bitmap, IntRect(sx, sy, sw, sh)));
 }
 
-} // namespace ImageBitmapFactories
+void ImageBitmapFactories::didStartLoading(PassRefPtr<ImageBitmapLoader> loader)
+{
+    m_pendingLoaders.add(loader);
+}
+
+void ImageBitmapFactories::didFinishLoading(PassRefPtr<ImageBitmapLoader> loader)
+{
+    ASSERT(m_pendingLoaders.contains(loader));
+    m_pendingLoaders.remove(loader);
+}
+
+ImageBitmapFactories::ImageBitmapLoader::ImageBitmapLoader(ImageBitmapFactories* factory, PassRefPtr<ScriptPromiseResolver> resolver, IntRect* cropRect)
+    : m_loader(FileReaderLoader::ReadAsArrayBuffer, this)
+    , m_scriptState(ScriptState::current())
+    , m_factory(factory)
+    , m_resolver(resolver)
+    , m_cropRect(cropRect)
+{
+}
+
+void ImageBitmapFactories::ImageBitmapLoader::loadBlobAsync(ScriptExecutionContext* context, Blob* blob)
+{
+    m_factory->didStartLoading(this);
+    m_loader.start(context, *blob);
+}
+
+void ImageBitmapFactories::ImageBitmapLoader::rejectPromise()
+{
+    ScriptScope scope(m_scriptState);
+    RefPtr<ImageBitmap> nullImageBitmap;

[do-not-use, 2013/08/12 15:15:59]

It looks like we don't really need this variable. Can't we simply pass 0 (or
nullptr) to the reject() call below?

+    m_resolver->reject(nullImageBitmap.release());
+    m_factory->didFinishLoading(this);
+}
+
+void ImageBitmapFactories::ImageBitmapLoader::didFinishLoading()
+{
+    if (!m_loader.arrayBufferResult()) {
+        rejectPromise();
+        return;
+    }
+    RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create((char*)m_loader.arrayBufferResult()->data(), m_loader.arrayBufferResult()->byteLength());
+
+    OwnPtr<ImageSource> source = adoptPtr(new ImageSource());
+    source->setData(sharedBuffer.get(), true);
+    RefPtr<NativeImageSkia> imageSkia = source->createFrameAtIndex(0);
+    if (!imageSkia) {
+        rejectPromise();
+        return;
+    }
+    RefPtr<Image> image = BitmapImage::create(imageSkia);
+
+    if (!m_cropRect)
+        m_cropRect = new IntRect(image->rect());
+    if (!m_cropRect->width() || !m_cropRect->height()) {
+        rejectPromise();
+        return;
+    }
+
+    RefPtr<ImageBitmap> imageBitmap = ImageBitmap::create(image.get(), *m_cropRect);
+    ScriptScope scope(m_scriptState);
+    m_resolver->fulfill(imageBitmap.release());
+    m_factory->didFinishLoading(this);
+}
+
+void ImageBitmapFactories::ImageBitmapLoader::didFail(FileError::ErrorCode)
+{
+    rejectPromise();
+}
+
 } // namespace WebCore