| /* |
| * 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/ExceptionCode.h" |
| #include "modules/mediastream/MediaTrackConstraintSet.h" |
| #include "platform/Logging.h" |
| #include "platform/RuntimeEnabledFeatures.h" |
| #include "wtf/HashMap.h" |
| #include "wtf/Vector.h" |
| #include "wtf/text/StringHash.h" |
| |
| namespace blink { |
| |
| namespace MediaConstraintsImpl { |
| |
| // 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/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/media_stream_audio_processor_options.cc |
| const char kEchoCancellation[] = "echoCancellation"; |
| 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 kExtendedFilterEchoCancellation[] = "googEchoCancellation2"; // duplicate k-name |
| const char kDAEchoCancellation[] = "googDAEchoCancellation"; |
| // const char kNoiseSuppression[] = "googNoiseSuppression"; // duplicate k-name |
| // const char kExperimentalNoiseSuppression[] = "googNoiseSuppression2"; // duplicate k-name |
| // const char kHighpassFilter[] = "googHighpassFilter"; // duplicate k-name |
| // const char kTypingNoiseDetection[] = "googTypingNoiseDetection"; // duplicate k-name |
| // const char kAudioMirroring[] = "googAudioMirroring"; // duplicate k-name |
| const char kAecDump[] = "audioDebugRecording"; |
| |
| // 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. |
| 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"; |
| // End of names from libjingle |
| |
| // Names used for testing. |
| const char kTestConstraint1[] = "valid_and_supported_1"; |
| const char kTestConstraint2[] = "valid_and_supported_2"; |
| |
| static bool parseMandatoryConstraintsDictionary(const Dictionary& mandatoryConstraintsDictionary, WebVector<WebMediaConstraint>& mandatory) |
| { |
| Vector<WebMediaConstraint> mandatoryConstraintsVector; |
| HashMap<String, String> mandatoryConstraintsHashMap; |
| bool ok = mandatoryConstraintsDictionary.getOwnPropertiesAsStringHashMap(mandatoryConstraintsHashMap); |
| if (!ok) |
| return false; |
| |
| for (const auto& iter : mandatoryConstraintsHashMap) |
| mandatoryConstraintsVector.append(WebMediaConstraint(iter.key, iter.value)); |
| mandatory.assign(mandatoryConstraintsVector); |
| return true; |
| } |
| |
| static bool parseOptionalConstraintsVectorElement(const Dictionary& constraint, Vector<WebMediaConstraint>& optionalConstraintsVector) |
| { |
| Vector<String> localNames; |
| bool ok = constraint.getPropertyNames(localNames); |
| if (!ok) |
| return false; |
| if (localNames.size() != 1) |
| return false; |
| const String& key = localNames[0]; |
| String value; |
| ok = DictionaryHelper::get(constraint, key, value); |
| if (!ok) |
| return false; |
| optionalConstraintsVector.append(WebMediaConstraint(key, value)); |
| return true; |
| } |
| |
| // Old style parser. Deprecated. |
| static bool parse(const Dictionary& constraintsDictionary, WebVector<WebMediaConstraint>& optional, WebVector<WebMediaConstraint>& mandatory) |
| { |
| if (constraintsDictionary.isUndefinedOrNull()) |
| return true; |
| |
| Vector<String> names; |
| bool ok = constraintsDictionary.getPropertyNames(names); |
| if (!ok) |
| return false; |
| |
| String mandatoryName("mandatory"); |
| String optionalName("optional"); |
| |
| for (Vector<String>::iterator it = names.begin(); it != names.end(); ++it) { |
| if (*it != mandatoryName && *it != optionalName) |
| return false; |
| } |
| |
| if (names.contains(mandatoryName)) { |
| Dictionary mandatoryConstraintsDictionary; |
| bool ok = constraintsDictionary.get(mandatoryName, mandatoryConstraintsDictionary); |
| if (!ok || mandatoryConstraintsDictionary.isUndefinedOrNull()) |
| return false; |
| ok = parseMandatoryConstraintsDictionary(mandatoryConstraintsDictionary, mandatory); |
| if (!ok) |
| return false; |
| } |
| |
| Vector<WebMediaConstraint> optionalConstraintsVector; |
| if (names.contains(optionalName)) { |
| ArrayValue optionalConstraints; |
| bool ok = DictionaryHelper::get(constraintsDictionary, optionalName, optionalConstraints); |
| if (!ok || optionalConstraints.isUndefinedOrNull()) |
| return false; |
| |
| size_t numberOfConstraints; |
| ok = optionalConstraints.length(numberOfConstraints); |
| if (!ok) |
| return false; |
| |
| for (size_t i = 0; i < numberOfConstraints; ++i) { |
| Dictionary constraint; |
| ok = optionalConstraints.get(i, constraint); |
| if (!ok || constraint.isUndefinedOrNull()) |
| return false; |
| ok = parseOptionalConstraintsVectorElement(constraint, optionalConstraintsVector); |
| if (!ok) |
| return false; |
| } |
| optional.assign(optionalConstraintsVector); |
| } |
| |
| return true; |
| } |
| |
| static bool parse(const MediaTrackConstraintSet& constraintsIn, WebVector<WebMediaConstraint>& optional, WebVector<WebMediaConstraint>& mandatory) |
| { |
| Vector<WebMediaConstraint> mandatoryConstraintsVector; |
| if (constraintsIn.hasMandatory()) { |
| bool ok = parseMandatoryConstraintsDictionary(constraintsIn.mandatory(), mandatory); |
| if (!ok) |
| return false; |
| } |
| |
| Vector<WebMediaConstraint> optionalConstraintsVector; |
| if (constraintsIn.hasOptional()) { |
| const Vector<Dictionary>& optionalConstraints = constraintsIn.optional(); |
| |
| for (const auto& constraint : optionalConstraints) { |
| if (constraint.isUndefinedOrNull()) |
| return false; |
| bool ok = parseOptionalConstraintsVectorElement(constraint, optionalConstraintsVector); |
| if (!ok) |
| return false; |
| } |
| optional.assign(optionalConstraintsVector); |
| } |
| return true; |
| } |
| |
| static bool toBoolean(const WebString& asWebString) |
| { |
| return asWebString.equals("true"); |
| // TODO(hta): Check against "false" and return error if it's neither. |
| // https://crbug.com/576582 |
| } |
| |
| static void parseOldStyleNames(const WebVector<WebMediaConstraint>& oldNames, WebMediaTrackConstraintSet& result, MediaErrorState& errorState) |
| { |
| for (const WebMediaConstraint& constraint : oldNames) { |
| if (constraint.m_name.equals(kMinAspectRatio)) { |
| result.aspectRatio.setMin(atof(constraint.m_value.utf8().c_str())); |
| } else if (constraint.m_name.equals(kMaxAspectRatio)) { |
| result.aspectRatio.setMax(atof(constraint.m_value.utf8().c_str())); |
| } else if (constraint.m_name.equals(kMaxWidth)) { |
| result.width.setMax(atoi(constraint.m_value.utf8().c_str())); |
| } else if (constraint.m_name.equals(kMinWidth)) { |
| result.width.setMin(atoi(constraint.m_value.utf8().c_str())); |
| } else if (constraint.m_name.equals(kMaxHeight)) { |
| result.height.setMax(atoi(constraint.m_value.utf8().c_str())); |
| } else if (constraint.m_name.equals(kMinHeight)) { |
| result.height.setMin(atoi(constraint.m_value.utf8().c_str())); |
| } else if (constraint.m_name.equals(kMinFrameRate)) { |
| result.frameRate.setMin(atof(constraint.m_value.utf8().c_str())); |
| } else if (constraint.m_name.equals(kMaxFrameRate)) { |
| result.frameRate.setMax(atof(constraint.m_value.utf8().c_str())); |
| } else if (constraint.m_name.equals(kEchoCancellation)) { |
| result.echoCancellation.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_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.mediaStreamSource.setExact(constraint.m_value); |
| } else if (constraint.m_name.equals(kMediaStreamSourceId) |
| || constraint.m_name.equals(kMediaStreamSourceInfoId)) { |
| result.deviceId.setExact(constraint.m_value); |
| } else if (constraint.m_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.renderToAssociatedSink.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kMediaStreamAudioHotword)) { |
| result.hotwordEnabled.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kGoogEchoCancellation)) { |
| result.googEchoCancellation.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kGoogExperimentalEchoCancellation)) { |
| result.googExperimentalEchoCancellation.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kGoogAutoGainControl)) { |
| result.googAutoGainControl.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kGoogExperimentalAutoGainControl)) { |
| result.googExperimentalAutoGainControl.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kGoogNoiseSuppression)) { |
| result.googNoiseSuppression.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kGoogExperimentalNoiseSuppression)) { |
| result.googExperimentalNoiseSuppression.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kGoogBeamforming)) { |
| result.googBeamforming.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kGoogArrayGeometry)) { |
| result.googArrayGeometry.setExact(constraint.m_value); |
| } else if (constraint.m_name.equals(kGoogHighpassFilter)) { |
| result.googHighpassFilter.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kGoogTypingNoiseDetection)) { |
| result.googTypingNoiseDetection.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kGoogAudioMirroring)) { |
| result.googAudioMirroring.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kDAEchoCancellation)) { |
| result.googDAEchoCancellation.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kAecDump)) { |
| result.googAecDump.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kNoiseReduction)) { |
| result.googNoiseReduction.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kOfferToReceiveAudio)) { |
| result.offerToReceiveAudio.setExact(constraint.m_value); |
| } else if (constraint.m_name.equals(kOfferToReceiveVideo)) { |
| result.offerToReceiveVideo.setExact(constraint.m_value); |
| } else if (constraint.m_name.equals(kVoiceActivityDetection)) { |
| result.voiceActivityDetection.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kIceRestart)) { |
| result.iceRestart.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kUseRtpMux)) { |
| result.googUseRtpMux.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kEnableDtlsSrtp)) { |
| result.enableDtlsSrtp.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kEnableRtpDataChannels)) { |
| result.enableRtpDataChannels.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kEnableDscp)) { |
| result.enableDscp.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kEnableIPv6)) { |
| result.enableIPv6.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kEnableVideoSuspendBelowMinBitrate)) { |
| result.googEnableVideoSuspendBelowMinBitrate.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kNumUnsignalledRecvStreams)) { |
| result.googNumUnsignalledRecvStreams.setExact(atoi(constraint.m_value.utf8().c_str())); |
| } else if (constraint.m_name.equals(kCombinedAudioVideoBwe)) { |
| result.googCombinedAudioVideoBwe.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kScreencastMinBitrate)) { |
| result.googScreencastMinBitrate.setExact(atoi(constraint.m_value.utf8().c_str())); |
| } else if (constraint.m_name.equals(kCpuOveruseDetection)) { |
| result.googCpuOveruseDetection.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kCpuUnderuseThreshold)) { |
| result.googCpuUnderuseThreshold.setExact(atoi(constraint.m_value.utf8().c_str())); |
| } else if (constraint.m_name.equals(kCpuOveruseThreshold)) { |
| result.googCpuOveruseThreshold.setExact(atoi(constraint.m_value.utf8().c_str())); |
| } else if (constraint.m_name.equals(kCpuUnderuseEncodeRsdThreshold)) { |
| result.googCpuUnderuseEncodeRsdThreshold.setExact(atoi(constraint.m_value.utf8().c_str())); |
| } else if (constraint.m_name.equals(kCpuOveruseEncodeRsdThreshold)) { |
| result.googCpuOveruseEncodeRsdThreshold.setExact(atoi(constraint.m_value.utf8().c_str())); |
| } else if (constraint.m_name.equals(kCpuOveruseEncodeUsage)) { |
| result.googCpuOveruseEncodeUsage.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kHighStartBitrate)) { |
| result.googHighStartBitrate.setExact(atoi(constraint.m_value.utf8().c_str())); |
| } else if (constraint.m_name.equals(kPayloadPadding)) { |
| result.googPayloadPadding.setExact(toBoolean(constraint.m_value)); |
| } else if (constraint.m_name.equals(kTestConstraint1) |
| || constraint.m_name.equals(kTestConstraint2)) { |
| // These constraints are only for testing parsing. Ignore them. |
| } else { |
| // TODO(hta): UMA stats for unknown constraints passed. |
| // https://crbug.com/576613 |
| WTF_LOG(Media, "Unknown constraint name detected"); |
| errorState.throwConstraintError("Unknown name of constraint detected", constraint.m_name); |
| } |
| } |
| } |
| |
| static WebMediaConstraints createFromNamedConstraints(WebVector<WebMediaConstraint>& mandatory, const WebVector<WebMediaConstraint>& optional, MediaErrorState& errorState) |
| { |
| WebMediaTrackConstraintSet basic; |
| WebMediaTrackConstraintSet advanced; |
| WebMediaConstraints constraints; |
| parseOldStyleNames(mandatory, basic, errorState); |
| if (errorState.hadException()) |
| return constraints; |
| // We ignore errors in optional constraints. |
| MediaErrorState ignoredErrorState; |
| parseOldStyleNames(optional, advanced, ignoredErrorState); |
| WebVector<WebMediaTrackConstraintSet> advancedVector(&advanced, 1); |
| // Use the 4-argument initializer until Chrome has been converted. |
| constraints.initialize(optional, mandatory, basic, advancedVector); |
| return constraints; |
| } |
| |
| // Deprecated. |
| WebMediaConstraints create(const Dictionary& constraintsDictionary, MediaErrorState& errorState) |
| { |
| WebVector<WebMediaConstraint> optional; |
| WebVector<WebMediaConstraint> mandatory; |
| if (!parse(constraintsDictionary, optional, mandatory)) { |
| errorState.throwTypeError("Malformed constraints object."); |
| return WebMediaConstraints(); |
| } |
| return createFromNamedConstraints(mandatory, optional, errorState); |
| } |
| |
| void copyLongConstraint(ConstrainLongRange blinkForm, LongConstraint& webForm) |
| { |
| if (blinkForm.hasMin()) { |
| webForm.setMin(blinkForm.min()); |
| } |
| if (blinkForm.hasMax()) { |
| webForm.setMax(blinkForm.max()); |
| } |
| if (blinkForm.hasIdeal()) { |
| webForm.setIdeal(blinkForm.ideal()); |
| } |
| if (blinkForm.hasExact()) { |
| webForm.setExact(blinkForm.exact()); |
| } |
| } |
| |
| void copyDoubleConstraint(ConstrainDoubleRange blinkForm, DoubleConstraint& webForm) |
| { |
| if (blinkForm.hasMin()) { |
| webForm.setMin(blinkForm.min()); |
| } |
| if (blinkForm.hasMax()) { |
| webForm.setMax(blinkForm.max()); |
| } |
| if (blinkForm.hasIdeal()) { |
| webForm.setIdeal(blinkForm.ideal()); |
| } |
| if (blinkForm.hasExact()) { |
| webForm.setExact(blinkForm.exact()); |
| } |
| } |
| |
| void copyStringConstraint(ConstrainDOMStringParameters blinkForm, StringConstraint& webForm) |
| { |
| WebVector<WebString> ideal; |
| WebVector<WebString> exact; |
| if (blinkForm.hasIdeal()) { |
| ideal = WebVector<WebString>(blinkForm.ideal()); |
| } |
| if (blinkForm.hasExact()) { |
| exact = WebVector<WebString>(blinkForm.exact()); |
| } |
| webForm = StringConstraint(ideal, exact); |
| } |
| |
| void copyBooleanConstraint(ConstrainBooleanParameters blinkForm, BooleanConstraint& webForm) |
| { |
| if (blinkForm.hasIdeal()) { |
| webForm.setIdeal(blinkForm.ideal()); |
| } |
| if (blinkForm.hasExact()) { |
| webForm.setExact(blinkForm.exact()); |
| } |
| } |
| |
| void copyConstraints(const MediaTrackConstraintSet& constraintsIn, WebMediaTrackConstraintSet& constraintBuffer) |
| { |
| if (constraintsIn.hasWidth()) { |
| copyLongConstraint(constraintsIn.width(), constraintBuffer.width); |
| } |
| if (constraintsIn.hasHeight()) { |
| copyLongConstraint(constraintsIn.height(), constraintBuffer.height); |
| } |
| if (constraintsIn.hasAspectRatio()) { |
| copyDoubleConstraint(constraintsIn.aspectRatio(), constraintBuffer.aspectRatio); |
| } |
| if (constraintsIn.hasFrameRate()) { |
| copyDoubleConstraint(constraintsIn.frameRate(), constraintBuffer.frameRate); |
| } |
| if (constraintsIn.hasFacingMode()) { |
| copyStringConstraint(constraintsIn.facingMode(), constraintBuffer.facingMode); |
| } |
| if (constraintsIn.hasVolume()) { |
| copyDoubleConstraint(constraintsIn.volume(), constraintBuffer.volume); |
| } |
| if (constraintsIn.hasSampleRate()) { |
| copyLongConstraint(constraintsIn.sampleRate(), constraintBuffer.sampleRate); |
| } |
| if (constraintsIn.hasSampleSize()) { |
| copyLongConstraint(constraintsIn.sampleSize(), constraintBuffer.sampleSize); |
| } |
| if (constraintsIn.hasEchoCancellation()) { |
| copyBooleanConstraint(constraintsIn.echoCancellation(), constraintBuffer.echoCancellation); |
| } |
| if (constraintsIn.hasLatency()) { |
| copyDoubleConstraint(constraintsIn.latency(), constraintBuffer.latency); |
| } |
| if (constraintsIn.hasChannelCount()) { |
| copyLongConstraint(constraintsIn.channelCount(), constraintBuffer.channelCount); |
| } |
| if (constraintsIn.hasDeviceId()) { |
| copyStringConstraint(constraintsIn.deviceId(), constraintBuffer.deviceId); |
| } |
| if (constraintsIn.hasGroupId()) { |
| copyStringConstraint(constraintsIn.groupId(), constraintBuffer.groupId); |
| } |
| } |
| |
| WebMediaConstraints create(const MediaTrackConstraintSet& constraintsIn, MediaErrorState& errorState) |
| { |
| WebMediaConstraints constraints; |
| WebMediaTrackConstraintSet constraintBuffer; |
| WebVector<WebMediaTrackConstraintSet> advancedBuffer; |
| copyConstraints(constraintsIn, constraintBuffer); |
| // TODO(hta): Add initialization of advanced constraints once present. |
| // https://crbug.com/253412 |
| if (constraintsIn.hasOptional() || constraintsIn.hasMandatory()) { |
| if (!constraintBuffer.isEmpty()) { |
| errorState.throwTypeError("Malformed constraint: Cannot use both optional/mandatory and specific constraints."); |
| return WebMediaConstraints(); |
| } |
| WebVector<WebMediaConstraint> optional; |
| WebVector<WebMediaConstraint> mandatory; |
| if (!parse(constraintsIn, optional, mandatory)) { |
| errorState.throwTypeError("Malformed constraints object."); |
| return WebMediaConstraints(); |
| } |
| return createFromNamedConstraints(mandatory, optional, errorState); |
| } |
| constraints.initialize(constraintBuffer, advancedBuffer); |
| return constraints; |
| } |
| |
| WebMediaConstraints create() |
| { |
| WebMediaConstraints constraints; |
| constraints.initialize(); |
| return constraints; |
| } |
| |
| } // namespace MediaConstraintsImpl |
| } // namespace blink |
