Make naked values in constraint behave right in "advanced"

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 29 matching lines @@
 #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 {
 
+// A naked value is treated as an "ideal" value in the basic constraints,
+// but as an exact value in "advanced" constraints.
+// https://w3c.github.io/mediacapture-main/#constrainable-interface
+enum class NakedValueDisposition { kTreatAsIdeal, kTreatAsExact };
+
 // Old type/value form of constraint. Used in parsing old-style constraints.
 struct NameValueStringConstraint {
   NameValueStringConstraint() {}
 
   NameValueStringConstraint(WebString name, WebString value)
       : m_name(name), m_value(value) {}
 
   WebString m_name;
   WebString m_value;
 };
@@ skipping 418 matching lines @@
   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 LongOrConstrainLongRange& blinkUnionForm,
+                        NakedValueDisposition nakedTreatment,
                         LongConstraint& webForm) {
   if (blinkUnionForm.isLong()) {
-    webForm.setIdeal(blinkUnionForm.getAsLong());
+    switch (nakedTreatment) {
+      case NakedValueDisposition::kTreatAsIdeal:
+        webForm.setIdeal(blinkUnionForm.getAsLong());
+        break;
+      case NakedValueDisposition::kTreatAsExact:
+        webForm.setExact(blinkUnionForm.getAsLong());
+        break;
+    }
     return;
   }
   const auto& blinkForm = blinkUnionForm.getAsConstrainLongRange();
   if (blinkForm.hasMin()) {
     webForm.setMin(blinkForm.min());
   }
   if (blinkForm.hasMax()) {
     webForm.setMax(blinkForm.max());
   }
   if (blinkForm.hasIdeal()) {
     webForm.setIdeal(blinkForm.ideal());
   }
   if (blinkForm.hasExact()) {
     webForm.setExact(blinkForm.exact());
   }
 }
 
 void copyDoubleConstraint(const DoubleOrConstrainDoubleRange& blinkUnionForm,
+                          NakedValueDisposition nakedTreatment,
                           DoubleConstraint& webForm) {
   if (blinkUnionForm.isDouble()) {
-    webForm.setIdeal(blinkUnionForm.getAsDouble());
+    switch (nakedTreatment) {
+      case NakedValueDisposition::kTreatAsIdeal:
+        webForm.setIdeal(blinkUnionForm.getAsDouble());
+        break;
+      case NakedValueDisposition::kTreatAsExact:
+        webForm.setExact(blinkUnionForm.getAsDouble());
+        break;
+    }
     return;
   }
   const auto& blinkForm = blinkUnionForm.getAsConstrainDoubleRange();
   if (blinkForm.hasMin()) {
     webForm.setMin(blinkForm.min());
   }
   if (blinkForm.hasMax()) {
     webForm.setMax(blinkForm.max());
   }
   if (blinkForm.hasIdeal()) {
     webForm.setIdeal(blinkForm.ideal());
   }
   if (blinkForm.hasExact()) {
     webForm.setExact(blinkForm.exact());
   }
 }
 
 void copyStringConstraint(
     const StringOrStringSequenceOrConstrainDOMStringParameters& blinkUnionForm,
+    NakedValueDisposition nakedTreatment,
     StringConstraint& webForm) {
   if (blinkUnionForm.isString()) {
-    webForm.setIdeal(Vector<String>(1, blinkUnionForm.getAsString()));
+    switch (nakedTreatment) {
+      case NakedValueDisposition::kTreatAsIdeal:
+        webForm.setIdeal(Vector<String>(1, blinkUnionForm.getAsString()));
+        break;
+      case NakedValueDisposition::kTreatAsExact:
+        webForm.setExact(Vector<String>(1, blinkUnionForm.getAsString()));
+
+        break;
+    }
     return;
   }
   if (blinkUnionForm.isStringSequence()) {
-    webForm.setIdeal(blinkUnionForm.getAsStringSequence());
+    switch (nakedTreatment) {
+      case NakedValueDisposition::kTreatAsIdeal:
+        webForm.setIdeal(blinkUnionForm.getAsStringSequence());
+        break;
+      case NakedValueDisposition::kTreatAsExact:
+        webForm.setExact(blinkUnionForm.getAsStringSequence());
+        break;
+    }
     return;
   }
   const auto& blinkForm = blinkUnionForm.getAsConstrainDOMStringParameters();
   if (blinkForm.hasIdeal()) {
     if (blinkForm.ideal().isStringSequence()) {
       webForm.setIdeal(blinkForm.ideal().getAsStringSequence());
     } else if (blinkForm.ideal().isString()) {
       webForm.setIdeal(Vector<String>(1, blinkForm.ideal().getAsString()));
     }
   }
   if (blinkForm.hasExact()) {
     if (blinkForm.exact().isStringSequence()) {
       webForm.setExact(blinkForm.exact().getAsStringSequence());
     } else if (blinkForm.exact().isString()) {
       webForm.setExact(Vector<String>(1, blinkForm.exact().getAsString()));
     }
   }
 }
 
 void copyBooleanConstraint(
     const BooleanOrConstrainBooleanParameters& blinkUnionForm,
+    NakedValueDisposition nakedTreatment,
     BooleanConstraint& webForm) {
   if (blinkUnionForm.isBoolean()) {
-    webForm.setIdeal(blinkUnionForm.getAsBoolean());
+    switch (nakedTreatment) {
+      case NakedValueDisposition::kTreatAsIdeal:
+        webForm.setIdeal(blinkUnionForm.getAsBoolean());
+        break;
+      case NakedValueDisposition::kTreatAsExact:
+        webForm.setExact(blinkUnionForm.getAsBoolean());
+        break;
+    }
     return;
   }
   const auto& blinkForm = blinkUnionForm.getAsConstrainBooleanParameters();
   if (blinkForm.hasIdeal()) {
     webForm.setIdeal(blinkForm.ideal());
   }
   if (blinkForm.hasExact()) {
     webForm.setExact(blinkForm.exact());
   }
 }
 
 void copyConstraintSet(const MediaTrackConstraintSet& constraintsIn,
+                       NakedValueDisposition nakedTreatment,
                        WebMediaTrackConstraintSet& constraintBuffer) {
   if (constraintsIn.hasWidth()) {
-    copyLongConstraint(constraintsIn.width(), constraintBuffer.width);
+    copyLongConstraint(constraintsIn.width(), nakedTreatment,
+                       constraintBuffer.width);
   }
   if (constraintsIn.hasHeight()) {
-    copyLongConstraint(constraintsIn.height(), constraintBuffer.height);
+    copyLongConstraint(constraintsIn.height(), nakedTreatment,
+                       constraintBuffer.height);
   }
   if (constraintsIn.hasAspectRatio()) {
-    copyDoubleConstraint(constraintsIn.aspectRatio(),
+    copyDoubleConstraint(constraintsIn.aspectRatio(), nakedTreatment,
                          constraintBuffer.aspectRatio);
   }
   if (constraintsIn.hasFrameRate()) {
-    copyDoubleConstraint(constraintsIn.frameRate(), constraintBuffer.frameRate);
+    copyDoubleConstraint(constraintsIn.frameRate(), nakedTreatment,
+                         constraintBuffer.frameRate);
   }
   if (constraintsIn.hasFacingMode()) {
-    copyStringConstraint(constraintsIn.facingMode(),
+    copyStringConstraint(constraintsIn.facingMode(), nakedTreatment,
                          constraintBuffer.facingMode);
   }
   if (constraintsIn.hasVolume()) {
-    copyDoubleConstraint(constraintsIn.volume(), constraintBuffer.volume);
+    copyDoubleConstraint(constraintsIn.volume(), nakedTreatment,
+                         constraintBuffer.volume);
   }
   if (constraintsIn.hasSampleRate()) {
-    copyLongConstraint(constraintsIn.sampleRate(), constraintBuffer.sampleRate);
+    copyLongConstraint(constraintsIn.sampleRate(), nakedTreatment,
+                       constraintBuffer.sampleRate);
   }
   if (constraintsIn.hasSampleSize()) {
-    copyLongConstraint(constraintsIn.sampleSize(), constraintBuffer.sampleSize);
+    copyLongConstraint(constraintsIn.sampleSize(), nakedTreatment,
+                       constraintBuffer.sampleSize);
   }
   if (constraintsIn.hasEchoCancellation()) {
-    copyBooleanConstraint(constraintsIn.echoCancellation(),
+    copyBooleanConstraint(constraintsIn.echoCancellation(), nakedTreatment,
                           constraintBuffer.echoCancellation);
   }
   if (constraintsIn.hasLatency()) {
-    copyDoubleConstraint(constraintsIn.latency(), constraintBuffer.latency);
+    copyDoubleConstraint(constraintsIn.latency(), nakedTreatment,
+                         constraintBuffer.latency);
   }
   if (constraintsIn.hasChannelCount()) {
-    copyLongConstraint(constraintsIn.channelCount(),
+    copyLongConstraint(constraintsIn.channelCount(), nakedTreatment,
                        constraintBuffer.channelCount);
   }
   if (constraintsIn.hasDeviceId()) {
-    copyStringConstraint(constraintsIn.deviceId(), constraintBuffer.deviceId);
+    copyStringConstraint(constraintsIn.deviceId(), nakedTreatment,
+                         constraintBuffer.deviceId);
   }
   if (constraintsIn.hasGroupId()) {
-    copyStringConstraint(constraintsIn.groupId(), constraintBuffer.groupId);
+    copyStringConstraint(constraintsIn.groupId(), nakedTreatment,
+                         constraintBuffer.groupId);
   }
 }
 
 WebMediaConstraints convertConstraintsToWeb(
     const MediaTrackConstraints& constraintsIn) {
   WebMediaConstraints constraints;
   WebMediaTrackConstraintSet constraintBuffer;
   Vector<WebMediaTrackConstraintSet> advancedBuffer;
-  copyConstraintSet(constraintsIn, constraintBuffer);
+  copyConstraintSet(constraintsIn, NakedValueDisposition::kTreatAsIdeal,
+                    constraintBuffer);
   if (constraintsIn.hasAdvanced()) {
     for (const auto& element : constraintsIn.advanced()) {
       WebMediaTrackConstraintSet advancedElement;
-      copyConstraintSet(element, advancedElement);
+      copyConstraintSet(element, NakedValueDisposition::kTreatAsExact,
+                        advancedElement);
       advancedBuffer.append(advancedElement);
     }
   }
   constraints.initialize(constraintBuffer, advancedBuffer);
   return constraints;
 }
 
 WebMediaConstraints create(ExecutionContext* context,
                            const MediaTrackConstraints& constraintsIn,
                            MediaErrorState& errorState) {
@@ skipping 18 matching lines @@
   UseCounter::count(context, UseCounter::MediaStreamConstraintsConformant);
   return standardForm;
 }
 
 WebMediaConstraints create() {
   WebMediaConstraints constraints;
   constraints.initialize();
   return constraints;
 }
 
-LongOrConstrainLongRange convertLong(const LongConstraint& input) {
+template <class T>
+bool useNakedNumeric(T input, NakedValueDisposition which) {
+  switch (which) {
+    case NakedValueDisposition::kTreatAsIdeal:
+      return input.hasIdeal() &&
+             !(input.hasExact() || input.hasMin() || input.hasMax());
+      break;
+    case NakedValueDisposition::kTreatAsExact:
+      return input.hasExact() &&
+             !(input.hasIdeal() || input.hasMin() || input.hasMax());
+      break;
+  }
+  NOTREACHED();
+  return false;
+};
+
+template <class T>
+bool useNakedNonNumeric(T input, NakedValueDisposition which) {
+  switch (which) {
+    case NakedValueDisposition::kTreatAsIdeal:
+      return input.hasIdeal() && !input.hasExact();
+      break;
+    case NakedValueDisposition::kTreatAsExact:
+      return input.hasExact() && !input.hasIdeal();
+      break;
+  }
+  NOTREACHED();
+  return false;
+};
+
+template <typename U, class T>
+U getNakedValue(T input, NakedValueDisposition which) {
+  switch (which) {
+    case NakedValueDisposition::kTreatAsIdeal:
+      return input.ideal();
+      break;
+    case NakedValueDisposition::kTreatAsExact:
+      return input.exact();
+      break;
+  }
+  NOTREACHED();
+  return input.exact();
+};
+
+LongOrConstrainLongRange convertLong(const LongConstraint& input,
+                                     NakedValueDisposition nakedTreatment) {
   LongOrConstrainLongRange outputUnion;
-  if (input.hasExact() || input.hasMin() || input.hasMax()) {
+  if (useNakedNumeric(input, nakedTreatment)) {
+    outputUnion.setLong(getNakedValue<long>(input, nakedTreatment));
+  } else if (!input.isEmpty()) {
     ConstrainLongRange output;
     if (input.hasExact())
       output.setExact(input.exact());
     if (input.hasMin())
       output.setMin(input.min());
     if (input.hasMax())
       output.setMax(input.max());
     if (input.hasIdeal())
       output.setIdeal(input.ideal());
     outputUnion.setConstrainLongRange(output);
-  } else {
-    if (input.hasIdeal()) {
-      outputUnion.setLong(input.ideal());
-    }
   }
   return outputUnion;
 }
 
-DoubleOrConstrainDoubleRange convertDouble(const DoubleConstraint& input) {
+DoubleOrConstrainDoubleRange convertDouble(
+    const DoubleConstraint& input,
+    NakedValueDisposition nakedTreatment) {
   DoubleOrConstrainDoubleRange outputUnion;
-  if (input.hasExact() || input.hasMin() || input.hasMax()) {
+  if (useNakedNumeric(input, nakedTreatment)) {
+    outputUnion.setDouble(getNakedValue<double>(input, nakedTreatment));
+  } else if (!input.isEmpty()) {
     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());
     outputUnion.setConstrainDoubleRange(output);
-  } else {
-    if (input.hasIdeal()) {
-      outputUnion.setDouble(input.ideal());
-    }
   }
   return outputUnion;
 }
 
 StringOrStringSequence convertStringSequence(
     const WebVector<WebString>& input) {
   StringOrStringSequence theStrings;
   if (input.size() > 1) {
     Vector<String> buffer;
     for (const auto& scanner : input)
       buffer.append(scanner);
     theStrings.setStringSequence(buffer);
   } else if (input.size() > 0) {
     theStrings.setString(input[0]);
   }
   return theStrings;
 }
 
 StringOrStringSequenceOrConstrainDOMStringParameters convertString(
-    const StringConstraint& input) {
+    const StringConstraint& input,
+    NakedValueDisposition nakedTreatment) {
   StringOrStringSequenceOrConstrainDOMStringParameters outputUnion;
-  if (input.hasExact()) {
-    ConstrainDOMStringParameters output;
-    output.setExact(convertStringSequence(input.exact()));
-    if (input.hasIdeal()) {
-      output.setIdeal(convertStringSequence(input.ideal()));
-    }
-    outputUnion.setConstrainDOMStringParameters(output);
-  } else if (input.hasIdeal()) {
-    if (input.ideal().size() > 1) {
+  if (useNakedNonNumeric(input, nakedTreatment)) {
+    WebVector<WebString> inputBuffer(
+        getNakedValue<WebVector<WebString>>(input, nakedTreatment));
+    if (inputBuffer.size() > 1) {
       Vector<String> buffer;
-      for (const auto& scanner : input.ideal())
+      for (const auto& scanner : inputBuffer)
         buffer.append(scanner);
       outputUnion.setStringSequence(buffer);
-    } else if (input.ideal().size() == 1) {
-      outputUnion.setString(input.ideal()[0]);
+    } else if (inputBuffer.size() > 0) {
+      outputUnion.setString(inputBuffer[0]);
     }
+  } else if (!input.isEmpty()) {
+    ConstrainDOMStringParameters output;
+    if (input.hasExact())
+      output.setExact(convertStringSequence(input.exact()));
+    if (input.hasIdeal())
+      output.setIdeal(convertStringSequence(input.ideal()));
+    outputUnion.setConstrainDOMStringParameters(output);
   }
   return outputUnion;
 }
 
 BooleanOrConstrainBooleanParameters convertBoolean(
-    const BooleanConstraint& input) {
+    const BooleanConstraint& input,
+    NakedValueDisposition nakedTreatment) {
   BooleanOrConstrainBooleanParameters outputUnion;
-  if (input.hasExact()) {
+  if (useNakedNonNumeric(input, nakedTreatment)) {
+    outputUnion.setBoolean(getNakedValue<bool>(input, nakedTreatment));
+  } else if (!input.isEmpty()) {
     ConstrainBooleanParameters output;
     if (input.hasExact())
       output.setExact(input.exact());
     if (input.hasIdeal())
       output.setIdeal(input.ideal());
     outputUnion.setConstrainBooleanParameters(output);
-  } else if (input.hasIdeal()) {
-    outputUnion.setBoolean(input.ideal());
   }
   return outputUnion;
 }
 
 void convertConstraintSet(const WebMediaTrackConstraintSet& input,
+                          NakedValueDisposition nakedTreatment,
                           MediaTrackConstraintSet& output) {
   if (!input.width.isEmpty())
-    output.setWidth(convertLong(input.width));
+    output.setWidth(convertLong(input.width, nakedTreatment));
   if (!input.height.isEmpty())
-    output.setHeight(convertLong(input.height));
+    output.setHeight(convertLong(input.height, nakedTreatment));
   if (!input.aspectRatio.isEmpty())
-    output.setAspectRatio(convertDouble(input.aspectRatio));
+    output.setAspectRatio(convertDouble(input.aspectRatio, nakedTreatment));
   if (!input.frameRate.isEmpty())
-    output.setFrameRate(convertDouble(input.frameRate));
+    output.setFrameRate(convertDouble(input.frameRate, nakedTreatment));
   if (!input.facingMode.isEmpty())
-    output.setFacingMode(convertString(input.facingMode));
+    output.setFacingMode(convertString(input.facingMode, nakedTreatment));
   if (!input.volume.isEmpty())
-    output.setVolume(convertDouble(input.volume));
+    output.setVolume(convertDouble(input.volume, nakedTreatment));
   if (!input.sampleRate.isEmpty())
-    output.setSampleRate(convertLong(input.sampleRate));
+    output.setSampleRate(convertLong(input.sampleRate, nakedTreatment));
   if (!input.sampleSize.isEmpty())
-    output.setSampleSize(convertLong(input.sampleSize));
-  if (!input.echoCancellation.isEmpty())
-    output.setEchoCancellation(convertBoolean(input.echoCancellation));
+    output.setSampleSize(convertLong(input.sampleSize, nakedTreatment));
+  if (!input.echoCancellation.isEmpty()) {
+    output.setEchoCancellation(
+        convertBoolean(input.echoCancellation, nakedTreatment));
+  }
   if (!input.latency.isEmpty())
-    output.setLatency(convertDouble(input.latency));
+    output.setLatency(convertDouble(input.latency, nakedTreatment));
   if (!input.channelCount.isEmpty())
-    output.setChannelCount(convertLong(input.channelCount));
+    output.setChannelCount(convertLong(input.channelCount, nakedTreatment));
   if (!input.deviceId.isEmpty())
-    output.setDeviceId(convertString(input.deviceId));
+    output.setDeviceId(convertString(input.deviceId, nakedTreatment));
   if (!input.groupId.isEmpty())
-    output.setGroupId(convertString(input.groupId));
+    output.setGroupId(convertString(input.groupId, nakedTreatment));
   // 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);
+  convertConstraintSet(input.basic(), NakedValueDisposition::kTreatAsIdeal,
+                       output);
   HeapVector<MediaTrackConstraintSet> advancedVector;
   for (const auto& it : input.advanced()) {
     MediaTrackConstraintSet element;
-    convertConstraintSet(it, element);
+    convertConstraintSet(it, NakedValueDisposition::kTreatAsExact, element);
     advancedVector.append(element);
   }
   if (!advancedVector.isEmpty())
     output.setAdvanced(advancedVector);
 }
 
 }  // namespace MediaConstraintsImpl
 }  // namespace blink