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 {

[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)
     {
     }
 
     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, 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);
     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, 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;
 
     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;
+    Vector<NameValueStringConstraint> 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 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();
 
         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(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)) {
             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, WebVector<NameValueStringConstraint>& mandatory, const WebVector<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);
+        WebVector<NameValueStringConstraint> elementAsList(&optionalConstraint, 1);
         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;
+    WebVector<NameValueStringConstraint> optional;
+    WebVector<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;
+        WebVector<NameValueStringConstraint> optional;
+        WebVector<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)

[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