Image Capture: prune Photo{Capabilities/Settings} and add MediaTrackConstraintSet.pointsOfInterest

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 113 matching lines @@
     return promise;
   }
   m_serviceRequests.insert(resolver);
 
   // m_streamTrack->component()->source()->id() is the renderer "name" of the
   // camera;
   // TODO(mcasas) consider sending the security origin as well:
   // scriptState->getExecutionContext()->getSecurityOrigin()->toString()
   m_service->GetCapabilities(
       m_streamTrack->component()->source()->id(),
-      convertToBaseCallback(WTF::bind(&ImageCapture::onCapabilities,
+      convertToBaseCallback(WTF::bind(&ImageCapture::onPhotoCapabilities,
                                       wrapPersistent(this),
                                       wrapPersistent(resolver))));
   return promise;
 }
 
 ScriptPromise ImageCapture::setOptions(ScriptState* scriptState,
                                        const PhotoSettings& photoSettings) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
   if (trackIsInactive(*m_streamTrack)) {
     resolver->reject(DOMException::create(
         InvalidStateError, "The associated Track is in an invalid state."));
     return promise;
   }
 
   if (!m_service) {
     resolver->reject(DOMException::create(NotFoundError, kNoServiceError));
     return promise;
   }
   m_serviceRequests.insert(resolver);
 
   // TODO(mcasas): should be using a mojo::StructTraits instead.
   auto settings = media::mojom::blink::PhotoSettings::New();
 
-  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)
-    settings->focus_mode = parseMeteringMode(photoSettings.focusMode());
-  settings->has_exposure_mode = photoSettings.hasExposureMode();
-  if (settings->has_exposure_mode)
-    settings->exposure_mode = parseMeteringMode(photoSettings.exposureMode());
-  settings->has_exposure_compensation = photoSettings.hasExposureCompensation();
-  if (settings->has_exposure_compensation)
-    settings->exposure_compensation = photoSettings.exposureCompensation();
-  settings->has_white_balance_mode = photoSettings.hasWhiteBalanceMode();
-  if (settings->has_white_balance_mode)
-    settings->white_balance_mode =
-        parseMeteringMode(photoSettings.whiteBalanceMode());
-  settings->has_iso = photoSettings.hasIso();
-  if (settings->has_iso)
-    settings->iso = photoSettings.iso();
+
   settings->has_red_eye_reduction = photoSettings.hasRedEyeReduction();
   if (settings->has_red_eye_reduction)
     settings->red_eye_reduction = photoSettings.redEyeReduction();
   settings->has_fill_light_mode = photoSettings.hasFillLightMode();
-  if (settings->has_fill_light_mode)
+  if (settings->has_fill_light_mode) {
     settings->fill_light_mode =
         parseFillLightMode(photoSettings.fillLightMode());
-  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.push_back(std::move(mojoPoint));
-    }
   }
-  settings->has_color_temperature = photoSettings.hasColorTemperature();
-  if (settings->has_color_temperature)
-    settings->color_temperature = photoSettings.colorTemperature();
-  settings->has_brightness = photoSettings.hasBrightness();
-  if (settings->has_brightness)
-    settings->brightness = photoSettings.brightness();
-  settings->has_contrast = photoSettings.hasContrast();
-  if (settings->has_contrast)
-    settings->contrast = photoSettings.contrast();
-  settings->has_saturation = photoSettings.hasSaturation();
-  if (settings->has_saturation)
-    settings->saturation = photoSettings.saturation();
-  settings->has_sharpness = photoSettings.hasSharpness();
-  if (settings->has_sharpness)
-    settings->sharpness = photoSettings.sharpness();
 
   m_service->SetOptions(m_streamTrack->component()->source()->id(),
                         std::move(settings),
                         convertToBaseCallback(WTF::bind(
                             &ImageCapture::onSetOptions, wrapPersistent(this),
                             wrapPersistent(resolver))));
   return promise;
 }
 
 ScriptPromise ImageCapture::takePhoto(ScriptState* scriptState) {
@@ skipping 88 matching lines @@
   }
 
   settings->has_focus_mode =
       constraints.hasFocusMode() && constraints.focusMode().isString();
   if (settings->has_focus_mode) {
     m_currentConstraints.setFocusMode(constraints.focusMode());
     settings->focus_mode =
         parseMeteringMode(constraints.focusMode().getAsString());
   }
 
+  // TODO(mcasas): support ConstrainPoint2DParameters.
+  if (constraints.hasPointsOfInterest() &&
+      constraints.pointsOfInterest().isPoint2DSequence()) {
+    for (const auto& point :
+         constraints.pointsOfInterest().getAsPoint2DSequence()) {
+      auto mojoPoint = media::mojom::blink::Point2D::New();
+      mojoPoint->x = point.x();
+      mojoPoint->y = point.y();
+      settings->points_of_interest.push_back(std::move(mojoPoint));
+    }
+  }
+
   // TODO(mcasas): support ConstrainDoubleRange where applicable.
   settings->has_exposure_compensation =
       constraints.hasExposureCompensation() &&
       constraints.exposureCompensation().isDouble();
   if (settings->has_exposure_compensation) {
     m_currentConstraints.setExposureCompensation(
         constraints.exposureCompensation());
     settings->exposure_compensation =
         constraints.exposureCompensation().getAsDouble();
   }
@@ skipping 99 matching lines @@
       &ImageCapture::onServiceConnectionError, wrapWeakPersistent(this))));
 
   // Launch a retrieval of the current capabilities, which arrive asynchronously
   // to avoid blocking the main UI thread.
   m_service->GetCapabilities(
       m_streamTrack->component()->source()->id(),
       convertToBaseCallback(WTF::bind(&ImageCapture::onCapabilitiesUpdate,
                                       wrapPersistent(this))));
 }
 
-void ImageCapture::onCapabilities(
+void ImageCapture::onPhotoCapabilities(
     ScriptPromiseResolver* resolver,
     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();
     // TODO(mcasas): Remove the explicit MediaSettingsRange::create() when
     // mojo::StructTraits supports garbage-collected mappings,
     // https://crbug.com/700180.
-    caps->setIso(MediaSettingsRange::create(std::move(capabilities->iso)));
     caps->setImageHeight(
         MediaSettingsRange::create(std::move(capabilities->height)));
     caps->setImageWidth(
         MediaSettingsRange::create(std::move(capabilities->width)));
-    caps->setZoom(MediaSettingsRange::create(std::move(capabilities->zoom)));
-    caps->setExposureCompensation(MediaSettingsRange::create(
-        std::move(capabilities->exposure_compensation)));
-    caps->setColorTemperature(
-        MediaSettingsRange::create(std::move(capabilities->color_temperature)));
-    caps->setBrightness(
-        MediaSettingsRange::create(std::move(capabilities->brightness)));
-    caps->setContrast(
-        MediaSettingsRange::create(std::move(capabilities->contrast)));
-    caps->setSaturation(
-        MediaSettingsRange::create(std::move(capabilities->saturation)));
-    caps->setSharpness(
-        MediaSettingsRange::create(std::move(capabilities->sharpness)));
+    caps->setFillLightMode(capabilities->fill_light_mode);
+    caps->setRedEyeReduction(capabilities->red_eye_reduction);
 
-    caps->setFocusMode(capabilities->focus_mode);
-    caps->setExposureMode(capabilities->exposure_mode);
-    caps->setWhiteBalanceMode(capabilities->white_balance_mode);
-    caps->setFillLightMode(capabilities->fill_light_mode);
-
-    caps->setRedEyeReduction(capabilities->red_eye_reduction);
     resolver->resolve(caps);
   }
   m_serviceRequests.erase(resolver);
 }
 
 void ImageCapture::onSetOptions(ScriptPromiseResolver* resolver, bool result) {
   if (!m_serviceRequests.contains(resolver))
     return;
 
   if (!result) {
     resolver->reject(DOMException::create(UnknownError, "setOptions failed"));
     m_serviceRequests.erase(resolver);
     return;
   }
 
   // Retrieve the current device status after setting the options.
   m_service->GetCapabilities(
       m_streamTrack->component()->source()->id(),
-      convertToBaseCallback(WTF::bind(&ImageCapture::onCapabilities,
+      convertToBaseCallback(WTF::bind(&ImageCapture::onPhotoCapabilities,
                                       wrapPersistent(this),
                                       wrapPersistent(resolver))));
 }
 
 void ImageCapture::onTakePhoto(ScriptPromiseResolver* resolver,
                                media::mojom::blink::BlobPtr blob) {
   if (!m_serviceRequests.contains(resolver))
     return;
 
   // TODO(mcasas): Should be using a mojo::StructTraits.
@@ skipping 66 matching lines @@
 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