Image Capture: make sure applyConstraints() only works for ImageCapture constraints

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"
 #include "core/fileapi/Blob.h"
 #include "core/frame/ImageBitmap.h"
 #include "modules/EventTargetModules.h"
 #include "modules/imagecapture/MediaSettingsRange.h"
 #include "modules/imagecapture/PhotoCapabilities.h"
 #include "modules/imagecapture/PhotoSettings.h"
 #include "modules/mediastream/MediaStreamTrack.h"
 #include "modules/mediastream/MediaTrackCapabilities.h"
+#include "modules/mediastream/MediaTrackConstraints.h"
 #include "platform/WaitableEvent.h"
 #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 {
 
@@ skipping 210 matching lines @@
   m_frameGrabber->grabFrame(
       &track, new CallbackPromiseAdapter<ImageBitmap, void>(resolver));
 
   return promise;
 }
 
 MediaTrackCapabilities& ImageCapture::getMediaTrackCapabilities() {
   return m_capabilities;
 }
 
-// TODO(mcasas): make the implementation fully Spec compliant, see inside the
-// method, https://crbug.com/700607.
+// TODO(mcasas): make the implementation fully Spec compliant, see the TODOs
+// inside the method, https://crbug.com/708723.
 void ImageCapture::setMediaTrackConstraints(
     ScriptPromiseResolver* resolver,
-    const MediaTrackConstraintSet& constraints) {
+    const HeapVector<MediaTrackConstraintSet>& constraintsVector) {
   if (!m_service) {
     resolver->reject(DOMException::create(NotFoundError, kNoServiceError));
     return;
   }
   m_serviceRequests.insert(resolver);
 
+  // TODO(mcasas): add support more than one single advanced constraint.
+  const auto constraints = constraintsVector[0];
+
   auto settings = media::mojom::blink::PhotoSettings::New();
 
   // TODO(mcasas): support other Mode types beyond simple string i.e. the
   // equivalents of "sequence<DOMString>"" or "ConstrainDOMStringParameters".
   settings->has_white_balance_mode = constraints.hasWhiteBalanceMode() &&
                                      constraints.whiteBalanceMode().isString();
   if (settings->has_white_balance_mode) {
     m_currentConstraints.setWhiteBalanceMode(constraints.whiteBalanceMode());
     settings->white_balance_mode =
         parseMeteringMode(constraints.whiteBalanceMode().getAsString());
@@ skipping 92 matching lines @@
                         std::move(settings),
                         convertToBaseCallback(WTF::bind(
                             &ImageCapture::onSetOptions, wrapPersistent(this),
                             wrapPersistent(resolver))));
 }
 
 const MediaTrackConstraintSet& ImageCapture::getMediaTrackConstraints() const {
   return m_currentConstraints;
 }
 
+void ImageCapture::clearMediaTrackConstraints(ScriptPromiseResolver* resolver) {
+  m_currentConstraints = MediaTrackConstraintSet();
+  resolver->resolve();
+
+  // TODO(mcasas): Clear also any PhotoSettings that the device might have got
+  // configured, for that we need to know a "default" state of the device; take
+  // a snapshot upon first opening. https://crbug.com/700607.
+}
+
 void ImageCapture::getMediaTrackSettings(MediaTrackSettings& settings) const {
   // Merge any present |m_settings| members into |settings|.
 
   if (m_settings.hasWhiteBalanceMode())
     settings.setWhiteBalanceMode(m_settings.whiteBalanceMode());
   if (m_settings.hasExposureMode())
     settings.setExposureMode(m_settings.exposureMode());
   if (m_settings.hasFocusMode())
     settings.setFocusMode(m_settings.focusMode());
 
@@ skipping 15 matching lines @@
     settings.setSaturation(m_settings.saturation());
   if (m_settings.hasSharpness())
     settings.setSharpness(m_settings.sharpness());
 
   if (m_settings.hasZoom())
     settings.setZoom(m_settings.zoom());
   if (m_settings.hasTorch())
     settings.setTorch(m_settings.torch());
 }
 
+bool ImageCapture::hasNonImageCaptureConstraints(
+    const MediaTrackConstraints& constraints) const {
+  if (!constraints.hasAdvanced())
+    return false;
+
+  const auto& advancedConstraints = constraints.advanced();
+  for (const auto& constraint : advancedConstraints) {
+    if (constraint.hasWidth() || constraint.hasHeight() ||
+        constraint.hasAspectRatio() || constraint.hasFrameRate() ||
+        constraint.hasFacingMode() || constraint.hasVolume() ||
+        constraint.hasSampleRate() || constraint.hasSampleSize() ||
+        constraint.hasEchoCancellation() || constraint.hasLatency() ||
+        constraint.hasChannelCount() || constraint.hasDeviceId() ||
+        constraint.hasGroupId() || constraint.hasVideoKind() ||
+        constraint.hasDepthNear() || constraint.hasDepthFar() ||
+        constraint.hasFocalLengthX() || constraint.hasFocalLengthY() ||
+        constraint.hasMandatory() || constraint.hasOptional()) {
+      return true;
+    }
+  }
+  return false;
+}
+
 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));
 
   m_service.set_connection_error_handler(convertToBaseCallback(WTF::bind(
       &ImageCapture::onServiceConnectionError, wrapWeakPersistent(this))));
@@ skipping 164 matching lines @@
   visitor->trace(m_streamTrack);
   visitor->trace(m_capabilities);
   visitor->trace(m_settings);
   visitor->trace(m_currentConstraints);
   visitor->trace(m_serviceRequests);
   EventTargetWithInlineData::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
 }
 
 }  // namespace blink