Image Capture: add |points_of_interest| to mojo and wire it to IDL layer

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 277 matching lines @@
   // 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));
     }
+    m_currentConstraints.setPointsOfInterest(constraints.pointsOfInterest());
   }
 
   // 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 =
@@ skipping 62 matching lines @@
 }
 
 void ImageCapture::getMediaTrackSettings(MediaTrackSettings& settings) const {
   if (m_capabilities.hasWhiteBalanceMode())
     settings.setWhiteBalanceMode(m_capabilities.whiteBalanceMode()[0]);
   if (m_capabilities.hasExposureMode())
     settings.setExposureMode(m_capabilities.exposureMode()[0]);
   if (m_capabilities.hasFocusMode())
     settings.setFocusMode(m_capabilities.focusMode()[0]);
 
+  if (!m_currentPointsOfInterest.isEmpty())
+    settings.setPointsOfInterest(m_currentPointsOfInterest);
+
   if (m_capabilities.hasExposureCompensation()) {
     settings.setExposureCompensation(
         m_capabilities.exposureCompensation()->current());
   }
   if (m_capabilities.hasColorTemperature())
     settings.setColorTemperature(m_capabilities.colorTemperature()->current());
   if (m_capabilities.hasIso())
     settings.setIso(m_capabilities.iso()->current());
 
   if (m_capabilities.hasBrightness())
     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());
 
   Platform::current()->interfaceProvider()->getInterface(
       mojo::MakeRequest(&m_service));
 
@@ skipping 10 matching lines @@
 
 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());
+    onCapabilitiesUpdateInternal(*capabilities);
 
     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(
@@ skipping 32 matching lines @@
   if (blob->data.isEmpty())
     resolver->reject(DOMException::create(UnknownError, "platform error"));
   else
     resolver->resolve(
         Blob::create(blob->data.data(), blob->data.size(), blob->mime_type));
   m_serviceRequests.erase(resolver);
 }
 
 void ImageCapture::onCapabilitiesUpdate(
     media::mojom::blink::PhotoCapabilitiesPtr capabilities) {
-  if (capabilities.is_null())
-    return;
+  if (!capabilities.is_null())
+    onCapabilitiesUpdateInternal(*capabilities);
+}
 
+void ImageCapture::onCapabilitiesUpdateInternal(
+    const media::mojom::blink::PhotoCapabilities& capabilities) {
   // TODO(mcasas): adapt the mojo interface to return a list of supported Modes
   // when moving these out of PhotoCapabilities, https://crbug.com/700607.
   m_capabilities.setWhiteBalanceMode(
-      WTF::Vector<WTF::String>({toString(capabilities->white_balance_mode)}));
+      WTF::Vector<WTF::String>({toString(capabilities.white_balance_mode)}));
   m_capabilities.setExposureMode(
-      WTF::Vector<WTF::String>({toString(capabilities->exposure_mode)}));
+      WTF::Vector<WTF::String>({toString(capabilities.exposure_mode)}));
   m_capabilities.setFocusMode(
-      WTF::Vector<WTF::String>({toString(capabilities->focus_mode)}));
+      WTF::Vector<WTF::String>({toString(capabilities.focus_mode)}));
+
+  if (!capabilities.points_of_interest.isEmpty()) {
+    m_currentPointsOfInterest.clear();
+    for (const auto& point : capabilities.points_of_interest) {
+      Point2D webPoint;
+      webPoint.setX(point->x);
+      webPoint.setY(point->y);
+      m_currentPointsOfInterest.push_back(mojo::Clone(webPoint));
+    }
+  }
 
   // TODO(mcasas): Remove the explicit MediaSettingsRange::create() when
   // mojo::StructTraits supports garbage-collected mappings,
   // https://crbug.com/700180.
-  if (capabilities->exposure_compensation->max !=
-      capabilities->exposure_compensation->min) {
+  if (capabilities.exposure_compensation->max !=
+      capabilities.exposure_compensation->min) {
     m_capabilities.setExposureCompensation(MediaSettingsRange::create(
-        std::move(capabilities->exposure_compensation)));
+        mojo::Clone(capabilities.exposure_compensation)));

[Reilly Grant (use Gerrit), 2017/04/04 00:06:06]

Update MediaSettingsRange::create() to take a const media::mojom::blink::Range&?

[mcasas, 2017/04/04 00:30:42]

Done.

   }
-  if (capabilities->color_temperature->max !=
-      capabilities->color_temperature->min) {
-    m_capabilities.setColorTemperature(
-        MediaSettingsRange::create(std::move(capabilities->color_temperature)));
+  if (capabilities.color_temperature->max !=
+      capabilities.color_temperature->min) {
+    m_capabilities.setColorTemperature(MediaSettingsRange::create(
+        mojo::Clone(capabilities.color_temperature)));
   }
-  if (capabilities->iso->max != capabilities->iso->min) {
+  if (capabilities.iso->max != capabilities.iso->min) {
     m_capabilities.setIso(
-        MediaSettingsRange::create(std::move(capabilities->iso)));
+        MediaSettingsRange::create(mojo::Clone(capabilities.iso)));
   }
 
-  if (capabilities->brightness->max != capabilities->brightness->min) {
+  if (capabilities.brightness->max != capabilities.brightness->min) {
     m_capabilities.setBrightness(
-        MediaSettingsRange::create(std::move(capabilities->brightness)));
+        MediaSettingsRange::create(mojo::Clone(capabilities.brightness)));
   }
-  if (capabilities->contrast->max != capabilities->contrast->min) {
+  if (capabilities.contrast->max != capabilities.contrast->min) {
     m_capabilities.setContrast(
-        MediaSettingsRange::create(std::move(capabilities->contrast)));
+        MediaSettingsRange::create(mojo::Clone(capabilities.contrast)));
   }
-  if (capabilities->saturation->max != capabilities->saturation->min) {
+  if (capabilities.saturation->max != capabilities.saturation->min) {
     m_capabilities.setSaturation(
-        MediaSettingsRange::create(std::move(capabilities->saturation)));
+        MediaSettingsRange::create(mojo::Clone(capabilities.saturation)));
   }
-  if (capabilities->sharpness->max != capabilities->sharpness->min) {
+  if (capabilities.sharpness->max != capabilities.sharpness->min) {
     m_capabilities.setSharpness(
-        MediaSettingsRange::create(std::move(capabilities->sharpness)));
+        MediaSettingsRange::create(mojo::Clone(capabilities.sharpness)));
   }
 
-  if (capabilities->zoom->max != capabilities->zoom->min) {
+  if (capabilities.zoom->max != capabilities.zoom->min) {
     m_capabilities.setZoom(
-        MediaSettingsRange::create(std::move(capabilities->zoom)));
+        MediaSettingsRange::create(mojo::Clone(capabilities.zoom)));
   }
 
-  m_capabilities.setTorch(capabilities->torch);
+  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_currentPointsOfInterest);
   visitor->trace(m_serviceRequests);
   EventTargetWithInlineData::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
 }
 
 }  // namespace blink