Patch constraints algorithm for device video-capture sources.

content/renderer/media/media_stream_constraints_util_video_device_unittest.cc

 // Copyright 2017 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 "content/renderer/media/media_stream_constraints_util_video_device.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/optional.h"
@@ skipping 1226 matching lines @@
     // constraint is the high-res device. The 1280x720 cropped to 1200x400 is
     // the lest expensive way to achieve it.
     EXPECT_EQ(high_res_device_->device_id, result.device_id);
     EXPECT_EQ(1280, result.Width());
     EXPECT_EQ(720, result.Height());
   }
 }
 
 // The "Advanced" tests check selection criteria involving advanced constraint
 // sets.
 TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, AdvancedExactResolution) {

[hbos_chromium, 2017/02/28 11:41:54]

This name no longer matches what the test is doing.

   constraint_factory_.Reset();
   blink::WebMediaTrackConstraintSet& advanced1 =
       constraint_factory_.AddAdvanced();
-  advanced1.width.setExact(4000);
-  advanced1.height.setExact(4000);
+  advanced1.width.setMin(4000);
+  advanced1.height.setMin(4000);
   blink::WebMediaTrackConstraintSet& advanced2 =
       constraint_factory_.AddAdvanced();
-  advanced2.width.setExact(3000);
-  advanced2.height.setExact(3000);
+  advanced2.width.setMin(3000);
+  advanced2.height.setMin(3000);
   auto result = SelectSettings();
   // No device supports the advanced constraint sets.
   // Tie-breaker rule that applies is closeness to default settings.

[hbos_chromium, 2017/02/28 11:41:54]

adv1 is superflous given adv2.

What about...?
adv1: >= 4000 - not supported by any format
SelectSettings() and make sure we get default

adv2: <= 3000 - supportable but contradicting adv1,
  which is OK since adv1 cannot be supported anyway.
SelectSettings() and make sure we still get default

adv3: >= 1920 - supportable and not contradicting adv2.
SelectSettings() and make sure we get HD

I wonder if this can be improved even further by having adv2 affect which
resolution is chosen (non-default) and then having adv3 make it chose yet
another resolution so we know all sets are in play. With the current example it
could be the case that adv2 is ignored because all formats apply to it. But
maybe that would break what is happening now with adv3 changing the resolution.
I think going from default to HD is OK too. We don't want adv3 to contradict
adv2.

[Guido Urdaneta, 2017/02/28 16:44:00]

Replaced with a test where each advanced set causes a device change.

   EXPECT_EQ(default_device_->device_id, result.device_id);
   EXPECT_EQ(*default_closest_format_, result.Format());
 
   blink::WebMediaTrackConstraintSet& advanced3 =
       constraint_factory_.AddAdvanced();
-  advanced3.width.setExact(1920);
-  advanced3.height.setExact(1080);
+  advanced3.width.setMin(1920);
+  advanced3.height.setMin(1080);
   result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
   // The high-res device natively supports the third advanced constraint set
   // and should be selected.
   // First tie-breaker rule that applies is support for advanced constraints
   // that appear first. Second tie-breaker rule is custom distance to advanced
   // constraint sets that appear first.
   EXPECT_EQ(high_res_device_->device_id, result.device_id);
   EXPECT_EQ(1920, result.Width());
   EXPECT_EQ(1080, result.Height());
 
   blink::WebMediaTrackConstraintSet& advanced4 =
       constraint_factory_.AddAdvanced();
-  advanced4.width.setExact(640);
-  advanced4.height.setExact(480);
+  advanced4.width.setMin(640);
+  advanced4.height.setMin(480);
   result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
   // First tie-breaker rule that applies is support for advanced constraints
   // that appear first, which leaves out configurations that only support the
   // fourth advanced constraint set in favor of configurations that support
   // the third set.
   // Second tie-breaker rule is custom distance to advanced constraint sets
   // that appear first.
   EXPECT_EQ(high_res_device_->device_id, result.device_id);
   EXPECT_EQ(1920, result.Width());
@@ skipping 42 matching lines @@
   EXPECT_EQ(high_res_device_->device_id, result.device_id);
   EXPECT_EQ(1920, result.Width());
   EXPECT_EQ(1080, result.Height());
   EXPECT_EQ(60.0, result.FrameRate());
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, AdvancedNoiseReduction) {
   constraint_factory_.Reset();
   blink::WebMediaTrackConstraintSet& advanced1 =
       constraint_factory_.AddAdvanced();
-  advanced1.width.setExact(640);
-  advanced1.height.setExact(480);
+  advanced1.width.setMin(640);
+  advanced1.height.setMin(480);
   blink::WebMediaTrackConstraintSet& advanced2 =
       constraint_factory_.AddAdvanced();
-  advanced2.width.setExact(1920);
-  advanced2.height.setExact(1080);
+  advanced2.width.setMin(1920);
+  advanced2.height.setMin(1080);
   advanced2.googNoiseReduction.setExact(false);
   auto result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
   EXPECT_EQ(high_res_device_->device_id, result.device_id);
-  EXPECT_EQ(1920, result.Width());
-  EXPECT_EQ(1080, result.Height());
+  EXPECT_LE(1920, result.Width());
+  EXPECT_LE(1080, result.Height());
   EXPECT_TRUE(result.noise_reduction && !*result.noise_reduction);
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
        AdvancedContradictoryNoiseReduction) {
   {
     constraint_factory_.Reset();
     blink::WebMediaTrackConstraintSet& advanced1 =
         constraint_factory_.AddAdvanced();
     advanced1.width.setMin(640);
@@ skipping 30 matching lines @@
     EXPECT_TRUE(result.HasValue());
     // Only the high-res device can satisfy the second advanced set.
     EXPECT_EQ(high_res_device_->device_id, result.device_id);
     EXPECT_LE(1920, result.Width());
     EXPECT_LE(1080, result.Height());
     // Should select default noise reduction setting.
     EXPECT_TRUE(!result.noise_reduction);
   }
 }
 
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
+       AdvancedContradictoryExactResolution) {
+  constraint_factory_.Reset();
+  blink::WebMediaTrackConstraintSet& advanced1 =
+      constraint_factory_.AddAdvanced();
+  advanced1.width.setExact(640);
+  advanced1.height.setExact(480);
+  blink::WebMediaTrackConstraintSet& advanced2 =
+      constraint_factory_.AddAdvanced();
+  advanced2.width.setExact(1920);
+  advanced2.height.setExact(1080);
+  auto result = SelectSettings();
+  EXPECT_TRUE(result.HasValue());
+  // The second advanced set must be ignored because it contradicts the first
+  // set. The low-res device is the one that best supports the requested
+  // resolution.
+  EXPECT_EQ(low_res_device_->device_id, result.device_id);
+  EXPECT_EQ(640, result.Width());
+  EXPECT_EQ(480, result.Height());

[hbos_chromium, 2017/02/28 11:41:54]

These tests are all good, but we want if possible test coverage of what the
ConstrainedFormat is doing.

This test would pass even without that class, because a format that can satisfy
the first but not the second (640x480) is already better than a format that can
satisfy the second but not the first (1920x1080).

We need something like I mentioned in the earlier comment with
camera: w = 1024
adv1: w <= 640
adv2: w >= 800

Can we distinguish between adv2 being rejected and not being rejected?

What if we have:
camera1: 1024@50Hz
camera2: 1024@60Hz
adv1: w <= 640
adv2: w >= 800, 60Hz
adv3: 50Hz

Without ConstrainedSet it should choose camera2 because it would falsely think
it could satisfy both adv1 and adv2.
With ConstrainedSet it should choose camera1 because adv2 is unsatisfiable but
adv1+adv3 isn't. We can distinguish between adv3 being used or not if 50Hz is
not the default Hz.

The test could do one SelectSetting with adv1+adv2 and get default Hz and one
with adv1+adv2+adv3 and get adv3's Hz.

One test like that for each value range maybe?

[Guido Urdaneta, 2017/02/28 16:44:00]

Added tests similar to the proposed ones with width/frameRate and
height/frameRate.

+}
+
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
+       AdvancedContradictoryResolutionRange) {
+  constraint_factory_.Reset();
+  blink::WebMediaTrackConstraintSet& advanced1 =
+      constraint_factory_.AddAdvanced();
+  advanced1.width.setMax(640);
+  advanced1.height.setMax(480);
+  blink::WebMediaTrackConstraintSet& advanced2 =
+      constraint_factory_.AddAdvanced();
+  advanced2.width.setMin(1920);
+  advanced2.height.setMin(1080);
+  auto result = SelectSettings();
+  EXPECT_TRUE(result.HasValue());
+  // The second advanced set must be ignored because it contradicts the first
+  // set.
+  EXPECT_EQ(default_device_->device_id, result.device_id);
+  EXPECT_GE(640, result.Width());
+  EXPECT_GE(480, result.Height());
+}
+
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
+       AdvancedContradictoryExactAspectRatio) {
+  constraint_factory_.Reset();
+  blink::WebMediaTrackConstraintSet& advanced1 =
+      constraint_factory_.AddAdvanced();
+  advanced1.aspectRatio.setExact(2300.0);
+  blink::WebMediaTrackConstraintSet& advanced2 =
+      constraint_factory_.AddAdvanced();
+  advanced2.aspectRatio.setExact(3.0);
+  auto result = SelectSettings();
+  EXPECT_TRUE(result.HasValue());
+  // The second advanced set must be ignored because it contradicts the first
+  // set. Only the high-res device in the highest-resolution format supports the
+  // requested aspect ratio.
+  EXPECT_EQ(high_res_device_->device_id, result.device_id);
+  EXPECT_EQ(*high_res_highest_format_, result.Format());
+}
+
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
+       AdvancedContradictoryAspectRatioRange) {
+  constraint_factory_.Reset();
+  blink::WebMediaTrackConstraintSet& advanced1 =
+      constraint_factory_.AddAdvanced();
+  advanced1.aspectRatio.setMin(2300.0);
+  blink::WebMediaTrackConstraintSet& advanced2 =
+      constraint_factory_.AddAdvanced();
+  advanced2.aspectRatio.setMax(3.0);
+  auto result = SelectSettings();
+  EXPECT_TRUE(result.HasValue());
+  // The second advanced set must be ignored because it contradicts the first
+  // set. Only the high-res device in the highest-resolution format supports the
+  // requested aspect ratio.
+  EXPECT_EQ(high_res_device_->device_id, result.device_id);
+  EXPECT_EQ(*high_res_highest_format_, result.Format());
+}
+
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
+       AdvancedContradictoryExactFrameRate) {
+  constraint_factory_.Reset();
+  blink::WebMediaTrackConstraintSet& advanced1 =
+      constraint_factory_.AddAdvanced();
+  advanced1.frameRate.setExact(40.0);
+  blink::WebMediaTrackConstraintSet& advanced2 =
+      constraint_factory_.AddAdvanced();
+  advanced2.frameRate.setExact(45.0);
+  auto result = SelectSettings();
+  EXPECT_TRUE(result.HasValue());
+  // The second advanced set must be ignored because it contradicts the first
+  // set.
+  EXPECT_EQ(40.0, result.FrameRate());
+}
+
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
+       AdvancedContradictoryFrameRateRange) {
+  constraint_factory_.Reset();
+  blink::WebMediaTrackConstraintSet& advanced1 =
+      constraint_factory_.AddAdvanced();
+  advanced1.frameRate.setMin(40.0);
+  blink::WebMediaTrackConstraintSet& advanced2 =
+      constraint_factory_.AddAdvanced();
+  advanced2.frameRate.setMax(35.0);
+  auto result = SelectSettings();
+  EXPECT_TRUE(result.HasValue());
+  // The second advanced set must be ignored because it contradicts the first
+  // set.
+  EXPECT_LE(40.0, result.FrameRate());
+}
+
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, AdvancedDeviceID) {
+  constraint_factory_.Reset();
+  blink::WebMediaTrackConstraintSet& advanced1 =
+      constraint_factory_.AddAdvanced();
+  blink::WebString id_vector1[] = {blink::WebString::fromASCII(kDeviceID1),
+                                   blink::WebString::fromASCII(kDeviceID2)};
+  advanced1.deviceId.setExact(
+      blink::WebVector<blink::WebString>(id_vector1, arraysize(id_vector1)));
+  blink::WebString id_vector2[] = {blink::WebString::fromASCII(kDeviceID2),
+                                   blink::WebString::fromASCII(kDeviceID3)};
+  blink::WebMediaTrackConstraintSet& advanced2 =
+      constraint_factory_.AddAdvanced();
+  advanced2.deviceId.setExact(
+      blink::WebVector<blink::WebString>(id_vector2, arraysize(id_vector2)));
+  auto result = SelectSettings();
+  EXPECT_TRUE(result.HasValue());
+  // kDeviceID2 must be selected because it is the only one that satisfies both
+  // advanced sets.
+  EXPECT_EQ(std::string(kDeviceID2), result.device_id);
+}
+
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
+       AdvancedContradictoryDeviceID) {
+  constraint_factory_.Reset();
+  blink::WebMediaTrackConstraintSet& advanced1 =
+      constraint_factory_.AddAdvanced();
+  blink::WebString id_vector1[] = {blink::WebString::fromASCII(kDeviceID1),
+                                   blink::WebString::fromASCII(kDeviceID2)};
+  advanced1.deviceId.setExact(
+      blink::WebVector<blink::WebString>(id_vector1, arraysize(id_vector1)));
+  blink::WebString id_vector2[] = {blink::WebString::fromASCII(kDeviceID3),
+                                   blink::WebString::fromASCII(kDeviceID4)};
+  blink::WebMediaTrackConstraintSet& advanced2 =
+      constraint_factory_.AddAdvanced();
+  advanced2.deviceId.setExact(
+      blink::WebVector<blink::WebString>(id_vector2, arraysize(id_vector2)));
+  auto result = SelectSettings();
+  EXPECT_TRUE(result.HasValue());
+  // The second advanced set must be ignored because it contradicts the first
+  // set.
+  EXPECT_EQ(std::string(kDeviceID1), result.device_id);
+}
+
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
+       AdvancedContradictoryPowerLineFrequency) {
+  {
+    constraint_factory_.Reset();
+    blink::WebMediaTrackConstraintSet& advanced1 =
+        constraint_factory_.AddAdvanced();
+    advanced1.width.setMin(640);
+    advanced1.height.setMin(480);
+    advanced1.googPowerLineFrequency.setExact(50);
+    blink::WebMediaTrackConstraintSet& advanced2 =
+        constraint_factory_.AddAdvanced();
+    advanced2.width.setMin(1920);
+    advanced2.height.setMin(1080);
+    advanced2.googPowerLineFrequency.setExact(60);
+    auto result = SelectSettings();
+    EXPECT_TRUE(result.HasValue());
+    // The second advanced set cannot be satisfied because it contradicts the
+    // first set. The default device supports the first set and should be
+    // selected.
+    EXPECT_EQ(default_device_->device_id, result.device_id);
+    EXPECT_LE(640, result.Width());
+    EXPECT_LE(480, result.Height());
+    EXPECT_EQ(50, static_cast<int>(result.PowerLineFrequency()));
+  }
+}
+
 // The "NoDevices" tests verify that the algorithm returns the expected result
 // when there are no candidates to choose from.
 TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, NoDevicesNoConstraints) {
   constraint_factory_.Reset();
   VideoDeviceCaptureCapabilities capabilities;
   auto result = SelectVideoDeviceCaptureSourceSettings(
       capabilities, constraint_factory_.CreateWebMediaConstraints());
   EXPECT_FALSE(result.HasValue());
   EXPECT_TRUE(std::string(result.failed_constraint_name).empty());
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, NoDevicesWithConstraints) {
   constraint_factory_.Reset();
   constraint_factory_.basic().height.setExact(100);
   VideoDeviceCaptureCapabilities capabilities;
   auto result = SelectVideoDeviceCaptureSourceSettings(
       capabilities, constraint_factory_.CreateWebMediaConstraints());
   EXPECT_FALSE(result.HasValue());
   EXPECT_TRUE(std::string(result.failed_constraint_name).empty());
 }
 
 }  // namespace content