Adds multiple forms of MediaStreamTrack constraints

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 435 matching lines @@
     Vector<NameValueStringConstraint> optional;
     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 ConstrainLongRange& blinkForm, LongConstraint& webForm)
+void copyLongConstraint(const LongOrConstrainLongRange& blinkUnionForm, LongConstraint& webForm)
 {
+    if (blinkUnionForm.isLong()) {
+        webForm.setIdeal(blinkUnionForm.getAsLong());
+        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 ConstrainDoubleRange& blinkForm, DoubleConstraint& webForm)
+void copyDoubleConstraint(const DoubleOrConstrainDoubleRange& blinkUnionForm, DoubleConstraint& webForm)
 {
+    if (blinkUnionForm.isDouble()) {
+        webForm.setIdeal(blinkUnionForm.getAsDouble());
+        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 ConstrainDOMStringParameters& blinkForm, StringConstraint& webForm)
+void copyStringConstraint(const StringOrStringSequenceOrConstrainDOMStringParameters& blinkUnionForm, StringConstraint& webForm)
 {
+    if (blinkUnionForm.isString()) {
+        webForm.setIdeal(Vector<String>(1, blinkUnionForm.getAsString()));
+        return;
+    }
+    if (blinkUnionForm.isStringSequence()) {
+        webForm.setIdeal(blinkUnionForm.getAsStringSequence());
+        return;
+    }
+    const auto& blinkForm = blinkUnionForm.getAsConstrainDOMStringParameters();
     if (blinkForm.hasIdeal()) {
-        webForm.setIdeal(WebVector<WebString>(blinkForm.ideal()));
+        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()) {
-        webForm.setExact(WebVector<WebString>(blinkForm.exact()));
+        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 ConstrainBooleanParameters& blinkForm, BooleanConstraint& webForm)
+void copyBooleanConstraint(const BooleanOrConstrainBooleanParameters& blinkUnionForm, BooleanConstraint& webForm)
 {
+    if (blinkUnionForm.isBoolean()) {
+        webForm.setIdeal(blinkUnionForm.getAsBoolean());
+        return;
+    }
+    const auto& blinkForm = blinkUnionForm.getAsConstrainBooleanParameters();
     if (blinkForm.hasIdeal()) {
         webForm.setIdeal(blinkForm.ideal());
     }
     if (blinkForm.hasExact()) {
         webForm.setExact(blinkForm.exact());
     }
 }
 
-void copyConstraints(const MediaTrackConstraintSet& constraintsIn, WebMediaTrackConstraintSet& constraintBuffer)
+void copyConstraintSet(const MediaTrackConstraintSet& constraintsIn, WebMediaTrackConstraintSet& constraintBuffer)
 {
     if (constraintsIn.hasWidth()) {
         copyLongConstraint(constraintsIn.width(), constraintBuffer.width);
     }
     if (constraintsIn.hasHeight()) {
         copyLongConstraint(constraintsIn.height(), constraintBuffer.height);
     }
     if (constraintsIn.hasAspectRatio()) {
         copyDoubleConstraint(constraintsIn.aspectRatio(), constraintBuffer.aspectRatio);
     }
@@ skipping 22 matching lines @@
         copyLongConstraint(constraintsIn.channelCount(), constraintBuffer.channelCount);
     }
     if (constraintsIn.hasDeviceId()) {
         copyStringConstraint(constraintsIn.deviceId(), constraintBuffer.deviceId);
     }
     if (constraintsIn.hasGroupId()) {
         copyStringConstraint(constraintsIn.groupId(), constraintBuffer.groupId);
     }
 }
 
+WebMediaConstraints convertConstraintsToWeb(const MediaTrackConstraints& constraintsIn)
+{
+    WebMediaConstraints constraints;
+    WebMediaTrackConstraintSet constraintBuffer;
+    Vector<WebMediaTrackConstraintSet> advancedBuffer;
+    copyConstraintSet(constraintsIn, constraintBuffer);
+    if (constraintsIn.hasAdvanced()) {
+        for (const auto& element : constraintsIn.advanced()) {
+            WebMediaTrackConstraintSet advancedElement;
+            copyConstraintSet(element, advancedElement);
+            advancedBuffer.append(advancedElement);
+        }
+    }
+    constraints.initialize(constraintBuffer, advancedBuffer);
+    return constraints;
+}
+
 WebMediaConstraints create(ExecutionContext* context, const MediaTrackConstraints& constraintsIn, MediaErrorState& errorState)
 {
-    WebMediaConstraints constraints;
-    WebMediaTrackConstraintSet constraintBuffer;
-    Vector<WebMediaTrackConstraintSet> advancedBuffer;
-    copyConstraints(constraintsIn, constraintBuffer);
-    if (constraintsIn.hasAdvanced()) {
-        for (const auto& element : constraintsIn.advanced()) {
-            WebMediaTrackConstraintSet advancedElement;
-            copyConstraints(element, advancedElement);
-            advancedBuffer.append(advancedElement);
-        }
-    }
-    // TODO(hta): Add initialization of advanced constraints once present.
-    // https://crbug.com/253412
+    WebMediaConstraints standardForm = convertConstraintsToWeb(constraintsIn);
     if (constraintsIn.hasOptional() || constraintsIn.hasMandatory()) {
-        if (!constraintBuffer.isEmpty() || constraintsIn.hasAdvanced()) {
+        if (!standardForm.isEmpty()) {
             errorState.throwTypeError("Malformed constraint: Cannot use both optional/mandatory and specific or advanced constraints.");
             return WebMediaConstraints();
         }
         Vector<NameValueStringConstraint> optional;
         Vector<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;
+    return standardForm;
 }
 
 WebMediaConstraints create()
 {
     WebMediaConstraints constraints;
     constraints.initialize();
     return constraints;
 }
 
-ConstrainLongRange convertLong(const LongConstraint& input)
+LongOrConstrainLongRange 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;
+    LongOrConstrainLongRange outputUnion;
+    if (input.hasExact() || input.hasMin() || input.hasMax()) {
+        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;
 }
 
-ConstrainDoubleRange convertDouble(const DoubleConstraint& input)
+DoubleOrConstrainDoubleRange 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;
+    DoubleOrConstrainDoubleRange outputUnion;
+    if (input.hasExact() || input.hasMin() || input.hasMax()) {
+        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;
 }
 
-ConstrainDOMStringParameters convertString(const StringConstraint& input)
+StringOrStringSequence convertStringSequence(const WebVector<WebString>& input)
 {
-    ConstrainDOMStringParameters output;
-    if (input.hasIdeal()) {
+    StringOrStringSequence theStrings;
+    if (input.size() > 1) {
         Vector<String> buffer;
-        for (const auto& scanner : input.ideal())
+        for (const auto& scanner : input)
             buffer.append(scanner);
-        output.setIdeal(buffer);
+        theStrings.setStringSequence(buffer);
+    } else if (input.size() > 0) {
+        theStrings.setString(input[0]);
     }
-    if (input.hasExact()) {
-        Vector<String> buffer;
-        for (const auto& scanner : input.exact())
-            buffer.append(scanner);
-        output.setExact(buffer);
-    }
-    return output;
+    return theStrings;
 }
 
-ConstrainBooleanParameters convertBoolean(const BooleanConstraint& input)
+StringOrStringSequenceOrConstrainDOMStringParameters convertString(const StringConstraint& input)
 {
+    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) {
+            Vector<String> buffer;
+            for (const auto& scanner : input.ideal())
+                buffer.append(scanner);
+            outputUnion.setStringSequence(buffer);
+        } else if (input.ideal().size() == 1) {
+            outputUnion.setString(input.ideal()[0]);
+        }
+    }
+    return outputUnion;
+}
 
-    ConstrainBooleanParameters output;
-    if (input.hasExact())
-        output.setExact(input.exact());
-    if (input.hasIdeal())
-        output.setIdeal(input.ideal());
-    return output;
+BooleanOrConstrainBooleanParameters convertBoolean(const BooleanConstraint& input)
+{
+    BooleanOrConstrainBooleanParameters outputUnion;
+    if (input.hasExact()) {
+        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, 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));
@@ skipping 32 matching lines @@
         MediaTrackConstraintSet element;
         convertConstraintSet(it, element);
         advancedVector.append(element);
     }
     if (!advancedVector.isEmpty())
         output.setAdvanced(advancedVector);
 }
 
 } // namespace MediaConstraintsImpl
 } // namespace blink