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..e0a5646ba6d24a61a6a5eb9bb3f6d87e358aee42 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 {

[Peter Beverloo, 2016/04/21 14:11:46]

Have you considered using something like the following instead?

using NameValueStringPair = std::pair<WebString, WebString>;

[hta - Chromium, 2016/04/24 09:58:25]

Not really - this was a struct that was exposed globally a few iterations ago; I
thought this was a good time to change the name to point out that it's *not*
part of the Web* interface any more, but I didn't want to spend time updating
the places it's used (which is all code that I hope to get to the dustbin one
day).

+    NameValueStringConstraint()
     {
     }
 
-    WebMediaConstraint(WebString name, WebString value)
+    NameValueStringConstraint(WebString name, WebString value)
         : m_name(name)
         , m_value(value)
     {
@@ -156,21 +157,21 @@ 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, WebVector<NameValueStringConstraint>& mandatory)
 {
-    Vector<WebMediaConstraint> mandatoryConstraintsVector;
+    Vector<NameValueStringConstraint> 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));
+        mandatoryConstraintsVector.append(NameValueStringConstraint(iter.key, iter.value));
     mandatory.assign(mandatoryConstraintsVector);
     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 +184,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, WebVector<NameValueStringConstraint>& optional, WebVector<NameValueStringConstraint>& mandatory)

[Peter Beverloo, 2016/04/21 14:11:46]

Is there any reason to use a WebVector here and elsewhere w/ the
NameValueStringConstraint type rather than a Vector?

The WebVector is the exposed version of a Vector in the WebKit API, but since
you're using it with an internal type that doesn't seem necessary.

[hta - Chromium, 2016/04/24 09:58:25]

Good point. It was used globally, but now it's just hassle.

 {
     if (constraintsDictionary.isUndefinedOrNull())
         return true;
@@ -216,7 +217,7 @@ static bool parse(const Dictionary& constraintsDictionary, WebVector<WebMediaCon
             return false;
     }
 
-    Vector<WebMediaConstraint> optionalConstraintsVector;
+    Vector<NameValueStringConstraint> optionalConstraintsVector;
     if (names.contains(optionalName)) {
         ArrayValue optionalConstraints;
         bool ok = DictionaryHelper::get(constraintsDictionary, optionalName, optionalConstraints);
@@ -243,16 +244,16 @@ static bool parse(const Dictionary& constraintsDictionary, WebVector<WebMediaCon
     return true;
 }
 
-static bool parse(const MediaTrackConstraints& constraintsIn, WebVector<WebMediaConstraint>& optional, WebVector<WebMediaConstraint>& mandatory)
+static bool parse(const MediaTrackConstraints& constraintsIn, WebVector<NameValueStringConstraint>& optional, WebVector<NameValueStringConstraint>& mandatory)
 {
-    Vector<WebMediaConstraint> mandatoryConstraintsVector;
+    Vector<NameValueStringConstraint> mandatoryConstraintsVector;
     if (constraintsIn.hasMandatory()) {
         bool ok = parseMandatoryConstraintsDictionary(constraintsIn.mandatory(), mandatory);
         if (!ok)
             return false;
     }
 
-    Vector<WebMediaConstraint> optionalConstraintsVector;
+    Vector<NameValueStringConstraint> optionalConstraintsVector;
     if (constraintsIn.hasOptional()) {
         const Vector<Dictionary>& optionalConstraints = constraintsIn.optional();
 
@@ -275,9 +276,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 WebVector<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 +425,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, WebVector<NameValueStringConstraint>& mandatory, const WebVector<NameValueStringConstraint>& optional, MediaErrorState& errorState)
 {
     WebMediaTrackConstraintSet basic;
     WebMediaTrackConstraintSet advanced;
@@ -437,7 +438,7 @@ static WebMediaConstraints createFromNamedConstraints(ExecutionContext* context,
     Vector<WebMediaTrackConstraintSet> advancedVector;
     for (const auto& optionalConstraint : optional) {
         WebMediaTrackConstraintSet advancedElement;
-        WebVector<WebMediaConstraint> elementAsList(&optionalConstraint, 1);
+        WebVector<NameValueStringConstraint> elementAsList(&optionalConstraint, 1);
         parseOldStyleNames(context, elementAsList, false, advancedElement, ignoredErrorState);
         if (!advancedElement.isEmpty())
             advancedVector.append(advancedElement);
@@ -449,8 +450,8 @@ static WebMediaConstraints createFromNamedConstraints(ExecutionContext* context,
 // Deprecated.
 WebMediaConstraints create(ExecutionContext* context, const Dictionary& constraintsDictionary, MediaErrorState& errorState)
 {
-    WebVector<WebMediaConstraint> optional;
-    WebVector<WebMediaConstraint> mandatory;
+    WebVector<NameValueStringConstraint> optional;
+    WebVector<NameValueStringConstraint> mandatory;
     if (!parse(constraintsDictionary, optional, mandatory)) {
         errorState.throwTypeError("Malformed constraints object.");
         return WebMediaConstraints();
@@ -574,8 +575,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;
+        WebVector<NameValueStringConstraint> optional;
+        WebVector<NameValueStringConstraint> mandatory;
         if (!parse(constraintsIn, optional, mandatory)) {
             errorState.throwTypeError("Malformed constraints object.");
             return WebMediaConstraints();
@@ -595,5 +596,110 @@ WebMediaConstraints create()
     return constraints;
 }
 
+ConstrainLongRange convertLong(const LongConstraint& input)

[Peter Beverloo, 2016/04/21 14:11:46]

While English is not my first language, it seems to me like the spec would want
to use the noun (Constraint) rather than the verb (Constrain) for these types?

[hta - Chromium, 2016/04/24 09:58:25]

Not my first language either, but it is the first language of the guy who picked
the name.... I think he was thinking that "this type serves to specify how to
constrain a Long to a Range". Don't want to revisit this piece of the spec.....
we're ready to call it a W3C CR just about now.

+{
+
+    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<WTF::String> buffer;

[Peter Beverloo, 2016/04/21 14:11:46]

nit: no need to prefix with WTF::

[hta - Chromium, 2016/04/24 09:58:25]

Done.

+        for (const auto& scanner : input.ideal())
+            buffer.append(scanner);
+        output.setIdeal(buffer);
+    }
+    if (input.hasExact()) {
+        Vector<WTF::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): Add the non-standard names (here and in IDL).

[Peter Beverloo, 2016/04/21 14:11:46]

These are the goog* right, or also the hotword/sinkId and others that are being
parsed in parseOldStyleNames()?

As long as we don't add any new ones, I'm definitely in favor of properly and
explicitly documenting what we're doing here :-).

[hta - Chromium, 2016/04/24 09:58:25]

I think I need to moderate this remark. I'll file a bug, it's a better way of
having a discussion about it.
https://crbug.com/605673 filed.

+}
+
+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