Revert of RELAND: ShapeDetection: use mojom::Bitmap for mojo interface.

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/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 {
 
-skia::mojom::blink::BitmapPtr createBitmapFromData(int width,
-                                                   int height,
-                                                   Vector<uint8_t> bitmapData) {
-  skia::mojom::blink::BitmapPtr bitmap = skia::mojom::blink::Bitmap::New();
+mojo::ScopedSharedBufferHandle getSharedBufferOnData(
+    ScriptPromiseResolver* resolver,
+    uint8_t* data,
+    int size) {
+  DCHECK(data);
+  DCHECK(size);
+  ScriptPromise promise = resolver->promise();
 
-  bitmap->color_type = (kN32_SkColorType == kRGBA_8888_SkColorType)
-                           ? skia::mojom::ColorType::RGBA_8888
-                           : skia::mojom::ColorType::BGRA_8888;
-  bitmap->width = width;
-  bitmap->height = height;
-  bitmap->pixel_data = std::move(bitmapData);
+  mojo::ScopedSharedBufferHandle sharedBufferHandle =
+      mojo::SharedBufferHandle::Create(size);
+  if (!sharedBufferHandle->is_valid()) {
+    resolver->reject(
+        DOMException::create(InvalidStateError, "Internal allocation error"));
+    return sharedBufferHandle;
+  }
 
-  return bitmap;
+  const mojo::ScopedSharedBufferMapping mappedBuffer =
+      sharedBufferHandle->Map(size);
+  DCHECK(mappedBuffer.get());
+  memcpy(mappedBuffer.get(), data, size);
+
+  return sharedBufferHandle;
 }
 
 }  // anonymous namespace
 
 ScriptPromise ShapeDetector::detect(ScriptState* scriptState,
                                     const ImageBitmapSourceUnion& imageSource) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
   // ImageDatas cannot be tainted by definition.
@@ skipping 72 matching lines @@
     pixelDataPtr = pixelData->data();
     allocationSize = imageBitmap->size().area() * 4 /* bytes per pixel */;
   } else {
     // TODO(mcasas): retrieve the pixels from elsewhere.
     NOTREACHED();
     resolver->reject(DOMException::create(
         InvalidStateError, "Failed to get pixels for current frame."));
     return promise;
   }
 
-  WTF::Vector<uint8_t> bitmapData;
-  bitmapData.append(pixelDataPtr,
-                    static_cast<int>(allocationSize.ValueOrDefault(0)));
+  mojo::ScopedSharedBufferHandle sharedBufferHandle = getSharedBufferOnData(
+      resolver, pixelDataPtr, allocationSize.ValueOrDefault(0));
+  if (!sharedBufferHandle->is_valid())
+    return promise;
 
-  return doDetect(resolver,
-                  createBitmapFromData(image->width(), image->height(),
-                                       std::move(bitmapData)));
+  return doDetect(resolver, std::move(sharedBufferHandle), image->width(),
+                  image->height());
 }
 
 ScriptPromise ShapeDetector::detectShapesOnImageData(
     ScriptPromiseResolver* resolver,
     ImageData* imageData) {
   ScriptPromise promise = resolver->promise();
 
   if (imageData->size().isZero()) {
     resolver->resolve(HeapVector<Member<DOMRect>>());
     return promise;
   }
 
   uint8_t* const data = imageData->data()->data();
   WTF::CheckedNumeric<int> allocationSize = imageData->size().area() * 4;
-  WTF::Vector<uint8_t> bitmapData;
-  bitmapData.append(data, static_cast<int>(allocationSize.ValueOrDefault(0)));
 
-  return doDetect(resolver,
-                  createBitmapFromData(imageData->width(), imageData->height(),
-                                       std::move(bitmapData)));
+  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()) {
     resolver->resolve(HeapVector<Member<DOMRect>>());
     return promise;
@@ skipping 20 matching lines @@
   DCHECK_EQ(img->naturalHeight(), static_cast<unsigned>(image->height()));
 
   if (!image) {
     resolver->reject(DOMException::create(
         InvalidStateError, "Failed to get image from current frame."));
     return promise;
   }
 
   const SkImageInfo skiaInfo =
       SkImageInfo::MakeN32(image->width(), image->height(), image->alphaType());
-  size_t rowBytes = skiaInfo.minRowBytes();
 
-  Vector<uint8_t> bitmapData(skiaInfo.getSafeSize(rowBytes));
-  const SkPixmap pixmap(skiaInfo, bitmapData.data(), rowBytes);
+  const uint32_t allocationSize = skiaInfo.getSafeSize(skiaInfo.minRowBytes());
+
+  mojo::ScopedSharedBufferHandle sharedBufferHandle =
+      mojo::SharedBufferHandle::Create(allocationSize);
+  if (!sharedBufferHandle.is_valid()) {
+    DLOG(ERROR) << "Requested allocation : " << allocationSize
+                << "B, larger than |mojo::edk::kMaxSharedBufferSize| == 16MB ";
+    // TODO(xianglu): For now we reject the promise if the image is too large.
+    // But consider resizing the image to remove restriction on the user side.
+    // Also, add LayoutTests for this case later.
+    resolver->reject(
+        DOMException::create(InvalidStateError, "Image exceeds size limit."));
+    return promise;
+  }
+
+  const mojo::ScopedSharedBufferMapping mappedBuffer =
+      sharedBufferHandle->Map(allocationSize);
+
+  const SkPixmap pixmap(skiaInfo, mappedBuffer.get(), skiaInfo.minRowBytes());
   if (!image->readPixels(pixmap, 0, 0)) {
     resolver->reject(DOMException::create(
         InvalidStateError,
         "Failed to read pixels: Unable to decompress or unsupported format."));
     return promise;
   }
 
-  return doDetect(
-      resolver, createBitmapFromData(img->naturalWidth(), img->naturalHeight(),
-                                     std::move(bitmapData)));
+  return doDetect(resolver, std::move(sharedBufferHandle), img->naturalWidth(),
+                  img->naturalHeight());
 }
 
 }  // namespace blink