Implement MediaStreamTrack.getConstraints

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

Index: third_party/WebKit/Source/modules/mediastream/MediaConstraintsImpl.cpp
diff --git a/third_party/WebKit/Source/modules/mediastream/MediaConstraintsImpl.cpp b/third_party/WebKit/Source/modules/mediastream/MediaConstraintsImpl.cpp
index 24262199521b02c5a0611fcaaf55b9a42ba4f654..a9b708e719c64bd01e7d691c25c5f6ac24fd9b55 100644
--- a/third_party/WebKit/Source/modules/mediastream/MediaConstraintsImpl.cpp
+++ b/third_party/WebKit/Source/modules/mediastream/MediaConstraintsImpl.cpp
@@ -40,6 +40,7 @@
 #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"
@@ -50,12 +51,12 @@ 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)
     {
@@ -156,21 +157,19 @@ const char kPowerLineFrequency[] = "googPowerLineFrequency";
 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);
@@ -183,12 +182,12 @@ static bool parseOptionalConstraintsVectorElement(const Dictionary& constraint,
     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;
@@ -216,7 +215,6 @@ static bool parse(const Dictionary& constraintsDictionary, WebVector<WebMediaCon
             return false;
     }
 
-    Vector<WebMediaConstraint> optionalConstraintsVector;
     if (names.contains(optionalName)) {
         ArrayValue optionalConstraints;
         bool ok = DictionaryHelper::get(constraintsDictionary, optionalName, optionalConstraints);
@@ -233,37 +231,34 @@ static bool parse(const Dictionary& constraintsDictionary, WebVector<WebMediaCon
             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;
 }
@@ -275,9 +270,9 @@ static bool toBoolean(const WebString& asWebString)
     // 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)) {
@@ -424,7 +419,7 @@ static void parseOldStyleNames(ExecutionContext* context, const WebVector<WebMed
     }
 }
 
-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;
@@ -437,7 +432,7 @@ static WebMediaConstraints createFromNamedConstraints(ExecutionContext* context,
     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);
@@ -449,8 +444,8 @@ static WebMediaConstraints createFromNamedConstraints(ExecutionContext* context,
 // 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();
@@ -574,8 +569,8 @@ WebMediaConstraints create(ExecutionContext* context, const MediaTrackConstraint
             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();
@@ -595,5 +590,112 @@ WebMediaConstraints create()
     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