[MediaStream] Add support for torch

https://bugs.webkit.org/show_bug.cgi?id=262131
rdar://116066837

Reviewed by Youenn Fablet.

Add support for `torch` to MediaTrackCapabilities and MediaTrackSettings, and expose
'torch' as a supported constraint in MockRealtimeVideoSource and AVVideoCaptureSource.

* LayoutTests/fast/mediastream/MediaStreamTrack-getCapabilities-expected.txt:
* LayoutTests/fast/mediastream/mediastreamtrack-video-torch-expected.txt: Added.
* LayoutTests/fast/mediastream/mediastreamtrack-video-torch.html: Added.
* Source/WebCore/Modules/mediastream/MediaDevices.cpp:
(WebCore::hasInvalidGetDisplayMediaConstraint):
* Source/WebCore/Modules/mediastream/MediaStreamTrack.cpp:
(WebCore::MediaStreamTrack::getSettings const):
* Source/WebCore/Modules/mediastream/MediaStreamTrack.h:
* Source/WebCore/Modules/mediastream/MediaStreamTrack.idl:
* Source/WebCore/Modules/mediastream/MediaTrackCapabilities.cpp:
(WebCore::toMediaTrackCapabilities):
* Source/WebCore/Modules/mediastream/MediaTrackCapabilities.h:
* Source/WebCore/Modules/mediastream/MediaTrackCapabilities.idl:
* Source/WebCore/Modules/mediastream/MediaTrackConstraints.cpp:
(WebCore::convertToInternalForm):
* Source/WebCore/Modules/mediastream/MediaTrackConstraints.h:
* Source/WebCore/Modules/mediastream/MediaTrackConstraints.idl:
* Source/WebCore/Modules/mediastream/MediaTrackSupportedConstraints.h:
* Source/WebCore/Modules/mediastream/MediaTrackSupportedConstraints.idl:
* Source/WebCore/PAL/pal/cocoa/AVFoundationSoftLink.h:
* Source/WebCore/PAL/pal/cocoa/AVFoundationSoftLink.mm:
* Source/WebCore/platform/mediastream/MediaConstraints.cpp:
(WebCore::MediaTrackConstraintSetMap::filter const):
(WebCore::MediaTrackConstraintSetMap::set):
* Source/WebCore/platform/mediastream/MediaConstraints.h:
(WebCore::MediaTrackConstraintSetMap::aspectRatio const):
(WebCore::MediaTrackConstraintSetMap::facingMode const):
(WebCore::MediaTrackConstraintSetMap::whiteBalanceMode const):
(WebCore::MediaTrackConstraintSetMap::zoom const):
(WebCore::MediaTrackConstraintSetMap::torch const):
* Source/WebCore/platform/mediastream/RealtimeMediaSource.cpp:
(WebCore::RealtimeMediaSource::fitnessDistance):
(WebCore::RealtimeMediaSource::applyConstraint):
(WebCore::RealtimeMediaSource::supportsConstraint):
(WebCore::RealtimeMediaSource::supportsConstraints):
(WebCore::RealtimeMediaSource::setTorch):
* Source/WebCore/platform/mediastream/RealtimeMediaSource.h:
* Source/WebCore/platform/mediastream/RealtimeMediaSourceCapabilities.h:
(WebCore::RealtimeMediaSourceCapabilities::RealtimeMediaSourceCapabilities):
(WebCore::RealtimeMediaSourceCapabilities::supportsWhiteBalanceMode const):
(WebCore::RealtimeMediaSourceCapabilities::whiteBalanceModes const):
(WebCore::RealtimeMediaSourceCapabilities::setWhiteBalanceModes):
(WebCore::RealtimeMediaSourceCapabilities::supportsTorch const):
(WebCore::RealtimeMediaSourceCapabilities::torch const):
(WebCore::RealtimeMediaSourceCapabilities::setTorch):
* Source/WebCore/platform/mediastream/RealtimeMediaSourceCenter.cpp:
(WebCore::RealtimeMediaSourceCenter::RealtimeMediaSourceCenter):
* Source/WebCore/platform/mediastream/RealtimeMediaSourceSettings.cpp:
(WebCore::RealtimeMediaSourceSettings::convertFlagsToString):
(WebCore::RealtimeMediaSourceSettings::difference const):
* Source/WebCore/platform/mediastream/RealtimeMediaSourceSettings.h:
(WebCore::RealtimeMediaSourceSettings::allFlags):
(WebCore::RealtimeMediaSourceSettings::RealtimeMediaSourceSettings):
(WebCore::RealtimeMediaSourceSettings::supportsWhiteBalanceMode const):
(WebCore::RealtimeMediaSourceSettings::whiteBalanceMode const):
(WebCore::RealtimeMediaSourceSettings::setWhiteBalanceMode):
(WebCore::RealtimeMediaSourceSettings::supportsTorch const):
(WebCore::RealtimeMediaSourceSettings::torch const):
(WebCore::RealtimeMediaSourceSettings::setTorch):
* Source/WebCore/platform/mediastream/RealtimeMediaSourceSupportedConstraints.cpp:
(WebCore::RealtimeMediaSourceSupportedConstraints::supportsConstraint const):
* Source/WebCore/platform/mediastream/RealtimeMediaSourceSupportedConstraints.h:
(WebCore::RealtimeMediaSourceSupportedConstraints::RealtimeMediaSourceSupportedConstraints):
(WebCore::RealtimeMediaSourceSupportedConstraints::supportsWhiteBalanceMode const):
(WebCore::RealtimeMediaSourceSupportedConstraints::setSupportsWhiteBalanceMode):
(WebCore::RealtimeMediaSourceSupportedConstraints::supportsTorch const):
(WebCore::RealtimeMediaSourceSupportedConstraints::setSupportsTorch):
* Source/WebCore/platform/mediastream/mac/AVVideoCaptureSource.h:
* Source/WebCore/platform/mediastream/mac/AVVideoCaptureSource.mm:
(WebCore::AVVideoCaptureSource::AVVideoCaptureSource):
(WebCore::AVVideoCaptureSource::settingsDidChange):
(WebCore::AVVideoCaptureSource::settings):
(WebCore::AVVideoCaptureSource::capabilities):
(WebCore::AVVideoCaptureSource::setSessionSizeFrameRateAndZoom):
(WebCore::AVVideoCaptureSource::lockForConfiguration):
(WebCore::AVVideoCaptureSource::updateWhiteBalanceMode):
(WebCore::AVVideoCaptureSource::updateTorch):
* Source/WebCore/platform/mock/MockMediaDevice.h:
* Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.cpp:
(WebCore::defaultDevices):
* Source/WebCore/platform/mock/MockRealtimeVideoSource.cpp:
(WebCore::MockRealtimeVideoSource::capabilities):
(WebCore::MockRealtimeVideoSource::settings):
* Source/WebKit/Shared/WebCoreArgumentCoders.serialization.in:

Canonical link: https://commits.webkit.org/268853@main

LayoutTests/fast/mediastream/MediaStreamTrack-getCapabilities-expected.txt

@@ -27,6 +27,7 @@ video track capabilities:
   capabilities.frameRate = { max: 120, min: 1 }
   capabilities.groupId = <UUID>
   capabilities.height = { max: 2160, min: 1 }
+  capabilities.torch = true
   capabilities.whiteBalanceMode = [ manual, single-shot, continuous ]
   capabilities.width = { max: 3840, min: 1 }
   capabilities.zoom = { max: 4, min: 1 }
@@ -46,6 +47,7 @@ video track capabilities:
   capabilities.frameRate = { max: 120, min: 1 }
   capabilities.groupId = <UUID>
   capabilities.height = { max: 2160, min: 1 }
+  capabilities.torch = true
   capabilities.whiteBalanceMode = [ manual, single-shot, continuous ]
   capabilities.width = { max: 3840, min: 1 }
   capabilities.zoom = { max: 4, min: 1 }

LayoutTests/fast/mediastream/mediastreamtrack-video-torch-expected.txt

@@ -0,0 +1,4 @@
+
+
+PASS getUserMedia torch
+

LayoutTests/fast/mediastream/mediastreamtrack-video-torch.html

@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset='utf-8'>
+    <title>Camera track torch</title>
+    <script src='../../resources/testharness.js'></script>
+    <script src='../../resources/testharnessreport.js'></script>
+</head>
+<body>
+    <canvas id='canvas'></canvas>
+    <video controls autoplay width=640 height=480 playsInline id='video'></video>
+    <script>
+
+        let stream;
+        promise_test(async (test) => {
+            stream = await navigator.mediaDevices.getUserMedia({ video: { width : 640 } });
+            assert_equals(stream.getVideoTracks()[0].getSettings().torch, undefined, 'settings-1');
+            assert_equals(stream.getVideoTracks()[0].getCapabilities().torch, undefined, 'capabilities-1');
+
+            stream = await navigator.mediaDevices.getUserMedia({ video: { width: 640, torch : true } });
+            assert_equals(stream.getVideoTracks()[0].getCapabilities().torch, true, 'capabilities-2');
+
+            await stream.getVideoTracks()[0].applyConstraints({ torch : true });
+            assert_equals(stream.getVideoTracks()[0].getSettings().torch, true, 'settings-2');
+
+            await stream.getVideoTracks()[0].applyConstraints({ torch : false });
+            assert_equals(stream.getVideoTracks()[0].getSettings().torch, false, 'settings -3');
+
+        }, 'getUserMedia torch');
+    </script>
+</body>
+</html>

Source/WebCore/Modules/mediastream/MediaDevices.cpp

@@ -228,8 +228,9 @@ static bool hasInvalidGetDisplayMediaConstraint(const MediaConstraints& constrai
         case MediaConstraintType::Volume:
         case MediaConstraintType::EchoCancellation:
         case MediaConstraintType::FocusDistance:
-        case MediaConstraintType::Zoom:
         case MediaConstraintType::WhiteBalanceMode:
+        case MediaConstraintType::Zoom:
+        case MediaConstraintType::Torch:
             // Ignored.
             break;
 

Source/WebCore/Modules/mediastream/MediaStreamTrack.cpp

@@ -276,8 +276,6 @@ MediaStreamTrack::TrackSettings MediaStreamTrack::getSettings() const
         result.frameRate = settings.frameRate();
     if (settings.supportsFacingMode())
         result.facingMode = convertEnumerationToString(settings.facingMode());
-    if (settings.supportsWhiteBalanceMode())
-        result.whiteBalanceMode = convertEnumerationToString(settings.whiteBalanceMode());
     if (settings.supportsVolume())
         result.volume = settings.volume();
     if (settings.supportsSampleRate())
@@ -292,8 +290,13 @@ MediaStreamTrack::TrackSettings MediaStreamTrack::getSettings() const
         result.groupId = m_groupId;
     if (settings.supportsDisplaySurface() && settings.displaySurface() != DisplaySurfaceType::Invalid)
         result.displaySurface = RealtimeMediaSourceSettings::displaySurface(settings.displaySurface());
+
+    if (settings.supportsWhiteBalanceMode())
+        result.whiteBalanceMode = convertEnumerationToString(settings.whiteBalanceMode());
     if (settings.supportsZoom())
         result.zoom = settings.zoom();
+    if (settings.supportsTorch())
+        result.torch = settings.torch();
 
     return result;
 }

Source/WebCore/Modules/mediastream/MediaStreamTrack.h

@@ -112,15 +112,17 @@ class MediaStreamTrack
         std::optional<double> aspectRatio;
         std::optional<double> frameRate;
         String facingMode;
-        String whiteBalanceMode;
         std::optional<double> volume;
         std::optional<int> sampleRate;
         std::optional<int> sampleSize;
         std::optional<bool> echoCancellation;
         String displaySurface;
         String deviceId;
         String groupId;
+
+        String whiteBalanceMode;
         std::optional<double> zoom;
+        std::optional<bool> torch;
     };
     TrackSettings getSettings() const;
 

Source/WebCore/Modules/mediastream/MediaStreamTrack.idl

@@ -73,7 +73,25 @@ enum MediaStreamTrackState { "live", "ended" };
     DOMString deviceId;
     DOMString groupId;
     DOMString displaySurface;
-    double zoom;
+
     DOMString whiteBalanceMode;
+    // FIXME: add exposureMode;
+    // FIXME: add focusMode;
+    // FIXME: add pointsOfInterest;
+
+    // FIXME: add exposureCompensation;
+    // FIXME: add exposureTime;
+    // FIXME: add colorTemperature;
+    // FIXME: add iso;
+
+    // FIXME: add brightness;
+    // FIXME: add contrast;
+    // FIXME: add saturation;
+    // FIXME: add sharpness;
+
+    // FIXME: add focusDistance;
+    double zoom;
+
+    boolean torch;
 
 };

Source/WebCore/Modules/mediastream/MediaTrackCapabilities.cpp

@@ -113,11 +113,12 @@ MediaTrackCapabilities toMediaTrackCapabilities(const RealtimeMediaSourceCapabil
         result.groupId = groupId;
     if (capabilities.supportsFocusDistance())
         result.focusDistance = capabilityDoubleRange(capabilities.focusDistance());
-    if (capabilities.supportsZoom())
-        result.zoom = capabilityDoubleRange(capabilities.zoom());
     if (capabilities.supportsWhiteBalanceMode())
         result.whiteBalanceMode = capabilityStringVector(capabilities.whiteBalanceModes());
-
+    if (capabilities.supportsZoom())
+        result.zoom = capabilityDoubleRange(capabilities.zoom());
+    if (capabilities.supportsTorch())
+        result.torch = capabilities.torch();
 
     return result;
 }

Source/WebCore/Modules/mediastream/MediaTrackCapabilities.h

@@ -41,7 +41,6 @@ struct MediaTrackCapabilities {
     std::optional<DoubleRange> aspectRatio;
     std::optional<DoubleRange> frameRate;
     std::optional<Vector<String>> facingMode;
-    std::optional<Vector<String>> whiteBalanceMode;
     std::optional<DoubleRange> volume;
     std::optional<LongRange> sampleRate;
     std::optional<LongRange> sampleSize;
@@ -50,7 +49,9 @@ struct MediaTrackCapabilities {
     String groupId;
     String displaySurface;
     std::optional<DoubleRange> focusDistance;
+    std::optional<Vector<String>> whiteBalanceMode;
     std::optional<DoubleRange> zoom;
+    std::optional<bool> torch;
 };
 
 MediaTrackCapabilities toMediaTrackCapabilities(const RealtimeMediaSourceCapabilities&, const String& groupId);

Source/WebCore/Modules/mediastream/MediaTrackCapabilities.idl

@@ -43,6 +43,23 @@
     DOMString groupId;
     DOMString displaySurface;
     DoubleRange focusDistance;
-    DoubleRange zoom;
+
     sequence<DOMString> whiteBalanceMode;
+    // FIXME: add exposureMode;
+    // FIXME: add focusMode;
+
+    // FIXME: add exposureCompensation;
+    // FIXME: add exposureTime;
+    // FIXME: add colorTemperature;
+    // FIXME: add iso;
+
+    // FIXME: add brightness;
+    // FIXME: add contrast;
+    // FIXME: add saturation;
+    // FIXME: add sharpness;
+
+    // FIXME: add focusDistance;
+    DoubleRange zoom;
+
+    boolean torch;
 };

Source/WebCore/Modules/mediastream/MediaTrackConstraints.cpp

@@ -173,8 +173,11 @@ static MediaTrackConstraintSetMap convertToInternalForm(ConstraintSetType setTyp
     set(result, setType, "groupId"_s, MediaConstraintType::GroupId, constraintSet.groupId);
     set(result, setType, "displaySurface"_s, MediaConstraintType::DisplaySurface, constraintSet.displaySurface);
     set(result, setType, "logicalSurface"_s, MediaConstraintType::LogicalSurface, constraintSet.logicalSurface);
-    set(result, setType, "zoom"_s, MediaConstraintType::Zoom, constraintSet.zoom);
+
     set(result, setType, "whiteBalanceMode"_s, MediaConstraintType::WhiteBalanceMode, constraintSet.whiteBalanceMode);
+    set(result, setType, "zoom"_s, MediaConstraintType::Zoom, constraintSet.zoom);
+    set(result, setType, "torch"_s, MediaConstraintType::Torch, constraintSet.torch);
+
     return result;
 }
 

Source/WebCore/Modules/mediastream/MediaTrackConstraints.h

@@ -67,7 +67,6 @@ struct MediaTrackConstraintSet {
     std::optional<ConstrainDouble> aspectRatio;
     std::optional<ConstrainDouble> frameRate;
     std::optional<ConstrainDOMString> facingMode;
-    std::optional<ConstrainDOMString> whiteBalanceMode;
     std::optional<ConstrainDouble> volume;
     std::optional<ConstrainLong> sampleRate;
     std::optional<ConstrainLong> sampleSize;
@@ -76,7 +75,10 @@ struct MediaTrackConstraintSet {
     std::optional<ConstrainDOMString> groupId;
     std::optional<ConstrainDOMString> displaySurface;
     std::optional<ConstrainBoolean> logicalSurface;
+
+    std::optional<ConstrainDOMString> whiteBalanceMode;
     std::optional<ConstrainDouble> zoom;
+    std::optional<ConstrainBoolean> torch;
 };
 
 struct MediaTrackConstraints : MediaTrackConstraintSet {

Source/WebCore/Modules/mediastream/MediaTrackConstraints.idl

@@ -49,8 +49,27 @@
     ConstrainDOMString groupId;
     ConstrainDOMString displaySurface;
     ConstrainBoolean logicalSurface;
-    ConstrainDouble zoom;
+
     ConstrainDOMString whiteBalanceMode;
+    // FIXME: add exposureMode;
+    // FIXME: add focusMode;
+    // FIXME: add pointsOfInterest;
+
+    // FIXME: add exposureCompensation;
+    // FIXME: add exposureTime;
+    // FIXME: add colorTemperature;
+    // FIXME: add iso;
+
+    // FIXME: add brightness;
+    // FIXME: add contrast;
+    // FIXME: add saturation;
+    // FIXME: add sharpness;
+
+    // FIXME: add focusDistance;
+    ConstrainDouble zoom;
+
+    ConstrainBoolean torch;
+
 };
 
 typedef (double or ConstrainDoubleRange) ConstrainDouble;

Source/WebCore/Modules/mediastream/MediaTrackSupportedConstraints.h

@@ -47,8 +47,9 @@ struct MediaTrackSupportedConstraints {
     bool deviceId;
     bool groupId;
     bool displaySurface;
-    bool zoom;
     bool whiteBalanceMode;
+    bool zoom;
+    bool torch;
 };
 
 } // namespace WebCore

Source/WebCore/Modules/mediastream/MediaTrackSupportedConstraints.idl

@@ -46,6 +46,23 @@
     boolean deviceId = true;
     boolean groupId = true;
     boolean displaySurface = true;
-    boolean zoom = true;
+
     boolean whiteBalanceMode = true;
+    // FIXME: add exposureMode
+    // FIXME: add focusMode
+    // FIXME: add pointsOfInterest
+
+    // FIXME: add exposureCompensation
+    // FIXME: add exposureTime
+    // FIXME: add colorTemperature
+    // FIXME: add iso
+
+    // FIXME: add brightness
+    // FIXME: add contrast
+    // FIXME: add saturation
+    // FIXME: add sharpness
+    // FIXME: add focusDistance
+    boolean zoom = true;
+    boolean torch = true;
+
 };

Source/WebCore/PAL/pal/cocoa/AVFoundationSoftLink.h

@@ -384,4 +384,7 @@ SOFT_LINK_CONSTANT_FOR_HEADER(PAL, AVFoundation, AVSpeechSynthesisAvailableVoice
 #define AVSpeechSynthesisAvailableVoicesDidChangeNotification PAL::get_AVFoundation_AVSpeechSynthesisAvailableVoicesDidChangeNotification()
 #endif // HAVE(AVSPEECHSYNTHESIS_VOICES_CHANGE_NOTIFICATION)
 
+SOFT_LINK_CONSTANT_FOR_HEADER(PAL, AVFoundation, AVCaptureMaxAvailableTorchLevel, float)
+#define AVCaptureMaxAvailableTorchLevel PAL::get_AVFoundation_AVCaptureMaxAvailableTorchLevel()
+
 #endif // USE(AVFOUNDATION)

Source/WebCore/PAL/pal/cocoa/AVFoundationSoftLink.mm

@@ -277,4 +277,6 @@ static BOOL justReturnsNO()
 SOFT_LINK_CONSTANT_FOR_SOURCE_WITH_EXPORT(PAL, AVFoundation, AVAudioSessionPortCarAudio, NSString *, PAL_EXPORT)
 #endif // HAVE(AVAUDIOSESSION)
 
+SOFT_LINK_CONSTANT_FOR_SOURCE_WITH_EXPORT(PAL, AVFoundation, AVCaptureMaxAvailableTorchLevel, float, PAL_EXPORT)
+
 #endif // USE(AVFOUNDATION)

Source/WebCore/platform/mediastream/MediaConstraints.cpp

@@ -201,8 +201,6 @@ void MediaTrackConstraintSetMap::filter(const Function<bool(const MediaConstrain
 
     if (m_aspectRatio && !m_aspectRatio->isEmpty() && callback(*m_aspectRatio))
         return;
-    if (m_zoom && !m_zoom->isEmpty() && callback(*m_zoom))
-        return;
     if (m_frameRate && !m_frameRate->isEmpty() && callback(*m_frameRate))
         return;
     if (m_volume && !m_volume->isEmpty() && callback(*m_volume))
@@ -213,12 +211,17 @@ void MediaTrackConstraintSetMap::filter(const Function<bool(const MediaConstrain
 
     if (m_facingMode && !m_facingMode->isEmpty() && callback(*m_facingMode))
         return;
-    if (m_whiteBalanceMode && !m_whiteBalanceMode->isEmpty() && callback(*m_whiteBalanceMode))
-        return;
     if (m_deviceId && !m_deviceId->isEmpty() && callback(*m_deviceId))
         return;
     if (m_groupId && !m_groupId->isEmpty() && callback(*m_groupId))
         return;
+
+    if (m_whiteBalanceMode && !m_whiteBalanceMode->isEmpty() && callback(*m_whiteBalanceMode))
+        return;
+    if (m_zoom && !m_zoom->isEmpty() && callback(*m_zoom))
+        return;
+    if (m_torch && !m_torch->isEmpty() && callback(*m_torch))
+        return;
 }
 
 void MediaTrackConstraintSetMap::set(MediaConstraintType constraintType, std::optional<IntConstraint>&& constraint)
@@ -247,8 +250,9 @@ void MediaTrackConstraintSetMap::set(MediaConstraintType constraintType, std::op
     case MediaConstraintType::DisplaySurface:
     case MediaConstraintType::LogicalSurface:
     case MediaConstraintType::FocusDistance:
-    case MediaConstraintType::Zoom:
     case MediaConstraintType::WhiteBalanceMode:
+    case MediaConstraintType::Zoom:
+    case MediaConstraintType::Torch:
     case MediaConstraintType::Unknown:
         ASSERT_NOT_REACHED();
         break;
@@ -283,6 +287,7 @@ void MediaTrackConstraintSetMap::set(MediaConstraintType constraintType, std::op
     case MediaConstraintType::LogicalSurface:
     case MediaConstraintType::FocusDistance:
     case MediaConstraintType::WhiteBalanceMode:
+    case MediaConstraintType::Torch:
     case MediaConstraintType::Unknown:
         ASSERT_NOT_REACHED();
         break;
@@ -302,6 +307,10 @@ void MediaTrackConstraintSetMap::set(MediaConstraintType constraintType, std::op
         m_logicalSurface = WTFMove(constraint);
         break;
 
+    case MediaConstraintType::Torch:
+        m_torch = WTFMove(constraint);
+        break;
+
     case MediaConstraintType::Width:
     case MediaConstraintType::Height:
     case MediaConstraintType::SampleRate:
@@ -327,9 +336,6 @@ void MediaTrackConstraintSetMap::set(MediaConstraintType constraintType, std::op
     case MediaConstraintType::FacingMode:
         m_facingMode = WTFMove(constraint);
         break;
-    case MediaConstraintType::WhiteBalanceMode:
-        m_whiteBalanceMode = WTFMove(constraint);
-        break;
     case MediaConstraintType::DeviceId:
         if (constraint)
             constraint->removeEmptyStringConstraint();
@@ -338,6 +344,9 @@ void MediaTrackConstraintSetMap::set(MediaConstraintType constraintType, std::op
     case MediaConstraintType::GroupId:
         m_groupId = WTFMove(constraint);
         break;
+    case MediaConstraintType::WhiteBalanceMode:
+        m_whiteBalanceMode = WTFMove(constraint);
+        break;
 
     case MediaConstraintType::Width:
     case MediaConstraintType::Height:
@@ -351,6 +360,7 @@ void MediaTrackConstraintSetMap::set(MediaConstraintType constraintType, std::op
     case MediaConstraintType::LogicalSurface:
     case MediaConstraintType::FocusDistance:
     case MediaConstraintType::Zoom:
+    case MediaConstraintType::Torch:
     case MediaConstraintType::Unknown:
         ASSERT_NOT_REACHED();
         break;