static void parseAdvancedConstraints(const Dictionary& mediaTrackConstraints, Vector<MediaTrackConstraintSetMap>& advancedConstraints)
{
ArrayValue sequenceOfMediaTrackConstraintSets;
if (!mediaTrackConstraints.get("advanced", sequenceOfMediaTrackConstraintSets) || sequenceOfMediaTrackConstraintSets.isUndefinedOrNull()) {
LOG(Media, "parseAdvancedConstraints() - value of advanced key is not a list.");
return;
}
size_t numberOfConstraintSets;
if (!sequenceOfMediaTrackConstraintSets.length(numberOfConstraintSets)) {
LOG(Media, "parseAdvancedConstraints() - ignoring empty advanced sequence of MediaTrackConstraintSets.");
return;
}
for (size_t i = 0; i < numberOfConstraintSets; ++i) {
Dictionary mediaTrackConstraintSet;
if (!sequenceOfMediaTrackConstraintSets.get(i, mediaTrackConstraintSet) || mediaTrackConstraintSet.isUndefinedOrNull()) {
LOG(Media, "parseAdvancedConstraints() - ignoring constraint set with index '%zu' in advanced list.", i);
continue;
}
MediaTrackConstraintSetMap map;
Vector<String> localKeys;
mediaTrackConstraintSet.getOwnPropertyNames(localKeys);
for (auto& localKey : localKeys)
parseMediaTrackConstraintSetForKey(mediaTrackConstraintSet, localKey, map, ConstraintSetType::Advanced);
if (!map.isEmpty())
advancedConstraints.append(WTFMove(map));
}
}
bool MediaConstraintsImpl::initialize(const Dictionary& constraints)
{
if (constraints.isUndefinedOrNull())
return true;
Vector<String> names;
constraints.getOwnPropertyNames(names);
String mandatory = ASCIILiteral("mandatory");
String optional = ASCIILiteral("optional");
for (Vector<String>::iterator it = names.begin(); it != names.end(); ++it) {
if (*it != mandatory && *it != optional)
return false;
}
if (names.contains(mandatory)) {
Dictionary mandatoryConstraints;
bool ok = constraints.get(mandatory, mandatoryConstraints);
if (!ok || mandatoryConstraints.isUndefinedOrNull())
return false;
ok = mandatoryConstraints.getOwnPropertiesAsStringHashMap(m_mandatoryConstraints);
if (!ok)
return false;
}
if (names.contains(optional)) {
ArrayValue optionalConstraints;
bool ok = constraints.get(optional, 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;
Vector<String> localNames;
constraint.getOwnPropertyNames(localNames);
if (localNames.size() != 1)
return false;
String key = localNames[0];
String value;
ok = constraint.get(key, value);
if (!ok)
return false;
m_optionalConstraints.append(MediaConstraint(key, value));
}
}
return true;
}
void RTCConfiguration::initialize(const Dictionary& configuration, ExceptionCode& ec)
{
ArrayValue iceServers;
bool ok = configuration.get("iceServers", iceServers);
if (!ok || iceServers.isUndefinedOrNull()) {
ec = TYPE_MISMATCH_ERR;
return;
}
size_t numberOfServers;
ok = iceServers.length(numberOfServers);
if (!ok || !numberOfServers) {
ec = !ok ? TYPE_MISMATCH_ERR : INVALID_ACCESS_ERR;
return;
}
for (size_t i = 0; i < numberOfServers; ++i) {
Dictionary iceServerDict;
ok = iceServers.get(i, iceServerDict);
if (!ok) {
ec = TYPE_MISMATCH_ERR;
return;
}
RefPtr<RTCIceServer> iceServer = parseIceServer(iceServerDict, ec);
if (!iceServer)
return;
m_iceServers.append(WTFMove(iceServer));
}
String iceTransportPolicy;
if (configuration.get("iceTransportPolicy", iceTransportPolicy)) {
if (iceTransportPolicy == "relay")
m_iceTransportPolicy = IceTransportPolicy::Relay;
else if (iceTransportPolicy == "all")
m_iceTransportPolicy = IceTransportPolicy::All;
else {
ec = TypeError;
return;
}
}
String bundlePolicy;
if (configuration.get("bundlePolicy", bundlePolicy)) {
if (bundlePolicy == "balanced")
m_bundlePolicy = BundlePolicy::Balanced;
else if (bundlePolicy == "max-compat")
m_bundlePolicy = BundlePolicy::MaxCompat;
else if (bundlePolicy == "max-bundle")
m_bundlePolicy = BundlePolicy::MaxBundle;
else
ec = TypeError;
}
}
// 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 void initializeStringConstraintWithList(StringConstraint& constraint, void (StringConstraint::*appendValue)(const String&), const ArrayValue& list)
{
size_t size;
if (!list.length(size))
return;
for (size_t i = 0; i < size; ++i) {
String value;
if (list.get(i, value))
(constraint.*appendValue)(value);
}
}
ustring DataValue::serializeArray(void *value) {
ustring result("[");
ArrayValue *arr = (ArrayValue*)value;
for(ArrayValue::iterator i = arr->begin(); i != arr->end(); i++) {
if(i != arr->begin())
result += ",";
result += "'" + i->name + "'=" + serialize(arr->type, i->data);
}
result += "]";
return result;
}
ExceptionOr<void> RTCConfiguration::initialize(const Dictionary& configuration)
{
ArrayValue iceServers;
bool ok = configuration.get("iceServers", iceServers);
if (!ok || iceServers.isUndefinedOrNull())
return Exception { TYPE_MISMATCH_ERR };
size_t numberOfServers;
ok = iceServers.length(numberOfServers);
if (!ok)
return Exception { TYPE_MISMATCH_ERR };
if (!numberOfServers)
return Exception { INVALID_ACCESS_ERR };
for (size_t i = 0; i < numberOfServers; ++i) {
Dictionary iceServerDict;
ok = iceServers.get(i, iceServerDict);
if (!ok)
return Exception { TYPE_MISMATCH_ERR };
auto server = parseIceServer(iceServerDict);
if (server.hasException())
return server.releaseException();
m_iceServers.append(server.releaseReturnValue());
}
String iceTransportPolicy;
if (configuration.get("iceTransportPolicy", iceTransportPolicy)) {
if (iceTransportPolicy == "relay")
m_iceTransportPolicy = IceTransportPolicy::Relay;
else if (iceTransportPolicy == "all")
m_iceTransportPolicy = IceTransportPolicy::All;
else
return Exception { TypeError };
}
String bundlePolicy;
if (configuration.get("bundlePolicy", bundlePolicy)) {
if (bundlePolicy == "balanced")
m_bundlePolicy = BundlePolicy::Balanced;
else if (bundlePolicy == "max-compat")
m_bundlePolicy = BundlePolicy::MaxCompat;
else if (bundlePolicy == "max-bundle")
m_bundlePolicy = BundlePolicy::MaxBundle;
else
return Exception { TypeError };
}
return { };
}
PassRefPtr<RTCConfiguration> RTCPeerConnection::parseConfiguration(const Dictionary& configuration, ExceptionCode& ec)
{
if (configuration.isUndefinedOrNull())
return nullptr;
ArrayValue iceServers;
bool ok = configuration.get("iceServers", iceServers);
if (!ok || iceServers.isUndefinedOrNull()) {
ec = TYPE_MISMATCH_ERR;
return nullptr;
}
size_t numberOfServers;
ok = iceServers.length(numberOfServers);
if (!ok) {
ec = TYPE_MISMATCH_ERR;
return nullptr;
}
RefPtr<RTCConfiguration> rtcConfiguration = RTCConfiguration::create();
for (size_t i = 0; i < numberOfServers; ++i) {
Dictionary iceServer;
ok = iceServers.get(i, iceServer);
if (!ok) {
ec = TYPE_MISMATCH_ERR;
return nullptr;
}
String urlString, credential, username;
ok = iceServer.get("url", urlString);
if (!ok) {
ec = TYPE_MISMATCH_ERR;
return nullptr;
}
URL url(URL(), urlString);
if (!url.isValid() || !(url.protocolIs("turn") || url.protocolIs("stun"))) {
ec = TYPE_MISMATCH_ERR;
return nullptr;
}
iceServer.get("credential", credential);
iceServer.get("username", username);
rtcConfiguration->appendServer(RTCIceServer::create(url, credential, username));
}
return rtcConfiguration.release();
}
void DataValue::parseArray(const ustring &text, void *value) {
ArrayValue *arr = (ArrayValue*)value;
int i = 1; // skip [
while (text[i] != ']') {
i++; // skip '
int p = text.find('\'', i);
void *v = arr->add(ustring(text, i, p - i));
i = p + 2; // skip =
p = text.find(',', i);
if(p == -1)
p = text.length() - 1;
parse(ustring(text, i, p - i), arr->type, v);
i = p;
if(text[i] == ',') i++;
}
}
void makeItems(ArrayValue const &ids, bool recommended)
{
for (Value const *value : ids.elements())
{
contents->items() << new Item(value->asText(), recommended, packageId);
}
}
CBORValue::CBORValue(const ArrayValue& inArray)
: m_type(Type::Array)
, m_arrayValue()
{
m_arrayValue.reserveCapacity(inArray.size());
for (const auto& val : inArray)
m_arrayValue.append(val.clone());
}
Value *DictionaryValue::next()
{
if (!_validIteration)
{
_iteration = _elements.begin();
_validIteration = true;
}
else if (_iteration == _elements.end())
{
return 0;
}
ArrayValue *pair = new ArrayValue;
pair->add(_iteration->first.value->duplicate());
pair->add(_iteration->second->duplicate());
++_iteration;
return pair;
}
PassRefPtr<RTCConfiguration> RTCPeerConnection::parseConfiguration(const Dictionary& configuration, ExceptionCode& ec)
{
if (configuration.isUndefinedOrNull())
return nullptr;
ArrayValue iceServers;
bool ok = configuration.get("iceServers", iceServers);
if (!ok || iceServers.isUndefinedOrNull()) {
ec = TYPE_MISMATCH_ERR;
return nullptr;
}
size_t numberOfServers;
ok = iceServers.length(numberOfServers);
if (!ok || !numberOfServers) {
ec = !ok ? TYPE_MISMATCH_ERR : INVALID_ACCESS_ERR;
return nullptr;
}
String iceTransports;
String requestIdentity;
configuration.get("iceTransports", iceTransports);
configuration.get("requestIdentity", requestIdentity);
RefPtr<RTCConfiguration> rtcConfiguration = RTCConfiguration::create();
rtcConfiguration->setIceTransports(iceTransports);
rtcConfiguration->setRequestIdentity(requestIdentity);
for (size_t i = 0; i < numberOfServers; ++i) {
Dictionary iceServer;
ok = iceServers.get(i, iceServer);
if (!ok) {
ec = TYPE_MISMATCH_ERR;
return nullptr;
}
ec = processIceServer(iceServer, rtcConfiguration.get());
if (ec)
return nullptr;
}
return rtcConfiguration.release();
}
static bool parse(const Dictionary& constraintsDictionary, blink::WebVector<blink::WebMediaConstraint>& optional, blink::WebVector<blink::WebMediaConstraint>& mandatory)
{
if (constraintsDictionary.isUndefinedOrNull())
return true;
Vector<String> names;
constraintsDictionary.getOwnPropertyNames(names);
String mandatoryName("mandatory");
String optionalName("optional");
for (Vector<String>::iterator it = names.begin(); it != names.end(); ++it) {
if (*it != mandatoryName && *it != optionalName)
return false;
}
Vector<blink::WebMediaConstraint> mandatoryConstraintsVector;
if (names.contains(mandatoryName)) {
Dictionary mandatoryConstraintsDictionary;
bool ok = constraintsDictionary.get(mandatoryName, mandatoryConstraintsDictionary);
if (!ok || mandatoryConstraintsDictionary.isUndefinedOrNull())
return false;
HashMap<String, String> mandatoryConstraintsHashMap;
ok = mandatoryConstraintsDictionary.getOwnPropertiesAsStringHashMap(mandatoryConstraintsHashMap);
if (!ok)
return false;
HashMap<String, String>::const_iterator iter = mandatoryConstraintsHashMap.begin();
for (; iter != mandatoryConstraintsHashMap.end(); ++iter)
mandatoryConstraintsVector.append(blink::WebMediaConstraint(iter->key, iter->value));
}
Vector<blink::WebMediaConstraint> optionalConstraintsVector;
if (names.contains(optionalName)) {
ArrayValue optionalConstraints;
bool ok = constraintsDictionary.get(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;
Vector<String> localNames;
constraint.getOwnPropertyNames(localNames);
if (localNames.size() != 1)
return false;
String key = localNames[0];
String value;
ok = constraint.get(key, value);
if (!ok)
return false;
optionalConstraintsVector.append(blink::WebMediaConstraint(key, value));
}
}
optional.assign(optionalConstraintsVector);
mandatory.assign(mandatoryConstraintsVector);
return true;
}
static Optional<StringConstraint> createStringConstraint(const Dictionary& mediaTrackConstraintSet, const String& name, MediaConstraintType type, ConstraintSetType constraintSetType)
{
auto constraint = StringConstraint(name, type);
// Dictionary constraint value.
Dictionary dictionaryValue;
if (mediaTrackConstraintSet.get(name, dictionaryValue) && !dictionaryValue.isUndefinedOrNull()) {
ArrayValue exactArrayValue;
if (dictionaryValue.get("exact", exactArrayValue) && !exactArrayValue.isUndefinedOrNull())
initializeStringConstraintWithList(constraint, &StringConstraint::appendExact, exactArrayValue);
else {
String exactStringValue;
if (dictionaryValue.get("exact", exactStringValue))
constraint.setExact(exactStringValue);
}
ArrayValue idealArrayValue;
if (dictionaryValue.get("ideal", idealArrayValue) && !idealArrayValue.isUndefinedOrNull())
initializeStringConstraintWithList(constraint, &StringConstraint::appendIdeal, idealArrayValue);
else {
String idealStringValue;
if (!dictionaryValue.get("ideal", idealStringValue))
constraint.setIdeal(idealStringValue);
}
if (constraint.isEmpty()) {
LOG(Media, "createStringConstraint() - ignoring string constraint '%s' with dictionary value since it has no valid or supported key/value pairs.", name.utf8().data());
return Nullopt;
}
return WTFMove(constraint);
}
// Array constraint value.
ArrayValue arrayValue;
if (mediaTrackConstraintSet.get(name, arrayValue) && !arrayValue.isUndefinedOrNull()) {
initializeStringConstraintWithList(constraint, &StringConstraint::appendIdeal, arrayValue);
if (constraint.isEmpty()) {
LOG(Media, "createStringConstraint() - ignoring string constraint '%s' with array value since it is empty.", name.utf8().data());
return Nullopt;
}
return WTFMove(constraint);
}
// Scalar constraint value.
String value;
if (mediaTrackConstraintSet.get(name, value)) {
if (constraintSetType == ConstraintSetType::Mandatory)
constraint.setIdeal(value);
else
constraint.setExact(value);
return WTFMove(constraint);
}
// Invalid constraint value.
LOG(Media, "createStringConstraint() - ignoring string constraint '%s' since it has neither a dictionary nor sequence nor scalar value.", name.utf8().data());
return Nullopt;
}
PassRefPtr<RTCConfiguration> RTCPeerConnection::parseConfiguration(const Dictionary& configuration, ExceptionState& exceptionState)
{
if (configuration.isUndefinedOrNull())
return nullptr;
ArrayValue iceServers;
bool ok = configuration.get("iceServers", iceServers);
if (!ok || iceServers.isUndefinedOrNull()) {
exceptionState.throwTypeError("Malformed RTCConfiguration");
return nullptr;
}
size_t numberOfServers;
ok = iceServers.length(numberOfServers);
if (!ok) {
exceptionState.throwTypeError("Malformed RTCConfiguration");
return nullptr;
}
RefPtr<RTCConfiguration> rtcConfiguration = RTCConfiguration::create();
for (size_t i = 0; i < numberOfServers; ++i) {
Dictionary iceServer;
ok = iceServers.get(i, iceServer);
if (!ok) {
exceptionState.throwTypeError("Malformed RTCIceServer");
return nullptr;
}
Vector<String> names;
iceServer.getOwnPropertyNames(names);
Vector<String> urlStrings;
if (names.contains("urls")) {
if (!iceServer.get("urls", urlStrings) || !urlStrings.size()) {
String urlString;
if (iceServer.get("urls", urlString)) {
urlStrings.append(urlString);
} else {
exceptionState.throwTypeError("Malformed RTCIceServer");
return nullptr;
}
}
} else if (names.contains("url")) {
String urlString;
if (iceServer.get("url", urlString)) {
urlStrings.append(urlString);
} else {
exceptionState.throwTypeError("Malformed RTCIceServer");
return nullptr;
}
} else {
exceptionState.throwTypeError("Malformed RTCIceServer");
return nullptr;
}
String username, credential;
iceServer.get("username", username);
iceServer.get("credential", credential);
for (Vector<String>::iterator iter = urlStrings.begin(); iter != urlStrings.end(); ++iter) {
KURL url(KURL(), *iter);
if (!url.isValid() || !(url.protocolIs("turn") || url.protocolIs("turns") || url.protocolIs("stun"))) {
exceptionState.throwTypeError("Malformed URL");
return nullptr;
}
rtcConfiguration->appendServer(RTCIceServer::create(url, username, credential));
}
}
return rtcConfiguration.release();
}
