ImageCapture: support exposure mode configuration

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 17 matching lines @@
 
 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 MeteringModeBlinkToMojo(const String& blinkMode)

[Reilly Grant (use Gerrit), 2016/08/24 18:14:03]

This isn't really Blink's metering mode. I'd name this parseMeteringMode().

[mcasas, 2016/08/24 18:36:23]

Done.

+{
+    if (blinkMode == "manual")
+        return media::mojom::blink::MeteringMode::MANUAL;
+    if (blinkMode == "single-shot")
+        return media::mojom::blink::MeteringMode::SINGLE_SHOT;
+    if (blinkMode == "continuous")
+        return media::mojom::blink::MeteringMode::CONTINUOUS;
+    return media::mojom::blink::MeteringMode::UNAVAILABLE;
+}
+
 } // anonymous namespace
 
 ImageCapture* ImageCapture::create(ExecutionContext* context, MediaStreamTrack* track, ExceptionState& exceptionState)
 {
     if (track->kind() != "video") {
         exceptionState.throwDOMException(NotSupportedError, "Cannot create an ImageCapturer from a non-video Track.");
         return nullptr;
     }
 
     return new ImageCapture(context, track);
@@ skipping 70 matching lines @@
     settings->has_zoom = photoSettings.hasZoom();
     if (settings->has_zoom)
         settings->zoom = photoSettings.zoom();
     settings->has_height = photoSettings.hasImageHeight();
     if (settings->has_height)
         settings->height = photoSettings.imageHeight();
     settings->has_width = photoSettings.hasImageWidth();
     if (settings->has_width)
         settings->width = photoSettings.imageWidth();
     settings->has_focus_mode = photoSettings.hasFocusMode();
-    if (settings->has_focus_mode) {
-        if (photoSettings.focusMode() == "manual")
-            settings->focus_mode = media::mojom::blink::FocusMode::MANUAL;
-        else if (photoSettings.focusMode() == "single-shot")
-            settings->focus_mode = media::mojom::blink::FocusMode::SINGLE_SHOT;
-        else if (photoSettings.focusMode() == "continuous")
-            settings->focus_mode = media::mojom::blink::FocusMode::CONTINUOUS;
-        else
-            settings->has_focus_mode = false;
-    }
+    if (settings->has_focus_mode)
+        settings->focus_mode = MeteringModeBlinkToMojo(photoSettings.focusMode());
+    settings->has_exposure_mode = photoSettings.hasExposureMode();
+    if (settings->has_exposure_mode)
+        settings->exposure_mode = MeteringModeBlinkToMojo(photoSettings.exposureMode());
     if (photoSettings.hasPointsOfInterest()) {
         for (const auto& point : photoSettings.pointsOfInterest()) {
             auto mojoPoint = media::mojom::blink::Point2D::New();
             mojoPoint->x = point.x();
             mojoPoint->y = point.y();
             settings->points_of_interest.append(std::move(mojoPoint));
         }
     }
 
     m_service->SetOptions(m_streamTrack->component()->source()->id(), std::move(settings), convertToBaseCallback(WTF::bind(&ImageCapture::onSetOptions, wrapPersistent(this), wrapPersistent(resolver))));
@@ skipping 77 matching lines @@
         MediaSettingsRange* iso = MediaSettingsRange::create(capabilities->iso->max, capabilities->iso->min, capabilities->iso->current);
         MediaSettingsRange* height = MediaSettingsRange::create(capabilities->height->max, capabilities->height->min, capabilities->height->current);
         MediaSettingsRange* width = MediaSettingsRange::create(capabilities->width->max, capabilities->width->min, capabilities->width->current);
         MediaSettingsRange* zoom = MediaSettingsRange::create(capabilities->zoom->max, capabilities->zoom->min, capabilities->zoom->current);
         PhotoCapabilities* caps = PhotoCapabilities::create();
         caps->setIso(iso);
         caps->setImageHeight(height);
         caps->setImageWidth(width);
         caps->setZoom(zoom);
         caps->setFocusMode(capabilities->focus_mode);
+        caps->setExposureMode(capabilities->exposure_mode);
         resolver->resolve(caps);
     }
     m_serviceRequests.remove(resolver);
 }
 
 void ImageCapture::onSetOptions(ScriptPromiseResolver* resolver, bool result)
 {
     if (!m_serviceRequests.contains(resolver))
         return;
 
@@ skipping 27 matching lines @@
 
 DEFINE_TRACE(ImageCapture)
 {
     visitor->trace(m_streamTrack);
     visitor->trace(m_serviceRequests);
     EventTargetWithInlineData::trace(visitor);
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink