Adds multiple forms of MediaStreamTrack constraints

third_party/WebKit/Source/modules/mediastream/MediaConstraintsTest.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "modules/mediastream/MediaConstraintsImpl.h"
+#include "modules/mediastream/MediaTrackConstraints.h"
 #include "public/platform/WebMediaConstraints.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "wtf/Vector.h"
+#include "wtf/text/WTFString.h"
+
+namespace blink {
 
 // The MediaTrackConstraintsTest group tests the types declared in
 // WebKit/public/platform/WebMediaConstraints.h
 TEST(MediaTrackConstraintsTest, LongConstraint)
 {
-    blink::LongConstraint rangeConstraint(nullptr);
+    LongConstraint rangeConstraint(nullptr);
     rangeConstraint.setMin(5);
     rangeConstraint.setMax(6);
     EXPECT_TRUE(rangeConstraint.matches(5));
     EXPECT_TRUE(rangeConstraint.matches(6));
     EXPECT_FALSE(rangeConstraint.matches(4));
     EXPECT_FALSE(rangeConstraint.matches(7));
-    blink::LongConstraint exactConstraint(nullptr);
+    LongConstraint exactConstraint(nullptr);
     exactConstraint.setExact(5);
     EXPECT_FALSE(exactConstraint.matches(4));
     EXPECT_TRUE(exactConstraint.matches(5));
     EXPECT_FALSE(exactConstraint.matches(6));
 }
 
 TEST(MediaTrackConstraintsTest, DoubleConstraint)
 {
-    blink::DoubleConstraint rangeConstraint(nullptr);
+    DoubleConstraint rangeConstraint(nullptr);
     EXPECT_TRUE(rangeConstraint.isEmpty());
     rangeConstraint.setMin(5.0);
     rangeConstraint.setMax(6.5);
     EXPECT_FALSE(rangeConstraint.isEmpty());
     // Matching within epsilon
-    EXPECT_TRUE(rangeConstraint.matches(5.0 - blink::DoubleConstraint::kConstraintEpsilon / 2));
-    EXPECT_TRUE(rangeConstraint.matches(6.5 + blink::DoubleConstraint::kConstraintEpsilon / 2));
-    blink::DoubleConstraint exactConstraint(nullptr);
+    EXPECT_TRUE(rangeConstraint.matches(5.0 - DoubleConstraint::kConstraintEpsilon / 2));
+    EXPECT_TRUE(rangeConstraint.matches(6.5 + DoubleConstraint::kConstraintEpsilon / 2));
+    DoubleConstraint exactConstraint(nullptr);
     exactConstraint.setExact(5.0);
     EXPECT_FALSE(rangeConstraint.isEmpty());
     EXPECT_FALSE(exactConstraint.matches(4.9));
     EXPECT_TRUE(exactConstraint.matches(5.0));
-    EXPECT_TRUE(exactConstraint.matches(5.0 - blink::DoubleConstraint::kConstraintEpsilon / 2));
-    EXPECT_TRUE(exactConstraint.matches(5.0 + blink::DoubleConstraint::kConstraintEpsilon / 2));
+    EXPECT_TRUE(exactConstraint.matches(5.0 - DoubleConstraint::kConstraintEpsilon / 2));
+    EXPECT_TRUE(exactConstraint.matches(5.0 + DoubleConstraint::kConstraintEpsilon / 2));
     EXPECT_FALSE(exactConstraint.matches(5.1));
 }
 
 TEST(MediaTrackConstraintsTest, BooleanConstraint)
 {
-    blink::BooleanConstraint boolConstraint(nullptr);
+    BooleanConstraint boolConstraint(nullptr);
     EXPECT_TRUE(boolConstraint.isEmpty());
     EXPECT_TRUE(boolConstraint.matches(false));
     EXPECT_TRUE(boolConstraint.matches(true));
     boolConstraint.setExact(false);
     EXPECT_FALSE(boolConstraint.isEmpty());
     EXPECT_FALSE(boolConstraint.matches(true));
     EXPECT_TRUE(boolConstraint.matches(false));
     boolConstraint.setExact(true);
     EXPECT_FALSE(boolConstraint.matches(false));
     EXPECT_TRUE(boolConstraint.matches(true));
 }
 
 TEST(MediaTrackConstraintsTest, ConstraintSetEmpty)
 {
-    blink::WebMediaTrackConstraintSet theSet;
+    WebMediaTrackConstraintSet theSet;
     EXPECT_TRUE(theSet.isEmpty());
     theSet.echoCancellation.setExact(false);
     EXPECT_FALSE(theSet.isEmpty());
 }
 
 TEST(MediaTrackConstraintsTest, ConstraintName)
 {
     const char* theName = "name";
-    blink::BooleanConstraint boolConstraint(theName);
+    BooleanConstraint boolConstraint(theName);
     EXPECT_EQ(theName, boolConstraint.name());
 }
 
 TEST(MediaTrackConstraintsTest, MandatoryChecks)
 {
-    blink::WebMediaTrackConstraintSet theSet;
+    WebMediaTrackConstraintSet theSet;
     std::string foundName;
     EXPECT_FALSE(theSet.hasMandatory());
     EXPECT_FALSE(theSet.hasMandatoryOutsideSet({ "width" }, foundName));
     EXPECT_FALSE(theSet.width.hasMandatory());
     theSet.width.setMax(240);
     EXPECT_TRUE(theSet.width.hasMandatory());
     EXPECT_TRUE(theSet.hasMandatory());
     EXPECT_FALSE(theSet.hasMandatoryOutsideSet({ "width" }, foundName));
     EXPECT_TRUE(theSet.hasMandatoryOutsideSet({ "height" }, foundName));
     EXPECT_EQ("width", foundName);
     theSet.googPayloadPadding.setExact(true);
     EXPECT_TRUE(theSet.hasMandatoryOutsideSet({ "width" }, foundName));
     EXPECT_EQ("googPayloadPadding", foundName);
 }
 
 TEST(MediaTrackConstraintsTest, SetToString)
 {
-    blink::WebMediaTrackConstraintSet theSet;
+    WebMediaTrackConstraintSet theSet;
     EXPECT_EQ("", theSet.toString());
     theSet.width.setMax(240);
     EXPECT_EQ("width: {max: 240}", theSet.toString().utf8());
     theSet.echoCancellation.setIdeal(true);
     EXPECT_EQ("width: {max: 240}, echoCancellation: {ideal: true}", theSet.toString().utf8());
 }
 
 TEST(MediaTrackConstraintsTest, ConstraintsToString)
 {
-    blink::WebMediaConstraints theConstraints;
-    blink::WebMediaTrackConstraintSet basic;
-    blink::WebVector<blink::WebMediaTrackConstraintSet> advanced(static_cast<size_t>(1));
+    WebMediaConstraints theConstraints;
+    WebMediaTrackConstraintSet basic;
+    WebVector<WebMediaTrackConstraintSet> advanced(static_cast<size_t>(1));
     basic.width.setMax(240);
     advanced[0].echoCancellation.setExact(true);
     theConstraints.initialize(basic, advanced);
     EXPECT_EQ("{width: {max: 240}, advanced: [{echoCancellation: {exact: true}}]}", theConstraints.toString().utf8());
 
-    blink::WebMediaConstraints nullConstraints;
+    WebMediaConstraints nullConstraints;
     EXPECT_EQ("", nullConstraints.toString().utf8());
 }
+
+TEST(MediaTrackConstraintsTest, ConvertWebConstraintsBasic)
+{
+    WebMediaConstraints input;
+    MediaTrackConstraints output;
+
+    MediaConstraintsImpl::convertConstraints(input, output);
+}
+
+TEST(MediaTrackConstraintsTest, ConvertWebSingleStringConstraint)
+{
+    WebMediaConstraints input;
+    MediaTrackConstraints output;
+
+    WebMediaTrackConstraintSet basic;
+    WebVector<WebMediaTrackConstraintSet> advanced;
+
+    basic.facingMode.setIdeal(WebVector<WebString>(Vector<String>(1, String("foo"))));

[tommi (sloooow) - chröme, 2016/05/24 21:36:41]

Thanks for making this explicit.  It's not exactly what I'm after but it does
highlight that we're creating a string to create a vector that we copy into
another vector that has a different type of strings (the 3rd type) so that we
have the right kind of vector.

WebString does support being initialized from static strings.  WebVector is a
simple template wrapper around std::vector.
So, how about this instead:

    basic.facingMode.setIdeal(WebVector<WebString>(&"foo", 1));

This avoids creating an extra vector and extra string.

Also, if you only needed the #includes to be able to use String and Vector, then
you shouldn't need those anymore (right?)

[hta - Chromium, 2016/05/25 07:02:41]

Thanks for finding that constructor - I'd been looking for it, but didn't find
it!

(BTW, it doesn't work when the argument is a function return value.)

+    input.initialize(basic, advanced);
+    MediaConstraintsImpl::convertConstraints(input, output);
+    ASSERT_TRUE(output.hasFacingMode());
+    ASSERT_TRUE(output.facingMode().isString());
+    EXPECT_EQ("foo", output.facingMode().getAsString());
+}
+
+TEST(MediaTrackConstraintsTest, ConvertWebDoubleStringConstraint)
+{
+    WebMediaConstraints input;
+    MediaTrackConstraints output;
+
+    WebMediaTrackConstraintSet basic;
+    std::vector<WebMediaTrackConstraintSet> advanced;

[tommi (sloooow) - chröme, 2016/05/24 21:36:41]

Btw, the general style guide rule for Chromium and Google is to keep variables
close to where they're used (ideally RAII).  I don't know if it is against the
blink convention, but since blink will eventually follow Chromium as far as
style goes, I think it doesn't hurt to keep that in mind.

[hta - Chromium, 2016/05/25 07:02:41]

Moved to where they're used. Since it's two arguments to one function, I kept
the declarations of the two together.

+    Vector<String> buffer;
+    buffer.append(String("foo"));
+    buffer.append(String("bar"));
+
+    basic.facingMode.setIdeal(WebVector<WebString>(buffer));

[tommi (sloooow) - chröme, 2016/05/24 21:36:41]

this can be replaced with:

    WebVector<WebString> buffer(static_cast<size_t>(2u));
    buffer[0] = "foo";
    buffer[1] = "bar";
    basic.facingMode.setIdeal(buffer);

[hta - Chromium, 2016/05/25 07:02:41]

So WebVector is in fact mutable, not just assignable, unlike a lot of other Web*
types... changed.

+    input.initialize(basic, advanced);
+    MediaConstraintsImpl::convertConstraints(input, output);
+    ASSERT_TRUE(output.hasFacingMode());
+    ASSERT_TRUE(output.facingMode().isStringSequence());
+    auto outBuffer = output.facingMode().getAsStringSequence();
+    EXPECT_EQ("foo", outBuffer[0]);
+    EXPECT_EQ("bar", outBuffer[1]);
+}
+
+TEST(MediaTrackConstraintsTest, ConvertBlinkStringConstraint)
+{
+    MediaTrackConstraints input;
+    WebMediaConstraints output;
+    StringOrStringSequenceOrConstrainDOMStringParameters parameter;
+    parameter.setString("foo");
+    input.setFacingMode(parameter);
+    output = MediaConstraintsImpl::convertConstraintsToWeb(input);
+    ASSERT_TRUE(output.basic().facingMode.hasIdeal());
+    ASSERT_EQ(1U, output.basic().facingMode.ideal().size());
+    ASSERT_EQ("foo", output.basic().facingMode.ideal()[0]);
+}
+
+TEST(MediaTrackConstraintsTest, ConvertBlinkComplexStringConstraint)
+{
+    MediaTrackConstraints input;
+    WebMediaConstraints output;
+    StringOrStringSequenceOrConstrainDOMStringParameters parameter;
+    ConstrainDOMStringParameters subparameter;
+    StringOrStringSequence innerString;
+    innerString.setString("foo");
+    subparameter.setIdeal(innerString);
+    parameter.setConstrainDOMStringParameters(subparameter);
+    input.setFacingMode(parameter);
+    output = MediaConstraintsImpl::convertConstraintsToWeb(input);
+    ASSERT_TRUE(output.basic().facingMode.hasIdeal());
+    ASSERT_EQ(1U, output.basic().facingMode.ideal().size());
+    ASSERT_EQ("foo", output.basic().facingMode.ideal()[0]);
+
+    // Convert this back, and see that it appears as a single string.
+    MediaTrackConstraints recycled;
+    MediaConstraintsImpl::convertConstraints(output, recycled);
+    ASSERT_TRUE(recycled.hasFacingMode());
+    ASSERT_TRUE(recycled.facingMode().isString());
+    ASSERT_EQ("foo", recycled.facingMode().getAsString());
+}
+
+} // namespace blink