ShapeDetection: split mojom into face and barcode interfaces

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/fetch/ImageResource.h"
@@ skipping 26 matching lines @@
 
   if (value.isHTMLVideoElement())
     return value.getAsHTMLVideoElement();
 
   return nullptr;
 }
 
 }  // anonymous namespace
 
 ShapeDetector::ShapeDetector(LocalFrame& frame) {
-  DCHECK(!m_service.is_bound());
+  DCHECK(!m_faceService.is_bound());
+  DCHECK(!m_barcodeService.is_bound());
   DCHECK(frame.interfaceProvider());
-  frame.interfaceProvider()->getInterface(mojo::GetProxy(&m_service));
+  frame.interfaceProvider()->getInterface(mojo::GetProxy(&m_faceService));
+  frame.interfaceProvider()->getInterface(mojo::GetProxy(&m_barcodeService));
 }
 
 ShapeDetector::ShapeDetector(LocalFrame& frame,
                              const FaceDetectorOptions& options)
     : ShapeDetector(frame) {
-  m_options = mojom::blink::FaceDetectorOptions::New();
-  m_options->max_detected_faces = options.maxDetectedFaces();
-  m_options->fast_mode = options.fastMode();
+  m_faceDetectorOptions = mojom::blink::FaceDetectorOptions::New();
+  m_faceDetectorOptions->max_detected_faces = options.maxDetectedFaces();
+  m_faceDetectorOptions->fast_mode = options.fastMode();
 }
 
 ScriptPromise ShapeDetector::detectShapes(
     ScriptState* scriptState,
     DetectorType detectorType,
     const CanvasImageSourceUnion& imageSource) {
   CanvasImageSource* imageSourceInternal = toImageSourceInternal(imageSource);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
@@ skipping 88 matching lines @@
       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;
   }
 
-  if (!m_service) {
-    resolver->reject(DOMException::create(
-        NotSupportedError, "Shape detection service unavailable."));
-    return promise;
-  }
-
   m_serviceRequests.add(resolver);
-  DCHECK(m_service.is_bound());
   if (detectorType == DetectorType::Face) {
-    m_service->DetectFaces(
-        std::move(sharedBufferHandle), img->naturalWidth(),
-        img->naturalHeight(), m_options.Clone(),
-        convertToBaseCallback(WTF::bind(&ShapeDetector::onDetectFaces,
-                                        wrapPersistent(this),
-                                        wrapPersistent(resolver))));
+    if (!m_faceService) {
+      resolver->reject(DOMException::create(
+          NotSupportedError, "Face detection service unavailable."));
+      return promise;
+    }
+    m_faceService->Detect(std::move(sharedBufferHandle), img->naturalWidth(),
+                          img->naturalHeight(), m_faceDetectorOptions.Clone(),
+                          convertToBaseCallback(WTF::bind(
+                              &ShapeDetector::onDetectFaces,
+                              wrapPersistent(this), wrapPersistent(resolver))));
   } else if (detectorType == DetectorType::Barcode) {
-    m_service->DetectBarcodes(
+    if (!m_barcodeService) {
+      resolver->reject(DOMException::create(
+          NotSupportedError, "Barcode detection service unavailable."));
+      return promise;
+    }
+    m_barcodeService->Detect(
         std::move(sharedBufferHandle), img->naturalWidth(),
         img->naturalHeight(),
         convertToBaseCallback(WTF::bind(&ShapeDetector::onDetectBarcodes,
                                         wrapPersistent(this),
                                         wrapPersistent(resolver))));
   } else {
     NOTREACHED() << "Unsupported detector type";
   }
 
   return promise;
@@ skipping 98 matching lines @@
   ScriptPromise promise = resolver->promise();
 
   mojo::ScopedSharedBufferHandle sharedBufferHandle =
       mojo::SharedBufferHandle::Create(size);
   if (!sharedBufferHandle->is_valid()) {
     resolver->reject(
         DOMException::create(InvalidStateError, "Internal allocation error"));
     return promise;
   }
 
-  if (!m_service) {
-    resolver->reject(DOMException::create(
-        NotSupportedError, "Shape detection service unavailable."));
-    return promise;
-  }
-
   const mojo::ScopedSharedBufferMapping mappedBuffer =
       sharedBufferHandle->Map(size);
   DCHECK(mappedBuffer.get());
 
   memcpy(mappedBuffer.get(), data, size);
 
   m_serviceRequests.add(resolver);
-  DCHECK(m_service.is_bound());
   if (detectorType == DetectorType::Face) {
-    m_service->DetectFaces(
-        std::move(sharedBufferHandle), width, height, m_options.Clone(),
-        convertToBaseCallback(WTF::bind(&ShapeDetector::onDetectFaces,
-                                        wrapPersistent(this),
-                                        wrapPersistent(resolver))));
+    if (!m_faceService) {
+      resolver->reject(DOMException::create(
+          NotSupportedError, "Face detection service unavailable."));
+      return promise;
+    }
+    m_faceService->Detect(std::move(sharedBufferHandle), width, height,
+                          m_faceDetectorOptions.Clone(),
+                          convertToBaseCallback(WTF::bind(
+                              &ShapeDetector::onDetectFaces,
+                              wrapPersistent(this), wrapPersistent(resolver))));
   } else if (detectorType == DetectorType::Barcode) {
-    m_service->DetectBarcodes(
+    if (!m_barcodeService) {
+      resolver->reject(DOMException::create(
+          NotSupportedError, "Barcode detection service unavailable."));
+      return promise;
+    }
+    m_barcodeService->Detect(
         std::move(sharedBufferHandle), width, height,
         convertToBaseCallback(WTF::bind(&ShapeDetector::onDetectBarcodes,
                                         wrapPersistent(this),
                                         wrapPersistent(resolver))));
   } else {
     NOTREACHED() << "Unsupported detector type";
   }
   sharedBufferHandle.reset();
   return promise;
 }
@@ skipping 32 matching lines @@
   }
 
   resolver->resolve(detectedBarcodes);
 }
 
 DEFINE_TRACE(ShapeDetector) {
   visitor->trace(m_serviceRequests);
 }
 
 }  // namespace blink