Add warmup and sandbox file-read permission for testing

third_party/WebKit/Source/modules/shapedetection/FaceDetector.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/FaceDetector.h"
 
 #include "core/dom/DOMException.h"
 #include "core/dom/DOMRect.h"
 #include "core/dom/Document.h"
 #include "core/fetch/ImageResource.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/canvas/CanvasImageSource.h"
+#include "modules/shapedetection/FaceDetectorImpl.h"
+#include "platform/SharedBuffer.h"
 #include "platform/graphics/Image.h"
 #include "public/platform/InterfaceProvider.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 33 matching lines @@
   ScriptPromise promise = resolver->promise();
 
   if (!imageSourceInternal) {
     // TODO(mcasas): Implement more CanvasImageSources, https://crbug.com/659138
     NOTIMPLEMENTED() << "Unsupported CanvasImageSource";
     resolver->reject(
         DOMException::create(NotFoundError, "Unsupported source."));
     return promise;
   }
 
-  if (imageSourceInternal->wouldTaintOrigin(
-          scriptState->getExecutionContext()->getSecurityOrigin())) {
-    resolver->reject(
-        DOMException::create(SecurityError, "Source would taint origin."));
-    return promise;
-  }
+  // if (imageSourceInternal->wouldTaintOrigin(
+  //         scriptState->getExecutionContext()->getSecurityOrigin())) {
+  //   resolver->reject(
+  //       DOMException::create(SecurityError, "Source would taint origin."));
+  //   return promise;
+  // }
 
   if (imageSource.isHTMLImageElement()) {
     return detectFacesOnImageElement(
         resolver, static_cast<HTMLImageElement*>(imageSourceInternal));
   }
   if (imageSourceInternal->isImageBitmap()) {
     return detectFacesOnImageBitmap(
         resolver, static_cast<ImageBitmap*>(imageSourceInternal));
   }
   if (imageSourceInternal->isVideoElement()) {
@@ skipping 22 matching lines @@
   }
 
   Image* const blinkImage = imageResource->getImage();
   if (!blinkImage) {
     resolver->reject(DOMException::create(
         InvalidStateError, "Failed to get image from resource."));
     return promise;
   }
 
   const sk_sp<SkImage> image = blinkImage->imageForCurrentFrame();
-  DCHECK_EQ(img->naturalWidth(), image->width());
-  DCHECK_EQ(img->naturalHeight(), 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());
 
   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;
   }
+  DLOG(ERROR) << "pixmap.getSafeSize():" << pixmap.getSafeSize();
 
-  if (!m_service) {
-    resolver->reject(DOMException::create(
-        NotSupportedError, "Face detection service unavailable."));
-    return promise;
-  }
-
-  m_serviceRequests.add(resolver);
-  DCHECK(m_service.is_bound());
-  m_service->DetectFace(std::move(sharedBufferHandle), img->naturalWidth(),
-                        img->naturalHeight(),
-                        convertToBaseCallback(WTF::bind(
-                            &FaceDetector::onDetectFace, wrapPersistent(this),
-                            wrapPersistent(resolver))));
+  FaceDetectorImpl* detector = FaceDetectorImpl::Create();
+  HeapVector<Member<DOMRect>> detectedFaces = detector->detectFace(
+      pixmap.writable_addr(), img->naturalWidth(), img->naturalHeight());
+  resolver->resolve(detectedFaces);
   return promise;
 }
 
 ScriptPromise FaceDetector::detectFacesOnImageBitmap(
     ScriptPromiseResolver* resolver,
     ImageBitmap* imageBitmap) {
   ScriptPromise promise = resolver->promise();
   if (!imageBitmap->originClean()) {
     resolver->reject(
         DOMException::create(SecurityError, "ImageBitmap is not origin clean"));
@@ skipping 130 matching lines @@
 
   resolver->resolve(detectedFaces);
   m_serviceRequests.remove(resolver);
 }
 
 DEFINE_TRACE(FaceDetector) {
   visitor->trace(m_serviceRequests);
 }
 
 }  // namespace blink