Image Capture: wire getSettings() from MediaStreamTrack

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/MediaTrackSettings.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 350 matching lines @@
                         std::move(settings),
                         convertToBaseCallback(WTF::bind(
                             &ImageCapture::onSetOptions, wrapPersistent(this),
                             wrapPersistent(resolver))));
 }
 
 const MediaTrackConstraintSet& ImageCapture::getMediaTrackConstraints() const {
   return m_currentConstraints;
 }
 
+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_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());
+
+  // 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));
 
   m_service.set_connection_error_handler(convertToBaseCallback(WTF::bind(
       &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::onCapabilitiesBootstrap,
+      convertToBaseCallback(WTF::bind(&ImageCapture::onCapabilitiesUpdate,
                                       wrapPersistent(this))));
 }
 
 void ImageCapture::onCapabilities(
     ScriptPromiseResolver* resolver,
     media::mojom::blink::PhotoCapabilitiesPtr capabilities) {
-  DVLOG(1) << __func__;
   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)));
@@ skipping 18 matching lines @@
     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->resolve();
-  else
+  if (!result) {
     resolver->reject(DOMException::create(UnknownError, "setOptions failed"));
-  m_serviceRequests.erase(resolver);
+    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,
+                                      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.
   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::onCapabilitiesBootstrap(
+void ImageCapture::onCapabilitiesUpdate(
     media::mojom::blink::PhotoCapabilitiesPtr capabilities) {
-  DVLOG(1) << __func__;
   if (capabilities.is_null())
     return;
 
   // 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)}));
   m_capabilities.setExposureMode(
       WTF::Vector<WTF::String>({toString(capabilities->exposure_mode)}));
   m_capabilities.setFocusMode(
@@ skipping 52 matching lines @@
 
 DEFINE_TRACE(ImageCapture) {
   visitor->trace(m_streamTrack);
   visitor->trace(m_capabilities);
   visitor->trace(m_serviceRequests);
   EventTargetWithInlineData::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
 }
 
 }  // namespace blink