ImageCapture: separate fillLightMode, redEyeReduction and Torch

third_party/WebKit/Source/modules/imagecapture/ImageCapture.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/imagecapture/ImageCapture.h"
 
 #include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
@@ skipping 10 matching lines @@
 #include "platform/mojo/MojoHelper.h"
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebImageCaptureFrameGrabber.h"
 #include "public/platform/WebMediaStreamTrack.h"
 #include "wtf/PtrUtil.h"
 
 namespace blink {
 
 using FillLightMode = media::mojom::blink::FillLightMode;
+using MeteringMode = media::mojom::blink::MeteringMode;
 
 namespace {
 
 const char kNoServiceError[] = "ImageCapture service unavailable.";
 
 bool trackIsInactive(const MediaStreamTrack& track) {
   // Spec instructs to return an exception if the Track's readyState() is not
   // "live". Also reject if the track is disabled or muted.
   return track.readyState() != "live" || !track.enabled() || track.muted();
 }
 
-media::mojom::blink::MeteringMode parseMeteringMode(const String& blinkMode) {
+MeteringMode parseMeteringMode(const String& blinkMode) {
   if (blinkMode == "manual")
-    return media::mojom::blink::MeteringMode::MANUAL;
+    return MeteringMode::MANUAL;
   if (blinkMode == "single-shot")
-    return media::mojom::blink::MeteringMode::SINGLE_SHOT;
+    return MeteringMode::SINGLE_SHOT;
   if (blinkMode == "continuous")
-    return media::mojom::blink::MeteringMode::CONTINUOUS;
-  return media::mojom::blink::MeteringMode::NONE;
+    return MeteringMode::CONTINUOUS;
+  if (blinkMode == "none")
+    return MeteringMode::NONE;
+  NOTREACHED();
+  return MeteringMode::NONE;
 }
 
 FillLightMode parseFillLightMode(const String& blinkMode) {
   if (blinkMode == "off")
     return FillLightMode::OFF;
   if (blinkMode == "auto")
     return FillLightMode::AUTO;
   if (blinkMode == "flash")
     return FillLightMode::FLASH;
-  return FillLightMode::NONE;
+  NOTREACHED();
+  return FillLightMode::OFF;
 }
 
-WebString toString(media::mojom::blink::MeteringMode value) {
+WebString toString(MeteringMode value) {
   switch (value) {
-    case media::mojom::blink::MeteringMode::NONE:
+    case MeteringMode::NONE:
       return WebString::fromUTF8("none");
-    case media::mojom::blink::MeteringMode::MANUAL:
+    case MeteringMode::MANUAL:
       return WebString::fromUTF8("manual");
-    case media::mojom::blink::MeteringMode::SINGLE_SHOT:
+    case MeteringMode::SINGLE_SHOT:
       return WebString::fromUTF8("single-shot");
-    case media::mojom::blink::MeteringMode::CONTINUOUS:
+    case MeteringMode::CONTINUOUS:
       return WebString::fromUTF8("continuous");
     default:
       NOTREACHED() << "Unknown MeteringMode";
   }
   return WebString();
 }
 
 }  // anonymous namespace
 
 ImageCapture* ImageCapture::create(ExecutionContext* context,
@@ skipping 257 matching lines @@
     m_currentConstraints.setSharpness(constraints.sharpness());
     settings->sharpness = constraints.sharpness().getAsDouble();
   }
 
   settings->has_zoom = constraints.hasZoom() && constraints.zoom().isDouble();
   if (settings->has_zoom) {
     m_currentConstraints.setZoom(constraints.zoom());
     settings->zoom = constraints.zoom().getAsDouble();
   }
 
-  // TODO(mcasas): add |torch| when the mojom interface is updated,
-  // https://crbug.com/700607.
+  // TODO(mcasas): support ConstrainBooleanParameters where applicable.
+  settings->has_torch =
+      constraints.hasTorch() && constraints.torch().isBoolean();
+  if (settings->has_torch) {
+    m_currentConstraints.setTorch(constraints.torch());
+    settings->torch = constraints.torch().getAsBoolean();
+  }
 
   m_service->SetOptions(m_streamTrack->component()->source()->id(),
                         std::move(settings),
                         convertToBaseCallback(WTF::bind(
                             &ImageCapture::onSetOptions, wrapPersistent(this),
                             wrapPersistent(resolver))));
 }
 
 const MediaTrackConstraintSet& ImageCapture::getMediaTrackConstraints() const {
   return m_currentConstraints;
@@ skipping 20 matching lines @@
     settings.setBrightness(m_capabilities.brightness()->current());
   if (m_capabilities.hasContrast())
     settings.setContrast(m_capabilities.contrast()->current());
   if (m_capabilities.hasSaturation())
     settings.setSaturation(m_capabilities.saturation()->current());
   if (m_capabilities.hasSharpness())
     settings.setSharpness(m_capabilities.sharpness()->current());
 
   if (m_capabilities.hasZoom())
     settings.setZoom(m_capabilities.zoom()->current());
+  if (m_capabilities.hasTorch())
+    settings.setTorch(m_capabilities.torch());
 
   // TODO(mcasas): add |torch| when the mojom interface is updated,
   // https://crbug.com/700607.
 }
 
 ImageCapture::ImageCapture(ExecutionContext* context, MediaStreamTrack* track)
     : ContextLifecycleObserver(context), m_streamTrack(track) {
   DCHECK(m_streamTrack);
   DCHECK(!m_service.is_bound());
 
@@ skipping 16 matching lines @@
     media::mojom::blink::PhotoCapabilitiesPtr capabilities) {
   if (!m_serviceRequests.contains(resolver))
     return;
   if (capabilities.is_null()) {
     resolver->reject(DOMException::create(UnknownError, "platform error"));
   } else {
     // Update the local capabilities cache.
     onCapabilitiesUpdate(capabilities.Clone());
 
     PhotoCapabilities* caps = PhotoCapabilities::create();
+
+    caps->setRedEyeReduction(capabilities->red_eye_reduction);
     // TODO(mcasas): Remove the explicit MediaSettingsRange::create() when
     // mojo::StructTraits supports garbage-collected mappings,
     // https://crbug.com/700180.
     caps->setImageHeight(
         MediaSettingsRange::create(std::move(capabilities->height)));
     caps->setImageWidth(
         MediaSettingsRange::create(std::move(capabilities->width)));
-
-    // TODO(mcasas): use a list of supported modes when mojo is updated.
-    // https://crbug.com/700607.
-    if (capabilities->fill_light_mode == FillLightMode::NONE)
-      caps->setFillLightMode(Vector<FillLightMode>());
-    else
-      caps->setFillLightMode({capabilities->fill_light_mode});
-
-    // TODO(mcasas): use a list of supported modes when mojo is updated.
-    // https://crbug.com/700607.
-    caps->setRedEyeReduction(capabilities->red_eye_reduction);
+    caps->setFillLightMode(capabilities->fill_light_mode);
 
     resolver->resolve(caps);
   }
   m_serviceRequests.erase(resolver);
 }
 
 void ImageCapture::onSetOptions(ScriptPromiseResolver* resolver, bool result) {
   if (!m_serviceRequests.contains(resolver))
     return;
 
@@ skipping 72 matching lines @@
   if (capabilities->sharpness->max != capabilities->sharpness->min) {
     m_capabilities.setSharpness(
         MediaSettingsRange::create(std::move(capabilities->sharpness)));
   }
 
   if (capabilities->zoom->max != capabilities->zoom->min) {
     m_capabilities.setZoom(
         MediaSettingsRange::create(std::move(capabilities->zoom)));
   }
 
+  m_capabilities.setTorch(capabilities->torch);
+
   // TODO(mcasas): do |torch| when the mojom interface is updated,
   // https://crbug.com/700607.
 }
 
 void ImageCapture::onServiceConnectionError() {
   m_service.reset();
   for (ScriptPromiseResolver* resolver : m_serviceRequests)
     resolver->reject(DOMException::create(NotFoundError, kNoServiceError));
   m_serviceRequests.clear();
 }
 
 DEFINE_TRACE(ImageCapture) {
   visitor->trace(m_streamTrack);
   visitor->trace(m_capabilities);
   visitor->trace(m_currentConstraints);
   visitor->trace(m_serviceRequests);
   EventTargetWithInlineData::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
 }
 
 }  // namespace blink