Implement MediaStreamTrack.getConstraints

third_party/WebKit/Source/modules/mediastream/MediaConstraintsImpl.cpp

 /*
  * 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
@@ skipping 22 matching lines @@
 #include "bindings/core/v8/ArrayValue.h"
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/frame/UseCounter.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "modules/mediastream/MediaTrackConstraints.h"
 #include "platform/Logging.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "wtf/Assertions.h"
 #include "wtf/HashMap.h"
 #include "wtf/Vector.h"
 #include "wtf/text/StringHash.h"
 
 namespace blink {
 
 
 namespace MediaConstraintsImpl {
 
 // Old type/value form of constraint. Used in parsing old-style constraints.
-struct WebMediaConstraint {
-    WebMediaConstraint()
+struct NameValueStringConstraint {
+    NameValueStringConstraint()
     {
     }
 
-    WebMediaConstraint(WebString name, WebString value)
+    NameValueStringConstraint(WebString name, WebString value)
         : m_name(name)
         , m_value(value)
     {
     }
 
     WebString m_name;
     WebString m_value;
 };
 
 
@@ skipping 80 matching lines @@
 // 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";
 // 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)
+static bool parseMandatoryConstraintsDictionary(const Dictionary& mandatoryConstraintsDictionary, Vector<NameValueStringConstraint>& 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);
+        mandatory.append(NameValueStringConstraint(iter.key, iter.value));
     return true;
 }
 
-static bool parseOptionalConstraintsVectorElement(const Dictionary& constraint, Vector<WebMediaConstraint>& optionalConstraintsVector)
+static bool parseOptionalConstraintsVectorElement(const Dictionary& constraint, Vector<NameValueStringConstraint>& 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));
+    optionalConstraintsVector.append(NameValueStringConstraint(key, value));
     return true;
 }
 
 // Old style parser. Deprecated.
-static bool parse(const Dictionary& constraintsDictionary, WebVector<WebMediaConstraint>& optional, WebVector<WebMediaConstraint>& mandatory)
+static bool parse(const Dictionary& constraintsDictionary, Vector<NameValueStringConstraint>& optional, Vector<NameValueStringConstraint>& 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);
+            ok = parseOptionalConstraintsVectorElement(constraint, optional);
             if (!ok)
                 return false;
         }
-        optional.assign(optionalConstraintsVector);
     }
 
     return true;
 }
 
-static bool parse(const MediaTrackConstraints& constraintsIn, WebVector<WebMediaConstraint>& optional, WebVector<WebMediaConstraint>& mandatory)
+static bool parse(const MediaTrackConstraints& constraintsIn, Vector<NameValueStringConstraint>& optional, Vector<NameValueStringConstraint>& mandatory)
 {
-    Vector<WebMediaConstraint> mandatoryConstraintsVector;
+    Vector<NameValueStringConstraint> 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);
+            bool ok = parseOptionalConstraintsVectorElement(constraint, optional);
             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(ExecutionContext* context, const WebVector<WebMediaConstraint>& oldNames, bool reportUnknownNames, WebMediaTrackConstraintSet& result, MediaErrorState& errorState)
+static void parseOldStyleNames(ExecutionContext* context, const Vector<NameValueStringConstraint>& oldNames, bool reportUnknownNames, WebMediaTrackConstraintSet& result, MediaErrorState& errorState)
 {
-    for (const WebMediaConstraint& constraint : oldNames) {
+    for (const NameValueStringConstraint& 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()));
@@ skipping 126 matching lines @@
                         DeprecationMessageSource,
                         WarningMessageLevel,
                         "Unknown constraint named "
                         + String(constraint.m_name) + " rejected"));
                 errorState.throwConstraintError("Unknown name of constraint detected", constraint.m_name);
             }
         }
     }
 }
 
-static WebMediaConstraints createFromNamedConstraints(ExecutionContext* context, WebVector<WebMediaConstraint>& mandatory, const WebVector<WebMediaConstraint>& optional, MediaErrorState& errorState)
+static WebMediaConstraints createFromNamedConstraints(ExecutionContext* context, Vector<NameValueStringConstraint>& mandatory, const Vector<NameValueStringConstraint>& optional, MediaErrorState& errorState)
 {
     WebMediaTrackConstraintSet basic;
     WebMediaTrackConstraintSet advanced;
     WebMediaConstraints constraints;
     parseOldStyleNames(context, mandatory, true, basic, errorState);
     if (errorState.hadException())
         return constraints;
     // We ignore unknow names and syntax errors in optional constraints.
     MediaErrorState ignoredErrorState;
     Vector<WebMediaTrackConstraintSet> advancedVector;
     for (const auto& optionalConstraint : optional) {
         WebMediaTrackConstraintSet advancedElement;
-        WebVector<WebMediaConstraint> elementAsList(&optionalConstraint, 1);
+        Vector<NameValueStringConstraint> elementAsList(1, optionalConstraint);
         parseOldStyleNames(context, elementAsList, false, advancedElement, ignoredErrorState);
         if (!advancedElement.isEmpty())
             advancedVector.append(advancedElement);
     }
     constraints.initialize(basic, advancedVector);
     return constraints;
 }
 
 // Deprecated.
 WebMediaConstraints create(ExecutionContext* context, const Dictionary& constraintsDictionary, MediaErrorState& errorState)
 {
-    WebVector<WebMediaConstraint> optional;
-    WebVector<WebMediaConstraint> mandatory;
+    Vector<NameValueStringConstraint> optional;
+    Vector<NameValueStringConstraint> mandatory;
     if (!parse(constraintsDictionary, optional, mandatory)) {
         errorState.throwTypeError("Malformed constraints object.");
         return WebMediaConstraints();
     }
     UseCounter::count(context, UseCounter::MediaStreamConstraintsFromDictionary);
     return createFromNamedConstraints(context, mandatory, optional, errorState);
 }
 
 void copyLongConstraint(const ConstrainLongRange& blinkForm, LongConstraint& webForm)
 {
@@ skipping 103 matching lines @@
             advancedBuffer.append(advancedElement);
         }
     }
     // TODO(hta): Add initialization of advanced constraints once present.
     // https://crbug.com/253412
     if (constraintsIn.hasOptional() || constraintsIn.hasMandatory()) {
         if (!constraintBuffer.isEmpty() || constraintsIn.hasAdvanced()) {
             errorState.throwTypeError("Malformed constraint: Cannot use both optional/mandatory and specific or advanced constraints.");
             return WebMediaConstraints();
         }
-        WebVector<WebMediaConstraint> optional;
-        WebVector<WebMediaConstraint> mandatory;
+        Vector<NameValueStringConstraint> optional;
+        Vector<NameValueStringConstraint> mandatory;
         if (!parse(constraintsIn, optional, mandatory)) {
             errorState.throwTypeError("Malformed constraints object.");
             return WebMediaConstraints();
         }
         UseCounter::count(context, UseCounter::MediaStreamConstraintsNameValue);
         return createFromNamedConstraints(context, mandatory, optional, errorState);
     }
     UseCounter::count(context, UseCounter::MediaStreamConstraintsConformant);
     constraints.initialize(constraintBuffer, advancedBuffer);
     return constraints;
 }
 
 WebMediaConstraints create()
 {
     WebMediaConstraints constraints;
     constraints.initialize();
     return constraints;
 }
 
+ConstrainLongRange convertLong(const LongConstraint& input)
+{
+
+    ConstrainLongRange 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());
+    return output;
+}
+
+ConstrainDoubleRange convertDouble(const DoubleConstraint& input)
+{
+
+    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());
+    return output;
+}
+
+ConstrainDOMStringParameters convertString(const StringConstraint& input)
+{
+    ConstrainDOMStringParameters output;
+    if (input.hasIdeal()) {
+        Vector<String> buffer;
+        for (const auto& scanner : input.ideal())
+            buffer.append(scanner);
+        output.setIdeal(buffer);
+    }
+    if (input.hasExact()) {
+        Vector<String> buffer;
+        for (const auto& scanner : input.exact())
+            buffer.append(scanner);
+        output.setExact(buffer);
+    }
+    return output;
+}
+
+ConstrainBooleanParameters convertBoolean(const BooleanConstraint& input)
+{
+
+    ConstrainBooleanParameters output;
+    if (input.hasExact())
+        output.setExact(input.exact());
+    if (input.hasIdeal())
+        output.setIdeal(input.ideal());
+    return output;
+}
+
+void convertConstraintSet(const WebMediaTrackConstraintSet& input, MediaTrackConstraintSet& output)
+{
+    if (!input.width.isEmpty())
+        output.setWidth(convertLong(input.width));
+    if (!input.height.isEmpty())
+        output.setHeight(convertLong(input.height));
+    if (!input.aspectRatio.isEmpty())
+        output.setAspectRatio(convertDouble(input.aspectRatio));
+    if (!input.frameRate.isEmpty())
+        output.setFrameRate(convertDouble(input.frameRate));
+    if (!input.facingMode.isEmpty())
+        output.setFacingMode(convertString(input.facingMode));
+    if (!input.volume.isEmpty())
+        output.setVolume(convertDouble(input.volume));
+    if (!input.sampleRate.isEmpty())
+        output.setSampleRate(convertLong(input.sampleRate));
+    if (!input.sampleSize.isEmpty())
+        output.setSampleSize(convertLong(input.sampleSize));
+    if (!input.echoCancellation.isEmpty())
+        output.setEchoCancellation(convertBoolean(input.echoCancellation));
+    if (!input.latency.isEmpty())
+        output.setLatency(convertDouble(input.latency));
+    if (!input.channelCount.isEmpty())
+        output.setChannelCount(convertLong(input.channelCount));
+    if (!input.deviceId.isEmpty())
+        output.setDeviceId(convertString(input.deviceId));
+    if (!input.groupId.isEmpty())
+        output.setGroupId(convertString(input.groupId));
+    // 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(), output);
+    HeapVector<MediaTrackConstraintSet> advancedVector;
+    for (const auto& it : input.advanced()) {
+        MediaTrackConstraintSet element;
+        convertConstraintSet(it, element);
+        advancedVector.append(element);
+    }
+    if (!advancedVector.isEmpty())
+        output.setAdvanced(advancedVector);
+}
+
 } // namespace MediaConstraintsImpl
 } // namespace blink