| /* |
| * Copyright (C) 2012 Google Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * 3. Neither the name of Google Inc. nor the names of its contributors |
| * may be used to endorse or promote products derived from this |
| * software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "modules/mediastream/MediaConstraintsImpl.h" |
| |
| #include "bindings/core/v8/ArrayValue.h" |
| #include "bindings/core/v8/Dictionary.h" |
| #include "bindings/core/v8/ExceptionState.h" |
| #include "core/dom/ExecutionContext.h" |
| #include "core/frame/UseCounter.h" |
| #include "core/inspector/ConsoleMessage.h" |
| #include "modules/mediastream/MediaTrackConstraints.h" |
| #include "platform/runtime_enabled_features.h" |
| #include "platform/wtf/Assertions.h" |
| #include "platform/wtf/HashMap.h" |
| #include "platform/wtf/Vector.h" |
| #include "platform/wtf/text/StringHash.h" |
| |
| namespace blink { |
| |
| namespace MediaConstraintsImpl { |
| |
| // A naked value is treated as an "ideal" value in the basic constraints, |
| // but as an exact value in "advanced" constraints. |
| // https://w3c.github.io/mediacapture-main/#constrainable-interface |
| enum class NakedValueDisposition { kTreatAsIdeal, kTreatAsExact }; |
| |
| // Old type/value form of constraint. Used in parsing old-style constraints. |
| struct NameValueStringConstraint { |
| NameValueStringConstraint() = default; |
| |
| NameValueStringConstraint(WebString name, WebString value) |
| : name_(name), value_(value) {} |
| |
| WebString name_; |
| WebString value_; |
| }; |
| |
| // Legal constraint names. |
| // Temporary Note: Comments about source are where they are copied from. |
| // Once the chrome parts use the new-style constraint values, they will |
| // be deleted from the files mentioned. |
| // TODO(hta): remove comments before https://crbug.com/543997 is closed. |
| |
| // From content/renderer/media/stream/media_stream_video_source.cc |
| const char kMinAspectRatio[] = "minAspectRatio"; |
| const char kMaxAspectRatio[] = "maxAspectRatio"; |
| const char kMaxWidth[] = "maxWidth"; |
| const char kMinWidth[] = "minWidth"; |
| const char kMaxHeight[] = "maxHeight"; |
| const char kMinHeight[] = "minHeight"; |
| const char kMaxFrameRate[] = "maxFrameRate"; |
| const char kMinFrameRate[] = "minFrameRate"; |
| // From content/common/media/media_stream_options.cc |
| const char kMediaStreamSource[] = "chromeMediaSource"; |
| const char kMediaStreamSourceId[] = |
| "chromeMediaSourceId"; // mapped to deviceId |
| const char kMediaStreamSourceInfoId[] = "sourceId"; // mapped to deviceId |
| const char kMediaStreamRenderToAssociatedSink[] = |
| "chromeRenderToAssociatedSink"; |
| // RenderToAssociatedSink will be going away in M50-M60 some time. |
| const char kMediaStreamAudioHotword[] = "googHotword"; |
| // TODO(hta): googHotword should go away. https://crbug.com/577627 |
| // From content/renderer/media/stream/media_stream_audio_processor_options.cc |
| const char kEchoCancellation[] = "echoCancellation"; |
| const char kDisableLocalEcho[] = "disableLocalEcho"; |
| const char kGoogEchoCancellation[] = "googEchoCancellation"; |
| const char kGoogExperimentalEchoCancellation[] = "googEchoCancellation2"; |
| const char kGoogAutoGainControl[] = "googAutoGainControl"; |
| const char kGoogExperimentalAutoGainControl[] = "googAutoGainControl2"; |
| const char kGoogNoiseSuppression[] = "googNoiseSuppression"; |
| const char kGoogExperimentalNoiseSuppression[] = "googNoiseSuppression2"; |
| const char kGoogBeamforming[] = "googBeamforming"; |
| const char kGoogArrayGeometry[] = "googArrayGeometry"; |
| const char kGoogHighpassFilter[] = "googHighpassFilter"; |
| const char kGoogTypingNoiseDetection[] = "googTypingNoiseDetection"; |
| const char kGoogAudioMirroring[] = "googAudioMirroring"; |
| |
| // From |
| // third_party/libjingle/source/talk/app/webrtc/mediaconstraintsinterface.cc |
| |
| // Audio constraints. |
| const char kDAEchoCancellation[] = "googDAEchoCancellation"; |
| |
| // Google-specific constraint keys for a local video source (getUserMedia). |
| const char kNoiseReduction[] = "googNoiseReduction"; |
| |
| // Constraint keys for CreateOffer / CreateAnswer defined in W3C specification. |
| const char kOfferToReceiveAudio[] = "OfferToReceiveAudio"; |
| const char kOfferToReceiveVideo[] = "OfferToReceiveVideo"; |
| const char kVoiceActivityDetection[] = "VoiceActivityDetection"; |
| const char kIceRestart[] = "IceRestart"; |
| // Google specific constraint for BUNDLE enable/disable. |
| const char kUseRtpMux[] = "googUseRtpMUX"; |
| // Below constraints should be used during PeerConnection construction. |
| const char kEnableDtlsSrtp[] = "DtlsSrtpKeyAgreement"; |
| const char kEnableRtpDataChannels[] = "RtpDataChannels"; |
| // Google-specific constraint keys. |
| // TODO(hta): These need to be made standard or deleted. crbug.com/605673 |
| const char kEnableDscp[] = "googDscp"; |
| const char kEnableIPv6[] = "googIPv6"; |
| const char kEnableVideoSuspendBelowMinBitrate[] = "googSuspendBelowMinBitrate"; |
| const char kNumUnsignalledRecvStreams[] = "googNumUnsignalledRecvStreams"; |
| const char kCombinedAudioVideoBwe[] = "googCombinedAudioVideoBwe"; |
| const char kScreencastMinBitrate[] = "googScreencastMinBitrate"; |
| const char kCpuOveruseDetection[] = "googCpuOveruseDetection"; |
| const char kCpuUnderuseThreshold[] = "googCpuUnderuseThreshold"; |
| const char kCpuOveruseThreshold[] = "googCpuOveruseThreshold"; |
| const char kCpuUnderuseEncodeRsdThreshold[] = |
| "googCpuUnderuseEncodeRsdThreshold"; |
| const char kCpuOveruseEncodeRsdThreshold[] = "googCpuOveruseEncodeRsdThreshold"; |
| const char kCpuOveruseEncodeUsage[] = "googCpuOveruseEncodeUsage"; |
| const char kHighStartBitrate[] = "googHighStartBitrate"; |
| const char kPayloadPadding[] = "googPayloadPadding"; |
| // From webrtc_audio_capturer |
| const char kAudioLatency[] = "latencyMs"; |
| // From media_stream_video_capturer_source |
| |
| // End of names from libjingle |
| // Names that have been used in the past, but should now be ignored. |
| // Kept around for backwards compatibility. |
| // https://crbug.com/579729 |
| const char kGoogLeakyBucket[] = "googLeakyBucket"; |
| const char kPowerLineFrequency[] = "googPowerLineFrequency"; |
| // mediacapture-depth: videoKind key and VideoKindEnum values. |
| const char kVideoKind[] = "videoKind"; |
| const char kVideoKindColor[] = "color"; |
| const char kVideoKindDepth[] = "depth"; |
| // Names used for testing. |
| const char kTestConstraint1[] = "valid_and_supported_1"; |
| const char kTestConstraint2[] = "valid_and_supported_2"; |
| |
| static bool ParseMandatoryConstraintsDictionary( |
| const Dictionary& mandatory_constraints_dictionary, |
| Vector<NameValueStringConstraint>& mandatory) { |
| DummyExceptionStateForTesting exception_state; |
| const HashMap<String, String>& mandatory_constraints_hash_map = |
| mandatory_constraints_dictionary.GetOwnPropertiesAsStringHashMap( |
| exception_state); |
| if (exception_state.HadException()) |
| return false; |
| |
| for (const auto& iter : mandatory_constraints_hash_map) |
| mandatory.push_back(NameValueStringConstraint(iter.key, iter.value)); |
| return true; |
| } |
| |
| static bool ParseOptionalConstraintsVectorElement( |
| const Dictionary& constraint, |
| Vector<NameValueStringConstraint>& optional_constraints_vector) { |
| DummyExceptionStateForTesting exception_state; |
| const Vector<String>& local_names = |
| constraint.GetPropertyNames(exception_state); |
| if (exception_state.HadException()) |
| return false; |
| if (local_names.size() != 1) |
| return false; |
| const String& key = local_names[0]; |
| String value; |
| bool ok = DictionaryHelper::Get(constraint, key, value); |
| if (!ok) |
| return false; |
| optional_constraints_vector.push_back(NameValueStringConstraint(key, value)); |
| return true; |
| } |
| |
| // Old style parser. Deprecated. |
| static bool Parse(const Dictionary& constraints_dictionary, |
| Vector<NameValueStringConstraint>& optional, |
| Vector<NameValueStringConstraint>& mandatory) { |
| if (constraints_dictionary.IsUndefinedOrNull()) |
| return true; |
| |
| DummyExceptionStateForTesting exception_state; |
| const Vector<String>& names = |
| constraints_dictionary.GetPropertyNames(exception_state); |
| if (exception_state.HadException()) |
| return false; |
| |
| String mandatory_name("mandatory"); |
| String optional_name("optional"); |
| |
| for (const auto& name : names) { |
| if (name != mandatory_name && name != optional_name) |
| return false; |
| } |
| |
| if (names.Contains(mandatory_name)) { |
| Dictionary mandatory_constraints_dictionary; |
| bool ok = constraints_dictionary.Get(mandatory_name, |
| mandatory_constraints_dictionary); |
| if (!ok || mandatory_constraints_dictionary.IsUndefinedOrNull()) |
| return false; |
| ok = ParseMandatoryConstraintsDictionary(mandatory_constraints_dictionary, |
| mandatory); |
| if (!ok) |
| return false; |
| } |
| |
| if (names.Contains(optional_name)) { |
| ArrayValue optional_constraints; |
| bool ok = DictionaryHelper::Get(constraints_dictionary, optional_name, |
| optional_constraints); |
| if (!ok || optional_constraints.IsUndefinedOrNull()) |
| return false; |
| |
| size_t number_of_constraints; |
| ok = optional_constraints.length(number_of_constraints); |
| if (!ok) |
| return false; |
| |
| for (size_t i = 0; i < number_of_constraints; ++i) { |
| Dictionary constraint; |
| ok = optional_constraints.Get(i, constraint); |
| if (!ok || constraint.IsUndefinedOrNull()) |
| return false; |
| ok = ParseOptionalConstraintsVectorElement(constraint, optional); |
| if (!ok) |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| static bool Parse(const MediaTrackConstraints& constraints_in, |
| Vector<NameValueStringConstraint>& optional, |
| Vector<NameValueStringConstraint>& mandatory) { |
| Vector<NameValueStringConstraint> mandatory_constraints_vector; |
| if (constraints_in.hasMandatory()) { |
| bool ok = ParseMandatoryConstraintsDictionary(constraints_in.mandatory(), |
| mandatory); |
| if (!ok) |
| return false; |
| } |
| |
| if (constraints_in.hasOptional()) { |
| const Vector<Dictionary>& optional_constraints = constraints_in.optional(); |
| |
| for (const auto& constraint : optional_constraints) { |
| if (constraint.IsUndefinedOrNull()) |
| return false; |
| bool ok = ParseOptionalConstraintsVectorElement(constraint, optional); |
| if (!ok) |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| static bool ToBoolean(const WebString& as_web_string) { |
| return as_web_string.Equals("true"); |
| // TODO(hta): Check against "false" and return error if it's neither. |
| // https://crbug.com/576582 |
| } |
| |
| static void ParseOldStyleNames( |
| ExecutionContext* context, |
| const Vector<NameValueStringConstraint>& old_names, |
| bool report_unknown_names, |
| WebMediaTrackConstraintSet& result, |
| MediaErrorState& error_state) { |
| for (const NameValueStringConstraint& constraint : old_names) { |
| if (constraint.name_.Equals(kMinAspectRatio)) { |
| result.aspect_ratio.SetMin(atof(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kMaxAspectRatio)) { |
| result.aspect_ratio.SetMax(atof(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kMaxWidth)) { |
| result.width.SetMax(atoi(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kMinWidth)) { |
| result.width.SetMin(atoi(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kMaxHeight)) { |
| result.height.SetMax(atoi(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kMinHeight)) { |
| result.height.SetMin(atoi(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kMinFrameRate)) { |
| result.frame_rate.SetMin(atof(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kMaxFrameRate)) { |
| result.frame_rate.SetMax(atof(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kEchoCancellation)) { |
| result.echo_cancellation.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kMediaStreamSource)) { |
| // TODO(hta): This has only a few legal values. Should be |
| // represented as an enum, and cause type errors. |
| // https://crbug.com/576582 |
| result.media_stream_source.SetExact(constraint.value_); |
| } else if (constraint.name_.Equals(kDisableLocalEcho) && |
| RuntimeEnabledFeatures:: |
| DesktopCaptureDisableLocalEchoControlEnabled()) { |
| result.disable_local_echo.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kMediaStreamSourceId) || |
| constraint.name_.Equals(kMediaStreamSourceInfoId)) { |
| result.device_id.SetExact(constraint.value_); |
| } else if (constraint.name_.Equals(kMediaStreamRenderToAssociatedSink)) { |
| // TODO(hta): This is a boolean represented as string. |
| // Should give TypeError when it's not parseable. |
| // https://crbug.com/576582 |
| result.render_to_associated_sink.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kMediaStreamAudioHotword)) { |
| result.hotword_enabled.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kGoogEchoCancellation)) { |
| result.goog_echo_cancellation.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kGoogExperimentalEchoCancellation)) { |
| result.goog_experimental_echo_cancellation.SetExact( |
| ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kGoogAutoGainControl)) { |
| result.goog_auto_gain_control.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kGoogExperimentalAutoGainControl)) { |
| result.goog_experimental_auto_gain_control.SetExact( |
| ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kGoogNoiseSuppression)) { |
| result.goog_noise_suppression.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kGoogExperimentalNoiseSuppression)) { |
| result.goog_experimental_noise_suppression.SetExact( |
| ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kGoogBeamforming)) { |
| result.goog_beamforming.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kGoogArrayGeometry)) { |
| result.goog_array_geometry.SetExact(constraint.value_); |
| } else if (constraint.name_.Equals(kGoogHighpassFilter)) { |
| result.goog_highpass_filter.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kGoogTypingNoiseDetection)) { |
| result.goog_typing_noise_detection.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kGoogAudioMirroring)) { |
| result.goog_audio_mirroring.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kDAEchoCancellation)) { |
| result.goog_da_echo_cancellation.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kNoiseReduction)) { |
| result.goog_noise_reduction.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kOfferToReceiveAudio)) { |
| // This constraint has formerly been defined both as a boolean |
| // and as an integer. Allow both forms. |
| if (constraint.value_.Equals("true")) |
| result.offer_to_receive_audio.SetExact(1); |
| else if (constraint.value_.Equals("false")) |
| result.offer_to_receive_audio.SetExact(0); |
| else |
| result.offer_to_receive_audio.SetExact( |
| atoi(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kOfferToReceiveVideo)) { |
| // This constraint has formerly been defined both as a boolean |
| // and as an integer. Allow both forms. |
| if (constraint.value_.Equals("true")) |
| result.offer_to_receive_video.SetExact(1); |
| else if (constraint.value_.Equals("false")) |
| result.offer_to_receive_video.SetExact(0); |
| else |
| result.offer_to_receive_video.SetExact( |
| atoi(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kVoiceActivityDetection)) { |
| result.voice_activity_detection.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kIceRestart)) { |
| result.ice_restart.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kUseRtpMux)) { |
| result.goog_use_rtp_mux.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kEnableDtlsSrtp)) { |
| bool value = ToBoolean(constraint.value_); |
| if (value) { |
| UseCounter::Count(context, |
| WebFeature::kRTCConstraintEnableDtlsSrtpTrue); |
| } else { |
| UseCounter::Count(context, |
| WebFeature::kRTCConstraintEnableDtlsSrtpFalse); |
| } |
| result.enable_dtls_srtp.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kEnableRtpDataChannels)) { |
| result.enable_rtp_data_channels.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kEnableDscp)) { |
| result.enable_dscp.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kEnableIPv6)) { |
| result.enable_i_pv6.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kEnableVideoSuspendBelowMinBitrate)) { |
| result.goog_enable_video_suspend_below_min_bitrate.SetExact( |
| ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kNumUnsignalledRecvStreams)) { |
| result.goog_num_unsignalled_recv_streams.SetExact( |
| atoi(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kCombinedAudioVideoBwe)) { |
| result.goog_combined_audio_video_bwe.SetExact( |
| ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kScreencastMinBitrate)) { |
| result.goog_screencast_min_bitrate.SetExact( |
| atoi(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kCpuOveruseDetection)) { |
| result.goog_cpu_overuse_detection.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kCpuUnderuseThreshold)) { |
| result.goog_cpu_underuse_threshold.SetExact( |
| atoi(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kCpuOveruseThreshold)) { |
| result.goog_cpu_overuse_threshold.SetExact( |
| atoi(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kCpuUnderuseEncodeRsdThreshold)) { |
| result.goog_cpu_underuse_encode_rsd_threshold.SetExact( |
| atoi(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kCpuOveruseEncodeRsdThreshold)) { |
| result.goog_cpu_overuse_encode_rsd_threshold.SetExact( |
| atoi(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kCpuOveruseEncodeUsage)) { |
| result.goog_cpu_overuse_encode_usage.SetExact( |
| ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kHighStartBitrate)) { |
| result.goog_high_start_bitrate.SetExact( |
| atoi(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kPayloadPadding)) { |
| result.goog_payload_padding.SetExact(ToBoolean(constraint.value_)); |
| } else if (constraint.name_.Equals(kAudioLatency)) { |
| result.goog_latency_ms.SetExact(atoi(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kPowerLineFrequency)) { |
| result.goog_power_line_frequency.SetExact( |
| atoi(constraint.value_.Utf8().c_str())); |
| } else if (constraint.name_.Equals(kGoogLeakyBucket)) { |
| context->AddConsoleMessage(ConsoleMessage::Create( |
| kDeprecationMessageSource, kWarningMessageLevel, |
| "Obsolete constraint named " + String(constraint.name_) + |
| " is ignored. Please stop using it.")); |
| } else if (constraint.name_.Equals(kVideoKind)) { |
| if (!constraint.value_.Equals(kVideoKindColor) && |
| !constraint.value_.Equals(kVideoKindDepth)) { |
| error_state.ThrowConstraintError("Illegal value for constraint", |
| constraint.name_); |
| } else { |
| result.video_kind.SetExact(constraint.value_); |
| } |
| } else if (constraint.name_.Equals(kTestConstraint1) || |
| constraint.name_.Equals(kTestConstraint2)) { |
| // These constraints are only for testing parsing. |
| // Values 0 and 1 are legal, all others are a ConstraintError. |
| if (!constraint.value_.Equals("0") && !constraint.value_.Equals("1")) { |
| error_state.ThrowConstraintError("Illegal value for constraint", |
| constraint.name_); |
| } |
| } else { |
| if (report_unknown_names) { |
| // TODO(hta): UMA stats for unknown constraints passed. |
| // https://crbug.com/576613 |
| context->AddConsoleMessage(ConsoleMessage::Create( |
| kDeprecationMessageSource, kWarningMessageLevel, |
| "Unknown constraint named " + String(constraint.name_) + |
| " rejected")); |
| error_state.ThrowConstraintError("Unknown name of constraint detected", |
| constraint.name_); |
| } |
| } |
| } |
| } |
| |
| static WebMediaConstraints CreateFromNamedConstraints( |
| ExecutionContext* context, |
| Vector<NameValueStringConstraint>& mandatory, |
| const Vector<NameValueStringConstraint>& optional, |
| MediaErrorState& error_state) { |
| WebMediaTrackConstraintSet basic; |
| WebMediaTrackConstraintSet advanced; |
| WebMediaConstraints constraints; |
| ParseOldStyleNames(context, mandatory, true, basic, error_state); |
| if (error_state.HadException()) |
| return constraints; |
| // We ignore unknow names and syntax errors in optional constraints. |
| MediaErrorState ignored_error_state; |
| Vector<WebMediaTrackConstraintSet> advanced_vector; |
| for (const auto& optional_constraint : optional) { |
| WebMediaTrackConstraintSet advanced_element; |
| Vector<NameValueStringConstraint> element_as_list(1, optional_constraint); |
| ParseOldStyleNames(context, element_as_list, false, advanced_element, |
| ignored_error_state); |
| if (!advanced_element.IsEmpty()) |
| advanced_vector.push_back(advanced_element); |
| } |
| constraints.Initialize(basic, advanced_vector); |
| return constraints; |
| } |
| |
| // Deprecated. |
| WebMediaConstraints Create(ExecutionContext* context, |
| const Dictionary& constraints_dictionary, |
| MediaErrorState& error_state) { |
| Vector<NameValueStringConstraint> optional; |
| Vector<NameValueStringConstraint> mandatory; |
| if (!Parse(constraints_dictionary, optional, mandatory)) { |
| error_state.ThrowTypeError("Malformed constraints object."); |
| return WebMediaConstraints(); |
| } |
| UseCounter::Count(context, WebFeature::kMediaStreamConstraintsFromDictionary); |
| return CreateFromNamedConstraints(context, mandatory, optional, error_state); |
| } |
| |
| void CopyLongConstraint(const LongOrConstrainLongRange& blink_union_form, |
| NakedValueDisposition naked_treatment, |
| LongConstraint& web_form) { |
| if (blink_union_form.IsLong()) { |
| switch (naked_treatment) { |
| case NakedValueDisposition::kTreatAsIdeal: |
| web_form.SetIdeal(blink_union_form.GetAsLong()); |
| break; |
| case NakedValueDisposition::kTreatAsExact: |
| web_form.SetExact(blink_union_form.GetAsLong()); |
| break; |
| } |
| return; |
| } |
| const auto& blink_form = blink_union_form.GetAsConstrainLongRange(); |
| if (blink_form.hasMin()) { |
| web_form.SetMin(blink_form.min()); |
| } |
| if (blink_form.hasMax()) { |
| web_form.SetMax(blink_form.max()); |
| } |
| if (blink_form.hasIdeal()) { |
| web_form.SetIdeal(blink_form.ideal()); |
| } |
| if (blink_form.hasExact()) { |
| web_form.SetExact(blink_form.exact()); |
| } |
| } |
| |
| void CopyDoubleConstraint(const DoubleOrConstrainDoubleRange& blink_union_form, |
| NakedValueDisposition naked_treatment, |
| DoubleConstraint& web_form) { |
| if (blink_union_form.IsDouble()) { |
| switch (naked_treatment) { |
| case NakedValueDisposition::kTreatAsIdeal: |
| web_form.SetIdeal(blink_union_form.GetAsDouble()); |
| break; |
| case NakedValueDisposition::kTreatAsExact: |
| web_form.SetExact(blink_union_form.GetAsDouble()); |
| break; |
| } |
| return; |
| } |
| const auto& blink_form = blink_union_form.GetAsConstrainDoubleRange(); |
| if (blink_form.hasMin()) { |
| web_form.SetMin(blink_form.min()); |
| } |
| if (blink_form.hasMax()) { |
| web_form.SetMax(blink_form.max()); |
| } |
| if (blink_form.hasIdeal()) { |
| web_form.SetIdeal(blink_form.ideal()); |
| } |
| if (blink_form.hasExact()) { |
| web_form.SetExact(blink_form.exact()); |
| } |
| } |
| |
| void CopyStringConstraint( |
| const StringOrStringSequenceOrConstrainDOMStringParameters& |
| blink_union_form, |
| NakedValueDisposition naked_treatment, |
| StringConstraint& web_form) { |
| if (blink_union_form.IsString()) { |
| switch (naked_treatment) { |
| case NakedValueDisposition::kTreatAsIdeal: |
| web_form.SetIdeal(Vector<String>(1, blink_union_form.GetAsString())); |
| break; |
| case NakedValueDisposition::kTreatAsExact: |
| web_form.SetExact(Vector<String>(1, blink_union_form.GetAsString())); |
| |
| break; |
| } |
| return; |
| } |
| if (blink_union_form.IsStringSequence()) { |
| switch (naked_treatment) { |
| case NakedValueDisposition::kTreatAsIdeal: |
| web_form.SetIdeal(blink_union_form.GetAsStringSequence()); |
| break; |
| case NakedValueDisposition::kTreatAsExact: |
| web_form.SetExact(blink_union_form.GetAsStringSequence()); |
| break; |
| } |
| return; |
| } |
| const auto& blink_form = blink_union_form.GetAsConstrainDOMStringParameters(); |
| if (blink_form.hasIdeal()) { |
| if (blink_form.ideal().IsStringSequence()) { |
| web_form.SetIdeal(blink_form.ideal().GetAsStringSequence()); |
| } else if (blink_form.ideal().IsString()) { |
| web_form.SetIdeal(Vector<String>(1, blink_form.ideal().GetAsString())); |
| } |
| } |
| if (blink_form.hasExact()) { |
| if (blink_form.exact().IsStringSequence()) { |
| web_form.SetExact(blink_form.exact().GetAsStringSequence()); |
| } else if (blink_form.exact().IsString()) { |
| web_form.SetExact(Vector<String>(1, blink_form.exact().GetAsString())); |
| } |
| } |
| } |
| |
| void CopyBooleanConstraint( |
| const BooleanOrConstrainBooleanParameters& blink_union_form, |
| NakedValueDisposition naked_treatment, |
| BooleanConstraint& web_form) { |
| if (blink_union_form.IsBoolean()) { |
| switch (naked_treatment) { |
| case NakedValueDisposition::kTreatAsIdeal: |
| web_form.SetIdeal(blink_union_form.GetAsBoolean()); |
| break; |
| case NakedValueDisposition::kTreatAsExact: |
| web_form.SetExact(blink_union_form.GetAsBoolean()); |
| break; |
| } |
| return; |
| } |
| const auto& blink_form = blink_union_form.GetAsConstrainBooleanParameters(); |
| if (blink_form.hasIdeal()) { |
| web_form.SetIdeal(blink_form.ideal()); |
| } |
| if (blink_form.hasExact()) { |
| web_form.SetExact(blink_form.exact()); |
| } |
| } |
| |
| void CopyConstraintSet(const MediaTrackConstraintSet& constraints_in, |
| NakedValueDisposition naked_treatment, |
| WebMediaTrackConstraintSet& constraint_buffer) { |
| if (constraints_in.hasWidth()) { |
| CopyLongConstraint(constraints_in.width(), naked_treatment, |
| constraint_buffer.width); |
| } |
| if (constraints_in.hasHeight()) { |
| CopyLongConstraint(constraints_in.height(), naked_treatment, |
| constraint_buffer.height); |
| } |
| if (constraints_in.hasAspectRatio()) { |
| CopyDoubleConstraint(constraints_in.aspectRatio(), naked_treatment, |
| constraint_buffer.aspect_ratio); |
| } |
| if (constraints_in.hasFrameRate()) { |
| CopyDoubleConstraint(constraints_in.frameRate(), naked_treatment, |
| constraint_buffer.frame_rate); |
| } |
| if (constraints_in.hasFacingMode()) { |
| CopyStringConstraint(constraints_in.facingMode(), naked_treatment, |
| constraint_buffer.facing_mode); |
| } |
| if (constraints_in.hasVolume()) { |
| CopyDoubleConstraint(constraints_in.volume(), naked_treatment, |
| constraint_buffer.volume); |
| } |
| if (constraints_in.hasSampleRate()) { |
| CopyLongConstraint(constraints_in.sampleRate(), naked_treatment, |
| constraint_buffer.sample_rate); |
| } |
| if (constraints_in.hasSampleSize()) { |
| CopyLongConstraint(constraints_in.sampleSize(), naked_treatment, |
| constraint_buffer.sample_size); |
| } |
| if (constraints_in.hasEchoCancellation()) { |
| CopyBooleanConstraint(constraints_in.echoCancellation(), naked_treatment, |
| constraint_buffer.echo_cancellation); |
| } |
| if (constraints_in.hasLatency()) { |
| CopyDoubleConstraint(constraints_in.latency(), naked_treatment, |
| constraint_buffer.latency); |
| } |
| if (constraints_in.hasChannelCount()) { |
| CopyLongConstraint(constraints_in.channelCount(), naked_treatment, |
| constraint_buffer.channel_count); |
| } |
| if (constraints_in.hasDeviceId()) { |
| CopyStringConstraint(constraints_in.deviceId(), naked_treatment, |
| constraint_buffer.device_id); |
| } |
| if (constraints_in.hasGroupId()) { |
| CopyStringConstraint(constraints_in.groupId(), naked_treatment, |
| constraint_buffer.group_id); |
| } |
| if (constraints_in.hasVideoKind()) { |
| CopyStringConstraint(constraints_in.videoKind(), naked_treatment, |
| constraint_buffer.video_kind); |
| } |
| if (constraints_in.hasDepthNear()) { |
| CopyDoubleConstraint(constraints_in.depthNear(), naked_treatment, |
| constraint_buffer.depth_near); |
| } |
| if (constraints_in.hasDepthFar()) { |
| CopyDoubleConstraint(constraints_in.depthFar(), naked_treatment, |
| constraint_buffer.depth_far); |
| } |
| if (constraints_in.hasFocalLengthX()) { |
| CopyDoubleConstraint(constraints_in.focalLengthX(), naked_treatment, |
| constraint_buffer.focal_length_x); |
| } |
| if (constraints_in.hasFocalLengthY()) { |
| CopyDoubleConstraint(constraints_in.focalLengthY(), naked_treatment, |
| constraint_buffer.focal_length_y); |
| } |
| } |
| |
| WebMediaConstraints ConvertConstraintsToWeb( |
| const MediaTrackConstraints& constraints_in) { |
| WebMediaConstraints constraints; |
| WebMediaTrackConstraintSet constraint_buffer; |
| Vector<WebMediaTrackConstraintSet> advanced_buffer; |
| CopyConstraintSet(constraints_in, NakedValueDisposition::kTreatAsIdeal, |
| constraint_buffer); |
| if (constraints_in.hasAdvanced()) { |
| for (const auto& element : constraints_in.advanced()) { |
| WebMediaTrackConstraintSet advanced_element; |
| CopyConstraintSet(element, NakedValueDisposition::kTreatAsExact, |
| advanced_element); |
| advanced_buffer.push_back(advanced_element); |
| } |
| } |
| constraints.Initialize(constraint_buffer, advanced_buffer); |
| return constraints; |
| } |
| |
| WebMediaConstraints Create(ExecutionContext* context, |
| const MediaTrackConstraints& constraints_in, |
| MediaErrorState& error_state) { |
| WebMediaConstraints standard_form = ConvertConstraintsToWeb(constraints_in); |
| if (constraints_in.hasOptional() || constraints_in.hasMandatory()) { |
| if (!standard_form.IsEmpty()) { |
| UseCounter::Count(context, WebFeature::kMediaStreamConstraintsOldAndNew); |
| error_state.ThrowTypeError( |
| "Malformed constraint: Cannot use both optional/mandatory and " |
| "specific or advanced constraints."); |
| return WebMediaConstraints(); |
| } |
| Vector<NameValueStringConstraint> optional; |
| Vector<NameValueStringConstraint> mandatory; |
| if (!Parse(constraints_in, optional, mandatory)) { |
| error_state.ThrowTypeError("Malformed constraints object."); |
| return WebMediaConstraints(); |
| } |
| UseCounter::Count(context, WebFeature::kMediaStreamConstraintsNameValue); |
| return CreateFromNamedConstraints(context, mandatory, optional, |
| error_state); |
| } |
| UseCounter::Count(context, WebFeature::kMediaStreamConstraintsConformant); |
| return standard_form; |
| } |
| |
| WebMediaConstraints Create() { |
| WebMediaConstraints constraints; |
| constraints.Initialize(); |
| return constraints; |
| } |
| |
| template <class T> |
| bool UseNakedNumeric(T input, NakedValueDisposition which) { |
| switch (which) { |
| case NakedValueDisposition::kTreatAsIdeal: |
| return input.HasIdeal() && |
| !(input.HasExact() || input.HasMin() || input.HasMax()); |
| break; |
| case NakedValueDisposition::kTreatAsExact: |
| return input.HasExact() && |
| !(input.HasIdeal() || input.HasMin() || input.HasMax()); |
| break; |
| } |
| NOTREACHED(); |
| return false; |
| }; |
| |
| template <class T> |
| bool UseNakedNonNumeric(T input, NakedValueDisposition which) { |
| switch (which) { |
| case NakedValueDisposition::kTreatAsIdeal: |
| return input.HasIdeal() && !input.HasExact(); |
| break; |
| case NakedValueDisposition::kTreatAsExact: |
| return input.HasExact() && !input.HasIdeal(); |
| break; |
| } |
| NOTREACHED(); |
| return false; |
| }; |
| |
| template <typename U, class T> |
| U GetNakedValue(T input, NakedValueDisposition which) { |
| switch (which) { |
| case NakedValueDisposition::kTreatAsIdeal: |
| return input.Ideal(); |
| break; |
| case NakedValueDisposition::kTreatAsExact: |
| return input.Exact(); |
| break; |
| } |
| NOTREACHED(); |
| return input.Exact(); |
| }; |
| |
| LongOrConstrainLongRange ConvertLong(const LongConstraint& input, |
| NakedValueDisposition naked_treatment) { |
| LongOrConstrainLongRange output_union; |
| if (UseNakedNumeric(input, naked_treatment)) { |
| output_union.SetLong(GetNakedValue<long>(input, naked_treatment)); |
| } else if (!input.IsEmpty()) { |
| ConstrainLongRange output; |
| if (input.HasExact()) |
| output.setExact(input.Exact()); |
| if (input.HasMin()) |
| output.setMin(input.Min()); |
| if (input.HasMax()) |
| output.setMax(input.Max()); |
| if (input.HasIdeal()) |
| output.setIdeal(input.Ideal()); |
| output_union.SetConstrainLongRange(output); |
| } |
| return output_union; |
| } |
| |
| DoubleOrConstrainDoubleRange ConvertDouble( |
| const DoubleConstraint& input, |
| NakedValueDisposition naked_treatment) { |
| DoubleOrConstrainDoubleRange output_union; |
| if (UseNakedNumeric(input, naked_treatment)) { |
| output_union.SetDouble(GetNakedValue<double>(input, naked_treatment)); |
| } else if (!input.IsEmpty()) { |
| ConstrainDoubleRange output; |
| if (input.HasExact()) |
| output.setExact(input.Exact()); |
| if (input.HasIdeal()) |
| output.setIdeal(input.Ideal()); |
| if (input.HasMin()) |
| output.setMin(input.Min()); |
| if (input.HasMax()) |
| output.setMax(input.Max()); |
| output_union.SetConstrainDoubleRange(output); |
| } |
| return output_union; |
| } |
| |
| StringOrStringSequence ConvertStringSequence( |
| const WebVector<WebString>& input) { |
| StringOrStringSequence the_strings; |
| if (input.size() > 1) { |
| Vector<String> buffer; |
| for (const auto& scanner : input) |
| buffer.push_back(scanner); |
| the_strings.SetStringSequence(buffer); |
| } else if (input.size() > 0) { |
| the_strings.SetString(input[0]); |
| } |
| return the_strings; |
| } |
| |
| StringOrStringSequenceOrConstrainDOMStringParameters ConvertString( |
| const StringConstraint& input, |
| NakedValueDisposition naked_treatment) { |
| StringOrStringSequenceOrConstrainDOMStringParameters output_union; |
| if (UseNakedNonNumeric(input, naked_treatment)) { |
| WebVector<WebString> input_buffer( |
| GetNakedValue<WebVector<WebString>>(input, naked_treatment)); |
| if (input_buffer.size() > 1) { |
| Vector<String> buffer; |
| for (const auto& scanner : input_buffer) |
| buffer.push_back(scanner); |
| output_union.SetStringSequence(buffer); |
| } else if (input_buffer.size() > 0) { |
| output_union.SetString(input_buffer[0]); |
| } |
| } else if (!input.IsEmpty()) { |
| ConstrainDOMStringParameters output; |
| if (input.HasExact()) |
| output.setExact(ConvertStringSequence(input.Exact())); |
| if (input.HasIdeal()) |
| output.setIdeal(ConvertStringSequence(input.Ideal())); |
| output_union.SetConstrainDOMStringParameters(output); |
| } |
| return output_union; |
| } |
| |
| BooleanOrConstrainBooleanParameters ConvertBoolean( |
| const BooleanConstraint& input, |
| NakedValueDisposition naked_treatment) { |
| BooleanOrConstrainBooleanParameters output_union; |
| if (UseNakedNonNumeric(input, naked_treatment)) { |
| output_union.SetBoolean(GetNakedValue<bool>(input, naked_treatment)); |
| } else if (!input.IsEmpty()) { |
| ConstrainBooleanParameters output; |
| if (input.HasExact()) |
| output.setExact(input.Exact()); |
| if (input.HasIdeal()) |
| output.setIdeal(input.Ideal()); |
| output_union.SetConstrainBooleanParameters(output); |
| } |
| return output_union; |
| } |
| |
| void ConvertConstraintSet(const WebMediaTrackConstraintSet& input, |
| NakedValueDisposition naked_treatment, |
| MediaTrackConstraintSet& output) { |
| if (!input.width.IsEmpty()) |
| output.setWidth(ConvertLong(input.width, naked_treatment)); |
| if (!input.height.IsEmpty()) |
| output.setHeight(ConvertLong(input.height, naked_treatment)); |
| if (!input.aspect_ratio.IsEmpty()) |
| output.setAspectRatio(ConvertDouble(input.aspect_ratio, naked_treatment)); |
| if (!input.frame_rate.IsEmpty()) |
| output.setFrameRate(ConvertDouble(input.frame_rate, naked_treatment)); |
| if (!input.facing_mode.IsEmpty()) |
| output.setFacingMode(ConvertString(input.facing_mode, naked_treatment)); |
| if (!input.volume.IsEmpty()) |
| output.setVolume(ConvertDouble(input.volume, naked_treatment)); |
| if (!input.sample_rate.IsEmpty()) |
| output.setSampleRate(ConvertLong(input.sample_rate, naked_treatment)); |
| if (!input.sample_size.IsEmpty()) |
| output.setSampleSize(ConvertLong(input.sample_size, naked_treatment)); |
| if (!input.echo_cancellation.IsEmpty()) { |
| output.setEchoCancellation( |
| ConvertBoolean(input.echo_cancellation, naked_treatment)); |
| } |
| if (!input.latency.IsEmpty()) |
| output.setLatency(ConvertDouble(input.latency, naked_treatment)); |
| if (!input.channel_count.IsEmpty()) |
| output.setChannelCount(ConvertLong(input.channel_count, naked_treatment)); |
| if (!input.device_id.IsEmpty()) |
| output.setDeviceId(ConvertString(input.device_id, naked_treatment)); |
| if (!input.group_id.IsEmpty()) |
| output.setGroupId(ConvertString(input.group_id, naked_treatment)); |
| if (!input.video_kind.IsEmpty()) |
| output.setVideoKind(ConvertString(input.video_kind, naked_treatment)); |
| // TODO(hta): Decide the future of the nonstandard constraints. |
| // If they go forward, they need to be added here. |
| // https://crbug.com/605673 |
| } |
| |
| void ConvertConstraints(const WebMediaConstraints& input, |
| MediaTrackConstraints& output) { |
| if (input.IsNull()) |
| return; |
| ConvertConstraintSet(input.Basic(), NakedValueDisposition::kTreatAsIdeal, |
| output); |
| HeapVector<MediaTrackConstraintSet> advanced_vector; |
| for (const auto& it : input.Advanced()) { |
| MediaTrackConstraintSet element; |
| ConvertConstraintSet(it, NakedValueDisposition::kTreatAsExact, element); |
| advanced_vector.push_back(element); |
| } |
| if (!advanced_vector.IsEmpty()) |
| output.setAdvanced(advanced_vector); |
| } |
| |
| } // namespace MediaConstraintsImpl |
| } // namespace blink |
