ShapeDetection: use ImageBitmapSource as input and support ImageData

third_party/WebKit/Source/modules/shapedetection/ShapeDetector.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/shapedetection/ShapeDetector.h"
 
 #include "core/dom/DOMException.h"
 #include "core/dom/DOMRect.h"
 #include "core/dom/Document.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLVideoElement.h"
-#include "core/html/canvas/CanvasImageSource.h"
+#include "core/html/ImageData.h"
 #include "core/loader/resource/ImageResourceContent.h"
 #include "platform/graphics/Image.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkImageInfo.h"
 #include "wtf/CheckedNumeric.h"
 
 namespace blink {
 
 namespace {
 
@@ skipping 21 matching lines @@
   return sharedBufferHandle;
 }
 
 }  // anonymous namespace
 
 ShapeDetector::ShapeDetector(LocalFrame& frame) {
   DCHECK(frame.interfaceProvider());
 }
 
 ScriptPromise ShapeDetector::detect(ScriptState* scriptState,
-                                    const CanvasImageSourceUnion& imageSource) {
+                                    const ImageBitmapSourceUnion& imageSource) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
+  if (imageSource.isImageData())
+    return detectShapesOnImageData(resolver, imageSource.getAsImageData());
+
   CanvasImageSource* canvasImageSource;
   if (imageSource.isHTMLImageElement()) {
     canvasImageSource = imageSource.getAsHTMLImageElement();
   } else if (imageSource.isImageBitmap()) {
     canvasImageSource = imageSource.getAsImageBitmap();
   } else if (imageSource.isHTMLVideoElement()) {
     canvasImageSource = imageSource.getAsHTMLVideoElement();
   } else if (imageSource.isHTMLCanvasElement()) {
     canvasImageSource = imageSource.getAsHTMLCanvasElement();
   } else if (imageSource.isOffscreenCanvas()) {
@@ skipping 64 matching lines @@
 
   mojo::ScopedSharedBufferHandle sharedBufferHandle = getSharedBufferOnData(
       resolver, pixelDataPtr, allocationSize.ValueOrDefault(0));
   if (!sharedBufferHandle->is_valid())
     return promise;
 
   return doDetect(resolver, std::move(sharedBufferHandle), image->width(),
                   image->height());
 }
 
+ScriptPromise ShapeDetector::detectShapesOnImageData(
+    ScriptPromiseResolver* resolver,
+    ImageData* imageData) {
+  ScriptPromise promise = resolver->promise();

[xianglu, 2016/12/14 22:32:28]

Should we check origin for ImageData as well?

[mcasas, 2016/12/14 23:37:42]

[1] tells us that ImageDatas can not be created from a 
Context 2D that is tainted, so we can assume here that 
a given ImageData is clean. Will add a note.

[1] https://www.w3.org/TR/2dcontext/#pixel-manipulation

+
+  uint8_t* const data = imageData->data()->data();
+  WTF::CheckedNumeric<int> allocationSize = imageData->size().area() * 4;
+
+  mojo::ScopedSharedBufferHandle sharedBufferHandle =
+      getSharedBufferOnData(resolver, data, allocationSize.ValueOrDefault(0));
+  if (!sharedBufferHandle->is_valid())
+    return promise;
+
+  return doDetect(resolver, std::move(sharedBufferHandle), imageData->width(),
+                  imageData->height());
+}
+
 ScriptPromise ShapeDetector::detectShapesOnImageElement(
     ScriptPromiseResolver* resolver,
     const HTMLImageElement* img) {
   ScriptPromise promise = resolver->promise();
 
   if (img->bitmapSourceSize().isZero()) {

[xianglu, 2016/12/14 22:32:28]

The promise is resolved when HTMLImageElement is empty. But we didn't check size
for other elements and they will get a promise rejection. Maybe we could make
them behave more consistently?

[mcasas, 2016/12/14 23:37:42]

Added a TODO+bug.

     resolver->resolve(HeapVector<Member<DOMRect>>());
     return promise;
   }
 
   ImageResourceContent* const imageResource = img->cachedImage();
   if (!imageResource || imageResource->errorOccurred()) {
     resolver->reject(DOMException::create(
         InvalidStateError, "Failed to load or decode HTMLImageElement."));
     return promise;
   }
@@ skipping 44 matching lines @@
         InvalidStateError,
         "Failed to read pixels: Unable to decompress or unsupported format."));
     return promise;
   }
 
   return doDetect(resolver, std::move(sharedBufferHandle), img->naturalWidth(),
                   img->naturalHeight());
 }
 
 }  // namespace blink